CONFIG_FILE_LOCKING should not depend on CONFIG_BLOCK
[sfrench/cifs-2.6.git] / arch / powerpc / kvm / 44x_emulate.c
1 /*
2  * This program is free software; you can redistribute it and/or modify
3  * it under the terms of the GNU General Public License, version 2, as
4  * published by the Free Software Foundation.
5  *
6  * This program is distributed in the hope that it will be useful,
7  * but WITHOUT ANY WARRANTY; without even the implied warranty of
8  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
9  * GNU General Public License for more details.
10  *
11  * You should have received a copy of the GNU General Public License
12  * along with this program; if not, write to the Free Software
13  * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
14  *
15  * Copyright IBM Corp. 2008
16  *
17  * Authors: Hollis Blanchard <hollisb@us.ibm.com>
18  */
19
20 #include <asm/kvm_ppc.h>
21 #include <asm/dcr.h>
22 #include <asm/dcr-regs.h>
23 #include <asm/disassemble.h>
24 #include <asm/kvm_44x.h>
25 #include "timing.h"
26
27 #include "booke.h"
28 #include "44x_tlb.h"
29
30 #define XOP_MFDCR   323
31 #define XOP_MTDCR   451
32 #define XOP_TLBSX   914
33 #define XOP_ICCCI   966
34 #define XOP_TLBWE   978
35
36 int kvmppc_core_emulate_op(struct kvm_run *run, struct kvm_vcpu *vcpu,
37                            unsigned int inst, int *advance)
38 {
39         int emulated = EMULATE_DONE;
40         int dcrn;
41         int ra;
42         int rb;
43         int rc;
44         int rs;
45         int rt;
46         int ws;
47
48         switch (get_op(inst)) {
49         case 31:
50                 switch (get_xop(inst)) {
51
52                 case XOP_MFDCR:
53                         dcrn = get_dcrn(inst);
54                         rt = get_rt(inst);
55
56                         /* The guest may access CPR0 registers to determine the timebase
57                          * frequency, and it must know the real host frequency because it
58                          * can directly access the timebase registers.
59                          *
60                          * It would be possible to emulate those accesses in userspace,
61                          * but userspace can really only figure out the end frequency.
62                          * We could decompose that into the factors that compute it, but
63                          * that's tricky math, and it's easier to just report the real
64                          * CPR0 values.
65                          */
66                         switch (dcrn) {
67                         case DCRN_CPR0_CONFIG_ADDR:
68                                 vcpu->arch.gpr[rt] = vcpu->arch.cpr0_cfgaddr;
69                                 break;
70                         case DCRN_CPR0_CONFIG_DATA:
71                                 local_irq_disable();
72                                 mtdcr(DCRN_CPR0_CONFIG_ADDR,
73                                           vcpu->arch.cpr0_cfgaddr);
74                                 vcpu->arch.gpr[rt] = mfdcr(DCRN_CPR0_CONFIG_DATA);
75                                 local_irq_enable();
76                                 break;
77                         default:
78                                 run->dcr.dcrn = dcrn;
79                                 run->dcr.data =  0;
80                                 run->dcr.is_write = 0;
81                                 vcpu->arch.io_gpr = rt;
82                                 vcpu->arch.dcr_needed = 1;
83                                 kvmppc_account_exit(vcpu, DCR_EXITS);
84                                 emulated = EMULATE_DO_DCR;
85                         }
86
87                         break;
88
89                 case XOP_MTDCR:
90                         dcrn = get_dcrn(inst);
91                         rs = get_rs(inst);
92
93                         /* emulate some access in kernel */
94                         switch (dcrn) {
95                         case DCRN_CPR0_CONFIG_ADDR:
96                                 vcpu->arch.cpr0_cfgaddr = vcpu->arch.gpr[rs];
97                                 break;
98                         default:
99                                 run->dcr.dcrn = dcrn;
100                                 run->dcr.data = vcpu->arch.gpr[rs];
101                                 run->dcr.is_write = 1;
102                                 vcpu->arch.dcr_needed = 1;
103                                 kvmppc_account_exit(vcpu, DCR_EXITS);
104                                 emulated = EMULATE_DO_DCR;
105                         }
106
107                         break;
108
109                 case XOP_TLBWE:
110                         ra = get_ra(inst);
111                         rs = get_rs(inst);
112                         ws = get_ws(inst);
113                         emulated = kvmppc_44x_emul_tlbwe(vcpu, ra, rs, ws);
114                         break;
115
116                 case XOP_TLBSX:
117                         rt = get_rt(inst);
118                         ra = get_ra(inst);
119                         rb = get_rb(inst);
120                         rc = get_rc(inst);
121                         emulated = kvmppc_44x_emul_tlbsx(vcpu, rt, ra, rb, rc);
122                         break;
123
124                 case XOP_ICCCI:
125                         break;
126
127                 default:
128                         emulated = EMULATE_FAIL;
129                 }
130
131                 break;
132
133         default:
134                 emulated = EMULATE_FAIL;
135         }
136
137         if (emulated == EMULATE_FAIL)
138                 emulated = kvmppc_booke_emulate_op(run, vcpu, inst, advance);
139
140         return emulated;
141 }
142
143 int kvmppc_core_emulate_mtspr(struct kvm_vcpu *vcpu, int sprn, int rs)
144 {
145         int emulated = EMULATE_DONE;
146
147         switch (sprn) {
148         case SPRN_PID:
149                 kvmppc_set_pid(vcpu, vcpu->arch.gpr[rs]); break;
150         case SPRN_MMUCR:
151                 vcpu->arch.mmucr = vcpu->arch.gpr[rs]; break;
152         case SPRN_CCR0:
153                 vcpu->arch.ccr0 = vcpu->arch.gpr[rs]; break;
154         case SPRN_CCR1:
155                 vcpu->arch.ccr1 = vcpu->arch.gpr[rs]; break;
156         default:
157                 emulated = kvmppc_booke_emulate_mtspr(vcpu, sprn, rs);
158         }
159
160         kvmppc_set_exit_type(vcpu, EMULATED_MTSPR_EXITS);
161         return emulated;
162 }
163
164 int kvmppc_core_emulate_mfspr(struct kvm_vcpu *vcpu, int sprn, int rt)
165 {
166         int emulated = EMULATE_DONE;
167
168         switch (sprn) {
169         case SPRN_PID:
170                 vcpu->arch.gpr[rt] = vcpu->arch.pid; break;
171         case SPRN_MMUCR:
172                 vcpu->arch.gpr[rt] = vcpu->arch.mmucr; break;
173         case SPRN_CCR0:
174                 vcpu->arch.gpr[rt] = vcpu->arch.ccr0; break;
175         case SPRN_CCR1:
176                 vcpu->arch.gpr[rt] = vcpu->arch.ccr1; break;
177         default:
178                 emulated = kvmppc_booke_emulate_mfspr(vcpu, sprn, rt);
179         }
180
181         kvmppc_set_exit_type(vcpu, EMULATED_MFSPR_EXITS);
182         return emulated;
183 }
184