--- /dev/null
+/* 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... */
+/*****************************************************************************/
Code Review / kvmfornfv.git / blobdiff