make log a bit verbose for some useful information

[lunaix-os.git] / lunaix-os / kernel / device / devdb.c

diff --git a/lunaix-os/kernel/device/devdb.c b/lunaix-os/kernel/device/devdb.c
index cf58a9d982f3ea260e733a08eee8d6762f7ba48d..a41364df5557f799da79f3715c65aebf1a223118 100644 (file)
--- a/lunaix-os/kernel/device/devdb.c
+++ b/lunaix-os/kernel/device/devdb.c
@@ -1,58 +1,87 @@
 #include <lunaix/device.h>
 #include <lunaix/fs/twifs.h>
 #include <lunaix/status.h>
 #include <lunaix/device.h>
 #include <lunaix/fs/twifs.h>
 #include <lunaix/status.h>

+#include <lunaix/syslog.h>

 
 

-#include <klibc/stdio.h>
+#include <klibc/hash.h>
+
+#include <klibc/strfmt.h>
+
+LOG_MODULE("devdb")

 
 static DECLARE_HASHTABLE(dev_registry, 32);
 static DECLARE_HASHTABLE(dev_byif, 8);
 static DEFINE_LLIST(dev_registry_flat);
 
 
 static DECLARE_HASHTABLE(dev_registry, 32);
 static DECLARE_HASHTABLE(dev_byif, 8);
 static DEFINE_LLIST(dev_registry_flat);
 

-static struct device* adhoc_devcat;
+static struct device_cat* adhoc_devcat;
+
+static inline u32_t
+hash_dev(u32_t fngrp, u32_t dev)
+{
+    return (hash_32(fngrp, 16) << 16) | (hash_32(dev, 16));
+}

 
 void
 
 void

-device_register_all()
+device_scan_drivers()

 {
     adhoc_devcat = device_addcat(NULL, "adhoc");
 
     hashtable_init(dev_registry);
     hashtable_init(dev_byif);
 
 {
     adhoc_devcat = device_addcat(NULL, "adhoc");
 
     hashtable_init(dev_registry);
     hashtable_init(dev_byif);
 

-    int idx = 0;
+    int idx = 0, errno;

     struct device_def* devdef;
     ldga_foreach(devdefs, struct device_def*, idx, devdef)
     {
     struct device_def* devdef;
     ldga_foreach(devdefs, struct device_def*, idx, devdef)
     {

-        u32_t hash = devclass_hash(devdef->class);
-        devdef->class.hash = hash;
+        struct devclass* devc = &devdef->class;
+        u32_t hash = hash_dev(devc->fn_grp, devc->device);
+        devdef->class_hash = hash;
+
+        if (!devdef->name) {
+            devdef->name = "<unspecified>";
+        }
+
+        errno = 0;
+        if (devdef->ad_tabulam) {
+            errno = devdef->ad_tabulam(devdef);
+        }
+
+        if (errno) {
+            ERROR("driver unable to register %xh:%xh.%d (err=%d)",
+                    devdef->class.fn_grp, 
+                    devdef->class.device,
+                    devdef->class.variant, errno);
+            continue;
+        }

 
         hashtable_hash_in(dev_registry, &devdef->hlist, hash);
 
         hashtable_hash_in(dev_registry, &devdef->hlist, hash);

-        hashtable_hash_in(
-          dev_byif, &devdef->hlist_if, DEV_IF(devdef->class.meta));
+        hashtable_hash_in(dev_byif, &devdef->hlist_if, DEV_VN(devc->fn_grp));

 
         llist_append(&dev_registry_flat, &devdef->dev_list);
     }
 
         llist_append(&dev_registry_flat, &devdef->dev_list);
     }

+
+    INFO("%d drivers registered", idx + 1);

 }
 
 static int
 devclass_eq(struct devclass* c1, struct devclass* c2)
 {
 }
 
 static int
 devclass_eq(struct devclass* c1, struct devclass* c2)
 {

-    return c1->meta == c2->meta && c1->variant == c2->variant &&
-           c1->device == c2->device;
+    return c1->fn_grp == c2->fn_grp && c1->device == c2->device;

 }
 
 struct device_def*
 }
 
 struct device_def*

-devdef_byclass(struct devclass* class)
+devdef_byclass(struct devclass* devc)

 {
 {

-    u32_t hash = devclass_hash(*class);
+    u32_t hash = hash_dev(devc->fn_grp, devc->device);

     int errno;
 
     struct device_def *pos, *n;
     hashtable_hash_foreach(dev_registry, hash, pos, n, hlist)
     {
     int errno;
 
     struct device_def *pos, *n;
     hashtable_hash_foreach(dev_registry, hash, pos, n, hlist)
     {

-        if (pos->class.hash != hash) {
+        if (pos->class_hash != hash) {

             continue;
         }
             continue;
         }

-        if (devclass_eq(class, &pos->class)) {
+        if (devclass_eq(devc, &pos->class)) {

             break;
         }
     }
             break;
         }
     }


@@ -60,45 +89,12 @@ devdef_byclass(struct devclass* class)
     return pos;
 }
 
     return pos;
 }
 

-struct device*
-device_create_byclass(struct devclass* class,
-                      u32_t type,
-                      char* name,
-                      int* err_code)
+struct device_def*
+devdef_byident(struct devident* ident)

 {
 {

-    int errno;
-    struct device_def* devdef = devdef_byclass(class);
-
-    if (!devdef) {
-        *err_code = ENOENT;
-        return NULL;
-    }
-
-    if (!devdef->init_for) {
-        if (err_code) {
-            *err_code = ENOTSUP;
-        }
-        return NULL;
-    }
-
-    struct device* dev = device_add(adhoc_devcat, NULL, type, NULL);
-
-    errno = devdef->init_for(devdef, dev);
-    if (err_code && !errno) {
-        *err_code = errno;
-        device_remove(dev);
-        return NULL;
-    }
-
-    device_setname(dev,
-                   "%s_%d:%d:%d_%d",
-                   name,
-                   class->meta,
-                   class->device,
-                   class->device,
-                   dev->dev_id);
-
-    return dev;
+    struct devclass derived = { .device = DEV_KIND_FROM(ident->unique),
+                                .fn_grp = ident->fn_grp };
+    return devdef_byclass(&derived);

 }
 
 struct hbucket*
 }
 
 struct hbucket*


@@ -107,32 +103,33 @@ device_definitions_byif(int if_type)
     return &dev_byif[__hashkey(dev_byif, if_type)];
 }
 
     return &dev_byif[__hashkey(dev_byif, if_type)];
 }
 

-#define device_load_on_stage(stage)                                            \
+#define __device_load_on_stage(stage)                                          \

     ({                                                                         \
         int idx = 0;                                                           \
         struct device_def* devdef;                                             \
     ({                                                                         \
         int idx = 0;                                                           \
         struct device_def* devdef;                                             \

-        ldga_foreach(dev_ld_##stage, struct device_def*, idx, devdef)          \
+        ldga_foreach(dev_##stage, struct device_def*, idx, devdef)             \

         {                                                                      \
         {                                                                      \

-            devdef->init(devdef);                                              \
+            device_chain_load_once(devdef);                                    \

         }                                                                      \
     })
         }                                                                      \
     })

+#define device_load_on_stage(stage) __device_load_on_stage(stage)

 
 void
 
 void

-device_earlystage()
+device_onboot_load()

 {
 {

-    device_load_on_stage(early);
+    device_load_on_stage(load_onboot);

 }
 
 void
 }
 
 void

-device_timerstage()
+device_postboot_load()

 {
 {

-    device_load_on_stage(aftertimer);
+    device_load_on_stage(load_postboot);

 }
 
 void
 }
 
 void

-device_poststage()
+device_sysconf_load()

 {
 {

-    device_load_on_stage(post);
+    device_load_on_stage(load_sysconf);

 }
 
 static int
 }
 
 static int


@@ -150,25 +147,32 @@ __devdb_db_gonext(struct twimap* mapping)
 static void
 __devdb_twifs_lsdb(struct twimap* mapping)
 {
 static void
 __devdb_twifs_lsdb(struct twimap* mapping)
 {

-    char flags[32];
+    char flags[64];

     struct device_def* def = twimap_index(mapping, struct device_def*);
 
     struct device_def* def = twimap_index(mapping, struct device_def*);
 

-    int meta = def->class.meta;
-    ksnprintf(flags, 32, "if=%x,fn=%x", DEV_IF(meta), DEV_FN(meta));
+    int meta = def->class.fn_grp;
+    ksnprintf(flags, 64, "vn=%x, fn=%x", DEV_VN(meta), DEV_FN(meta));

 
     twimap_printf(mapping,
 
     twimap_printf(mapping,

-                  "%d:%d:%d %s (%s)\n",
-                  def->class.meta,
+                  "%08xh:%04d \"%s\" %s\n",
+                  def->class.fn_grp,

                   def->class.device,
                   def->class.device,

-                  def->class.variant,

                   def->name,
                   flags);
 }
 
                   def->name,
                   flags);
 }
 

+void
+__devdb_reset(struct twimap* map)
+{
+    map->index =
+      container_of(dev_registry_flat.next, struct device_def, dev_list);
+}
+

 static void
 devdb_twifs_plugin()
 {
     struct twimap* map = twifs_mapping(NULL, NULL, "devtab");
 static void
 devdb_twifs_plugin()
 {
     struct twimap* map = twifs_mapping(NULL, NULL, "devtab");

+    map->reset = __devdb_reset;

     map->read = __devdb_twifs_lsdb;
     map->go_next = __devdb_db_gonext;
 }
     map->read = __devdb_twifs_lsdb;
     map->go_next = __devdb_db_gonext;
 }