sys/powerpc/ofw/ofw_machdep.c

   1 /*-
   2  * Copyright (C) 1996 Wolfgang Solfrank.
   3  * Copyright (C) 1996 TooLs GmbH.
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  * 3. All advertising materials mentioning features or use of this software
  15  *    must display the following acknowledgement:
  16  *      This product includes software developed by TooLs GmbH.
  17  * 4. The name of TooLs GmbH may not be used to endorse or promote products
  18  *    derived from this software without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR
  21  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  22  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  23  * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  25  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  26  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  27  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  28  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  29  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30  *
  31  * $NetBSD: ofw_machdep.c,v 1.5 2000/05/23 13:25:43 tsubai Exp $
  32  */
  33
  34 #include <sys/cdefs.h>
  35 __FBSDID("$FreeBSD$");
  36
  37 #include "opt_platform.h"
  38 #include <sys/param.h>
  39 #include <sys/bus.h>
  40 #include <sys/systm.h>
  41 #include <sys/conf.h>
  42 #include <sys/disk.h>
  43 #include <sys/fcntl.h>
  44 #include <sys/malloc.h>
  45 #include <sys/smp.h>
  46 #include <sys/stat.h>
  47 #include <sys/endian.h>
  48
  49 #include <net/ethernet.h>
  50
  51 #include <dev/fdt/fdt_common.h>
  52 #include <dev/ofw/openfirm.h>
  53 #include <dev/ofw/ofw_pci.h>
  54 #include <dev/ofw/ofw_bus.h>
  55 #include <dev/ofw/ofw_subr.h>
  56
  57 #include <vm/vm.h>
  58 #include <vm/vm_param.h>
  59 #include <vm/vm_page.h>
  60
  61 #include <machine/bus.h>
  62 #include <machine/cpu.h>
  63 #include <machine/md_var.h>
  64 #include <machine/platform.h>
  65 #include <machine/ofw_machdep.h>
  66 #include <machine/trap.h>
  67
  68 static void     *fdt;
  69 int             ofw_real_mode;
  70
  71 #ifdef AIM
  72 extern register_t ofmsr[5];
  73 extern void     *openfirmware_entry;
  74 char            save_trap_init[0x2f00];          /* EXC_LAST */
  75 char            save_trap_of[0x2f00];            /* EXC_LAST */
  76
  77 int             ofwcall(void *);
  78 static int      openfirmware(void *args);
  79
  80 __inline void
  81 ofw_save_trap_vec(char *save_trap_vec)
  82 {
  83         if (!ofw_real_mode)
  84                 return;
  85
  86         bcopy((void *)EXC_RST, save_trap_vec, EXC_LAST - EXC_RST);
  87 }
  88
  89 static __inline void
  90 ofw_restore_trap_vec(char *restore_trap_vec)
  91 {
  92         if (!ofw_real_mode)
  93                 return;
  94
  95         bcopy(restore_trap_vec, (void *)EXC_RST, EXC_LAST - EXC_RST);
  96         __syncicache(EXC_RSVD, EXC_LAST - EXC_RSVD);
  97 }
  98
  99 /*
 100  * Saved SPRG0-3 from OpenFirmware. Will be restored prior to the callback.
 101  */
 102 register_t      ofw_sprg0_save;
 103
 104 static __inline void
 105 ofw_sprg_prepare(void)
 106 {
 107         if (ofw_real_mode)
 108                 return;
 109
 110         /*
 111          * Assume that interrupt are disabled at this point, or
 112          * SPRG1-3 could be trashed
 113          */
 114 #ifdef __powerpc64__
 115         __asm __volatile("mtsprg1 %0\n\t"
 116                          "mtsprg2 %1\n\t"
 117                          "mtsprg3 %2\n\t"
 118                          :
 119                          : "r"(ofmsr[2]),
 120                          "r"(ofmsr[3]),
 121                          "r"(ofmsr[4]));
 122 #else
 123         __asm __volatile("mfsprg0 %0\n\t"
 124                          "mtsprg0 %1\n\t"
 125                          "mtsprg1 %2\n\t"
 126                          "mtsprg2 %3\n\t"
 127                          "mtsprg3 %4\n\t"
 128                          : "=&r"(ofw_sprg0_save)
 129                          : "r"(ofmsr[1]),
 130                          "r"(ofmsr[2]),
 131                          "r"(ofmsr[3]),
 132                          "r"(ofmsr[4]));
 133 #endif
 134 }
 135
 136 static __inline void
 137 ofw_sprg_restore(void)
 138 {
 139         if (ofw_real_mode)
 140                 return;
 141
 142         /*
 143          * Note that SPRG1-3 contents are irrelevant. They are scratch
 144          * registers used in the early portion of trap handling when
 145          * interrupts are disabled.
 146          *
 147          * PCPU data cannot be used until this routine is called !
 148          */
 149 #ifndef __powerpc64__
 150         __asm __volatile("mtsprg0 %0" :: "r"(ofw_sprg0_save));
 151 #endif
 152 }
 153 #endif
 154
 155 static int
 156 parse_ofw_memory(phandle_t node, const char *prop, struct mem_region *output)
 157 {
 158         cell_t address_cells, size_cells;
 159         cell_t OFmem[4 * PHYS_AVAIL_SZ];
 160         int sz, i, j;
 161         phandle_t phandle;
 162
 163         sz = 0;
 164
 165         /*
 166          * Get #address-cells from root node, defaulting to 1 if it cannot
 167          * be found.
 168          */
 169         phandle = OF_finddevice("/");
 170         if (OF_getencprop(phandle, "#address-cells", &address_cells,
 171             sizeof(address_cells)) < (ssize_t)sizeof(address_cells))
 172                 address_cells = 1;
 173         if (OF_getencprop(phandle, "#size-cells", &size_cells,
 174             sizeof(size_cells)) < (ssize_t)sizeof(size_cells))
 175                 size_cells = 1;
 176
 177         /*
 178          * Get memory.
 179          */
 180         if (node == -1 || (sz = OF_getencprop(node, prop,
 181             OFmem, sizeof(OFmem))) <= 0)
 182                 panic("Physical memory map not found");
 183
 184         i = 0;
 185         j = 0;
 186         while (i < sz/sizeof(cell_t)) {
 187               #if !defined(__powerpc64__) && !defined(BOOKE)
 188                 /* On 32-bit PPC (OEA), ignore regions starting above 4 GB */
 189                 if (address_cells > 1 && OFmem[i] > 0) {
 190                         i += address_cells + size_cells;
 191                         continue;
 192                 }
 193               #endif
 194
 195                 output[j].mr_start = OFmem[i++];
 196                 if (address_cells == 2) {
 197                         output[j].mr_start <<= 32;
 198                         output[j].mr_start += OFmem[i++];
 199                 }
 200
 201                 output[j].mr_size = OFmem[i++];
 202                 if (size_cells == 2) {
 203                         output[j].mr_size <<= 32;
 204                         output[j].mr_size += OFmem[i++];
 205                 }
 206
 207               #if !defined(__powerpc64__) && !defined(BOOKE)
 208                 /* Book-E can support 36-bit addresses. */
 209                 /*
 210                  * Check for memory regions extending above 32-bit
 211                  * memory space, and restrict them to stay there.
 212                  */
 213                 if (((uint64_t)output[j].mr_start +
 214                     (uint64_t)output[j].mr_size) >
 215                     BUS_SPACE_MAXADDR_32BIT) {
 216                         output[j].mr_size = BUS_SPACE_MAXADDR_32BIT -
 217                             output[j].mr_start;
 218                 }
 219               #endif
 220
 221                 j++;
 222         }
 223         sz = j*sizeof(output[0]);
 224
 225         return (sz);
 226 }
 227
 228 static int
 229 excise_fdt_reserved(struct mem_region *avail, int asz)
 230 {
 231         struct {
 232                 uint64_t address;
 233                 uint64_t size;
 234         } fdtmap[16];
 235         ssize_t fdtmapsize;
 236         phandle_t chosen;
 237         int i, j, k;
 238
 239         chosen = OF_finddevice("/chosen");
 240         fdtmapsize = OF_getprop(chosen, "fdtmemreserv", fdtmap, sizeof(fdtmap));
 241
 242         for (j = 0; j < fdtmapsize/sizeof(fdtmap[0]); j++) {
 243                 fdtmap[j].address = be64toh(fdtmap[j].address);
 244                 fdtmap[j].size = be64toh(fdtmap[j].size);
 245         }
 246
 247         for (i = 0; i < asz; i++) {
 248                 for (j = 0; j < fdtmapsize/sizeof(fdtmap[0]); j++) {
 249                         /*
 250                          * Case 1: Exclusion region encloses complete
 251                          * available entry. Drop it and move on.
 252                          */
 253                         if (fdtmap[j].address <= avail[i].mr_start &&
 254                             fdtmap[j].address + fdtmap[j].size >=
 255                             avail[i].mr_start + avail[i].mr_size) {
 256                                 for (k = i+1; k < asz; k++)
 257                                         avail[k-1] = avail[k];
 258                                 asz--;
 259                                 i--; /* Repeat some entries */
 260                                 continue;
 261                         }
 262
 263                         /*
 264                          * Case 2: Exclusion region starts in available entry.
 265                          * Trim it to where the entry begins and append
 266                          * a new available entry with the region after
 267                          * the excluded region, if any.
 268                          */
 269                         if (fdtmap[j].address >= avail[i].mr_start &&
 270                             fdtmap[j].address < avail[i].mr_start +
 271                             avail[i].mr_size) {
 272                                 if (fdtmap[j].address + fdtmap[j].size <
 273                                     avail[i].mr_start + avail[i].mr_size) {
 274                                         avail[asz].mr_start =
 275                                             fdtmap[j].address + fdtmap[j].size;
 276                                         avail[asz].mr_size = avail[i].mr_start +
 277                                              avail[i].mr_size -
 278                                              avail[asz].mr_start;
 279                                         asz++;
 280                                 }
 281
 282                                 avail[i].mr_size = fdtmap[j].address -
 283                                     avail[i].mr_start;
 284                         }
 285
 286                         /*
 287                          * Case 3: Exclusion region ends in available entry.
 288                          * Move start point to where the exclusion zone ends.
 289                          * The case of a contained exclusion zone has already
 290                          * been caught in case 2.
 291                          */
 292                         if (fdtmap[j].address + fdtmap[j].size >=
 293                             avail[i].mr_start && fdtmap[j].address +
 294                             fdtmap[j].size < avail[i].mr_start +
 295                             avail[i].mr_size) {
 296                                 avail[i].mr_size += avail[i].mr_start;
 297                                 avail[i].mr_start =
 298                                     fdtmap[j].address + fdtmap[j].size;
 299                                 avail[i].mr_size -= avail[i].mr_start;
 300                         }
 301                 }
 302         }
 303
 304         return (asz);
 305 }
 306
 307 /*
 308  * This is called during powerpc_init, before the system is really initialized.
 309  * It shall provide the total and the available regions of RAM.
 310  * The available regions need not take the kernel into account.
 311  */
 312 void
 313 ofw_mem_regions(struct mem_region *memp, int *memsz,
 314                 struct mem_region *availp, int *availsz)
 315 {
 316         phandle_t phandle;
 317         int asz, msz;
 318         int res;
 319         char name[31];
 320
 321         asz = msz = 0;
 322
 323         /*
 324          * Get memory from all the /memory nodes.
 325          */
 326         for (phandle = OF_child(OF_peer(0)); phandle != 0;
 327             phandle = OF_peer(phandle)) {
 328                 if (OF_getprop(phandle, "name", name, sizeof(name)) <= 0)
 329                         continue;
 330                 if (strncmp(name, "memory", sizeof(name)) != 0 &&
 331                     strncmp(name, "memory@", strlen("memory@")) != 0)
 332                         continue;
 333
 334                 res = parse_ofw_memory(phandle, "reg", &memp[msz]);
 335                 msz += res/sizeof(struct mem_region);
 336                 if (OF_getproplen(phandle, "available") >= 0)
 337                         res = parse_ofw_memory(phandle, "available",
 338                             &availp[asz]);
 339                 else
 340                         res = parse_ofw_memory(phandle, "reg", &availp[asz]);
 341                 asz += res/sizeof(struct mem_region);
 342         }
 343
 344         phandle = OF_finddevice("/chosen");
 345         if (OF_hasprop(phandle, "fdtmemreserv"))
 346                 asz = excise_fdt_reserved(availp, asz);
 347
 348         *memsz = msz;
 349         *availsz = asz;
 350 }
 351
 352 void
 353 OF_initial_setup(void *fdt_ptr, void *junk, int (*openfirm)(void *))
 354 {
 355 #ifdef AIM
 356         ofmsr[0] = mfmsr();
 357         #ifdef __powerpc64__
 358         ofmsr[0] &= ~PSL_SF;
 359         #else
 360         __asm __volatile("mfsprg0 %0" : "=&r"(ofmsr[1]));
 361         #endif
 362         __asm __volatile("mfsprg1 %0" : "=&r"(ofmsr[2]));
 363         __asm __volatile("mfsprg2 %0" : "=&r"(ofmsr[3]));
 364         __asm __volatile("mfsprg3 %0" : "=&r"(ofmsr[4]));
 365         openfirmware_entry = openfirm;
 366
 367         if (ofmsr[0] & PSL_DR)
 368                 ofw_real_mode = 0;
 369         else
 370                 ofw_real_mode = 1;
 371
 372         ofw_save_trap_vec(save_trap_init);
 373 #else
 374         ofw_real_mode = 1;
 375 #endif
 376
 377         fdt = fdt_ptr;
 378
 379         #ifdef FDT_DTB_STATIC
 380         /* Check for a statically included blob */
 381         if (fdt == NULL)
 382                 fdt = &fdt_static_dtb;
 383         #endif
 384 }
 385
 386 boolean_t
 387 OF_bootstrap()
 388 {
 389         boolean_t status = FALSE;
 390
 391 #ifdef AIM
 392         if (openfirmware_entry != NULL) {
 393                 if (ofw_real_mode) {
 394                         status = OF_install(OFW_STD_REAL, 0);
 395                 } else {
 396                         #ifdef __powerpc64__
 397                         status = OF_install(OFW_STD_32BIT, 0);
 398                         #else
 399                         status = OF_install(OFW_STD_DIRECT, 0);
 400                         #endif
 401                 }
 402
 403                 if (status != TRUE)
 404                         return status;
 405
 406                 OF_init(openfirmware);
 407         } else
 408 #endif
 409         if (fdt != NULL) {
 410                 status = OF_install(OFW_FDT, 0);
 411
 412                 if (status != TRUE)
 413                         return status;
 414
 415                 OF_init(fdt);
 416                 OF_interpret("perform-fixup", 0);
 417         }
 418
 419         return (status);
 420 }
 421
 422 #ifdef AIM
 423 void
 424 ofw_quiesce(void)
 425 {
 426         struct {
 427                 cell_t name;
 428                 cell_t nargs;
 429                 cell_t nreturns;
 430         } args;
 431
 432         KASSERT(!pmap_bootstrapped, ("Cannot call ofw_quiesce after VM is up"));
 433
 434         args.name = (cell_t)(uintptr_t)"quiesce";
 435         args.nargs = 0;
 436         args.nreturns = 0;
 437         openfirmware(&args);
 438 }
 439
 440 static int
 441 openfirmware_core(void *args)
 442 {
 443         int             result;
 444         register_t      oldmsr;
 445
 446         if (openfirmware_entry == NULL)
 447                 return (-1);
 448
 449         /*
 450          * Turn off exceptions - we really don't want to end up
 451          * anywhere unexpected with PCPU set to something strange
 452          * or the stack pointer wrong.
 453          */
 454         oldmsr = intr_disable();
 455
 456         ofw_sprg_prepare();
 457
 458         /* Save trap vectors */
 459         ofw_save_trap_vec(save_trap_of);
 460
 461         /* Restore initially saved trap vectors */
 462         ofw_restore_trap_vec(save_trap_init);
 463
 464 #if defined(AIM) && !defined(__powerpc64__)
 465         /*
 466          * Clear battable[] translations
 467          */
 468         if (!(cpu_features & PPC_FEATURE_64))
 469                 __asm __volatile("mtdbatu 2, %0\n"
 470                                  "mtdbatu 3, %0" : : "r" (0));
 471         isync();
 472 #endif
 473
 474         result = ofwcall(args);
 475
 476         /* Restore trap vecotrs */
 477         ofw_restore_trap_vec(save_trap_of);
 478
 479         ofw_sprg_restore();
 480
 481         intr_restore(oldmsr);
 482
 483         return (result);
 484 }
 485
 486 #ifdef SMP
 487 struct ofw_rv_args {
 488         void *args;
 489         int retval;
 490         volatile int in_progress;
 491 };
 492
 493 static void
 494 ofw_rendezvous_dispatch(void *xargs)
 495 {
 496         struct ofw_rv_args *rv_args = xargs;
 497
 498         /* NOTE: Interrupts are disabled here */
 499
 500         if (PCPU_GET(cpuid) == 0) {
 501                 /*
 502                  * Execute all OF calls on CPU 0
 503                  */
 504                 rv_args->retval = openfirmware_core(rv_args->args);
 505                 rv_args->in_progress = 0;
 506         } else {
 507                 /*
 508                  * Spin with interrupts off on other CPUs while OF has
 509                  * control of the machine.
 510                  */
 511                 while (rv_args->in_progress)
 512                         cpu_spinwait();
 513         }
 514 }
 515 #endif
 516
 517 static int
 518 openfirmware(void *args)
 519 {
 520         int result;
 521         #ifdef SMP
 522         struct ofw_rv_args rv_args;
 523         #endif
 524
 525         if (openfirmware_entry == NULL)
 526                 return (-1);
 527
 528         #ifdef SMP
 529         rv_args.args = args;
 530         rv_args.in_progress = 1;
 531         smp_rendezvous(smp_no_rendezvous_barrier, ofw_rendezvous_dispatch,
 532             smp_no_rendezvous_barrier, &rv_args);
 533         result = rv_args.retval;
 534         #else
 535         result = openfirmware_core(args);
 536         #endif
 537
 538         return (result);
 539 }
 540
 541 void
 542 OF_reboot()
 543 {
 544         struct {
 545                 cell_t name;
 546                 cell_t nargs;
 547                 cell_t nreturns;
 548                 cell_t arg;
 549         } args;
 550
 551         args.name = (cell_t)(uintptr_t)"interpret";
 552         args.nargs = 1;
 553         args.nreturns = 0;
 554         args.arg = (cell_t)(uintptr_t)"reset-all";
 555         openfirmware_core(&args); /* Don't do rendezvous! */
 556
 557         for (;;);       /* just in case */
 558 }
 559
 560 #endif /* AIM */
 561
 562 void
 563 OF_getetheraddr(device_t dev, u_char *addr)
 564 {
 565         phandle_t       node;
 566
 567         node = ofw_bus_get_node(dev);
 568         OF_getprop(node, "local-mac-address", addr, ETHER_ADDR_LEN);
 569 }
 570
 571 /*
 572  * Return a bus handle and bus tag that corresponds to the register
 573  * numbered regno for the device referenced by the package handle
 574  * dev. This function is intended to be used by console drivers in
 575  * early boot only. It works by mapping the address of the device's
 576  * register in the address space of its parent and recursively walk
 577  * the device tree upward this way.
 578  */
 579 int
 580 OF_decode_addr(phandle_t dev, int regno, bus_space_tag_t *tag,
 581     bus_space_handle_t *handle, bus_size_t *sz)
 582 {
 583         bus_addr_t addr;
 584         bus_size_t size;
 585         pcell_t pci_hi;
 586         int flags, res;
 587
 588         res = ofw_reg_to_paddr(dev, regno, &addr, &size, &pci_hi);
 589         if (res < 0)
 590                 return (res);
 591
 592         if (pci_hi == OFW_PADDR_NOT_PCI) {
 593                 *tag = &bs_be_tag;
 594                 flags = 0;
 595         } else {
 596                 *tag = &bs_le_tag;
 597                 flags = (pci_hi & OFW_PCI_PHYS_HI_PREFETCHABLE) ?
 598                     BUS_SPACE_MAP_PREFETCHABLE: 0;
 599         }
 600
 601         if (sz != NULL)
 602                 *sz = size;
 603
 604         return (bus_space_map(*tag, addr, size, flags, handle));
 605 }
 606