Commit | Line | Data |
---|---|---|
b00dc837 | 1 | /* |
1da177e4 LT |
2 | * misc.c: Miscellaneous prom functions that don't belong |
3 | * anywhere else. | |
4 | * | |
5 | * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu) | |
6 | * Copyright (C) 1996,1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz) | |
7 | */ | |
8 | ||
1da177e4 LT |
9 | #include <linux/types.h> |
10 | #include <linux/kernel.h> | |
11 | #include <linux/sched.h> | |
12 | #include <linux/interrupt.h> | |
13 | #include <linux/delay.h> | |
14 | #include <asm/openprom.h> | |
15 | #include <asm/oplib.h> | |
16 | #include <asm/system.h> | |
b3e13fbe | 17 | #include <asm/ldc.h> |
1da177e4 | 18 | |
22d6a1cb DM |
19 | int prom_service_exists(const char *service_name) |
20 | { | |
21 | int err = p1275_cmd("test", P1275_ARG(0, P1275_ARG_IN_STRING) | | |
22 | P1275_INOUT(1, 1), service_name); | |
23 | ||
24 | if (err) | |
25 | return 0; | |
26 | return 1; | |
27 | } | |
28 | ||
29 | void prom_sun4v_guest_soft_state(void) | |
30 | { | |
31 | const char *svc = "SUNW,soft-state-supported"; | |
32 | ||
33 | if (!prom_service_exists(svc)) | |
34 | return; | |
35 | p1275_cmd(svc, P1275_INOUT(0, 0)); | |
36 | } | |
37 | ||
1da177e4 | 38 | /* Reset and reboot the machine with the command 'bcommand'. */ |
bff06d55 | 39 | void prom_reboot(const char *bcommand) |
1da177e4 | 40 | { |
b3e13fbe DM |
41 | #ifdef CONFIG_SUN_LDOMS |
42 | if (ldom_domaining_enabled) | |
43 | ldom_reboot(bcommand); | |
44 | #endif | |
1da177e4 LT |
45 | p1275_cmd("boot", P1275_ARG(0, P1275_ARG_IN_STRING) | |
46 | P1275_INOUT(1, 0), bcommand); | |
47 | } | |
48 | ||
49 | /* Forth evaluate the expression contained in 'fstring'. */ | |
bff06d55 | 50 | void prom_feval(const char *fstring) |
1da177e4 LT |
51 | { |
52 | if (!fstring || fstring[0] == 0) | |
53 | return; | |
54 | p1275_cmd("interpret", P1275_ARG(0, P1275_ARG_IN_STRING) | | |
55 | P1275_INOUT(1, 1), fstring); | |
56 | } | |
57 | ||
1da177e4 LT |
58 | #ifdef CONFIG_SMP |
59 | extern void smp_capture(void); | |
60 | extern void smp_release(void); | |
61 | #endif | |
62 | ||
63 | /* Drop into the prom, with the chance to continue with the 'go' | |
64 | * prom command. | |
65 | */ | |
66 | void prom_cmdline(void) | |
67 | { | |
68 | unsigned long flags; | |
69 | ||
70 | local_irq_save(flags); | |
71 | ||
1da177e4 LT |
72 | #ifdef CONFIG_SMP |
73 | smp_capture(); | |
74 | #endif | |
75 | ||
76 | p1275_cmd("enter", P1275_INOUT(0, 0)); | |
77 | ||
78 | #ifdef CONFIG_SMP | |
79 | smp_release(); | |
80 | #endif | |
81 | ||
1da177e4 LT |
82 | local_irq_restore(flags); |
83 | } | |
84 | ||
1da177e4 LT |
85 | /* Drop into the prom, but completely terminate the program. |
86 | * No chance of continuing. | |
87 | */ | |
88 | void prom_halt(void) | |
89 | { | |
4f0234f4 DM |
90 | #ifdef CONFIG_SUN_LDOMS |
91 | if (ldom_domaining_enabled) | |
92 | ldom_power_off(); | |
93 | #endif | |
1da177e4 LT |
94 | again: |
95 | p1275_cmd("exit", P1275_INOUT(0, 0)); | |
96 | goto again; /* PROM is out to get me -DaveM */ | |
97 | } | |
98 | ||
99 | void prom_halt_power_off(void) | |
100 | { | |
4f0234f4 DM |
101 | #ifdef CONFIG_SUN_LDOMS |
102 | if (ldom_domaining_enabled) | |
103 | ldom_power_off(); | |
104 | #endif | |
1da177e4 LT |
105 | p1275_cmd("SUNW,power-off", P1275_INOUT(0, 0)); |
106 | ||
107 | /* if nothing else helps, we just halt */ | |
108 | prom_halt(); | |
109 | } | |
110 | ||
111 | /* Set prom sync handler to call function 'funcp'. */ | |
112 | void prom_setcallback(callback_func_t funcp) | |
113 | { | |
114 | if (!funcp) | |
115 | return; | |
116 | p1275_cmd("set-callback", P1275_ARG(0, P1275_ARG_IN_FUNCTION) | | |
117 | P1275_INOUT(1, 1), funcp); | |
118 | } | |
119 | ||
120 | /* Get the idprom and stuff it into buffer 'idbuf'. Returns the | |
121 | * format type. 'num_bytes' is the number of bytes that your idbuf | |
122 | * has space for. Returns 0xff on error. | |
123 | */ | |
124 | unsigned char prom_get_idprom(char *idbuf, int num_bytes) | |
125 | { | |
126 | int len; | |
127 | ||
128 | len = prom_getproplen(prom_root_node, "idprom"); | |
129 | if ((len >num_bytes) || (len == -1)) | |
130 | return 0xff; | |
131 | if (!prom_getproperty(prom_root_node, "idprom", idbuf, num_bytes)) | |
132 | return idbuf[0]; | |
133 | ||
134 | return 0xff; | |
135 | } | |
136 | ||
1da177e4 LT |
137 | int prom_get_mmu_ihandle(void) |
138 | { | |
139 | int node, ret; | |
140 | ||
bff06d55 DM |
141 | if (prom_mmu_ihandle_cache != 0) |
142 | return prom_mmu_ihandle_cache; | |
1da177e4 | 143 | |
bff06d55 DM |
144 | node = prom_finddevice(prom_chosen_path); |
145 | ret = prom_getint(node, prom_mmu_name); | |
1da177e4 | 146 | if (ret == -1 || ret == 0) |
bff06d55 | 147 | prom_mmu_ihandle_cache = -1; |
1da177e4 | 148 | else |
bff06d55 | 149 | prom_mmu_ihandle_cache = ret; |
1da177e4 LT |
150 | |
151 | return ret; | |
152 | } | |
153 | ||
154 | static int prom_get_memory_ihandle(void) | |
155 | { | |
156 | static int memory_ihandle_cache; | |
157 | int node, ret; | |
158 | ||
159 | if (memory_ihandle_cache != 0) | |
160 | return memory_ihandle_cache; | |
161 | ||
162 | node = prom_finddevice("/chosen"); | |
163 | ret = prom_getint(node, "memory"); | |
164 | if (ret == -1 || ret == 0) | |
165 | memory_ihandle_cache = -1; | |
166 | else | |
167 | memory_ihandle_cache = ret; | |
168 | ||
169 | return ret; | |
170 | } | |
171 | ||
172 | /* Load explicit I/D TLB entries. */ | |
173 | long prom_itlb_load(unsigned long index, | |
174 | unsigned long tte_data, | |
175 | unsigned long vaddr) | |
176 | { | |
bff06d55 | 177 | return p1275_cmd(prom_callmethod_name, |
1da177e4 LT |
178 | (P1275_ARG(0, P1275_ARG_IN_STRING) | |
179 | P1275_ARG(2, P1275_ARG_IN_64B) | | |
180 | P1275_ARG(3, P1275_ARG_IN_64B) | | |
181 | P1275_INOUT(5, 1)), | |
182 | "SUNW,itlb-load", | |
183 | prom_get_mmu_ihandle(), | |
184 | /* And then our actual args are pushed backwards. */ | |
185 | vaddr, | |
186 | tte_data, | |
187 | index); | |
188 | } | |
189 | ||
190 | long prom_dtlb_load(unsigned long index, | |
191 | unsigned long tte_data, | |
192 | unsigned long vaddr) | |
193 | { | |
bff06d55 | 194 | return p1275_cmd(prom_callmethod_name, |
1da177e4 LT |
195 | (P1275_ARG(0, P1275_ARG_IN_STRING) | |
196 | P1275_ARG(2, P1275_ARG_IN_64B) | | |
197 | P1275_ARG(3, P1275_ARG_IN_64B) | | |
198 | P1275_INOUT(5, 1)), | |
199 | "SUNW,dtlb-load", | |
200 | prom_get_mmu_ihandle(), | |
201 | /* And then our actual args are pushed backwards. */ | |
202 | vaddr, | |
203 | tte_data, | |
204 | index); | |
205 | } | |
206 | ||
207 | int prom_map(int mode, unsigned long size, | |
208 | unsigned long vaddr, unsigned long paddr) | |
209 | { | |
bff06d55 | 210 | int ret = p1275_cmd(prom_callmethod_name, |
1da177e4 LT |
211 | (P1275_ARG(0, P1275_ARG_IN_STRING) | |
212 | P1275_ARG(3, P1275_ARG_IN_64B) | | |
213 | P1275_ARG(4, P1275_ARG_IN_64B) | | |
214 | P1275_ARG(6, P1275_ARG_IN_64B) | | |
215 | P1275_INOUT(7, 1)), | |
bff06d55 | 216 | prom_map_name, |
1da177e4 LT |
217 | prom_get_mmu_ihandle(), |
218 | mode, | |
219 | size, | |
220 | vaddr, | |
221 | 0, | |
222 | paddr); | |
223 | ||
224 | if (ret == 0) | |
225 | ret = -1; | |
226 | return ret; | |
227 | } | |
228 | ||
229 | void prom_unmap(unsigned long size, unsigned long vaddr) | |
230 | { | |
bff06d55 | 231 | p1275_cmd(prom_callmethod_name, |
1da177e4 LT |
232 | (P1275_ARG(0, P1275_ARG_IN_STRING) | |
233 | P1275_ARG(2, P1275_ARG_IN_64B) | | |
234 | P1275_ARG(3, P1275_ARG_IN_64B) | | |
235 | P1275_INOUT(4, 0)), | |
bff06d55 | 236 | prom_unmap_name, |
1da177e4 LT |
237 | prom_get_mmu_ihandle(), |
238 | size, | |
239 | vaddr); | |
240 | } | |
241 | ||
242 | /* Set aside physical memory which is not touched or modified | |
243 | * across soft resets. | |
244 | */ | |
bff06d55 | 245 | unsigned long prom_retain(const char *name, |
1da177e4 LT |
246 | unsigned long pa_low, unsigned long pa_high, |
247 | long size, long align) | |
248 | { | |
249 | /* XXX I don't think we return multiple values correctly. | |
250 | * XXX OBP supposedly returns pa_low/pa_high here, how does | |
251 | * XXX it work? | |
252 | */ | |
253 | ||
254 | /* If align is zero, the pa_low/pa_high args are passed, | |
255 | * else they are not. | |
256 | */ | |
257 | if (align == 0) | |
258 | return p1275_cmd("SUNW,retain", | |
259 | (P1275_ARG(0, P1275_ARG_IN_BUF) | P1275_INOUT(5, 2)), | |
260 | name, pa_low, pa_high, size, align); | |
261 | else | |
262 | return p1275_cmd("SUNW,retain", | |
263 | (P1275_ARG(0, P1275_ARG_IN_BUF) | P1275_INOUT(3, 2)), | |
264 | name, size, align); | |
265 | } | |
266 | ||
267 | /* Get "Unumber" string for the SIMM at the given | |
268 | * memory address. Usually this will be of the form | |
269 | * "Uxxxx" where xxxx is a decimal number which is | |
270 | * etched into the motherboard next to the SIMM slot | |
271 | * in question. | |
272 | */ | |
273 | int prom_getunumber(int syndrome_code, | |
274 | unsigned long phys_addr, | |
275 | char *buf, int buflen) | |
276 | { | |
bff06d55 | 277 | return p1275_cmd(prom_callmethod_name, |
1da177e4 LT |
278 | (P1275_ARG(0, P1275_ARG_IN_STRING) | |
279 | P1275_ARG(3, P1275_ARG_OUT_BUF) | | |
280 | P1275_ARG(6, P1275_ARG_IN_64B) | | |
281 | P1275_INOUT(8, 2)), | |
282 | "SUNW,get-unumber", prom_get_memory_ihandle(), | |
283 | buflen, buf, P1275_SIZE(buflen), | |
284 | 0, phys_addr, syndrome_code); | |
285 | } | |
286 | ||
287 | /* Power management extensions. */ | |
288 | void prom_sleepself(void) | |
289 | { | |
290 | p1275_cmd("SUNW,sleep-self", P1275_INOUT(0, 0)); | |
291 | } | |
292 | ||
293 | int prom_sleepsystem(void) | |
294 | { | |
295 | return p1275_cmd("SUNW,sleep-system", P1275_INOUT(0, 1)); | |
296 | } | |
297 | ||
298 | int prom_wakeupsystem(void) | |
299 | { | |
300 | return p1275_cmd("SUNW,wakeup-system", P1275_INOUT(0, 1)); | |
301 | } | |
302 | ||
303 | #ifdef CONFIG_SMP | |
7890f794 | 304 | void prom_startcpu(int cpunode, unsigned long pc, unsigned long arg) |
1da177e4 | 305 | { |
7890f794 DM |
306 | p1275_cmd("SUNW,start-cpu", P1275_INOUT(3, 0), cpunode, pc, arg); |
307 | } | |
308 | ||
309 | void prom_startcpu_cpuid(int cpuid, unsigned long pc, unsigned long arg) | |
310 | { | |
311 | p1275_cmd("SUNW,start-cpu-by-cpuid", P1275_INOUT(3, 0), | |
312 | cpuid, pc, arg); | |
313 | } | |
314 | ||
315 | void prom_stopcpu_cpuid(int cpuid) | |
316 | { | |
317 | p1275_cmd("SUNW,stop-cpu-by-cpuid", P1275_INOUT(1, 0), | |
318 | cpuid); | |
1da177e4 LT |
319 | } |
320 | ||
321 | void prom_stopself(void) | |
322 | { | |
323 | p1275_cmd("SUNW,stop-self", P1275_INOUT(0, 0)); | |
324 | } | |
325 | ||
326 | void prom_idleself(void) | |
327 | { | |
328 | p1275_cmd("SUNW,idle-self", P1275_INOUT(0, 0)); | |
329 | } | |
330 | ||
331 | void prom_resumecpu(int cpunode) | |
332 | { | |
333 | p1275_cmd("SUNW,resume-cpu", P1275_INOUT(1, 0), cpunode); | |
334 | } | |
335 | #endif |