merge HAL support from Shams E. King

git-svn-id: file:///home/lennart/svn/public/pulseaudio/trunk@1187 fefdeb5f-60dc-0310-8127-8f9354f1896f

3 files changed, 885 insertions, 0 deletions

diff --git a/src/modules/dbus-util.c b/src/modules/dbus-util.c
new file mode 100644
index 00000000..0c9978e7
--- /dev/null
+++ b/src/modules/dbus-util.c
@@ -0,0 +1,354 @@
+/***
+  This file is part of PulseAudio.
+ 
+  PulseAudio is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Lesser General Public License as published
+  by the Free Software Foundation; either version 2 of the License,
+  or (at your option) any later version.
+ 
+  PulseAudio is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+  General Public License for more details.
+ 
+  You should have received a copy of the GNU Lesser General Public License
+  along with PulseAudio; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+  USA.
+***/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <assert.h>
+#include <pulsecore/log.h>
+#include <pulsecore/props.h>
+#include <pulse/xmalloc.h>
+
+#include "dbus-util.h"
+
+struct pa_dbus_connection {
+    int refcount;
+    pa_core *core;
+    DBusConnection *connection;
+    const char *property_name;
+    pa_defer_event* dispatch_event;
+};
+
+static void dispatch_cb(pa_mainloop_api *ea, pa_defer_event *ev, void *userdata)
+{
+    DBusConnection *conn = (DBusConnection *) userdata;
+    if (dbus_connection_dispatch(conn) == DBUS_DISPATCH_COMPLETE) {
+        /* no more data to process, disable the deferred */
+        ea->defer_enable(ev, 0);
+    }
+}
+
+/* DBusDispatchStatusFunction callback for the pa mainloop */
+static void dispatch_status(DBusConnection *conn, DBusDispatchStatus status,
+                            void *userdata)
+{
+    pa_dbus_connection *c = (pa_dbus_connection*) userdata;
+    switch(status) {
+        case DBUS_DISPATCH_COMPLETE:
+            c->core->mainloop->defer_enable(c->dispatch_event, 0);
+            break;
+        case DBUS_DISPATCH_DATA_REMAINS:
+        case DBUS_DISPATCH_NEED_MEMORY:
+        default:
+            c->core->mainloop->defer_enable(c->dispatch_event, 1);
+            break;
+    }
+}
+
+static pa_io_event_flags_t
+get_watch_flags(DBusWatch *watch)
+{
+    unsigned int flags = dbus_watch_get_flags(watch);
+    pa_io_event_flags_t events = PA_IO_EVENT_HANGUP | PA_IO_EVENT_ERROR;
+
+    /* no watch flags for disabled watches */
+    if (!dbus_watch_get_enabled(watch))
+        return PA_IO_EVENT_NULL;
+
+    if (flags & DBUS_WATCH_READABLE)
+        events |= PA_IO_EVENT_INPUT;
+    if (flags & DBUS_WATCH_WRITABLE)
+        events |= PA_IO_EVENT_OUTPUT;
+
+    return events;
+}
+
+static void timeval_next(struct timeval *tv, int millint)
+{
+    /* number of seconds in the milli-second interval */
+    tv->tv_sec += (millint / 1000);
+    /* milliseconds minus the seconds portion, converted to microseconds */
+    tv->tv_usec += (millint - tv->tv_sec * 1000) * 1000;
+}
+
+/* pa_io_event_cb_t IO event handler */
+static void handle_io_event(PA_GCC_UNUSED pa_mainloop_api *ea, pa_io_event *e,
+                            int fd, pa_io_event_flags_t events, void *userdata)
+{
+    unsigned int flags = 0;
+    DBusWatch *watch = (DBusWatch*) userdata;
+
+    assert(fd == dbus_watch_get_fd(watch));
+
+    if (!dbus_watch_get_enabled(watch)) {
+        pa_log_warn(__FILE__": Asked to handle disabled watch: %p %i",
+                    (void *) watch, fd);
+        return;
+    }
+
+    if (events & PA_IO_EVENT_INPUT)
+        flags |= DBUS_WATCH_READABLE;
+    if (events & PA_IO_EVENT_OUTPUT)
+        flags |= DBUS_WATCH_WRITABLE;
+    if (events & PA_IO_EVENT_HANGUP)
+        flags |= DBUS_WATCH_HANGUP;
+    if (events & PA_IO_EVENT_ERROR)
+        flags |= DBUS_WATCH_ERROR;
+
+    dbus_watch_handle(watch, flags);
+}
+
+/* pa_time_event_cb_t timer event handler */
+static void handle_time_event(pa_mainloop_api *ea, pa_time_event* e,
+                              const struct timeval *tv, void *userdata)
+{
+    DBusTimeout *timeout = (DBusTimeout*) userdata;
+
+    if (dbus_timeout_get_enabled(timeout)) {
+        struct timeval next = *tv;
+        dbus_timeout_handle(timeout);
+
+        /* restart it for the next scheduled time */
+        timeval_next(&next, dbus_timeout_get_interval(timeout));
+        ea->time_restart(e, &next);
+    }
+}
+
+/* DBusAddWatchFunction callback for pa mainloop */
+static dbus_bool_t add_watch(DBusWatch *watch, void *data)
+{
+    pa_io_event *ev;
+    pa_core *c = (pa_core*) data;
+
+    ev = c->mainloop->io_new(c->mainloop, dbus_watch_get_fd(watch),
+                             get_watch_flags(watch),
+                             handle_io_event, (void*) watch);
+    if (NULL == ev)
+        return FALSE;
+
+    /* dbus_watch_set_data(watch, (void*) ev, c->mainloop->io_free); */
+    dbus_watch_set_data(watch, (void*) ev, NULL);
+
+    return TRUE;
+}
+
+/* DBusRemoveWatchFunction callback for pa mainloop */
+static void remove_watch(DBusWatch *watch, void *data)
+{
+    pa_core *c = (pa_core*) data;
+    pa_io_event *ev = (pa_io_event*) dbus_watch_get_data(watch);
+
+    /* free the event */
+    if (NULL != ev)
+        c->mainloop->io_free(ev);
+}
+
+/* DBusWatchToggledFunction callback for pa mainloop */
+static void toggle_watch(DBusWatch *watch, void *data)
+{
+    pa_core *c = (pa_core*) data;
+    pa_io_event *ev = (pa_io_event*) dbus_watch_get_data(watch);
+
+    /* get_watch_flags() checks if the watch is enabled */
+    c->mainloop->io_enable(ev, get_watch_flags(watch));
+}
+
+/* DBusAddTimeoutFunction callback for pa mainloop */
+static dbus_bool_t add_timeout(DBusTimeout *timeout, void *data)
+{
+    struct timeval tv;
+    pa_time_event *ev;
+    pa_core *c = (pa_core*) data;
+
+    if (!dbus_timeout_get_enabled(timeout))
+        return FALSE;
+
+    if (gettimeofday(&tv, NULL) < 0)
+        return -1;
+
+    timeval_next(&tv, dbus_timeout_get_interval(timeout));
+
+    ev = c->mainloop->time_new(c->mainloop, &tv, handle_time_event,
+                               (void*) timeout);
+    if (NULL == ev)
+        return FALSE;
+
+    /* dbus_timeout_set_data(timeout, (void*) ev, c->mainloop->time_free); */
+    dbus_timeout_set_data(timeout, (void*) ev, NULL);
+
+    return TRUE;
+}
+
+/* DBusRemoveTimeoutFunction callback for pa mainloop */
+static void remove_timeout(DBusTimeout *timeout, void *data)
+{
+    pa_core *c = (pa_core*) data;
+    pa_time_event *ev = (pa_time_event*) dbus_timeout_get_data(timeout);
+
+    /* free the event */
+    if (NULL != ev)
+        c->mainloop->time_free(ev);
+}
+
+/* DBusTimeoutToggledFunction callback for pa mainloop */
+static void toggle_timeout(DBusTimeout *timeout, void *data)
+{
+    struct timeval tv;
+    pa_core *c = (pa_core*) data;
+    pa_time_event *ev = (pa_time_event*) dbus_timeout_get_data(timeout);
+
+    gettimeofday(&tv, NULL);
+    if (dbus_timeout_get_enabled(timeout)) {
+        timeval_next(&tv, dbus_timeout_get_interval(timeout));
+        c->mainloop->time_restart(ev, &tv);
+    } else {
+        /* set it to expire one second ago */
+        tv.tv_sec -= 1;
+        c->mainloop->time_restart(ev, &tv);
+    }
+}
+
+static void
+pa_dbus_connection_free(pa_dbus_connection *c)
+{
+    assert(c);
+    assert(!dbus_connection_get_is_connected(c->connection));
+
+    /* already disconnected, just free */
+    pa_property_remove(c->core, c->property_name);
+    c->core->mainloop->defer_free(c->dispatch_event);
+    dbus_connection_unref(c->connection);
+    pa_xfree(c);
+}
+
+static void
+wakeup_main(void *userdata)
+{
+    pa_dbus_connection *c = (pa_dbus_connection*) userdata;
+    /* this will wakeup the mainloop and dispatch events, although
+     * it may not be the cleanest way of accomplishing it */
+    c->core->mainloop->defer_enable(c->dispatch_event, 1);
+}
+
+static pa_dbus_connection* pa_dbus_connection_new(pa_core* c, DBusConnection *conn, const char* name)
+{
+    pa_dbus_connection *pconn = pa_xmalloc(sizeof(pa_dbus_connection));
+
+    pconn->refcount = 1;
+    pconn->core = c;
+    pconn->property_name = name;
+    pconn->connection = conn;
+    pconn->dispatch_event = c->mainloop->defer_new(c->mainloop, dispatch_cb,
+                                                   (void*) conn);
+
+    pa_property_set(c, name, pconn);
+
+    return pconn;
+}
+
+DBusConnection* pa_dbus_connection_get(pa_dbus_connection *c)
+{
+    assert(c && c->connection);
+    return c->connection;
+}
+
+void pa_dbus_connection_unref(pa_dbus_connection *c)
+{
+    assert(c);
+
+    /* non-zero refcount, still outstanding refs */
+    if (--(c->refcount))
+        return;
+
+    /* refcount is zero */
+    if (dbus_connection_get_is_connected(c->connection)) {
+        /* disconnect as we have no more internal references */
+        dbus_connection_close(c->connection);
+        /* must process remaining messages, bit of a kludge to
+         * handle both unload and shutdown */
+        while(dbus_connection_read_write_dispatch(c->connection, -1));
+    }
+    pa_dbus_connection_free(c);
+}
+
+pa_dbus_connection* pa_dbus_connection_ref(pa_dbus_connection *c)
+{
+    assert(c);
+
+    ++(c->refcount);
+
+    return c;
+}
+
+pa_dbus_connection* pa_dbus_bus_get(pa_core *c, DBusBusType type,
+                                    DBusError *error)
+{
+    const char* name;
+    DBusConnection *conn;
+    pa_dbus_connection *pconn;
+    static const char sysname[] = "dbus-connection-system";
+    static const char sessname[] = "dbus-connection-session";
+    static const char startname[] = "dbus-connection-starter";
+
+    switch (type) {
+        case DBUS_BUS_SYSTEM:
+            name = sysname;
+            break;
+        case DBUS_BUS_SESSION:
+            name = sessname;
+            break;
+        case DBUS_BUS_STARTER:
+            name = startname;
+            break;
+        default:
+            assert(0); /* never reached */
+            break;
+    }
+
+    if ((pconn = pa_property_get(c, name)))
+        return pa_dbus_connection_ref(pconn);
+
+    /* else */
+    conn = dbus_bus_get_private(type, error);
+    if (conn == NULL || dbus_error_is_set(error)) {
+        return NULL;
+    }
+
+    pconn = pa_dbus_connection_new(c, conn, name);
+
+    /* don't exit on disconnect */
+    dbus_connection_set_exit_on_disconnect(conn, FALSE);
+    /* set up the DBUS call backs */
+    dbus_connection_set_dispatch_status_function(conn, dispatch_status,
+                                                 (void*) pconn, NULL);
+    dbus_connection_set_watch_functions(conn,
+                                        add_watch,
+                                        remove_watch,
+                                        toggle_watch,
+                                        (void*) c, NULL);
+    dbus_connection_set_timeout_functions(conn,
+                                          add_timeout,
+                                          remove_timeout,
+                                          toggle_timeout,
+                                          (void*) c, NULL);
+    dbus_connection_set_wakeup_main_function(conn, wakeup_main, pconn, NULL);
+
+    return pconn;
+}
diff --git a/src/modules/dbus-util.h b/src/modules/dbus-util.h
new file mode 100644
index 00000000..d5d5b36a
--- /dev/null
+++ b/src/modules/dbus-util.h
@@ -0,0 +1,36 @@
+#ifndef foodbusutilhfoo
+#define foodbusutilhfoo
+
+/***
+  This file is part of PulseAudio.
+ 
+  PulseAudio is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Lesser General Public License as published
+  by the Free Software Foundation; either version 2 of the License,
+  or (at your option) any later version.
+ 
+  PulseAudio is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+  General Public License for more details.
+ 
+  You should have received a copy of the GNU Lesser General Public License
+  along with PulseAudio; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+  USA.
+***/
+
+#include <dbus/dbus.h>
+
+typedef struct pa_dbus_connection pa_dbus_connection;
+
+/* return the DBusConnection of the specified type for the given core,
+ * like dbus_bus_get(), but integrates the connection with the pa_core */
+pa_dbus_connection* pa_dbus_bus_get(pa_core *c, DBusBusType type, DBusError *error);
+
+DBusConnection* pa_dbus_connection_get(pa_dbus_connection *conn);
+
+pa_dbus_connection* pa_dbus_connection_ref(pa_dbus_connection *conn);
+void pa_dbus_connection_unref(pa_dbus_connection *conn);
+
+#endif
diff --git a/src/modules/module-hal-detect.c b/src/modules/module-hal-detect.c
new file mode 100644
index 00000000..1c15a2d1
--- /dev/null
+++ b/src/modules/module-hal-detect.c
@@ -0,0 +1,495 @@
+/***
+  This file is part of PulseAudio.
+ 
+  PulseAudio is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Lesser General Public License as published
+  by the Free Software Foundation; either version 2 of the License,
+  or (at your option) any later version.
+ 
+  PulseAudio is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+  General Public License for more details.
+ 
+  You should have received a copy of the GNU Lesser General Public License
+  along with PulseAudio; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+  USA.
+***/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <assert.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include <pulse/xmalloc.h>
+
+#include <pulsecore/core-error.h>
+#include <pulsecore/module.h>
+#include <pulsecore/log.h>
+#include <pulsecore/core-subscribe.h>
+#include <pulsecore/hashmap.h>
+#include <pulsecore/idxset.h>
+#include <pulsecore/core-util.h>
+
+#include <hal/libhal.h>
+
+#include "dbus-util.h"
+#include "module-hal-detect-symdef.h"
+
+PA_MODULE_AUTHOR("Shahms King")
+PA_MODULE_DESCRIPTION("Detect available audio hardware and load matching drivers")
+PA_MODULE_VERSION(PACKAGE_VERSION)
+
+static const char* capabilities[] = { "alsa", "oss" };
+
+typedef enum {
+    CAP_ALSA,
+    CAP_OSS,
+    CAP_MAX
+} capability_t;
+
+typedef enum {
+    ALSA_TYPE_SINK,
+    ALSA_TYPE_SOURCE,
+    ALSA_TYPE_OTHER,
+    ALSA_TYPE_MAX
+} alsa_type_t;
+
+struct device {
+    char *udi;
+    pa_module *module;
+};
+
+struct userdata {
+    pa_core *core;
+    pa_subscription *sub;
+    LibHalContext *ctx;
+    capability_t capability;
+    pa_dbus_connection *conn;
+    pa_hashmap *by_udi;
+    pa_hashmap *by_module;
+};
+
+struct timerdata {
+    struct userdata *u;
+    char *udi;
+};
+
+static alsa_type_t hal_device_get_alsa_type(LibHalContext *ctx, const char *udi,
+                                            DBusError *error)
+{
+    char *type;
+    alsa_type_t t;
+
+    type = libhal_device_get_property_string(ctx, udi, "alsa.type", error);
+    if (!type || dbus_error_is_set(error))
+        return FALSE;
+
+    if (!strcmp(type, "playback")) {
+        t = ALSA_TYPE_SINK;
+    } else if (!strcmp(type, "capture")) {
+        t = ALSA_TYPE_SOURCE;
+    } else {
+        t = ALSA_TYPE_OTHER;
+    }
+    libhal_free_string(type);
+
+    return t;
+}
+
+static int hal_device_get_alsa_card(LibHalContext *ctx, const char *udi,
+                                    DBusError *error)
+{
+    return libhal_device_get_property_int(ctx, udi, "alsa.card", error);
+}
+
+static int hal_device_get_alsa_device(LibHalContext *ctx, const char *udi,
+                                      DBusError *error)
+{
+    return libhal_device_get_property_int(ctx, udi, "alsa.device", error);
+}
+
+static void hal_device_free(struct device* d) {
+    pa_xfree(d->udi);
+    pa_xfree(d);
+}
+
+static void hal_device_free_cb(void *d, PA_GCC_UNUSED void *data) {
+    hal_device_free((struct device*) d);
+}
+
+static dbus_bool_t hal_device_add_alsa(struct userdata *u, const char *udi,
+                                       DBusError  *error)
+{
+    char args[64];
+    alsa_type_t type;
+    int device, card;
+    pa_module *m;
+    struct device *d;
+    const char *module_name;
+
+    type = hal_device_get_alsa_type(u->ctx, udi, error);
+    if (dbus_error_is_set(error) || type == ALSA_TYPE_OTHER) {
+        return FALSE;
+    }
+
+    device = hal_device_get_alsa_device(u->ctx, udi, error);
+    if (dbus_error_is_set(error) || device != 0)
+        return FALSE;
+
+    card = hal_device_get_alsa_card(u->ctx, udi, error);
+    if (dbus_error_is_set(error))
+        return FALSE;
+
+    module_name = (type == ALSA_TYPE_SINK) ? "module-alsa-sink"
+                                           : "module-alsa-source";
+    snprintf(args, sizeof(args), "device=hw:%u", card);
+    if (!(m = pa_module_load(u->core, module_name, args)))
+        return FALSE;
+
+    d = pa_xmalloc(sizeof(struct device));
+    d->udi = pa_xstrdup(udi);
+    d->module = m;
+
+    pa_hashmap_put(u->by_module, m, d);
+    pa_hashmap_put(u->by_udi, udi, d);
+
+    return TRUE;
+}
+
+static int hal_device_add_all(struct userdata *u, capability_t capability)
+{
+    DBusError error;
+    int i,n,count;
+    dbus_bool_t r;
+    char** udis;
+    const char* cap = capabilities[capability];
+
+    assert(capability < CAP_MAX);
+
+    pa_log_info(__FILE__": Trying capability %u (%s)", capability, cap);
+    dbus_error_init(&error);
+    udis = libhal_find_device_by_capability(u->ctx, cap, &n, &error);
+    if (dbus_error_is_set(&error)) {
+        pa_log_error(__FILE__": Error finding devices: %s: %s", error.name,
+                     error.message);
+        dbus_error_free(&error);
+        return -1;
+    }
+    count = 0;
+    for (i = 0; i < n; ++i) {
+        switch(capability) {
+            case CAP_ALSA:
+                r = hal_device_add_alsa(u, udis[i], &error);
+                break;
+            case CAP_OSS:
+                /* r = hal_device_add_oss(u, udis[i], &error)
+                 * break; */
+            case CAP_MAX:
+            default:
+                assert(FALSE);
+                break;
+        }
+
+        if (dbus_error_is_set(&error)) {
+            pa_log_error(__FILE__": Error adding device: %s: %s", error.name,
+                         error.message);
+            dbus_error_free(&error);
+            count = -1;
+            break;
+        }
+        if (r)
+            ++count;
+    }
+
+    libhal_free_string_array(udis);
+    u->capability = capability;
+    return count;
+}
+
+static dbus_bool_t device_has_capability(LibHalContext *ctx, const char *udi,
+                                         const char* cap, DBusError *error)
+{
+    dbus_bool_t has_prop;
+    has_prop = libhal_device_property_exists(ctx, udi, "info.capabilities",
+                                            error);
+    if (!has_prop || dbus_error_is_set(error))
+        return FALSE;
+
+    return libhal_device_query_capability(ctx, udi, cap, error);
+}
+
+static void device_added_time_cb(pa_mainloop_api *ea, pa_time_event *ev,
+                                 const struct timeval *tv, void *userdata)
+{
+    DBusError error;
+    struct timerdata *td = (struct timerdata*) userdata;
+
+    dbus_error_init(&error);
+    if (!libhal_device_exists(td->u->ctx, td->udi, &error))
+        goto exit;
+
+    switch(td->u->capability) {
+        case CAP_ALSA:
+            hal_device_add_alsa(td->u, td->udi, &error);
+            break;
+        case CAP_OSS:
+            /* hal_device_add_oss(td->u, td->udi, &error);
+             * break; */
+        case CAP_MAX:
+        default:
+            /* not reached */
+            assert(FALSE);
+            break;
+    }
+
+exit:
+    if (dbus_error_is_set(&error)) {
+        pa_log_error(__FILE__": Error adding device: %s: %s", error.name,
+                     error.message);
+        dbus_error_free(&error);
+    }
+
+    pa_xfree(td->udi);
+    pa_xfree(td);
+    ea->time_free(ev);
+}
+
+static void device_added_cb(LibHalContext *ctx, const char *udi)
+{
+    DBusError error;
+    struct timeval tv;
+    dbus_bool_t has_cap;
+    struct timerdata *t;
+    struct userdata *u = (struct userdata*) libhal_ctx_get_user_data(ctx);
+    const char* cap = capabilities[u->capability];
+
+    pa_log_debug(__FILE__": HAL Device added: %s", udi);
+
+    dbus_error_init(&error);
+    has_cap = device_has_capability(ctx, udi, cap, &error);
+    if (dbus_error_is_set(&error)) {
+        pa_log_error(__FILE__": Error getting capability: %s: %s", error.name,
+                     error.message);
+        dbus_error_free(&error);
+        return;
+    }
+
+    /* skip it */
+    if (!has_cap)
+        return;
+
+    /* actually add the device one second later */
+    t = pa_xmalloc(sizeof(struct timerdata));
+    t->u = u;
+    t->udi = pa_xstrdup(udi);
+
+    gettimeofday(&tv, NULL);
+    tv.tv_sec += 1;
+    u->core->mainloop->time_new(u->core->mainloop, &tv,
+                                device_added_time_cb, t);
+}
+
+static void device_removed_cb(LibHalContext* ctx, const char *udi)
+{
+    struct device *d;
+    struct userdata *u = (struct userdata*) libhal_ctx_get_user_data(ctx);
+
+    pa_log_debug(__FILE__": Device removed: %s", udi);
+    if ((d = pa_hashmap_remove(u->by_udi, udi))) {
+        d = pa_hashmap_remove(u->by_module, d->module);
+        pa_log_debug(__FILE__": Unloading: %s <%s>", d->module->name, d->module->argument);
+        pa_module_unload_request(d->module);
+        hal_device_free(d);
+    }
+}
+
+#if 0
+static void new_capability_cb(LibHalContext *ctx, const char *udi,
+                                      const char* capability)
+{
+}
+
+static void lost_capability_cb(LibHalContext *ctx, const char *udi,
+                               const char* capability)
+{
+}
+
+static void property_modified_cb(LibHalContext *ctx, const char *udi,
+                                 const char* key,
+                                 dbus_bool_t is_removed,
+                                 dbus_bool_t is_added)
+{
+}
+#endif
+
+static void subscribe_notify_cb(pa_core *c, pa_subscription_event_type_t type,
+                                uint32_t idx, void *userdata)
+{
+    pa_module *m;
+    struct device *d;
+    struct userdata *u = (struct userdata*) userdata;
+
+    /* only listen for module remove events */
+    if (type != (PA_SUBSCRIPTION_EVENT_MODULE|PA_SUBSCRIPTION_EVENT_REMOVE))
+        return;
+
+    if (!(m = pa_idxset_get_by_index(c->modules, idx)))
+        return;
+
+    /* we found the module, see if it's one we care about */
+    if ((d = pa_hashmap_remove(u->by_module, m))) {
+        pa_log_debug(__FILE__": Removing module #%u %s: %s",
+                     m->index, m->name, d->udi);
+        d = pa_hashmap_remove(u->by_udi, d->udi);
+        hal_device_free(d);
+    }
+}
+
+
+static void pa_hal_context_free(LibHalContext* hal_ctx)
+{
+    DBusError error;
+
+    dbus_error_init(&error);
+    libhal_ctx_shutdown(hal_ctx, &error);
+    libhal_ctx_free(hal_ctx);
+
+    if (dbus_error_is_set(&error)) {
+        dbus_error_free(&error);
+    }
+}
+
+static void userdata_free(struct userdata *u) {
+    pa_hal_context_free(u->ctx);
+    pa_subscription_free(u->sub);
+    /* free the hashmap */
+    pa_hashmap_free(u->by_module, NULL, NULL);
+    /* free the devices with the hashmap */
+    pa_hashmap_free(u->by_udi, hal_device_free_cb, NULL);
+    pa_dbus_connection_unref(u->conn);
+    pa_xfree(u);
+}
+
+static LibHalContext* pa_hal_context_new(pa_core* c, DBusConnection *conn)
+{
+    DBusError error;
+    LibHalContext *hal_ctx = NULL;
+
+    dbus_error_init(&error);
+    if (!(hal_ctx = libhal_ctx_new())) {
+        pa_log_error(__FILE__": libhal_ctx_new() failed");
+        goto fail;
+    }
+
+    if (!libhal_ctx_set_dbus_connection(hal_ctx, conn)) {
+        pa_log_error(__FILE__": Error establishing DBUS connection: %s: %s",
+                     error.name, error.message);
+        goto fail;
+    }
+
+    if (!libhal_ctx_init(hal_ctx, &error)) {
+        pa_log_error(__FILE__": Couldn't connect to hald: %s: %s",
+                     error.name, error.message);
+        goto fail;
+    }
+
+    return hal_ctx;
+
+fail:
+    if (hal_ctx)
+        pa_hal_context_free(hal_ctx);
+
+    if (dbus_error_is_set(&error))
+        dbus_error_free(&error);
+
+    return NULL;
+}
+
+int pa__init(pa_core *c, pa_module*m) {
+    int n;
+    DBusError error;
+    pa_dbus_connection *conn;
+    struct userdata *u = NULL;
+    LibHalContext *hal_ctx = NULL;
+
+    assert(c);
+    assert(m);
+
+    dbus_error_init(&error);
+    if (!(conn = pa_dbus_bus_get(c, DBUS_BUS_SYSTEM, &error))) {
+        pa_log_error(__FILE__": Unable to contact DBUS system bus: %s: %s",
+                     error.name, error.message);
+        dbus_error_free(&error);
+        return -1;
+    }
+
+    if (!(hal_ctx = pa_hal_context_new(c, pa_dbus_connection_get(conn)))) {
+        /* pa_hal_context_new() logs appropriate errors */
+        return -1;
+    }
+
+    u = pa_xmalloc(sizeof(struct userdata));
+    u->core = c;
+    u->ctx = hal_ctx;
+    u->conn = conn;
+    u->by_module = pa_hashmap_new(NULL, NULL);
+    u->by_udi = pa_hashmap_new(pa_idxset_string_hash_func,
+                               pa_idxset_string_compare_func);
+    u->sub = pa_subscription_new(c, PA_SUBSCRIPTION_MASK_MODULE,
+                                 subscribe_notify_cb, (void*) u);
+    m->userdata = (void*) u;
+
+#if HAVE_ALSA
+    if ((n = hal_device_add_all(u, CAP_ALSA)) <= 0)
+#endif
+#if HAVE_OSS
+    if ((n = hal_device_add_all(u, CAP_OSS)) <= 0)
+#endif
+    {
+        pa_log_warn(__FILE__": failed to detect any sound hardware.");
+        userdata_free(u);
+        return -1;
+    }
+
+    libhal_ctx_set_user_data(hal_ctx, (void*) u);
+    libhal_ctx_set_device_added(hal_ctx, device_added_cb);
+    libhal_ctx_set_device_removed(hal_ctx, device_removed_cb);
+
+    dbus_error_init(&error);
+    if (!libhal_device_property_watch_all(hal_ctx, &error)) {
+        pa_log_error(__FILE__": error monitoring device list: %s: %s",
+                     error.name, error.message);
+        dbus_error_free(&error);
+        userdata_free(u);
+        return -1;
+    }
+
+    /*
+    libhal_ctx_set_device_new_capability(hal_ctx, new_capability_cb);
+    libhal_ctx_set_device_lost_capability(hal_ctx, lost_capability_cb);
+    libhal_ctx_set_device_property_modified(hal_ctx, property_modified_cb);
+    */
+
+    pa_log_info(__FILE__": loaded %i modules.", n);
+
+    return 0;
+}
+
+
+void pa__done(PA_GCC_UNUSED pa_core *c, pa_module *m) {
+    assert (c && m);
+
+    /* free the user data */
+    userdata_free(m->userdata);
+}