2 * "Cell Reference Set" HTAB support.
4 * (C) Copyright 2006-2007 TOSHIBA CORPORATION
6 * This code is based on arch/powerpc/platforms/pseries/lpar.c:
7 * Copyright (C) 2001 Todd Inglett, IBM Corporation
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License along
20 * with this program; if not, write to the Free Software Foundation, Inc.,
21 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
26 #include <linux/kernel.h>
27 #include <linux/spinlock.h>
31 #include <asm/pgtable.h>
32 #include <asm/machdep.h>
35 #include "beat_wrapper.h"
38 #define DBG_LOW(fmt...) do { udbg_printf(fmt); } while(0)
40 #define DBG_LOW(fmt...) do { } while(0)
43 static DEFINE_SPINLOCK(beat_htab_lock);
45 static inline unsigned int beat_read_mask(unsigned hpte_group)
47 unsigned long hpte_v[5];
48 unsigned long rmask = 0;
50 beat_read_htab_entries(0, hpte_group + 0, hpte_v);
51 if (!(hpte_v[0] & HPTE_V_BOLTED))
53 if (!(hpte_v[1] & HPTE_V_BOLTED))
55 if (!(hpte_v[2] & HPTE_V_BOLTED))
57 if (!(hpte_v[3] & HPTE_V_BOLTED))
59 beat_read_htab_entries(0, hpte_group + 4, hpte_v);
60 if (!(hpte_v[0] & HPTE_V_BOLTED))
62 if (!(hpte_v[1] & HPTE_V_BOLTED))
64 if (!(hpte_v[2] & HPTE_V_BOLTED))
66 if (!(hpte_v[3] & HPTE_V_BOLTED))
68 hpte_group = ~hpte_group & (htab_hash_mask * HPTES_PER_GROUP);
69 beat_read_htab_entries(0, hpte_group + 0, hpte_v);
70 if (!(hpte_v[0] & HPTE_V_BOLTED))
72 if (!(hpte_v[1] & HPTE_V_BOLTED))
74 if (!(hpte_v[2] & HPTE_V_BOLTED))
76 if (!(hpte_v[3] & HPTE_V_BOLTED))
78 beat_read_htab_entries(0, hpte_group + 4, hpte_v);
79 if (!(hpte_v[0] & HPTE_V_BOLTED))
81 if (!(hpte_v[1] & HPTE_V_BOLTED))
83 if (!(hpte_v[2] & HPTE_V_BOLTED))
85 if (!(hpte_v[3] & HPTE_V_BOLTED))
90 static long beat_lpar_hpte_insert(unsigned long hpte_group,
91 unsigned long va, unsigned long pa,
92 unsigned long rflags, unsigned long vflags,
95 unsigned long lpar_rc;
97 unsigned long hpte_v, hpte_r;
100 /* same as iseries */
101 if (vflags & HPTE_V_SECONDARY)
104 if (!(vflags & HPTE_V_BOLTED))
105 DBG_LOW("hpte_insert(group=%lx, va=%016lx, pa=%016lx, "
106 "rflags=%lx, vflags=%lx, psize=%d)\n",
107 hpte_group, va, pa, rflags, vflags, psize);
109 hpte_v = hpte_encode_v(va, psize) | vflags | HPTE_V_VALID;
110 hpte_r = hpte_encode_r(pa, psize) | rflags;
112 if (!(vflags & HPTE_V_BOLTED))
113 DBG_LOW(" hpte_v=%016lx, hpte_r=%016lx\n", hpte_v, hpte_r);
115 if (rflags & (_PAGE_GUARDED|_PAGE_NO_CACHE))
116 hpte_r &= ~_PAGE_COHERENT;
118 spin_lock_irqsave(&beat_htab_lock, flags);
119 if ((lpar_rc = beat_read_mask(hpte_group)) == 0) {
120 if (!(vflags & HPTE_V_BOLTED))
122 spin_unlock_irqrestore(&beat_htab_lock, flags);
126 lpar_rc = beat_insert_htab_entry(0, hpte_group, lpar_rc << 48,
127 hpte_v, hpte_r, &slot);
128 spin_unlock_irqrestore(&beat_htab_lock, flags);
131 * Since we try and ioremap PHBs we don't own, the pte insert
132 * will fail. However we must catch the failure in hash_page
133 * or we will loop forever, so return -2 in this case.
135 if (unlikely(lpar_rc != 0)) {
136 if (!(vflags & HPTE_V_BOLTED))
137 DBG_LOW(" lpar err %lx\n", lpar_rc);
140 if (!(vflags & HPTE_V_BOLTED))
141 DBG_LOW(" -> slot: %lx\n", slot);
143 /* We have to pass down the secondary bucket bit here as well */
144 return (slot ^ hpte_group) & 15;
147 static long beat_lpar_hpte_remove(unsigned long hpte_group)
149 DBG_LOW("hpte_remove(group=%lx)\n", hpte_group);
153 static unsigned long beat_lpar_hpte_getword0(unsigned long slot)
155 unsigned long dword0, dword[5];
156 unsigned long lpar_rc;
158 lpar_rc = beat_read_htab_entries(0, slot & ~3UL, dword);
160 dword0 = dword[slot&3];
162 BUG_ON(lpar_rc != 0);
167 static void beat_lpar_hptab_clear(void)
169 unsigned long size_bytes = 1UL << ppc64_pft_size;
170 unsigned long hpte_count = size_bytes >> 4;
172 unsigned long dummy0, dummy1;
174 /* TODO: Use bulk call */
175 for (i = 0; i < hpte_count; i++)
176 beat_write_htab_entry(0, i, 0, 0, -1UL, -1UL, &dummy0, &dummy1);
180 * NOTE: for updatepp ops we are fortunate that the linux "newpp" bits and
181 * the low 3 bits of flags happen to line up. So no transform is needed.
182 * We can probably optimize here and assume the high bits of newpp are
183 * already zero. For now I am paranoid.
185 static long beat_lpar_hpte_updatepp(unsigned long slot,
188 int psize, int local)
190 unsigned long lpar_rc;
191 unsigned long dummy0, dummy1, want_v;
194 want_v = hpte_encode_v(va, psize);
197 "avpnv=%016lx, slot=%016lx, psize: %d, newpp %016lx ... ",
198 want_v & HPTE_V_AVPN, slot, psize, newpp);
200 spin_lock_irqsave(&beat_htab_lock, flags);
201 dummy0 = beat_lpar_hpte_getword0(slot);
202 if ((dummy0 & ~0x7FUL) != (want_v & ~0x7FUL)) {
203 DBG_LOW("not found !\n");
204 spin_unlock_irqrestore(&beat_htab_lock, flags);
208 lpar_rc = beat_write_htab_entry(0, slot, 0, newpp, 0, 7, &dummy0,
210 spin_unlock_irqrestore(&beat_htab_lock, flags);
211 if (lpar_rc != 0 || dummy0 == 0) {
212 DBG_LOW("not found !\n");
216 DBG_LOW("ok %lx %lx\n", dummy0, dummy1);
218 BUG_ON(lpar_rc != 0);
223 static long beat_lpar_hpte_find(unsigned long va, int psize)
228 unsigned long want_v, hpte_v;
230 hash = hpt_hash(va, mmu_psize_defs[psize].shift);
231 want_v = hpte_encode_v(va, psize);
233 for (j = 0; j < 2; j++) {
234 slot = (hash & htab_hash_mask) * HPTES_PER_GROUP;
235 for (i = 0; i < HPTES_PER_GROUP; i++) {
236 hpte_v = beat_lpar_hpte_getword0(slot);
238 if (HPTE_V_COMPARE(hpte_v, want_v)
239 && (hpte_v & HPTE_V_VALID)
240 && (!!(hpte_v & HPTE_V_SECONDARY) == j)) {
254 static void beat_lpar_hpte_updateboltedpp(unsigned long newpp,
258 unsigned long lpar_rc, slot, vsid, va, dummy0, dummy1;
261 vsid = get_kernel_vsid(ea);
262 va = (vsid << 28) | (ea & 0x0fffffff);
264 spin_lock_irqsave(&beat_htab_lock, flags);
265 slot = beat_lpar_hpte_find(va, psize);
268 lpar_rc = beat_write_htab_entry(0, slot, 0, newpp, 0, 7,
270 spin_unlock_irqrestore(&beat_htab_lock, flags);
272 BUG_ON(lpar_rc != 0);
275 static void beat_lpar_hpte_invalidate(unsigned long slot, unsigned long va,
276 int psize, int local)
278 unsigned long want_v;
279 unsigned long lpar_rc;
280 unsigned long dummy1, dummy2;
283 DBG_LOW(" inval : slot=%lx, va=%016lx, psize: %d, local: %d\n",
284 slot, va, psize, local);
285 want_v = hpte_encode_v(va, psize);
287 spin_lock_irqsave(&beat_htab_lock, flags);
288 dummy1 = beat_lpar_hpte_getword0(slot);
290 if ((dummy1 & ~0x7FUL) != (want_v & ~0x7FUL)) {
291 DBG_LOW("not found !\n");
292 spin_unlock_irqrestore(&beat_htab_lock, flags);
296 lpar_rc = beat_write_htab_entry(0, slot, 0, 0, HPTE_V_VALID, 0,
298 spin_unlock_irqrestore(&beat_htab_lock, flags);
300 BUG_ON(lpar_rc != 0);
303 void __init hpte_init_beat(void)
305 ppc_md.hpte_invalidate = beat_lpar_hpte_invalidate;
306 ppc_md.hpte_updatepp = beat_lpar_hpte_updatepp;
307 ppc_md.hpte_updateboltedpp = beat_lpar_hpte_updateboltedpp;
308 ppc_md.hpte_insert = beat_lpar_hpte_insert;
309 ppc_md.hpte_remove = beat_lpar_hpte_remove;
310 ppc_md.hpte_clear_all = beat_lpar_hptab_clear;