← Back to branch summary

~pmdj/ubuntu/trusty/qemu/2.9+applesmc+fadtv3

« back to all changes in this revision

Viewing changes to roms/SLOF/slof/ppc64.code

  • Committer: Phil Dennis-Jordan
  • Date: 2017-07-21 08:03:43 UTC
  • mfrom: (1.1.1)
  • Revision ID: phil@philjordan.eu-20170721080343-2yr2vdj7713czahv
New upstream release 2.9.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
 
 
b'\\ No newline at end of file'