1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * PS3 pagetable management routines.
4 *
5 * Copyright (C) 2006 Sony Computer Entertainment Inc.
6 * Copyright 2006, 2007 Sony Corporation
7 */
8
9 #include <linux/kernel.h>
10 #include <linux/memblock.h>
11
12 #include <asm/machdep.h>
13 #include <asm/udbg.h>
14 #include <asm/lv1call.h>
15 #include <asm/ps3fb.h>
16
17 #define PS3_VERBOSE_RESULT
18 #include "platform.h"
19
20 /**
21 * enum lpar_vas_id - id of LPAR virtual address space.
22 * @lpar_vas_id_current: Current selected virtual address space
23 *
24 * Identify the target LPAR address space.
25 */
26
27 enum ps3_lpar_vas_id {
28 PS3_LPAR_VAS_ID_CURRENT = 0,
29 };
30
31
32 static DEFINE_SPINLOCK(ps3_htab_lock);
33
34 static long ps3_hpte_insert(unsigned long hpte_group, unsigned long vpn,
35 unsigned long pa, unsigned long rflags, unsigned long vflags,
36 int psize, int apsize, int ssize)
37 {
38 int result;
39 u64 hpte_v, hpte_r;
40 u64 inserted_index;
41 u64 evicted_v, evicted_r;
42 u64 hpte_v_array[4], hpte_rs;
43 unsigned long flags;
44 long ret = -1;
45
46 /*
47 * lv1_insert_htab_entry() will search for victim
48 * entry in both primary and secondary pte group
49 */
50 vflags &= ~HPTE_V_SECONDARY;
51
52 hpte_v = hpte_encode_v(vpn, psize, apsize, ssize) | vflags | HPTE_V_VALID;
53 hpte_r = hpte_encode_r(ps3_mm_phys_to_lpar(pa), psize, apsize) | rflags;
54
55 spin_lock_irqsave(&ps3_htab_lock, flags);
56
57 /* talk hvc to replace entries BOLTED == 0 */
58 result = lv1_insert_htab_entry(PS3_LPAR_VAS_ID_CURRENT, hpte_group,
59 hpte_v, hpte_r,
60 HPTE_V_BOLTED, 0,
61 &inserted_index,
62 &evicted_v, &evicted_r);
63
64 if (result) {
65 /* all entries bolted !*/
66 pr_info("%s:result=%s vpn=%lx pa=%lx ix=%lx v=%llx r=%llx\n",
67 __func__, ps3_result(result), vpn, pa, hpte_group,
68 hpte_v, hpte_r);
69 BUG();
70 }
71
72 /*
73 * see if the entry is inserted into secondary pteg
74 */
75 result = lv1_read_htab_entries(PS3_LPAR_VAS_ID_CURRENT,
76 inserted_index & ~0x3UL,
77 &hpte_v_array[0], &hpte_v_array[1],
78 &hpte_v_array[2], &hpte_v_array[3],
79 &hpte_rs);
80 BUG_ON(result);
81
82 if (hpte_v_array[inserted_index % 4] & HPTE_V_SECONDARY)
83 ret = (inserted_index & 7) | (1 << 3);
84 else
85 ret = inserted_index & 7;
86
87 spin_unlock_irqrestore(&ps3_htab_lock, flags);
88
89 return ret;
90 }
91
92 static long ps3_hpte_remove(unsigned long hpte_group)
93 {
94 panic("ps3_hpte_remove() not implemented");
95 return 0;
96 }
97
98 static long ps3_hpte_updatepp(unsigned long slot, unsigned long newpp,
99 unsigned long vpn, int psize, int apsize,
100 int ssize, unsigned long inv_flags)
101 {
102 int result;
103 u64 hpte_v, want_v, hpte_rs;
104 u64 hpte_v_array[4];
105 unsigned long flags;
106 long ret;
107
108 want_v = hpte_encode_avpn(vpn, psize, ssize);
109
110 spin_lock_irqsave(&ps3_htab_lock, flags);
111
112 result = lv1_read_htab_entries(PS3_LPAR_VAS_ID_CURRENT, slot & ~0x3UL,
113 &hpte_v_array[0], &hpte_v_array[1],
114 &hpte_v_array[2], &hpte_v_array[3],
115 &hpte_rs);
116
117 if (result) {
118 pr_info("%s: result=%s read vpn=%lx slot=%lx psize=%d\n",
119 __func__, ps3_result(result), vpn, slot, psize);
120 BUG();
121 }
122
123 hpte_v = hpte_v_array[slot % 4];
124
125 /*
126 * As lv1_read_htab_entries() does not give us the RPN, we can
127 * not synthesize the new hpte_r value here, and therefore can
128 * not update the hpte with lv1_insert_htab_entry(), so we
129 * instead invalidate it and ask the caller to update it via
130 * ps3_hpte_insert() by returning a -1 value.
131 */
132 if (!HPTE_V_COMPARE(hpte_v, want_v) || !(hpte_v & HPTE_V_VALID)) {
133 /* not found */
134 ret = -1;
135 } else {
136 /* entry found, just invalidate it */
137 result = lv1_write_htab_entry(PS3_LPAR_VAS_ID_CURRENT,
138 slot, 0, 0);
139 ret = -1;
140 }
141
142 spin_unlock_irqrestore(&ps3_htab_lock, flags);
143 return ret;
144 }
145
146 static void ps3_hpte_updateboltedpp(unsigned long newpp, unsigned long ea,
147 int psize, int ssize)
148 {
149 pr_info("ps3_hpte_updateboltedpp() not implemented");
150 }
151
152 static void ps3_hpte_invalidate(unsigned long slot, unsigned long vpn,
153 int psize, int apsize, int ssize, int local)
154 {
155 unsigned long flags;
156 int result;
157
158 spin_lock_irqsave(&ps3_htab_lock, flags);
159
160 result = lv1_write_htab_entry(PS3_LPAR_VAS_ID_CURRENT, slot, 0, 0);
161
162 if (result) {
163 pr_info("%s: result=%s vpn=%lx slot=%lx psize=%d\n",
164 __func__, ps3_result(result), vpn, slot, psize);
165 BUG();
166 }
167
168 spin_unlock_irqrestore(&ps3_htab_lock, flags);
169 }
170
171 /* Called during kexec sequence with MMU off */
172 static notrace void ps3_hpte_clear(void)
173 {
174 unsigned long hpte_count = (1UL << ppc64_pft_size) >> 4;
175 u64 i;
176
177 for (i = 0; i < hpte_count; i++)
178 lv1_write_htab_entry(PS3_LPAR_VAS_ID_CURRENT, i, 0, 0);
179
180 ps3_mm_shutdown();
181 ps3_mm_vas_destroy();
182 }
183
184 void __init ps3_hpte_init(unsigned long htab_size)
185 {
186 mmu_hash_ops.hpte_invalidate = ps3_hpte_invalidate;
187 mmu_hash_ops.hpte_updatepp = ps3_hpte_updatepp;
188 mmu_hash_ops.hpte_updateboltedpp = ps3_hpte_updateboltedpp;
189 mmu_hash_ops.hpte_insert = ps3_hpte_insert;
190 mmu_hash_ops.hpte_remove = ps3_hpte_remove;
191 mmu_hash_ops.hpte_clear_all = ps3_hpte_clear;
192
193 ppc64_pft_size = __ilog2(htab_size);
194 }
195
196
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.