arch/sparc64/prom/misc.c

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