arch/sparc/kernel/prom_64.c

   1 /*
   2  * Procedures for creating, accessing and interpreting the device tree.
   3  *
   4  * Paul Mackerras       August 1996.
   5  * Copyright (C) 1996-2005 Paul Mackerras.
   6  *
   7  *  Adapted for 64bit PowerPC by Dave Engebretsen and Peter Bergner.
   8  *    {engebret|bergner}@us.ibm.com
   9  *
  10  *  Adapted for sparc64 by David S. Miller davem@davemloft.net
  11  *
  12  *      This program is free software; you can redistribute it and/or
  13  *      modify it under the terms of the GNU General Public License
  14  *      as published by the Free Software Foundation; either version
  15  *      2 of the License, or (at your option) any later version.
  16  */
  17
  18 #include <linux/memblock.h>
  19 #include <linux/kernel.h>
  20 #include <linux/string.h>
  21 #include <linux/types.h>
  22 #include <linux/cpu.h>
  23 #include <linux/mm.h>
  24 #include <linux/of.h>
  25
  26 #include <asm/prom.h>
  27 #include <asm/oplib.h>
  28 #include <asm/irq.h>
  29 #include <asm/asi.h>
  30 #include <asm/upa.h>
  31 #include <asm/smp.h>
  32
  33 #include "prom.h"
  34
  35 void * __init prom_early_alloc(unsigned long size)
  36 {
  37         unsigned long paddr = memblock_alloc(size, SMP_CACHE_BYTES);
  38         void *ret;
  39
  40         if (!paddr) {
  41                 prom_printf("prom_early_alloc(%lu) failed\n", size);
  42                 prom_halt();
  43         }
  44
  45         ret = __va(paddr);
  46         memset(ret, 0, size);
  47         prom_early_allocated += size;
  48
  49         return ret;
  50 }
  51
  52 /* The following routines deal with the black magic of fully naming a
  53  * node.
  54  *
  55  * Certain well known named nodes are just the simple name string.
  56  *
  57  * Actual devices have an address specifier appended to the base name
  58  * string, like this "foo@addr".  The "addr" can be in any number of
  59  * formats, and the platform plus the type of the node determine the
  60  * format and how it is constructed.
  61  *
  62  * For children of the ROOT node, the naming convention is fixed and
  63  * determined by whether this is a sun4u or sun4v system.
  64  *
  65  * For children of other nodes, it is bus type specific.  So
  66  * we walk up the tree until we discover a "device_type" property
  67  * we recognize and we go from there.
  68  *
  69  * As an example, the boot device on my workstation has a full path:
  70  *
  71  *      /pci@1e,600000/ide@d/disk@0,0:c
  72  */
  73 static void __init sun4v_path_component(struct device_node *dp, char *tmp_buf)
  74 {
  75         struct linux_prom64_registers *regs;
  76         struct property *rprop;
  77         u32 high_bits, low_bits, type;
  78
  79         rprop = of_find_property(dp, "reg", NULL);
  80         if (!rprop)
  81                 return;
  82
  83         regs = rprop->value;
  84         if (!of_node_is_root(dp->parent)) {
  85                 sprintf(tmp_buf, "%s@%x,%x",
  86                         dp->name,
  87                         (unsigned int) (regs->phys_addr >> 32UL),
  88                         (unsigned int) (regs->phys_addr & 0xffffffffUL));
  89                 return;
  90         }
  91
  92         type = regs->phys_addr >> 60UL;
  93         high_bits = (regs->phys_addr >> 32UL) & 0x0fffffffUL;
  94         low_bits = (regs->phys_addr & 0xffffffffUL);
  95
  96         if (type == 0 || type == 8) {
  97                 const char *prefix = (type == 0) ? "m" : "i";
  98
  99                 if (low_bits)
 100                         sprintf(tmp_buf, "%s@%s%x,%x",
 101                                 dp->name, prefix,
 102                                 high_bits, low_bits);
 103                 else
 104                         sprintf(tmp_buf, "%s@%s%x",
 105                                 dp->name,
 106                                 prefix,
 107                                 high_bits);
 108         } else if (type == 12) {
 109                 sprintf(tmp_buf, "%s@%x",
 110                         dp->name, high_bits);
 111         }
 112 }
 113
 114 static void __init sun4u_path_component(struct device_node *dp, char *tmp_buf)
 115 {
 116         struct linux_prom64_registers *regs;
 117         struct property *prop;
 118
 119         prop = of_find_property(dp, "reg", NULL);
 120         if (!prop)
 121                 return;
 122
 123         regs = prop->value;
 124         if (!of_node_is_root(dp->parent)) {
 125                 sprintf(tmp_buf, "%s@%x,%x",
 126                         dp->name,
 127                         (unsigned int) (regs->phys_addr >> 32UL),
 128                         (unsigned int) (regs->phys_addr & 0xffffffffUL));
 129                 return;
 130         }
 131
 132         prop = of_find_property(dp, "upa-portid", NULL);
 133         if (!prop)
 134                 prop = of_find_property(dp, "portid", NULL);
 135         if (prop) {
 136                 unsigned long mask = 0xffffffffUL;
 137
 138                 if (tlb_type >= cheetah)
 139                         mask = 0x7fffff;
 140
 141                 sprintf(tmp_buf, "%s@%x,%x",
 142                         dp->name,
 143                         *(u32 *)prop->value,
 144                         (unsigned int) (regs->phys_addr & mask));
 145         }
 146 }
 147
 148 /* "name@slot,offset"  */
 149 static void __init sbus_path_component(struct device_node *dp, char *tmp_buf)
 150 {
 151         struct linux_prom_registers *regs;
 152         struct property *prop;
 153
 154         prop = of_find_property(dp, "reg", NULL);
 155         if (!prop)
 156                 return;
 157
 158         regs = prop->value;
 159         sprintf(tmp_buf, "%s@%x,%x",
 160                 dp->name,
 161                 regs->which_io,
 162                 regs->phys_addr);
 163 }
 164
 165 /* "name@devnum[,func]" */
 166 static void __init pci_path_component(struct device_node *dp, char *tmp_buf)
 167 {
 168         struct linux_prom_pci_registers *regs;
 169         struct property *prop;
 170         unsigned int devfn;
 171
 172         prop = of_find_property(dp, "reg", NULL);
 173         if (!prop)
 174                 return;
 175
 176         regs = prop->value;
 177         devfn = (regs->phys_hi >> 8) & 0xff;
 178         if (devfn & 0x07) {
 179                 sprintf(tmp_buf, "%s@%x,%x",
 180                         dp->name,
 181                         devfn >> 3,
 182                         devfn & 0x07);
 183         } else {
 184                 sprintf(tmp_buf, "%s@%x",
 185                         dp->name,
 186                         devfn >> 3);
 187         }
 188 }
 189
 190 /* "name@UPA_PORTID,offset" */
 191 static void __init upa_path_component(struct device_node *dp, char *tmp_buf)
 192 {
 193         struct linux_prom64_registers *regs;
 194         struct property *prop;
 195
 196         prop = of_find_property(dp, "reg", NULL);
 197         if (!prop)
 198                 return;
 199
 200         regs = prop->value;
 201
 202         prop = of_find_property(dp, "upa-portid", NULL);
 203         if (!prop)
 204                 return;
 205
 206         sprintf(tmp_buf, "%s@%x,%x",
 207                 dp->name,
 208                 *(u32 *) prop->value,
 209                 (unsigned int) (regs->phys_addr & 0xffffffffUL));
 210 }
 211
 212 /* "name@reg" */
 213 static void __init vdev_path_component(struct device_node *dp, char *tmp_buf)
 214 {
 215         struct property *prop;
 216         u32 *regs;
 217
 218         prop = of_find_property(dp, "reg", NULL);
 219         if (!prop)
 220                 return;
 221
 222         regs = prop->value;
 223
 224         sprintf(tmp_buf, "%s@%x", dp->name, *regs);
 225 }
 226
 227 /* "name@addrhi,addrlo" */
 228 static void __init ebus_path_component(struct device_node *dp, char *tmp_buf)
 229 {
 230         struct linux_prom64_registers *regs;
 231         struct property *prop;
 232
 233         prop = of_find_property(dp, "reg", NULL);
 234         if (!prop)
 235                 return;
 236
 237         regs = prop->value;
 238
 239         sprintf(tmp_buf, "%s@%x,%x",
 240                 dp->name,
 241                 (unsigned int) (regs->phys_addr >> 32UL),
 242                 (unsigned int) (regs->phys_addr & 0xffffffffUL));
 243 }
 244
 245 /* "name@bus,addr" */
 246 static void __init i2c_path_component(struct device_node *dp, char *tmp_buf)
 247 {
 248         struct property *prop;
 249         u32 *regs;
 250
 251         prop = of_find_property(dp, "reg", NULL);
 252         if (!prop)
 253                 return;
 254
 255         regs = prop->value;
 256
 257         /* This actually isn't right... should look at the #address-cells
 258          * property of the i2c bus node etc. etc.
 259          */
 260         sprintf(tmp_buf, "%s@%x,%x",
 261                 dp->name, regs[0], regs[1]);
 262 }
 263
 264 /* "name@reg0[,reg1]" */
 265 static void __init usb_path_component(struct device_node *dp, char *tmp_buf)
 266 {
 267         struct property *prop;
 268         u32 *regs;
 269
 270         prop = of_find_property(dp, "reg", NULL);
 271         if (!prop)
 272                 return;
 273
 274         regs = prop->value;
 275
 276         if (prop->length == sizeof(u32) || regs[1] == 1) {
 277                 sprintf(tmp_buf, "%s@%x",
 278                         dp->name, regs[0]);
 279         } else {
 280                 sprintf(tmp_buf, "%s@%x,%x",
 281                         dp->name, regs[0], regs[1]);
 282         }
 283 }
 284
 285 /* "name@reg0reg1[,reg2reg3]" */
 286 static void __init ieee1394_path_component(struct device_node *dp, char *tmp_buf)
 287 {
 288         struct property *prop;
 289         u32 *regs;
 290
 291         prop = of_find_property(dp, "reg", NULL);
 292         if (!prop)
 293                 return;
 294
 295         regs = prop->value;
 296
 297         if (regs[2] || regs[3]) {
 298                 sprintf(tmp_buf, "%s@%08x%08x,%04x%08x",
 299                         dp->name, regs[0], regs[1], regs[2], regs[3]);
 300         } else {
 301                 sprintf(tmp_buf, "%s@%08x%08x",
 302                         dp->name, regs[0], regs[1]);
 303         }
 304 }
 305
 306 static void __init __build_path_component(struct device_node *dp, char *tmp_buf)
 307 {
 308         struct device_node *parent = dp->parent;
 309
 310         if (parent != NULL) {
 311                 if (!strcmp(parent->type, "pci") ||
 312                     !strcmp(parent->type, "pciex")) {
 313                         pci_path_component(dp, tmp_buf);
 314                         return;
 315                 }
 316                 if (!strcmp(parent->type, "sbus")) {
 317                         sbus_path_component(dp, tmp_buf);
 318                         return;
 319                 }
 320                 if (!strcmp(parent->type, "upa")) {
 321                         upa_path_component(dp, tmp_buf);
 322                         return;
 323                 }
 324                 if (!strcmp(parent->type, "ebus")) {
 325                         ebus_path_component(dp, tmp_buf);
 326                         return;
 327                 }
 328                 if (!strcmp(parent->name, "usb") ||
 329                     !strcmp(parent->name, "hub")) {
 330                         usb_path_component(dp, tmp_buf);
 331                         return;
 332                 }
 333                 if (!strcmp(parent->type, "i2c")) {
 334                         i2c_path_component(dp, tmp_buf);
 335                         return;
 336                 }
 337                 if (!strcmp(parent->type, "firewire")) {
 338                         ieee1394_path_component(dp, tmp_buf);
 339                         return;
 340                 }
 341                 if (!strcmp(parent->type, "virtual-devices")) {
 342                         vdev_path_component(dp, tmp_buf);
 343                         return;
 344                 }
 345                 /* "isa" is handled with platform naming */
 346         }
 347
 348         /* Use platform naming convention.  */
 349         if (tlb_type == hypervisor) {
 350                 sun4v_path_component(dp, tmp_buf);
 351                 return;
 352         } else {
 353                 sun4u_path_component(dp, tmp_buf);
 354         }
 355 }
 356
 357 char * __init build_path_component(struct device_node *dp)
 358 {
 359         char tmp_buf[64], *n;
 360
 361         tmp_buf[0] = '\0';
 362         __build_path_component(dp, tmp_buf);
 363         if (tmp_buf[0] == '\0')
 364                 strcpy(tmp_buf, dp->name);
 365
 366         n = prom_early_alloc(strlen(tmp_buf) + 1);
 367         strcpy(n, tmp_buf);
 368
 369         return n;
 370 }
 371
 372 static const char *get_mid_prop(void)
 373 {
 374         return (tlb_type == spitfire ? "upa-portid" : "portid");
 375 }
 376
 377 bool arch_find_n_match_cpu_physical_id(struct device_node *cpun,
 378                                        int cpu, unsigned int *thread)
 379 {
 380         const char *mid_prop = get_mid_prop();
 381         int this_cpu_id;
 382
 383         /* On hypervisor based platforms we interrogate the 'reg'
 384          * property.  On everything else we look for a 'upa-portis',
 385          * 'portid', or 'cpuid' property.
 386          */
 387
 388         if (tlb_type == hypervisor) {
 389                 struct property *prop = of_find_property(cpun, "reg", NULL);
 390                 u32 *regs;
 391
 392                 if (!prop) {
 393                         pr_warn("CPU node missing reg property\n");
 394                         return false;
 395                 }
 396                 regs = prop->value;
 397                 this_cpu_id = regs[0] & 0x0fffffff;
 398         } else {
 399                 this_cpu_id = of_getintprop_default(cpun, mid_prop, -1);
 400
 401                 if (this_cpu_id < 0) {
 402                         mid_prop = "cpuid";
 403                         this_cpu_id = of_getintprop_default(cpun, mid_prop, -1);
 404                 }
 405                 if (this_cpu_id < 0) {
 406                         pr_warn("CPU node missing cpu ID property\n");
 407                         return false;
 408                 }
 409         }
 410         if (this_cpu_id == cpu) {
 411                 if (thread) {
 412                         int proc_id = cpu_data(cpu).proc_id;
 413
 414                         /* On sparc64, the cpu thread information is obtained
 415                          * either from OBP or the machine description.  We've
 416                          * actually probed this information already long before
 417                          * this interface gets called so instead of interrogating
 418                          * both the OF node and the MDESC again, just use what
 419                          * we discovered already.
 420                          */
 421                         if (proc_id < 0)
 422                                 proc_id = 0;
 423                         *thread = proc_id;
 424                 }
 425                 return true;
 426         }
 427         return false;
 428 }
 429
 430 static void *of_iterate_over_cpus(void *(*func)(struct device_node *, int, int), int arg)
 431 {
 432         struct device_node *dp;
 433         const char *mid_prop;
 434
 435         mid_prop = get_mid_prop();
 436         for_each_node_by_type(dp, "cpu") {
 437                 int cpuid = of_getintprop_default(dp, mid_prop, -1);
 438                 const char *this_mid_prop = mid_prop;
 439                 void *ret;
 440
 441                 if (cpuid < 0) {
 442                         this_mid_prop = "cpuid";
 443                         cpuid = of_getintprop_default(dp, this_mid_prop, -1);
 444                 }
 445                 if (cpuid < 0) {
 446                         prom_printf("OF: Serious problem, cpu lacks "
 447                                     "%s property", this_mid_prop);
 448                         prom_halt();
 449                 }
 450 #ifdef CONFIG_SMP
 451                 if (cpuid >= NR_CPUS) {
 452                         printk(KERN_WARNING "Ignoring CPU %d which is "
 453                                ">= NR_CPUS (%d)\n",
 454                                cpuid, NR_CPUS);
 455                         continue;
 456                 }
 457 #endif
 458                 ret = func(dp, cpuid, arg);
 459                 if (ret)
 460                         return ret;
 461         }
 462         return NULL;
 463 }
 464
 465 static void *check_cpu_node(struct device_node *dp, int cpuid, int id)
 466 {
 467         if (id == cpuid)
 468                 return dp;
 469         return NULL;
 470 }
 471
 472 struct device_node *of_find_node_by_cpuid(int cpuid)
 473 {
 474         return of_iterate_over_cpus(check_cpu_node, cpuid);
 475 }
 476
 477 static void *record_one_cpu(struct device_node *dp, int cpuid, int arg)
 478 {
 479         ncpus_probed++;
 480 #ifdef CONFIG_SMP
 481         set_cpu_present(cpuid, true);
 482         set_cpu_possible(cpuid, true);
 483 #endif
 484         return NULL;
 485 }
 486
 487 void __init of_populate_present_mask(void)
 488 {
 489         if (tlb_type == hypervisor)
 490                 return;
 491
 492         ncpus_probed = 0;
 493         of_iterate_over_cpus(record_one_cpu, 0);
 494 }
 495
 496 static void *fill_in_one_cpu(struct device_node *dp, int cpuid, int arg)
 497 {
 498         struct device_node *portid_parent = NULL;
 499         int portid = -1;
 500
 501         if (of_find_property(dp, "cpuid", NULL)) {
 502                 int limit = 2;
 503
 504                 portid_parent = dp;
 505                 while (limit--) {
 506                         portid_parent = portid_parent->parent;
 507                         if (!portid_parent)
 508                                 break;
 509                         portid = of_getintprop_default(portid_parent,
 510                                                        "portid", -1);
 511                         if (portid >= 0)
 512                                 break;
 513                 }
 514         }
 515
 516 #ifndef CONFIG_SMP
 517         /* On uniprocessor we only want the values for the
 518          * real physical cpu the kernel booted onto, however
 519          * cpu_data() only has one entry at index 0.
 520          */
 521         if (cpuid != real_hard_smp_processor_id())
 522                 return NULL;
 523         cpuid = 0;
 524 #endif
 525
 526         cpu_data(cpuid).clock_tick =
 527                 of_getintprop_default(dp, "clock-frequency", 0);
 528
 529         if (portid_parent) {
 530                 cpu_data(cpuid).dcache_size =
 531                         of_getintprop_default(dp, "l1-dcache-size",
 532                                               16 * 1024);
 533                 cpu_data(cpuid).dcache_line_size =
 534                         of_getintprop_default(dp, "l1-dcache-line-size",
 535                                               32);
 536                 cpu_data(cpuid).icache_size =
 537                         of_getintprop_default(dp, "l1-icache-size",
 538                                               8 * 1024);
 539                 cpu_data(cpuid).icache_line_size =
 540                         of_getintprop_default(dp, "l1-icache-line-size",
 541                                               32);
 542                 cpu_data(cpuid).ecache_size =
 543                         of_getintprop_default(dp, "l2-cache-size", 0);
 544                 cpu_data(cpuid).ecache_line_size =
 545                         of_getintprop_default(dp, "l2-cache-line-size", 0);
 546                 if (!cpu_data(cpuid).ecache_size ||
 547                     !cpu_data(cpuid).ecache_line_size) {
 548                         cpu_data(cpuid).ecache_size =
 549                                 of_getintprop_default(portid_parent,
 550                                                       "l2-cache-size",
 551                                                       (4 * 1024 * 1024));
 552                         cpu_data(cpuid).ecache_line_size =
 553                                 of_getintprop_default(portid_parent,
 554                                                       "l2-cache-line-size", 64);
 555                 }
 556
 557                 cpu_data(cpuid).core_id = portid + 1;
 558                 cpu_data(cpuid).proc_id = portid;
 559         } else {
 560                 cpu_data(cpuid).dcache_size =
 561                         of_getintprop_default(dp, "dcache-size", 16 * 1024);
 562                 cpu_data(cpuid).dcache_line_size =
 563                         of_getintprop_default(dp, "dcache-line-size", 32);
 564
 565                 cpu_data(cpuid).icache_size =
 566                         of_getintprop_default(dp, "icache-size", 16 * 1024);
 567                 cpu_data(cpuid).icache_line_size =
 568                         of_getintprop_default(dp, "icache-line-size", 32);
 569
 570                 cpu_data(cpuid).ecache_size =
 571                         of_getintprop_default(dp, "ecache-size",
 572                                               (4 * 1024 * 1024));
 573                 cpu_data(cpuid).ecache_line_size =
 574                         of_getintprop_default(dp, "ecache-line-size", 64);
 575
 576                 cpu_data(cpuid).core_id = 0;
 577                 cpu_data(cpuid).proc_id = -1;
 578         }
 579
 580         return NULL;
 581 }
 582
 583 void __init of_fill_in_cpu_data(void)
 584 {
 585         if (tlb_type == hypervisor)
 586                 return;
 587
 588         of_iterate_over_cpus(fill_in_one_cpu, 0);
 589
 590         smp_fill_in_sib_core_maps();
 591 }
 592
 593 void __init of_console_init(void)
 594 {
 595         char *msg = "OF stdout device is: %s\n";
 596         struct device_node *dp;
 597         const char *type;
 598         phandle node;
 599
 600         of_console_path = prom_early_alloc(256);
 601         if (prom_ihandle2path(prom_stdout, of_console_path, 256) < 0) {
 602                 prom_printf("Cannot obtain path of stdout.\n");
 603                 prom_halt();
 604         }
 605         of_console_options = strrchr(of_console_path, ':');
 606         if (of_console_options) {
 607                 of_console_options++;
 608                 if (*of_console_options == '\0')
 609                         of_console_options = NULL;
 610         }
 611
 612         node = prom_inst2pkg(prom_stdout);
 613         if (!node) {
 614                 prom_printf("Cannot resolve stdout node from "
 615                             "instance %08x.\n", prom_stdout);
 616                 prom_halt();
 617         }
 618
 619         dp = of_find_node_by_phandle(node);
 620         type = of_get_property(dp, "device_type", NULL);
 621         if (!type) {
 622                 prom_printf("Console stdout lacks device_type property.\n");
 623                 prom_halt();
 624         }
 625
 626         if (strcmp(type, "display") && strcmp(type, "serial")) {
 627                 prom_printf("Console device_type is neither display "
 628                             "nor serial.\n");
 629                 prom_halt();
 630         }
 631
 632         of_console_device = dp;
 633
 634         printk(msg, of_console_path);
 635 }