2005-10-06 04:06:20 +02:00
|
|
|
/*
|
|
|
|
* Procedures for creating, accessing and interpreting the device tree.
|
|
|
|
*
|
|
|
|
* Paul Mackerras August 1996.
|
|
|
|
* Copyright (C) 1996-2005 Paul Mackerras.
|
|
|
|
*
|
|
|
|
* Adapted for 64bit PowerPC by Dave Engebretsen and Peter Bergner.
|
|
|
|
* {engebret|bergner}@us.ibm.com
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version
|
|
|
|
* 2 of the License, or (at your option) any later version.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#undef DEBUG
|
|
|
|
|
|
|
|
#include <stdarg.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/threads.h>
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/pci.h>
|
|
|
|
#include <linux/stringify.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/initrd.h>
|
|
|
|
#include <linux/bitops.h>
|
|
|
|
#include <linux/module.h>
|
2005-12-04 08:39:48 +01:00
|
|
|
#include <linux/kexec.h>
|
2006-06-23 10:16:03 +02:00
|
|
|
#include <linux/debugfs.h>
|
2006-07-03 13:36:01 +02:00
|
|
|
#include <linux/irq.h>
|
2008-02-14 01:56:49 +01:00
|
|
|
#include <linux/lmb.h>
|
2005-10-06 04:06:20 +02:00
|
|
|
|
|
|
|
#include <asm/prom.h>
|
|
|
|
#include <asm/rtas.h>
|
|
|
|
#include <asm/page.h>
|
|
|
|
#include <asm/processor.h>
|
|
|
|
#include <asm/irq.h>
|
|
|
|
#include <asm/io.h>
|
2005-12-04 08:39:37 +01:00
|
|
|
#include <asm/kdump.h>
|
2005-10-06 04:06:20 +02:00
|
|
|
#include <asm/smp.h>
|
|
|
|
#include <asm/system.h>
|
|
|
|
#include <asm/mmu.h>
|
|
|
|
#include <asm/pgtable.h>
|
|
|
|
#include <asm/pci.h>
|
|
|
|
#include <asm/iommu.h>
|
|
|
|
#include <asm/btext.h>
|
|
|
|
#include <asm/sections.h>
|
|
|
|
#include <asm/machdep.h>
|
|
|
|
#include <asm/pSeries_reconfig.h>
|
2005-10-10 14:50:37 +02:00
|
|
|
#include <asm/pci-bridge.h>
|
2008-03-22 00:37:08 +01:00
|
|
|
#include <asm/phyp_dump.h>
|
2006-05-17 10:00:46 +02:00
|
|
|
#include <asm/kexec.h>
|
2008-04-21 20:22:34 +02:00
|
|
|
#include <mm/mmu_decl.h>
|
2005-10-06 04:06:20 +02:00
|
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
#define DBG(fmt...) printk(KERN_ERR fmt)
|
|
|
|
#else
|
|
|
|
#define DBG(fmt...)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
static int __initdata dt_root_addr_cells;
|
|
|
|
static int __initdata dt_root_size_cells;
|
|
|
|
|
|
|
|
#ifdef CONFIG_PPC64
|
2006-04-13 04:52:33 +02:00
|
|
|
int __initdata iommu_is_off;
|
2005-10-06 04:06:20 +02:00
|
|
|
int __initdata iommu_force_on;
|
2005-10-31 03:07:02 +01:00
|
|
|
unsigned long tce_alloc_start, tce_alloc_end;
|
2005-10-06 04:06:20 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
typedef u32 cell_t;
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
static struct boot_param_header *initial_boot_params __initdata;
|
|
|
|
#else
|
|
|
|
struct boot_param_header *initial_boot_params;
|
|
|
|
#endif
|
|
|
|
|
2007-04-24 09:57:33 +02:00
|
|
|
extern struct device_node *allnodes; /* temporary while merging */
|
2005-10-06 04:06:20 +02:00
|
|
|
|
2007-04-24 08:46:53 +02:00
|
|
|
extern rwlock_t devtree_lock; /* temporary while merging */
|
2005-10-06 04:06:20 +02:00
|
|
|
|
|
|
|
/* export that to outside world */
|
|
|
|
struct device_node *of_chosen;
|
|
|
|
|
|
|
|
static inline char *find_flat_dt_string(u32 offset)
|
|
|
|
{
|
|
|
|
return ((char *)initial_boot_params) +
|
|
|
|
initial_boot_params->off_dt_strings + offset;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* This function is used to scan the flattened device-tree, it is
|
|
|
|
* used to extract the memory informations at boot before we can
|
|
|
|
* unflatten the tree
|
|
|
|
*/
|
2005-11-07 01:06:55 +01:00
|
|
|
int __init of_scan_flat_dt(int (*it)(unsigned long node,
|
|
|
|
const char *uname, int depth,
|
|
|
|
void *data),
|
|
|
|
void *data)
|
2005-10-06 04:06:20 +02:00
|
|
|
{
|
|
|
|
unsigned long p = ((unsigned long)initial_boot_params) +
|
|
|
|
initial_boot_params->off_dt_struct;
|
|
|
|
int rc = 0;
|
|
|
|
int depth = -1;
|
|
|
|
|
|
|
|
do {
|
|
|
|
u32 tag = *((u32 *)p);
|
|
|
|
char *pathp;
|
|
|
|
|
|
|
|
p += 4;
|
|
|
|
if (tag == OF_DT_END_NODE) {
|
|
|
|
depth --;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (tag == OF_DT_NOP)
|
|
|
|
continue;
|
|
|
|
if (tag == OF_DT_END)
|
|
|
|
break;
|
|
|
|
if (tag == OF_DT_PROP) {
|
|
|
|
u32 sz = *((u32 *)p);
|
|
|
|
p += 8;
|
|
|
|
if (initial_boot_params->version < 0x10)
|
|
|
|
p = _ALIGN(p, sz >= 8 ? 8 : 4);
|
|
|
|
p += sz;
|
|
|
|
p = _ALIGN(p, 4);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (tag != OF_DT_BEGIN_NODE) {
|
|
|
|
printk(KERN_WARNING "Invalid tag %x scanning flattened"
|
|
|
|
" device tree !\n", tag);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
depth++;
|
|
|
|
pathp = (char *)p;
|
|
|
|
p = _ALIGN(p + strlen(pathp) + 1, 4);
|
|
|
|
if ((*pathp) == '/') {
|
|
|
|
char *lp, *np;
|
|
|
|
for (lp = NULL, np = pathp; *np; np++)
|
|
|
|
if ((*np) == '/')
|
|
|
|
lp = np+1;
|
|
|
|
if (lp != NULL)
|
|
|
|
pathp = lp;
|
|
|
|
}
|
|
|
|
rc = it(p, pathp, depth, data);
|
|
|
|
if (rc != 0)
|
|
|
|
break;
|
|
|
|
} while(1);
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2006-03-28 14:15:54 +02:00
|
|
|
unsigned long __init of_get_flat_dt_root(void)
|
|
|
|
{
|
|
|
|
unsigned long p = ((unsigned long)initial_boot_params) +
|
|
|
|
initial_boot_params->off_dt_struct;
|
|
|
|
|
|
|
|
while(*((u32 *)p) == OF_DT_NOP)
|
|
|
|
p += 4;
|
|
|
|
BUG_ON (*((u32 *)p) != OF_DT_BEGIN_NODE);
|
|
|
|
p += 4;
|
|
|
|
return _ALIGN(p + strlen((char *)p) + 1, 4);
|
|
|
|
}
|
|
|
|
|
2005-10-06 04:06:20 +02:00
|
|
|
/**
|
|
|
|
* This function can be used within scan_flattened_dt callback to get
|
|
|
|
* access to properties
|
|
|
|
*/
|
2005-11-07 01:06:55 +01:00
|
|
|
void* __init of_get_flat_dt_prop(unsigned long node, const char *name,
|
|
|
|
unsigned long *size)
|
2005-10-06 04:06:20 +02:00
|
|
|
{
|
|
|
|
unsigned long p = node;
|
|
|
|
|
|
|
|
do {
|
|
|
|
u32 tag = *((u32 *)p);
|
|
|
|
u32 sz, noff;
|
|
|
|
const char *nstr;
|
|
|
|
|
|
|
|
p += 4;
|
|
|
|
if (tag == OF_DT_NOP)
|
|
|
|
continue;
|
|
|
|
if (tag != OF_DT_PROP)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
sz = *((u32 *)p);
|
|
|
|
noff = *((u32 *)(p + 4));
|
|
|
|
p += 8;
|
|
|
|
if (initial_boot_params->version < 0x10)
|
|
|
|
p = _ALIGN(p, sz >= 8 ? 8 : 4);
|
|
|
|
|
|
|
|
nstr = find_flat_dt_string(noff);
|
|
|
|
if (nstr == NULL) {
|
|
|
|
printk(KERN_WARNING "Can't find property index"
|
|
|
|
" name !\n");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
if (strcmp(name, nstr) == 0) {
|
|
|
|
if (size)
|
|
|
|
*size = sz;
|
|
|
|
return (void *)p;
|
|
|
|
}
|
|
|
|
p += sz;
|
|
|
|
p = _ALIGN(p, 4);
|
|
|
|
} while(1);
|
|
|
|
}
|
|
|
|
|
2006-03-28 14:15:54 +02:00
|
|
|
int __init of_flat_dt_is_compatible(unsigned long node, const char *compat)
|
|
|
|
{
|
|
|
|
const char* cp;
|
|
|
|
unsigned long cplen, l;
|
|
|
|
|
|
|
|
cp = of_get_flat_dt_prop(node, "compatible", &cplen);
|
|
|
|
if (cp == NULL)
|
|
|
|
return 0;
|
|
|
|
while (cplen > 0) {
|
|
|
|
if (strncasecmp(cp, compat, strlen(compat)) == 0)
|
|
|
|
return 1;
|
|
|
|
l = strlen(cp) + 1;
|
|
|
|
cp += l;
|
|
|
|
cplen -= l;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-10-06 04:06:20 +02:00
|
|
|
static void *__init unflatten_dt_alloc(unsigned long *mem, unsigned long size,
|
|
|
|
unsigned long align)
|
|
|
|
{
|
|
|
|
void *res;
|
|
|
|
|
|
|
|
*mem = _ALIGN(*mem, align);
|
|
|
|
res = (void *)*mem;
|
|
|
|
*mem += size;
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned long __init unflatten_dt_node(unsigned long mem,
|
|
|
|
unsigned long *p,
|
|
|
|
struct device_node *dad,
|
|
|
|
struct device_node ***allnextpp,
|
|
|
|
unsigned long fpsize)
|
|
|
|
{
|
|
|
|
struct device_node *np;
|
|
|
|
struct property *pp, **prev_pp = NULL;
|
|
|
|
char *pathp;
|
|
|
|
u32 tag;
|
|
|
|
unsigned int l, allocl;
|
|
|
|
int has_name = 0;
|
|
|
|
int new_format = 0;
|
|
|
|
|
|
|
|
tag = *((u32 *)(*p));
|
|
|
|
if (tag != OF_DT_BEGIN_NODE) {
|
|
|
|
printk("Weird tag at start of node: %x\n", tag);
|
|
|
|
return mem;
|
|
|
|
}
|
|
|
|
*p += 4;
|
|
|
|
pathp = (char *)*p;
|
|
|
|
l = allocl = strlen(pathp) + 1;
|
|
|
|
*p = _ALIGN(*p + l, 4);
|
|
|
|
|
|
|
|
/* version 0x10 has a more compact unit name here instead of the full
|
|
|
|
* path. we accumulate the full path size using "fpsize", we'll rebuild
|
|
|
|
* it later. We detect this because the first character of the name is
|
|
|
|
* not '/'.
|
|
|
|
*/
|
|
|
|
if ((*pathp) != '/') {
|
|
|
|
new_format = 1;
|
|
|
|
if (fpsize == 0) {
|
|
|
|
/* root node: special case. fpsize accounts for path
|
|
|
|
* plus terminating zero. root node only has '/', so
|
|
|
|
* fpsize should be 2, but we want to avoid the first
|
|
|
|
* level nodes to have two '/' so we use fpsize 1 here
|
|
|
|
*/
|
|
|
|
fpsize = 1;
|
|
|
|
allocl = 2;
|
|
|
|
} else {
|
|
|
|
/* account for '/' and path size minus terminal 0
|
|
|
|
* already in 'l'
|
|
|
|
*/
|
|
|
|
fpsize += l;
|
|
|
|
allocl = fpsize;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
np = unflatten_dt_alloc(&mem, sizeof(struct device_node) + allocl,
|
|
|
|
__alignof__(struct device_node));
|
|
|
|
if (allnextpp) {
|
|
|
|
memset(np, 0, sizeof(*np));
|
|
|
|
np->full_name = ((char*)np) + sizeof(struct device_node);
|
|
|
|
if (new_format) {
|
|
|
|
char *p = np->full_name;
|
|
|
|
/* rebuild full path for new format */
|
|
|
|
if (dad && dad->parent) {
|
|
|
|
strcpy(p, dad->full_name);
|
|
|
|
#ifdef DEBUG
|
|
|
|
if ((strlen(p) + l + 1) != allocl) {
|
|
|
|
DBG("%s: p: %d, l: %d, a: %d\n",
|
2006-03-28 14:15:54 +02:00
|
|
|
pathp, (int)strlen(p), l, allocl);
|
2005-10-06 04:06:20 +02:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
p += strlen(p);
|
|
|
|
}
|
|
|
|
*(p++) = '/';
|
|
|
|
memcpy(p, pathp, l);
|
|
|
|
} else
|
|
|
|
memcpy(np->full_name, pathp, l);
|
|
|
|
prev_pp = &np->properties;
|
|
|
|
**allnextpp = np;
|
|
|
|
*allnextpp = &np->allnext;
|
|
|
|
if (dad != NULL) {
|
|
|
|
np->parent = dad;
|
|
|
|
/* we temporarily use the next field as `last_child'*/
|
|
|
|
if (dad->next == 0)
|
|
|
|
dad->child = np;
|
|
|
|
else
|
|
|
|
dad->next->sibling = np;
|
|
|
|
dad->next = np;
|
|
|
|
}
|
|
|
|
kref_init(&np->kref);
|
|
|
|
}
|
|
|
|
while(1) {
|
|
|
|
u32 sz, noff;
|
|
|
|
char *pname;
|
|
|
|
|
|
|
|
tag = *((u32 *)(*p));
|
|
|
|
if (tag == OF_DT_NOP) {
|
|
|
|
*p += 4;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (tag != OF_DT_PROP)
|
|
|
|
break;
|
|
|
|
*p += 4;
|
|
|
|
sz = *((u32 *)(*p));
|
|
|
|
noff = *((u32 *)((*p) + 4));
|
|
|
|
*p += 8;
|
|
|
|
if (initial_boot_params->version < 0x10)
|
|
|
|
*p = _ALIGN(*p, sz >= 8 ? 8 : 4);
|
|
|
|
|
|
|
|
pname = find_flat_dt_string(noff);
|
|
|
|
if (pname == NULL) {
|
|
|
|
printk("Can't find property name in list !\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (strcmp(pname, "name") == 0)
|
|
|
|
has_name = 1;
|
|
|
|
l = strlen(pname) + 1;
|
|
|
|
pp = unflatten_dt_alloc(&mem, sizeof(struct property),
|
|
|
|
__alignof__(struct property));
|
|
|
|
if (allnextpp) {
|
|
|
|
if (strcmp(pname, "linux,phandle") == 0) {
|
|
|
|
np->node = *((u32 *)*p);
|
|
|
|
if (np->linux_phandle == 0)
|
|
|
|
np->linux_phandle = np->node;
|
|
|
|
}
|
|
|
|
if (strcmp(pname, "ibm,phandle") == 0)
|
|
|
|
np->linux_phandle = *((u32 *)*p);
|
|
|
|
pp->name = pname;
|
|
|
|
pp->length = sz;
|
|
|
|
pp->value = (void *)*p;
|
|
|
|
*prev_pp = pp;
|
|
|
|
prev_pp = &pp->next;
|
|
|
|
}
|
|
|
|
*p = _ALIGN((*p) + sz, 4);
|
|
|
|
}
|
|
|
|
/* with version 0x10 we may not have the name property, recreate
|
|
|
|
* it here from the unit name if absent
|
|
|
|
*/
|
|
|
|
if (!has_name) {
|
|
|
|
char *p = pathp, *ps = pathp, *pa = NULL;
|
|
|
|
int sz;
|
|
|
|
|
|
|
|
while (*p) {
|
|
|
|
if ((*p) == '@')
|
|
|
|
pa = p;
|
|
|
|
if ((*p) == '/')
|
|
|
|
ps = p + 1;
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
if (pa < ps)
|
|
|
|
pa = p;
|
|
|
|
sz = (pa - ps) + 1;
|
|
|
|
pp = unflatten_dt_alloc(&mem, sizeof(struct property) + sz,
|
|
|
|
__alignof__(struct property));
|
|
|
|
if (allnextpp) {
|
|
|
|
pp->name = "name";
|
|
|
|
pp->length = sz;
|
2007-04-03 02:58:52 +02:00
|
|
|
pp->value = pp + 1;
|
2005-10-06 04:06:20 +02:00
|
|
|
*prev_pp = pp;
|
|
|
|
prev_pp = &pp->next;
|
|
|
|
memcpy(pp->value, ps, sz - 1);
|
|
|
|
((char *)pp->value)[sz - 1] = 0;
|
2007-04-03 02:58:52 +02:00
|
|
|
DBG("fixed up name for %s -> %s\n", pathp,
|
|
|
|
(char *)pp->value);
|
2005-10-06 04:06:20 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (allnextpp) {
|
|
|
|
*prev_pp = NULL;
|
2007-04-03 02:54:01 +02:00
|
|
|
np->name = of_get_property(np, "name", NULL);
|
|
|
|
np->type = of_get_property(np, "device_type", NULL);
|
2005-10-06 04:06:20 +02:00
|
|
|
|
|
|
|
if (!np->name)
|
|
|
|
np->name = "<NULL>";
|
|
|
|
if (!np->type)
|
|
|
|
np->type = "<NULL>";
|
|
|
|
}
|
|
|
|
while (tag == OF_DT_BEGIN_NODE) {
|
|
|
|
mem = unflatten_dt_node(mem, p, np, allnextpp, fpsize);
|
|
|
|
tag = *((u32 *)(*p));
|
|
|
|
}
|
|
|
|
if (tag != OF_DT_END_NODE) {
|
|
|
|
printk("Weird tag at end of node: %x\n", tag);
|
|
|
|
return mem;
|
|
|
|
}
|
|
|
|
*p += 4;
|
|
|
|
return mem;
|
|
|
|
}
|
|
|
|
|
2006-05-17 10:00:46 +02:00
|
|
|
static int __init early_parse_mem(char *p)
|
|
|
|
{
|
|
|
|
if (!p)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
memory_limit = PAGE_ALIGN(memparse(p, &p));
|
|
|
|
DBG("memory limit = 0x%lx\n", memory_limit);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
early_param("mem", early_parse_mem);
|
|
|
|
|
2007-09-06 19:47:29 +02:00
|
|
|
/**
|
|
|
|
* move_device_tree - move tree to an unused area, if needed.
|
|
|
|
*
|
|
|
|
* The device tree may be allocated beyond our memory limit, or inside the
|
|
|
|
* crash kernel region for kdump. If so, move it out of the way.
|
2006-05-17 10:00:46 +02:00
|
|
|
*/
|
2008-03-28 17:07:45 +01:00
|
|
|
static void __init move_device_tree(void)
|
2006-05-17 10:00:46 +02:00
|
|
|
{
|
|
|
|
unsigned long start, size;
|
|
|
|
void *p;
|
|
|
|
|
|
|
|
DBG("-> move_device_tree\n");
|
|
|
|
|
|
|
|
start = __pa(initial_boot_params);
|
|
|
|
size = initial_boot_params->totalsize;
|
|
|
|
|
|
|
|
if ((memory_limit && (start + size) > memory_limit) ||
|
|
|
|
overlaps_crashkernel(start, size)) {
|
|
|
|
p = __va(lmb_alloc_base(size, PAGE_SIZE, lmb.rmo_size));
|
|
|
|
memcpy(p, initial_boot_params, size);
|
|
|
|
initial_boot_params = (struct boot_param_header *)p;
|
|
|
|
DBG("Moved device tree to 0x%p\n", p);
|
|
|
|
}
|
|
|
|
|
|
|
|
DBG("<- move_device_tree\n");
|
|
|
|
}
|
2005-10-06 04:06:20 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* unflattens the device-tree passed by the firmware, creating the
|
|
|
|
* tree of struct device_node. It also fills the "name" and "type"
|
|
|
|
* pointers of the nodes so the normal device-tree walking functions
|
|
|
|
* can be used (this used to be done by finish_device_tree)
|
|
|
|
*/
|
|
|
|
void __init unflatten_device_tree(void)
|
|
|
|
{
|
|
|
|
unsigned long start, mem, size;
|
|
|
|
struct device_node **allnextp = &allnodes;
|
|
|
|
|
|
|
|
DBG(" -> unflatten_device_tree()\n");
|
|
|
|
|
|
|
|
/* First pass, scan for size */
|
|
|
|
start = ((unsigned long)initial_boot_params) +
|
|
|
|
initial_boot_params->off_dt_struct;
|
|
|
|
size = unflatten_dt_node(0, &start, NULL, NULL, 0);
|
|
|
|
size = (size | 3) + 1;
|
|
|
|
|
|
|
|
DBG(" size is %lx, allocating...\n", size);
|
|
|
|
|
|
|
|
/* Allocate memory for the expanded device tree */
|
|
|
|
mem = lmb_alloc(size + 4, __alignof__(struct device_node));
|
|
|
|
mem = (unsigned long) __va(mem);
|
|
|
|
|
|
|
|
((u32 *)mem)[size / 4] = 0xdeadbeef;
|
|
|
|
|
|
|
|
DBG(" unflattening %lx...\n", mem);
|
|
|
|
|
|
|
|
/* Second pass, do actual unflattening */
|
|
|
|
start = ((unsigned long)initial_boot_params) +
|
|
|
|
initial_boot_params->off_dt_struct;
|
|
|
|
unflatten_dt_node(mem, &start, NULL, &allnextp, 0);
|
|
|
|
if (*((u32 *)start) != OF_DT_END)
|
|
|
|
printk(KERN_WARNING "Weird tag at end of tree: %08x\n", *((u32 *)start));
|
|
|
|
if (((u32 *)mem)[size / 4] != 0xdeadbeef)
|
|
|
|
printk(KERN_WARNING "End of tree marker overwritten: %08x\n",
|
|
|
|
((u32 *)mem)[size / 4] );
|
|
|
|
*allnextp = NULL;
|
|
|
|
|
|
|
|
/* Get pointer to OF "/chosen" node for use everywhere */
|
|
|
|
of_chosen = of_find_node_by_path("/chosen");
|
2005-10-23 09:23:21 +02:00
|
|
|
if (of_chosen == NULL)
|
|
|
|
of_chosen = of_find_node_by_path("/chosen@0");
|
2005-10-06 04:06:20 +02:00
|
|
|
|
|
|
|
DBG(" <- unflatten_device_tree()\n");
|
|
|
|
}
|
|
|
|
|
2006-05-03 15:04:37 +02:00
|
|
|
/*
|
|
|
|
* ibm,pa-features is a per-cpu property that contains a string of
|
|
|
|
* attribute descriptors, each of which has a 2 byte header plus up
|
|
|
|
* to 254 bytes worth of processor attribute bits. First header
|
|
|
|
* byte specifies the number of bytes following the header.
|
|
|
|
* Second header byte is an "attribute-specifier" type, of which
|
|
|
|
* zero is the only currently-defined value.
|
|
|
|
* Implementation: Pass in the byte and bit offset for the feature
|
|
|
|
* that we are interested in. The function will return -1 if the
|
|
|
|
* pa-features property is missing, or a 1/0 to indicate if the feature
|
|
|
|
* is supported/not supported. Note that the bit numbers are
|
|
|
|
* big-endian to match the definition in PAPR.
|
|
|
|
*/
|
|
|
|
static struct ibm_pa_feature {
|
|
|
|
unsigned long cpu_features; /* CPU_FTR_xxx bit */
|
|
|
|
unsigned int cpu_user_ftrs; /* PPC_FEATURE_xxx bit */
|
|
|
|
unsigned char pabyte; /* byte number in ibm,pa-features */
|
|
|
|
unsigned char pabit; /* bit number (big-endian) */
|
|
|
|
unsigned char invert; /* if 1, pa bit set => clear feature */
|
|
|
|
} ibm_pa_features[] __initdata = {
|
|
|
|
{0, PPC_FEATURE_HAS_MMU, 0, 0, 0},
|
|
|
|
{0, PPC_FEATURE_HAS_FPU, 0, 1, 0},
|
|
|
|
{CPU_FTR_SLB, 0, 0, 2, 0},
|
|
|
|
{CPU_FTR_CTRL, 0, 0, 3, 0},
|
|
|
|
{CPU_FTR_NOEXECUTE, 0, 0, 6, 0},
|
|
|
|
{CPU_FTR_NODSISRALIGN, 0, 1, 1, 1},
|
|
|
|
{CPU_FTR_CI_LARGE_PAGE, 0, 1, 2, 0},
|
2006-06-29 09:12:30 +02:00
|
|
|
{CPU_FTR_REAL_LE, PPC_FEATURE_TRUE_LE, 5, 0, 0},
|
2006-05-03 15:04:37 +02:00
|
|
|
};
|
|
|
|
|
2006-11-10 10:38:53 +01:00
|
|
|
static void __init scan_features(unsigned long node, unsigned char *ftrs,
|
|
|
|
unsigned long tablelen,
|
|
|
|
struct ibm_pa_feature *fp,
|
|
|
|
unsigned long ft_size)
|
2006-05-03 15:04:37 +02:00
|
|
|
{
|
2006-11-10 10:38:53 +01:00
|
|
|
unsigned long i, len, bit;
|
2006-05-03 15:04:37 +02:00
|
|
|
|
|
|
|
/* find descriptor with type == 0 */
|
|
|
|
for (;;) {
|
|
|
|
if (tablelen < 3)
|
|
|
|
return;
|
2006-11-10 10:38:53 +01:00
|
|
|
len = 2 + ftrs[0];
|
2006-05-03 15:04:37 +02:00
|
|
|
if (tablelen < len)
|
|
|
|
return; /* descriptor 0 not found */
|
2006-11-10 10:38:53 +01:00
|
|
|
if (ftrs[1] == 0)
|
2006-05-03 15:04:37 +02:00
|
|
|
break;
|
|
|
|
tablelen -= len;
|
2006-11-10 10:38:53 +01:00
|
|
|
ftrs += len;
|
2006-05-03 15:04:37 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* loop over bits we know about */
|
2006-11-10 10:38:53 +01:00
|
|
|
for (i = 0; i < ft_size; ++i, ++fp) {
|
|
|
|
if (fp->pabyte >= ftrs[0])
|
2006-05-03 15:04:37 +02:00
|
|
|
continue;
|
2006-11-10 10:38:53 +01:00
|
|
|
bit = (ftrs[2 + fp->pabyte] >> (7 - fp->pabit)) & 1;
|
2006-05-03 15:04:37 +02:00
|
|
|
if (bit ^ fp->invert) {
|
|
|
|
cur_cpu_spec->cpu_features |= fp->cpu_features;
|
|
|
|
cur_cpu_spec->cpu_user_features |= fp->cpu_user_ftrs;
|
|
|
|
} else {
|
|
|
|
cur_cpu_spec->cpu_features &= ~fp->cpu_features;
|
|
|
|
cur_cpu_spec->cpu_user_features &= ~fp->cpu_user_ftrs;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-11-10 10:38:53 +01:00
|
|
|
static void __init check_cpu_pa_features(unsigned long node)
|
|
|
|
{
|
|
|
|
unsigned char *pa_ftrs;
|
|
|
|
unsigned long tablelen;
|
|
|
|
|
|
|
|
pa_ftrs = of_get_flat_dt_prop(node, "ibm,pa-features", &tablelen);
|
|
|
|
if (pa_ftrs == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
scan_features(node, pa_ftrs, tablelen,
|
|
|
|
ibm_pa_features, ARRAY_SIZE(ibm_pa_features));
|
|
|
|
}
|
|
|
|
|
2007-12-06 07:24:48 +01:00
|
|
|
#ifdef CONFIG_PPC64
|
|
|
|
static void __init check_cpu_slb_size(unsigned long node)
|
|
|
|
{
|
|
|
|
u32 *slb_size_ptr;
|
|
|
|
|
2009-01-14 14:42:41 +01:00
|
|
|
slb_size_ptr = of_get_flat_dt_prop(node, "slb-size", NULL);
|
|
|
|
if (slb_size_ptr != NULL) {
|
|
|
|
mmu_slb_size = *slb_size_ptr;
|
|
|
|
return;
|
|
|
|
}
|
2007-12-06 07:24:48 +01:00
|
|
|
slb_size_ptr = of_get_flat_dt_prop(node, "ibm,slb-size", NULL);
|
|
|
|
if (slb_size_ptr != NULL) {
|
|
|
|
mmu_slb_size = *slb_size_ptr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
#define check_cpu_slb_size(node) do { } while(0)
|
|
|
|
#endif
|
|
|
|
|
2006-11-10 10:38:53 +01:00
|
|
|
static struct feature_property {
|
|
|
|
const char *name;
|
|
|
|
u32 min_value;
|
|
|
|
unsigned long cpu_feature;
|
|
|
|
unsigned long cpu_user_ftr;
|
|
|
|
} feature_properties[] __initdata = {
|
|
|
|
#ifdef CONFIG_ALTIVEC
|
|
|
|
{"altivec", 0, CPU_FTR_ALTIVEC, PPC_FEATURE_HAS_ALTIVEC},
|
|
|
|
{"ibm,vmx", 1, CPU_FTR_ALTIVEC, PPC_FEATURE_HAS_ALTIVEC},
|
|
|
|
#endif /* CONFIG_ALTIVEC */
|
2008-06-25 06:07:18 +02:00
|
|
|
#ifdef CONFIG_VSX
|
|
|
|
/* Yes, this _really_ is ibm,vmx == 2 to enable VSX */
|
|
|
|
{"ibm,vmx", 2, CPU_FTR_VSX, PPC_FEATURE_HAS_VSX},
|
|
|
|
#endif /* CONFIG_VSX */
|
2006-11-10 10:38:53 +01:00
|
|
|
#ifdef CONFIG_PPC64
|
|
|
|
{"ibm,dfp", 1, 0, PPC_FEATURE_HAS_DFP},
|
|
|
|
{"ibm,purr", 1, CPU_FTR_PURR, 0},
|
|
|
|
{"ibm,spurr", 1, CPU_FTR_SPURR, 0},
|
|
|
|
#endif /* CONFIG_PPC64 */
|
|
|
|
};
|
|
|
|
|
2007-12-21 17:24:02 +01:00
|
|
|
#if defined(CONFIG_44x) && defined(CONFIG_PPC_FPU)
|
|
|
|
static inline void identical_pvr_fixup(unsigned long node)
|
|
|
|
{
|
|
|
|
unsigned int pvr;
|
|
|
|
char *model = of_get_flat_dt_prop(node, "model", NULL);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Since 440GR(x)/440EP(x) processors have the same pvr,
|
|
|
|
* we check the node path and set bit 28 in the cur_cpu_spec
|
|
|
|
* pvr for EP(x) processor version. This bit is always 0 in
|
|
|
|
* the "real" pvr. Then we call identify_cpu again with
|
|
|
|
* the new logical pvr to enable FPU support.
|
|
|
|
*/
|
|
|
|
if (model && strstr(model, "440EP")) {
|
|
|
|
pvr = cur_cpu_spec->pvr_value | 0x8;
|
|
|
|
identify_cpu(0, pvr);
|
|
|
|
DBG("Using logical pvr %x for %s\n", pvr, model);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
#define identical_pvr_fixup(node) do { } while(0)
|
|
|
|
#endif
|
|
|
|
|
2006-11-10 10:38:53 +01:00
|
|
|
static void __init check_cpu_feature_properties(unsigned long node)
|
|
|
|
{
|
|
|
|
unsigned long i;
|
|
|
|
struct feature_property *fp = feature_properties;
|
|
|
|
const u32 *prop;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(feature_properties); ++i, ++fp) {
|
|
|
|
prop = of_get_flat_dt_prop(node, fp->name, NULL);
|
|
|
|
if (prop && *prop >= fp->min_value) {
|
|
|
|
cur_cpu_spec->cpu_features |= fp->cpu_feature;
|
|
|
|
cur_cpu_spec->cpu_user_features |= fp->cpu_user_ftr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-10-06 04:06:20 +02:00
|
|
|
static int __init early_init_dt_scan_cpus(unsigned long node,
|
2006-03-25 07:25:17 +01:00
|
|
|
const char *uname, int depth,
|
|
|
|
void *data)
|
2005-10-06 04:06:20 +02:00
|
|
|
{
|
2006-03-25 07:25:17 +01:00
|
|
|
static int logical_cpuid = 0;
|
|
|
|
char *type = of_get_flat_dt_prop(node, "device_type", NULL);
|
2006-11-10 10:38:53 +01:00
|
|
|
const u32 *prop;
|
|
|
|
const u32 *intserv;
|
2006-03-25 07:25:17 +01:00
|
|
|
int i, nthreads;
|
|
|
|
unsigned long len;
|
|
|
|
int found = 0;
|
2005-10-06 04:06:20 +02:00
|
|
|
|
|
|
|
/* We are scanning "cpu" nodes only */
|
|
|
|
if (type == NULL || strcmp(type, "cpu") != 0)
|
|
|
|
return 0;
|
|
|
|
|
2006-03-25 07:25:17 +01:00
|
|
|
/* Get physical cpuid */
|
|
|
|
intserv = of_get_flat_dt_prop(node, "ibm,ppc-interrupt-server#s", &len);
|
|
|
|
if (intserv) {
|
|
|
|
nthreads = len / sizeof(int);
|
2005-10-06 04:06:20 +02:00
|
|
|
} else {
|
2006-03-25 07:25:17 +01:00
|
|
|
intserv = of_get_flat_dt_prop(node, "reg", NULL);
|
|
|
|
nthreads = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Now see if any of these threads match our boot cpu.
|
|
|
|
* NOTE: This must match the parsing done in smp_setup_cpu_maps.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < nthreads; i++) {
|
|
|
|
/*
|
|
|
|
* version 2 of the kexec param format adds the phys cpuid of
|
|
|
|
* booted proc.
|
|
|
|
*/
|
|
|
|
if (initial_boot_params && initial_boot_params->version >= 2) {
|
|
|
|
if (intserv[i] ==
|
|
|
|
initial_boot_params->boot_cpuid_phys) {
|
|
|
|
found = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Check if it's the boot-cpu, set it's hw index now,
|
|
|
|
* unfortunately this format did not support booting
|
|
|
|
* off secondary threads.
|
|
|
|
*/
|
|
|
|
if (of_get_flat_dt_prop(node,
|
2005-11-07 01:06:55 +01:00
|
|
|
"linux,boot-cpu", NULL) != NULL) {
|
2006-03-25 07:25:17 +01:00
|
|
|
found = 1;
|
|
|
|
break;
|
|
|
|
}
|
2005-10-06 04:06:20 +02:00
|
|
|
}
|
2006-03-25 07:25:17 +01:00
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
/* logical cpu id is always 0 on UP kernels */
|
|
|
|
logical_cpuid++;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
if (found) {
|
|
|
|
DBG("boot cpu: logical %d physical %d\n", logical_cpuid,
|
|
|
|
intserv[i]);
|
|
|
|
boot_cpuid = logical_cpuid;
|
|
|
|
set_hard_smp_processor_id(boot_cpuid, intserv[i]);
|
2005-10-06 04:06:20 +02:00
|
|
|
|
2006-11-10 10:38:53 +01:00
|
|
|
/*
|
|
|
|
* PAPR defines "logical" PVR values for cpus that
|
|
|
|
* meet various levels of the architecture:
|
|
|
|
* 0x0f000001 Architecture version 2.04
|
|
|
|
* 0x0f000002 Architecture version 2.05
|
|
|
|
* If the cpu-version property in the cpu node contains
|
|
|
|
* such a value, we call identify_cpu again with the
|
|
|
|
* logical PVR value in order to use the cpu feature
|
|
|
|
* bits appropriate for the architecture level.
|
|
|
|
*
|
|
|
|
* A POWER6 partition in "POWER6 architected" mode
|
|
|
|
* uses the 0x0f000002 PVR value; in POWER5+ mode
|
|
|
|
* it uses 0x0f000001.
|
|
|
|
*/
|
|
|
|
prop = of_get_flat_dt_prop(node, "cpu-version", NULL);
|
|
|
|
if (prop && (*prop & 0xff000000) == 0x0f000000)
|
|
|
|
identify_cpu(0, *prop);
|
2007-12-21 17:24:02 +01:00
|
|
|
|
|
|
|
identical_pvr_fixup(node);
|
2005-10-06 04:06:20 +02:00
|
|
|
}
|
|
|
|
|
2006-11-10 10:38:53 +01:00
|
|
|
check_cpu_feature_properties(node);
|
2006-05-03 15:04:37 +02:00
|
|
|
check_cpu_pa_features(node);
|
2007-12-06 07:24:48 +01:00
|
|
|
check_cpu_slb_size(node);
|
2006-05-03 15:04:37 +02:00
|
|
|
|
2005-10-06 04:06:20 +02:00
|
|
|
#ifdef CONFIG_PPC_PSERIES
|
2006-03-25 07:25:17 +01:00
|
|
|
if (nthreads > 1)
|
2005-10-06 04:06:20 +02:00
|
|
|
cur_cpu_spec->cpu_features |= CPU_FTR_SMT;
|
2006-03-25 07:25:17 +01:00
|
|
|
else
|
|
|
|
cur_cpu_spec->cpu_features &= ~CPU_FTR_SMT;
|
2005-10-06 04:06:20 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-05-10 09:06:30 +02:00
|
|
|
#ifdef CONFIG_BLK_DEV_INITRD
|
|
|
|
static void __init early_init_dt_check_for_initrd(unsigned long node)
|
|
|
|
{
|
|
|
|
unsigned long l;
|
|
|
|
u32 *prop;
|
|
|
|
|
|
|
|
DBG("Looking for initrd properties... ");
|
|
|
|
|
|
|
|
prop = of_get_flat_dt_prop(node, "linux,initrd-start", &l);
|
|
|
|
if (prop) {
|
|
|
|
initrd_start = (unsigned long)__va(of_read_ulong(prop, l/4));
|
|
|
|
|
|
|
|
prop = of_get_flat_dt_prop(node, "linux,initrd-end", &l);
|
|
|
|
if (prop) {
|
|
|
|
initrd_end = (unsigned long)
|
|
|
|
__va(of_read_ulong(prop, l/4));
|
|
|
|
initrd_below_start_ok = 1;
|
|
|
|
} else {
|
|
|
|
initrd_start = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
DBG("initrd_start=0x%lx initrd_end=0x%lx\n", initrd_start, initrd_end);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static inline void early_init_dt_check_for_initrd(unsigned long node)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_BLK_DEV_INITRD */
|
|
|
|
|
2005-10-06 04:06:20 +02:00
|
|
|
static int __init early_init_dt_scan_chosen(unsigned long node,
|
|
|
|
const char *uname, int depth, void *data)
|
|
|
|
{
|
|
|
|
unsigned long *lprop;
|
2006-02-24 17:54:52 +01:00
|
|
|
unsigned long l;
|
|
|
|
char *p;
|
2005-10-06 04:06:20 +02:00
|
|
|
|
|
|
|
DBG("search \"chosen\", depth: %d, uname: %s\n", depth, uname);
|
|
|
|
|
2005-10-23 09:23:21 +02:00
|
|
|
if (depth != 1 ||
|
|
|
|
(strcmp(uname, "chosen") != 0 && strcmp(uname, "chosen@0") != 0))
|
2005-10-06 04:06:20 +02:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
#ifdef CONFIG_PPC64
|
|
|
|
/* check if iommu is forced on or off */
|
2005-11-07 01:06:55 +01:00
|
|
|
if (of_get_flat_dt_prop(node, "linux,iommu-off", NULL) != NULL)
|
2005-10-06 04:06:20 +02:00
|
|
|
iommu_is_off = 1;
|
2005-11-07 01:06:55 +01:00
|
|
|
if (of_get_flat_dt_prop(node, "linux,iommu-force-on", NULL) != NULL)
|
2005-10-06 04:06:20 +02:00
|
|
|
iommu_force_on = 1;
|
|
|
|
#endif
|
|
|
|
|
2006-05-17 10:00:46 +02:00
|
|
|
/* mem=x on the command line is the preferred mechanism */
|
2005-11-07 01:06:55 +01:00
|
|
|
lprop = of_get_flat_dt_prop(node, "linux,memory-limit", NULL);
|
2005-10-06 04:06:20 +02:00
|
|
|
if (lprop)
|
|
|
|
memory_limit = *lprop;
|
|
|
|
|
|
|
|
#ifdef CONFIG_PPC64
|
2005-11-07 01:06:55 +01:00
|
|
|
lprop = of_get_flat_dt_prop(node, "linux,tce-alloc-start", NULL);
|
2005-10-06 04:06:20 +02:00
|
|
|
if (lprop)
|
|
|
|
tce_alloc_start = *lprop;
|
2005-11-07 01:06:55 +01:00
|
|
|
lprop = of_get_flat_dt_prop(node, "linux,tce-alloc-end", NULL);
|
2005-10-06 04:06:20 +02:00
|
|
|
if (lprop)
|
|
|
|
tce_alloc_end = *lprop;
|
|
|
|
#endif
|
|
|
|
|
2005-12-04 08:39:48 +01:00
|
|
|
#ifdef CONFIG_KEXEC
|
2009-01-06 14:54:25 +01:00
|
|
|
lprop = of_get_flat_dt_prop(node, "linux,crashkernel-base", NULL);
|
2007-09-06 19:46:15 +02:00
|
|
|
if (lprop)
|
|
|
|
crashk_res.start = *lprop;
|
2005-12-04 08:39:48 +01:00
|
|
|
|
2009-01-06 14:54:25 +01:00
|
|
|
lprop = of_get_flat_dt_prop(node, "linux,crashkernel-size", NULL);
|
2007-09-06 19:46:15 +02:00
|
|
|
if (lprop)
|
|
|
|
crashk_res.end = crashk_res.start + *lprop - 1;
|
2005-12-04 08:39:48 +01:00
|
|
|
#endif
|
|
|
|
|
2007-05-10 09:06:30 +02:00
|
|
|
early_init_dt_check_for_initrd(node);
|
2007-02-28 04:12:29 +01:00
|
|
|
|
2006-02-24 17:54:52 +01:00
|
|
|
/* Retreive command line */
|
|
|
|
p = of_get_flat_dt_prop(node, "bootargs", &l);
|
|
|
|
if (p != NULL && l > 0)
|
|
|
|
strlcpy(cmd_line, p, min((int)l, COMMAND_LINE_SIZE));
|
|
|
|
|
|
|
|
#ifdef CONFIG_CMDLINE
|
2006-10-05 20:35:16 +02:00
|
|
|
if (p == NULL || l == 0 || (l == 1 && (*p) == 0))
|
2006-02-24 17:54:52 +01:00
|
|
|
strlcpy(cmd_line, CONFIG_CMDLINE, COMMAND_LINE_SIZE);
|
|
|
|
#endif /* CONFIG_CMDLINE */
|
|
|
|
|
|
|
|
DBG("Command line is: %s\n", cmd_line);
|
|
|
|
|
2005-10-06 04:06:20 +02:00
|
|
|
/* break now */
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __init early_init_dt_scan_root(unsigned long node,
|
|
|
|
const char *uname, int depth, void *data)
|
|
|
|
{
|
|
|
|
u32 *prop;
|
|
|
|
|
|
|
|
if (depth != 0)
|
|
|
|
return 0;
|
|
|
|
|
2005-11-07 01:06:55 +01:00
|
|
|
prop = of_get_flat_dt_prop(node, "#size-cells", NULL);
|
2005-10-06 04:06:20 +02:00
|
|
|
dt_root_size_cells = (prop == NULL) ? 1 : *prop;
|
|
|
|
DBG("dt_root_size_cells = %x\n", dt_root_size_cells);
|
|
|
|
|
2005-11-07 01:06:55 +01:00
|
|
|
prop = of_get_flat_dt_prop(node, "#address-cells", NULL);
|
2005-10-06 04:06:20 +02:00
|
|
|
dt_root_addr_cells = (prop == NULL) ? 2 : *prop;
|
|
|
|
DBG("dt_root_addr_cells = %x\n", dt_root_addr_cells);
|
|
|
|
|
|
|
|
/* break now */
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2008-02-15 19:17:14 +01:00
|
|
|
static u64 __init dt_mem_next_cell(int s, cell_t **cellp)
|
2005-10-06 04:06:20 +02:00
|
|
|
{
|
|
|
|
cell_t *p = *cellp;
|
|
|
|
|
2006-09-19 06:06:27 +02:00
|
|
|
*cellp = p + s;
|
2008-02-15 19:17:14 +01:00
|
|
|
return of_read_number(p, s);
|
2005-10-06 04:06:20 +02:00
|
|
|
}
|
|
|
|
|
[POWERPC] Support ibm,dynamic-reconfiguration-memory nodes
For PAPR partitions with large amounts of memory, the firmware has an
alternative, more compact representation for the information about the
memory in the partition and its NUMA associativity information. This
adds the code to the kernel to parse this alternative representation.
The other part of this patch is telling the firmware that we can
handle the alternative representation. There is however a subtlety
here, because the firmware will invoke a reboot if the memory
representation we request is different from the representation that
firmware is currently using. This is because firmware can't change
the representation on the fly. Further, some firmware versions used
on POWER5+ machines have a bug where this reboot leaves the machine
with an altered value of load-base, which will prevent any kernel
booting until it is reset to the normal value (0x4000). Because of
this bug, we do NOT set fake_elf.rpanote.new_mem_def = 1, and thus we
do not request the new representation on POWER5+ and earlier machines.
We do request the new representation on POWER6, which uses the
ibm,client-architecture-support call.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-11-29 12:27:42 +01:00
|
|
|
#ifdef CONFIG_PPC_PSERIES
|
|
|
|
/*
|
|
|
|
* Interpret the ibm,dynamic-memory property in the
|
|
|
|
* /ibm,dynamic-reconfiguration-memory node.
|
|
|
|
* This contains a list of memory blocks along with NUMA affinity
|
|
|
|
* information.
|
|
|
|
*/
|
|
|
|
static int __init early_init_dt_scan_drconf_memory(unsigned long node)
|
|
|
|
{
|
powerpc: Add support for dynamic reconfiguration memory in kexec/kdump kernels
Kdump kernel needs to use only those memory regions that it is allowed
to use (crashkernel, rtas, tce, etc.). Each of these regions have
their own sizes and are currently added under 'linux,usable-memory'
property under each memory@xxx node of the device tree.
The ibm,dynamic-memory property of ibm,dynamic-reconfiguration-memory
node (on POWER6) now stores in it the representation for most of the
logical memory blocks with the size of each memory block being a
constant (lmb_size). If one or more or part of the above mentioned
regions lie under one of the lmb from ibm,dynamic-memory property,
there is a need to identify those regions within the given lmb.
This makes the kernel recognize a new 'linux,drconf-usable-memory'
property added by kexec-tools. Each entry in this property is of the
form of a count followed by that many (base, size) pairs for the above
mentioned regions. The number of cells in the count value is given by
the #size-cells property of the root node.
Signed-off-by: Chandru Siddalingappa <chandru@in.ibm.com>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2008-08-29 16:28:16 +02:00
|
|
|
cell_t *dm, *ls, *usm;
|
2008-02-15 19:17:14 +01:00
|
|
|
unsigned long l, n, flags;
|
|
|
|
u64 base, size, lmb_size;
|
powerpc: Add support for dynamic reconfiguration memory in kexec/kdump kernels
Kdump kernel needs to use only those memory regions that it is allowed
to use (crashkernel, rtas, tce, etc.). Each of these regions have
their own sizes and are currently added under 'linux,usable-memory'
property under each memory@xxx node of the device tree.
The ibm,dynamic-memory property of ibm,dynamic-reconfiguration-memory
node (on POWER6) now stores in it the representation for most of the
logical memory blocks with the size of each memory block being a
constant (lmb_size). If one or more or part of the above mentioned
regions lie under one of the lmb from ibm,dynamic-memory property,
there is a need to identify those regions within the given lmb.
This makes the kernel recognize a new 'linux,drconf-usable-memory'
property added by kexec-tools. Each entry in this property is of the
form of a count followed by that many (base, size) pairs for the above
mentioned regions. The number of cells in the count value is given by
the #size-cells property of the root node.
Signed-off-by: Chandru Siddalingappa <chandru@in.ibm.com>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2008-08-29 16:28:16 +02:00
|
|
|
unsigned int is_kexec_kdump = 0, rngs;
|
[POWERPC] Support ibm,dynamic-reconfiguration-memory nodes
For PAPR partitions with large amounts of memory, the firmware has an
alternative, more compact representation for the information about the
memory in the partition and its NUMA associativity information. This
adds the code to the kernel to parse this alternative representation.
The other part of this patch is telling the firmware that we can
handle the alternative representation. There is however a subtlety
here, because the firmware will invoke a reboot if the memory
representation we request is different from the representation that
firmware is currently using. This is because firmware can't change
the representation on the fly. Further, some firmware versions used
on POWER5+ machines have a bug where this reboot leaves the machine
with an altered value of load-base, which will prevent any kernel
booting until it is reset to the normal value (0x4000). Because of
this bug, we do NOT set fake_elf.rpanote.new_mem_def = 1, and thus we
do not request the new representation on POWER5+ and earlier machines.
We do request the new representation on POWER6, which uses the
ibm,client-architecture-support call.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-11-29 12:27:42 +01:00
|
|
|
|
2009-01-06 14:54:25 +01:00
|
|
|
ls = of_get_flat_dt_prop(node, "ibm,lmb-size", &l);
|
[POWERPC] Support ibm,dynamic-reconfiguration-memory nodes
For PAPR partitions with large amounts of memory, the firmware has an
alternative, more compact representation for the information about the
memory in the partition and its NUMA associativity information. This
adds the code to the kernel to parse this alternative representation.
The other part of this patch is telling the firmware that we can
handle the alternative representation. There is however a subtlety
here, because the firmware will invoke a reboot if the memory
representation we request is different from the representation that
firmware is currently using. This is because firmware can't change
the representation on the fly. Further, some firmware versions used
on POWER5+ machines have a bug where this reboot leaves the machine
with an altered value of load-base, which will prevent any kernel
booting until it is reset to the normal value (0x4000). Because of
this bug, we do NOT set fake_elf.rpanote.new_mem_def = 1, and thus we
do not request the new representation on POWER5+ and earlier machines.
We do request the new representation on POWER6, which uses the
ibm,client-architecture-support call.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-11-29 12:27:42 +01:00
|
|
|
if (ls == NULL || l < dt_root_size_cells * sizeof(cell_t))
|
|
|
|
return 0;
|
|
|
|
lmb_size = dt_mem_next_cell(dt_root_size_cells, &ls);
|
|
|
|
|
2009-01-06 14:54:25 +01:00
|
|
|
dm = of_get_flat_dt_prop(node, "ibm,dynamic-memory", &l);
|
[POWERPC] Support ibm,dynamic-reconfiguration-memory nodes
For PAPR partitions with large amounts of memory, the firmware has an
alternative, more compact representation for the information about the
memory in the partition and its NUMA associativity information. This
adds the code to the kernel to parse this alternative representation.
The other part of this patch is telling the firmware that we can
handle the alternative representation. There is however a subtlety
here, because the firmware will invoke a reboot if the memory
representation we request is different from the representation that
firmware is currently using. This is because firmware can't change
the representation on the fly. Further, some firmware versions used
on POWER5+ machines have a bug where this reboot leaves the machine
with an altered value of load-base, which will prevent any kernel
booting until it is reset to the normal value (0x4000). Because of
this bug, we do NOT set fake_elf.rpanote.new_mem_def = 1, and thus we
do not request the new representation on POWER5+ and earlier machines.
We do request the new representation on POWER6, which uses the
ibm,client-architecture-support call.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-11-29 12:27:42 +01:00
|
|
|
if (dm == NULL || l < sizeof(cell_t))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
n = *dm++; /* number of entries */
|
|
|
|
if (l < (n * (dt_root_addr_cells + 4) + 1) * sizeof(cell_t))
|
|
|
|
return 0;
|
|
|
|
|
powerpc: Add support for dynamic reconfiguration memory in kexec/kdump kernels
Kdump kernel needs to use only those memory regions that it is allowed
to use (crashkernel, rtas, tce, etc.). Each of these regions have
their own sizes and are currently added under 'linux,usable-memory'
property under each memory@xxx node of the device tree.
The ibm,dynamic-memory property of ibm,dynamic-reconfiguration-memory
node (on POWER6) now stores in it the representation for most of the
logical memory blocks with the size of each memory block being a
constant (lmb_size). If one or more or part of the above mentioned
regions lie under one of the lmb from ibm,dynamic-memory property,
there is a need to identify those regions within the given lmb.
This makes the kernel recognize a new 'linux,drconf-usable-memory'
property added by kexec-tools. Each entry in this property is of the
form of a count followed by that many (base, size) pairs for the above
mentioned regions. The number of cells in the count value is given by
the #size-cells property of the root node.
Signed-off-by: Chandru Siddalingappa <chandru@in.ibm.com>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2008-08-29 16:28:16 +02:00
|
|
|
/* check if this is a kexec/kdump kernel. */
|
2009-01-06 14:54:25 +01:00
|
|
|
usm = of_get_flat_dt_prop(node, "linux,drconf-usable-memory",
|
powerpc: Add support for dynamic reconfiguration memory in kexec/kdump kernels
Kdump kernel needs to use only those memory regions that it is allowed
to use (crashkernel, rtas, tce, etc.). Each of these regions have
their own sizes and are currently added under 'linux,usable-memory'
property under each memory@xxx node of the device tree.
The ibm,dynamic-memory property of ibm,dynamic-reconfiguration-memory
node (on POWER6) now stores in it the representation for most of the
logical memory blocks with the size of each memory block being a
constant (lmb_size). If one or more or part of the above mentioned
regions lie under one of the lmb from ibm,dynamic-memory property,
there is a need to identify those regions within the given lmb.
This makes the kernel recognize a new 'linux,drconf-usable-memory'
property added by kexec-tools. Each entry in this property is of the
form of a count followed by that many (base, size) pairs for the above
mentioned regions. The number of cells in the count value is given by
the #size-cells property of the root node.
Signed-off-by: Chandru Siddalingappa <chandru@in.ibm.com>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2008-08-29 16:28:16 +02:00
|
|
|
&l);
|
|
|
|
if (usm != NULL)
|
|
|
|
is_kexec_kdump = 1;
|
|
|
|
|
[POWERPC] Support ibm,dynamic-reconfiguration-memory nodes
For PAPR partitions with large amounts of memory, the firmware has an
alternative, more compact representation for the information about the
memory in the partition and its NUMA associativity information. This
adds the code to the kernel to parse this alternative representation.
The other part of this patch is telling the firmware that we can
handle the alternative representation. There is however a subtlety
here, because the firmware will invoke a reboot if the memory
representation we request is different from the representation that
firmware is currently using. This is because firmware can't change
the representation on the fly. Further, some firmware versions used
on POWER5+ machines have a bug where this reboot leaves the machine
with an altered value of load-base, which will prevent any kernel
booting until it is reset to the normal value (0x4000). Because of
this bug, we do NOT set fake_elf.rpanote.new_mem_def = 1, and thus we
do not request the new representation on POWER5+ and earlier machines.
We do request the new representation on POWER6, which uses the
ibm,client-architecture-support call.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-11-29 12:27:42 +01:00
|
|
|
for (; n != 0; --n) {
|
|
|
|
base = dt_mem_next_cell(dt_root_addr_cells, &dm);
|
|
|
|
flags = dm[3];
|
|
|
|
/* skip DRC index, pad, assoc. list index, flags */
|
|
|
|
dm += 4;
|
|
|
|
/* skip this block if the reserved bit is set in flags (0x80)
|
|
|
|
or if the block is not assigned to this partition (0x8) */
|
|
|
|
if ((flags & 0x80) || !(flags & 0x8))
|
|
|
|
continue;
|
|
|
|
size = lmb_size;
|
powerpc: Add support for dynamic reconfiguration memory in kexec/kdump kernels
Kdump kernel needs to use only those memory regions that it is allowed
to use (crashkernel, rtas, tce, etc.). Each of these regions have
their own sizes and are currently added under 'linux,usable-memory'
property under each memory@xxx node of the device tree.
The ibm,dynamic-memory property of ibm,dynamic-reconfiguration-memory
node (on POWER6) now stores in it the representation for most of the
logical memory blocks with the size of each memory block being a
constant (lmb_size). If one or more or part of the above mentioned
regions lie under one of the lmb from ibm,dynamic-memory property,
there is a need to identify those regions within the given lmb.
This makes the kernel recognize a new 'linux,drconf-usable-memory'
property added by kexec-tools. Each entry in this property is of the
form of a count followed by that many (base, size) pairs for the above
mentioned regions. The number of cells in the count value is given by
the #size-cells property of the root node.
Signed-off-by: Chandru Siddalingappa <chandru@in.ibm.com>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2008-08-29 16:28:16 +02:00
|
|
|
rngs = 1;
|
|
|
|
if (is_kexec_kdump) {
|
|
|
|
/*
|
|
|
|
* For each lmb in ibm,dynamic-memory, a corresponding
|
|
|
|
* entry in linux,drconf-usable-memory property contains
|
|
|
|
* a counter 'p' followed by 'p' (base, size) duple.
|
|
|
|
* Now read the counter from
|
|
|
|
* linux,drconf-usable-memory property
|
|
|
|
*/
|
|
|
|
rngs = dt_mem_next_cell(dt_root_size_cells, &usm);
|
|
|
|
if (!rngs) /* there are no (base, size) duple */
|
[POWERPC] Support ibm,dynamic-reconfiguration-memory nodes
For PAPR partitions with large amounts of memory, the firmware has an
alternative, more compact representation for the information about the
memory in the partition and its NUMA associativity information. This
adds the code to the kernel to parse this alternative representation.
The other part of this patch is telling the firmware that we can
handle the alternative representation. There is however a subtlety
here, because the firmware will invoke a reboot if the memory
representation we request is different from the representation that
firmware is currently using. This is because firmware can't change
the representation on the fly. Further, some firmware versions used
on POWER5+ machines have a bug where this reboot leaves the machine
with an altered value of load-base, which will prevent any kernel
booting until it is reset to the normal value (0x4000). Because of
this bug, we do NOT set fake_elf.rpanote.new_mem_def = 1, and thus we
do not request the new representation on POWER5+ and earlier machines.
We do request the new representation on POWER6, which uses the
ibm,client-architecture-support call.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-11-29 12:27:42 +01:00
|
|
|
continue;
|
|
|
|
}
|
powerpc: Add support for dynamic reconfiguration memory in kexec/kdump kernels
Kdump kernel needs to use only those memory regions that it is allowed
to use (crashkernel, rtas, tce, etc.). Each of these regions have
their own sizes and are currently added under 'linux,usable-memory'
property under each memory@xxx node of the device tree.
The ibm,dynamic-memory property of ibm,dynamic-reconfiguration-memory
node (on POWER6) now stores in it the representation for most of the
logical memory blocks with the size of each memory block being a
constant (lmb_size). If one or more or part of the above mentioned
regions lie under one of the lmb from ibm,dynamic-memory property,
there is a need to identify those regions within the given lmb.
This makes the kernel recognize a new 'linux,drconf-usable-memory'
property added by kexec-tools. Each entry in this property is of the
form of a count followed by that many (base, size) pairs for the above
mentioned regions. The number of cells in the count value is given by
the #size-cells property of the root node.
Signed-off-by: Chandru Siddalingappa <chandru@in.ibm.com>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2008-08-29 16:28:16 +02:00
|
|
|
do {
|
|
|
|
if (is_kexec_kdump) {
|
|
|
|
base = dt_mem_next_cell(dt_root_addr_cells,
|
|
|
|
&usm);
|
|
|
|
size = dt_mem_next_cell(dt_root_size_cells,
|
|
|
|
&usm);
|
|
|
|
}
|
|
|
|
if (iommu_is_off) {
|
|
|
|
if (base >= 0x80000000ul)
|
|
|
|
continue;
|
|
|
|
if ((base + size) > 0x80000000ul)
|
|
|
|
size = 0x80000000ul - base;
|
|
|
|
}
|
|
|
|
lmb_add(base, size);
|
|
|
|
} while (--rngs);
|
[POWERPC] Support ibm,dynamic-reconfiguration-memory nodes
For PAPR partitions with large amounts of memory, the firmware has an
alternative, more compact representation for the information about the
memory in the partition and its NUMA associativity information. This
adds the code to the kernel to parse this alternative representation.
The other part of this patch is telling the firmware that we can
handle the alternative representation. There is however a subtlety
here, because the firmware will invoke a reboot if the memory
representation we request is different from the representation that
firmware is currently using. This is because firmware can't change
the representation on the fly. Further, some firmware versions used
on POWER5+ machines have a bug where this reboot leaves the machine
with an altered value of load-base, which will prevent any kernel
booting until it is reset to the normal value (0x4000). Because of
this bug, we do NOT set fake_elf.rpanote.new_mem_def = 1, and thus we
do not request the new representation on POWER5+ and earlier machines.
We do request the new representation on POWER6, which uses the
ibm,client-architecture-support call.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-11-29 12:27:42 +01:00
|
|
|
}
|
|
|
|
lmb_dump_all();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
#define early_init_dt_scan_drconf_memory(node) 0
|
|
|
|
#endif /* CONFIG_PPC_PSERIES */
|
2005-10-06 04:06:20 +02:00
|
|
|
|
|
|
|
static int __init early_init_dt_scan_memory(unsigned long node,
|
|
|
|
const char *uname, int depth, void *data)
|
|
|
|
{
|
2005-11-07 01:06:55 +01:00
|
|
|
char *type = of_get_flat_dt_prop(node, "device_type", NULL);
|
2005-10-06 04:06:20 +02:00
|
|
|
cell_t *reg, *endp;
|
|
|
|
unsigned long l;
|
|
|
|
|
[POWERPC] Support ibm,dynamic-reconfiguration-memory nodes
For PAPR partitions with large amounts of memory, the firmware has an
alternative, more compact representation for the information about the
memory in the partition and its NUMA associativity information. This
adds the code to the kernel to parse this alternative representation.
The other part of this patch is telling the firmware that we can
handle the alternative representation. There is however a subtlety
here, because the firmware will invoke a reboot if the memory
representation we request is different from the representation that
firmware is currently using. This is because firmware can't change
the representation on the fly. Further, some firmware versions used
on POWER5+ machines have a bug where this reboot leaves the machine
with an altered value of load-base, which will prevent any kernel
booting until it is reset to the normal value (0x4000). Because of
this bug, we do NOT set fake_elf.rpanote.new_mem_def = 1, and thus we
do not request the new representation on POWER5+ and earlier machines.
We do request the new representation on POWER6, which uses the
ibm,client-architecture-support call.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-11-29 12:27:42 +01:00
|
|
|
/* Look for the ibm,dynamic-reconfiguration-memory node */
|
|
|
|
if (depth == 1 &&
|
|
|
|
strcmp(uname, "ibm,dynamic-reconfiguration-memory") == 0)
|
|
|
|
return early_init_dt_scan_drconf_memory(node);
|
|
|
|
|
2005-10-06 04:06:20 +02:00
|
|
|
/* We are scanning "memory" nodes only */
|
2005-11-10 02:00:55 +01:00
|
|
|
if (type == NULL) {
|
|
|
|
/*
|
|
|
|
* The longtrail doesn't have a device_type on the
|
|
|
|
* /memory node, so look for the node called /memory@0.
|
|
|
|
*/
|
|
|
|
if (depth != 1 || strcmp(uname, "memory@0") != 0)
|
|
|
|
return 0;
|
|
|
|
} else if (strcmp(type, "memory") != 0)
|
2005-10-06 04:06:20 +02:00
|
|
|
return 0;
|
|
|
|
|
2009-01-06 14:54:25 +01:00
|
|
|
reg = of_get_flat_dt_prop(node, "linux,usable-memory", &l);
|
2005-12-04 08:39:55 +01:00
|
|
|
if (reg == NULL)
|
2009-01-06 14:54:25 +01:00
|
|
|
reg = of_get_flat_dt_prop(node, "reg", &l);
|
2005-10-06 04:06:20 +02:00
|
|
|
if (reg == NULL)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
endp = reg + (l / sizeof(cell_t));
|
|
|
|
|
2005-11-03 05:39:09 +01:00
|
|
|
DBG("memory scan node %s, reg size %ld, data: %x %x %x %x,\n",
|
2005-10-06 04:06:20 +02:00
|
|
|
uname, l, reg[0], reg[1], reg[2], reg[3]);
|
|
|
|
|
|
|
|
while ((endp - reg) >= (dt_root_addr_cells + dt_root_size_cells)) {
|
2008-02-15 19:17:14 +01:00
|
|
|
u64 base, size;
|
2005-10-06 04:06:20 +02:00
|
|
|
|
|
|
|
base = dt_mem_next_cell(dt_root_addr_cells, ®);
|
|
|
|
size = dt_mem_next_cell(dt_root_size_cells, ®);
|
|
|
|
|
|
|
|
if (size == 0)
|
|
|
|
continue;
|
2008-02-15 19:17:14 +01:00
|
|
|
DBG(" - %llx , %llx\n", (unsigned long long)base,
|
|
|
|
(unsigned long long)size);
|
2005-10-06 04:06:20 +02:00
|
|
|
#ifdef CONFIG_PPC64
|
|
|
|
if (iommu_is_off) {
|
|
|
|
if (base >= 0x80000000ul)
|
|
|
|
continue;
|
|
|
|
if ((base + size) > 0x80000000ul)
|
|
|
|
size = 0x80000000ul - base;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
lmb_add(base, size);
|
2008-04-21 20:22:34 +02:00
|
|
|
|
|
|
|
memstart_addr = min((u64)memstart_addr, base);
|
2005-10-06 04:06:20 +02:00
|
|
|
}
|
2008-04-21 20:22:34 +02:00
|
|
|
|
2005-10-06 04:06:20 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __init early_reserve_mem(void)
|
|
|
|
{
|
2006-01-12 00:57:13 +01:00
|
|
|
u64 base, size;
|
|
|
|
u64 *reserve_map;
|
2006-06-18 00:51:09 +02:00
|
|
|
unsigned long self_base;
|
|
|
|
unsigned long self_size;
|
2005-10-06 04:06:20 +02:00
|
|
|
|
2006-01-12 00:57:13 +01:00
|
|
|
reserve_map = (u64 *)(((unsigned long)initial_boot_params) +
|
2005-10-06 04:06:20 +02:00
|
|
|
initial_boot_params->off_mem_rsvmap);
|
2006-05-19 00:03:05 +02:00
|
|
|
|
|
|
|
/* before we do anything, lets reserve the dt blob */
|
2006-06-18 00:51:09 +02:00
|
|
|
self_base = __pa((unsigned long)initial_boot_params);
|
|
|
|
self_size = initial_boot_params->totalsize;
|
|
|
|
lmb_reserve(self_base, self_size);
|
2006-05-19 00:03:05 +02:00
|
|
|
|
2007-02-28 04:12:29 +01:00
|
|
|
#ifdef CONFIG_BLK_DEV_INITRD
|
|
|
|
/* then reserve the initrd, if any */
|
|
|
|
if (initrd_start && (initrd_end > initrd_start))
|
|
|
|
lmb_reserve(__pa(initrd_start), initrd_end - initrd_start);
|
|
|
|
#endif /* CONFIG_BLK_DEV_INITRD */
|
|
|
|
|
2006-01-12 00:57:13 +01:00
|
|
|
#ifdef CONFIG_PPC32
|
|
|
|
/*
|
|
|
|
* Handle the case where we might be booting from an old kexec
|
|
|
|
* image that setup the mem_rsvmap as pairs of 32-bit values
|
|
|
|
*/
|
|
|
|
if (*reserve_map > 0xffffffffull) {
|
|
|
|
u32 base_32, size_32;
|
|
|
|
u32 *reserve_map_32 = (u32 *)reserve_map;
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
base_32 = *(reserve_map_32++);
|
|
|
|
size_32 = *(reserve_map_32++);
|
|
|
|
if (size_32 == 0)
|
|
|
|
break;
|
2006-06-18 00:51:09 +02:00
|
|
|
/* skip if the reservation is for the blob */
|
|
|
|
if (base_32 == self_base && size_32 == self_size)
|
|
|
|
continue;
|
2006-02-24 17:54:52 +01:00
|
|
|
DBG("reserving: %x -> %x\n", base_32, size_32);
|
2006-01-12 00:57:13 +01:00
|
|
|
lmb_reserve(base_32, size_32);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
2005-10-06 04:06:20 +02:00
|
|
|
while (1) {
|
|
|
|
base = *(reserve_map++);
|
|
|
|
size = *(reserve_map++);
|
|
|
|
if (size == 0)
|
|
|
|
break;
|
2006-01-12 00:57:13 +01:00
|
|
|
DBG("reserving: %llx -> %llx\n", base, size);
|
2005-10-06 04:06:20 +02:00
|
|
|
lmb_reserve(base, size);
|
|
|
|
}
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
DBG("memory reserved, lmbs :\n");
|
|
|
|
lmb_dump_all();
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2008-03-22 00:37:08 +01:00
|
|
|
#ifdef CONFIG_PHYP_DUMP
|
2008-04-12 01:31:52 +02:00
|
|
|
/**
|
|
|
|
* phyp_dump_calculate_reserve_size() - reserve variable boot area 5% or arg
|
|
|
|
*
|
|
|
|
* Function to find the largest size we need to reserve
|
|
|
|
* during early boot process.
|
|
|
|
*
|
|
|
|
* It either looks for boot param and returns that OR
|
|
|
|
* returns larger of 256 or 5% rounded down to multiples of 256MB.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static inline unsigned long phyp_dump_calculate_reserve_size(void)
|
|
|
|
{
|
|
|
|
unsigned long tmp;
|
|
|
|
|
|
|
|
if (phyp_dump_info->reserve_bootvar)
|
|
|
|
return phyp_dump_info->reserve_bootvar;
|
|
|
|
|
|
|
|
/* divide by 20 to get 5% of value */
|
|
|
|
tmp = lmb_end_of_DRAM();
|
|
|
|
do_div(tmp, 20);
|
|
|
|
|
|
|
|
/* round it down in multiples of 256 */
|
|
|
|
tmp = tmp & ~0x0FFFFFFFUL;
|
|
|
|
|
|
|
|
return (tmp > PHYP_DUMP_RMR_END ? tmp : PHYP_DUMP_RMR_END);
|
|
|
|
}
|
|
|
|
|
2008-03-22 00:37:08 +01:00
|
|
|
/**
|
|
|
|
* phyp_dump_reserve_mem() - reserve all not-yet-dumped mmemory
|
|
|
|
*
|
|
|
|
* This routine may reserve memory regions in the kernel only
|
|
|
|
* if the system is supported and a dump was taken in last
|
|
|
|
* boot instance or if the hardware is supported and the
|
|
|
|
* scratch area needs to be setup. In other instances it returns
|
|
|
|
* without reserving anything. The memory in case of dump being
|
|
|
|
* active is freed when the dump is collected (by userland tools).
|
|
|
|
*/
|
|
|
|
static void __init phyp_dump_reserve_mem(void)
|
|
|
|
{
|
|
|
|
unsigned long base, size;
|
2008-04-12 01:31:52 +02:00
|
|
|
unsigned long variable_reserve_size;
|
|
|
|
|
2008-03-22 00:37:08 +01:00
|
|
|
if (!phyp_dump_info->phyp_dump_configured) {
|
|
|
|
printk(KERN_ERR "Phyp-dump not supported on this hardware\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-03-22 01:38:59 +01:00
|
|
|
if (!phyp_dump_info->phyp_dump_at_boot) {
|
|
|
|
printk(KERN_INFO "Phyp-dump disabled at boot time\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-04-12 01:31:52 +02:00
|
|
|
variable_reserve_size = phyp_dump_calculate_reserve_size();
|
|
|
|
|
2008-03-22 00:37:08 +01:00
|
|
|
if (phyp_dump_info->phyp_dump_is_active) {
|
|
|
|
/* Reserve *everything* above RMR.Area freed by userland tools*/
|
2008-04-12 01:31:52 +02:00
|
|
|
base = variable_reserve_size;
|
2008-03-22 00:37:08 +01:00
|
|
|
size = lmb_end_of_DRAM() - base;
|
|
|
|
|
|
|
|
/* XXX crashed_ram_end is wrong, since it may be beyond
|
|
|
|
* the memory_limit, it will need to be adjusted. */
|
|
|
|
lmb_reserve(base, size);
|
|
|
|
|
|
|
|
phyp_dump_info->init_reserve_start = base;
|
|
|
|
phyp_dump_info->init_reserve_size = size;
|
|
|
|
} else {
|
|
|
|
size = phyp_dump_info->cpu_state_size +
|
|
|
|
phyp_dump_info->hpte_region_size +
|
2008-04-12 01:31:52 +02:00
|
|
|
variable_reserve_size;
|
2008-03-22 00:37:08 +01:00
|
|
|
base = lmb_end_of_DRAM() - size;
|
|
|
|
lmb_reserve(base, size);
|
|
|
|
phyp_dump_info->init_reserve_start = base;
|
|
|
|
phyp_dump_info->init_reserve_size = size;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static inline void __init phyp_dump_reserve_mem(void) {}
|
|
|
|
#endif /* CONFIG_PHYP_DUMP && CONFIG_PPC_RTAS */
|
|
|
|
|
|
|
|
|
2005-10-06 04:06:20 +02:00
|
|
|
void __init early_init_devtree(void *params)
|
|
|
|
{
|
2008-11-26 17:19:26 +01:00
|
|
|
unsigned long limit;
|
|
|
|
|
2007-06-16 00:06:14 +02:00
|
|
|
DBG(" -> early_init_devtree(%p)\n", params);
|
2005-10-06 04:06:20 +02:00
|
|
|
|
|
|
|
/* Setup flat device-tree pointer */
|
|
|
|
initial_boot_params = params;
|
|
|
|
|
2006-06-23 10:20:13 +02:00
|
|
|
#ifdef CONFIG_PPC_RTAS
|
|
|
|
/* Some machines might need RTAS info for debugging, grab it now. */
|
|
|
|
of_scan_flat_dt(early_init_dt_scan_rtas, NULL);
|
|
|
|
#endif
|
|
|
|
|
2008-03-22 00:37:08 +01:00
|
|
|
#ifdef CONFIG_PHYP_DUMP
|
|
|
|
/* scan tree to see if dump occured during last boot */
|
|
|
|
of_scan_flat_dt(early_init_dt_scan_phyp_dump, NULL);
|
|
|
|
#endif
|
|
|
|
|
2005-10-06 04:06:20 +02:00
|
|
|
/* Retrieve various informations from the /chosen node of the
|
|
|
|
* device-tree, including the platform type, initrd location and
|
|
|
|
* size, TCE reserve, and more ...
|
|
|
|
*/
|
2005-11-07 01:06:55 +01:00
|
|
|
of_scan_flat_dt(early_init_dt_scan_chosen, NULL);
|
2005-10-06 04:06:20 +02:00
|
|
|
|
|
|
|
/* Scan memory nodes and rebuild LMBs */
|
|
|
|
lmb_init();
|
2005-11-07 01:06:55 +01:00
|
|
|
of_scan_flat_dt(early_init_dt_scan_root, NULL);
|
|
|
|
of_scan_flat_dt(early_init_dt_scan_memory, NULL);
|
2006-05-17 10:00:45 +02:00
|
|
|
|
|
|
|
/* Save command line for /proc/cmdline and then parse parameters */
|
2007-02-12 09:54:17 +01:00
|
|
|
strlcpy(boot_command_line, cmd_line, COMMAND_LINE_SIZE);
|
2006-05-17 10:00:45 +02:00
|
|
|
parse_early_param();
|
|
|
|
|
2005-10-06 04:06:20 +02:00
|
|
|
/* Reserve LMB regions used by kernel, initrd, dt, etc... */
|
2005-12-04 08:39:37 +01:00
|
|
|
lmb_reserve(PHYSICAL_START, __pa(klimit) - PHYSICAL_START);
|
powerpc: Make the 64-bit kernel as a position-independent executable
This implements CONFIG_RELOCATABLE for 64-bit by making the kernel as
a position-independent executable (PIE) when it is set. This involves
processing the dynamic relocations in the image in the early stages of
booting, even if the kernel is being run at the address it is linked at,
since the linker does not necessarily fill in words in the image for
which there are dynamic relocations. (In fact the linker does fill in
such words for 64-bit executables, though not for 32-bit executables,
so in principle we could avoid calling relocate() entirely when we're
running a 64-bit kernel at the linked address.)
The dynamic relocations are processed by a new function relocate(addr),
where the addr parameter is the virtual address where the image will be
run. In fact we call it twice; once before calling prom_init, and again
when starting the main kernel. This means that reloc_offset() returns
0 in prom_init (since it has been relocated to the address it is running
at), which necessitated a few adjustments.
This also changes __va and __pa to use an equivalent definition that is
simpler. With the relocatable kernel, PAGE_OFFSET and MEMORY_START are
constants (for 64-bit) whereas PHYSICAL_START is a variable (and
KERNELBASE ideally should be too, but isn't yet).
With this, relocatable kernels still copy themselves down to physical
address 0 and run there.
Signed-off-by: Paul Mackerras <paulus@samba.org>
2008-08-30 03:43:47 +02:00
|
|
|
/* If relocatable, reserve first 32k for interrupt vectors etc. */
|
|
|
|
if (PHYSICAL_START > MEMORY_START)
|
|
|
|
lmb_reserve(MEMORY_START, 0x8000);
|
2006-05-17 10:00:49 +02:00
|
|
|
reserve_kdump_trampoline();
|
2006-05-18 03:16:11 +02:00
|
|
|
reserve_crashkernel();
|
2005-10-06 04:06:20 +02:00
|
|
|
early_reserve_mem();
|
2008-03-22 00:37:08 +01:00
|
|
|
phyp_dump_reserve_mem();
|
2005-10-06 04:06:20 +02:00
|
|
|
|
2008-11-26 17:19:26 +01:00
|
|
|
limit = memory_limit;
|
|
|
|
if (! limit) {
|
|
|
|
unsigned long memsize;
|
|
|
|
|
|
|
|
/* Ensure that total memory size is page-aligned, because
|
|
|
|
* otherwise mark_bootmem() gets upset. */
|
|
|
|
lmb_analyze();
|
|
|
|
memsize = lmb_phys_mem_size();
|
|
|
|
if ((memsize & PAGE_MASK) != memsize)
|
|
|
|
limit = memsize & PAGE_MASK;
|
|
|
|
}
|
|
|
|
lmb_enforce_memory_limit(limit);
|
|
|
|
|
2006-05-17 10:00:46 +02:00
|
|
|
lmb_analyze();
|
|
|
|
|
|
|
|
DBG("Phys. mem: %lx\n", lmb_phys_mem_size());
|
|
|
|
|
|
|
|
/* We may need to relocate the flat tree, do it now.
|
|
|
|
* FIXME .. and the initrd too? */
|
|
|
|
move_device_tree();
|
|
|
|
|
2005-10-06 04:06:20 +02:00
|
|
|
DBG("Scanning CPUs ...\n");
|
|
|
|
|
2005-11-07 01:06:55 +01:00
|
|
|
/* Retreive CPU related informations from the flat tree
|
|
|
|
* (altivec support, boot CPU ID, ...)
|
2005-10-06 04:06:20 +02:00
|
|
|
*/
|
2005-11-07 01:06:55 +01:00
|
|
|
of_scan_flat_dt(early_init_dt_scan_cpus, NULL);
|
2005-10-06 04:06:20 +02:00
|
|
|
|
|
|
|
DBG(" <- early_init_devtree()\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Indicates whether the root node has a given value in its
|
|
|
|
* compatible property.
|
|
|
|
*/
|
|
|
|
int machine_is_compatible(const char *compat)
|
|
|
|
{
|
|
|
|
struct device_node *root;
|
|
|
|
int rc = 0;
|
|
|
|
|
|
|
|
root = of_find_node_by_path("/");
|
|
|
|
if (root) {
|
2007-04-03 02:55:39 +02:00
|
|
|
rc = of_device_is_compatible(root, compat);
|
2005-10-06 04:06:20 +02:00
|
|
|
of_node_put(root);
|
|
|
|
}
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(machine_is_compatible);
|
|
|
|
|
|
|
|
/*******
|
|
|
|
*
|
|
|
|
* New implementation of the OF "find" APIs, return a refcounted
|
|
|
|
* object, call of_node_put() when done. The device tree and list
|
|
|
|
* are protected by a rw_lock.
|
|
|
|
*
|
|
|
|
* Note that property management will need some locking as well,
|
|
|
|
* this isn't dealt with yet.
|
|
|
|
*
|
|
|
|
*******/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* of_find_node_by_phandle - Find a node given a phandle
|
|
|
|
* @handle: phandle of the node to find
|
|
|
|
*
|
|
|
|
* Returns a node pointer with refcount incremented, use
|
|
|
|
* of_node_put() on it when done.
|
|
|
|
*/
|
|
|
|
struct device_node *of_find_node_by_phandle(phandle handle)
|
|
|
|
{
|
|
|
|
struct device_node *np;
|
|
|
|
|
|
|
|
read_lock(&devtree_lock);
|
|
|
|
for (np = allnodes; np != 0; np = np->allnext)
|
|
|
|
if (np->linux_phandle == handle)
|
|
|
|
break;
|
2007-01-02 12:31:47 +01:00
|
|
|
of_node_get(np);
|
2005-10-06 04:06:20 +02:00
|
|
|
read_unlock(&devtree_lock);
|
|
|
|
return np;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_find_node_by_phandle);
|
|
|
|
|
2008-12-10 15:46:04 +01:00
|
|
|
/**
|
|
|
|
* of_find_next_cache_node - Find a node's subsidiary cache
|
|
|
|
* @np: node of type "cpu" or "cache"
|
|
|
|
*
|
|
|
|
* Returns a node pointer with refcount incremented, use
|
|
|
|
* of_node_put() on it when done. Caller should hold a reference
|
|
|
|
* to np.
|
|
|
|
*/
|
|
|
|
struct device_node *of_find_next_cache_node(struct device_node *np)
|
|
|
|
{
|
|
|
|
struct device_node *child;
|
|
|
|
const phandle *handle;
|
|
|
|
|
|
|
|
handle = of_get_property(np, "l2-cache", NULL);
|
|
|
|
if (!handle)
|
|
|
|
handle = of_get_property(np, "next-level-cache", NULL);
|
|
|
|
|
|
|
|
if (handle)
|
|
|
|
return of_find_node_by_phandle(*handle);
|
|
|
|
|
|
|
|
/* OF on pmac has nodes instead of properties named "l2-cache"
|
|
|
|
* beneath CPU nodes.
|
|
|
|
*/
|
|
|
|
if (!strcmp(np->type, "cpu"))
|
|
|
|
for_each_child_of_node(np, child)
|
|
|
|
if (!strcmp(child->type, "cache"))
|
|
|
|
return child;
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2005-10-06 04:06:20 +02:00
|
|
|
/**
|
|
|
|
* of_find_all_nodes - Get next node in global list
|
|
|
|
* @prev: Previous node or NULL to start iteration
|
|
|
|
* of_node_put() will be called on it
|
|
|
|
*
|
|
|
|
* Returns a node pointer with refcount incremented, use
|
|
|
|
* of_node_put() on it when done.
|
|
|
|
*/
|
|
|
|
struct device_node *of_find_all_nodes(struct device_node *prev)
|
|
|
|
{
|
|
|
|
struct device_node *np;
|
|
|
|
|
|
|
|
read_lock(&devtree_lock);
|
|
|
|
np = prev ? prev->allnext : allnodes;
|
|
|
|
for (; np != 0; np = np->allnext)
|
|
|
|
if (of_node_get(np))
|
|
|
|
break;
|
2007-01-02 12:31:47 +01:00
|
|
|
of_node_put(prev);
|
2005-10-06 04:06:20 +02:00
|
|
|
read_unlock(&devtree_lock);
|
|
|
|
return np;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_find_all_nodes);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* of_node_get - Increment refcount of a node
|
|
|
|
* @node: Node to inc refcount, NULL is supported to
|
|
|
|
* simplify writing of callers
|
|
|
|
*
|
|
|
|
* Returns node.
|
|
|
|
*/
|
|
|
|
struct device_node *of_node_get(struct device_node *node)
|
|
|
|
{
|
|
|
|
if (node)
|
|
|
|
kref_get(&node->kref);
|
|
|
|
return node;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_node_get);
|
|
|
|
|
|
|
|
static inline struct device_node * kref_to_device_node(struct kref *kref)
|
|
|
|
{
|
|
|
|
return container_of(kref, struct device_node, kref);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* of_node_release - release a dynamically allocated node
|
|
|
|
* @kref: kref element of the node to be released
|
|
|
|
*
|
|
|
|
* In of_node_put() this function is passed to kref_put()
|
|
|
|
* as the destructor.
|
|
|
|
*/
|
|
|
|
static void of_node_release(struct kref *kref)
|
|
|
|
{
|
|
|
|
struct device_node *node = kref_to_device_node(kref);
|
|
|
|
struct property *prop = node->properties;
|
|
|
|
|
2007-06-19 08:08:00 +02:00
|
|
|
/* We should never be releasing nodes that haven't been detached. */
|
|
|
|
if (!of_node_check_flag(node, OF_DETACHED)) {
|
|
|
|
printk("WARNING: Bad of_node_put() on %s\n", node->full_name);
|
|
|
|
dump_stack();
|
|
|
|
kref_init(&node->kref);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2007-06-19 08:07:58 +02:00
|
|
|
if (!of_node_check_flag(node, OF_DYNAMIC))
|
2005-10-06 04:06:20 +02:00
|
|
|
return;
|
2007-06-19 08:08:00 +02:00
|
|
|
|
2005-10-06 04:06:20 +02:00
|
|
|
while (prop) {
|
|
|
|
struct property *next = prop->next;
|
|
|
|
kfree(prop->name);
|
|
|
|
kfree(prop->value);
|
|
|
|
kfree(prop);
|
|
|
|
prop = next;
|
2006-01-12 23:08:27 +01:00
|
|
|
|
|
|
|
if (!prop) {
|
|
|
|
prop = node->deadprops;
|
|
|
|
node->deadprops = NULL;
|
|
|
|
}
|
2005-10-06 04:06:20 +02:00
|
|
|
}
|
|
|
|
kfree(node->full_name);
|
|
|
|
kfree(node->data);
|
|
|
|
kfree(node);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* of_node_put - Decrement refcount of a node
|
|
|
|
* @node: Node to dec refcount, NULL is supported to
|
|
|
|
* simplify writing of callers
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
void of_node_put(struct device_node *node)
|
|
|
|
{
|
|
|
|
if (node)
|
|
|
|
kref_put(&node->kref, of_node_release);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(of_node_put);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Plug a device node into the tree and global list.
|
|
|
|
*/
|
|
|
|
void of_attach_node(struct device_node *np)
|
|
|
|
{
|
2008-04-09 09:21:36 +02:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
write_lock_irqsave(&devtree_lock, flags);
|
2005-10-06 04:06:20 +02:00
|
|
|
np->sibling = np->parent->child;
|
|
|
|
np->allnext = allnodes;
|
|
|
|
np->parent->child = np;
|
|
|
|
allnodes = np;
|
2008-04-09 09:21:36 +02:00
|
|
|
write_unlock_irqrestore(&devtree_lock, flags);
|
2005-10-06 04:06:20 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* "Unplug" a node from the device tree. The caller must hold
|
|
|
|
* a reference to the node. The memory associated with the node
|
|
|
|
* is not freed until its refcount goes to zero.
|
|
|
|
*/
|
2007-07-20 07:58:38 +02:00
|
|
|
void of_detach_node(struct device_node *np)
|
2005-10-06 04:06:20 +02:00
|
|
|
{
|
|
|
|
struct device_node *parent;
|
2008-04-09 09:21:36 +02:00
|
|
|
unsigned long flags;
|
2005-10-06 04:06:20 +02:00
|
|
|
|
2008-04-09 09:21:36 +02:00
|
|
|
write_lock_irqsave(&devtree_lock, flags);
|
2005-10-06 04:06:20 +02:00
|
|
|
|
|
|
|
parent = np->parent;
|
2007-06-19 08:07:56 +02:00
|
|
|
if (!parent)
|
|
|
|
goto out_unlock;
|
2005-10-06 04:06:20 +02:00
|
|
|
|
|
|
|
if (allnodes == np)
|
|
|
|
allnodes = np->allnext;
|
|
|
|
else {
|
|
|
|
struct device_node *prev;
|
|
|
|
for (prev = allnodes;
|
|
|
|
prev->allnext != np;
|
|
|
|
prev = prev->allnext)
|
|
|
|
;
|
|
|
|
prev->allnext = np->allnext;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (parent->child == np)
|
|
|
|
parent->child = np->sibling;
|
|
|
|
else {
|
|
|
|
struct device_node *prevsib;
|
|
|
|
for (prevsib = np->parent->child;
|
|
|
|
prevsib->sibling != np;
|
|
|
|
prevsib = prevsib->sibling)
|
|
|
|
;
|
|
|
|
prevsib->sibling = np->sibling;
|
|
|
|
}
|
|
|
|
|
2007-06-19 08:08:00 +02:00
|
|
|
of_node_set_flag(np, OF_DETACHED);
|
|
|
|
|
2007-06-19 08:07:56 +02:00
|
|
|
out_unlock:
|
2008-04-09 09:21:36 +02:00
|
|
|
write_unlock_irqrestore(&devtree_lock, flags);
|
2005-10-06 04:06:20 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_PPC_PSERIES
|
|
|
|
/*
|
|
|
|
* Fix up the uninitialized fields in a new device node:
|
2006-07-03 13:36:01 +02:00
|
|
|
* name, type and pci-specific fields
|
2005-10-06 04:06:20 +02:00
|
|
|
*/
|
|
|
|
|
2005-12-13 08:01:21 +01:00
|
|
|
static int of_finish_dynamic_node(struct device_node *node)
|
2005-10-06 04:06:20 +02:00
|
|
|
{
|
|
|
|
struct device_node *parent = of_get_parent(node);
|
|
|
|
int err = 0;
|
2006-07-12 07:35:54 +02:00
|
|
|
const phandle *ibm_phandle;
|
2005-10-06 04:06:20 +02:00
|
|
|
|
2007-04-03 02:54:01 +02:00
|
|
|
node->name = of_get_property(node, "name", NULL);
|
|
|
|
node->type = of_get_property(node, "device_type", NULL);
|
2005-10-06 04:06:20 +02:00
|
|
|
|
2007-05-16 08:57:24 +02:00
|
|
|
if (!node->name)
|
|
|
|
node->name = "<NULL>";
|
|
|
|
if (!node->type)
|
|
|
|
node->type = "<NULL>";
|
|
|
|
|
2005-10-06 04:06:20 +02:00
|
|
|
if (!parent) {
|
|
|
|
err = -ENODEV;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We don't support that function on PowerMac, at least
|
|
|
|
* not yet
|
|
|
|
*/
|
2006-03-28 14:15:54 +02:00
|
|
|
if (machine_is(powermac))
|
2005-10-06 04:06:20 +02:00
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
/* fix up new node's linux_phandle field */
|
2007-04-03 02:54:01 +02:00
|
|
|
if ((ibm_phandle = of_get_property(node, "ibm,phandle", NULL)))
|
2005-10-06 04:06:20 +02:00
|
|
|
node->linux_phandle = *ibm_phandle;
|
|
|
|
|
|
|
|
out:
|
|
|
|
of_node_put(parent);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int prom_reconfig_notifier(struct notifier_block *nb,
|
|
|
|
unsigned long action, void *node)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
switch (action) {
|
|
|
|
case PSERIES_RECONFIG_ADD:
|
2005-12-13 08:01:21 +01:00
|
|
|
err = of_finish_dynamic_node(node);
|
2005-10-06 04:06:20 +02:00
|
|
|
if (err < 0) {
|
|
|
|
printk(KERN_ERR "finish_node returned %d\n", err);
|
|
|
|
err = NOTIFY_BAD;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
err = NOTIFY_DONE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct notifier_block prom_reconfig_nb = {
|
|
|
|
.notifier_call = prom_reconfig_notifier,
|
|
|
|
.priority = 10, /* This one needs to run first */
|
|
|
|
};
|
|
|
|
|
|
|
|
static int __init prom_reconfig_setup(void)
|
|
|
|
{
|
|
|
|
return pSeries_reconfig_notifier_register(&prom_reconfig_nb);
|
|
|
|
}
|
|
|
|
__initcall(prom_reconfig_setup);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Add a property to a node
|
|
|
|
*/
|
2005-11-07 04:29:02 +01:00
|
|
|
int prom_add_property(struct device_node* np, struct property* prop)
|
2005-10-06 04:06:20 +02:00
|
|
|
{
|
2005-11-07 04:29:02 +01:00
|
|
|
struct property **next;
|
2008-04-09 09:21:36 +02:00
|
|
|
unsigned long flags;
|
2005-10-06 04:06:20 +02:00
|
|
|
|
|
|
|
prop->next = NULL;
|
2008-04-09 09:21:36 +02:00
|
|
|
write_lock_irqsave(&devtree_lock, flags);
|
2005-11-07 04:29:02 +01:00
|
|
|
next = &np->properties;
|
|
|
|
while (*next) {
|
|
|
|
if (strcmp(prop->name, (*next)->name) == 0) {
|
|
|
|
/* duplicate ! don't insert it */
|
2008-04-09 09:21:36 +02:00
|
|
|
write_unlock_irqrestore(&devtree_lock, flags);
|
2005-11-07 04:29:02 +01:00
|
|
|
return -1;
|
|
|
|
}
|
2005-10-06 04:06:20 +02:00
|
|
|
next = &(*next)->next;
|
2005-11-07 04:29:02 +01:00
|
|
|
}
|
2005-10-06 04:06:20 +02:00
|
|
|
*next = prop;
|
2008-04-09 09:21:36 +02:00
|
|
|
write_unlock_irqrestore(&devtree_lock, flags);
|
2005-11-07 04:29:02 +01:00
|
|
|
|
2005-11-10 03:37:51 +01:00
|
|
|
#ifdef CONFIG_PROC_DEVICETREE
|
2005-11-07 04:29:02 +01:00
|
|
|
/* try to add to proc as well if it was initialized */
|
|
|
|
if (np->pde)
|
|
|
|
proc_device_tree_add_prop(np->pde, prop);
|
2005-11-10 03:37:51 +01:00
|
|
|
#endif /* CONFIG_PROC_DEVICETREE */
|
2005-11-07 04:29:02 +01:00
|
|
|
|
|
|
|
return 0;
|
2005-10-06 04:06:20 +02:00
|
|
|
}
|
|
|
|
|
2006-01-12 23:08:27 +01:00
|
|
|
/*
|
|
|
|
* Remove a property from a node. Note that we don't actually
|
|
|
|
* remove it, since we have given out who-knows-how-many pointers
|
|
|
|
* to the data using get-property. Instead we just move the property
|
|
|
|
* to the "dead properties" list, so it won't be found any more.
|
|
|
|
*/
|
|
|
|
int prom_remove_property(struct device_node *np, struct property *prop)
|
|
|
|
{
|
|
|
|
struct property **next;
|
2008-04-09 09:21:36 +02:00
|
|
|
unsigned long flags;
|
2006-01-12 23:08:27 +01:00
|
|
|
int found = 0;
|
|
|
|
|
2008-04-09 09:21:36 +02:00
|
|
|
write_lock_irqsave(&devtree_lock, flags);
|
2006-01-12 23:08:27 +01:00
|
|
|
next = &np->properties;
|
|
|
|
while (*next) {
|
|
|
|
if (*next == prop) {
|
|
|
|
/* found the node */
|
|
|
|
*next = prop->next;
|
|
|
|
prop->next = np->deadprops;
|
|
|
|
np->deadprops = prop;
|
|
|
|
found = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
next = &(*next)->next;
|
|
|
|
}
|
2008-04-09 09:21:36 +02:00
|
|
|
write_unlock_irqrestore(&devtree_lock, flags);
|
2006-01-12 23:08:27 +01:00
|
|
|
|
|
|
|
if (!found)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
#ifdef CONFIG_PROC_DEVICETREE
|
|
|
|
/* try to remove the proc node as well */
|
|
|
|
if (np->pde)
|
|
|
|
proc_device_tree_remove_prop(np->pde, prop);
|
|
|
|
#endif /* CONFIG_PROC_DEVICETREE */
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Update a property in a node. Note that we don't actually
|
|
|
|
* remove it, since we have given out who-knows-how-many pointers
|
|
|
|
* to the data using get-property. Instead we just move the property
|
|
|
|
* to the "dead properties" list, and add the new property to the
|
|
|
|
* property list
|
|
|
|
*/
|
|
|
|
int prom_update_property(struct device_node *np,
|
|
|
|
struct property *newprop,
|
|
|
|
struct property *oldprop)
|
|
|
|
{
|
|
|
|
struct property **next;
|
2008-04-09 09:21:36 +02:00
|
|
|
unsigned long flags;
|
2006-01-12 23:08:27 +01:00
|
|
|
int found = 0;
|
|
|
|
|
2008-04-09 09:21:36 +02:00
|
|
|
write_lock_irqsave(&devtree_lock, flags);
|
2006-01-12 23:08:27 +01:00
|
|
|
next = &np->properties;
|
|
|
|
while (*next) {
|
|
|
|
if (*next == oldprop) {
|
|
|
|
/* found the node */
|
|
|
|
newprop->next = oldprop->next;
|
|
|
|
*next = newprop;
|
|
|
|
oldprop->next = np->deadprops;
|
|
|
|
np->deadprops = oldprop;
|
|
|
|
found = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
next = &(*next)->next;
|
|
|
|
}
|
2008-04-09 09:21:36 +02:00
|
|
|
write_unlock_irqrestore(&devtree_lock, flags);
|
2006-01-12 23:08:27 +01:00
|
|
|
|
|
|
|
if (!found)
|
|
|
|
return -ENODEV;
|
2005-10-06 04:06:20 +02:00
|
|
|
|
2006-01-12 23:08:27 +01:00
|
|
|
#ifdef CONFIG_PROC_DEVICETREE
|
|
|
|
/* try to add to proc as well if it was initialized */
|
|
|
|
if (np->pde)
|
|
|
|
proc_device_tree_update_prop(np->pde, newprop, oldprop);
|
|
|
|
#endif /* CONFIG_PROC_DEVICETREE */
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2006-02-03 09:05:47 +01:00
|
|
|
|
2006-06-19 20:33:16 +02:00
|
|
|
|
|
|
|
/* Find the device node for a given logical cpu number, also returns the cpu
|
|
|
|
* local thread number (index in ibm,interrupt-server#s) if relevant and
|
|
|
|
* asked for (non NULL)
|
|
|
|
*/
|
|
|
|
struct device_node *of_get_cpu_node(int cpu, unsigned int *thread)
|
|
|
|
{
|
|
|
|
int hardid;
|
|
|
|
struct device_node *np;
|
|
|
|
|
|
|
|
hardid = get_hard_smp_processor_id(cpu);
|
|
|
|
|
|
|
|
for_each_node_by_type(np, "cpu") {
|
2006-07-12 07:35:54 +02:00
|
|
|
const u32 *intserv;
|
2006-06-19 20:33:16 +02:00
|
|
|
unsigned int plen, t;
|
|
|
|
|
|
|
|
/* Check for ibm,ppc-interrupt-server#s. If it doesn't exist
|
|
|
|
* fallback to "reg" property and assume no threads
|
|
|
|
*/
|
2007-04-03 02:54:01 +02:00
|
|
|
intserv = of_get_property(np, "ibm,ppc-interrupt-server#s",
|
2006-07-12 07:35:54 +02:00
|
|
|
&plen);
|
2006-06-19 20:33:16 +02:00
|
|
|
if (intserv == NULL) {
|
2007-04-03 02:54:01 +02:00
|
|
|
const u32 *reg = of_get_property(np, "reg", NULL);
|
2006-06-19 20:33:16 +02:00
|
|
|
if (reg == NULL)
|
|
|
|
continue;
|
|
|
|
if (*reg == hardid) {
|
|
|
|
if (thread)
|
|
|
|
*thread = 0;
|
|
|
|
return np;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
plen /= sizeof(u32);
|
|
|
|
for (t = 0; t < plen; t++) {
|
|
|
|
if (hardid == intserv[t]) {
|
|
|
|
if (thread)
|
|
|
|
*thread = t;
|
|
|
|
return np;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
2006-10-24 18:39:45 +02:00
|
|
|
EXPORT_SYMBOL(of_get_cpu_node);
|
2006-06-23 10:16:03 +02:00
|
|
|
|
2007-06-20 02:54:19 +02:00
|
|
|
#if defined(CONFIG_DEBUG_FS) && defined(DEBUG)
|
2006-06-23 10:16:03 +02:00
|
|
|
static struct debugfs_blob_wrapper flat_dt_blob;
|
|
|
|
|
|
|
|
static int __init export_flat_device_tree(void)
|
|
|
|
{
|
|
|
|
struct dentry *d;
|
|
|
|
|
|
|
|
flat_dt_blob.data = initial_boot_params;
|
|
|
|
flat_dt_blob.size = initial_boot_params->totalsize;
|
|
|
|
|
|
|
|
d = debugfs_create_blob("flat-device-tree", S_IFREG | S_IRUSR,
|
2007-06-20 02:54:19 +02:00
|
|
|
powerpc_debugfs_root, &flat_dt_blob);
|
2006-06-23 10:16:03 +02:00
|
|
|
if (!d)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
__initcall(export_flat_device_tree);
|
|
|
|
#endif
|