?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add missing FORCE_RET()
[qemu/mini2440.git] / target-ppc / translate_init.c
blob012c34f73dbbebb0d619ee1daa2cf174861a23d4
1 /*
2 * PowerPC CPU initialization for qemu.
3 *
4 * Copyright (c) 2003-2005 Jocelyn Mayer
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21 /* A lot of PowerPC definition have been included here.
22 * Most of them are not usable for now but have been kept
23 * inside "#if defined(TODO) ... #endif" statements to make tests easier.
24 */
25
26 //#define PPC_DUMP_CPU
27 //#define PPC_DEBUG_SPR
28
29 struct ppc_def_t {
30 const unsigned char *name;
31 uint32_t pvr;
32 uint32_t pvr_mask;
33 uint32_t insns_flags;
34 uint32_t flags;
35 uint64_t msr_mask;
36 };
37
38 /* Generic callbacks:
39 * do nothing but store/retrieve spr value
40 */
41 static void spr_read_generic (void *opaque, int sprn)
42 {
43 gen_op_load_spr(sprn);
44 }
45
46 static void spr_write_generic (void *opaque, int sprn)
47 {
48 gen_op_store_spr(sprn);
49 }
50
51 /* SPR common to all PPC */
52 /* XER */
53 static void spr_read_xer (void *opaque, int sprn)
54 {
55 gen_op_load_xer();
56 }
57
58 static void spr_write_xer (void *opaque, int sprn)
59 {
60 gen_op_store_xer();
61 }
62
63 /* LR */
64 static void spr_read_lr (void *opaque, int sprn)
65 {
66 gen_op_load_lr();
67 }
68
69 static void spr_write_lr (void *opaque, int sprn)
70 {
71 gen_op_store_lr();
72 }
73
74 /* CTR */
75 static void spr_read_ctr (void *opaque, int sprn)
76 {
77 gen_op_load_ctr();
78 }
79
80 static void spr_write_ctr (void *opaque, int sprn)
81 {
82 gen_op_store_ctr();
83 }
84
85 /* User read access to SPR */
86 /* USPRx */
87 /* UMMCRx */
88 /* UPMCx */
89 /* USIA */
90 /* UDECR */
91 static void spr_read_ureg (void *opaque, int sprn)
92 {
93 gen_op_load_spr(sprn + 0x10);
94 }
95
96 /* SPR common to all non-embedded PPC (ie not 4xx) */
97 /* DECR */
98 static void spr_read_decr (void *opaque, int sprn)
99 {
100 gen_op_load_decr();
101 }
102
103 static void spr_write_decr (void *opaque, int sprn)
104 {
105 gen_op_store_decr();
106 }
107
108 /* SPR common to all non-embedded PPC, except 601 */
109 /* Time base */
110 static void spr_read_tbl (void *opaque, int sprn)
111 {
112 gen_op_load_tbl();
113 }
114
115 static void spr_write_tbl (void *opaque, int sprn)
116 {
117 gen_op_store_tbl();
118 }
119
120 static void spr_read_tbu (void *opaque, int sprn)
121 {
122 gen_op_load_tbu();
123 }
124
125 static void spr_write_tbu (void *opaque, int sprn)
126 {
127 gen_op_store_tbu();
128 }
129
130 /* IBAT0U...IBAT0U */
131 /* IBAT0L...IBAT7L */
132 static void spr_read_ibat (void *opaque, int sprn)
133 {
134 gen_op_load_ibat(sprn & 1, (sprn - SPR_IBAT0U) / 2);
135 }
136
137 static void spr_read_ibat_h (void *opaque, int sprn)
138 {
139 gen_op_load_ibat(sprn & 1, (sprn - SPR_IBAT4U) / 2);
140 }
141
142 static void spr_write_ibatu (void *opaque, int sprn)
143 {
144 DisasContext *ctx = opaque;
145
146 gen_op_store_ibatu((sprn - SPR_IBAT0U) / 2);
147 RET_STOP(ctx);
148 }
149
150 static void spr_write_ibatu_h (void *opaque, int sprn)
151 {
152 DisasContext *ctx = opaque;
153
154 gen_op_store_ibatu((sprn - SPR_IBAT4U) / 2);
155 RET_STOP(ctx);
156 }
157
158 static void spr_write_ibatl (void *opaque, int sprn)
159 {
160 DisasContext *ctx = opaque;
161
162 gen_op_store_ibatl((sprn - SPR_IBAT0L) / 2);
163 RET_STOP(ctx);
164 }
165
166 static void spr_write_ibatl_h (void *opaque, int sprn)
167 {
168 DisasContext *ctx = opaque;
169
170 gen_op_store_ibatl((sprn - SPR_IBAT4L) / 2);
171 RET_STOP(ctx);
172 }
173
174 /* DBAT0U...DBAT7U */
175 /* DBAT0L...DBAT7L */
176 static void spr_read_dbat (void *opaque, int sprn)
177 {
178 gen_op_load_dbat(sprn & 1, (sprn - SPR_DBAT0U) / 2);
179 }
180
181 static void spr_read_dbat_h (void *opaque, int sprn)
182 {
183 gen_op_load_dbat(sprn & 1, (sprn - SPR_DBAT4U) / 2);
184 }
185
186 static void spr_write_dbatu (void *opaque, int sprn)
187 {
188 DisasContext *ctx = opaque;
189
190 gen_op_store_dbatu((sprn - SPR_DBAT0U) / 2);
191 RET_STOP(ctx);
192 }
193
194 static void spr_write_dbatu_h (void *opaque, int sprn)
195 {
196 DisasContext *ctx = opaque;
197
198 gen_op_store_dbatu((sprn - SPR_DBAT4U) / 2);
199 RET_STOP(ctx);
200 }
201
202 static void spr_write_dbatl (void *opaque, int sprn)
203 {
204 DisasContext *ctx = opaque;
205
206 gen_op_store_dbatl((sprn - SPR_DBAT0L) / 2);
207 RET_STOP(ctx);
208 }
209
210 static void spr_write_dbatl_h (void *opaque, int sprn)
211 {
212 DisasContext *ctx = opaque;
213
214 gen_op_store_dbatl((sprn - SPR_DBAT4L) / 2);
215 RET_STOP(ctx);
216 }
217
218 /* SDR1 */
219 static void spr_read_sdr1 (void *opaque, int sprn)
220 {
221 gen_op_load_sdr1();
222 }
223
224 static void spr_write_sdr1 (void *opaque, int sprn)
225 {
226 DisasContext *ctx = opaque;
227
228 gen_op_store_sdr1();
229 RET_STOP(ctx);
230 }
231
232 static void spr_write_pir (void *opaque, int sprn)
233 {
234 gen_op_store_pir();
235 }
236
237 static inline void spr_register (CPUPPCState *env, int num,
238 const unsigned char *name,
239 void (*uea_read)(void *opaque, int sprn),
240 void (*uea_write)(void *opaque, int sprn),
241 void (*oea_read)(void *opaque, int sprn),
242 void (*oea_write)(void *opaque, int sprn),
243 target_ulong initial_value)
244 {
245 ppc_spr_t *spr;
246
247 spr = &env->spr_cb[num];
248 if (spr->name != NULL ||env-> spr[num] != 0x00000000 ||
249 spr->uea_read != NULL || spr->uea_write != NULL ||
250 spr->oea_read != NULL || spr->oea_write != NULL) {
251 printf("Error: Trying to register SPR %d (%03x) twice !\n", num, num);
252 exit(1);
253 }
254 #if defined(PPC_DEBUG_SPR)
255 printf("*** register spr %d (%03x) %s val %08llx\n", num, num, name,
256 (unsigned long long)initial_value);
257 #endif
258 spr->name = name;
259 spr->uea_read = uea_read;
260 spr->uea_write = uea_write;
261 spr->oea_read = oea_read;
262 spr->oea_write = oea_write;
263 env->spr[num] = initial_value;
264 }
265
266 /* Generic PowerPC SPRs */
267 static void gen_spr_generic (CPUPPCState *env)
268 {
269 /* Integer processing */
270 spr_register(env, SPR_XER, "XER",
271 &spr_read_xer, &spr_write_xer,
272 &spr_read_xer, &spr_write_xer,
273 0x00000000);
274 /* Branch contol */
275 spr_register(env, SPR_LR, "LR",
276 &spr_read_lr, &spr_write_lr,
277 &spr_read_lr, &spr_write_lr,
278 0x00000000);
279 spr_register(env, SPR_CTR, "CTR",
280 &spr_read_ctr, &spr_write_ctr,
281 &spr_read_ctr, &spr_write_ctr,
282 0x00000000);
283 /* Interrupt processing */
284 spr_register(env, SPR_SRR0, "SRR0",
285 SPR_NOACCESS, SPR_NOACCESS,
286 &spr_read_generic, &spr_write_generic,
287 0x00000000);
288 spr_register(env, SPR_SRR1, "SRR1",
289 SPR_NOACCESS, SPR_NOACCESS,
290 &spr_read_generic, &spr_write_generic,
291 0x00000000);
292 /* Processor control */
293 spr_register(env, SPR_SPRG0, "SPRG0",
294 SPR_NOACCESS, SPR_NOACCESS,
295 &spr_read_generic, &spr_write_generic,
296 0x00000000);
297 spr_register(env, SPR_SPRG1, "SPRG1",
298 SPR_NOACCESS, SPR_NOACCESS,
299 &spr_read_generic, &spr_write_generic,
300 0x00000000);
301 spr_register(env, SPR_SPRG2, "SPRG2",
302 SPR_NOACCESS, SPR_NOACCESS,
303 &spr_read_generic, &spr_write_generic,
304 0x00000000);
305 spr_register(env, SPR_SPRG3, "SPRG3",
306 SPR_NOACCESS, SPR_NOACCESS,
307 &spr_read_generic, &spr_write_generic,
308 0x00000000);
309 }
310
311 /* SPR common to all non-embedded PowerPC, including 601 */
312 static void gen_spr_ne_601 (CPUPPCState *env)
313 {
314 /* Exception processing */
315 spr_register(env, SPR_DSISR, "DSISR",
316 SPR_NOACCESS, SPR_NOACCESS,
317 &spr_read_generic, &spr_write_generic,
318 0x00000000);
319 spr_register(env, SPR_DAR, "DAR",
320 SPR_NOACCESS, SPR_NOACCESS,
321 &spr_read_generic, &spr_write_generic,
322 0x00000000);
323 /* Timer */
324 spr_register(env, SPR_DECR, "DECR",
325 SPR_NOACCESS, SPR_NOACCESS,
326 &spr_read_decr, &spr_write_decr,
327 0x00000000);
328 /* Memory management */
329 spr_register(env, SPR_SDR1, "SDR1",
330 SPR_NOACCESS, SPR_NOACCESS,
331 &spr_read_sdr1, &spr_write_sdr1,
332 0x00000000);
333 }
334
335 /* BATs 0-3 */
336 static void gen_low_BATs (CPUPPCState *env)
337 {
338 spr_register(env, SPR_IBAT0U, "IBAT0U",
339 SPR_NOACCESS, SPR_NOACCESS,
340 &spr_read_ibat, &spr_write_ibatu,
341 0x00000000);
342 spr_register(env, SPR_IBAT0L, "IBAT0L",
343 SPR_NOACCESS, SPR_NOACCESS,
344 &spr_read_ibat, &spr_write_ibatl,
345 0x00000000);
346 spr_register(env, SPR_IBAT1U, "IBAT1U",
347 SPR_NOACCESS, SPR_NOACCESS,
348 &spr_read_ibat, &spr_write_ibatu,
349 0x00000000);
350 spr_register(env, SPR_IBAT1L, "IBAT1L",
351 SPR_NOACCESS, SPR_NOACCESS,
352 &spr_read_ibat, &spr_write_ibatl,
353 0x00000000);
354 spr_register(env, SPR_IBAT2U, "IBAT2U",
355 SPR_NOACCESS, SPR_NOACCESS,
356 &spr_read_ibat, &spr_write_ibatu,
357 0x00000000);
358 spr_register(env, SPR_IBAT2L, "IBAT2L",
359 SPR_NOACCESS, SPR_NOACCESS,
360 &spr_read_ibat, &spr_write_ibatl,
361 0x00000000);
362 spr_register(env, SPR_IBAT3U, "IBAT3U",
363 SPR_NOACCESS, SPR_NOACCESS,
364 &spr_read_ibat, &spr_write_ibatu,
365 0x00000000);
366 spr_register(env, SPR_IBAT3L, "IBAT3L",
367 SPR_NOACCESS, SPR_NOACCESS,
368 &spr_read_ibat, &spr_write_ibatl,
369 0x00000000);
370 spr_register(env, SPR_DBAT0U, "DBAT0U",
371 SPR_NOACCESS, SPR_NOACCESS,
372 &spr_read_dbat, &spr_write_dbatu,
373 0x00000000);
374 spr_register(env, SPR_DBAT0L, "DBAT0L",
375 SPR_NOACCESS, SPR_NOACCESS,
376 &spr_read_dbat, &spr_write_dbatl,
377 0x00000000);
378 spr_register(env, SPR_DBAT1U, "DBAT1U",
379 SPR_NOACCESS, SPR_NOACCESS,
380 &spr_read_dbat, &spr_write_dbatu,
381 0x00000000);
382 spr_register(env, SPR_DBAT1L, "DBAT1L",
383 SPR_NOACCESS, SPR_NOACCESS,
384 &spr_read_dbat, &spr_write_dbatl,
385 0x00000000);
386 spr_register(env, SPR_DBAT2U, "DBAT2U",
387 SPR_NOACCESS, SPR_NOACCESS,
388 &spr_read_dbat, &spr_write_dbatu,
389 0x00000000);
390 spr_register(env, SPR_DBAT2L, "DBAT2L",
391 SPR_NOACCESS, SPR_NOACCESS,
392 &spr_read_dbat, &spr_write_dbatl,
393 0x00000000);
394 spr_register(env, SPR_DBAT3U, "DBAT3U",
395 SPR_NOACCESS, SPR_NOACCESS,
396 &spr_read_dbat, &spr_write_dbatu,
397 0x00000000);
398 spr_register(env, SPR_DBAT3L, "DBAT3L",
399 SPR_NOACCESS, SPR_NOACCESS,
400 &spr_read_dbat, &spr_write_dbatl,
401 0x00000000);
402 env->nb_BATs = 4;
403 }
404
405 /* BATs 4-7 */
406 static void gen_high_BATs (CPUPPCState *env)
407 {
408 spr_register(env, SPR_IBAT4U, "IBAT4U",
409 SPR_NOACCESS, SPR_NOACCESS,
410 &spr_read_ibat_h, &spr_write_ibatu_h,
411 0x00000000);
412 spr_register(env, SPR_IBAT4L, "IBAT4L",
413 SPR_NOACCESS, SPR_NOACCESS,
414 &spr_read_ibat_h, &spr_write_ibatl_h,
415 0x00000000);
416 spr_register(env, SPR_IBAT5U, "IBAT5U",
417 SPR_NOACCESS, SPR_NOACCESS,
418 &spr_read_ibat_h, &spr_write_ibatu_h,
419 0x00000000);
420 spr_register(env, SPR_IBAT5L, "IBAT5L",
421 SPR_NOACCESS, SPR_NOACCESS,
422 &spr_read_ibat_h, &spr_write_ibatl_h,
423 0x00000000);
424 spr_register(env, SPR_IBAT6U, "IBAT6U",
425 SPR_NOACCESS, SPR_NOACCESS,
426 &spr_read_ibat_h, &spr_write_ibatu_h,
427 0x00000000);
428 spr_register(env, SPR_IBAT6L, "IBAT6L",
429 SPR_NOACCESS, SPR_NOACCESS,
430 &spr_read_ibat_h, &spr_write_ibatl_h,
431 0x00000000);
432 spr_register(env, SPR_IBAT7U, "IBAT7U",
433 SPR_NOACCESS, SPR_NOACCESS,
434 &spr_read_ibat_h, &spr_write_ibatu_h,
435 0x00000000);
436 spr_register(env, SPR_IBAT7L, "IBAT7L",
437 SPR_NOACCESS, SPR_NOACCESS,
438 &spr_read_ibat_h, &spr_write_ibatl_h,
439 0x00000000);
440 spr_register(env, SPR_DBAT4U, "DBAT4U",
441 SPR_NOACCESS, SPR_NOACCESS,
442 &spr_read_dbat_h, &spr_write_dbatu_h,
443 0x00000000);
444 spr_register(env, SPR_DBAT4L, "DBAT4L",
445 SPR_NOACCESS, SPR_NOACCESS,
446 &spr_read_dbat_h, &spr_write_dbatl_h,
447 0x00000000);
448 spr_register(env, SPR_DBAT5U, "DBAT5U",
449 SPR_NOACCESS, SPR_NOACCESS,
450 &spr_read_dbat_h, &spr_write_dbatu_h,
451 0x00000000);
452 spr_register(env, SPR_DBAT5L, "DBAT5L",
453 SPR_NOACCESS, SPR_NOACCESS,
454 &spr_read_dbat_h, &spr_write_dbatl_h,
455 0x00000000);
456 spr_register(env, SPR_DBAT6U, "DBAT6U",
457 SPR_NOACCESS, SPR_NOACCESS,
458 &spr_read_dbat_h, &spr_write_dbatu_h,
459 0x00000000);
460 spr_register(env, SPR_DBAT6L, "DBAT6L",
461 SPR_NOACCESS, SPR_NOACCESS,
462 &spr_read_dbat_h, &spr_write_dbatl_h,
463 0x00000000);
464 spr_register(env, SPR_DBAT7U, "DBAT7U",
465 SPR_NOACCESS, SPR_NOACCESS,
466 &spr_read_dbat_h, &spr_write_dbatu_h,
467 0x00000000);
468 spr_register(env, SPR_DBAT7L, "DBAT7L",
469 SPR_NOACCESS, SPR_NOACCESS,
470 &spr_read_dbat_h, &spr_write_dbatl_h,
471 0x00000000);
472 env->nb_BATs = 8;
473 }
474
475 /* Generic PowerPC time base */
476 static void gen_tbl (CPUPPCState *env)
477 {
478 spr_register(env, SPR_VTBL, "TBL",
479 &spr_read_tbl, SPR_NOACCESS,
480 &spr_read_tbl, SPR_NOACCESS,
481 0x00000000);
482 spr_register(env, SPR_TBL, "TBL",
483 SPR_NOACCESS, SPR_NOACCESS,
484 SPR_NOACCESS, &spr_write_tbl,
485 0x00000000);
486 spr_register(env, SPR_VTBU, "TBU",
487 &spr_read_tbu, SPR_NOACCESS,
488 &spr_read_tbu, SPR_NOACCESS,
489 0x00000000);
490 spr_register(env, SPR_TBU, "TBU",
491 SPR_NOACCESS, SPR_NOACCESS,
492 SPR_NOACCESS, &spr_write_tbu,
493 0x00000000);
494 }
495
496 /* SPR common to all 7xx PowerPC implementations */
497 static void gen_spr_7xx (CPUPPCState *env)
498 {
499 /* Breakpoints */
500 /* XXX : not implemented */
501 spr_register(env, SPR_DABR, "DABR",
502 SPR_NOACCESS, SPR_NOACCESS,
503 &spr_read_generic, &spr_write_generic,
504 0x00000000);
505 /* XXX : not implemented */
506 spr_register(env, SPR_IABR, "IABR",
507 SPR_NOACCESS, SPR_NOACCESS,
508 &spr_read_generic, &spr_write_generic,
509 0x00000000);
510 /* Cache management */
511 /* XXX : not implemented */
512 spr_register(env, SPR_ICTC, "ICTC",
513 SPR_NOACCESS, SPR_NOACCESS,
514 &spr_read_generic, &spr_write_generic,
515 0x00000000);
516 /* Performance monitors */
517 /* XXX : not implemented */
518 spr_register(env, SPR_MMCR0, "MMCR0",
519 SPR_NOACCESS, SPR_NOACCESS,
520 &spr_read_generic, &spr_write_generic,
521 0x00000000);
522 /* XXX : not implemented */
523 spr_register(env, SPR_MMCR1, "MMCR1",
524 SPR_NOACCESS, SPR_NOACCESS,
525 &spr_read_generic, &spr_write_generic,
526 0x00000000);
527 /* XXX : not implemented */
528 spr_register(env, SPR_PMC1, "PMC1",
529 SPR_NOACCESS, SPR_NOACCESS,
530 &spr_read_generic, &spr_write_generic,
531 0x00000000);
532 /* XXX : not implemented */
533 spr_register(env, SPR_PMC2, "PMC2",
534 SPR_NOACCESS, SPR_NOACCESS,
535 &spr_read_generic, &spr_write_generic,
536 0x00000000);
537 /* XXX : not implemented */
538 spr_register(env, SPR_PMC3, "PMC3",
539 SPR_NOACCESS, SPR_NOACCESS,
540 &spr_read_generic, &spr_write_generic,
541 0x00000000);
542 /* XXX : not implemented */
543 spr_register(env, SPR_PMC4, "PMC4",
544 SPR_NOACCESS, SPR_NOACCESS,
545 &spr_read_generic, &spr_write_generic,
546 0x00000000);
547 /* XXX : not implemented */
548 spr_register(env, SPR_SIA, "SIA",
549 SPR_NOACCESS, SPR_NOACCESS,
550 &spr_read_generic, SPR_NOACCESS,
551 0x00000000);
552 spr_register(env, SPR_UMMCR0, "UMMCR0",
553 &spr_read_ureg, SPR_NOACCESS,
554 &spr_read_ureg, SPR_NOACCESS,
555 0x00000000);
556 spr_register(env, SPR_UMMCR1, "UMMCR1",
557 &spr_read_ureg, SPR_NOACCESS,
558 &spr_read_ureg, SPR_NOACCESS,
559 0x00000000);
560 spr_register(env, SPR_UPMC1, "UPMC1",
561 &spr_read_ureg, SPR_NOACCESS,
562 &spr_read_ureg, SPR_NOACCESS,
563 0x00000000);
564 spr_register(env, SPR_UPMC2, "UPMC2",
565 &spr_read_ureg, SPR_NOACCESS,
566 &spr_read_ureg, SPR_NOACCESS,
567 0x00000000);
568 spr_register(env, SPR_UPMC3, "UPMC3",
569 &spr_read_ureg, SPR_NOACCESS,
570 &spr_read_ureg, SPR_NOACCESS,
571 0x00000000);
572 spr_register(env, SPR_UPMC4, "UPMC4",
573 &spr_read_ureg, SPR_NOACCESS,
574 &spr_read_ureg, SPR_NOACCESS,
575 0x00000000);
576 spr_register(env, SPR_USIA, "USIA",
577 &spr_read_ureg, SPR_NOACCESS,
578 &spr_read_ureg, SPR_NOACCESS,
579 0x00000000);
580 /* Thermal management */
581 /* XXX : not implemented */
582 spr_register(env, SPR_THRM1, "THRM1",
583 SPR_NOACCESS, SPR_NOACCESS,
584 &spr_read_generic, &spr_write_generic,
585 0x00000000);
586 /* XXX : not implemented */
587 spr_register(env, SPR_THRM2, "THRM2",
588 SPR_NOACCESS, SPR_NOACCESS,
589 &spr_read_generic, &spr_write_generic,
590 0x00000000);
591 /* XXX : not implemented */
592 spr_register(env, SPR_THRM3, "THRM3",
593 SPR_NOACCESS, SPR_NOACCESS,
594 &spr_read_generic, &spr_write_generic,
595 0x00000000);
596 /* External access control */
597 /* XXX : not implemented */
598 spr_register(env, SPR_EAR, "EAR",
599 SPR_NOACCESS, SPR_NOACCESS,
600 &spr_read_generic, &spr_write_generic,
601 0x00000000);
602 }
603
604 /* SPR specific to PowerPC 604 implementation */
605 static void gen_spr_604 (CPUPPCState *env)
606 {
607 /* Processor identification */
608 spr_register(env, SPR_PIR, "PIR",
609 SPR_NOACCESS, SPR_NOACCESS,
610 &spr_read_generic, &spr_write_pir,
611 0x00000000);
612 /* Breakpoints */
613 /* XXX : not implemented */
614 spr_register(env, SPR_IABR, "IABR",
615 SPR_NOACCESS, SPR_NOACCESS,
616 &spr_read_generic, &spr_write_generic,
617 0x00000000);
618 /* XXX : not implemented */
619 spr_register(env, SPR_DABR, "DABR",
620 SPR_NOACCESS, SPR_NOACCESS,
621 &spr_read_generic, &spr_write_generic,
622 0x00000000);
623 /* Performance counters */
624 /* XXX : not implemented */
625 spr_register(env, SPR_MMCR0, "MMCR0",
626 SPR_NOACCESS, SPR_NOACCESS,
627 &spr_read_generic, &spr_write_generic,
628 0x00000000);
629 /* XXX : not implemented */
630 spr_register(env, SPR_MMCR1, "MMCR1",
631 SPR_NOACCESS, SPR_NOACCESS,
632 &spr_read_generic, &spr_write_generic,
633 0x00000000);
634 /* XXX : not implemented */
635 spr_register(env, SPR_PMC1, "PMC1",
636 SPR_NOACCESS, SPR_NOACCESS,
637 &spr_read_generic, &spr_write_generic,
638 0x00000000);
639 /* XXX : not implemented */
640 spr_register(env, SPR_PMC2, "PMC2",
641 SPR_NOACCESS, SPR_NOACCESS,
642 &spr_read_generic, &spr_write_generic,
643 0x00000000);
644 /* XXX : not implemented */
645 spr_register(env, SPR_PMC3, "PMC3",
646 SPR_NOACCESS, SPR_NOACCESS,
647 &spr_read_generic, &spr_write_generic,
648 0x00000000);
649 /* XXX : not implemented */
650 spr_register(env, SPR_PMC4, "PMC4",
651 SPR_NOACCESS, SPR_NOACCESS,
652 &spr_read_generic, &spr_write_generic,
653 0x00000000);
654 /* XXX : not implemented */
655 spr_register(env, SPR_SIA, "SIA",
656 SPR_NOACCESS, SPR_NOACCESS,
657 &spr_read_generic, SPR_NOACCESS,
658 0x00000000);
659 /* XXX : not implemented */
660 spr_register(env, SPR_SDA, "SDA",
661 SPR_NOACCESS, SPR_NOACCESS,
662 &spr_read_generic, SPR_NOACCESS,
663 0x00000000);
664 /* External access control */
665 /* XXX : not implemented */
666 spr_register(env, SPR_EAR, "EAR",
667 SPR_NOACCESS, SPR_NOACCESS,
668 &spr_read_generic, &spr_write_generic,
669 0x00000000);
670 }
671
672 // XXX: TODO (64 bits PPC sprs)
673 /*
674 * ASR => SPR 280 (64 bits)
675 * FPECR => SPR 1022 (?)
676 * VRSAVE => SPR 256 (Altivec)
677 * SCOMC => SPR 276 (64 bits ?)
678 * SCOMD => SPR 277 (64 bits ?)
679 * HSPRG0 => SPR 304 (hypervisor)
680 * HSPRG1 => SPR 305 (hypervisor)
681 * HDEC => SPR 310 (hypervisor)
682 * HIOR => SPR 311 (hypervisor)
683 * RMOR => SPR 312 (970)
684 * HRMOR => SPR 313 (hypervisor)
685 * HSRR0 => SPR 314 (hypervisor)
686 * HSRR1 => SPR 315 (hypervisor)
687 * LPCR => SPR 316 (970)
688 * LPIDR => SPR 317 (970)
689 * ... and more (thermal management, performance counters, ...)
690 */
691
692 static void init_ppc_proc (CPUPPCState *env, ppc_def_t *def)
693 {
694 /* Default MMU definitions */
695 env->nb_BATs = -1;
696 env->nb_tlb = 0;
697 env->nb_ways = 0;
698 /* XXX: missing:
699 * 32 bits PPC:
700 * - MPC5xx(x)
701 * - MPC8xx(x)
702 * - RCPU (MPC5xx)
703 */
704 spr_register(env, SPR_PVR, "PVR",
705 SPR_NOACCESS, SPR_NOACCESS,
706 &spr_read_generic, SPR_NOACCESS,
707 def->pvr);
708 switch (def->pvr & def->pvr_mask) {
709 case CPU_PPC_604: /* PPC 604 */
710 case CPU_PPC_604E: /* PPC 604e */
711 case CPU_PPC_604R: /* PPC 604r */
712 gen_spr_generic(env);
713 gen_spr_ne_601(env);
714 /* Memory management */
715 gen_low_BATs(env);
716 /* Time base */
717 gen_tbl(env);
718 gen_spr_604(env);
719 /* Hardware implementation registers */
720 /* XXX : not implemented */
721 spr_register(env, SPR_HID0, "HID0",
722 SPR_NOACCESS, SPR_NOACCESS,
723 &spr_read_generic, &spr_write_generic,
724 0x00000000);
725 /* XXX : not implemented */
726 spr_register(env, SPR_HID1, "HID1",
727 SPR_NOACCESS, SPR_NOACCESS,
728 &spr_read_generic, &spr_write_generic,
729 0x00000000);
730 break;
731
732 case CPU_PPC_74x: /* PPC 740 / 750 */
733 case CPU_PPC_74xP: /* PPC 740P / 750P */
734 case CPU_PPC_750CXE: /* IBM PPC 750cxe */
735 gen_spr_generic(env);
736 gen_spr_ne_601(env);
737 /* Memory management */
738 gen_low_BATs(env);
739 /* Time base */
740 gen_tbl(env);
741 gen_spr_7xx(env);
742 /* XXX : not implemented */
743 spr_register(env, SPR_L2CR, "L2CR",
744 SPR_NOACCESS, SPR_NOACCESS,
745 &spr_read_generic, &spr_write_generic,
746 0x00000000);
747 /* Hardware implementation registers */
748 /* XXX : not implemented */
749 spr_register(env, SPR_HID0, "HID0",
750 SPR_NOACCESS, SPR_NOACCESS,
751 &spr_read_generic, &spr_write_generic,
752 0x00000000);
753 /* XXX : not implemented */
754 spr_register(env, SPR_HID1, "HID1",
755 SPR_NOACCESS, SPR_NOACCESS,
756 &spr_read_generic, &spr_write_generic,
757 0x00000000);
758 break;
759
760 case CPU_PPC_750FX: /* IBM PPC 750 FX */
761 case CPU_PPC_750GX: /* IBM PPC 750 GX */
762 gen_spr_generic(env);
763 gen_spr_ne_601(env);
764 /* Memory management */
765 gen_low_BATs(env);
766 /* PowerPC 750fx & 750gx has 8 DBATs and 8 IBATs */
767 gen_high_BATs(env);
768 /* Time base */
769 gen_tbl(env);
770 gen_spr_7xx(env);
771 /* XXX : not implemented */
772 spr_register(env, SPR_L2CR, "L2CR",
773 SPR_NOACCESS, SPR_NOACCESS,
774 &spr_read_generic, &spr_write_generic,
775 0x00000000);
776 /* Hardware implementation registers */
777 /* XXX : not implemented */
778 spr_register(env, SPR_HID0, "HID0",
779 SPR_NOACCESS, SPR_NOACCESS,
780 &spr_read_generic, &spr_write_generic,
781 0x00000000);
782 /* XXX : not implemented */
783 spr_register(env, SPR_HID1, "HID1",
784 SPR_NOACCESS, SPR_NOACCESS,
785 &spr_read_generic, &spr_write_generic,
786 0x00000000);
787 /* XXX : not implemented */
788 spr_register(env, SPR_750_HID2, "HID2",
789 SPR_NOACCESS, SPR_NOACCESS,
790 &spr_read_generic, &spr_write_generic,
791 0x00000000);
792 break;
793
794 default:
795 gen_spr_generic(env);
796 break;
797 }
798 if (env->nb_BATs == -1)
799 env->nb_BATs = 4;
800 }
801
802 #if defined(PPC_DUMP_CPU)
803 static void dump_sprs (CPUPPCState *env)
804 {
805 ppc_spr_t *spr;
806 uint32_t pvr = env->spr[SPR_PVR];
807 uint32_t sr, sw, ur, uw;
808 int i, j, n;
809
810 printf("* SPRs for PVR=%08x\n", pvr);
811 for (i = 0; i < 32; i++) {
812 for (j = 0; j < 32; j++) {
813 n = (i << 5) | j;
814 spr = &env->spr_cb[n];
815 sw = spr->oea_write != NULL && spr->oea_write != SPR_NOACCESS;
816 sr = spr->oea_read != NULL && spr->oea_read != SPR_NOACCESS;
817 uw = spr->uea_write != NULL && spr->uea_write != SPR_NOACCESS;
818 ur = spr->uea_read != NULL && spr->uea_read != SPR_NOACCESS;
819 if (sw || sr || uw || ur) {
820 printf("%4d (%03x) %8s s%c%c u%c%c\n",
821 (i << 5) | j, (i << 5) | j, spr->name,
822 sw ? 'w' : '-', sr ? 'r' : '-',
823 uw ? 'w' : '-', ur ? 'r' : '-');
824 }
825 }
826 }
827 fflush(stdout);
828 fflush(stderr);
829 }
830 #endif
831
832 /*****************************************************************************/
833 #include <stdlib.h>
834 #include <string.h>
835
836 int fflush (FILE *stream);
837
838 /* Opcode types */
839 enum {
840 PPC_DIRECT = 0, /* Opcode routine */
841 PPC_INDIRECT = 1, /* Indirect opcode table */
842 };
843
844 static inline int is_indirect_opcode (void *handler)
845 {
846 return ((unsigned long)handler & 0x03) == PPC_INDIRECT;
847 }
848
849 static inline opc_handler_t **ind_table(void *handler)
850 {
851 return (opc_handler_t **)((unsigned long)handler & ~3);
852 }
853
854 /* Instruction table creation */
855 /* Opcodes tables creation */
856 static void fill_new_table (opc_handler_t **table, int len)
857 {
858 int i;
859
860 for (i = 0; i < len; i++)
861 table[i] = &invalid_handler;
862 }
863
864 static int create_new_table (opc_handler_t **table, unsigned char idx)
865 {
866 opc_handler_t **tmp;
867
868 tmp = malloc(0x20 * sizeof(opc_handler_t));
869 if (tmp == NULL)
870 return -1;
871 fill_new_table(tmp, 0x20);
872 table[idx] = (opc_handler_t *)((unsigned long)tmp | PPC_INDIRECT);
873
874 return 0;
875 }
876
877 static int insert_in_table (opc_handler_t **table, unsigned char idx,
878 opc_handler_t *handler)
879 {
880 if (table[idx] != &invalid_handler)
881 return -1;
882 table[idx] = handler;
883
884 return 0;
885 }
886
887 static int register_direct_insn (opc_handler_t **ppc_opcodes,
888 unsigned char idx, opc_handler_t *handler)
889 {
890 if (insert_in_table(ppc_opcodes, idx, handler) < 0) {
891 printf("*** ERROR: opcode %02x already assigned in main "
892 "opcode table\n", idx);
893 return -1;
894 }
895
896 return 0;
897 }
898
899 static int register_ind_in_table (opc_handler_t **table,
900 unsigned char idx1, unsigned char idx2,
901 opc_handler_t *handler)
902 {
903 if (table[idx1] == &invalid_handler) {
904 if (create_new_table(table, idx1) < 0) {
905 printf("*** ERROR: unable to create indirect table "
906 "idx=%02x\n", idx1);
907 return -1;
908 }
909 } else {
910 if (!is_indirect_opcode(table[idx1])) {
911 printf("*** ERROR: idx %02x already assigned to a direct "
912 "opcode\n", idx1);
913 return -1;
914 }
915 }
916 if (handler != NULL &&
917 insert_in_table(ind_table(table[idx1]), idx2, handler) < 0) {
918 printf("*** ERROR: opcode %02x already assigned in "
919 "opcode table %02x\n", idx2, idx1);
920 return -1;
921 }
922
923 return 0;
924 }
925
926 static int register_ind_insn (opc_handler_t **ppc_opcodes,
927 unsigned char idx1, unsigned char idx2,
928 opc_handler_t *handler)
929 {
930 int ret;
931
932 ret = register_ind_in_table(ppc_opcodes, idx1, idx2, handler);
933
934 return ret;
935 }
936
937 static int register_dblind_insn (opc_handler_t **ppc_opcodes,
938 unsigned char idx1, unsigned char idx2,
939 unsigned char idx3, opc_handler_t *handler)
940 {
941 if (register_ind_in_table(ppc_opcodes, idx1, idx2, NULL) < 0) {
942 printf("*** ERROR: unable to join indirect table idx "
943 "[%02x-%02x]\n", idx1, idx2);
944 return -1;
945 }
946 if (register_ind_in_table(ind_table(ppc_opcodes[idx1]), idx2, idx3,
947 handler) < 0) {
948 printf("*** ERROR: unable to insert opcode "
949 "[%02x-%02x-%02x]\n", idx1, idx2, idx3);
950 return -1;
951 }
952
953 return 0;
954 }
955
956 static int register_insn (opc_handler_t **ppc_opcodes, opcode_t *insn)
957 {
958 if (insn->opc2 != 0xFF) {
959 if (insn->opc3 != 0xFF) {
960 if (register_dblind_insn(ppc_opcodes, insn->opc1, insn->opc2,
961 insn->opc3, &insn->handler) < 0)
962 return -1;
963 } else {
964 if (register_ind_insn(ppc_opcodes, insn->opc1,
965 insn->opc2, &insn->handler) < 0)
966 return -1;
967 }
968 } else {
969 if (register_direct_insn(ppc_opcodes, insn->opc1, &insn->handler) < 0)
970 return -1;
971 }
972
973 return 0;
974 }
975
976 static int test_opcode_table (opc_handler_t **table, int len)
977 {
978 int i, count, tmp;
979
980 for (i = 0, count = 0; i < len; i++) {
981 /* Consistency fixup */
982 if (table[i] == NULL)
983 table[i] = &invalid_handler;
984 if (table[i] != &invalid_handler) {
985 if (is_indirect_opcode(table[i])) {
986 tmp = test_opcode_table(ind_table(table[i]), 0x20);
987 if (tmp == 0) {
988 free(table[i]);
989 table[i] = &invalid_handler;
990 } else {
991 count++;
992 }
993 } else {
994 count++;
995 }
996 }
997 }
998
999 return count;
1000 }
1001
1002 static void fix_opcode_tables (opc_handler_t **ppc_opcodes)
1003 {
1004 if (test_opcode_table(ppc_opcodes, 0x40) == 0)
1005 printf("*** WARNING: no opcode defined !\n");
1006 }
1007
1008 /*****************************************************************************/
1009 static int create_ppc_opcodes (CPUPPCState *env, ppc_def_t *def)
1010 {
1011 opcode_t *opc, *start, *end;
1012
1013 fill_new_table(env->opcodes, 0x40);
1014 #if defined(PPC_DUMP_CPU)
1015 printf("* PPC instructions for PVR %08x: %s\n", def->pvr, def->name);
1016 #endif
1017 if (&opc_start < &opc_end) {
1018 start = &opc_start;
1019 end = &opc_end;
1020 } else {
1021 start = &opc_end;
1022 end = &opc_start;
1023 }
1024 for (opc = start + 1; opc != end; opc++) {
1025 if ((opc->handler.type & def->insns_flags) != 0) {
1026 if (register_insn(env->opcodes, opc) < 0) {
1027 printf("*** ERROR initializing PPC instruction "
1028 "0x%02x 0x%02x 0x%02x\n", opc->opc1, opc->opc2,
1029 opc->opc3);
1030 return -1;
1031 }
1032 #if defined(PPC_DUMP_CPU)
1033 if (opc1 != 0x00) {
1034 if (opc->opc3 == 0xFF) {
1035 if (opc->opc2 == 0xFF) {
1036 printf(" %02x -- -- (%2d ----) : %s\n",
1037 opc->opc1, opc->opc1, opc->oname);
1038 } else {
1039 printf(" %02x %02x -- (%2d %4d) : %s\n",
1040 opc->opc1, opc->opc2, opc->opc1, opc->opc2,
1041 opc->oname);
1042 }
1043 } else {
1044 printf(" %02x %02x %02x (%2d %4d) : %s\n",
1045 opc->opc1, opc->opc2, opc->opc3,
1046 opc->opc1, (opc->opc3 << 5) | opc->opc2,
1047 opc->oname);
1048 }
1049 }
1050 #endif
1051 }
1052 }
1053 fix_opcode_tables(env->opcodes);
1054 fflush(stdout);
1055 fflush(stderr);
1056
1057 return 0;
1058 }
1059
1060 int cpu_ppc_register (CPUPPCState *env, ppc_def_t *def)
1061 {
1062 env->msr_mask = def->msr_mask;
1063 env->flags = def->flags;
1064 if (create_ppc_opcodes(env, def) < 0) {
1065 printf("Error creating opcodes table\n");
1066 fflush(stdout);
1067 fflush(stderr);
1068 return -1;
1069 }
1070 init_ppc_proc(env, def);
1071 #if defined(PPC_DUMP_CPU)
1072 dump_sprs(env);
1073 #endif
1074 fflush(stdout);
1075 fflush(stderr);
1076
1077 return 0;
1078 }
1079
1080 CPUPPCState *cpu_ppc_init(void)
1081 {
1082 CPUPPCState *env;
1083
1084 env = qemu_mallocz(sizeof(CPUPPCState));
1085 if (!env)
1086 return NULL;
1087 cpu_exec_init(env);
1088 tlb_flush(env, 1);
1089 #if defined (DO_SINGLE_STEP) && 0
1090 /* Single step trace mode */
1091 msr_se = 1;
1092 msr_be = 1;
1093 #endif
1094 msr_fp = 1; /* Allow floating point exceptions */
1095 msr_me = 1; /* Allow machine check exceptions */
1096 #if defined(CONFIG_USER_ONLY)
1097 msr_pr = 1;
1098 #else
1099 env->nip = 0xFFFFFFFC;
1100 #endif
1101 do_compute_hflags(env);
1102 env->reserve = -1;
1103 return env;
1104 }
1105
1106 void cpu_ppc_close(CPUPPCState *env)
1107 {
1108 /* Should also remove all opcode tables... */
1109 free(env);
1110 }
1111
1112 /*****************************************************************************/
1113 /* PowerPC CPU definitions */
1114 static ppc_def_t ppc_defs[] =
1115 {
1116 /* Embedded PPC */
1117 #if defined (TODO)
1118 /* PPC 401 */
1119 {
1120 .name = "401",
1121 .pvr = CPU_PPC_401,
1122 .pvr_mask = 0xFFFF0000,
1123 .insns_flags = PPC_INSNS_401,
1124 .flags = PPC_FLAGS_401,
1125 .msr_mask = xxx,
1126 },
1127 #endif
1128 #if defined (TODO)
1129 /* IOP480 (401 microcontroler) */
1130 {
1131 .name = "iop480",
1132 .pvr = CPU_PPC_IOP480,
1133 .pvr_mask = 0xFFFF0000,
1134 .insns_flags = PPC_INSNS_401,
1135 .flags = PPC_FLAGS_401,
1136 .msr_mask = xxx,
1137 },
1138 #endif
1139 #if defined (TODO)
1140 /* PPC 403 GA */
1141 {
1142 .name = "403ga",
1143 .pvr = CPU_PPC_403GA,
1144 .pvr_mask = 0xFFFFFF00,
1145 .insns_flags = PPC_INSNS_403,
1146 .flags = PPC_FLAGS_403,
1147 .msr_mask = 0x000000000007D23D,
1148 },
1149 #endif
1150 #if defined (TODO)
1151 /* PPC 403 GB */
1152 {
1153 .name = "403gb",
1154 .pvr = CPU_PPC_403GB,
1155 .pvr_mask = 0xFFFFFF00,
1156 .insns_flags = PPC_INSNS_403,
1157 .flags = PPC_FLAGS_403,
1158 .msr_mask = 0x000000000007D23D,
1159 },
1160 #endif
1161 #if defined (TODO)
1162 /* PPC 403 GC */
1163 {
1164 .name = "403gc",
1165 .pvr = CPU_PPC_403GC,
1166 .pvr_mask = 0xFFFFFF00,
1167 .insns_flags = PPC_INSNS_403,
1168 .flags = PPC_FLAGS_403,
1169 .msr_mask = 0x000000000007D23D,
1170 },
1171 #endif
1172 #if defined (TODO)
1173 /* PPC 403 GCX */
1174 {
1175 .name = "403gcx",
1176 .pvr = CPU_PPC_403GCX,
1177 .pvr_mask = 0xFFFFFF00,
1178 .insns_flags = PPC_INSNS_403,
1179 .flags = PPC_FLAGS_403,
1180 .msr_mask = 0x000000000007D23D,
1181 },
1182 #endif
1183 #if defined (TODO)
1184 /* PPC 405 CR */
1185 {
1186 .name = "405cr",
1187 .pvr = CPU_PPC_405,
1188 .pvr_mask = 0xFFFF0000,
1189 .insns_flags = PPC_INSNS_405,
1190 .flags = PPC_FLAGS_405,
1191 .msr_mask = 0x00000000020EFF30,
1192 },
1193 #endif
1194 #if defined (TODO)
1195 /* PPC 405 GP */
1196 {
1197 .name = "405gp",
1198 .pvr = CPU_PPC_405,
1199 .pvr_mask = 0xFFFF0000,
1200 .insns_flags = PPC_INSNS_405,
1201 .flags = PPC_FLAGS_405,
1202 .msr_mask = 0x00000000020EFF30,
1203 },
1204 #endif
1205 #if defined (TODO)
1206 /* PPC 405 EP */
1207 {
1208 .name = "405ep",
1209 .pvr = CPU_PPC_405EP,
1210 .pvr_mask = 0xFFFF0000,
1211 .insns_flags = PPC_INSNS_405,
1212 .flags = PPC_FLAGS_405,
1213 .msr_mask = 0x00000000020EFF30,
1214 },
1215 #endif
1216 #if defined (TODO)
1217 /* PPC 405 GPR */
1218 {
1219 .name = "405gpr",
1220 .pvr = CPU_PPC_405GPR,
1221 .pvr_mask = 0xFFFF0000,
1222 .insns_flags = PPC_INSNS_405,
1223 .flags = PPC_FLAGS_405,
1224 .msr_mask = 0x00000000020EFF30,
1225 },
1226 #endif
1227 #if defined (TODO)
1228 /* PPC 405 D2 */
1229 {
1230 .name = "405d2",
1231 .pvr = CPU_PPC_405D2,
1232 .pvr_mask = 0xFFFF0000,
1233 .insns_flags = PPC_INSNS_405,
1234 .flags = PPC_FLAGS_405,
1235 .msr_mask = 0x00000000020EFF30,
1236 },
1237 #endif
1238 #if defined (TODO)
1239 /* PPC 405 D4 */
1240 {
1241 .name = "405d4",
1242 .pvr = CPU_PPC_405D4,
1243 .pvr_mask = 0xFFFF0000,
1244 .insns_flags = PPC_INSNS_405,
1245 .flags = PPC_FLAGS_405,
1246 .msr_mask = 0x00000000020EFF30,
1247 },
1248 #endif
1249 #if defined (TODO)
1250 /* Npe405 H */
1251 {
1252 .name = "Npe405H",
1253 .pvr = CPU_PPC_NPE405H,
1254 .pvr_mask = 0xFFFF0000,
1255 .insns_flags = PPC_INSNS_405,
1256 .flags = PPC_FLAGS_405,
1257 .msr_mask = 0x00000000020EFF30,
1258 },
1259 #endif
1260 #if defined (TODO)
1261 /* Npe405 L */
1262 {
1263 .name = "Npe405L",
1264 .pvr = CPU_PPC_NPE405L,
1265 .pvr_mask = 0xFFFF0000,
1266 .insns_flags = PPC_INSNS_405,
1267 .flags = PPC_FLAGS_405,
1268 .msr_mask = 0x00000000020EFF30,
1269 },
1270 #endif
1271 #if defined (TODO)
1272 /* STB03xx */
1273 {
1274 .name = "STB03",
1275 .pvr = CPU_PPC_STB03,
1276 .pvr_mask = 0xFFFF0000,
1277 .insns_flags = PPC_INSNS_405,
1278 .flags = PPC_FLAGS_405,
1279 .msr_mask = 0x00000000020EFF30,
1280 },
1281 #endif
1282 #if defined (TODO)
1283 /* STB04xx */
1284 {
1285 .name = "STB04",
1286 .pvr = CPU_PPC_STB04,
1287 .pvr_mask = 0xFFFF0000,
1288 .insns_flags = PPC_INSNS_405,
1289 .flags = PPC_FLAGS_405,
1290 .msr_mask = 0x00000000020EFF30,
1291 },
1292 #endif
1293 #if defined (TODO)
1294 /* STB25xx */
1295 {
1296 .name = "STB25",
1297 .pvr = CPU_PPC_STB25,
1298 .pvr_mask = 0xFFFF0000,
1299 .insns_flags = PPC_INSNS_405,
1300 .flags = PPC_FLAGS_405,
1301 .msr_mask = 0x00000000020EFF30,
1302 },
1303 #endif
1304 #if defined (TODO)
1305 /* PPC 440 EP */
1306 {
1307 .name = "440ep",
1308 .pvr = CPU_PPC_440EP,
1309 .pvr_mask = 0xFFFF0000,
1310 .insns_flags = PPC_INSNS_440,
1311 .flags = PPC_FLAGS_440,
1312 .msr_mask = 0x000000000006D630,
1313 },
1314 #endif
1315 #if defined (TODO)
1316 /* PPC 440 GP */
1317 {
1318 .name = "440gp",
1319 .pvr = CPU_PPC_440GP,
1320 .pvr_mask = 0xFFFFFF00,
1321 .insns_flags = PPC_INSNS_440,
1322 .flags = PPC_FLAGS_440,
1323 .msr_mask = 0x000000000006D630,
1324 },
1325 #endif
1326 #if defined (TODO)
1327 /* PPC 440 GX */
1328 {
1329 .name = "440gx",
1330 .pvr = CPU_PPC_440GX,
1331 .pvr_mask = 0xFFFF0000,
1332 .insns_flags = PPC_INSNS_405,
1333 .flags = PPC_FLAGS_440,
1334 .msr_mask = 0x000000000006D630,
1335 },
1336 #endif
1337
1338 /* 32 bits "classic" powerpc */
1339 #if defined (TODO)
1340 /* PPC 601 */
1341 {
1342 .name = "601",
1343 .pvr = CPU_PPC_601,
1344 .pvr_mask = 0xFFFF0000,
1345 .insns_flags = PPC_INSNS_601,
1346 .flags = PPC_FLAGS_601,
1347 .msr_mask = 0x000000000000FD70,
1348 },
1349 #endif
1350 #if defined (TODO)
1351 /* PPC 602 */
1352 {
1353 .name = "602",
1354 .pvr = CPU_PPC_602,
1355 .pvr_mask = 0xFFFF0000,
1356 .insns_flags = PPC_INSNS_602,
1357 .flags = PPC_FLAGS_602,
1358 .msr_mask = 0x0000000000C7FF73,
1359 },
1360 #endif
1361 #if defined (TODO)
1362 /* PPC 603 */
1363 {
1364 .name = "603",
1365 .pvr = CPU_PPC_603,
1366 .pvr_mask = 0xFFFF0000,
1367 .insns_flags = PPC_INSNS_603,
1368 .flags = PPC_FLAGS_603,
1369 .msr_mask = 0x000000000007FF73,
1370 },
1371 #endif
1372 #if defined (TODO)
1373 /* PPC 603e */
1374 {
1375 .name = "603e",
1376 .pvr = CPU_PPC_603E,
1377 .pvr_mask = 0xFFFF0000,
1378 .insns_flags = PPC_INSNS_603,
1379 .flags = PPC_FLAGS_603,
1380 .msr_mask = 0x000000000007FF73,
1381 },
1382 {
1383 .name = "Stretch",
1384 .pvr = CPU_PPC_603E,
1385 .pvr_mask = 0xFFFF0000,
1386 .insns_flags = PPC_INSNS_603,
1387 .flags = PPC_FLAGS_603,
1388 .msr_mask = 0x000000000007FF73,
1389 },
1390 #endif
1391 #if defined (TODO)
1392 /* PPC 603ev */
1393 {
1394 .name = "603ev",
1395 .pvr = CPU_PPC_603EV,
1396 .pvr_mask = 0xFFFFF000,
1397 .insns_flags = PPC_INSNS_603,
1398 .flags = PPC_FLAGS_603,
1399 .msr_mask = 0x000000000007FF73,
1400 },
1401 #endif
1402 #if defined (TODO)
1403 /* PPC 603r */
1404 {
1405 .name = "603r",
1406 .pvr = CPU_PPC_603R,
1407 .pvr_mask = 0xFFFFF000,
1408 .insns_flags = PPC_INSNS_603,
1409 .flags = PPC_FLAGS_603,
1410 .msr_mask = 0x000000000007FF73,
1411 },
1412 {
1413 .name = "Goldeneye",
1414 .pvr = CPU_PPC_603R,
1415 .pvr_mask = 0xFFFFF000,
1416 .insns_flags = PPC_INSNS_603,
1417 .flags = PPC_FLAGS_603,
1418 .msr_mask = 0x000000000007FF73,
1419 },
1420 #endif
1421 #if defined (TODO)
1422 /* XXX: TODO: according to Motorola UM, this is a derivative to 603e */
1423 {
1424 .name = "G2",
1425 .pvr = CPU_PPC_G2,
1426 .pvr_mask = 0xFFFF0000,
1427 .insns_flags = PPC_INSNS_G2,
1428 .flags = PPC_FLAGS_G2,
1429 .msr_mask = 0x000000000006FFF2,
1430 },
1431 { /* Same as G2, with LE mode support */
1432 .name = "G2le",
1433 .pvr = CPU_PPC_G2LE,
1434 .pvr_mask = 0xFFFF0000,
1435 .insns_flags = PPC_INSNS_G2,
1436 .flags = PPC_FLAGS_G2,
1437 .msr_mask = 0x000000000007FFF3,
1438 },
1439 #endif
1440 /* PPC 604 */
1441 {
1442 .name = "604",
1443 .pvr = CPU_PPC_604,
1444 .pvr_mask = 0xFFFF0000,
1445 .insns_flags = PPC_INSNS_604,
1446 .flags = PPC_FLAGS_604,
1447 .msr_mask = 0x000000000005FF77,
1448 },
1449 /* PPC 604e */
1450 {
1451 .name = "604e",
1452 .pvr = CPU_PPC_604E,
1453 .pvr_mask = 0xFFFF0000,
1454 .insns_flags = PPC_INSNS_604,
1455 .flags = PPC_FLAGS_604,
1456 .msr_mask = 0x000000000005FF77,
1457 },
1458 /* PPC 604r */
1459 {
1460 .name = "604r",
1461 .pvr = CPU_PPC_604R,
1462 .pvr_mask = 0xFFFF0000,
1463 .insns_flags = PPC_INSNS_604,
1464 .flags = PPC_FLAGS_604,
1465 .msr_mask = 0x000000000005FF77,
1466 },
1467 /* generic G3 */
1468 {
1469 .name = "G3",
1470 .pvr = CPU_PPC_74x,
1471 .pvr_mask = 0xFFFFF000,
1472 .insns_flags = PPC_INSNS_7x0,
1473 .flags = PPC_FLAGS_7x0,
1474 .msr_mask = 0x000000000007FF77,
1475 },
1476 #if defined (TODO)
1477 /* MPC740 (G3) */
1478 {
1479 .name = "740",
1480 .pvr = CPU_PPC_74x,
1481 .pvr_mask = 0xFFFFF000,
1482 .insns_flags = PPC_INSNS_7x0,
1483 .flags = PPC_FLAGS_7x0,
1484 .msr_mask = 0x000000000007FF77,
1485 },
1486 {
1487 .name = "Arthur",
1488 .pvr = CPU_PPC_74x,
1489 .pvr_mask = 0xFFFFF000,
1490 .insns_flags = PPC_INSNS_7x0,
1491 .flags = PPC_FLAGS_7x0,
1492 .msr_mask = 0x000000000007FF77,
1493 },
1494 #endif
1495 #if defined (TODO)
1496 /* MPC745 (G3) */
1497 {
1498 .name = "745",
1499 .pvr = CPU_PPC_74x,
1500 .pvr_mask = 0xFFFFF000,
1501 .insns_flags = PPC_INSNS_7x5,
1502 .flags = PPC_FLAGS_7x5,
1503 .msr_mask = 0x000000000007FF77,
1504 },
1505 {
1506 .name = "Goldfinger",
1507 .pvr = CPU_PPC_74x,
1508 .pvr_mask = 0xFFFFF000,
1509 .insns_flags = PPC_INSNS_7x5,
1510 .flags = PPC_FLAGS_7x5,
1511 .msr_mask = 0x000000000007FF77,
1512 },
1513 #endif
1514 /* MPC750 (G3) */
1515 {
1516 .name = "750",
1517 .pvr = CPU_PPC_74x,
1518 .pvr_mask = 0xFFFFF000,
1519 .insns_flags = PPC_INSNS_7x0,
1520 .flags = PPC_FLAGS_7x0,
1521 .msr_mask = 0x000000000007FF77,
1522 },
1523 #if defined (TODO)
1524 /* MPC755 (G3) */
1525 {
1526 .name = "755",
1527 .pvr = CPU_PPC_755,
1528 .pvr_mask = 0xFFFFF000,
1529 .insns_flags = PPC_INSNS_7x5,
1530 .flags = PPC_FLAGS_7x5,
1531 .msr_mask = 0x000000000007FF77,
1532 },
1533 #endif
1534 #if defined (TODO)
1535 /* MPC740P (G3) */
1536 {
1537 .name = "740p",
1538 .pvr = CPU_PPC_74xP,
1539 .pvr_mask = 0xFFFFF000,
1540 .insns_flags = PPC_INSNS_7x0,
1541 .flags = PPC_FLAGS_7x0,
1542 .msr_mask = 0x000000000007FF77,
1543 },
1544 {
1545 .name = "Conan/Doyle",
1546 .pvr = CPU_PPC_74xP,
1547 .pvr_mask = 0xFFFFF000,
1548 .insns_flags = PPC_INSNS_7x0,
1549 .flags = PPC_FLAGS_7x0,
1550 .msr_mask = 0x000000000007FF77,
1551 },
1552 #endif
1553 #if defined (TODO)
1554 /* MPC745P (G3) */
1555 {
1556 .name = "745p",
1557 .pvr = CPU_PPC_74xP,
1558 .pvr_mask = 0xFFFFF000,
1559 .insns_flags = PPC_INSNS_7x5,
1560 .flags = PPC_FLAGS_7x5,
1561 .msr_mask = 0x000000000007FF77,
1562 },
1563 #endif
1564 /* MPC750P (G3) */
1565 {
1566 .name = "750p",
1567 .pvr = CPU_PPC_74xP,
1568 .pvr_mask = 0xFFFFF000,
1569 .insns_flags = PPC_INSNS_7x0,
1570 .flags = PPC_FLAGS_7x0,
1571 .msr_mask = 0x000000000007FF77,
1572 },
1573 #if defined (TODO)
1574 /* MPC755P (G3) */
1575 {
1576 .name = "755p",
1577 .pvr = CPU_PPC_74xP,
1578 .pvr_mask = 0xFFFFF000,
1579 .insns_flags = PPC_INSNS_7x5,
1580 .flags = PPC_FLAGS_7x5,
1581 .msr_mask = 0x000000000007FF77,
1582 },
1583 #endif
1584 /* IBM 750CXe (G3 embedded) */
1585 {
1586 .name = "750cxe",
1587 .pvr = CPU_PPC_750CXE,
1588 .pvr_mask = 0xFFFFF000,
1589 .insns_flags = PPC_INSNS_7x0,
1590 .flags = PPC_FLAGS_7x0,
1591 .msr_mask = 0x000000000007FF77,
1592 },
1593 /* IBM 750FX (G3 embedded) */
1594 {
1595 .name = "750fx",
1596 .pvr = CPU_PPC_750FX,
1597 .pvr_mask = 0xFFFF0000,
1598 .insns_flags = PPC_INSNS_7x0,
1599 .flags = PPC_FLAGS_7x0,
1600 .msr_mask = 0x000000000007FF77,
1601 },
1602 /* IBM 750GX (G3 embedded) */
1603 {
1604 .name = "750gx",
1605 .pvr = CPU_PPC_750GX,
1606 .pvr_mask = 0xFFFF0000,
1607 .insns_flags = PPC_INSNS_7x0,
1608 .flags = PPC_FLAGS_7x0,
1609 .msr_mask = 0x000000000007FF77,
1610 },
1611 #if defined (TODO)
1612 /* generic G4 */
1613 {
1614 .name = "G4",
1615 .pvr = CPU_PPC_7400,
1616 .pvr_mask = 0xFFFF0000,
1617 .insns_flags = PPC_INSNS_74xx,
1618 .flags = PPC_FLAGS_74xx,
1619 .msr_mask = 0x000000000205FF77,
1620 },
1621 #endif
1622 #if defined (TODO)
1623 /* PPC 7400 (G4) */
1624 {
1625 .name = "7400",
1626 .pvr = CPU_PPC_7400,
1627 .pvr_mask = 0xFFFF0000,
1628 .insns_flags = PPC_INSNS_74xx,
1629 .flags = PPC_FLAGS_74xx,
1630 .msr_mask = 0x000000000205FF77,
1631 },
1632 {
1633 .name = "Max",
1634 .pvr = CPU_PPC_7400,
1635 .pvr_mask = 0xFFFF0000,
1636 .insns_flags = PPC_INSNS_74xx,
1637 .flags = PPC_FLAGS_74xx,
1638 .msr_mask = 0x000000000205FF77,
1639 },
1640 #endif
1641 #if defined (TODO)
1642 /* PPC 7410 (G4) */
1643 {
1644 .name = "7410",
1645 .pvr = CPU_PPC_7410,
1646 .pvr_mask = 0xFFFF0000,
1647 .insns_flags = PPC_INSNS_74xx,
1648 .flags = PPC_FLAGS_74xx,
1649 .msr_mask = 0x000000000205FF77,
1650 },
1651 {
1652 .name = "Nitro",
1653 .pvr = CPU_PPC_7410,
1654 .pvr_mask = 0xFFFF0000,
1655 .insns_flags = PPC_INSNS_74xx,
1656 .flags = PPC_FLAGS_74xx,
1657 .msr_mask = 0x000000000205FF77,
1658 },
1659 #endif
1660 /* XXX: 7441 */
1661 /* XXX: 7445 */
1662 /* XXX: 7447 */
1663 /* XXX: 7447A */
1664 #if defined (TODO)
1665 /* PPC 7450 (G4) */
1666 {
1667 .name = "7450",
1668 .pvr = CPU_PPC_7450,
1669 .pvr_mask = 0xFFFF0000,
1670 .insns_flags = PPC_INSNS_74xx,
1671 .flags = PPC_FLAGS_74xx,
1672 .msr_mask = 0x000000000205FF77,
1673 },
1674 {
1675 .name = "Vger",
1676 .pvr = CPU_PPC_7450,
1677 .pvr_mask = 0xFFFF0000,
1678 .insns_flags = PPC_INSNS_74xx,
1679 .flags = PPC_FLAGS_74xx,
1680 .msr_mask = 0x000000000205FF77,
1681 },
1682 #endif
1683 /* XXX: 7451 */
1684 #if defined (TODO)
1685 /* PPC 7455 (G4) */
1686 {
1687 .name = "7455",
1688 .pvr = CPU_PPC_7455,
1689 .pvr_mask = 0xFFFF0000,
1690 .insns_flags = PPC_INSNS_74xx,
1691 .flags = PPC_FLAGS_74xx,
1692 .msr_mask = 0x000000000205FF77,
1693 },
1694 {
1695 .name = "Apollo 6",
1696 .pvr = CPU_PPC_7455,
1697 .pvr_mask = 0xFFFF0000,
1698 .insns_flags = PPC_INSNS_74xx,
1699 .flags = PPC_FLAGS_74xx,
1700 .msr_mask = 0x000000000205FF77,
1701 },
1702 #endif
1703 #if defined (TODO)
1704 /* PPC 7457 (G4) */
1705 {
1706 .name = "7457",
1707 .pvr = CPU_PPC_7457,
1708 .pvr_mask = 0xFFFF0000,
1709 .insns_flags = PPC_INSNS_74xx,
1710 .flags = PPC_FLAGS_74xx,
1711 .msr_mask = 0x000000000205FF77,
1712 },
1713 {
1714 .name = "Apollo 7",
1715 .pvr = CPU_PPC_7457,
1716 .pvr_mask = 0xFFFF0000,
1717 .insns_flags = PPC_INSNS_74xx,
1718 .flags = PPC_FLAGS_74xx,
1719 .msr_mask = 0x000000000205FF77,
1720 },
1721 #endif
1722 #if defined (TODO)
1723 /* PPC 7457A (G4) */
1724 {
1725 .name = "7457A",
1726 .pvr = CPU_PPC_7457A,
1727 .pvr_mask = 0xFFFF0000,
1728 .insns_flags = PPC_INSNS_74xx,
1729 .flags = PPC_FLAGS_74xx,
1730 .msr_mask = 0x000000000205FF77,
1731 },
1732 {
1733 .name = "Apollo 7 PM",
1734 .pvr = CPU_PPC_7457A,
1735 .pvr_mask = 0xFFFF0000,
1736 .insns_flags = PPC_INSNS_74xx,
1737 .flags = PPC_FLAGS_74xx,
1738 .msr_mask = 0x000000000205FF77,
1739 },
1740 #endif
1741 /* 64 bits PPC */
1742 #if defined (TODO)
1743 /* PPC 620 */
1744 {
1745 .name = "620",
1746 .pvr = CPU_PPC_620,
1747 .pvr_mask = 0xFFFF0000,
1748 .insns_flags = PPC_INSNS_620,
1749 .flags = PPC_FLAGS_620,
1750 .msr_mask = 0x800000000005FF73,
1751 },
1752 #endif
1753 #if defined (TODO)
1754 /* PPC 630 (POWER3) */
1755 {
1756 .name = "630",
1757 .pvr = CPU_PPC_630,
1758 .pvr_mask = 0xFFFF0000,
1759 .insns_flags = PPC_INSNS_630,
1760 .flags = PPC_FLAGS_630,
1761 .msr_mask = xxx,
1762 }
1763 {
1764 .name = "POWER3",
1765 .pvr = CPU_PPC_630,
1766 .pvr_mask = 0xFFFF0000,
1767 .insns_flags = PPC_INSNS_630,
1768 .flags = PPC_FLAGS_630,
1769 .msr_mask = xxx,
1770 }
1771 #endif
1772 #if defined (TODO)
1773 /* PPC 631 (Power 3+)*/
1774 {
1775 .name = "631",
1776 .pvr = CPU_PPC_631,
1777 .pvr_mask = 0xFFFF0000,
1778 .insns_flags = PPC_INSNS_631,
1779 .flags = PPC_FLAGS_631,
1780 .msr_mask = xxx,
1781 },
1782 {
1783 .name = "POWER3+",
1784 .pvr = CPU_PPC_631,
1785 .pvr_mask = 0xFFFF0000,
1786 .insns_flags = PPC_INSNS_631,
1787 .flags = PPC_FLAGS_631,
1788 .msr_mask = xxx,
1789 },
1790 #endif
1791 #if defined (TODO)
1792 /* POWER4 */
1793 {
1794 .name = "POWER4",
1795 .pvr = CPU_PPC_POWER4,
1796 .pvr_mask = 0xFFFF0000,
1797 .insns_flags = PPC_INSNS_POWER4,
1798 .flags = PPC_FLAGS_POWER4,
1799 .msr_mask = xxx,
1800 },
1801 #endif
1802 #if defined (TODO)
1803 /* POWER4p */
1804 {
1805 .name = "POWER4+",
1806 .pvr = CPU_PPC_POWER4P,
1807 .pvr_mask = 0xFFFF0000,
1808 .insns_flags = PPC_INSNS_POWER4,
1809 .flags = PPC_FLAGS_POWER4,
1810 .msr_mask = xxx,
1811 },
1812 #endif
1813 #if defined (TODO)
1814 /* POWER5 */
1815 {
1816 .name = "POWER5",
1817 .pvr = CPU_PPC_POWER5,
1818 .pvr_mask = 0xFFFF0000,
1819 .insns_flags = PPC_INSNS_POWER5,
1820 .flags = PPC_FLAGS_POWER5,
1821 .msr_mask = xxx,
1822 },
1823 #endif
1824 #if defined (TODO)
1825 /* POWER5+ */
1826 {
1827 .name = "POWER5+",
1828 .pvr = CPU_PPC_POWER5P,
1829 .pvr_mask = 0xFFFF0000,
1830 .insns_flags = PPC_INSNS_POWER5,
1831 .flags = PPC_FLAGS_POWER5,
1832 .msr_mask = xxx,
1833 },
1834 #endif
1835 #if defined (TODO)
1836 /* PPC 970 */
1837 {
1838 .name = "970",
1839 .pvr = CPU_PPC_970,
1840 .pvr_mask = 0xFFFF0000,
1841 .insns_flags = PPC_INSNS_970,
1842 .flags = PPC_FLAGS_970,
1843 .msr_mask = 0x900000000204FF36,
1844 },
1845 #endif
1846 #if defined (TODO)
1847 /* PPC 970FX (G5) */
1848 {
1849 .name = "970fx",
1850 .pvr = CPU_PPC_970FX,
1851 .pvr_mask = 0xFFFF0000,
1852 .insns_flags = PPC_INSNS_970FX,
1853 .flags = PPC_FLAGS_970FX,
1854 .msr_mask = 0x800000000204FF36,
1855 },
1856 #endif
1857 #if defined (TODO)
1858 /* RS64 (Apache/A35) */
1859 /* This one seems to support the whole POWER2 instruction set
1860 * and the PowerPC 64 one.
1861 */
1862 {
1863 .name = "RS64",
1864 .pvr = CPU_PPC_RS64,
1865 .pvr_mask = 0xFFFF0000,
1866 .insns_flags = PPC_INSNS_RS64,
1867 .flags = PPC_FLAGS_RS64,
1868 .msr_mask = xxx,
1869 },
1870 {
1871 .name = "Apache",
1872 .pvr = CPU_PPC_RS64,
1873 .pvr_mask = 0xFFFF0000,
1874 .insns_flags = PPC_INSNS_RS64,
1875 .flags = PPC_FLAGS_RS64,
1876 .msr_mask = xxx,
1877 },
1878 {
1879 .name = "A35",
1880 .pvr = CPU_PPC_RS64,
1881 .pvr_mask = 0xFFFF0000,
1882 .insns_flags = PPC_INSNS_RS64,
1883 .flags = PPC_FLAGS_RS64,
1884 .msr_mask = xxx,
1885 },
1886 #endif
1887 #if defined (TODO)
1888 /* RS64-II (NorthStar/A50) */
1889 {
1890 .name = "RS64-II",
1891 .pvr = CPU_PPC_RS64II,
1892 .pvr_mask = 0xFFFF0000,
1893 .insns_flags = PPC_INSNS_RS64,
1894 .flags = PPC_FLAGS_RS64,
1895 .msr_mask = xxx,
1896 },
1897 {
1898 .name = "NortStar",
1899 .pvr = CPU_PPC_RS64II,
1900 .pvr_mask = 0xFFFF0000,
1901 .insns_flags = PPC_INSNS_RS64,
1902 .flags = PPC_FLAGS_RS64,
1903 .msr_mask = xxx,
1904 },
1905 {
1906 .name = "A50",
1907 .pvr = CPU_PPC_RS64II,
1908 .pvr_mask = 0xFFFF0000,
1909 .insns_flags = PPC_INSNS_RS64,
1910 .flags = PPC_FLAGS_RS64,
1911 .msr_mask = xxx,
1912 },
1913 #endif
1914 #if defined (TODO)
1915 /* RS64-III (Pulsar) */
1916 {
1917 .name = "RS64-III",
1918 .pvr = CPU_PPC_RS64III,
1919 .pvr_mask = 0xFFFF0000,
1920 .insns_flags = PPC_INSNS_RS64,
1921 .flags = PPC_FLAGS_RS64,
1922 .msr_mask = xxx,
1923 },
1924 {
1925 .name = "Pulsar",
1926 .pvr = CPU_PPC_RS64III,
1927 .pvr_mask = 0xFFFF0000,
1928 .insns_flags = PPC_INSNS_RS64,
1929 .flags = PPC_FLAGS_RS64,
1930 .msr_mask = xxx,
1931 },
1932 #endif
1933 #if defined (TODO)
1934 /* RS64-IV (IceStar/IStar/SStar) */
1935 {
1936 .name = "RS64-IV",
1937 .pvr = CPU_PPC_RS64IV,
1938 .pvr_mask = 0xFFFF0000,
1939 .insns_flags = PPC_INSNS_RS64,
1940 .flags = PPC_FLAGS_RS64,
1941 .msr_mask = xxx,
1942 },
1943 {
1944 .name = "IceStar",
1945 .pvr = CPU_PPC_RS64IV,
1946 .pvr_mask = 0xFFFF0000,
1947 .insns_flags = PPC_INSNS_RS64,
1948 .flags = PPC_FLAGS_RS64,
1949 .msr_mask = xxx,
1950 },
1951 {
1952 .name = "IStar",
1953 .pvr = CPU_PPC_RS64IV,
1954 .pvr_mask = 0xFFFF0000,
1955 .insns_flags = PPC_INSNS_RS64,
1956 .flags = PPC_FLAGS_RS64,
1957 .msr_mask = xxx,
1958 },
1959 {
1960 .name = "SStar",
1961 .pvr = CPU_PPC_RS64IV,
1962 .pvr_mask = 0xFFFF0000,
1963 .insns_flags = PPC_INSNS_RS64,
1964 .flags = PPC_FLAGS_RS64,
1965 .msr_mask = xxx,
1966 },
1967 #endif
1968 /* POWER */
1969 #if defined (TODO)
1970 /* Original POWER */
1971 {
1972 .name = "POWER",
1973 .pvr = CPU_POWER,
1974 .pvr_mask = 0xFFFF0000,
1975 .insns_flags = PPC_INSNS_POWER,
1976 .flags = PPC_FLAGS_POWER,
1977 .msr_mask = xxx,
1978 },
1979 #endif
1980 #if defined (TODO)
1981 /* POWER2 */
1982 {
1983 .name = "POWER2",
1984 .pvr = CPU_POWER2,
1985 .pvr_mask = 0xFFFF0000,
1986 .insns_flags = PPC_INSNS_POWER,
1987 .flags = PPC_FLAGS_POWER,
1988 .msr_mask = xxx,
1989 },
1990 #endif
1991 /* Generic PowerPCs */
1992 #if defined (TODO)
1993 {
1994 .name = "ppc64",
1995 .pvr = CPU_PPC_970,
1996 .pvr_mask = 0xFFFF0000,
1997 .insns_flags = PPC_INSNS_PPC64,
1998 .flags = PPC_FLAGS_PPC64,
1999 .msr_mask = 0xA00000000204FF36,
2000 },
2001 #endif
2002 {
2003 .name = "ppc32",
2004 .pvr = CPU_PPC_604,
2005 .pvr_mask = 0xFFFF0000,
2006 .insns_flags = PPC_INSNS_PPC32,
2007 .flags = PPC_FLAGS_PPC32,
2008 .msr_mask = 0x000000000005FF77,
2009 },
2010 /* Fallback */
2011 {
2012 .name = "ppc",
2013 .pvr = CPU_PPC_604,
2014 .pvr_mask = 0xFFFF0000,
2015 .insns_flags = PPC_INSNS_PPC32,
2016 .flags = PPC_FLAGS_PPC32,
2017 .msr_mask = 0x000000000005FF77,
2018 },
2019 };
2020
2021 int ppc_find_by_name (const unsigned char *name, ppc_def_t **def)
2022 {
2023 int i, ret;
2024
2025 ret = -1;
2026 *def = NULL;
2027 for (i = 0; strcmp(ppc_defs[i].name, "ppc") != 0; i++) {
2028 if (strcasecmp(name, ppc_defs[i].name) == 0) {
2029 *def = &ppc_defs[i];
2030 ret = 0;
2031 break;
2032 }
2033 }
2034
2035 return ret;
2036 }
2037
2038 int ppc_find_by_pvr (uint32_t pvr, ppc_def_t **def)
2039 {
2040 int i, ret;
2041
2042 ret = -1;
2043 *def = NULL;
2044 for (i = 0; ppc_defs[i].name != NULL; i++) {
2045 if ((pvr & ppc_defs[i].pvr_mask) ==
2046 (ppc_defs[i].pvr & ppc_defs[i].pvr_mask)) {
2047 *def = &ppc_defs[i];
2048 ret = 0;
2049 break;
2050 }
2051 }
2052
2053 return ret;
2054 }
2055
2056 void ppc_cpu_list (FILE *f, int (*cpu_fprintf)(FILE *f, const char *fmt, ...))
2057 {
2058 int i;
2059
2060 for (i = 0; ; i++) {
2061 (*cpu_fprintf)(f, "PowerPC '%s' PVR %08x mask %08x\n",
2062 ppc_defs[i].name,
2063 ppc_defs[i].pvr, ppc_defs[i].pvr_mask);
2064 if (strcmp(ppc_defs[i].name, "ppc") == 0)
2065 break;
2066 }
2067 }
Samsung s3c2440 and arm920t support for the mini2440 dev board