arch/powerpc/platforms/ps3/htab.c

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