static inline unsigned int
__interrupt_keysize(struct dt_node_base* base)
{
- return base->addr_c + base->intr_c;
+ return dt_size_cells(base) + base->intr_c;
}
static void
}
void
-resolve_interrupt_map(struct dt_node* node)
+dt_resolve_interrupt_map(struct dt_node* node)
{
struct dt_intr_node* inode;
struct dt_intr_map* imap;
}
struct dt_prop_val*
-resolve_interrupt(struct dt_node* node)
+dt_resolve_interrupt(struct dt_node* node)
{
struct dt_node_base* nexus;
struct dt_intr_node* i_nexus, *i_node;
return &i_node->intr.arr;
}
- keylen = nexus->addr_c + nexus->intr_c;
+ keylen = __interrupt_keysize(nexus);
key = (struct dt_intr_mapkey) {
.val = valloc(keylen * sizeof(int)),
.size = keylen
};
memcpy( key.val,
- node->reg.encoded, nexus->addr_c * sizeof(int));
+ node->reg.encoded, dt_addr_cells(nexus) * sizeof(int));
- memcpy(&key.val[nexus->addr_c],
+ memcpy(&key.val[dt_addr_cells(nexus)],
i_node->intr.arr.encoded, nexus->intr_c * sizeof(int));
__mask_key(&key, &i_nexus->map->key_mask);
{
return &pos->parent_props;
}
- }
+ }
+
+ __destory_key(&key);
}
bool
bool dma_ncoherent : 1;
bool intr_controll : 1;
bool intr_neuxs : 1;
- unsigned int other : 29;
};
unsigned int flags;
};
node_predicate_t pred;
};
-#define dtnode_child_foreach(node_base, pos, n) \
- llist_for_each(pos, n, &(node_base)->children, siblings)
+
+
+/****
+ * FDT Related
+ ****/
#define fdt_prop(tok) ((tok)->token == FDT_PROP)
#define fdt_node(tok) ((tok)->token == FDT_NOD_BEGIN)
void
fdt_memrsvd_itend(struct fdt_memrsvd_iter* rsvdi);
+static inline char*
+fdtit_prop_key(struct fdt_iter* fdti)
+{
+ return &fdti->str_block[fdti->prop->nameoff];
+}
+
+
+/****
+ * DT Main Functions: General
+ ****/
bool
dt_load(ptr_t dtb_dropoff);
struct dt_prop_val*
dt_getprop(struct dt_node_base* base, const char* name);
+struct dt_prop_val*
+dt_resolve_interrupt(struct dt_node* node);
+
+void
+dt_resolve_interrupt_map(struct dt_node* node);
+
+static inline unsigned int
+dt_addr_cells(struct dt_node_base* base)
+{
+ return base->parent ? base->parent->addr_c : base->addr_c;
+}
+
+static inline unsigned int
+dt_size_cells(struct dt_node_base* base)
+{
+ return base->parent ? base->parent->sz_c : base->sz_c;
+}
+
+
+/****
+ * DT Main Functions: Node-finder
+ ****/
+
void
dt_begin_find_byname(struct dt_node_iter* iter,
struct dt_node* node, const char* name);
dt_begin_find(struct dt_node_iter* iter, struct dt_node* node,
node_predicate_t pred, void* closure);
-struct dt_prop_val*
-resolve_interrupt(struct dt_node* node);
-
-void
-resolve_interrupt_map(struct dt_node* node);
-
static inline void
dt_end_find(struct dt_node_iter* iter)
{
}
+/****
+ * DT Main Functions: Node-binding
+ ****/
+
static inline void
dt_bind_object(struct dt_node_base* base, void* obj)
{
#define dt_binding_of(node_base, type) \
((type)(node_base)->obj)
-static inline char*
-fdtit_prop_key(struct fdt_iter* fdti)
-{
- return &fdti->str_block[fdti->prop->nameoff];
-}
+
+/****
+ * DT Main Functions: Prop decoders
+ ****/
static inline void
dt_decode(struct dt_prop_iter* dtpi, struct dt_node_base* node,
#define dt_decode_reg(dtpi, node, field) \
dt_decode(dtpi, &(node)->base, &(node)->field, \
- (node)->base.sz_c + (node)->base.addr_c);
+ dt_size_cells(&(node)->base) \
+ + dt_addr_cells(&(node)->base))
#define dt_decode_range(dtpi, node, field) \
dt_decode(dtpi, &(node)->base, &(node)->field, \
- (node)->base.sz_c * 2 + (node)->base.addr_c);
+ dt_size_cells(&(node)->base) * 2 \
+ + dt_addr_cells(&(node)->base))
+
+#define dt_decode_simple(dtpi, prop) \
+ dt_decode(dtpi, NULL, prop, 1);
#define dtprop_off(dtpi) \
(unsigned int)(\
ptr_t t;
t = (ptr_t)dtprop_to_u64(dtprop_reg_addr(dtpi));
- dtprop_next(dtpi);
+ dtprop_next_n(dtpi, dt_addr_cells(dtpi->node));
return t;
}
size_t t;
t = (size_t)dtprop_to_u64(dtprop_reg_len(dtpi));
- dtprop_next(dtpi);
+ dtprop_next_n(dtpi, dt_size_cells(dtpi->node));
return t;
}
static inline dt_enc_t
dtprop_range_parentbus(struct dt_prop_iter* dtpi)
{
- return dtprop_extract(dtpi, dtpi->node->addr_c);
+ return dtprop_extract(dtpi, dt_addr_cells(dtpi->node));
}
static inline dt_enc_t
dtprop_range_len(struct dt_prop_iter* dtpi)
{
- return dtprop_extract(dtpi, dtpi->node->addr_c * 2);
+ return dtprop_extract(dtpi, dt_addr_cells(dtpi->node) * 2);
}
#endif /* __LUNAIX_DEVTREE_H */