/* Open firmware emulation.
*
* This is really simplistic. The first goal is to implement all stuff
* needed to boot Linux. Then, I'll try Darwin.
* Note that this emulation run in the host environment.
* There is no Forth interpreter, so standard bootloader cannot be launched.
* In the future, it will be nice to get a complete OpenFirmware implementation
* so that OSes can be launched exactly the way they are in the real world...
*
* Copyright (c) 2003-2005 Jocelyn Mayer
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License V2
* as published by the Free Software Foundation
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include <stdlib.h>
#include <stdio.h>
#include "bios.h"
//#define DEBUG_OF 1
#if defined (DEBUG_OF)
#define OF_DPRINTF(fmt, args...) \
do { dprintf("%s: " fmt, __func__ , ##args); } while (0)
#else
#define OF_DPRINTF(fmt, args...) \
do { } while (0)
#endif
#define PROT_READ 1
#define PROT_WRITE 2
typedef struct OF_transl_t OF_transl_t;
struct OF_transl_t {
uint32_t virt;
uint32_t size;
uint32_t phys;
uint32_t mode;
};
typedef struct OF_env_t OF_env_t;
struct OF_env_t {
uint32_t *stackp; /* Stack pointer */
uint32_t *stackb; /* Stack base */
uint32_t *funcp; /* Function stack pointer */
uint32_t *funcb; /* Function stack base */
};
typedef struct OF_bustyp_t OF_bustyp_t;
struct OF_bustyp_t {
const char *name;
int type;
};
typedef struct pci_address_t pci_address_t;
struct pci_address_t {
uint32_t hi;
uint32_t mid;
uint32_t lo;
};
typedef struct pci_reg_prop_t pci_reg_prop_t;
struct pci_reg_prop_t {
pci_address_t addr;
uint32_t size_hi;
uint32_t size_lo;
};
typedef struct pci_range_t pci_range_t;
struct pci_range_t {
pci_address_t addr;
uint32_t phys;
uint32_t size_hi;
uint32_t size_lo;
};
/*****************************************************************************/
__attribute__ (( section (".OpenFirmware") ))
static void OF_lds (uint8_t *dst, const void *address)
{
const uint8_t *p;
uint8_t *_d = dst;
for (p = address; *p != '\0'; p++) {
*_d++ = *p;
}
*_d = '\0';
OF_DPRINTF("Loaded string %s\n", dst);
}
__attribute__ (( section (".OpenFirmware") ))
static void OF_sts (void *address, const uint8_t *src)
{
const uint8_t *_s;
uint8_t *p = address;
OF_DPRINTF("Store string %s\n", src);
for (_s = src; *_s != '\0'; _s++) {
*p++ = *_s;
}
*p = '\0';
}
#define OF_DUMP_STRING(env, buffer) \
do { \
unsigned char tmp[OF_NAMELEN_MAX]; \
OF_lds(tmp, buffer); \
OF_DPRINTF("[%s]\n", tmp); \
} while (0)
/*****************************************************************************/
/* Forth like environmnent */
#define OF_CHECK_NBARGS(env, nb) \
do { \
int nb_args; \
nb_args = stackd_depth((env)); \
if (nb_args != (nb)) { \
printf("%s: Bad number of arguments (%d - %d)\n", \
__func__, nb_args, (nb)); \
bug(); \
popd_all((env), nb_args); \
pushd((env), -1); \
return; \
} \
} while (0)
#define OF_STACK_SIZE 0x1000
#define OF_FSTACK_SIZE 0x100
__attribute__ (( section (".OpenFirmware_vars") ))
uint8_t OF_stack[OF_STACK_SIZE];
__attribute__ (( section (".OpenFirmware_vars") ))
uint8_t OF_fstack[OF_FSTACK_SIZE];
typedef void (*OF_cb_t)(OF_env_t *OF_env);
static inline void _push (uint32_t **stackp, uint32_t data)
{
// OF_DPRINTF("%p 0x%0x\n", *stackp, data);
**stackp = data;
(*stackp)--;
}
static inline uint32_t _pop (uint32_t **stackp)
{
(*stackp)++;
// OF_DPRINTF("%p 0x%0x\n", *stackp, **stackp);
return **stackp;
}
static inline void _pop_all (uint32_t **stackp, int nb)
{
int i;
for (i = 0; i < nb; i++)
(*stackp)++;
}
static inline int _stack_depth (uint32_t *stackp, uint32_t *basep)
{
return basep - stackp;
}
static inline void pushd (OF_env_t *OF_env, uint32_t data)
{
_push(&OF_env->stackp, data);
}
static inline uint32_t popd (OF_env_t *OF_env)
{
return _pop(&OF_env->stackp);
}
static inline void popd_all (OF_env_t *OF_env, int nb)
{
_pop_all(&OF_env->stackp, nb);
}
static inline int stackd_depth (OF_env_t *OF_env)
{
return _stack_depth(OF_env->stackp, OF_env->stackb);
}
static inline void pushf (OF_env_t *OF_env, OF_cb_t *func)
{
_push(&OF_env->funcp, (uint32_t)func);
}
static inline OF_cb_t *popf (OF_env_t *OF_env)
{
return (OF_cb_t *)_pop(&OF_env->funcp);
}
static inline void popf_all (OF_env_t *OF_env, int nb)
{
_pop_all(&OF_env->funcp, nb);
}
static inline int stackf_depth (OF_env_t *OF_env)
{
return _stack_depth(OF_env->funcp, OF_env->funcb);
}
static inline void OF_env_init (OF_env_t *OF_env)
{
OF_env->stackb = (uint32_t *)(OF_stack + OF_STACK_SIZE - 4);
OF_env->stackp = OF_env->stackb;
OF_env->funcb = (uint32_t *)(OF_fstack + OF_FSTACK_SIZE - 4);
OF_env->funcp = OF_env->funcb;
}
/* Forth run-time */
__attribute__ (( section (".OpenFirmware") ))
static void C_to_Forth (OF_env_t *env, void *p, OF_cb_t *cb)
{
OF_cb_t *_cb;
uint32_t *u, *rets;
uint32_t i, n_args, n_rets, tmp;
// OF_DPRINTF("enter\n");
/* Fill argument structure */
u = p;
n_args = *u++;
n_rets = *u++;
u += n_args;
rets = u;
// OF_DPRINTF("n_args=%d n_rets=%d\n", n_args, n_rets);
/* Load arguments */
for (i = 0; i < n_args; i++)
pushd(env, *(--u));
pushf(env, cb);
while (stackf_depth(env) != 0) {
// OF_DPRINTF("func stack: %p %p\n", env->funcb, env->funcp);
_cb = popf(env);
// OF_DPRINTF("Next func: %p %d\n", cb, stackf_depth(env));
(*_cb)(env);
}
// OF_DPRINTF("Back to C: n_args=%d n_rets=%d\n", n_args, n_rets);
/* Copy returned values */
for (i = 0; stackd_depth(env) != 0; i++) {
tmp = popd(env);
// OF_DPRINTF("Store 0x%0x (%d)\n", tmp, tmp);
*rets++ = tmp;
}
for (; i < n_rets; i++)
*rets++ = 0;
OF_CHECK_NBARGS(env, 0);
// OF_DPRINTF("done\n");
}
/*****************************************************************************/
/* Memory pool (will be needed when it'll become native) */
#if 0
#define OF_INTBITS_LEN 128
#define OF_INTPOOL_LEN (OF_INTBITS_LEN * 8)
__attribute__ (( section (".OpenFirmware_vars") ))
static uint32_t OF_int_pool[OF_INTPOOL_LEN];
__attribute__ (( section (".OpenFirmware_vars") ))
static uint8_t OF_int_bits[OF_INTBITS_LEN];
__attribute__ (( section (".OpenFirmware") ))
static uint32_t *OF_int_alloc (unused OF_env_t *env)
{
uint8_t tmp;
int i, j;
for (i = 0; i < OF_INTBITS_LEN; i++) {
tmp = OF_int_bits[i];
if (tmp == 0xFF)
continue;
for (j = 0; j < 7; j++) {
if ((tmp & 1) == 0) {
OF_int_bits[i] |= 1 << j;
return &OF_int_pool[(i << 3) | j];
}
tmp = tmp >> 1;
}
}
printf("ALERT: unable to \"allocate\" new integer\n");
return NULL;
}
__attribute__ (( section (".OpenFirmware") ))
static void OF_int_free (unused OF_env_t *env,
uint32_t *area)
{
int i, j;
i = area - OF_int_pool;
j = i & 7;
i = i >> 3;
OF_int_bits[i] &= ~(1 << j);
}
__attribute__ (( section (".OpenFirmware") ))
static void OF_free (unused OF_env_t *env, void *area)
{
uint32_t *check;
/* Check if it's in our int pool */
check = area;
if (check >= OF_int_pool && check < (OF_int_pool + OF_INTPOOL_LEN)) {
OF_int_free(env, check);
return;
}
#if 0
free(area);
#endif
}
#endif
/*****************************************************************************/
/* Internal structures */
/* Property value types */
typedef struct OF_node_t OF_node_t;
typedef struct OF_prop_t OF_prop_t;
typedef struct OF_method_t OF_method_t;
typedef struct OF_inst_t OF_inst_t;
#define OF_ADDRESS_NONE ((uint32_t)(-1))
/* Tree node */
struct OF_node_t {
/* Parent node */
OF_node_t *parent;
/* Link to next node at the same level */
OF_node_t *next;
/* Link to children, if any */
OF_node_t *children, *child_last;
/* refcount */
int refcount;
/* The following ones belong to the package */
/* Package */
uint16_t pack_id;
/* links count */
uint16_t link_count;
uint16_t link_cur;
OF_node_t *link_ref;
/* Properties */
OF_prop_t *properties, *prop_last, *prop_name, *prop_address;
/* Methods */
OF_method_t *methods, *method_last;
/* private data */
void *private_data;
/* static data */
void *static_data;
/* instances */
OF_inst_t *instances, *inst_last;
};
/* Node property */
struct OF_prop_t {
/* Link to next property */
OF_prop_t *next;
/* The node it belongs to */
OF_node_t *node;
/* property name */
const unsigned char *name;
/* property value len */
int vlen;
/* property value buffer */
char *value;
/* Property change callback */
void (*cb)(OF_env_t *OF_env, OF_prop_t *prop, const void *data, int len);
};
/* Node method */
enum {
OF_METHOD_INTERNAL = 0,
OF_METHOD_EXPORTED,
};
struct OF_method_t {
/* Link to next method */
OF_method_t *next;
/* The package it belongs to */
OF_node_t *node;
/* method name */
unsigned char *name;
/* Method function pointer */
OF_cb_t func;
};
/* Package instance */
struct OF_inst_t {
/* Link to next instance of the same package */
OF_inst_t *next;
/* Link to the parent instance */
OF_inst_t *parent;
/* The package it belongs to */
OF_node_t *node;
/* Instance identifier */
uint16_t inst_id;
/* Instance data */
void *data;
};
/* reg property */
typedef struct OF_regprop_t OF_regprop_t;
struct OF_regprop_t {
uint32_t address;
uint32_t size;
};
/* range property */
typedef struct OF_range_t OF_range_t;
struct OF_range_t {
uint32_t virt;
uint32_t size;
uint32_t phys;
};
/* Open firmware tree */
#define OF_MAX_PACKAGE 256
/* nodes and packages */
__attribute__ (( section (".OpenFirmware_vars") ))
static OF_node_t *OF_node_root;
__attribute__ (( section (".OpenFirmware_vars") ))
static uint16_t OF_pack_last_id = 0;
__attribute__ (( section (".OpenFirmware_vars") ))
static uint16_t inst_last_id = 0;
/* To speed up lookup by id, we get a package table */
__attribute__ (( section (".OpenFirmware_vars") ))
static OF_node_t *OF_packages[OF_MAX_PACKAGE];
__attribute__ (( section (".OpenFirmware_vars") ))
static OF_node_t *OF_pack_active;
static OF_prop_t *OF_prop_string_new (OF_env_t *env, OF_node_t *node,
const unsigned char *name,
const unsigned char *string);
static OF_prop_t *OF_prop_int_new (OF_env_t *env, OF_node_t *node,
const unsigned char *name, uint32_t value);
static OF_prop_t *OF_property_get (OF_env_t *env, OF_node_t *node,
const unsigned char *name);
static uint16_t OF_pack_handle (OF_env_t *env, OF_node_t *node);
__attribute__ (( section (".OpenFirmware_vars") ))
static uint8_t *RTAS_memory;
/*****************************************************************************/
/* Node management */
/* Insert a new node */
__attribute__ (( section (".OpenFirmware") ))
static uint16_t OF_pack_new_id (unused OF_env_t *env, OF_node_t *node)
{
uint16_t cur_id;
for (cur_id = OF_pack_last_id + 1; cur_id != OF_pack_last_id; cur_id++) {
if (cur_id == (uint16_t)(OF_MAX_PACKAGE))
cur_id = 1;
if (OF_packages[cur_id] == NULL) {
OF_packages[cur_id] = node;
OF_pack_last_id = cur_id;
return cur_id;
}
}
return (uint16_t)(-1);
}
static OF_node_t *OF_node_create (OF_env_t *env, OF_node_t *parent,
const unsigned char *name, uint32_t address)
{
OF_node_t *new;
OF_DPRINTF("New node: %s\n", name);
new = malloc(sizeof(OF_node_t));
if (new == NULL) {
ERROR("%s can't alloc new node '%s'\n", __func__, name);
return NULL;
}
memset(new, 0, sizeof(OF_node_t));
new->parent = parent;
new->refcount = 1;
new->link_count = 1;
new->prop_name = OF_prop_string_new(env, new, "name", name);
if (new->prop_name == NULL) {
free(new);
ERROR("%s can't alloc new node '%s' name\n", __func__, name);
return NULL;
}
new->prop_address = OF_prop_int_new(env, new, "unit-address", address);
if (new->prop_address == NULL) {
free(new->prop_name->value);
free(new->prop_name);
free(new);
ERROR("%s can't alloc new node '%s' address\n", __func__, name);
return NULL;
}
/* Link it in parent tree */
if (parent != NULL) {
/* SHOULD LOCK */
if (parent->children == NULL) {
parent->children = new;
} else {
parent->child_last->next = new;
}
parent->child_last = new;
} else {
/* This is a bug and should never happen, but for root node */
if (strcmp(name, "device-tree") != 0)
ERROR("WARNING: parent of '%s' is NULL!\n", name);
}
// OF_DPRINTF("New node: %s get id\n", name);
return new;
}
__attribute__ (( section (".OpenFirmware") ))
static OF_node_t *OF_node_new (OF_env_t *env, OF_node_t *parent,
const unsigned char *name, uint32_t address)
{
OF_node_t *new;
new = OF_node_create(env, parent, name, address);
if (new == NULL)
return NULL;
new->pack_id = OF_pack_new_id(env, new);
// OF_DPRINTF("New node: %s id=0x%0x\n", name, new->pack_id);
OF_pack_active = new;
return new;
}
static inline OF_node_t *OF_node_parent (unused OF_env_t *env, OF_node_t *node)
{
return node->parent;
}
/* Look for a node, given its name */
__attribute__ (( section (".OpenFirmware") ))
static OF_node_t *OF_node_get_child (OF_env_t *env, OF_node_t *parent,
const unsigned char *name,
uint32_t address)
{
unsigned char tname[OF_NAMELEN_MAX];
OF_node_t *parse, *tmp;
OF_prop_t *prop_name, *prop_address;
uint32_t *addr_valp;
int len, i;
if (parent == OF_node_root) {
OF_DPRINTF("Look for node [%s]\n", name);
}
len = strlen(name);
memcpy(tname, name, len + 1);
for (i = len; i > 0; i--) {
if (tname[i - 1] == ',') {
tname[i - 1] = '\0';
len = i;
break;
}
}
for (parse = parent->children; parse != NULL; parse = parse->next) {
prop_name = parse->prop_name;
prop_address = parse->prop_address;
if (prop_address == NULL)
addr_valp = NULL;
else
addr_valp = (void *)prop_address->value;
#if 0
OF_DPRINTF("node [%s] <=> [%s]\n", prop_name->value, tname);
#endif
if (prop_name != NULL && strncmp(prop_name->value, tname, len) == 0 &&
(prop_name->value[len] == '\0') &&
(address == OF_ADDRESS_NONE || addr_valp == NULL ||
address == *addr_valp)) {
parse->refcount++;
return parse;
}
#if 1
OF_DPRINTF("look in children [%s]\n", prop_name->value);
#endif
tmp = OF_node_get_child(env, parse, tname, address);
if (tmp != NULL)
return tmp;
#if 0
OF_DPRINTF("didn't find in children [%s]\n", prop_name->value);
#endif
}
if (parent == OF_node_root) {
OF_DPRINTF("node [%s] not found\n", name);
}
return NULL;
}
__attribute__ (( section (".OpenFirmware") ))
static OF_node_t *OF_node_get (OF_env_t *env, const unsigned char *name)
{
unsigned char tname[OF_NAMELEN_MAX];
unsigned char *addrp;
uint32_t address;
if (strcmp(name, "device_tree") == 0)
return OF_node_root;
strcpy(tname, name);
addrp = strchr(tname, '@');
if (addrp == NULL) {
address = OF_ADDRESS_NONE;
} else {
*addrp++ = '\0';
address = strtol(addrp, NULL, 16);
}
/* SHOULD LOCK */
return OF_node_get_child(env, OF_node_root, name, address);
}
/* Release a node */
__attribute__ (( section (".OpenFirmware") ))
static void OF_node_put (unused OF_env_t *env, OF_node_t *node)
{
if (--node->refcount < 0)
node->refcount = 0;
}
/*****************************************************************************/
/* Packages tree walk */
__attribute__ (( section (".OpenFirmware") ))
static uint16_t OF_pack_handle (unused OF_env_t *env, OF_node_t *node)
{
if (node == NULL)
return 0;
return node->pack_id;
}
__attribute__ (( section (".OpenFirmware") ))
static OF_node_t *OF_pack_find_by_name (OF_env_t *env, OF_node_t *base,
const unsigned char *name)
{
unsigned char tmp[OF_NAMELEN_MAX], *addrp;
const unsigned char *sl, *st;
OF_node_t *parse;
OF_prop_t *prop_name, *prop_address;
uint32_t address, *addr_valp;
int len;
OF_DPRINTF("Path [%s] in '%s'\n", name, base->prop_name->value);
st = name;
if (*st == '/') {
st++;
}
if (*st == '\0') {
/* Should never happen */
OF_DPRINTF("Done\n");
return base;
}
sl = strchr(st, '/');
if (sl == NULL) {
len = strlen(st);
} else {
len = sl - st;
}
memcpy(tmp, st, len);
tmp[len] = '\0';
addrp = strchr(tmp, '@');
if (addrp == NULL) {
address = OF_ADDRESS_NONE;
} else {
len = addrp - tmp;
*addrp++ = '\0';
address = strtol(addrp, NULL, 16);
}
OF_DPRINTF("Look for [%s] '%s' %08x\n", tmp, sl, address);
for (parse = base->children; parse != NULL; parse = parse->next) {
prop_name = parse->prop_name;
prop_address = parse->prop_address;
if (prop_address == NULL)
addr_valp = NULL;
else
addr_valp = (void *)prop_address->value;
#if 0
OF_DPRINTF("Check [%s]\n", prop_name->value);
#endif
if (prop_name == NULL) {
printf("ERROR: missing address in node, parent: '%s'\n",
base->prop_name->value);
bug();
}
if (strncmp(prop_name->value, tmp, len) == 0 &&
prop_name->value[len] == '\0' &&
(address == OF_ADDRESS_NONE || addr_valp == NULL ||
address == *addr_valp)) {
OF_pack_active = parse;
if (sl == NULL) {
OF_DPRINTF("Done\n");
return parse;
}
OF_DPRINTF("Recurse: '%s'\n", sl + 1);
return OF_pack_find_by_name(env, parse, sl + 1);
}
}
OF_DPRINTF("Didn't found [%s]\n", tmp);
return NULL;
}
__attribute__ (( section (".OpenFirmware") ))
static OF_node_t *OF_pack_find (unused OF_env_t *env, uint16_t phandle)
{
if (phandle > OF_MAX_PACKAGE)
return NULL;
if (OF_packages[phandle] == NULL) {
OF_DPRINTF("No package %0x\n", phandle);
} else {
OF_DPRINTF("return package: %0x %p [%s]\n", phandle,
OF_packages[phandle],
OF_packages[phandle]->prop_name->value);
}
return OF_packages[phandle];
}
__attribute__ (( section (".OpenFirmware") ))
static OF_node_t *OF_pack_next (OF_env_t *env, uint16_t phandle)
{
OF_node_t *node;
for (node = OF_pack_find(env, phandle); node != NULL; node = node->next) {
if (OF_pack_handle(env, node) != phandle)
break;
}
#if 0
OF_DPRINTF("found node %p [%s]\n", node, node->prop_name->value);
#endif
return node;
}
__attribute__ (( section (".OpenFirmware") ))
static OF_node_t *OF_pack_child (OF_env_t *env, uint16_t phandle)
{
OF_node_t *node;
node = OF_pack_find(env, phandle);
if (node == NULL) {
ERROR("%s didn't find pack %04x\n", __func__, phandle);
return NULL;
}
node = node->children;
#if 0
OF_DPRINTF("found node %p [%s]\n", node, node->prop_name->value);
#endif
return node;
}
__attribute__ (( section (".OpenFirmware") ))
static OF_node_t *OF_pack_parent (OF_env_t *env, uint16_t phandle)
{
OF_node_t *node;
node = OF_pack_find(env, phandle);
if (node == NULL) {
ERROR("%s didn't find pack %04x\n", __func__, phandle);
return NULL;
}
node = OF_node_parent(env, node);
#if 0
OF_DPRINTF("found node %p [%s]\n", node, node->prop_name->value);
#endif
return node;
}
/*****************************************************************************/
/* Package properties management */
/* Insert a new property */
__attribute__ (( section (".OpenFirmware") ))
static OF_prop_t *OF_property_new (unused OF_env_t *env, OF_node_t *node,
const unsigned char *name,
const void *data, int len)
{
OF_prop_t *prop;
#ifdef DEBUG_OF
{
OF_prop_t *_prop;
_prop = OF_property_get(env, node, name);
if (_prop != NULL) {
printf("Property '%s' already present !\n", name);
bug();
}
}
#endif
/* Allocate a new property */
prop = malloc(sizeof(OF_prop_t));
if (prop == NULL) {
ERROR("%s cannot allocate property '%s'\n", __func__, name);
return NULL;
}
memset(prop, 0, sizeof(OF_prop_t));
prop->name = strdup(name);
if (prop->name == NULL) {
free(prop);
ERROR("%s cannot allocate property '%s' name\n", __func__, name);
return NULL;
}
/* Fill it */
if (data != NULL && len > 0) {
prop->value = malloc(len);
if (prop->value == NULL) {
free(prop);
ERROR("%s cannot allocate property '%s' value\n", __func__, name);
return NULL;
}
prop->vlen = len;
memcpy(prop->value, data, len);
}
OF_DPRINTF("New property [%s] '%s'\n\t%p %p %d %p\n", name, prop->name, prop->name, data, len, prop->value);
/* Link it */
/* SHOULD LOCK */
if (node->properties == NULL)
node->properties = prop;
else
node->prop_last->next = prop;
node->prop_last = prop;
return prop;
}
/* Find a property given its name */
__attribute__ (( section (".OpenFirmware") ))
static OF_prop_t *OF_property_get (unused OF_env_t *env, OF_node_t *node,
const unsigned char *name)
{
OF_prop_t *prop;
#if 0
OF_DPRINTF("Look for property [%s] in 0x%0x '%s'\n", name,
node->pack_id, node->prop_name->value);
#endif
if (node == NULL)
return NULL;
/* *SHOULD LOCK* */
for (prop = node->properties; prop != NULL; prop = prop->next) {
#if 0
OF_DPRINTF("property [%s] <=> [%s]\n", prop->name, name);
#endif
if (strcmp(prop->name, name) == 0) {
return prop;
}
}
#if 0
OF_DPRINTF("property [%s] not found in 0x%08x '%s'\n", name,
node->pack_id, node->prop_name->value);
#endif
return NULL;
}
/* Change a property */
__attribute__ (( section (".OpenFirmware") ))
static OF_prop_t *OF_property_set (OF_env_t *env, OF_node_t *node,
const unsigned char *name,
const void *data, int len)
{
OF_prop_t *prop;
void *tmp;
if (node == NULL)
return NULL;
prop = OF_property_get(env, node, name);
if (prop != NULL) {
OF_DPRINTF("change property [%s]\n", name);
tmp = malloc(len);
if (tmp == NULL && len != 0) {
ERROR("%s cannot set property '%s'\n", __func__, name);
return NULL;
}
free(prop->value);
prop->value = tmp;
prop->vlen = len;
memcpy(prop->value, data, len);
if (prop->cb != NULL) {
(*prop->cb)(env, prop, data, len);
}
} else {
OF_DPRINTF("new property [%s]\n", name);
prop = OF_property_new(env, node, name, data, len);
}
return prop;
}
__attribute__ (( section (".OpenFirmware") ))
static int OF_property_len (OF_env_t *env, OF_node_t *node,
const unsigned char *name)
{
OF_prop_t *prop;
prop = OF_property_get(env, node, name);
if (prop == NULL)
return -1;
return prop->vlen;
}
__attribute__ (( section (".OpenFirmware") ))
static unsigned char *hex2buf (unsigned char *buf, uint32_t value, int fill)
{
int pos, d;
buf[8] = '\0';
pos = 7;
if (value == 0) {
buf[pos--] = '0';
} else {
for (; value != 0; pos--) {
d = value & 0xF;
if (d > 9)
d += 'a' - '0' - 10;
buf[pos] = d + '0';
value = value >> 4;
}
}
if (fill != 0) {
for (; pos != -1; pos--) {
buf[pos] = '0';
}
}
return &buf[pos];
}
__attribute__ (( section (".OpenFirmware") ))
static int OF_property_copy (OF_env_t *env, void *buffer, int maxlen,
OF_node_t *node, const unsigned char *name)
{
unsigned char tmp[OF_PROPLEN_MAX];
OF_prop_t *prop;
int len;
prop = OF_property_get(env, node, name);
if (prop == NULL) {
ERROR("%s cannot get property '%s' for %s\n", __func__, name,
node->prop_name->value);
return -1;
}
len = prop->vlen > maxlen ? maxlen : prop->vlen;
if (prop->value != NULL) {
tmp[0] = '0';
tmp[1] = 'x';
hex2buf(tmp + 2, *((uint32_t *)prop->value), 1);
} else {
*tmp = '\0';
}
OF_DPRINTF("copy property [%s] len=%d to %p len=%d\n",
name, prop->vlen, buffer, maxlen);
if (strcmp(name, "name") == 0) {
OF_DPRINTF("=> '%s'\n", prop->value);
}
memcpy(buffer, prop->value, len);
// OF_DPRINTF("done\n");
return len;
}
__attribute__ (( section (".OpenFirmware") ))
static OF_prop_t *OF_property_next (OF_env_t *env, OF_node_t *node,
const unsigned char *name)
{
OF_prop_t *prop, *next;
if (name == NULL || *name == '\0') {
next = node->properties;
} else {
prop = OF_property_get(env, node, name);
if (prop == NULL) {
OF_DPRINTF("Property [%s] not found\n", name);
next = NULL;
} else {
next = prop->next;
/* Skip address if not set */
if (next == node->prop_address &&
*((uint32_t *)next->value) == OF_ADDRESS_NONE)
next = next->next;
}
}
#if 0
OF_DPRINTF("Found property %p\n", next);
#endif
return next;
}
/* Simplified helpers */
__attribute__ (( section (".OpenFirmware") ))
static OF_prop_t *OF_prop_string_new (OF_env_t *env, OF_node_t *node,
const unsigned char *name,
const unsigned char *string)
{
#ifdef DEBUG_OF
{
OF_prop_t *prop;
prop = OF_property_get(env, node, name);
if (prop != NULL) {
printf("Property '%s' already present !\n", name);
bug();
}
}
#endif
return OF_property_new(env, node, name,
string, strlen(string) + 1);
}
/* convert '\1' char to '\0' */
static OF_prop_t *OF_prop_string_new1 (OF_env_t *env, OF_node_t *node,
const unsigned char *name,
const unsigned char *string)
{
int len, i;
OF_prop_t *ret;
unsigned char *str;
if (strchr(string, '\1') == NULL) {
return OF_prop_string_new(env, node, name, string);
} else {
len = strlen(string) + 1;
str = malloc(len);
if (!str)
return NULL;
memcpy(str, string, len);
for(i = 0; i < len; i++)
if (str[i] == '\1')
str[i] = '\0';
ret = OF_property_new(env, node, name,
str, len);
free(str);
return ret;
}
}
__attribute__ (( section (".OpenFirmware") ))
static OF_prop_t *OF_prop_int_new (OF_env_t *env, OF_node_t *node,
const unsigned char *name, uint32_t value)
{
#ifdef DEBUG_OF
{
OF_prop_t *prop;
prop = OF_property_get(env, node, name);
if (prop != NULL) {
printf("Property '%s' already present !\n", name);
bug();
}
}
#endif
return OF_property_new(env, node, name, &value, sizeof(uint32_t));
}
__attribute__ (( section (".OpenFirmware") ))
static OF_prop_t *OF_prop_string_set (OF_env_t *env, OF_node_t *node,
const unsigned char *name,
const unsigned char *string)
{
const unsigned char *tmp;
tmp = strdup(string);
if (tmp == NULL) {
ERROR("%s cannot duplicate property '%s'\n", __func__, name);
return NULL;
}
return OF_property_set(env, node, name, tmp, strlen(string) + 1);
}
__attribute__ (( section (".OpenFirmware") ))
static OF_prop_t *OF_prop_int_set (OF_env_t *env, OF_node_t *node,
const unsigned char *name, uint32_t value)
{
return OF_property_set(env, node, name, &value, sizeof(uint32_t));
}
__attribute__ (( section (".OpenFirmware") ))
unused
static OF_prop_t *OF_set_compatibility (OF_env_t *env, OF_node_t *node,
const unsigned char *compat)
{
return OF_prop_string_new(env, node, "compatible", compat);
}
__attribute__ (( section (".OpenFirmware") ))
static inline void OF_property_set_cb (unused OF_env_t *OF_env,
OF_prop_t *prop,
void (*cb)(OF_env_t *OF_env,
OF_prop_t *prop,
const void *data, int len))
{
prop->cb = cb;
}
/*****************************************************************************/
/* Packages methods management */
__attribute__ (( section (".OpenFirmware") ))
static OF_method_t *OF_method_new (unused OF_env_t *env, OF_node_t *node,
const unsigned char *name, OF_cb_t cb)
{
OF_method_t *new;
new = malloc(sizeof(OF_method_t));
if (new == NULL) {
ERROR("%s cannot allocate method '%s'\n", __func__, name);
return NULL;
}
memset(new, 0, sizeof(OF_method_t));
new->node = node;
new->name = strdup(name);
if (new->name == NULL) {
free(new);
ERROR("%s cannot allocate method '%s' name\n", __func__, name);
return NULL;
}
OF_DPRINTF("new method name %p %s\n", new, new->name);
new->func = cb;
/* Link it */
/* *SHOULD LOCK* */
if (node->method_last == NULL)
node->methods = new;
else
node->method_last->next = new;
node->method_last = new;
return new;
}
__attribute__ (( section (".OpenFirmware") ))
static OF_method_t *OF_method_get (unused OF_env_t *env, OF_node_t *node,
const unsigned char *name)
{
OF_method_t *parse;
if (node == NULL) {
OF_DPRINTF("No method in NULL package !\n");
return NULL;
}
#if 0
OF_DPRINTF("Look for method %s in package %0x\n",
name, node->pack_id);
#endif
for (parse = node->methods; parse != NULL; parse = parse->next) {
#if 0
OF_DPRINTF("check %p %p\n", parse, parse->name);
OF_DPRINTF("name=%s\n", parse->name);
#endif
if (strcmp(parse->name, name) == 0)
return parse;
}
return NULL;
}
/*****************************************************************************/
/* Packages instances management */
__attribute__ (( section (".OpenFirmware") ))
static uint16_t OF_inst_new_id (unused OF_env_t *env, OF_node_t *node)
{
OF_inst_t *tmp_inst;
uint16_t cur_id;
#if 0
OF_DPRINTF("[%s] %d\n", node->prop_name->value,
inst_last_id);
#endif
for (cur_id = inst_last_id + 1;
cur_id != inst_last_id; cur_id++) {
if (cur_id == (uint16_t)(OF_MAX_PACKAGE))
cur_id = 0;
for (tmp_inst = node->instances; tmp_inst != NULL;
tmp_inst = tmp_inst->next) {
if (tmp_inst->inst_id == cur_id)
continue;
}
inst_last_id = cur_id;
#if 1
OF_DPRINTF("0x%0x\n", cur_id);
#endif
return cur_id;
}
OF_DPRINTF("no ID found\n");
return (uint16_t)(-1);
}
/* Create a new package's instance */
__attribute__ (( section (".OpenFirmware") ))
static OF_inst_t *OF_instance_new (OF_env_t *env, OF_node_t *node)
{
OF_inst_t *new, *parent;
uint16_t new_id;
/* TODO: recurse to root... */
new = malloc(sizeof(OF_inst_t));
if (new == NULL) {
ERROR("%s cannot allocate instance of '%s'\n", __func__,
node->prop_name->value);
return NULL;
}
memset(new, 0, sizeof(OF_inst_t));
if (OF_node_parent(env, node) != NULL) {
parent = OF_instance_new(env, OF_node_parent(env, node));
if (parent == NULL) {
free(new);
ERROR("%s cannot allocate instance of '%s' parent\n", __func__,
node->prop_name->value);
return NULL;
}
new->parent = parent;
} else {
new->parent = NULL;
}
new_id = OF_inst_new_id(env, node);
if (new_id == (uint16_t)(-1)) {
free(new);
return NULL;
}
new->inst_id = new_id;
new->node = node;
/* Link it */
/* SHOULD LOCK */
if (node->inst_last == NULL)
node->instances = new;
else
node->inst_last->next = new;
node->inst_last = new;
return new;
}
__attribute__ (( section (".OpenFirmware") ))
static uint32_t OF_instance_get_id (unused OF_env_t *env, OF_inst_t *instance)
{
OF_DPRINTF("p: %0x i: %0x\n", instance->node->pack_id, instance->inst_id);
return (instance->node->pack_id << 16) | instance->inst_id;
}
__attribute__ (( section (".OpenFirmware") ))
static OF_inst_t *OF_inst_find (OF_env_t *env, uint32_t ihandle)
{
OF_node_t *node;
OF_inst_t *parse;
uint16_t phandle = ihandle >> 16;
ihandle &= 0xFFFF;
OF_DPRINTF("p: %0x i: %0x\n", phandle, ihandle);
if (ihandle > OF_MAX_PACKAGE)
return NULL;
node = OF_pack_find(env, phandle);
if (node == NULL)
return NULL;
for (parse = node->instances; parse != NULL; parse = parse->next) {
if (parse->inst_id == ihandle)
return parse;
}
return NULL;
}
#if 0
__attribute__ (( section (".OpenFirmware") ))
static OF_inst_t *OF_inst_get_child (OF_env_t *env, OF_node_t *parent,
const uint32_t handle)
{
OF_node_t *parse, *tmp;
for (parse = parent->children; parse != NULL; parse = parse->next) {
if (parse->pack_id == (handle >> 16)) {
return NULL;
}
tmp = OF_inst_get_child(env, parse, handle);
if (tmp != NULL)
return tmp;
}
return NULL;
}
__attribute__ (( section (".OpenFirmware") ))
static OF_inst_t *OF_inst_get (OF_env_t *env, const unsigned char *name)
{
return _OF_node_get(env, &OF_node_root);
}
#endif
#if 0
__attribute__ (( section (".OpenFirmware") ))
int get_node_name (OF_env_t *env, unsigned char *name,
int len, OF_node_t *node)
{
int tmp, total;
int i;
/* Set up manufacturer name */
total = 0;
tmp = 0;
#if 0
if (OF_node_parent(env, node) == NULL ||
node->manufct != OF_node_parent(env, node)->manufct) {
tmp = strlen(node->manufct);
if ((tmp + 2) > len)
return -1;
memcpy(name, node->manufct, tmp);
name += tmp;
} else if (len < 2) {
return -1;
}
*name++ = ',';
len -= tmp + 1;
total += tmp + 1;
#endif
/* Set up device model */
tmp = strlen(node->name);
if ((tmp + 2) > len)
return -1;
memcpy(name, node->model, tmp);
name += tmp;
*name++ = '@';
len -= tmp + 1;
total += tmp + 1;
/* Set up unit address */
tmp = strlen(node->address);
if ((tmp + 2) > len)
return -1;
memcpy(name, node->address, tmp);
name += tmp;
*name++ = ':';
len -= tmp + 1;
total += tmp + 1;
for (i = 0; node->arguments[i] != NULL; i++) {
if (i != 0)
*name++ = ',';
tmp = strlen(node->arguments[i]);
if ((tmp + 2) > len)
return -1;
memcpy(name, node->arguments[i], tmp);
name += tmp;
len -= tmp + 1;
total += tmp + 1;
}
*name = '\0';
return total;
}
#endif
__attribute__ (( section (".OpenFirmware") ))
static int OF_pack_get_path (OF_env_t *env, unsigned char *name,
int len, OF_node_t *node)
{
OF_prop_t *prop_name, *prop_address;
uint32_t address;
int tmp, nlen;
/* Recurse until we reach the root node */
OF_DPRINTF("look for [%s]\n", node->prop_name->value);
if (OF_node_parent(env, node) == NULL) {
name[0] = '/';
tmp = 0;
nlen = 1;
} else {
tmp = OF_pack_get_path(env, name, len, OF_node_parent(env, node));
/* Add node name */
prop_name = node->prop_name;
prop_address = node->prop_address;
#if 1
OF_DPRINTF("Found [%s]\n", prop_name->value);
#endif
if ((len - tmp) < 2) {
OF_DPRINTF("Buffer too short (%d 2)\n", len - tmp);
return 0;
}
if (prop_name == NULL) {
printf("No name in node !\n");
bug();
}
nlen = strlen(prop_name->value);
#if 1
OF_DPRINTF("got '%s' for '%s' parent (%d %d)\n",
name, prop_name->value, tmp, nlen);
#endif
if (name[tmp - 1] != '/') {
name[tmp] = '/';
tmp++;
}
address = *((uint32_t *)prop_address->value);
if (address != OF_ADDRESS_NONE) {
if ((len - tmp - nlen) < 10) {
OF_DPRINTF("Buffer too short (%d %d)\n", len - tmp, nlen + 10);
return 0;
}
} else {
if ((len - tmp - nlen) < 1) {
OF_DPRINTF("Buffer too short (%d %d)\n", len - tmp, nlen + 1);
return 0;
}
}
memcpy(name + tmp, prop_name->value, nlen);
if (address != OF_ADDRESS_NONE) {
OF_DPRINTF("Add address 0x%08x\n", address);
sprintf(name + tmp + nlen, "@%x", address);
nlen += strlen(name + tmp + nlen);
} else {
OF_DPRINTF("No address....\n");
}
}
name[tmp + nlen] = '\0';
OF_DPRINTF("stored [%d]\n", tmp + nlen);
OF_DUMP_STRING(env, name);
#if 1
OF_DPRINTF("name '%s' => '%s' %d\n",
node->properties->value, name, tmp + nlen);
#endif
return tmp + nlen;
}
__attribute__ (( section (".OpenFirmware") ))
static int OF_inst_get_path (OF_env_t *env, unsigned char *name,
int len, OF_inst_t *inst)
{
return OF_pack_get_path(env, name, len, inst->node);
}
/*****************************************************************************/
/* Open firmware C interface */
static void OF_serial_write (OF_env_t *OF_env);
static void OF_serial_read (OF_env_t *OF_env);
static void OF_mmu_translate (OF_env_t *OF_env);
static void OF_mmu_map (OF_env_t *OF_env);
static void RTAS_instantiate (OF_env_t *RTAS_env);
static OF_env_t *OF_env_main;
/* Init standard OF structures */
__attribute__ (( section (".OpenFirmware") ))
int OF_init (void)
{
#if 0
"PowerMac3,1\0MacRISC\0Power Macintosh\0";
"PowerMac1,2\0MacRISC\0Power Macintosh\0";
"AAPL,PowerMac G3\0PowerMac G3\0MacRISC\0Power Macintosh\0";
"AAPL,PowerMac3,0\0MacRISC\0Power Macintosh\0";
"AAPL,Gossamer\0MacRISC\0Power Macintosh\0";
#endif
OF_env_t *OF_env;
OF_node_t *als, *opt, *chs, *pks;
OF_inst_t *inst;
OF_range_t range;
OF_DPRINTF("start\n");
OF_env_main = malloc(sizeof(OF_env_t));
if (OF_env_main == NULL) {
ERROR("%s cannot allocate main OF env\n", __func__);
return -1;
}
// memset(OF_env_main, 0, sizeof(OF_env_t));
OF_env = OF_env_main;
// OF_env_init(OF_env);
OF_DPRINTF("start\n");
/* Set up standard IEEE 1275 nodes */
/* "/device-tree" */
OF_node_root = OF_node_new(OF_env, NULL, "device-tree", OF_ADDRESS_NONE);
if (OF_node_root == NULL) {
ERROR("Cannot create 'device-tree'\n");
return -1;
}
OF_prop_string_new(OF_env, OF_node_root, "device_type", "bootrom");
if (arch == ARCH_HEATHROW) {
const unsigned char compat_str[] =
"PowerMac1,1\0MacRISC\0Power Macintosh";
OF_property_new(OF_env, OF_node_root, "compatible",
compat_str, sizeof(compat_str));
OF_prop_string_new(OF_env, OF_node_root,
"model", "Power Macintosh");
} else {
const unsigned char compat_str[] =
"PowerMac3,1\0MacRISC\0Power Macintosh";
OF_property_new(OF_env, OF_node_root, "compatible",
compat_str, sizeof(compat_str));
OF_prop_string_new(OF_env, OF_node_root,
"model", "PowerMac3,1");
}
#if 0
OF_prop_string_new(OF_env, OF_node_root, "copyright", copyright);
#else
OF_prop_string_new(OF_env, OF_node_root, "copyright",
"Copyright 1983-1999 Apple Computer, Inc. All Rights Reserved");
#endif
OF_prop_string_new(OF_env, OF_node_root, "system-id", "42");
OF_prop_int_new(OF_env, OF_node_root, "#address-cells", 1);
OF_prop_int_new(OF_env, OF_node_root, "#size-cells", 1);
OF_prop_int_new(OF_env, OF_node_root, "clock-frequency", 0x05F03E4D);
/* "/aliases" node */
als = OF_node_new(OF_env, OF_node_root, "aliases", OF_ADDRESS_NONE);
if (als == NULL) {
ERROR("Cannot create 'aliases'\n");
return -1;
}
/* "/chosen" node */
chs = OF_node_new(OF_env, OF_node_root, "chosen", OF_ADDRESS_NONE);
if (chs == NULL) {
ERROR("Cannot create 'choosen'\n");
return -1;
}
/* "/packages" node */
pks = OF_node_new(OF_env, OF_node_root, "packages", OF_ADDRESS_NONE);
if (pks == NULL) {
ERROR("Cannot create 'packages'\n");
return -1;
}
/* "/cpus" node */
{
OF_node_t *cpus;
cpus = OF_node_new(OF_env, OF_node_root, "cpus", OF_ADDRESS_NONE);
if (cpus == NULL) {
ERROR("Cannot create 'cpus'\n");
return -1;
}
OF_prop_int_new(OF_env, cpus, "#address-cells", 1);
OF_prop_int_new(OF_env, cpus, "#size-cells", 0);
OF_node_put(OF_env, cpus);
}
/* "/memory@0" node */
{
OF_node_t *mem;
mem = OF_node_new(OF_env, OF_node_root, "memory", 0);
if (mem == NULL) {
ERROR("Cannot create 'memory'\n");
return -1;
}
OF_prop_string_new(OF_env, mem, "device_type", "memory");
OF_prop_int_new(OF_env, chs, "memory", OF_pack_handle(OF_env, mem));
OF_node_put(OF_env, mem);
}
/* "/openprom" node */
{
OF_node_t *opp;
opp = OF_node_new(OF_env, OF_node_root, "openprom", OF_ADDRESS_NONE);
if (opp == NULL) {
ERROR("Cannot create 'openprom'\n");
return -1;
}
OF_prop_string_new(OF_env, opp, "device_type", "BootROM");
OF_prop_string_new(OF_env, opp, "model", "OpenFirmware 3");
OF_prop_int_new(OF_env, opp, "boot-syntax", 0x0001);
OF_property_new(OF_env, opp, "relative-addressing", NULL, 0);
OF_property_new(OF_env, opp, "supports-bootinfo", NULL, 0);
OF_prop_string_new(OF_env, opp, "built-on", stringify(BUILD_DATE));
OF_prop_string_new(OF_env, als, "rom", "/openprom");
OF_node_put(OF_env, opp);
}
/* "/options" node */
opt = OF_node_new(OF_env, OF_node_root, "options", OF_ADDRESS_NONE);
if (opt == NULL) {
ERROR("Cannot create 'options'\n");
return -1;
}
OF_prop_string_new(OF_env, opt, "little-endian?", "false");
OF_prop_string_new(OF_env, opt, "real-mode?", "false");
// Will play with this...
OF_prop_string_new(OF_env, opt, "security-mode", "none");
/* "/rom@ff800000" node */
{
OF_regprop_t regs;
OF_node_t *rom, *brom;
rom = OF_node_new(OF_env, OF_node_root, "rom", 0xff800000);
if (rom == NULL) {
ERROR("Cannot create 'rom'\n");
return -1;
}
regs.address = 0xFF800000;
regs.size = 0x00000000;
OF_property_new(OF_env, rom, "reg", ®s, sizeof(OF_regprop_t));
range.virt = 0xFF800000;
range.phys = 0xFF800000;
range.size = 0x00800000;
OF_property_new(OF_env, rom, "ranges", &range, sizeof(OF_range_t));
OF_prop_int_new(OF_env, rom, "#address-cells", 1);
/* "/rom/boot-rom@fff00000" node */
brom = OF_node_new(OF_env, rom, "boot-rom", 0xfff00000);
if (brom == NULL) {
ERROR("Cannot create 'boot-rom'\n");
return -1;
}
regs.address = 0xFFF00000;
regs.size = 0x00100000;
OF_property_new(OF_env, brom, "reg", ®s, sizeof(OF_regprop_t));
OF_prop_string_new(OF_env, brom, "write-characteristic", "flash");
OF_prop_string_new(OF_env, brom, "BootROM-build-date",
stringify(BUILD_DATE) " at " stringify(BUILD_TIME));
OF_prop_string_new(OF_env, brom, "BootROM-version", BIOS_VERSION);
OF_prop_string_new(OF_env, brom, "copyright", copyright);
OF_prop_string_new(OF_env, brom, "model", BIOS_str);
OF_prop_int_new(OF_env, brom, "result", 0);
#if 1
{
/* Hack taken 'as-is' from PearPC */
unsigned char info[] = {
0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00,
0x00, 0x01, 0x12, 0xf2, 0x19, 0x99, 0x08, 0x19,
0x94, 0x4e, 0x73, 0x27, 0xff, 0xf0, 0x80, 0x00,
0x00, 0x07, 0x80, 0x01, 0x00, 0x01, 0x12, 0xf2,
0x19, 0x99, 0x08, 0x19, 0xd7, 0xf3, 0xfc, 0x17,
0xff, 0xf8, 0x00, 0x00, 0x00, 0x08, 0x00, 0x02,
0x00, 0x01, 0x12, 0xf2, 0x19, 0x99, 0x08, 0x19,
0xbb, 0x10, 0xfc, 0x17,
};
OF_property_new(OF_env, brom, "info", info, sizeof(info));
}
#endif
OF_node_put(OF_env, brom);
OF_node_put(OF_env, rom);
}
#if 0
/* From here, hardcoded hacks to get a Mac-like machine */
/* XXX: Core99 does not seem to like this NVRAM tree */
/* "/nvram@fff04000" node */
{
OF_regprop_t regs;
OF_node_t *nvr;
nvr = OF_node_new(OF_env, OF_node_root, "nvram", 0xfff04000);
if (nvr == NULL) {
ERROR("Cannot create 'nvram'\n");
return -1;
}
OF_prop_string_new(OF_env, nvr, "device_type", "nvram");
/* XXX: use real NVRAM size instead */
OF_prop_int_new(OF_env, nvr, "#bytes", 0x2000);
OF_prop_string_new(OF_env, nvr, "compatible", "nvram,flash");
regs.address = 0xFFF04000;
regs.size = 0x00004000; /* Strange, isn't it ? */
OF_property_new(OF_env, nvr, "reg", ®s, sizeof(regs));
OF_prop_int_new(OF_env, chs, "nvram", OF_pack_handle(OF_env, nvr));
OF_node_put(OF_env, nvr);
}
#endif
/* "/pseudo-hid" : hid emulation as Apple does */
{
OF_node_t *hid;
hid = OF_node_new(OF_env, OF_node_root,
"pseudo-hid", OF_ADDRESS_NONE);
if (hid == NULL) {
ERROR("Cannot create 'pseudo-hid'\n");
return -1;
}
/* "keyboard" node */
{
OF_node_t *kbd;
kbd = OF_node_new(OF_env, hid, "keyboard", OF_ADDRESS_NONE);
if (kbd == NULL) {
ERROR("Cannot create 'keyboard'\n");
return -1;
}
OF_prop_string_new(OF_env, kbd, "device_type", "keyboard");
OF_node_put(OF_env, kbd);
}
/* "mouse" node */
{
OF_node_t *mouse;
mouse = OF_node_new(OF_env, hid, "mouse", OF_ADDRESS_NONE);
if (mouse == NULL) {
ERROR("Cannot create 'mouse'\n");
return -1;
}
OF_prop_string_new(OF_env, mouse, "device_type", "mouse");
OF_node_put(OF_env, mouse);
}
/* "eject-key" node */
{
OF_node_t *ejk;
ejk = OF_node_new(OF_env, hid, "eject-key", OF_ADDRESS_NONE);
if (ejk == NULL) {
ERROR("Cannot create 'eject-key'\n");
return -1;
}
OF_prop_string_new(OF_env, ejk, "device_type", "eject-key");
OF_node_put(OF_env, ejk);
}
OF_node_put(OF_env, hid);
}
if (arch == ARCH_MAC99) {
OF_node_t *unin;
OF_regprop_t regs;
unin = OF_node_new(OF_env, OF_node_root,
"uni-n", 0xf8000000);
if (unin == NULL) {
ERROR("Cannot create 'uni-n'\n");
return -1;
}
OF_prop_string_new(OF_env, unin, "device-type", "memory-controller");
OF_prop_string_new(OF_env, unin, "model", "AAPL,UniNorth");
OF_prop_string_new(OF_env, unin, "compatible", "uni-north");
regs.address = 0xf8000000;
regs.size = 0x01000000;
OF_property_new(OF_env, unin, "reg", ®s, sizeof(regs));
OF_prop_int_new(OF_env, unin, "#address-cells", 1);
OF_prop_int_new(OF_env, unin, "#size-cells", 1);
OF_prop_int_new(OF_env, unin, "device-rev", 3);
OF_node_put(OF_env, unin);
}
#if 1 /* This is mandatory for claim to work
* but I don't know where it should really be (in cpu ?)
*/
{
OF_node_t *mmu;
/* "/mmu" node */
mmu = OF_node_new(OF_env, OF_node_root, "mmu", OF_ADDRESS_NONE);
if (mmu == NULL) {
ERROR("Cannot create 'mmu'\n");
return -1;
}
inst = OF_instance_new(OF_env, mmu);
if (inst == NULL) {
OF_node_put(OF_env, mmu);
ERROR("Cannot create 'mmu' instance\n");
return -1;
}
OF_prop_int_new(OF_env, chs, "mmu",
OF_instance_get_id(OF_env, inst));
OF_method_new(OF_env, mmu, "translate", &OF_mmu_translate);
OF_method_new(OF_env, mmu, "map", &OF_mmu_map);
OF_node_put(OF_env, mmu);
}
#endif
/* "/options/boot-args" node */
{
// const unsigned char *args = "-v rootdev cdrom";
//const unsigned char *args = "-v io=0xffffffff";
const unsigned char *args = "-v";
/* Ask MacOS X to print debug messages */
// OF_prop_string_new(OF_env, chs, "machargs", args);
// OF_prop_string_new(OF_env, opt, "boot-command", args);
OF_prop_string_new(OF_env, opt, "boot-args", args);
}
/* Release nodes */
OF_node_put(OF_env, opt);
OF_node_put(OF_env, pks);
OF_node_put(OF_env, chs);
OF_node_put(OF_env, als);
OF_node_put(OF_env, OF_node_root);
OF_DPRINTF("done\n");
return 0;
}
/* Motherboard */
#if 0 // For now, static values are used
__attribute__ (( section (".OpenFirmware") ))
int OF_register_mb (const unsigned char *model, const unsigned char **compats)
{
OF_env_t *OF_env;
OF_node_t *root;
int i;
OF_env = OF_env_main;
OF_DPRINTF("start\n");
root = OF_node_get(OF_env, "device_tree");
if (root == NULL) {
ERROR("Cannot get 'device-tree'\n");
return -1;
}
OF_DPRINTF("add model\n");
OF_prop_string_new(OF_env, OF_node_root, "model", model);
for (i = 0; i < 1 && compats[i] != NULL; i++) {
OF_DPRINTF("add compats %s\n", compats[i]);
OF_set_compatibility(OF_env, OF_node_root, compats[i]);
}
/* we don't implement neither "l2-cache" nor "cache" nodes */
OF_node_put(OF_env, root);
OF_DPRINTF("done\n");
return 0;
}
#endif
/* CPU */
__attribute__ (( section (".OpenFirmware") ))
int OF_register_cpu (const unsigned char *name, int num, uint32_t pvr,
uint32_t min_freq, uint32_t max_freq, uint32_t bus_freq,
uint32_t tb_freq, uint32_t reset_io)
{
unsigned char tmp[OF_NAMELEN_MAX];
OF_env_t *OF_env;
OF_node_t *cpus, *cpu, *l2c, *chs, *als;
OF_env = OF_env_main;
OF_DPRINTF("start\n");
cpus = OF_node_get(OF_env, "cpus");
if (cpus == NULL) {
ERROR("Cannot get 'cpus'\n");
return -1;
}
cpu = OF_node_new(OF_env, cpus, name, OF_ADDRESS_NONE);
if (cpu == NULL) {
OF_node_put(OF_env, cpus);
ERROR("Cannot create cpu '%s'\n", name);
return -1;
}
OF_prop_string_new(OF_env, cpu, "device_type", "cpu");
OF_prop_int_new(OF_env, cpu, "#address-cells", 0x00000001);
OF_prop_int_new(OF_env, cpu, "#size-cells", 0x00000000);
OF_prop_int_new(OF_env, cpu, "reg", num);
OF_prop_int_new(OF_env, cpu, "cpu-version", pvr);
OF_prop_int_new(OF_env, cpu, "clock-frequency", max_freq);
OF_prop_int_new(OF_env, cpu, "timebase-frequency", tb_freq);
OF_prop_int_new(OF_env, cpu, "bus-frequency", bus_freq);
OF_prop_int_new(OF_env, cpu, "min-clock-frequency", min_freq);
OF_prop_int_new(OF_env, cpu, "max-clock-frequency", max_freq);
OF_prop_int_new(OF_env, cpu, "tlb-size", 0x80);
OF_prop_int_new(OF_env, cpu, "tlb-sets", 0x40);
OF_prop_int_new(OF_env, cpu, "i-tlb-size", 0x40);
OF_prop_int_new(OF_env, cpu, "i-tlb-sets", 0x20);
OF_prop_int_new(OF_env, cpu, "i-cache-size", 0x8000);
OF_prop_int_new(OF_env, cpu, "i-cache-sets", 0x80);
OF_prop_int_new(OF_env, cpu, "i-cache-bloc-size", 0x20);
OF_prop_int_new(OF_env, cpu, "i-cache-line-size", 0x20);
OF_prop_int_new(OF_env, cpu, "d-tlb-size", 0x40);
OF_prop_int_new(OF_env, cpu, "d-tlb-sets", 0x20);
OF_prop_int_new(OF_env, cpu, "d-cache-size", 0x8000);
OF_prop_int_new(OF_env, cpu, "d-cache-sets", 0x80);
OF_prop_int_new(OF_env, cpu, "d-cache-bloc-size", 0x20);
OF_prop_int_new(OF_env, cpu, "d-cache-line-size", 0x20);
OF_prop_int_new(OF_env, cpu, "reservation-granule-size", 0x20);
OF_prop_int_new(OF_env, cpus, "soft-reset", reset_io);
OF_prop_string_new(OF_env, cpus, "graphics", "");
OF_prop_string_new(OF_env, cpus, "performance-monitor", "");
OF_prop_string_new(OF_env, cpus, "data-streams", "");
OF_prop_string_new(OF_env, cpu, "state", "running");
/* We don't implement:
* "dynamic-powerstep" & "reduced-clock-frequency"
* "l2cr-value"
*/
/* Add L2 cache */
l2c = OF_node_new(OF_env, cpu, "l2cache", OF_ADDRESS_NONE);
if (l2c == NULL) {
ERROR("Cannot create 'l2cache'\n");
return -1;
}
OF_prop_string_new(OF_env, l2c, "device_type", "cache");
OF_prop_int_new(OF_env, l2c, "i-cache-size", 0x100000);
OF_prop_int_new(OF_env, l2c, "i-cache-sets", 0x2000);
OF_prop_int_new(OF_env, l2c, "i-cache-line-size", 0x40);
OF_prop_int_new(OF_env, l2c, "d-cache-size", 0x100000);
OF_prop_int_new(OF_env, l2c, "d-cache-sets", 0x2000);
OF_prop_int_new(OF_env, l2c, "d-cache-line-size", 0x40);
/* Register it in the cpu node */
OF_prop_int_new(OF_env, cpu, "l2-cache", OF_pack_handle(OF_env, l2c));
OF_node_put(OF_env, l2c);
/* Set it in "/chosen" and "/aliases" */
if (num == 0) {
OF_pack_get_path(OF_env, tmp, 512, cpu);
chs = OF_node_get(OF_env, "chosen");
if (chs == NULL) {
OF_node_put(OF_env, cpus);
ERROR("Cannot get 'chosen'\n");
return -1;
}
OF_prop_int_new(OF_env, chs, "cpu", OF_pack_handle(OF_env, cpu));
OF_node_put(OF_env, chs);
als = OF_node_get(OF_env, "aliases");
if (als == NULL) {
OF_node_put(OF_env, cpus);
ERROR("Cannot get 'aliases'\n");
return -1;
}
OF_prop_string_new(OF_env, als, "cpu", tmp);
OF_node_put(OF_env, als);
}
OF_node_put(OF_env, cpu);
OF_node_put(OF_env, cpus);
OF_DPRINTF("done\n");
return 0;
}
__attribute__ (( section (".OpenFirmware") ))
int OF_register_translations (int nb, OF_transl_t *translations)
{
OF_env_t *OF_env;
OF_node_t *cpus, *cpu;
OF_transl_t *new;
int i;
OF_env = OF_env_main;
OF_DPRINTF("start\n");
cpus = OF_node_get(OF_env, "cpus");
if (cpus == NULL) {
OF_node_put(OF_env, cpus);
ERROR("Cannot get 'cpus'\n");
return -1;
}
cpu = cpus->children;
new = malloc(nb * sizeof(OF_transl_t));
if (new == NULL) {
ERROR("Cannot create new translation\n");
return -1;
}
for (i = 0; i < nb; i++) {
new->virt = translations[i].virt;
new->size = translations[i].size;
new->phys = translations[i].phys;
new->mode = translations[i].mode;
OF_DPRINTF("%d\n", i);
}
OF_property_new(OF_env, cpu, "translations",
new, nb * sizeof(OF_transl_t));
OF_node_put(OF_env, cpus);
OF_DPRINTF("done\n");
return 0;
}
/* Memory ranges */
typedef struct OF_mem_t OF_mem_t;
struct OF_mem_t {
uint32_t start;
uint32_t size;
};
#define OF_MAX_MEMRANGES 16
/* First entry is the whole known memory space */
static OF_mem_t OF_mem_ranges[OF_MAX_MEMRANGES + 1];
__attribute__ (( section (".OpenFirmware") ))
int OF_register_memory (uint32_t memsize, unused uint32_t bios_size)
{
OF_env_t *OF_env;
OF_node_t *mem;
OF_regprop_t regs[4];
int i;
OF_env = OF_env_main;
OF_DPRINTF("find node\n");
mem = OF_node_get(OF_env, "memory");
if (mem == NULL) {
ERROR("Cannot get 'memory'\n");
return -1;
}
OF_DPRINTF("Memory package: %04x\n", OF_pack_handle(OF_env, mem));
regs[0].address = 0x00000000;
regs[0].size = memsize;
regs[1].address = 0x00000000;
regs[1].size = 0x00000000;
regs[2].address = 0x00000000;
regs[2].size = 0x00000000;
regs[3].address = 0x00000000;
regs[3].size = 0x00000000;
OF_property_new(OF_env, mem, "reg", regs, 4 * sizeof(OF_regprop_t));
#if 0
#if 1
regs[0].address = 0x00000000;
regs[0].size = 0x05800000;
regs[1].address = 0x06000000;
regs[1].size = memsize - 0x06000000;
regs[2].address = 0x00000000;
regs[2].size = 0x00000000;
OF_property_new(OF_env, mem, "available",
regs, 3 * sizeof(OF_regprop_t));
#else
regs[0].address = 0x06000000;
regs[0].size = memsize - 0x06000000;
regs[1].address = 0x00000000;
regs[1].size = 0x00000000;
OF_property_new(OF_env, mem, "available",
regs, 2 * sizeof(OF_regprop_t));
#endif
#endif
OF_node_put(OF_env, mem);
#if 0
{
OF_node_t *mmu;
mmu = OF_node_get(OF_env, "mmu");
if (mmu == NULL) {
ERROR("Cannot get 'mmu'\n");
return -1;
}
regs[0].address = 0x00000000;
regs[0].size = memsize;
OF_property_new(OF_env, mmu, "reg", regs, sizeof(OF_regprop_t));
regs[0].address = 0x00000000;
regs[0].size = 0x05800000;
regs[1].address = 0x06000000;
regs[1].size = memsize - 0x06000000;
regs[2].address = 0x00000000;
regs[2].size = 0x00000000;
OF_property_new(OF_env, mmu, "available",
regs, 3 * sizeof(OF_regprop_t));
OF_node_put(OF_env, mmu);
}
#endif
/* Also update the claim areas */
OF_mem_ranges[0].start = 0x00000000;
OF_mem_ranges[0].size = memsize;
OF_mem_ranges[1].start = 0x58000000;
OF_mem_ranges[1].size = 0x08000000;
for (i = 2; i < OF_MAX_MEMRANGES + 1; i++) {
OF_mem_ranges[i].start = -1;
OF_mem_ranges[i].size = -1;
}
OF_DPRINTF("done\n");
return 0;
}
/* Linux kernel command line */
__attribute__ (( section (".OpenFirmware") ))
int OF_register_bootargs (const unsigned char *bootargs)
{
OF_env_t *OF_env;
OF_node_t *chs;
OF_env = OF_env_main;
if (bootargs == NULL)
bootargs = "";
chs = OF_node_get(OF_env, "chosen");
if (chs == NULL) {
ERROR("Cannot get 'chosen'\n");
return -1;
}
OF_prop_string_set(OF_env, chs, "bootargs", bootargs);
// OF_prop_string_set(OF_env, OF_node_root, "bootargs", "");
OF_node_put(OF_env, chs);
return 0;
}
__attribute__ (( section (".OpenFirmware") ))
static void *OF_pci_device_new (OF_env_t *OF_env, OF_node_t *parent,
pci_dev_t *dev, uint32_t address,
uint16_t rev, uint32_t ccode,
uint16_t min_grant, uint16_t max_latency)
{
OF_node_t *node;
dprintf("register '%s' '%s' '%s' '%s' 0x%08x in '%s' 0x%08x\n",
dev->name, dev->type, dev->compat, dev->model, address,
parent->prop_name->value, *(uint32_t *)parent->prop_address->value);
node = OF_node_new(OF_env, parent, dev->name, address);
if (node == NULL)
return NULL;
OF_prop_int_new(OF_env, node, "vendor-id", dev->vendor);
OF_prop_int_new(OF_env, node, "device-id", dev->product);
OF_prop_int_new(OF_env, node, "revision-id", rev);
OF_prop_int_new(OF_env, node, "class-code", ccode);
OF_prop_int_new(OF_env, node, "min-grant", min_grant);
OF_prop_int_new(OF_env, node, "max-latency", max_latency);
if (dev->type != NULL)
OF_prop_string_new1(OF_env, node, "device_type", dev->type);
if (dev->compat != NULL)
OF_prop_string_new1(OF_env, node, "compatible", dev->compat);
if (dev->model != NULL)
OF_prop_string_new1(OF_env, node, "model", dev->model);
if (dev->acells != 0)
OF_prop_int_new(OF_env, node, "#address-cells", dev->acells);
if (dev->scells != 0)
OF_prop_int_new(OF_env, node, "#size-cells", dev->scells);
if (dev->icells != 0)
OF_prop_int_new(OF_env, node, "#interrupt-cells", dev->icells);
dprintf("Done %p %p\n", parent, node);
return node;
}
__attribute__ (( section (".OpenFirmware") ))
void *OF_register_pci_host (pci_dev_t *dev, uint16_t rev, uint32_t ccode,
uint32_t cfg_base, uint32_t cfg_len,
uint32_t mem_base, uint32_t mem_len,
uint32_t io_base, uint32_t io_len,
uint32_t rbase, uint32_t rlen,
uint16_t min_grant, uint16_t max_latency)
{
OF_env_t *OF_env;
pci_range_t ranges[3];
OF_regprop_t regs[1];
OF_node_t *pci_host, *als;
int nranges;
unsigned char buffer[OF_NAMELEN_MAX];
OF_env = OF_env_main;
dprintf("register PCI host '%s' '%s' '%s' '%s'\n",
dev->name, dev->type, dev->compat, dev->model);
pci_host = OF_pci_device_new(OF_env, OF_node_root, dev, cfg_base,
rev, ccode, min_grant, max_latency);
if (pci_host == NULL) {
ERROR("Cannot create pci host\n");
return NULL;
}
als = OF_node_get(OF_env, "aliases");
if (als == NULL) {
ERROR("Cannot get 'aliases'\n");
return NULL;
}
sprintf(buffer, "/%s", dev->name);
OF_prop_string_set(OF_env, als, "pci", buffer);
OF_node_put(OF_env, als);
regs[0].address = cfg_base;
regs[0].size = cfg_len;
OF_property_new(OF_env, pci_host, "reg", regs, sizeof(OF_regprop_t));
nranges = 0;
if (rbase != 0x00000000) {
ranges[nranges].addr.hi = 0x02000000;
ranges[nranges].addr.mid = 0x00000000;
ranges[nranges].addr.lo = rbase;
ranges[nranges].phys = rbase;
ranges[nranges].size_hi = 0x00000000;
ranges[nranges].size_lo = rlen;
nranges++;
}
if (io_base != 0x00000000) {
ranges[nranges].addr.hi = 0x01000000;
ranges[nranges].addr.mid = 0x00000000;
ranges[nranges].addr.lo = 0x00000000;
ranges[nranges].phys = io_base;
ranges[nranges].size_hi = 0x00000000;
ranges[nranges].size_lo = io_len;
nranges++;
}
if (mem_base != 0x00000000) {
ranges[nranges].addr.hi = 0x02000000;
ranges[nranges].addr.mid = 0x00000000;
ranges[nranges].addr.lo = mem_base;
ranges[nranges].phys = mem_base;
ranges[nranges].size_hi = 0x00000000;
ranges[nranges].size_lo = mem_len;
nranges++;
}
OF_property_new(OF_env, pci_host, "ranges", ranges,
nranges * sizeof(pci_range_t));
return pci_host;
}
__attribute__ (( section (".OpenFirmware") ))
void *OF_register_pci_bridge (void *parent, pci_dev_t *dev,
uint32_t cfg_base, uint32_t cfg_len,
uint8_t devfn, uint8_t rev, uint32_t ccode,
uint16_t min_grant, uint16_t max_latency)
{
OF_env_t *OF_env;
OF_regprop_t regs[1];
OF_node_t *pci_bridge;
OF_env = OF_env_main;
OF_DPRINTF("register '%s' %08x '%s' '%s' '%s'\n",
dev->name, devfn >> 3, dev->type, dev->compat, dev->model);
dprintf("register PCI bridge '%s' %08x '%s' '%s' '%s'\n",
dev->name, devfn >> 3, dev->type, dev->compat, dev->model);
pci_bridge = OF_pci_device_new(OF_env, parent, dev, devfn >> 3,
rev, ccode, min_grant, max_latency);
if (pci_bridge == NULL) {
ERROR("Cannot create pci bridge\n");
return NULL;
}
regs[0].address = cfg_base;
regs[0].size = cfg_len;
OF_property_new(OF_env, pci_bridge, "reg", regs, sizeof(OF_regprop_t));
return pci_bridge;
}
__attribute__ (( section (".OpenFirmware") ))
void *OF_register_pci_device (void *parent, pci_dev_t *dev,
uint8_t devfn, uint8_t rev, uint32_t ccode,
uint16_t min_grant, uint16_t max_latency)
{
OF_env_t *OF_env;
OF_node_t *pci_dev;
OF_env = OF_env_main;
OF_DPRINTF("register '%s' %08x '%s' '%s' '%s'\n",
dev->name, devfn >> 3, dev->type, dev->compat, dev->model);
dprintf("register pci device '%s' %08x '%s' '%s' '%s'\n",
dev->name, devfn >> 3, dev->type, dev->compat, dev->model);
pci_dev = OF_pci_device_new(OF_env, parent, dev, devfn >> 3,
rev, ccode, min_grant, max_latency);
return pci_dev;
}
/* XXX: suppress that, used for interrupt map init */
OF_node_t *pci_host_node;
uint32_t pci_host_interrupt_map[7 * 32];
int pci_host_interrupt_map_len = 0;
void OF_finalize_pci_host (void *dev, int first_bus, int nb_busses)
{
OF_env_t *OF_env;
OF_regprop_t regs[1];
OF_env = OF_env_main;
regs[0].address = first_bus;
regs[0].size = nb_busses;
OF_property_new(OF_env, dev, "bus-range", regs, sizeof(OF_regprop_t));
pci_host_node = dev;
}
void OF_finalize_pci_device (void *dev, uint8_t bus, uint8_t devfn,
uint32_t *regions, uint32_t *sizes,
int irq_line)
{
OF_env_t *OF_env;
pci_reg_prop_t pregs[6], rregs[6];
uint32_t mask;
int i, j, k;
OF_env = OF_env_main;
/* XXX: only useful for VGA card in fact */
if (regions[0] != 0x00000000)
OF_prop_int_set(OF_env, dev, "address", regions[0] & ~0x0000000F);
for (i = 0, j = 0, k = 0; i < 6; i++) {
if (regions[i] != 0x00000000 && sizes[i] != 0x00000000) {
/* Generate "reg" property
*/
if (regions[i] & 1) {
/* IO space */
rregs[j].addr.hi = 0x01000000;
mask = 0x00000001;
} else if (regions[i] & 4) {
/* 64 bits address space */
rregs[j].addr.hi = 0x83000000;
mask = 0x0000000F;
#if 0
} else if ((regions[i] & 0xF) == 0x00) { /* ? */
/* Configuration space */
rregs[j].addr.hi = 0x00000000;
mask = 0x0000000F;
#endif
} else {
/* 32 bits address space */
rregs[j].addr.hi = 0x82000000;
mask = 0x0000000F;
}
/* Set bus number */
rregs[j].addr.hi |= bus << 16;
/* Set device/function */
rregs[j].addr.hi |= devfn << 8;
/* Set register */
#if 1
rregs[j].addr.hi |= 0x10 + (i * sizeof(uint32_t)); /* ? */
#endif
/* Set address */
rregs[j].addr.mid = 0x00000000;
rregs[j].addr.lo = regions[i] & ~mask;
/* Set size */
rregs[j].size_hi = 0x00000000;
rregs[j].size_lo = sizes[i];
#if 0
if ((rregs[j].addr.hi & 0x03000000) != 0x00000000)
#endif
{
/* No assigned address for configuration space */
pregs[k].addr.hi = rregs[j].addr.hi; /* ? */
pregs[k].addr.mid = rregs[j].addr.mid;
pregs[k].addr.lo = rregs[j].addr.lo; /* ? */
pregs[k].size_hi = rregs[j].size_hi;
pregs[k].size_lo = rregs[j].size_lo;
k++;
}
j++;
}
}
if (j > 0) {
OF_property_new(OF_env, dev, "reg",
rregs, j * sizeof(pci_reg_prop_t));
} else {
OF_property_new(OF_env, dev, "reg", NULL, 0);
}
if (k > 0) {
OF_property_new(OF_env, dev, "assigned-addresses",
pregs, k * sizeof(pci_reg_prop_t));
} else {
OF_property_new(OF_env, dev, "assigned-addresses", NULL, 0);
}
if (irq_line >= 0) {
int i;
OF_prop_int_new(OF_env, dev, "interrupts", 1);
i = pci_host_interrupt_map_len;
pci_host_interrupt_map[i++] = (devfn << 8) & 0xf800;
pci_host_interrupt_map[i++] = 0;
pci_host_interrupt_map[i++] = 0;
pci_host_interrupt_map[i++] = 0;
pci_host_interrupt_map[i++] = 0; /* pic handle will be patched later */
pci_host_interrupt_map[i++] = irq_line;
if (arch != ARCH_HEATHROW) {
pci_host_interrupt_map[i++] = 1;
}
pci_host_interrupt_map_len = i;
}
#if 1
{
OF_prop_t *prop_name = ((OF_node_t *)dev)->prop_name;
if (j > 0) {
dprintf("PCI device '%s' %d %d %d reg properties:\n",
prop_name->value, bus, devfn >> 3, devfn & 7);
for (i = 0; i < j; i++) {
dprintf(" addr: %08x %08x %08x size: %08x %08x\n",
rregs[i].addr.hi, rregs[i].addr.mid, rregs[i].addr.lo,
rregs[i].size_hi, rregs[i].size_lo);
}
} else {
dprintf("PCI device '%s' %d %d %d has no reg properties:\n",
prop_name->value, bus, devfn >> 3, devfn & 7);
}
if (k > 0) {
dprintf("PCI device '%s' %d %d %d "
"assigned addresses properties:\n",
prop_name->value, bus, devfn >> 3, devfn & 7);
for (i = 0; i < j; i++) {
dprintf(" addr: %08x %08x %08x size: %08x %08x\n",
pregs[i].addr.hi, pregs[i].addr.mid, pregs[i].addr.lo,
pregs[i].size_hi, pregs[i].size_lo);
}
} else {
dprintf("PCI device '%s' %d %d %d has no "
"assigned addresses properties:\n",
prop_name->value, bus, devfn >> 3, devfn & 7);
}
}
#endif
}
__attribute__ (( section (".OpenFirmware") ))
int OF_register_bus (const unsigned char *name, uint32_t address,
const unsigned char *type)
{
unsigned char buffer[OF_NAMELEN_MAX];
OF_env_t *OF_env;
OF_node_t *bus, *als;
OF_env = OF_env_main;
als = OF_node_get(OF_env, "aliases");
if (als == NULL) {
ERROR("Cannot get 'aliases'\n");
return -1;
}
bus = OF_node_new(OF_env, OF_node_root, name, address);
if (bus == NULL) {
OF_node_put(OF_env, als);
ERROR("Cannot create bus '%s'\n", name);
return -1;
}
OF_prop_string_set(OF_env, bus, "type", type);
sprintf(buffer, "/%s", name);
OF_prop_string_set(OF_env, als, name, buffer);
/* For ISA, should add DMA ranges */
OF_node_put(OF_env, bus);
OF_node_put(OF_env, als);
return 0;
}
// We will need to register stdin & stdout via the serial port
__attribute__ (( section (".OpenFirmware") ))
int OF_register_serial (const unsigned char *bus, const unsigned char *name,
uint32_t io_base, unused int irq)
{
unsigned char tmp[OF_NAMELEN_MAX];
OF_env_t *OF_env;
OF_node_t *busn, *srl, *als;
OF_env = OF_env_main;
als = OF_node_get(OF_env, "aliases");
if (als == NULL) {
ERROR("Cannot get 'aliases'\n");
return -1;
}
busn = OF_node_get(OF_env, bus);
srl = OF_node_new(OF_env, busn, name, io_base);
if (srl == NULL) {
OF_node_put(OF_env, als);
ERROR("Cannot create serial '%s'\n", name);
return -1;
}
OF_prop_string_set(OF_env, srl, "device_type", "serial");
OF_prop_string_set(OF_env, srl, "compatible", "pnpPNP,501");
switch (io_base) {
case 0x3F8:
OF_pack_get_path(OF_env, tmp, 512, srl);
OF_prop_string_new(OF_env, als, "com1", tmp);
break;
case 0x2F8:
OF_pack_get_path(OF_env, tmp, 512, srl);
OF_prop_string_new(OF_env, als, "com2", tmp);
break;
default:
break;
}
/* register read/write methods and create an instance of the package */
OF_method_new(OF_env, srl, "write", &OF_serial_write);
OF_method_new(OF_env, srl, "read", &OF_serial_read);
OF_node_put(OF_env, srl);
OF_node_put(OF_env, busn);
OF_node_put(OF_env, als);
return 0;
}
/* We will also need /isa/rtc */
__attribute__ (( section (".OpenFirmware") ))
int OF_register_stdio (const unsigned char *dev_in,
const unsigned char *dev_out)
{
OF_env_t *OF_env;
OF_node_t *chs, *ndev_in, *ndev_out, *kbd;
OF_inst_t *in_inst, *out_inst;
OF_env = OF_env_main;
chs = OF_node_get(OF_env, "chosen");
if (chs == NULL) {
ERROR("Cannot get 'chosen'\n");
return -1;
}
ndev_in = OF_node_get(OF_env, dev_in);
ndev_out = OF_node_get(OF_env, dev_out);
in_inst = OF_instance_new(OF_env, ndev_in);
if (in_inst == NULL) {
OF_node_put(OF_env, ndev_out);
OF_node_put(OF_env, ndev_in);
OF_node_put(OF_env, chs);
ERROR("Cannot create in_inst\n");
return -1;
}
out_inst = OF_instance_new(OF_env, ndev_out);
if (out_inst == NULL) {
OF_node_put(OF_env, ndev_out);
OF_node_put(OF_env, ndev_in);
OF_node_put(OF_env, chs);
ERROR("Cannot create out_inst\n");
return -1;
}
OF_prop_int_set(OF_env, chs, "stdin",
OF_instance_get_id(OF_env, in_inst));
OF_prop_int_set(OF_env, chs, "stdout",
OF_instance_get_id(OF_env, out_inst));
kbd = OF_node_new(OF_env, ndev_in, "keyboard", OF_ADDRESS_NONE);
if (kbd == NULL) {
OF_node_put(OF_env, ndev_out);
OF_node_put(OF_env, ndev_in);
OF_node_put(OF_env, chs);
ERROR("Cannot create 'keyboard' for stdio\n");
return -1;
}
OF_prop_string_new(OF_env, kbd, "device_type", "keyboard");
OF_node_put(OF_env, kbd);
OF_DPRINTF("stdin h: 0x%0x out : 0x%0x\n",
OF_instance_get_id(OF_env, in_inst),
OF_instance_get_id(OF_env, out_inst));
OF_node_put(OF_env, ndev_out);
OF_node_put(OF_env, ndev_in);
OF_node_put(OF_env, chs);
return 0;
}
static void keylargo_ata(OF_node_t *mio, uint32_t base_address,
uint32_t base, int irq1, int irq2,
uint16_t pic_phandle)
{
OF_env_t *OF_env = OF_env_main;
OF_node_t *ata;
OF_regprop_t regs[2];
ata = OF_node_new(OF_env, mio, "ata-4", base);
if (ata == NULL) {
ERROR("Cannot create 'ata-4'\n");
return;
}
OF_prop_string_new(OF_env, ata, "device_type", "ata");
#if 1
OF_prop_string_new(OF_env, ata, "compatible", "key2largo-ata");
OF_prop_string_new(OF_env, ata, "model", "ata-4");
OF_prop_string_new(OF_env, ata, "cable-type", "80-conductor");
#else
OF_prop_string_new(OF_env, ata, "compatible", "cmd646-ata");
OF_prop_string_new(OF_env, ata, "model", "ata-4");
#endif
OF_prop_int_new(OF_env, ata, "#address-cells", 1);
OF_prop_int_new(OF_env, ata, "#size-cells", 0);
regs[0].address = base;
regs[0].size = 0x00001000;
#if 0 // HACK: Don't set up DMA registers
regs[1].address = 0x00008A00;
regs[1].size = 0x00001000;
OF_property_new(OF_env, ata, "reg",
regs, 2 * sizeof(OF_regprop_t));
#else
OF_property_new(OF_env, ata, "reg",
regs, sizeof(OF_regprop_t));
#endif
OF_prop_int_new(OF_env, ata, "interrupt-parent", pic_phandle);
regs[0].address = irq1;
regs[0].size = 0x00000001;
regs[1].address = irq2;
regs[1].size = 0x00000000;
OF_property_new(OF_env, ata, "interrupts",
regs, 2 * sizeof(OF_regprop_t));
if (base == 0x1f000)
ide_pci_pmac_register(base_address + base, 0x00000000, ata);
else
ide_pci_pmac_register(0x00000000, base_address + base, ata);
}
void OF_finalize_pci_macio (void *dev, uint32_t base_address, uint32_t size,
void *private_data)
{
unsigned char tmp[OF_NAMELEN_MAX];
OF_env_t *OF_env;
pci_reg_prop_t pregs[2];
OF_node_t *mio, *chs, *als;
uint16_t pic_phandle;
int rec_len;
OF_prop_t *mio_reg;
OF_DPRINTF("mac-io: %p\n", dev);
OF_env = OF_env_main;
chs = OF_node_get(OF_env, "chosen");
if (chs == NULL) {
ERROR("Cannot get 'chosen'\n");
return;
}
als = OF_node_get(OF_env, "aliases");
if (als == NULL) {
OF_node_put(OF_env, als);
ERROR("Cannot get 'aliases'\n");
return;
}
/* Mac-IO is mandatory for OSX to boot */
mio = dev;
mio->private_data = private_data;
pregs[0].addr.hi = 0x00000000;
pregs[0].addr.mid = 0x00000000;
pregs[0].addr.lo = 0x00000000;
pregs[0].size_hi = base_address;
pregs[0].size_lo = size;
mio_reg = OF_property_get(OF_env, mio, "reg");
if (mio_reg && mio_reg->vlen >= 5 * 4) {
pregs[0].addr.mid = ((pci_reg_prop_t *)mio_reg->value)->addr.hi;
}
OF_property_new(OF_env, mio, "ranges",
&pregs, sizeof(pci_reg_prop_t));
#if 0
pregs[0].addr.hi = 0x82013810;
pregs[0].addr.mid = 0x00000000;
pregs[0].addr.lo = 0x80800000;
pregs[0].size_hi = 0x00000000;
pregs[0].size_lo = 0x00080000;
OF_property_new(OF_env, mio, "assigned-addresses",
&pregs, sizeof(pci_reg_prop_t));
#endif
if (arch == ARCH_HEATHROW) {
/* Heathrow PIC */
OF_regprop_t regs;
OF_node_t *mpic;
const char compat_str[] = "heathrow\0mac-risc";
mpic = OF_node_new(OF_env, mio, "interrupt-controller", 0x10);
if (mpic == NULL) {
ERROR("Cannot create 'mpic'\n");
goto out;
}
OF_prop_string_new(OF_env, mpic, "device_type", "interrupt-controller");
OF_property_new(OF_env, mpic, "compatible", compat_str, sizeof(compat_str));
OF_prop_int_new(OF_env, mpic, "#interrupt-cells", 1);
regs.address = 0x10;
regs.size = 0x20;
OF_property_new(OF_env, mpic, "reg",
®s, sizeof(regs));
OF_property_new(OF_env, mpic, "interrupt-controller", NULL, 0);
pic_phandle = OF_pack_handle(OF_env, mpic);
OF_prop_int_new(OF_env, chs, "interrupt-controller", pic_phandle);
OF_node_put(OF_env, mpic);
rec_len = 6;
} else {
/* OpenPIC */
OF_regprop_t regs[4];
OF_node_t *mpic;
mpic = OF_node_new(OF_env, mio, "interrupt-controller", 0x40000);
if (mpic == NULL) {
ERROR("Cannot create 'mpic'\n");
goto out;
}
OF_prop_string_new(OF_env, mpic, "device_type", "open-pic");
OF_prop_string_new(OF_env, mpic, "compatible", "chrp,open-pic");
OF_property_new(OF_env, mpic, "interrupt-controller", NULL, 0);
OF_property_new(OF_env, mpic, "built-in", NULL, 0);
OF_prop_int_new(OF_env, mpic, "clock-frequency", 0x003F7A00);
OF_prop_int_new(OF_env, mpic, "#address-cells", 0);
OF_prop_int_new(OF_env, mpic, "#interrupt-cells", 2);
memset(regs, 0, 4 * sizeof(OF_regprop_t));
regs[0].address = 0x00040000;
regs[0].size = 0x00040000;
OF_property_new(OF_env, mpic, "reg",
®s, 1 * sizeof(OF_regprop_t));
pic_phandle = OF_pack_handle(OF_env, mpic);
OF_prop_int_new(OF_env, chs, "interrupt-controller", pic_phandle);
OF_node_put(OF_env, mpic);
rec_len = 7;
}
/* patch pci host table */
/* XXX: do it after the PCI init */
{
int i;
uint32_t tab[4];
for(i = 0; i < pci_host_interrupt_map_len; i += rec_len)
pci_host_interrupt_map[i + 4] = pic_phandle;
#if 0
dprintf("interrupt-map:\n");
for(i = 0; i < pci_host_interrupt_map_len; i++) {
dprintf(" %08x", pci_host_interrupt_map[i]);
if ((i % rec_len) == (rec_len - 1))
dprintf("\n");
}
dprintf("\n");
#endif
OF_property_new(OF_env, pci_host_node, "interrupt-map",
pci_host_interrupt_map,
pci_host_interrupt_map_len * sizeof(uint32_t));
tab[0] = 0xf800;
tab[1] = 0;
tab[2] = 0;
tab[3] = 0;
OF_property_new(OF_env, pci_host_node, "interrupt-map-mask",
tab, 4 * sizeof(uint32_t));
}
#if 0
/* escc is useful to get MacOS X debug messages */
{
OF_regprop_t regs[8];
uint32_t irqs[6];
OF_node_t *scc, *chann;
scc = OF_node_new(OF_env, mio, "escc", 0x13000);
if (scc == NULL) {
ERROR("Cannot create 'escc'\n");
goto out;
}
OF_prop_string_new(OF_env, scc, "device_type", "escc");
OF_prop_string_new(OF_env, scc, "compatible", "chrp,es0");
OF_property_new(OF_env, scc, "built-in", NULL, 0);
OF_prop_int_new(OF_env, scc, "#address-cells", 1);
memset(regs, 0, 8 * sizeof(OF_regprop_t));
regs[0].address = 0x00013000;
regs[0].size = 0x00001000;
regs[1].address = 0x00008400;
regs[1].size = 0x00000100;
regs[2].address = 0x00008500;
regs[2].size = 0x00000100;
regs[3].address = 0x00008600;
regs[3].size = 0x00000100;
regs[4].address = 0x00008700;
regs[4].size = 0x00000100;
OF_property_new(OF_env, scc, "reg",
regs, 5 * sizeof(OF_regprop_t));
OF_property_new(OF_env, scc, "ranges", NULL, 0);
/* Set up two channels */
chann = OF_node_new(OF_env, scc, "ch-a", 0x13020);
if (chann == NULL) {
ERROR("Cannot create 'ch-a'\n");
goto out;
}
OF_prop_string_new(OF_env, chann, "device_type", "serial");
OF_prop_string_new(OF_env, chann, "compatible", "chrp,es2");
OF_property_new(OF_env, chann, "built-in", NULL, 0);
OF_prop_int_new(OF_env, chann, "slot-names", 0);
OF_prop_int_new(OF_env, chann, "interrupt-parent", pic_phandle);
memset(regs, 0, 8 * sizeof(OF_regprop_t));
regs[0].address = 0x00013020;
regs[0].size = 0x00000001;
regs[1].address = 0x00013030;
regs[1].size = 0x00000001;
regs[2].address = 0x00013050;
regs[2].size = 0x00000001;
regs[3].address = 0x00008400;
regs[3].size = 0x00000100;
regs[4].address = 0x00008500;
regs[4].size = 0x00000100;
OF_property_new(OF_env, chann, "reg",
regs, 5 * sizeof(OF_regprop_t));
/* XXX: tofix: those are regprops */
irqs[0] = 0x16;
irqs[1] = 0x01;
irqs[2] = 0x05;
irqs[3] = 0x00;
irqs[4] = 0x06;
irqs[5] = 0x00;
OF_property_new(OF_env, chann, "interrupts",
irqs, 6 * sizeof(uint32_t));
OF_node_put(OF_env, chann);
chann = OF_node_new(OF_env, scc, "ch-b", 0x13000);
if (chann == NULL) {
ERROR("Cannot create 'ch-b'\n");
goto out;
}
OF_prop_string_new(OF_env, chann, "device_type", "serial");
OF_prop_string_new(OF_env, chann, "compatible", "chrp,es3");
OF_property_new(OF_env, chann, "built-in", NULL, 0);
OF_prop_int_new(OF_env, chann, "slot-names", 0);
OF_prop_int_new(OF_env, chann, "interrupt-parent", pic_phandle);
memset(regs, 0, 8 * sizeof(OF_regprop_t));
regs[0].address = 0x00013000;
regs[0].size = 0x00000001;
regs[1].address = 0x00013010;
regs[1].size = 0x00000001;
regs[2].address = 0x00013040;
regs[2].size = 0x00000001;
regs[3].address = 0x00008600;
regs[3].size = 0x00000100;
regs[4].address = 0x00008700;
regs[4].size = 0x00000100;
OF_property_new(OF_env, chann, "reg",
regs, 5 * sizeof(OF_regprop_t));
/* XXX: tofix: those are regprops */
irqs[0] = 0x17;
irqs[1] = 0x01;
irqs[2] = 0x07;
irqs[3] = 0x00;
irqs[4] = 0x08;
irqs[5] = 0x00;
OF_property_new(OF_env, chann, "interrupts",
irqs, 6 * sizeof(uint32_t));
OF_node_put(OF_env, chann);
OF_node_put(OF_env, scc);
/* MacOS likes escc-legacy */
scc = OF_node_new(OF_env, mio, "escc-legacy", 0x12000);
if (scc == NULL) {
ERROR("Cannot create 'escc-legacy'\n");
goto out;
}
OF_prop_string_new(OF_env, scc, "device_type", "escc-legacy");
OF_prop_string_new(OF_env, scc, "compatible", "chrp,es1");
OF_property_new(OF_env, scc, "built-in", NULL, 0);
OF_prop_int_new(OF_env, scc, "#address-cells", 1);
memset(regs, 0, 8 * sizeof(OF_regprop_t));
regs[0].address = 0x00012000;
regs[0].size = 0x00001000;
regs[1].address = 0x00008400;
regs[1].size = 0x00000100;
regs[2].address = 0x00008500;
regs[2].size = 0x00000100;
regs[3].address = 0x00008600;
regs[3].size = 0x00000100;
regs[4].address = 0x00008700;
regs[4].size = 0x00000100;
OF_property_new(OF_env, scc, "reg",
regs, 8 * sizeof(OF_regprop_t));
OF_property_new(OF_env, scc, "ranges", NULL, 0);
/* Set up two channels */
chann = OF_node_new(OF_env, scc, "ch-a", 0x12004);
if (chann == NULL) {
ERROR("Cannot create 'ch-a'\n");
goto out;
}
OF_prop_string_new(OF_env, chann, "device_type", "serial");
OF_prop_string_new(OF_env, chann, "compatible", "chrp,es4");
OF_property_new(OF_env, chann, "built-in", NULL, 0);
OF_prop_int_new(OF_env, chann, "interrupt-parent", pic_phandle);
memset(regs, 0, 8 * sizeof(OF_regprop_t));
regs[0].address = 0x00012004;
regs[0].size = 0x00000001;
regs[1].address = 0x00012006;
regs[1].size = 0x00000001;
regs[2].address = 0x0001200A;
regs[2].size = 0x00000001;
regs[3].address = 0x00008400;
regs[3].size = 0x00000100;
regs[4].address = 0x00008500;
regs[4].size = 0x00000100;
OF_property_new(OF_env, chann, "reg",
regs, 8 * sizeof(OF_regprop_t));
/* XXX: tofix: those are regprops */
irqs[0] = 0x16;
irqs[1] = 0x01;
irqs[2] = 0x05;
irqs[3] = 0x00;
irqs[4] = 0x06;
irqs[5] = 0x00;
OF_property_new(OF_env, chann, "interrupts",
irqs, 6 * sizeof(uint32_t));
OF_node_put(OF_env, chann);
chann = OF_node_new(OF_env, scc, "ch-b", 0x12000);
if (chann == NULL) {
ERROR("Cannot create 'ch-b'\n");
goto out;
}
OF_prop_string_new(OF_env, chann, "device_type", "serial");
OF_prop_string_new(OF_env, chann, "compatible", "chrp,es5");
OF_property_new(OF_env, chann, "built-in", NULL, 0);
OF_prop_int_new(OF_env, chann, "interrupt-parent", pic_phandle);
memset(regs, 0, 8 * sizeof(OF_regprop_t));
regs[0].address = 0x00012000;
regs[0].size = 0x00000001;
regs[1].address = 0x00012002;
regs[1].size = 0x00000001;
regs[2].address = 0x00012008;
regs[2].size = 0x00000001;
regs[3].address = 0x00008600;
regs[3].size = 0x00000100;
regs[4].address = 0x00008700;
regs[4].size = 0x00000100;
OF_property_new(OF_env, chann, "reg",
regs, 8 * sizeof(OF_regprop_t));
/* XXX: tofix: those are regprops */
irqs[0] = 0x17;
irqs[1] = 0x01;
irqs[2] = 0x07;
irqs[3] = 0x00;
irqs[4] = 0x08;
irqs[5] = 0x00;
OF_property_new(OF_env, chann, "interrupts",
irqs, 6 * sizeof(uint32_t));
OF_node_put(OF_env, chann);
OF_node_put(OF_env, scc);
}
#endif
/* Keylargo IDE controller: need some work (DMA problem ?) */
if (arch == ARCH_MAC99) {
keylargo_ata(mio, base_address, 0x1f000, 0x13, 0xb, pic_phandle);
keylargo_ata(mio, base_address, 0x20000, 0x14, 0xb, pic_phandle);
}
#if 0
/* Timer */
{
OF_node_t *tmr;
OF_regprop_t regs[1];
tmr = OF_node_new(OF_env, mio, "timer", 0x15000);
if (tmr == NULL) {
ERROR("Cannot create 'timer'\n");
goto out;
}
OF_prop_string_new(OF_env, tmr, "device_type", "timer");
OF_prop_string_new(OF_env, tmr, "compatible", "keylargo-timer");
OF_prop_int_new(OF_env, tmr, "clock-frequency", 0x01194000);
regs[0].address = 0x00015000;
regs[0].size = 0x00001000;
OF_property_new(OF_env, tmr, "reg", regs, sizeof(OF_regprop_t));
OF_prop_int_new(OF_env, tmr, "interrupt-parent", pic_phandle);
regs[0].address = 0x00000020;
regs[0].size = 0x00000001;
OF_property_new(OF_env, tmr, "interrupts",
regs, sizeof(OF_regprop_t));
OF_node_put(OF_env, tmr);
}
#endif
/* VIA-PMU */
{
/* Controls adb, RTC and power-mgt (forget it !) */
OF_node_t *via, *adb;
OF_regprop_t regs[1];
#if 0 // THIS IS A HACK AND IS COMPLETELY ABSURD !
// (but needed has Qemu doesn't emulate via-pmu).
via = OF_node_new(OF_env, mio, "via-pmu", 0x16000);
if (via == NULL) {
ERROR("Cannot create 'via-pmu'\n");
goto out;
}
OF_prop_string_new(OF_env, via, "device_type", "via-pmu");
OF_prop_string_new(OF_env, via, "compatible", "pmu");
#else
via = OF_node_new(OF_env, mio, "via-cuda", 0x16000);
if (via == NULL) {
ERROR("Cannot create 'via-cuda'\n");
goto out;
}
OF_prop_string_new(OF_env, via, "device_type", "via-cuda");
OF_prop_string_new(OF_env, via, "compatible", "cuda");
#endif
regs[0].address = 0x00016000;
regs[0].size = 0x00002000;
OF_property_new(OF_env, via, "reg", regs, sizeof(OF_regprop_t));
OF_prop_int_new(OF_env, via, "interrupt-parent", pic_phandle);
if (arch == ARCH_HEATHROW) {
OF_prop_int_new(OF_env, via, "interrupts", 0x12);
} else {
regs[0].address = 0x00000019;
regs[0].size = 0x00000001;
OF_property_new(OF_env, via, "interrupts",
regs, sizeof(OF_regprop_t));
}
/* force usage of OF bus speeds */
OF_prop_int_new(OF_env, via, "BusSpeedCorrect", 1);
#if 0
OF_prop_int_new(OF_env, via, "pmu-version", 0x00D0740C);
#endif
{
OF_node_t *kbd, *mouse;
/* ADB pseudo-device */
adb = OF_node_new(OF_env, via, "adb", OF_ADDRESS_NONE);
if (adb == NULL) {
ERROR("Cannot create 'adb'\n");
goto out;
}
OF_prop_string_new(OF_env, adb, "device_type", "adb");
#if 0
OF_prop_string_new(OF_env, adb, "compatible", "pmu-99");
#else
OF_prop_string_new(OF_env, adb, "compatible", "adb");
#endif
OF_prop_int_new(OF_env, adb, "#address-cells", 1);
OF_prop_int_new(OF_env, adb, "#size-cells", 0);
OF_pack_get_path(OF_env, tmp, 512, adb);
OF_prop_string_new(OF_env, als, "adb", tmp);
kbd = OF_node_new(OF_env, adb, "keyboard", 2);
if (kbd == NULL) {
ERROR("Cannot create 'kbd'\n");
goto out;
}
OF_prop_string_new(OF_env, kbd, "device_type", "keyboard");
OF_prop_int_new(OF_env, kbd, "reg", 2);
mouse = OF_node_new(OF_env, adb, "mouse", 3);
if (mouse == NULL) {
ERROR("Cannot create 'mouse'\n");
goto out;
}
OF_prop_string_new(OF_env, mouse, "device_type", "mouse");
OF_prop_int_new(OF_env, mouse, "reg", 3);
OF_prop_int_new(OF_env, mouse, "#buttons", 3);
}
{
OF_node_t *rtc;
rtc = OF_node_new(OF_env, via, "rtc", OF_ADDRESS_NONE);
if (rtc == NULL) {
ERROR("Cannot create 'rtc'\n");
goto out;
}
OF_prop_string_new(OF_env, rtc, "device_type", "rtc");
#if 0
OF_prop_string_new(OF_env, rtc, "compatible", "rtc,via-pmu");
#else
OF_prop_string_new(OF_env, rtc, "compatible", "rtc");
#endif
OF_node_put(OF_env, rtc);
}
// OF_node_put(OF_env, via);
}
{
OF_node_t *pmgt;
pmgt = OF_node_new(OF_env, mio, "power-mgt", OF_ADDRESS_NONE);
OF_prop_string_new(OF_env, pmgt, "device_type", "power-mgt");
OF_prop_string_new(OF_env, pmgt, "compatible", "cuda");
OF_prop_string_new(OF_env, pmgt, "mgt-kind", "min-consumption-pwm-led");
OF_node_put(OF_env, pmgt);
}
if (arch == ARCH_HEATHROW) {
/* NVRAM */
OF_node_t *nvr;
OF_regprop_t regs;
nvr = OF_node_new(OF_env, mio, "nvram", 0x60000);
OF_prop_string_new(OF_env, nvr, "device_type", "nvram");
regs.address = 0x60000;
regs.size = 0x00020000;
OF_property_new(OF_env, nvr, "reg", ®s, sizeof(regs));
OF_prop_int_new(OF_env, nvr, "#bytes", 0x2000);
OF_node_put(OF_env, nvr);
}
out:
// OF_node_put(OF_env, mio);
OF_node_put(OF_env, chs);
OF_node_put(OF_env, als);
}
void OF_finalize_pci_ide (void *dev,
uint32_t io_base0, uint32_t io_base1,
uint32_t io_base2, uint32_t io_base3)
{
OF_env_t *OF_env = OF_env_main;
OF_node_t *pci_ata = dev;
OF_node_t *ata, *atas[2];
int i;
OF_prop_int_new(OF_env, pci_ata, "#address-cells", 1);
OF_prop_int_new(OF_env, pci_ata, "#size-cells", 0);
/* XXX: Darwin handles only one device */
for(i = 0; i < 1; i++) {
ata = OF_node_new(OF_env, pci_ata, "ata-4", i);
if (ata == NULL) {
ERROR("Cannot create 'ata-4'\n");
return;
}
OF_prop_string_new(OF_env, ata, "device_type", "ata");
OF_prop_string_new(OF_env, ata, "compatible", "cmd646-ata");
OF_prop_string_new(OF_env, ata, "model", "ata-4");
OF_prop_int_new(OF_env, ata, "#address-cells", 1);
OF_prop_int_new(OF_env, ata, "#size-cells", 0);
OF_prop_int_new(OF_env, ata, "reg", i);
atas[i] = ata;
}
ide_pci_pc_register(io_base0, io_base1, io_base2, io_base3,
atas[0], atas[1]);
}
/*****************************************************************************/
/* Fake package */
static void OF_method_fake (OF_env_t *OF_env)
{
uint32_t ihandle;
ihandle = popd(OF_env);
OF_DPRINTF("ih: %0x %d\n", ihandle, stackd_depth(OF_env));
pushd(OF_env, ihandle);
}
static void OF_mmu_translate (OF_env_t *OF_env)
{
const unsigned char *args;
uint32_t address, more;
uint32_t ihandle;
OF_CHECK_NBARGS(OF_env, 4);
/* As we get a 1:1 mapping, do nothing */
ihandle = popd(OF_env);
args = (void *)popd(OF_env);
address = popd(OF_env);
more = popd(OF_env);
OF_DPRINTF("Translate address %0x %0x %0x\n", ihandle, address, more);
// BAT_setup(3, more, address, 0x10000000, 1, 1, 2);
pushd(OF_env, address);
pushd(OF_env, 0x00000000);
pushd(OF_env, 0x00000000);
pushd(OF_env, 0);
}
static void OF_mmu_map (OF_env_t *OF_env)
{
const unsigned char *args;
uint32_t address, virt, size;
uint32_t ihandle;
OF_CHECK_NBARGS(OF_env, 6);
/* As we get a 1:1 mapping, do nothing */
ihandle = popd(OF_env);
args = (void *)popd(OF_env);
popd(OF_env);
size = popd(OF_env);
virt = popd(OF_env);
address = popd(OF_env);
OF_DPRINTF("Map %0x %0x %0x %0x\n", ihandle, address,
virt, size);
pushd(OF_env, 0);
}
/* Serial device package */
static void OF_serial_write (OF_env_t *OF_env)
{
const unsigned char *args;
OF_inst_t *inst;
OF_node_t *node;
uint32_t ihandle;
unsigned char *str;
int len;
OF_CHECK_NBARGS(OF_env, 4);
ihandle = popd(OF_env);
args = (void *)popd(OF_env);
str = (void *)popd(OF_env);
len = popd(OF_env);
inst = OF_inst_find(OF_env, ihandle);
if (inst == NULL) {
pushd(OF_env, -1);
ERROR("Cannot get serial instance\n");
return;
}
node = inst->node;
// OF_DPRINTF("args: %p str: %p\n", args, str);
/* XXX: should use directly the serial port
* and have another console package.
*/
console_write(str, len);
pushd(OF_env, 0);
}
static void OF_serial_read (OF_env_t *OF_env)
{
const unsigned char *args;
char *dest;
uint32_t len;
uint32_t ihandle;
uint16_t phandle;
int ret, count;
OF_CHECK_NBARGS(OF_env, 4);
ihandle = popd(OF_env);
args = (void *)popd(OF_env);
phandle = (ihandle >> 16) & 0xFFFF;
dest = (void *)popd(OF_env);
len = popd(OF_env);
ret = -1; /* Don't know why gcc thinks it might be uninitialized... */
for (count = 0; count < 1000; count++) {
ret = console_read(dest, len);
/* Stop if we read something or got an error */
if (ret != 0)
break;
/* Random sleep. Seems allright for serial port */
usleep(10000);
}
if (ret <= 0) {
pushd(OF_env, 0);
} else {
OF_DPRINTF("send '%s'\n", dest);
pushd(OF_env, ret);
}
}
typedef struct blockdev_inst_t {
int type;
union {
bloc_device_t *bd;
part_t *part;
inode_t *file;
} u;
} blockdev_inst_t;
static int OF_split_args (unsigned char *args, unsigned char **argv,
int max_args)
{
unsigned char *pos, *end;
int i;
pos = args;
end = pos;
for (i = 0; i < max_args && *pos != '\0' && end != NULL; i++) {
end = strchr(pos, ',');
if (end != NULL)
*end = '\0';
argv[i] = pos;
pos = end + 1;
}
return i;
}
static void OF_convert_path (unsigned char **path)
{
unsigned char *pos;
OF_DPRINTF("%s: '%s'\n", __func__, *path);
for (pos = *path; *pos != '\0'; pos++) {
if (*pos == '\\')
*pos = '/';
}
OF_DPRINTF("%s: '%s'\n", __func__, *path);
pos = *path;
#if 1
if (pos[0] == '/' && pos[1] == '/') {
pos += 2;
*path = pos;
}
#else
for (; *pos == '/'; pos++)
continue;
*path = pos;
#endif
OF_DPRINTF("%s: '%s'\n", __func__, *path);
}
/* Block devices package */
static void OF_blockdev_open (OF_env_t *OF_env)
{
unsigned char tmp[OF_NAMELEN_MAX];
unsigned char *args, *argv[4];
OF_inst_t *dsk_inst;
OF_node_t *dsk;
bloc_device_t *bd;
blockdev_inst_t *bdinst;
uint32_t ihandle;
uint16_t phandle;
int nargs, partnum;
OF_CHECK_NBARGS(OF_env, 2);
ihandle = popd(OF_env);
args = (void *)popd(OF_env);
phandle = (ihandle >> 16) & 0xFFFF;
dsk_inst = OF_inst_find(OF_env, ihandle);
if (dsk_inst == NULL) {
ERROR("Disk not found (ih: %0x)\n", ihandle);
pushd(OF_env, -1);
return;
}
dsk = dsk_inst->node;
bd = dsk->private_data;
bdinst = malloc(sizeof(blockdev_inst_t));
if (bdinst == NULL) {
ihandle = -1;
ERROR("Cannot alloc blockdev instance\n");
goto out;
}
memset(bdinst, 0, sizeof(blockdev_inst_t));
OF_DPRINTF("called with args '%s'\n", args);
nargs = OF_split_args(args, argv, 4);
partnum = -1;
if (nargs > 0) {
partnum = strtol(argv[0], NULL, 10);
if (partnum > 0) {
OF_DPRINTF("Open partition... %d %d\n", partnum, nargs);
bdinst->type = 1;
bdinst->u.part = part_get(bd, partnum);
if (bdinst->u.part == NULL) {
OF_DPRINTF("Partition %d not found\n", partnum);
free(bdinst);
pushd(OF_env, -1);
return;
}
if (nargs > 1) {
/* TODO: open file */
bdinst->type = 2;
OF_DPRINTF("Open file... %d %d '%s'\n",
partnum, nargs, argv[1]);
OF_convert_path(&argv[1]);
if (*argv[1] != '/') {
sprintf(tmp, "%s/%s",
fs_get_boot_dirname(part_fs(bdinst->u.part)),
argv[1]);
bdinst->u.file = fs_open(part_fs(bdinst->u.part), tmp);
} else {
bdinst->u.file = fs_open(part_fs(bdinst->u.part), argv[1]);
}
if (bdinst->u.file == NULL) {
#if 0
bug();
#endif
pushd(OF_env, 0x00000000);
ERROR("File not found '%s'\n", argv[1]);
return;
}
}
}
}
if (nargs == 0 || partnum == 0) {
OF_DPRINTF("Open disk... %d %d\n", nargs, partnum);
bdinst->type = 0;
bdinst->u.bd = bd;
}
/* TODO: find partition &/| file */
dsk_inst->data = bdinst;
OF_node_put(OF_env, dsk);
out:
pushd(OF_env, ihandle);
}
static void OF_blockdev_seek (OF_env_t *OF_env)
{
const unsigned char *args;
OF_inst_t *dsk_inst;
blockdev_inst_t *bdinst;
uint32_t posh, posl, bloc, pos, blocsize, tmp;
uint32_t ihandle;
uint16_t phandle;
int sh;
OF_CHECK_NBARGS(OF_env, 4);
ihandle = popd(OF_env);
args = (void *)popd(OF_env);
phandle = (ihandle >> 16) & 0xFFFF;
posh = popd(OF_env);
posl = popd(OF_env);
dsk_inst = OF_inst_find(OF_env, ihandle);
if (dsk_inst == NULL) {
ERROR("Disk not found (ih: %0x)\n", ihandle);
pushd(OF_env, -1);
return;
}
bdinst = dsk_inst->data;
switch (bdinst->type) {
case 0:
blocsize = bd_seclen(bdinst->u.bd);
for (tmp = blocsize, sh = 0; tmp != 1; tmp = tmp / 2)
sh++;
bloc = ((posh << (32 - sh)) | (posl / blocsize));
pos = posl % blocsize;
OF_DPRINTF("disk: bsize %08x %08x %08x => %08x %08x\n", blocsize,
posh, posl, bloc, pos);
pushd(OF_env, bd_seek(bdinst->u.bd, bloc, pos));
break;
case 1:
blocsize = part_blocsize(bdinst->u.part);
for (tmp = blocsize, sh = 0; tmp != 1; tmp = tmp / 2)
sh++;
bloc = ((posh << (32 - sh)) | (posl / blocsize));
pos = posl % blocsize;
OF_DPRINTF("part: bsize %08x %08x %08x => %08x %08x\n", blocsize,
posh, posl, bloc, pos);
pushd(OF_env, part_seek(bdinst->u.part, bloc, pos));
break;
case 2:
blocsize = part_blocsize(fs_inode_get_part(bdinst->u.file));
for (tmp = blocsize, sh = 0; tmp != 1; tmp = tmp / 2)
sh++;
bloc = ((posh << (32 - sh)) | (posl / blocsize));
pos = posl % blocsize;
OF_DPRINTF("file: bsize %08x %08x %08x => %08x %08x\n", blocsize,
posh, posl, bloc, pos);
pushd(OF_env, fs_seek(bdinst->u.file, bloc, pos));
break;
}
}
static void OF_blockdev_read (OF_env_t *OF_env)
{
const unsigned char *args;
OF_inst_t *dsk_inst;
blockdev_inst_t *bdinst;
void *dest;
uint32_t len;
uint32_t ihandle;
uint16_t phandle;
OF_CHECK_NBARGS(OF_env, 4);
ihandle = popd(OF_env);
args = (void *)popd(OF_env);
phandle = (ihandle >> 16) & 0xFFFF;
dest = (void *)popd(OF_env);
len = popd(OF_env);
dsk_inst = OF_inst_find(OF_env, ihandle);
if (dsk_inst == NULL) {
ERROR("Disk not found (ih: %0x)\n", ihandle);
pushd(OF_env, -1);
return;
}
bdinst = dsk_inst->data;
set_check(0);
OF_DPRINTF("dest: %p len: %d %d\n", dest, len, bdinst->type);
switch (bdinst->type) {
case 0:
OF_DPRINTF("read disk\n");
pushd(OF_env, bd_read(bdinst->u.bd, dest, len));
break;
case 1:
OF_DPRINTF("read partition\n");
pushd(OF_env, part_read(bdinst->u.part, dest, len));
break;
case 2:
OF_DPRINTF("read file\n");
pushd(OF_env, fs_read(bdinst->u.file, dest, len));
break;
}
OF_DPRINTF("%08x %08x %08x %08x\n",
((uint32_t *)dest)[0], ((uint32_t *)dest)[1],
((uint32_t *)dest)[2], ((uint32_t *)dest)[3]);
OF_DPRINTF("%08x %08x %08x %08x\n",
((uint32_t *)dest)[4], ((uint32_t *)dest)[5],
((uint32_t *)dest)[6], ((uint32_t *)dest)[7]);
set_check(1);
}
static void OF_blockdev_get_blocsize (OF_env_t *OF_env)
{
const unsigned char *args;
OF_inst_t *dsk_inst;
blockdev_inst_t *bdinst;
uint32_t ihandle;
uint16_t phandle;
uint32_t blocsize;
OF_CHECK_NBARGS(OF_env, 2);
ihandle = popd(OF_env);
args = (void *)popd(OF_env);
phandle = (ihandle >> 16) & 0xFFFF;
dsk_inst = OF_inst_find(OF_env, ihandle);
if (dsk_inst == NULL) {
ERROR("Disk not found (ih: %0x)\n", ihandle);
pushd(OF_env, -1);
return;
}
bdinst = dsk_inst->data;
#if 0
switch (bdinst->type) {
case 0:
blocsize = bd_seclen(bdinst->u.bd);
break;
case 1:
blocsize = part_blocsize(bdinst->u.part);
break;
case 2:
blocsize = 512;
break;
}
#else
blocsize = 512;
#endif
pushd(OF_env, blocsize);
pushd(OF_env, 0);
}
static void OF_blockdev_dma_alloc (OF_env_t *OF_env)
{
const unsigned char *args;
void *address;
uint32_t ihandle;
uint32_t size;
OF_CHECK_NBARGS(OF_env, 3);
ihandle = popd(OF_env);
args = (void *)popd(OF_env);
size = popd(OF_env);
OF_DPRINTF("size: %08x\n", size);
mem_align(size);
address = malloc(size);
if (address != NULL)
memset(address, 0, size);
pushd(OF_env, (uint32_t)address);
pushd(OF_env, 0);
}
static void OF_blockdev_dma_free (OF_env_t *OF_env)
{
const unsigned char *args;
void *address;
uint32_t ihandle;
uint32_t size;
OF_CHECK_NBARGS(OF_env, 4);
ihandle = popd(OF_env);
args = (void *)popd(OF_env);
size = popd(OF_env);
address = (void *)popd(OF_env);
OF_DPRINTF("address: %p size: %08x\n", address, size);
free(address);
pushd(OF_env, 0);
}
void *OF_blockdev_register (void *parent, void *private,
const unsigned char *type,
const unsigned char *name, int devnum,
const char *alias)
{
unsigned char tmp[OF_NAMELEN_MAX], path[OF_NAMELEN_MAX], *pos;
OF_env_t *OF_env;
OF_node_t *dsk, *als;
int i;
OF_env = OF_env_main;
dsk = OF_node_new(OF_env, parent, name, devnum);
if (dsk == NULL) {
ERROR("Cannot create blockdev '%s'\n", name);
return NULL;
}
OF_prop_string_new(OF_env, dsk, "device_type", "block");
OF_prop_string_new(OF_env, dsk, "category", type);
OF_prop_int_new(OF_env, dsk, "device_id", devnum);
OF_prop_int_new(OF_env, dsk, "reg", devnum);
OF_method_new(OF_env, dsk, "open", &OF_blockdev_open);
OF_method_new(OF_env, dsk, "seek", &OF_blockdev_seek);
OF_method_new(OF_env, dsk, "read", &OF_blockdev_read);
OF_method_new(OF_env, dsk, "block-size",
&OF_blockdev_get_blocsize);
OF_method_new(OF_env, dsk, "dma-alloc", &OF_blockdev_dma_alloc);
OF_method_new(OF_env, dsk, "dma-free", &OF_blockdev_dma_free);
if (strcmp(type, "cdrom") == 0)
OF_method_new(OF_env, dsk, "eject", &OF_method_fake);
OF_method_new(OF_env, dsk, "close", &OF_method_fake);
dsk->private_data = private;
/* Set up aliases */
OF_pack_get_path(OF_env, path, OF_NAMELEN_MAX, dsk);
if (alias != NULL) {
als = OF_node_get(OF_env, "aliases");
if (als == NULL) {
ERROR("Cannot get 'aliases'\n");
return NULL;
}
strcpy(tmp, alias);
if (OF_property_copy(OF_env, NULL, 0, als, tmp) >= 0) {
pos = tmp + strlen(alias);
for (i = 0; ; i++) {
sprintf(pos, "%d", i);
if (OF_property_copy(OF_env, NULL, 0, als, tmp) < 0)
break;
}
}
OF_DPRINTF("Set alias to %s\n", tmp);
OF_prop_string_new(OF_env, dsk, "alias", tmp);
OF_prop_string_new(OF_env, als, tmp, path);
OF_node_put(OF_env, als);
}
return dsk;
}
void OF_blockdev_set_boot_device (void *disk, int partnum,
const unsigned char *file)
{
unsigned char tmp[OF_NAMELEN_MAX], *pos;
OF_env_t *OF_env;
OF_node_t *dsk = disk, *opts, *chs;
OF_env = OF_env_main;
if (OF_property_copy(OF_env, tmp, OF_NAMELEN_MAX, dsk, "alias") < 0)
OF_pack_get_path(OF_env, tmp, OF_NAMELEN_MAX, dsk);
sprintf(tmp + strlen(tmp), ":%d", partnum);
/* OpenDarwin 6.02 seems to need this one */
opts = OF_node_get(OF_env, "options");
if (opts == NULL) {
ERROR("Cannot get 'options'\n");
return;
}
OF_prop_string_set(OF_env, OF_node_root, "boot-device", tmp);
OF_prop_string_set(OF_env, opts, "boot-device", tmp);
OF_DPRINTF("Set boot device to: '%s'\n", tmp);
OF_node_put(OF_env, opts);
/* Set the real boot path */
pos = tmp + strlen(tmp);
sprintf(pos, ",%s", file);
/* Convert all '/' into '\' in the boot file name */
for (; *pos != '\0'; pos++) {
if (*pos == '/')
*pos = '\\';
}
chs = OF_node_get(OF_env, "chosen");
if (chs == NULL) {
ERROR("Cannot get 'chosen'\n");
return;
}
OF_prop_string_set(OF_env, chs, "bootpath", tmp);
OF_DPRINTF("Set boot path to: '%s'\n", tmp);
OF_node_put(OF_env, chs);
}
/* Display package */
static void OF_vga_draw_rectangle (OF_env_t *OF_env)
{
const void *buf;
const unsigned char *args;
uint32_t posx, posy, width, height;
uint32_t ihandle;
OF_CHECK_NBARGS(OF_env, 7);
ihandle = popd(OF_env);
args = (void *)popd(OF_env);
height = popd(OF_env);
width = popd(OF_env);
posy = popd(OF_env);
posx = popd(OF_env);
buf = (const void *)popd(OF_env);
OF_DPRINTF("x=%d y=%d h=%d ", posx, posy, width);
OF_DPRINTF("w=%d buf=%p\n", height, buf);
set_check(0);
vga_draw_buf(buf, width * vga_fb_bpp, posx, posy, width, height);
set_check(1);
pushd(OF_env, 0);
}
static void OF_vga_fill_rectangle (OF_env_t *OF_env)
{
const unsigned char *args;
uint32_t color, posx, posy, width, height;
uint32_t ihandle;
OF_CHECK_NBARGS(OF_env, 7);
ihandle = popd(OF_env);
args = (void *)popd(OF_env);
height = popd(OF_env);
width = popd(OF_env);
posy = popd(OF_env);
posx = popd(OF_env);
color = popd(OF_env);
OF_DPRINTF("x=%d y=%d\n", posx, posy);
OF_DPRINTF("h=%d w=%d c=%0x\n", width, height, color);
vga_fill_rect(posx, posy, width, height, color);
pushd(OF_env, 0);
}
static void OF_vga_set_width (OF_env_t *OF_env, OF_prop_t *prop,
const void *data, int len)
{
uint32_t width, height, depth;
if (len == sizeof(uint32_t)) {
width = *(uint32_t *)data;
OF_property_copy(OF_env, &height, 4, prop->node, "height");
OF_property_copy(OF_env, &depth, 4, prop->node, "depth");
vga_set_mode(width, height, depth);
}
}
static void OF_vga_set_height (OF_env_t *OF_env, OF_prop_t *prop,
const void *data, int len)
{
uint32_t width, height, depth;
if (len == sizeof(uint32_t)) {
OF_property_copy(OF_env, &width, 4, prop->node, "width");
height = *(uint32_t *)data;
OF_property_copy(OF_env, &depth, 4, prop->node, "depth");
vga_set_mode(width, height, depth);
}
}
static void OF_vga_set_depth (OF_env_t *OF_env, OF_prop_t *prop,
const void *data, int len)
{
uint32_t width, height, depth;
if (len == sizeof(uint32_t)) {
OF_property_copy(OF_env, &width, 4, prop->node, "width");
OF_property_copy(OF_env, &height, 4, prop->node, "height");
depth = *(uint32_t *)data;
vga_set_mode(width, height, depth);
}
}
void OF_vga_register (const unsigned char *name, unused uint32_t address,
int width, int height, int depth,
unsigned long vga_bios_addr, unsigned long vga_bios_size)
{
OF_env_t *OF_env;
unsigned char tmp[OF_NAMELEN_MAX];
OF_node_t *disp, *chs, *als;
OF_prop_t *prop;
OF_DPRINTF("Set frame buffer %08x %dx%dx%d\n",
address, width, height, depth);
OF_env = OF_env_main;
disp = OF_node_get(OF_env, name);
if (disp == NULL) {
ERROR("Cannot get display '%s'\n", name);
return;
}
prop = OF_prop_int_new(OF_env, disp, "width", width);
if (prop == NULL) {
OF_node_put(OF_env, disp);
ERROR("Cannot create display width property\n");
return;
}
OF_property_set_cb(OF_env, prop, &OF_vga_set_width);
prop = OF_prop_int_new(OF_env, disp, "height", height);
if (prop == NULL) {
OF_node_put(OF_env, disp);
ERROR("Cannot create display height property\n");
return;
}
OF_property_set_cb(OF_env, prop, &OF_vga_set_height);
switch (depth) {
case 8:
break;
case 15:
depth = 16;
break;
case 32:
break;
default:
/* OF spec this is mandatory, but we have no support for it */
printf("%d bits VGA isn't implemented\n", depth);
bug();
/* Never come here */
break;
}
prop = OF_prop_int_new(OF_env, disp, "depth", depth);
if (prop == NULL) {
ERROR("Cannot create display depth\n");
goto out;
}
OF_property_set_cb(OF_env, prop, &OF_vga_set_depth);
OF_prop_int_new(OF_env, disp, "linebytes", vga_fb_linesize);
OF_method_new(OF_env, disp, "draw-rectangle", &OF_vga_draw_rectangle);
OF_method_new(OF_env, disp, "fill-rectangle", &OF_vga_fill_rectangle);
OF_method_new(OF_env, disp, "color!", &OF_method_fake);
chs = OF_node_get(OF_env, "chosen");
if (chs == NULL) {
ERROR("Cannot get 'chosen'\n");
goto out;
}
OF_prop_int_new(OF_env, chs, "display", OF_pack_handle(OF_env, disp));
OF_node_put(OF_env, chs);
OF_pack_get_path(OF_env, tmp, 512, disp);
printf("Set display '%s' path to '%s'\n", name, tmp);
als = OF_node_get(OF_env, "aliases");
if (als == NULL) {
ERROR("Cannot get 'aliases'\n");
goto out;
}
OF_prop_string_new(OF_env, als, "screen", tmp);
OF_prop_string_new(OF_env, als, "display", tmp);
OF_node_put(OF_env, als);
/* XXX: may also need read-rectangle */
if (vga_bios_size >= 8) {
const uint8_t *p;
int size;
/* check the QEMU VGA BIOS header */
p = (const uint8_t *)vga_bios_addr;
if (p[0] == 'N' && p[1] == 'D' && p[2] == 'R' && p[3] == 'V') {
size = *(uint32_t *)(p + 4);
OF_property_new(OF_env, disp, "driver,AAPL,MacOS,PowerPC",
p + 8, size);
}
}
out:
OF_node_put(OF_env, disp);
}
/* Pseudo packages to make BootX happy */
/* sl_words package */
static void slw_set_output_level (OF_env_t *OF_env)
{
OF_node_t *slw;
const unsigned char *args;
int level;
OF_CHECK_NBARGS(OF_env, 3);
popd(OF_env);
args = (void *)popd(OF_env);
level = popd(OF_env);
slw = OF_node_get(OF_env, "sl_words");
if (slw == NULL) {
pushd(OF_env, -1);
} else {
OF_DPRINTF("Set output level to: %d\n", level);
OF_prop_int_set(OF_env, slw, "outputLevel", level);
OF_node_put(OF_env, slw);
pushd(OF_env, 0);
}
}
#ifdef DEBUG_BIOS
#define EMIT_BUFFER_LEN 256
static unsigned char emit_buffer[EMIT_BUFFER_LEN];
static int emit_pos = 0;
#endif
static void slw_emit (OF_env_t *OF_env)
{
const unsigned char *args;
int c;
OF_CHECK_NBARGS(OF_env, 3);
popd(OF_env);
args = (void *)popd(OF_env);
c = popd(OF_env);
// OF_DPRINTF("Emit char %d\n", c);
#ifdef DEBUG_BIOS
if (emit_pos < EMIT_BUFFER_LEN - 1) {
emit_buffer[emit_pos++] = c;
// outb(0xFF00, c);
outb(0x0F00, c);
} else {
emit_buffer[emit_pos] = '\0';
}
#else
outb(0x0F00, c);
#endif
pushd(OF_env, 0);
}
static void slw_cr (OF_env_t *OF_env)
{
const unsigned char *args;
OF_CHECK_NBARGS(OF_env, 2);
popd(OF_env);
args = (void *)popd(OF_env);
// OF_DPRINTF("Emit CR char\n");
// outb(0xFF01, '\n');
outb(0x0F01, '\n');
#ifdef DEBUG_BIOS
emit_buffer[emit_pos] = '\0';
if (strcmp(emit_buffer, "Call Kernel!") == 0) {
/* Set qemu in debug mode:
* log in_asm,op,int,ioport,cpu
*/
uint16_t loglevel = 0x02 | 0x10 | 0x80;
// outw(0xFF02, loglevel);
outb(0x0F02, loglevel);
}
emit_pos = 0;
#endif
pushd(OF_env, 0);
}
static void slw_init_keymap (OF_env_t *OF_env)
{
const unsigned char *args;
OF_node_t *node;
OF_prop_t *prop;
uint32_t phandle, ihandle;
OF_CHECK_NBARGS(OF_env, 3);
ihandle = popd(OF_env);
args = (void *)popd(OF_env);
phandle = ihandle >> 16;
ihandle &= 0xFFFF;
OF_DPRINTF("\n");
node = OF_pack_find(OF_env, phandle);
if (node == NULL) {
ERROR("Cant' init slw keymap\n");
pushd(OF_env, -1);
} else {
prop = OF_property_get(OF_env, node, "keyMap");
if (prop == NULL) {
pushd(OF_env, -1);
} else {
pushd(OF_env, (uint32_t)prop->value);
pushd(OF_env, 0);
}
}
}
static void slw_update_keymap (OF_env_t *OF_env)
{
const unsigned char *args;
OF_CHECK_NBARGS(OF_env, 2);
popd(OF_env);
args = (void *)popd(OF_env);
OF_DPRINTF("\n");
pushd(OF_env, 0);
}
static void slw_spin (OF_env_t *OF_env)
{
const unsigned char *args;
/* XXX: cur_spin should be in sl_words package */
static int cur_spin = 0;
int c;
OF_CHECK_NBARGS(OF_env, 2);
popd(OF_env);
args = (void *)popd(OF_env);
if (cur_spin > 15) {
c = RGB(0x30, 0x30, 0x50);
} else {
c = RGB(0x11, 0x11, 0x11);
}
c = vga_get_color(c);
vga_fill_rect((cur_spin % 15) * 5 + 280, 420, 4, 3, c);
cur_spin = (cur_spin + 1) & 31;
OF_DPRINTF("\n");
pushd(OF_env, -1);
}
static void slw_spin_init (OF_env_t *OF_env)
{
const unsigned char *args;
OF_CHECK_NBARGS(OF_env, 8);
popd(OF_env);
args = (void *)popd(OF_env);
popd(OF_env);
popd(OF_env);
popd(OF_env);
popd(OF_env);
popd(OF_env);
popd(OF_env);
pushd(OF_env, -1);
}
static void slw_pwd (OF_env_t *OF_env)
{
const unsigned char *args;
OF_CHECK_NBARGS(OF_env, 3);
popd(OF_env);
args = (void *)popd(OF_env);
OF_DPRINTF("\n");
pushd(OF_env, -1);
}
static void slw_sum (OF_env_t *OF_env)
{
const unsigned char *args;
OF_CHECK_NBARGS(OF_env, 3);
popd(OF_env);
args = (void *)popd(OF_env);
OF_DPRINTF("\n");
pushd(OF_env, -1);
}
/*****************************************************************************/
/* Client program interface */
/* Client interface services */
static void OF_test (OF_env_t *OF_env);
/* Device tree services */
/* Get next package */
__attribute__ (( section (".OpenFirmware") ))
static void OF_peer (OF_env_t *OF_env)
{
OF_node_t *node;
uint32_t phandle;
OF_CHECK_NBARGS(OF_env, 1);
phandle = popd(OF_env);
OF_DPRINTF("phandle 0x%0x\n", phandle);
if (phandle == 0)
node = OF_node_root;
else
node = OF_pack_next(OF_env, phandle);
if (node == NULL)
pushd(OF_env, 0);
else
pushd(OF_env, OF_pack_handle(OF_env, node));
}
/* Get first child package */
__attribute__ (( section (".OpenFirmware") ))
static void OF_child (OF_env_t *OF_env)
{
OF_node_t *node;
uint32_t phandle;
OF_CHECK_NBARGS(OF_env, 1);
phandle = popd(OF_env);
OF_DPRINTF("phandle 0x%0x\n", phandle);
node = OF_pack_child(OF_env, phandle);
if (node == NULL)
pushd(OF_env, 0);
else
pushd(OF_env, OF_pack_handle(OF_env, node));
}
/* Get parent package */
__attribute__ (( section (".OpenFirmware") ))
static void OF_parent (OF_env_t *OF_env)
{
OF_node_t *node;
uint32_t phandle;
OF_CHECK_NBARGS(OF_env, 1);
phandle = popd(OF_env);
OF_DPRINTF("phandle 0x%0x\n", phandle);
node = OF_pack_parent(OF_env, phandle);
if (node == NULL)
pushd(OF_env, 0);
else
pushd(OF_env, OF_pack_handle(OF_env, node));
}
/* Get package related to an instance */
__attribute__ (( section (".OpenFirmware") ))
static void OF_instance_to_package (OF_env_t *OF_env)
{
uint32_t ihandle;
OF_CHECK_NBARGS(OF_env, 1);
ihandle = popd(OF_env);
OF_DPRINTF("ihandle 0x%0x\n", ihandle);
pushd(OF_env, (ihandle >> 16) & 0xFFFF);
}
/* Get property len */
__attribute__ (( section (".OpenFirmware") ))
static void OF_getproplen (OF_env_t *OF_env)
{
unsigned char name[OF_NAMELEN_MAX], *namep;
OF_node_t *node;
uint32_t phandle;
OF_CHECK_NBARGS(OF_env, 2);
phandle = popd(OF_env);
namep = (unsigned char *)popd(OF_env);
OF_lds(name, namep);
OF_DPRINTF("phandle 0x%0x prop [%s]\n", phandle, name);
node = OF_pack_find(OF_env, phandle);
if (node == NULL)
pushd(OF_env, -1);
else
pushd(OF_env, OF_property_len(OF_env, node, name));
}
/* Get property */
__attribute__ (( section (".OpenFirmware") ))
static void OF_getprop (OF_env_t *OF_env)
{
unsigned char name[OF_NAMELEN_MAX], *namep;
OF_node_t *node;
void *buffer;
uint32_t phandle;
int len, nb_args;
// OF_CHECK_NBARGS(OF_env, 4);
nb_args = stackd_depth(OF_env);
phandle = popd(OF_env);
namep = (unsigned char *)popd(OF_env);
OF_lds(name, namep);
buffer = (void *)popd(OF_env);
if (nb_args == 3) {
/* This hack is needed to boot MacOS X panther (10.3) */
len = 1024;
} else {
len = popd(OF_env);
}
OF_DPRINTF("phandle 0x%0x prop [%s]\n", phandle, name);
OF_DPRINTF("buffer %p len %d\n", buffer, len);
node = OF_pack_find(OF_env, phandle);
if (node == NULL) {
len = -1;
} else {
len = OF_property_copy(OF_env, buffer, len, node, name);
if (len != -1) {
OF_DPRINTF("Copied %d bytes\n", len);
}
}
pushd(OF_env, len);
}
/* Check existence of next property */
__attribute__ (( section (".OpenFirmware") ))
static void OF_nextprop (OF_env_t *OF_env)
{
unsigned char name[OF_NAMELEN_MAX], *namep;
OF_node_t *node;
OF_prop_t *next;
unsigned char *next_name;
uint32_t phandle;
OF_CHECK_NBARGS(OF_env, 3);
phandle = popd(OF_env);
namep = (unsigned char *)popd(OF_env);
OF_lds(name, namep);
OF_DPRINTF("phandle 0x%0x prop [%s]\n", phandle, name);
next_name = (unsigned char *)popd(OF_env);
node = OF_pack_find(OF_env, phandle);
if (node == NULL) {
pushd(OF_env, -1);
} else {
next = OF_property_next(OF_env, node, name);
if (next == NULL || next->name == NULL) {
OF_DPRINTF("No next property found [%s]\n", name);
pushd(OF_env, 0);
} else {
OF_DPRINTF("Return property name [%s]\n", next->name);
OF_sts(next_name, (void *)(next->name));
OF_DUMP_STRING(OF_env, next_name);
pushd(OF_env, strlen(next->name) + 1);
}
}
}
/* Set a property */
__attribute__ (( section (".OpenFirmware") ))
static void OF_setprop (OF_env_t *OF_env)
{
unsigned char name[OF_NAMELEN_MAX], *namep;
unsigned char *value, *buffer;
OF_node_t *node;
OF_prop_t *prop;
uint32_t phandle;
int len;
int i;
OF_CHECK_NBARGS(OF_env, 4);
phandle = popd(OF_env);
namep = (unsigned char *)popd(OF_env);
OF_lds(name, namep);
OF_DPRINTF("phandle 0x%0x prop [%s]\n", phandle, name);
buffer = (unsigned char *)popd(OF_env);
len = popd(OF_env);
node = OF_pack_find(OF_env, phandle);
if (node == NULL) {
pushd(OF_env, -1);
ERROR("Cannot get pack %04x\n", phandle);
return;
}
value = malloc(len);
if (value == NULL && len != 0) {
pushd(OF_env, -1);
ERROR("%s: Cannot alloc property '%s' (%d)\n", __func__, name, len);
return;
}
for (i = 0; i < len; i++)
value[i] = buffer[i];
prop = OF_property_set(OF_env, node, name, value, len);
if (prop == NULL)
len = -1;
pushd(OF_env, len);
}
/* "canon" */
/* Find a device given its path */
__attribute__ (( section (".OpenFirmware") ))
static OF_node_t *OF_get_alias (OF_env_t *OF_env, const unsigned char *name)
{
unsigned char tmp[OF_NAMELEN_MAX], *pos, *st;
const unsigned char *alias, *npos;
OF_node_t *als, *node;
OF_prop_t *prop;
node = NULL;
strcpy(tmp, name);
for (st = tmp; *st == '/'; st++)
continue;
pos = strchr(st, '/');
if (pos == NULL) {
pos = strchr(st, ':');
}
if (pos != NULL) {
*pos = '\0';
npos = name + (pos - tmp);
} else {
npos = "";
}
OF_DPRINTF("Look for alias for '%s' => '%s' '%s'\n", name, tmp, npos);
als = OF_pack_find_by_name(OF_env, OF_node_root, "/aliases");
if (als == NULL) {
ERROR("Cannot get 'aliases'\n");
return NULL;
}
prop = OF_property_get(OF_env, als, tmp);
if (prop == NULL) {
OF_DPRINTF("No %s alias !\n", tmp);
goto out;
}
alias = prop->value;
OF_DPRINTF("Found alias '%s' '%s'\n", alias, npos);
sprintf(tmp, "%s%s", alias, npos);
node = OF_pack_find_by_name(OF_env, OF_node_root, tmp);
if (node == NULL) {
printf("%s alias is a broken link !\n", name);
goto out;
}
OF_node_put(OF_env, node);
out:
OF_node_put(OF_env, als);
return node;
}
__attribute__ (( section (".OpenFirmware") ))
static void OF_finddevice (OF_env_t *OF_env)
{
unsigned char name[OF_NAMELEN_MAX], *namep;
OF_node_t *node;
int ret;
OF_CHECK_NBARGS(OF_env, 1);
namep = (unsigned char *)popd(OF_env);
OF_lds(name, namep);
OF_DPRINTF("name %p [%s]\n", namep, name);
/* Search first in "/aliases" */
node = OF_get_alias(OF_env, name);
if (node == NULL) {
node = OF_pack_find_by_name(OF_env, OF_node_root, name);
}
if (node == NULL)
ret = -1;
else
ret = OF_pack_handle(OF_env, node);
OF_DPRINTF("ret 0x%0x\n", ret);
pushd(OF_env, ret);
}
/* "instance-to-path */
__attribute__ (( section (".OpenFirmware") ))
static void OF_instance_to_path (OF_env_t *OF_env)
{
void *buffer;
OF_inst_t *inst;
uint32_t ihandle;
int len;
OF_CHECK_NBARGS(OF_env, 3);
OF_DPRINTF("\n");
ihandle = popd(OF_env);
buffer = (void *)popd(OF_env);
len = popd(OF_env);
OF_DPRINTF("ihandle: 0x%0x len=%d\n", ihandle, len);
inst = OF_inst_find(OF_env, ihandle);
if (inst == NULL)
len = -1;
else
len = OF_inst_get_path(OF_env, buffer, len, inst) + 1;
OF_DUMP_STRING(OF_env, buffer);
pushd(OF_env, len);
}
/* "package-to-path" */
__attribute__ (( section (".OpenFirmware") ))
static void OF_package_to_path (OF_env_t *OF_env)
{
void *buffer;
OF_node_t *node;
uint32_t phandle;
int len;
OF_CHECK_NBARGS(OF_env, 3);
OF_DPRINTF("\n");
phandle = popd(OF_env);
buffer = (void *)popd(OF_env);
len = popd(OF_env);
node = OF_pack_find(OF_env, phandle);
if (node == NULL)
len = -1;
else
len = OF_pack_get_path(OF_env, buffer, len, node) + 1;
OF_DUMP_STRING(OF_env, buffer);
pushd(OF_env, len);
}
/* Call a package's method */
__attribute__ (( section (".OpenFirmware") ))
static void _OF_callmethod (OF_env_t *OF_env, const unsigned char *name,
uint32_t ihandle, const unsigned char *argp)
{
OF_node_t *node;
OF_inst_t *inst;
OF_method_t *method;
OF_cb_t cb;
inst = OF_inst_find(OF_env, ihandle);
OF_DPRINTF("Attempt to call method [%s] of package instance 0x%0x\n",
name, ihandle);
if (inst == NULL) {
OF_DPRINTF("No instance %0x\n", ihandle);
pushd(OF_env, -1);
return;
}
node = inst->node;
method = OF_method_get(OF_env, node, name);
if (method != NULL) {
cb = method->func;
} else {
if (strcmp(name, "open") == 0) {
cb = &OF_method_fake;
} else {
printf("Method '%s' not found in '%s'\n",
name, node->prop_name->value);
pushd(OF_env, -1);
bug();
return;
}
}
#if 0
OF_DPRINTF("Push instance method %p (%p)...\n", &method->func,
&slw_emit);
#endif
pushf(OF_env, &cb);
if (argp != NULL)
pushd(OF_env, (uint32_t)argp);
else
pushd(OF_env, 0x00000000);
pushd(OF_env, ihandle);
}
__attribute__ (( section (".OpenFirmware") ))
static unsigned char *OF_get_args (unused OF_env_t *env, unsigned char *name)
{
unsigned char *sd;
sd = strchr(name, ':');
if (sd == NULL)
return NULL;
*sd = '\0';
return sd + 1;
}
__attribute__ (( section (".OpenFirmware") ))
static void OF_callmethod (OF_env_t *OF_env)
{
const unsigned char *args;
unsigned char name[OF_NAMELEN_MAX], *namep;
uint32_t ihandle;
OF_DPRINTF("\n\n\n#### CALL METHOD ####\n\n");
namep = (unsigned char *)popd(OF_env);
OF_lds(name, namep);
args = OF_get_args(OF_env, name);
ihandle = popd(OF_env);
_OF_callmethod(OF_env, name, ihandle, args);
}
/* Device IO services */
/* Create a new instance of a device's package */
__attribute__ (( section (".OpenFirmware") ))
static void OF_open (OF_env_t *OF_env)
{
const unsigned char *args;
unsigned char name[OF_NAMELEN_MAX], *namep;
OF_node_t *node;
OF_inst_t *inst;
uint32_t ihandle;
OF_CHECK_NBARGS(OF_env, 1);
namep = (unsigned char *)popd(OF_env);
OF_lds(name, namep);
OF_DPRINTF("package [%s]\n", name);
args = OF_get_args(OF_env, name);
node = OF_get_alias(OF_env, name);
if (node == NULL) {
node = OF_pack_find_by_name(OF_env, OF_node_root, name);
}
if (node == NULL) {
OF_DPRINTF("package not found !\n");
pushd(OF_env, -1);
return;
}
inst = OF_instance_new(OF_env, node);
if (inst == NULL) {
pushd(OF_env, -1);
ERROR("Cannot create package instance\n");
return;
}
ihandle = OF_instance_get_id(OF_env, inst);
/* If an "open" method exists in the package, call it */
OF_DPRINTF("package [%s] => %0x\n", name, ihandle);
OF_node_put(OF_env, node);
_OF_callmethod(OF_env, "open", ihandle, args);
}
/* De-instanciate a package */
__attribute__ (( section (".OpenFirmware") ))
static void OF_close (OF_env_t *OF_env)
{
uint32_t ihandle;
OF_CHECK_NBARGS(OF_env, 1);
ihandle = popd(OF_env);
/* If an "close" method exists in the package, call it */
_OF_callmethod(OF_env, "close", ihandle, NULL);
/* XXX: Should free the instance */
}
/* "read" */
__attribute__ (( section (".OpenFirmware") ))
static void OF_read (OF_env_t *OF_env)
{
uint32_t ihandle;
OF_CHECK_NBARGS(OF_env, 3);
ihandle = popd(OF_env);
OF_DPRINTF("ih: %0x\n", ihandle);
/* If a "read" method exists in the package, call it */
_OF_callmethod(OF_env, "read", ihandle, NULL);
}
/* Try call the "read" method of a device's package */
/* "write" */
__attribute__ (( section (".OpenFirmware") ))
static void OF_write (OF_env_t *OF_env)
{
uint32_t ihandle;
OF_CHECK_NBARGS(OF_env, 3);
ihandle = popd(OF_env);
// OF_DPRINTF("ih: %0x\n", ihandle);
/* If a "write" method exists in the package, call it */
_OF_callmethod(OF_env, "write", ihandle, NULL);
}
/* "seek" */
__attribute__ (( section (".OpenFirmware") ))
static void OF_seek (OF_env_t *OF_env)
{
uint32_t ihandle;
OF_CHECK_NBARGS(OF_env, 3);
ihandle = popd(OF_env);
OF_DPRINTF("ih: %0x\n", ihandle);
/* If a "seek" method exists in the package, call it */
_OF_callmethod(OF_env, "seek", ihandle, NULL);
}
/* Memory services */
/* Claim some memory space */
__attribute__ (( section (".OpenFirmware") ))
uint32_t OF_claim_virt (uint32_t virt, uint32_t size, int *range)
{
int i, keep = -1;
OF_DPRINTF("Claim %d bytes at 0x%0x\n", size, virt);
/* First check that the requested memory stands in the physical memory */
if (OF_mem_ranges[0].start > virt ||
(OF_mem_ranges[0].start + OF_mem_ranges[0].size) < (virt + size)) {
ERROR("not in memory: start 0x%0x virt 0x%0x end 0x%0x 0x%0x\n",
OF_mem_ranges[0].start, virt,
OF_mem_ranges[0].start + OF_mem_ranges[0].size,
virt + size);
return (uint32_t)(-1);
}
/* Now check that it doesn't overlap with already claimed areas */
for (i = 1; i < OF_MAX_MEMRANGES + 1; i++) {
if (OF_mem_ranges[i].start == (uint32_t)(-1) ||
OF_mem_ranges[i].size == (uint32_t)(-1)) {
if (keep == -1)
keep = i;
continue;
}
if (OF_mem_ranges[i].start == virt &&
(OF_mem_ranges[i].start + OF_mem_ranges[i].size) == (virt + size)) {
return virt;
}
if (!((OF_mem_ranges[i].start >= (virt + size) ||
(OF_mem_ranges[i].start + OF_mem_ranges[i].size) <= virt))) {
ERROR("overlap: start 0x%0x virt 0x%0x end 0x%0x 0x%0x\n",
OF_mem_ranges[i].start, virt,
OF_mem_ranges[i].start + OF_mem_ranges[i].size,
virt + size);
/* Aie... */
return (uint32_t)(-1);
}
}
OF_DPRINTF("return range: %d\n", keep);
if (keep == -1) {
/* no more rooms */
ERROR("No more rooms\n");
return (uint32_t)(-1);
} else {
ERROR("Give range: start 0x%0x 0x%0x\n", virt, size);
}
if (range != NULL)
*range = keep;
return virt;
}
/* We always try to get the upper address we can */
__attribute__ (( section (".OpenFirmware") ))
static uint32_t OF_claim_size (uint32_t size, int align, int *range)
{
uint32_t addr, max = (uint32_t)(-1);
int i;
OF_DPRINTF("Try map %d bytes at 0x00000000\n", size);
if (OF_claim_virt(0, size, range) != (uint32_t)(-1))
max = 0;
for (i = 1; i < OF_MAX_MEMRANGES + 1; i++) {
if (OF_mem_ranges[i].start == (uint32_t)(-1) ||
OF_mem_ranges[i].size == (uint32_t)(-1))
continue;
addr = (OF_mem_ranges[i].start + OF_mem_ranges[i].size + align - 1) &
~(align - 1);
OF_DPRINTF("Try map %d bytes at 0x%0x\n", size, addr);
if ((addr + 1) > (max + 1)) {
if (OF_claim_virt(addr, size, range) != (uint32_t)(-1))
max = addr;
}
}
return max;
}
__attribute__ (( section (".OpenFirmware") ))
static void OF_claim (OF_env_t *OF_env)
{
uint32_t virt, size, addr;
int align;
int i, range;
OF_CHECK_NBARGS(OF_env, 3);
virt = popd(OF_env);
size = popd(OF_env);
align = popd(OF_env);
DPRINTF("virt 0x%0x size 0x%0x align %d\n", virt, size, align);
if (align == 0) {
addr = OF_claim_virt(virt, size, &range);
} else {
for (i = 1; i < align; i = i << 1)
continue;
align = i;
size = (size + align - 1) & ~(align - 1);
addr = OF_claim_size(size, align, &range);
}
if (addr == (uint32_t)-1) {
ERROR("No range match !\n");
pushd(OF_env, -1);
}
if (range != -1) {
OF_mem_ranges[range].start = addr;
OF_mem_ranges[range].size = size;
}
OF_DPRINTF("Give address 0x%0x\n", addr);
pushd(OF_env, addr);
}
/* release some previously claimed memory */
__attribute__ (( section (".OpenFirmware") ))
static void OF_release (OF_env_t *OF_env)
{
uint32_t virt, size;
int i;
OF_CHECK_NBARGS(OF_env, 2);
virt = popd(OF_env);
size = popd(OF_env);
OF_DPRINTF("virt 0x%0x size 0x%0x\n", virt, size);
for (i = 0; i < OF_MAX_MEMRANGES; i++) {
if (OF_mem_ranges[i].start == virt && OF_mem_ranges[i].size == size) {
OF_mem_ranges[i].start = (uint32_t)(-1);
OF_mem_ranges[i].size = (uint32_t)(-1);
break;
}
}
}
/* Control transfer services */
/* "boot" */
/* Enter Open-Firmware interpreter */
__attribute__ (( section (".OpenFirmware") ))
static void OF_enter (OF_env_t *OF_env)
{
int n_args;
n_args = stackd_depth(OF_env);
/* means that the bootloader has ended.
* So qemu will...
*/
OF_DPRINTF("%d \n", n_args);
// printf("Bootloader has quitted...\n");
// abort();
}
/* Exit client program */
__attribute__ (( section (".OpenFirmware") ))
static void OF_exit (OF_env_t *OF_env)
{
int n_args;
n_args = stackd_depth(OF_env);
/* means that the bootloader has ended.
* So qemu will...
*/
OF_DPRINTF("%d \n", n_args);
// printf("Bootloader has quitted...\n");
// abort();
}
/* "chain" */
/* User interface services */
/* "interpret" */
__attribute__ (( section (".OpenFirmware") ))
static void OF_interpret (OF_env_t *OF_env)
{
const unsigned char *FString;
void *buf;
OF_inst_t *inst;
OF_node_t *pks, *slw, *chs, *disp;
uint32_t ihandle, crc;
OF_DPRINTF("\n");
// OF_CHECK_NBARGS(OF_env, 1);
FString = (const void *)popd(OF_env);
crc = crc32(0, FString, strlen(FString));
OF_DPRINTF("\n\nOF INTERPRETER CALL:\n [%s]\n crc=%0x\n", FString, crc);
/* Do some hacks to make BootX happy */
switch (crc) {
case 0x225b6748: /* MacOS X 10.2 and OpenDarwin 1.41 */
case 0xb1cd4d25: /* OpenDarwin 6.02 */
/* Create "sl_words" package */
popd(OF_env);
/* Find "/packages" */
pks = OF_pack_find_by_name(OF_env, OF_node_root, "/packages");
if (pks == NULL) {
OF_node_put(OF_env, pks);
pushd(OF_env, -1);
ERROR("Cannot get '/packages'\n");
break;
}
slw = OF_node_new(OF_env, pks, "sl_words", OF_ADDRESS_NONE);
if (slw == NULL) {
OF_node_put(OF_env, pks);
pushd(OF_env, -1);
ERROR("Cannot create 'sl_words'\n");
break;
}
/* Create methods */
OF_method_new(OF_env, slw, "slw_set_output_level",
&slw_set_output_level);
OF_method_new(OF_env, slw, "slw_emit", &slw_emit);
OF_method_new(OF_env, slw, "slw_cr", &slw_cr);
OF_method_new(OF_env, slw, "slw_init_keymap", &slw_init_keymap);
OF_method_new(OF_env, slw, "slw_update_keymap", &slw_update_keymap);
OF_method_new(OF_env, slw, "slw_spin", &slw_spin);
OF_method_new(OF_env, slw, "slw_spin_init", &slw_spin_init);
OF_method_new(OF_env, slw, "slw_pwd", &slw_pwd);
OF_method_new(OF_env, slw, "slw_sum", &slw_sum);
/* Init properties */
OF_prop_int_new(OF_env, slw, "outputLevel", 0);
OF_prop_int_new(OF_env, slw, "keyboardIH", 0);
{
#if 0
OF_node_t *kbd;
kbd = OF_pack_find_by_name(OF_env, OF_node_root, "/keyboard");
if (kbd == NULL) {
OF_node_put(OF_env, pks);
pushd(OF_env, -1);
ERROR("Cannot get '/keyboard'\n");
break;
}
buf = malloc(0x20);
if (buf == NULL) {
OF_node_put(OF_env, pks);
pushd(OF_env, -1);
ERROR("Cannot allocate keyboard buff\n");
break;
}
#else
buf = malloc(0x20);
if (buf == NULL) {
OF_node_put(OF_env, pks);
pushd(OF_env, -1);
ERROR("Cannot allocate keyboard buff\n");
break;
}
memset(buf, 0, 0x20);
OF_property_new(OF_env, slw, "keyMap", buf, 0x20);
#endif
}
OF_prop_int_new(OF_env, slw, "screenIH", 0);
OF_prop_int_new(OF_env, slw, "cursorAddr", 0);
OF_prop_int_new(OF_env, slw, "cursorX", 0);
OF_prop_int_new(OF_env, slw, "cursorY", 0);
OF_prop_int_new(OF_env, slw, "cursorW", 0);
OF_prop_int_new(OF_env, slw, "cursorH", 0);
OF_prop_int_new(OF_env, slw, "cursorFrames", 0);
OF_prop_int_new(OF_env, slw, "cursorPixelSize", 0);
OF_prop_int_new(OF_env, slw, "cursorStage", 0);
OF_prop_int_new(OF_env, slw, "cursorTime", 0);
OF_prop_int_new(OF_env, slw, "cursorDelay", 0);
/* Instanciate sl_words */
inst = OF_instance_new(OF_env, slw);
if (inst == NULL) {
OF_node_put(OF_env, pks);
pushd(OF_env, -1);
ERROR("Cannot create sl_words instance\n");
break;
}
ihandle = OF_instance_get_id(OF_env, inst);
/* Release packages */
OF_node_put(OF_env, slw);
OF_node_put(OF_env, pks);
OF_DPRINTF("sl_words instance: %0x\n", ihandle);
/* Set return value */
if (crc == 0xb1cd4d25) /* Hack for OpenDarwin 6.02 */
pushd(OF_env, ihandle);
pushd(OF_env, ihandle);
pushd(OF_env, 0);
break;
case 0x233441d3: /* MacOS X 10.2 and OpenDarwin 1.41 */
/* Create "memory-map" pseudo device */
{
OF_node_t *map;
uint32_t phandle;
/* Find "/packages" */
chs = OF_pack_find_by_name(OF_env, OF_node_root, "/chosen");
if (chs == NULL) {
pushd(OF_env, -1);
ERROR("Cannot get '/chosen'\n");
break;
}
map = OF_node_new(OF_env, chs, "memory-map", OF_ADDRESS_NONE);
if (map == NULL) {
pushd(OF_env, -1);
ERROR("Cannot create 'memory-map'\n");
break;
}
phandle = OF_pack_handle(OF_env, map);
OF_node_put(OF_env, map);
OF_node_put(OF_env, chs);
pushd(OF_env, phandle);
pushd(OF_env, 0);
}
break;
case 0x32a2d18e: /* MacOS X 10.2 and OpenDarwin 6.02 */
/* Return screen ihandle */
disp = OF_get_alias(OF_env, "screen");
if (disp == NULL) {
pushd(OF_env, 0);
pushd(OF_env, -1);
ERROR("Cannot get 'screen' alias\n");
break;
}
inst = OF_instance_new(OF_env, disp);
if (inst == NULL) {
OF_node_put(OF_env, disp);
pushd(OF_env, 0);
pushd(OF_env, -1);
ERROR("Cannot create 'screen' instance\n");
break;
}
ihandle = OF_instance_get_id(OF_env, inst);
OF_node_put(OF_env, disp);
OF_DPRINTF("Return screen ihandle: %0x\n", ihandle);
pushd(OF_env, ihandle);
pushd(OF_env, 0);
break;
case 0xF3A9841F: /* MacOS X 10.2 */
case 0x76fbdf18: /* OpenDarwin 6.02 */
/* Set current display as active package */
disp = OF_get_alias (OF_env, "screen");
if (disp == NULL) {
pushd(OF_env, 0);
pushd(OF_env, -1);
}
OF_node_put(OF_env, disp);
break;
case 0x1c3bc93f: /* MacOS X 10.3 */
/* get-package-property if 0 0 then */
OF_getprop(OF_env);
{
uint32_t len;
len = popd(OF_env);
if (len == (uint32_t)-1)
len = 0;
pushd(OF_env, len);
}
break;
case 0x218d5ccb: /* yaboot */
case 0x27b32255:
case 0x05d332ef:
case 0xc7b5d3b5:
/* skip it */
break;
case 0xf541a878:
case 0x6a9b2be6:
/* Yaboot: set background color to black */
break;
case 0x846077fb:
case 0x299c2c5d: /* gentoo */
/* Yaboot: set foreground color to grey */
break;
case 0x4ad41f2d:
/* Yaboot: wait 10 ms: sure ! */
break;
default:
/* ERROR */
printf("Script: len=%d\n%s\n", (int)strlen(FString), FString);
printf("Call %0x NOT IMPLEMENTED !\n", crc);
bug();
break;
}
OF_DPRINTF("\n\nOF INTERPRETER CALL DONE\n\n");
}
/* "set-callback" */
/* "set-symbol-lookup" */
/* Time services */
/* "milliseconds" */
__attribute__ (( section (".OpenFirmware") ))
static void OF_milliseconds (OF_env_t *OF_env)
{
#if 0
struct timeval tv;
OF_DPRINTF("\n");
OF_CHECK_NBARGS(OF_env, 0);
gettimeofday(&tv, NULL);
pushd(OF_env, (tv.tv_sec * 1000) + (tv.tv_usec / 1000));
#else
static uint32_t ms = 0;
OF_CHECK_NBARGS(OF_env, 0);
pushd(OF_env, ms);
usleep(10000); /* XXX: TOFIX: Random sleep */
ms += 10;
#endif
}
/* Undocumented in IEEE 1275 */
__attribute__ (( section (".OpenFirmware") ))
static void OF_quiesce (OF_env_t *OF_env)
{
OF_CHECK_NBARGS(OF_env, 0);
/* Should free all OF resources */
bd_reset_all();
#if defined (DEBUG_BIOS)
{
uint16_t loglevel = 0x02 | 0x10 | 0x80;
// outw(0xFF02, loglevel);
outb(0x0F02, loglevel);
}
#endif
}
typedef struct OF_service_t OF_service_t;
struct OF_service_t {
const unsigned char *name;
OF_cb_t cb;
};
static OF_service_t services[] = {
{ "test", &OF_test, },
{ "peer", &OF_peer, },
{ "child", &OF_child, },
{ "parent", &OF_parent, },
{ "instance-to-package", &OF_instance_to_package, },
{ "getproplen", &OF_getproplen, },
{ "getprop", &OF_getprop, },
{ "nextprop", &OF_nextprop, },
{ "setprop", &OF_setprop, },
{ "finddevice", &OF_finddevice, },
{ "instance-to-path", &OF_instance_to_path, },
{ "package-to-path", &OF_package_to_path, },
{ "call-method", &OF_callmethod, },
{ "open", &OF_open, },
{ "open-package", &OF_open, },
{ "close", &OF_close, },
{ "read", &OF_read, },
{ "write", &OF_write, },
{ "seek", &OF_seek, },
{ "claim", &OF_claim, },
{ "release", &OF_release, },
{ "enter", &OF_enter, },
{ "exit", &OF_exit, },
{ "interpret", &OF_interpret, },
{ "milliseconds", &OF_milliseconds, },
{ "quiesce", &OF_quiesce, },
};
/* Probe if a named service exists */
__attribute__ (( section (".OpenFirmware") ))
static void OF_test (OF_env_t *OF_env)
{
unsigned char name[OF_NAMELEN_MAX], *namep;
uint32_t i;
int ret = -1;
OF_CHECK_NBARGS(OF_env, 1);
namep = (unsigned char *)popd(OF_env);
OF_lds(name, namep);
OF_DPRINTF("service [%s]\n", name);
for (i = 0; i < (sizeof(services) / sizeof(OF_service_t)); i++) {
if (strcmp(services[i].name, name) == 0) {
ret = 0;
break;
}
}
pushd(OF_env, ret);
}
/* Main entry point for PPC clients */
__attribute__ (( section (".OpenFirmware") ))
int OF_client_entry (void *p)
{
unsigned char buffer[OF_NAMELEN_MAX];
OF_env_t OF_env;
OF_cb_t cb;
unsigned char *namep;
uint32_t i;
/* set our environment */
MMU_off();
OF_DPRINTF("Called with arg: %p\n", p);
/* Load function name string */
namep = (unsigned char *)(*(uint32_t *)p);
OF_lds(buffer, namep);
/* Find callback */
cb = NULL;
OF_DPRINTF("Look for service [%s]\n", buffer);
for (i = 0; i < (sizeof(services) / sizeof(OF_service_t)); i++) {
if (strcmp(services[i].name, buffer) == 0) {
cb = services[i].cb;
break;
}
}
if (cb == NULL) {
OF_DPRINTF("service [%s] not implemented\n", buffer);
// bug();
return -1;
}
#if 0
OF_DPRINTF("Service [%s] found\n", buffer);
#endif
/* Set up stack *NON REENTRANT* */
OF_env_init(&OF_env);
/* Launch Forth glue */
C_to_Forth(&OF_env, (uint32_t *)p + 1, &cb);
OF_DPRINTF("done\n");
MMU_on();
return 0;
}
/*****************************************************************************/
/* Run-time abstraction services */
/* RTAS RAM is organised this way:
* RTAS_memory is given by the OS when instanciating RTAS.
* it's an 32 kB area divided in 2 zones:
* Up is a stack, used to call RTAS services
* Down is the variables area.
*/
__attribute__ (( section (".RTAS_vars") ))
static OF_cb_t *RTAS_callbacks[32];
#if 0
__attribute__ (( section (".RTAS_vars") ))
static uint8_t *RTAS_base;
#endif
/* RTAS is called in real mode (ie no MMU), privileged with all exceptions
* disabled. It has to preserve all registers except R3 to R12.
* The OS should ensure it's not re-entered.
*/
__attribute__ (( section (".RTAS") ))
int RTAS_entry (void *p)
{
OF_env_t RTAS_env;
uint32_t token;
OF_DPRINTF("Called with arg: %p\n", p);
/* set our environment */
token = *(uint32_t *)p;
/* Set up stack */
RTAS_env.stackb = (uint32_t *)(RTAS_memory + 0x8000 - 4);
RTAS_env.stackp = RTAS_env.stackb;
RTAS_env.funcb = (uint32_t *)(RTAS_memory + 0x8000 - OF_STACK_SIZE - 4);
RTAS_env.funcp = RTAS_env.funcb;
/* Call Forth glue */
C_to_Forth(&RTAS_env, (uint32_t *)p + 1, RTAS_callbacks[token & 0x3F]);
OF_DPRINTF("done\n");
return 0;
}
__attribute__ (( section (".RTAS") ))
static void RTAS_restart_rtas (OF_env_t *RTAS_env)
{
OF_DPRINTF("\n");
OF_CHECK_NBARGS(RTAS_env, 0);
/* No implementation: return error */
pushd(RTAS_env, -1);
}
__attribute__ (( section (".RTAS") ))
static void RTAS_nvram_fetch (OF_env_t *RTAS_env)
{
uint8_t *buffer;
int offset, length;
int i;
OF_DPRINTF("\n");
OF_CHECK_NBARGS(RTAS_env, 3);
offset = popd(RTAS_env);
buffer = (uint8_t *)popd(RTAS_env);
length = popd(RTAS_env);
for (i = 0; i < length; i++) {
if ((i + offset) >= NVRAM_get_size(nvram)) {
pushd(RTAS_env, -3);
return;
}
*buffer++ = NVRAM_read(nvram, i + offset);
}
pushd(RTAS_env, length);
}
__attribute__ (( section (".RTAS") ))
static void RTAS_nvram_store (OF_env_t *RTAS_env)
{
uint8_t *buffer;
int offset, length;
int i;
OF_DPRINTF("\n");
OF_CHECK_NBARGS(RTAS_env, 3);
offset = popd(RTAS_env);
buffer = (uint8_t *)popd(RTAS_env);
length = popd(RTAS_env);
for (i = 0; i < length; i++) {
if ((i + offset) >= NVRAM_get_size(nvram)) {
pushd(RTAS_env, -3);
return;
}
NVRAM_write(nvram, i + offset, *buffer++);
}
pushd(RTAS_env, length);
}
__attribute__ (( section (".RTAS") ))
static void RTAS_get_time_of_day (OF_env_t *RTAS_env)
{
#if 0
struct tm tm;
time_t t;
OF_DPRINTF("\n");
OF_CHECK_NBARGS(RTAS_env, 0);
t = get_time();
localtime_r(&t, &tm);
pushd(RTAS_env, 0); /* nanoseconds */
pushd(RTAS_env, tm.tm_sec);
pushd(RTAS_env, tm.tm_min);
pushd(RTAS_env, tm.tm_hour);
pushd(RTAS_env, tm.tm_mday);
pushd(RTAS_env, tm.tm_mon);
pushd(RTAS_env, tm.tm_year);
pushd(RTAS_env, 0); /* status */
#else
pushd(RTAS_env, 0);
pushd(RTAS_env, 0);
pushd(RTAS_env, 0);
pushd(RTAS_env, 0);
pushd(RTAS_env, 0);
pushd(RTAS_env, 0);
pushd(RTAS_env, 0);
pushd(RTAS_env, 0);
#endif
}
__attribute__ (( section (".RTAS") ))
static void RTAS_set_time_of_day (OF_env_t *RTAS_env)
{
#if 0
struct tm tm;
time_t t;
OF_DPRINTF("\n");
OF_CHECK_NBARGS(RTAS_env, 7);
tm.tm_year = popd(RTAS_env);
tm.tm_mon = popd(RTAS_env);
tm.tm_mday = popd(RTAS_env);
tm.tm_hour = popd(RTAS_env);
tm.tm_min = popd(RTAS_env);
tm.tm_sec = popd(RTAS_env);
popd(RTAS_env); /* nanoseconds */
t = mktime(&tm);
set_time_offset(t);
#endif
pushd(RTAS_env, 0); /* status */
}
__attribute__ (( section (".RTAS") ))
static void RTAS_set_time_for_power_on (OF_env_t *RTAS_env)
{
OF_DPRINTF("\n");
OF_CHECK_NBARGS(RTAS_env, 7);
/* Do nothing */
pushd(RTAS_env, 0); /* status */
}
__attribute__ (( section (".RTAS") ))
static void RTAS_event_scan (OF_env_t *RTAS_env)
{
OF_DPRINTF("\n");
OF_CHECK_NBARGS(RTAS_env, 4);
/* Pretend there are no new events */
pushd(RTAS_env, 1);
}
__attribute__ (( section (".RTAS") ))
static void RTAS_check_exception (OF_env_t *RTAS_env)
{
OF_DPRINTF("\n");
OF_CHECK_NBARGS(RTAS_env, 6);
/* Pretend we found no exceptions */
pushd(RTAS_env, 1);
}
__attribute__ (( section (".RTAS") ))
static void RTAS_read_pci_config (OF_env_t *RTAS_env)
{
OF_DPRINTF("\n");
OF_CHECK_NBARGS(RTAS_env, 2);
/* Hardware error */
pushd(RTAS_env, -1);
}
__attribute__ (( section (".RTAS") ))
static void RTAS_write_pci_config (OF_env_t *RTAS_env)
{
OF_DPRINTF("\n");
OF_CHECK_NBARGS(RTAS_env, 3);
/* Hardware error */
pushd(RTAS_env, -1);
}
__attribute__ (( section (".RTAS") ))
static void RTAS_display_character (OF_env_t *RTAS_env)
{
int c;
OF_DPRINTF("\n");
OF_CHECK_NBARGS(RTAS_env, 1);
c = popd(RTAS_env);
#if 0
printf("%c", c);
#else
outb(0x0F00, c);
#endif
pushd(RTAS_env, 0);
}
__attribute__ (( section (".RTAS") ))
static void RTAS_set_indicator (OF_env_t *RTAS_env)
{
const unsigned char *name;
int indic, state;
OF_DPRINTF("\n");
OF_CHECK_NBARGS(RTAS_env, 3);
indic = popd(RTAS_env);
state = popd(RTAS_env);
switch (indic) {
case 1:
name = "tone frequency";
break;
case 2:
name = "tone volume";
break;
case 3:
name = "system power state";
break;
case 4:
name = "warning light";
break;
case 5:
name = "disk activity light";
break;
case 6:
name = "hexadecimal display unit";
break;
case 7:
name = "batery warning time";
break;
case 8:
name = "condition cycle request";
break;
case 9000 ... 9999:
name = "vendor specific";
break;
default:
pushd(RTAS_env, -3);
return;
}
OF_DPRINTF("Set indicator %d [%s] to %d\n", indic, name, state);
pushd(RTAS_env, 0);
}
__attribute__ (( section (".RTAS") ))
static void RTAS_get_sensor_state (OF_env_t *RTAS_env)
{
const unsigned char *name;
int type, index;
int state;
OF_DPRINTF("\n");
OF_CHECK_NBARGS(RTAS_env, 2);
type = popd(RTAS_env);
index = popd(RTAS_env);
switch (index) {
case 1:
name = "key switch";
state = 1; /* Normal */
break;
case 2:
name = "enclosure switch";
state = 0; /* Closed */
break;
case 3:
name = "thermal sensor";
state = 40; /* in degrees Celsius (not too hot !) */
break;
case 4:
name = "lid status";
state = 1; /* Open */
break;
case 5:
name = "power source";
state = 0; /* AC */
break;
case 6:
name = "battery voltage";
state = 6; /* Let's have a moderated answer :-) */
break;
case 7:
name = "battery capacity remaining";
state = 3; /* High */
break;
case 8:
name = "battery capacity percentage";
state = 1000; /* 100 % */
break;
case 9:
name = "EPOW sensor";
state = 5; /* ? */
break;
case 10:
name = "battery condition cycle state";
state = 0; /* none */
break;
case 11:
name = "battery charge state";
state = 2; /* No current flow */
break;
case 9000 ... 9999:
name = "vendor specific";
state = 0;
break;
default:
pushd(RTAS_env, -3);
return;
}
OF_DPRINTF("Pretend sensor %d [%s] is in state %d\n", index, name, state);
pushd(RTAS_env, state);
pushd(RTAS_env, 0);
}
#if 0 // No power management */
__attribute__ (( section (".RTAS") ))
static void RTAS_set_power_level (OF_env_t *RTAS_env)
{
OF_DPRINTF("\n");
}
__attribute__ (( section (".RTAS") ))
static void RTAS_get_power_level (OF_env_t *RTAS_env)
{
OF_DPRINTF("\n");
}
__attribute__ (( section (".RTAS") ))
static void RTAS_assume_power_management (OF_env_t *RTAS_env)
{
OF_DPRINTF("\n");
}
__attribute__ (( section (".RTAS") ))
static void RTAS_relinquish_power_management (OF_env_t *RTAS_env)
{
OF_DPRINTF("\n");
}
#endif
__attribute__ (( section (".RTAS") ))
static void RTAS_power_off (OF_env_t *RTAS_env)
{
printf("RTAS was asked to switch off\n");
OF_CHECK_NBARGS(RTAS_env, 2);
// abort();
}
__attribute__ (( section (".RTAS") ))
static void RTAS_suspend (OF_env_t *RTAS_env)
{
OF_DPRINTF("\n");
OF_CHECK_NBARGS(RTAS_env, 3);
/* Pretend we don't succeed */
pushd(RTAS_env, -1);
}
__attribute__ (( section (".RTAS") ))
static void RTAS_hibernate (OF_env_t *RTAS_env)
{
OF_DPRINTF("\n");
OF_CHECK_NBARGS(RTAS_env, 3);
/* Pretend we don't succeed */
pushd(RTAS_env, -1);
}
__attribute__ (( section (".RTAS") ))
static void RTAS_system_reboot (OF_env_t *RTAS_env)
{
printf("RTAS was asked to reboot\n");
OF_CHECK_NBARGS(RTAS_env, 0);
// abort();
}
#if 0 // No power management nor SMP */
__attribute__ (( section (".RTAS") ))
static void RTAS_cache_control (OF_env_t *RTAS_env)
{
OF_DPRINTF("\n");
}
__attribute__ (( section (".RTAS") ))
static void RTAS_freeze_time_base (OF_env_t *RTAS_env)
{
OF_DPRINTF("\n");
}
__attribute__ (( section (".RTAS") ))
static void RTAS_thaw_time_base (OF_env_t *RTAS_env)
{
OF_DPRINTF("\n");
}
__attribute__ (( section (".RTAS") ))
static void RTAS_stop_self (OF_env_t *RTAS_env)
{
OF_DPRINTF("\n");
}
__attribute__ (( section (".RTAS") ))
static void RTAS_start_cpu (OF_env_t *RTAS_env)
{
OF_DPRINTF("\n");
}
#endif
__attribute__ (( section (".RTAS") ))
static void RTAS_instantiate (OF_env_t *RTAS_env)
{
const unsigned char *args;
uint32_t ihandle;
uint32_t base_address;
OF_DPRINTF("\n");
OF_CHECK_NBARGS(RTAS_env, 3);
ihandle = popd(RTAS_env);
args = (void *)popd(RTAS_env);
base_address = popd(RTAS_env);
memmove((void *)base_address, (void *)(&_RTAS_start),
(char *)(&_RTAS_data_end) - (char *)(&_RTAS_start));
OF_DPRINTF("base_address=0x%0x\n", base_address);
pushd(RTAS_env, base_address);
pushd(RTAS_env, 0);
}
__attribute__ (( section (".RTAS") ))
static void RTAS_new_cb (OF_env_t *env, OF_node_t *rtas,
const unsigned char *name,
OF_cb_t cb, uint32_t *token_next)
{
OF_prop_int_new(env, rtas, name, 0xabcd0000 | *token_next);
RTAS_callbacks[*token_next] = &cb;
(*token_next)++;
}
__attribute__ (( section (".RTAS") ))
void RTAS_init (void)
{
OF_env_t *RTAS_env;
OF_node_t *rtas, *chs;
OF_prop_t *stdout;
uint32_t token_next = 0, size;
RTAS_env = OF_env_main;
rtas = OF_node_new(RTAS_env, OF_node_root, "rtas", OF_ADDRESS_NONE);
if (rtas == NULL) {
ERROR("RTAS not found\n");
return;
}
size = ((char *)(&_RTAS_data_end) - (char *)(&_RTAS_start) + 0x0000FFFF) &
~0x0000FFFF;
OF_DPRINTF("RTAS size: %d bytes (%d)\n", size,
(char *)(&_RTAS_data_end) - (char *)(&_RTAS_start));
OF_prop_int_new(RTAS_env, rtas, "rtas-size", size);
OF_prop_int_new(RTAS_env, rtas, "rtas-version", 1);
OF_prop_int_new(RTAS_env, rtas, "rtas-event-scan-rate", 0);
OF_prop_int_new(RTAS_env, rtas, "rtas-error-log-max", 0);
chs = OF_node_get(RTAS_env, "chosen");
if (chs == NULL) {
ERROR("choosen not found\n");
return;
}
stdout = OF_property_get(RTAS_env, chs, "stdout");
if (stdout == NULL) {
OF_node_put(RTAS_env, chs);
ERROR("stdout not found\n");
return;
}
OF_prop_int_new(RTAS_env, rtas, "rtas-display-device",
*(uint32_t *)stdout->value);
/* RTAS tokens */
RTAS_new_cb(RTAS_env, rtas, "restart_rtas",
&RTAS_restart_rtas, &token_next);
RTAS_new_cb(RTAS_env, rtas, "nvram_fetch",
&RTAS_nvram_fetch, &token_next);
RTAS_new_cb(RTAS_env, rtas, "nvram_store",
&RTAS_nvram_store, &token_next);
RTAS_new_cb(RTAS_env, rtas, "get-time-of_day",
&RTAS_get_time_of_day, &token_next);
RTAS_new_cb(RTAS_env, rtas, "set-time-of-day",
&RTAS_set_time_of_day, &token_next);
RTAS_new_cb(RTAS_env, rtas, "set-time-for-power-on",
&RTAS_set_time_for_power_on, &token_next);
RTAS_new_cb(RTAS_env, rtas, "event-scan", &RTAS_event_scan, &token_next);
RTAS_new_cb(RTAS_env, rtas, "check-exception",
&RTAS_check_exception, &token_next);
RTAS_new_cb(RTAS_env, rtas, "read-pci-config",
&RTAS_read_pci_config, &token_next);
RTAS_new_cb(RTAS_env, rtas, "write-pci-config",
&RTAS_write_pci_config, &token_next);
RTAS_new_cb(RTAS_env, rtas, "display-character",
&RTAS_display_character, &token_next);
RTAS_new_cb(RTAS_env, rtas, "set-indicator",
&RTAS_set_indicator, &token_next);
RTAS_new_cb(RTAS_env, rtas, "get-sensor-state",
&RTAS_get_sensor_state, &token_next);
#if 0 // No power management */
RTAS_new_cb(RTAS_env, rtas, "set-power-level",
&RTAS_set_power_level, &token_next);
RTAS_new_cb(RTAS_env, rtas, "get-power-level",
&RTAS_get_power_level, &token_next);
RTAS_new_cb(RTAS_env, rtas, "assume-power-management",
&RTAS_assume_power_management, &token_next);
RTAS_new_cb(RTAS_env, rtas, "relinquish-power-management",
&RTAS_relinquish_power_management, &token_next);
#endif
RTAS_new_cb(RTAS_env, rtas, "power-off", &RTAS_power_off, &token_next);
RTAS_new_cb(RTAS_env, rtas, "suspend", &RTAS_suspend, &token_next);
RTAS_new_cb(RTAS_env, rtas, "hibernate", &RTAS_hibernate, &token_next);
RTAS_new_cb(RTAS_env, rtas, "system-reboot",
&RTAS_system_reboot, &token_next);
#if 0 // No power management nor SMP */
RTAS_new_cb(RTAS_env, rtas, "cache-control",
&RTAS_cache_control, &token_next);
RTAS_new_cb(RTAS_env, rtas, "freeze_time_base",
&RTAS_freeze_time_base, &token_next);
RTAS_new_cb(RTAS_env, rtas, "thaw_time_base",
&RTAS_thaw_time_base, &token_next);
RTAS_new_cb(RTAS_env, rtas, "stop-self", &RTAS_stop_self, &token_next);
RTAS_new_cb(RTAS_env, rtas, "start-cpu", &RTAS_start_cpu, &token_next);
#endif
/* missing
* "update-flash"
* "update-flash-and-reboot"
* "query-cpu-stopped-state" for SMP
*/
OF_method_new(RTAS_env, rtas, "instantiate-rtas", &RTAS_instantiate);
OF_node_put(RTAS_env, rtas);
OF_node_new(RTAS_env, OF_node_root, "nomore", OF_ADDRESS_NONE);
DPRINTF("RTAS done\n");
}
/*****************************************************************************/
/* That's all for now... */
/*****************************************************************************/