git.oblomov.eu Git - linux-2.6/blob - arch/ppc/syslib/prom_init.c

   1 /*
   2  * Note that prom_init() and anything called from prom_init()
   3  * may be running at an address that is different from the address
   4  * that it was linked at.  References to static data items are
   5  * handled by compiling this file with -mrelocatable-lib.
   6  */
   7
   8 #include <linux/config.h>
   9 #include <linux/kernel.h>
  10 #include <linux/string.h>
  11 #include <linux/init.h>
  12 #include <linux/threads.h>
  13 #include <linux/spinlock.h>
  14 #include <linux/ioport.h>
  15 #include <linux/pci.h>
  16 #include <linux/slab.h>
  17 #include <linux/bitops.h>
  18
  19 #include <asm/sections.h>
  20 #include <asm/prom.h>
  21 #include <asm/page.h>
  22 #include <asm/irq.h>
  23 #include <asm/io.h>
  24 #include <asm/smp.h>
  25 #include <asm/bootx.h>
  26 #include <asm/system.h>
  27 #include <asm/mmu.h>
  28 #include <asm/pgtable.h>
  29 #include <asm/bootinfo.h>
  30 #include <asm/btext.h>
  31 #include <asm/pci-bridge.h>
  32 #include <asm/open_pic.h>
  33 #include <asm/cacheflush.h>
  34
  35 #ifdef CONFIG_LOGO_LINUX_CLUT224
  36 #include <linux/linux_logo.h>
  37 extern const struct linux_logo logo_linux_clut224;
  38 #endif
  39
  40 /*
  41  * Properties whose value is longer than this get excluded from our
  42  * copy of the device tree.  This way we don't waste space storing
  43  * things like "driver,AAPL,MacOS,PowerPC" properties.  But this value
  44  * does need to be big enough to ensure that we don't lose things
  45  * like the interrupt-map property on a PCI-PCI bridge.
  46  */
  47 #define MAX_PROPERTY_LENGTH     4096
  48
  49 #ifndef FB_MAX                  /* avoid pulling in all of the fb stuff */
  50 #define FB_MAX  8
  51 #endif
  52
  53 #define ALIGNUL(x) (((x) + sizeof(unsigned long)-1) & -sizeof(unsigned long))
  54
  55 typedef u32 prom_arg_t;
  56
  57 struct prom_args {
  58         const char *service;
  59         int nargs;
  60         int nret;
  61         prom_arg_t args[10];
  62 };
  63
  64 struct pci_address {
  65         unsigned a_hi;
  66         unsigned a_mid;
  67         unsigned a_lo;
  68 };
  69
  70 struct pci_reg_property {
  71         struct pci_address addr;
  72         unsigned size_hi;
  73         unsigned size_lo;
  74 };
  75
  76 struct pci_range {
  77         struct pci_address addr;
  78         unsigned phys;
  79         unsigned size_hi;
  80         unsigned size_lo;
  81 };
  82
  83 struct isa_reg_property {
  84         unsigned space;
  85         unsigned address;
  86         unsigned size;
  87 };
  88
  89 struct pci_intr_map {
  90         struct pci_address addr;
  91         unsigned dunno;
  92         phandle int_ctrler;
  93         unsigned intr;
  94 };
  95
  96 static void prom_exit(void);
  97 static int  call_prom(const char *service, int nargs, int nret, ...);
  98 static int  call_prom_ret(const char *service, int nargs, int nret,
  99                           prom_arg_t *rets, ...);
 100 static void prom_print_hex(unsigned int v);
 101 static int  prom_set_color(ihandle ih, int i, int r, int g, int b);
 102 static int  prom_next_node(phandle *nodep);
 103 static unsigned long check_display(unsigned long mem);
 104 static void setup_disp_fake_bi(ihandle dp);
 105 static unsigned long copy_device_tree(unsigned long mem_start,
 106                                 unsigned long mem_end);
 107 static unsigned long inspect_node(phandle node, struct device_node *dad,
 108                                 unsigned long mem_start, unsigned long mem_end,
 109                                 struct device_node ***allnextpp);
 110 static void prom_hold_cpus(unsigned long mem);
 111 static void prom_instantiate_rtas(void);
 112 static void * early_get_property(unsigned long base, unsigned long node,
 113                                 char *prop);
 114
 115 prom_entry prom __initdata;
 116 ihandle prom_chosen __initdata;
 117 ihandle prom_stdout __initdata;
 118
 119 static char *prom_display_paths[FB_MAX] __initdata;
 120 static phandle prom_display_nodes[FB_MAX] __initdata;
 121 static unsigned int prom_num_displays __initdata;
 122 static ihandle prom_disp_node __initdata;
 123 char *of_stdout_device __initdata;
 124
 125 unsigned int rtas_data;   /* physical pointer */
 126 unsigned int rtas_entry;  /* physical pointer */
 127 unsigned int rtas_size;
 128 unsigned int old_rtas;
 129
 130 boot_infos_t *boot_infos;
 131 char *bootpath;
 132 char *bootdevice;
 133 struct device_node *allnodes;
 134
 135 extern char *klimit;
 136
 137 static void __init
 138 prom_exit(void)
 139 {
 140         struct prom_args args;
 141
 142         args.service = "exit";
 143         args.nargs = 0;
 144         args.nret = 0;
 145         prom(&args);
 146         for (;;)                        /* should never get here */
 147                 ;
 148 }
 149
 150 static int __init
 151 call_prom(const char *service, int nargs, int nret, ...)
 152 {
 153         va_list list;
 154         int i;
 155         struct prom_args prom_args;
 156
 157         prom_args.service = service;
 158         prom_args.nargs = nargs;
 159         prom_args.nret = nret;
 160         va_start(list, nret);
 161         for (i = 0; i < nargs; ++i)
 162                 prom_args.args[i] = va_arg(list, prom_arg_t);
 163         va_end(list);
 164         for (i = 0; i < nret; ++i)
 165                 prom_args.args[i + nargs] = 0;
 166         prom(&prom_args);
 167         return prom_args.args[nargs];
 168 }
 169
 170 static int __init
 171 call_prom_ret(const char *service, int nargs, int nret, prom_arg_t *rets, ...)
 172 {
 173         va_list list;
 174         int i;
 175         struct prom_args prom_args;
 176
 177         prom_args.service = service;
 178         prom_args.nargs = nargs;
 179         prom_args.nret = nret;
 180         va_start(list, rets);
 181         for (i = 0; i < nargs; ++i)
 182                 prom_args.args[i] = va_arg(list, int);
 183         va_end(list);
 184         for (i = 0; i < nret; ++i)
 185                 prom_args.args[i + nargs] = 0;
 186         prom(&prom_args);
 187         for (i = 1; i < nret; ++i)
 188                 rets[i-1] = prom_args.args[nargs + i];
 189         return prom_args.args[nargs];
 190 }
 191
 192 void __init
 193 prom_print(const char *msg)
 194 {
 195         const char *p, *q;
 196
 197         if (prom_stdout == 0)
 198                 return;
 199
 200         for (p = msg; *p != 0; p = q) {
 201                 for (q = p; *q != 0 && *q != '\n'; ++q)
 202                         ;
 203                 if (q > p)
 204                         call_prom("write", 3, 1, prom_stdout, p, q - p);
 205                 if (*q != 0) {
 206                         ++q;
 207                         call_prom("write", 3, 1, prom_stdout, "\r\n", 2);
 208                 }
 209         }
 210 }
 211
 212 static void __init
 213 prom_print_hex(unsigned int v)
 214 {
 215         char buf[16];
 216         int i, c;
 217
 218         for (i = 0; i < 8; ++i) {
 219                 c = (v >> ((7-i)*4)) & 0xf;
 220                 c += (c >= 10)? ('a' - 10): '0';
 221                 buf[i] = c;
 222         }
 223         buf[i] = ' ';
 224         buf[i+1] = 0;
 225         prom_print(buf);
 226 }
 227
 228 static int __init
 229 prom_set_color(ihandle ih, int i, int r, int g, int b)
 230 {
 231         return call_prom("call-method", 6, 1, "color!", ih, i, b, g, r);
 232 }
 233
 234 static int __init
 235 prom_next_node(phandle *nodep)
 236 {
 237         phandle node;
 238
 239         if ((node = *nodep) != 0
 240             && (*nodep = call_prom("child", 1, 1, node)) != 0)
 241                 return 1;
 242         if ((*nodep = call_prom("peer", 1, 1, node)) != 0)
 243                 return 1;
 244         for (;;) {
 245                 if ((node = call_prom("parent", 1, 1, node)) == 0)
 246                         return 0;
 247                 if ((*nodep = call_prom("peer", 1, 1, node)) != 0)
 248                         return 1;
 249         }
 250 }
 251
 252 #ifdef CONFIG_POWER4
 253 /*
 254  * Set up a hash table with a set of entries in it to map the
 255  * first 64MB of RAM.  This is used on 64-bit machines since
 256  * some of them don't have BATs.
 257  */
 258
 259 static inline void make_pte(unsigned long htab, unsigned int hsize,
 260                             unsigned int va, unsigned int pa, int mode)
 261 {
 262         unsigned int *pteg;
 263         unsigned int hash, i, vsid;
 264
 265         vsid = ((va >> 28) * 0x111) << 12;
 266         hash = ((va ^ vsid) >> 5) & 0x7fff80;
 267         pteg = (unsigned int *)(htab + (hash & (hsize - 1)));
 268         for (i = 0; i < 8; ++i, pteg += 4) {
 269                 if ((pteg[1] & 1) == 0) {
 270                         pteg[1] = vsid | ((va >> 16) & 0xf80) | 1;
 271                         pteg[3] = pa | mode;
 272                         break;
 273                 }
 274         }
 275 }
 276
 277 extern unsigned long _SDR1;
 278 extern PTE *Hash;
 279 extern unsigned long Hash_size;
 280
 281 static void __init
 282 prom_alloc_htab(void)
 283 {
 284         unsigned int hsize;
 285         unsigned long htab;
 286         unsigned int addr;
 287
 288         /*
 289          * Because of OF bugs we can't use the "claim" client
 290          * interface to allocate memory for the hash table.
 291          * This code is only used on 64-bit PPCs, and the only
 292          * 64-bit PPCs at the moment are RS/6000s, and their
 293          * OF is based at 0xc00000 (the 12M point), so we just
 294          * arbitrarily use the 0x800000 - 0xc00000 region for the
 295          * hash table.
 296          *  -- paulus.
 297          */
 298         hsize = 4 << 20;        /* POWER4 has no BATs */
 299         htab = (8 << 20);
 300         call_prom("claim", 3, 1, htab, hsize, 0);
 301         Hash = (void *)(htab + KERNELBASE);
 302         Hash_size = hsize;
 303         _SDR1 = htab + __ilog2(hsize) - 18;
 304
 305         /*
 306          * Put in PTEs for the first 64MB of RAM
 307          */
 308         memset((void *)htab, 0, hsize);
 309         for (addr = 0; addr < 0x4000000; addr += 0x1000)
 310                 make_pte(htab, hsize, addr + KERNELBASE, addr,
 311                          _PAGE_ACCESSED | _PAGE_COHERENT | PP_RWXX);
 312 #if 0 /* DEBUG stuff mapping the SCC */
 313         make_pte(htab, hsize, 0x80013000, 0x80013000,
 314                  _PAGE_ACCESSED | _PAGE_NO_CACHE | _PAGE_GUARDED | PP_RWXX);
 315 #endif
 316 }
 317 #endif /* CONFIG_POWER4 */
 318
 319
 320 /*
 321  * If we have a display that we don't know how to drive,
 322  * we will want to try to execute OF's open method for it
 323  * later.  However, OF will probably fall over if we do that
 324  * we've taken over the MMU.
 325  * So we check whether we will need to open the display,
 326  * and if so, open it now.
 327  */
 328 static unsigned long __init
 329 check_display(unsigned long mem)
 330 {
 331         phandle node;
 332         ihandle ih;
 333         int i, j;
 334         char type[16], *path;
 335         static unsigned char default_colors[] = {
 336                 0x00, 0x00, 0x00,
 337                 0x00, 0x00, 0xaa,
 338                 0x00, 0xaa, 0x00,
 339                 0x00, 0xaa, 0xaa,
 340                 0xaa, 0x00, 0x00,
 341                 0xaa, 0x00, 0xaa,
 342                 0xaa, 0xaa, 0x00,
 343                 0xaa, 0xaa, 0xaa,
 344                 0x55, 0x55, 0x55,
 345                 0x55, 0x55, 0xff,
 346                 0x55, 0xff, 0x55,
 347                 0x55, 0xff, 0xff,
 348                 0xff, 0x55, 0x55,
 349                 0xff, 0x55, 0xff,
 350                 0xff, 0xff, 0x55,
 351                 0xff, 0xff, 0xff
 352         };
 353         const unsigned char *clut;
 354
 355         prom_disp_node = 0;
 356
 357         for (node = 0; prom_next_node(&node); ) {
 358                 type[0] = 0;
 359                 call_prom("getprop", 4, 1, node, "device_type",
 360                           type, sizeof(type));
 361                 if (strcmp(type, "display") != 0)
 362                         continue;
 363                 /* It seems OF doesn't null-terminate the path :-( */
 364                 path = (char *) mem;
 365                 memset(path, 0, 256);
 366                 if (call_prom("package-to-path", 3, 1, node, path, 255) < 0)
 367                         continue;
 368
 369                 /*
 370                  * If this display is the device that OF is using for stdout,
 371                  * move it to the front of the list.
 372                  */
 373                 mem += strlen(path) + 1;
 374                 i = prom_num_displays++;
 375                 if (of_stdout_device != 0 && i > 0
 376                     && strcmp(of_stdout_device, path) == 0) {
 377                         for (; i > 0; --i) {
 378                                 prom_display_paths[i]
 379                                         = prom_display_paths[i-1];
 380                                 prom_display_nodes[i]
 381                                         = prom_display_nodes[i-1];
 382                         }
 383                 }
 384                 prom_display_paths[i] = path;
 385                 prom_display_nodes[i] = node;
 386                 if (i == 0)
 387                         prom_disp_node = node;
 388                 if (prom_num_displays >= FB_MAX)
 389                         break;
 390         }
 391
 392         for (j=0; j<prom_num_displays; j++) {
 393                 path = prom_display_paths[j];
 394                 node = prom_display_nodes[j];
 395                 prom_print("opening display ");
 396                 prom_print(path);
 397                 ih = call_prom("open", 1, 1, path);
 398                 if (ih == 0 || ih == (ihandle) -1) {
 399                         prom_print("... failed\n");
 400                         for (i=j+1; i<prom_num_displays; i++) {
 401                                 prom_display_paths[i-1] = prom_display_paths[i];
 402                                 prom_display_nodes[i-1] = prom_display_nodes[i];
 403                         }
 404                         if (--prom_num_displays > 0) {
 405                                 prom_disp_node = prom_display_nodes[j];
 406                                 j--;
 407                         } else
 408                                 prom_disp_node = 0;
 409                         continue;
 410                 } else {
 411                         prom_print("... ok\n");
 412                         call_prom("setprop", 4, 1, node, "linux,opened", 0, 0);
 413
 414                         /*
 415                          * Setup a usable color table when the appropriate
 416                          * method is available.
 417                          * Should update this to use set-colors.
 418                          */
 419                         clut = default_colors;
 420                         for (i = 0; i < 32; i++, clut += 3)
 421                                 if (prom_set_color(ih, i, clut[0], clut[1],
 422                                                    clut[2]) != 0)
 423                                         break;
 424
 425 #ifdef CONFIG_LOGO_LINUX_CLUT224
 426                         clut = PTRRELOC(logo_linux_clut224.clut);
 427                         for (i = 0; i < logo_linux_clut224.clutsize;
 428                              i++, clut += 3)
 429                                 if (prom_set_color(ih, i + 32, clut[0],
 430                                                    clut[1], clut[2]) != 0)
 431                                         break;
 432 #endif /* CONFIG_LOGO_LINUX_CLUT224 */
 433                 }
 434         }
 435
 436         if (prom_stdout) {
 437                 phandle p;
 438                 p = call_prom("instance-to-package", 1, 1, prom_stdout);
 439                 if (p && p != -1) {
 440                         type[0] = 0;
 441                         call_prom("getprop", 4, 1, p, "device_type",
 442                                   type, sizeof(type));
 443                         if (strcmp(type, "display") == 0)
 444                                 call_prom("setprop", 4, 1, p, "linux,boot-display",
 445                                           0, 0);
 446                 }
 447         }
 448
 449         return ALIGNUL(mem);
 450 }
 451
 452 /* This function will enable the early boot text when doing OF booting. This
 453  * way, xmon output should work too
 454  */
 455 static void __init
 456 setup_disp_fake_bi(ihandle dp)
 457 {
 458 #ifdef CONFIG_BOOTX_TEXT
 459         int width = 640, height = 480, depth = 8, pitch;
 460         unsigned address;
 461         struct pci_reg_property addrs[8];
 462         int i, naddrs;
 463         char name[32];
 464         char *getprop = "getprop";
 465
 466         prom_print("Initializing fake screen: ");
 467
 468         memset(name, 0, sizeof(name));
 469         call_prom(getprop, 4, 1, dp, "name", name, sizeof(name));
 470         name[sizeof(name)-1] = 0;
 471         prom_print(name);
 472         prom_print("\n");
 473         call_prom(getprop, 4, 1, dp, "width", &width, sizeof(width));
 474         call_prom(getprop, 4, 1, dp, "height", &height, sizeof(height));
 475         call_prom(getprop, 4, 1, dp, "depth", &depth, sizeof(depth));
 476         pitch = width * ((depth + 7) / 8);
 477         call_prom(getprop, 4, 1, dp, "linebytes",
 478                   &pitch, sizeof(pitch));
 479         if (pitch == 1)
 480                 pitch = 0x1000;         /* for strange IBM display */
 481         address = 0;
 482         call_prom(getprop, 4, 1, dp, "address",
 483                   &address, sizeof(address));
 484         if (address == 0) {
 485                 /* look for an assigned address with a size of >= 1MB */
 486                 naddrs = call_prom(getprop, 4, 1, dp, "assigned-addresses",
 487                                    addrs, sizeof(addrs));
 488                 naddrs /= sizeof(struct pci_reg_property);
 489                 for (i = 0; i < naddrs; ++i) {
 490                         if (addrs[i].size_lo >= (1 << 20)) {
 491                                 address = addrs[i].addr.a_lo;
 492                                 /* use the BE aperture if possible */
 493                                 if (addrs[i].size_lo >= (16 << 20))
 494                                         address += (8 << 20);
 495                                 break;
 496                         }
 497                 }
 498                 if (address == 0) {
 499                         prom_print("Failed to get address\n");
 500                         return;
 501                 }
 502         }
 503         /* kludge for valkyrie */
 504         if (strcmp(name, "valkyrie") == 0)
 505                 address += 0x1000;
 506
 507 #ifdef CONFIG_POWER4
 508 #if CONFIG_TASK_SIZE > 0x80000000
 509 #error CONFIG_TASK_SIZE cannot be above 0x80000000 with BOOTX_TEXT on G5
 510 #endif
 511         {
 512                 extern boot_infos_t disp_bi;
 513                 unsigned long va, pa, i, offset;
 514                 va = 0x90000000;
 515                 pa = address & 0xfffff000ul;
 516                 offset = address & 0x00000fff;
 517
 518                 for (i=0; i<0x4000; i++) {
 519                         make_pte((unsigned long)Hash - KERNELBASE, Hash_size, va, pa,
 520                                  _PAGE_ACCESSED | _PAGE_NO_CACHE |
 521                                  _PAGE_GUARDED | PP_RWXX);
 522                         va += 0x1000;
 523                         pa += 0x1000;
 524                 }
 525                 btext_setup_display(width, height, depth, pitch, 0x90000000 | offset);
 526                 disp_bi.dispDeviceBase = (u8 *)address;
 527         }
 528 #else /* CONFIG_POWER4 */
 529         btext_setup_display(width, height, depth, pitch, address);
 530         btext_prepare_BAT();
 531 #endif /* CONFIG_POWER4 */
 532 #endif /* CONFIG_BOOTX_TEXT */
 533 }
 534
 535 /*
 536  * Make a copy of the device tree from the PROM.
 537  */
 538 static unsigned long __init
 539 copy_device_tree(unsigned long mem_start, unsigned long mem_end)
 540 {
 541         phandle root;
 542         unsigned long new_start;
 543         struct device_node **allnextp;
 544
 545         root = call_prom("peer", 1, 1, (phandle)0);
 546         if (root == (phandle)0) {
 547                 prom_print("couldn't get device tree root\n");
 548                 prom_exit();
 549         }
 550         allnextp = &allnodes;
 551         mem_start = ALIGNUL(mem_start);
 552         new_start = inspect_node(root, NULL, mem_start, mem_end, &allnextp);
 553         *allnextp = NULL;
 554         return new_start;
 555 }
 556
 557 static unsigned long __init
 558 inspect_node(phandle node, struct device_node *dad,
 559              unsigned long mem_start, unsigned long mem_end,
 560              struct device_node ***allnextpp)
 561 {
 562         int l;
 563         phandle child;
 564         struct device_node *np;
 565         struct property *pp, **prev_propp;
 566         char *prev_name, *namep;
 567         unsigned char *valp;
 568
 569         np = (struct device_node *) mem_start;
 570         mem_start += sizeof(struct device_node);
 571         memset(np, 0, sizeof(*np));
 572         np->node = node;
 573         **allnextpp = PTRUNRELOC(np);
 574         *allnextpp = &np->allnext;
 575         if (dad != 0) {
 576                 np->parent = PTRUNRELOC(dad);
 577                 /* we temporarily use the `next' field as `last_child'. */
 578                 if (dad->next == 0)
 579                         dad->child = PTRUNRELOC(np);
 580                 else
 581                         dad->next->sibling = PTRUNRELOC(np);
 582                 dad->next = np;
 583         }
 584
 585         /* get and store all properties */
 586         prev_propp = &np->properties;
 587         prev_name = "";
 588         for (;;) {
 589                 pp = (struct property *) mem_start;
 590                 namep = (char *) (pp + 1);
 591                 pp->name = PTRUNRELOC(namep);
 592                 if (call_prom("nextprop", 3, 1, node, prev_name, namep) <= 0)
 593                         break;
 594                 mem_start = ALIGNUL((unsigned long)namep + strlen(namep) + 1);
 595                 prev_name = namep;
 596                 valp = (unsigned char *) mem_start;
 597                 pp->value = PTRUNRELOC(valp);
 598                 pp->length = call_prom("getprop", 4, 1, node, namep,
 599                                        valp, mem_end - mem_start);
 600                 if (pp->length < 0)
 601                         continue;
 602 #ifdef MAX_PROPERTY_LENGTH
 603                 if (pp->length > MAX_PROPERTY_LENGTH)
 604                         continue; /* ignore this property */
 605 #endif
 606                 mem_start = ALIGNUL(mem_start + pp->length);
 607                 *prev_propp = PTRUNRELOC(pp);
 608                 prev_propp = &pp->next;
 609         }
 610         if (np->node != 0) {
 611                 /* Add a "linux,phandle" property" */
 612                 pp = (struct property *) mem_start;
 613                 *prev_propp = PTRUNRELOC(pp);
 614                 prev_propp = &pp->next;
 615                 namep = (char *) (pp + 1);
 616                 pp->name = PTRUNRELOC(namep);
 617                 strcpy(namep, "linux,phandle");
 618                 mem_start = ALIGNUL((unsigned long)namep + strlen(namep) + 1);
 619                 pp->value = (unsigned char *) PTRUNRELOC(&np->node);
 620                 pp->length = sizeof(np->node);
 621         }
 622         *prev_propp = NULL;
 623
 624         /* get the node's full name */
 625         l = call_prom("package-to-path", 3, 1, node,
 626                       mem_start, mem_end - mem_start);
 627         if (l >= 0) {
 628                 char *p, *ep;
 629
 630                 np->full_name = PTRUNRELOC((char *) mem_start);
 631                 *(char *)(mem_start + l) = 0;
 632                 /* Fixup an Apple bug where they have bogus \0 chars in the
 633                  * middle of the path in some properties
 634                  */
 635                 for (p = (char *)mem_start, ep = p + l; p < ep; p++)
 636                         if ((*p) == '\0') {
 637                                 memmove(p, p+1, ep - p);
 638                                 ep--;
 639                         }
 640                 mem_start = ALIGNUL(mem_start + l + 1);
 641         }
 642
 643         /* do all our children */
 644         child = call_prom("child", 1, 1, node);
 645         while (child != 0) {
 646                 mem_start = inspect_node(child, np, mem_start, mem_end,
 647                                          allnextpp);
 648                 child = call_prom("peer", 1, 1, child);
 649         }
 650
 651         return mem_start;
 652 }
 653
 654 unsigned long smp_chrp_cpu_nr __initdata = 0;
 655
 656 /*
 657  * With CHRP SMP we need to use the OF to start the other
 658  * processors so we can't wait until smp_boot_cpus (the OF is
 659  * trashed by then) so we have to put the processors into
 660  * a holding pattern controlled by the kernel (not OF) before
 661  * we destroy the OF.
 662  *
 663  * This uses a chunk of high memory, puts some holding pattern
 664  * code there and sends the other processors off to there until
 665  * smp_boot_cpus tells them to do something.  We do that by using
 666  * physical address 0x0.  The holding pattern checks that address
 667  * until its cpu # is there, when it is that cpu jumps to
 668  * __secondary_start().  smp_boot_cpus() takes care of setting those
 669  * values.
 670  *
 671  * We also use physical address 0x4 here to tell when a cpu
 672  * is in its holding pattern code.
 673  *
 674  * -- Cort
 675  *
 676  * Note that we have to do this if we have more than one CPU,
 677  * even if this is a UP kernel.  Otherwise when we trash OF
 678  * the other CPUs will start executing some random instructions
 679  * and crash the system.  -- paulus
 680  */
 681 static void __init
 682 prom_hold_cpus(unsigned long mem)
 683 {
 684         extern void __secondary_hold(void);
 685         unsigned long i;
 686         int cpu;
 687         phandle node;
 688         char type[16], *path;
 689         unsigned int reg;
 690
 691         /*
 692          * XXX: hack to make sure we're chrp, assume that if we're
 693          *      chrp we have a device_type property -- Cort
 694          */
 695         node = call_prom("finddevice", 1, 1, "/");
 696         if (call_prom("getprop", 4, 1, node,
 697                       "device_type", type, sizeof(type)) <= 0)
 698                 return;
 699
 700         /* copy the holding pattern code to someplace safe (0) */
 701         /* the holding pattern is now within the first 0x100
 702            bytes of the kernel image -- paulus */
 703         memcpy((void *)0, _stext, 0x100);
 704         flush_icache_range(0, 0x100);
 705
 706         /* look for cpus */
 707         *(unsigned long *)(0x0) = 0;
 708         asm volatile("dcbf 0,%0": : "r" (0) : "memory");
 709         for (node = 0; prom_next_node(&node); ) {
 710                 type[0] = 0;
 711                 call_prom("getprop", 4, 1, node, "device_type",
 712                           type, sizeof(type));
 713                 if (strcmp(type, "cpu") != 0)
 714                         continue;
 715                 path = (char *) mem;
 716                 memset(path, 0, 256);
 717                 if (call_prom("package-to-path", 3, 1, node, path, 255) < 0)
 718                         continue;
 719                 reg = -1;
 720                 call_prom("getprop", 4, 1, node, "reg", &reg, sizeof(reg));
 721                 cpu = smp_chrp_cpu_nr++;
 722 #ifdef CONFIG_SMP
 723                 smp_hw_index[cpu] = reg;
 724 #endif /* CONFIG_SMP */
 725                 /* XXX: hack - don't start cpu 0, this cpu -- Cort */
 726                 if (cpu == 0)
 727                         continue;
 728                 prom_print("starting cpu ");
 729                 prom_print(path);
 730                 *(ulong *)(0x4) = 0;
 731                 call_prom("start-cpu", 3, 0, node,
 732                           (char *)__secondary_hold - _stext, cpu);
 733                 prom_print("...");
 734                 for ( i = 0 ; (i < 10000) && (*(ulong *)(0x4) == 0); i++ )
 735                         ;
 736                 if (*(ulong *)(0x4) == cpu)
 737                         prom_print("ok\n");
 738                 else {
 739                         prom_print("failed: ");
 740                         prom_print_hex(*(ulong *)0x4);
 741                         prom_print("\n");
 742                 }
 743         }
 744 }
 745
 746 static void __init
 747 prom_instantiate_rtas(void)
 748 {
 749         ihandle prom_rtas;
 750         prom_arg_t result;
 751
 752         prom_rtas = call_prom("finddevice", 1, 1, "/rtas");
 753         if (prom_rtas == -1)
 754                 return;
 755
 756         rtas_size = 0;
 757         call_prom("getprop", 4, 1, prom_rtas,
 758                   "rtas-size", &rtas_size, sizeof(rtas_size));
 759         prom_print("instantiating rtas");
 760         if (rtas_size == 0) {
 761                 rtas_data = 0;
 762         } else {
 763                 /*
 764                  * Ask OF for some space for RTAS.
 765                  * Actually OF has bugs so we just arbitrarily
 766                  * use memory at the 6MB point.
 767                  */
 768                 rtas_data = 6 << 20;
 769                 prom_print(" at ");
 770                 prom_print_hex(rtas_data);
 771         }
 772
 773         prom_rtas = call_prom("open", 1, 1, "/rtas");
 774         prom_print("...");
 775         rtas_entry = 0;
 776         if (call_prom_ret("call-method", 3, 2, &result,
 777                           "instantiate-rtas", prom_rtas, rtas_data) == 0)
 778                 rtas_entry = result;
 779         if ((rtas_entry == -1) || (rtas_entry == 0))
 780                 prom_print(" failed\n");
 781         else
 782                 prom_print(" done\n");
 783 }
 784
 785 /*
 786  * We enter here early on, when the Open Firmware prom is still
 787  * handling exceptions and the MMU hash table for us.
 788  */
 789 unsigned long __init
 790 prom_init(int r3, int r4, prom_entry pp)
 791 {
 792         unsigned long mem;
 793         ihandle prom_mmu;
 794         unsigned long offset = reloc_offset();
 795         int i, l;
 796         char *p, *d;
 797         unsigned long phys;
 798         prom_arg_t result[3];
 799         char model[32];
 800         phandle node;
 801         int rc;
 802
 803         /* Default */
 804         phys = (unsigned long) &_stext;
 805
 806         /* First get a handle for the stdout device */
 807         prom = pp;
 808         prom_chosen = call_prom("finddevice", 1, 1, "/chosen");
 809         if (prom_chosen == -1)
 810                 prom_exit();
 811         if (call_prom("getprop", 4, 1, prom_chosen, "stdout",
 812                       &prom_stdout, sizeof(prom_stdout)) <= 0)
 813                 prom_exit();
 814
 815         /* Get the full OF pathname of the stdout device */
 816         mem = (unsigned long) klimit + offset;
 817         p = (char *) mem;
 818         memset(p, 0, 256);
 819         call_prom("instance-to-path", 3, 1, prom_stdout, p, 255);
 820         of_stdout_device = p;
 821         mem += strlen(p) + 1;
 822
 823         /* Get the boot device and translate it to a full OF pathname. */
 824         p = (char *) mem;
 825         l = call_prom("getprop", 4, 1, prom_chosen, "bootpath", p, 1<<20);
 826         if (l > 0) {
 827                 p[l] = 0;       /* should already be null-terminated */
 828                 bootpath = PTRUNRELOC(p);
 829                 mem += l + 1;
 830                 d = (char *) mem;
 831                 *d = 0;
 832                 call_prom("canon", 3, 1, p, d, 1<<20);
 833                 bootdevice = PTRUNRELOC(d);
 834                 mem = ALIGNUL(mem + strlen(d) + 1);
 835         }
 836
 837         prom_instantiate_rtas();
 838
 839 #ifdef CONFIG_POWER4
 840         /*
 841          * Find out how much memory we have and allocate a
 842          * suitably-sized hash table.
 843          */
 844         prom_alloc_htab();
 845 #endif
 846         mem = check_display(mem);
 847
 848         prom_print("copying OF device tree...");
 849         mem = copy_device_tree(mem, mem + (1<<20));
 850         prom_print("done\n");
 851
 852         prom_hold_cpus(mem);
 853
 854         klimit = (char *) (mem - offset);
 855
 856         node = call_prom("finddevice", 1, 1, "/");
 857         rc = call_prom("getprop", 4, 1, node, "model", model, sizeof(model));
 858         if (rc > 0 && !strncmp (model, "Pegasos", 7)
 859                 && strncmp (model, "Pegasos2", 8)) {
 860                 /* Pegasos 1 has a broken translate method in the OF,
 861                  * and furthermore the BATs are mapped 1:1 so the phys
 862                  * address calculated above is correct, so let's use
 863                  * it directly.
 864                  */
 865         } else if (offset == 0) {
 866                 /* If we are already running at 0xc0000000, we assume we were
 867                  * loaded by an OF bootloader which did set a BAT for us.
 868                  * This breaks OF translate so we force phys to be 0.
 869                  */
 870                 prom_print("(already at 0xc0000000) phys=0\n");
 871                 phys = 0;
 872         } else if (call_prom("getprop", 4, 1, prom_chosen, "mmu",
 873                              &prom_mmu, sizeof(prom_mmu)) <= 0) {
 874                 prom_print(" no MMU found\n");
 875         } else if (call_prom_ret("call-method", 4, 4, result, "translate",
 876                                  prom_mmu, &_stext, 1) != 0) {
 877                 prom_print(" (translate failed)\n");
 878         } else {
 879                 /* We assume the phys. address size is 3 cells */
 880                 phys = result[2];
 881         }
 882
 883         if (prom_disp_node != 0)
 884                 setup_disp_fake_bi(prom_disp_node);
 885
 886         /* Use quiesce call to get OF to shut down any devices it's using */
 887         prom_print("Calling quiesce ...\n");
 888         call_prom("quiesce", 0, 0);
 889
 890         /* Relocate various pointers which will be used once the
 891            kernel is running at the address it was linked at. */
 892         for (i = 0; i < prom_num_displays; ++i)
 893                 prom_display_paths[i] = PTRUNRELOC(prom_display_paths[i]);
 894
 895 #ifdef CONFIG_SERIAL_CORE_CONSOLE
 896         /* Relocate the of stdout for console autodetection */
 897         of_stdout_device = PTRUNRELOC(of_stdout_device);
 898 #endif
 899
 900         prom_print("returning 0x");
 901         prom_print_hex(phys);
 902         prom_print("from prom_init\n");
 903         prom_stdout = 0;
 904
 905         return phys;
 906 }
 907
 908 /*
 909  * early_get_property is used to access the device tree image prepared
 910  * by BootX very early on, before the pointers in it have been relocated.
 911  */
 912 static void * __init
 913 early_get_property(unsigned long base, unsigned long node, char *prop)
 914 {
 915         struct device_node *np = (struct device_node *)(base + node);
 916         struct property *pp;
 917
 918         for (pp = np->properties; pp != 0; pp = pp->next) {
 919                 pp = (struct property *) (base + (unsigned long)pp);
 920                 if (strcmp((char *)((unsigned long)pp->name + base),
 921                            prop) == 0) {
 922                         return (void *)((unsigned long)pp->value + base);
 923                 }
 924         }
 925         return NULL;
 926 }
 927
 928 /* Is boot-info compatible ? */
 929 #define BOOT_INFO_IS_COMPATIBLE(bi)             ((bi)->compatible_version <= BOOT_INFO_VERSION)
 930 #define BOOT_INFO_IS_V2_COMPATIBLE(bi)  ((bi)->version >= 2)
 931 #define BOOT_INFO_IS_V4_COMPATIBLE(bi)  ((bi)->version >= 4)
 932
 933 void __init
 934 bootx_init(unsigned long r4, unsigned long phys)
 935 {
 936         boot_infos_t *bi = (boot_infos_t *) r4;
 937         unsigned long space;
 938         unsigned long ptr, x;
 939         char *model;
 940
 941         boot_infos = PTRUNRELOC(bi);
 942         if (!BOOT_INFO_IS_V2_COMPATIBLE(bi))
 943                 bi->logicalDisplayBase = NULL;
 944
 945 #ifdef CONFIG_BOOTX_TEXT
 946         btext_init(bi);
 947
 948         /*
 949          * Test if boot-info is compatible.  Done only in config
 950          * CONFIG_BOOTX_TEXT since there is nothing much we can do
 951          * with an incompatible version, except display a message
 952          * and eventually hang the processor...
 953          *
 954          * I'll try to keep enough of boot-info compatible in the
 955          * future to always allow display of this message;
 956          */
 957         if (!BOOT_INFO_IS_COMPATIBLE(bi)) {
 958                 btext_drawstring(" !!! WARNING - Incompatible version of BootX !!!\n\n\n");
 959                 btext_flushscreen();
 960         }
 961 #endif  /* CONFIG_BOOTX_TEXT */
 962
 963         /* New BootX enters kernel with MMU off, i/os are not allowed
 964            here. This hack will have been done by the boostrap anyway.
 965         */
 966         if (bi->version < 4) {
 967                 /*
 968                  * XXX If this is an iMac, turn off the USB controller.
 969                  */
 970                 model = (char *) early_get_property
 971                         (r4 + bi->deviceTreeOffset, 4, "model");
 972                 if (model
 973                     && (strcmp(model, "iMac,1") == 0
 974                         || strcmp(model, "PowerMac1,1") == 0)) {
 975                         out_le32((unsigned *)0x80880008, 1);    /* XXX */
 976                 }
 977         }
 978
 979         /* Move klimit to enclose device tree, args, ramdisk, etc... */
 980         if (bi->version < 5) {
 981                 space = bi->deviceTreeOffset + bi->deviceTreeSize;
 982                 if (bi->ramDisk)
 983                         space = bi->ramDisk + bi->ramDiskSize;
 984         } else
 985                 space = bi->totalParamsSize;
 986         klimit = PTRUNRELOC((char *) bi + space);
 987
 988         /* New BootX will have flushed all TLBs and enters kernel with
 989            MMU switched OFF, so this should not be useful anymore.
 990         */
 991         if (bi->version < 4) {
 992                 /*
 993                  * Touch each page to make sure the PTEs for them
 994                  * are in the hash table - the aim is to try to avoid
 995                  * getting DSI exceptions while copying the kernel image.
 996                  */
 997                 for (ptr = ((unsigned long) &_stext) & PAGE_MASK;
 998                      ptr < (unsigned long)bi + space; ptr += PAGE_SIZE)
 999                         x = *(volatile unsigned long *)ptr;
1000         }
1001
1002 #ifdef CONFIG_BOOTX_TEXT
1003         /*
1004          * Note that after we call btext_prepare_BAT, we can't do
1005          * prom_draw*, flushscreen or clearscreen until we turn the MMU
1006          * on, since btext_prepare_BAT sets disp_bi.logicalDisplayBase
1007          * to a virtual address.
1008          */
1009         btext_prepare_BAT();
1010 #endif
1011 }