arch/ppc/qemu/init.c

   1 /*
   2  *   Creation Date: <2004/08/28 18:38:22 greg>
   3  *   Time-stamp: <2004/08/28 18:38:22 greg>
   4  *
   5  *      <init.c>
   6  *
   7  *      Initialization for qemu
   8  *
   9  *   Copyright (C) 2004 Greg Watson
  10  *   Copyright (C) 2005 Stefan Reinauer
  11  *
  12  *   based on mol/init.c:
  13  *
  14  *   Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004 Samuel & David Rydh
  15  *      (samuel@ibrium.se, dary@lindesign.se)
  16  *
  17  *   This program is free software; you can redistribute it and/or
  18  *   modify it under the terms of the GNU General Public License
  19  *   as published by the Free Software Foundation
  20  *
  21  */
  22
  23 #include "config.h"
  24 #include "libopenbios/openbios.h"
  25 #include "libopenbios/bindings.h"
  26 #include "drivers/pci.h"
  27 #include "arch/common/nvram.h"
  28 #include "drivers/drivers.h"
  29 #include "qemu/qemu.h"
  30 #include "libopenbios/ofmem.h"
  31 #include "openbios-version.h"
  32 #include "libc/byteorder.h"
  33 #include "libc/vsprintf.h"
  34 #define NO_QEMU_PROTOS
  35 #include "arch/common/fw_cfg.h"
  36 #include "arch/ppc/processor.h"
  37
  38 #define UUID_FMT "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x"
  39
  40 struct cpudef {
  41     unsigned long iu_version;
  42     const char *name;
  43     int icache_size, dcache_size;
  44     int icache_sets, dcache_sets;
  45     int icache_block_size, dcache_block_size;
  46     int clock_frequency;
  47     void (*initfn)(const struct cpudef *cpu);
  48 };
  49
  50 static uint16_t machine_id = 0;
  51
  52 extern void unexpected_excep( int vector );
  53
  54 void
  55 unexpected_excep( int vector )
  56 {
  57         printk("openbios panic: Unexpected exception %x\n", vector );
  58         for( ;; )
  59                 ;
  60 }
  61
  62 enum {
  63     ARCH_PREP = 0,
  64     ARCH_MAC99,
  65     ARCH_HEATHROW,
  66     ARCH_MAC99_U3,
  67 };
  68
  69 int is_apple(void)
  70 {
  71         return 1;
  72 }
  73
  74 int is_oldworld(void)
  75 {
  76         return machine_id == ARCH_HEATHROW;
  77 }
  78
  79 int is_newworld(void)
  80 {
  81         return (machine_id == ARCH_MAC99) ||
  82                (machine_id == ARCH_MAC99_U3);
  83 }
  84
  85 static const pci_arch_t known_arch[] = {
  86     [ARCH_PREP] = {
  87         .name = "PREP",
  88         .vendor_id = PCI_VENDOR_ID_MOTOROLA,
  89         .device_id = PCI_DEVICE_ID_MOTOROLA_RAVEN,
  90         .cfg_addr = 0x80800000,
  91         .cfg_data = 0x800c0000,
  92         .cfg_base = 0x80000000,
  93         .cfg_len = 0x00100000,
  94         .host_mem_base = 0xf0000000,
  95         .pci_mem_base = 0xf0000000,
  96         .mem_len = 0x10000000,
  97         .io_base = 0x80000000,
  98         .io_len = 0x00010000,
  99         .rbase = 0x00000000,
 100         .rlen = 0x00400000,
 101         .irqs = { 9, 11, 9, 11 }
 102     },
 103     [ARCH_MAC99] = {
 104         .name = "MAC99",
 105         .vendor_id = PCI_VENDOR_ID_APPLE,
 106         .device_id = PCI_DEVICE_ID_APPLE_UNI_N_PCI,
 107         .cfg_addr = 0xf2800000,
 108         .cfg_data = 0xf2c00000,
 109         .cfg_base = 0xf2000000,
 110         .cfg_len = 0x02000000,
 111         .host_mem_base = 0x80000000,
 112         .pci_mem_base = 0x80000000,
 113         .mem_len = 0x10000000,
 114         .io_base = 0xf2000000,
 115         .io_len = 0x00800000,
 116         .rbase = 0x00000000,
 117         .rlen = 0x01000000,
 118         .irqs = { 0x1b, 0x1c, 0x1d, 0x1e }
 119     },
 120     [ARCH_MAC99_U3] = {
 121         .name = "MAC99_U3",
 122         .vendor_id = PCI_VENDOR_ID_APPLE,
 123         .device_id = PCI_DEVICE_ID_APPLE_U3_AGP,
 124         .cfg_addr = 0xf0800000,
 125         .cfg_data = 0xf0c00000,
 126         .cfg_base = 0xf0000000,
 127         .cfg_len = 0x02000000,
 128         .host_mem_base = 0x80000000,
 129         .pci_mem_base = 0x80000000,
 130         .mem_len = 0x10000000,
 131         .io_base = 0xf2000000,
 132         .io_len = 0x00800000,
 133         .rbase = 0x00000000,
 134         .rlen = 0x01000000,
 135         .irqs = { 0x1b, 0x1c, 0x1d, 0x1e }
 136     },
 137     [ARCH_HEATHROW] = {
 138         .name = "HEATHROW",
 139         .vendor_id = PCI_VENDOR_ID_MOTOROLA,
 140         .device_id = PCI_DEVICE_ID_MOTOROLA_MPC106,
 141         .cfg_addr = 0xfec00000,
 142         .cfg_data = 0xfee00000,
 143         .cfg_base = 0x80000000,
 144         .cfg_len = 0x7f000000,
 145         .host_mem_base = 0x80000000,
 146         .pci_mem_base = 0x80000000,
 147         .mem_len = 0x01000000,
 148         .io_base = 0xfe000000,
 149         .io_len = 0x00800000,
 150         .rbase = 0xfd000000,
 151         .rlen = 0x01000000,
 152         .irqs = { 21, 22, 23, 24 }
 153     },
 154 };
 155 uint32_t isa_io_base;
 156
 157 void
 158 entry( void )
 159 {
 160         uint32_t temp = 0;
 161         char buf[5];
 162
 163         arch = &known_arch[ARCH_HEATHROW];
 164
 165         fw_cfg_init();
 166
 167         fw_cfg_read(FW_CFG_SIGNATURE, buf, 4);
 168         buf[4] = '\0';
 169         if (strncmp(buf, "QEMU", 4) == 0) {
 170             temp = fw_cfg_read_i32(FW_CFG_ID);
 171             if (temp == 1) {
 172                 machine_id = fw_cfg_read_i16(FW_CFG_MACHINE_ID);
 173                 arch = &known_arch[machine_id];
 174             }
 175         }
 176
 177         isa_io_base = arch->io_base;
 178
 179         if (temp != 1) {
 180             printk("Incompatible configuration device version, freezing\n");
 181             for(;;);
 182         }
 183
 184         ofmem_init();
 185         initialize_forth();
 186         /* won't return */
 187
 188         printk("of_startup returned!\n");
 189         for( ;; )
 190                 ;
 191 }
 192
 193 static void
 194 cpu_generic_init(const struct cpudef *cpu)
 195 {
 196     unsigned long iu_version;
 197
 198     push_str("/cpus");
 199     fword("find-device");
 200
 201     fword("new-device");
 202
 203     push_str(cpu->name);
 204     fword("device-name");
 205
 206     push_str("cpu");
 207     fword("device-type");
 208
 209     asm("mfpvr %0\n"
 210         : "=r"(iu_version) :);
 211     PUSH(iu_version);
 212     fword("encode-int");
 213     push_str("cpu-version");
 214     fword("property");
 215
 216     PUSH(cpu->dcache_size);
 217     fword("encode-int");
 218     push_str("dcache-size");
 219     fword("property");
 220
 221     PUSH(cpu->icache_size);
 222     fword("encode-int");
 223     push_str("icache-size");
 224     fword("property");
 225
 226     PUSH(cpu->dcache_sets);
 227     fword("encode-int");
 228     push_str("dcache-sets");
 229     fword("property");
 230
 231     PUSH(cpu->icache_sets);
 232     fword("encode-int");
 233     push_str("icache-sets");
 234     fword("property");
 235
 236     PUSH(cpu->dcache_block_size);
 237     fword("encode-int");
 238     push_str("dcache-block-size");
 239     fword("property");
 240
 241     PUSH(cpu->icache_block_size);
 242     fword("encode-int");
 243     push_str("icache-block-size");
 244     fword("property");
 245
 246     PUSH(fw_cfg_read_i32(FW_CFG_PPC_TBFREQ));
 247     fword("encode-int");
 248     push_str("timebase-frequency");
 249     fword("property");
 250
 251     PUSH(fw_cfg_read_i32(FW_CFG_PPC_CPUFREQ));
 252     fword("encode-int");
 253     push_str("clock-frequency");
 254     fword("property");
 255
 256     push_str("running");
 257     fword("encode-string");
 258     push_str("state");
 259     fword("property");
 260 }
 261
 262 static void
 263 cpu_add_pir_property(void)
 264 {
 265     unsigned long pir;
 266
 267     asm("mfspr %0, 1023\n"
 268         : "=r"(pir) :);
 269     PUSH(pir);
 270     fword("encode-int");
 271     push_str("reg");
 272     fword("property");
 273 }
 274
 275 static void
 276 cpu_604_init(const struct cpudef *cpu)
 277 {
 278     cpu_generic_init(cpu);
 279     cpu_add_pir_property();
 280
 281     fword("finish-device");
 282 }
 283
 284 static void
 285 cpu_750_init(const struct cpudef *cpu)
 286 {
 287     cpu_generic_init(cpu);
 288
 289     PUSH(0);
 290     fword("encode-int");
 291     push_str("reg");
 292     fword("property");
 293
 294     fword("finish-device");
 295 }
 296
 297 static void
 298 cpu_g4_init(const struct cpudef *cpu)
 299 {
 300     cpu_generic_init(cpu);
 301     cpu_add_pir_property();
 302
 303     fword("finish-device");
 304 }
 305
 306 #ifdef CONFIG_PPC_64BITSUPPORT
 307 /* In order to get 64 bit aware handlers that rescue all our
 308    GPRs from getting truncated to 32 bits, we need to patch the
 309    existing handlers so they jump to our 64 bit aware ones. */
 310 static void
 311 ppc64_patch_handlers(void)
 312 {
 313     uint32_t *dsi = (uint32_t *)0x300UL;
 314     uint32_t *isi = (uint32_t *)0x400UL;
 315
 316     // Patch the first DSI handler instruction to: ba 0x2000
 317     *dsi = 0x48002002;
 318
 319     // Patch the first ISI handler instruction to: ba 0x2200
 320     *isi = 0x48002202;
 321
 322     // Invalidate the cache lines
 323     asm ( "icbi 0, %0" : : "r"(dsi) );
 324     asm ( "icbi 0, %0" : : "r"(isi) );
 325 }
 326 #endif
 327
 328 static void
 329 cpu_970_init(const struct cpudef *cpu)
 330 {
 331     cpu_generic_init(cpu);
 332
 333     PUSH(0);
 334     fword("encode-int");
 335     push_str("reg");
 336     fword("property");
 337
 338     PUSH(0);
 339     PUSH(0);
 340     fword("encode-bytes");
 341     push_str("64-bit");
 342     fword("property");
 343
 344     fword("finish-device");
 345
 346 #ifdef CONFIG_PPC_64BITSUPPORT
 347     /* The 970 is a PPC64 CPU, so we need to activate
 348      * 64bit aware interrupt handlers */
 349
 350     ppc64_patch_handlers();
 351 #endif
 352
 353     /* The 970 also implements the HIOR which we need to set to 0 */
 354
 355     mtspr(S_HIOR, 0);
 356 }
 357
 358 static const struct cpudef ppc_defs[] = {
 359     {
 360         .iu_version = 0x00040000,
 361         .name = "PowerPC,604",
 362         .icache_size = 0x4000,
 363         .dcache_size = 0x4000,
 364         .icache_sets = 0x80,
 365         .dcache_sets = 0x80,
 366         .icache_block_size = 0x20,
 367         .dcache_block_size = 0x20,
 368         .clock_frequency = 0x07de2900,
 369         .initfn = cpu_604_init,
 370     },
 371     { // XXX find out real values
 372         .iu_version = 0x00090000,
 373         .name = "PowerPC,604e",
 374         .icache_size = 0x4000,
 375         .dcache_size = 0x4000,
 376         .icache_sets = 0x80,
 377         .dcache_sets = 0x80,
 378         .icache_block_size = 0x20,
 379         .dcache_block_size = 0x20,
 380         .clock_frequency = 0x07de2900,
 381         .initfn = cpu_604_init,
 382     },
 383     { // XXX find out real values
 384         .iu_version = 0x000a0000,
 385         .name = "PowerPC,604r",
 386         .icache_size = 0x4000,
 387         .dcache_size = 0x4000,
 388         .icache_sets = 0x80,
 389         .dcache_sets = 0x80,
 390         .icache_block_size = 0x20,
 391         .dcache_block_size = 0x20,
 392         .clock_frequency = 0x07de2900,
 393         .initfn = cpu_604_init,
 394     },
 395     { // XXX find out real values
 396         .iu_version = 0x80040000,
 397         .name = "PowerPC,MPC86xx",
 398         .icache_size = 0x8000,
 399         .dcache_size = 0x8000,
 400         .icache_sets = 0x80,
 401         .dcache_sets = 0x80,
 402         .icache_block_size = 0x20,
 403         .dcache_block_size = 0x20,
 404         .clock_frequency = 0x14dc9380,
 405         .initfn = cpu_750_init,
 406     },
 407     {
 408         .iu_version = 0x000080000,
 409         .name = "PowerPC,750",
 410         .icache_size = 0x8000,
 411         .dcache_size = 0x8000,
 412         .icache_sets = 0x80,
 413         .dcache_sets = 0x80,
 414         .icache_block_size = 0x20,
 415         .dcache_block_size = 0x20,
 416         .clock_frequency = 0x14dc9380,
 417         .initfn = cpu_750_init,
 418     },
 419     { // XXX find out real values
 420         .iu_version = 0x10080000,
 421         .name = "PowerPC,750",
 422         .icache_size = 0x8000,
 423         .dcache_size = 0x8000,
 424         .icache_sets = 0x80,
 425         .dcache_sets = 0x80,
 426         .icache_block_size = 0x20,
 427         .dcache_block_size = 0x20,
 428         .clock_frequency = 0x14dc9380,
 429         .initfn = cpu_750_init,
 430     },
 431     { // XXX find out real values
 432         .iu_version = 0x70000000,
 433         .name = "PowerPC,750",
 434         .icache_size = 0x8000,
 435         .dcache_size = 0x8000,
 436         .icache_sets = 0x80,
 437         .dcache_sets = 0x80,
 438         .icache_block_size = 0x20,
 439         .dcache_block_size = 0x20,
 440         .clock_frequency = 0x14dc9380,
 441         .initfn = cpu_750_init,
 442     },
 443     { // XXX find out real values
 444         .iu_version = 0x70020000,
 445         .name = "PowerPC,750",
 446         .icache_size = 0x8000,
 447         .dcache_size = 0x8000,
 448         .icache_sets = 0x80,
 449         .dcache_sets = 0x80,
 450         .icache_block_size = 0x20,
 451         .dcache_block_size = 0x20,
 452         .clock_frequency = 0x14dc9380,
 453         .initfn = cpu_750_init,
 454     },
 455     { // XXX find out real values
 456         .iu_version = 0x800c0000,
 457         .name = "PowerPC,74xx",
 458         .icache_size = 0x8000,
 459         .dcache_size = 0x8000,
 460         .icache_sets = 0x80,
 461         .dcache_sets = 0x80,
 462         .icache_block_size = 0x20,
 463         .dcache_block_size = 0x20,
 464         .clock_frequency = 0x14dc9380,
 465         .initfn = cpu_750_init,
 466     },
 467     {
 468         .iu_version = 0x0000c0000,
 469         .name = "PowerPC,G4",
 470         .icache_size = 0x8000,
 471         .dcache_size = 0x8000,
 472         .icache_sets = 0x80,
 473         .dcache_sets = 0x80,
 474         .icache_block_size = 0x20,
 475         .dcache_block_size = 0x20,
 476         .clock_frequency = 0x1dcd6500,
 477         .initfn = cpu_g4_init,
 478     },
 479     {
 480         .iu_version = 0x00390000,
 481         .name = "PowerPC,970",
 482         .icache_size = 0x10000,
 483         .dcache_size = 0x8000,
 484         .icache_sets = 0x200,
 485         .dcache_sets = 0x80,
 486         .icache_block_size = 0x80,
 487         .dcache_block_size = 0x80,
 488         .clock_frequency = 0x5f5e1000,
 489         .initfn = cpu_970_init,
 490     },
 491     { // XXX find out real values
 492         .iu_version = 0x003C0000,
 493         .name = "PowerPC,970FX",
 494         .icache_size = 0x10000,
 495         .dcache_size = 0x8000,
 496         .icache_sets = 0x80,
 497         .dcache_sets = 0x80,
 498         .icache_block_size = 0x80,
 499         .dcache_block_size = 0x80,
 500         .clock_frequency = 0x1dcd6500,
 501         .initfn = cpu_970_init,
 502     },
 503 };
 504
 505 static const struct cpudef *
 506 id_cpu(void)
 507 {
 508     unsigned long iu_version;
 509     unsigned int i;
 510
 511     asm("mfpvr %0\n"
 512         : "=r"(iu_version) :);
 513     iu_version &= 0xffff0000;
 514
 515     for (i = 0; i < sizeof(ppc_defs)/sizeof(struct cpudef); i++) {
 516         if (iu_version == ppc_defs[i].iu_version)
 517             return &ppc_defs[i];
 518     }
 519     printk("Unknown cpu (pvr %lx), freezing!\n", iu_version);
 520     for (;;);
 521 }
 522
 523 static void go( void );
 524
 525 static void
 526 go( void )
 527 {
 528     ucell addr;
 529
 530     feval("saved-program-state >sps.entry @");
 531     addr = POP();
 532
 533     call_elf( 0, 0, addr);
 534 }
 535
 536 static void kvm_of_init(void)
 537 {
 538         char hypercall[4 * 4];
 539         uint32_t *hc32;
 540
 541         /* Don't expose /hypervisor when not in KVM */
 542         if (!fw_cfg_read_i32(FW_CFG_PPC_IS_KVM))
 543                 return;
 544
 545         push_str("/");
 546         fword("find-device");
 547
 548         fword("new-device");
 549
 550         push_str("hypervisor");
 551         fword("device-name");
 552
 553         push_str("hypervisor");
 554         fword("device-type");
 555
 556         /* compatible */
 557
 558         push_str("linux,kvm");
 559         fword("encode-string");
 560         push_str("epapr,hypervisor-0.2");
 561         fword("encode-string");
 562         fword("encode+");
 563         push_str("compatible");
 564         fword("property");
 565
 566         /* Tell the guest about the hypercall instructions */
 567         fw_cfg_read(FW_CFG_PPC_KVM_HC, hypercall, 4 * 4);
 568         hc32 = (uint32_t*)hypercall;
 569         PUSH(hc32[0]);
 570         fword("encode-int");
 571         PUSH(hc32[1]);
 572         fword("encode-int");
 573         fword("encode+");
 574         PUSH(hc32[2]);
 575         fword("encode-int");
 576         fword("encode+");
 577         PUSH(hc32[3]);
 578         fword("encode-int");
 579         fword("encode+");
 580         push_str("hcall-instructions");
 581         fword("property");
 582
 583         /* ePAPR requires us to provide a unique guest id */
 584         PUSH(fw_cfg_read_i32(FW_CFG_PPC_KVM_PID));
 585         fword("encode-int");
 586         push_str("guest-id");
 587         fword("property");
 588
 589         /* ePAPR requires us to provide a guest name */
 590         push_str("KVM guest");
 591         fword("encode-string");
 592         push_str("guest-name");
 593         fword("property");
 594
 595         fword("finish-device");
 596 }
 597
 598 void
 599 arch_of_init( void )
 600 {
 601 #ifdef CONFIG_RTAS
 602         phandle_t ph;
 603 #endif
 604         uint64_t ram_size;
 605         const struct cpudef *cpu;
 606         char buf[64], qemu_uuid[16];
 607         const char *stdin_path, *stdout_path, *boot_path;
 608         uint32_t temp = 0;
 609
 610     ofmem_t *ofmem = ofmem_arch_get_private();
 611
 612         openbios_init();
 613         modules_init();
 614         setup_timers();
 615 #ifdef CONFIG_DRIVER_PCI
 616         ob_pci_init();
 617 #endif
 618
 619         printk("\n");
 620         printk("=============================================================\n");
 621         printk(PROGRAM_NAME " " OPENBIOS_VERSION_STR " [%s]\n",
 622                OPENBIOS_BUILD_DATE);
 623
 624         fw_cfg_read(FW_CFG_SIGNATURE, buf, 4);
 625         buf[4] = '\0';
 626         printk("Configuration device id %s", buf);
 627
 628         temp = fw_cfg_read_i32(FW_CFG_ID);
 629         printk(" version %d machine id %d\n", temp, machine_id);
 630
 631         temp = fw_cfg_read_i32(FW_CFG_NB_CPUS);
 632
 633         printk("CPUs: %x\n", temp);
 634
 635         ram_size = ofmem->ramsize;
 636
 637         printk("Memory: %lldM\n", ram_size / 1024 / 1024);
 638
 639         fw_cfg_read(FW_CFG_UUID, qemu_uuid, 16);
 640
 641         printk("UUID: " UUID_FMT "\n", qemu_uuid[0], qemu_uuid[1], qemu_uuid[2],
 642                qemu_uuid[3], qemu_uuid[4], qemu_uuid[5], qemu_uuid[6],
 643                qemu_uuid[7], qemu_uuid[8], qemu_uuid[9], qemu_uuid[10],
 644                qemu_uuid[11], qemu_uuid[12], qemu_uuid[13], qemu_uuid[14],
 645                qemu_uuid[15]);
 646
 647         /* set device tree root info */
 648
 649         push_str("/");
 650         fword("find-device");
 651
 652         switch(machine_id) {
 653         case ARCH_HEATHROW:     /* OldWorld */
 654
 655                 /* model */
 656
 657                 push_str("Power Macintosh");
 658                 fword("model");
 659
 660                 /* compatible */
 661
 662                 push_str("AAPL,PowerMac G3");
 663                 fword("encode-string");
 664                 push_str("MacRISC");
 665                 fword("encode-string");
 666                 fword("encode+");
 667                 push_str("compatible");
 668                 fword("property");
 669
 670                 /* misc */
 671
 672                 push_str("device-tree");
 673                 fword("encode-string");
 674                 push_str("AAPL,original-name");
 675                 fword("property");
 676
 677                 PUSH(0);
 678                 fword("encode-int");
 679                 push_str("AAPL,cpu-id");
 680                 fword("property");
 681
 682                 PUSH(66 * 1000 * 1000);
 683                 fword("encode-int");
 684                 push_str("clock-frequency");
 685                 fword("property");
 686                 break;
 687
 688         case ARCH_MAC99:
 689         case ARCH_MAC99_U3:
 690         case ARCH_PREP:
 691         default:
 692
 693                 /* model */
 694
 695                 push_str("PowerMac2,1");
 696                 fword("model");
 697
 698                 /* compatible */
 699
 700                 push_str("PowerMac2,1");
 701                 fword("encode-string");
 702                 push_str("MacRISC");
 703                 fword("encode-string");
 704                 fword("encode+");
 705                 push_str("Power Macintosh");
 706                 fword("encode-string");
 707                 fword("encode+");
 708                 push_str("compatible");
 709                 fword("property");
 710
 711                 /* misc */
 712
 713                 push_str("bootrom");
 714                 fword("device-type");
 715
 716                 PUSH(100 * 1000 * 1000);
 717                 fword("encode-int");
 718                 push_str("clock-frequency");
 719                 fword("property");
 720                 break;
 721         }
 722
 723         /* Perhaps we can store UUID here ? */
 724
 725         push_str("0000000000000");
 726         fword("encode-string");
 727         push_str("system-id");
 728         fword("property");
 729
 730         /* memory info */
 731
 732         push_str("/memory");
 733         fword("find-device");
 734
 735         /* all memory */
 736
 737         /* TODO Adjust this when #address-cells gets increased for ppc64. */
 738         PUSH(0);
 739         fword("encode-phys");
 740         /* This needs adjusting if #size-cells gets increased.
 741            Alternatively use multiple (address, size) tuples. */
 742         PUSH(ram_size & 0xffffffff);
 743         fword("encode-int");
 744         fword("encode+");
 745         push_str("reg");
 746         fword("property");
 747
 748         cpu = id_cpu();
 749         cpu->initfn(cpu);
 750         printk("CPU type %s\n", cpu->name);
 751
 752         snprintf(buf, sizeof(buf), "/cpus/%s", cpu->name);
 753         ofmem_register(find_dev("/memory"), find_dev(buf));
 754         node_methods_init(buf);
 755
 756 #ifdef CONFIG_RTAS
 757         /* OldWorld Macs don't have an /rtas node. */
 758         switch (machine_id) {
 759         case ARCH_MAC99:
 760         case ARCH_MAC99_U3:
 761                 if (!(ph = find_dev("/rtas"))) {
 762                         printk("Warning: No /rtas node\n");
 763                 } else {
 764                         unsigned long size = 0x1000;
 765                         while (size < (unsigned long)of_rtas_end - (unsigned long)of_rtas_start)
 766                                 size *= 2;
 767                         set_property(ph, "rtas-size", (char*)&size, sizeof(size));
 768                         set_int_property(ph, "rtas-version", is_apple() ? 0x41 : 1);
 769                 }
 770                 break;
 771         }
 772 #endif
 773
 774         if (fw_cfg_read_i16(FW_CFG_NOGRAPHIC)) {
 775                 if (CONFIG_SERIAL_PORT) {
 776                        stdin_path = "scca";
 777                        stdout_path = "scca";
 778                 } else {
 779                        stdin_path = "sccb";
 780                        stdout_path = "sccb";
 781                 }
 782
 783                 /* Some bootloaders force the output to the screen device, so
 784                    let's create a screen alias for the serial device too */
 785                 push_str("/aliases");
 786                 fword("find-device");
 787
 788                 push_str(stdout_path);
 789                 fword("pathres-resolve-aliases");
 790                 fword("encode-string");
 791                 push_str("screen");
 792                 fword("property");
 793         } else {
 794                 stdin_path = "adb-keyboard";
 795                 stdout_path = "screen";
 796         }
 797
 798         kvm_of_init();
 799
 800         /* Setup nvram variables */
 801         push_str("/options");
 802         fword("find-device");
 803
 804         uint16_t boot_device = fw_cfg_read_i16(FW_CFG_BOOT_DEVICE);
 805         switch (boot_device) {
 806                 case 'c':
 807                         boot_path = "hd";
 808                         break;
 809                 default:
 810                 case 'd':
 811                         boot_path = "cd";
 812                         break;
 813         }
 814
 815         /* Setup default boot devices */
 816         snprintf(buf, sizeof(buf), "%s:,\\\\:tbxi %s:,\\ppc\\bootinfo.txt", boot_path, boot_path);
 817         push_str(buf);
 818         fword("encode-string");
 819         push_str("boot-device");
 820         fword("property");
 821
 822         /* Set up other properties */
 823         push_str("/chosen");
 824         fword("find-device");
 825
 826         push_str(stdin_path);
 827         fword("open-dev");
 828         fword("encode-int");
 829         push_str("stdin");
 830         fword("property");
 831
 832         push_str(stdout_path);
 833         fword("open-dev");
 834         fword("encode-int");
 835         push_str("stdout");
 836         fword("property");
 837
 838         push_str(stdin_path);
 839         fword("pathres-resolve-aliases");
 840         push_str("input-device");
 841         fword("$setenv");
 842
 843         push_str(stdout_path);
 844         fword("pathres-resolve-aliases");
 845         push_str("output-device");
 846         fword("$setenv");
 847
 848         push_str(stdin_path);
 849         fword("input");
 850
 851         push_str(stdout_path);
 852         fword("output");
 853
 854 #if 0
 855         if( getbool("tty-interface?") == 1 )
 856 #endif
 857                 fword("activate-tty-interface");
 858
 859         device_end();
 860
 861         bind_func("platform-boot", boot );
 862         bind_func("(go)", go);
 863 }