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