2008-05-19 16:52:27 -07:00
|
|
|
/*
|
2005-04-16 15:20:36 -07:00
|
|
|
* tree.c: Basic device tree traversal/scanning for the Linux
|
|
|
|
* prom library.
|
|
|
|
*
|
|
|
|
* Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
|
|
|
|
* Copyright (C) 1996,1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/sched.h>
|
2009-01-08 17:58:20 -07:00
|
|
|
#include <linux/module.h>
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
#include <asm/openprom.h>
|
|
|
|
#include <asm/oplib.h>
|
2007-07-12 15:55:55 -07:00
|
|
|
#include <asm/ldc.h>
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
/* Return the child of node 'node' or zero if no this node has no
|
|
|
|
* direct descendent.
|
|
|
|
*/
|
2007-10-27 00:13:04 -07:00
|
|
|
inline int __prom_getchild(int node)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
return p1275_cmd ("child", P1275_INOUT(1, 1), node);
|
|
|
|
}
|
|
|
|
|
2007-10-27 00:13:04 -07:00
|
|
|
inline int prom_getchild(int node)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
int cnode;
|
|
|
|
|
|
|
|
if(node == -1) return 0;
|
|
|
|
cnode = __prom_getchild(node);
|
|
|
|
if(cnode == -1) return 0;
|
|
|
|
return (int)cnode;
|
|
|
|
}
|
2009-01-08 17:58:20 -07:00
|
|
|
EXPORT_SYMBOL(prom_getchild);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2007-10-27 00:13:04 -07:00
|
|
|
inline int prom_getparent(int node)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
int cnode;
|
|
|
|
|
|
|
|
if(node == -1) return 0;
|
|
|
|
cnode = p1275_cmd ("parent", P1275_INOUT(1, 1), node);
|
|
|
|
if(cnode == -1) return 0;
|
|
|
|
return (int)cnode;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Return the next sibling of node 'node' or zero if no more siblings
|
|
|
|
* at this level of depth in the tree.
|
|
|
|
*/
|
2007-10-27 00:13:04 -07:00
|
|
|
inline int __prom_getsibling(int node)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
2006-02-09 03:52:44 -07:00
|
|
|
return p1275_cmd(prom_peer_name, P1275_INOUT(1, 1), node);
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
2007-10-27 00:13:04 -07:00
|
|
|
inline int prom_getsibling(int node)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
int sibnode;
|
|
|
|
|
2006-02-09 03:52:44 -07:00
|
|
|
if (node == -1)
|
|
|
|
return 0;
|
2005-04-16 15:20:36 -07:00
|
|
|
sibnode = __prom_getsibling(node);
|
2006-02-09 03:52:44 -07:00
|
|
|
if (sibnode == -1)
|
|
|
|
return 0;
|
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
return sibnode;
|
|
|
|
}
|
2009-01-08 17:58:20 -07:00
|
|
|
EXPORT_SYMBOL(prom_getsibling);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
/* Return the length in bytes of property 'prop' at node 'node'.
|
|
|
|
* Return -1 on error.
|
|
|
|
*/
|
2007-10-27 00:13:04 -07:00
|
|
|
inline int prom_getproplen(int node, const char *prop)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
if((!node) || (!prop)) return -1;
|
|
|
|
return p1275_cmd ("getproplen",
|
|
|
|
P1275_ARG(1,P1275_ARG_IN_STRING)|
|
|
|
|
P1275_INOUT(2, 1),
|
|
|
|
node, prop);
|
|
|
|
}
|
2009-01-08 17:58:20 -07:00
|
|
|
EXPORT_SYMBOL(prom_getproplen);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
/* Acquire a property 'prop' at node 'node' and place it in
|
|
|
|
* 'buffer' which has a size of 'bufsize'. If the acquisition
|
|
|
|
* was successful the length will be returned, else -1 is returned.
|
|
|
|
*/
|
2007-10-27 00:13:04 -07:00
|
|
|
inline int prom_getproperty(int node, const char *prop,
|
|
|
|
char *buffer, int bufsize)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
int plen;
|
|
|
|
|
|
|
|
plen = prom_getproplen(node, prop);
|
[SPARC64]: Rewrite bootup sequence.
Instead of all of this cpu-specific code to remap the kernel
to the correct location, use portable firmware calls to do
this instead.
What we do now is the following in position independant
assembler:
chosen_node = prom_finddevice("/chosen");
prom_mmu_ihandle_cache = prom_getint(chosen_node, "mmu");
vaddr = 4MB_ALIGN(current_text_addr());
prom_translate(vaddr, &paddr_high, &paddr_low, &mode);
prom_boot_mapping_mode = mode;
prom_boot_mapping_phys_high = paddr_high;
prom_boot_mapping_phys_low = paddr_low;
prom_map(-1, 8 * 1024 * 1024, KERNBASE, paddr_low);
and that replaces the massive amount of by-hand TLB probing and
programming we used to do here.
The new code should also handle properly the case where the kernel
is mapped at the correct address already (think: future kexec
support).
Consequently, the bulk of remap_kernel() dies as does the entirety
of arch/sparc64/prom/map.S
We try to share some strings in the PROM library with the ones used
at bootup, and while we're here mark input strings to oplib.h routines
with "const" when appropriate.
There are many more simplifications now possible. For one thing, we
can consolidate the two copies we now have of a lot of cpu setup code
sitting in head.S and trampoline.S.
This is a significant step towards CONFIG_DEBUG_PAGEALLOC support.
Signed-off-by: David S. Miller <davem@davemloft.net>
2005-09-22 20:11:33 -07:00
|
|
|
if ((plen > bufsize) || (plen == 0) || (plen == -1)) {
|
2005-04-16 15:20:36 -07:00
|
|
|
return -1;
|
[SPARC64]: Rewrite bootup sequence.
Instead of all of this cpu-specific code to remap the kernel
to the correct location, use portable firmware calls to do
this instead.
What we do now is the following in position independant
assembler:
chosen_node = prom_finddevice("/chosen");
prom_mmu_ihandle_cache = prom_getint(chosen_node, "mmu");
vaddr = 4MB_ALIGN(current_text_addr());
prom_translate(vaddr, &paddr_high, &paddr_low, &mode);
prom_boot_mapping_mode = mode;
prom_boot_mapping_phys_high = paddr_high;
prom_boot_mapping_phys_low = paddr_low;
prom_map(-1, 8 * 1024 * 1024, KERNBASE, paddr_low);
and that replaces the massive amount of by-hand TLB probing and
programming we used to do here.
The new code should also handle properly the case where the kernel
is mapped at the correct address already (think: future kexec
support).
Consequently, the bulk of remap_kernel() dies as does the entirety
of arch/sparc64/prom/map.S
We try to share some strings in the PROM library with the ones used
at bootup, and while we're here mark input strings to oplib.h routines
with "const" when appropriate.
There are many more simplifications now possible. For one thing, we
can consolidate the two copies we now have of a lot of cpu setup code
sitting in head.S and trampoline.S.
This is a significant step towards CONFIG_DEBUG_PAGEALLOC support.
Signed-off-by: David S. Miller <davem@davemloft.net>
2005-09-22 20:11:33 -07:00
|
|
|
} else {
|
2005-04-16 15:20:36 -07:00
|
|
|
/* Ok, things seem all right. */
|
[SPARC64]: Rewrite bootup sequence.
Instead of all of this cpu-specific code to remap the kernel
to the correct location, use portable firmware calls to do
this instead.
What we do now is the following in position independant
assembler:
chosen_node = prom_finddevice("/chosen");
prom_mmu_ihandle_cache = prom_getint(chosen_node, "mmu");
vaddr = 4MB_ALIGN(current_text_addr());
prom_translate(vaddr, &paddr_high, &paddr_low, &mode);
prom_boot_mapping_mode = mode;
prom_boot_mapping_phys_high = paddr_high;
prom_boot_mapping_phys_low = paddr_low;
prom_map(-1, 8 * 1024 * 1024, KERNBASE, paddr_low);
and that replaces the massive amount of by-hand TLB probing and
programming we used to do here.
The new code should also handle properly the case where the kernel
is mapped at the correct address already (think: future kexec
support).
Consequently, the bulk of remap_kernel() dies as does the entirety
of arch/sparc64/prom/map.S
We try to share some strings in the PROM library with the ones used
at bootup, and while we're here mark input strings to oplib.h routines
with "const" when appropriate.
There are many more simplifications now possible. For one thing, we
can consolidate the two copies we now have of a lot of cpu setup code
sitting in head.S and trampoline.S.
This is a significant step towards CONFIG_DEBUG_PAGEALLOC support.
Signed-off-by: David S. Miller <davem@davemloft.net>
2005-09-22 20:11:33 -07:00
|
|
|
return p1275_cmd(prom_getprop_name,
|
|
|
|
P1275_ARG(1,P1275_ARG_IN_STRING)|
|
|
|
|
P1275_ARG(2,P1275_ARG_OUT_BUF)|
|
|
|
|
P1275_INOUT(4, 1),
|
|
|
|
node, prop, buffer, P1275_SIZE(plen));
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
}
|
2009-01-08 17:58:20 -07:00
|
|
|
EXPORT_SYMBOL(prom_getproperty);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
/* Acquire an integer property and return its value. Returns -1
|
|
|
|
* on failure.
|
|
|
|
*/
|
2007-10-27 00:13:04 -07:00
|
|
|
inline int prom_getint(int node, const char *prop)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
int intprop;
|
|
|
|
|
|
|
|
if(prom_getproperty(node, prop, (char *) &intprop, sizeof(int)) != -1)
|
|
|
|
return intprop;
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
2009-01-08 17:58:20 -07:00
|
|
|
EXPORT_SYMBOL(prom_getint);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
/* Acquire an integer property, upon error return the passed default
|
|
|
|
* integer.
|
|
|
|
*/
|
|
|
|
|
2007-10-27 00:13:04 -07:00
|
|
|
int prom_getintdefault(int node, const char *property, int deflt)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
retval = prom_getint(node, property);
|
|
|
|
if(retval == -1) return deflt;
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
2009-01-08 17:58:20 -07:00
|
|
|
EXPORT_SYMBOL(prom_getintdefault);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
/* Acquire a boolean property, 1=TRUE 0=FALSE. */
|
2007-10-27 00:13:04 -07:00
|
|
|
int prom_getbool(int node, const char *prop)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
retval = prom_getproplen(node, prop);
|
|
|
|
if(retval == -1) return 0;
|
|
|
|
return 1;
|
|
|
|
}
|
2009-01-08 17:58:20 -07:00
|
|
|
EXPORT_SYMBOL(prom_getbool);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
/* Acquire a property whose value is a string, returns a null
|
|
|
|
* string on error. The char pointer is the user supplied string
|
|
|
|
* buffer.
|
|
|
|
*/
|
2007-10-27 00:13:04 -07:00
|
|
|
void prom_getstring(int node, const char *prop, char *user_buf, int ubuf_size)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
int len;
|
|
|
|
|
|
|
|
len = prom_getproperty(node, prop, user_buf, ubuf_size);
|
|
|
|
if(len != -1) return;
|
|
|
|
user_buf[0] = 0;
|
|
|
|
return;
|
|
|
|
}
|
2009-01-08 17:58:20 -07:00
|
|
|
EXPORT_SYMBOL(prom_getstring);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
/* Does the device at node 'node' have name 'name'?
|
|
|
|
* YES = 1 NO = 0
|
|
|
|
*/
|
2007-10-27 00:13:04 -07:00
|
|
|
int prom_nodematch(int node, const char *name)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
char namebuf[128];
|
|
|
|
prom_getproperty(node, "name", namebuf, sizeof(namebuf));
|
|
|
|
if(strcmp(namebuf, name) == 0) return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Search siblings at 'node_start' for a node with name
|
|
|
|
* 'nodename'. Return node if successful, zero if not.
|
|
|
|
*/
|
2007-10-27 00:13:04 -07:00
|
|
|
int prom_searchsiblings(int node_start, const char *nodename)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
|
|
|
|
int thisnode, error;
|
|
|
|
char promlib_buf[128];
|
|
|
|
|
|
|
|
for(thisnode = node_start; thisnode;
|
|
|
|
thisnode=prom_getsibling(thisnode)) {
|
|
|
|
error = prom_getproperty(thisnode, "name", promlib_buf,
|
|
|
|
sizeof(promlib_buf));
|
|
|
|
/* Should this ever happen? */
|
|
|
|
if(error == -1) continue;
|
|
|
|
if(strcmp(nodename, promlib_buf)==0) return thisnode;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2009-01-08 17:58:20 -07:00
|
|
|
EXPORT_SYMBOL(prom_searchsiblings);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
/* Return the first property type for node 'node'.
|
|
|
|
* buffer should be at least 32B in length
|
|
|
|
*/
|
2007-10-27 00:13:04 -07:00
|
|
|
inline char *prom_firstprop(int node, char *buffer)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
*buffer = 0;
|
|
|
|
if(node == -1) return buffer;
|
|
|
|
p1275_cmd ("nextprop", P1275_ARG(2,P1275_ARG_OUT_32B)|
|
|
|
|
P1275_INOUT(3, 0),
|
|
|
|
node, (char *) 0x0, buffer);
|
|
|
|
return buffer;
|
|
|
|
}
|
2009-01-08 17:58:20 -07:00
|
|
|
EXPORT_SYMBOL(prom_firstprop);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
/* Return the property type string after property type 'oprop'
|
|
|
|
* at node 'node' . Returns NULL string if no more
|
|
|
|
* property types for this node.
|
|
|
|
*/
|
2007-10-27 00:13:04 -07:00
|
|
|
inline char *prom_nextprop(int node, const char *oprop, char *buffer)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
char buf[32];
|
|
|
|
|
|
|
|
if(node == -1) {
|
|
|
|
*buffer = 0;
|
|
|
|
return buffer;
|
|
|
|
}
|
|
|
|
if (oprop == buffer) {
|
|
|
|
strcpy (buf, oprop);
|
|
|
|
oprop = buf;
|
|
|
|
}
|
|
|
|
p1275_cmd ("nextprop", P1275_ARG(1,P1275_ARG_IN_STRING)|
|
|
|
|
P1275_ARG(2,P1275_ARG_OUT_32B)|
|
|
|
|
P1275_INOUT(3, 0),
|
|
|
|
node, oprop, buffer);
|
|
|
|
return buffer;
|
|
|
|
}
|
2009-01-08 17:58:20 -07:00
|
|
|
EXPORT_SYMBOL(prom_nextprop);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
int
|
[SPARC64]: Rewrite bootup sequence.
Instead of all of this cpu-specific code to remap the kernel
to the correct location, use portable firmware calls to do
this instead.
What we do now is the following in position independant
assembler:
chosen_node = prom_finddevice("/chosen");
prom_mmu_ihandle_cache = prom_getint(chosen_node, "mmu");
vaddr = 4MB_ALIGN(current_text_addr());
prom_translate(vaddr, &paddr_high, &paddr_low, &mode);
prom_boot_mapping_mode = mode;
prom_boot_mapping_phys_high = paddr_high;
prom_boot_mapping_phys_low = paddr_low;
prom_map(-1, 8 * 1024 * 1024, KERNBASE, paddr_low);
and that replaces the massive amount of by-hand TLB probing and
programming we used to do here.
The new code should also handle properly the case where the kernel
is mapped at the correct address already (think: future kexec
support).
Consequently, the bulk of remap_kernel() dies as does the entirety
of arch/sparc64/prom/map.S
We try to share some strings in the PROM library with the ones used
at bootup, and while we're here mark input strings to oplib.h routines
with "const" when appropriate.
There are many more simplifications now possible. For one thing, we
can consolidate the two copies we now have of a lot of cpu setup code
sitting in head.S and trampoline.S.
This is a significant step towards CONFIG_DEBUG_PAGEALLOC support.
Signed-off-by: David S. Miller <davem@davemloft.net>
2005-09-22 20:11:33 -07:00
|
|
|
prom_finddevice(const char *name)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
[SPARC64]: Rewrite bootup sequence.
Instead of all of this cpu-specific code to remap the kernel
to the correct location, use portable firmware calls to do
this instead.
What we do now is the following in position independant
assembler:
chosen_node = prom_finddevice("/chosen");
prom_mmu_ihandle_cache = prom_getint(chosen_node, "mmu");
vaddr = 4MB_ALIGN(current_text_addr());
prom_translate(vaddr, &paddr_high, &paddr_low, &mode);
prom_boot_mapping_mode = mode;
prom_boot_mapping_phys_high = paddr_high;
prom_boot_mapping_phys_low = paddr_low;
prom_map(-1, 8 * 1024 * 1024, KERNBASE, paddr_low);
and that replaces the massive amount of by-hand TLB probing and
programming we used to do here.
The new code should also handle properly the case where the kernel
is mapped at the correct address already (think: future kexec
support).
Consequently, the bulk of remap_kernel() dies as does the entirety
of arch/sparc64/prom/map.S
We try to share some strings in the PROM library with the ones used
at bootup, and while we're here mark input strings to oplib.h routines
with "const" when appropriate.
There are many more simplifications now possible. For one thing, we
can consolidate the two copies we now have of a lot of cpu setup code
sitting in head.S and trampoline.S.
This is a significant step towards CONFIG_DEBUG_PAGEALLOC support.
Signed-off-by: David S. Miller <davem@davemloft.net>
2005-09-22 20:11:33 -07:00
|
|
|
if (!name)
|
|
|
|
return 0;
|
|
|
|
return p1275_cmd(prom_finddev_name,
|
|
|
|
P1275_ARG(0,P1275_ARG_IN_STRING)|
|
|
|
|
P1275_INOUT(1, 1),
|
|
|
|
name);
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
2009-01-08 17:58:20 -07:00
|
|
|
EXPORT_SYMBOL(prom_finddevice);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
[SPARC64]: Rewrite bootup sequence.
Instead of all of this cpu-specific code to remap the kernel
to the correct location, use portable firmware calls to do
this instead.
What we do now is the following in position independant
assembler:
chosen_node = prom_finddevice("/chosen");
prom_mmu_ihandle_cache = prom_getint(chosen_node, "mmu");
vaddr = 4MB_ALIGN(current_text_addr());
prom_translate(vaddr, &paddr_high, &paddr_low, &mode);
prom_boot_mapping_mode = mode;
prom_boot_mapping_phys_high = paddr_high;
prom_boot_mapping_phys_low = paddr_low;
prom_map(-1, 8 * 1024 * 1024, KERNBASE, paddr_low);
and that replaces the massive amount of by-hand TLB probing and
programming we used to do here.
The new code should also handle properly the case where the kernel
is mapped at the correct address already (think: future kexec
support).
Consequently, the bulk of remap_kernel() dies as does the entirety
of arch/sparc64/prom/map.S
We try to share some strings in the PROM library with the ones used
at bootup, and while we're here mark input strings to oplib.h routines
with "const" when appropriate.
There are many more simplifications now possible. For one thing, we
can consolidate the two copies we now have of a lot of cpu setup code
sitting in head.S and trampoline.S.
This is a significant step towards CONFIG_DEBUG_PAGEALLOC support.
Signed-off-by: David S. Miller <davem@davemloft.net>
2005-09-22 20:11:33 -07:00
|
|
|
int prom_node_has_property(int node, const char *prop)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
char buf [32];
|
|
|
|
|
|
|
|
*buf = 0;
|
|
|
|
do {
|
|
|
|
prom_nextprop(node, buf, buf);
|
|
|
|
if(!strcmp(buf, prop))
|
|
|
|
return 1;
|
|
|
|
} while (*buf);
|
|
|
|
return 0;
|
|
|
|
}
|
2009-01-08 17:58:20 -07:00
|
|
|
EXPORT_SYMBOL(prom_node_has_property);
|
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
/* Set property 'pname' at node 'node' to value 'value' which has a length
|
|
|
|
* of 'size' bytes. Return the number of bytes the prom accepted.
|
|
|
|
*/
|
|
|
|
int
|
[SPARC64]: Rewrite bootup sequence.
Instead of all of this cpu-specific code to remap the kernel
to the correct location, use portable firmware calls to do
this instead.
What we do now is the following in position independant
assembler:
chosen_node = prom_finddevice("/chosen");
prom_mmu_ihandle_cache = prom_getint(chosen_node, "mmu");
vaddr = 4MB_ALIGN(current_text_addr());
prom_translate(vaddr, &paddr_high, &paddr_low, &mode);
prom_boot_mapping_mode = mode;
prom_boot_mapping_phys_high = paddr_high;
prom_boot_mapping_phys_low = paddr_low;
prom_map(-1, 8 * 1024 * 1024, KERNBASE, paddr_low);
and that replaces the massive amount of by-hand TLB probing and
programming we used to do here.
The new code should also handle properly the case where the kernel
is mapped at the correct address already (think: future kexec
support).
Consequently, the bulk of remap_kernel() dies as does the entirety
of arch/sparc64/prom/map.S
We try to share some strings in the PROM library with the ones used
at bootup, and while we're here mark input strings to oplib.h routines
with "const" when appropriate.
There are many more simplifications now possible. For one thing, we
can consolidate the two copies we now have of a lot of cpu setup code
sitting in head.S and trampoline.S.
This is a significant step towards CONFIG_DEBUG_PAGEALLOC support.
Signed-off-by: David S. Miller <davem@davemloft.net>
2005-09-22 20:11:33 -07:00
|
|
|
prom_setprop(int node, const char *pname, char *value, int size)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
2007-07-12 15:55:55 -07:00
|
|
|
if (size == 0)
|
|
|
|
return 0;
|
|
|
|
if ((pname == 0) || (value == 0))
|
|
|
|
return 0;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2007-07-12 15:55:55 -07:00
|
|
|
#ifdef CONFIG_SUN_LDOMS
|
|
|
|
if (ldom_domaining_enabled) {
|
|
|
|
ldom_set_var(pname, value);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
2005-04-16 15:20:36 -07:00
|
|
|
return p1275_cmd ("setprop", P1275_ARG(1,P1275_ARG_IN_STRING)|
|
|
|
|
P1275_ARG(2,P1275_ARG_IN_BUF)|
|
|
|
|
P1275_INOUT(4, 1),
|
|
|
|
node, pname, value, P1275_SIZE(size));
|
|
|
|
}
|
2009-01-08 17:58:20 -07:00
|
|
|
EXPORT_SYMBOL(prom_setprop);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2007-10-27 00:13:04 -07:00
|
|
|
inline int prom_inst2pkg(int inst)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
int node;
|
|
|
|
|
|
|
|
node = p1275_cmd ("instance-to-package", P1275_INOUT(1, 1), inst);
|
|
|
|
if (node == -1) return 0;
|
|
|
|
return node;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Return 'node' assigned to a particular prom 'path'
|
|
|
|
* FIXME: Should work for v0 as well
|
|
|
|
*/
|
|
|
|
int
|
[SPARC64]: Rewrite bootup sequence.
Instead of all of this cpu-specific code to remap the kernel
to the correct location, use portable firmware calls to do
this instead.
What we do now is the following in position independant
assembler:
chosen_node = prom_finddevice("/chosen");
prom_mmu_ihandle_cache = prom_getint(chosen_node, "mmu");
vaddr = 4MB_ALIGN(current_text_addr());
prom_translate(vaddr, &paddr_high, &paddr_low, &mode);
prom_boot_mapping_mode = mode;
prom_boot_mapping_phys_high = paddr_high;
prom_boot_mapping_phys_low = paddr_low;
prom_map(-1, 8 * 1024 * 1024, KERNBASE, paddr_low);
and that replaces the massive amount of by-hand TLB probing and
programming we used to do here.
The new code should also handle properly the case where the kernel
is mapped at the correct address already (think: future kexec
support).
Consequently, the bulk of remap_kernel() dies as does the entirety
of arch/sparc64/prom/map.S
We try to share some strings in the PROM library with the ones used
at bootup, and while we're here mark input strings to oplib.h routines
with "const" when appropriate.
There are many more simplifications now possible. For one thing, we
can consolidate the two copies we now have of a lot of cpu setup code
sitting in head.S and trampoline.S.
This is a significant step towards CONFIG_DEBUG_PAGEALLOC support.
Signed-off-by: David S. Miller <davem@davemloft.net>
2005-09-22 20:11:33 -07:00
|
|
|
prom_pathtoinode(const char *path)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
int node, inst;
|
|
|
|
|
|
|
|
inst = prom_devopen (path);
|
|
|
|
if (inst == 0) return 0;
|
|
|
|
node = prom_inst2pkg (inst);
|
|
|
|
prom_devclose (inst);
|
|
|
|
if (node == -1) return 0;
|
|
|
|
return node;
|
|
|
|
}
|
2007-07-20 16:59:26 -07:00
|
|
|
|
|
|
|
int prom_ihandle2path(int handle, char *buffer, int bufsize)
|
|
|
|
{
|
|
|
|
return p1275_cmd("instance-to-path",
|
|
|
|
P1275_ARG(1,P1275_ARG_OUT_BUF)|
|
|
|
|
P1275_INOUT(3, 1),
|
|
|
|
handle, buffer, P1275_SIZE(bufsize));
|
|
|
|
}
|