forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
196 lines
4.9 KiB
196 lines
4.9 KiB
// SPDX-License-Identifier: GPL-2.0-only |
|
/* |
|
* PS3 pagetable management routines. |
|
* |
|
* Copyright (C) 2006 Sony Computer Entertainment Inc. |
|
* Copyright 2006, 2007 Sony Corporation |
|
*/ |
|
|
|
#include <linux/kernel.h> |
|
#include <linux/memblock.h> |
|
|
|
#include <asm/machdep.h> |
|
#include <asm/prom.h> |
|
#include <asm/udbg.h> |
|
#include <asm/lv1call.h> |
|
#include <asm/ps3fb.h> |
|
|
|
#define PS3_VERBOSE_RESULT |
|
#include "platform.h" |
|
|
|
/** |
|
* enum lpar_vas_id - id of LPAR virtual address space. |
|
* @lpar_vas_id_current: Current selected virtual address space |
|
* |
|
* Identify the target LPAR address space. |
|
*/ |
|
|
|
enum ps3_lpar_vas_id { |
|
PS3_LPAR_VAS_ID_CURRENT = 0, |
|
}; |
|
|
|
|
|
static DEFINE_SPINLOCK(ps3_htab_lock); |
|
|
|
static long ps3_hpte_insert(unsigned long hpte_group, unsigned long vpn, |
|
unsigned long pa, unsigned long rflags, unsigned long vflags, |
|
int psize, int apsize, int ssize) |
|
{ |
|
int result; |
|
u64 hpte_v, hpte_r; |
|
u64 inserted_index; |
|
u64 evicted_v, evicted_r; |
|
u64 hpte_v_array[4], hpte_rs; |
|
unsigned long flags; |
|
long ret = -1; |
|
|
|
/* |
|
* lv1_insert_htab_entry() will search for victim |
|
* entry in both primary and secondary pte group |
|
*/ |
|
vflags &= ~HPTE_V_SECONDARY; |
|
|
|
hpte_v = hpte_encode_v(vpn, psize, apsize, ssize) | vflags | HPTE_V_VALID; |
|
hpte_r = hpte_encode_r(ps3_mm_phys_to_lpar(pa), psize, apsize) | rflags; |
|
|
|
spin_lock_irqsave(&ps3_htab_lock, flags); |
|
|
|
/* talk hvc to replace entries BOLTED == 0 */ |
|
result = lv1_insert_htab_entry(PS3_LPAR_VAS_ID_CURRENT, hpte_group, |
|
hpte_v, hpte_r, |
|
HPTE_V_BOLTED, 0, |
|
&inserted_index, |
|
&evicted_v, &evicted_r); |
|
|
|
if (result) { |
|
/* all entries bolted !*/ |
|
pr_info("%s:result=%s vpn=%lx pa=%lx ix=%lx v=%llx r=%llx\n", |
|
__func__, ps3_result(result), vpn, pa, hpte_group, |
|
hpte_v, hpte_r); |
|
BUG(); |
|
} |
|
|
|
/* |
|
* see if the entry is inserted into secondary pteg |
|
*/ |
|
result = lv1_read_htab_entries(PS3_LPAR_VAS_ID_CURRENT, |
|
inserted_index & ~0x3UL, |
|
&hpte_v_array[0], &hpte_v_array[1], |
|
&hpte_v_array[2], &hpte_v_array[3], |
|
&hpte_rs); |
|
BUG_ON(result); |
|
|
|
if (hpte_v_array[inserted_index % 4] & HPTE_V_SECONDARY) |
|
ret = (inserted_index & 7) | (1 << 3); |
|
else |
|
ret = inserted_index & 7; |
|
|
|
spin_unlock_irqrestore(&ps3_htab_lock, flags); |
|
|
|
return ret; |
|
} |
|
|
|
static long ps3_hpte_remove(unsigned long hpte_group) |
|
{ |
|
panic("ps3_hpte_remove() not implemented"); |
|
return 0; |
|
} |
|
|
|
static long ps3_hpte_updatepp(unsigned long slot, unsigned long newpp, |
|
unsigned long vpn, int psize, int apsize, |
|
int ssize, unsigned long inv_flags) |
|
{ |
|
int result; |
|
u64 hpte_v, want_v, hpte_rs; |
|
u64 hpte_v_array[4]; |
|
unsigned long flags; |
|
long ret; |
|
|
|
want_v = hpte_encode_avpn(vpn, psize, ssize); |
|
|
|
spin_lock_irqsave(&ps3_htab_lock, flags); |
|
|
|
result = lv1_read_htab_entries(PS3_LPAR_VAS_ID_CURRENT, slot & ~0x3UL, |
|
&hpte_v_array[0], &hpte_v_array[1], |
|
&hpte_v_array[2], &hpte_v_array[3], |
|
&hpte_rs); |
|
|
|
if (result) { |
|
pr_info("%s: result=%s read vpn=%lx slot=%lx psize=%d\n", |
|
__func__, ps3_result(result), vpn, slot, psize); |
|
BUG(); |
|
} |
|
|
|
hpte_v = hpte_v_array[slot % 4]; |
|
|
|
/* |
|
* As lv1_read_htab_entries() does not give us the RPN, we can |
|
* not synthesize the new hpte_r value here, and therefore can |
|
* not update the hpte with lv1_insert_htab_entry(), so we |
|
* instead invalidate it and ask the caller to update it via |
|
* ps3_hpte_insert() by returning a -1 value. |
|
*/ |
|
if (!HPTE_V_COMPARE(hpte_v, want_v) || !(hpte_v & HPTE_V_VALID)) { |
|
/* not found */ |
|
ret = -1; |
|
} else { |
|
/* entry found, just invalidate it */ |
|
result = lv1_write_htab_entry(PS3_LPAR_VAS_ID_CURRENT, |
|
slot, 0, 0); |
|
ret = -1; |
|
} |
|
|
|
spin_unlock_irqrestore(&ps3_htab_lock, flags); |
|
return ret; |
|
} |
|
|
|
static void ps3_hpte_updateboltedpp(unsigned long newpp, unsigned long ea, |
|
int psize, int ssize) |
|
{ |
|
panic("ps3_hpte_updateboltedpp() not implemented"); |
|
} |
|
|
|
static void ps3_hpte_invalidate(unsigned long slot, unsigned long vpn, |
|
int psize, int apsize, int ssize, int local) |
|
{ |
|
unsigned long flags; |
|
int result; |
|
|
|
spin_lock_irqsave(&ps3_htab_lock, flags); |
|
|
|
result = lv1_write_htab_entry(PS3_LPAR_VAS_ID_CURRENT, slot, 0, 0); |
|
|
|
if (result) { |
|
pr_info("%s: result=%s vpn=%lx slot=%lx psize=%d\n", |
|
__func__, ps3_result(result), vpn, slot, psize); |
|
BUG(); |
|
} |
|
|
|
spin_unlock_irqrestore(&ps3_htab_lock, flags); |
|
} |
|
|
|
/* Called during kexec sequence with MMU off */ |
|
static notrace void ps3_hpte_clear(void) |
|
{ |
|
unsigned long hpte_count = (1UL << ppc64_pft_size) >> 4; |
|
u64 i; |
|
|
|
for (i = 0; i < hpte_count; i++) |
|
lv1_write_htab_entry(PS3_LPAR_VAS_ID_CURRENT, i, 0, 0); |
|
|
|
ps3_mm_shutdown(); |
|
ps3_mm_vas_destroy(); |
|
} |
|
|
|
void __init ps3_hpte_init(unsigned long htab_size) |
|
{ |
|
mmu_hash_ops.hpte_invalidate = ps3_hpte_invalidate; |
|
mmu_hash_ops.hpte_updatepp = ps3_hpte_updatepp; |
|
mmu_hash_ops.hpte_updateboltedpp = ps3_hpte_updateboltedpp; |
|
mmu_hash_ops.hpte_insert = ps3_hpte_insert; |
|
mmu_hash_ops.hpte_remove = ps3_hpte_remove; |
|
mmu_hash_ops.hpte_clear_all = ps3_hpte_clear; |
|
|
|
ppc64_pft_size = __ilog2(htab_size); |
|
} |
|
|
|
|