* [Qemu-devel] [RFC v0 01/10] device_tree: allow offsets for cell properties
2012-09-17 9:02 [Qemu-devel] [RFC v0 00/10] Microblaze generic FDT framework Peter A. G. Crosthwaite
@ 2012-09-17 9:02 ` Peter A. G. Crosthwaite
2012-09-17 9:02 ` [Qemu-devel] [RFC v0 02/10] device_tree: return Error* from prop getters Peter A. G. Crosthwaite
` (8 subsequent siblings)
9 siblings, 0 replies; 16+ messages in thread
From: Peter A. G. Crosthwaite @ 2012-09-17 9:02 UTC (permalink / raw)
To: qemu-devel, edgar.iglesias; +Cc: peter.crosthwaite, crwulff
Signed-off-by: Peter A. G. Crosthwaite <peter.crosthwaite@petalogix.com>
---
device_tree.c | 10 +++++-----
device_tree.h | 2 +-
hw/arm_boot.c | 4 ++--
3 files changed, 8 insertions(+), 8 deletions(-)
diff --git a/device_tree.c b/device_tree.c
index d7a9b6b..92a383e 100644
--- a/device_tree.c
+++ b/device_tree.c
@@ -196,16 +196,16 @@ const void *qemu_devtree_getprop(void *fdt, const char *node_path,
}
uint32_t qemu_devtree_getprop_cell(void *fdt, const char *node_path,
- const char *property)
+ const char *property, int offset)
{
int len;
const uint32_t *p = qemu_devtree_getprop(fdt, node_path, property, &len);
- if (len != 4) {
- fprintf(stderr, "%s: %s/%s not 4 bytes long (not a cell?)\n",
- __func__, node_path, property);
+ if (len < (offset+1)*4) {
+ fprintf(stderr, "%s: %s/%s not long enough to hold %d properties\n",
+ __func__, node_path, property, offset+1);
exit(1);
}
- return be32_to_cpu(*p);
+ return be32_to_cpu(p[offset]);
}
uint32_t qemu_devtree_get_phandle(void *fdt, const char *path)
diff --git a/device_tree.h b/device_tree.h
index f7a3e6c..759e142 100644
--- a/device_tree.h
+++ b/device_tree.h
@@ -31,7 +31,7 @@ int qemu_devtree_setprop_phandle(void *fdt, const char *node_path,
const void *qemu_devtree_getprop(void *fdt, const char *node_path,
const char *property, int *lenp);
uint32_t qemu_devtree_getprop_cell(void *fdt, const char *node_path,
- const char *property);
+ const char *property, int offset);
uint32_t qemu_devtree_get_phandle(void *fdt, const char *path);
uint32_t qemu_devtree_alloc_phandle(void *fdt);
int qemu_devtree_nop_node(void *fdt, const char *node_path);
diff --git a/hw/arm_boot.c b/hw/arm_boot.c
index a6e9143..051aee6 100644
--- a/hw/arm_boot.c
+++ b/hw/arm_boot.c
@@ -237,8 +237,8 @@ static int load_dtb(target_phys_addr_t addr, const struct arm_boot_info *binfo)
}
g_free(filename);
- acells = qemu_devtree_getprop_cell(fdt, "/", "#address-cells");
- scells = qemu_devtree_getprop_cell(fdt, "/", "#size-cells");
+ acells = qemu_devtree_getprop_cell(fdt, "/", "#address-cells", 0);
+ scells = qemu_devtree_getprop_cell(fdt, "/", "#size-cells", 0);
if (acells == 0 || scells == 0) {
fprintf(stderr, "dtb file invalid (#address-cells or #size-cells 0)\n");
return -1;
--
1.7.0.4
^ permalink raw reply related [flat|nested] 16+ messages in thread* [Qemu-devel] [RFC v0 02/10] device_tree: return Error* from prop getters
2012-09-17 9:02 [Qemu-devel] [RFC v0 00/10] Microblaze generic FDT framework Peter A. G. Crosthwaite
2012-09-17 9:02 ` [Qemu-devel] [RFC v0 01/10] device_tree: allow offsets for cell properties Peter A. G. Crosthwaite
@ 2012-09-17 9:02 ` Peter A. G. Crosthwaite
2012-09-17 9:02 ` [Qemu-devel] [RFC v0 03/10] device_tree: allow property getters to inherit Peter A. G. Crosthwaite
` (7 subsequent siblings)
9 siblings, 0 replies; 16+ messages in thread
From: Peter A. G. Crosthwaite @ 2012-09-17 9:02 UTC (permalink / raw)
To: qemu-devel, edgar.iglesias; +Cc: peter.crosthwaite, crwulff
Rather than exit(1) on fail return an Error*. Clients can then handle errors as
they wish.
Signed-off-by: Peter A. G. Crosthwaite <peter.crosthwaite@petalogix.com>
---
device_tree.c | 25 ++++++++++++++++++-------
device_tree.h | 9 +++++++--
hw/arm_boot.c | 8 ++++++--
3 files changed, 31 insertions(+), 11 deletions(-)
diff --git a/device_tree.c b/device_tree.c
index 92a383e..3792085 100644
--- a/device_tree.c
+++ b/device_tree.c
@@ -179,7 +179,8 @@ int qemu_devtree_setprop_string(void *fdt, const char *node_path,
}
const void *qemu_devtree_getprop(void *fdt, const char *node_path,
- const char *property, int *lenp)
+ const char *property, int *lenp,
+ Error **errp)
{
int len;
const void *r;
@@ -190,20 +191,30 @@ const void *qemu_devtree_getprop(void *fdt, const char *node_path,
if (!r) {
fprintf(stderr, "%s: Couldn't get %s/%s: %s\n", __func__,
node_path, property, fdt_strerror(*lenp));
- exit(1);
+ /* FIXME: Be smarter */
+ error_set(errp, QERR_UNDEFINED_ERROR);
+ return NULL;
}
return r;
}
uint32_t qemu_devtree_getprop_cell(void *fdt, const char *node_path,
- const char *property, int offset)
+ const char *property, int offset,
+ Error **errp)
{
int len;
- const uint32_t *p = qemu_devtree_getprop(fdt, node_path, property, &len);
+ const uint32_t *p = qemu_devtree_getprop(fdt, node_path, property, &len,
+ errp);
+ if (errp && *errp) {
+ return 0;
+ }
if (len < (offset+1)*4) {
- fprintf(stderr, "%s: %s/%s not long enough to hold %d properties\n",
- __func__, node_path, property, offset+1);
- exit(1);
+ fprintf(stderr, "%s: %s/%s not long enough to hold %d properties "
+ "(length = %d)\n", __func__, node_path, property,
+ offset+1, len);
+ /* FIXME: Be smarter */
+ error_set(errp, QERR_UNDEFINED_ERROR);
+ return 0;
}
return be32_to_cpu(p[offset]);
}
diff --git a/device_tree.h b/device_tree.h
index 759e142..b707085 100644
--- a/device_tree.h
+++ b/device_tree.h
@@ -14,6 +14,9 @@
#ifndef __DEVICE_TREE_H__
#define __DEVICE_TREE_H__
+#include "qemu-common.h"
+#include "qerror.h"
+
void *create_device_tree(int *sizep);
void *load_device_tree(const char *filename_path, int *sizep);
@@ -29,9 +32,11 @@ int qemu_devtree_setprop_phandle(void *fdt, const char *node_path,
const char *property,
const char *target_node_path);
const void *qemu_devtree_getprop(void *fdt, const char *node_path,
- const char *property, int *lenp);
+ const char *property, int *lenp,
+ Error **errp);
uint32_t qemu_devtree_getprop_cell(void *fdt, const char *node_path,
- const char *property, int offset);
+ const char *property, int offset,
+ Error **errp);
uint32_t qemu_devtree_get_phandle(void *fdt, const char *path);
uint32_t qemu_devtree_alloc_phandle(void *fdt);
int qemu_devtree_nop_node(void *fdt, const char *node_path);
diff --git a/hw/arm_boot.c b/hw/arm_boot.c
index 051aee6..45a7455 100644
--- a/hw/arm_boot.c
+++ b/hw/arm_boot.c
@@ -221,6 +221,8 @@ static int load_dtb(target_phys_addr_t addr, const struct arm_boot_info *binfo)
void *fdt = NULL;
char *filename;
int size, rc;
+ Error *errp = NULL;
+
uint32_t acells, scells, hival;
filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, binfo->dtb_filename);
@@ -237,8 +239,10 @@ static int load_dtb(target_phys_addr_t addr, const struct arm_boot_info *binfo)
}
g_free(filename);
- acells = qemu_devtree_getprop_cell(fdt, "/", "#address-cells", 0);
- scells = qemu_devtree_getprop_cell(fdt, "/", "#size-cells", 0);
+ acells = qemu_devtree_getprop_cell(fdt, "/", "#address-cells", 0, &errp);
+ scells = qemu_devtree_getprop_cell(fdt, "/", "#size-cells", 0, &errp);
+ assert_no_error(errp);
+
if (acells == 0 || scells == 0) {
fprintf(stderr, "dtb file invalid (#address-cells or #size-cells 0)\n");
return -1;
--
1.7.0.4
^ permalink raw reply related [flat|nested] 16+ messages in thread* [Qemu-devel] [RFC v0 03/10] device_tree: allow property getters to inherit
2012-09-17 9:02 [Qemu-devel] [RFC v0 00/10] Microblaze generic FDT framework Peter A. G. Crosthwaite
2012-09-17 9:02 ` [Qemu-devel] [RFC v0 01/10] device_tree: allow offsets for cell properties Peter A. G. Crosthwaite
2012-09-17 9:02 ` [Qemu-devel] [RFC v0 02/10] device_tree: return Error* from prop getters Peter A. G. Crosthwaite
@ 2012-09-17 9:02 ` Peter A. G. Crosthwaite
2012-09-17 9:02 ` [Qemu-devel] [RFC v0 04/10] device_tree: get_prop(): memdup returned properties Peter A. G. Crosthwaite
` (6 subsequent siblings)
9 siblings, 0 replies; 16+ messages in thread
From: Peter A. G. Crosthwaite @ 2012-09-17 9:02 UTC (permalink / raw)
To: qemu-devel, edgar.iglesias; +Cc: peter.crosthwaite, crwulff
If the inherit flag is set, and the specified property is not found, then search
the parents for it as well.
Signed-off-by: Peter A. G. Crosthwaite <peter.crosthwaite@petalogix.com>
---
device_tree.c | 11 ++++++++---
device_tree.h | 4 ++--
hw/arm_boot.c | 6 ++++--
3 files changed, 14 insertions(+), 7 deletions(-)
diff --git a/device_tree.c b/device_tree.c
index 3792085..7edbbff 100644
--- a/device_tree.c
+++ b/device_tree.c
@@ -180,7 +180,7 @@ int qemu_devtree_setprop_string(void *fdt, const char *node_path,
const void *qemu_devtree_getprop(void *fdt, const char *node_path,
const char *property, int *lenp,
- Error **errp)
+ bool inherit, Error **errp)
{
int len;
const void *r;
@@ -189,6 +189,11 @@ const void *qemu_devtree_getprop(void *fdt, const char *node_path,
}
r = fdt_getprop(fdt, findnode_nofail(fdt, node_path), property, lenp);
if (!r) {
+ char parent[DT_PATH_LENGTH];
+ if (inherit && !qemu_devtree_getparent(fdt, parent, node_path)) {
+ return qemu_devtree_getprop(fdt, parent, property, lenp, true,
+ errp);
+ }
fprintf(stderr, "%s: Couldn't get %s/%s: %s\n", __func__,
node_path, property, fdt_strerror(*lenp));
/* FIXME: Be smarter */
@@ -200,11 +205,11 @@ const void *qemu_devtree_getprop(void *fdt, const char *node_path,
uint32_t qemu_devtree_getprop_cell(void *fdt, const char *node_path,
const char *property, int offset,
- Error **errp)
+ bool inherit, Error **errp)
{
int len;
const uint32_t *p = qemu_devtree_getprop(fdt, node_path, property, &len,
- errp);
+ inherit, errp);
if (errp && *errp) {
return 0;
}
diff --git a/device_tree.h b/device_tree.h
index b707085..c3f3b28 100644
--- a/device_tree.h
+++ b/device_tree.h
@@ -33,10 +33,10 @@ int qemu_devtree_setprop_phandle(void *fdt, const char *node_path,
const char *target_node_path);
const void *qemu_devtree_getprop(void *fdt, const char *node_path,
const char *property, int *lenp,
- Error **errp);
+ bool inherit, Error **errp);
uint32_t qemu_devtree_getprop_cell(void *fdt, const char *node_path,
const char *property, int offset,
- Error **errp);
+ bool inherit, Error **errp);
uint32_t qemu_devtree_get_phandle(void *fdt, const char *path);
uint32_t qemu_devtree_alloc_phandle(void *fdt);
int qemu_devtree_nop_node(void *fdt, const char *node_path);
diff --git a/hw/arm_boot.c b/hw/arm_boot.c
index 45a7455..d79605c 100644
--- a/hw/arm_boot.c
+++ b/hw/arm_boot.c
@@ -239,8 +239,10 @@ static int load_dtb(target_phys_addr_t addr, const struct arm_boot_info *binfo)
}
g_free(filename);
- acells = qemu_devtree_getprop_cell(fdt, "/", "#address-cells", 0, &errp);
- scells = qemu_devtree_getprop_cell(fdt, "/", "#size-cells", 0, &errp);
+ acells = qemu_devtree_getprop_cell(fdt, "/", "#address-cells", 0,
+ false, &errp);
+ scells = qemu_devtree_getprop_cell(fdt, "/", "#size-cells", 0,
+ false, &errp);
assert_no_error(errp);
if (acells == 0 || scells == 0) {
--
1.7.0.4
^ permalink raw reply related [flat|nested] 16+ messages in thread* [Qemu-devel] [RFC v0 04/10] device_tree: get_prop(): memdup returned properties
2012-09-17 9:02 [Qemu-devel] [RFC v0 00/10] Microblaze generic FDT framework Peter A. G. Crosthwaite
` (2 preceding siblings ...)
2012-09-17 9:02 ` [Qemu-devel] [RFC v0 03/10] device_tree: allow property getters to inherit Peter A. G. Crosthwaite
@ 2012-09-17 9:02 ` Peter A. G. Crosthwaite
2012-09-17 9:02 ` [Qemu-devel] [RFC v0 05/10] qemu-coroutine: Add simple work queue support Peter A. G. Crosthwaite
` (5 subsequent siblings)
9 siblings, 0 replies; 16+ messages in thread
From: Peter A. G. Crosthwaite @ 2012-09-17 9:02 UTC (permalink / raw)
To: qemu-devel, edgar.iglesias; +Cc: peter.crosthwaite, crwulff
getprop currently return a pointer into the device tree itself. These pointers
will be corrupted if the device tree is written to in anyway. To make getprop()
safe, duplicate the property so that the value doesnt change over the lifetime
of the returned pointer.
Signed-off-by: Peter A. G. Crosthwaite <peter.crosthwaite@petalogix.com>
---
device_tree.c | 11 +++++++----
device_tree.h | 2 +-
2 files changed, 8 insertions(+), 5 deletions(-)
diff --git a/device_tree.c b/device_tree.c
index 7edbbff..3e22286 100644
--- a/device_tree.c
+++ b/device_tree.c
@@ -178,7 +178,7 @@ int qemu_devtree_setprop_string(void *fdt, const char *node_path,
return r;
}
-const void *qemu_devtree_getprop(void *fdt, const char *node_path,
+void *qemu_devtree_getprop(void *fdt, const char *node_path,
const char *property, int *lenp,
bool inherit, Error **errp)
{
@@ -200,7 +200,7 @@ const void *qemu_devtree_getprop(void *fdt, const char *node_path,
error_set(errp, QERR_UNDEFINED_ERROR);
return NULL;
}
- return r;
+ return g_memdup(r, *lenp);
}
uint32_t qemu_devtree_getprop_cell(void *fdt, const char *node_path,
@@ -208,7 +208,8 @@ uint32_t qemu_devtree_getprop_cell(void *fdt, const char *node_path,
bool inherit, Error **errp)
{
int len;
- const uint32_t *p = qemu_devtree_getprop(fdt, node_path, property, &len,
+ uint32_t ret;
+ uint32_t *p = qemu_devtree_getprop(fdt, node_path, property, &len,
inherit, errp);
if (errp && *errp) {
return 0;
@@ -221,7 +222,9 @@ uint32_t qemu_devtree_getprop_cell(void *fdt, const char *node_path,
error_set(errp, QERR_UNDEFINED_ERROR);
return 0;
}
- return be32_to_cpu(p[offset]);
+ ret = be32_to_cpu(p[offset]);
+ g_free(p);
+ return ret;
}
uint32_t qemu_devtree_get_phandle(void *fdt, const char *path)
diff --git a/device_tree.h b/device_tree.h
index c3f3b28..2bc188a 100644
--- a/device_tree.h
+++ b/device_tree.h
@@ -31,7 +31,7 @@ int qemu_devtree_setprop_string(void *fdt, const char *node_path,
int qemu_devtree_setprop_phandle(void *fdt, const char *node_path,
const char *property,
const char *target_node_path);
-const void *qemu_devtree_getprop(void *fdt, const char *node_path,
+void *qemu_devtree_getprop(void *fdt, const char *node_path,
const char *property, int *lenp,
bool inherit, Error **errp);
uint32_t qemu_devtree_getprop_cell(void *fdt, const char *node_path,
--
1.7.0.4
^ permalink raw reply related [flat|nested] 16+ messages in thread* [Qemu-devel] [RFC v0 05/10] qemu-coroutine: Add simple work queue support
2012-09-17 9:02 [Qemu-devel] [RFC v0 00/10] Microblaze generic FDT framework Peter A. G. Crosthwaite
` (3 preceding siblings ...)
2012-09-17 9:02 ` [Qemu-devel] [RFC v0 04/10] device_tree: get_prop(): memdup returned properties Peter A. G. Crosthwaite
@ 2012-09-17 9:02 ` Peter A. G. Crosthwaite
2012-09-17 9:02 ` [Qemu-devel] [RFC v0 06/10] device_tree: Extended interface for fdt_generic Peter A. G. Crosthwaite
` (4 subsequent siblings)
9 siblings, 0 replies; 16+ messages in thread
From: Peter A. G. Crosthwaite @ 2012-09-17 9:02 UTC (permalink / raw)
To: qemu-devel, edgar.iglesias; +Cc: peter.crosthwaite, crwulff
Add a function co_queue_enter_next() which will immediately transfer
control to the coroutine at the head of a co queue. This can be used for
implementing simple work queues where the manager of a co-queue only
needs to enter queued routines one at a time.
Signed-off-by: Peter A. G. Crosthwaite <peter.crosthwaite@petalogix.com>
---
qemu-coroutine-lock.c | 13 +++++++++++++
qemu-coroutine.h | 9 +++++++++
2 files changed, 22 insertions(+), 0 deletions(-)
diff --git a/qemu-coroutine-lock.c b/qemu-coroutine-lock.c
index 26ad76b..6e343b1 100644
--- a/qemu-coroutine-lock.c
+++ b/qemu-coroutine-lock.c
@@ -91,6 +91,19 @@ void qemu_co_queue_restart_all(CoQueue *queue)
}
}
+bool qemu_co_queue_enter_next(CoQueue *queue)
+{
+ Coroutine *next;
+
+ next = QTAILQ_FIRST(&queue->entries);
+ if (next) {
+ QTAILQ_REMOVE(&queue->entries, next, co_queue_next);
+ qemu_coroutine_enter(next, NULL);
+ }
+
+ return (next != NULL);
+}
+
bool qemu_co_queue_empty(CoQueue *queue)
{
return (QTAILQ_FIRST(&queue->entries) == NULL);
diff --git a/qemu-coroutine.h b/qemu-coroutine.h
index 34c15d4..d63b103 100644
--- a/qemu-coroutine.h
+++ b/qemu-coroutine.h
@@ -137,6 +137,15 @@ bool qemu_co_queue_next(CoQueue *queue);
void qemu_co_queue_restart_all(CoQueue *queue);
/**
+ * Transfers control to the next coroutine in the CoQueue and removes it from
+ * the queue.
+ *
+ * Returns true once after control transfers back to caller, or false
+ * immediately if the queue is empty.
+ */
+bool qemu_co_queue_enter_next(CoQueue *queue);
+
+/**
* Checks if the CoQueue is empty.
*/
bool qemu_co_queue_empty(CoQueue *queue);
--
1.7.0.4
^ permalink raw reply related [flat|nested] 16+ messages in thread* [Qemu-devel] [RFC v0 06/10] device_tree: Extended interface for fdt_generic
2012-09-17 9:02 [Qemu-devel] [RFC v0 00/10] Microblaze generic FDT framework Peter A. G. Crosthwaite
` (4 preceding siblings ...)
2012-09-17 9:02 ` [Qemu-devel] [RFC v0 05/10] qemu-coroutine: Add simple work queue support Peter A. G. Crosthwaite
@ 2012-09-17 9:02 ` Peter A. G. Crosthwaite
2012-09-17 9:02 ` [Qemu-devel] [RFC v0 07/10] fdt_generic: First revision Peter A. G. Crosthwaite
` (3 subsequent siblings)
9 siblings, 0 replies; 16+ messages in thread
From: Peter A. G. Crosthwaite @ 2012-09-17 9:02 UTC (permalink / raw)
To: qemu-devel, edgar.iglesias; +Cc: peter.crosthwaite, crwulff
Extended the wrapper interface (around libfdt) for device tree. Node Property
getters have been added (qemu_devtree_getprop*) as well as helpers to search/
navigate the nodes of a FDT blob.
Signed-off-by: Peter A. G. Crosthwaite <peter.crosthwaite@petalogix.com>
---
device_tree.c | 158 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
device_tree.h | 27 ++++++++++
2 files changed, 185 insertions(+), 0 deletions(-)
diff --git a/device_tree.c b/device_tree.c
index 3e22286..2c5c9ef 100644
--- a/device_tree.c
+++ b/device_tree.c
@@ -323,3 +323,161 @@ int qemu_devtree_add_subnode(void *fdt, const char *name)
g_free(dupname);
return retval;
}
+
+char *qemu_devtree_get_node_name(void *fdt, const char *node_path)
+{
+ const char *ret = fdt_get_name(fdt, fdt_path_offset(fdt, node_path), NULL);
+ return ret ? strdup(ret) : NULL;
+}
+
+int qemu_devtree_get_node_depth(void *fdt, const char *node_path)
+{
+ return fdt_node_depth(fdt, fdt_path_offset(fdt, node_path));
+}
+
+static void qemu_devtree_children_info(void *fdt, const char *node_path,
+ int depth, int *num, char **returned_paths) {
+ int offset = fdt_path_offset(fdt, node_path);
+ int root_depth = fdt_node_depth(fdt, offset);
+ int cur_depth = root_depth;
+
+ *num = 0;
+ for (;;) {
+ offset = fdt_next_node(fdt, offset, &cur_depth);
+ if (cur_depth <= root_depth) {
+ break;
+ }
+ if (cur_depth <= root_depth + depth || depth == 0) {
+ if (returned_paths) {
+ returned_paths[*num] = g_malloc0(DT_PATH_LENGTH);
+ fdt_get_path(fdt, offset, returned_paths[*num], DT_PATH_LENGTH);
+ }
+ (*num)++;
+ }
+ }
+}
+
+char **qemu_devtree_get_children(void *fdt, const char *node_path, int depth)
+{
+ int num_children = qemu_devtree_get_num_children(fdt, node_path, depth);
+ char **ret = g_malloc0(sizeof(*ret) * num_children);
+
+ qemu_devtree_children_info(fdt, node_path, depth, &num_children, ret);
+ return ret;
+}
+
+int qemu_devtree_get_num_children(void *fdt, const char *node_path, int depth)
+{
+ int ret;
+
+ qemu_devtree_children_info(fdt, node_path, depth, &ret, NULL);
+ return ret;
+}
+
+int qemu_devtree_node_by_compatible(void *fdt, char *node_path,
+ const char *compats)
+{
+ int offset = fdt_node_offset_by_compatible(fdt, 0, compats);
+ return offset > 0 ?
+ fdt_get_path(fdt, offset, node_path, DT_PATH_LENGTH) : 1;
+}
+
+int qemu_devtree_get_node_by_name(void *fdt, char *node_path,
+ const char *cmpname) {
+ int offset = 0;
+ char *name = NULL;
+
+ do {
+ offset = fdt_next_node(fdt, offset, NULL);
+ name = (void *)fdt_get_name(fdt, offset, NULL);
+ if (!name) {
+ continue;
+ }
+ if (!strncmp(name, cmpname, strlen(cmpname))) {
+ break;
+ }
+ } while (offset > 0);
+ return offset > 0 ?
+ fdt_get_path(fdt, offset, node_path, DT_PATH_LENGTH) : 1;
+}
+
+int qemu_devtree_get_node_by_phandle(void *fdt, char *node_path, int phandle)
+{
+ return fdt_get_path(fdt, fdt_node_offset_by_phandle(fdt, phandle),
+ node_path, DT_PATH_LENGTH);
+}
+
+int qemu_devtree_getparent(void *fdt, char *node_path, const char *current)
+{
+ int offset = fdt_path_offset(fdt, current);
+ int parent_offset = fdt_supernode_atdepth_offset(fdt, offset,
+ fdt_node_depth(fdt, offset) - 1, NULL);
+
+ return parent_offset > 0 ?
+ fdt_get_path(fdt, parent_offset, node_path, DT_PATH_LENGTH) : 1;
+}
+
+int qemu_devtree_get_root_node(void *fdt, char *node_path)
+{
+ return fdt_get_path(fdt, 0, node_path, DT_PATH_LENGTH);
+}
+
+static void devtree_scan(void *fdt, int *num_nodes, int info_dump)
+{
+ int depth = 0, offset = 0;
+
+ if (num_nodes) {
+ *num_nodes = 0;
+ }
+ for (;;) {
+ offset = fdt_next_node(fdt, offset, &depth);
+ if (num_nodes) {
+ (*num_nodes)++;
+ }
+ if (offset <= 0 || depth <= 0) {
+ break;
+ }
+
+ if (info_dump) {
+ char node_path[DT_PATH_LENGTH];
+ char *all_compats = NULL;
+ int compat_len;
+ Error *errp = NULL;
+
+ if (fdt_get_path(fdt, offset, node_path, DT_PATH_LENGTH)) {
+ sprintf(node_path, "(none)");
+ } else {
+ all_compats = qemu_devtree_getprop(fdt, node_path, "compatible",
+ &compat_len, false, &errp);
+ }
+ if (!errp) {
+ char *i = all_compats;
+ for (;;) {
+ char *j = rawmemchr(i, '\0');
+ compat_len -= ((j+1)-i);
+ if (!compat_len) {
+ break;
+ }
+ *j = ' ';
+ i = j+1;
+ }
+ }
+ printf("OFFSET: %d, DEPTH: %d, PATH: %s, COMPATS: %s\n",
+ offset, depth, node_path,
+ all_compats ? all_compats : "(none)");
+ }
+ }
+}
+
+void devtree_info_dump(void *fdt)
+{
+ devtree_scan(fdt, NULL, 1);
+}
+
+int devtree_get_num_nodes(void *fdt)
+{
+ int ret;
+
+ devtree_scan(fdt, &ret, 0);
+ return ret;
+}
diff --git a/device_tree.h b/device_tree.h
index 2bc188a..e741c2a 100644
--- a/device_tree.h
+++ b/device_tree.h
@@ -20,6 +20,8 @@
void *create_device_tree(int *sizep);
void *load_device_tree(const char *filename_path, int *sizep);
+/* property setters */
+
int qemu_devtree_setprop(void *fdt, const char *node_path,
const char *property, const void *val_array, int size);
int qemu_devtree_setprop_cell(void *fdt, const char *node_path,
@@ -54,4 +56,29 @@ int qemu_devtree_add_subnode(void *fdt, const char *name);
sizeof(qdt_tmp)); \
} while (0)
+/* node queries */
+
+char *qemu_devtree_get_node_name(void *fdt, const char *node_path);
+int qemu_devtree_get_node_depth(void *fdt, const char *node_path);
+int qemu_devtree_get_num_children(void *fdt, const char *node_path, int depth);
+char **qemu_devtree_get_children(void *fdt, const char *node_path, int depth);
+
+/* node getters */
+
+int qemu_devtree_node_by_compatible(void *fdt, char *node_path,
+ const char *compats);
+int qemu_devtree_get_node_by_name(void *fdt, char *node_path,
+ const char *cmpname);
+int qemu_devtree_get_node_by_phandle(void *fdt, char *node_path, int phandle);
+int qemu_devtree_getparent(void *fdt, char *node_path,
+ const char *current);
+int qemu_devtree_get_root_node(void *fdt, char *node_path);
+
+/* misc */
+
+int devtree_get_num_nodes(void *fdt);
+void devtree_info_dump(void *fdt);
+
+#define DT_PATH_LENGTH 1024
+
#endif /* __DEVICE_TREE_H__ */
--
1.7.0.4
^ permalink raw reply related [flat|nested] 16+ messages in thread* [Qemu-devel] [RFC v0 07/10] fdt_generic: First revision
2012-09-17 9:02 [Qemu-devel] [RFC v0 00/10] Microblaze generic FDT framework Peter A. G. Crosthwaite
` (5 preceding siblings ...)
2012-09-17 9:02 ` [Qemu-devel] [RFC v0 06/10] device_tree: Extended interface for fdt_generic Peter A. G. Crosthwaite
@ 2012-09-17 9:02 ` Peter A. G. Crosthwaite
2012-09-17 9:48 ` Paolo Bonzini
2012-09-17 9:03 ` [Qemu-devel] [RFC v0 08/10] pflash_cfi01: Added fdt generic platform support Peter A. G. Crosthwaite
` (2 subsequent siblings)
9 siblings, 1 reply; 16+ messages in thread
From: Peter A. G. Crosthwaite @ 2012-09-17 9:02 UTC (permalink / raw)
To: qemu-devel, edgar.iglesias; +Cc: peter.crosthwaite, crwulff
First revision of fdt generic infrastructure. These modules allow
for fdt generic machine models, which create machines to match a device
tree specification.
Signed-off-by: Peter A. G. Crosthwaite <peter.crosthwaite@petalogix.com>
---
default-configs/microblaze-softmmu.mak | 1 +
default-configs/microblazeel-softmmu.mak | 1 +
hw/fdt_generic.c | 215 +++++++++++++++
hw/fdt_generic.h | 92 +++++++
hw/fdt_generic_util.c | 438 ++++++++++++++++++++++++++++++
hw/fdt_generic_util.h | 36 +++
hw/microblaze/Makefile.objs | 3 +
7 files changed, 786 insertions(+), 0 deletions(-)
create mode 100644 hw/fdt_generic.c
create mode 100644 hw/fdt_generic.h
create mode 100644 hw/fdt_generic_util.c
create mode 100644 hw/fdt_generic_util.h
diff --git a/default-configs/microblaze-softmmu.mak b/default-configs/microblaze-softmmu.mak
index 64c9485..c3bd740 100644
--- a/default-configs/microblaze-softmmu.mak
+++ b/default-configs/microblaze-softmmu.mak
@@ -5,3 +5,4 @@ CONFIG_PFLASH_CFI01=y
CONFIG_SERIAL=y
CONFIG_XILINX=y
CONFIG_XILINX_AXI=y
+CONFIG_FDT_GENERIC=y
diff --git a/default-configs/microblazeel-softmmu.mak b/default-configs/microblazeel-softmmu.mak
index a962276..dda2c51 100644
--- a/default-configs/microblazeel-softmmu.mak
+++ b/default-configs/microblazeel-softmmu.mak
@@ -5,3 +5,4 @@ CONFIG_PFLASH_CFI01=y
CONFIG_SERIAL=y
CONFIG_XILINX=y
CONFIG_XILINX_AXI=y
+CONFIG_FDT_GENERIC=y
diff --git a/hw/fdt_generic.c b/hw/fdt_generic.c
new file mode 100644
index 0000000..3950107
--- /dev/null
+++ b/hw/fdt_generic.c
@@ -0,0 +1,215 @@
+/*
+ * Tables of FDT device models and their init functions. Keyed by compatibility
+ * strings, device instance names.
+ *
+ * Copyright (c) 2010 PetaLogix Qld Pty Ltd.
+ * Copyright (c) 2010 Peter A. G. Crosthwaite <peter.crosthwaite@petalogix.com>.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "fdt_generic.h"
+
+#define FDT_GENERIC_ERR_DEBUG
+
+#ifdef FDT_GENERIC_ERR_DEBUG
+#define DB_PRINT(...) do { \
+ fprintf(stderr, ": %s: ", __func__); \
+ fprintf(stderr, ## __VA_ARGS__); \
+ } while (0);
+#else
+ #define DB_PRINT(...)
+#endif
+
+#define FDT_GENERIC_MAX_PATTERN_LEN 1024
+
+typedef struct TableListNode {
+ void *next;
+ char key[FDT_GENERIC_MAX_PATTERN_LEN];
+ FDTInitFn fdt_init;
+ void *opaque;
+} TableListNode;
+
+/* add a node to the table specified by *head_p */
+
+static void add_to_table(
+ FDTInitFn fdt_init,
+ const char *key,
+ void *opaque,
+ TableListNode **head_p)
+{
+ TableListNode *nn = malloc(sizeof(*nn));
+ nn->next = (void *)(*head_p);
+ strcpy(nn->key, key);
+ nn->fdt_init = fdt_init;
+ nn->opaque = opaque;
+ *head_p = nn;
+}
+
+/* FIXME: add return codes that differentiate between not found and error */
+
+/* search a table for a key string and call the fdt init function if found.
+ * Returns 0 if a match if found, 1 otherwise
+ */
+
+static int fdt_init_search_table(
+ char *node_path,
+ FDTMachineInfo *fdti,
+ const char *key, /* string to match */
+ TableListNode **head) /* head of the list to search */
+{
+ TableListNode *c = *head;
+ if (c == NULL) {
+ return 1;
+ } else if (!strcmp(key, c->key)) {
+ return c->fdt_init(node_path, fdti, c->opaque);
+ }
+ return fdt_init_search_table(node_path, fdti, key,
+ (TableListNode **)(&(*head)->next));
+}
+
+TableListNode *compat_list_head;
+
+void add_to_compat_table(FDTInitFn fdt_init, const char *compat, void *opaque)
+{
+ add_to_table(fdt_init, compat, opaque, &compat_list_head);
+}
+
+int fdt_init_compat(char *node_path, FDTMachineInfo *fdti, const char *compat)
+{
+ return fdt_init_search_table(node_path, fdti, compat, &compat_list_head);
+}
+
+TableListNode *inst_bind_list_head;
+
+void add_to_inst_bind_table(FDTInitFn fdt_init, const char *name, void *opaque)
+{
+ add_to_table(fdt_init, name, opaque, &inst_bind_list_head);
+}
+
+int fdt_init_inst_bind(char *node_path, FDTMachineInfo *fdti,
+ const char *name)
+{
+ return fdt_init_search_table(node_path, fdti, name, &inst_bind_list_head);
+}
+
+TableListNode *force_list_head;
+
+void add_to_force_table(FDTInitFn fdt_init, const char *name, void *opaque)
+{
+ add_to_table(fdt_init, name, opaque, &force_list_head);
+}
+
+int fdt_force_bind_all(FDTMachineInfo *fdti)
+{
+ int ret = 0;
+ while (force_list_head != NULL) {
+ TableListNode *to_delete = force_list_head;
+ ret |= force_list_head->fdt_init(NULL, fdti, force_list_head->opaque);
+ force_list_head = force_list_head->next;
+ free(to_delete);
+ }
+ return ret;
+}
+
+static void dump_table(TableListNode *head)
+{
+ if (head == NULL) {
+ return;
+ }
+ printf("key : %s, opaque data %p\n", head->key, head->opaque);
+ dump_table(head->next);
+}
+
+void dump_compat_table(void)
+{
+ printf("FDT COMPATIBILITY TABLE:\n");
+ dump_table(compat_list_head);
+}
+
+void dump_inst_bind_table(void)
+{
+ printf("FDT INSTANCE BINDING TABLE:\n");
+ dump_table(inst_bind_list_head);
+}
+
+void fdt_init_yield(FDTMachineInfo *fdti)
+{
+ static int yield_index;
+ int this_yield = yield_index++;
+
+ DB_PRINT("yield #%d %p\n", this_yield, fdti->cq);
+ qemu_co_queue_wait(fdti->cq);
+ DB_PRINT("unyield #%d\n", this_yield);
+}
+
+void fdt_init_set_opaque(FDTMachineInfo *fdti, char *node_path, void *opaque)
+{
+ FDTDevOpaque *dp;
+ for (dp = fdti->dev_opaques;
+ dp->node_path && strcmp(dp->node_path, node_path);
+ dp++);
+ if (!dp->node_path) {
+ dp->node_path = strdup(node_path);
+ }
+ dp->opaque = opaque;
+}
+
+int fdt_init_has_opaque(FDTMachineInfo *fdti, char *node_path)
+{
+ FDTDevOpaque *dp;
+ for (dp = fdti->dev_opaques; dp->node_path; dp++) {
+ if (!strcmp(dp->node_path, node_path)) {
+ return 1;
+ }
+ }
+ return 0;
+}
+
+void *fdt_init_get_opaque(FDTMachineInfo *fdti, char *node_path)
+{
+ FDTDevOpaque *dp;
+ for (dp = fdti->dev_opaques; dp->node_path; dp++) {
+ if (!strcmp(dp->node_path, node_path)) {
+ return dp->opaque;
+ }
+ }
+ return NULL;
+}
+
+FDTMachineInfo *fdt_init_new_fdti(void *fdt)
+{
+ FDTMachineInfo *fdti = g_malloc0(sizeof(*fdti));
+ fdti->fdt = fdt;
+ fdti->cq = g_malloc0(sizeof(*(fdti->cq)));
+ qemu_co_queue_init(fdti->cq);
+ fdti->dev_opaques = g_malloc0(sizeof(*(fdti->dev_opaques)) *
+ (devtree_get_num_nodes(fdt) + 1));
+ return fdti;
+}
+
+void fdt_init_destroy_fdti(FDTMachineInfo *fdti)
+{
+ FDTDevOpaque *dp;
+ for (dp = fdti->dev_opaques; dp->node_path; dp++) {
+ g_free(dp->node_path);
+ }
+ g_free(fdti->dev_opaques);
+ g_free(fdti);
+}
diff --git a/hw/fdt_generic.h b/hw/fdt_generic.h
new file mode 100644
index 0000000..41992e3
--- /dev/null
+++ b/hw/fdt_generic.h
@@ -0,0 +1,92 @@
+/*
+ * Tables of FDT device models and their init functions. Keyed by compatibility
+ * strings, device instance names.
+ */
+
+#ifndef FDT_GENERIC_H
+#define FDT_GENERIC_H
+
+#include "qemu-common.h"
+#include "sysbus.h"
+#include "device_tree.h"
+#include "qemu-coroutine.h"
+
+typedef struct FDTDevOpaque {
+ char *node_path;
+ void *opaque;
+} FDTDevOpaque;
+
+typedef struct FDTMachineInfo {
+ /* the fdt blob */
+ void *fdt;
+ /* irq descriptors for top level int controller */
+ qemu_irq *irq_base;
+ /* per-device specific opaques */
+ FDTDevOpaque *dev_opaques;
+ /* recheck coroutine queue */
+ CoQueue *cq;
+} FDTMachineInfo;
+
+/* create a new FDTMachineInfo. The client is responsible for setting irq_base.
+ * the mutex fdt_mutex is locked on return. Client must call
+ * fdt_init_destroy_fdti to cleanup
+ */
+
+FDTMachineInfo *fdt_init_new_fdti(void *fdt);
+void fdt_init_destroy_fdti(FDTMachineInfo *fdti);
+
+typedef int (*FDTInitFn)(char *, FDTMachineInfo *, void *);
+
+/* associate a FDTInitFn with a FDT compatibility */
+
+void add_to_compat_table(FDTInitFn, const char *, void *);
+
+/* try and find a device model for a particular compatibility. If found,
+ * the FDTInitFn associated with the compat will be called and 0 will
+ * be returned. Returns non-zero on not found or error
+ */
+
+int fdt_init_compat(char *, FDTMachineInfo *, const char *);
+
+/* same as above, but associates with a FDT node name (rather than compat) */
+
+void add_to_inst_bind_table(FDTInitFn, const char *, void *);
+int fdt_init_inst_bind(char *, FDTMachineInfo *, const char *);
+
+/* Register an FDTInitFn that should always be called upon machine creation */
+
+void add_to_force_table(FDTInitFn, const char *, void *);
+int fdt_force_bind_all(FDTMachineInfo *);
+
+void dump_compat_table(void);
+void dump_inst_bind_table(void);
+
+/* Called from FDTInitFn's to inform the framework that a dependency is
+ * unresolved and the calling context needs to wait for another device to
+ * instantiate first. The calling thread will suspend until a change in state
+ * in the argument fdt machine is detected.
+ */
+
+void fdt_init_yield(FDTMachineInfo *);
+
+/* set, check and get per device opaques. Keyed by fdt node_paths */
+
+void fdt_init_set_opaque(FDTMachineInfo *fdti, char *node_path, void *opaque);
+int fdt_init_has_opaque(FDTMachineInfo *fdti, char *node_path);
+void *fdt_init_get_opaque(FDTMachineInfo *fdti, char *node_path);
+
+/* statically register a FDTInitFn as being associate with a compatibility */
+
+#define fdt_register_compatibility_opaque(function, compat, n, opaque) \
+static void __attribute__((constructor)) \
+function ## n ## _register_imp(void) { \
+ add_to_compat_table(function, compat, opaque); \
+}
+
+#define fdt_register_compatibility_n(function, compat, n) \
+fdt_register_compatibility_opaque(function, compat, n, NULL)
+
+#define fdt_register_compatibility(function, compat) \
+fdt_register_compatibility_n(function, compat, 0)
+
+#endif /* FDT_GENERIC_H */
diff --git a/hw/fdt_generic_util.c b/hw/fdt_generic_util.c
new file mode 100644
index 0000000..3c04957
--- /dev/null
+++ b/hw/fdt_generic_util.c
@@ -0,0 +1,438 @@
+/*
+ * Utility functions for fdt generic framework
+ *
+ * Copyright (c) 2009 Edgar E. Iglesias.
+ * Copyright (c) 2009 Michal Simek.
+ * Copyright (c) 2011 PetaLogix Qld Pty Ltd.
+ * Copyright (c) 2011 Peter A. G. Crosthwaite <peter.crosthwaite@petalogix.com>.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#define FDT_GENERIC_UTIL_ERR_DEBUG
+
+#ifdef FDT_GENERIC_UTIL_ERR_DEBUG
+#define DB_PRINT(...) do { \
+ fprintf(stderr, ": %s: ", __func__); \
+ fprintf(stderr, ## __VA_ARGS__); \
+ } while (0);
+#else
+ #define DB_PRINT(...)
+#endif
+
+#include "fdt_generic_util.h"
+#include "net.h"
+
+/* FIXME: wrap direct calls into libfdt */
+
+#include <libfdt.h>
+
+FDTMachineInfo *fdt_generic_create_machine(void *fdt, qemu_irq *cpu_irq)
+{
+ char node_path[DT_PATH_LENGTH];
+
+ FDTMachineInfo *fdti = fdt_init_new_fdti(fdt);
+
+ fdti->irq_base = cpu_irq;
+
+ /* bind any force bound instances */
+ fdt_force_bind_all(fdti);
+
+ /* parse the device tree */
+ if (!qemu_devtree_get_root_node(fdt, node_path)) {
+ simple_bus_fdt_init(node_path, fdti, NULL);
+ while (qemu_co_queue_enter_next(fdti->cq));
+ } else {
+ fprintf(stderr, "FDT: ERROR: cannot get root node from device tree %s\n"
+ , node_path);
+ }
+
+ printf("FDT: Device tree scan complete\n");
+ FDTMachineInfo *ret = g_malloc0(sizeof(*ret));
+ return fdti;
+}
+
+struct FDTInitNodeArgs {
+ char *node_path;
+ FDTMachineInfo *fdti;
+};
+
+static int fdt_init_qdev(char *node_path, FDTMachineInfo *fdti, char *compat);
+
+static void fdt_init_node(void *args)
+{
+
+ struct FDTInitNodeArgs *a = args;
+ char *node_path = a->node_path;
+ FDTMachineInfo *fdti = a->fdti;
+ g_free(a);
+
+ char *all_compats = NULL, *compat, *node_name, *next_compat;
+ int compat_len;
+
+ static int entry_index;
+ int this_entry = entry_index++;
+ DB_PRINT("enter %d %s\n", this_entry, node_path);
+
+ /* try instance binding first */
+ node_name = qemu_devtree_get_node_name(fdti->fdt, node_path);
+ if (!node_name) {
+ printf("FDT: ERROR: nameless node: %s\n", node_path);
+ }
+ if (!fdt_init_inst_bind(node_path, fdti, node_name)) {
+ goto exit;
+ }
+
+ /* fallback to compatibility binding */
+ all_compats = qemu_devtree_getprop(fdti->fdt, node_path,
+ "compatible", &compat_len, false, NULL);
+ if (!all_compats) {
+ printf("FDT: ERROR: no compatibility found for node %s%s\n", node_path,
+ node_name);
+ DB_PRINT("exit %d\n", this_entry);
+ return;
+ }
+ compat = all_compats;
+
+try_next_compat:
+ if (compat_len == 0) {
+ goto invalidate;
+ }
+ if (!fdt_init_compat(node_path, fdti, compat)) {
+ goto exit;
+ }
+ if (!fdt_init_qdev(node_path, fdti, compat)) {
+ goto exit;
+ }
+ next_compat = rawmemchr(compat, '\0');
+ compat_len -= (next_compat + 1 - compat);
+ if (compat_len > 0) {
+ *next_compat = ' ';
+ }
+ compat = next_compat+1;
+ goto try_next_compat;
+invalidate:
+ printf("FDT: Unsupported peripheral invalidated %s compatibilities %s\n",
+ node_name, all_compats);
+ qemu_devtree_setprop_string(fdti->fdt, node_path, "compatible",
+ "invalidated");
+exit:
+
+ DB_PRINT("exit %d\n", this_entry);
+
+ if (!fdt_init_has_opaque(fdti, node_path)) {
+ fdt_init_set_opaque(fdti, node_path, NULL);
+ }
+ g_free(node_path);
+ g_free(all_compats);
+ return;
+}
+
+int simple_bus_fdt_init(char *bus_node_path, FDTMachineInfo *fdti, void *unused)
+{
+ int i;
+ int num_children = qemu_devtree_get_num_children(fdti->fdt, bus_node_path,
+ 1);
+ char **children = qemu_devtree_get_children(fdti->fdt, bus_node_path, 1);
+
+ DB_PRINT("num child devices: %d\n", num_children);
+
+ for (i = 0; i < num_children; i++) {
+ struct FDTInitNodeArgs *init_args = g_malloc0(sizeof(*init_args));
+ init_args->node_path = children[i];
+ init_args->fdti = fdti;
+ qemu_coroutine_enter(qemu_coroutine_create(fdt_init_node), init_args);
+ }
+
+ g_free(children);
+ return 0;
+}
+
+qemu_irq fdt_get_irq_info(FDTMachineInfo *fdti, char *node_path, int irq_idx,
+ int *err, char *info) {
+ void *fdt = fdti->fdt;
+ int intc_phandle, intc_cells, idx, errl;
+ char intc_node_path[DT_PATH_LENGTH];
+ Error *errp = NULL;
+ DeviceState *intc;
+
+ if (!err) {
+ err = &errl;
+ }
+ intc_phandle = qemu_devtree_getprop_cell(fdt, node_path, "interrupt-parent",
+ 0, true, &errp);
+ if (errp) {
+ goto fail;
+ }
+
+ if (qemu_devtree_get_node_by_phandle(fdt, intc_node_path, intc_phandle)) {
+ goto fail;
+ }
+ intc_cells = qemu_devtree_getprop_cell(fdt, intc_node_path,
+ "#interrupt-cells", 0, false, &errp);
+ if (errp) {
+ goto fail;
+ }
+ idx = qemu_devtree_getprop_cell(fdt, node_path, "interrupts",
+ intc_cells * irq_idx, false, &errp);
+ if (errp) {
+ goto fail;
+ }
+
+ while (!fdt_init_has_opaque(fdti, intc_node_path)) {
+ fdt_init_yield(fdti);
+ }
+ intc = DEVICE(fdt_init_get_opaque(fdti, intc_node_path));
+ if (!intc) {
+ goto fail;
+ }
+ if (info) {
+ char *node_name = qemu_devtree_get_node_name(fdt, intc_node_path);
+ sprintf(info, "%d (%s)", idx, node_name);
+ g_free((void *)node_name);
+ }
+ return qdev_get_gpio_in(intc, idx);
+fail:
+ *err = 1;
+ if (info) {
+ sprintf(info, "(none)");
+ }
+ return NULL;
+}
+
+qemu_irq fdt_get_irq(FDTMachineInfo *fdti, char *node_path, int irq_idx)
+{
+ return fdt_get_irq_info(fdti, node_path, irq_idx, NULL, NULL);
+}
+
+/* FIXME: figure out a real solution to this */
+
+#define DIGIT(a) ((a) >= '0' && (a) <= '9')
+#define LOWER_CASE(a) ((a) >= 'a' && (a) <= 'z')
+
+static void trim_xilinx_version(char *x)
+{
+ for (;;) {
+ x = strchr(x, '-');
+ if (!x || strlen(x) < 7) {
+ return;
+ }
+ if (DIGIT(x[1]) &&
+ x[2] == '.' &&
+ DIGIT(x[3]) &&
+ DIGIT(x[4]) &&
+ x[5] == '.' &&
+ LOWER_CASE(x[6])) {
+ *x = '\0';
+ return;
+ }
+ x++;
+ }
+}
+
+static void substitute_char(char *s, char a, char b)
+{
+ for (;;) {
+ s = strchr(s, a);
+ if (!s) {
+ return;
+ }
+ *s = b;
+ s++;
+ }
+}
+
+static DeviceState *fdt_create_qdev_from_compat(char *compat, char **dev_type)
+{
+ DeviceState *ret = NULL;
+
+ char *c = g_strdup(compat);
+ ret = qdev_try_create(NULL, c);
+ if (!ret) {
+ /* QEMU substitutes "."s for ","s in device names, so try with that
+ * substitutution
+ */
+ substitute_char(c, ',', '.');
+ ret = qdev_try_create(NULL, c);
+ }
+ if (!ret) {
+ /* try again with the xilinx version string trimmed */
+ trim_xilinx_version(c);
+ ret = qdev_try_create(NULL, c);
+ }
+
+ if (dev_type) {
+ *dev_type = c;
+ } else {
+ g_free(c);
+ }
+ return ret;
+}
+
+static inline const char *trim_vendor(const char *s)
+{
+ /* FIXME: be more intelligent */
+ const char *ret = memchr(s, ',', sizeof(s));
+ return ret ? ret + 1 : s;
+}
+
+/*FIXME: roll into device tree functionality */
+
+static inline uint64_t get_int_be(const void *p, int len)
+{
+ switch (len) {
+ case 1:
+ return *((uint8_t *)p);
+ case 2:
+ return be16_to_cpu(*((uint16_t *)p));
+ case 4:
+ return be32_to_cpu(*((uint32_t *)p));
+ case 8:
+ return be32_to_cpu(*((uint64_t *)p));
+ default:
+ fprintf(stderr, "unsupported integer length\n");
+ abort();
+ }
+}
+
+static int fdt_init_qdev(char *node_path, FDTMachineInfo *fdti, char *compat)
+{
+ int err;
+ qemu_irq irq;
+ target_phys_addr_t base;
+ int offset;
+ DeviceState *dev;
+ char *dev_type = NULL;
+ int is_intc;
+ Error *errp = NULL;
+ int i;
+
+ dev = fdt_create_qdev_from_compat(compat, &dev_type);
+ if (!dev) {
+ DB_PRINT("no match found for %s\n", compat);
+ return 1;
+ }
+ /* FIXME: attach to the sysbus instead */
+ object_property_add_child(container_get(qdev_get_machine(), "/unattached"),
+ qemu_devtree_get_node_name(fdti->fdt, node_path),
+ OBJECT(dev), NULL);
+
+ fdt_init_set_opaque(fdti, node_path, dev);
+
+ /* connect nic if appropriate */
+ static int nics;
+ qdev_set_nic_properties(dev, &nd_table[nics]);
+ if (nd_table[nics].instantiated) {
+ DB_PRINT("NIC instantiated: %s\n", dev_type);
+ nics++;
+ }
+
+ offset = fdt_path_offset(fdti->fdt, node_path);
+ for (offset = fdt_first_property_offset(fdti->fdt, offset);
+ offset != -FDT_ERR_NOTFOUND;
+ offset = fdt_next_property_offset(fdti->fdt, offset)) {
+ const char *propname;
+ int len;
+ const void *val = fdt_getprop_by_offset(fdti->fdt, offset,
+ &propname, &len);
+
+ propname = trim_vendor(propname);
+ ObjectProperty *p = object_property_find(OBJECT(dev), propname, NULL);
+ if (p) {
+ DB_PRINT("matched property: %s of type %s, len %d\n",
+ propname, p->type, len);
+ }
+ if (!p) {
+ continue;
+ }
+
+ /* FIXME: handle generically using accessors and stuff */
+ if (!strcmp(p->type, "uint8") || !strcmp(p->type, "uint16") ||
+ !strcmp(p->type, "uint32") || !strcmp(p->type, "uint64")) {
+ object_property_set_int(OBJECT(dev), get_int_be(val, len), propname,
+ &errp);
+ assert_no_error(errp);
+ DB_PRINT("set property %s to %#llx\n", propname,
+ get_int_be(val, len));
+ } else if (!strcmp(p->type, "bool")) {
+ object_property_set_bool(OBJECT(dev), !!get_int_be(val, len),
+ propname, &errp);
+ assert_no_error(errp);
+ DB_PRINT("set property %s to %#llx\n", propname,
+ get_int_be(val, len));
+ } else if (!strncmp(p->type, "link", 4)) {
+ char target_node_path[DT_PATH_LENGTH];
+ DeviceState *linked_dev;
+
+ if (qemu_devtree_get_node_by_phandle(fdti->fdt, target_node_path,
+ get_int_be(val, len))) {
+ abort();
+ }
+ while (!fdt_init_has_opaque(fdti, target_node_path)) {
+ fdt_init_yield(fdti);
+ }
+ linked_dev = fdt_init_get_opaque(fdti, target_node_path);
+ object_property_set_link(OBJECT(dev), OBJECT(linked_dev), propname,
+ errp);
+ assert_no_error(errp);
+ }
+ }
+
+ qdev_init_nofail(dev);
+ /* map slave attachment */
+ base = qemu_devtree_getprop_cell(fdti->fdt, node_path, "reg", 0, false,
+ &errp);
+ assert_no_error(errp);
+ sysbus_mmio_map(sysbus_from_qdev(dev), 0, base);
+
+ {
+ int len;
+ fdt_get_property(fdti->fdt, fdt_path_offset(fdti->fdt, node_path),
+ "interrupt-controller", &len);
+ is_intc = len >= 0;
+ DB_PRINT("is interrupt controller: %c\n", is_intc ? 'y' : 'n');
+ }
+ /* connect irq */
+ for (i = 0; ; ++i) {
+ char irq_info[1024];
+ irq = fdt_get_irq_info(fdti, node_path, i, &err, irq_info);
+ /* INTCs inferr their top level, if no IRQ connection specified */
+ if (err && is_intc) {
+ irq = fdti->irq_base[0];
+ sysbus_connect_irq(sysbus_from_qdev(dev), 0, irq);
+ fprintf(stderr, "FDT: (%s) connected top level irq %s\n", dev_type,
+ irq_info);
+ break;
+ }
+ if (!err) {
+ sysbus_connect_irq(sysbus_from_qdev(dev), i, irq);
+ fprintf(stderr, "FDT: (%s) connected irq %s\n", dev_type, irq_info);
+ } else {
+ break;
+ }
+ }
+
+ if (dev_type) {
+ g_free(dev_type);
+ }
+
+ return 0;
+}
+
+fdt_register_compatibility(simple_bus_fdt_init, "simple-bus");
diff --git a/hw/fdt_generic_util.h b/hw/fdt_generic_util.h
new file mode 100644
index 0000000..3906721
--- /dev/null
+++ b/hw/fdt_generic_util.h
@@ -0,0 +1,36 @@
+#ifndef FDT_GENERIC_UTIL_H
+#define FDT_GENERIC_UTIL_H
+
+#include "qemu-common.h"
+#include "fdt_generic.h"
+
+/* create a fdt_generic machine. the top level cpu irqs are required for
+ * systems instantiating interrupt devices. The client is responsible for
+ * destroying the returned FDTMachineInfo (using fdt_init_destroy_fdti)
+ */
+
+FDTMachineInfo *fdt_generic_create_machine(void *fdt, qemu_irq *cpu_irq);
+
+/* fdt init a simple bus. Search the bus for child nodes and instantiate or
+ * invalidate devices as appropriate. Conformant to FDTInitFn prototype, i.e.
+ * a bus may fdt_register_compatibilty this as its instantiator.
+ */
+
+int simple_bus_fdt_init(char *node_path, FDTMachineInfo *fdti, void *priv);
+
+/* get an irq for a device. The interrupt parent of a device is idenitified
+ * and the specified irq (by the interrupts device-tree property) is retrieved
+ */
+
+qemu_irq fdt_get_irq(FDTMachineInfo *fdti, char *node_path, int irq_idx);
+
+/* same as above, but poulates err with non-zero if something goes wrong, and
+ * populates info with a human readable string giving some basic information
+ * about the interrupt connection found (or not found). Both arguments are
+ * optional (i.e. can be NULL)
+ */
+
+qemu_irq fdt_get_irq_info(FDTMachineInfo *fdti, char *node_path, int irq_idx,
+ int *err, char * info);
+
+#endif /* FDT_GENERIC_UTIL_H */
diff --git a/hw/microblaze/Makefile.objs b/hw/microblaze/Makefile.objs
index 274d2c5..23f9cbb 100644
--- a/hw/microblaze/Makefile.objs
+++ b/hw/microblaze/Makefile.objs
@@ -6,4 +6,7 @@ obj-y += microblaze_pic_cpu.o
obj-y += xilinx_ethlite.o
obj-$(CONFIG_FDT) += ../device_tree.o
+obj-$(CONFIG_FDT_GENERIC) += fdt_generic.o
+obj-$(CONFIG_FDT_GENERIC) += fdt_generic_util.o
+
obj-y := $(addprefix ../,$(obj-y))
--
1.7.0.4
^ permalink raw reply related [flat|nested] 16+ messages in thread* Re: [Qemu-devel] [RFC v0 07/10] fdt_generic: First revision
2012-09-17 9:02 ` [Qemu-devel] [RFC v0 07/10] fdt_generic: First revision Peter A. G. Crosthwaite
@ 2012-09-17 9:48 ` Paolo Bonzini
2012-09-17 10:10 ` Peter Crosthwaite
0 siblings, 1 reply; 16+ messages in thread
From: Paolo Bonzini @ 2012-09-17 9:48 UTC (permalink / raw)
To: Peter A. G. Crosthwaite; +Cc: edgar.iglesias, crwulff, qemu-devel
Il 17/09/2012 11:02, Peter A. G. Crosthwaite ha scritto:
> First revision of fdt generic infrastructure. These modules allow
> for fdt generic machine models, which create machines to match a device
> tree specification.
Ok, so here is the famous coroutine-based FDT generation. :)
It does look pretty, to be fair.
However, as things stand there is nothing (I think) that really requires
coroutines. A simple 2-pass initialization would do, with links and
irqs connected on the second pass. I'm wondering how your patch fares
in terms of error handling for example; can you end up with
partially-uninitialized devices or infinite loops? If so, why not?
It would be nice if you included some simple qtest test cases. They
would generate a few machines with different device trees and check that
the output of "info qtree" matches somewhat the device tree. Rough
checks should not be hard to implement, and would provide some guidance
to people who want to hack the code.
Paolo
^ permalink raw reply [flat|nested] 16+ messages in thread
* Re: [Qemu-devel] [RFC v0 07/10] fdt_generic: First revision
2012-09-17 9:48 ` Paolo Bonzini
@ 2012-09-17 10:10 ` Peter Crosthwaite
2012-09-17 12:55 ` Paolo Bonzini
0 siblings, 1 reply; 16+ messages in thread
From: Peter Crosthwaite @ 2012-09-17 10:10 UTC (permalink / raw)
To: Paolo Bonzini; +Cc: edgar.iglesias, crwulff, qemu-devel
On Mon, Sep 17, 2012 at 7:48 PM, Paolo Bonzini <pbonzini@redhat.com> wrote:
> Il 17/09/2012 11:02, Peter A. G. Crosthwaite ha scritto:
>> First revision of fdt generic infrastructure. These modules allow
>> for fdt generic machine models, which create machines to match a device
>> tree specification.
>
> Ok, so here is the famous coroutine-based FDT generation. :)
>
> It does look pretty, to be fair.
>
Thanks :)
> However, as things stand there is nothing (I think) that really requires
> coroutines. A simple 2-pass initialization would do, with links and
> irqs connected on the second pass.
I'm just trying to be a little more general. For more complex setups
we may in the future want to resolve dependencies at different phases
of the machine init process. The ability to yield arbitrarily solves
that problem universally rather than have to manage a discrete number
of passes. That and two pass is brutally ugly in code (and
in-efficient) as you need to tag passes.
I'm wondering how your patch fares
> in terms of error handling for example; can you end up with
> partially-uninitialized devices or infinite loops? If so, why not?
>
Deadlock looping shouldnt happen if thats what your worried about.
Each device is instantiated before its able to yield (waiting on
another) and all devices are inited before you reach that
all-threads-are-yielded point. Essentially your "first-pass" as you
suggested above is complete before before every thread is yielded,
which makes deadlock impossible with current usages.
Paritally initied shouldnt happen - as that can only happen if
coroutines are left yielded. The machine init does not return until
all coros have exited.
Regards,
Peter
> It would be nice if you included some simple qtest test cases. They
> would generate a few machines with different device trees and check that
> the output of "info qtree" matches somewhat the device tree. Rough
> checks should not be hard to implement, and would provide some guidance
> to people who want to hack the code.
>
> Paolo
^ permalink raw reply [flat|nested] 16+ messages in thread
* Re: [Qemu-devel] [RFC v0 07/10] fdt_generic: First revision
2012-09-17 10:10 ` Peter Crosthwaite
@ 2012-09-17 12:55 ` Paolo Bonzini
0 siblings, 0 replies; 16+ messages in thread
From: Paolo Bonzini @ 2012-09-17 12:55 UTC (permalink / raw)
To: Peter Crosthwaite; +Cc: edgar iglesias, crwulff, qemu-devel
> > However, as things stand there is nothing (I think) that really requires
> > coroutines. A simple 2-pass initialization would do, with links and
> > irqs connected on the second pass.
>
> I'm just trying to be a little more general. For more complex setups
> we may in the future want to resolve dependencies at different phases
> of the machine init process.
Do you have any examples of things that are more complicated than
"build everything" followed by "resolve everything"?
> That and two pass is brutally ugly in code (and
> in-efficient) as you need to tag passes.
Not sure I follow, but I can't of course promise aesthetics without
having written any code.
> I'm wondering how your patch fares
> > in terms of error handling for example; can you end up with
> > partially-uninitialized devices or infinite loops? If so, why not?
>
> Deadlock looping shouldnt happen if thats what your worried about.
> Each device is instantiated before its able to yield (waiting on
> another) and all devices are inited before you reach that
> all-threads-are-yielded point. Essentially your "first-pass" as you
> suggested above is complete before before every thread is yielded,
> which makes deadlock impossible with current usages.
Ok, so something checks the syntax before initialization runs.
Pao
^ permalink raw reply [flat|nested] 16+ messages in thread
* [Qemu-devel] [RFC v0 08/10] pflash_cfi01: Added fdt generic platform support
2012-09-17 9:02 [Qemu-devel] [RFC v0 00/10] Microblaze generic FDT framework Peter A. G. Crosthwaite
` (6 preceding siblings ...)
2012-09-17 9:02 ` [Qemu-devel] [RFC v0 07/10] fdt_generic: First revision Peter A. G. Crosthwaite
@ 2012-09-17 9:03 ` Peter A. G. Crosthwaite
2012-09-17 9:03 ` [Qemu-devel] [RFC v0 09/10] microblaze_generic_fdt: first revision Peter A. G. Crosthwaite
2012-09-17 9:03 ` [Qemu-devel] [RFC v0 10/10] serial: added fdt generic platform support Peter A. G. Crosthwaite
9 siblings, 0 replies; 16+ messages in thread
From: Peter A. G. Crosthwaite @ 2012-09-17 9:03 UTC (permalink / raw)
To: qemu-devel, edgar.iglesias; +Cc: peter.crosthwaite, crwulff
Added fdt generic platform support. Note that this does not add the fdt init
handler to the table of registered models as this needs to be handled in a
platform dependent way (due to target endianness issues). Fdt generic machine
models are required to register this device should it be supported.
Signed-off-by: Peter A. G. Crosthwaite <peter.crosthwaite@petalogix.com>
---
hw/fdt_generic_devices.c | 45 +++++++++++++++++++++++++++++++++++++++++++
hw/fdt_generic_devices.h | 8 +++++++
hw/microblaze/Makefile.objs | 1 +
3 files changed, 54 insertions(+), 0 deletions(-)
create mode 100644 hw/fdt_generic_devices.c
create mode 100644 hw/fdt_generic_devices.h
diff --git a/hw/fdt_generic_devices.c b/hw/fdt_generic_devices.c
new file mode 100644
index 0000000..91b3c5b
--- /dev/null
+++ b/hw/fdt_generic_devices.c
@@ -0,0 +1,45 @@
+
+#include "blockdev.h"
+
+#include "fdt_generic_util.h"
+#include "fdt_generic_devices.h"
+
+#define FLASH_SECTOR_SIZE (64 * 1024)
+
+/* FIXME: This file should go away. When these devices are properly QOMified
+ * then these FDT creations should happen automatically without need for these
+ * explict shim functions
+ */
+
+int pflash_cfi01_fdt_init(char *node_path, FDTMachineInfo *fdti, void *opaque)
+{
+
+ int flash_base = 0;
+ int flash_size = 0;
+ Error *errp = NULL;
+
+ int be = *((int *)opaque);
+
+ DriveInfo *dinfo;
+ int bank_width;
+
+ flash_base = qemu_devtree_getprop_cell(fdti->fdt, node_path, "reg", 0,
+ false, &errp);
+ flash_size = qemu_devtree_getprop_cell(fdti->fdt, node_path, "reg", 1,
+ false, &errp);
+ bank_width = qemu_devtree_getprop_cell(fdti->fdt, node_path, "bank-width",
+ 0, false, &errp);
+ assert_no_error(errp);
+
+ printf("FDT: FLASH: baseaddr: 0x%x, size: 0x%x\n",
+ flash_base, flash_size);
+
+ dinfo = drive_get_next(IF_PFLASH);
+ pflash_cfi01_register(flash_base, NULL, node_path, flash_size,
+ dinfo ? dinfo->bdrv : NULL, FLASH_SECTOR_SIZE,
+ flash_size/FLASH_SECTOR_SIZE,
+ bank_width, 0x89, 0x18, 0x0000, 0x0, be);
+ return 0;
+}
+
+#endif /* CONFIG_FDT */
diff --git a/hw/fdt_generic_devices.h b/hw/fdt_generic_devices.h
new file mode 100644
index 0000000..3bb4c05
--- /dev/null
+++ b/hw/fdt_generic_devices.h
@@ -0,0 +1,8 @@
+#ifndef FDT_GENERIC_DEVICES_H
+#define FDT_GENERIC_DEVICES_H
+
+#include "fdt_generic.h"
+
+int pflash_cfi01_fdt_init(char *node_path, FDTMachineInfo *fdti, void *opaque);
+
+#endif /* FDT_GENERIC_DEVICES_H */
diff --git a/hw/microblaze/Makefile.objs b/hw/microblaze/Makefile.objs
index 23f9cbb..ef2d6b7 100644
--- a/hw/microblaze/Makefile.objs
+++ b/hw/microblaze/Makefile.objs
@@ -8,5 +8,6 @@ obj-$(CONFIG_FDT) += ../device_tree.o
obj-$(CONFIG_FDT_GENERIC) += fdt_generic.o
obj-$(CONFIG_FDT_GENERIC) += fdt_generic_util.o
+obj-$(CONFIG_FDT_GENERIC) += fdt_generic_devices.o
obj-y := $(addprefix ../,$(obj-y))
--
1.7.0.4
^ permalink raw reply related [flat|nested] 16+ messages in thread* [Qemu-devel] [RFC v0 09/10] microblaze_generic_fdt: first revision
2012-09-17 9:02 [Qemu-devel] [RFC v0 00/10] Microblaze generic FDT framework Peter A. G. Crosthwaite
` (7 preceding siblings ...)
2012-09-17 9:03 ` [Qemu-devel] [RFC v0 08/10] pflash_cfi01: Added fdt generic platform support Peter A. G. Crosthwaite
@ 2012-09-17 9:03 ` Peter A. G. Crosthwaite
2012-09-17 15:20 ` Andreas Färber
2012-09-17 9:03 ` [Qemu-devel] [RFC v0 10/10] serial: added fdt generic platform support Peter A. G. Crosthwaite
9 siblings, 1 reply; 16+ messages in thread
From: Peter A. G. Crosthwaite @ 2012-09-17 9:03 UTC (permalink / raw)
To: qemu-devel, edgar.iglesias; +Cc: peter.crosthwaite, crwulff
First revision of fdt generic platform for xilinx microblaze platforms.
Adds machine model "microblaze-fdt" which can be used along with the --hw-dtb
option to lauch dts driven machine models for microblaze platforms.
Signed-off-by: Peter A. G. Crosthwaite <peter.crosthwaite@petalogix.com>
---
hw/microblaze/Makefile.objs | 1 +
hw/microblaze_generic_fdt.c | 378 +++++++++++++++++++++++++++++++++++++++++++
2 files changed, 379 insertions(+), 0 deletions(-)
create mode 100644 hw/microblaze_generic_fdt.c
diff --git a/hw/microblaze/Makefile.objs b/hw/microblaze/Makefile.objs
index ef2d6b7..be3aaa5 100644
--- a/hw/microblaze/Makefile.objs
+++ b/hw/microblaze/Makefile.objs
@@ -1,5 +1,6 @@
obj-y = petalogix_s3adsp1800_mmu.o
obj-y += petalogix_ml605_mmu.o
+obj-y += microblaze_generic_fdt.o
obj-y += microblaze_boot.o
obj-y += microblaze_pic_cpu.o
diff --git a/hw/microblaze_generic_fdt.c b/hw/microblaze_generic_fdt.c
new file mode 100644
index 0000000..1a58210
--- /dev/null
+++ b/hw/microblaze_generic_fdt.c
@@ -0,0 +1,378 @@
+/*
+ * Model of Petalogix linux reference design for all boards
+ *
+ * Copyright (c) 2009 Edgar E. Iglesias.
+ * Copyright (c) 2009 Michal Simek.
+ * Copyright (c) 2012 Peter A.G. Crosthwaite (peter.croshtwaite@petalogix.com)
+ * Copyright (c) 2012 Petalogix Pty Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "sysbus.h"
+#include "net.h"
+#include "flash.h"
+#include "sysemu.h"
+#include "boards.h"
+#include "device_tree.h"
+#include "exec-memory.h"
+
+#include "fdt_generic_util.h"
+#include "fdt_generic_devices.h"
+
+#include "microblaze_pic_cpu.h"
+#include "microblaze_boot.h"
+
+#define VAL(name) qemu_devtree_getprop_cell(fdt, node_path, name, 0, false, \
+ NULL)
+
+static void
+microblaze_generic_fdt_reset(MicroBlazeCPU *cpu, void *fdt)
+{
+ CPUMBState *env = &cpu->env;
+
+ char node_path[DT_PATH_LENGTH];
+ qemu_devtree_get_node_by_name(fdt, node_path, "cpu@");
+ int t;
+ int use_exc = 0;
+
+ env->pvr.regs[0] = 0;
+ env->pvr.regs[2] = PVR2_D_OPB_MASK \
+ | PVR2_D_LMB_MASK \
+ | PVR2_I_OPB_MASK \
+ | PVR2_I_LMB_MASK \
+ | 0;
+
+ if (VAL("xlnx,pvr")) {
+ env->sregs[SR_MSR] |= MSR_PVR;
+ }
+
+ /* Even if we don't have PVR's, we fill out everything
+ because QEMU will internally follow what the pvr regs
+ state about the HW. */
+
+ if (VAL("xlnx,pvr") == 2) {
+ env->pvr.regs[0] |= PVR0_PVR_FULL_MASK;
+ }
+
+ if (VAL("xlnx,endianness")) {
+ env->pvr.regs[0] |= PVR0_ENDI;
+ }
+
+ if (VAL("xlnx,use-barrel")) {
+ env->pvr.regs[0] |= PVR0_USE_BARREL_MASK;
+ env->pvr.regs[2] |= PVR2_USE_BARREL_MASK;
+ }
+
+ if (VAL("xlnx,use-div")) {
+ env->pvr.regs[0] |= PVR0_USE_DIV_MASK;
+ env->pvr.regs[2] |= PVR2_USE_DIV_MASK;
+ }
+
+ t = VAL("xlnx,use-hw-mul");
+ if (t) {
+ env->pvr.regs[0] |= PVR0_USE_HW_MUL_MASK;
+ env->pvr.regs[2] |= PVR2_USE_HW_MUL_MASK;
+ if (t >= 2) {
+ env->pvr.regs[2] |= PVR2_USE_MUL64_MASK;
+ }
+ }
+
+ t = VAL("xlnx,use-fpu");
+ if (t) {
+ env->pvr.regs[0] |= PVR0_USE_FPU_MASK;
+ env->pvr.regs[2] |= PVR2_USE_FPU_MASK;
+ if (t > 1) {
+ env->pvr.regs[2] |= PVR2_USE_FPU2_MASK;
+ }
+ }
+
+ if (VAL("xlnx,use-msr-instr")) {
+ env->pvr.regs[2] |= PVR2_USE_MSR_INSTR;
+ }
+
+ if (VAL("xlnx,use-pcmp-instr")) {
+ env->pvr.regs[2] |= PVR2_USE_PCMP_INSTR;
+ }
+
+ if (VAL("xlnx,opcode-0x0-illegal")) {
+ env->pvr.regs[2] |= PVR2_OPCODE_0x0_ILL_MASK;
+ }
+
+ if (VAL("xlnx,unaligned-exceptions")) {
+ env->pvr.regs[2] |= PVR2_UNALIGNED_EXC_MASK;
+ use_exc = 1;
+ }
+
+ if (VAL("xlnx,ill-opcode-exception")) {
+ env->pvr.regs[2] |= PVR2_ILL_OPCODE_EXC_MASK;
+ use_exc = 1;
+ }
+
+ if (VAL("xlnx,iopb-bus-exception")) {
+ env->pvr.regs[2] |= PVR2_IOPB_BUS_EXC_MASK;
+ use_exc = 1;
+ }
+
+ if (VAL("xlnx,dopb-bus-exception")) {
+ env->pvr.regs[2] |= PVR2_DOPB_BUS_EXC_MASK;
+ use_exc = 1;
+ }
+
+ if (VAL("xlnx,div-zero-exception")) {
+ env->pvr.regs[2] |= PVR2_DIV_ZERO_EXC_MASK;
+ use_exc = 1;
+ }
+
+ if (VAL("xlnx,fpu-exception")) {
+ env->pvr.regs[2] |= PVR2_FPU_EXC_MASK;
+ use_exc = 1;
+ }
+
+ env->pvr.regs[0] |= VAL("xlnx,pvr-user1") & 0xff;
+ env->pvr.regs[1] = VAL("xlnx,pvr-user2");
+
+ /* MMU regs. */
+ t = VAL("xlnx,use-mmu");
+ if (use_exc || t) {
+ env->pvr.regs[0] |= PVR0_USE_EXC_MASK ;
+ }
+
+ if (t) {
+ env->pvr.regs[0] |= PVR0_USE_MMU;
+ }
+ env->pvr.regs[11] = t << 30;
+ t = VAL("xlnx,mmu-zones");
+ env->pvr.regs[11] |= t << 17;
+ env->mmu.c_mmu_zones = t;
+
+ t = VAL("xlnx,mmu-tlb-access");
+ env->mmu.c_mmu_tlb_access = t;
+ env->pvr.regs[11] |= t << 22;
+
+ {
+ char *str;
+ const struct {
+ const char *name;
+ unsigned int arch;
+ } arch_lookup[] = {
+ {"virtex2", 0x4},
+ {"virtex2pro", 0x5},
+ {"spartan3", 0x6},
+ {"virtex4", 0x7},
+ {"virtex5", 0x8},
+ {"spartan3e", 0x9},
+ {"spartan3a", 0xa},
+ {"spartan3an", 0xb},
+ {"spartan3adsp", 0xc},
+ {"spartan6", 0xd},
+ {"virtex6", 0xe},
+ {"spartan2", 0xf0},
+ {NULL, 0},
+ };
+ unsigned int i = 0;
+
+ str = qemu_devtree_getprop(fdt, node_path, "xlnx,family", NULL,
+ false, NULL);
+ while (arch_lookup[i].name && str) {
+ if (strcmp(arch_lookup[i].name, str) == 0) {
+ break;
+ }
+ i++;
+ }
+ if (!str || !arch_lookup[i].arch) {
+ env->pvr.regs[10] = 0x0c000000; /* spartan 3a dsp family. */
+ } else {
+ env->pvr.regs[10] = arch_lookup[i].arch << 24;
+ }
+ g_free(str);
+ }
+
+ {
+ char *str;
+ const struct {
+ const char *name;
+ unsigned int arch;
+ } cpu_lookup[] = {
+ /* These key value are as per MBV field in PVR0 */
+ {"5.00.a", 0x01},
+ {"5.00.b", 0x02},
+ {"5.00.c", 0x03},
+ {"6.00.a", 0x04},
+ {"6.00.b", 0x06},
+ {"7.00.a", 0x05},
+ {"7.00.b", 0x07},
+ {"7.10.a", 0x08},
+ {"7.10.b", 0x09},
+ {"7.10.c", 0x0a},
+ {"7.10.d", 0x0b},
+ {"7.20.a", 0x0c},
+ {"7.20.b", 0x0d},
+ {"7.20.c", 0x0e},
+ {"7.20.d", 0x0f},
+ {"7.30.a", 0x10},
+ {"7.30.b", 0x11},
+ {"8.00.a", 0x12},
+ {"8.00.b", 0x13},
+ {"8.10.a", 0x14},
+ /* FIXME There is no keycode defined in MBV for these versions */
+ {"2.10.a", 0x10},
+ {"3.00.a", 0x20},
+ {"4.00.a", 0x30},
+ {"4.00.b", 0x40},
+ {NULL, 0},
+ };
+ unsigned int i = 0;
+
+ str = qemu_devtree_getprop(fdt, node_path, "model", NULL, false, NULL);
+
+ while (cpu_lookup[i].name && str) {
+ if (strcmp(cpu_lookup[i].name, str + strlen("microblaze,")) == 0) {
+ break;
+ }
+ i++;
+ }
+ if (!str || !cpu_lookup[i].arch) {
+ fprintf(stderr, "unable to find MicroBlaze model.\n");
+ env->pvr.regs[0] |= 0xb << 8;
+ } else {
+ env->pvr.regs[0] |= cpu_lookup[i].arch << 8;
+ }
+ g_free(str);
+ }
+
+ {
+ env->pvr.regs[4] = PVR4_USE_ICACHE_MASK
+ | (21 << 26) /* Tag size. */
+ | (4 << 21)
+ | (11 << 16);
+ env->pvr.regs[6] = VAL("d-cache-baseaddr");
+ env->pvr.regs[7] = VAL("d-cache-highaddr");
+ env->pvr.regs[5] = PVR5_USE_DCACHE_MASK
+ | (21 << 26) /* Tag size. */
+ | (4 << 21)
+ | (11 << 16);
+
+ if (VAL("xlnx,dcache-use-writeback")) {
+ env->pvr.regs[5] |= PVR5_DCACHE_WRITEBACK_MASK;
+ }
+
+ env->pvr.regs[8] = VAL("i-cache-baseaddr");
+ env->pvr.regs[9] = VAL("i-cache-highaddr");
+ }
+}
+
+#define LMB_BRAM_SIZE (128 * 1024)
+
+#define MACHINE_NAME "microblaze-fdt"
+
+#ifdef TARGET_WORDS_BIGENDIAN
+int endian = 1;
+#else
+int endian;
+#endif
+
+static void
+microblaze_generic_fdt_init(ram_addr_t ram_size,
+ const char *boot_device,
+ const char *kernel_filename,
+ const char *kernel_cmdline,
+ const char *initrd_filename, const char *cpu_model)
+{
+ MicroBlazeCPU *cpu;
+ MemoryRegion *address_space_mem = get_system_memory();
+ MemoryRegion *lmb_bram = g_new(MemoryRegion, 1);
+ MemoryRegion *ddr_ram = g_new(MemoryRegion, 1);
+ target_phys_addr_t ram_base;
+ void *fdt = NULL;
+ const char *dtb_arg;
+ QemuOpts *machine_opts;
+ Error *errp = NULL;
+
+ /* for memory node */
+ char node_path[DT_PATH_LENGTH];
+
+ machine_opts = qemu_opts_find(qemu_find_opts("machine"), 0);
+ if (!machine_opts) {
+ goto no_dtb_arg;
+ }
+ dtb_arg = qemu_opt_get(machine_opts, "dtb");
+ if (!dtb_arg) {
+ goto no_dtb_arg;
+ }
+
+ fdt = load_device_tree(dtb_arg, NULL);
+ if (!fdt) {
+ hw_error("Error: Unable to load Device Tree %s\n", dtb_arg);
+ return;
+ }
+
+ /* init CPUs */
+ if (cpu_model == NULL) {
+ cpu_model = "microblaze";
+ }
+ cpu = cpu_mb_init(cpu_model);
+
+ /* find memory node */
+ /* FIXME it could be good to fix case when you don't find memory node */
+ qemu_devtree_get_node_by_name(fdt, node_path, "memory@");
+ ram_base = qemu_devtree_getprop_cell(fdt, node_path, "reg", 0,
+ false, &errp);
+ ram_size = qemu_devtree_getprop_cell(fdt, node_path, "reg", 1,
+ false, &errp);
+ assert_no_error(errp);
+
+ /* FIXME: instantiate from FDT like evrything else */
+ /* Attach emulated BRAM through the LMB. */
+ memory_region_init_ram(lmb_bram, "microblaze_fdt.lmb_bram", LMB_BRAM_SIZE);
+ vmstate_register_ram_global(lmb_bram);
+ memory_region_add_subregion(address_space_mem, 0, lmb_bram);
+
+ memory_region_init_ram(ddr_ram, "microblaze_fdt.ddr_ram", ram_size);
+ vmstate_register_ram_global(ddr_ram);
+ memory_region_add_subregion(address_space_mem, ram_base, ddr_ram);
+
+ /* Instantiate peripherals from the FDT. */
+ fdt_init_destroy_fdti(
+ fdt_generic_create_machine(fdt, microblaze_pic_init_cpu(&cpu->env)));
+
+ microblaze_load_kernel(cpu, ram_base, ram_size, NULL,
+ microblaze_generic_fdt_reset, fdt);
+ return;
+no_dtb_arg:
+ hw_error("DTB must be specified for %s machine model\n", MACHINE_NAME);
+ return;
+}
+
+static QEMUMachine microblaze_generic_fdt = {
+ .name = MACHINE_NAME,
+ .desc = "Petalogix FDT Generic, for all Microblaze MMU boards",
+ .init = microblaze_generic_fdt_init,
+};
+
+static void microblaze_fdt_init(void)
+{
+ qemu_register_machine(µblaze_generic_fdt);
+}
+
+machine_init(microblaze_fdt_init);
+
+fdt_register_compatibility(simple_bus_fdt_init, "xlnx,compound");
+fdt_register_compatibility_opaque(pflash_cfi01_fdt_init, "cfi-flash", 0,
+ &endian);
--
1.7.0.4
^ permalink raw reply related [flat|nested] 16+ messages in thread* Re: [Qemu-devel] [RFC v0 09/10] microblaze_generic_fdt: first revision
2012-09-17 9:03 ` [Qemu-devel] [RFC v0 09/10] microblaze_generic_fdt: first revision Peter A. G. Crosthwaite
@ 2012-09-17 15:20 ` Andreas Färber
2012-09-17 15:31 ` Paolo Bonzini
0 siblings, 1 reply; 16+ messages in thread
From: Andreas Färber @ 2012-09-17 15:20 UTC (permalink / raw)
To: Peter A. G. Crosthwaite
Cc: edgar.iglesias, crwulff, qemu-devel, Paolo Bonzini
Am 17.09.2012 11:03, schrieb Peter A. G. Crosthwaite:
> First revision of fdt generic platform for xilinx microblaze platforms.
> Adds machine model "microblaze-fdt" which can be used along with the --hw-dtb
> option to lauch dts driven machine models for microblaze platforms.
>
> Signed-off-by: Peter A. G. Crosthwaite <peter.crosthwaite@petalogix.com>
> ---
> hw/microblaze/Makefile.objs | 1 +
> hw/microblaze_generic_fdt.c | 378 +++++++++++++++++++++++++++++++++++++++++++
> 2 files changed, 379 insertions(+), 0 deletions(-)
> create mode 100644 hw/microblaze_generic_fdt.c
>
> diff --git a/hw/microblaze/Makefile.objs b/hw/microblaze/Makefile.objs
> index ef2d6b7..be3aaa5 100644
> --- a/hw/microblaze/Makefile.objs
> +++ b/hw/microblaze/Makefile.objs
> @@ -1,5 +1,6 @@
> obj-y = petalogix_s3adsp1800_mmu.o
> obj-y += petalogix_ml605_mmu.o
> +obj-y += microblaze_generic_fdt.o
> obj-y += microblaze_boot.o
>
> obj-y += microblaze_pic_cpu.o
[snip]
Since this file clearly is MicroBlaze-specific, I suggest to place it in
hw/microblaze/generic_fdt.c instead. (CC'ing Mr. Makefile)
Cheers,
Andreas
--
SUSE LINUX Products GmbH, Maxfeldstr. 5, 90409 Nürnberg, Germany
GF: Jeff Hawn, Jennifer Guild, Felix Imendörffer; HRB 16746 AG Nürnberg
^ permalink raw reply [flat|nested] 16+ messages in thread
* [Qemu-devel] [RFC v0 10/10] serial: added fdt generic platform support
2012-09-17 9:02 [Qemu-devel] [RFC v0 00/10] Microblaze generic FDT framework Peter A. G. Crosthwaite
` (8 preceding siblings ...)
2012-09-17 9:03 ` [Qemu-devel] [RFC v0 09/10] microblaze_generic_fdt: first revision Peter A. G. Crosthwaite
@ 2012-09-17 9:03 ` Peter A. G. Crosthwaite
9 siblings, 0 replies; 16+ messages in thread
From: Peter A. G. Crosthwaite @ 2012-09-17 9:03 UTC (permalink / raw)
To: qemu-devel, edgar.iglesias; +Cc: peter.crosthwaite, crwulff
fdt generic platform support for 16550 uarts.
Signed-off-by: Peter A. G. Crosthwaite <peter.crosthwaite@petalogix.com>
---
hw/fdt_generic_devices.c | 39 +++++++++++++++++++++++++++++++++++++--
1 files changed, 37 insertions(+), 2 deletions(-)
diff --git a/hw/fdt_generic_devices.c b/hw/fdt_generic_devices.c
index 91b3c5b..69017e8 100644
--- a/hw/fdt_generic_devices.c
+++ b/hw/fdt_generic_devices.c
@@ -1,4 +1,3 @@
-
#include "blockdev.h"
#include "fdt_generic_util.h"
@@ -42,4 +41,40 @@ int pflash_cfi01_fdt_init(char *node_path, FDTMachineInfo *fdti, void *opaque)
return 0;
}
-#endif /* CONFIG_FDT */
+static int uart16550_fdt_init(char *node_path, FDTMachineInfo *fdti,
+ void *priv)
+{
+ /* FIXME: Pass in dynamically */
+ MemoryRegion *address_space_mem = get_system_memory();
+ target_phys_addr_t base;
+ int baudrate;
+ qemu_irq irqline;
+ char irq_info[1024];
+ void *serial = NULL;
+ Error *errp = NULL;
+
+ base = qemu_devtree_getprop_cell(fdti->fdt, node_path, "reg", 0,
+ false, &errp);
+ base += qemu_devtree_getprop_cell(fdti->fdt, node_path, "reg-offset", 0,
+ false, &errp);
+ assert_no_error(errp);
+ base &= ~3ULL; /* qemu uart16550 model starts with 3* 8bit offset */
+
+ baudrate = qemu_devtree_getprop_cell(fdti->fdt, node_path, "current-speed",
+ 0, false, &errp);
+ if (errp) {
+ baudrate = 115200;
+ }
+
+ irqline = fdt_get_irq_info(fdti, node_path, 0 , NULL, irq_info);
+ printf("FDT: UART16550a: baseaddr: 0x"
+ TARGET_FMT_plx ", irq: %s, baud %d\n", base, irq_info, baudrate);
+
+ /* it_shift = 2, reg-shift in DTS - for Xilnx IP is hardcoded */
+ serial = serial_mm_init(address_space_mem, base, 2, irqline, baudrate,
+ qemu_char_get_next_serial(), DEVICE_LITTLE_ENDIAN);
+ return 0;
+}
+
+fdt_register_compatibility_n(uart16550_fdt_init, "ns16550", 0);
+fdt_register_compatibility_n(uart16550_fdt_init, "ns16550a", 1);
--
1.7.0.4
^ permalink raw reply related [flat|nested] 16+ messages in thread