← Back to branch summary

~ubuntu-branches/ubuntu/trusty/qemu/trusty

« back to all changes in this revision

Viewing changes to target-ppc/translate_init.c

  • Committer: Package Import Robot
  • Author(s): Serge Hallyn
  • Date: 2013-10-22 22:47:07 UTC
  • mfrom: (1.8.3) (10.1.42 sid)
  • Revision ID: package-import@ubuntu.com-20131022224707-1lya34fw3k3f24tv
Tags: 1.6.0+dfsg-2ubuntu1
http://bugs.debian.org/709241
* Merge 1.6.0~rc0+dfsg-2exp from debian experimental.  Remaining changes:
  - debian/control
    * update maintainer
    * remove libiscsi, usb-redir, vde, vnc-jpeg, and libssh2-1-dev
      from build-deps
    * enable rbd
    * add qemu-system and qemu-common B/R to qemu-keymaps
    * add D:udev, R:qemu, R:qemu-common and B:qemu-common to
      qemu-system-common
    * qemu-system-arm, qemu-system-ppc, qemu-system-sparc:
      - add qemu-kvm to Provides
      - add qemu-common, qemu-kvm, kvm to B/R
      - remove openbios-sparc from qemu-system-sparc D
      - drop openbios-ppc and openhackware Depends to Suggests (for now)
    * qemu-system-x86:
      - add qemu-common to Breaks/Replaces.
      - add cpu-checker to Recommends.
    * qemu-user: add B/R:qemu-kvm
    * qemu-kvm:
      - add armhf armel powerpc sparc to Architecture
      - C/R/P: qemu-kvm-spice
    * add qemu-common package
    * drop qemu-slof which is not packaged in ubuntu
  - add qemu-system-common.links for tap ifup/down scripts and OVMF link.
  - qemu-system-x86.links:
    * remove pxe rom links which are in kvm-ipxe
    * add symlink for kvm.1 manpage
  - debian/rules
    * add kvm-spice symlink to qemu-kvm
    * call dh_installmodules for qemu-system-x86
    * update dh_installinit to install upstart script
    * run dh_installman (Closes: #709241) (cherrypicked from 1.5.0+dfsg-2)
  - Add qemu-utils.links for kvm-* symlinks.
  - Add qemu-system-x86.qemu-kvm.upstart and .default
  - Add qemu-system-x86.modprobe to set nesting=1
  - Add qemu-system-common.preinst to add kvm group
  - qemu-system-common.postinst: remove bad group acl if there, then have
    udev relabel /dev/kvm.
  - New linaro patches from qemu-linaro rebasing branch
  - Dropped patches:
    * xen-simplify-xen_enabled.patch
    * sparc-linux-user-fix-missing-symbols-in-.rel-.rela.plt-sections.patch
    * main_loop-do-not-set-nonblocking-if-xen_enabled.patch
    * xen_machine_pv-do-not-create-a-dummy-CPU-in-machine-.patch
    * virtio-rng-fix-crash
  - Kept patches:
    * expose_vms_qemu64cpu.patch - updated
    * linaro arm patches from qemu-linaro rebasing branch
  - New patches:
    * fix-pci-add: change CONFIG variable in ifdef to make sure that
      pci_add is defined.
* Add linaro patches
* Add experimental mach-virt patches for arm virtualization.
* qemu-system-common.install: add debian/tmp/usr/lib to install the
  qemu-bridge-helper

Show diffs side-by-side

added added

removed removed

Lines of Context:
target-ppc/translate_init.c
1381
1381
    /* XXX : not implemented */
1382
1382
    spr_register(env, SPR_L2CR, "L2CR",
1383
1383
                 SPR_NOACCESS, SPR_NOACCESS,
1384
 
                 &spr_read_generic, &spr_write_generic,
 
1384
                 &spr_read_generic, NULL,
1385
1385
                 0x00000000);
1386
1386
    /* Not strictly an SPR */
1387
1387
    vscr_init(env, 0x00010000);
3147
3147
                       PPC_CACHE_DCBZ |
3148
3148
                       PPC_MEM_SYNC | PPC_MEM_EIEIO |
3149
3149
                       PPC_4xx_COMMON | PPC_40x_EXCP;
3150
 
    pcc->insns_flags2 = PPC_NONE;
3151
3150
    pcc->msr_mask = 0x00000000000FD201ULL;
3152
3151
    pcc->mmu_model = POWERPC_MMU_REAL;
3153
3152
    pcc->excp_model = POWERPC_EXCP_40x;
3195
3194
                       PPC_MEM_SYNC | PPC_MEM_EIEIO |
3196
3195
                       PPC_40x_TLB | PPC_MEM_TLBIA | PPC_MEM_TLBSYNC |
3197
3196
                       PPC_4xx_COMMON | PPC_40x_EXCP;
3198
 
    pcc->insns_flags2 = PPC_NONE;
3199
3197
    pcc->msr_mask = 0x00000000001FD231ULL;
3200
3198
    pcc->mmu_model = POWERPC_MMU_SOFT_4xx_Z;
3201
3199
    pcc->excp_model = POWERPC_EXCP_40x;
3237
3235
                       PPC_MEM_SYNC | PPC_MEM_EIEIO |
3238
3236
                       PPC_40x_TLB | PPC_MEM_TLBIA | PPC_MEM_TLBSYNC |
3239
3237
                       PPC_4xx_COMMON | PPC_40x_EXCP;
3240
 
    pcc->insns_flags2 = PPC_NONE;
3241
3238
    pcc->msr_mask = 0x00000000001FD631ULL;
3242
3239
    pcc->mmu_model = POWERPC_MMU_SOFT_4xx_Z;
3243
3240
    pcc->excp_model = POWERPC_EXCP_40x;
3285
3282
                       PPC_MEM_SYNC | PPC_MEM_EIEIO |
3286
3283
                       PPC_40x_TLB | PPC_MEM_TLBIA | PPC_MEM_TLBSYNC |
3287
3284
                       PPC_4xx_COMMON | PPC_40x_EXCP;
3288
 
    pcc->insns_flags2 = PPC_NONE;
3289
3285
    pcc->msr_mask = 0x00000000001FD231ULL;
3290
3286
    pcc->mmu_model = POWERPC_MMU_SOFT_4xx_Z;
3291
3287
    pcc->excp_model = POWERPC_EXCP_40x;
3325
3321
                       PPC_CACHE_DCBZ |
3326
3322
                       PPC_MEM_SYNC | PPC_MEM_EIEIO |
3327
3323
                       PPC_4xx_COMMON | PPC_40x_EXCP;
3328
 
    pcc->insns_flags2 = PPC_NONE;
3329
3324
    pcc->msr_mask = 0x000000000007D00DULL;
3330
3325
    pcc->mmu_model = POWERPC_MMU_REAL;
3331
3326
    pcc->excp_model = POWERPC_EXCP_40x;
3385
3380
                       PPC_MEM_SYNC | PPC_MEM_EIEIO |
3386
3381
                       PPC_40x_TLB | PPC_MEM_TLBIA | PPC_MEM_TLBSYNC |
3387
3382
                       PPC_4xx_COMMON | PPC_40x_EXCP;
3388
 
    pcc->insns_flags2 = PPC_NONE;
3389
3383
    pcc->msr_mask = 0x000000000007D00DULL;
3390
3384
    pcc->mmu_model = POWERPC_MMU_SOFT_4xx_Z;
3391
3385
    pcc->excp_model = POWERPC_EXCP_40x;
3444
3438
                       PPC_MEM_SYNC | PPC_MEM_EIEIO |
3445
3439
                       PPC_40x_TLB | PPC_MEM_TLBIA | PPC_MEM_TLBSYNC |
3446
3440
                       PPC_4xx_COMMON | PPC_405_MAC | PPC_40x_EXCP;
3447
 
    pcc->insns_flags2 = PPC_NONE;
3448
3441
    pcc->msr_mask = 0x000000000006E630ULL;
3449
3442
    pcc->mmu_model = POWERPC_MMU_SOFT_4xx;
3450
3443
    pcc->excp_model = POWERPC_EXCP_40x;
3538
3531
                       PPC_MEM_TLBSYNC | PPC_MFTB |
3539
3532
                       PPC_BOOKE | PPC_4xx_COMMON | PPC_405_MAC |
3540
3533
                       PPC_440_SPEC;
3541
 
    pcc->insns_flags2 = PPC_NONE;
3542
3534
    pcc->msr_mask = 0x000000000006FF30ULL;
3543
3535
    pcc->mmu_model = POWERPC_MMU_BOOKE;
3544
3536
    pcc->excp_model = POWERPC_EXCP_BOOKE;
3611
3603
                       PPC_MEM_TLBSYNC | PPC_TLBIVA | PPC_MFTB |
3612
3604
                       PPC_BOOKE | PPC_4xx_COMMON | PPC_405_MAC |
3613
3605
                       PPC_440_SPEC;
3614
 
    pcc->insns_flags2 = PPC_NONE;
3615
3606
    pcc->msr_mask = 0x000000000006FF30ULL;
3616
3607
    pcc->mmu_model = POWERPC_MMU_BOOKE;
3617
3608
    pcc->excp_model = POWERPC_EXCP_BOOKE;
3684
3675
                       PPC_MEM_TLBSYNC | PPC_MFTB |
3685
3676
                       PPC_BOOKE | PPC_4xx_COMMON | PPC_405_MAC |
3686
3677
                       PPC_440_SPEC;
3687
 
    pcc->insns_flags2 = PPC_NONE;
3688
3678
    pcc->msr_mask = 0x000000000006FF30ULL;
3689
3679
    pcc->mmu_model = POWERPC_MMU_BOOKE;
3690
3680
    pcc->excp_model = POWERPC_EXCP_BOOKE;
3775
3765
                       PPC_MEM_TLBSYNC | PPC_MFTB |
3776
3766
                       PPC_BOOKE | PPC_4xx_COMMON | PPC_405_MAC |
3777
3767
                       PPC_440_SPEC;
3778
 
    pcc->insns_flags2 = PPC_NONE;
3779
3768
    pcc->msr_mask = 0x000000000006FF30ULL;
3780
3769
    pcc->mmu_model = POWERPC_MMU_BOOKE;
3781
3770
    pcc->excp_model = POWERPC_EXCP_BOOKE;
3872
3861
                       PPC_MEM_TLBSYNC | PPC_TLBIVA |
3873
3862
                       PPC_BOOKE | PPC_4xx_COMMON | PPC_405_MAC |
3874
3863
                       PPC_440_SPEC;
3875
 
    pcc->insns_flags2 = PPC_NONE;
3876
3864
    pcc->msr_mask = 0x000000000006FF30ULL;
3877
3865
    pcc->mmu_model = POWERPC_MMU_BOOKE;
3878
3866
    pcc->excp_model = POWERPC_EXCP_BOOKE;
3972
3960
                       PPC_MEM_TLBSYNC | PPC_TLBIVA |
3973
3961
                       PPC_BOOKE | PPC_4xx_COMMON | PPC_405_MAC |
3974
3962
                       PPC_440_SPEC;
3975
 
    pcc->insns_flags2 = PPC_NONE;
3976
3963
    pcc->msr_mask = 0x000000000006FF30ULL;
3977
3964
    pcc->mmu_model = POWERPC_MMU_BOOKE;
3978
3965
    pcc->excp_model = POWERPC_EXCP_BOOKE;
4006
3993
                       PPC_MEM_EIEIO | PPC_MEM_SYNC |
4007
3994
                       PPC_CACHE_ICBI | PPC_FLOAT | PPC_FLOAT_STFIWX |
4008
3995
                       PPC_MFTB;
4009
 
    pcc->insns_flags2 = PPC_NONE;
4010
3996
    pcc->msr_mask = 0x000000000001FF43ULL;
4011
3997
    pcc->mmu_model = POWERPC_MMU_REAL;
4012
3998
    pcc->excp_model = POWERPC_EXCP_603;
4039
4025
    pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING  |
4040
4026
                       PPC_MEM_EIEIO | PPC_MEM_SYNC |
4041
4027
                       PPC_CACHE_ICBI | PPC_MFTB;
4042
 
    pcc->insns_flags2 = PPC_NONE;
4043
4028
    pcc->msr_mask = 0x000000000001F673ULL;
4044
4029
    pcc->mmu_model = POWERPC_MMU_MPC8xx;
4045
4030
    pcc->excp_model = POWERPC_EXCP_603;
4106
4091
                       PPC_MEM_SYNC | PPC_MEM_EIEIO |
4107
4092
                       PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | PPC_6xx_TLB |
4108
4093
                       PPC_SEGMENT | PPC_EXTERN;
4109
 
    pcc->insns_flags2 = PPC_NONE;
4110
4094
    pcc->msr_mask = 0x000000000006FFF2ULL;
4111
4095
    pcc->mmu_model = POWERPC_MMU_SOFT_6xx;
4112
4096
    pcc->excp_model = POWERPC_EXCP_G2;
4198
4182
                       PPC_MEM_SYNC | PPC_MEM_EIEIO |
4199
4183
                       PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | PPC_6xx_TLB |
4200
4184
                       PPC_SEGMENT | PPC_EXTERN;
4201
 
    pcc->insns_flags2 = PPC_NONE;
4202
4185
    pcc->msr_mask = 0x000000000007FFF3ULL;
4203
4186
    pcc->mmu_model = POWERPC_MMU_SOFT_6xx;
4204
4187
    pcc->excp_model = POWERPC_EXCP_G2;
4339
4322
                       PPC_CACHE_DCBZ | PPC_CACHE_DCBA |
4340
4323
                       PPC_MEM_TLBSYNC | PPC_TLBIVAX |
4341
4324
                       PPC_BOOKE;
4342
 
    pcc->insns_flags2 = PPC_NONE;
4343
4325
    pcc->msr_mask = 0x000000000606FF30ULL;
4344
4326
    pcc->mmu_model = POWERPC_MMU_BOOKE206;
4345
4327
    pcc->excp_model = POWERPC_EXCP_BOOKE;
4398
4380
                       PPC_MEM_SYNC | PPC_MEM_EIEIO |
4399
4381
                       PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | PPC_6xx_TLB |
4400
4382
                       PPC_SEGMENT | PPC_EXTERN;
4401
 
    pcc->insns_flags2 = PPC_NONE;
4402
4383
    pcc->msr_mask = 0x000000000007FFF3ULL;
4403
4384
    pcc->mmu_model = POWERPC_MMU_SOFT_6xx;
4404
4385
    pcc->excp_model = POWERPC_EXCP_603;
4810
4791
                       PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
4811
4792
                       PPC_MEM_SYNC | PPC_MEM_EIEIO | PPC_MEM_TLBIE |
4812
4793
                       PPC_SEGMENT | PPC_EXTERN;
4813
 
    pcc->insns_flags2 = PPC_NONE;
4814
4794
    pcc->msr_mask = 0x000000000000FD70ULL;
4815
4795
    pcc->mmu_model = POWERPC_MMU_601;
4816
4796
#if defined(CONFIG_SOFTMMU)
4847
4827
                       PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
4848
4828
                       PPC_MEM_SYNC | PPC_MEM_EIEIO | PPC_MEM_TLBIE |
4849
4829
                       PPC_SEGMENT | PPC_EXTERN;
4850
 
    pcc->insns_flags2 = PPC_NONE;
4851
4830
    pcc->msr_mask = 0x000000000000FD70ULL;
4852
4831
    pcc->mmu_model = POWERPC_MMU_601;
4853
4832
#if defined(CONFIG_SOFTMMU)
4900
4879
                       PPC_MEM_SYNC | PPC_MEM_EIEIO |
4901
4880
                       PPC_MEM_TLBIE | PPC_6xx_TLB | PPC_MEM_TLBSYNC |
4902
4881
                       PPC_SEGMENT | PPC_602_SPEC;
4903
 
    pcc->insns_flags2 = PPC_NONE;
4904
4882
    pcc->msr_mask = 0x0000000000C7FF73ULL;
4905
4883
    /* XXX: 602 MMU is quite specific. Should add a special case */
4906
4884
    pcc->mmu_model = POWERPC_MMU_SOFT_6xx;
4953
4931
                       PPC_MEM_SYNC | PPC_MEM_EIEIO |
4954
4932
                       PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | PPC_6xx_TLB |
4955
4933
                       PPC_SEGMENT | PPC_EXTERN;
4956
 
    pcc->insns_flags2 = PPC_NONE;
4957
4934
    pcc->msr_mask = 0x000000000007FF73ULL;
4958
4935
    pcc->mmu_model = POWERPC_MMU_SOFT_6xx;
4959
4936
    pcc->excp_model = POWERPC_EXCP_603;
4980
4957
                 SPR_NOACCESS, SPR_NOACCESS,
4981
4958
                 &spr_read_generic, &spr_write_generic,
4982
4959
                 0x00000000);
4983
 
    /* XXX : not implemented */
4984
 
    spr_register(env, SPR_IABR, "IABR",
4985
 
                 SPR_NOACCESS, SPR_NOACCESS,
4986
 
                 &spr_read_generic, &spr_write_generic,
4987
 
                 0x00000000);
4988
4960
    /* Memory management */
4989
4961
    gen_low_BATs(env);
4990
4962
    gen_6xx_7xx_soft_tlb(env, 64, 2);
5010
4982
                       PPC_MEM_SYNC | PPC_MEM_EIEIO |
5011
4983
                       PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | PPC_6xx_TLB |
5012
4984
                       PPC_SEGMENT | PPC_EXTERN;
5013
 
    pcc->insns_flags2 = PPC_NONE;
5014
4985
    pcc->msr_mask = 0x000000000007FF73ULL;
5015
4986
    pcc->mmu_model = POWERPC_MMU_SOFT_6xx;
5016
4987
    pcc->excp_model = POWERPC_EXCP_603E;
5056
5027
                       PPC_MEM_SYNC | PPC_MEM_EIEIO |
5057
5028
                       PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
5058
5029
                       PPC_SEGMENT | PPC_EXTERN;
5059
 
    pcc->insns_flags2 = PPC_NONE;
5060
5030
    pcc->msr_mask = 0x000000000005FF77ULL;
5061
5031
    pcc->mmu_model = POWERPC_MMU_32B;
5062
5032
#if defined(CONFIG_SOFTMMU)
5125
5095
                       PPC_MEM_SYNC | PPC_MEM_EIEIO |
5126
5096
                       PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
5127
5097
                       PPC_SEGMENT | PPC_EXTERN;
5128
 
    pcc->insns_flags2 = PPC_NONE;
5129
5098
    pcc->msr_mask = 0x000000000005FF77ULL;
5130
5099
    pcc->mmu_model = POWERPC_MMU_32B;
5131
5100
#if defined(CONFIG_SOFTMMU)
5181
5150
                       PPC_MEM_SYNC | PPC_MEM_EIEIO |
5182
5151
                       PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
5183
5152
                       PPC_SEGMENT | PPC_EXTERN;
5184
 
    pcc->insns_flags2 = PPC_NONE;
5185
5153
    pcc->msr_mask = 0x000000000005FF77ULL;
5186
5154
    pcc->mmu_model = POWERPC_MMU_32B;
5187
5155
#if defined(CONFIG_SOFTMMU)
5201
5169
    /* XXX : not implemented */
5202
5170
    spr_register(env, SPR_L2CR, "L2CR",
5203
5171
                 SPR_NOACCESS, SPR_NOACCESS,
5204
 
                 &spr_read_generic, &spr_write_generic,
 
5172
                 &spr_read_generic, NULL,
5205
5173
                 0x00000000);
5206
5174
    /* Time base */
5207
5175
    gen_tbl(env);
5245
5213
                       PPC_MEM_SYNC | PPC_MEM_EIEIO |
5246
5214
                       PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
5247
5215
                       PPC_SEGMENT | PPC_EXTERN;
5248
 
    pcc->insns_flags2 = PPC_NONE;
5249
5216
    pcc->msr_mask = 0x000000000005FF77ULL;
5250
5217
    pcc->mmu_model = POWERPC_MMU_32B;
5251
5218
#if defined(CONFIG_SOFTMMU)
5265
5232
    /* XXX : not implemented */
5266
5233
    spr_register(env, SPR_L2CR, "L2CR",
5267
5234
                 SPR_NOACCESS, SPR_NOACCESS,
5268
 
                 &spr_read_generic, &spr_write_generic,
 
5235
                 &spr_read_generic, NULL,
5269
5236
                 0x00000000);
5270
5237
    /* Time base */
5271
5238
    gen_tbl(env);
5432
5399
                       PPC_MEM_SYNC | PPC_MEM_EIEIO |
5433
5400
                       PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
5434
5401
                       PPC_SEGMENT | PPC_EXTERN;
5435
 
    pcc->insns_flags2 = PPC_NONE;
5436
5402
    pcc->msr_mask = 0x000000000005FF77ULL;
5437
5403
    pcc->mmu_model = POWERPC_MMU_32B;
5438
5404
#if defined(CONFIG_SOFTMMU)
5452
5418
    /* XXX : not implemented */
5453
5419
    spr_register(env, SPR_L2CR, "L2CR",
5454
5420
                 SPR_NOACCESS, SPR_NOACCESS,
5455
 
                 &spr_read_generic, &spr_write_generic,
 
5421
                 &spr_read_generic, NULL,
5456
5422
                 0x00000000);
5457
5423
    /* Time base */
5458
5424
    gen_tbl(env);
5500
5466
                       PPC_MEM_SYNC | PPC_MEM_EIEIO |
5501
5467
                       PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
5502
5468
                       PPC_SEGMENT | PPC_EXTERN;
5503
 
    pcc->insns_flags2 = PPC_NONE;
5504
5469
    pcc->msr_mask = 0x000000000005FF77ULL;
5505
5470
    pcc->mmu_model = POWERPC_MMU_32B;
5506
5471
#if defined(CONFIG_SOFTMMU)
5520
5485
    /* XXX : not implemented */
5521
5486
    spr_register(env, SPR_L2CR, "L2CR",
5522
5487
                 SPR_NOACCESS, SPR_NOACCESS,
5523
 
                 &spr_read_generic, &spr_write_generic,
 
5488
                 &spr_read_generic, NULL,
5524
5489
                 0x00000000);
5525
5490
    /* Time base */
5526
5491
    gen_tbl(env);
5573
5538
                       PPC_MEM_SYNC | PPC_MEM_EIEIO |
5574
5539
                       PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
5575
5540
                       PPC_SEGMENT | PPC_EXTERN;
5576
 
    pcc->insns_flags2 = PPC_NONE;
5577
5541
    pcc->msr_mask = 0x000000000005FF77ULL;
5578
5542
    pcc->mmu_model = POWERPC_MMU_32B;
5579
5543
#if defined(CONFIG_SOFTMMU)
5593
5557
    /* XXX : not implemented (XXX: different from 750fx) */
5594
5558
    spr_register(env, SPR_L2CR, "L2CR",
5595
5559
                 SPR_NOACCESS, SPR_NOACCESS,
5596
 
                 &spr_read_generic, &spr_write_generic,
 
5560
                 &spr_read_generic, NULL,
5597
5561
                 0x00000000);
5598
5562
    /* Time base */
5599
5563
    gen_tbl(env);
5646
5610
                       PPC_MEM_SYNC | PPC_MEM_EIEIO |
5647
5611
                       PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
5648
5612
                       PPC_SEGMENT | PPC_EXTERN;
5649
 
    pcc->insns_flags2 = PPC_NONE;
5650
5613
    pcc->msr_mask = 0x000000000005FF77ULL;
5651
5614
    pcc->mmu_model = POWERPC_MMU_32B;
5652
5615
#if defined(CONFIG_SOFTMMU)
5710
5673
                       PPC_MEM_SYNC | PPC_MEM_EIEIO |
5711
5674
                       PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | PPC_6xx_TLB |
5712
5675
                       PPC_SEGMENT | PPC_EXTERN;
5713
 
    pcc->insns_flags2 = PPC_NONE;
5714
5676
    pcc->msr_mask = 0x000000000005FF77ULL;
5715
5677
    pcc->mmu_model = POWERPC_MMU_SOFT_6xx;
5716
5678
    pcc->excp_model = POWERPC_EXCP_7x5;
5731
5693
    /* XXX : not implemented */
5732
5694
    spr_register(env, SPR_L2CR, "L2CR",
5733
5695
                 SPR_NOACCESS, SPR_NOACCESS,
5734
 
                 &spr_read_generic, &spr_write_generic,
 
5696
                 &spr_read_generic, NULL,
5735
5697
                 0x00000000);
5736
5698
    /* XXX : not implemented */
5737
5699
    spr_register(env, SPR_L2PMCR, "L2PMCR",
5782
5744
                       PPC_MEM_SYNC | PPC_MEM_EIEIO |
5783
5745
                       PPC_MEM_TLBIE | PPC_MEM_TLBSYNC | PPC_6xx_TLB |
5784
5746
                       PPC_SEGMENT | PPC_EXTERN;
5785
 
    pcc->insns_flags2 = PPC_NONE;
5786
5747
    pcc->msr_mask = 0x000000000005FF77ULL;
5787
5748
    pcc->mmu_model = POWERPC_MMU_SOFT_6xx;
5788
5749
    pcc->excp_model = POWERPC_EXCP_7x5;
5841
5802
                       PPC_MEM_TLBIA |
5842
5803
                       PPC_SEGMENT | PPC_EXTERN |
5843
5804
                       PPC_ALTIVEC;
5844
 
    pcc->insns_flags2 = PPC_NONE;
5845
5805
    pcc->msr_mask = 0x000000000205FF77ULL;
5846
5806
    pcc->mmu_model = POWERPC_MMU_32B;
5847
5807
#if defined(CONFIG_SOFTMMU)
5910
5870
                       PPC_MEM_TLBIA |
5911
5871
                       PPC_SEGMENT | PPC_EXTERN |
5912
5872
                       PPC_ALTIVEC;
5913
 
    pcc->insns_flags2 = PPC_NONE;
5914
5873
    pcc->msr_mask = 0x000000000205FF77ULL;
5915
5874
    pcc->mmu_model = POWERPC_MMU_32B;
5916
5875
#if defined(CONFIG_SOFTMMU)
6005
5964
                       PPC_MEM_TLBIA | PPC_74xx_TLB |
6006
5965
                       PPC_SEGMENT | PPC_EXTERN |
6007
5966
                       PPC_ALTIVEC;
6008
 
    pcc->insns_flags2 = PPC_NONE;
6009
5967
    pcc->msr_mask = 0x000000000205FF77ULL;
6010
5968
    pcc->mmu_model = POWERPC_MMU_SOFT_74xx;
6011
5969
    pcc->excp_model = POWERPC_EXCP_74xx;
6123
6081
                       PPC_MEM_TLBIA | PPC_74xx_TLB |
6124
6082
                       PPC_SEGMENT | PPC_EXTERN |
6125
6083
                       PPC_ALTIVEC;
6126
 
    pcc->insns_flags2 = PPC_NONE;
6127
6084
    pcc->msr_mask = 0x000000000205FF77ULL;
6128
6085
    pcc->mmu_model = POWERPC_MMU_SOFT_74xx;
6129
6086
    pcc->excp_model = POWERPC_EXCP_74xx;
6244
6201
                       PPC_MEM_TLBIA | PPC_74xx_TLB |
6245
6202
                       PPC_SEGMENT | PPC_EXTERN |
6246
6203
                       PPC_ALTIVEC;
6247
 
    pcc->insns_flags2 = PPC_NONE;
6248
6204
    pcc->msr_mask = 0x000000000205FF77ULL;
6249
6205
    pcc->mmu_model = POWERPC_MMU_SOFT_74xx;
6250
6206
    pcc->excp_model = POWERPC_EXCP_74xx;
6367
6323
                       PPC_MEM_TLBIA | PPC_74xx_TLB |
6368
6324
                       PPC_SEGMENT | PPC_EXTERN |
6369
6325
                       PPC_ALTIVEC;
6370
 
    pcc->insns_flags2 = PPC_NONE;
6371
6326
    pcc->msr_mask = 0x000000000205FF77ULL;
6372
6327
    pcc->mmu_model = POWERPC_MMU_SOFT_74xx;
6373
6328
    pcc->excp_model = POWERPC_EXCP_74xx;
6514
6469
                       PPC_MEM_TLBIA | PPC_74xx_TLB |
6515
6470
                       PPC_SEGMENT | PPC_EXTERN |
6516
6471
                       PPC_ALTIVEC;
 
6472
    pcc->msr_mask = 0x000000000205FF77ULL;
 
6473
    pcc->mmu_model = POWERPC_MMU_SOFT_74xx;
 
6474
    pcc->excp_model = POWERPC_EXCP_74xx;
 
6475
    pcc->bus_model = PPC_FLAGS_INPUT_6xx;
 
6476
    pcc->bfd_mach = bfd_mach_ppc_7400;
 
6477
    pcc->flags = POWERPC_FLAG_VRE | POWERPC_FLAG_SE |
 
6478
                 POWERPC_FLAG_BE | POWERPC_FLAG_PMM |
 
6479
                 POWERPC_FLAG_BUS_CLK;
 
6480
}
 
6481
 
 
6482
static void init_proc_e600 (CPUPPCState *env)
 
6483
{
 
6484
    gen_spr_ne_601(env);
 
6485
    gen_spr_7xx(env);
 
6486
    /* Time base */
 
6487
    gen_tbl(env);
 
6488
    /* 74xx specific SPR */
 
6489
    gen_spr_74xx(env);
 
6490
    /* XXX : not implemented */
 
6491
    spr_register(env, SPR_UBAMR, "UBAMR",
 
6492
                 &spr_read_ureg, SPR_NOACCESS,
 
6493
                 &spr_read_ureg, SPR_NOACCESS,
 
6494
                 0x00000000);
 
6495
    /* XXX : not implemented */
 
6496
    spr_register(env, SPR_LDSTCR, "LDSTCR",
 
6497
                 SPR_NOACCESS, SPR_NOACCESS,
 
6498
                 &spr_read_generic, &spr_write_generic,
 
6499
                 0x00000000);
 
6500
    /* XXX : not implemented */
 
6501
    spr_register(env, SPR_ICTRL, "ICTRL",
 
6502
                 SPR_NOACCESS, SPR_NOACCESS,
 
6503
                 &spr_read_generic, &spr_write_generic,
 
6504
                 0x00000000);
 
6505
    /* XXX : not implemented */
 
6506
    spr_register(env, SPR_MSSSR0, "MSSSR0",
 
6507
                 SPR_NOACCESS, SPR_NOACCESS,
 
6508
                 &spr_read_generic, &spr_write_generic,
 
6509
                 0x00000000);
 
6510
    /* XXX : not implemented */
 
6511
    spr_register(env, SPR_PMC5, "PMC5",
 
6512
                 SPR_NOACCESS, SPR_NOACCESS,
 
6513
                 &spr_read_generic, &spr_write_generic,
 
6514
                 0x00000000);
 
6515
    /* XXX : not implemented */
 
6516
    spr_register(env, SPR_UPMC5, "UPMC5",
 
6517
                 &spr_read_ureg, SPR_NOACCESS,
 
6518
                 &spr_read_ureg, SPR_NOACCESS,
 
6519
                 0x00000000);
 
6520
    /* XXX : not implemented */
 
6521
    spr_register(env, SPR_PMC6, "PMC6",
 
6522
                 SPR_NOACCESS, SPR_NOACCESS,
 
6523
                 &spr_read_generic, &spr_write_generic,
 
6524
                 0x00000000);
 
6525
    /* XXX : not implemented */
 
6526
    spr_register(env, SPR_UPMC6, "UPMC6",
 
6527
                 &spr_read_ureg, SPR_NOACCESS,
 
6528
                 &spr_read_ureg, SPR_NOACCESS,
 
6529
                 0x00000000);
 
6530
    /* SPRGs */
 
6531
    spr_register(env, SPR_SPRG4, "SPRG4",
 
6532
                 SPR_NOACCESS, SPR_NOACCESS,
 
6533
                 &spr_read_generic, &spr_write_generic,
 
6534
                 0x00000000);
 
6535
    spr_register(env, SPR_USPRG4, "USPRG4",
 
6536
                 &spr_read_ureg, SPR_NOACCESS,
 
6537
                 &spr_read_ureg, SPR_NOACCESS,
 
6538
                 0x00000000);
 
6539
    spr_register(env, SPR_SPRG5, "SPRG5",
 
6540
                 SPR_NOACCESS, SPR_NOACCESS,
 
6541
                 &spr_read_generic, &spr_write_generic,
 
6542
                 0x00000000);
 
6543
    spr_register(env, SPR_USPRG5, "USPRG5",
 
6544
                 &spr_read_ureg, SPR_NOACCESS,
 
6545
                 &spr_read_ureg, SPR_NOACCESS,
 
6546
                 0x00000000);
 
6547
    spr_register(env, SPR_SPRG6, "SPRG6",
 
6548
                 SPR_NOACCESS, SPR_NOACCESS,
 
6549
                 &spr_read_generic, &spr_write_generic,
 
6550
                 0x00000000);
 
6551
    spr_register(env, SPR_USPRG6, "USPRG6",
 
6552
                 &spr_read_ureg, SPR_NOACCESS,
 
6553
                 &spr_read_ureg, SPR_NOACCESS,
 
6554
                 0x00000000);
 
6555
    spr_register(env, SPR_SPRG7, "SPRG7",
 
6556
                 SPR_NOACCESS, SPR_NOACCESS,
 
6557
                 &spr_read_generic, &spr_write_generic,
 
6558
                 0x00000000);
 
6559
    spr_register(env, SPR_USPRG7, "USPRG7",
 
6560
                 &spr_read_ureg, SPR_NOACCESS,
 
6561
                 &spr_read_ureg, SPR_NOACCESS,
 
6562
                 0x00000000);
 
6563
    /* Memory management */
 
6564
    gen_low_BATs(env);
 
6565
    gen_high_BATs(env);
 
6566
    gen_74xx_soft_tlb(env, 128, 2);
 
6567
    init_excp_7450(env);
 
6568
    env->dcache_line_size = 32;
 
6569
    env->icache_line_size = 32;
 
6570
    /* Allocate hardware IRQ controller */
 
6571
    ppc6xx_irq_init(env);
 
6572
}
 
6573
 
 
6574
POWERPC_FAMILY(e600)(ObjectClass *oc, void *data)
 
6575
{
 
6576
    DeviceClass *dc = DEVICE_CLASS(oc);
 
6577
    PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
 
6578
 
 
6579
    dc->desc = "PowerPC e600";
 
6580
    pcc->init_proc = init_proc_e600;
 
6581
    pcc->check_pow = check_pow_hid0_74xx;
 
6582
    pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
 
6583
                       PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
 
6584
                       PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |
 
6585
                       PPC_FLOAT_STFIWX |
 
6586
                       PPC_CACHE | PPC_CACHE_ICBI |
 
6587
                       PPC_CACHE_DCBA | PPC_CACHE_DCBZ |
 
6588
                       PPC_MEM_SYNC | PPC_MEM_EIEIO |
 
6589
                       PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
 
6590
                       PPC_MEM_TLBIA | PPC_74xx_TLB |
 
6591
                       PPC_SEGMENT | PPC_EXTERN |
 
6592
                       PPC_ALTIVEC;
6517
6593
    pcc->insns_flags2 = PPC_NONE;
6518
6594
    pcc->msr_mask = 0x000000000205FF77ULL;
6519
 
    pcc->mmu_model = POWERPC_MMU_SOFT_74xx;
 
6595
    pcc->mmu_model = POWERPC_MMU_32B;
 
6596
#if defined(CONFIG_SOFTMMU)
 
6597
    pcc->handle_mmu_fault = ppc_hash32_handle_mmu_fault;
 
6598
#endif
6520
6599
    pcc->excp_model = POWERPC_EXCP_74xx;
6521
6600
    pcc->bus_model = PPC_FLAGS_INPUT_6xx;
6522
6601
    pcc->bfd_mach = bfd_mach_ppc_7400;
6570
6649
    /* XXX : not implemented */
6571
6650
    spr_register(env, SPR_L2CR, "L2CR",
6572
6651
                 SPR_NOACCESS, SPR_NOACCESS,
6573
 
                 &spr_read_generic, &spr_write_generic,
 
6652
                 &spr_read_generic, NULL,
6574
6653
                 0x00000000);
6575
6654
    /* Memory management */
6576
6655
    /* XXX: not correct */
6619
6698
                       PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
6620
6699
                       PPC_64B | PPC_ALTIVEC |
6621
6700
                       PPC_SEGMENT_64B | PPC_SLBI;
6622
 
    pcc->insns_flags2 = PPC_NONE;
6623
6701
    pcc->msr_mask = 0x900000000204FF36ULL;
6624
6702
    pcc->mmu_model = POWERPC_MMU_64B;
6625
6703
#if defined(CONFIG_SOFTMMU)
6671
6749
    /* XXX : not implemented */
6672
6750
    spr_register(env, SPR_L2CR, "L2CR",
6673
6751
                 SPR_NOACCESS, SPR_NOACCESS,
6674
 
                 &spr_read_generic, &spr_write_generic,
 
6752
                 &spr_read_generic, NULL,
6675
6753
                 0x00000000);
6676
6754
    /* Memory management */
6677
6755
    /* XXX: not correct */
6732
6810
                       PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
6733
6811
                       PPC_64B | PPC_ALTIVEC |
6734
6812
                       PPC_SEGMENT_64B | PPC_SLBI;
6735
 
    pcc->insns_flags2 = PPC_NONE;
6736
6813
    pcc->msr_mask = 0x800000000204FF36ULL;
6737
6814
    pcc->mmu_model = POWERPC_MMU_64B;
6738
6815
#if defined(CONFIG_SOFTMMU)
6784
6861
    /* XXX : not implemented */
6785
6862
    spr_register(env, SPR_L2CR, "L2CR",
6786
6863
                 SPR_NOACCESS, SPR_NOACCESS,
6787
 
                 &spr_read_generic, &spr_write_generic,
 
6864
                 &spr_read_generic, NULL,
6788
6865
                 0x00000000);
6789
6866
    /* Memory management */
6790
6867
    /* XXX: not correct */
6833
6910
                       PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
6834
6911
                       PPC_64B | PPC_ALTIVEC |
6835
6912
                       PPC_SEGMENT_64B | PPC_SLBI;
6836
 
    pcc->insns_flags2 = PPC_NONE;
6837
6913
    pcc->msr_mask = 0x800000000204FF36ULL;
6838
6914
    pcc->mmu_model = POWERPC_MMU_64B;
6839
6915
#if defined(CONFIG_SOFTMMU)
6885
6961
    /* XXX : not implemented */
6886
6962
    spr_register(env, SPR_L2CR, "L2CR",
6887
6963
                 SPR_NOACCESS, SPR_NOACCESS,
6888
 
                 &spr_read_generic, &spr_write_generic,
 
6964
                 &spr_read_generic, NULL,
6889
6965
                 0x00000000);
6890
6966
    /* Memory management */
6891
6967
    /* XXX: not correct */
6934
7010
                       PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
6935
7011
                       PPC_64B | PPC_ALTIVEC |
6936
7012
                       PPC_SEGMENT_64B | PPC_SLBI;
6937
 
    pcc->insns_flags2 = PPC_NONE;
6938
7013
    pcc->msr_mask = 0x900000000204FF36ULL;
6939
7014
    pcc->mmu_model = POWERPC_MMU_64B;
6940
7015
#if defined(CONFIG_SOFTMMU)
6948
7023
                 POWERPC_FLAG_BUS_CLK;
6949
7024
}
6950
7025
 
 
7026
static void init_proc_power5plus(CPUPPCState *env)
 
7027
{
 
7028
    gen_spr_ne_601(env);
 
7029
    gen_spr_7xx(env);
 
7030
    /* Time base */
 
7031
    gen_tbl(env);
 
7032
    /* Hardware implementation registers */
 
7033
    /* XXX : not implemented */
 
7034
    spr_register(env, SPR_HID0, "HID0",
 
7035
                 SPR_NOACCESS, SPR_NOACCESS,
 
7036
                 &spr_read_generic, &spr_write_clear,
 
7037
                 0x60000000);
 
7038
    /* XXX : not implemented */
 
7039
    spr_register(env, SPR_HID1, "HID1",
 
7040
                 SPR_NOACCESS, SPR_NOACCESS,
 
7041
                 &spr_read_generic, &spr_write_generic,
 
7042
                 0x00000000);
 
7043
    /* XXX : not implemented */
 
7044
    spr_register(env, SPR_750FX_HID2, "HID2",
 
7045
                 SPR_NOACCESS, SPR_NOACCESS,
 
7046
                 &spr_read_generic, &spr_write_generic,
 
7047
                 0x00000000);
 
7048
    /* XXX : not implemented */
 
7049
    spr_register(env, SPR_970_HID5, "HID5",
 
7050
                 SPR_NOACCESS, SPR_NOACCESS,
 
7051
                 &spr_read_generic, &spr_write_generic,
 
7052
                 POWERPC970_HID5_INIT);
 
7053
    /* XXX : not implemented */
 
7054
    spr_register(env, SPR_L2CR, "L2CR",
 
7055
                 SPR_NOACCESS, SPR_NOACCESS,
 
7056
                 &spr_read_generic, NULL,
 
7057
                 0x00000000);
 
7058
    /* Memory management */
 
7059
    /* XXX: not correct */
 
7060
    gen_low_BATs(env);
 
7061
    /* XXX : not implemented */
 
7062
    spr_register(env, SPR_MMUCFG, "MMUCFG",
 
7063
                 SPR_NOACCESS, SPR_NOACCESS,
 
7064
                 &spr_read_generic, SPR_NOACCESS,
 
7065
                 0x00000000); /* TOFIX */
 
7066
    /* XXX : not implemented */
 
7067
    spr_register(env, SPR_MMUCSR0, "MMUCSR0",
 
7068
                 SPR_NOACCESS, SPR_NOACCESS,
 
7069
                 &spr_read_generic, &spr_write_generic,
 
7070
                 0x00000000); /* TOFIX */
 
7071
    spr_register(env, SPR_HIOR, "SPR_HIOR",
 
7072
                 SPR_NOACCESS, SPR_NOACCESS,
 
7073
                 &spr_read_hior, &spr_write_hior,
 
7074
                 0x00000000);
 
7075
    spr_register(env, SPR_CTRL, "SPR_CTRL",
 
7076
                 SPR_NOACCESS, SPR_NOACCESS,
 
7077
                 &spr_read_generic, &spr_write_generic,
 
7078
                 0x00000000);
 
7079
    spr_register(env, SPR_UCTRL, "SPR_UCTRL",
 
7080
                 SPR_NOACCESS, SPR_NOACCESS,
 
7081
                 &spr_read_generic, &spr_write_generic,
 
7082
                 0x00000000);
 
7083
    spr_register(env, SPR_VRSAVE, "SPR_VRSAVE",
 
7084
                 &spr_read_generic, &spr_write_generic,
 
7085
                 &spr_read_generic, &spr_write_generic,
 
7086
                 0x00000000);
 
7087
#if !defined(CONFIG_USER_ONLY)
 
7088
    env->slb_nr = 64;
 
7089
#endif
 
7090
    init_excp_970(env);
 
7091
    env->dcache_line_size = 128;
 
7092
    env->icache_line_size = 128;
 
7093
    /* Allocate hardware IRQ controller */
 
7094
    ppc970_irq_init(env);
 
7095
    /* Can't find information on what this should be on reset.  This
 
7096
     * value is the one used by 74xx processors. */
 
7097
    vscr_init(env, 0x00010000);
 
7098
}
 
7099
 
 
7100
POWERPC_FAMILY(POWER5P)(ObjectClass *oc, void *data)
 
7101
{
 
7102
    DeviceClass *dc = DEVICE_CLASS(oc);
 
7103
    PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
 
7104
 
 
7105
    dc->desc = "POWER5+";
 
7106
    pcc->init_proc = init_proc_power5plus;
 
7107
    pcc->check_pow = check_pow_970FX;
 
7108
    pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
 
7109
                       PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
 
7110
                       PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |
 
7111
                       PPC_FLOAT_STFIWX |
 
7112
                       PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
 
7113
                       PPC_MEM_SYNC | PPC_MEM_EIEIO |
 
7114
                       PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
 
7115
                       PPC_64B |
 
7116
                       PPC_SEGMENT_64B | PPC_SLBI;
 
7117
    pcc->msr_mask = 0x800000000204FF36ULL;
 
7118
    pcc->mmu_model = POWERPC_MMU_64B;
 
7119
#if defined(CONFIG_SOFTMMU)
 
7120
    pcc->handle_mmu_fault = ppc_hash64_handle_mmu_fault;
 
7121
#endif
 
7122
    pcc->excp_model = POWERPC_EXCP_970;
 
7123
    pcc->bus_model = PPC_FLAGS_INPUT_970;
 
7124
    pcc->bfd_mach = bfd_mach_ppc64;
 
7125
    pcc->flags = POWERPC_FLAG_VRE | POWERPC_FLAG_SE |
 
7126
                 POWERPC_FLAG_BE | POWERPC_FLAG_PMM |
 
7127
                 POWERPC_FLAG_BUS_CLK;
 
7128
}
 
7129
 
6951
7130
static void init_proc_POWER7 (CPUPPCState *env)
6952
7131
{
6953
7132
    gen_spr_ne_601(env);
7061
7240
    pcc->l1_dcache_size = 0x8000;
7062
7241
    pcc->l1_icache_size = 0x8000;
7063
7242
}
 
7243
 
 
7244
POWERPC_FAMILY(POWER8)(ObjectClass *oc, void *data)
 
7245
{
 
7246
    DeviceClass *dc = DEVICE_CLASS(oc);
 
7247
    PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
 
7248
 
 
7249
    dc->desc = "POWER8";
 
7250
    pcc->init_proc = init_proc_POWER7;
 
7251
    pcc->check_pow = check_pow_nocheck;
 
7252
    pcc->insns_flags = PPC_INSNS_BASE | PPC_STRING | PPC_MFTB |
 
7253
                       PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
 
7254
                       PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |
 
7255
                       PPC_FLOAT_STFIWX |
 
7256
                       PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
 
7257
                       PPC_MEM_SYNC | PPC_MEM_EIEIO |
 
7258
                       PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
 
7259
                       PPC_64B | PPC_ALTIVEC |
 
7260
                       PPC_SEGMENT_64B | PPC_SLBI |
 
7261
                       PPC_POPCNTB | PPC_POPCNTWD;
 
7262
    pcc->insns_flags2 = PPC2_VSX | PPC2_DFP | PPC2_DBRX;
 
7263
    pcc->msr_mask = 0x800000000204FF36ULL;
 
7264
    pcc->mmu_model = POWERPC_MMU_2_06;
 
7265
#if defined(CONFIG_SOFTMMU)
 
7266
    pcc->handle_mmu_fault = ppc_hash64_handle_mmu_fault;
 
7267
#endif
 
7268
    pcc->excp_model = POWERPC_EXCP_POWER7;
 
7269
    pcc->bus_model = PPC_FLAGS_INPUT_POWER7;
 
7270
    pcc->bfd_mach = bfd_mach_ppc64;
 
7271
    pcc->flags = POWERPC_FLAG_VRE | POWERPC_FLAG_SE |
 
7272
                 POWERPC_FLAG_BE | POWERPC_FLAG_PMM |
 
7273
                 POWERPC_FLAG_BUS_CLK | POWERPC_FLAG_CFAR;
 
7274
    pcc->l1_dcache_size = 0x8000;
 
7275
    pcc->l1_icache_size = 0x8000;
 
7276
}
7064
7277
#endif /* defined (TARGET_PPC64) */
7065
7278
 
7066
7279
 
7306
7519
{
7307
7520
    opc_handler_t **tmp;
7308
7521
 
7309
 
    tmp = malloc(0x20 * sizeof(opc_handler_t));
 
7522
    tmp = g_malloc(0x20 * sizeof(opc_handler_t));
7310
7523
    fill_new_table(tmp, 0x20);
7311
7524
    table[idx] = (opc_handler_t *)((uintptr_t)tmp | PPC_INDIRECT);
7312
7525
 
7695
7908
 
7696
7909
static void ppc_cpu_realizefn(DeviceState *dev, Error **errp)
7697
7910
{
 
7911
    CPUState *cs = CPU(dev);
7698
7912
    PowerPCCPU *cpu = POWERPC_CPU(dev);
7699
 
    CPUPPCState *env = &cpu->env;
7700
7913
    PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cpu);
7701
7914
    Error *local_err = NULL;
7702
7915
#if !defined(CONFIG_USER_ONLY)
7716
7929
            error_setg(errp, "Unable to virtualize selected CPU with KVM");
7717
7930
            return;
7718
7931
        }
7719
 
    } else {
 
7932
    } else if (tcg_enabled()) {
7720
7933
        if (ppc_fixup_cpu(cpu) != 0) {
7721
7934
            error_setg(errp, "Unable to emulate selected CPU with TCG");
7722
7935
            return;
7740
7953
    init_ppc_proc(cpu);
7741
7954
 
7742
7955
    if (pcc->insns_flags & PPC_FLOAT) {
7743
 
        gdb_register_coprocessor(env, gdb_get_float_reg, gdb_set_float_reg,
 
7956
        gdb_register_coprocessor(cs, gdb_get_float_reg, gdb_set_float_reg,
7744
7957
                                 33, "power-fpu.xml", 0);
7745
7958
    }
7746
7959
    if (pcc->insns_flags & PPC_ALTIVEC) {
7747
 
        gdb_register_coprocessor(env, gdb_get_avr_reg, gdb_set_avr_reg,
 
7960
        gdb_register_coprocessor(cs, gdb_get_avr_reg, gdb_set_avr_reg,
7748
7961
                                 34, "power-altivec.xml", 0);
7749
7962
    }
7750
7963
    if (pcc->insns_flags & PPC_SPE) {
7751
 
        gdb_register_coprocessor(env, gdb_get_spe_reg, gdb_set_spe_reg,
 
7964
        gdb_register_coprocessor(cs, gdb_get_spe_reg, gdb_set_spe_reg,
7752
7965
                                 34, "power-spe.xml", 0);
7753
7966
    }
7754
7967
 
7755
 
    qemu_init_vcpu(env);
 
7968
    qemu_init_vcpu(cs);
7756
7969
 
7757
7970
    pcc->parent_realize(dev, errp);
7758
7971
 
7759
7972
#if defined(PPC_DUMP_CPU)
7760
7973
    {
 
7974
        CPUPPCState *env = &cpu->env;
7761
7975
        const char *mmu_model, *excp_model, *bus_model;
7762
7976
        switch (env->mmu_model) {
7763
7977
        case POWERPC_MMU_32B:
7909
8123
            printf("                        none\n");
7910
8124
        printf("    Time-base/decrementer clock source: %s\n",
7911
8125
               env->flags & POWERPC_FLAG_RTC_CLK ? "RTC clock" : "bus clock");
 
8126
        dump_ppc_insns(env);
 
8127
        dump_ppc_sprs(env);
 
8128
        fflush(stdout);
7912
8129
    }
7913
 
    dump_ppc_insns(env);
7914
 
    dump_ppc_sprs(env);
7915
 
    fflush(stdout);
7916
8130
#endif
7917
8131
}
7918
8132
 
 
8133
static void ppc_cpu_unrealizefn(DeviceState *dev, Error **errp)
 
8134
{
 
8135
    PowerPCCPU *cpu = POWERPC_CPU(dev);
 
8136
    CPUPPCState *env = &cpu->env;
 
8137
    int i;
 
8138
 
 
8139
    for (i = 0; i < PPC_CPU_OPCODES_LEN; i++) {
 
8140
        if (env->opcodes[i] != &invalid_handler) {
 
8141
            g_free(env->opcodes[i]);
 
8142
        }
 
8143
    }
 
8144
}
 
8145
 
7919
8146
static gint ppc_cpu_compare_class_pvr(gconstpointer a, gconstpointer b)
7920
8147
{
7921
8148
    ObjectClass *oc = (ObjectClass *)a;
7973
8200
 
7974
8201
#include <ctype.h>
7975
8202
 
 
8203
static ObjectClass *ppc_cpu_class_by_name(const char *name);
 
8204
 
 
8205
static ObjectClass *ppc_cpu_class_by_alias(PowerPCCPUAlias *alias)
 
8206
{
 
8207
    ObjectClass *invalid_class = (void*)ppc_cpu_class_by_alias;
 
8208
 
 
8209
    /* Cache target class lookups in the alias table */
 
8210
    if (!alias->oc) {
 
8211
        alias->oc = ppc_cpu_class_by_name(alias->model);
 
8212
        if (!alias->oc) {
 
8213
            /* Fast check for non-existing aliases */
 
8214
            alias->oc = invalid_class;
 
8215
        }
 
8216
    }
 
8217
 
 
8218
    if (alias->oc == invalid_class) {
 
8219
        return NULL;
 
8220
    } else {
 
8221
        return alias->oc;
 
8222
    }
 
8223
}
 
8224
 
7976
8225
static ObjectClass *ppc_cpu_class_by_name(const char *name)
7977
8226
{
7978
8227
    GSList *list, *item;
8000
8249
 
8001
8250
    for (i = 0; ppc_cpu_aliases[i].alias != NULL; i++) {
8002
8251
        if (strcmp(ppc_cpu_aliases[i].alias, name) == 0) {
8003
 
            return ppc_cpu_class_by_name(ppc_cpu_aliases[i].model);
 
8252
            return ppc_cpu_class_by_alias(&ppc_cpu_aliases[i]);
8004
8253
        }
8005
8254
    }
8006
8255
 
8090
8339
    (*s->cpu_fprintf)(s->file, "PowerPC %-16s PVR %08x\n",
8091
8340
                      name, pcc->pvr);
8092
8341
    for (i = 0; ppc_cpu_aliases[i].alias != NULL; i++) {
8093
 
        const PowerPCCPUAlias *alias = &ppc_cpu_aliases[i];
8094
 
        ObjectClass *alias_oc = ppc_cpu_class_by_name(alias->model);
 
8342
        PowerPCCPUAlias *alias = &ppc_cpu_aliases[i];
 
8343
        ObjectClass *alias_oc = ppc_cpu_class_by_alias(alias);
8095
8344
 
8096
8345
        if (alias_oc != oc) {
8097
8346
            continue;
8158
8407
    g_slist_free(list);
8159
8408
 
8160
8409
    for (i = 0; ppc_cpu_aliases[i].alias != NULL; i++) {
8161
 
        const PowerPCCPUAlias *alias = &ppc_cpu_aliases[i];
 
8410
        PowerPCCPUAlias *alias = &ppc_cpu_aliases[i];
8162
8411
        ObjectClass *oc;
8163
8412
        CpuDefinitionInfoList *entry;
8164
8413
        CpuDefinitionInfo *info;
8165
8414
 
8166
 
        oc = ppc_cpu_class_by_name(alias->model);
 
8415
        oc = ppc_cpu_class_by_alias(alias);
8167
8416
        if (oc == NULL) {
8168
8417
            continue;
8169
8418
        }
8180
8429
    return cpu_list;
8181
8430
}
8182
8431
 
 
8432
static void ppc_cpu_set_pc(CPUState *cs, vaddr value)
 
8433
{
 
8434
    PowerPCCPU *cpu = POWERPC_CPU(cs);
 
8435
 
 
8436
    cpu->env.nip = value;
 
8437
}
 
8438
 
8183
8439
/* CPUClass::reset() */
8184
8440
static void ppc_cpu_reset(CPUState *s)
8185
8441
{
8188
8444
    CPUPPCState *env = &cpu->env;
8189
8445
    target_ulong msr;
8190
8446
 
8191
 
    if (qemu_loglevel_mask(CPU_LOG_RESET)) {
8192
 
        qemu_log("CPU Reset (CPU %d)\n", s->cpu_index);
8193
 
        log_cpu_state(env, 0);
8194
 
    }
8195
 
 
8196
8447
    pcc->parent_reset(s);
8197
8448
 
8198
8449
    msr = (target_ulong)0;
8303
8554
 
8304
8555
    pcc->parent_realize = dc->realize;
8305
8556
    dc->realize = ppc_cpu_realizefn;
 
8557
    dc->unrealize = ppc_cpu_unrealizefn;
8306
8558
 
8307
8559
    pcc->parent_reset = cc->reset;
8308
8560
    cc->reset = ppc_cpu_reset;
8309
8561
 
8310
8562
    cc->class_by_name = ppc_cpu_class_by_name;
8311
8563
    cc->do_interrupt = ppc_cpu_do_interrupt;
 
8564
    cc->dump_state = ppc_cpu_dump_state;
 
8565
    cc->dump_statistics = ppc_cpu_dump_statistics;
 
8566
    cc->set_pc = ppc_cpu_set_pc;
 
8567
    cc->gdb_read_register = ppc_cpu_gdb_read_register;
 
8568
    cc->gdb_write_register = ppc_cpu_gdb_write_register;
 
8569
#ifndef CONFIG_USER_ONLY
 
8570
    cc->get_phys_page_debug = ppc_cpu_get_phys_page_debug;
 
8571
    cc->vmsd = &vmstate_ppc_cpu;
 
8572
#endif
 
8573
 
 
8574
    cc->gdb_num_core_regs = 71;
 
8575
#if defined(TARGET_PPC64)
 
8576
    cc->gdb_core_xml_file = "power64-core.xml";
 
8577
#else
 
8578
    cc->gdb_core_xml_file = "power-core.xml";
 
8579
#endif
8312
8580
}
8313
8581
 
8314
8582
static const TypeInfo ppc_cpu_type_info = {