 @@ -1,130 +1,130 @@
-# $NetBSD: Makefile,v 1.79 2017/10/10 13:51:21 jperkin Exp $
+# $NetBSD: Makefile,v 1.80 2018/05/19 13:25:36 jmcneill Exp $
 DISTNAME=		hal-0.5.14
-PKGREVISION=		18
+PKGREVISION=		19
 CATEGORIES=		sysutils
 MASTER_SITES=		http://hal.freedesktop.org/releases/
 EXTRACT_SUFX=		.tar.bz2
 MAINTAINER=		pkgsrc-users@NetBSD.org
 HOMEPAGE=		http://hal.freedesktop.org/
 COMMENT=		FreeDesktop hardware abstraction layer
 LICENSE=		gnu-gpl-v2
 DEPENDS+=		pciids-[0-9]*:../../misc/pciids
 BUILD_DEFS+=		VARBASE PKG_SYSCONFBASE
 GNU_CONFIGURE=		YES
 USE_PKGLOCALEDIR=	YES
 USE_TOOLS+=		gmake intltool msgfmt perl pkg-config
 USE_TOOLS+=		autoconf automake autoreconf
 USE_LIBTOOL=		YES
 MAKE_DIRS+=		/media
 MAKE_DIRS+=		${VARBASE}/cache/hald
 SPECIAL_PERMS+=		${VARBASE}/cache/hald ${HAL_USER} ${HAL_GROUP} 0644
 EGDIR=			${PREFIX}/share/examples/hal
 CONF_FILES=		${EGDIR}/hal.conf ${PKG_SYSCONFBASE}/dbus-1/system.d/hal.conf
 CONFIGURE_ARGS+=        --sysconfdir=${PKG_SYSCONFBASE}
 CONFIGURE_ARGS+=	--localstatedir=${VARBASE}
 CONFIGURE_ARGS+=	--with-pci-ids=${PREFIX}/share/pciids
 CONFIGURE_ARGS+=	--with-usb-ids=${PREFIX}/share/usbids
 CONFIGURE_ARGS+=	--without-os-type
 .include "../../mk/bsd.prefs.mk"
 .if ${OPSYS} == "DragonFly"
 .include "../../devel/libvolume_id/buildlink3.mk"
 CONFIGURE_ARGS+=	--with-eject=/usr/sbin/cdcontrol
 CONFIGURE_ARGS+=	--with-backend=freebsd
 PLIST_SRC=		PLIST.DragonFly PLIST
 .elif ${OPSYS} == "FreeBSD"
 .include "../../devel/libvolume_id/buildlink3.mk"
 CONFIGURE_ARGS+=	--with-eject=/usr/sbin/cdcontrol
 CONFIGURE_ARGS+=	--with-backend=freebsd
 PLIST_SRC=		PLIST.FreeBSD PLIST
 .elif !empty(MACHINE_PLATFORM:MNetBSD-[5-9]*)
 .include "../../devel/libvolume_id/buildlink3.mk"
 CONFIGURE_ARGS+=	--with-backend=netbsd
 HAL_GROUP=		operator
 .elif ${OPSYS} == "Linux"
 .include "../../devel/gperf/buildlink3.mk"
 .include "../../devel/libblkid/buildlink3.mk"
 .include "../../devel/libvolume_id/buildlink3.mk"
 .include "../../sysutils/pciutils/buildlink3.mk"
 CONFIGURE_ARGS+=	--with-backend=linux
 MAKE_DIRS+=		/etc/udev
 MAKE_DIRS+=		/etc/udev/rules.d
 CONF_FILES+=		${EGDIR}/90-hal.rules \
 			/etc/udev/rules.d/90-hal.rules
 PLIST_VARS+=	imac
 .if ${MACHINE_ARCH} == "i386" || ${MACHINE_ARCH} == "x86_64"
 PLIST.imac=	yes
 CONFIGURE_ARGS+=	--with-imac
 .else
 CONFIGURE_ARGS+=	--without-imac
 .endif
 .else	# Unsupported systems
 # Pull in the dummy backend
 .include "../../devel/libvolume_id/buildlink3.mk"
 CONFIGURE_ARGS+=	--with-backend=dummy
 PLIST_SRC=		PLIST
 .endif
 CFLAGS.SunOS+=		-Du_int32_t=uint32_t
 BUILDLINK_TRANSFORM.SunOS+=	opt:-Wl,--as-needed:-Wl,-zignore
 REPLACE_INTERPRETER+=	bash
 REPLACE.bash.old=	/bin/bash
 REPLACE.bash.new=	${SH}
 .for halscript in luks-remove luks-setup luks-teardown system-wol-enable system-wol-enabled system-wol-supported
 REPLACE_FILES.bash+=	tools/hal-${halscript}
 .endfor
 HAL_USER?=		haldaemon
 HAL_GROUP?=		haldaemon
 CONFIGURE_ARGS+=	--with-hal-user=${HAL_USER}
 CONFIGURE_ARGS+=	--with-hal-group=${HAL_GROUP}
 CONFIGURE_ARGS+=	--disable-pmu
 RCD_SCRIPTS=		hal
 SMF_METHODS=		hal
 .if ${HAL_GROUP} != "operator"
 PKG_GROUPS=		${HAL_GROUP}
 .endif
 PKG_USERS=		${HAL_USER}:${HAL_GROUP}
 PKG_HOME.haldaemon=	${VARBASE}/run/hald
 FILES_SUBST+=		HAL_USER=${HAL_USER}
 FILES_SUBST+=		HAL_GROUP=${HAL_GROUP}
 FILES_SUBST+=		PKG_HOME.haldaemon=${PKG_HOME.haldaemon}
 PLIST_SUBST+=		PKG_SYSCONFDIR=${PKG_SYSCONFDIR}
 TEST_TARGET=		check
 post-extract:
 	${CP} -r ${FILESDIR}/hald-netbsd ${WRKSRC}/hald/netbsd
 	${CP} -r ${FILESDIR}/tools-netbsd ${WRKSRC}/tools/netbsd
 pre-configure:
 	cd ${WRKSRC} && autoreconf -vi ${AUTORECONF_ARGS}
 .include "../../devel/GConf/schemas.mk"
 .include "../../devel/glib2/buildlink3.mk"
 .include "../../misc/usbids/buildlink3.mk"
 .include "../../security/policykit/buildlink3.mk"
 .include "../../sysutils/dbus/buildlink3.mk"
 .include "../../sysutils/dbus-glib/buildlink3.mk"
 .include "../../sysutils/hal-info/buildlink3.mk"
 .include "../../textproc/expat/buildlink3.mk"
 .include "../../mk/bsd.pkg.mk"

 @@ -1,418 +1,433 @@
 /***************************************************************************
+ *
  * devinfo.c : main file for drvctl-based device enumeration
+ *
  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
  * Use is subject to license terms.
+ *
  * Licensed under the Academic Free License version 2.1
+ *
  **************************************************************************/
 #ifdef HAVE_CONFIG_H
 #  include <config.h>
 #endif
 #include <stdio.h>
 #include <string.h>
 #include <sys/drvctlio.h>
 #include "../osspec.h"
 #include "../logger.h"
 #include "../hald.h"
 #include "../hald_dbus.h"
 #include "../device_info.h"
 #include "../util.h"
 #include "../hald_runner.h"
 #include "osspec_netbsd.h"
 #include "hotplug.h"
 #include "devinfo.h"
 #include "devinfo_audio.h"
 #include "devinfo_video.h"
 #include "devinfo_pci.h"
 #include "devinfo_storage.h"
 #include "devinfo_mass.h"
 #include "devinfo_usb.h"
 #include "devinfo_misc.h"
 #include "devinfo_cpu.h"
 #include "devinfo_optical.h"
 /* #include "devinfo_scsipi.h" */
 #include "drvctl.h"
 void devinfo_add_subtree(HalDevice *parent, const char *devnode, gboolean is_root);
 void
 devinfo_add(HalDevice *parent, gchar *name)
+{
 	devinfo_add_subtree (parent, name, TRUE);
+}
 gboolean
 devinfo_probe(HalDevice *parent, gchar *name)
+{
 	struct devlistargs laa;
 	if (drvctl_list (name, &laa) == -1) {
 		HAL_INFO (("devinfo_probe: no %s device found", name));
 		return FALSE;
+	}
 	free (laa.l_childname);
 	return TRUE;
+}
 void
 devinfo_add_subtree(HalDevice *parent, const char *devnode, gboolean is_root)
+{
 	HalDevice *d;
 	struct devlistargs laa;
 	int i;
 	HAL_INFO (("add_subtree: %s", devnode));
 	if (parent == NULL) {
 		parent = devinfo_add_node (NULL, devnode);
+	}
 	if (drvctl_list (devnode, &laa) == -1) {
 		HAL_INFO (("devinfo_add_subtree: drvctl_list failed"));
 		return;
+	}
 	for (i = 0; i < laa.l_children; i++) {
 		d = devinfo_add_node (parent, laa.l_childname[i]);
 		if (d)
 			devinfo_add_subtree (d, laa.l_childname[i], FALSE);
+	}
 	if (laa.l_childname)
 		free(laa.l_childname);
+}
 void
 devinfo_set_default_properties (HalDevice *d, HalDevice *parent, const char *devnode, char *devfs_path)
+{
 	char	*driver_name, *s;
 	const char *s1;
 	char	udi[HAL_PATH_MAX];
 	if (parent != NULL) {
 		char *pdevice = hal_device_property_get_string (parent, "netbsd.device");
 		if (pdevice) {
 			gchar *path;
-			if (strcmp (pdevice, "mainbus0") == 0)
+			if (strcmp (pdevice, "mainbus0") == 0 || strcmp (pdevice, "armfdt0") == 0)
 				pdevice = "computer";
 			path = g_strdup_printf ("/org/freedesktop/Hal/devices/%s", pdevice);
 			hal_device_property_set_string (d, "info.parent", path);
 			g_free (path);
+		}
 	} else {
 		gchar pdevnode[512];
 		char *pdevice = pdevnode;
 		if (drvctl_find_parent (devnode, pdevnode) == TRUE) {
 			gchar *path;
-			if (strcmp (pdevnode, "mainbus0") == 0)
+			if (strcmp (pdevnode, "mainbus0") == 0 || strcmp (pdevnode, "armfdt0") == 0)
 				pdevice = "computer";
 			path = g_strdup_printf ("/org/freedesktop/Hal/devices/%s", pdevice);
 			hal_device_property_set_string (d, "info.parent", path);
 			g_free (path);
 		} else
 			hal_device_property_set_string (d, "info.parent", "/org/freedesktop/Hal/devices/local");
+	}
 	hald_compute_udi (udi, sizeof (udi),
 			  "/org/freedesktop/Hal/devices/%s", devnode);
 	hal_device_set_udi (d, udi);
 #if notyet
 	if (di_prop_lookup_strings (DDI_DEV_T_ANY, node, "model", &s) > 0) {
 		hal_device_property_set_string (d, "info.product", s);
 	} else {
 		hal_device_property_set_string (d, "info.product", di_node_name (node));
+	}
 #else
 	hal_device_property_set_string (d, "info.product", devnode);
 #endif
 	hal_device_property_set_string (d, "netbsd.device", devnode);
 #if notyet
 	if ((driver_name = di_driver_name (node)) != NULL) {
 		hal_device_property_set_string (d, "info.solaris.driver",
 						driver_name);
+	}
 	/* inherit parent's claim attributes */
 	if (hal_device_property_get_bool (parent, "info.claimed")) {
 		s1 = hal_device_property_get_string (parent, "info.claimed.service");
 		if (s1 != NULL) {
 			hal_device_property_set_bool (d, "info.claimed", TRUE);
 			hal_device_property_set_string (d, "info.claimed.service", s1);
+		}
+	}
 #endif
+}
 /* device handlers, ordered specific to generic */
 static DevinfoDevHandler *devinfo_handlers[] = {
 	&devinfo_computer_handler,
 	&devinfo_cpu_handler,
 	&devinfo_optical_handler,
 #if notyet
 	&devinfo_scsipi_handler,
 	&devinfo_ide_handler,
 	&devinfo_scsi_handler,
 	&devinfo_floppy_handler,
 	&devinfo_usb_handler,
 	&devinfo_pci_handler,
 	&devinfo_lofi_handler,
 #endif
 	&devinfo_audio_handler,
 	&devinfo_audio_mixer_handler,
 	&devinfo_audio_dsp_handler,
 	&devinfo_video_handler,
 	&devinfo_mass_handler,
 	&devinfo_default_handler,
 	NULL
 };
 HalDevice *
 devinfo_add_node(HalDevice *parent, const char *devnode)
+{
 	HalDevice *d = NULL;
 	char	*devfs_path;
 	char	*device_type = NULL;
 	DevinfoDevHandler *handler;
 	int	i;
 	devfs_path = g_strdup_printf ("%s", devnode);
 #if notyet
         (void) di_prop_lookup_strings (DDI_DEV_T_ANY, node, "device_type",
 	    &device_type);
 #else
 	device_type = "unknown";
 #endif
 	for (i = 0; (d == NULL) && (devinfo_handlers[i] != NULL); i++) {
 		handler = devinfo_handlers[i];
 		d = handler->add (parent, devnode, devfs_path, device_type);
+	}
 	g_free(devfs_path);
 	HAL_INFO (("add_node: %s", d ? hal_device_get_udi (d) : "none"));
 	return (d);
+}
 void
 devinfo_hotplug_enqueue(HalDevice *d, gchar *devfs_path, DevinfoDevHandler *handler, int action, int front)
+{
 	HotplugEvent *hotplug_event;
 	hotplug_event = g_new0 (HotplugEvent, 1);
 	hotplug_event->action = action;
 	hotplug_event->type = HOTPLUG_EVENT_DEVFS;
 	hotplug_event->d = d;
 	strlcpy (hotplug_event->un.devfs.devfs_path, devfs_path,
 		sizeof (hotplug_event->un.devfs.devfs_path));
 	hotplug_event->un.devfs.handler = handler;
 	hotplug_event_enqueue (hotplug_event, front);
+}
 void
 devinfo_add_enqueue(HalDevice *d, gchar *devfs_path, DevinfoDevHandler *handler)
+{
 	devinfo_hotplug_enqueue (d, devfs_path, handler, HOTPLUG_ACTION_ADD, 0);
+}
 void
 devinfo_add_enqueue_at_front(HalDevice *d, gchar *devfs_path, DevinfoDevHandler *handler)
+{
 	devinfo_hotplug_enqueue (d, devfs_path, handler, HOTPLUG_ACTION_ADD, 1);
+}
 void
 devinfo_remove_enqueue(gchar *devfs_path, DevinfoDevHandler *handler)
+{
 	devinfo_hotplug_enqueue (NULL, devfs_path, handler, HOTPLUG_ACTION_REMOVE, 0);
+}
 void
 devinfo_callouts_add_done (HalDevice *d, gpointer userdata1, gpointer userdata2)
+{
         void *end_token = (void *) userdata1;
         /* Move from temporary to global device store */
         hal_device_store_remove (hald_get_tdl (), d);
         hal_device_store_add (hald_get_gdl (), d);
         hotplug_event_end (end_token);
+}
 void
 devinfo_callouts_probing_done (HalDevice *d, guint32 exit_type, gint return_code, char **error, gpointer userdata1, gpointer userdata2)
+{
         void *end_token = (void *) userdata1;
         /* Discard device if probing reports failure */
         if (exit_type != HALD_RUN_SUCCESS || (return_code != 0)) {
 		HAL_INFO (("Probing for %s failed %d", hal_device_get_udi (d), return_code));
                 hal_device_store_remove (hald_get_tdl (), d);
                 g_object_unref (d);
                 hotplug_event_end (end_token);
 		return;
+        }
         /* Merge properties from .fdi files */
         di_search_and_merge (d, DEVICE_INFO_TYPE_INFORMATION);
         di_search_and_merge (d, DEVICE_INFO_TYPE_POLICY);
 	hal_util_callout_device_add (d, devinfo_callouts_add_done, end_token, NULL);
+}
 void
 devinfo_callouts_preprobing_done (HalDevice *d, gpointer userdata1, gpointer userdata2)
+{
         void *end_token = (void *) userdata1;
 	DevinfoDevHandler *handler = (DevinfoDevHandler *) userdata2;
 	void (*probing_done) (HalDevice *, guint32, gint, char **, gpointer, gpointer);
 	const gchar *prober;
 	int prober_timeout;
         if (hal_device_property_get_bool (d, "info.ignore")) {
 		HAL_INFO (("Preprobing merged info.ignore==TRUE"));
                 /* Leave device with info.ignore==TRUE so we won't pick up children */
 		hal_device_property_remove (d, "info.category");
 		hal_device_property_remove (d, "info.capabilities");
 		hal_device_store_remove (hald_get_tdl (), d);
 		hal_device_store_add (hald_get_gdl (), d);
 		hotplug_event_end (end_token);
 		return;
+        }
         if (handler != NULL && handler->get_prober != NULL) {
                 prober = handler->get_prober (d, &prober_timeout);
         } else {
                 prober = NULL;
+	}
 	if (handler->probing_done != NULL) {
 		probing_done = handler->probing_done;
 	} else {
 		probing_done = devinfo_callouts_probing_done;
+	}
         if (prober != NULL) {
                 /* probe the device */
 		HAL_INFO(("Probing udi=%s", hal_device_get_udi (d)));
                 hald_runner_run (d,
 				prober, NULL,
 				prober_timeout,
 				probing_done,
 				(gpointer) end_token, (gpointer) handler);
 	} else {
 		probing_done (d, 0, 0, NULL, userdata1, userdata2);
+	}
+}
 /* This is the beginning of hotplug even handling */
 void
 hotplug_event_begin_add_devinfo (HalDevice *d, HalDevice *parent, DevinfoDevHandler *handler, void *end_token)
+{
 	HAL_INFO(("Preprobing udi=%s", hal_device_get_udi (d)));
 	if (parent != NULL && hal_device_property_get_bool (parent, "info.ignore")) {
 		HAL_INFO (("Ignoring device since parent has info.ignore==TRUE"));
 		hotplug_event_end (end_token);
 		return;
+	}
         /* add to TDL so preprobing callouts and prober can access it */
         hal_device_store_add (hald_get_tdl (), d);
 #if 0
         /* Process preprobe fdi files */
         di_search_and_merge (d, DEVICE_INFO_TYPE_PREPROBE);
 #endif
         /* Run preprobe callouts */
         hal_util_callout_device_preprobe (d, devinfo_callouts_preprobing_done, end_token, handler);
+}
 void
 devinfo_remove (gchar *devfs_path)
+{
 	devinfo_remove_enqueue ((gchar *)devfs_path, NULL);
+}
 /* generate hotplug event for each device in this branch */
 void
 devinfo_remove_branch (gchar *devnode, HalDevice *d)
+{
 	GSList *i;
 	GSList *children;
 	HalDevice *child;
 	char *child_devfs_path;
 	if (d == NULL) {
 		d = hal_device_store_match_key_value_string (hald_get_gdl (),
 			"netbsd.device", devnode);
 		if (d == NULL)
 			return;
+	}
 	HAL_INFO (("remove_branch: %s %s\n", devnode, hal_device_get_udi (d)));
 	/* first remove children */
 	children = hal_device_store_match_multiple_key_value_string (hald_get_gdl(),
 		"info.parent", hal_device_get_udi (d));
         for (i = children; i != NULL; i = g_slist_next (i)) {
                 child = HAL_DEVICE (i->data);
 		HAL_INFO (("remove_branch: child %s\n", hal_device_get_udi (child)));
 		devinfo_remove_branch ((gchar *)hal_device_property_get_string (child, "netbsd.device"), child);
+	}
 	g_slist_free (children);
 	HAL_INFO (("remove_branch: done with children"));
 	/* then remove self */
 	HAL_INFO (("remove_branch: queueing %s", devnode));
 	devinfo_remove_enqueue (devnode, NULL);
+}
 void
 devinfo_callouts_remove_done (HalDevice *d, gpointer userdata1, gpointer userdata2)
+{
         void *end_token = (void *) userdata1;
         HAL_INFO (("Remove callouts completed udi=%s", hal_device_get_udi (d)));
         if (!hal_device_store_remove (hald_get_gdl (), d)) {
                 HAL_WARNING (("Error removing device"));
+        }
         g_object_unref (d);
         hotplug_event_end (end_token);
+}
 void
 hotplug_event_begin_remove_devinfo (HalDevice *d, gchar *devfs_path, void *end_token)
+{
 #if notyet
 	if (hal_device_has_capability (d, "volume")) {
 		devinfo_volume_hotplug_begin_remove (d, devfs_path, end_token);
 	} else {
 		hal_util_callout_device_remove (d, devinfo_callouts_remove_done, end_token, NULL);
+	}
 #else
 #warning hotplug_event_begin_remove_devinfo TODO
 	hal_util_callout_device_remove (d, devinfo_callouts_remove_done, end_token, NULL);
 #endif
+}
 gboolean
 devinfo_device_rescan (HalDevice *d)
+{
 #if notyet
 	if (hal_device_has_capability (d, "block")) {
 		return (devinfo_storage_device_rescan (d));
 	} else {
 		return (FALSE);
+	}
 #else
 #warning devinfo_device_rescan TODO
 	return FALSE;
 #endif
+}

 @@ -1,72 +1,73 @@
 /***************************************************************************
+ *
  * devinfo.h : definitions for libdevinfo-based device enumeration
+ *
  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
  * Use is subject to license terms.
+ *
  * Licensed under the Academic Free License version 2.1
+ *
  **************************************************************************/
 #ifndef DEVINFO_H
 #define DEVINFO_H
 #include <glib.h>
 #include <prop/proplib.h>
 #include "../hald.h"
 #include "../device_info.h"
 typedef struct DevinfoDevHandler_s
+{
 	HalDevice *(*add) (HalDevice *parent, const char *devnode, char *devfs_path, char *device_type);
 	/* yet unused */
 	void (*remove) (char *devfs_path);
 	void (*hotplug_begin_add) (HalDevice *d, HalDevice *parent, struct DevinfoDevHandler_s *handler, void *end_token);
 	void (*hotplug_begin_remove) (HalDevice *d, struct DevinfoDevHandler_s *handler, void *end_token);
 	void (*probing_done) (HalDevice *d, guint32 exit_type, gint return_code, char **error, gpointer userdata1, gpointer userdata2);
 	const gchar *(*get_prober) (HalDevice *d, int *timeout);
 } DevinfoDevHandler;
 #define PROP_INT(d, node, v, diprop, halprop) \
 	if (di_prop_lookup_ints(DDI_DEV_T_ANY, node, diprop, &(v)) > 0) { \
 		hal_device_property_set_int (d, halprop, *(v)); \
+	}
 #define PROP_STR(d, node, v, diprop, halprop) \
 	if (di_prop_lookup_strings(DDI_DEV_T_ANY, node, diprop, &(v)) > 0) { \
 		hal_device_property_set_string (d, halprop, v); \
+	}
 #define PROP_BOOL(d, node, v, diprop, halprop) \
 	hal_device_property_set_bool (d, halprop, \
 	    (di_prop_lookup_ints(DDI_DEV_T_ANY, node, diprop, &(v)) >= 0));
 #define	NELEM(a)	(sizeof (a) / sizeof (*(a)))
 void devinfo_add (HalDevice *parent, gchar *path);
 gboolean devinfo_probe (HalDevice *parent, gchar *path);
 HalDevice *devinfo_add_node(HalDevice *parent, const char *devnode);
 void devinfo_set_default_properties (HalDevice *d, HalDevice *parent, const char *devnode, char *devfs_path);
 void devinfo_callouts_preprobing_done (HalDevice *d, gpointer userdata1, gpointer userdata2);
 void devinfo_callouts_probing_done (HalDevice *d, guint32 exit_type, gint return_code, char **error,
 	gpointer userdata1, gpointer userdata2);
 void devinfo_callouts_add_done (HalDevice *d, gpointer userdata1, gpointer userdata2);
 void devinfo_callouts_remove_done (HalDevice *d, gpointer userdata1, gpointer userdata2);
 void hotplug_event_begin_add_devinfo (HalDevice *d, HalDevice *parent, DevinfoDevHandler *handler, void *end_token);
 void devinfo_remove (gchar *path);
 void devinfo_remove_branch (gchar *path, HalDevice *d);
 void hotplug_event_begin_remove_devinfo (HalDevice *d, gchar *devfs_path, void *end_token);
 void devinfo_hotplug_enqueue(HalDevice *d, gchar *devfs_path, DevinfoDevHandler *handler, int action, int front);
 void devinfo_add_enqueue(HalDevice *d, gchar *devfs_path, DevinfoDevHandler *handler);
 void devinfo_add_enqueue_at_front(HalDevice *d, gchar *devfs_path, DevinfoDevHandler *handler);
 void devinfo_remove_enqueue(gchar *devfs_path, DevinfoDevHandler *handler);
 gboolean devinfo_device_rescan (HalDevice *d);
 #endif /* DEVINFO_H */

 @@ -1,204 +1,204 @@
 /***************************************************************************
+ *
  * hotplug.c : HAL-internal hotplug events
+ *
  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
  * Use is subject to license terms.
+ *
  * Licensed under the Academic Free License version 2.1
+ *
  **************************************************************************/
 #pragma ident	"@(#)hotplug.c	1.2	06/10/13 SMI"
 #ifdef HAVE_CONFIG_H
 #  include <config.h>
 #endif
 #include <stdio.h>
 #include <string.h>
 #include <errno.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/un.h>
 #include <sys/utsname.h>
 #include <unistd.h>
 #include <glib.h>
 #include <dbus/dbus.h>
 #include <dbus/dbus-glib.h>
 #include "../osspec.h"
 #include "../logger.h"
 #include "../hald.h"
 #include "../device_info.h"
 #include "osspec_netbsd.h"
 #include "hotplug.h"
 #include "devinfo.h"
 /** Queue of ordered hotplug events */
 GQueue *hotplug_event_queue;
 /** List of HotplugEvent objects we are currently processing */
 GSList *hotplug_events_in_progress = NULL;
 static void hotplug_event_begin (HotplugEvent *hotplug_event);
 void
 hotplug_event_end (void *end_token)
+{
 	HotplugEvent *hotplug_event = (HotplugEvent *) end_token;
 	hotplug_events_in_progress = g_slist_remove (hotplug_events_in_progress, hotplug_event);
 	g_free (hotplug_event);
 	hotplug_event_process_queue ();
+}
 static void
 hotplug_event_begin_devfs_add (HotplugEvent *hotplug_event, HalDevice *d)
+{
 	HalDevice *parent;
 	const gchar *parent_udi;
 	void (*begin_add_func) (HalDevice *, HalDevice *, DevinfoDevHandler *, void *);
 	if (d != NULL) {
 		/* XXX */
 		HAL_ERROR (("devpath %s already present in store, ignore event", hotplug_event->un.devfs.devfs_path));
 		hotplug_event_end ((void *) hotplug_event);
 		return;
+	}
 	/* find parent */
 	parent_udi = hal_device_property_get_string (hotplug_event->d, "info.parent");
 	if (parent_udi == NULL || strlen(parent_udi) == 0) {
 		parent = NULL;
 		HAL_INFO (("no info.parent parameter found"));
 	} else {
 		parent = hal_device_store_match_key_value_string (hald_get_gdl (), "info.udi", parent_udi);
 		if (parent == NULL)
 			HAL_INFO (("no info.udi=%s parameter found", parent_udi));
+	}
 	if (parent == NULL) {
 		gchar pdevnode[512];
 		HAL_INFO (("couldn't look up %s parent by udi, trying netbsd.device", hotplug_event->un.devfs.devfs_path));
 		if (drvctl_find_parent (hotplug_event->un.devfs.devfs_path, pdevnode) == TRUE)
 			parent = hal_device_store_match_key_value_string (hald_get_gdl (), "netbsd.device", pdevnode);
+	}
 	/* only root node is allowed to be orphan */
 	if (parent == NULL) {
-		if (strcmp(hotplug_event->un.devfs.devfs_path, "mainbus0") != 0) {
+		if (strcmp(hotplug_event->un.devfs.devfs_path, "mainbus0") != 0 && strcmp(hotplug_event->un.devfs.devfs_path, "armfdt0") != 0) {
 			HAL_ERROR (("Parent is NULL devfs_path=%s parent_udi=%s", hotplug_event->un.devfs.devfs_path, parent_udi ? parent_udi : "<null>"));
 			hotplug_event_end ((void *) hotplug_event);
 			return;
+		}
+	}
 	/* children of ignored parent should be ignored */
 	if (hal_device_property_get_bool (parent, "info.ignore")) {
 		HAL_INFO (("parent ignored %s", parent_udi));
 			hotplug_event_end ((void *) hotplug_event);
 			return;
+	}
 	/* custom or generic add function */
 	begin_add_func = hotplug_event->un.devfs.handler->hotplug_begin_add;
 	if (begin_add_func == NULL) {
 		begin_add_func = hotplug_event_begin_add_devinfo;
+	}
 	begin_add_func (hotplug_event->d,
 			 parent,
 			 hotplug_event->un.devfs.handler,
 			 (void *) hotplug_event);
+}
 static void
 hotplug_event_begin_devfs_remove (HotplugEvent *hotplug_event, HalDevice *d)
+{
 	if (d == NULL) {
 		HAL_ERROR (("devpath %s not present in store, ignore event", hotplug_event->un.devfs.devfs_path));
 		hotplug_event_end ((void *) hotplug_event);
 		return;
+	}
 	HAL_INFO (("hotplug_event_begin_devfs_remove %s", hal_device_get_udi (d)));
 	hotplug_event_begin_remove_devinfo(d,
 			 hotplug_event->un.devfs.devfs_path,
 			 (void *) hotplug_event);
+}
 static void
 hotplug_event_begin_devfs (HotplugEvent *hotplug_event)
+{
 	HalDevice *d;
 	HAL_INFO (("hotplug_event_begin_devfs: %s", hotplug_event->un.devfs.devfs_path));
 	d = hal_device_store_match_key_value_string (hald_get_gdl (),
 						"netbsd.device",
 						hotplug_event->un.devfs.devfs_path);
 	if (hotplug_event->action == HOTPLUG_ACTION_ADD) {
 		hotplug_event_begin_devfs_add (hotplug_event, d);
 	} else if (hotplug_event->action == HOTPLUG_ACTION_REMOVE) {
 		hotplug_event_begin_devfs_remove (hotplug_event, d);
 	} else {
 		hotplug_event_end ((void *) hotplug_event);
+	}
+}
 static void
 hotplug_event_begin (HotplugEvent *hotplug_event)
+{
 	switch (hotplug_event->type) {
 	case HOTPLUG_EVENT_DEVFS:
 		hotplug_event_begin_devfs (hotplug_event);
 		break;
 	default:
 		HAL_ERROR (("Unknown hotplug event type %d", hotplug_event->type));
 		hotplug_event_end ((void *) hotplug_event);
 		break;
+	}
+}
 void
 hotplug_event_enqueue (HotplugEvent *hotplug_event, int front)
+{
 	if (hotplug_event_queue == NULL)
 		hotplug_event_queue = g_queue_new ();
 	if (front) {
 		g_queue_push_head (hotplug_event_queue, hotplug_event);
 	} else {
 		g_queue_push_tail (hotplug_event_queue, hotplug_event);
+	}
+}
 void
 hotplug_event_process_queue (void)
+{
 	HotplugEvent *hotplug_event;
 	if (hotplug_events_in_progress == NULL &&
 	    (hotplug_event_queue == NULL || g_queue_is_empty (hotplug_event_queue))) {
 		hotplug_queue_now_empty ();
 		goto out;
+	}
 	/* do not process events if some other event is in progress */
 	if (hotplug_events_in_progress != NULL && g_slist_length (hotplug_events_in_progress) > 0)
 		goto out;
 	hotplug_event = g_queue_pop_head (hotplug_event_queue);
 	if (hotplug_event == NULL)
 		goto out;
 	hotplug_events_in_progress = g_slist_append (hotplug_events_in_progress, hotplug_event);
 	hotplug_event_begin (hotplug_event);
 out:
+	;
+}

 @@ -1,168 +1,168 @@
 /***************************************************************************
+ *
  * devinfo_misc : misc devices
+ *
  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
  * Use is subject to license terms.
+ *
  * Licensed under the Academic Free License version 2.1
+ *
  **************************************************************************/
 #include <sys/types.h>
 #include <sys/sysctl.h>
 #ifdef HAVE_CONFIG_H
 #  include <config.h>
 #endif
 #include <sys/utsname.h>
 #include <stdio.h>
 #include <string.h>
 #include "../osspec.h"
 #include "../logger.h"
 #include "../hald.h"
 #include "../hald_dbus.h"
 #include "../device_info.h"
 #include "../util.h"
 #include "devinfo_misc.h"
 #include "drvctl.h"
 static HalDevice *devinfo_computer_add(HalDevice *, const char *, char *, char *);
 static HalDevice *devinfo_cpu_add(HalDevice *, const char *, char *,char *);
 static HalDevice *devinfo_default_add(HalDevice *, const char *, char *, char *);
 DevinfoDevHandler devinfo_computer_handler = {
         devinfo_computer_add,
 	NULL,
 	NULL,
 	NULL,
 	NULL,
         NULL
 };
 DevinfoDevHandler devinfo_cpu_handler = {
         devinfo_cpu_add,
 	NULL,
 	NULL,
 	NULL,
 	NULL,
         NULL
 };
 DevinfoDevHandler devinfo_default_handler = {
         devinfo_default_add,
 	NULL,
 	NULL,
 	NULL,
 	NULL,
         NULL
 };
 static HalDevice *
 devinfo_computer_add(HalDevice *parent, const char *devnode, char *devfs_path, char *device_type)
+{
 	HalDevice *d;
 	struct utsname un;
 	char acpi_supported_states[20];
 	size_t len = sizeof(acpi_supported_states);
-	if (strcmp (devnode, "mainbus0") != 0) {
+	if (strcmp (devnode, "mainbus0") != 0 && strcmp (devnode, "armfdt0") != 0) {
 		return (NULL);
+	}
 	HAL_INFO (("devinfo_computer_add parent=%p devnode=%s devfs_path=%s device_type=%s",
 	    parent, devnode, devfs_path, device_type));
 	d = hal_device_new ();
         hal_device_property_set_string (d, "info.subsystem", "unknown");
         hal_device_property_set_string (d, "info.product", "Computer");
         hal_device_set_udi (d, "/org/freedesktop/Hal/devices/computer");
 	hal_device_property_set_string (d, "netbsd.device", devnode);
 	if (uname (&un) >= 0) {
 		hal_device_property_set_string (d, "system.kernel.name", un.sysname);
 		hal_device_property_set_string (d, "system.kernel.version", un.release);
 		hal_device_property_set_string (d, "system.kernel.machine", un.machine);
+	}
 	devinfo_add_enqueue (d, devfs_path, &devinfo_computer_handler);
 	if (sysctlbyname ("hw.acpi.supported_states", acpi_supported_states, &len, NULL, 0) == 0 ||
 	    sysctlbyname ("hw.acpi.sleep.states", acpi_supported_states, &len, NULL, 0) == 0) {
 		hal_device_property_set_string (d, "power_management.type", "acpi");
 		if (strstr (acpi_supported_states, "S3") != NULL)
 			hal_device_property_set_bool (d, "power_management.can_suspend", TRUE);
 		else
 			hal_device_property_set_bool (d, "power_management.can_suspend", FALSE);
 		hal_device_property_set_bool (d, "power_management.can_hibernate", FALSE);
+	}
 	if (drvctl_find_device ("acpibat0", NULL) == TRUE)
 		hal_device_property_set_string (d, "system.formfactor", "laptop");
 	else
 		hal_device_property_set_string (d, "system.formfactor", "desktop");	/* XXX */
 	devinfo_add_enqueue (d, devnode, &devinfo_default_handler);
 	return d;
+}
 static HalDevice *
 devinfo_cpu_add(HalDevice *parent, const char *devnode, char *devfs_path, char *device_type)
+{
 	HalDevice *d;
 	if (strncmp(devnode, "cpu", 3) != 0) {
 		return (NULL);
+	}
 	HAL_INFO (("devinfo_cpu_add: parent=%p devnode=%s devfs_path=%s device_type=%s",
 	    parent, devnode, devfs_path, device_type));
 	d = hal_device_new ();
 	devinfo_set_default_properties (d, parent, devnode, devnode);
 	hal_device_add_capability (d, "processor");
 	devinfo_add_enqueue (d, devnode, &devinfo_cpu_handler);
 	return (d);
+}
 static void
 devinfo_default_apply_quirks(HalDevice *d, const char *devnode)
+{
 /* acpiacad(4) */
 	if (strncmp (devnode, "acpiacad", 8) == 0) {
 		HAL_INFO (("%s: applying acpiacad quirks",devnode));
 		hal_device_add_capability (d, "ac_adapter");
 /* acpibat(4) */
 	} else if (strncmp (devnode, "acpibat", 7) == 0) {
 		HAL_INFO (("%s: applying acpibat quirks",devnode));
 		hal_device_add_capability (d, "battery");
 		hal_device_property_set_string (d, "battery.type", "primary");
+	}
+}
 static HalDevice *
 devinfo_default_add(HalDevice *parent, const char *devnode, char *devfs_path, char *device_type)
+{
 	char *driver_name;
 	const char *parent_path;
 	HalDevice *d;
 	d = hal_device_new ();
 	devinfo_set_default_properties (d, parent, devnode, devnode);
 	devinfo_default_apply_quirks (d, devnode);
 	devinfo_add_enqueue (d, devnode, &devinfo_default_handler);
 	return (d);
+}

 @@ -1,303 +1,311 @@
 /***************************************************************************
+ *
  * drvctl.c : NetBSD drvctl events
+ *
  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
  * Use is subject to license terms.
+ *
  * Licensed under the Academic Free License version 2.1
+ *
  **************************************************************************/
 #ifdef HAVE_CONFIG_H
 #  include <config.h>
 #endif
 #include <stdio.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <sys/ioctl.h>
 #include <sys/drvctlio.h>
 #include <sys/dkio.h>
 #include <sys/stat.h>
 #include <sys/drvctlio.h>
 #include <glib.h>
 #include "../osspec.h"
 #include "../logger.h"
 #include "../hald.h"
 #include "../hald_dbus.h"
 #include "../device_info.h"
 #include "../util.h"
 #include "osspec_netbsd.h"
 #include "hotplug.h"
 #include "devinfo.h"
 #include "devinfo_storage.h"
 #include "drvctl.h"
 static gboolean drvctl_iochannel_data(GIOChannel *, GIOCondition, gpointer);
 static void	drvctl_dev_add(gchar *);
 static void	drvctl_dev_remove(gchar *);
 static void	drvctl_dev_branch(gchar *);
 static int drvctl_fd;
 static GIOChannel *drvctl_iochannel;
 gboolean
 drvctl_init(void)
+{
 	drvctl_fd = open (DRVCTLDEV, O_RDWR);
 	if (drvctl_fd == -1) {
 		HAL_INFO (("open(%s, O_RDWR) failed: %s", DRVCTLDEV, strerror(errno)));
 		return FALSE;
+	}
         drvctl_iochannel = g_io_channel_unix_new (drvctl_fd);
 	if (drvctl_iochannel == NULL) {
                 HAL_INFO (("g_io_channel_unix_new failed"));
 		return FALSE;
+	}
         g_io_add_watch (drvctl_iochannel, G_IO_IN, drvctl_iochannel_data, NULL);
 	return TRUE;
+}
 void
 drvctl_fini(void)
+{
 	HAL_INFO (("drvctl_fini"));
+}
 static gboolean
 drvctl_iochannel_data (GIOChannel *source,
                     GIOCondition condition,
                     gpointer user_data)
+{
 	prop_dictionary_t ev;
 	const char *event, *device;
 	int res;
 	HAL_INFO (("drvctl_iochannel_data"));
 	res = prop_dictionary_recv_ioctl (drvctl_fd, DRVGETEVENT, &ev);
 	if (res) {
 		HAL_WARNING (("DRVGETEVENT failed: %s", strerror(errno)));
 		return FALSE;
+	}
 	if (!prop_dictionary_get_cstring_nocopy (ev, "event", &event)) {
 		HAL_WARNING (("DRVGETEVENT missing \"event\" parameter"));
 		goto done;
+	}
 	if (!prop_dictionary_get_cstring_nocopy (ev, "device", &device)) {
 		HAL_WARNING (("DRVGETEVENT missing \"device\" parameter"));
 		goto done;
+	}
 	HAL_INFO (("DRVGETEVENT event=%s device=%s", event, device));
 	if (strcmp (event, "device-attach") == 0) {
 		drvctl_dev_add (device);
 	} else {
 		drvctl_dev_remove (device);
+	}
 done:
 	prop_object_release(ev);
 	return TRUE;
+}
 static void
 drvctl_dev_add(gchar *name)
+{
 	HalDevice *parent, *d;
 	gchar pdevnode[512];
 	if (drvctl_find_parent (name, pdevnode) == FALSE) {
 		HAL_INFO (("dev_add: name=%s orphan", name));
 		parent = NULL;
 	} else {
 		parent = hal_device_store_match_key_value_string (
 		    hald_get_gdl(), "netbsd.device", pdevnode);
 		if (parent == NULL)
 			HAL_INFO (("dev_add: name=%s but netbsd.device=%s not found",name, pdevnode));
+	}
 	d = devinfo_add_node (parent, name);
 	if (d == NULL)
 		HAL_WARNING (("dev_add: couldn't add %s node (parent=%p)", name, parent));
 	hotplug_event_process_queue ();
+}
 static void
 drvctl_dev_remove(gchar *name)
+{
 	HAL_INFO (("dev_remove: %s", name));
 	devinfo_remove_branch (name, NULL);
 	hotplug_event_process_queue ();
+}
 static void
 drvctl_dev_branch(gchar *name)
+{
 	HAL_INFO (("branch_remove: %s", name));
 	devinfo_remove_branch (name, NULL);
 	hotplug_event_process_queue ();
+}
 int
 drvctl_list(const gchar *name, struct devlistargs *laa)
+{
 	size_t children;
 	/* HAL_INFO (("drvctl_list: %s", name)); */
 	memset (laa, 0, sizeof (*laa));
 	strlcpy (laa->l_devname, name, sizeof (laa->l_devname));
 	if (ioctl (drvctl_fd, DRVLISTDEV, laa) == -1) {
 		HAL_INFO (("DRVLISTDEV/1 failed: %s", strerror(errno)));
 		return -1;
+	}
 	children = laa->l_children;
 	/* HAL_INFO (("%s: found %d children", name, children)); */
 	if (children == 0)
 		return -1;
 	laa->l_childname = malloc (children * sizeof (laa->l_childname[0]));
 	if (laa->l_childname == NULL) {
 		HAL_INFO (("drvctl_list couldn't allocate %d children: %s\n", children, strerror(errno)));
 		return -1;
+	}
 	if (ioctl (drvctl_fd, DRVLISTDEV, laa) == -1) {
 		HAL_INFO (("DRVLISTDEV/2 failed: %s", strerror(errno)));
 		return -1;
+	}
 	if (children != laa->l_children)
 		HAL_WARNING (("DRVLISTDEV/3 expected %d children, got %d", children, laa->l_childname));
 	return 0;
+}
 gboolean
 drvctl_find_device(const gchar *devnode, prop_dictionary_t *properties)
+{
 	prop_dictionary_t command_dict;
 	prop_dictionary_t args_dict;
 	prop_dictionary_t results_dict;
 	int err;
 	command_dict = prop_dictionary_create ();
 	args_dict = prop_dictionary_create ();
 	prop_dictionary_set_cstring_nocopy (command_dict, "drvctl-command", "get-properties");
 	prop_dictionary_set_cstring_nocopy (args_dict, "device-name", devnode);
 	prop_dictionary_set (command_dict, "drvctl-arguments", args_dict);
 	prop_object_release (args_dict);
 	err = prop_dictionary_sendrecv_ioctl (command_dict, drvctl_fd,
 					      DRVCTLCOMMAND, &results_dict);
 	prop_object_release (command_dict);
 	if (err)
 		return FALSE;
 	if (prop_dictionary_get_int8 (results_dict, "drvctl-error", &err) == false || err != 0) {
 		prop_object_release (results_dict);
 		return FALSE;
+	}
 	if (properties) {
 		prop_dictionary_t result_data;
 		result_data = prop_dictionary_get (results_dict, "drvctl-result-data");
 		if (result_data)
 			*properties = prop_dictionary_copy (result_data);
+	}
 	prop_object_release (results_dict);
 	return TRUE;
+}
 static gboolean
 drvctl_find_device_with_child(const gchar *curnode, const gchar *devnode,
     char *parent)
+{
 	struct devlistargs laa;
 	u_int i;
 	if (drvctl_list (curnode, &laa) == -1)
 		return FALSE;
 	for (i = 0; i < laa.l_children; i++) {
 		if (strcmp (laa.l_childname[i], devnode) == 0) {
 			strlcpy(parent, curnode, 16);
 			free(laa.l_childname);
 			return TRUE;
+		}
 		if (drvctl_find_device_with_child (laa.l_childname[i], devnode, parent) == TRUE) {
 			free(laa.l_childname);
 			return TRUE;
+		}
+	}
 	if (laa.l_childname)
 		free(laa.l_childname);
 	HAL_INFO (("%s: couldn't find device with child %s", curnode, devnode));
 	return FALSE;
+}
 gboolean
 drvctl_find_parent(const gchar *devnode, char *parent)
+{
-	return drvctl_find_device_with_child("mainbus0", devnode, parent);
+	gboolean ret;
 	ret = drvctl_find_device_with_child("mainbus0", devnode, parent);
 	if (ret == FALSE) {
 		ret = drvctl_find_device_with_child("armfdt0", devnode, parent);
+	}
 	return ret;
+}
 #if 0
 static void
 drvctl_lofi_add(gchar *devfs_path, gchar *name)
+{
 	di_node_t node;
 	const char *parent_udi;
 	HalDevice *d, *parent;
 	HAL_INFO (("lofi_add: %s %s", name, devfs_path));
 	if ((d = hal_device_store_match_key_value_string (hald_get_gdl (),
 	    "solaris.devfs_path", devfs_path)) == NULL) {
 		HAL_INFO (("device not found in GDL %s", devfs_path));
 		return;
+	}
 	parent_udi = hal_device_property_get_string (d, "info.parent");
 	if ((parent_udi == NULL) || (strlen(parent_udi) == 0)) {
 		HAL_INFO (("parent not found in GDL %s", parent_udi));
 		return;
+	}
 	if ((parent = hal_device_store_match_key_value_string (hald_get_gdl (),
 	    "info.udi", parent_udi)) == NULL) {
 		HAL_INFO (("parent not found in GDL %s", parent_udi));
 		return;
+	}
 	if ((node = di_init (devfs_path, DINFOCPYALL)) == DI_NODE_NIL) {
 		HAL_INFO (("device not found in devinfo %s", devfs_path));
 		return;
+	}
 	HAL_INFO (("device %s parent %s", hal_device_get_udi (d), parent_udi));
 	devinfo_lofi_add_major (parent, node, devfs_path, NULL, TRUE, d);
 	di_fini (node);
 	hotplug_event_process_queue ();
+}
 static void
 drvctl_lofi_remove(gchar *parent_devfs_path, gchar *name)
+{
 	devinfo_lofi_remove_minor(parent_devfs_path, name);
 	hotplug_event_process_queue ();
+}
 #endif

	@@ -1,183 +1,188 @@		@@ -1,183 +1,188 @@
1	/***************************************************************************	1	/***************************************************************************
2	*	2	*
3	* osspec.c : NetBSD HAL backend entry points	3	* osspec.c : NetBSD HAL backend entry points
4	*	4	*
5	* Copyright 2008 Jared D. McNeill <jmcneill@NetBSD.org>	5	* Copyright 2008 Jared D. McNeill <jmcneill@NetBSD.org>
6	* Copyright 2006 Sun Microsystems, Inc. All rights reserved.	6	* Copyright 2006 Sun Microsystems, Inc. All rights reserved.
7	* Use is subject to license terms.	7	* Use is subject to license terms.
8	*	8	*
9	* Licensed under the Academic Free License version 2.1	9	* Licensed under the Academic Free License version 2.1
10	*	10	*
11	**************************************************************************/	11	**************************************************************************/
12		12
13	#ifdef HAVE_CONFIG_H	13	#ifdef HAVE_CONFIG_H
14	# include <config.h>	14	# include <config.h>
15	#endif	15	#endif
16		16
17	#include <stdio.h>	17	#include <stdio.h>
18	#include <unistd.h>	18	#include <unistd.h>
19	#include <strings.h>	19	#include <strings.h>
20	#include <sys/stat.h>	20	#include <sys/stat.h>
21	#include <fcntl.h>	21	#include <fcntl.h>
22	#include <sys/types.h>	22	#include <sys/types.h>
23	#include <sys/statvfs.h>	23	#include <sys/statvfs.h>
24		24
25	#include "../osspec.h"	25	#include "../osspec.h"
26	#include "../logger.h"	26	#include "../logger.h"
27	#include "../hald.h"	27	#include "../hald.h"
28	#include "../hald_dbus.h"	28	#include "../hald_dbus.h"
29	#include "../device_info.h"	29	#include "../device_info.h"
30	#include "../util.h"	30	#include "../util.h"
31	#include "../ids.h"	31	#include "../ids.h"
32	#include "osspec_netbsd.h"	32	#include "osspec_netbsd.h"
33	#include "hotplug.h"	33	#include "hotplug.h"
34	#include "drvctl.h"	34	#include "drvctl.h"
35	#include "envsys.h"	35	#include "envsys.h"
36	#include "devinfo.h"	36	#include "devinfo.h"
37	#include "devinfo_storage.h"	37	#include "devinfo_storage.h"
38		38
39	static void mntinfo_event_init ();	39	static void mntinfo_event_init ();
40	static gboolean mntinfo_timeout (gpointer user_data);	40	static gboolean mntinfo_timeout (gpointer user_data);
41		41
42	HalFileMonitor *	42	HalFileMonitor *
43	osspec_get_file_monitor (void)	43	osspec_get_file_monitor (void)
44	{	44	{
45	#warning Please implement	45	#warning Please implement
46	return NULL;	46	return NULL;
47	}	47	}
48		48
49	void	49	void
50	osspec_init (void)	50	osspec_init (void)
51	{	51	{
52	ids_init ();	52	ids_init ();
53	mntinfo_event_init ();	53	mntinfo_event_init ();
54	envsys_init ();	54	envsys_init ();
55	}	55	}
56		56
57	void	57	void
58	osspec_privileged_init (void)	58	osspec_privileged_init (void)
59	{	59	{
60	drvctl_init ();	60	drvctl_init ();
61	}	61	}
62		62
63	void	63	void
64	hotplug_queue_now_empty (void)	64	hotplug_queue_now_empty (void)
65	{	65	{
66	if (hald_is_initialising) {	66	if (hald_is_initialising) {
67	osspec_probe_done ();	67	osspec_probe_done ();
68	}	68	}
69	}	69	}
70		70
71	void	71	void
72	osspec_probe (void)	72	osspec_probe (void)
73	{	73	{
74	/* add entire device tree */	74	/* add entire device tree */
75	devinfo_add (NULL, "mainbus0");	75	if (devinfo_probe (NULL, "mainbus0") == TRUE) {
		76	devinfo_add (NULL, "mainbus0");
		77	}
		78	if (devinfo_probe (NULL, "armfdt0") == TRUE) {
		79	devinfo_add (NULL, "armfdt0");
		80	}
76		81
77	/* start processing events */	82	/* start processing events */
78	hotplug_event_process_queue ();	83	hotplug_event_process_queue ();
79	}	84	}
80		85
81	gboolean	86	gboolean
82	osspec_device_rescan (HalDevice *d)	87	osspec_device_rescan (HalDevice *d)
83	{	88	{
84	return (devinfo_device_rescan (d));	89	return (devinfo_device_rescan (d));
85	}	90	}
86		91
87	gboolean	92	gboolean
88	osspec_device_reprobe (HalDevice *d)	93	osspec_device_reprobe (HalDevice *d)
89	{	94	{
90	return FALSE;	95	return FALSE;
91	}	96	}
92		97
93	DBusHandlerResult	98	DBusHandlerResult
94	osspec_filter_function (DBusConnection connection, DBusMessage message, void *user_data)	99	osspec_filter_function (DBusConnection connection, DBusMessage message, void *user_data)
95	{	100	{
96	return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;	101	return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
97	}	102	}
98		103
99	/**	104	/**
100	* hal_util_find_closest_ancestor:	105	* hal_util_find_closest_ancestor:
101	* @devfs_path: Path into devfs, e.g. /pci@0,0/pci1025,57@10,2/storage@1	106	* @devfs_path: Path into devfs, e.g. /pci@0,0/pci1025,57@10,2/storage@1
102	*	107	*
103	* Returns: Parent Hal Device Object or #NULL if there is none	108	* Returns: Parent Hal Device Object or #NULL if there is none
104	*	109	*
105	* Find the closest ancestor by looking at devfs paths	110	* Find the closest ancestor by looking at devfs paths
106	*/	111	*/
107	HalDevice *	112	HalDevice *
108	hal_util_find_closest_ancestor (const gchar devfs_path, gchar ancestor_devfs_path, gchar *hotplug_devfs_path)	113	hal_util_find_closest_ancestor (const gchar devfs_path, gchar ancestor_devfs_path, gchar *hotplug_devfs_path)
109	{	114	{
110	gchar buf[512];	115	gchar buf[512];
111	gchar c;	116	gchar c;
112	HalDevice *parent;	117	HalDevice *parent;
113		118
114	parent = NULL;	119	parent = NULL;
115		120
116	if (drvctl_find_parent (devfs_path, buf) == FALSE)	121	if (drvctl_find_parent (devfs_path, buf) == FALSE)
117	return NULL;	122	return NULL;
118		123
119	HAL_INFO (("hal_util_find_closest_ancestor: devnode=%s parent=%s\n", devfs_path, buf));	124	HAL_INFO (("hal_util_find_closest_ancestor: devnode=%s parent=%s\n", devfs_path, buf));
120		125
121	parent = hal_device_store_match_key_value_string (hald_get_gdl (),	126	parent = hal_device_store_match_key_value_string (hald_get_gdl (),
122	"netbsd.device",	127	"netbsd.device",
123	buf);	128	buf);
124	if (parent != NULL) {	129	if (parent != NULL) {
125	if (ancestor_devfs_path != NULL) {	130	if (ancestor_devfs_path != NULL) {
126	*ancestor_devfs_path = g_strdup (buf);	131	*ancestor_devfs_path = g_strdup (buf);
127	}	132	}
128	if (hotplug_devfs_path != NULL) {	133	if (hotplug_devfs_path != NULL) {
129	*hotplug_devfs_path = g_strdup (buf);	134	*hotplug_devfs_path = g_strdup (buf);
130	}	135	}
131	}	136	}
132		137
133	return parent;	138	return parent;
134	}	139	}
135		140
136	char *	141	char *
137	dsk_to_rdsk(char *dsk)	142	dsk_to_rdsk(char *dsk)
138	{	143	{
139	int len, pos;	144	int len, pos;
140	char *p;	145	char *p;
141	char *rdsk;	146	char *rdsk;
142		147
143	if ((len = strlen (dsk)) < sizeof ("/dev/AANA") - 1) {	148	if ((len = strlen (dsk)) < sizeof ("/dev/AANA") - 1) {
144	return (strdup(""));	149	return (strdup(""));
145	}	150	}
146	p = strstr (dsk, "/dev/");	151	p = strstr (dsk, "/dev/");
147	if (p == NULL) {	152	if (p == NULL) {
148	return (strdup(""));	153	return (strdup(""));
149	}	154	}
150		155
151	pos = (uintptr_t)p - (uintptr_t)dsk;	156	pos = (uintptr_t)p - (uintptr_t)dsk;
152	if ((rdsk = (char *)calloc (len + 2, 1)) != NULL) {	157	if ((rdsk = (char *)calloc (len + 2, 1)) != NULL) {
153	strncpy (rdsk, dsk, pos + 1);	158	strncpy (rdsk, dsk, pos + 1);
154	rdsk[pos + 1] = 'r';	159	rdsk[pos + 1] = 'r';
155	strcpy (rdsk + pos + 2, dsk + pos + 1);	160	strcpy (rdsk + pos + 2, dsk + pos + 1);
156	}	161	}
157		162
158	return (rdsk);	163	return (rdsk);
159	}	164	}
160		165
161	/*	166	/*
162	* Setup to watch mntinfo changes	167	* Setup to watch mntinfo changes
163	*/	168	*/
164	static void	169	static void
165	mntinfo_event_init ()	170	mntinfo_event_init ()
166	{	171	{
167	g_timeout_add (1000, mntinfo_timeout, NULL);	172	g_timeout_add (1000, mntinfo_timeout, NULL);
168	}	173	}
169		174
170	static gboolean	175	static gboolean
171	mntinfo_timeout (gpointer user_data)	176	mntinfo_timeout (gpointer user_data)
172	{	177	{
173	if (!hald_is_initialising)	178	if (!hald_is_initialising)
174	vfsstat_event (NULL);	179	vfsstat_event (NULL);
175		180
176	return TRUE;	181	return TRUE;
177	}	182	}
178		183
179	void	184	void
180	osspec_refresh_mount_state_for_block_device (HalDevice *d)	185	osspec_refresh_mount_state_for_block_device (HalDevice *d)
181	{	186	{
182	vfsstat_event (d);	187	vfsstat_event (d);
183	}	188	}