modify platform_ofw

Author: fangjianzhou

components/drivers/core/platform_ofw.c

@@ -17,6 +17,8 @@
 #include <drivers/platform.h>
 #include <drivers/core/dm.h>
 
+#include "../ofw/ofw_internal.h"
+
 static const struct rt_ofw_node_id platform_ofw_ids[] =
 {
     { .compatible = "simple-bus", },
@@ -35,11 +37,32 @@ static const struct rt_ofw_node_id platform_ofw_ids[] =
 #endif
     { /* sentinel */ }
 };
+static struct rt_platform_device *alloc_ofw_platform_device(struct rt_ofw_node *np)
+{
+    struct rt_platform_device *pdev = rt_platform_device_alloc(np->name);
+
+    if (pdev)
+    {
+        /* inc reference of dt-node */
+        rt_ofw_node_get(np);
+        rt_ofw_node_set_flag(np, RT_OFW_F_PLATFORM);
+
+#ifdef RT_USING_OFW
+        pdev->parent.ofw_node = np;
+#endif
+    }
+    else
+    {
+        LOG_E("Alloc device fail for %s", rt_ofw_node_full_name(np));
+    }
+
+    return pdev;
+}
 
 static rt_err_t platform_ofw_device_probe_once(struct rt_ofw_node *parent_np)
 {
     rt_err_t err = RT_EOK;
-    struct rt_ofw_node *np, *child;
+    struct rt_ofw_node *np;
     struct rt_platform_device *pdev;
 
     rt_ofw_foreach_available_child_node(parent_np, np)
@@ -48,6 +71,8 @@ static rt_err_t platform_ofw_device_probe_once(struct rt_ofw_node *parent_np)
         struct rt_ofw_node_id *id;
         struct rt_ofw_prop *compat_prop = RT_NULL;
 
+        LOG_D("%s found in %s", np->full_name, parent_np->full_name);
+
         /* Is system node or have driver */
         if (rt_ofw_node_test_flag(np, RT_OFW_F_SYSTEM) ||
             rt_ofw_node_test_flag(np, RT_OFW_F_READLY))
@@ -66,54 +91,91 @@ static rt_err_t platform_ofw_device_probe_once(struct rt_ofw_node *parent_np)
 
         id = rt_ofw_prop_match(compat_prop, platform_ofw_ids);
 
-        if (id && (child = rt_ofw_get_next_child(np, RT_NULL)))
+        if (id && np->child)
         {
             /* scan next level */
-            err = platform_ofw_device_probe_once(child);
-
-            rt_ofw_node_put(child);
+            err = platform_ofw_device_probe_once(np);
 
             if (err)
             {
+                rt_ofw_node_put(np);
                 LOG_E("%s bus probe fail", np->full_name);
 
                 break;
             }
         }
 
-        pdev = rt_platform_device_alloc(np->name);
+        pdev = alloc_ofw_platform_device(np);
 
         if (!pdev)
         {
+            rt_ofw_node_put(np);
             err = -RT_ENOMEM;
 
             break;
         }
 
-        /* inc reference of dt-node */
-        rt_ofw_node_get(np);
-        rt_ofw_node_set_flag(np, RT_OFW_F_PLATFORM);
-
-        pdev->parent.ofw_node = np;
+        pdev->dev_id = ofw_alias_node_id(np);
+        LOG_D("%s register to bus", np->full_name);
 
         rt_platform_device_register(pdev);
     }
 
     return err;
 }
 
+rt_err_t rt_platform_ofw_device_probe_child(struct rt_ofw_node *np)
+{
+    rt_err_t err;
+    struct rt_ofw_node *parent = rt_ofw_get_parent(np);
+
+    if (parent && rt_strcmp(parent->name, "/") &&
+        rt_ofw_get_prop(np, "compatible", RT_NULL) &&
+        !rt_ofw_node_test_flag(np, RT_OFW_F_PLATFORM))
+    {
+        struct rt_platform_device *pdev = alloc_ofw_platform_device(np);
+
+        if (pdev)
+        {
+            err = rt_platform_device_register(pdev);
+        }
+        else
+        {
+            err = -RT_ENOMEM;
+        }
+    }
+    else
+    {
+        err = -RT_EINVAL;
+    }
+
+    rt_ofw_node_put(parent);
+
+    return err;
+}
+
 static int platform_ofw_device_probe(void)
 {
     rt_err_t err = RT_EOK;
-    struct rt_ofw_node *root_np;
-
-    root_np = rt_ofw_find_node_by_path("/");
+    struct rt_ofw_node *node;
 
-    if (root_np)
+    if (ofw_node_root)
     {
-        err = platform_ofw_device_probe_once(root_np);
+        err = platform_ofw_device_probe_once(ofw_node_root);
 
-        rt_ofw_node_put(root_np);
+        rt_ofw_node_put(ofw_node_root);
+
+        if ((node = rt_ofw_find_node_by_path("/firmware")))
+        {
+            platform_ofw_device_probe_once(node);
+            rt_ofw_node_put(node);
+        }
+
+        if ((node = rt_ofw_get_child_by_compatible(ofw_node_chosen, "simple-framebuffer")))
+        {
+            platform_ofw_device_probe_once(node);
+            rt_ofw_node_put(node);
+        }
     }
     else
     {

components/drivers/include/drivers/platform.h

@@ -22,6 +22,8 @@ struct rt_platform_device
 {
     struct rt_device parent;
 
+    int dev_id;
+
     const char *name;
 
 #ifdef RT_USING_OFW
@@ -49,6 +51,8 @@ struct rt_platform_device *rt_platform_device_alloc(const char *name);
 rt_err_t rt_platform_driver_register(struct rt_platform_driver *pdrv);
 rt_err_t rt_platform_device_register(struct rt_platform_device *pdev);
 
+rt_err_t rt_platform_ofw_device_probe_child(struct rt_ofw_node *np);
+
 #define RT_PLATFORM_DRIVER_EXPORT(driver)  RT_DRIVER_EXPORT(driver, platform, BUILIN)
 
 #endif /* __PLATFORM_H__ */

components/drivers/ofw/base.c

@@ -1092,6 +1092,32 @@ struct rt_ofw_node *rt_ofw_get_alias_node(const char *tag, int id)
     return np;
 }
 
+int ofw_alias_node_id(struct rt_ofw_node *np)
+{
+    int id;
+    struct alias_info *info;
+
+    if (np)
+    {
+        id = -1;
+
+        rt_list_for_each_entry(info, &_aliases_nodes, list)
+        {
+            if (info->np == np)
+            {
+                id = info->id;
+                break;
+            }
+        }
+    }
+    else
+    {
+        id = -RT_EINVAL;
+    }
+
+    return id;
+}
+
 int rt_ofw_get_alias_id(struct rt_ofw_node *np, const char *tag)
 {
     int id;

components/drivers/ofw/ofw_internal.h

@@ -68,6 +68,7 @@ extern struct rt_fdt_earlycon fdt_earlycon;
     (to_type)(((value) >> ((sizeof(value) - sizeof(to_type)) * 8)))
 
 rt_err_t ofw_alias_scan(void);
+int ofw_alias_node_id(struct rt_ofw_node *np);
 rt_err_t ofw_phandle_hash_reset(rt_phandle min, rt_phandle max);
 
 #endif /* __OFW_INTERNAL_H__ */