qemu/roms/SLOF/slof/ppc64.code

   1 /******************************************************************************
   2  * Copyright (c) 2004, 2008 IBM Corporation
   3  * All rights reserved.
   4  * This program and the accompanying materials
   5  * are made available under the terms of the BSD License
   6  * which accompanies this distribution, and is available at
   7  * http://www.opensource.org/licenses/bsd-license.php
   8  *
   9  * Contributors:
  10  *     IBM Corporation - initial implementation
  11  *****************************************************************************/
  12
  13
  14 // This file contains the implementation of the Forth code words specific
  15 // to PowerPC64.  Some of this is 970-only.
  16
  17 // 970-specific CPU registers.
  18 // Don't use on P7 !
  19 PRIM(HID0_X21)
  20         unsigned long hid0 = TOS.u;
  21         asm volatile("sync ; mtspr 1008,%0 ; mfspr %0,1008 ; mfspr %0,1008 ; mfspr %0,1008 ; mfspr %0,1008 ; mfspr %0,1008 ; mfspr %0,1008" : "+r"(hid0));
  22         POP;
  23 MIRP
  24
  25 PRIM(HID0_X40)
  26         PUSH;
  27         asm volatile("mfspr %0,1008" : "=r"(TOS));
  28 MIRP
  29
  30 PRIM(HID1_X21)
  31         unsigned long hid1 = TOS.u;
  32         asm volatile("mtspr 1009,%0 ; mtspr 1009,%0 ; isync" : : "r"(hid1));
  33         POP;
  34 MIRP
  35
  36 PRIM(HID1_X40)
  37         PUSH;
  38         asm volatile("mfspr %0,1009" : "=r"(TOS));
  39 MIRP
  40
  41 PRIM(HID4_X21)
  42         unsigned long hid4 = TOS.u;
  43         asm volatile("sync ; mtspr 1012,%0 ; isync" : : "r"(hid4));
  44         POP;
  45 MIRP
  46
  47 PRIM(HID4_X40)
  48         PUSH;
  49         asm volatile("mfspr %0,1012" : "=r"(TOS));
  50 MIRP
  51
  52 PRIM(HID5_X21)
  53         unsigned long hid5 = TOS.u;
  54         asm volatile("mtspr 1014,%0" : : "r"(hid5));
  55         POP;
  56 MIRP
  57
  58 PRIM(HID5_X40)
  59         PUSH;
  60         asm volatile("mfspr %0,1014" : "=r"(TOS));
  61 MIRP
  62
  63 // PowerPC special registers.
  64 PRIM(MSR_X21)
  65         unsigned long msr = TOS.u;
  66         asm volatile("mtmsrd %0" : : "r"(msr));
  67         POP;
  68 MIRP
  69
  70 PRIM(MSR_X40)
  71         PUSH;
  72         asm volatile("mfmsr %0" : "=r"(TOS));
  73 MIRP
  74
  75 PRIM(SDR1_X21)
  76         unsigned long sdr1 = TOS.u;
  77         asm volatile("mtsdr1 %0" : : "r"(sdr1));
  78         POP;
  79 MIRP
  80
  81 PRIM(SDR1_X40)
  82         PUSH;
  83         asm volatile("mfsdr1 %0" : "=r"(TOS));
  84 MIRP
  85
  86 PRIM(PVR_X40)
  87         PUSH;
  88         asm volatile("mfpvr %0" : "=r"(TOS));
  89 MIRP
  90
  91 PRIM(PIR_X40)
  92         PUSH;
  93         asm volatile("mfspr %0,1023" : "=r"(TOS));
  94 MIRP
  95
  96 PRIM(TBL_X40)
  97         PUSH;
  98         asm volatile("mftbl %0" : "=r"(TOS));
  99 MIRP
 100
 101 PRIM(TBU_X40)
 102         PUSH;
 103         asm volatile("mftbu %0" : "=r"(TOS));
 104 MIRP
 105
 106 PRIM(DABR_X21)
 107         unsigned long dabr = TOS.u;
 108         asm volatile("mtspr 1013,%0" : : "r"(dabr));
 109         POP;
 110 MIRP
 111
 112 PRIM(DABR_X40)
 113         PUSH;
 114         asm volatile("mfspr %0,1013" : "=r"(TOS));
 115 MIRP
 116
 117 PRIM(HIOR_X21)
 118         unsigned long dabr = TOS.u;
 119         asm volatile("mtspr 311,%0" : : "r"(dabr));
 120         POP;
 121 MIRP
 122
 123 PRIM(HIOR_X40)
 124         PUSH;
 125         asm volatile("mfspr %0,311" : "=r"(TOS));
 126 MIRP
 127
 128
 129
 130 PRIM(SPRG0_X21)
 131         unsigned long sprg0 = TOS.u;
 132         asm volatile("mtsprg0 %0" : "+r"(sprg0));
 133         POP;
 134 MIRP
 135
 136 PRIM(SPRG0_X40)
 137         PUSH;
 138         asm volatile("mfsprg0 %0" : "=r"(TOS));
 139 MIRP
 140
 141 PRIM(SPRG1_X21)
 142         unsigned long sprg1 = TOS.u;
 143         asm volatile("mtsprg1 %0" : "+r"(sprg1));
 144         POP;
 145 MIRP
 146
 147 PRIM(SPRG1_X40)
 148         PUSH;
 149         asm volatile("mfsprg1 %0" : "=r"(TOS));
 150 MIRP
 151
 152 PRIM(SPRG2_X21)
 153         unsigned long sprg2 = TOS.u;
 154         asm volatile("mtsprg2 %0" : "+r"(sprg2));
 155         POP;
 156 MIRP
 157
 158 PRIM(SPRG2_X40)
 159         PUSH;
 160         asm volatile("mfsprg2 %0" : "=r"(TOS));
 161 MIRP
 162
 163 PRIM(SPRG3_X21)
 164         unsigned long sprg3 = TOS.u;
 165         asm volatile("mtsprg3 %0" : "+r"(sprg3));
 166         POP;
 167 MIRP
 168
 169 PRIM(SPRG3_X40)
 170         PUSH;
 171         asm volatile("mfsprg3 %0" : "=r"(TOS));
 172 MIRP
 173
 174 PRIM(HSPRG0_X21)
 175         unsigned long hsprg0 = TOS.u;
 176         asm volatile("mtspr 304,%0" : "+r"(hsprg0));
 177         POP;
 178 MIRP
 179
 180 PRIM(HSPRG0_X40)
 181         PUSH;
 182         asm volatile("mfspr %0,304" : "=r"(TOS));
 183 MIRP
 184
 185 PRIM(HSPRG1_X21)
 186         unsigned long hsprg1 = TOS.u;
 187         asm volatile("mtspr 305,%0" : "+r"(hsprg1));
 188         POP;
 189 MIRP
 190
 191 PRIM(HSPRG1_X40)
 192         PUSH;
 193         asm volatile("mfspr %0,305" : "=r"(TOS));
 194 MIRP
 195
 196
 197 PRIM(MMCR0_X21)
 198         unsigned long mmcr0 = TOS.u;
 199         asm volatile("sync ; mtspr 795,%0 ; isync" : : "r"(mmcr0));
 200         POP;
 201 MIRP
 202
 203 PRIM(PMC1_X40)
 204         PUSH;
 205         asm volatile("sync ; mfspr %0,787" : "=r"(TOS));
 206 MIRP
 207
 208 PRIM(ICBI)
 209         asm volatile("dcbst 0,%0 ; sync ; icbi 0,%0 ; sync ; isync" : : "r"(TOS));
 210         POP;
 211 MIRP
 212
 213 // Call into the client program.
 214 PRIM(JUMP_X2d_CLIENT)
 215         TOS.u = call_client(TOS);
 216 MIRP
 217
 218
 219 // Hang.  Useful for debugging, believe it or not.
 220 PRIM(CRASH)
 221         for (;;) ;
 222 MIRP
 223
 224 PRIM(START_X2d_RTAS)
 225         cell e = TOS; POP;
 226         cell p1 = TOS; POP;
 227         cell p0 = TOS;
 228         TOS.u = call_c(p0, p1, (cell)0UL, e);
 229 MIRP
 230
 231 PRIM(CALL_X2d_C)
 232         cell e = TOS; POP;
 233         cell p2 = TOS; POP;
 234         cell p1 = TOS; POP;
 235         cell p0 = TOS;
 236         TOS.u = call_c(p0, p1, p2, e);
 237 MIRP
 238
 239 PRIM(FLUSHCACHE)
 240         type_u n = TOS.u; POP;
 241         unsigned char* p = TOS.a; POP;
 242         flush_cache(p, n);
 243 MIRP
 244
 245 PRIM(DEC_X21)
 246         unsigned long dec = TOS.u;
 247         asm volatile("mtdec %0" : "+r"(dec));
 248         POP;
 249 MIRP
 250
 251 PRIM(DEC_X40)
 252         PUSH;
 253         asm volatile("mfdec %0" : "=r"(TOS));
 254 MIRP
 255
 256 PRIM(BM_X2d_ALLOCATOR_X2d_INIT)
 257         unsigned long blocksize = TOS.u; POP;
 258         unsigned long size = TOS.u; POP;
 259         unsigned long start = TOS.u;
 260         TOS.u = SLOF_bm_allocator_init(start, size, blocksize);
 261 MIRP
 262
 263 PRIM(BM_X2d_ALLOC)
 264         unsigned long size = TOS.u; POP;
 265         unsigned long handle = TOS.u;
 266         TOS.u = SLOF_bm_alloc(handle, size);
 267 MIRP
 268
 269 PRIM(BM_X2d_FREE)
 270         unsigned long size = TOS.u; POP;
 271         unsigned long addr = TOS.u; POP;
 272         unsigned long handle = TOS.u; POP;
 273         SLOF_bm_free(handle, addr, size);
 274 MIRP