initial

18 files changed, 2317 insertions, 0 deletions

diff --git a/cpufreq/src/cpufreq-selector/Makefile.am b/cpufreq/src/cpufreq-selector/Makefile.am
new file mode 100644
index 00000000..b2db7a97
--- /dev/null
+++ b/cpufreq/src/cpufreq-selector/Makefile.am
@@ -0,0 +1,89 @@
+cpufreqselectordir = $(bindir)
+
+INCLUDES = $(CPUFREQ_SELECTOR_CFLAGS)
+
+if HAVE_POLKIT
+INCLUDES += \
+	$(DBUS_CFLAGS)		\
+	$(POLKIT_CFLAGS)
+endif
+
+bin_PROGRAMS = cpufreq-selector
+
+install-exec-hook:
+if CPUFREQ_SELECTOR_SUID
+	chmod 4755 $(DESTDIR)$(bindir)/cpufreq-selector
+endif
+
+
+if HAVE_LIBCPUFREQ
+cpufreq_files=cpufreq-selector-libcpufreq.c        cpufreq-selector-libcpufreq.h
+endif
+
+if HAVE_POLKIT
+service_files=cpufreq-selector-service.c       cpufreq-selector-service.h
+endif
+
+cpufreq_selector_SOURCES = \
+	cpufreq-selector.c               cpufreq-selector.h        	\
+	cpufreq-selector-sysfs.c         cpufreq-selector-sysfs.h  	\
+	cpufreq-selector-procfs.c        cpufreq-selector-procfs.h 	\
+	$(cpufreq_files)					   	\
+	$(service_files)						\
+	cpufreq-selector-factory.c	 cpufreq-selector-factory.h	\
+	$(BUILT_SOURCES)						\
+	main.c
+
+cpufreq_selector_LDADD = \
+	$(CPUFREQ_SELECTOR_LIBS) 	\
+	$(LIBCPUFREQ_LIBS)
+
+if HAVE_POLKIT
+cpufreq_selector_LDADD += \
+	$(DBUS_LIBS)		\
+	$(POLKIT_LIBS)
+endif
+
+cpufreq_selector_LDFLAGS = $(LDFLAGS) -Wl,-z,now
+
+dbus_services_in_files = org.mate.CPUFreqSelector.service.in
+polkit_in_files = org.mate.cpufreqselector.policy.in
+
+dbus_servicesdir = $(datadir)/dbus-1/system-services
+dbus_confdir = $(sysconfdir)/dbus-1/system.d
+polkitdir = $(datadir)/polkit-1/actions
+
+if HAVE_POLKIT
+BUILT_SOURCES = cpufreq-selector-service-glue.h
+
+cpufreq-selector-service-glue.h: $(srcdir)/cpufreq-selector-service.xml
+	dbus-binding-tool --prefix=cpufreq_selector_service --mode=glib-server	\
+	                  --output=cpufreq-selector-service-glue.h		\
+	                  $(srcdir)/cpufreq-selector-service.xml
+
+dbus_services_DATA = $(dbus_services_in_files:.service.in=.service)
+$(dbus_services_DATA): $(dbus_services_in_files)
+	sed -e "s|\@BINDIR\@|$(DESTDIR)$(bindir)|" $< > $@
+dbus_conf_DATA = org.mate.CPUFreqSelector.conf
+
+@INTLTOOL_POLICY_RULE@
+polkit_DATA = $(polkit_in_files:.policy.in=.policy)
+
+else
+dbus_services_DATA=
+dbus_conf_DATA=
+polkit_DATA=
+endif
+
+EXTRA_DIST = \
+	cpufreq-selector-service.xml	\
+	$(dbus_services_in_files)	\
+	org.mate.CPUFreqSelector.conf	\
+	$(polkit_in_files)
+
+CLEANFILES = \
+	$(BUILT_SOURCES)	\
+	$(dbus_services_DATA)	\
+	$(polkit_DATA)
+
+-include $(top_srcdir)/git.mk
diff --git a/cpufreq/src/cpufreq-selector/cpufreq-selector-factory.c b/cpufreq/src/cpufreq-selector/cpufreq-selector-factory.c
new file mode 100644
index 00000000..024b5cb7
--- /dev/null
+++ b/cpufreq/src/cpufreq-selector/cpufreq-selector-factory.c
@@ -0,0 +1,47 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2008 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "cpufreq-selector-factory.h"
+#include "cpufreq-selector-sysfs.h"
+#include "cpufreq-selector-procfs.h"
+#ifdef HAVE_LIBCPUFREQ
+#include "cpufreq-selector-libcpufreq.h"
+#endif
+
+CPUFreqSelector *
+cpufreq_selector_factory_create_selector (guint cpu)
+{
+	CPUFreqSelector *selector = NULL;
+	
+#ifdef HAVE_LIBCPUFREQ
+	selector = cpufreq_selector_libcpufreq_new (cpu);
+#else
+	if (g_file_test ("/sys/devices/system/cpu/cpu0/cpufreq", G_FILE_TEST_EXISTS)) { /* 2.6 kernel */
+		selector = cpufreq_selector_sysfs_new (cpu);
+	} else if (g_file_test ("/proc/cpufreq", G_FILE_TEST_EXISTS)) { /* 2.4 kernel */
+		selector = cpufreq_selector_procfs_new (cpu);
+	}
+#endif /* HAVE_LIBCPUFREQ */
+
+	return selector;
+}
diff --git a/cpufreq/src/cpufreq-selector/cpufreq-selector-factory.h b/cpufreq/src/cpufreq-selector/cpufreq-selector-factory.h
new file mode 100644
index 00000000..fba0a8dc
--- /dev/null
+++ b/cpufreq/src/cpufreq-selector/cpufreq-selector-factory.h
@@ -0,0 +1,31 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2008 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef CPUFREQ_SELECTOR_FACTORY
+#define CPUFREQ_SELECTOR_FACTORY
+
+#include "cpufreq-selector.h"
+
+G_BEGIN_DECLS
+
+CPUFreqSelector *cpufreq_selector_factory_create_selector (guint cpu);
+
+G_END_DECLS
+
+#endif /* CPUFREQ_SELECTOR_FACTORY */
diff --git a/cpufreq/src/cpufreq-selector/cpufreq-selector-libcpufreq.c b/cpufreq/src/cpufreq-selector/cpufreq-selector-libcpufreq.c
new file mode 100644
index 00000000..4b9573b3
--- /dev/null
+++ b/cpufreq/src/cpufreq-selector/cpufreq-selector-libcpufreq.c
@@ -0,0 +1,197 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2004 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Authors : Carlos Garc�a Campos <[email protected]>
+ */
+
+#include <glib.h>
+#include <glib/gstdio.h>
+#include <cpufreq.h>
+#include <stdlib.h>
+
+#include "cpufreq-selector-libcpufreq.h"
+
+static void     cpufreq_selector_libcpufreq_init          (CPUFreqSelectorLibcpufreq      *selector);
+static void     cpufreq_selector_libcpufreq_class_init    (CPUFreqSelectorLibcpufreqClass *klass);
+
+static gboolean cpufreq_selector_libcpufreq_set_frequency (CPUFreqSelector           *selector,
+							   guint                      frequency,
+							   GError                   **error);
+static gboolean cpufreq_selector_libcpufreq_set_governor  (CPUFreqSelector           *selector,
+							   const gchar               *governor,
+							   GError                   **error);
+
+G_DEFINE_TYPE (CPUFreqSelectorLibcpufreq, cpufreq_selector_libcpufreq, CPUFREQ_TYPE_SELECTOR)
+
+typedef struct cpufreq_policy                CPUFreqPolicy;
+typedef struct cpufreq_available_frequencies CPUFreqFrequencyList;
+typedef struct cpufreq_available_governors   CPUFreqGovernorList;
+
+static void
+cpufreq_selector_libcpufreq_init (CPUFreqSelectorLibcpufreq *selector)
+{
+}
+
+static void
+cpufreq_selector_libcpufreq_class_init (CPUFreqSelectorLibcpufreqClass *klass)
+{
+        CPUFreqSelectorClass *selector_class = CPUFREQ_SELECTOR_CLASS (klass);
+
+	selector_class->set_frequency = cpufreq_selector_libcpufreq_set_frequency;
+        selector_class->set_governor = cpufreq_selector_libcpufreq_set_governor;
+}
+
+CPUFreqSelector *
+cpufreq_selector_libcpufreq_new (guint cpu)
+{
+        CPUFreqSelector *selector;
+
+        selector = CPUFREQ_SELECTOR (g_object_new (CPUFREQ_TYPE_SELECTOR_LIBCPUFREQ,
+						   "cpu", cpu, 
+						   NULL));
+
+        return selector;
+}
+
+static guint 
+cpufreq_selector_libcpufreq_get_valid_frequency (CPUFreqSelectorLibcpufreq *selector,
+						 guint                      frequency)
+{
+	guint                 cpu;
+	gint                  dist = G_MAXINT;
+	guint                 retval = 0;
+	CPUFreqFrequencyList *freqs, *freq;
+
+	g_object_get (G_OBJECT (selector),
+		      "cpu", &cpu,
+		      NULL);
+
+	freqs = cpufreq_get_available_frequencies (cpu);
+	if (!freqs)
+		return 0;
+
+	for (freq = freqs; freq; freq = freq->next) {
+		guint current_dist;
+		
+		if (freq->frequency == frequency) {
+			cpufreq_put_available_frequencies (freqs);
+
+			return frequency;
+		}
+
+		current_dist = abs (freq->frequency - frequency);
+		if (current_dist < dist) {
+			dist = current_dist;
+			retval = freq->frequency;
+		}
+	}
+
+	return retval;
+}
+
+static gboolean
+cpufreq_selector_libcpufreq_set_frequency (CPUFreqSelector *selector,
+					   guint            frequency,
+					   GError         **error)
+{
+	guint freq;
+	guint cpu;
+
+	g_object_get (G_OBJECT (selector),
+		      "cpu", &cpu,
+		      NULL);
+
+	freq = cpufreq_selector_libcpufreq_get_valid_frequency (CPUFREQ_SELECTOR_LIBCPUFREQ (selector),
+								frequency);
+	if (cpufreq_set_frequency (cpu, freq) != 0) {
+		g_set_error (error,
+			     CPUFREQ_SELECTOR_ERROR,
+			     SELECTOR_ERROR_SET_FREQUENCY,
+			     "Cannot set frequency '%d'",
+			     frequency);
+		
+		return FALSE;
+	}
+	
+	return TRUE;
+}
+
+static gboolean
+cpufreq_selector_libcpufreq_validate_governor (CPUFreqSelectorLibcpufreq *selector,
+					       const gchar               *governor)
+{
+	guint                cpu;
+	CPUFreqGovernorList *govs, *gov;
+
+	g_object_get (G_OBJECT (selector),
+		      "cpu", &cpu,
+		      NULL);
+
+	govs = cpufreq_get_available_governors (cpu);
+	if (!govs)
+		return FALSE;
+
+	for (gov = govs; gov; gov = gov->next) {
+		if (g_ascii_strcasecmp (gov->governor, governor) == 0) {
+			cpufreq_put_available_governors (govs);
+
+			return TRUE;
+		}
+	}
+
+	cpufreq_put_available_governors (govs);
+
+	return FALSE;
+}
+
+static gboolean
+cpufreq_selector_libcpufreq_set_governor (CPUFreqSelector *selector,
+					  const gchar     *governor,
+					  GError         **error)
+{
+	CPUFreqSelectorLibcpufreq *selector_libcpufreq;
+	guint                      cpu;
+
+	selector_libcpufreq = CPUFREQ_SELECTOR_LIBCPUFREQ (selector);
+
+	if (!cpufreq_selector_libcpufreq_validate_governor (selector_libcpufreq, governor)) {
+		g_set_error (error,
+			     CPUFREQ_SELECTOR_ERROR,
+			     SELECTOR_ERROR_INVALID_GOVERNOR,
+			     "Invalid governor '%s'",
+			     governor);
+		
+		return FALSE;
+	}
+	
+	g_object_get (G_OBJECT (selector),
+		      "cpu", &cpu,
+		      NULL);
+
+	if (cpufreq_modify_policy_governor (cpu, (gchar *)governor) != 0) {
+		g_set_error (error,
+			     CPUFREQ_SELECTOR_ERROR,
+			     SELECTOR_ERROR_INVALID_GOVERNOR,
+			     "Invalid governor '%s'",
+			     governor);
+
+		return FALSE;
+	}
+
+	return TRUE;
+}
diff --git a/cpufreq/src/cpufreq-selector/cpufreq-selector-libcpufreq.h b/cpufreq/src/cpufreq-selector/cpufreq-selector-libcpufreq.h
new file mode 100644
index 00000000..37dcda63
--- /dev/null
+++ b/cpufreq/src/cpufreq-selector/cpufreq-selector-libcpufreq.h
@@ -0,0 +1,61 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2004 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Authors : Carlos Garc�a Campos <[email protected]>
+ */
+
+#ifndef __CPUFREQ_SELECTOR_LIBCPUFREQ_H__
+#define __CPUFREQ_SELECTOR_LIBCPUFREQ_H__
+
+#include <glib-object.h>
+
+#include "cpufreq-selector.h"
+
+G_BEGIN_DECLS
+
+#define CPUFREQ_TYPE_SELECTOR_LIBCPUFREQ            \
+	(cpufreq_selector_libcpufreq_get_type ())
+#define CPUFREQ_SELECTOR_LIBCPUFREQ(obj)            \
+	(G_TYPE_CHECK_INSTANCE_CAST ((obj), CPUFREQ_TYPE_SELECTOR_LIBCPUFREQ, CPUFreqSelectorLibcpufreq))
+#define CPUFREQ_SELECTOR_LIBCPUFREQ_CLASS(klass)    \
+	(G_TYPE_CHECK_CLASS_CAST((klass), CPUFREQ_TYPE_SELECTOR_LIBCPUFREQ, CPUFreqSelectorLibcpufreqClass))
+#define CPUFREQ_IS_SELECTOR_LIBCPUFREQ(obj)         \
+	(G_TYPE_CHECK_INSTANCE_TYPE ((obj), CPUFREQ_TYPE_SELECTOR_LIBCPUFREQ))
+#define CPUFREQ_IS_SELECTOR_LIBCPUFREQ_CLASS(klass) \
+	(G_TYPE_CHECK_CLASS_TYPE ((klass), CPUFREQ_TYPE_SELECTOR_LIBCPUFREQ))
+#define CPUFREQ_SELECTOR_LIBCPUFREQ_GET_CLASS(obj)  \
+	(G_TYPE_INSTANCE_GET_CLASS ((obj), CPUFREQ_TYPE_SELECTOR_LIBCPUFREQ, CPUFreqSelectorLibcpufreqClass))
+
+typedef struct _CPUFreqSelectorLibcpufreq      CPUFreqSelectorLibcpufreq;
+typedef struct _CPUFreqSelectorLibcpufreqClass CPUFreqSelectorLibcpufreqClass;
+
+struct _CPUFreqSelectorLibcpufreq {
+        CPUFreqSelector parent;
+};
+
+struct _CPUFreqSelectorLibcpufreqClass {
+        CPUFreqSelectorClass parent_class;
+};
+
+
+GType            cpufreq_selector_libcpufreq_get_type (void) G_GNUC_CONST;
+CPUFreqSelector *cpufreq_selector_libcpufreq_new      (guint cpu);
+
+G_END_DECLS
+
+#endif /* __CPUFREQ_SELECTOR_SYSFS_H__ */
diff --git a/cpufreq/src/cpufreq-selector/cpufreq-selector-procfs.c b/cpufreq/src/cpufreq-selector/cpufreq-selector-procfs.c
new file mode 100644
index 00000000..f08d681d
--- /dev/null
+++ b/cpufreq/src/cpufreq-selector/cpufreq-selector-procfs.c
@@ -0,0 +1,243 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2004 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Authors : Carlos Garc�a Campos <[email protected]>
+ */
+
+#include <glib.h>
+#include <glib/gstdio.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+
+#include "cpufreq-selector-procfs.h"
+
+static void     cpufreq_selector_procfs_init          (CPUFreqSelectorProcfs      *selector);
+static void     cpufreq_selector_procfs_class_init    (CPUFreqSelectorProcfsClass *klass);
+
+static gboolean cpufreq_selector_procfs_set_frequency (CPUFreqSelector            *selector,
+						       guint                       frequency,
+						       GError                    **error);
+static gboolean cpufreq_selector_procfs_set_governor  (CPUFreqSelector            *selector,
+						       const gchar                *governor,
+						       GError                    **error);
+
+G_DEFINE_TYPE (CPUFreqSelectorProcfs, cpufreq_selector_procfs, CPUFREQ_TYPE_SELECTOR)
+
+static void
+cpufreq_selector_procfs_init (CPUFreqSelectorProcfs *selector)
+{
+}
+
+static void
+cpufreq_selector_procfs_class_init (CPUFreqSelectorProcfsClass *klass)
+{
+        CPUFreqSelectorClass *selector_class = CPUFREQ_SELECTOR_CLASS (klass);
+
+	selector_class->set_frequency = cpufreq_selector_procfs_set_frequency;
+        selector_class->set_governor = cpufreq_selector_procfs_set_governor;
+}
+
+CPUFreqSelector *
+cpufreq_selector_procfs_new (guint cpu)
+{
+        CPUFreqSelector *selector;
+
+        selector = CPUFREQ_SELECTOR (g_object_new (CPUFREQ_TYPE_SELECTOR_PROCFS,
+						   "cpu", cpu,
+						   NULL));
+
+        return selector;
+}
+
+static gboolean
+cpufreq_procfs_read (guint    selector_cpu,
+		     guint   *fmax,
+		     guint   *pmin,
+		     guint   *pmax,
+		     guint   *fmin,
+		     gchar   *mode,
+		     GError **error)
+{
+	gchar  **lines;
+	gchar   *buffer = NULL;
+	gint     i;
+	guint    cpu;
+	gboolean found = FALSE;
+	
+	if (!g_file_get_contents ("/proc/cpufreq", &buffer, NULL, error)) {
+		return FALSE;
+	}
+
+	lines = g_strsplit (buffer, "\n", -1);
+	for (i = 0; lines[i]; i++) {
+		if (g_ascii_strncasecmp (lines[i], "CPU", 3) == 0) {
+			/* CPU  0       650000 kHz ( 81 %)  -     800000 kHz (100 %)  -  powersave */
+			sscanf (lines[i], "CPU %u %u kHz (%u %%) - %u kHz (%u %%) - %20s",
+				&cpu, fmin, pmin, fmax, pmax, mode);
+
+			if (cpu == selector_cpu) {
+				found = TRUE;
+				break;
+			}
+		}
+	}
+
+	g_strfreev (lines);
+	g_free (buffer);
+
+	if (!found) {
+		g_set_error (error,
+			     CPUFREQ_SELECTOR_ERROR,
+			     SELECTOR_ERROR_INVALID_CPU,
+			     "Invalid CPU number '%d'",
+			     selector_cpu);
+		
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+static gboolean
+cpufreq_procfs_write (const gchar *path,
+		      const gchar *setting,
+		      GError     **error)
+{
+	FILE *fd;
+
+	fd = g_fopen (path, "w");
+
+	if (!fd) {
+		g_set_error (error,
+			     G_FILE_ERROR,
+			     g_file_error_from_errno (errno),
+			     "Failed to open '%s' for writing: "
+			     "g_fopen() failed: %s",
+			     path,
+			     g_strerror (errno));
+
+		return FALSE;
+	}
+
+	if (g_fprintf (fd, "%s", setting) < 0) {
+		g_set_error (error,
+			     G_FILE_ERROR,
+			     g_file_error_from_errno (errno),
+			     "Failed to write '%s': "
+			     "g_fprintf() failed: %s",
+			     path,
+			     g_strerror (errno));
+
+		fclose (fd);
+
+		return FALSE;
+	}
+
+	fclose (fd);
+
+	return TRUE;
+}
+
+static gboolean 
+cpufreq_selector_procfs_set_frequency (CPUFreqSelector *selector,
+				       guint            frequency,
+				       GError         **error)
+{
+        gchar *str;
+	gchar *path;
+	guint  freq;
+	guint  cpu;
+	guint  pmin, pmax;
+	guint  sc_max, sc_min;
+	gchar  mode[21];
+
+	g_object_get (G_OBJECT (selector),
+		      "cpu", &cpu,
+		      NULL);
+
+	if (!cpufreq_procfs_read (cpu, &sc_max, &pmin, &pmax, &sc_min, mode, error)) {
+		return FALSE;
+	}
+
+	if (g_ascii_strcasecmp (mode, "userspace") != 0) {
+		if (!cpufreq_selector_procfs_set_governor (selector,
+							   "userspace",
+							   error)) {
+			return FALSE;
+		}
+	}
+
+	if (frequency != sc_max && frequency != sc_min) {
+		if (abs (sc_max - frequency) < abs (frequency - sc_min))
+			freq = sc_max;
+		else
+			freq = sc_min;
+	} else {
+		freq = frequency;
+	}
+	
+	path = g_strdup_printf ("/proc/sys/cpu/%u/speed", cpu);
+	str = g_strdup_printf ("%u", freq);
+	if (!cpufreq_procfs_write (path, str, error)) {
+		g_free (path);
+		g_free (str);
+
+		return FALSE;
+	}
+
+	g_free (path);
+	g_free (str);
+	
+	return TRUE;
+}
+        
+static gboolean
+cpufreq_selector_procfs_set_governor (CPUFreqSelector *selector,
+				      const gchar     *governor,
+				      GError         **error)
+{
+	gchar *str;
+	guint  cpu;
+	guint  pmin, pmax;
+	guint  sc_max, sc_min;
+	gchar  mode[21];
+
+	g_object_get (G_OBJECT (selector),
+		      "cpu", &cpu,
+		      NULL);
+
+	if (!cpufreq_procfs_read (cpu, &sc_max, &pmin, &pmax, &sc_min, mode, error)) {
+		return FALSE;
+	}
+
+	if (g_ascii_strcasecmp (governor, mode) == 0)
+		return TRUE;
+
+	str = g_strdup_printf ("%u:%u:%u:%s", cpu, sc_min, sc_max, governor);
+
+	if (!cpufreq_procfs_write ("/proc/cpufreq", str, error)) {
+		g_free (str);
+
+		return FALSE;
+	}
+
+	g_free (str);
+
+	return TRUE;
+}
diff --git a/cpufreq/src/cpufreq-selector/cpufreq-selector-procfs.h b/cpufreq/src/cpufreq-selector/cpufreq-selector-procfs.h
new file mode 100644
index 00000000..55193731
--- /dev/null
+++ b/cpufreq/src/cpufreq-selector/cpufreq-selector-procfs.h
@@ -0,0 +1,54 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2004 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Authors : Carlos Garc�a Campos <[email protected]>
+ */
+
+#ifndef __CPUFREQ_SELECTOR_PROCFS_H__
+#define __CPUFREQ_SELECTOR_PROCFS_H__
+
+#include <glib-object.h>
+
+#include "cpufreq-selector.h"
+
+G_BEGIN_DECLS
+
+#define CPUFREQ_TYPE_SELECTOR_PROCFS            (cpufreq_selector_procfs_get_type ())
+#define CPUFREQ_SELECTOR_PROCFS(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), CPUFREQ_TYPE_SELECTOR_PROCFS, CPUFreqSelectorProcfs))
+#define CPUFREQ_SELECTOR_PROCFS_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), CPUFREQ_TYPE_SELECTOR_PROCFS, CPUFreqSelectorProcfsClass))
+#define CPUFREQ_IS_SELECTOR_PROCFS(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CPUFREQ_TYPE_SELECTOR_PROCFS))
+#define CPUFREQ_IS_SELECTOR_PROCFS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CPUFREQ_TYPE_SELECTOR_PROCFS))
+#define CPUFREQ_SELECTOR_PROCFS_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), CPUFREQ_TYPE_SELECTOR_PROCFS, CPUFreqSelectorProcfsClass))
+
+typedef struct _CPUFreqSelectorProcfs         CPUFreqSelectorProcfs;
+typedef struct _CPUFreqSelectorProcfsClass    CPUFreqSelectorProcfsClass;
+
+struct _CPUFreqSelectorProcfs {
+        CPUFreqSelector parent;
+};
+
+struct _CPUFreqSelectorProcfsClass {
+        CPUFreqSelectorClass parent_class;
+};
+
+GType            cpufreq_selector_procfs_get_type (void) G_GNUC_CONST;
+CPUFreqSelector *cpufreq_selector_procfs_new      (guint cpu);
+
+G_END_DECLS
+
+#endif /* __CPUFREQ_SELECTOR_PROCFS_H__ */
diff --git a/cpufreq/src/cpufreq-selector/cpufreq-selector-service.c b/cpufreq/src/cpufreq-selector/cpufreq-selector-service.c
new file mode 100644
index 00000000..696ff220
--- /dev/null
+++ b/cpufreq/src/cpufreq-selector/cpufreq-selector-service.c
@@ -0,0 +1,487 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2008 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <polkit/polkit.h>
+#include <dbus/dbus-glib-lowlevel.h>
+
+#include "cpufreq-selector.h"
+#include "cpufreq-selector-factory.h"
+#include "cpufreq-selector-service.h"
+
+#include "cpufreq-selector-service-glue.h"
+
+#define MAX_CPUS 255
+
+struct _CPUFreqSelectorService {
+        GObject parent;
+
+	CPUFreqSelector *selectors[MAX_CPUS];
+	gint             selectors_max;
+
+	DBusGConnection *system_bus;
+	
+	/* PolicyKit */
+	PolkitAuthority   *authority;
+};
+
+struct _CPUFreqSelectorServiceClass {
+        GObjectClass parent_class;
+};
+
+G_DEFINE_TYPE (CPUFreqSelectorService, cpufreq_selector_service, G_TYPE_OBJECT)
+
+#define BUS_NAME "org.mate.CPUFreqSelector"
+
+GType
+cpufreq_selector_service_error_get_type (void)
+{
+	static GType etype = 0;
+
+	if (G_UNLIKELY (etype == 0)) {
+		static const GEnumValue values[] = {
+			{ SERVICE_ERROR_GENERAL,            "SERVICE_ERROR_GENERAL",            "GeneralError" },
+			{ SERVICE_ERROR_DBUS,               "SERVICE_ERROR_DBUS",               "DBUSError" },
+			{ SERVICE_ERROR_ALREADY_REGISTERED, "SERVICE_ERROR_ALREADY_REGISTERED", "AlreadyRegistered" },
+			{ SERVICE_ERROR_NOT_AUTHORIZED,     "SERVICE_ERROR_NOT_AUTHORIZED",     "NotAuthorized"},
+			{ 0, NULL, NULL}
+		};
+		
+		etype = g_enum_register_static ("CPUFreqSelectorServiceError", values);
+	}
+
+	return etype;
+}
+
+GQuark
+cpufreq_selector_service_error_quark (void)
+{
+	static GQuark error_quark = 0;
+
+	if (G_UNLIKELY (error_quark == 0))
+		error_quark =
+			g_quark_from_static_string ("cpufreq-selector-service-error-quark");
+	
+	return error_quark;
+}
+
+static void
+cpufreq_selector_service_finalize (GObject *object)
+{
+	CPUFreqSelectorService *service = CPUFREQ_SELECTOR_SERVICE (object);
+	gint i;
+
+	service->system_bus = NULL;
+	
+	if (service->selectors_max >= 0) {
+		for (i = 0; i < service->selectors_max; i++) {
+			if (service->selectors[i]) {
+				g_object_unref (service->selectors[i]);
+				service->selectors[i] = NULL;
+			}
+		}
+
+		service->selectors_max = -1;
+	}
+
+	if (service->authority) {
+		g_object_unref (service->authority);
+		service->authority = NULL;
+	}
+
+	G_OBJECT_CLASS (cpufreq_selector_service_parent_class)->finalize (object);
+}
+
+static void
+cpufreq_selector_service_class_init (CPUFreqSelectorServiceClass *klass)
+{
+	GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+	object_class->finalize = cpufreq_selector_service_finalize;
+}
+
+static void
+cpufreq_selector_service_init (CPUFreqSelectorService *service)
+{
+	service->selectors_max = -1;
+}
+
+CPUFreqSelectorService *
+cpufreq_selector_service_get_instance (void)
+{
+	static CPUFreqSelectorService *service = NULL;
+
+	if (!service)
+		service = CPUFREQ_SELECTOR_SERVICE (g_object_new (CPUFREQ_TYPE_SELECTOR_SERVICE, NULL));
+
+	return service;
+}
+
+static gboolean
+service_shutdown (gpointer user_data)
+{
+	g_object_unref (SELECTOR_SERVICE);
+
+	return FALSE;
+}
+
+static void
+reset_killtimer (void)
+{
+	static guint timer_id = 0;
+
+	if (timer_id > 0)
+		g_source_remove (timer_id);
+
+	timer_id = g_timeout_add_seconds (30,
+					  (GSourceFunc) service_shutdown,
+					  NULL);
+}
+
+gboolean
+cpufreq_selector_service_register (CPUFreqSelectorService *service,
+				   GError                **error)
+{
+	DBusGConnection *connection;
+	DBusGProxy      *bus_proxy;
+	gboolean         res;
+	guint            result;
+	GError          *err = NULL;
+
+	if (service->system_bus) {
+		g_set_error (error,
+			     CPUFREQ_SELECTOR_SERVICE_ERROR,
+			     SERVICE_ERROR_ALREADY_REGISTERED,
+			     "Service %s already registered", BUS_NAME);
+		return FALSE;
+	}
+
+	connection = dbus_g_bus_get (DBUS_BUS_SYSTEM, &err);
+	if (!connection) {
+		g_set_error (error,
+			     CPUFREQ_SELECTOR_SERVICE_ERROR,
+			     SERVICE_ERROR_DBUS,
+			     "Couldn't connect to system bus: %s",
+			     err->message);
+		g_error_free (err);
+
+		return FALSE;
+	}
+
+	bus_proxy = dbus_g_proxy_new_for_name (connection,
+					       DBUS_SERVICE_DBUS,
+					       DBUS_PATH_DBUS,
+					       DBUS_INTERFACE_DBUS);
+	if (!bus_proxy) {
+		g_set_error (error,
+			     CPUFREQ_SELECTOR_SERVICE_ERROR,
+			     SERVICE_ERROR_DBUS,
+			     "Could not construct bus_proxy object");
+		return FALSE;
+	}
+
+	res = dbus_g_proxy_call (bus_proxy,
+				 "RequestName",
+				 &err,
+				 G_TYPE_STRING, BUS_NAME,
+				 G_TYPE_UINT, DBUS_NAME_FLAG_DO_NOT_QUEUE,
+				 G_TYPE_INVALID,
+				 G_TYPE_UINT, &result,
+				 G_TYPE_INVALID);
+	g_object_unref (bus_proxy);
+	
+	if (!res) {
+		if (err) {
+			g_set_error (error,
+				     CPUFREQ_SELECTOR_SERVICE_ERROR,
+				     SERVICE_ERROR_DBUS,
+				     "Failed to acquire %s: %s",
+				     BUS_NAME, err->message);
+			g_error_free (err);
+		} else {
+			g_set_error (error,
+				     CPUFREQ_SELECTOR_SERVICE_ERROR,
+				     SERVICE_ERROR_DBUS,
+				     "Failed to acquire %s", BUS_NAME);
+		}
+
+		return FALSE;
+	}
+
+	if (result == DBUS_REQUEST_NAME_REPLY_EXISTS) {
+		g_set_error (error,
+			     CPUFREQ_SELECTOR_SERVICE_ERROR,
+			     SERVICE_ERROR_ALREADY_REGISTERED,
+			     "Service %s already registered", BUS_NAME);
+		return FALSE;
+	}
+
+	service->authority = polkit_authority_get ();
+
+	service->system_bus = connection;
+
+	dbus_g_object_type_install_info (CPUFREQ_TYPE_SELECTOR_SERVICE,
+					 &dbus_glib_cpufreq_selector_service_object_info);
+	dbus_g_connection_register_g_object (connection,
+					     "/org/mate/cpufreq_selector/selector",
+					     G_OBJECT (service));
+	dbus_g_error_domain_register (CPUFREQ_SELECTOR_SERVICE_ERROR, NULL,
+				      CPUFREQ_TYPE_SELECTOR_SERVICE_ERROR);
+
+	reset_killtimer ();
+
+	return TRUE;
+}
+
+static CPUFreqSelector *
+get_selector_for_cpu (CPUFreqSelectorService *service,
+		      guint                   cpu)
+{
+	if (!service->selectors[cpu]) {
+		service->selectors[cpu] = cpufreq_selector_factory_create_selector (cpu);
+		if (!service->selectors[cpu])
+			return NULL;
+		
+		if (service->selectors_max < cpu)
+			service->selectors_max = cpu;
+	}
+	
+	return service->selectors[cpu];
+}
+
+/* PolicyKit */
+static gboolean
+cpufreq_selector_service_check_policy (CPUFreqSelectorService *service,
+				       DBusGMethodInvocation  *context,
+				       GError                **error)
+{
+	PolkitSubject             *subject;
+	PolkitAuthorizationResult *result;
+	gchar                     *sender;
+	gboolean                   ret;
+
+	sender = dbus_g_method_get_sender (context);
+	subject = polkit_system_bus_name_new (sender);
+	g_free (sender);
+
+	result = polkit_authority_check_authorization_sync (service->authority,
+                                                            subject,
+                                                            "org.mate.cpufreqselector",
+                                                            NULL,
+                                                            POLKIT_CHECK_AUTHORIZATION_FLAGS_ALLOW_USER_INTERACTION,
+                                                            NULL, error);
+        g_object_unref (subject);
+
+        if (*error) {
+		g_warning ("Check policy: %s", (*error)->message);
+		g_object_unref (result);
+
+		return FALSE;
+	}
+
+	ret = polkit_authorization_result_get_is_authorized (result);
+	if (!ret) {
+		g_set_error (error,
+			     CPUFREQ_SELECTOR_SERVICE_ERROR,
+			     SERVICE_ERROR_NOT_AUTHORIZED,
+			     "Caller is not authorized");
+	}
+
+	g_object_unref (result);
+
+	return ret;
+}
+
+/* D-BUS interface */
+gboolean
+cpufreq_selector_service_set_frequency (CPUFreqSelectorService *service,
+					guint                   cpu,
+					guint                   frequency,
+					DBusGMethodInvocation  *context)
+{
+	CPUFreqSelector *selector;
+	GError          *error = NULL;
+
+	reset_killtimer ();
+
+	if (!cpufreq_selector_service_check_policy (service, context, &error)) {
+		dbus_g_method_return_error (context, error);
+		g_error_free (error);
+
+		return FALSE;
+	}
+
+	if (cpu > MAX_CPUS) {
+		GError *err;
+		
+		err = g_error_new (CPUFREQ_SELECTOR_SERVICE_ERROR,
+				   SERVICE_ERROR_DBUS,
+				   "Error setting frequency on cpu %d: Invalid cpu",
+				   cpu);
+		dbus_g_method_return_error (context, err);
+		g_error_free (err);
+
+		return FALSE;
+	}
+
+	selector = get_selector_for_cpu (service, cpu);
+	if (!selector) {
+		GError *err;
+
+		err = g_error_new (CPUFREQ_SELECTOR_SERVICE_ERROR,
+				   SERVICE_ERROR_DBUS,
+				   "Error setting frequency on cpu %d: No cpufreq support",
+				   cpu);
+		dbus_g_method_return_error (context, err);
+		g_error_free (err);
+
+		return FALSE;
+	}
+
+	cpufreq_selector_set_frequency (selector, frequency, &error);
+	if (error) {
+		GError *err;
+
+		err = g_error_new (CPUFREQ_SELECTOR_SERVICE_ERROR,
+				   SERVICE_ERROR_DBUS,
+				   "Error setting frequency %d on cpu %d: %s",
+				   frequency, cpu, error->message);
+		dbus_g_method_return_error (context, err);
+		g_error_free (err);
+		g_error_free (error);
+
+		return FALSE;
+	}
+	
+	dbus_g_method_return (context);
+	
+	return TRUE;
+}
+
+gboolean
+cpufreq_selector_service_set_governor (CPUFreqSelectorService *service,
+				       guint                   cpu,
+				       const gchar            *governor,
+				       DBusGMethodInvocation  *context)
+{
+	CPUFreqSelector *selector;
+	GError          *error = NULL;
+
+	reset_killtimer ();
+
+	if (!cpufreq_selector_service_check_policy (service, context, &error)) {
+		dbus_g_method_return_error (context, error);
+		g_error_free (error);
+
+		return FALSE;
+	}
+	
+	if (cpu > MAX_CPUS) {
+		GError *err;
+
+		err = g_error_new (CPUFREQ_SELECTOR_SERVICE_ERROR,
+				   SERVICE_ERROR_DBUS,
+				   "Error setting governor on cpu %d: Invalid cpu",
+				   cpu);
+		dbus_g_method_return_error (context, err);
+		g_error_free (err);
+
+		return FALSE;
+	}
+
+	selector = get_selector_for_cpu (service, cpu);
+	if (!selector) {
+		GError *err;
+
+		err = g_error_new (CPUFREQ_SELECTOR_SERVICE_ERROR,
+				   SERVICE_ERROR_DBUS,
+				   "Error setting governor on cpu %d: No cpufreq support",
+				   cpu);
+		dbus_g_method_return_error (context, err);
+		g_error_free (err);
+
+		return FALSE;
+	}
+
+	cpufreq_selector_set_governor (selector, governor, &error);
+	if (error) {
+		GError *err;
+
+		err = g_error_new (CPUFREQ_SELECTOR_SERVICE_ERROR,
+				   SERVICE_ERROR_DBUS,
+				   "Error setting governor %s on cpu %d: %s",
+				   governor, cpu, error->message);
+		dbus_g_method_return_error (context, err);
+		g_error_free (err);
+		g_error_free (error);
+
+		return FALSE;
+	}
+
+	dbus_g_method_return (context);
+	
+	return TRUE;
+}
+
+
+gboolean
+cpufreq_selector_service_can_set (CPUFreqSelectorService *service,
+				  DBusGMethodInvocation  *context)
+{
+	PolkitSubject             *subject;
+	PolkitAuthorizationResult *result;
+	gchar                     *sender;
+	gboolean                   ret;
+        GError                    *error = NULL;
+
+	reset_killtimer ();
+
+	sender = dbus_g_method_get_sender (context);
+	subject = polkit_system_bus_name_new (sender);
+	g_free (sender);
+
+	result = polkit_authority_check_authorization_sync (service->authority,
+                                                            subject,
+                                                            "org.mate.cpufreqselector",
+                                                            NULL,
+                                                            0,
+                                                            NULL,
+							    &error);
+        g_object_unref (subject);
+
+	if (error) {
+		dbus_g_method_return_error (context, error);
+		g_error_free (error);
+
+		return FALSE;
+	}
+
+        if (polkit_authorization_result_get_is_authorized (result)) {
+		ret = TRUE;
+	} else if (polkit_authorization_result_get_is_challenge (result)) {
+		ret = TRUE;
+	} else {
+		ret = FALSE;
+	}
+
+	g_object_unref (result);
+
+        dbus_g_method_return (context, ret);
+
+	return TRUE;
+}
diff --git a/cpufreq/src/cpufreq-selector/cpufreq-selector-service.h b/cpufreq/src/cpufreq-selector/cpufreq-selector-service.h
new file mode 100644
index 00000000..a6bcc77b
--- /dev/null
+++ b/cpufreq/src/cpufreq-selector/cpufreq-selector-service.h
@@ -0,0 +1,71 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2008 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef __CPUFREQ_SELECTOR_SERVICE_H__
+#define __CPUFREQ_SELECTOR_SERVICE_H__
+
+#include <glib-object.h>
+#include <dbus/dbus-glib.h>
+
+G_BEGIN_DECLS
+
+#define CPUFREQ_TYPE_SELECTOR_SERVICE            (cpufreq_selector_service_get_type ())
+#define CPUFREQ_SELECTOR_SERVICE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), CPUFREQ_TYPE_SELECTOR_SERVICE, CPUFreqSelectorService))
+#define CPUFREQ_SELECTOR_SERVICE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), CPUFREQ_TYPE_SELECTOR_SERVICE, CPUFreqSelectorServiceClass))
+#define CPUFREQ_IS_SELECTOR_SERVICE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CPUFREQ_TYPE_SELECTOR_SERVICE))
+#define CPUFREQ_IS_SELECTOR_SERVICE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CPUFREQ_TYPE_SELECTOR_SERVICE))
+#define CPUFREQ_SELECTOR_SERVICE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), CPUFREQ_TYPE_SELECTOR_SERVICE, CPUFreqSelectorServiceClass))
+
+#define SELECTOR_SERVICE                         (cpufreq_selector_service_get_instance ())
+
+#define CPUFREQ_SELECTOR_SERVICE_ERROR           (cpufreq_selector_service_error_quark ())
+#define CPUFREQ_TYPE_SELECTOR_SERVICE_ERROR      (cpufreq_selector_service_error_get_type ())
+
+enum {
+	SERVICE_ERROR_GENERAL,
+	SERVICE_ERROR_DBUS,
+	SERVICE_ERROR_ALREADY_REGISTERED,
+	SERVICE_ERROR_NOT_AUTHORIZED
+};
+
+typedef struct _CPUFreqSelectorService        CPUFreqSelectorService;
+typedef struct _CPUFreqSelectorServiceClass   CPUFreqSelectorServiceClass;
+
+GType                   cpufreq_selector_service_get_type       (void) G_GNUC_CONST;
+GType                   cpufreq_selector_service_error_get_type (void) G_GNUC_CONST;
+GQuark                  cpufreq_selector_service_error_quark    (void) G_GNUC_CONST;
+CPUFreqSelectorService *cpufreq_selector_service_get_instance   (void);
+gboolean                cpufreq_selector_service_register       (CPUFreqSelectorService *service,
+								 GError                **error);
+
+gboolean                cpufreq_selector_service_set_frequency  (CPUFreqSelectorService *service,
+								 guint                   cpu,
+								 guint                   frequency,
+								 DBusGMethodInvocation  *context);
+gboolean                cpufreq_selector_service_set_governor   (CPUFreqSelectorService *service,
+								 guint                   cpu,
+								 const gchar            *governor,
+								 DBusGMethodInvocation  *context);
+gboolean               cpufreq_selector_service_can_set         (CPUFreqSelectorService *service,
+								 DBusGMethodInvocation  *context);
+
+G_END_DECLS
+
+#endif /* __CPUFREQ_SELECTOR_SERVICE_H__ */
+
diff --git a/cpufreq/src/cpufreq-selector/cpufreq-selector-service.xml b/cpufreq/src/cpufreq-selector/cpufreq-selector-service.xml
new file mode 100644
index 00000000..798dd5b2
--- /dev/null
+++ b/cpufreq/src/cpufreq-selector/cpufreq-selector-service.xml
@@ -0,0 +1,23 @@
+<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN" "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
+
+<node name="/org/mate/CPUFreqSelector">
+  <interface name="org.mate.CPUFreqSelector">
+    <method name="SetFrequency">
+      <annotation name="org.freedesktop.DBus.GLib.Async" value=""/>
+      <arg name="cpu" direction="in" type="u"/>
+      <arg name="frequency" direction="in" type="u"/>
+    </method>
+
+    <method name="SetGovernor">
+      <annotation name="org.freedesktop.DBus.GLib.Async" value=""/>
+      <arg name="cpu" direction="in" type="u"/>
+      <arg name="governor" direction="in" type="s"/>
+    </method>
+
+    <method name="CanSet">
+      <annotation name="org.freedesktop.DBus.GLib.Async" value=""/>
+      <arg name="result" direction="out" type="b"/>
+    </method>
+
+  </interface>
+</node>
diff --git a/cpufreq/src/cpufreq-selector/cpufreq-selector-sysfs.c b/cpufreq/src/cpufreq-selector/cpufreq-selector-sysfs.c
new file mode 100644
index 00000000..ae790caf
--- /dev/null
+++ b/cpufreq/src/cpufreq-selector/cpufreq-selector-sysfs.c
@@ -0,0 +1,430 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2004 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Authors : Carlos Garc�a Campos <[email protected]>
+ */
+
+#include <glib.h>
+#include <glib/gstdio.h>
+#include <stdlib.h>
+#include <errno.h>
+
+#include "cpufreq-selector-sysfs.h"
+
+#define CPUFREQ_SELECTOR_SYSFS_GET_PRIVATE(obj) \
+        (G_TYPE_INSTANCE_GET_PRIVATE((obj), CPUFREQ_TYPE_SELECTOR_SYSFS, CPUFreqSelectorSysfsPrivate))
+
+struct _CPUFreqSelectorSysfsPrivate {
+	GList *available_freqs;
+	GList *available_govs;
+};
+
+static void     cpufreq_selector_sysfs_init          (CPUFreqSelectorSysfs      *selector);
+static void     cpufreq_selector_sysfs_class_init    (CPUFreqSelectorSysfsClass *klass);
+static void     cpufreq_selector_sysfs_finalize      (GObject                   *object);
+
+static gboolean cpufreq_selector_sysfs_set_frequency (CPUFreqSelector           *selector,
+						      guint                      frequency,
+						      GError                   **error);
+static gboolean cpufreq_selector_sysfs_set_governor  (CPUFreqSelector           *selector,
+						      const gchar               *governor,
+						      GError                   **error);
+
+#define CPUFREQ_SYSFS_BASE_PATH "/sys/devices/system/cpu/cpu%u/cpufreq/%s"
+
+G_DEFINE_TYPE (CPUFreqSelectorSysfs, cpufreq_selector_sysfs, CPUFREQ_TYPE_SELECTOR)
+
+static void
+cpufreq_selector_sysfs_init (CPUFreqSelectorSysfs *selector)
+{
+	selector->priv = CPUFREQ_SELECTOR_SYSFS_GET_PRIVATE (selector);
+
+	selector->priv->available_freqs = NULL;
+	selector->priv->available_govs = NULL;
+}
+
+static void
+cpufreq_selector_sysfs_class_init (CPUFreqSelectorSysfsClass *klass)
+{
+        GObjectClass         *object_class = G_OBJECT_CLASS (klass);
+        CPUFreqSelectorClass *selector_class = CPUFREQ_SELECTOR_CLASS (klass);
+
+        g_type_class_add_private (klass, sizeof (CPUFreqSelectorSysfsPrivate));
+
+	selector_class->set_frequency = cpufreq_selector_sysfs_set_frequency;
+        selector_class->set_governor = cpufreq_selector_sysfs_set_governor;
+
+        object_class->finalize = cpufreq_selector_sysfs_finalize;
+}
+
+static void
+cpufreq_selector_sysfs_finalize (GObject *object)
+{
+        CPUFreqSelectorSysfs *selector = CPUFREQ_SELECTOR_SYSFS (object);
+
+        if (selector->priv->available_freqs) {
+                g_list_foreach (selector->priv->available_freqs,
+                                (GFunc) g_free,
+				NULL);
+                g_list_free (selector->priv->available_freqs);
+                selector->priv->available_freqs = NULL;
+	}
+           
+        if (selector->priv->available_govs) {
+                g_list_foreach (selector->priv->available_govs,
+                                (GFunc) g_free,
+				NULL);
+                g_list_free (selector->priv->available_govs);
+                selector->priv->available_govs = NULL;
+	}
+
+	G_OBJECT_CLASS (cpufreq_selector_sysfs_parent_class)->finalize (object);
+}
+
+CPUFreqSelector *
+cpufreq_selector_sysfs_new (guint cpu)
+{
+        CPUFreqSelector *selector;
+
+        selector = CPUFREQ_SELECTOR (g_object_new (CPUFREQ_TYPE_SELECTOR_SYSFS,
+						   "cpu", cpu, 
+						   NULL));
+
+        return selector;
+}
+
+static gchar *
+cpufreq_sysfs_read (const gchar *path,
+		    GError     **error)
+{
+	gchar  *buffer = NULL;
+
+	if (!g_file_get_contents (path, &buffer, NULL, error)) {
+		return NULL;
+	}
+
+	return g_strchomp (buffer);
+}
+
+static gboolean
+cpufreq_sysfs_write (const gchar *path,
+		     const gchar *setting,
+		     GError     **error)
+{
+	FILE *fd;
+
+	fd = g_fopen (path, "w");
+
+	if (!fd) {
+		g_set_error (error,
+			     G_FILE_ERROR,
+			     g_file_error_from_errno (errno),
+			     "Failed to open '%s' for writing: "
+			     "g_fopen() failed: %s",
+			     path,
+			     g_strerror (errno));
+
+		return FALSE;
+	}
+
+	if (g_fprintf (fd, "%s", setting) < 0) {
+		g_set_error (error,
+			     G_FILE_ERROR,
+			     g_file_error_from_errno (errno),
+			     "Failed to write '%s': "
+			     "g_fprintf() failed: %s",
+			     path,
+			     g_strerror (errno));
+
+		fclose (fd);
+
+		return FALSE;
+	}
+
+	fclose (fd);
+
+	return TRUE;
+}
+
+static gint
+compare (gconstpointer a, gconstpointer b)
+{
+        gint aa, bb;
+	
+        aa = atoi ((gchar *) a);
+        bb = atoi ((gchar *) b);
+	
+        if (aa == bb)
+                return 0;
+        else if (aa > bb)
+                return -1;
+        else
+                return 1;
+}
+
+static GList *
+cpufreq_selector_sysfs_get_freqs (CPUFreqSelectorSysfs *selector)
+{
+        gchar  *buffer;
+        GList  *list = NULL;
+        gchar **frequencies = NULL;
+        gint    i;
+        gchar  *path;
+	guint   cpu;
+	GError *error = NULL;
+
+	g_object_get (G_OBJECT (selector),
+		      "cpu", &cpu,
+		      NULL);
+	
+        path = g_strdup_printf (CPUFREQ_SYSFS_BASE_PATH, cpu, 
+				"scaling_available_frequencies");
+
+	buffer = cpufreq_sysfs_read (path, &error);
+	if (!buffer) {
+		g_warning ("%s", error->message);
+		g_error_free (error);
+
+		g_free (path);
+
+		return NULL;
+	}
+
+	g_free (path);
+
+	frequencies = g_strsplit (buffer, " ", -1);
+
+	i = 0;
+	while (frequencies[i]) {
+		if (!g_list_find_custom (list, frequencies[i], compare))
+			list = g_list_prepend (list, g_strdup (frequencies[i]));
+		i++;
+	}
+
+	g_strfreev (frequencies);
+	g_free (buffer);
+
+	return g_list_sort (list, compare);
+}
+
+static const gchar *
+cpufreq_selector_sysfs_get_valid_frequency (CPUFreqSelectorSysfs *selector,
+					    guint                 frequency)
+{
+	GList       *list = NULL;
+	GList       *l;
+	gint         dist = G_MAXINT;
+	const gchar *retval = NULL;
+	
+	if (!selector->priv->available_freqs) {
+		list = cpufreq_selector_sysfs_get_freqs (selector);
+		selector->priv->available_freqs = list;
+	} else {
+		list = selector->priv->available_freqs;
+	}
+
+	if (!list)
+		return NULL;
+
+	for (l = list; l && l->data; l = g_list_next (l)) {
+		const gchar *freq;
+		guint        f;
+		guint        current_dist;
+
+		freq = (const gchar *) l->data;
+		f = atoi (freq);
+
+		if (f == frequency)
+			return freq;
+
+		current_dist = abs (frequency - f);
+		if (current_dist < dist) {
+			dist = current_dist;
+			retval = freq;
+		}
+	}
+
+	return retval;
+}
+
+static gboolean
+cpufreq_selector_sysfs_set_frequency (CPUFreqSelector *selector,
+				      guint            frequency,
+				      GError         **error)
+{
+	gchar       *governor;
+	gchar       *path;
+	const gchar *frequency_text;
+	guint        cpu;
+
+	g_object_get (G_OBJECT (selector),
+		      "cpu", &cpu,
+		      NULL);
+	
+	path = g_strdup_printf (CPUFREQ_SYSFS_BASE_PATH, cpu,
+				"scaling_governor");
+	
+	governor = cpufreq_sysfs_read (path, error);
+	g_free (path);
+	
+	if (!governor)
+		return FALSE;
+
+	if (g_ascii_strcasecmp (governor, "userspace") != 0) {
+		if (!cpufreq_selector_sysfs_set_governor (selector,
+							  "userspace",
+							  error)) {
+			g_free (governor);
+
+			return FALSE;
+		}
+	}
+
+	g_free (governor);
+
+	frequency_text =
+		cpufreq_selector_sysfs_get_valid_frequency (CPUFREQ_SELECTOR_SYSFS (selector),
+							    frequency);
+	if (!frequency_text) {
+		g_set_error (error,
+			     CPUFREQ_SELECTOR_ERROR,
+			     SELECTOR_ERROR_SET_FREQUENCY,
+			     "Cannot set frequency '%d'",
+			     frequency);
+
+		return FALSE;
+	}
+
+	path = g_strdup_printf (CPUFREQ_SYSFS_BASE_PATH, cpu,
+				"scaling_setspeed");
+	if (!cpufreq_sysfs_write (path, frequency_text, error)) {
+		g_free (path);
+		
+		return FALSE;
+	}
+	
+	g_free (path);
+	
+	return TRUE;
+}
+
+static GList *
+cpufreq_selector_sysfs_get_govs (CPUFreqSelectorSysfs *selector)
+{
+	gchar  *buffer;
+	GList  *list = NULL;
+	gchar **governors = NULL;
+	gint    i;
+	gchar  *path;
+	guint   cpu;
+	GError *error = NULL;
+
+	g_object_get (G_OBJECT (selector),
+		      "cpu", &cpu,
+		      NULL);
+
+	path = g_strdup_printf (CPUFREQ_SYSFS_BASE_PATH, cpu, 
+				"scaling_available_governors");
+
+	buffer = cpufreq_sysfs_read (path, &error);
+	if (!buffer) {
+		g_warning ("%s", error->message);
+		g_error_free (error);
+
+		g_free (path);
+
+		return NULL;
+	}
+
+	g_free (path);
+
+	governors = g_strsplit (buffer, " ", -1);
+
+	i = 0;
+	while (governors[i]) {
+		list = g_list_prepend (list, g_strdup (governors[i]));
+		i++;
+	}
+
+	g_strfreev (governors);
+	g_free (buffer);
+	
+	return list;
+}
+
+static gboolean
+cpufreq_selector_sysfs_validate_governor (CPUFreqSelectorSysfs *selector,
+					  const gchar          *governor)
+{
+	GList *list = NULL;
+	
+	if (!selector->priv->available_govs) {
+		list = cpufreq_selector_sysfs_get_govs (selector);
+		selector->priv->available_govs = list;
+	} else {
+		list = selector->priv->available_govs;
+	}
+
+	if (!list)
+		return FALSE;
+	
+	list = g_list_find_custom (selector->priv->available_govs,
+				   governor,
+				   (GCompareFunc) g_ascii_strcasecmp);
+	
+	return (list != NULL);
+}
+
+static gboolean
+cpufreq_selector_sysfs_set_governor (CPUFreqSelector *selector,
+				     const gchar     *governor,
+				     GError         **error)
+{
+	CPUFreqSelectorSysfs *selector_sysfs;
+        gchar                *path;
+	guint                 cpu;
+
+	selector_sysfs = CPUFREQ_SELECTOR_SYSFS (selector);
+
+	if (!cpufreq_selector_sysfs_validate_governor (selector_sysfs, governor)) {
+		g_set_error (error,
+			     CPUFREQ_SELECTOR_ERROR,
+			     SELECTOR_ERROR_INVALID_GOVERNOR,
+			     "Invalid governor '%s'",
+			     governor);
+		
+		return FALSE;
+	}
+	
+	g_object_get (G_OBJECT (selector),
+		      "cpu", &cpu,
+		      NULL);
+
+        path = g_strdup_printf (CPUFREQ_SYSFS_BASE_PATH, cpu,
+				"scaling_governor");
+
+	if (!cpufreq_sysfs_write (path, governor, error)) {
+		g_free (path);
+		
+		return FALSE;
+	}
+
+        g_free (path);
+
+	return TRUE;
+}
diff --git a/cpufreq/src/cpufreq-selector/cpufreq-selector-sysfs.h b/cpufreq/src/cpufreq-selector/cpufreq-selector-sysfs.h
new file mode 100644
index 00000000..a2608bbc
--- /dev/null
+++ b/cpufreq/src/cpufreq-selector/cpufreq-selector-sysfs.h
@@ -0,0 +1,58 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2004 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Authors : Carlos Garc�a Campos <[email protected]>
+ */
+
+#ifndef __CPUFREQ_SELECTOR_SYSFS_H__
+#define __CPUFREQ_SELECTOR_SYSFS_H__
+
+#include <glib-object.h>
+
+#include "cpufreq-selector.h"
+
+G_BEGIN_DECLS
+
+#define CPUFREQ_TYPE_SELECTOR_SYSFS            (cpufreq_selector_sysfs_get_type ())
+#define CPUFREQ_SELECTOR_SYSFS(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), CPUFREQ_TYPE_SELECTOR_SYSFS, CPUFreqSelectorSysfs))
+#define CPUFREQ_SELECTOR_SYSFS_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), CPUFREQ_TYPE_SELECTOR_SYSFS, CPUFreqSelectorSysfsClass))
+#define CPUFREQ_IS_SELECTOR_SYSFS(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CPUFREQ_TYPE_SELECTOR_SYSFS))
+#define CPUFREQ_IS_SELECTOR_SYSFS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CPUFREQ_TYPE_SELECTOR_SYSFS))
+#define CPUFREQ_SELECTOR_SYSFS_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), CPUFREQ_TYPE_SELECTOR_SYSFS, CPUFreqSelectorSysfsClass))
+
+typedef struct _CPUFreqSelectorSysfs        CPUFreqSelectorSysfs;
+typedef struct _CPUFreqSelectorSysfsClass   CPUFreqSelectorSysfsClass;
+typedef struct _CPUFreqSelectorSysfsPrivate CPUFreqSelectorSysfsPrivate;
+
+struct _CPUFreqSelectorSysfs {
+        CPUFreqSelector parent;
+
+	CPUFreqSelectorSysfsPrivate *priv;
+};
+
+struct _CPUFreqSelectorSysfsClass {
+        CPUFreqSelectorClass parent_class;
+};
+
+
+GType            cpufreq_selector_sysfs_get_type (void) G_GNUC_CONST;
+CPUFreqSelector *cpufreq_selector_sysfs_new      (guint cpu);
+
+G_END_DECLS
+
+#endif /* __CPUFREQ_SELECTOR_SYSFS_H__ */
diff --git a/cpufreq/src/cpufreq-selector/cpufreq-selector.c b/cpufreq/src/cpufreq-selector/cpufreq-selector.c
new file mode 100644
index 00000000..f019fec3
--- /dev/null
+++ b/cpufreq/src/cpufreq-selector/cpufreq-selector.c
@@ -0,0 +1,173 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2004 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Authors : Carlos Garc�a Campos <[email protected]>
+ */
+
+#include <glib.h>
+#include "cpufreq-selector.h"
+
+#define CPUFREQ_SELECTOR_GET_PRIVATE(obj) \
+        (G_TYPE_INSTANCE_GET_PRIVATE((obj), CPUFREQ_TYPE_SELECTOR, CPUFreqSelectorPrivate))
+
+enum {
+	PROP_0,
+	PROP_CPU
+};
+
+struct _CPUFreqSelectorPrivate {
+	guint  cpu;
+};
+
+static void cpufreq_selector_init         (CPUFreqSelector      *selector);
+static void cpufreq_selector_class_init   (CPUFreqSelectorClass *klass);
+
+static void cpufreq_selector_set_property (GObject              *object,
+					   guint                 prop_id,
+					   const GValue         *value,
+					   GParamSpec           *spec);
+static void cpufreq_selector_get_property (GObject              *object,
+					   guint                 prop_id,
+					   GValue               *value,
+					   GParamSpec           *spec);
+
+G_DEFINE_ABSTRACT_TYPE (CPUFreqSelector, cpufreq_selector, G_TYPE_OBJECT)
+
+GQuark
+cpufreq_selector_error_quark (void)
+{
+	static GQuark error_quark = 0;
+
+	if (error_quark == 0)
+		error_quark =
+			g_quark_from_static_string ("cpufreq-selector-error-quark");
+
+	return error_quark;
+}
+
+static void
+cpufreq_selector_init (CPUFreqSelector *selector)
+{
+
+	selector->priv = CPUFREQ_SELECTOR_GET_PRIVATE (selector);
+
+        selector->priv->cpu = 0;
+}
+
+static void
+cpufreq_selector_class_init (CPUFreqSelectorClass *klass)
+{
+        GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+        g_type_class_add_private (klass, sizeof (CPUFreqSelectorPrivate));
+
+        object_class->set_property = cpufreq_selector_set_property;
+        object_class->get_property = cpufreq_selector_get_property;
+
+	/* Public virtual methods */
+	klass->set_frequency = NULL;
+	klass->set_governor = NULL;
+
+	/* Porperties */
+        g_object_class_install_property (object_class,
+					 PROP_CPU,
+                                         g_param_spec_uint ("cpu",
+							    NULL,
+							    NULL,
+                                                            0,
+							    G_MAXUINT,
+							    0,
+							    G_PARAM_CONSTRUCT_ONLY |
+                                                            G_PARAM_READWRITE));
+}
+
+static void
+cpufreq_selector_set_property (GObject      *object,
+			       guint         prop_id,
+			       const GValue *value,
+			       GParamSpec   *spec)
+{
+	CPUFreqSelector *selector = CPUFREQ_SELECTOR (object);
+
+        switch (prop_id) {
+        case PROP_CPU:
+                selector->priv->cpu = g_value_get_uint (value);
+                break;
+        default:
+                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, spec);
+		break;
+        }
+}
+
+static void
+cpufreq_selector_get_property (GObject    *object,
+			       guint       prop_id,
+			       GValue     *value,
+			       GParamSpec *spec)
+{
+	CPUFreqSelector *selector = CPUFREQ_SELECTOR (object);
+
+        switch (prop_id) {
+        case PROP_CPU:
+                g_value_set_uint (value, selector->priv->cpu);
+                break;
+        default:
+                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, spec);
+		break;
+        }
+}
+
+gboolean
+cpufreq_selector_set_frequency (CPUFreqSelector *selector,
+				guint            frequency,
+				GError         **error)
+{
+	CPUFreqSelectorClass *class;
+	
+	g_return_val_if_fail (CPUFREQ_IS_SELECTOR (selector), FALSE);
+	g_return_val_if_fail (frequency > 0, FALSE);
+
+	class = CPUFREQ_SELECTOR_GET_CLASS (selector);
+	
+	if (class->set_frequency) {
+		return class->set_frequency (selector, frequency, error);
+	}
+
+	return FALSE;
+}
+
+gboolean
+cpufreq_selector_set_governor (CPUFreqSelector *selector,
+			       const gchar     *governor,
+			       GError         **error)
+{
+	CPUFreqSelectorClass *class;
+	
+        g_return_val_if_fail (CPUFREQ_IS_SELECTOR (selector), FALSE);
+	g_return_val_if_fail (governor != NULL, FALSE);
+
+	class = CPUFREQ_SELECTOR_GET_CLASS (selector);
+	
+        if (class->set_governor) {
+                return class->set_governor (selector, governor, error);
+        }
+
+	return FALSE;
+}
+
+
diff --git a/cpufreq/src/cpufreq-selector/cpufreq-selector.h b/cpufreq/src/cpufreq-selector/cpufreq-selector.h
new file mode 100644
index 00000000..73e41054
--- /dev/null
+++ b/cpufreq/src/cpufreq-selector/cpufreq-selector.h
@@ -0,0 +1,74 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2004 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Authors : Carlos Garc�a Campos <[email protected]>
+ */
+
+#ifndef __CPUFREQ_SELECTOR_H__
+#define __CPUFREQ_SELECTOR_H__
+
+#include <glib-object.h>
+
+#define CPUFREQ_TYPE_SELECTOR            (cpufreq_selector_get_type ())
+#define CPUFREQ_SELECTOR(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), CPUFREQ_TYPE_SELECTOR, CPUFreqSelector))
+#define CPUFREQ_SELECTOR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), CPUFREQ_TYPE_SELECTOR, CPUFreqSelectorClass))
+#define CPUFREQ_IS_SELECTOR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CPUFREQ_TYPE_SELECTOR))
+#define CPUFREQ_IS_SELECTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CPUFREQ_TYPE_SELECTOR))
+#define CPUFREQ_SELECTOR_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), CPUFREQ_TYPE_SELECTOR, CPUFreqSelectorClass))
+
+#define CPUFREQ_SELECTOR_ERROR (cpufreq_selector_error_quark ())
+
+enum {
+	SELECTOR_ERROR_INVALID_CPU,
+	SELECTOR_ERROR_INVALID_GOVERNOR,
+	SELECTOR_ERROR_SET_FREQUENCY
+};
+
+typedef struct _CPUFreqSelector        CPUFreqSelector;
+typedef struct _CPUFreqSelectorClass   CPUFreqSelectorClass;
+typedef struct _CPUFreqSelectorPrivate CPUFreqSelectorPrivate;
+
+struct _CPUFreqSelector {
+        GObject parent;
+
+	CPUFreqSelectorPrivate *priv;
+};
+
+struct _CPUFreqSelectorClass {
+        GObjectClass parent_class;
+
+	gboolean  (* set_frequency) (CPUFreqSelector *selector,
+				     guint            frequency,
+				     GError         **error);
+        gboolean  (* set_governor)  (CPUFreqSelector *selector,
+				     const gchar     *governor,
+				     GError         **error);
+};
+
+
+GType    cpufreq_selector_get_type      (void) G_GNUC_CONST;
+GQuark   cpufreq_selector_error_quark   (void) G_GNUC_CONST;
+
+gboolean cpufreq_selector_set_frequency (CPUFreqSelector *selector,
+					 guint            frequency,
+					 GError         **error);
+gboolean cpufreq_selector_set_governor  (CPUFreqSelector *selector,
+					 const gchar     *governor,
+					 GError         **error);
+
+#endif /* __CPUFREQ_SELECTOR_H__ */
diff --git a/cpufreq/src/cpufreq-selector/main.c b/cpufreq/src/cpufreq-selector/main.c
new file mode 100644
index 00000000..f0fbb7b1
--- /dev/null
+++ b/cpufreq/src/cpufreq-selector/main.c
@@ -0,0 +1,233 @@
+/*
+ * MATE CPUFreq Applet
+ * Copyright (C) 2004 Carlos Garcia Campos <[email protected]>
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public
+ *  License along with this library; if not, write to the Free
+ *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Authors : Carlos Garc�a Campos <[email protected]>
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <glib.h>
+#include <glib-object.h>
+
+#ifdef HAVE_POLKIT
+#include "cpufreq-selector-service.h"
+#endif
+#include "cpufreq-selector-factory.h"
+
+
+static gint    cpu = 0;
+static gchar  *governor = NULL;
+static gulong  frequency = 0;
+
+static const GOptionEntry options[] = {
+	{ "cpu",       'c', 0, G_OPTION_ARG_INT,    &cpu,       "CPU Number",       NULL },
+	{ "governor",  'g', 0, G_OPTION_ARG_STRING, &governor,  "Governor",         NULL },
+	{ "frequency", 'f', 0, G_OPTION_ARG_INT,    &frequency, "Frequency in KHz", NULL },
+	{ NULL }
+};
+
+#ifdef HAVE_POLKIT
+static void
+do_exit (GMainLoop *loop,
+	 GObject   *object)
+{
+	if (g_main_loop_is_running (loop))
+		g_main_loop_quit (loop);
+}
+
+static void
+cpufreq_selector_set_values_dbus (void)
+{
+	DBusGConnection *connection;
+	DBusGProxy      *proxy;
+	gboolean         res;
+	GError          *error = NULL;
+
+	connection = dbus_g_bus_get (DBUS_BUS_SYSTEM, &error);
+	if (!connection) {
+		g_printerr ("Couldn't connect to system bus: %s\n",
+			    error->message);
+		g_error_free (error);
+
+		return;
+	}
+
+	proxy = dbus_g_proxy_new_for_name (connection,
+					   "org.mate.CPUFreqSelector",
+					   "/org/mate/cpufreq_selector/selector",
+					   "org.mate.CPUFreqSelector");
+	if (!proxy) {
+		g_printerr ("Could not construct proxy object\n");
+
+		return;
+	}
+
+	if (governor) {
+		res = dbus_g_proxy_call (proxy, "SetGovernor", &error,
+					 G_TYPE_UINT, cpu,
+					 G_TYPE_STRING, governor,
+					 G_TYPE_INVALID,
+					 G_TYPE_INVALID);
+		if (!res) {
+			if (error) {
+				g_printerr ("Error calling SetGovernor: %s\n", error->message);
+				g_error_free (error);
+			} else {
+				g_printerr ("Error calling SetGovernor\n");
+			}
+			
+			g_object_unref (proxy);
+			
+			return;
+		}
+	}
+
+	if (frequency != 0) {
+		res = dbus_g_proxy_call (proxy, "SetFrequency", &error,
+					 G_TYPE_UINT, cpu,
+					 G_TYPE_UINT, frequency,
+					 G_TYPE_INVALID,
+					 G_TYPE_INVALID);
+		if (!res) {
+			if (error) {
+				g_printerr ("Error calling SetFrequency: %s\n", error->message);
+				g_error_free (error);
+			} else {
+				g_printerr ("Error calling SetFrequency\n");
+			}
+			
+			g_object_unref (proxy);
+			
+			return;
+		}
+	}
+
+	g_object_unref (proxy);
+}
+#endif /* HAVE_POLKIT */
+
+static void
+cpufreq_selector_set_values (void)
+{
+	CPUFreqSelector *selector;
+	GError          *error = NULL;
+
+	selector = cpufreq_selector_factory_create_selector (cpu);
+	if (!selector) {
+		g_printerr ("No cpufreq support\n");
+
+		return;
+	}
+
+	if (governor) {
+		cpufreq_selector_set_governor (selector, governor, &error);
+
+		if (error) {
+			g_printerr ("%s\n", error->message);
+			g_error_free (error);
+			error = NULL;
+		}
+	}
+
+	if (frequency != 0) {
+		cpufreq_selector_set_frequency (selector, frequency, &error);
+
+		if (error) {
+			g_printerr ("%s\n", error->message);
+			g_error_free (error);
+			error = NULL;
+		}
+	}
+
+	g_object_unref (selector);
+}
+
+gint
+main (gint argc, gchar **argv)
+{
+#ifdef HAVE_POLKIT
+	GMainLoop      *loop;
+#endif
+        GOptionContext *context;
+	GError         *error = NULL;
+
+#ifndef HAVE_POLKIT
+	if (geteuid () != 0) {
+		g_printerr ("You must be root\n");
+
+		return 1;
+	}
+	
+	if (argc < 2) {
+		g_printerr ("Missing operand after `cpufreq-selector'\n");
+		g_printerr ("Try `cpufreq-selector --help' for more information.\n");
+
+		return 1;
+	}
+#endif
+	
+	g_type_init ();
+
+	context = g_option_context_new ("- CPUFreq Selector");
+	g_option_context_add_main_entries (context, options, NULL);
+	
+	if (!g_option_context_parse (context, &argc, &argv, &error)) {
+		if (error) {
+			g_printerr ("%s\n", error->message);
+			g_error_free (error);
+		} 
+
+		g_option_context_free (context);
+		
+		return 1;
+	}
+	
+	g_option_context_free (context);
+	
+#ifdef HAVE_POLKIT
+	if (!cpufreq_selector_service_register (SELECTOR_SERVICE, &error)) {
+		if (governor || frequency != 0) {
+			cpufreq_selector_set_values_dbus ();
+
+			return 0;
+		}
+
+		g_printerr ("%s\n", error->message);
+		g_error_free (error);
+
+		return 1;
+	}
+
+	cpufreq_selector_set_values ();
+
+	loop = g_main_loop_new (NULL, FALSE);
+	g_object_weak_ref (G_OBJECT (SELECTOR_SERVICE),
+			   (GWeakNotify) do_exit,
+			   loop);
+		
+	g_main_loop_run (loop);
+
+	g_main_loop_unref (loop);
+#else /* !HAVE_POLKIT */
+	cpufreq_selector_set_values ();
+#endif /* HAVE_POLKIT */
+
+        return 0;
+}
diff --git a/cpufreq/src/cpufreq-selector/org.mate.CPUFreqSelector.conf b/cpufreq/src/cpufreq-selector/org.mate.CPUFreqSelector.conf
new file mode 100644
index 00000000..c4b27a23
--- /dev/null
+++ b/cpufreq/src/cpufreq-selector/org.mate.CPUFreqSelector.conf
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!DOCTYPE busconfig PUBLIC
+	  "-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN"
+	  "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
+
+<busconfig>
+
+  <!-- Only root can own the service -->
+  <policy user="root">
+    <allow own="org.mate.CPUFreqSelector"/>
+    <allow send_interface="org.mate.CPUFreqSelector"/>
+  </policy>
+
+  <policy context="default">
+    <allow send_interface="org.mate.CPUFreqSelector"/>
+  </policy>
+
+</busconfig>
+	  
diff --git a/cpufreq/src/cpufreq-selector/org.mate.CPUFreqSelector.service.in b/cpufreq/src/cpufreq-selector/org.mate.CPUFreqSelector.service.in
new file mode 100644
index 00000000..e402df2e
--- /dev/null
+++ b/cpufreq/src/cpufreq-selector/org.mate.CPUFreqSelector.service.in
@@ -0,0 +1,4 @@
+[D-BUS Service]
+Name=org.mate.CPUFreqSelector
+Exec=@BINDIR@/cpufreq-selector
+User=root
diff --git a/cpufreq/src/cpufreq-selector/org.mate.cpufreqselector.policy.in b/cpufreq/src/cpufreq-selector/org.mate.cpufreqselector.policy.in
new file mode 100644
index 00000000..f1249cd2
--- /dev/null
+++ b/cpufreq/src/cpufreq-selector/org.mate.cpufreqselector.policy.in
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!DOCTYPE policyconfig PUBLIC
+	  "-//freedesktop//DTD PolicyKit Policy Configuration 1.0//EN"
+	  "http://www.freedesktop.org/standards/PolicyKit/1.0/policyconfig.dtd">
+
+<policyconfig>
+
+  <vendor>The MATE Project</vendor>
+  <vendor_url>http://www.mate.org/</vendor_url>
+  <icon_name>mate-cpu-frequency-applet</icon_name>
+
+  <action id="org.mate.cpufreqselector">
+    <_description>Change CPU Frequency scaling</_description>
+    <_message>Privileges are required to change the CPU Frequency scaling.</_message>
+    <defaults>
+      <allow_inactive>no</allow_inactive>
+      <allow_active>auth_admin_keep</allow_active>
+    </defaults>
+  </action>
+
+</policyconfig>