trivial: DkpDevice -> UpDevice (no ABI or API break)

24 files changed, 845 insertions, 845 deletions

diff --git a/src/Makefile.am b/src/Makefile.am
index 315b2d6..ac20da9 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -48,7 +48,7 @@ up-daemon-glue.h: org.freedesktop.DeviceKit.Power.xml Makefile.am
 	dbus-binding-tool --prefix=up_daemon --mode=glib-server --output=up-daemon-glue.h org.freedesktop.DeviceKit.Power.xml
 
 up-device-glue.h: org.freedesktop.DeviceKit.Power.Device.xml Makefile.am
-	dbus-binding-tool --prefix=dkp_device --mode=glib-server --output=up-device-glue.h org.freedesktop.DeviceKit.Power.Device.xml
+	dbus-binding-tool --prefix=up_device --mode=glib-server --output=up-device-glue.h org.freedesktop.DeviceKit.Power.Device.xml
 
 up-qos-glue.h: org.freedesktop.DeviceKit.Power.QoS.xml Makefile.am
 	dbus-binding-tool --prefix=dkp_qos --mode=glib-server --output=up-qos-glue.h org.freedesktop.DeviceKit.Power.QoS.xml
diff --git a/src/dummy/up-backend.c b/src/dummy/up-backend.c
index 23e063c..d1445ad 100644
--- a/src/dummy/up-backend.c
+++ b/src/dummy/up-backend.c
@@ -43,8 +43,8 @@ static void	up_backend_finalize	(GObject		*object);
 struct UpBackendPrivate
 {
 	UpDaemon		*daemon;
-	DkpDevice		*device;
-	DkpDeviceList		*device_list; /* unused */
+	UpDevice		*device;
+	UpDeviceList		*device_list; /* unused */
 	GObject			*native;
 };
 
@@ -64,7 +64,7 @@ G_DEFINE_TYPE (UpBackend, up_backend, G_TYPE_OBJECT)
 static gboolean
 up_backend_changed_time_cb (UpBackend *backend)
 {
-	DkpDevice *device;
+	UpDevice *device;
 	GTimeVal timeval;
 
 	//FIXME!
@@ -85,7 +85,7 @@ up_backend_add_cb (UpBackend *backend)
 	gboolean ret;
 
 	/* coldplug */
-	ret = dkp_device_coldplug (backend->priv->device, backend->priv->daemon, backend->priv->native);
+	ret = up_device_coldplug (backend->priv->device, backend->priv->daemon, backend->priv->native);
 	if (!ret) {
 		egg_warning ("failed to coldplug");
 		goto out;
@@ -157,8 +157,8 @@ up_backend_init (UpBackend *backend)
 	backend->priv = UP_BACKEND_GET_PRIVATE (backend);
 	backend->priv->daemon = NULL;
 	backend->priv->device_list = NULL;
-	backend->priv->native = g_object_new (DKP_TYPE_DEVICE, NULL);
-	backend->priv->device = dkp_device_new ();
+	backend->priv->native = g_object_new (UP_TYPE_DEVICE, NULL);
+	backend->priv->device = up_device_new ();
 
 	/* setup dummy */
 	g_object_set (backend->priv->device,
diff --git a/src/freebsd/up-backend.c b/src/freebsd/up-backend.c
index 18efb45..7118ebd 100644
--- a/src/freebsd/up-backend.c
+++ b/src/freebsd/up-backend.c
@@ -64,7 +64,7 @@ static gboolean	up_backend_supports_sleep_state (const gchar *state);
 struct UpBackendPrivate
 {
 	UpDaemon		*daemon;
-	DkpDeviceList		*device_list;
+	UpDeviceList		*device_list;
 	GHashTable		*handle_map;
 	guint			poll_timer_id;
 };
@@ -95,15 +95,15 @@ up_backend_refresh_devices (gpointer user_data)
 {
 	UpBackend *backend;
 	GPtrArray *array;
-	DkpDevice *device;
+	UpDevice *device;
 	guint i;
 
 	backend = UP_BACKEND (user_data);
-	array = dkp_device_list_get_array (backend->priv->device_list);
+	array = up_device_list_get_array (backend->priv->device_list);
 
 	for (i = 0; i < array->len; i++) {
-		device = DKP_DEVICE (g_ptr_array_index (array, i));
-		dkp_device_refresh_internal (device);
+		device = UP_DEVICE (g_ptr_array_index (array, i));
+		up_device_refresh_internal (device);
 	}
 
 	g_ptr_array_unref (array);
@@ -125,7 +125,7 @@ up_backend_acpi_devd_notify (UpBackend *backend, const gchar *system, const gcha
 
 	if (!strcmp (subsystem, "ACAD")) {
 		native = dkp_acpi_native_new ("hw.acpi.acline");
-		object = dkp_device_list_lookup (backend->priv->device_list, G_OBJECT (native));
+		object = up_device_list_lookup (backend->priv->device_list, G_OBJECT (native));
 	} else if (!strcmp (subsystem, "CMBAT")) {
 		gchar *ptr;
 		int unit;
@@ -134,13 +134,13 @@ up_backend_acpi_devd_notify (UpBackend *backend, const gchar *system, const gcha
 
 		if (ptr != NULL && sscanf (ptr, ".BAT%i", &unit)) {
 			native = dkp_acpi_native_new_driver_unit ("battery", unit);
-			object = dkp_device_list_lookup (backend->priv->device_list, G_OBJECT (native));
+			object = up_device_list_lookup (backend->priv->device_list, G_OBJECT (native));
 			if (object == NULL) {
 				gpointer hptr;
 
 				hptr = g_hash_table_lookup (backend->priv->handle_map, type);
 				if (hptr != NULL) {
-					object = dkp_device_list_lookup (backend->priv->device_list, G_OBJECT (hptr));
+					object = up_device_list_lookup (backend->priv->device_list, G_OBJECT (hptr));
 				}
 			}
 		}
@@ -171,7 +171,7 @@ up_backend_acpi_devd_notify (UpBackend *backend, const gchar *system, const gcha
 		goto out;
 	}
 
-	dkp_device_refresh_internal (DKP_DEVICE (object));
+	up_device_refresh_internal (UP_DEVICE (object));
 
 	if (object != NULL)
 		g_object_unref (object);
@@ -188,11 +188,11 @@ out:
 static gboolean
 up_backend_create_new_device (UpBackend *backend, DkpAcpiNative *native)
 {
-	DkpDevice *device;
+	UpDevice *device;
 	gboolean ret;
 
-	device = DKP_DEVICE (dkp_device_supply_new ());
-	ret = dkp_device_coldplug (device, backend->priv->daemon, G_OBJECT (native));
+	device = UP_DEVICE (up_device_supply_new ());
+	ret = up_device_coldplug (device, backend->priv->daemon, G_OBJECT (native));
 	if (!ret)
 		g_object_unref (device);
 	else {
@@ -260,15 +260,15 @@ up_backend_coldplug (UpBackend *backend, UpDaemon *daemon)
 
 		for (j = 0; dkp_has_sysctl ("dev.%s.%i.%%driver", handlers[i], j); j++) {
 			DkpAcpiNative *native;
-			DkpDevice *device;
+			UpDevice *device;
 			GObject *object;
 
 			native = dkp_acpi_native_new_driver_unit (handlers[i], j);
-			object = dkp_device_list_lookup (backend->priv->device_list, G_OBJECT (native));
+			object = up_device_list_lookup (backend->priv->device_list, G_OBJECT (native));
 			if (object != NULL) {
-				device = DKP_DEVICE (object);
-				egg_warning ("treating add event as change event on %s", dkp_device_get_object_path (device));
-				dkp_device_refresh_internal (device);
+				device = UP_DEVICE (object);
+				egg_warning ("treating add event as change event on %s", up_device_get_object_path (device));
+				up_device_refresh_internal (device);
 			} else {
 				up_backend_create_new_device (backend, native);
 			}
diff --git a/src/freebsd/up-device-supply.c b/src/freebsd/up-device-supply.c
index 69eb092..9aa0700 100644
--- a/src/freebsd/up-device-supply.c
+++ b/src/freebsd/up-device-supply.c
@@ -47,25 +47,25 @@
 
 #define DKP_ACPIDEV			"/dev/acpi"
 
-G_DEFINE_TYPE (DkpDeviceSupply, dkp_device_supply, DKP_TYPE_DEVICE)
-
-static gboolean		 dkp_device_supply_refresh	 	(DkpDevice *device);
-static DkpDeviceTechnology	dkp_device_supply_convert_device_technology (const gchar *type);
-static gboolean		dkp_device_supply_acline_coldplug	(DkpDevice *device);
-static gboolean		dkp_device_supply_battery_coldplug	(DkpDevice *device, DkpAcpiNative *native);
-static gboolean		dkp_device_supply_acline_set_properties	(DkpDevice *device);
-static gboolean		dkp_device_supply_battery_set_properties	(DkpDevice *device, DkpAcpiNative *native);
-static gboolean		dkp_device_supply_get_on_battery	(DkpDevice *device, gboolean *on_battery);
-static gboolean		dkp_device_supply_get_low_battery	(DkpDevice *device, gboolean *low_battery);
-static gboolean		dkp_device_supply_get_online		(DkpDevice *device, gboolean *online);
+G_DEFINE_TYPE (UpDeviceSupply, up_device_supply, UP_TYPE_DEVICE)
+
+static gboolean		 up_device_supply_refresh	 	(UpDevice *device);
+static UpDeviceTechnology	up_device_supply_convert_device_technology (const gchar *type);
+static gboolean		up_device_supply_acline_coldplug	(UpDevice *device);
+static gboolean		up_device_supply_battery_coldplug	(UpDevice *device, DkpAcpiNative *native);
+static gboolean		up_device_supply_acline_set_properties	(UpDevice *device);
+static gboolean		up_device_supply_battery_set_properties	(UpDevice *device, DkpAcpiNative *native);
+static gboolean		up_device_supply_get_on_battery	(UpDevice *device, gboolean *on_battery);
+static gboolean		up_device_supply_get_low_battery	(UpDevice *device, gboolean *low_battery);
+static gboolean		up_device_supply_get_online		(UpDevice *device, gboolean *online);
 
 /**
- * dkp_device_supply_convert_device_technology:
+ * up_device_supply_convert_device_technology:
  *
  * This is taken from linux/dkp-device-supply.c.
  **/
-static DkpDeviceTechnology
-dkp_device_supply_convert_device_technology (const gchar *type)
+static UpDeviceTechnology
+up_device_supply_convert_device_technology (const gchar *type)
 {
 	if (type == NULL)
 		return DKP_DEVICE_TECHNOLOGY_UNKNOWN;
@@ -87,10 +87,10 @@ dkp_device_supply_convert_device_technology (const gchar *type)
 }
 
 /**
- * dkp_device_supply_reset_values:
+ * up_device_supply_reset_values:
  **/
 static void
-dkp_device_supply_reset_values (DkpDevice *device)
+up_device_supply_reset_values (UpDevice *device)
 {
 	/* reset to default */
 	g_object_set (device,
@@ -120,10 +120,10 @@ dkp_device_supply_reset_values (DkpDevice *device)
 }
 
 /**
- * dkp_device_supply_acline_coldplug:
+ * up_device_supply_acline_coldplug:
  **/
 static gboolean
-dkp_device_supply_acline_coldplug (DkpDevice *device)
+up_device_supply_acline_coldplug (UpDevice *device)
 {
 	gboolean ret;
 
@@ -133,30 +133,30 @@ dkp_device_supply_acline_coldplug (DkpDevice *device)
 		      "type", DKP_DEVICE_TYPE_LINE_POWER,
 		      NULL);
 
-	ret = dkp_device_supply_acline_set_properties (device);
+	ret = up_device_supply_acline_set_properties (device);
 
 	return ret;
 }
 
 /**
- * dkp_device_supply_battery_coldplug:
+ * up_device_supply_battery_coldplug:
  **/
 static gboolean
-dkp_device_supply_battery_coldplug (DkpDevice *device, DkpAcpiNative *native)
+up_device_supply_battery_coldplug (UpDevice *device, DkpAcpiNative *native)
 {
 	gboolean ret;
 
 	g_object_set (device, "type", DKP_DEVICE_TYPE_BATTERY, NULL);
-	ret = dkp_device_supply_battery_set_properties (device, native);
+	ret = up_device_supply_battery_set_properties (device, native);
 
 	return ret;
 }
 
 /**
- * dkp_device_supply_battery_set_properties:
+ * up_device_supply_battery_set_properties:
  **/
 static gboolean
-dkp_device_supply_battery_set_properties (DkpDevice *device, DkpAcpiNative *native)
+up_device_supply_battery_set_properties (UpDevice *device, DkpAcpiNative *native)
 {
 	gint fd;
 	gdouble volt, dvolt, rate, lastfull, cap, dcap, lcap, capacity;
@@ -164,8 +164,8 @@ dkp_device_supply_battery_set_properties (DkpDevice *device, DkpAcpiNative *nati
 	gboolean ret = FALSE;
 	guint64 time_to_empty, time_to_full;
 	gchar *vendor, *model, *serial;
-	DkpDeviceTechnology technology;
-	DkpDeviceState state;
+	UpDeviceTechnology technology;
+	UpDeviceState state;
 	union acpi_battery_ioctl_arg battif, battst, battinfo;
 
 	if (!dkp_has_sysctl ("hw.acpi.battery.units"))
@@ -200,14 +200,14 @@ dkp_device_supply_battery_set_properties (DkpDevice *device, DkpAcpiNative *nati
 	g_object_set (device, "is-present", is_present, NULL);
 
 	if (!is_present) {
-		dkp_device_supply_reset_values (device);
+		up_device_supply_reset_values (device);
 		goto end;
 	}
 
 	vendor = dkp_make_safe_string (battif.bif.oeminfo);
 	model = dkp_make_safe_string (battif.bif.model);
 	serial = dkp_make_safe_string (battif.bif.serial);
-	technology = dkp_device_supply_convert_device_technology (battif.bif.type);
+	technology = up_device_supply_convert_device_technology (battif.bif.type);
 
 	g_object_set (device,
 		      "vendor", vendor,
@@ -323,10 +323,10 @@ end:
 }
 
 /**
- * dkp_device_supply_acline_set_properties:
+ * up_device_supply_acline_set_properties:
  **/
 static gboolean
-dkp_device_supply_acline_set_properties (DkpDevice *device)
+up_device_supply_acline_set_properties (UpDevice *device)
 {
 	int acstate;
 
@@ -339,20 +339,20 @@ dkp_device_supply_acline_set_properties (DkpDevice *device)
 }
 
 /**
- * dkp_device_supply_coldplug:
+ * up_device_supply_coldplug:
  * Return %TRUE on success, %FALSE if we failed to get data and should be removed
  **/
 static gboolean
-dkp_device_supply_coldplug (DkpDevice *device)
+up_device_supply_coldplug (UpDevice *device)
 {
 	DkpAcpiNative *native;
 	const gchar *native_path;
 	const gchar *driver;
 	gboolean ret = FALSE;
 
-	dkp_device_supply_reset_values (device);
+	up_device_supply_reset_values (device);
 
-	native = DKP_ACPI_NATIVE (dkp_device_get_native (device));
+	native = DKP_ACPI_NATIVE (up_device_get_native (device));
 	native_path = dkp_acpi_native_get_path (native);
 	driver = dkp_acpi_native_get_driver (native);
 	if (native_path == NULL) {
@@ -361,12 +361,12 @@ dkp_device_supply_coldplug (DkpDevice *device)
 	}
 
 	if (!strcmp (native_path, "hw.acpi.acline")) {
-		ret = dkp_device_supply_acline_coldplug (device);
+		ret = up_device_supply_acline_coldplug (device);
 		goto out;
 	}
 
 	if (!g_strcmp0 (driver, "battery")) {
-		ret = dkp_device_supply_battery_coldplug (device, native);
+		ret = up_device_supply_battery_coldplug (device, native);
 		goto out;
 	}
 
@@ -377,26 +377,26 @@ out:
 }
 
 /**
- * dkp_device_supply_refresh:
+ * up_device_supply_refresh:
  *
  * Return %TRUE on success, %FALSE if we failed to refresh or no data
  **/
 static gboolean
-dkp_device_supply_refresh (DkpDevice *device)
+up_device_supply_refresh (UpDevice *device)
 {
 	GObject *object;
 	GTimeVal timeval;
-	DkpDeviceType type;
+	UpDeviceType type;
 	gboolean ret;
 
 	g_object_get (device, "type", &type, NULL);
 	switch (type) {
 		case DKP_DEVICE_TYPE_LINE_POWER:
-			ret = dkp_device_supply_acline_set_properties (device);
+			ret = up_device_supply_acline_set_properties (device);
 			break;
 		case DKP_DEVICE_TYPE_BATTERY:
-			object = dkp_device_get_native (device);
-			ret = dkp_device_supply_battery_set_properties (device, DKP_ACPI_NATIVE (object));
+			object = up_device_get_native (device);
+			ret = up_device_supply_battery_set_properties (device, DKP_ACPI_NATIVE (object));
 			break;
 		default:
 			g_assert_not_reached ();
@@ -412,13 +412,13 @@ dkp_device_supply_refresh (DkpDevice *device)
 }
 
 /**
- * dkp_device_supply_get_on_battery:
+ * up_device_supply_get_on_battery:
  **/
 static gboolean
-dkp_device_supply_get_on_battery (DkpDevice *device, gboolean *on_battery)
+up_device_supply_get_on_battery (UpDevice *device, gboolean *on_battery)
 {
-	DkpDeviceType type;
-	DkpDeviceState state;
+	UpDeviceType type;
+	UpDeviceState state;
 	gboolean is_present;
 
 	g_return_val_if_fail (on_battery != NULL, FALSE);
@@ -441,10 +441,10 @@ dkp_device_supply_get_on_battery (DkpDevice *device, gboolean *on_battery)
 }
 
 /**
- * dkp_device_supply_get_low_battery:
+ * up_device_supply_get_low_battery:
  **/
 static gboolean
-dkp_device_supply_get_low_battery (DkpDevice *device, gboolean *low_battery)
+up_device_supply_get_low_battery (UpDevice *device, gboolean *low_battery)
 {
 	gboolean ret;
 	gboolean on_battery;
@@ -452,7 +452,7 @@ dkp_device_supply_get_low_battery (DkpDevice *device, gboolean *low_battery)
 
 	g_return_val_if_fail (low_battery != NULL, FALSE);
 
-	ret = dkp_device_supply_get_on_battery (device, &on_battery);
+	ret = up_device_supply_get_on_battery (device, &on_battery);
 	if (!ret)
 		return FALSE;
 
@@ -467,12 +467,12 @@ dkp_device_supply_get_low_battery (DkpDevice *device, gboolean *low_battery)
 }
 
 /**
- * dkp_device_supply_get_online:
+ * up_device_supply_get_online:
  **/
 static gboolean
-dkp_device_supply_get_online (DkpDevice *device, gboolean *online)
+up_device_supply_get_online (UpDevice *device, gboolean *online)
 {
-	DkpDeviceType type;
+	UpDeviceType type;
 	gboolean online_tmp;
 
 	g_return_val_if_fail (online != NULL, FALSE);
@@ -491,52 +491,52 @@ dkp_device_supply_get_online (DkpDevice *device, gboolean *online)
 }
 
 /**
- * dkp_device_supply_init:
+ * up_device_supply_init:
  **/
 static void
-dkp_device_supply_init (DkpDeviceSupply *supply)
+up_device_supply_init (UpDeviceSupply *supply)
 {
 }
 
 /**
- * dkp_device_supply_finalize:
+ * up_device_supply_finalize:
  **/
 static void
-dkp_device_supply_finalize (GObject *object)
+up_device_supply_finalize (GObject *object)
 {
-	DkpDeviceSupply *supply;
+	UpDeviceSupply *supply;
 
 	g_return_if_fail (object != NULL);
-	g_return_if_fail (DKP_IS_SUPPLY (object));
+	g_return_if_fail (UP_IS_DEVICE_SUPPLY (object));
 
-	supply = DKP_DEVICE_SUPPLY (object);
+	supply = UP_DEVICE_SUPPLY (object);
 
-	G_OBJECT_CLASS (dkp_device_supply_parent_class)->finalize (object);
+	G_OBJECT_CLASS (up_device_supply_parent_class)->finalize (object);
 }
 
 /**
- * dkp_device_supply_class_init:
+ * up_device_supply_class_init:
  **/
 static void
-dkp_device_supply_class_init (DkpDeviceSupplyClass *klass)
+up_device_supply_class_init (UpDeviceSupplyClass *klass)
 {
 	GObjectClass *object_class = G_OBJECT_CLASS (klass);
-	DkpDeviceClass *device_class = DKP_DEVICE_CLASS (klass);
-
-	object_class->finalize = dkp_device_supply_finalize;
-	device_class->get_on_battery = dkp_device_supply_get_on_battery;
-	device_class->get_low_battery = dkp_device_supply_get_low_battery;
-	device_class->get_online = dkp_device_supply_get_online;
-	device_class->coldplug = dkp_device_supply_coldplug;
-	device_class->refresh = dkp_device_supply_refresh;
+	UpDeviceClass *device_class = UP_DEVICE_CLASS (klass);
+
+	object_class->finalize = up_device_supply_finalize;
+	device_class->get_on_battery = up_device_supply_get_on_battery;
+	device_class->get_low_battery = up_device_supply_get_low_battery;
+	device_class->get_online = up_device_supply_get_online;
+	device_class->coldplug = up_device_supply_coldplug;
+	device_class->refresh = up_device_supply_refresh;
 }
 
 /**
- * dkp_device_supply_new:
+ * up_device_supply_new:
  **/
-DkpDeviceSupply *
-dkp_device_supply_new (void)
+UpDeviceSupply *
+up_device_supply_new (void)
 {
-	return g_object_new (DKP_TYPE_SUPPLY, NULL);
+	return g_object_new (UP_TYPE_DEVICE_SUPPLY, NULL);
 }
 
diff --git a/src/freebsd/up-device-supply.h b/src/freebsd/up-device-supply.h
index e1b042f..025a070 100644
--- a/src/freebsd/up-device-supply.h
+++ b/src/freebsd/up-device-supply.h
@@ -19,38 +19,38 @@
  *
  */
 
-#ifndef __DKP_DEVICE_SUPPLY_H__
-#define __DKP_DEVICE_SUPPLY_H__
+#ifndef __UP_DEVICE_SUPPLY_H__
+#define __UP_DEVICE_SUPPLY_H__
 
 #include <glib-object.h>
 #include "up-device.h"
 
 G_BEGIN_DECLS
 
-#define DKP_TYPE_SUPPLY  		(dkp_device_supply_get_type ())
-#define DKP_DEVICE_SUPPLY(o)		(G_TYPE_CHECK_INSTANCE_CAST ((o), DKP_TYPE_SUPPLY, DkpDeviceSupply))
-#define DKP_DEVICE_SUPPLY_CLASS(k)	(G_TYPE_CHECK_CLASS_CAST((k), DKP_TYPE_SUPPLY, DkpDeviceSupplyClass))
-#define DKP_IS_SUPPLY(o)		(G_TYPE_CHECK_INSTANCE_TYPE ((o), DKP_TYPE_SUPPLY))
-#define DKP_IS_SUPPLY_CLASS(k)		(G_TYPE_CHECK_CLASS_TYPE ((k), DKP_TYPE_SUPPLY))
-#define DKP_DEVICE_SUPPLY_GET_CLASS(o)	(G_TYPE_INSTANCE_GET_CLASS ((o), DKP_TYPE_SUPPLY, DkpDeviceSupplyClass))
+#define UP_TYPE_DEVICE_SUPPLY  		(up_device_supply_get_type ())
+#define UP_DEVICE_SUPPLY(o)		(G_TYPE_CHECK_INSTANCE_CAST ((o), UP_TYPE_DEVICE_SUPPLY, UpDeviceSupply))
+#define UP_DEVICE_SUPPLY_CLASS(k)	(G_TYPE_CHECK_CLASS_CAST((k), UP_TYPE_DEVICE_SUPPLY, UpDeviceSupplyClass))
+#define UP_IS_DEVICE_SUPPLY(o)		(G_TYPE_CHECK_INSTANCE_TYPE ((o), UP_TYPE_DEVICE_SUPPLY))
+#define UP_IS_DEVICE_SUPPLY_CLASS(k)		(G_TYPE_CHECK_CLASS_TYPE ((k), UP_TYPE_DEVICE_SUPPLY))
+#define UP_DEVICE_SUPPLY_GET_CLASS(o)	(G_TYPE_INSTANCE_GET_CLASS ((o), UP_TYPE_DEVICE_SUPPLY, UpDeviceSupplyClass))
 
-typedef struct DkpDeviceSupplyPrivate DkpDeviceSupplyPrivate;
+typedef struct UpDeviceSupplyPrivate UpDeviceSupplyPrivate;
 
 typedef struct
 {
-	DkpDevice		 parent;
-	DkpDeviceSupplyPrivate	*priv;
-} DkpDeviceSupply;
+	UpDevice		 parent;
+	UpDeviceSupplyPrivate	*priv;
+} UpDeviceSupply;
 
 typedef struct
 {
-	DkpDeviceClass		 parent_class;
-} DkpDeviceSupplyClass;
+	UpDeviceClass		 parent_class;
+} UpDeviceSupplyClass;
 
-GType		 dkp_device_supply_get_type		(void);
-DkpDeviceSupply	*dkp_device_supply_new			(void);
+GType		 up_device_supply_get_type		(void);
+UpDeviceSupply	*up_device_supply_new			(void);
 
 G_END_DECLS
 
-#endif /* __DKP_DEVICE_SUPPLY_H__ */
+#endif /* __UP_DEVICE_SUPPLY_H__ */
 
diff --git a/src/linux/up-backend.c b/src/linux/up-backend.c
index 0d14aee..34daf4b 100644
--- a/src/linux/up-backend.c
+++ b/src/linux/up-backend.c
@@ -50,9 +50,9 @@ static void	up_backend_finalize	(GObject		*object);
 struct UpBackendPrivate
 {
 	UpDaemon		*daemon;
-	DkpDeviceList		*device_list;
+	UpDeviceList		*device_list;
 	GUdevClient		*gudev_client;
-	DkpDeviceList		*managed_devices;
+	UpDeviceList		*managed_devices;
 };
 
 enum {
@@ -71,12 +71,12 @@ static void up_backend_device_remove (UpBackend *backend, GUdevDevice *native);
 /**
  * up_backend_device_new:
  **/
-static DkpDevice *
+static UpDevice *
 up_backend_device_new (UpBackend *backend, GUdevDevice *native)
 {
 	const gchar *subsys;
 	const gchar *native_path;
-	DkpDevice *device = NULL;
+	UpDevice *device = NULL;
 	DkpInput *input;
 	gboolean ret;
 
@@ -84,8 +84,8 @@ up_backend_device_new (UpBackend *backend, GUdevDevice *native)
 	if (g_strcmp0 (subsys, "power_supply") == 0) {
 
 		/* are we a valid power supply */
-		device = DKP_DEVICE (dkp_device_supply_new ());
-		ret = dkp_device_coldplug (device, backend->priv->daemon, G_OBJECT (native));
+		device = UP_DEVICE (up_device_supply_new ());
+		ret = up_device_coldplug (device, backend->priv->daemon, G_OBJECT (native));
 		if (ret)
 			goto out;
 		g_object_unref (device);
@@ -96,8 +96,8 @@ up_backend_device_new (UpBackend *backend, GUdevDevice *native)
 	} else if (g_strcmp0 (subsys, "tty") == 0) {
 
 		/* try to detect a Watts Up? Pro monitor */
-		device = DKP_DEVICE (dkp_device_wup_new ());
-		ret = dkp_device_coldplug (device, backend->priv->daemon, G_OBJECT (native));
+		device = UP_DEVICE (up_device_wup_new ());
+		ret = up_device_coldplug (device, backend->priv->daemon, G_OBJECT (native));
 		if (ret)
 			goto out;
 		g_object_unref (device);
@@ -108,15 +108,15 @@ up_backend_device_new (UpBackend *backend, GUdevDevice *native)
 	} else if (g_strcmp0 (subsys, "usb") == 0) {
 
 		/* see if this is a CSR mouse or keyboard */
-		device = DKP_DEVICE (dkp_device_csr_new ());
-		ret = dkp_device_coldplug (device, backend->priv->daemon, G_OBJECT (native));
+		device = UP_DEVICE (up_device_csr_new ());
+		ret = up_device_coldplug (device, backend->priv->daemon, G_OBJECT (native));
 		if (ret)
 			goto out;
 		g_object_unref (device);
 
 		/* try to detect a HID UPS */
-		device = DKP_DEVICE (dkp_device_hid_new ());
-		ret = dkp_device_coldplug (device, backend->priv->daemon, G_OBJECT (native));
+		device = UP_DEVICE (up_device_hid_new ());
+		ret = up_device_coldplug (device, backend->priv->daemon, G_OBJECT (native));
 		if (ret)
 			goto out;
 		g_object_unref (device);
@@ -140,7 +140,7 @@ up_backend_device_new (UpBackend *backend, GUdevDevice *native)
 			      NULL);
 
 		/* not a power device */
-		dkp_device_list_insert (backend->priv->managed_devices, G_OBJECT (native), G_OBJECT (input));
+		up_device_list_insert (backend->priv->managed_devices, G_OBJECT (native), G_OBJECT (input));
 
 		/* no valid input object */
 		device = NULL;
@@ -160,11 +160,11 @@ static void
 up_backend_device_changed (UpBackend *backend, GUdevDevice *native)
 {
 	GObject *object;
-	DkpDevice *device;
+	UpDevice *device;
 	gboolean ret;
 
 	/* first, check the device and add it if it doesn't exist */
-	object = dkp_device_list_lookup (backend->priv->device_list, G_OBJECT (native));
+	object = up_device_list_lookup (backend->priv->device_list, G_OBJECT (native));
 	if (object == NULL) {
 		egg_warning ("treating change event as add on %s", g_udev_device_get_sysfs_path (native));
 		up_backend_device_add (backend, native);
@@ -172,10 +172,10 @@ up_backend_device_changed (UpBackend *backend, GUdevDevice *native)
 	}
 
 	/* need to refresh device */
-	device = DKP_DEVICE (object);
-	ret = dkp_device_refresh_internal (device);
+	device = UP_DEVICE (object);
+	ret = up_device_refresh_internal (device);
 	if (!ret) {
-		egg_debug ("no changes on %s", dkp_device_get_object_path (device));
+		egg_debug ("no changes on %s", up_device_get_object_path (device));
 		goto out;
 	}
 out:
@@ -190,15 +190,15 @@ static gboolean
 up_backend_device_add (UpBackend *backend, GUdevDevice *native)
 {
 	GObject *object;
-	DkpDevice *device;
+	UpDevice *device;
 	gboolean ret = TRUE;
 
 	/* does device exist in db? */
-	object = dkp_device_list_lookup (backend->priv->device_list, G_OBJECT (native));
+	object = up_device_list_lookup (backend->priv->device_list, G_OBJECT (native));
 	if (object != NULL) {
-		device = DKP_DEVICE (object);
+		device = UP_DEVICE (object);
 		/* we already have the device; treat as change event */
-		egg_warning ("treating add event as change event on %s", dkp_device_get_object_path (device));
+		egg_warning ("treating add event as change event on %s", up_device_get_object_path (device));
 		up_backend_device_changed (backend, native);
 		goto out;
 	}
@@ -225,16 +225,16 @@ static void
 up_backend_device_remove (UpBackend *backend, GUdevDevice *native)
 {
 	GObject *object;
-	DkpDevice *device;
+	UpDevice *device;
 
 	/* does device exist in db? */
-	object = dkp_device_list_lookup (backend->priv->device_list, G_OBJECT (native));
+	object = up_device_list_lookup (backend->priv->device_list, G_OBJECT (native));
 	if (object == NULL) {
 		egg_debug ("ignoring remove event on %s", g_udev_device_get_sysfs_path (native));
 		goto out;
 	}
 
-	device = DKP_DEVICE (object);
+	device = UP_DEVICE (object);
 	/* emit */
 	egg_debug ("emitting device-removed: %s", g_udev_device_get_sysfs_path (native));
 	g_signal_emit (backend, signals[SIGNAL_DEVICE_REMOVED], 0, native, device);
@@ -342,7 +342,7 @@ up_backend_init (UpBackend *backend)
 	backend->priv = UP_BACKEND_GET_PRIVATE (backend);
 	backend->priv->daemon = NULL;
 	backend->priv->device_list = NULL;
-	backend->priv->managed_devices = dkp_device_list_new ();
+	backend->priv->managed_devices = up_device_list_new ();
 }
 
 /**
diff --git a/src/linux/up-device-csr.c b/src/linux/up-device-csr.c
index 2c67174..b52e616 100644
--- a/src/linux/up-device-csr.c
+++ b/src/linux/up-device-csr.c
@@ -40,7 +40,7 @@
 #include "up-enum.h"
 #include "up-device-csr.h"
 
-#define DKP_DEVICE_CSR_REFRESH_TIMEOUT		30L
+#define UP_DEVICE_CSR_REFRESH_TIMEOUT		30L
 
 /* Internal CSR registers */
 #define CSR_P6  			(buf[0])
@@ -52,7 +52,7 @@
 #define CSR_PB0 			(buf[6])
 #define CSR_PB1 			(buf[7])
 
-struct DkpDeviceCsrPrivate
+struct UpDeviceCsrPrivate
 {
 	guint			 poll_timer_id;
 	gboolean		 is_dual;
@@ -62,31 +62,31 @@ struct DkpDeviceCsrPrivate
 	struct usb_device	*device;
 };
 
-G_DEFINE_TYPE (DkpDeviceCsr, dkp_device_csr, DKP_TYPE_DEVICE)
-#define DKP_DEVICE_CSR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), DKP_TYPE_CSR, DkpDeviceCsrPrivate))
+G_DEFINE_TYPE (UpDeviceCsr, up_device_csr, UP_TYPE_DEVICE)
+#define UP_DEVICE_CSR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), UP_TYPE_DEVICE_CSR, UpDeviceCsrPrivate))
 
-static gboolean		 dkp_device_csr_refresh	 	(DkpDevice *device);
+static gboolean		 up_device_csr_refresh	 	(UpDevice *device);
 
 /**
- * dkp_device_csr_poll_cb:
+ * up_device_csr_poll_cb:
  **/
 static gboolean
-dkp_device_csr_poll_cb (DkpDeviceCsr *csr)
+up_device_csr_poll_cb (UpDeviceCsr *csr)
 {
-	DkpDevice *device = DKP_DEVICE (csr);
+	UpDevice *device = UP_DEVICE (csr);
 
-	egg_debug ("Polling: %s", dkp_device_get_object_path (device));
-	dkp_device_csr_refresh (device);
+	egg_debug ("Polling: %s", up_device_get_object_path (device));
+	up_device_csr_refresh (device);
 
 	/* always continue polling */
 	return TRUE;
 }
 
 /**
- * dkp_device_csr_find_device:
+ * up_device_csr_find_device:
  **/
 static struct usb_device *
-dkp_device_csr_find_device (DkpDeviceCsr *csr)
+up_device_csr_find_device (UpDeviceCsr *csr)
 {
 	struct usb_bus *curr_bus;
 	struct usb_device *curr_device;
@@ -123,14 +123,14 @@ out:
 }
 
 /**
- * dkp_device_csr_coldplug:
+ * up_device_csr_coldplug:
  *
  * Return %TRUE on success, %FALSE if we failed to get data and should be removed
  **/
 static gboolean
-dkp_device_csr_coldplug (DkpDevice *device)
+up_device_csr_coldplug (UpDevice *device)
 {
-	DkpDeviceCsr *csr = DKP_DEVICE_CSR (device);
+	UpDeviceCsr *csr = UP_DEVICE_CSR (device);
 	GUdevDevice *native;
 	gboolean ret = FALSE;
 	const gchar *type;
@@ -139,7 +139,7 @@ dkp_device_csr_coldplug (DkpDevice *device)
 	const gchar *product;
 
 	/* get the type */
-	native = G_UDEV_DEVICE (dkp_device_get_native (device));
+	native = G_UDEV_DEVICE (up_device_get_native (device));
 	type = g_udev_device_get_property (native, "DKP_BATTERY_TYPE");
 	if (type == NULL)
 		goto out;
@@ -166,7 +166,7 @@ dkp_device_csr_coldplug (DkpDevice *device)
 	}
 
 	/* try to get the usb device */
-	csr->priv->device = dkp_device_csr_find_device (csr);
+	csr->priv->device = up_device_csr_find_device (csr);
 	if (csr->priv->device == NULL) {
 		egg_debug ("failed to get device %p", csr);
 		goto out;
@@ -198,29 +198,29 @@ dkp_device_csr_coldplug (DkpDevice *device)
 		      NULL);
 
 	/* coldplug */
-	ret = dkp_device_csr_refresh (device);
+	ret = up_device_csr_refresh (device);
 	if (!ret)
 		goto out;
 
 	/* set up a poll */
-	csr->priv->poll_timer_id = g_timeout_add_seconds (DKP_DEVICE_CSR_REFRESH_TIMEOUT,
-							  (GSourceFunc) dkp_device_csr_poll_cb, csr);
+	csr->priv->poll_timer_id = g_timeout_add_seconds (UP_DEVICE_CSR_REFRESH_TIMEOUT,
+							  (GSourceFunc) up_device_csr_poll_cb, csr);
 
 out:
 	return ret;
 }
 
 /**
- * dkp_device_csr_refresh:
+ * up_device_csr_refresh:
  *
  * Return %TRUE on success, %FALSE if we failed to refresh or no data
  **/
 static gboolean
-dkp_device_csr_refresh (DkpDevice *device)
+up_device_csr_refresh (UpDevice *device)
 {
 	gboolean ret = FALSE;
 	GTimeVal timeval;
-	DkpDeviceCsr *csr = DKP_DEVICE_CSR (device);
+	UpDeviceCsr *csr = UP_DEVICE_CSR (device);
 	usb_dev_handle *handle = NULL;
 	char buf[80];
 	unsigned int addr;
@@ -245,7 +245,7 @@ dkp_device_csr_refresh (DkpDevice *device)
 	}
 
 	/* get the charge */
-	written = usb_control_msg (handle, 0xc0, 0x09, 0x03|addr, 0x00|addr, buf, 8, DKP_DEVICE_CSR_REFRESH_TIMEOUT);
+	written = usb_control_msg (handle, 0xc0, 0x09, 0x03|addr, 0x00|addr, buf, 8, UP_DEVICE_CSR_REFRESH_TIMEOUT);
 	ret = (written == 8);
 	if (!ret) {
 		egg_warning ("failed to write to device, wrote %i bytes", written);
@@ -277,12 +277,12 @@ out:
 }
 
 /**
- * dkp_device_csr_init:
+ * up_device_csr_init:
  **/
 static void
-dkp_device_csr_init (DkpDeviceCsr *csr)
+up_device_csr_init (UpDeviceCsr *csr)
 {
-	csr->priv = DKP_DEVICE_CSR_GET_PRIVATE (csr);
+	csr->priv = UP_DEVICE_CSR_GET_PRIVATE (csr);
 
 	usb_init ();
 	usb_find_busses ();
@@ -294,47 +294,47 @@ dkp_device_csr_init (DkpDeviceCsr *csr)
 }
 
 /**
- * dkp_device_csr_finalize:
+ * up_device_csr_finalize:
  **/
 static void
-dkp_device_csr_finalize (GObject *object)
+up_device_csr_finalize (GObject *object)
 {
-	DkpDeviceCsr *csr;
+	UpDeviceCsr *csr;
 
 	g_return_if_fail (object != NULL);
-	g_return_if_fail (DKP_IS_CSR (object));
+	g_return_if_fail (UP_IS_DEVICE_CSR (object));
 
-	csr = DKP_DEVICE_CSR (object);
+	csr = UP_DEVICE_CSR (object);
 	g_return_if_fail (csr->priv != NULL);
 
 	if (csr->priv->poll_timer_id > 0)
 		g_source_remove (csr->priv->poll_timer_id);
 
-	G_OBJECT_CLASS (dkp_device_csr_parent_class)->finalize (object);
+	G_OBJECT_CLASS (up_device_csr_parent_class)->finalize (object);
 }
 
 /**
- * dkp_device_csr_class_init:
+ * up_device_csr_class_init:
  **/
 static void
-dkp_device_csr_class_init (DkpDeviceCsrClass *klass)
+up_device_csr_class_init (UpDeviceCsrClass *klass)
 {
 	GObjectClass *object_class = G_OBJECT_CLASS (klass);
-	DkpDeviceClass *device_class = DKP_DEVICE_CLASS (klass);
+	UpDeviceClass *device_class = UP_DEVICE_CLASS (klass);
 
-	object_class->finalize = dkp_device_csr_finalize;
-	device_class->coldplug = dkp_device_csr_coldplug;
-	device_class->refresh = dkp_device_csr_refresh;
+	object_class->finalize = up_device_csr_finalize;
+	device_class->coldplug = up_device_csr_coldplug;
+	device_class->refresh = up_device_csr_refresh;
 
-	g_type_class_add_private (klass, sizeof (DkpDeviceCsrPrivate));
+	g_type_class_add_private (klass, sizeof (UpDeviceCsrPrivate));
 }
 
 /**
- * dkp_device_csr_new:
+ * up_device_csr_new:
  **/
-DkpDeviceCsr *
-dkp_device_csr_new (void)
+UpDeviceCsr *
+up_device_csr_new (void)
 {
-	return g_object_new (DKP_TYPE_CSR, NULL);
+	return g_object_new (UP_TYPE_DEVICE_CSR, NULL);
 }
 
diff --git a/src/linux/up-device-csr.h b/src/linux/up-device-csr.h
index d605853..65e7f35 100644
--- a/src/linux/up-device-csr.h
+++ b/src/linux/up-device-csr.h
@@ -19,38 +19,38 @@
  *
  */
 
-#ifndef __DKP_DEVICE_CSR_H__
-#define __DKP_DEVICE_CSR_H__
+#ifndef __UP_DEVICE_CSR_H__
+#define __UP_DEVICE_CSR_H__
 
 #include <glib-object.h>
 #include "up-device.h"
 
 G_BEGIN_DECLS
 
-#define DKP_TYPE_CSR  			(dkp_device_csr_get_type ())
-#define DKP_DEVICE_CSR(o)		(G_TYPE_CHECK_INSTANCE_CAST ((o), DKP_TYPE_CSR, DkpDeviceCsr))
-#define DKP_DEVICE_CSR_CLASS(k)		(G_TYPE_CHECK_CLASS_CAST((k), DKP_TYPE_CSR, DkpDeviceCsrClass))
-#define DKP_IS_CSR(o)			(G_TYPE_CHECK_INSTANCE_TYPE ((o), DKP_TYPE_CSR))
-#define DKP_IS_CSR_CLASS(k)		(G_TYPE_CHECK_CLASS_TYPE ((k), DKP_TYPE_CSR))
-#define DKP_DEVICE_CSR_GET_CLASS(o)	(G_TYPE_INSTANCE_GET_CLASS ((o), DKP_TYPE_CSR, DkpDeviceCsrClass))
+#define UP_TYPE_DEVICE_CSR  			(up_device_csr_get_type ())
+#define UP_DEVICE_CSR(o)		(G_TYPE_CHECK_INSTANCE_CAST ((o), UP_TYPE_DEVICE_CSR, UpDeviceCsr))
+#define UP_DEVICE_CSR_CLASS(k)		(G_TYPE_CHECK_CLASS_CAST((k), UP_TYPE_DEVICE_CSR, UpDeviceCsrClass))
+#define UP_IS_DEVICE_CSR(o)			(G_TYPE_CHECK_INSTANCE_TYPE ((o), UP_TYPE_DEVICE_CSR))
+#define UP_IS_DEVICE_CSR_CLASS(k)		(G_TYPE_CHECK_CLASS_TYPE ((k), UP_TYPE_DEVICE_CSR))
+#define UP_DEVICE_CSR_GET_CLASS(o)	(G_TYPE_INSTANCE_GET_CLASS ((o), UP_TYPE_DEVICE_CSR, UpDeviceCsrClass))
 
-typedef struct DkpDeviceCsrPrivate DkpDeviceCsrPrivate;
+typedef struct UpDeviceCsrPrivate UpDeviceCsrPrivate;
 
 typedef struct
 {
-	DkpDevice		 parent;
-	DkpDeviceCsrPrivate	*priv;
-} DkpDeviceCsr;
+	UpDevice		 parent;
+	UpDeviceCsrPrivate	*priv;
+} UpDeviceCsr;
 
 typedef struct
 {
-	DkpDeviceClass		 parent_class;
-} DkpDeviceCsrClass;
+	UpDeviceClass		 parent_class;
+} UpDeviceCsrClass;
 
-GType		 dkp_device_csr_get_type		(void);
-DkpDeviceCsr	*dkp_device_csr_new			(void);
+GType		 up_device_csr_get_type		(void);
+UpDeviceCsr	*up_device_csr_new			(void);
 
 G_END_DECLS
 
-#endif /* __DKP_DEVICE_CSR_H__ */
+#endif /* __UP_DEVICE_CSR_H__ */
 
diff --git a/src/linux/up-device-hid.c b/src/linux/up-device-hid.c
index 7e88d0c..93a1b8e 100644
--- a/src/linux/up-device-hid.c
+++ b/src/linux/up-device-hid.c
@@ -53,54 +53,54 @@
 #include "up-enum.h"
 #include "up-device-hid.h"
 
-#define DKP_DEVICE_HID_REFRESH_TIMEOUT			30l
-
-#define DKP_DEVICE_HID_USAGE				0x840000
-#define DKP_DEVICE_HID_SERIAL				0x8400fe
-#define DKP_DEVICE_HID_CHEMISTRY			0x850089
-#define DKP_DEVICE_HID_CAPACITY_MODE			0x85002c
-#define DKP_DEVICE_HID_BATTERY_VOLTAGE			0x840030
-#define DKP_DEVICE_HID_BELOW_RCL			0x840042
-#define DKP_DEVICE_HID_SHUTDOWN_IMMINENT		0x840069
-#define DKP_DEVICE_HID_PRODUCT				0x8400fe
-#define DKP_DEVICE_HID_SERIAL_NUMBER			0x8400ff
-#define DKP_DEVICE_HID_CHARGING				0x850044
-#define DKP_DEVICE_HID_DISCHARGING 			0x850045
-#define DKP_DEVICE_HID_REMAINING_CAPACITY		0x850066
-#define DKP_DEVICE_HID_RUNTIME_TO_EMPTY			0x850068
-#define DKP_DEVICE_HID_AC_PRESENT			0x8500d0
-#define DKP_DEVICE_HID_BATTERY_PRESENT			0x8500d1
-#define DKP_DEVICE_HID_DESIGN_CAPACITY			0x850083
-#define DKP_DEVICE_HID_DEVICE_NAME			0x850088
-#define DKP_DEVICE_HID_DEVICE_CHEMISTRY			0x850089
-#define DKP_DEVICE_HID_RECHARGEABLE			0x85008b
-#define DKP_DEVICE_HID_OEM_INFORMATION			0x85008f
-
-#define DKP_DEVICE_HID_PAGE_GENERIC_DESKTOP		0x01
-#define DKP_DEVICE_HID_PAGE_CONSUMER_PRODUCT		0x0c
-#define DKP_DEVICE_HID_PAGE_USB_MONITOR			0x80
-#define DKP_DEVICE_HID_PAGE_USB_ENUMERATED_VALUES	0x81
-#define DKP_DEVICE_HID_PAGE_VESA_VIRTUAL_CONTROLS	0x82
-#define DKP_DEVICE_HID_PAGE_RESERVED_MONITOR		0x83
-#define DKP_DEVICE_HID_PAGE_POWER_DEVICE		0x84
-#define DKP_DEVICE_HID_PAGE_BATTERY_SYSTEM		0x85
-
-struct DkpDeviceHidPrivate
+#define UP_DEVICE_HID_REFRESH_TIMEOUT			30l
+
+#define UP_DEVICE_HID_USAGE				0x840000
+#define UP_DEVICE_HID_SERIAL				0x8400fe
+#define UP_DEVICE_HID_CHEMISTRY			0x850089
+#define UP_DEVICE_HID_CAPACITY_MODE			0x85002c
+#define UP_DEVICE_HID_BATTERY_VOLTAGE			0x840030
+#define UP_DEVICE_HID_BELOW_RCL			0x840042
+#define UP_DEVICE_HID_SHUTDOWN_IMMINENT		0x840069
+#define UP_DEVICE_HID_PRODUCT				0x8400fe
+#define UP_DEVICE_HID_SERIAL_NUMBER			0x8400ff
+#define UP_DEVICE_HID_CHARGING				0x850044
+#define UP_DEVICE_HID_DISCHARGING 			0x850045
+#define UP_DEVICE_HID_REMAINING_CAPACITY		0x850066
+#define UP_DEVICE_HID_RUNTIME_TO_EMPTY			0x850068
+#define UP_DEVICE_HID_AC_PRESENT			0x8500d0
+#define UP_DEVICE_HID_BATTERY_PRESENT			0x8500d1
+#define UP_DEVICE_HID_DESIGN_CAPACITY			0x850083
+#define UP_DEVICE_HID_DEVICE_NAME			0x850088
+#define UP_DEVICE_HID_DEVICE_CHEMISTRY			0x850089
+#define UP_DEVICE_HID_RECHARGEABLE			0x85008b
+#define UP_DEVICE_HID_OEM_INFORMATION			0x85008f
+
+#define UP_DEVICE_HID_PAGE_GENERIC_DESKTOP		0x01
+#define UP_DEVICE_HID_PAGE_CONSUMER_PRODUCT		0x0c
+#define UP_DEVICE_HID_PAGE_USB_MONITOR			0x80
+#define UP_DEVICE_HID_PAGE_USB_ENUMERATED_VALUES	0x81
+#define UP_DEVICE_HID_PAGE_VESA_VIRTUAL_CONTROLS	0x82
+#define UP_DEVICE_HID_PAGE_RESERVED_MONITOR		0x83
+#define UP_DEVICE_HID_PAGE_POWER_DEVICE		0x84
+#define UP_DEVICE_HID_PAGE_BATTERY_SYSTEM		0x85
+
+struct UpDeviceHidPrivate
 {
 	guint			 poll_timer_id;
 	int			 fd;
 };
 
-G_DEFINE_TYPE (DkpDeviceHid, dkp_device_hid, DKP_TYPE_DEVICE)
-#define DKP_DEVICE_HID_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), DKP_TYPE_HID, DkpDeviceHidPrivate))
+G_DEFINE_TYPE (UpDeviceHid, up_device_hid, UP_TYPE_DEVICE)
+#define UP_DEVICE_HID_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), UP_TYPE_DEVICE_HID, UpDeviceHidPrivate))
 
-static gboolean		 dkp_device_hid_refresh	 	(DkpDevice *device);
+static gboolean		 up_device_hid_refresh	 	(UpDevice *device);
 
 /**
- * dkp_device_hid_is_ups:
+ * up_device_hid_is_ups:
  **/
 static gboolean
-dkp_device_hid_is_ups (DkpDeviceHid *hid)
+up_device_hid_is_ups (UpDeviceHid *hid)
 {
 	guint i;
 	int retval;
@@ -117,7 +117,7 @@ dkp_device_hid_is_ups (DkpDeviceHid *hid)
 	/* can we use the hid device as a UPS? */
 	for (i = 0; i < device_info.num_applications; i++) {
 		retval = ioctl (hid->priv->fd, HIDIOCAPPLICATION, i);
-		if (retval >> 16 == DKP_DEVICE_HID_PAGE_POWER_DEVICE) {
+		if (retval >> 16 == UP_DEVICE_HID_PAGE_POWER_DEVICE) {
 			ret = TRUE;
 			goto out;
 		}
@@ -127,25 +127,25 @@ out:
 }
 
 /**
- * dkp_device_hid_poll:
+ * up_device_hid_poll:
  **/
 static gboolean
-dkp_device_hid_poll (DkpDeviceHid *hid)
+up_device_hid_poll (UpDeviceHid *hid)
 {
-	DkpDevice *device = DKP_DEVICE (hid);
+	UpDevice *device = UP_DEVICE (hid);
 
-	egg_debug ("Polling: %s", dkp_device_get_object_path (device));
-	dkp_device_hid_refresh (device);
+	egg_debug ("Polling: %s", up_device_get_object_path (device));
+	up_device_hid_refresh (device);
 
 	/* always continue polling */
 	return TRUE;
 }
 
 /**
- * dkp_device_hid_get_string:
+ * up_device_hid_get_string:
  **/
 static const gchar *
-dkp_device_hid_get_string (DkpDeviceHid *hid, int sindex)
+up_device_hid_get_string (UpDeviceHid *hid, int sindex)
 {
 	static struct hiddev_string_descriptor sdesc;
 
@@ -164,10 +164,10 @@ dkp_device_hid_get_string (DkpDeviceHid *hid, int sindex)
 }
 
 /**
- * dkp_device_hid_convert_device_technology:
+ * up_device_hid_convert_device_technology:
  **/
-static DkpDeviceTechnology
-dkp_device_hid_convert_device_technology (const gchar *type)
+static UpDeviceTechnology
+up_device_hid_convert_device_technology (const gchar *type)
 {
 	if (type == NULL)
 		return DKP_DEVICE_TECHNOLOGY_UNKNOWN;
@@ -178,53 +178,53 @@ dkp_device_hid_convert_device_technology (const gchar *type)
 }
 
 /**
- * dkp_device_hid_set_values:
+ * up_device_hid_set_values:
  **/
 static gboolean
-dkp_device_hid_set_values (DkpDeviceHid *hid, int code, int value)
+up_device_hid_set_values (UpDeviceHid *hid, int code, int value)
 {
 	const gchar *type;
 	gboolean ret = TRUE;
-	DkpDevice *device = DKP_DEVICE (hid);
+	UpDevice *device = UP_DEVICE (hid);
 
 	switch (code) {
-	case DKP_DEVICE_HID_REMAINING_CAPACITY:
+	case UP_DEVICE_HID_REMAINING_CAPACITY:
 		g_object_set (device, "percentage", (gfloat) value, NULL);
 		break;
-	case DKP_DEVICE_HID_RUNTIME_TO_EMPTY:
+	case UP_DEVICE_HID_RUNTIME_TO_EMPTY:
 		g_object_set (device, "time-to-empty", (gint64) value, NULL);
 		break;
-	case DKP_DEVICE_HID_CHARGING:
+	case UP_DEVICE_HID_CHARGING:
 		if (value != 0)
 			g_object_set (device, "state", DKP_DEVICE_STATE_CHARGING, NULL);
 		break;
-	case DKP_DEVICE_HID_DISCHARGING:
+	case UP_DEVICE_HID_DISCHARGING:
 		if (value != 0)
 			g_object_set (device, "state", DKP_DEVICE_STATE_DISCHARGING, NULL);
 		break;
-	case DKP_DEVICE_HID_BATTERY_PRESENT:
+	case UP_DEVICE_HID_BATTERY_PRESENT:
 		g_object_set (device, "is-present", (value != 0), NULL);
 		break;
-	case DKP_DEVICE_HID_DEVICE_NAME:
-		g_object_set (device, "device-name", dkp_device_hid_get_string (hid, value), NULL);
+	case UP_DEVICE_HID_DEVICE_NAME:
+		g_object_set (device, "device-name", up_device_hid_get_string (hid, value), NULL);
 		break;
-	case DKP_DEVICE_HID_CHEMISTRY:
-		type = dkp_device_hid_get_string (hid, value);
-		g_object_set (device, "technology", dkp_device_hid_convert_device_technology (type), NULL);
+	case UP_DEVICE_HID_CHEMISTRY:
+		type = up_device_hid_get_string (hid, value);
+		g_object_set (device, "technology", up_device_hid_convert_device_technology (type), NULL);
 		break;
-	case DKP_DEVICE_HID_RECHARGEABLE:
+	case UP_DEVICE_HID_RECHARGEABLE:
 		g_object_set (device, "is-rechargeable", (value != 0), NULL);
 		break;
-	case DKP_DEVICE_HID_OEM_INFORMATION:
-		g_object_set (device, "vendor", dkp_device_hid_get_string (hid, value), NULL);
+	case UP_DEVICE_HID_OEM_INFORMATION:
+		g_object_set (device, "vendor", up_device_hid_get_string (hid, value), NULL);
 		break;
-	case DKP_DEVICE_HID_PRODUCT:
-		g_object_set (device, "model", dkp_device_hid_get_string (hid, value), NULL);
+	case UP_DEVICE_HID_PRODUCT:
+		g_object_set (device, "model", up_device_hid_get_string (hid, value), NULL);
 		break;
-	case DKP_DEVICE_HID_SERIAL_NUMBER:
-		g_object_set (device, "serial", dkp_device_hid_get_string (hid, value), NULL);
+	case UP_DEVICE_HID_SERIAL_NUMBER:
+		g_object_set (device, "serial", up_device_hid_get_string (hid, value), NULL);
 		break;
-	case DKP_DEVICE_HID_DESIGN_CAPACITY:
+	case UP_DEVICE_HID_DESIGN_CAPACITY:
 		g_object_set (device, "energy-full-design", (gfloat) value, NULL);
 		break;
 	default:
@@ -235,10 +235,10 @@ dkp_device_hid_set_values (DkpDeviceHid *hid, int code, int value)
 }
 
 /**
- * dkp_device_hid_get_all_data:
+ * up_device_hid_get_all_data:
  **/
 static gboolean
-dkp_device_hid_get_all_data (DkpDeviceHid *hid)
+up_device_hid_get_all_data (UpDeviceHid *hid)
 {
 	struct hiddev_report_info rinfo;
 	struct hiddev_field_info finfo;
@@ -269,7 +269,7 @@ dkp_device_hid_get_all_data (DkpDeviceHid *hid)
 					ioctl (hid->priv->fd, HIDIOCGUSAGE, &uref);
 
 					/* process each */
-					dkp_device_hid_set_values (hid, uref.usage_code, uref.value);
+					up_device_hid_set_values (hid, uref.usage_code, uref.value);
 
 					/* we got some data */
 					ret = TRUE;
@@ -282,10 +282,10 @@ dkp_device_hid_get_all_data (DkpDeviceHid *hid)
 }
 
 /**
- * dkp_device_hid_fixup_state:
+ * up_device_hid_fixup_state:
  **/
 static void
-dkp_device_hid_fixup_state (DkpDevice *device)
+up_device_hid_fixup_state (UpDevice *device)
 {
 	gdouble percentage;
 
@@ -298,14 +298,14 @@ dkp_device_hid_fixup_state (DkpDevice *device)
 }
 
 /**
- * dkp_device_hid_coldplug:
+ * up_device_hid_coldplug:
  *
  * Return %TRUE on success, %FALSE if we failed to get data and should be removed
  **/
 static gboolean
-dkp_device_hid_coldplug (DkpDevice *device)
+up_device_hid_coldplug (UpDevice *device)
 {
-	DkpDeviceHid *hid = DKP_DEVICE_HID (device);
+	UpDeviceHid *hid = UP_DEVICE_HID (device);
 	GUdevDevice *native;
 	gboolean ret = FALSE;
 	const gchar *device_file;
@@ -313,7 +313,7 @@ dkp_device_hid_coldplug (DkpDevice *device)
 	const gchar *vendor;
 
 	/* detect what kind of device we are */
-	native = G_UDEV_DEVICE (dkp_device_get_native (device));
+	native = G_UDEV_DEVICE (up_device_get_native (device));
 	type = g_udev_device_get_property (native, "DKP_BATTERY_TYPE");
 	if (type == NULL || g_strcmp0 (type, "ups") != 0)
 		goto out;
@@ -334,7 +334,7 @@ dkp_device_hid_coldplug (DkpDevice *device)
 	}
 
 	/* first check that we are an UPS */
-	ret = dkp_device_hid_is_ups (hid);
+	ret = up_device_hid_is_ups (hid);
 	if (!ret) {
 		egg_debug ("not a HID device: %s", device_file);
 		goto out;
@@ -357,25 +357,25 @@ dkp_device_hid_coldplug (DkpDevice *device)
 		      NULL);
 
 	/* coldplug everything */
-	ret = dkp_device_hid_get_all_data (hid);
+	ret = up_device_hid_get_all_data (hid);
 	if (!ret) {
 		egg_debug ("failed to coldplug: %s", device_file);
 		goto out;
 	}
 
 	/* fix up device states */
-	dkp_device_hid_fixup_state (device);
+	up_device_hid_fixup_state (device);
 out:
 	return ret;
 }
 
 /**
- * dkp_device_hid_refresh:
+ * up_device_hid_refresh:
  *
  * Return %TRUE on success, %FALSE if we failed to refresh or no data
  **/
 static gboolean
-dkp_device_hid_refresh (DkpDevice *device)
+up_device_hid_refresh (UpDevice *device)
 {
 	gboolean set = FALSE;
 	gboolean ret = FALSE;
@@ -383,7 +383,7 @@ dkp_device_hid_refresh (DkpDevice *device)
 	guint i;
 	struct hiddev_event ev[64];
 	int rd;
-	DkpDeviceHid *hid = DKP_DEVICE_HID (device);
+	UpDeviceHid *hid = UP_DEVICE_HID (device);
 
 	/* read any data */
 	rd = read (hid->priv->fd, ev, sizeof (ev));
@@ -403,7 +403,7 @@ dkp_device_hid_refresh (DkpDevice *device)
 
 	/* process each event */
 	for (i=0; i < rd / sizeof (ev[0]); i++) {
-		set = dkp_device_hid_set_values (hid, ev[i].hid, ev[i].value);
+		set = up_device_hid_set_values (hid, ev[i].hid, ev[i].value);
 
 		/* if only takes one match to make refresh a success */
 		if (set)
@@ -411,7 +411,7 @@ dkp_device_hid_refresh (DkpDevice *device)
 	}
 
 	/* fix up device states */
-	dkp_device_hid_fixup_state (device);
+	up_device_hid_fixup_state (device);
 
 	/* reset time */
 	g_get_current_time (&timeval);
@@ -421,29 +421,29 @@ out:
 }
 
 /**
- * dkp_device_hid_init:
+ * up_device_hid_init:
  **/
 static void
-dkp_device_hid_init (DkpDeviceHid *hid)
+up_device_hid_init (UpDeviceHid *hid)
 {
-	hid->priv = DKP_DEVICE_HID_GET_PRIVATE (hid);
+	hid->priv = UP_DEVICE_HID_GET_PRIVATE (hid);
 	hid->priv->fd = -1;
-	hid->priv->poll_timer_id = g_timeout_add_seconds (DKP_DEVICE_HID_REFRESH_TIMEOUT,
-							  (GSourceFunc) dkp_device_hid_poll, hid);
+	hid->priv->poll_timer_id = g_timeout_add_seconds (UP_DEVICE_HID_REFRESH_TIMEOUT,
+							  (GSourceFunc) up_device_hid_poll, hid);
 }
 
 /**
- * dkp_device_hid_finalize:
+ * up_device_hid_finalize:
  **/
 static void
-dkp_device_hid_finalize (GObject *object)
+up_device_hid_finalize (GObject *object)
 {
-	DkpDeviceHid *hid;
+	UpDeviceHid *hid;
 
 	g_return_if_fail (object != NULL);
-	g_return_if_fail (DKP_IS_HID (object));
+	g_return_if_fail (UP_IS_DEVICE_HID (object));
 
-	hid = DKP_DEVICE_HID (object);
+	hid = UP_DEVICE_HID (object);
 	g_return_if_fail (hid->priv != NULL);
 
 	if (hid->priv->fd > 0)
@@ -451,31 +451,31 @@ dkp_device_hid_finalize (GObject *object)
 	if (hid->priv->poll_timer_id > 0)
 		g_source_remove (hid->priv->poll_timer_id);
 
-	G_OBJECT_CLASS (dkp_device_hid_parent_class)->finalize (object);
+	G_OBJECT_CLASS (up_device_hid_parent_class)->finalize (object);
 }
 
 /**
- * dkp_device_hid_class_init:
+ * up_device_hid_class_init:
  **/
 static void
-dkp_device_hid_class_init (DkpDeviceHidClass *klass)
+up_device_hid_class_init (UpDeviceHidClass *klass)
 {
 	GObjectClass *object_class = G_OBJECT_CLASS (klass);
-	DkpDeviceClass *device_class = DKP_DEVICE_CLASS (klass);
+	UpDeviceClass *device_class = UP_DEVICE_CLASS (klass);
 
-	object_class->finalize = dkp_device_hid_finalize;
-	device_class->coldplug = dkp_device_hid_coldplug;
-	device_class->refresh = dkp_device_hid_refresh;
+	object_class->finalize = up_device_hid_finalize;
+	device_class->coldplug = up_device_hid_coldplug;
+	device_class->refresh = up_device_hid_refresh;
 
-	g_type_class_add_private (klass, sizeof (DkpDeviceHidPrivate));
+	g_type_class_add_private (klass, sizeof (UpDeviceHidPrivate));
 }
 
 /**
- * dkp_device_hid_new:
+ * up_device_hid_new:
  **/
-DkpDeviceHid *
-dkp_device_hid_new (void)
+UpDeviceHid *
+up_device_hid_new (void)
 {
-	return g_object_new (DKP_TYPE_HID, NULL);
+	return g_object_new (UP_TYPE_DEVICE_HID, NULL);
 }
 
diff --git a/src/linux/up-device-hid.h b/src/linux/up-device-hid.h
index 7736c94..86bd4d7 100644
--- a/src/linux/up-device-hid.h
+++ b/src/linux/up-device-hid.h
@@ -18,38 +18,38 @@
  *
  */
 
-#ifndef __DKP_DEVICE_HID_H__
-#define __DKP_DEVICE_HID_H__
+#ifndef __UP_DEVICE_HID_H__
+#define __UP_DEVICE_HID_H__
 
 #include <glib-object.h>
 #include "up-device.h"
 
 G_BEGIN_DECLS
 
-#define DKP_TYPE_HID  			(dkp_device_hid_get_type ())
-#define DKP_DEVICE_HID(o)		(G_TYPE_CHECK_INSTANCE_CAST ((o), DKP_TYPE_HID, DkpDeviceHid))
-#define DKP_DEVICE_HID_CLASS(k)		(G_TYPE_CHECK_CLASS_CAST((k), DKP_TYPE_HID, DkpDeviceHidClass))
-#define DKP_IS_HID(o)			(G_TYPE_CHECK_INSTANCE_TYPE ((o), DKP_TYPE_HID))
-#define DKP_IS_HID_CLASS(k)		(G_TYPE_CHECK_CLASS_TYPE ((k), DKP_TYPE_HID))
-#define DKP_DEVICE_HID_GET_CLASS(o)	(G_TYPE_INSTANCE_GET_CLASS ((o), DKP_TYPE_HID, DkpDeviceHidClass))
+#define UP_TYPE_DEVICE_HID  			(up_device_hid_get_type ())
+#define UP_DEVICE_HID(o)		(G_TYPE_CHECK_INSTANCE_CAST ((o), UP_TYPE_DEVICE_HID, UpDeviceHid))
+#define UP_DEVICE_HID_CLASS(k)		(G_TYPE_CHECK_CLASS_CAST((k), UP_TYPE_DEVICE_HID, UpDeviceHidClass))
+#define UP_IS_DEVICE_HID(o)			(G_TYPE_CHECK_INSTANCE_TYPE ((o), UP_TYPE_DEVICE_HID))
+#define UP_IS_DEVICE_HID_CLASS(k)		(G_TYPE_CHECK_CLASS_TYPE ((k), UP_TYPE_DEVICE_HID))
+#define UP_DEVICE_HID_GET_CLASS(o)	(G_TYPE_INSTANCE_GET_CLASS ((o), UP_TYPE_DEVICE_HID, UpDeviceHidClass))
 
-typedef struct DkpDeviceHidPrivate DkpDeviceHidPrivate;
+typedef struct UpDeviceHidPrivate UpDeviceHidPrivate;
 
 typedef struct
 {
-	DkpDevice		 parent;
-	DkpDeviceHidPrivate	*priv;
-} DkpDeviceHid;
+	UpDevice		 parent;
+	UpDeviceHidPrivate	*priv;
+} UpDeviceHid;
 
 typedef struct
 {
-	DkpDeviceClass		 parent_class;
-} DkpDeviceHidClass;
+	UpDeviceClass		 parent_class;
+} UpDeviceHidClass;
 
-GType		 dkp_device_hid_get_type		(void);
-DkpDeviceHid	*dkp_device_hid_new			(void);
+GType		 up_device_hid_get_type		(void);
+UpDeviceHid	*up_device_hid_new			(void);
 
 G_END_DECLS
 
-#endif /* __DKP_DEVICE_HID_H__ */
+#endif /* __UP_DEVICE_HID_H__ */
 
diff --git a/src/linux/up-device-supply.c b/src/linux/up-device-supply.c
index cd7c6cb..d60f896 100644
--- a/src/linux/up-device-supply.c
+++ b/src/linux/up-device-supply.c
@@ -39,12 +39,12 @@
 #include "up-enum.h"
 #include "up-device-supply.h"
 
-#define DKP_DEVICE_SUPPLY_REFRESH_TIMEOUT	30	/* seconds */
-#define DKP_DEVICE_SUPPLY_UNKNOWN_TIMEOUT	2	/* seconds */
-#define DKP_DEVICE_SUPPLY_UNKNOWN_RETRIES	30
-#define DKP_DEVICE_SUPPLY_CHARGED_THRESHOLD	90.0f	/* % */
+#define UP_DEVICE_SUPPLY_REFRESH_TIMEOUT	30	/* seconds */
+#define UP_DEVICE_SUPPLY_UNKNOWN_TIMEOUT	2	/* seconds */
+#define UP_DEVICE_SUPPLY_UNKNOWN_RETRIES	30
+#define UP_DEVICE_SUPPLY_CHARGED_THRESHOLD	90.0f	/* % */
 
-struct DkpDeviceSupplyPrivate
+struct UpDeviceSupplyPrivate
 {
 	guint			 poll_timer_id;
 	gboolean		 has_coldplug_values;
@@ -54,20 +54,20 @@ struct DkpDeviceSupplyPrivate
 	gboolean		 enable_poll;
 };
 
-G_DEFINE_TYPE (DkpDeviceSupply, dkp_device_supply, DKP_TYPE_DEVICE)
-#define DKP_DEVICE_SUPPLY_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), DKP_TYPE_SUPPLY, DkpDeviceSupplyPrivate))
+G_DEFINE_TYPE (UpDeviceSupply, up_device_supply, UP_TYPE_DEVICE)
+#define UP_DEVICE_SUPPLY_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), UP_TYPE_DEVICE_SUPPLY, UpDeviceSupplyPrivate))
 
-static gboolean		 dkp_device_supply_refresh	 	(DkpDevice *device);
+static gboolean		 up_device_supply_refresh	 	(UpDevice *device);
 
 /**
- * dkp_device_supply_refresh_line_power:
+ * up_device_supply_refresh_line_power:
  *
  * Return %TRUE on success, %FALSE if we failed to refresh or no data
  **/
 static gboolean
-dkp_device_supply_refresh_line_power (DkpDeviceSupply *supply)
+up_device_supply_refresh_line_power (UpDeviceSupply *supply)
 {
-	DkpDevice *device = DKP_DEVICE (supply);
+	UpDevice *device = UP_DEVICE (supply);
 	GUdevDevice *native;
 	const gchar *native_path;
 
@@ -75,7 +75,7 @@ dkp_device_supply_refresh_line_power (DkpDeviceSupply *supply)
 	g_object_set (device, "power-supply", TRUE, NULL);
 
 	/* get new AC value */
-	native = G_UDEV_DEVICE (dkp_device_get_native (device));
+	native = G_UDEV_DEVICE (up_device_get_native (device));
 	native_path = g_udev_device_get_sysfs_path (native);
 	g_object_set (device, "online", sysfs_get_int (native_path, "online"), NULL);
 
@@ -83,12 +83,12 @@ dkp_device_supply_refresh_line_power (DkpDeviceSupply *supply)
 }
 
 /**
- * dkp_device_supply_reset_values:
+ * up_device_supply_reset_values:
  **/
 static void
-dkp_device_supply_reset_values (DkpDeviceSupply *supply)
+up_device_supply_reset_values (UpDeviceSupply *supply)
 {
-	DkpDevice *device = DKP_DEVICE (supply);
+	UpDevice *device = UP_DEVICE (supply);
 
 	supply->priv->has_coldplug_values = FALSE;
 	supply->priv->energy_old = 0;
@@ -122,17 +122,17 @@ dkp_device_supply_reset_values (DkpDeviceSupply *supply)
 }
 
 /**
- * dkp_device_supply_get_on_battery:
+ * up_device_supply_get_on_battery:
  **/
 static gboolean
-dkp_device_supply_get_on_battery (DkpDevice *device, gboolean *on_battery)
+up_device_supply_get_on_battery (UpDevice *device, gboolean *on_battery)
 {
-	DkpDeviceSupply *supply = DKP_DEVICE_SUPPLY (device);
-	DkpDeviceType type;
-	DkpDeviceState state;
+	UpDeviceSupply *supply = UP_DEVICE_SUPPLY (device);
+	UpDeviceType type;
+	UpDeviceState state;
 	gboolean is_present;
 
-	g_return_val_if_fail (DKP_IS_SUPPLY (supply), FALSE);
+	g_return_val_if_fail (UP_IS_DEVICE_SUPPLY (supply), FALSE);
 	g_return_val_if_fail (on_battery != NULL, FALSE);
 
 	g_object_get (device,
@@ -153,21 +153,21 @@ dkp_device_supply_get_on_battery (DkpDevice *device, gboolean *on_battery)
 }
 
 /**
- * dkp_device_supply_get_low_battery:
+ * up_device_supply_get_low_battery:
  **/
 static gboolean
-dkp_device_supply_get_low_battery (DkpDevice *device, gboolean *low_battery)
+up_device_supply_get_low_battery (UpDevice *device, gboolean *low_battery)
 {
 	gboolean ret;
 	gboolean on_battery;
-	DkpDeviceSupply *supply = DKP_DEVICE_SUPPLY (device);
+	UpDeviceSupply *supply = UP_DEVICE_SUPPLY (device);
 	gdouble percentage;
 
-	g_return_val_if_fail (DKP_IS_SUPPLY (supply), FALSE);
+	g_return_val_if_fail (UP_IS_DEVICE_SUPPLY (supply), FALSE);
 	g_return_val_if_fail (low_battery != NULL, FALSE);
 
 	/* reuse the common checks */
-	ret = dkp_device_supply_get_on_battery (device, &on_battery);
+	ret = up_device_supply_get_on_battery (device, &on_battery);
 	if (!ret)
 		return FALSE;
 
@@ -183,16 +183,16 @@ dkp_device_supply_get_low_battery (DkpDevice *device, gboolean *low_battery)
 }
 
 /**
- * dkp_device_supply_get_online:
+ * up_device_supply_get_online:
  **/
 static gboolean
-dkp_device_supply_get_online (DkpDevice *device, gboolean *online)
+up_device_supply_get_online (UpDevice *device, gboolean *online)
 {
-	DkpDeviceSupply *supply = DKP_DEVICE_SUPPLY (device);
-	DkpDeviceType type;
+	UpDeviceSupply *supply = UP_DEVICE_SUPPLY (device);
+	UpDeviceType type;
 	gboolean online_tmp;
 
-	g_return_val_if_fail (DKP_IS_SUPPLY (supply), FALSE);
+	g_return_val_if_fail (UP_IS_DEVICE_SUPPLY (supply), FALSE);
 	g_return_val_if_fail (online != NULL, FALSE);
 
 	g_object_get (device,
@@ -209,16 +209,16 @@ dkp_device_supply_get_online (DkpDevice *device, gboolean *online)
 }
 
 /**
- * dkp_device_supply_calculate_rate:
+ * up_device_supply_calculate_rate:
  **/
 static void
-dkp_device_supply_calculate_rate (DkpDeviceSupply *supply)
+up_device_supply_calculate_rate (UpDeviceSupply *supply)
 {
 	guint time_s;
 	gdouble energy;
 	gdouble energy_rate;
 	GTimeVal now;
-	DkpDevice *device = DKP_DEVICE (supply);
+	UpDevice *device = UP_DEVICE (supply);
 
 	g_object_get (device, "energy", &energy, NULL);
 
@@ -249,10 +249,10 @@ dkp_device_supply_calculate_rate (DkpDeviceSupply *supply)
 }
 
 /**
- * dkp_device_supply_convert_device_technology:
+ * up_device_supply_convert_device_technology:
  **/
-static DkpDeviceTechnology
-dkp_device_supply_convert_device_technology (const gchar *type)
+static UpDeviceTechnology
+up_device_supply_convert_device_technology (const gchar *type)
 {
 	if (type == NULL)
 		return DKP_DEVICE_TECHNOLOGY_UNKNOWN;
@@ -275,10 +275,10 @@ dkp_device_supply_convert_device_technology (const gchar *type)
 }
 
 /**
- * dkp_device_supply_get_string:
+ * up_device_supply_get_string:
  **/
 static gchar *
-dkp_device_supply_get_string (const gchar *native_path, const gchar *key)
+up_device_supply_get_string (const gchar *native_path, const gchar *key)
 {
 	gchar *value;
 
@@ -300,10 +300,10 @@ out:
 }
 
 /**
- * dkp_device_supply_get_design_voltage:
+ * up_device_supply_get_design_voltage:
  **/
 static gdouble
-dkp_device_supply_get_design_voltage (const gchar *native_path)
+up_device_supply_get_design_voltage (const gchar *native_path)
 {
 	gdouble voltage;
 
@@ -343,10 +343,10 @@ out:
 }
 
 /**
- * dkp_device_supply_make_safe_string:
+ * up_device_supply_make_safe_string:
  **/
 static void
-dkp_device_supply_make_safe_string (gchar *text)
+up_device_supply_make_safe_string (gchar *text)
 {
 	guint i;
 	guint idx = 0;
@@ -372,20 +372,20 @@ dkp_device_supply_make_safe_string (gchar *text)
 }
 
 /**
- * dkp_device_supply_refresh_battery:
+ * up_device_supply_refresh_battery:
  *
  * Return %TRUE on success, %FALSE if we failed to refresh or no data
  **/
 static gboolean
-dkp_device_supply_refresh_battery (DkpDeviceSupply *supply)
+up_device_supply_refresh_battery (UpDeviceSupply *supply)
 {
 	gchar *status = NULL;
 	gchar *technology_native = NULL;
 	gboolean ret = TRUE;
 	gdouble voltage_design;
-	DkpDeviceState old_state;
-	DkpDeviceState state;
-	DkpDevice *device = DKP_DEVICE (supply);
+	UpDeviceState old_state;
+	UpDeviceState state;
+	UpDevice *device = UP_DEVICE (supply);
 	const gchar *native_path;
 	GUdevDevice *native;
 	gboolean is_present;
@@ -408,14 +408,14 @@ dkp_device_supply_refresh_battery (DkpDeviceSupply *supply)
 	gboolean on_battery;
 	guint battery_count;
 
-	native = G_UDEV_DEVICE (dkp_device_get_native (device));
+	native = G_UDEV_DEVICE (up_device_get_native (device));
 	native_path = g_udev_device_get_sysfs_path (native);
 
 	/* have we just been removed? */
 	is_present = sysfs_get_bool (native_path, "present");
 	g_object_set (device, "is-present", is_present, NULL);
 	if (!is_present) {
-		dkp_device_supply_reset_values (supply);
+		up_device_supply_reset_values (supply);
 		goto out;
 	}
 
@@ -425,7 +425,7 @@ dkp_device_supply_refresh_battery (DkpDeviceSupply *supply)
 		energy = sysfs_get_double (native_path, "energy_avg") / 1000000.0;
 
 	/* used to convert A to W later */
-	voltage_design = dkp_device_supply_get_design_voltage (native_path);
+	voltage_design = up_device_supply_get_design_voltage (native_path);
 
 	/* initial values */
 	if (!supply->priv->has_coldplug_values) {
@@ -434,18 +434,18 @@ dkp_device_supply_refresh_battery (DkpDeviceSupply *supply)
 		g_object_set (device, "power-supply", TRUE, NULL);
 
 		/* the ACPI spec is bad at defining battery type constants */
-		technology_native = dkp_device_supply_get_string (native_path, "technology");
-		g_object_set (device, "technology", dkp_device_supply_convert_device_technology (technology_native), NULL);
+		technology_native = up_device_supply_get_string (native_path, "technology");
+		g_object_set (device, "technology", up_device_supply_convert_device_technology (technology_native), NULL);
 
 		/* get values which may be blank */
-		manufacturer = dkp_device_supply_get_string (native_path, "manufacturer");
-		model_name = dkp_device_supply_get_string (native_path, "model_name");
-		serial_number = dkp_device_supply_get_string (native_path, "serial_number");
+		manufacturer = up_device_supply_get_string (native_path, "manufacturer");
+		model_name = up_device_supply_get_string (native_path, "model_name");
+		serial_number = up_device_supply_get_string (native_path, "serial_number");
 
 		/* some vendors fill this with binary garbage */
-		dkp_device_supply_make_safe_string (manufacturer);
-		dkp_device_supply_make_safe_string (model_name);
-		dkp_device_supply_make_safe_string (serial_number);
+		up_device_supply_make_safe_string (manufacturer);
+		up_device_supply_make_safe_string (model_name);
+		up_device_supply_make_safe_string (serial_number);
 
 		/* are we possibly recalled by the vendor? */
 		recall_notice = g_udev_device_has_property (native, "DKP_RECALL_NOTICE");
@@ -571,7 +571,7 @@ dkp_device_supply_refresh_battery (DkpDeviceSupply *supply)
 
 	/* the hardware reporting failed -- try to calculate this */
 	if (energy_rate < 0)
-		dkp_device_supply_calculate_rate (supply);
+		up_device_supply_calculate_rate (supply);
 
 	/* get a precise percentage */
 	if (energy_full > 0.0f) {
@@ -584,7 +584,7 @@ dkp_device_supply_refresh_battery (DkpDeviceSupply *supply)
 
 	/* some batteries stop charging much before 100% */
 	if (state == DKP_DEVICE_STATE_UNKNOWN &&
-	    percentage > DKP_DEVICE_SUPPLY_CHARGED_THRESHOLD) {
+	    percentage > UP_DEVICE_SUPPLY_CHARGED_THRESHOLD) {
 		egg_debug ("fixing up unknown %f", percentage);
 		state = DKP_DEVICE_STATE_FULLY_CHARGED;
 	}
@@ -594,7 +594,7 @@ dkp_device_supply_refresh_battery (DkpDeviceSupply *supply)
 	if (state == DKP_DEVICE_STATE_UNKNOWN) {
 
 		/* get global battery status */
-		daemon = dkp_device_get_daemon (device);
+		daemon = up_device_get_daemon (device);
 		g_object_get (daemon,
 			      "on-battery", &on_battery,
 			      NULL);
@@ -626,7 +626,7 @@ dkp_device_supply_refresh_battery (DkpDeviceSupply *supply)
 
 		/* print what we did */
 		egg_debug ("guessing battery state '%s' using global on-battery:%i",
-			   dkp_device_state_to_text (state), on_battery);
+			   up_device_state_to_text (state), on_battery);
 
 		g_object_unref (daemon);
 	}
@@ -690,40 +690,40 @@ out:
 }
 
 /**
- * dkp_device_supply_poll_battery:
+ * up_device_supply_poll_battery:
  **/
 static gboolean
-dkp_device_supply_poll_battery (DkpDeviceSupply *supply)
+up_device_supply_poll_battery (UpDeviceSupply *supply)
 {
-	DkpDevice *device = DKP_DEVICE (supply);
+	UpDevice *device = UP_DEVICE (supply);
 
-	egg_debug ("No updates on supply %s for %i seconds; forcing update", dkp_device_get_object_path (device), DKP_DEVICE_SUPPLY_REFRESH_TIMEOUT);
+	egg_debug ("No updates on supply %s for %i seconds; forcing update", up_device_get_object_path (device), UP_DEVICE_SUPPLY_REFRESH_TIMEOUT);
 	supply->priv->poll_timer_id = 0;
-	dkp_device_supply_refresh (device);
+	up_device_supply_refresh (device);
 
 	/* never repeat */
 	return FALSE;
 }
 
 /**
- * dkp_device_supply_coldplug:
+ * up_device_supply_coldplug:
  *
  * Return %TRUE on success, %FALSE if we failed to get data and should be removed
  **/
 static gboolean
-dkp_device_supply_coldplug (DkpDevice *device)
+up_device_supply_coldplug (UpDevice *device)
 {
-	DkpDeviceSupply *supply = DKP_DEVICE_SUPPLY (device);
+	UpDeviceSupply *supply = UP_DEVICE_SUPPLY (device);
 	gboolean ret = FALSE;
 	GUdevDevice *native;
 	const gchar *native_path;
 	gchar *device_type = NULL;
-	DkpDeviceType type = DKP_DEVICE_TYPE_UNKNOWN;
+	UpDeviceType type = DKP_DEVICE_TYPE_UNKNOWN;
 
-	dkp_device_supply_reset_values (supply);
+	up_device_supply_reset_values (supply);
 
 	/* detect what kind of device we are */
-	native = G_UDEV_DEVICE (dkp_device_get_native (device));
+	native = G_UDEV_DEVICE (up_device_get_native (device));
 	native_path = g_udev_device_get_sysfs_path (native);
 	if (native_path == NULL) {
 		egg_warning ("could not get native path for %p", device);
@@ -731,7 +731,7 @@ dkp_device_supply_coldplug (DkpDevice *device)
 	}
 
 	/* try to detect using the device type */
-	device_type = dkp_device_supply_get_string (native_path, "type");
+	device_type = up_device_supply_get_string (native_path, "type");
 	if (device_type != NULL) {
 		if (g_ascii_strcasecmp (device_type, "mains") == 0) {
 			type = DKP_DEVICE_TYPE_LINE_POWER;
@@ -756,20 +756,20 @@ dkp_device_supply_coldplug (DkpDevice *device)
 	g_object_set (device, "type", type, NULL);
 
 	/* coldplug values */
-	ret = dkp_device_supply_refresh (device);
+	ret = up_device_supply_refresh (device);
 out:
 	g_free (device_type);
 	return ret;
 }
 
 /**
- * dkp_device_supply_setup_poll:
+ * up_device_supply_setup_poll:
  **/
 static gboolean
-dkp_device_supply_setup_poll (DkpDevice *device)
+up_device_supply_setup_poll (UpDevice *device)
 {
-	DkpDeviceState state;
-	DkpDeviceSupply *supply = DKP_DEVICE_SUPPLY (device);
+	UpDeviceState state;
+	UpDeviceSupply *supply = UP_DEVICE_SUPPLY (device);
 
 	g_object_get (device, "state", &state, NULL);
 
@@ -779,10 +779,10 @@ dkp_device_supply_setup_poll (DkpDevice *device)
 
 	/* if it's unknown, poll faster than we would normally */
 	if (state == DKP_DEVICE_STATE_UNKNOWN &&
-	    supply->priv->unknown_retries < DKP_DEVICE_SUPPLY_UNKNOWN_RETRIES) {
+	    supply->priv->unknown_retries < UP_DEVICE_SUPPLY_UNKNOWN_RETRIES) {
 		supply->priv->poll_timer_id =
-			g_timeout_add_seconds (DKP_DEVICE_SUPPLY_UNKNOWN_TIMEOUT,
-					       (GSourceFunc) dkp_device_supply_poll_battery, supply);
+			g_timeout_add_seconds (UP_DEVICE_SUPPLY_UNKNOWN_TIMEOUT,
+					       (GSourceFunc) up_device_supply_poll_battery, supply);
 		/* increase count, we don't want to poll at 0.5Hz forever */
 		supply->priv->unknown_retries++;
 		goto out;
@@ -790,24 +790,24 @@ dkp_device_supply_setup_poll (DkpDevice *device)
 
 	/* any other state just fall back */
 	supply->priv->poll_timer_id =
-		g_timeout_add_seconds (DKP_DEVICE_SUPPLY_REFRESH_TIMEOUT,
-				       (GSourceFunc) dkp_device_supply_poll_battery, supply);
+		g_timeout_add_seconds (UP_DEVICE_SUPPLY_REFRESH_TIMEOUT,
+				       (GSourceFunc) up_device_supply_poll_battery, supply);
 out:
 	return (supply->priv->poll_timer_id != 0);
 }
 
 /**
- * dkp_device_supply_refresh:
+ * up_device_supply_refresh:
  *
  * Return %TRUE on success, %FALSE if we failed to refresh or no data
  **/
 static gboolean
-dkp_device_supply_refresh (DkpDevice *device)
+up_device_supply_refresh (UpDevice *device)
 {
 	gboolean ret;
 	GTimeVal timeval;
-	DkpDeviceSupply *supply = DKP_DEVICE_SUPPLY (device);
-	DkpDeviceType type;
+	UpDeviceSupply *supply = UP_DEVICE_SUPPLY (device);
+	UpDeviceType type;
 
 	if (supply->priv->poll_timer_id > 0) {
 		g_source_remove (supply->priv->poll_timer_id);
@@ -817,14 +817,14 @@ dkp_device_supply_refresh (DkpDevice *device)
 	g_object_get (device, "type", &type, NULL);
 	switch (type) {
 	case DKP_DEVICE_TYPE_LINE_POWER:
-		ret = dkp_device_supply_refresh_line_power (supply);
+		ret = up_device_supply_refresh_line_power (supply);
 		break;
 	case DKP_DEVICE_TYPE_BATTERY:
-		ret = dkp_device_supply_refresh_battery (supply);
+		ret = up_device_supply_refresh_battery (supply);
 
 		/* Seems that we don't get change uevents from the
 		 * kernel on some BIOS types */
-		dkp_device_supply_setup_poll (device);
+		up_device_supply_setup_poll (device);
 		break;
 	default:
 		g_assert_not_reached ();
@@ -841,62 +841,62 @@ dkp_device_supply_refresh (DkpDevice *device)
 }
 
 /**
- * dkp_device_supply_init:
+ * up_device_supply_init:
  **/
 static void
-dkp_device_supply_init (DkpDeviceSupply *supply)
+up_device_supply_init (UpDeviceSupply *supply)
 {
-	supply->priv = DKP_DEVICE_SUPPLY_GET_PRIVATE (supply);
+	supply->priv = UP_DEVICE_SUPPLY_GET_PRIVATE (supply);
 	supply->priv->unknown_retries = 0;
 	supply->priv->poll_timer_id = 0;
 	supply->priv->enable_poll = TRUE;
 }
 
 /**
- * dkp_device_supply_finalize:
+ * up_device_supply_finalize:
  **/
 static void
-dkp_device_supply_finalize (GObject *object)
+up_device_supply_finalize (GObject *object)
 {
-	DkpDeviceSupply *supply;
+	UpDeviceSupply *supply;
 
 	g_return_if_fail (object != NULL);
-	g_return_if_fail (DKP_IS_SUPPLY (object));
+	g_return_if_fail (UP_IS_DEVICE_SUPPLY (object));
 
-	supply = DKP_DEVICE_SUPPLY (object);
+	supply = UP_DEVICE_SUPPLY (object);
 	g_return_if_fail (supply->priv != NULL);
 
 	if (supply->priv->poll_timer_id > 0)
 		g_source_remove (supply->priv->poll_timer_id);
 
-	G_OBJECT_CLASS (dkp_device_supply_parent_class)->finalize (object);
+	G_OBJECT_CLASS (up_device_supply_parent_class)->finalize (object);
 }
 
 /**
- * dkp_device_supply_class_init:
+ * up_device_supply_class_init:
  **/
 static void
-dkp_device_supply_class_init (DkpDeviceSupplyClass *klass)
+up_device_supply_class_init (UpDeviceSupplyClass *klass)
 {
 	GObjectClass *object_class = G_OBJECT_CLASS (klass);
-	DkpDeviceClass *device_class = DKP_DEVICE_CLASS (klass);
+	UpDeviceClass *device_class = UP_DEVICE_CLASS (klass);
 
-	object_class->finalize = dkp_device_supply_finalize;
-	device_class->get_on_battery = dkp_device_supply_get_on_battery;
-	device_class->get_low_battery = dkp_device_supply_get_low_battery;
-	device_class->get_online = dkp_device_supply_get_online;
-	device_class->coldplug = dkp_device_supply_coldplug;
-	device_class->refresh = dkp_device_supply_refresh;
+	object_class->finalize = up_device_supply_finalize;
+	device_class->get_on_battery = up_device_supply_get_on_battery;
+	device_class->get_low_battery = up_device_supply_get_low_battery;
+	device_class->get_online = up_device_supply_get_online;
+	device_class->coldplug = up_device_supply_coldplug;
+	device_class->refresh = up_device_supply_refresh;
 
-	g_type_class_add_private (klass, sizeof (DkpDeviceSupplyPrivate));
+	g_type_class_add_private (klass, sizeof (UpDeviceSupplyPrivate));
 }
 
 /**
- * dkp_device_supply_new:
+ * up_device_supply_new:
  **/
-DkpDeviceSupply *
-dkp_device_supply_new (void)
+UpDeviceSupply *
+up_device_supply_new (void)
 {
-	return g_object_new (DKP_TYPE_SUPPLY, NULL);
+	return g_object_new (UP_TYPE_DEVICE_SUPPLY, NULL);
 }
 
diff --git a/src/linux/up-device-supply.h b/src/linux/up-device-supply.h
index e1b042f..a83c0fd 100644
--- a/src/linux/up-device-supply.h
+++ b/src/linux/up-device-supply.h
@@ -19,38 +19,38 @@
  *
  */
 
-#ifndef __DKP_DEVICE_SUPPLY_H__
-#define __DKP_DEVICE_SUPPLY_H__
+#ifndef __UP_DEVICE_SUPPLY_H__
+#define __UP_DEVICE_SUPPLY_H__
 
 #include <glib-object.h>
 #include "up-device.h"
 
 G_BEGIN_DECLS
 
-#define DKP_TYPE_SUPPLY  		(dkp_device_supply_get_type ())
-#define DKP_DEVICE_SUPPLY(o)		(G_TYPE_CHECK_INSTANCE_CAST ((o), DKP_TYPE_SUPPLY, DkpDeviceSupply))
-#define DKP_DEVICE_SUPPLY_CLASS(k)	(G_TYPE_CHECK_CLASS_CAST((k), DKP_TYPE_SUPPLY, DkpDeviceSupplyClass))
-#define DKP_IS_SUPPLY(o)		(G_TYPE_CHECK_INSTANCE_TYPE ((o), DKP_TYPE_SUPPLY))
-#define DKP_IS_SUPPLY_CLASS(k)		(G_TYPE_CHECK_CLASS_TYPE ((k), DKP_TYPE_SUPPLY))
-#define DKP_DEVICE_SUPPLY_GET_CLASS(o)	(G_TYPE_INSTANCE_GET_CLASS ((o), DKP_TYPE_SUPPLY, DkpDeviceSupplyClass))
+#define UP_TYPE_DEVICE_SUPPLY  		(up_device_supply_get_type ())
+#define UP_DEVICE_SUPPLY(o)		(G_TYPE_CHECK_INSTANCE_CAST ((o), UP_TYPE_DEVICE_SUPPLY, UpDeviceSupply))
+#define UP_DEVICE_SUPPLY_CLASS(k)	(G_TYPE_CHECK_CLASS_CAST((k), UP_TYPE_DEVICE_SUPPLY, UpDeviceSupplyClass))
+#define UP_IS_DEVICE_SUPPLY(o)		(G_TYPE_CHECK_INSTANCE_TYPE ((o), UP_TYPE_DEVICE_SUPPLY))
+#define UP_IS_DEVICE_SUPPLY_CLASS(k)	(G_TYPE_CHECK_CLASS_TYPE ((k), UP_TYPE_DEVICE_SUPPLY))
+#define UP_DEVICE_SUPPLY_GET_CLASS(o)	(G_TYPE_INSTANCE_GET_CLASS ((o), UP_TYPE_DEVICE_SUPPLY, UpDeviceSupplyClass))
 
-typedef struct DkpDeviceSupplyPrivate DkpDeviceSupplyPrivate;
+typedef struct UpDeviceSupplyPrivate UpDeviceSupplyPrivate;
 
 typedef struct
 {
-	DkpDevice		 parent;
-	DkpDeviceSupplyPrivate	*priv;
-} DkpDeviceSupply;
+	UpDevice		 parent;
+	UpDeviceSupplyPrivate	*priv;
+} UpDeviceSupply;
 
 typedef struct
 {
-	DkpDeviceClass		 parent_class;
-} DkpDeviceSupplyClass;
+	UpDeviceClass		 parent_class;
+} UpDeviceSupplyClass;
 
-GType		 dkp_device_supply_get_type		(void);
-DkpDeviceSupply	*dkp_device_supply_new			(void);
+GType		 up_device_supply_get_type		(void);
+UpDeviceSupply	*up_device_supply_new			(void);
 
 G_END_DECLS
 
-#endif /* __DKP_DEVICE_SUPPLY_H__ */
+#endif /* __UP_DEVICE_SUPPLY_H__ */
 
diff --git a/src/linux/up-device-wup.c b/src/linux/up-device-wup.c
index 8fc3296..96aec4f 100644
--- a/src/linux/up-device-wup.c
+++ b/src/linux/up-device-wup.c
@@ -47,58 +47,58 @@
 #include "up-enum.h"
 #include "up-device-wup.h"
 
-#define DKP_DEVICE_WUP_REFRESH_TIMEOUT			10 /* seconds */
-#define DKP_DEVICE_WUP_RESPONSE_OFFSET_WATTS		0x0
-#define DKP_DEVICE_WUP_RESPONSE_OFFSET_VOLTS		0x1
-#define DKP_DEVICE_WUP_RESPONSE_OFFSET_AMPS		0x2
-#define DKP_DEVICE_WUP_RESPONSE_OFFSET_KWH		0x3
-#define DKP_DEVICE_WUP_RESPONSE_OFFSET_COST		0x4
-#define DKP_DEVICE_WUP_RESPONSE_OFFSET_MONTHLY_KWH	0x5
-#define DKP_DEVICE_WUP_RESPONSE_OFFSET_MONTHLY_COST	0x6
-#define DKP_DEVICE_WUP_RESPONSE_OFFSET_MAX_WATTS	0x7
-#define DKP_DEVICE_WUP_RESPONSE_OFFSET_MAX_VOLTS	0x8
-#define DKP_DEVICE_WUP_RESPONSE_OFFSET_MAX_AMPS	0x9
-#define DKP_DEVICE_WUP_RESPONSE_OFFSET_MIN_WATTS	0xa
-#define DKP_DEVICE_WUP_RESPONSE_OFFSET_MIN_VOLTS	0xb
-#define DKP_DEVICE_WUP_RESPONSE_OFFSET_MIN_AMPS	0xc
-#define DKP_DEVICE_WUP_RESPONSE_OFFSET_POWER_FACTOR	0xd
-#define DKP_DEVICE_WUP_RESPONSE_OFFSET_DUTY_CYCLE	0xe
-#define DKP_DEVICE_WUP_RESPONSE_OFFSET_POWER_CYCLE	0xf
+#define UP_DEVICE_WUP_REFRESH_TIMEOUT			10 /* seconds */
+#define UP_DEVICE_WUP_RESPONSE_OFFSET_WATTS		0x0
+#define UP_DEVICE_WUP_RESPONSE_OFFSET_VOLTS		0x1
+#define UP_DEVICE_WUP_RESPONSE_OFFSET_AMPS		0x2
+#define UP_DEVICE_WUP_RESPONSE_OFFSET_KWH		0x3
+#define UP_DEVICE_WUP_RESPONSE_OFFSET_COST		0x4
+#define UP_DEVICE_WUP_RESPONSE_OFFSET_MONTHLY_KWH	0x5
+#define UP_DEVICE_WUP_RESPONSE_OFFSET_MONTHLY_COST	0x6
+#define UP_DEVICE_WUP_RESPONSE_OFFSET_MAX_WATTS	0x7
+#define UP_DEVICE_WUP_RESPONSE_OFFSET_MAX_VOLTS	0x8
+#define UP_DEVICE_WUP_RESPONSE_OFFSET_MAX_AMPS	0x9
+#define UP_DEVICE_WUP_RESPONSE_OFFSET_MIN_WATTS	0xa
+#define UP_DEVICE_WUP_RESPONSE_OFFSET_MIN_VOLTS	0xb
+#define UP_DEVICE_WUP_RESPONSE_OFFSET_MIN_AMPS	0xc
+#define UP_DEVICE_WUP_RESPONSE_OFFSET_POWER_FACTOR	0xd
+#define UP_DEVICE_WUP_RESPONSE_OFFSET_DUTY_CYCLE	0xe
+#define UP_DEVICE_WUP_RESPONSE_OFFSET_POWER_CYCLE	0xf
 
 /* commands can never be bigger then this */
-#define DKP_DEVICE_WUP_COMMAND_LEN			256
+#define UP_DEVICE_WUP_COMMAND_LEN			256
 
-struct DkpDeviceWupPrivate
+struct UpDeviceWupPrivate
 {
 	guint			 poll_timer_id;
 	int			 fd;
 };
 
-G_DEFINE_TYPE (DkpDeviceWup, dkp_device_wup, DKP_TYPE_DEVICE)
-#define DKP_DEVICE_WUP_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), DKP_TYPE_WUP, DkpDeviceWupPrivate))
+G_DEFINE_TYPE (UpDeviceWup, up_device_wup, UP_TYPE_DEVICE)
+#define UP_DEVICE_WUP_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), UP_TYPE_DEVICE_WUP, UpDeviceWupPrivate))
 
-static gboolean		 dkp_device_wup_refresh	 	(DkpDevice *device);
+static gboolean		 up_device_wup_refresh	 	(UpDevice *device);
 
 /**
- * dkp_device_wup_poll_cb:
+ * up_device_wup_poll_cb:
  **/
 static gboolean
-dkp_device_wup_poll_cb (DkpDeviceWup *wup)
+up_device_wup_poll_cb (UpDeviceWup *wup)
 {
-	DkpDevice *device = DKP_DEVICE (wup);
+	UpDevice *device = UP_DEVICE (wup);
 
-	egg_debug ("Polling: %s", dkp_device_get_object_path (device));
-	dkp_device_wup_refresh (device);
+	egg_debug ("Polling: %s", up_device_get_object_path (device));
+	up_device_wup_refresh (device);
 
 	/* always continue polling */
 	return TRUE;
 }
 
 /**
- * dkp_device_wup_set_speed:
+ * up_device_wup_set_speed:
  **/
 static gboolean
-dkp_device_wup_set_speed (DkpDeviceWup *wup)
+up_device_wup_set_speed (UpDeviceWup *wup)
 {
 	struct termios t;
 	int retval;
@@ -126,12 +126,12 @@ dkp_device_wup_set_speed (DkpDeviceWup *wup)
 }
 
 /**
- * dkp_device_wup_write_command:
+ * up_device_wup_write_command:
  *
  * data: a command string in the form "#command,subcommand,datalen,data[n]", e.g. "#R,W,0"
  **/
 static gboolean
-dkp_device_wup_write_command (DkpDeviceWup *wup, const gchar *data)
+up_device_wup_write_command (UpDeviceWup *wup, const gchar *data)
 {
 	guint ret = TRUE;
 	gint retval;
@@ -148,16 +148,16 @@ dkp_device_wup_write_command (DkpDeviceWup *wup, const gchar *data)
 }
 
 /**
- * dkp_device_wup_read_command:
+ * up_device_wup_read_command:
  *
  * Return value: Some data to parse
  **/
 static gchar *
-dkp_device_wup_read_command (DkpDeviceWup *wup)
+up_device_wup_read_command (UpDeviceWup *wup)
 {
 	int retval;
-	gchar buffer[DKP_DEVICE_WUP_COMMAND_LEN];
-	retval = read (wup->priv->fd, &buffer, DKP_DEVICE_WUP_COMMAND_LEN);
+	gchar buffer[UP_DEVICE_WUP_COMMAND_LEN];
+	retval = read (wup->priv->fd, &buffer, UP_DEVICE_WUP_COMMAND_LEN);
 	if (retval < 0) {
 		egg_debug ("failed to read from fd: %s", strerror (errno));
 		return NULL;
@@ -166,12 +166,12 @@ dkp_device_wup_read_command (DkpDeviceWup *wup)
 }
 
 /**
- * dkp_device_wup_parse_command:
+ * up_device_wup_parse_command:
  *
  * Return value: Som data to parse
  **/
 static gboolean
-dkp_device_wup_parse_command (DkpDeviceWup *wup, const gchar *data)
+up_device_wup_parse_command (UpDeviceWup *wup, const gchar *data)
 {
 	gboolean ret = FALSE;
 	gchar command;
@@ -182,7 +182,7 @@ dkp_device_wup_parse_command (DkpDeviceWup *wup, const gchar *data)
 	guint size;
 	guint length;
 	guint number_tokens;
-	DkpDevice *device = DKP_DEVICE (wup);
+	UpDevice *device = UP_DEVICE (wup);
 	const guint offset = 3;
 
 	/* invalid */
@@ -272,8 +272,8 @@ dkp_device_wup_parse_command (DkpDeviceWup *wup, const gchar *data)
 	/* update the command fields */
 	if (command == 'd' && subcommand == '-' && number_tokens - offset == 18) {
 		g_object_set (device,
-			      "energy-rate", strtod (tokens[offset+DKP_DEVICE_WUP_RESPONSE_OFFSET_WATTS], NULL) / 10.0f,
-			      "voltage", strtod (tokens[offset+DKP_DEVICE_WUP_RESPONSE_OFFSET_VOLTS], NULL) / 10.0f,
+			      "energy-rate", strtod (tokens[offset+UP_DEVICE_WUP_RESPONSE_OFFSET_WATTS], NULL) / 10.0f,
+			      "voltage", strtod (tokens[offset+UP_DEVICE_WUP_RESPONSE_OFFSET_VOLTS], NULL) / 10.0f,
 			      NULL);
 		ret = TRUE;
 	} else {
@@ -287,14 +287,14 @@ out:
 }
 
 /**
- * dkp_device_wup_coldplug:
+ * up_device_wup_coldplug:
  *
  * Return %TRUE on success, %FALSE if we failed to get data and should be removed
  **/
 static gboolean
-dkp_device_wup_coldplug (DkpDevice *device)
+up_device_wup_coldplug (UpDevice *device)
 {
-	DkpDeviceWup *wup = DKP_DEVICE_WUP (device);
+	UpDeviceWup *wup = UP_DEVICE_WUP (device);
 	GUdevDevice *native;
 	gboolean ret = FALSE;
 	const gchar *device_file;
@@ -305,7 +305,7 @@ dkp_device_wup_coldplug (DkpDevice *device)
 	const gchar *product;
 
 	/* detect what kind of device we are */
-	native = G_UDEV_DEVICE (dkp_device_get_native (device));
+	native = G_UDEV_DEVICE (up_device_get_native (device));
 	type = g_udev_device_get_property (native, "DKP_MONITOR_TYPE");
 	if (type == NULL || g_strcmp0 (type, "wup") != 0)
 		goto out;
@@ -326,30 +326,30 @@ dkp_device_wup_coldplug (DkpDevice *device)
 	egg_debug ("opened %s", device_file);
 
 	/* set speed */
-	ret = dkp_device_wup_set_speed (wup);
+	ret = up_device_wup_set_speed (wup);
 	if (!ret) {
 		egg_debug ("not a WUP device (cannot set speed): %s", device_file);
 		goto out;
 	}
 
 	/* attempt to clear */
-	ret = dkp_device_wup_write_command (wup, "#R,W,0;");
+	ret = up_device_wup_write_command (wup, "#R,W,0;");
 	if (!ret)
 		egg_debug ("failed to clear, nonfatal");
 
 	/* setup logging interval */
-	data = g_strdup_printf ("#L,W,3,E,1,%i;", DKP_DEVICE_WUP_REFRESH_TIMEOUT);
-	ret = dkp_device_wup_write_command (wup, data);
+	data = g_strdup_printf ("#L,W,3,E,1,%i;", UP_DEVICE_WUP_REFRESH_TIMEOUT);
+	ret = up_device_wup_write_command (wup, data);
 	if (!ret)
 		egg_debug ("failed to setup logging interval, nonfatal");
 	g_free (data);
 
 	/* dummy read */
-	data = dkp_device_wup_read_command (wup);
+	data = up_device_wup_read_command (wup);
 	egg_debug ("data after clear %s", data);
 
 	/* shouldn't do anything */
-	dkp_device_wup_parse_command (wup, data);
+	up_device_wup_parse_command (wup, data);
 	g_free (data);
 
 	/* prefer DKP names */
@@ -376,7 +376,7 @@ dkp_device_wup_coldplug (DkpDevice *device)
 
 	/* coldplug */
 	egg_debug ("coldplug");
-	dkp_device_wup_refresh (device);
+	up_device_wup_refresh (device);
 
 	/* hardcode true, as we'll retry later if busy */
 	ret = TRUE;
@@ -386,27 +386,27 @@ out:
 }
 
 /**
- * dkp_device_wup_refresh:
+ * up_device_wup_refresh:
  *
  * Return %TRUE on success, %FALSE if we failed to refresh or no data
  **/
 static gboolean
-dkp_device_wup_refresh (DkpDevice *device)
+up_device_wup_refresh (UpDevice *device)
 {
 	gboolean ret = FALSE;
 	GTimeVal timeval;
 	gchar *data = NULL;
-	DkpDeviceWup *wup = DKP_DEVICE_WUP (device);
+	UpDeviceWup *wup = UP_DEVICE_WUP (device);
 
 	/* get data */
-	data = dkp_device_wup_read_command (wup);
+	data = up_device_wup_read_command (wup);
 	if (data == NULL) {
 		egg_debug ("no data");
 		goto out;
 	}
 
 	/* parse */
-	ret = dkp_device_wup_parse_command (wup, data);
+	ret = up_device_wup_parse_command (wup, data);
 	if (!ret) {
 		egg_debug ("failed to parse %s", data);
 		goto out;
@@ -423,29 +423,29 @@ out:
 }
 
 /**
- * dkp_device_wup_init:
+ * up_device_wup_init:
  **/
 static void
-dkp_device_wup_init (DkpDeviceWup *wup)
+up_device_wup_init (UpDeviceWup *wup)
 {
-	wup->priv = DKP_DEVICE_WUP_GET_PRIVATE (wup);
+	wup->priv = UP_DEVICE_WUP_GET_PRIVATE (wup);
 	wup->priv->fd = -1;
-	wup->priv->poll_timer_id = g_timeout_add_seconds (DKP_DEVICE_WUP_REFRESH_TIMEOUT,
-							  (GSourceFunc) dkp_device_wup_poll_cb, wup);
+	wup->priv->poll_timer_id = g_timeout_add_seconds (UP_DEVICE_WUP_REFRESH_TIMEOUT,
+							  (GSourceFunc) up_device_wup_poll_cb, wup);
 }
 
 /**
- * dkp_device_wup_finalize:
+ * up_device_wup_finalize:
  **/
 static void
-dkp_device_wup_finalize (GObject *object)
+up_device_wup_finalize (GObject *object)
 {
-	DkpDeviceWup *wup;
+	UpDeviceWup *wup;
 
 	g_return_if_fail (object != NULL);
-	g_return_if_fail (DKP_IS_WUP (object));
+	g_return_if_fail (UP_IS_DEVICE_WUP (object));
 
-	wup = DKP_DEVICE_WUP (object);
+	wup = UP_DEVICE_WUP (object);
 	g_return_if_fail (wup->priv != NULL);
 
 	if (wup->priv->fd > 0)
@@ -453,31 +453,31 @@ dkp_device_wup_finalize (GObject *object)
 	if (wup->priv->poll_timer_id > 0)
 		g_source_remove (wup->priv->poll_timer_id);
 
-	G_OBJECT_CLASS (dkp_device_wup_parent_class)->finalize (object);
+	G_OBJECT_CLASS (up_device_wup_parent_class)->finalize (object);
 }
 
 /**
- * dkp_device_wup_class_init:
+ * up_device_wup_class_init:
  **/
 static void
-dkp_device_wup_class_init (DkpDeviceWupClass *klass)
+up_device_wup_class_init (UpDeviceWupClass *klass)
 {
 	GObjectClass *object_class = G_OBJECT_CLASS (klass);
-	DkpDeviceClass *device_class = DKP_DEVICE_CLASS (klass);
+	UpDeviceClass *device_class = UP_DEVICE_CLASS (klass);
 
-	object_class->finalize = dkp_device_wup_finalize;
-	device_class->coldplug = dkp_device_wup_coldplug;
-	device_class->refresh = dkp_device_wup_refresh;
+	object_class->finalize = up_device_wup_finalize;
+	device_class->coldplug = up_device_wup_coldplug;
+	device_class->refresh = up_device_wup_refresh;
 
-	g_type_class_add_private (klass, sizeof (DkpDeviceWupPrivate));
+	g_type_class_add_private (klass, sizeof (UpDeviceWupPrivate));
 }
 
 /**
- * dkp_device_wup_new:
+ * up_device_wup_new:
  **/
-DkpDeviceWup *
-dkp_device_wup_new (void)
+UpDeviceWup *
+up_device_wup_new (void)
 {
-	return g_object_new (DKP_TYPE_WUP, NULL);
+	return g_object_new (UP_TYPE_DEVICE_WUP, NULL);
 }
 
diff --git a/src/linux/up-device-wup.h b/src/linux/up-device-wup.h
index 9d39360..27531fd 100644
--- a/src/linux/up-device-wup.h
+++ b/src/linux/up-device-wup.h
@@ -18,38 +18,38 @@
  *
  */
 
-#ifndef __DKP_DEVICE_WUP_H__
-#define __DKP_DEVICE_WUP_H__
+#ifndef __UP_DEVICE_WUP_H__
+#define __UP_DEVICE_WUP_H__
 
 #include <glib-object.h>
 #include "up-device.h"
 
 G_BEGIN_DECLS
 
-#define DKP_TYPE_WUP  			(dkp_device_wup_get_type ())
-#define DKP_DEVICE_WUP(o)		(G_TYPE_CHECK_INSTANCE_CAST ((o), DKP_TYPE_WUP, DkpDeviceWup))
-#define DKP_DEVICE_WUP_CLASS(k)		(G_TYPE_CHECK_CLASS_CAST((k), DKP_TYPE_WUP, DkpDeviceWupClass))
-#define DKP_IS_WUP(o)			(G_TYPE_CHECK_INSTANCE_TYPE ((o), DKP_TYPE_WUP))
-#define DKP_IS_WUP_CLASS(k)		(G_TYPE_CHECK_CLASS_TYPE ((k), DKP_TYPE_WUP))
-#define DKP_DEVICE_WUP_GET_CLASS(o)	(G_TYPE_INSTANCE_GET_CLASS ((o), DKP_TYPE_WUP, DkpDeviceWupClass))
+#define UP_TYPE_DEVICE_WUP  			(up_device_wup_get_type ())
+#define UP_DEVICE_WUP(o)		(G_TYPE_CHECK_INSTANCE_CAST ((o), UP_TYPE_DEVICE_WUP, UpDeviceWup))
+#define UP_DEVICE_WUP_CLASS(k)		(G_TYPE_CHECK_CLASS_CAST((k), UP_TYPE_DEVICE_WUP, UpDeviceWupClass))
+#define UP_IS_DEVICE_WUP(o)			(G_TYPE_CHECK_INSTANCE_TYPE ((o), UP_TYPE_DEVICE_WUP))
+#define UP_IS_DEVICE_WUP_CLASS(k)		(G_TYPE_CHECK_CLASS_TYPE ((k), UP_TYPE_DEVICE_WUP))
+#define UP_DEVICE_WUP_GET_CLASS(o)	(G_TYPE_INSTANCE_GET_CLASS ((o), UP_TYPE_DEVICE_WUP, UpDeviceWupClass))
 
-typedef struct DkpDeviceWupPrivate DkpDeviceWupPrivate;
+typedef struct UpDeviceWupPrivate UpDeviceWupPrivate;
 
 typedef struct
 {
-	DkpDevice		 parent;
-	DkpDeviceWupPrivate	*priv;
-} DkpDeviceWup;
+	UpDevice		 parent;
+	UpDeviceWupPrivate	*priv;
+} UpDeviceWup;
 
 typedef struct
 {
-	DkpDeviceClass		 parent_class;
-} DkpDeviceWupClass;
+	UpDeviceClass		 parent_class;
+} UpDeviceWupClass;
 
-GType		 dkp_device_wup_get_type		(void);
-DkpDeviceWup	*dkp_device_wup_new			(void);
+GType		 up_device_wup_get_type		(void);
+UpDeviceWup	*up_device_wup_new			(void);
 
 G_END_DECLS
 
-#endif /* __DKP_DEVICE_WUP_H__ */
+#endif /* __UP_DEVICE_WUP_H__ */
 
diff --git a/src/up-backend.h b/src/up-backend.h
index 4d3aecd..e88c1f6 100644
--- a/src/up-backend.h
+++ b/src/up-backend.h
@@ -52,13 +52,13 @@ typedef struct
 	GObjectClass	 parent_class;
 	void		(* device_added)	(UpBackend	*backend,
 						 GObject	*native,
-						 DkpDevice	*device);
+						 UpDevice	*device);
 	void		(* device_changed)	(UpBackend	*backend,
 						 GObject	*native,
-						 DkpDevice	*device);
+						 UpDevice	*device);
 	void		(* device_removed)	(UpBackend	*backend,
 						 GObject	*native,
-						 DkpDevice	*device);
+						 UpDevice	*device);
 } UpBackendClass;
 
 GType		 up_backend_get_type			(void);
diff --git a/src/up-daemon.c b/src/up-daemon.c
index d3f59d5..3b6b481 100644
--- a/src/up-daemon.c
+++ b/src/up-daemon.c
@@ -73,7 +73,7 @@ struct UpDaemonPrivate
 	DBusGProxy		*proxy;
 	DkpPolkit		*polkit;
 	UpBackend		*backend;
-	DkpDeviceList		*power_devices;
+	UpDeviceList		*power_devices;
 	gboolean		 on_battery;
 	gboolean		 on_low_battery;
 	gboolean		 lid_is_closed;
@@ -309,14 +309,14 @@ up_daemon_get_on_battery_local (UpDaemon *daemon)
 	gboolean ret;
 	gboolean result = FALSE;
 	gboolean on_battery;
-	DkpDevice *device;
+	UpDevice *device;
 	GPtrArray *array;
 
 	/* ask each device */
-	array = dkp_device_list_get_array (daemon->priv->power_devices);
+	array = up_device_list_get_array (daemon->priv->power_devices);
 	for (i=0; i<array->len; i++) {
-		device = (DkpDevice *) g_ptr_array_index (array, i);
-		ret = dkp_device_get_on_battery (device, &on_battery);
+		device = (UpDevice *) g_ptr_array_index (array, i);
+		ret = up_device_get_on_battery (device, &on_battery);
 		if (ret && on_battery) {
 			result = TRUE;
 			break;
@@ -330,18 +330,18 @@ up_daemon_get_on_battery_local (UpDaemon *daemon)
  * up_daemon_get_number_devices_of_type:
  **/
 guint
-up_daemon_get_number_devices_of_type (UpDaemon *daemon, DkpDeviceType type)
+up_daemon_get_number_devices_of_type (UpDaemon *daemon, UpDeviceType type)
 {
 	guint i;
-	DkpDevice *device;
+	UpDevice *device;
 	GPtrArray *array;
-	DkpDeviceType type_tmp;
+	UpDeviceType type_tmp;
 	guint count = 0;
 
 	/* ask each device */
-	array = dkp_device_list_get_array (daemon->priv->power_devices);
+	array = up_device_list_get_array (daemon->priv->power_devices);
 	for (i=0; i<array->len; i++) {
-		device = (DkpDevice *) g_ptr_array_index (array, i);
+		device = (UpDevice *) g_ptr_array_index (array, i);
 		g_object_get (device,
 			      "type", &type_tmp,
 			      NULL);
@@ -364,14 +364,14 @@ up_daemon_get_on_low_battery_local (UpDaemon *daemon)
 	gboolean ret;
 	gboolean result = TRUE;
 	gboolean on_low_battery;
-	DkpDevice *device;
+	UpDevice *device;
 	GPtrArray *array;
 
 	/* ask each device */
-	array = dkp_device_list_get_array (daemon->priv->power_devices);
+	array = up_device_list_get_array (daemon->priv->power_devices);
 	for (i=0; i<array->len; i++) {
-		device = (DkpDevice *) g_ptr_array_index (array, i);
-		ret = dkp_device_get_low_battery (device, &on_low_battery);
+		device = (UpDevice *) g_ptr_array_index (array, i);
+		ret = up_device_get_low_battery (device, &on_low_battery);
 		if (ret && !on_low_battery) {
 			result = FALSE;
 			break;
@@ -393,14 +393,14 @@ up_daemon_get_on_ac_local (UpDaemon *daemon)
 	gboolean ret;
 	gboolean result = FALSE;
 	gboolean online;
-	DkpDevice *device;
+	UpDevice *device;
 	GPtrArray *array;
 
 	/* ask each device */
-	array = dkp_device_list_get_array (daemon->priv->power_devices);
+	array = up_device_list_get_array (daemon->priv->power_devices);
 	for (i=0; i<array->len; i++) {
-		device = (DkpDevice *) g_ptr_array_index (array, i);
-		ret = dkp_device_get_online (device, &online);
+		device = (UpDevice *) g_ptr_array_index (array, i);
+		ret = up_device_get_online (device, &online);
 		if (ret && online) {
 			result = TRUE;
 			break;
@@ -444,19 +444,19 @@ up_daemon_refresh_battery_devices (UpDaemon *daemon)
 {
 	guint i;
 	GPtrArray *array;
-	DkpDevice *device;
-	DkpDeviceType type;
+	UpDevice *device;
+	UpDeviceType type;
 
 	/* refresh all devices in array */
-	array = dkp_device_list_get_array (daemon->priv->power_devices);
+	array = up_device_list_get_array (daemon->priv->power_devices);
 	for (i=0; i<array->len; i++) {
-		device = (DkpDevice *) g_ptr_array_index (array, i);
+		device = (UpDevice *) g_ptr_array_index (array, i);
 		/* only refresh battery devices */
 		g_object_get (device,
 			      "type", &type,
 			      NULL);
 		if (type == DKP_DEVICE_TYPE_BATTERY)
-			dkp_device_refresh_internal (device);
+			up_device_refresh_internal (device);
 	}
 	g_ptr_array_unref (array);
 
@@ -472,14 +472,14 @@ up_daemon_enumerate_devices (UpDaemon *daemon, DBusGMethodInvocation *context)
 	guint i;
 	GPtrArray *array;
 	GPtrArray *object_paths;
-	DkpDevice *device;
+	UpDevice *device;
 
 	/* build a pointer array of the object paths */
 	object_paths = g_ptr_array_new_with_free_func (g_free);
-	array = dkp_device_list_get_array (daemon->priv->power_devices);
+	array = up_device_list_get_array (daemon->priv->power_devices);
 	for (i=0; i<array->len; i++) {
-		device = (DkpDevice *) g_ptr_array_index (array, i);
-		g_ptr_array_add (object_paths, g_strdup (dkp_device_get_object_path (device)));
+		device = (UpDevice *) g_ptr_array_index (array, i);
+		g_ptr_array_add (object_paths, g_strdup (up_device_get_object_path (device)));
 	}
 	g_ptr_array_unref (array);
 
@@ -694,7 +694,7 @@ out:
 /**
  * up_daemon_get_device_list:
  **/
-DkpDeviceList *
+UpDeviceList *
 up_daemon_get_device_list (UpDaemon *daemon)
 {
 	return g_object_ref (daemon->priv->power_devices);
@@ -739,14 +739,14 @@ up_daemon_poll_battery_devices_for_a_little_bit (UpDaemon *daemon)
  * up_daemon_device_changed_cb:
  **/
 static void
-up_daemon_device_changed_cb (DkpDevice *device, UpDaemon *daemon)
+up_daemon_device_changed_cb (UpDevice *device, UpDaemon *daemon)
 {
 	const gchar *object_path;
-	DkpDeviceType type;
+	UpDeviceType type;
 	gboolean ret;
 
 	g_return_if_fail (UP_IS_DAEMON (daemon));
-	g_return_if_fail (DKP_IS_DEVICE (device));
+	g_return_if_fail (UP_IS_DEVICE (device));
 
 	/* refresh battery devices when AC state changes */
 	g_object_get (device,
@@ -773,7 +773,7 @@ up_daemon_device_changed_cb (DkpDevice *device, UpDaemon *daemon)
 
 	/* emit */
 	if (!daemon->priv->during_coldplug) {
-		object_path = dkp_device_get_object_path (device);
+		object_path = up_device_get_object_path (device);
 		egg_debug ("emitting device-changed: %s", object_path);
 
 		/* don't crash the session */
@@ -789,17 +789,17 @@ up_daemon_device_changed_cb (DkpDevice *device, UpDaemon *daemon)
  * up_daemon_device_added_cb:
  **/
 static void
-up_daemon_device_added_cb (UpBackend *backend, GObject *native, DkpDevice *device, UpDaemon *daemon)
+up_daemon_device_added_cb (UpBackend *backend, GObject *native, UpDevice *device, UpDaemon *daemon)
 {
-	DkpDeviceType type;
+	UpDeviceType type;
 	const gchar *object_path;
 
 	g_return_if_fail (UP_IS_DAEMON (daemon));
-	g_return_if_fail (DKP_IS_DEVICE (device));
+	g_return_if_fail (UP_IS_DEVICE (device));
 	g_return_if_fail (G_IS_OBJECT (native));
 
 	/* add to device list */
-	dkp_device_list_insert (daemon->priv->power_devices, native, G_OBJECT (device));
+	up_device_list_insert (daemon->priv->power_devices, native, G_OBJECT (device));
 
 	/* connect, so we get changes */
 	g_signal_connect (device, "changed",
@@ -814,7 +814,7 @@ up_daemon_device_added_cb (UpBackend *backend, GObject *native, DkpDevice *devic
 
 	/* emit */
 	if (!daemon->priv->during_coldplug) {
-		object_path = dkp_device_get_object_path (device);
+		object_path = up_device_get_object_path (device);
 		egg_debug ("emitting added: %s (during coldplug %i)", object_path, daemon->priv->during_coldplug);
 
 		/* don't crash the session */
@@ -830,17 +830,17 @@ up_daemon_device_added_cb (UpBackend *backend, GObject *native, DkpDevice *devic
  * up_daemon_device_removed_cb:
  **/
 static void
-up_daemon_device_removed_cb (UpBackend *backend, GObject *native, DkpDevice *device, UpDaemon *daemon)
+up_daemon_device_removed_cb (UpBackend *backend, GObject *native, UpDevice *device, UpDaemon *daemon)
 {
-	DkpDeviceType type;
+	UpDeviceType type;
 	const gchar *object_path;
 
 	g_return_if_fail (UP_IS_DAEMON (daemon));
-	g_return_if_fail (DKP_IS_DEVICE (device));
+	g_return_if_fail (UP_IS_DEVICE (device));
 	g_return_if_fail (G_IS_OBJECT (native));
 
 	/* remove from list */
-	dkp_device_list_remove (daemon->priv->power_devices, G_OBJECT(device));
+	up_device_list_remove (daemon->priv->power_devices, G_OBJECT(device));
 
 	/* refresh after a short delay */
 	g_object_get (device,
@@ -851,7 +851,7 @@ up_daemon_device_removed_cb (UpBackend *backend, GObject *native, DkpDevice *dev
 
 	/* emit */
 	if (!daemon->priv->during_coldplug) {
-		object_path = dkp_device_get_object_path (device);
+		object_path = up_device_get_object_path (device);
 		egg_debug ("emitting device-removed: %s", object_path);
 
 		/* don't crash the session */
@@ -897,7 +897,7 @@ up_daemon_init (UpDaemon *daemon)
 	daemon->priv->kernel_can_hibernate = FALSE;
 	daemon->priv->hibernate_has_swap_space = FALSE;
 	daemon->priv->hibernate_has_encrypted_swap = FALSE;
-	daemon->priv->power_devices = dkp_device_list_new ();
+	daemon->priv->power_devices = up_device_list_new ();
 	daemon->priv->on_battery = FALSE;
 	daemon->priv->on_low_battery = FALSE;
 	daemon->priv->during_coldplug = FALSE;
diff --git a/src/up-daemon.h b/src/up-daemon.h
index b295188..9c370b4 100644
--- a/src/up-daemon.h
+++ b/src/up-daemon.h
@@ -70,8 +70,8 @@ void		 up_daemon_test		(gpointer	 user_data);
 
 /* private */
 guint		 up_daemon_get_number_devices_of_type (UpDaemon	*daemon,
-						 DkpDeviceType		 type);
-DkpDeviceList	*up_daemon_get_device_list	(UpDaemon		*daemon);
+						 UpDeviceType		 type);
+UpDeviceList	*up_daemon_get_device_list	(UpDaemon		*daemon);
 gboolean	 up_daemon_startup		(UpDaemon		*daemon);
 
 /* exported */
diff --git a/src/up-device-list.c b/src/up-device-list.c
index beecbc4..2da3051 100644
--- a/src/up-device-list.c
+++ b/src/up-device-list.c
@@ -30,33 +30,33 @@
 #include "up-native.h"
 #include "up-device-list.h"
 
-static void	dkp_device_list_finalize	(GObject		*object);
+static void	up_device_list_finalize	(GObject		*object);
 
-#define DKP_DEVICE_LIST_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), DKP_TYPE_DEVICE_LIST, DkpDeviceListPrivate))
+#define UP_DEVICE_LIST_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), UP_TYPE_DEVICE_LIST, UpDeviceListPrivate))
 
-struct DkpDeviceListPrivate
+struct UpDeviceListPrivate
 {
 	GPtrArray		*array;
 	GHashTable		*map_native_path_to_device;
 };
 
-G_DEFINE_TYPE (DkpDeviceList, dkp_device_list, G_TYPE_OBJECT)
+G_DEFINE_TYPE (UpDeviceList, up_device_list, G_TYPE_OBJECT)
 
 /**
- * dkp_device_list_lookup:
+ * up_device_list_lookup:
  *
- * Convert a native %GObject into a %DkpDevice -- we use the native path
+ * Convert a native %GObject into a %UpDevice -- we use the native path
  * to look these up as it's the only thing they share.
  *
  * Return value: the object, or %NULL if not found. Free with g_object_unref()
  **/
 GObject *
-dkp_device_list_lookup (DkpDeviceList *list, GObject *native)
+up_device_list_lookup (UpDeviceList *list, GObject *native)
 {
 	GObject *device;
 	const gchar *native_path;
 
-	g_return_val_if_fail (DKP_IS_DEVICE_LIST (list), NULL);
+	g_return_val_if_fail (UP_IS_DEVICE_LIST (list), NULL);
 
 	/* does device exist in db? */
 	native_path = dkp_native_get_native_path (native);
@@ -69,17 +69,17 @@ dkp_device_list_lookup (DkpDeviceList *list, GObject *native)
 }
 
 /**
- * dkp_device_list_insert:
+ * up_device_list_insert:
  *
- * Insert a %GObject device and it's mapping to a backing %DkpDevice
+ * Insert a %GObject device and it's mapping to a backing %UpDevice
  * into a list of devices.
  **/
 gboolean
-dkp_device_list_insert (DkpDeviceList *list, GObject *native, GObject *device)
+up_device_list_insert (UpDeviceList *list, GObject *native, GObject *device)
 {
 	const gchar *native_path;
 
-	g_return_val_if_fail (DKP_IS_DEVICE_LIST (list), FALSE);
+	g_return_val_if_fail (UP_IS_DEVICE_LIST (list), FALSE);
 	g_return_val_if_fail (native != NULL, FALSE);
 	g_return_val_if_fail (device != NULL, FALSE);
 
@@ -96,10 +96,10 @@ dkp_device_list_insert (DkpDeviceList *list, GObject *native, GObject *device)
 }
 
 /**
- * dkp_device_list_remove_cb:
+ * up_device_list_remove_cb:
  **/
 static gboolean
-dkp_device_list_remove_cb (gpointer key, gpointer value, gpointer user_data)
+up_device_list_remove_cb (gpointer key, gpointer value, gpointer user_data)
 {
 	if (value == user_data) {
 		egg_debug ("removed %s", (char *) key);
@@ -109,17 +109,17 @@ dkp_device_list_remove_cb (gpointer key, gpointer value, gpointer user_data)
 }
 
 /**
- * dkp_device_list_remove:
+ * up_device_list_remove:
  **/
 gboolean
-dkp_device_list_remove (DkpDeviceList *list, GObject *device)
+up_device_list_remove (UpDeviceList *list, GObject *device)
 {
-	g_return_val_if_fail (DKP_IS_DEVICE_LIST (list), FALSE);
+	g_return_val_if_fail (UP_IS_DEVICE_LIST (list), FALSE);
 	g_return_val_if_fail (device != NULL, FALSE);
 
 	/* remove the device from the db */
 	g_hash_table_foreach_remove (list->priv->map_native_path_to_device,
-				     dkp_device_list_remove_cb, device);
+				     up_device_list_remove_cb, device);
 	g_ptr_array_remove (list->priv->array, device);
 
 	/* we're removed the last instance? */
@@ -132,73 +132,73 @@ dkp_device_list_remove (DkpDeviceList *list, GObject *device)
 }
 
 /**
- * dkp_device_list_get_array:
+ * up_device_list_get_array:
  *
  * This is quick to iterate when we don't have GObject's to resolve
  *
  * Return value: the array, free with g_ptr_array_unref()
  **/
 GPtrArray	*
-dkp_device_list_get_array (DkpDeviceList *list)
+up_device_list_get_array (UpDeviceList *list)
 {
-	g_return_val_if_fail (DKP_IS_DEVICE_LIST (list), NULL);
+	g_return_val_if_fail (UP_IS_DEVICE_LIST (list), NULL);
 	return g_ptr_array_ref (list->priv->array);
 }
 
 /**
- * dkp_device_list_class_init:
- * @klass: The DkpDeviceListClass
+ * up_device_list_class_init:
+ * @klass: The UpDeviceListClass
  **/
 static void
-dkp_device_list_class_init (DkpDeviceListClass *klass)
+up_device_list_class_init (UpDeviceListClass *klass)
 {
 	GObjectClass *object_class = G_OBJECT_CLASS (klass);
-	object_class->finalize = dkp_device_list_finalize;
-	g_type_class_add_private (klass, sizeof (DkpDeviceListPrivate));
+	object_class->finalize = up_device_list_finalize;
+	g_type_class_add_private (klass, sizeof (UpDeviceListPrivate));
 }
 
 /**
- * dkp_device_list_init:
+ * up_device_list_init:
  * @list: This class instance
  **/
 static void
-dkp_device_list_init (DkpDeviceList *list)
+up_device_list_init (UpDeviceList *list)
 {
-	list->priv = DKP_DEVICE_LIST_GET_PRIVATE (list);
+	list->priv = UP_DEVICE_LIST_GET_PRIVATE (list);
 	list->priv->array = g_ptr_array_new_with_free_func (g_object_unref);
 	list->priv->map_native_path_to_device = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref);
 }
 
 /**
- * dkp_device_list_finalize:
+ * up_device_list_finalize:
  * @object: The object to finalize
  **/
 static void
-dkp_device_list_finalize (GObject *object)
+up_device_list_finalize (GObject *object)
 {
-	DkpDeviceList *list;
+	UpDeviceList *list;
 
-	g_return_if_fail (DKP_IS_DEVICE_LIST (object));
+	g_return_if_fail (UP_IS_DEVICE_LIST (object));
 
-	list = DKP_DEVICE_LIST (object);
+	list = UP_DEVICE_LIST (object);
 
 	g_ptr_array_unref (list->priv->array);
 	g_hash_table_unref (list->priv->map_native_path_to_device);
 
-	G_OBJECT_CLASS (dkp_device_list_parent_class)->finalize (object);
+	G_OBJECT_CLASS (up_device_list_parent_class)->finalize (object);
 }
 
 /**
- * dkp_device_list_new:
+ * up_device_list_new:
  *
- * Return value: a new DkpDeviceList object.
+ * Return value: a new UpDeviceList object.
  **/
-DkpDeviceList *
-dkp_device_list_new (void)
+UpDeviceList *
+up_device_list_new (void)
 {
-	DkpDeviceList *list;
-	list = g_object_new (DKP_TYPE_DEVICE_LIST, NULL);
-	return DKP_DEVICE_LIST (list);
+	UpDeviceList *list;
+	list = g_object_new (UP_TYPE_DEVICE_LIST, NULL);
+	return UP_DEVICE_LIST (list);
 }
 
 
@@ -209,39 +209,39 @@ dkp_device_list_new (void)
 #include "egg-test.h"
 
 void
-dkp_device_list_test (gpointer user_data)
+up_device_list_test (gpointer user_data)
 {
 	EggTest *test = (EggTest *) user_data;
-	DkpDeviceList *list;
+	UpDeviceList *list;
 	GObject *native;
 	GObject *device;
 	GObject *found;
 	gboolean ret;
 
-	if (!egg_test_start (test, "DkpDeviceList"))
+	if (!egg_test_start (test, "UpDeviceList"))
 		return;
 
 	/************************************************************/
 	egg_test_title (test, "get instance");
-	list = dkp_device_list_new ();
+	list = up_device_list_new ();
 	egg_test_assert (test, list != NULL);
 
 	/************************************************************/
 	egg_test_title (test, "add device");
 	native = g_object_new (G_TYPE_OBJECT, NULL);
 	device = g_object_new (G_TYPE_OBJECT, NULL);
-	ret = dkp_device_list_insert (list, native, device);
+	ret = up_device_list_insert (list, native, device);
 	egg_test_assert (test, ret);
 
 	/************************************************************/
 	egg_test_title (test, "find device");
-	found = dkp_device_list_lookup (list, native);
+	found = up_device_list_lookup (list, native);
 	egg_test_assert (test, (found != NULL));
 	g_object_unref (found);
 
 	/************************************************************/
 	egg_test_title (test, "remove device");
-	ret = dkp_device_list_remove (list, device);
+	ret = up_device_list_remove (list, device);
 	egg_test_assert (test, ret);
 
 	/* unref */
diff --git a/src/up-device-list.h b/src/up-device-list.h
index aac2a6c..86fcf19 100644
--- a/src/up-device-list.h
+++ b/src/up-device-list.h
@@ -19,50 +19,50 @@
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  */
 
-#ifndef __DKP_DEVICE_LIST_H
-#define __DKP_DEVICE_LIST_H
+#ifndef __UP_DEVICE_LIST_H
+#define __UP_DEVICE_LIST_H
 
 #include <glib-object.h>
 #include <dkp-enum.h>
 
 G_BEGIN_DECLS
 
-#define DKP_TYPE_DEVICE_LIST		(dkp_device_list_get_type ())
-#define DKP_DEVICE_LIST(o)		(G_TYPE_CHECK_INSTANCE_CAST ((o), DKP_TYPE_DEVICE_LIST, DkpDeviceList))
-#define DKP_DEVICE_LIST_CLASS(k)	(G_TYPE_CHECK_CLASS_CAST((k), DKP_TYPE_DEVICE_LIST, DkpDeviceListClass))
-#define DKP_IS_DEVICE_LIST(o)		(G_TYPE_CHECK_INSTANCE_TYPE ((o), DKP_TYPE_DEVICE_LIST))
-#define DKP_IS_DEVICE_LIST_CLASS(k)	(G_TYPE_CHECK_CLASS_TYPE ((k), DKP_TYPE_DEVICE_LIST))
-#define DKP_DEVICE_LIST_GET_CLASS(o)	(G_TYPE_INSTANCE_GET_CLASS ((o), DKP_TYPE_DEVICE_LIST, DkpDeviceListClass))
-#define DKP_DEVICE_LIST_ERROR		(dkp_device_list_error_quark ())
-#define DKP_DEVICE_LIST_TYPE_ERROR	(dkp_device_list_error_get_type ())
+#define UP_TYPE_DEVICE_LIST		(up_device_list_get_type ())
+#define UP_DEVICE_LIST(o)		(G_TYPE_CHECK_INSTANCE_CAST ((o), UP_TYPE_DEVICE_LIST, UpDeviceList))
+#define UP_DEVICE_LIST_CLASS(k)	(G_TYPE_CHECK_CLASS_CAST((k), UP_TYPE_DEVICE_LIST, UpDeviceListClass))
+#define UP_IS_DEVICE_LIST(o)		(G_TYPE_CHECK_INSTANCE_TYPE ((o), UP_TYPE_DEVICE_LIST))
+#define UP_IS_DEVICE_LIST_CLASS(k)	(G_TYPE_CHECK_CLASS_TYPE ((k), UP_TYPE_DEVICE_LIST))
+#define UP_DEVICE_LIST_GET_CLASS(o)	(G_TYPE_INSTANCE_GET_CLASS ((o), UP_TYPE_DEVICE_LIST, UpDeviceListClass))
+#define UP_DEVICE_LIST_ERROR		(up_device_list_error_quark ())
+#define UP_DEVICE_LIST_TYPE_ERROR	(up_device_list_error_get_type ())
 
-typedef struct DkpDeviceListPrivate DkpDeviceListPrivate;
+typedef struct UpDeviceListPrivate UpDeviceListPrivate;
 
 typedef struct
 {
 	 GObject		 parent;
-	 DkpDeviceListPrivate	*priv;
-} DkpDeviceList;
+	 UpDeviceListPrivate	*priv;
+} UpDeviceList;
 
 typedef struct
 {
 	GObjectClass		 parent_class;
-} DkpDeviceListClass;
+} UpDeviceListClass;
 
-GType		 dkp_device_list_get_type		(void);
-DkpDeviceList	*dkp_device_list_new			(void);
-void		 dkp_device_list_test			(gpointer		 user_data);
+GType		 up_device_list_get_type		(void);
+UpDeviceList	*up_device_list_new			(void);
+void		 up_device_list_test			(gpointer		 user_data);
 
-GObject		*dkp_device_list_lookup			(DkpDeviceList		*list,
+GObject		*up_device_list_lookup			(UpDeviceList		*list,
 							 GObject		*native);
-gboolean	 dkp_device_list_insert			(DkpDeviceList		*list,
+gboolean	 up_device_list_insert			(UpDeviceList		*list,
 							 GObject		*native,
 							 GObject		*device);
-gboolean	 dkp_device_list_remove			(DkpDeviceList		*list,
+gboolean	 up_device_list_remove			(UpDeviceList		*list,
 							 GObject		*device);
-GPtrArray	*dkp_device_list_get_array		(DkpDeviceList		*list);
+GPtrArray	*up_device_list_get_array		(UpDeviceList		*list);
 
 G_END_DECLS
 
-#endif /* __DKP_DEVICE_LIST_H */
+#endif /* __UP_DEVICE_LIST_H */
 
diff --git a/src/up-device.c b/src/up-device.c
index e8b6e99..54bc90a 100644
--- a/src/up-device.c
+++ b/src/up-device.c
@@ -42,7 +42,7 @@
 #include "up-marshal.h"
 #include "up-device-glue.h"
 
-struct DkpDevicePrivate
+struct UpDevicePrivate
 {
 	gchar			*object_path;
 	DBusGConnection		*system_bus_connection;
@@ -65,9 +65,9 @@ struct DkpDevicePrivate
 	gboolean		 is_rechargeable;
 	gboolean		 has_history;
 	gboolean		 has_statistics;
-	DkpDeviceType		 type;
-	DkpDeviceState		 state;
-	DkpDeviceTechnology	 technology;
+	UpDeviceType		 type;
+	UpDeviceState		 state;
+	UpDeviceTechnology	 technology;
 	gdouble			 capacity;		/* percent */
 	gdouble			 energy;		/* Watt Hours */
 	gdouble			 energy_empty;		/* Watt Hours */
@@ -83,7 +83,7 @@ struct DkpDevicePrivate
 	gchar			*recall_url;
 };
 
-static gboolean	dkp_device_register_device	(DkpDevice *device);
+static gboolean	up_device_register_device	(UpDevice *device);
 
 enum {
 	PROP_0,
@@ -124,23 +124,23 @@ enum {
 
 static guint signals[SIGNAL_LAST] = { 0 };
 
-G_DEFINE_TYPE (DkpDevice, dkp_device, G_TYPE_OBJECT)
-#define DKP_DEVICE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), DKP_TYPE_DEVICE, DkpDevicePrivate))
+G_DEFINE_TYPE (UpDevice, up_device, G_TYPE_OBJECT)
+#define UP_DEVICE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), UP_TYPE_DEVICE, UpDevicePrivate))
 #define DKP_DBUS_STRUCT_UINT_DOUBLE_UINT (dbus_g_type_get_struct ("GValueArray", \
 	G_TYPE_UINT, G_TYPE_DOUBLE, G_TYPE_UINT, G_TYPE_INVALID))
 #define DKP_DBUS_STRUCT_DOUBLE_DOUBLE (dbus_g_type_get_struct ("GValueArray", \
 	G_TYPE_DOUBLE, G_TYPE_DOUBLE, G_TYPE_INVALID))
 
 /**
- * dkp_device_error_quark:
+ * up_device_error_quark:
  **/
 GQuark
-dkp_device_error_quark (void)
+up_device_error_quark (void)
 {
 	static GQuark ret = 0;
 
 	if (ret == 0) {
-		ret = g_quark_from_static_string ("dkp_device_error");
+		ret = g_quark_from_static_string ("up_device_error");
 	}
 
 	return ret;
@@ -149,10 +149,10 @@ dkp_device_error_quark (void)
 #define ENUM_ENTRY(NAME, DESC) { NAME, "" #NAME "", DESC }
 
 /**
- * dkp_device_error_get_type:
+ * up_device_error_get_type:
  **/
 GType
-dkp_device_error_get_type (void)
+up_device_error_get_type (void)
 {
 	static GType etype = 0;
 
@@ -160,22 +160,22 @@ dkp_device_error_get_type (void)
 	{
 		static const GEnumValue values[] =
 			{
-				ENUM_ENTRY (DKP_DEVICE_ERROR_GENERAL, "GeneralError"),
+				ENUM_ENTRY (UP_DEVICE_ERROR_GENERAL, "GeneralError"),
 				{ 0, 0, 0 }
 			};
-		g_assert (DKP_DEVICE_NUM_ERRORS == G_N_ELEMENTS (values) - 1);
-		etype = g_enum_register_static ("DkpDeviceError", values);
+		g_assert (UP_DEVICE_NUM_ERRORS == G_N_ELEMENTS (values) - 1);
+		etype = g_enum_register_static ("UpDeviceError", values);
 	}
 	return etype;
 }
 
 /**
- * dkp_device_get_property:
+ * up_device_get_property:
  **/
 static void
-dkp_device_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
+up_device_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
 {
-	DkpDevice *device = DKP_DEVICE (object);
+	UpDevice *device = UP_DEVICE (object);
 	switch (prop_id) {
 	case PROP_NATIVE_PATH:
 		g_value_set_string (value, device->priv->native_path);
@@ -265,12 +265,12 @@ dkp_device_get_property (GObject *object, guint prop_id, GValue *value, GParamSp
 }
 
 /**
- * dkp_device_set_property:
+ * up_device_set_property:
  **/
 static void
-dkp_device_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
+up_device_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
 {
-	DkpDevice *device = DKP_DEVICE (object);
+	UpDevice *device = UP_DEVICE (object);
 
 	switch (prop_id) {
 	case PROP_NATIVE_PATH:
@@ -367,16 +367,16 @@ dkp_device_set_property (GObject *object, guint prop_id, const GValue *value, GP
 }
 
 /**
- * dkp_device_get_on_battery:
+ * up_device_get_on_battery:
  *
  * Note: Only implement for system devices, i.e. ones supplying the system
  **/
 gboolean
-dkp_device_get_on_battery (DkpDevice *device, gboolean *on_battery)
+up_device_get_on_battery (UpDevice *device, gboolean *on_battery)
 {
-	DkpDeviceClass *klass = DKP_DEVICE_GET_CLASS (device);
+	UpDeviceClass *klass = UP_DEVICE_GET_CLASS (device);
 
-	g_return_val_if_fail (DKP_IS_DEVICE (device), FALSE);
+	g_return_val_if_fail (UP_IS_DEVICE (device), FALSE);
 
 	/* no support */
 	if (klass->get_on_battery == NULL)
@@ -386,16 +386,16 @@ dkp_device_get_on_battery (DkpDevice *device, gboolean *on_battery)
 }
 
 /**
- * dkp_device_get_low_battery:
+ * up_device_get_low_battery:
  *
  * Note: Only implement for system devices, i.e. ones supplying the system
  **/
 gboolean
-dkp_device_get_low_battery (DkpDevice *device, gboolean *low_battery)
+up_device_get_low_battery (UpDevice *device, gboolean *low_battery)
 {
-	DkpDeviceClass *klass = DKP_DEVICE_GET_CLASS (device);
+	UpDeviceClass *klass = UP_DEVICE_GET_CLASS (device);
 
-	g_return_val_if_fail (DKP_IS_DEVICE (device), FALSE);
+	g_return_val_if_fail (UP_IS_DEVICE (device), FALSE);
 
 	/* no support */
 	if (klass->get_low_battery == NULL)
@@ -405,16 +405,16 @@ dkp_device_get_low_battery (DkpDevice *device, gboolean *low_battery)
 }
 
 /**
- * dkp_device_get_online:
+ * up_device_get_online:
  *
  * Note: Only implement for system devices, i.e. devices supplying the system
  **/
 gboolean
-dkp_device_get_online (DkpDevice *device, gboolean *online)
+up_device_get_online (UpDevice *device, gboolean *online)
 {
-	DkpDeviceClass *klass = DKP_DEVICE_GET_CLASS (device);
+	UpDeviceClass *klass = UP_DEVICE_GET_CLASS (device);
 
-	g_return_val_if_fail (DKP_IS_DEVICE (device), FALSE);
+	g_return_val_if_fail (UP_IS_DEVICE (device), FALSE);
 
 	/* no support */
 	if (klass->get_online == NULL)
@@ -424,10 +424,10 @@ dkp_device_get_online (DkpDevice *device, gboolean *online)
 }
 
 /**
- * dkp_device_get_id:
+ * up_device_get_id:
  **/
 static gchar *
-dkp_device_get_id (DkpDevice *device)
+up_device_get_id (UpDevice *device)
 {
 	GString *string;
 	gchar *id = NULL;
@@ -507,12 +507,12 @@ out:
 }
 
 /**
- * dkp_device_get_daemon:
+ * up_device_get_daemon:
  *
  * Returns a refcounted #UpDaemon instance, or %NULL
  **/
 UpDaemon *
-dkp_device_get_daemon (DkpDevice *device)
+up_device_get_daemon (UpDevice *device)
 {
 	if (device->priv->daemon == NULL)
 		return NULL;
@@ -520,19 +520,19 @@ dkp_device_get_daemon (DkpDevice *device)
 }
 
 /**
- * dkp_device_coldplug:
+ * up_device_coldplug:
  *
  * Return %TRUE on success, %FALSE if we failed to get data and should be removed
  **/
 gboolean
-dkp_device_coldplug (DkpDevice *device, UpDaemon *daemon, GObject *native)
+up_device_coldplug (UpDevice *device, UpDaemon *daemon, GObject *native)
 {
 	gboolean ret;
 	const gchar *native_path;
-	DkpDeviceClass *klass = DKP_DEVICE_GET_CLASS (device);
+	UpDeviceClass *klass = UP_DEVICE_GET_CLASS (device);
 	gchar *id = NULL;
 
-	g_return_val_if_fail (DKP_IS_DEVICE (device), FALSE);
+	g_return_val_if_fail (UP_IS_DEVICE (device), FALSE);
 
 	/* save */
 	device->priv->native = g_object_ref (native);
@@ -556,14 +556,14 @@ dkp_device_coldplug (DkpDevice *device, UpDaemon *daemon, GObject *native)
 	}
 
 	/* only put on the bus if we succeeded */
-	ret = dkp_device_register_device (device);
+	ret = up_device_register_device (device);
 	if (!ret) {
 		egg_warning ("failed to register device %s", device->priv->native_path);
 		goto out;
 	}
 
 	/* force a refresh, although failure isn't fatal */
-	ret = dkp_device_refresh_internal (device);
+	ret = up_device_refresh_internal (device);
 	if (!ret) {
 		egg_debug ("failed to refresh %s", device->priv->native_path);
 
@@ -574,7 +574,7 @@ dkp_device_coldplug (DkpDevice *device, UpDaemon *daemon, GObject *native)
 	}
 
 	/* get the id so we can load the old history */
-	id = dkp_device_get_id (device);
+	id = up_device_get_id (device);
 	if (id != NULL)
 		dkp_history_set_id (device->priv->history, id);
 
@@ -588,10 +588,10 @@ out:
 }
 
 /**
- * dkp_device_get_statistics:
+ * up_device_get_statistics:
  **/
 gboolean
-dkp_device_get_statistics (DkpDevice *device, const gchar *type, DBusGMethodInvocation *context)
+up_device_get_statistics (UpDevice *device, const gchar *type, DBusGMethodInvocation *context)
 {
 	GError *error;
 	GPtrArray *array = NULL;
@@ -600,7 +600,7 @@ dkp_device_get_statistics (DkpDevice *device, const gchar *type, DBusGMethodInvo
 	GValue *value;
 	guint i;
 
-	g_return_val_if_fail (DKP_IS_DEVICE (device), FALSE);
+	g_return_val_if_fail (UP_IS_DEVICE (device), FALSE);
 	g_return_val_if_fail (type != NULL, FALSE);
 
 	/* doesn't even try to support this */
@@ -650,10 +650,10 @@ out:
 }
 
 /**
- * dkp_device_get_history:
+ * up_device_get_history:
  **/
 gboolean
-dkp_device_get_history (DkpDevice *device, const gchar *type_string, guint timespan, guint resolution, DBusGMethodInvocation *context)
+up_device_get_history (UpDevice *device, const gchar *type_string, guint timespan, guint resolution, DBusGMethodInvocation *context)
 {
 	GError *error;
 	GPtrArray *array = NULL;
@@ -663,7 +663,7 @@ dkp_device_get_history (DkpDevice *device, const gchar *type_string, guint times
 	guint i;
 	DkpHistoryType type = DKP_HISTORY_TYPE_UNKNOWN;
 
-	g_return_val_if_fail (DKP_IS_DEVICE (device), FALSE);
+	g_return_val_if_fail (UP_IS_DEVICE (device), FALSE);
 	g_return_val_if_fail (type_string != NULL, FALSE);
 
 	/* doesn't even try to support this */
@@ -715,17 +715,17 @@ out:
 }
 
 /**
- * dkp_device_refresh_internal:
+ * up_device_refresh_internal:
  *
  * NOTE: if you're calling this function you have to ensure you're doing the
  * the changed signals on the right interfaces, although by monitoring
  * notify::update-time this should be mostly done.
  **/
 gboolean
-dkp_device_refresh_internal (DkpDevice *device)
+up_device_refresh_internal (UpDevice *device)
 {
 	gboolean ret = FALSE;
-	DkpDeviceClass *klass = DKP_DEVICE_GET_CLASS (device);
+	UpDeviceClass *klass = UP_DEVICE_GET_CLASS (device);
 
 	/* not implemented */
 	if (klass->refresh == NULL)
@@ -749,44 +749,44 @@ out:
 }
 
 /**
- * dkp_device_refresh:
+ * up_device_refresh:
  *
  * Return %TRUE on success, %FALSE if we failed to refresh or no data
  **/
 gboolean
-dkp_device_refresh (DkpDevice *device, DBusGMethodInvocation *context)
+up_device_refresh (UpDevice *device, DBusGMethodInvocation *context)
 {
 	gboolean ret;
 
-	g_return_val_if_fail (DKP_IS_DEVICE (device), FALSE);
+	g_return_val_if_fail (UP_IS_DEVICE (device), FALSE);
 
-	ret = dkp_device_refresh_internal (device);
+	ret = up_device_refresh_internal (device);
 	dbus_g_method_return (context);
 	return ret;
 }
 
 /**
- * dkp_device_get_object_path:
+ * up_device_get_object_path:
  **/
 const gchar *
-dkp_device_get_object_path (DkpDevice *device)
+up_device_get_object_path (UpDevice *device)
 {
-	g_return_val_if_fail (DKP_IS_DEVICE (device), NULL);
+	g_return_val_if_fail (UP_IS_DEVICE (device), NULL);
 	return device->priv->object_path;
 }
 
 GObject *
-dkp_device_get_native (DkpDevice *device)
+up_device_get_native (UpDevice *device)
 {
-	g_return_val_if_fail (DKP_IS_DEVICE (device), NULL);
+	g_return_val_if_fail (UP_IS_DEVICE (device), NULL);
 	return device->priv->native;
 }
 
 /**
- * dkp_device_compute_object_path:
+ * up_device_compute_object_path:
  **/
 static gchar *
-dkp_device_compute_object_path (DkpDevice *device)
+up_device_compute_object_path (UpDevice *device)
 {
 	gchar *basename;
 	gchar *id;
@@ -795,7 +795,7 @@ dkp_device_compute_object_path (DkpDevice *device)
 	const gchar *type;
 	guint i;
 
-	type = dkp_device_type_to_text (device->priv->type);
+	type = up_device_type_to_text (device->priv->type);
 	native_path = device->priv->native_path;
 	basename = g_path_get_basename (native_path);
 	id = g_strjoin ("_", type, basename, NULL);
@@ -818,14 +818,14 @@ dkp_device_compute_object_path (DkpDevice *device)
 }
 
 /**
- * dkp_device_register_device:
+ * up_device_register_device:
  **/
 static gboolean
-dkp_device_register_device (DkpDevice *device)
+up_device_register_device (UpDevice *device)
 {
 	gboolean ret = TRUE;
 
-	device->priv->object_path = dkp_device_compute_object_path (device);
+	device->priv->object_path = up_device_compute_object_path (device);
 	egg_debug ("object path = %s", device->priv->object_path);
 	dbus_g_connection_register_g_object (device->priv->system_bus_connection,
 					     device->priv->object_path, G_OBJECT (device));
@@ -839,12 +839,12 @@ dkp_device_register_device (DkpDevice *device)
 }
 
 /**
- * dkp_device_perhaps_changed_cb:
+ * up_device_perhaps_changed_cb:
  **/
 static void
-dkp_device_perhaps_changed_cb (GObject *object, GParamSpec *pspec, DkpDevice *device)
+up_device_perhaps_changed_cb (GObject *object, GParamSpec *pspec, UpDevice *device)
 {
-	g_return_if_fail (DKP_IS_DEVICE (device));
+	g_return_if_fail (UP_IS_DEVICE (device));
 
 	/* don't proxy during coldplug */
 	if (device->priv->during_coldplug)
@@ -864,14 +864,14 @@ dkp_device_perhaps_changed_cb (GObject *object, GParamSpec *pspec, DkpDevice *de
 }
 
 /**
- * dkp_device_init:
+ * up_device_init:
  **/
 static void
-dkp_device_init (DkpDevice *device)
+up_device_init (UpDevice *device)
 {
 	GError *error = NULL;
 
-	device->priv = DKP_DEVICE_GET_PRIVATE (device);
+	device->priv = UP_DEVICE_GET_PRIVATE (device);
 	device->priv->object_path = NULL;
 	device->priv->system_bus_connection = NULL;
 	device->priv->system_bus_proxy = NULL;
@@ -886,21 +886,21 @@ dkp_device_init (DkpDevice *device)
 		egg_error ("error getting system bus: %s", error->message);
 		g_error_free (error);
 	}
-	g_signal_connect (device, "notify::update-time", G_CALLBACK (dkp_device_perhaps_changed_cb), device);
+	g_signal_connect (device, "notify::update-time", G_CALLBACK (up_device_perhaps_changed_cb), device);
 }
 
 /**
- * dkp_device_finalize:
+ * up_device_finalize:
  **/
 static void
-dkp_device_finalize (GObject *object)
+up_device_finalize (GObject *object)
 {
-	DkpDevice *device;
+	UpDevice *device;
 
 	g_return_if_fail (object != NULL);
-	g_return_if_fail (DKP_IS_DEVICE (object));
+	g_return_if_fail (UP_IS_DEVICE (object));
 
-	device = DKP_DEVICE (object);
+	device = UP_DEVICE (object);
 	g_return_if_fail (device->priv != NULL);
 	if (device->priv->native != NULL)
 		g_object_unref (device->priv->native);
@@ -915,21 +915,21 @@ dkp_device_finalize (GObject *object)
 	g_free (device->priv->recall_vendor);
 	g_free (device->priv->recall_url);
 
-	G_OBJECT_CLASS (dkp_device_parent_class)->finalize (object);
+	G_OBJECT_CLASS (up_device_parent_class)->finalize (object);
 }
 
 /**
- * dkp_device_class_init:
+ * up_device_class_init:
  **/
 static void
-dkp_device_class_init (DkpDeviceClass *klass)
+up_device_class_init (UpDeviceClass *klass)
 {
 	GObjectClass *object_class = G_OBJECT_CLASS (klass);
-	object_class->get_property = dkp_device_get_property;
-	object_class->set_property = dkp_device_set_property;
-	object_class->finalize = dkp_device_finalize;
+	object_class->get_property = up_device_get_property;
+	object_class->set_property = up_device_set_property;
+	object_class->finalize = up_device_finalize;
 
-	g_type_class_add_private (klass, sizeof (DkpDevicePrivate));
+	g_type_class_add_private (klass, sizeof (UpDevicePrivate));
 
 	signals[SIGNAL_CHANGED] =
 		g_signal_new ("changed",
@@ -939,10 +939,10 @@ dkp_device_class_init (DkpDeviceClass *klass)
 			      g_cclosure_marshal_VOID__VOID,
 			      G_TYPE_NONE, 0);
 
-	dbus_g_object_type_install_info (DKP_TYPE_DEVICE, &dbus_glib_dkp_device_object_info);
+	dbus_g_object_type_install_info (UP_TYPE_DEVICE, &dbus_glib_up_device_object_info);
 
 	/**
-	 * DkpDevice:update-time:
+	 * UpDevice:update-time:
 	 */
 	g_object_class_install_property (object_class,
 					 PROP_UPDATE_TIME,
@@ -951,7 +951,7 @@ dkp_device_class_init (DkpDeviceClass *klass)
 							      0, G_MAXUINT64, 0,
 							      G_PARAM_READWRITE));
 	/**
-	 * DkpDevice:vendor:
+	 * UpDevice:vendor:
 	 */
 	g_object_class_install_property (object_class,
 					 PROP_VENDOR,
@@ -960,7 +960,7 @@ dkp_device_class_init (DkpDeviceClass *klass)
 							      NULL,
 							      G_PARAM_READWRITE));
 	/**
-	 * DkpDevice:model:
+	 * UpDevice:model:
 	 */
 	g_object_class_install_property (object_class,
 					 PROP_MODEL,
@@ -969,7 +969,7 @@ dkp_device_class_init (DkpDeviceClass *klass)
 							      NULL,
 							      G_PARAM_READWRITE));
 	/**
-	 * DkpDevice:serial:
+	 * UpDevice:serial:
 	 */
 	g_object_class_install_property (object_class,
 					 PROP_SERIAL,
@@ -978,7 +978,7 @@ dkp_device_class_init (DkpDeviceClass *klass)
 							      NULL,
 							      G_PARAM_READWRITE));
 	/**
-	 * DkpDevice:native-path:
+	 * UpDevice:native-path:
 	 */
 	g_object_class_install_property (object_class,
 					 PROP_NATIVE_PATH,
@@ -987,7 +987,7 @@ dkp_device_class_init (DkpDeviceClass *klass)
 							      NULL,
 							      G_PARAM_READWRITE));
 	/**
-	 * DkpDevice:power-supply:
+	 * UpDevice:power-supply:
 	 */
 	g_object_class_install_property (object_class,
 					 PROP_POWER_SUPPLY,
@@ -996,7 +996,7 @@ dkp_device_class_init (DkpDeviceClass *klass)
 							       FALSE,
 							       G_PARAM_READWRITE));
 	/**
-	 * DkpDevice:online:
+	 * UpDevice:online:
 	 */
 	g_object_class_install_property (object_class,
 					 PROP_ONLINE,
@@ -1005,7 +1005,7 @@ dkp_device_class_init (DkpDeviceClass *klass)
 							       FALSE,
 							       G_PARAM_READWRITE));
 	/**
-	 * DkpDevice:is-present:
+	 * UpDevice:is-present:
 	 */
 	g_object_class_install_property (object_class,
 					 PROP_IS_PRESENT,
@@ -1014,7 +1014,7 @@ dkp_device_class_init (DkpDeviceClass *klass)
 							       FALSE,
 							       G_PARAM_READWRITE));
 	/**
-	 * DkpDevice:is-rechargeable:
+	 * UpDevice:is-rechargeable:
 	 */
 	g_object_class_install_property (object_class,
 					 PROP_IS_RECHARGEABLE,
@@ -1023,7 +1023,7 @@ dkp_device_class_init (DkpDeviceClass *klass)
 							       FALSE,
 							       G_PARAM_READWRITE));
 	/**
-	 * DkpDevice:has-history:
+	 * UpDevice:has-history:
 	 */
 	g_object_class_install_property (object_class,
 					 PROP_HAS_HISTORY,
@@ -1032,7 +1032,7 @@ dkp_device_class_init (DkpDeviceClass *klass)
 							       FALSE,
 							       G_PARAM_READWRITE));
 	/**
-	 * DkpDevice:has-statistics:
+	 * UpDevice:has-statistics:
 	 */
 	g_object_class_install_property (object_class,
 					 PROP_HAS_STATISTICS,
@@ -1041,7 +1041,7 @@ dkp_device_class_init (DkpDeviceClass *klass)
 							       FALSE,
 							       G_PARAM_READWRITE));
 	/**
-	 * DkpDevice:type:
+	 * UpDevice:type:
 	 */
 	g_object_class_install_property (object_class,
 					 PROP_TYPE,
@@ -1052,7 +1052,7 @@ dkp_device_class_init (DkpDeviceClass *klass)
 							    DKP_DEVICE_TYPE_UNKNOWN,
 							    G_PARAM_READWRITE));
 	/**
-	 * DkpDevice:state:
+	 * UpDevice:state:
 	 */
 	g_object_class_install_property (object_class,
 					 PROP_STATE,
@@ -1063,7 +1063,7 @@ dkp_device_class_init (DkpDeviceClass *klass)
 							    DKP_DEVICE_STATE_UNKNOWN,
 							    G_PARAM_READWRITE));
 	/**
-	 * DkpDevice:technology:
+	 * UpDevice:technology:
 	 */
 	g_object_class_install_property (object_class,
 					 PROP_TECHNOLOGY,
@@ -1074,7 +1074,7 @@ dkp_device_class_init (DkpDeviceClass *klass)
 							    DKP_DEVICE_TECHNOLOGY_UNKNOWN,
 							    G_PARAM_READWRITE));
 	/**
-	 * DkpDevice:capacity:
+	 * UpDevice:capacity:
 	 */
 	g_object_class_install_property (object_class,
 					 PROP_CAPACITY,
@@ -1082,7 +1082,7 @@ dkp_device_class_init (DkpDeviceClass *klass)
 							      0.0, 100.f, 100.0,
 							      G_PARAM_READWRITE));
 	/**
-	 * DkpDevice:energy:
+	 * UpDevice:energy:
 	 */
 	g_object_class_install_property (object_class,
 					 PROP_ENERGY,
@@ -1090,7 +1090,7 @@ dkp_device_class_init (DkpDeviceClass *klass)
 							      0.0, G_MAXDOUBLE, 0.0,
 							      G_PARAM_READWRITE));
 	/**
-	 * DkpDevice:energy-empty:
+	 * UpDevice:energy-empty:
 	 */
 	g_object_class_install_property (object_class,
 					 PROP_ENERGY_EMPTY,
@@ -1098,7 +1098,7 @@ dkp_device_class_init (DkpDeviceClass *klass)
 							      0.0, G_MAXDOUBLE, 0.0,
 							      G_PARAM_READWRITE));
 	/**
-	 * DkpDevice:energy-full:
+	 * UpDevice:energy-full:
 	 */
 	g_object_class_install_property (object_class,
 					 PROP_ENERGY_FULL,
@@ -1106,7 +1106,7 @@ dkp_device_class_init (DkpDeviceClass *klass)
 							      0.0, G_MAXDOUBLE, 0.0,
 							      G_PARAM_READWRITE));
 	/**
-	 * DkpDevice:energy-full-design:
+	 * UpDevice:energy-full-design:
 	 */
 	g_object_class_install_property (object_class,
 					 PROP_ENERGY_FULL_DESIGN,
@@ -1114,7 +1114,7 @@ dkp_device_class_init (DkpDeviceClass *klass)
 							      0.0, G_MAXDOUBLE, 0.0,
 							      G_PARAM_READWRITE));
 	/**
-	 * DkpDevice:energy-rate:
+	 * UpDevice:energy-rate:
 	 */
 	g_object_class_install_property (object_class,
 					 PROP_ENERGY_RATE,
@@ -1122,7 +1122,7 @@ dkp_device_class_init (DkpDeviceClass *klass)
 							      0.0, G_MAXDOUBLE, 0.0,
 							      G_PARAM_READWRITE));
 	/**
-	 * DkpDevice:voltage:
+	 * UpDevice:voltage:
 	 */
 	g_object_class_install_property (object_class,
 					 PROP_VOLTAGE,
@@ -1130,7 +1130,7 @@ dkp_device_class_init (DkpDeviceClass *klass)
 							      0.0, G_MAXDOUBLE, 0.0,
 							      G_PARAM_READWRITE));
 	/**
-	 * DkpDevice:time-to-empty:
+	 * UpDevice:time-to-empty:
 	 */
 	g_object_class_install_property (object_class,
 					 PROP_TIME_TO_EMPTY,
@@ -1138,7 +1138,7 @@ dkp_device_class_init (DkpDeviceClass *klass)
 							      0, G_MAXINT64, 0,
 							      G_PARAM_READWRITE));
 	/**
-	 * DkpDevice:time-to-full:
+	 * UpDevice:time-to-full:
 	 */
 	g_object_class_install_property (object_class,
 					 PROP_TIME_TO_FULL,
@@ -1146,7 +1146,7 @@ dkp_device_class_init (DkpDeviceClass *klass)
 							      0, G_MAXINT64, 0,
 							      G_PARAM_READWRITE));
 	/**
-	 * DkpDevice:percentage:
+	 * UpDevice:percentage:
 	 */
 	g_object_class_install_property (object_class,
 					 PROP_PERCENTAGE,
@@ -1154,7 +1154,7 @@ dkp_device_class_init (DkpDeviceClass *klass)
 							      0.0, 100.f, 100.0,
 							      G_PARAM_READWRITE));
 	/**
-	 * DkpDevice:recall-notice:
+	 * UpDevice:recall-notice:
 	 */
 	g_object_class_install_property (object_class,
 					 PROP_RECALL_NOTICE,
@@ -1163,7 +1163,7 @@ dkp_device_class_init (DkpDeviceClass *klass)
 							       FALSE,
 							       G_PARAM_READWRITE));
 	/**
-	 * DkpDevice:recall-vendor:
+	 * UpDevice:recall-vendor:
 	 */
 	g_object_class_install_property (object_class,
 					 PROP_RECALL_VENDOR,
@@ -1172,7 +1172,7 @@ dkp_device_class_init (DkpDeviceClass *klass)
 							      NULL,
 							      G_PARAM_READWRITE));
 	/**
-	 * DkpDevice:recall-url:
+	 * UpDevice:recall-url:
 	 */
 	g_object_class_install_property (object_class,
 					 PROP_RECALL_URL,
@@ -1181,17 +1181,17 @@ dkp_device_class_init (DkpDeviceClass *klass)
 							      NULL,
 							      G_PARAM_READWRITE));
 
-	dbus_g_error_domain_register (DKP_DEVICE_ERROR, NULL, DKP_DEVICE_TYPE_ERROR);
+	dbus_g_error_domain_register (UP_DEVICE_ERROR, NULL, UP_DEVICE_TYPE_ERROR);
 }
 
 /**
- * dkp_device_new:
+ * up_device_new:
  **/
-DkpDevice *
-dkp_device_new (void)
+UpDevice *
+up_device_new (void)
 {
-	DkpDevice *device;
-	device = DKP_DEVICE (g_object_new (DKP_TYPE_DEVICE, NULL));
+	UpDevice *device;
+	device = UP_DEVICE (g_object_new (UP_TYPE_DEVICE, NULL));
 	return device;
 }
 
@@ -1202,17 +1202,17 @@ dkp_device_new (void)
 #include "egg-test.h"
 
 void
-dkp_device_test (gpointer user_data)
+up_device_test (gpointer user_data)
 {
 	EggTest *test = (EggTest *) user_data;
-	DkpDevice *device;
+	UpDevice *device;
 
-	if (!egg_test_start (test, "DkpDevice"))
+	if (!egg_test_start (test, "UpDevice"))
 		return;
 
 	/************************************************************/
 	egg_test_title (test, "get instance");
-	device = dkp_device_new ();
+	device = up_device_new ();
 	egg_test_assert (test, device != NULL);
 
 	/* unref */
diff --git a/src/up-device.h b/src/up-device.h
index 4133aef..020e529 100644
--- a/src/up-device.h
+++ b/src/up-device.h
@@ -19,8 +19,8 @@
  *
  */
 
-#ifndef __DKP_DEVICE_H__
-#define __DKP_DEVICE_H__
+#ifndef __UP_DEVICE_H__
+#define __UP_DEVICE_H__
 
 #include <glib-object.h>
 #include <polkit/polkit.h>
@@ -30,78 +30,78 @@
 
 G_BEGIN_DECLS
 
-#define DKP_TYPE_DEVICE		(dkp_device_get_type ())
-#define DKP_DEVICE(o)	   	(G_TYPE_CHECK_INSTANCE_CAST ((o), DKP_TYPE_DEVICE, DkpDevice))
-#define DKP_DEVICE_CLASS(k)	(G_TYPE_CHECK_CLASS_CAST((k), DKP_TYPE_DEVICE, DkpDeviceClass))
-#define DKP_IS_DEVICE(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), DKP_TYPE_DEVICE))
-#define DKP_IS_DEVICE_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), DKP_TYPE_DEVICE))
-#define DKP_DEVICE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), DKP_TYPE_DEVICE, DkpDeviceClass))
+#define UP_TYPE_DEVICE		(up_device_get_type ())
+#define UP_DEVICE(o)	   	(G_TYPE_CHECK_INSTANCE_CAST ((o), UP_TYPE_DEVICE, UpDevice))
+#define UP_DEVICE_CLASS(k)	(G_TYPE_CHECK_CLASS_CAST((k), UP_TYPE_DEVICE, UpDeviceClass))
+#define UP_IS_DEVICE(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), UP_TYPE_DEVICE))
+#define UP_IS_DEVICE_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), UP_TYPE_DEVICE))
+#define UP_DEVICE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UP_TYPE_DEVICE, UpDeviceClass))
 
-typedef struct DkpDevicePrivate DkpDevicePrivate;
+typedef struct UpDevicePrivate UpDevicePrivate;
 
 typedef struct
 {
 	GObject			 parent;
-	DkpDevicePrivate	*priv;
-} DkpDevice;
+	UpDevicePrivate	*priv;
+} UpDevice;
 
 typedef struct
 {
 	GObjectClass	 parent_class;
 
 	/* vtable */
-	gboolean	 (*coldplug)		(DkpDevice	*device);
-	gboolean	 (*refresh)		(DkpDevice	*device);
-	const gchar	*(*get_id)		(DkpDevice	*device);
-	gboolean	 (*get_on_battery)	(DkpDevice	*device,
+	gboolean	 (*coldplug)		(UpDevice	*device);
+	gboolean	 (*refresh)		(UpDevice	*device);
+	const gchar	*(*get_id)		(UpDevice	*device);
+	gboolean	 (*get_on_battery)	(UpDevice	*device,
 						 gboolean	*on_battery);
-	gboolean	 (*get_low_battery)	(DkpDevice	*device,
+	gboolean	 (*get_low_battery)	(UpDevice	*device,
 						 gboolean	*low_battery);
-	gboolean	 (*get_online)		(DkpDevice	*device,
+	gboolean	 (*get_online)		(UpDevice	*device,
 						 gboolean	*online);
-} DkpDeviceClass;
+} UpDeviceClass;
 
 typedef enum
 {
-	DKP_DEVICE_ERROR_GENERAL,
-	DKP_DEVICE_NUM_ERRORS
-} DkpDeviceError;
+	UP_DEVICE_ERROR_GENERAL,
+	UP_DEVICE_NUM_ERRORS
+} UpDeviceError;
 
-#define DKP_DEVICE_ERROR dkp_device_error_quark ()
-#define DKP_DEVICE_TYPE_ERROR (dkp_device_error_get_type ())
+#define UP_DEVICE_ERROR up_device_error_quark ()
+#define UP_DEVICE_TYPE_ERROR (up_device_error_get_type ())
 
-GQuark		 dkp_device_error_quark		(void);
-GType		 dkp_device_error_get_type	(void);
-GType		 dkp_device_get_type		(void);
-DkpDevice	*dkp_device_new			(void);
-void		 dkp_device_test		(gpointer	 user_data);
+GQuark		 up_device_error_quark		(void);
+GType		 up_device_error_get_type	(void);
+GType		 up_device_get_type		(void);
+UpDevice	*up_device_new			(void);
+void		 up_device_test		(gpointer	 user_data);
 
-gboolean	 dkp_device_coldplug		(DkpDevice	*device,
+gboolean	 up_device_coldplug		(UpDevice	*device,
 						 UpDaemon	*daemon,
 						 GObject	*native);
-UpDaemon	*dkp_device_get_daemon		(DkpDevice	*device);
-GObject		*dkp_device_get_native		(DkpDevice	*device);
-const gchar	*dkp_device_get_object_path	(DkpDevice	*device);
-gboolean	 dkp_device_get_on_battery	(DkpDevice	*device,
+UpDaemon	*up_device_get_daemon		(UpDevice	*device);
+GObject		*up_device_get_native		(UpDevice	*device);
+const gchar	*up_device_get_object_path	(UpDevice	*device);
+gboolean	 up_device_get_on_battery	(UpDevice	*device,
 						 gboolean	*on_battery);
-gboolean	 dkp_device_get_low_battery	(DkpDevice	*device,
+gboolean	 up_device_get_low_battery	(UpDevice	*device,
 						 gboolean	*low_battery);
-gboolean	 dkp_device_get_online		(DkpDevice	*device,
+gboolean	 up_device_get_online		(UpDevice	*device,
 						 gboolean	*online);
-gboolean	 dkp_device_refresh_internal	(DkpDevice	*device);
+gboolean	 up_device_refresh_internal	(UpDevice	*device);
 
 /* exported methods */
-gboolean	 dkp_device_refresh		(DkpDevice		*device,
+gboolean	 up_device_refresh		(UpDevice		*device,
 						 DBusGMethodInvocation	*context);
-gboolean	 dkp_device_get_history		(DkpDevice		*device,
+gboolean	 up_device_get_history		(UpDevice		*device,
 						 const gchar		*type,
 						 guint			 timespan,
 						 guint			 resolution,
 						 DBusGMethodInvocation	*context);
-gboolean	 dkp_device_get_statistics	(DkpDevice		*device,
+gboolean	 up_device_get_statistics	(UpDevice		*device,
 						 const gchar		*type,
 						 DBusGMethodInvocation	*context);
 
 G_END_DECLS
 
-#endif /* __DKP_DEVICE_H__ */
+#endif /* __UP_DEVICE_H__ */
diff --git a/src/up-history.c b/src/up-history.c
index 6f2581a..c1a1c5d 100644
--- a/src/up-history.c
+++ b/src/up-history.c
@@ -45,7 +45,7 @@ struct DkpHistoryPrivate
 	gint64			 time_full_last;
 	gint64			 time_empty_last;
 	gdouble			 percentage_last;
-	DkpDeviceState		 state;
+	UpDeviceState		 state;
 	GPtrArray		*data_rate;
 	GPtrArray		*data_charge;
 	GPtrArray		*data_time_full;
@@ -114,7 +114,7 @@ dkp_history_array_limit_resolution (GPtrArray *array, guint max_num)
 	guint last;
 	guint first;
 	GPtrArray *new;
-	DkpDeviceState state = DKP_DEVICE_STATE_UNKNOWN;
+	UpDeviceState state = DKP_DEVICE_STATE_UNKNOWN;
 	guint64 time_s = 0;
 	gdouble value = 0;
 	guint64 count = 0;
@@ -669,7 +669,7 @@ dkp_history_set_id (DkpHistory *history, const gchar *id)
  * dkp_history_set_state:
  **/
 gboolean
-dkp_history_set_state (DkpHistory *history, DkpDeviceState state)
+dkp_history_set_state (DkpHistory *history, UpDeviceState state)
 {
 	g_return_val_if_fail (DKP_IS_HISTORY (history), FALSE);
 
diff --git a/src/up-history.h b/src/up-history.h
index afabaca..cdac023 100644
--- a/src/up-history.h
+++ b/src/up-history.h
@@ -71,7 +71,7 @@ GPtrArray	*dkp_history_get_profile_data		(DkpHistory		*history,
 gboolean	 dkp_history_set_id			(DkpHistory		*history,
 							 const gchar		*id);
 gboolean	 dkp_history_set_state			(DkpHistory		*history,
-							 DkpDeviceState		 state);
+							 UpDeviceState		 state);
 gboolean	 dkp_history_set_charge_data		(DkpHistory		*history,
 							 gdouble		 percentage);
 gboolean	 dkp_history_set_rate_data		(DkpHistory		*history,
diff --git a/src/up-self-test.c b/src/up-self-test.c
index 594f872..a8184ee 100644
--- a/src/up-self-test.c
+++ b/src/up-self-test.c
@@ -46,8 +46,8 @@ main (int argc, char **argv)
 
 	/* tests go here */
 	up_backend_test (test);
-	dkp_device_test (test);
-	dkp_device_list_test (test);
+	up_device_test (test);
+	up_device_list_test (test);
 	dkp_history_test (test);
 	dkp_native_test (test);
 	dkp_polkit_test (test);