Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* $Id: misc.c,v 1.20 2001/09/21 03:17:07 kanoj Exp $ |
| 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 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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> |
David S. Miller | b3e13fb | 2007-07-12 15:55:55 -0700 | [diff] [blame] | 17 | #include <asm/ldc.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 18 | |
David S. Miller | 22d6a1c | 2007-05-25 00:37:12 -0700 | [diff] [blame] | 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 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 38 | /* Reset and reboot the machine with the command 'bcommand'. */ |
David S. Miller | bff06d5 | 2005-09-22 20:11:33 -0700 | [diff] [blame] | 39 | void prom_reboot(const char *bcommand) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 40 | { |
David S. Miller | b3e13fb | 2007-07-12 15:55:55 -0700 | [diff] [blame] | 41 | #ifdef CONFIG_SUN_LDOMS |
| 42 | if (ldom_domaining_enabled) |
| 43 | ldom_reboot(bcommand); |
| 44 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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'. */ |
David S. Miller | bff06d5 | 2005-09-22 20:11:33 -0700 | [diff] [blame] | 50 | void prom_feval(const char *fstring) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
| 58 | /* We want to do this more nicely some day. */ |
| 59 | extern void (*prom_palette)(int); |
| 60 | |
| 61 | #ifdef CONFIG_SMP |
| 62 | extern void smp_capture(void); |
| 63 | extern void smp_release(void); |
| 64 | #endif |
| 65 | |
| 66 | /* Drop into the prom, with the chance to continue with the 'go' |
| 67 | * prom command. |
| 68 | */ |
| 69 | void prom_cmdline(void) |
| 70 | { |
| 71 | unsigned long flags; |
| 72 | |
| 73 | local_irq_save(flags); |
| 74 | |
| 75 | if (!serial_console && prom_palette) |
| 76 | prom_palette(1); |
| 77 | |
| 78 | #ifdef CONFIG_SMP |
| 79 | smp_capture(); |
| 80 | #endif |
| 81 | |
| 82 | p1275_cmd("enter", P1275_INOUT(0, 0)); |
| 83 | |
| 84 | #ifdef CONFIG_SMP |
| 85 | smp_release(); |
| 86 | #endif |
| 87 | |
| 88 | if (!serial_console && prom_palette) |
| 89 | prom_palette(0); |
| 90 | |
| 91 | local_irq_restore(flags); |
| 92 | } |
| 93 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 94 | /* Drop into the prom, but completely terminate the program. |
| 95 | * No chance of continuing. |
| 96 | */ |
| 97 | void prom_halt(void) |
| 98 | { |
David S. Miller | 4f0234f | 2007-07-13 16:03:42 -0700 | [diff] [blame^] | 99 | #ifdef CONFIG_SUN_LDOMS |
| 100 | if (ldom_domaining_enabled) |
| 101 | ldom_power_off(); |
| 102 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 103 | again: |
| 104 | p1275_cmd("exit", P1275_INOUT(0, 0)); |
| 105 | goto again; /* PROM is out to get me -DaveM */ |
| 106 | } |
| 107 | |
| 108 | void prom_halt_power_off(void) |
| 109 | { |
David S. Miller | 4f0234f | 2007-07-13 16:03:42 -0700 | [diff] [blame^] | 110 | #ifdef CONFIG_SUN_LDOMS |
| 111 | if (ldom_domaining_enabled) |
| 112 | ldom_power_off(); |
| 113 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 114 | p1275_cmd("SUNW,power-off", P1275_INOUT(0, 0)); |
| 115 | |
| 116 | /* if nothing else helps, we just halt */ |
| 117 | prom_halt(); |
| 118 | } |
| 119 | |
| 120 | /* Set prom sync handler to call function 'funcp'. */ |
| 121 | void prom_setcallback(callback_func_t funcp) |
| 122 | { |
| 123 | if (!funcp) |
| 124 | return; |
| 125 | p1275_cmd("set-callback", P1275_ARG(0, P1275_ARG_IN_FUNCTION) | |
| 126 | P1275_INOUT(1, 1), funcp); |
| 127 | } |
| 128 | |
| 129 | /* Get the idprom and stuff it into buffer 'idbuf'. Returns the |
| 130 | * format type. 'num_bytes' is the number of bytes that your idbuf |
| 131 | * has space for. Returns 0xff on error. |
| 132 | */ |
| 133 | unsigned char prom_get_idprom(char *idbuf, int num_bytes) |
| 134 | { |
| 135 | int len; |
| 136 | |
| 137 | len = prom_getproplen(prom_root_node, "idprom"); |
| 138 | if ((len >num_bytes) || (len == -1)) |
| 139 | return 0xff; |
| 140 | if (!prom_getproperty(prom_root_node, "idprom", idbuf, num_bytes)) |
| 141 | return idbuf[0]; |
| 142 | |
| 143 | return 0xff; |
| 144 | } |
| 145 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 146 | /* Install Linux trap table so PROM uses that instead of its own. */ |
| 147 | void prom_set_trap_table(unsigned long tba) |
| 148 | { |
David S. Miller | c79f767 | 2006-02-20 22:56:01 -0800 | [diff] [blame] | 149 | p1275_cmd("SUNW,set-trap-table", |
| 150 | (P1275_ARG(0, P1275_ARG_IN_64B) | |
| 151 | P1275_INOUT(1, 0)), tba); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 152 | } |
| 153 | |
David S. Miller | 12eaa32 | 2006-02-10 15:39:51 -0800 | [diff] [blame] | 154 | void prom_set_trap_table_sun4v(unsigned long tba, unsigned long mmfsa) |
| 155 | { |
David S. Miller | c79f767 | 2006-02-20 22:56:01 -0800 | [diff] [blame] | 156 | p1275_cmd("SUNW,set-trap-table", |
| 157 | (P1275_ARG(0, P1275_ARG_IN_64B) | |
| 158 | P1275_ARG(1, P1275_ARG_IN_64B) | |
| 159 | P1275_INOUT(2, 0)), tba, mmfsa); |
David S. Miller | 12eaa32 | 2006-02-10 15:39:51 -0800 | [diff] [blame] | 160 | } |
| 161 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 162 | int prom_get_mmu_ihandle(void) |
| 163 | { |
| 164 | int node, ret; |
| 165 | |
David S. Miller | bff06d5 | 2005-09-22 20:11:33 -0700 | [diff] [blame] | 166 | if (prom_mmu_ihandle_cache != 0) |
| 167 | return prom_mmu_ihandle_cache; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 168 | |
David S. Miller | bff06d5 | 2005-09-22 20:11:33 -0700 | [diff] [blame] | 169 | node = prom_finddevice(prom_chosen_path); |
| 170 | ret = prom_getint(node, prom_mmu_name); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 171 | if (ret == -1 || ret == 0) |
David S. Miller | bff06d5 | 2005-09-22 20:11:33 -0700 | [diff] [blame] | 172 | prom_mmu_ihandle_cache = -1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 173 | else |
David S. Miller | bff06d5 | 2005-09-22 20:11:33 -0700 | [diff] [blame] | 174 | prom_mmu_ihandle_cache = ret; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 175 | |
| 176 | return ret; |
| 177 | } |
| 178 | |
| 179 | static int prom_get_memory_ihandle(void) |
| 180 | { |
| 181 | static int memory_ihandle_cache; |
| 182 | int node, ret; |
| 183 | |
| 184 | if (memory_ihandle_cache != 0) |
| 185 | return memory_ihandle_cache; |
| 186 | |
| 187 | node = prom_finddevice("/chosen"); |
| 188 | ret = prom_getint(node, "memory"); |
| 189 | if (ret == -1 || ret == 0) |
| 190 | memory_ihandle_cache = -1; |
| 191 | else |
| 192 | memory_ihandle_cache = ret; |
| 193 | |
| 194 | return ret; |
| 195 | } |
| 196 | |
| 197 | /* Load explicit I/D TLB entries. */ |
| 198 | long prom_itlb_load(unsigned long index, |
| 199 | unsigned long tte_data, |
| 200 | unsigned long vaddr) |
| 201 | { |
David S. Miller | bff06d5 | 2005-09-22 20:11:33 -0700 | [diff] [blame] | 202 | return p1275_cmd(prom_callmethod_name, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 203 | (P1275_ARG(0, P1275_ARG_IN_STRING) | |
| 204 | P1275_ARG(2, P1275_ARG_IN_64B) | |
| 205 | P1275_ARG(3, P1275_ARG_IN_64B) | |
| 206 | P1275_INOUT(5, 1)), |
| 207 | "SUNW,itlb-load", |
| 208 | prom_get_mmu_ihandle(), |
| 209 | /* And then our actual args are pushed backwards. */ |
| 210 | vaddr, |
| 211 | tte_data, |
| 212 | index); |
| 213 | } |
| 214 | |
| 215 | long prom_dtlb_load(unsigned long index, |
| 216 | unsigned long tte_data, |
| 217 | unsigned long vaddr) |
| 218 | { |
David S. Miller | bff06d5 | 2005-09-22 20:11:33 -0700 | [diff] [blame] | 219 | return p1275_cmd(prom_callmethod_name, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 220 | (P1275_ARG(0, P1275_ARG_IN_STRING) | |
| 221 | P1275_ARG(2, P1275_ARG_IN_64B) | |
| 222 | P1275_ARG(3, P1275_ARG_IN_64B) | |
| 223 | P1275_INOUT(5, 1)), |
| 224 | "SUNW,dtlb-load", |
| 225 | prom_get_mmu_ihandle(), |
| 226 | /* And then our actual args are pushed backwards. */ |
| 227 | vaddr, |
| 228 | tte_data, |
| 229 | index); |
| 230 | } |
| 231 | |
| 232 | int prom_map(int mode, unsigned long size, |
| 233 | unsigned long vaddr, unsigned long paddr) |
| 234 | { |
David S. Miller | bff06d5 | 2005-09-22 20:11:33 -0700 | [diff] [blame] | 235 | int ret = p1275_cmd(prom_callmethod_name, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 236 | (P1275_ARG(0, P1275_ARG_IN_STRING) | |
| 237 | P1275_ARG(3, P1275_ARG_IN_64B) | |
| 238 | P1275_ARG(4, P1275_ARG_IN_64B) | |
| 239 | P1275_ARG(6, P1275_ARG_IN_64B) | |
| 240 | P1275_INOUT(7, 1)), |
David S. Miller | bff06d5 | 2005-09-22 20:11:33 -0700 | [diff] [blame] | 241 | prom_map_name, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 242 | prom_get_mmu_ihandle(), |
| 243 | mode, |
| 244 | size, |
| 245 | vaddr, |
| 246 | 0, |
| 247 | paddr); |
| 248 | |
| 249 | if (ret == 0) |
| 250 | ret = -1; |
| 251 | return ret; |
| 252 | } |
| 253 | |
| 254 | void prom_unmap(unsigned long size, unsigned long vaddr) |
| 255 | { |
David S. Miller | bff06d5 | 2005-09-22 20:11:33 -0700 | [diff] [blame] | 256 | p1275_cmd(prom_callmethod_name, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 257 | (P1275_ARG(0, P1275_ARG_IN_STRING) | |
| 258 | P1275_ARG(2, P1275_ARG_IN_64B) | |
| 259 | P1275_ARG(3, P1275_ARG_IN_64B) | |
| 260 | P1275_INOUT(4, 0)), |
David S. Miller | bff06d5 | 2005-09-22 20:11:33 -0700 | [diff] [blame] | 261 | prom_unmap_name, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 262 | prom_get_mmu_ihandle(), |
| 263 | size, |
| 264 | vaddr); |
| 265 | } |
| 266 | |
| 267 | /* Set aside physical memory which is not touched or modified |
| 268 | * across soft resets. |
| 269 | */ |
David S. Miller | bff06d5 | 2005-09-22 20:11:33 -0700 | [diff] [blame] | 270 | unsigned long prom_retain(const char *name, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 271 | unsigned long pa_low, unsigned long pa_high, |
| 272 | long size, long align) |
| 273 | { |
| 274 | /* XXX I don't think we return multiple values correctly. |
| 275 | * XXX OBP supposedly returns pa_low/pa_high here, how does |
| 276 | * XXX it work? |
| 277 | */ |
| 278 | |
| 279 | /* If align is zero, the pa_low/pa_high args are passed, |
| 280 | * else they are not. |
| 281 | */ |
| 282 | if (align == 0) |
| 283 | return p1275_cmd("SUNW,retain", |
| 284 | (P1275_ARG(0, P1275_ARG_IN_BUF) | P1275_INOUT(5, 2)), |
| 285 | name, pa_low, pa_high, size, align); |
| 286 | else |
| 287 | return p1275_cmd("SUNW,retain", |
| 288 | (P1275_ARG(0, P1275_ARG_IN_BUF) | P1275_INOUT(3, 2)), |
| 289 | name, size, align); |
| 290 | } |
| 291 | |
| 292 | /* Get "Unumber" string for the SIMM at the given |
| 293 | * memory address. Usually this will be of the form |
| 294 | * "Uxxxx" where xxxx is a decimal number which is |
| 295 | * etched into the motherboard next to the SIMM slot |
| 296 | * in question. |
| 297 | */ |
| 298 | int prom_getunumber(int syndrome_code, |
| 299 | unsigned long phys_addr, |
| 300 | char *buf, int buflen) |
| 301 | { |
David S. Miller | bff06d5 | 2005-09-22 20:11:33 -0700 | [diff] [blame] | 302 | return p1275_cmd(prom_callmethod_name, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 303 | (P1275_ARG(0, P1275_ARG_IN_STRING) | |
| 304 | P1275_ARG(3, P1275_ARG_OUT_BUF) | |
| 305 | P1275_ARG(6, P1275_ARG_IN_64B) | |
| 306 | P1275_INOUT(8, 2)), |
| 307 | "SUNW,get-unumber", prom_get_memory_ihandle(), |
| 308 | buflen, buf, P1275_SIZE(buflen), |
| 309 | 0, phys_addr, syndrome_code); |
| 310 | } |
| 311 | |
| 312 | /* Power management extensions. */ |
| 313 | void prom_sleepself(void) |
| 314 | { |
| 315 | p1275_cmd("SUNW,sleep-self", P1275_INOUT(0, 0)); |
| 316 | } |
| 317 | |
| 318 | int prom_sleepsystem(void) |
| 319 | { |
| 320 | return p1275_cmd("SUNW,sleep-system", P1275_INOUT(0, 1)); |
| 321 | } |
| 322 | |
| 323 | int prom_wakeupsystem(void) |
| 324 | { |
| 325 | return p1275_cmd("SUNW,wakeup-system", P1275_INOUT(0, 1)); |
| 326 | } |
| 327 | |
| 328 | #ifdef CONFIG_SMP |
David S. Miller | 7890f79 | 2006-02-15 02:26:54 -0800 | [diff] [blame] | 329 | void prom_startcpu(int cpunode, unsigned long pc, unsigned long arg) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 330 | { |
David S. Miller | 7890f79 | 2006-02-15 02:26:54 -0800 | [diff] [blame] | 331 | p1275_cmd("SUNW,start-cpu", P1275_INOUT(3, 0), cpunode, pc, arg); |
| 332 | } |
| 333 | |
| 334 | void prom_startcpu_cpuid(int cpuid, unsigned long pc, unsigned long arg) |
| 335 | { |
| 336 | p1275_cmd("SUNW,start-cpu-by-cpuid", P1275_INOUT(3, 0), |
| 337 | cpuid, pc, arg); |
| 338 | } |
| 339 | |
| 340 | void prom_stopcpu_cpuid(int cpuid) |
| 341 | { |
| 342 | p1275_cmd("SUNW,stop-cpu-by-cpuid", P1275_INOUT(1, 0), |
| 343 | cpuid); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 344 | } |
| 345 | |
| 346 | void prom_stopself(void) |
| 347 | { |
| 348 | p1275_cmd("SUNW,stop-self", P1275_INOUT(0, 0)); |
| 349 | } |
| 350 | |
| 351 | void prom_idleself(void) |
| 352 | { |
| 353 | p1275_cmd("SUNW,idle-self", P1275_INOUT(0, 0)); |
| 354 | } |
| 355 | |
| 356 | void prom_resumecpu(int cpunode) |
| 357 | { |
| 358 | p1275_cmd("SUNW,resume-cpu", P1275_INOUT(1, 0), cpunode); |
| 359 | } |
| 360 | #endif |