| /* $Id: misc.c,v 1.20 2001/09/21 03:17:07 kanoj Exp $ | |
| * misc.c: Miscellaneous prom functions that don't belong | |
| * anywhere else. | |
| * | |
| * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu) | |
| * Copyright (C) 1996,1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz) | |
| */ | |
| #include <linux/types.h> | |
| #include <linux/kernel.h> | |
| #include <linux/sched.h> | |
| #include <linux/interrupt.h> | |
| #include <linux/delay.h> | |
| #include <asm/openprom.h> | |
| #include <asm/oplib.h> | |
| #include <asm/system.h> | |
| /* Reset and reboot the machine with the command 'bcommand'. */ | |
| void prom_reboot(const char *bcommand) | |
| { | |
| p1275_cmd("boot", P1275_ARG(0, P1275_ARG_IN_STRING) | | |
| P1275_INOUT(1, 0), bcommand); | |
| } | |
| /* Forth evaluate the expression contained in 'fstring'. */ | |
| void prom_feval(const char *fstring) | |
| { | |
| if (!fstring || fstring[0] == 0) | |
| return; | |
| p1275_cmd("interpret", P1275_ARG(0, P1275_ARG_IN_STRING) | | |
| P1275_INOUT(1, 1), fstring); | |
| } | |
| /* We want to do this more nicely some day. */ | |
| extern void (*prom_palette)(int); | |
| #ifdef CONFIG_SMP | |
| extern void smp_capture(void); | |
| extern void smp_release(void); | |
| #endif | |
| /* Drop into the prom, with the chance to continue with the 'go' | |
| * prom command. | |
| */ | |
| void prom_cmdline(void) | |
| { | |
| unsigned long flags; | |
| local_irq_save(flags); | |
| if (!serial_console && prom_palette) | |
| prom_palette(1); | |
| #ifdef CONFIG_SMP | |
| smp_capture(); | |
| #endif | |
| p1275_cmd("enter", P1275_INOUT(0, 0)); | |
| #ifdef CONFIG_SMP | |
| smp_release(); | |
| #endif | |
| if (!serial_console && prom_palette) | |
| prom_palette(0); | |
| local_irq_restore(flags); | |
| } | |
| /* Drop into the prom, but completely terminate the program. | |
| * No chance of continuing. | |
| */ | |
| void prom_halt(void) | |
| { | |
| again: | |
| p1275_cmd("exit", P1275_INOUT(0, 0)); | |
| goto again; /* PROM is out to get me -DaveM */ | |
| } | |
| void prom_halt_power_off(void) | |
| { | |
| p1275_cmd("SUNW,power-off", P1275_INOUT(0, 0)); | |
| /* if nothing else helps, we just halt */ | |
| prom_halt(); | |
| } | |
| /* Set prom sync handler to call function 'funcp'. */ | |
| void prom_setcallback(callback_func_t funcp) | |
| { | |
| if (!funcp) | |
| return; | |
| p1275_cmd("set-callback", P1275_ARG(0, P1275_ARG_IN_FUNCTION) | | |
| P1275_INOUT(1, 1), funcp); | |
| } | |
| /* Get the idprom and stuff it into buffer 'idbuf'. Returns the | |
| * format type. 'num_bytes' is the number of bytes that your idbuf | |
| * has space for. Returns 0xff on error. | |
| */ | |
| unsigned char prom_get_idprom(char *idbuf, int num_bytes) | |
| { | |
| int len; | |
| len = prom_getproplen(prom_root_node, "idprom"); | |
| if ((len >num_bytes) || (len == -1)) | |
| return 0xff; | |
| if (!prom_getproperty(prom_root_node, "idprom", idbuf, num_bytes)) | |
| return idbuf[0]; | |
| return 0xff; | |
| } | |
| /* Install Linux trap table so PROM uses that instead of its own. */ | |
| void prom_set_trap_table(unsigned long tba) | |
| { | |
| p1275_cmd("SUNW,set-trap-table", | |
| (P1275_ARG(0, P1275_ARG_IN_64B) | | |
| P1275_INOUT(1, 0)), tba); | |
| } | |
| void prom_set_trap_table_sun4v(unsigned long tba, unsigned long mmfsa) | |
| { | |
| p1275_cmd("SUNW,set-trap-table", | |
| (P1275_ARG(0, P1275_ARG_IN_64B) | | |
| P1275_ARG(1, P1275_ARG_IN_64B) | | |
| P1275_INOUT(2, 0)), tba, mmfsa); | |
| } | |
| int prom_get_mmu_ihandle(void) | |
| { | |
| int node, ret; | |
| if (prom_mmu_ihandle_cache != 0) | |
| return prom_mmu_ihandle_cache; | |
| node = prom_finddevice(prom_chosen_path); | |
| ret = prom_getint(node, prom_mmu_name); | |
| if (ret == -1 || ret == 0) | |
| prom_mmu_ihandle_cache = -1; | |
| else | |
| prom_mmu_ihandle_cache = ret; | |
| return ret; | |
| } | |
| static int prom_get_memory_ihandle(void) | |
| { | |
| static int memory_ihandle_cache; | |
| int node, ret; | |
| if (memory_ihandle_cache != 0) | |
| return memory_ihandle_cache; | |
| node = prom_finddevice("/chosen"); | |
| ret = prom_getint(node, "memory"); | |
| if (ret == -1 || ret == 0) | |
| memory_ihandle_cache = -1; | |
| else | |
| memory_ihandle_cache = ret; | |
| return ret; | |
| } | |
| /* Load explicit I/D TLB entries. */ | |
| long prom_itlb_load(unsigned long index, | |
| unsigned long tte_data, | |
| unsigned long vaddr) | |
| { | |
| return p1275_cmd(prom_callmethod_name, | |
| (P1275_ARG(0, P1275_ARG_IN_STRING) | | |
| P1275_ARG(2, P1275_ARG_IN_64B) | | |
| P1275_ARG(3, P1275_ARG_IN_64B) | | |
| P1275_INOUT(5, 1)), | |
| "SUNW,itlb-load", | |
| prom_get_mmu_ihandle(), | |
| /* And then our actual args are pushed backwards. */ | |
| vaddr, | |
| tte_data, | |
| index); | |
| } | |
| long prom_dtlb_load(unsigned long index, | |
| unsigned long tte_data, | |
| unsigned long vaddr) | |
| { | |
| return p1275_cmd(prom_callmethod_name, | |
| (P1275_ARG(0, P1275_ARG_IN_STRING) | | |
| P1275_ARG(2, P1275_ARG_IN_64B) | | |
| P1275_ARG(3, P1275_ARG_IN_64B) | | |
| P1275_INOUT(5, 1)), | |
| "SUNW,dtlb-load", | |
| prom_get_mmu_ihandle(), | |
| /* And then our actual args are pushed backwards. */ | |
| vaddr, | |
| tte_data, | |
| index); | |
| } | |
| int prom_map(int mode, unsigned long size, | |
| unsigned long vaddr, unsigned long paddr) | |
| { | |
| int ret = p1275_cmd(prom_callmethod_name, | |
| (P1275_ARG(0, P1275_ARG_IN_STRING) | | |
| P1275_ARG(3, P1275_ARG_IN_64B) | | |
| P1275_ARG(4, P1275_ARG_IN_64B) | | |
| P1275_ARG(6, P1275_ARG_IN_64B) | | |
| P1275_INOUT(7, 1)), | |
| prom_map_name, | |
| prom_get_mmu_ihandle(), | |
| mode, | |
| size, | |
| vaddr, | |
| 0, | |
| paddr); | |
| if (ret == 0) | |
| ret = -1; | |
| return ret; | |
| } | |
| void prom_unmap(unsigned long size, unsigned long vaddr) | |
| { | |
| p1275_cmd(prom_callmethod_name, | |
| (P1275_ARG(0, P1275_ARG_IN_STRING) | | |
| P1275_ARG(2, P1275_ARG_IN_64B) | | |
| P1275_ARG(3, P1275_ARG_IN_64B) | | |
| P1275_INOUT(4, 0)), | |
| prom_unmap_name, | |
| prom_get_mmu_ihandle(), | |
| size, | |
| vaddr); | |
| } | |
| /* Set aside physical memory which is not touched or modified | |
| * across soft resets. | |
| */ | |
| unsigned long prom_retain(const char *name, | |
| unsigned long pa_low, unsigned long pa_high, | |
| long size, long align) | |
| { | |
| /* XXX I don't think we return multiple values correctly. | |
| * XXX OBP supposedly returns pa_low/pa_high here, how does | |
| * XXX it work? | |
| */ | |
| /* If align is zero, the pa_low/pa_high args are passed, | |
| * else they are not. | |
| */ | |
| if (align == 0) | |
| return p1275_cmd("SUNW,retain", | |
| (P1275_ARG(0, P1275_ARG_IN_BUF) | P1275_INOUT(5, 2)), | |
| name, pa_low, pa_high, size, align); | |
| else | |
| return p1275_cmd("SUNW,retain", | |
| (P1275_ARG(0, P1275_ARG_IN_BUF) | P1275_INOUT(3, 2)), | |
| name, size, align); | |
| } | |
| /* Get "Unumber" string for the SIMM at the given | |
| * memory address. Usually this will be of the form | |
| * "Uxxxx" where xxxx is a decimal number which is | |
| * etched into the motherboard next to the SIMM slot | |
| * in question. | |
| */ | |
| int prom_getunumber(int syndrome_code, | |
| unsigned long phys_addr, | |
| char *buf, int buflen) | |
| { | |
| return p1275_cmd(prom_callmethod_name, | |
| (P1275_ARG(0, P1275_ARG_IN_STRING) | | |
| P1275_ARG(3, P1275_ARG_OUT_BUF) | | |
| P1275_ARG(6, P1275_ARG_IN_64B) | | |
| P1275_INOUT(8, 2)), | |
| "SUNW,get-unumber", prom_get_memory_ihandle(), | |
| buflen, buf, P1275_SIZE(buflen), | |
| 0, phys_addr, syndrome_code); | |
| } | |
| /* Power management extensions. */ | |
| void prom_sleepself(void) | |
| { | |
| p1275_cmd("SUNW,sleep-self", P1275_INOUT(0, 0)); | |
| } | |
| int prom_sleepsystem(void) | |
| { | |
| return p1275_cmd("SUNW,sleep-system", P1275_INOUT(0, 1)); | |
| } | |
| int prom_wakeupsystem(void) | |
| { | |
| return p1275_cmd("SUNW,wakeup-system", P1275_INOUT(0, 1)); | |
| } | |
| #ifdef CONFIG_SMP | |
| void prom_startcpu(int cpunode, unsigned long pc, unsigned long arg) | |
| { | |
| p1275_cmd("SUNW,start-cpu", P1275_INOUT(3, 0), cpunode, pc, arg); | |
| } | |
| void prom_startcpu_cpuid(int cpuid, unsigned long pc, unsigned long arg) | |
| { | |
| p1275_cmd("SUNW,start-cpu-by-cpuid", P1275_INOUT(3, 0), | |
| cpuid, pc, arg); | |
| } | |
| void prom_stopcpu_cpuid(int cpuid) | |
| { | |
| p1275_cmd("SUNW,stop-cpu-by-cpuid", P1275_INOUT(1, 0), | |
| cpuid); | |
| } | |
| void prom_stopself(void) | |
| { | |
| p1275_cmd("SUNW,stop-self", P1275_INOUT(0, 0)); | |
| } | |
| void prom_idleself(void) | |
| { | |
| p1275_cmd("SUNW,idle-self", P1275_INOUT(0, 0)); | |
| } | |
| void prom_resumecpu(int cpunode) | |
| { | |
| p1275_cmd("SUNW,resume-cpu", P1275_INOUT(1, 0), cpunode); | |
| } | |
| #endif |