1
2
3
4
5
6
7
8
9
10
11
12
13
14
15#include <linux/kvm_host.h>
16#include <linux/slab.h>
17#include <linux/err.h>
18#include <linux/export.h>
19#include <linux/module.h>
20#include <linux/miscdevice.h>
21
22#include <asm/reg.h>
23#include <asm/cputable.h>
24#include <asm/tlbflush.h>
25#include <asm/kvm_ppc.h>
26
27#include "../mm/mmu_decl.h"
28#include "booke.h"
29#include "e500.h"
30
31struct id {
32 unsigned long val;
33 struct id **pentry;
34};
35
36#define NUM_TIDS 256
37
38
39
40
41
42
43
44
45
46
47struct vcpu_id_table {
48 struct id id[2][NUM_TIDS][2];
49};
50
51
52
53
54
55
56struct pcpu_id_table {
57 struct id *entry[NUM_TIDS];
58};
59
60static DEFINE_PER_CPU(struct pcpu_id_table, pcpu_sids);
61
62
63
64static DEFINE_PER_CPU(unsigned long, pcpu_last_used_sid);
65
66
67
68
69
70
71
72
73
74static inline int local_sid_setup_one(struct id *entry)
75{
76 unsigned long sid;
77 int ret = -1;
78
79 sid = __this_cpu_inc_return(pcpu_last_used_sid);
80 if (sid < NUM_TIDS) {
81 __this_cpu_write(pcpu_sids.entry[sid], entry);
82 entry->val = sid;
83 entry->pentry = this_cpu_ptr(&pcpu_sids.entry[sid]);
84 ret = sid;
85 }
86
87
88
89
90
91
92
93
94 WARN_ON(sid > NUM_TIDS);
95
96 return ret;
97}
98
99
100
101
102
103
104
105
106
107
108static inline int local_sid_lookup(struct id *entry)
109{
110 if (entry && entry->val != 0 &&
111 __this_cpu_read(pcpu_sids.entry[entry->val]) == entry &&
112 entry->pentry == this_cpu_ptr(&pcpu_sids.entry[entry->val]))
113 return entry->val;
114 return -1;
115}
116
117
118static inline void local_sid_destroy_all(void)
119{
120 __this_cpu_write(pcpu_last_used_sid, 0);
121 memset(this_cpu_ptr(&pcpu_sids), 0, sizeof(pcpu_sids));
122}
123
124static void *kvmppc_e500_id_table_alloc(struct kvmppc_vcpu_e500 *vcpu_e500)
125{
126 vcpu_e500->idt = kzalloc(sizeof(struct vcpu_id_table), GFP_KERNEL);
127 return vcpu_e500->idt;
128}
129
130static void kvmppc_e500_id_table_free(struct kvmppc_vcpu_e500 *vcpu_e500)
131{
132 kfree(vcpu_e500->idt);
133 vcpu_e500->idt = NULL;
134}
135
136
137
138
139
140static void kvmppc_e500_recalc_shadow_pid(struct kvmppc_vcpu_e500 *vcpu_e500)
141{
142 preempt_disable();
143 vcpu_e500->vcpu.arch.shadow_pid = kvmppc_e500_get_sid(vcpu_e500,
144 get_cur_as(&vcpu_e500->vcpu),
145 get_cur_pid(&vcpu_e500->vcpu),
146 get_cur_pr(&vcpu_e500->vcpu), 1);
147 vcpu_e500->vcpu.arch.shadow_pid1 = kvmppc_e500_get_sid(vcpu_e500,
148 get_cur_as(&vcpu_e500->vcpu), 0,
149 get_cur_pr(&vcpu_e500->vcpu), 1);
150 preempt_enable();
151}
152
153
154static void kvmppc_e500_id_table_reset_all(struct kvmppc_vcpu_e500 *vcpu_e500)
155{
156 memset(vcpu_e500->idt, 0, sizeof(struct vcpu_id_table));
157
158
159 kvmppc_e500_recalc_shadow_pid(vcpu_e500);
160}
161
162
163static inline void kvmppc_e500_id_table_reset_one(
164 struct kvmppc_vcpu_e500 *vcpu_e500,
165 int as, int pid, int pr)
166{
167 struct vcpu_id_table *idt = vcpu_e500->idt;
168
169 BUG_ON(as >= 2);
170 BUG_ON(pid >= NUM_TIDS);
171 BUG_ON(pr >= 2);
172
173 idt->id[as][pid][pr].val = 0;
174 idt->id[as][pid][pr].pentry = NULL;
175
176
177 kvmppc_e500_recalc_shadow_pid(vcpu_e500);
178}
179
180
181
182
183
184
185
186
187
188
189unsigned int kvmppc_e500_get_sid(struct kvmppc_vcpu_e500 *vcpu_e500,
190 unsigned int as, unsigned int gid,
191 unsigned int pr, int avoid_recursion)
192{
193 struct vcpu_id_table *idt = vcpu_e500->idt;
194 int sid;
195
196 BUG_ON(as >= 2);
197 BUG_ON(gid >= NUM_TIDS);
198 BUG_ON(pr >= 2);
199
200 sid = local_sid_lookup(&idt->id[as][gid][pr]);
201
202 while (sid <= 0) {
203
204 sid = local_sid_setup_one(&idt->id[as][gid][pr]);
205 if (sid <= 0) {
206 _tlbil_all();
207 local_sid_destroy_all();
208 }
209
210
211 if (!avoid_recursion)
212 kvmppc_e500_recalc_shadow_pid(vcpu_e500);
213 }
214
215 return sid;
216}
217
218unsigned int kvmppc_e500_get_tlb_stid(struct kvm_vcpu *vcpu,
219 struct kvm_book3e_206_tlb_entry *gtlbe)
220{
221 return kvmppc_e500_get_sid(to_e500(vcpu), get_tlb_ts(gtlbe),
222 get_tlb_tid(gtlbe), get_cur_pr(vcpu), 0);
223}
224
225void kvmppc_set_pid(struct kvm_vcpu *vcpu, u32 pid)
226{
227 struct kvmppc_vcpu_e500 *vcpu_e500 = to_e500(vcpu);
228
229 if (vcpu->arch.pid != pid) {
230 vcpu_e500->pid[0] = vcpu->arch.pid = pid;
231 kvmppc_e500_recalc_shadow_pid(vcpu_e500);
232 }
233}
234
235
236void kvmppc_e500_tlbil_one(struct kvmppc_vcpu_e500 *vcpu_e500,
237 struct kvm_book3e_206_tlb_entry *gtlbe)
238{
239 struct vcpu_id_table *idt = vcpu_e500->idt;
240 unsigned int pr, tid, ts, pid;
241 u32 val, eaddr;
242 unsigned long flags;
243
244 ts = get_tlb_ts(gtlbe);
245 tid = get_tlb_tid(gtlbe);
246
247 preempt_disable();
248
249
250 for (pr = 0; pr < 2; pr++) {
251
252
253
254
255
256
257
258
259
260 pid = local_sid_lookup(&idt->id[ts][tid][pr]);
261 if (pid <= 0) {
262 kvmppc_e500_id_table_reset_one(vcpu_e500, ts, tid, pr);
263 continue;
264 }
265
266
267
268
269
270
271
272 val = (pid << MAS6_SPID_SHIFT) | MAS6_SAS;
273 eaddr = get_tlb_eaddr(gtlbe);
274
275 local_irq_save(flags);
276
277 mtspr(SPRN_MAS6, val);
278 asm volatile("tlbsx 0, %[eaddr]" : : [eaddr] "r" (eaddr));
279 val = mfspr(SPRN_MAS1);
280 if (val & MAS1_VALID) {
281 mtspr(SPRN_MAS1, val & ~MAS1_VALID);
282 asm volatile("tlbwe");
283 }
284
285 local_irq_restore(flags);
286 }
287
288 preempt_enable();
289}
290
291void kvmppc_e500_tlbil_all(struct kvmppc_vcpu_e500 *vcpu_e500)
292{
293 kvmppc_e500_id_table_reset_all(vcpu_e500);
294}
295
296void kvmppc_mmu_msr_notify(struct kvm_vcpu *vcpu, u32 old_msr)
297{
298
299 kvmppc_e500_recalc_shadow_pid(to_e500(vcpu));
300}
301
302static void kvmppc_core_vcpu_load_e500(struct kvm_vcpu *vcpu, int cpu)
303{
304 kvmppc_booke_vcpu_load(vcpu, cpu);
305
306
307 kvmppc_e500_recalc_shadow_pid(to_e500(vcpu));
308}
309
310static void kvmppc_core_vcpu_put_e500(struct kvm_vcpu *vcpu)
311{
312#ifdef CONFIG_SPE
313 if (vcpu->arch.shadow_msr & MSR_SPE)
314 kvmppc_vcpu_disable_spe(vcpu);
315#endif
316
317 kvmppc_booke_vcpu_put(vcpu);
318}
319
320int kvmppc_core_check_processor_compat(void)
321{
322 int r;
323
324 if (strcmp(cur_cpu_spec->cpu_name, "e500v2") == 0)
325 r = 0;
326 else
327 r = -ENOTSUPP;
328
329 return r;
330}
331
332static void kvmppc_e500_tlb_setup(struct kvmppc_vcpu_e500 *vcpu_e500)
333{
334 struct kvm_book3e_206_tlb_entry *tlbe;
335
336
337 tlbe = get_entry(vcpu_e500, 1, 0);
338 tlbe->mas1 = MAS1_VALID | MAS1_TSIZE(BOOK3E_PAGESZ_256M);
339 tlbe->mas2 = 0;
340 tlbe->mas7_3 = E500_TLB_SUPER_PERM_MASK;
341
342
343 tlbe = get_entry(vcpu_e500, 1, 1);
344 tlbe->mas1 = MAS1_VALID | MAS1_TSIZE(BOOK3E_PAGESZ_4K);
345 tlbe->mas2 = (0xe0004500 & 0xFFFFF000) | MAS2_I | MAS2_G;
346 tlbe->mas7_3 = (0xe0004500 & 0xFFFFF000) | E500_TLB_SUPER_PERM_MASK;
347}
348
349int kvmppc_core_vcpu_setup(struct kvm_vcpu *vcpu)
350{
351 struct kvmppc_vcpu_e500 *vcpu_e500 = to_e500(vcpu);
352
353 kvmppc_e500_tlb_setup(vcpu_e500);
354
355
356 vcpu->arch.pvr = mfspr(SPRN_PVR);
357 vcpu_e500->svr = mfspr(SPRN_SVR);
358
359 vcpu->arch.cpu_type = KVM_CPU_E500V2;
360
361 return 0;
362}
363
364static int kvmppc_core_get_sregs_e500(struct kvm_vcpu *vcpu,
365 struct kvm_sregs *sregs)
366{
367 struct kvmppc_vcpu_e500 *vcpu_e500 = to_e500(vcpu);
368
369 sregs->u.e.features |= KVM_SREGS_E_ARCH206_MMU | KVM_SREGS_E_SPE |
370 KVM_SREGS_E_PM;
371 sregs->u.e.impl_id = KVM_SREGS_E_IMPL_FSL;
372
373 sregs->u.e.impl.fsl.features = 0;
374 sregs->u.e.impl.fsl.svr = vcpu_e500->svr;
375 sregs->u.e.impl.fsl.hid0 = vcpu_e500->hid0;
376 sregs->u.e.impl.fsl.mcar = vcpu_e500->mcar;
377
378 sregs->u.e.ivor_high[0] = vcpu->arch.ivor[BOOKE_IRQPRIO_SPE_UNAVAIL];
379 sregs->u.e.ivor_high[1] = vcpu->arch.ivor[BOOKE_IRQPRIO_SPE_FP_DATA];
380 sregs->u.e.ivor_high[2] = vcpu->arch.ivor[BOOKE_IRQPRIO_SPE_FP_ROUND];
381 sregs->u.e.ivor_high[3] =
382 vcpu->arch.ivor[BOOKE_IRQPRIO_PERFORMANCE_MONITOR];
383
384 kvmppc_get_sregs_ivor(vcpu, sregs);
385 kvmppc_get_sregs_e500_tlb(vcpu, sregs);
386 return 0;
387}
388
389static int kvmppc_core_set_sregs_e500(struct kvm_vcpu *vcpu,
390 struct kvm_sregs *sregs)
391{
392 struct kvmppc_vcpu_e500 *vcpu_e500 = to_e500(vcpu);
393 int ret;
394
395 if (sregs->u.e.impl_id == KVM_SREGS_E_IMPL_FSL) {
396 vcpu_e500->svr = sregs->u.e.impl.fsl.svr;
397 vcpu_e500->hid0 = sregs->u.e.impl.fsl.hid0;
398 vcpu_e500->mcar = sregs->u.e.impl.fsl.mcar;
399 }
400
401 ret = kvmppc_set_sregs_e500_tlb(vcpu, sregs);
402 if (ret < 0)
403 return ret;
404
405 if (!(sregs->u.e.features & KVM_SREGS_E_IVOR))
406 return 0;
407
408 if (sregs->u.e.features & KVM_SREGS_E_SPE) {
409 vcpu->arch.ivor[BOOKE_IRQPRIO_SPE_UNAVAIL] =
410 sregs->u.e.ivor_high[0];
411 vcpu->arch.ivor[BOOKE_IRQPRIO_SPE_FP_DATA] =
412 sregs->u.e.ivor_high[1];
413 vcpu->arch.ivor[BOOKE_IRQPRIO_SPE_FP_ROUND] =
414 sregs->u.e.ivor_high[2];
415 }
416
417 if (sregs->u.e.features & KVM_SREGS_E_PM) {
418 vcpu->arch.ivor[BOOKE_IRQPRIO_PERFORMANCE_MONITOR] =
419 sregs->u.e.ivor_high[3];
420 }
421
422 return kvmppc_set_sregs_ivor(vcpu, sregs);
423}
424
425static int kvmppc_get_one_reg_e500(struct kvm_vcpu *vcpu, u64 id,
426 union kvmppc_one_reg *val)
427{
428 int r = kvmppc_get_one_reg_e500_tlb(vcpu, id, val);
429 return r;
430}
431
432static int kvmppc_set_one_reg_e500(struct kvm_vcpu *vcpu, u64 id,
433 union kvmppc_one_reg *val)
434{
435 int r = kvmppc_get_one_reg_e500_tlb(vcpu, id, val);
436 return r;
437}
438
439static struct kvm_vcpu *kvmppc_core_vcpu_create_e500(struct kvm *kvm,
440 unsigned int id)
441{
442 struct kvmppc_vcpu_e500 *vcpu_e500;
443 struct kvm_vcpu *vcpu;
444 int err;
445
446 vcpu_e500 = kmem_cache_zalloc(kvm_vcpu_cache, GFP_KERNEL);
447 if (!vcpu_e500) {
448 err = -ENOMEM;
449 goto out;
450 }
451
452 vcpu = &vcpu_e500->vcpu;
453 err = kvm_vcpu_init(vcpu, kvm, id);
454 if (err)
455 goto free_vcpu;
456
457 if (kvmppc_e500_id_table_alloc(vcpu_e500) == NULL)
458 goto uninit_vcpu;
459
460 err = kvmppc_e500_tlb_init(vcpu_e500);
461 if (err)
462 goto uninit_id;
463
464 vcpu->arch.shared = (void*)__get_free_page(GFP_KERNEL|__GFP_ZERO);
465 if (!vcpu->arch.shared)
466 goto uninit_tlb;
467
468 return vcpu;
469
470uninit_tlb:
471 kvmppc_e500_tlb_uninit(vcpu_e500);
472uninit_id:
473 kvmppc_e500_id_table_free(vcpu_e500);
474uninit_vcpu:
475 kvm_vcpu_uninit(vcpu);
476free_vcpu:
477 kmem_cache_free(kvm_vcpu_cache, vcpu_e500);
478out:
479 return ERR_PTR(err);
480}
481
482static void kvmppc_core_vcpu_free_e500(struct kvm_vcpu *vcpu)
483{
484 struct kvmppc_vcpu_e500 *vcpu_e500 = to_e500(vcpu);
485
486 free_page((unsigned long)vcpu->arch.shared);
487 kvmppc_e500_tlb_uninit(vcpu_e500);
488 kvmppc_e500_id_table_free(vcpu_e500);
489 kvm_vcpu_uninit(vcpu);
490 kmem_cache_free(kvm_vcpu_cache, vcpu_e500);
491}
492
493static int kvmppc_core_init_vm_e500(struct kvm *kvm)
494{
495 return 0;
496}
497
498static void kvmppc_core_destroy_vm_e500(struct kvm *kvm)
499{
500}
501
502static struct kvmppc_ops kvm_ops_e500 = {
503 .get_sregs = kvmppc_core_get_sregs_e500,
504 .set_sregs = kvmppc_core_set_sregs_e500,
505 .get_one_reg = kvmppc_get_one_reg_e500,
506 .set_one_reg = kvmppc_set_one_reg_e500,
507 .vcpu_load = kvmppc_core_vcpu_load_e500,
508 .vcpu_put = kvmppc_core_vcpu_put_e500,
509 .vcpu_create = kvmppc_core_vcpu_create_e500,
510 .vcpu_free = kvmppc_core_vcpu_free_e500,
511 .mmu_destroy = kvmppc_mmu_destroy_e500,
512 .init_vm = kvmppc_core_init_vm_e500,
513 .destroy_vm = kvmppc_core_destroy_vm_e500,
514 .emulate_op = kvmppc_core_emulate_op_e500,
515 .emulate_mtspr = kvmppc_core_emulate_mtspr_e500,
516 .emulate_mfspr = kvmppc_core_emulate_mfspr_e500,
517};
518
519static int __init kvmppc_e500_init(void)
520{
521 int r, i;
522 unsigned long ivor[3];
523
524 unsigned long *handler = &kvmppc_booke_handler_addr[16];
525 unsigned long handler_len;
526 unsigned long max_ivor = 0;
527
528 r = kvmppc_core_check_processor_compat();
529 if (r)
530 goto err_out;
531
532 r = kvmppc_booke_init();
533 if (r)
534 goto err_out;
535
536
537 ivor[0] = mfspr(SPRN_IVOR32);
538 ivor[1] = mfspr(SPRN_IVOR33);
539 ivor[2] = mfspr(SPRN_IVOR34);
540 for (i = 0; i < 3; i++) {
541 if (ivor[i] > ivor[max_ivor])
542 max_ivor = i;
543
544 handler_len = handler[i + 1] - handler[i];
545 memcpy((void *)kvmppc_booke_handlers + ivor[i],
546 (void *)handler[i], handler_len);
547 }
548 handler_len = handler[max_ivor + 1] - handler[max_ivor];
549 flush_icache_range(kvmppc_booke_handlers, kvmppc_booke_handlers +
550 ivor[max_ivor] + handler_len);
551
552 r = kvm_init(NULL, sizeof(struct kvmppc_vcpu_e500), 0, THIS_MODULE);
553 if (r)
554 goto err_out;
555 kvm_ops_e500.owner = THIS_MODULE;
556 kvmppc_pr_ops = &kvm_ops_e500;
557
558err_out:
559 return r;
560}
561
562static void __exit kvmppc_e500_exit(void)
563{
564 kvmppc_pr_ops = NULL;
565 kvmppc_booke_exit();
566}
567
568module_init(kvmppc_e500_init);
569module_exit(kvmppc_e500_exit);
570MODULE_ALIAS_MISCDEV(KVM_MINOR);
571MODULE_ALIAS("devname:kvm");
572