WebSVN – HelenOS – Diff – /trunk/boot/genarch/ofw.c


/*
 * Copyright (c) 2005 Martin Decky
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
#include <ofw.h>
#include <ofwarch.h>
#include <printf.h>
#include <asm.h>
#include <types.h>
 
uintptr_t ofw_cif;
 
phandle ofw_chosen;
ihandle ofw_stdout;
phandle ofw_root;
ihandle ofw_mmu;
ihandle ofw_memory_prop;
phandle ofw_memory;
phandle ofw_aliases;
 
void ofw_init(void)
{
    ofw_chosen = ofw_find_device("/chosen");
    if (ofw_chosen == -1)
        halt();
   
    if (ofw_get_property(ofw_chosen, "stdout", &ofw_stdout,
        sizeof(ofw_stdout)) <= 0)
        ofw_stdout = 0;
   
    ofw_root = ofw_find_device("/");
    if (ofw_root == -1) {
        puts("\r\nError: Unable to find / device, halted.\r\n");
        halt();
    }
   
    if (ofw_get_property(ofw_chosen, "mmu", &ofw_mmu,
        sizeof(ofw_mmu)) <= 0) {
        puts("\r\nError: Unable to get mmu property, halted.\r\n");
        halt();
    }
    if (ofw_get_property(ofw_chosen, "memory", &ofw_memory_prop,
        sizeof(ofw_memory_prop)) <= 0) {
        puts("\r\nError: Unable to get memory property, halted.\r\n");
        halt();
    }
 
    ofw_memory = ofw_find_device("/memory");
    if (ofw_memory == -1) {
        puts("\r\nError: Unable to find /memory device, halted.\r\n");
        halt();
    }
   
    ofw_aliases = ofw_find_device("/aliases");
    if (ofw_aliases == -1) {
        puts("\r\nError: Unable to find /aliases device, halted.\r\n");
        halt();
    }
}
 
/** Perform a call to OpenFirmware client interface.
 *
 * @param service   String identifying the service requested.
 * @param nargs     Number of input arguments.
 * @param nret      Number of output arguments. This includes the return
 *          value.
 * @param rets      Buffer for output arguments or NULL. The buffer must
 *          accommodate nret - 1 items.
 *
 * @return      Return value returned by the client interface.
 */
unsigned long
ofw_call(const char *service, const int nargs, const int nret, ofw_arg_t *rets,
    ...)
{
    va_list list;
    ofw_args_t args;
    int i;
   
    args.service = (ofw_arg_t) service;
    args.nargs = nargs;
    args.nret = nret;
   
    va_start(list, rets);
    for (i = 0; i < nargs; i++)
        args.args[i] = va_arg(list, ofw_arg_t);
    va_end(list);
   
    for (i = 0; i < nret; i++)
        args.args[i + nargs] = 0;
   
    (void) ofw(&args);
 
    for (i = 1; i < nret; i++)
        rets[i - 1] = args.args[i + nargs];
 
    return args.args[nargs];
}
 
phandle ofw_find_device(const char *name)
{
    return ofw_call("finddevice", 1, 1, NULL, name);
}
 
int
ofw_get_property(const phandle device, const char *name, void *buf,
    const int buflen)
{
    return ofw_call("getprop", 4, 1, NULL, device, name, buf, buflen);
}
 
int ofw_get_proplen(const phandle device, const char *name)
{
    return ofw_call("getproplen", 2, 1, NULL, device, name);
}
 
int ofw_next_property(const phandle device, char *previous, char *buf)
{
    return ofw_call("nextprop", 3, 1, NULL, device, previous, buf);
}
 
int ofw_package_to_path(const phandle device, char *buf, const int buflen)
{
    return ofw_call("package-to-path", 3, 1, NULL, device, buf, buflen);
}
 
unsigned int ofw_get_address_cells(const phandle device)
{
    unsigned int ret = 1;
   
    if (ofw_get_property(device, "#address-cells", &ret, sizeof(ret)) <= 0)
        if (ofw_get_property(ofw_root, "#address-cells", &ret,
            sizeof(ret)) <= 0)
            ret = OFW_ADDRESS_CELLS;
   
    return ret;
}
 
 
unsigned int ofw_get_size_cells(const phandle device)
{
    unsigned int ret;
   
    if (ofw_get_property(device, "#size-cells", &ret, sizeof(ret)) <= 0)
        if (ofw_get_property(ofw_root, "#size-cells", &ret,
            sizeof(ret)) <= 0)
            ret = OFW_SIZE_CELLS;
   
    return ret;
}
 
phandle ofw_get_child_node(const phandle node)
{
    return ofw_call("child", 1, 1, NULL, node);
}
 
phandle ofw_get_peer_node(const phandle node)
{
    return ofw_call("peer", 1, 1, NULL, node);
}
 
static ihandle ofw_open(const char *name)
{
    return ofw_call("open", 1, 1, NULL, name);
}
 
 
void ofw_write(const char *str, const int len)
{
    if (ofw_stdout == 0)
        return;
   
    ofw_call("write", 3, 1, NULL, ofw_stdout, str, len);
}
 
 
void *ofw_translate(const void *virt)
{
    ofw_arg_t result[4];
    int shift;
 
    if (ofw_call("call-method", 4, 5, result, "translate", ofw_mmu,
        virt, 0) != 0) {
        puts("Error: MMU method translate() failed, halting.\n");
        halt();
    }
 
    if (ofw_translate_failed(result[0]))
        return NULL;
 
    if (sizeof(unative_t) == 8)
        shift = 32;
    else
        shift = 0;
 
    return (void *) ((result[2] << shift) | result[3]);
}
 
void *ofw_claim_virt(const void *virt, const int len)
{
    ofw_arg_t retaddr;
 
    if (ofw_call("call-method", 5, 2, &retaddr, "claim", ofw_mmu, 0, len,
        virt) != 0) {
        puts("Error: MMU method claim() failed, halting.\n");
        halt();
    }
 
    return (void *) retaddr;
}
 
void *ofw_claim_phys(const void *phys, const int len)
{
    ofw_arg_t retaddr[2];
    int shift;
 
    if (sizeof(unative_t) == 8) {
        shift = 32;
        if (ofw_call("call-method", 6, 3, retaddr, "claim",
            ofw_memory_prop, 0, len, ((uintptr_t) phys) >> shift,
            ((uintptr_t) phys) & ((uint32_t) -1)) != 0) {
            /*
             * Note that this will help us to discover
             * conflicts between OpenFirmware allocations
             * and our use of physical memory.
             * It is better to detect collisions here
             * than to cope with weird errors later.
             *
             * So this is really not to make the loader
             * more generic; it is here for debugging
             * purposes.
             */
            puts("Error: memory method claim() failed, halting.\n");
            halt();
        }
    } else {
        shift = 0;
        /*
         * FIXME: the number of arguments is probably different...
         */
        puts("Error: 32-bit ofw_claim_phys not implemented.\n");
        halt();
    }
 
    return (void *) ((retaddr[0] << shift) | retaddr[1]);
}
 
int ofw_map(const void *phys, const void *virt, const int size, const int mode)
{
    uintptr_t phys_hi, phys_lo;
 
    if (sizeof(unative_t) == 8) {
        int shift = 32;
        phys_hi = (uintptr_t) phys >> shift;
        phys_lo = (uintptr_t) phys & 0xffffffff;
    } else {
        phys_hi = 0;
        phys_lo = (uintptr_t) phys;
    }
 
    return ofw_call("call-method", 7, 1, NULL, "map", ofw_mmu, mode, size,
        virt, phys_hi, phys_lo);
}
 
/** Save OpenFirmware physical memory map.
 *
 * @param map Memory map structure where the map will be saved.
 *
 * @return Zero on failure, non-zero on success.
 */
int ofw_memmap(memmap_t *map)
{
    unsigned int ac = ofw_get_address_cells(ofw_memory) /
        (sizeof(uintptr_t) / sizeof(uint32_t));
    unsigned int sc = ofw_get_size_cells(ofw_memory) /
        (sizeof(uintptr_t) / sizeof(uint32_t));
 
    uintptr_t buf[((ac + sc) * MEMMAP_MAX_RECORDS)];
    int ret = ofw_get_property(ofw_memory, "reg", buf, sizeof(buf));
    if (ret <= 0)       /* ret is the number of written bytes */
        return false;
 
    int pos;
    map->total = 0;
    map->count = 0;
    for (pos = 0; (pos < ret / sizeof(uintptr_t)) &&
        (map->count < MEMMAP_MAX_RECORDS); pos += ac + sc) {
        void *start = (void *) (buf[pos + ac - 1]);
        unsigned int size = buf[pos + ac + sc - 1];
 
        /*
         * This is a hot fix of the issue which occurs on machines
         * where there are holes in the physical memory (such as
         * SunBlade 1500). Should we detect a hole in the physical
         * memory, we will ignore any memory detected behind
         * the hole and pretend the hole does not exist.
         */
        if ((map->count > 0) && (map->zones[map->count - 1].start +
            map->zones[map->count - 1].size < start))
            break;
 
        if (size > 0) {
            map->zones[map->count].start = start;
            map->zones[map->count].size = size;
            map->count++;
            map->total += size;
        }
    }
   
    return true;
}
 
int ofw_screen(screen_t *screen)
{
    char device_name[BUF_SIZE];
    uint32_t virtaddr;
   
    if (ofw_get_property(ofw_aliases, "screen", device_name,
        sizeof(device_name)) <= 0)
        return false;
   
    phandle device = ofw_find_device(device_name);
    if (device == -1)
        return false;
   
    if (ofw_get_property(device, "address", &virtaddr,
        sizeof(virtaddr)) <= 0)
        return false;
 
    screen->addr = (void *) ((uintptr_t) virtaddr);
 
    if (ofw_get_property(device, "width", &screen->width,
        sizeof(screen->width)) <= 0)
        return false;
   
    if (ofw_get_property(device, "height", &screen->height,
        sizeof(screen->height)) <= 0)
        return false;
   
    if (ofw_get_property(device, "depth", &screen->bpp,
        sizeof(screen->bpp)) <= 0)
        return false;
   
    if (ofw_get_property(device, "linebytes", &screen->scanline,
        sizeof(screen->scanline)) <= 0)
        return false;
   
    return true;
}
 
#define RED(i)    (((i) >> 5) & ((1 << 3) - 1))
#define GREEN(i)  (((i) >> 3) & ((1 << 2) - 1))
#define BLUE(i)   ((i) & ((1 << 3) - 1))
#define CLIP(i)   ((i) <= 255 ? (i) : 255)
 
 
/**
 * Sets up the palette for the 8-bit color depth configuration so that the
 * 3:2:3 color scheme can be used. Checks that setting the palette makes sense
 * (appropriate nodes exist in the OBP tree and the color depth is not greater
 * than 8).
 *
 * @return true if the palette has been set, false otherwise
 *
 
 */
int ofw_setup_palette(void)
{
    char device_name[BUF_SIZE];
   
    /* resolve alias */
    if (ofw_get_property(ofw_aliases, "screen", device_name,
        sizeof(device_name)) <= 0)
        return false;
   
    /* for depth greater than 8 it makes no sense to set up the palette */
    uint32_t depth;
    phandle device = ofw_find_device(device_name);
    if (device == -1)
        return false;
    if (ofw_get_property(device, "depth", &depth, sizeof(uint32_t)) <= 0)
        return false;
    if (depth != 8)
        return false;
   
    /* required in order to be able to make a method call */
    ihandle screen = ofw_open(device_name);
    if (screen == -1)
        return false;
   
    /* setup the palette so that the (inverted) 3:2:3 scheme is usable */
    unsigned int i;
    for (i = 0; i < 256; i++)
        ofw_call("call-method", 6, 1, NULL, "color!", screen,
 
 
 
            255 - i, CLIP(BLUE(i) * 37), GREEN(i) * 85, CLIP(RED(i) * 37));
    return true;
}
 
void ofw_quiesce(void)
{
    ofw_call("quiesce", 0, 0, NULL);
}
 

Rev 3826	Rev 3861
1	/*	1	/*
2	* Copyright (c) 2005 Martin Decky	2	* Copyright (c) 2005 Martin Decky
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions	6	* modification, are permitted provided that the following conditions
7	* are met:	7	* are met:
8	*	8	*
9	* - Redistributions of source code must retain the above copyright	9	* - Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.	10	* notice, this list of conditions and the following disclaimer.
11	* - Redistributions in binary form must reproduce the above copyright	11	* - Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the	12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.	13	* documentation and/or other materials provided with the distribution.
14	* - The name of the author may not be used to endorse or promote products	14	* - The name of the author may not be used to endorse or promote products
15	* derived from this software without specific prior written permission.	15	* derived from this software without specific prior written permission.
16	*	16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	#include <ofw.h>	29	#include <ofw.h>
30	#include <ofwarch.h>	30	#include <ofwarch.h>
31	#include <printf.h>	31	#include <printf.h>
32	#include <asm.h>	32	#include <asm.h>
33	#include <types.h>	33	#include <types.h>
34		34
35	uintptr_t ofw_cif;	35	uintptr_t ofw_cif;
36		36
37	phandle ofw_chosen;	37	phandle ofw_chosen;
38	ihandle ofw_stdout;	38	ihandle ofw_stdout;
39	phandle ofw_root;	39	phandle ofw_root;
40	ihandle ofw_mmu;	40	ihandle ofw_mmu;
41	ihandle ofw_memory_prop;	41	ihandle ofw_memory_prop;
42	phandle ofw_memory;	42	phandle ofw_memory;
43	phandle ofw_aliases;	43	phandle ofw_aliases;
44		44
45	void ofw_init(void)	45	void ofw_init(void)
46	{	46	{
47	ofw_chosen = ofw_find_device("/chosen");	47	ofw_chosen = ofw_find_device("/chosen");
48	if (ofw_chosen == -1)	48	if (ofw_chosen == -1)
49	halt();	49	halt();
50		50
51	if (ofw_get_property(ofw_chosen, "stdout", &ofw_stdout,	51	if (ofw_get_property(ofw_chosen, "stdout", &ofw_stdout,
52	sizeof(ofw_stdout)) <= 0)	52	sizeof(ofw_stdout)) <= 0)
53	ofw_stdout = 0;	53	ofw_stdout = 0;
54		54
55	ofw_root = ofw_find_device("/");	55	ofw_root = ofw_find_device("/");
56	if (ofw_root == -1) {	56	if (ofw_root == -1) {
57	puts("\r\nError: Unable to find / device, halted.\r\n");	57	puts("\r\nError: Unable to find / device, halted.\r\n");
58	halt();	58	halt();
59	}	59	}
60		60
61	if (ofw_get_property(ofw_chosen, "mmu", &ofw_mmu,	61	if (ofw_get_property(ofw_chosen, "mmu", &ofw_mmu,
62	sizeof(ofw_mmu)) <= 0) {	62	sizeof(ofw_mmu)) <= 0) {
63	puts("\r\nError: Unable to get mmu property, halted.\r\n");	63	puts("\r\nError: Unable to get mmu property, halted.\r\n");
64	halt();	64	halt();
65	}	65	}
66	if (ofw_get_property(ofw_chosen, "memory", &ofw_memory_prop,	66	if (ofw_get_property(ofw_chosen, "memory", &ofw_memory_prop,
67	sizeof(ofw_memory_prop)) <= 0) {	67	sizeof(ofw_memory_prop)) <= 0) {
68	puts("\r\nError: Unable to get memory property, halted.\r\n");	68	puts("\r\nError: Unable to get memory property, halted.\r\n");
69	halt();	69	halt();
70	}	70	}
71		71
72	ofw_memory = ofw_find_device("/memory");	72	ofw_memory = ofw_find_device("/memory");
73	if (ofw_memory == -1) {	73	if (ofw_memory == -1) {
74	puts("\r\nError: Unable to find /memory device, halted.\r\n");	74	puts("\r\nError: Unable to find /memory device, halted.\r\n");
75	halt();	75	halt();
76	}	76	}
77		77
78	ofw_aliases = ofw_find_device("/aliases");	78	ofw_aliases = ofw_find_device("/aliases");
79	if (ofw_aliases == -1) {	79	if (ofw_aliases == -1) {
80	puts("\r\nError: Unable to find /aliases device, halted.\r\n");	80	puts("\r\nError: Unable to find /aliases device, halted.\r\n");
81	halt();	81	halt();
82	}	82	}
83	}	83	}
84		84
85	/** Perform a call to OpenFirmware client interface.	85	/** Perform a call to OpenFirmware client interface.
86	*	86	*
87	* @param service String identifying the service requested.	87	* @param service String identifying the service requested.
88	* @param nargs Number of input arguments.	88	* @param nargs Number of input arguments.
89	* @param nret Number of output arguments. This includes the return	89	* @param nret Number of output arguments. This includes the return
90	* value.	90	* value.
91	* @param rets Buffer for output arguments or NULL. The buffer must	91	* @param rets Buffer for output arguments or NULL. The buffer must
92	* accommodate nret - 1 items.	92	* accommodate nret - 1 items.
93	*	93	*
94	* @return Return value returned by the client interface.	94	* @return Return value returned by the client interface.
95	*/	95	*/
96	unsigned long	96	unsigned long
97	ofw_call(const char service, const int nargs, const int nret, ofw_arg_t rets,	97	ofw_call(const char service, const int nargs, const int nret, ofw_arg_t rets,
98	...)	98	...)
99	{	99	{
100	va_list list;	100	va_list list;
101	ofw_args_t args;	101	ofw_args_t args;
102	int i;	102	int i;
103		103
104	args.service = (ofw_arg_t) service;	104	args.service = (ofw_arg_t) service;
105	args.nargs = nargs;	105	args.nargs = nargs;
106	args.nret = nret;	106	args.nret = nret;
107		107
108	va_start(list, rets);	108	va_start(list, rets);
109	for (i = 0; i < nargs; i++)	109	for (i = 0; i < nargs; i++)
110	args.args[i] = va_arg(list, ofw_arg_t);	110	args.args[i] = va_arg(list, ofw_arg_t);
111	va_end(list);	111	va_end(list);
112		112
113	for (i = 0; i < nret; i++)	113	for (i = 0; i < nret; i++)
114	args.args[i + nargs] = 0;	114	args.args[i + nargs] = 0;
115		115
116	(void) ofw(&args);	116	(void) ofw(&args);
117		117
118	for (i = 1; i < nret; i++)	118	for (i = 1; i < nret; i++)
119	rets[i - 1] = args.args[i + nargs];	119	rets[i - 1] = args.args[i + nargs];
120		120
121	return args.args[nargs];	121	return args.args[nargs];
122	}	122	}
123		123
124	phandle ofw_find_device(const char *name)	124	phandle ofw_find_device(const char *name)
125	{	125	{
126	return ofw_call("finddevice", 1, 1, NULL, name);	126	return ofw_call("finddevice", 1, 1, NULL, name);
127	}	127	}
128		128
129	int	129	int
130	ofw_get_property(const phandle device, const char name, void buf,	130	ofw_get_property(const phandle device, const char name, void buf,
131	const int buflen)	131	const int buflen)
132	{	132	{
133	return ofw_call("getprop", 4, 1, NULL, device, name, buf, buflen);	133	return ofw_call("getprop", 4, 1, NULL, device, name, buf, buflen);
134	}	134	}
135		135
136	int ofw_get_proplen(const phandle device, const char *name)	136	int ofw_get_proplen(const phandle device, const char *name)
137	{	137	{
138	return ofw_call("getproplen", 2, 1, NULL, device, name);	138	return ofw_call("getproplen", 2, 1, NULL, device, name);
139	}	139	}
140		140
141	int ofw_next_property(const phandle device, char previous, char buf)	141	int ofw_next_property(const phandle device, char previous, char buf)
142	{	142	{
143	return ofw_call("nextprop", 3, 1, NULL, device, previous, buf);	143	return ofw_call("nextprop", 3, 1, NULL, device, previous, buf);
144	}	144	}
145		145
146	int ofw_package_to_path(const phandle device, char *buf, const int buflen)	146	int ofw_package_to_path(const phandle device, char *buf, const int buflen)
147	{	147	{
148	return ofw_call("package-to-path", 3, 1, NULL, device, buf, buflen);	148	return ofw_call("package-to-path", 3, 1, NULL, device, buf, buflen);
149	}	149	}
150		150
151	unsigned int ofw_get_address_cells(const phandle device)	151	unsigned int ofw_get_address_cells(const phandle device)
152	{	152	{
153	unsigned int ret = 1;	153	unsigned int ret = 1;
154		154
155	if (ofw_get_property(device, "#address-cells", &ret, sizeof(ret)) <= 0)	155	if (ofw_get_property(device, "#address-cells", &ret, sizeof(ret)) <= 0)
156	if (ofw_get_property(ofw_root, "#address-cells", &ret,	156	if (ofw_get_property(ofw_root, "#address-cells", &ret,
157	sizeof(ret)) <= 0)	157	sizeof(ret)) <= 0)
158	ret = OFW_ADDRESS_CELLS;	158	ret = OFW_ADDRESS_CELLS;
159		159
160	return ret;	160	return ret;
161	}	161	}
162		162
163		163
164	unsigned int ofw_get_size_cells(const phandle device)	164	unsigned int ofw_get_size_cells(const phandle device)
165	{	165	{
166	unsigned int ret;	166	unsigned int ret;
167		167
168	if (ofw_get_property(device, "#size-cells", &ret, sizeof(ret)) <= 0)	168	if (ofw_get_property(device, "#size-cells", &ret, sizeof(ret)) <= 0)
169	if (ofw_get_property(ofw_root, "#size-cells", &ret,	169	if (ofw_get_property(ofw_root, "#size-cells", &ret,
170	sizeof(ret)) <= 0)	170	sizeof(ret)) <= 0)
171	ret = OFW_SIZE_CELLS;	171	ret = OFW_SIZE_CELLS;
172		172
173	return ret;	173	return ret;
174	}	174	}
175		175
176	phandle ofw_get_child_node(const phandle node)	176	phandle ofw_get_child_node(const phandle node)
177	{	177	{
178	return ofw_call("child", 1, 1, NULL, node);	178	return ofw_call("child", 1, 1, NULL, node);
179	}	179	}
180		180
181	phandle ofw_get_peer_node(const phandle node)	181	phandle ofw_get_peer_node(const phandle node)
182	{	182	{
183	return ofw_call("peer", 1, 1, NULL, node);	183	return ofw_call("peer", 1, 1, NULL, node);
184	}	184	}
185		185
186	static ihandle ofw_open(const char *name)	186	static ihandle ofw_open(const char *name)
187	{	187	{
188	return ofw_call("open", 1, 1, NULL, name);	188	return ofw_call("open", 1, 1, NULL, name);
189	}	189	}
190		190
191		191
192	void ofw_write(const char *str, const int len)	192	void ofw_write(const char *str, const int len)
193	{	193	{
194	if (ofw_stdout == 0)	194	if (ofw_stdout == 0)
195	return;	195	return;
196		196
197	ofw_call("write", 3, 1, NULL, ofw_stdout, str, len);	197	ofw_call("write", 3, 1, NULL, ofw_stdout, str, len);
198	}	198	}
199		199
200		200
201	void ofw_translate(const void virt)	201	void ofw_translate(const void virt)
202	{	202	{
203	ofw_arg_t result[4];	203	ofw_arg_t result[4];
204	int shift;	204	int shift;
205		205
206	if (ofw_call("call-method", 4, 5, result, "translate", ofw_mmu,	206	if (ofw_call("call-method", 4, 5, result, "translate", ofw_mmu,
207	virt, 0) != 0) {	207	virt, 0) != 0) {
208	puts("Error: MMU method translate() failed, halting.\n");	208	puts("Error: MMU method translate() failed, halting.\n");
209	halt();	209	halt();
210	}	210	}
211		211
212	if (ofw_translate_failed(result[0]))	212	if (ofw_translate_failed(result[0]))
213	return NULL;	213	return NULL;
214		214
215	if (sizeof(unative_t) == 8)	215	if (sizeof(unative_t) == 8)
216	shift = 32;	216	shift = 32;
217	else	217	else
218	shift = 0;	218	shift = 0;
219		219
220	return (void *) ((result[2] << shift) \| result[3]);	220	return (void *) ((result[2] << shift) \| result[3]);
221	}	221	}
222		222
223	void ofw_claim_virt(const void virt, const int len)	223	void ofw_claim_virt(const void virt, const int len)
224	{	224	{
225	ofw_arg_t retaddr;	225	ofw_arg_t retaddr;
226		226
227	if (ofw_call("call-method", 5, 2, &retaddr, "claim", ofw_mmu, 0, len,	227	if (ofw_call("call-method", 5, 2, &retaddr, "claim", ofw_mmu, 0, len,
228	virt) != 0) {	228	virt) != 0) {
229	puts("Error: MMU method claim() failed, halting.\n");	229	puts("Error: MMU method claim() failed, halting.\n");
230	halt();	230	halt();
231	}	231	}
232		232
233	return (void *) retaddr;	233	return (void *) retaddr;
234	}	234	}
235		235
236	void ofw_claim_phys(const void phys, const int len)	236	void ofw_claim_phys(const void phys, const int len)
237	{	237	{
238	ofw_arg_t retaddr[2];	238	ofw_arg_t retaddr[2];
239	int shift;	239	int shift;
240		240
241	if (sizeof(unative_t) == 8) {	241	if (sizeof(unative_t) == 8) {
242	shift = 32;	242	shift = 32;
243	if (ofw_call("call-method", 6, 3, retaddr, "claim",	243	if (ofw_call("call-method", 6, 3, retaddr, "claim",
244	ofw_memory_prop, 0, len, ((uintptr_t) phys) >> shift,	244	ofw_memory_prop, 0, len, ((uintptr_t) phys) >> shift,
245	((uintptr_t) phys) & ((uint32_t) -1)) != 0) {	245	((uintptr_t) phys) & ((uint32_t) -1)) != 0) {
246	/*	246	/*
247	* Note that this will help us to discover	247	* Note that this will help us to discover
248	* conflicts between OpenFirmware allocations	248	* conflicts between OpenFirmware allocations
249	* and our use of physical memory.	249	* and our use of physical memory.
250	* It is better to detect collisions here	250	* It is better to detect collisions here
251	* than to cope with weird errors later.	251	* than to cope with weird errors later.
252	*	252	*
253	* So this is really not to make the loader	253	* So this is really not to make the loader
254	* more generic; it is here for debugging	254	* more generic; it is here for debugging
255	* purposes.	255	* purposes.
256	*/	256	*/
257	puts("Error: memory method claim() failed, halting.\n");	257	puts("Error: memory method claim() failed, halting.\n");
258	halt();	258	halt();
259	}	259	}
260	} else {	260	} else {
261	shift = 0;	261	shift = 0;
262	/*	262	/*
263	* FIXME: the number of arguments is probably different...	263	* FIXME: the number of arguments is probably different...
264	*/	264	*/
265	puts("Error: 32-bit ofw_claim_phys not implemented.\n");	265	puts("Error: 32-bit ofw_claim_phys not implemented.\n");
266	halt();	266	halt();
267	}	267	}
268		268
269	return (void *) ((retaddr[0] << shift) \| retaddr[1]);	269	return (void *) ((retaddr[0] << shift) \| retaddr[1]);
270	}	270	}
271		271
272	int ofw_map(const void phys, const void virt, const int size, const int mode)	272	int ofw_map(const void phys, const void virt, const int size, const int mode)
273	{	273	{
274	uintptr_t phys_hi, phys_lo;	274	uintptr_t phys_hi, phys_lo;
275		275
276	if (sizeof(unative_t) == 8) {	276	if (sizeof(unative_t) == 8) {
277	int shift = 32;	277	int shift = 32;
278	phys_hi = (uintptr_t) phys >> shift;	278	phys_hi = (uintptr_t) phys >> shift;
279	phys_lo = (uintptr_t) phys & 0xffffffff;	279	phys_lo = (uintptr_t) phys & 0xffffffff;
280	} else {	280	} else {
281	phys_hi = 0;	281	phys_hi = 0;
282	phys_lo = (uintptr_t) phys;	282	phys_lo = (uintptr_t) phys;
283	}	283	}
284		284
285	return ofw_call("call-method", 7, 1, NULL, "map", ofw_mmu, mode, size,	285	return ofw_call("call-method", 7, 1, NULL, "map", ofw_mmu, mode, size,
286	virt, phys_hi, phys_lo);	286	virt, phys_hi, phys_lo);
287	}	287	}
288		288
289	/** Save OpenFirmware physical memory map.	289	/** Save OpenFirmware physical memory map.
290	*	290	*
291	* @param map Memory map structure where the map will be saved.	291	* @param map Memory map structure where the map will be saved.
292	*	292	*
293	* @return Zero on failure, non-zero on success.	293	* @return Zero on failure, non-zero on success.
294	*/	294	*/
295	int ofw_memmap(memmap_t *map)	295	int ofw_memmap(memmap_t *map)
296	{	296	{
297	unsigned int ac = ofw_get_address_cells(ofw_memory) /	297	unsigned int ac = ofw_get_address_cells(ofw_memory) /
298	(sizeof(uintptr_t) / sizeof(uint32_t));	298	(sizeof(uintptr_t) / sizeof(uint32_t));
299	unsigned int sc = ofw_get_size_cells(ofw_memory) /	299	unsigned int sc = ofw_get_size_cells(ofw_memory) /
300	(sizeof(uintptr_t) / sizeof(uint32_t));	300	(sizeof(uintptr_t) / sizeof(uint32_t));
301		301
302	uintptr_t buf[((ac + sc) * MEMMAP_MAX_RECORDS)];	302	uintptr_t buf[((ac + sc) * MEMMAP_MAX_RECORDS)];
303	int ret = ofw_get_property(ofw_memory, "reg", buf, sizeof(buf));	303	int ret = ofw_get_property(ofw_memory, "reg", buf, sizeof(buf));
304	if (ret <= 0) /* ret is the number of written bytes */	304	if (ret <= 0) /* ret is the number of written bytes */
305	return false;	305	return false;
306		306
307	int pos;	307	int pos;
308	map->total = 0;	308	map->total = 0;
309	map->count = 0;	309	map->count = 0;
310	for (pos = 0; (pos < ret / sizeof(uintptr_t)) &&	310	for (pos = 0; (pos < ret / sizeof(uintptr_t)) &&
311	(map->count < MEMMAP_MAX_RECORDS); pos += ac + sc) {	311	(map->count < MEMMAP_MAX_RECORDS); pos += ac + sc) {
312	void start = (void ) (buf[pos + ac - 1]);	312	void start = (void ) (buf[pos + ac - 1]);
313	unsigned int size = buf[pos + ac + sc - 1];	313	unsigned int size = buf[pos + ac + sc - 1];
314		314
315	/*	315	/*
316	* This is a hot fix of the issue which occurs on machines	316	* This is a hot fix of the issue which occurs on machines
317	* where there are holes in the physical memory (such as	317	* where there are holes in the physical memory (such as
318	* SunBlade 1500). Should we detect a hole in the physical	318	* SunBlade 1500). Should we detect a hole in the physical
319	* memory, we will ignore any memory detected behind	319	* memory, we will ignore any memory detected behind
320	* the hole and pretend the hole does not exist.	320	* the hole and pretend the hole does not exist.
321	*/	321	*/
322	if ((map->count > 0) && (map->zones[map->count - 1].start +	322	if ((map->count > 0) && (map->zones[map->count - 1].start +
323	map->zones[map->count - 1].size < start))	323	map->zones[map->count - 1].size < start))
324	break;	324	break;
325		325
326	if (size > 0) {	326	if (size > 0) {
327	map->zones[map->count].start = start;	327	map->zones[map->count].start = start;
328	map->zones[map->count].size = size;	328	map->zones[map->count].size = size;
329	map->count++;	329	map->count++;
330	map->total += size;	330	map->total += size;
331	}	331	}
332	}	332	}
333		333
334	return true;	334	return true;
335	}	335	}
336		336
337	int ofw_screen(screen_t *screen)	337	int ofw_screen(screen_t *screen)
338	{	338	{
339	char device_name[BUF_SIZE];	339	char device_name[BUF_SIZE];
340	uint32_t virtaddr;	340	uint32_t virtaddr;
341		341
342	if (ofw_get_property(ofw_aliases, "screen", device_name,	342	if (ofw_get_property(ofw_aliases, "screen", device_name,
343	sizeof(device_name)) <= 0)	343	sizeof(device_name)) <= 0)
344	return false;	344	return false;
345		345
346	phandle device = ofw_find_device(device_name);	346	phandle device = ofw_find_device(device_name);
347	if (device == -1)	347	if (device == -1)
348	return false;	348	return false;
349		349
350	if (ofw_get_property(device, "address", &virtaddr,	350	if (ofw_get_property(device, "address", &virtaddr,
351	sizeof(virtaddr)) <= 0)	351	sizeof(virtaddr)) <= 0)
352	return false;	352	return false;
353		353
354	screen->addr = (void *) ((uintptr_t) virtaddr);	354	screen->addr = (void *) ((uintptr_t) virtaddr);
355		355
356	if (ofw_get_property(device, "width", &screen->width,	356	if (ofw_get_property(device, "width", &screen->width,
357	sizeof(screen->width)) <= 0)	357	sizeof(screen->width)) <= 0)
358	return false;	358	return false;
359		359
360	if (ofw_get_property(device, "height", &screen->height,	360	if (ofw_get_property(device, "height", &screen->height,
361	sizeof(screen->height)) <= 0)	361	sizeof(screen->height)) <= 0)
362	return false;	362	return false;
363		363
364	if (ofw_get_property(device, "depth", &screen->bpp,	364	if (ofw_get_property(device, "depth", &screen->bpp,
365	sizeof(screen->bpp)) <= 0)	365	sizeof(screen->bpp)) <= 0)
366	return false;	366	return false;
367		367
368	if (ofw_get_property(device, "linebytes", &screen->scanline,	368	if (ofw_get_property(device, "linebytes", &screen->scanline,
369	sizeof(screen->scanline)) <= 0)	369	sizeof(screen->scanline)) <= 0)
370	return false;	370	return false;
371		371
372	return true;	372	return true;
373	}	373	}
374		374
-		375	#define RED(i) (((i) >> 5) & ((1 << 3) - 1))
-		376	#define GREEN(i) (((i) >> 3) & ((1 << 2) - 1))
-		377	#define BLUE(i) ((i) & ((1 << 3) - 1))
-		378	#define CLIP(i) ((i) <= 255 ? (i) : 255)
-		379
-		380
375	/**	381	/**
376	* Sets up the palette for the 8-bit color depth configuration so that the	382	* Sets up the palette for the 8-bit color depth configuration so that the
377	* 3:2:3 color scheme can be used. Checks that setting the palette makes sense	383	* 3:2:3 color scheme can be used. Checks that setting the palette makes sense
378	* (appropriate nodes exist in the OBP tree and the color depth is not greater	384	* (appropriate nodes exist in the OBP tree and the color depth is not greater
379	* than 8).	385	* than 8).
-		386	*
-		387	* @return true if the palette has been set, false otherwise
380	*	388	*
381	* @return true if the palette has been set, false otherwise	-
382	*/	389	*/
383	int setup_palette(void)	390	int ofw_setup_palette(void)
384	{	391	{
385	char device_name[BUF_SIZE];	392	char device_name[BUF_SIZE];
386		393
387	/* resolve alias */	394	/* resolve alias */
388	if (ofw_get_property(ofw_aliases, "screen", device_name,	395	if (ofw_get_property(ofw_aliases, "screen", device_name,
389	sizeof(device_name)) <= 0)	396	sizeof(device_name)) <= 0)
390	return false;	397	return false;
391		398
392	/* for depth greater than 8 it makes no sense to set up the palette */	399	/* for depth greater than 8 it makes no sense to set up the palette */
393	uint32_t depth;	400	uint32_t depth;
394	phandle device = ofw_find_device(device_name);	401	phandle device = ofw_find_device(device_name);
395	if (device == -1)	402	if (device == -1)
396	return false;	403	return false;
397	if (ofw_get_property(device, "depth", &depth, sizeof(uint32_t)) <= 0)	404	if (ofw_get_property(device, "depth", &depth, sizeof(uint32_t)) <= 0)
398	return false;	405	return false;
399	if (depth != 8)	406	if (depth != 8)
400	return false;	407	return false;
401		408
402	/* required in order to be able to make a method call */	409	/* required in order to be able to make a method call */
403	ihandle screen = ofw_open(device_name);	410	ihandle screen = ofw_open(device_name);
404	if (screen == -1)	411	if (screen == -1)
405	return false;	412	return false;
406		413
407	/* setup the palette so that the (inverted) 3:2:3 scheme is usable */	414	/* setup the palette so that the (inverted) 3:2:3 scheme is usable */
408	unsigned int i;	415	unsigned int i;
409	for (i = 0; i < 256; i++)	416	for (i = 0; i < 256; i++)
410	if (ofw_call("call-method", 6, 1, NULL, "color!", screen,	417	ofw_call("call-method", 6, 1, NULL, "color!", screen,
411	255 - i,	-
412	i << 5,	-
413	(i >> 3) << 6,	-
414	(i >> 5) << 5) != 0);	418	255 - i, CLIP(BLUE(i) * 37), GREEN(i) * 85, CLIP(RED(i) * 37));
415	return true;	419	return true;
416	}	420	}
417		421
418	void ofw_quiesce(void)	422	void ofw_quiesce(void)
419	{	423	{
420	ofw_call("quiesce", 0, 0, NULL);	424	ofw_call("quiesce", 0, 0, NULL);
421	}	425	}
422		426

Subversion Repositories HelenOS

(root)/trunk/boot/genarch/ofw.c – Rev 3826 → 3861