diff --git a/configure.in b/configure.in index 064389f3d..f2ce3e7f0 100644 --- a/configure.in +++ b/configure.in @@ -212,6 +212,7 @@ src/modules/clock/Makefile src/modules/pager/Makefile src/modules/battery/Makefile src/modules/temperature/Makefile +src/modules/cpufreq/Makefile data/Makefile data/fonts/Makefile data/images/Makefile diff --git a/data/themes/Makefile.am b/data/themes/Makefile.am index 7d8606ec7..ad2b12e97 100644 --- a/data/themes/Makefile.am +++ b/data/themes/Makefile.am @@ -25,7 +25,8 @@ default_pager.edc \ default_resize.edc \ default_move.edc \ default_temperature.edc \ -default_error.edc +default_error.edc \ +default_cpufreq.edc default.edj: Makefile $(EXTRA_DIST) $(EDJE_CC) $(EDJE_FLAGS) \ diff --git a/data/themes/default.edc b/data/themes/default.edc index 70bd2afaa..40cd72b0f 100644 --- a/data/themes/default.edc +++ b/data/themes/default.edc @@ -35,5 +35,6 @@ collections { #include "default_move.edc" #include "default_temperature.edc" #include "default_error.edc" +#include "default_cpufreq.edc" } diff --git a/data/themes/default_cpufreq.edc b/data/themes/default_cpufreq.edc new file mode 100644 index 000000000..723715b33 --- /dev/null +++ b/data/themes/default_cpufreq.edc @@ -0,0 +1,421 @@ +images { + image: "e17_cpufreq_freq00.png" COMP; + image: "e17_cpufreq_freq01.png" COMP; + image: "e17_cpufreq_freq02.png" COMP; + image: "e17_cpufreq_freq03.png" COMP; + image: "e17_cpufreq_freq04.png" COMP; + image: "e17_cpufreq_freq05.png" COMP; + image: "e17_cpufreq_freq06.png" COMP; + image: "e17_cpufreq_freq07.png" COMP; + image: "e17_cpufreq_freq08.png" COMP; + image: "e17_cpufreq_freq09.png" COMP; + image: "e17_cpufreq_freq10.png" COMP; + image: "e17_cpufreq_increase1.png" COMP; + image: "e17_cpufreq_increase2.png" COMP; + image: "e17_cpufreq_decrease1.png" COMP; + image: "e17_cpufreq_decrease2.png" COMP; + image: "e17_cpufreq_cpu1.png" COMP; + image: "e17_cpufreq_cpu2.png" COMP; +} + +group { + name: "modules/cpufreq/main"; + min: 4 4; + max: 128 128; + + script { + public available_frequencies; + public available_governors; + + public message(Msg_Type:type, id, ...) { + if ((type == MSG_INT_SET) && (id == 1)) { + while (count(available_frequencies) > 0) { + remove(available_frequencies, 0); + } + for (new i = 2; i < numargs(); i++) { + append_int(available_frequencies, getarg(i)); + } + } else if ((type == MSG_STRING_SET) && (id == 2)) { + new text[100]; + + while (count(available_governors) > 0) { + remove(available_governors, 0); + } + + for (new i = 2; i < numargs(); i++) { + snprintf(text, 100, "%s", getarg(i)); + append_str(available_governors, text); + } + } else if ((type == MSG_INT_SET) && (id == 3)) { + new f = getarg(2); + new use_buttons = getarg(3); + new Float:freq, Float:min_freq, Float:max_freq; + new text[100]; + + freq = f; + min_freq = fetch_int(available_frequencies, 0); + max_freq = fetch_int(available_frequencies, + count(available_frequencies) - 1); + + freq = (freq - min_freq) / (max_freq - min_freq); + set_state(PART:"meter", "default", freq); + + if (f < 1000000) { + snprintf(text, 100, "%i Mhz", f / 1000); + } else { + snprintf(text, 100, "%i.%i Ghz", f / 1000000, + (f % 1000000) / 100000); + } + set_text(PART:"readout", text); + + if (use_buttons == 0) { + set_state(PART:"increase_button", "inactive", 0.0); + set_state(PART:"decrease_button", "inactive", 0.0); + set_state(PART:"increase", "inactive", 0.0); + set_state(PART:"decrease", "inactive", 0.0); + } else { + set_state(PART:"increase_button", "default", 0.0); + set_state(PART:"decrease_button", "default", 0.0); + set_state(PART:"increase", "default", 0.0); + set_state(PART:"decrease", "default", 0.0); + } + } else if((type == MSG_STRING) && (id == 4)) { + new text[100]; + snprintf(text, 100, "%s", getarg(2)); +/* + if (!strcmp(text, "performance") || !strcmp(text, "powersave") || + !strcmp(text, "userspace") || !strcmp(text, "ondemand")) { + set_state(PART:"governor", text, 0.0); + set_state(PART:"governorbackground", text, 0.0); + } else { + set_state(PART:"governor", "default", 0.0); + set_state(PART:"governorbackground", "default", 0.0); + } + */ + } + } + } + + parts { + part { + name: "meter"; + type: IMAGE; + + description { + state: "default" 0.0; + rel1 { + relative: 0.078125 0.0; + offset: 0 0; + } + rel2 { + relative: 0.921875 0.375; + offset: -1 -1; + } + image { + normal: "e17_cpufreq_freq00.png"; + } + } + description { + state: "default" 0.1; + inherit: "default" 0.0; + image { + normal: "e17_cpufreq_freq01.png"; + } + } + description { + state: "default" 0.2; + inherit: "default" 0.0; + image { + normal: "e17_cpufreq_freq02.png"; + } + } + description { + state: "default" 0.3; + inherit: "default" 0.0; + image { + normal: "e17_cpufreq_freq03.png"; + } + } + description { + state: "default" 0.4; + inherit: "default" 0.0; + image { + normal: "e17_cpufreq_freq04.png"; + } + } + description { + state: "default" 0.5; + inherit: "default" 0.0; + image { + normal: "e17_cpufreq_freq05.png"; + } + } + description { + state: "default" 0.6; + inherit: "default" 0.0; + image { + normal: "e17_cpufreq_freq06.png"; + } + } + description { + state: "default" 0.7; + inherit: "default" 0.0; + image { + normal: "e17_cpufreq_freq07.png"; + } + } + description { + state: "default" 0.8; + inherit: "default" 0.0; + image { + normal: "e17_cpufreq_freq08.png"; + } + } + description { + state: "default" 0.9; + inherit: "default" 0.0; + image { + normal: "e17_cpufreq_freq09.png"; + } + } + description { + state: "default" 1.00; + inherit: "default" 0.0; + image { + normal: "e17_cpufreq_freq10.png"; + } + } + } + + part { + name: "decrease_button"; + type: IMAGE; + mouse_events: 1; + + description { + state: "default" 0.0; + rel1 { + relative: 0.0 0.; + offset: 0 0; + } + rel2 { + relative: 1.0 0.375; + offset: -1 -1; + } + image { + normal: "e17_cpufreq_decrease1.png"; + } + } + description { + state: "clicked" 0.0; + inherit: "default" 0.0; + image { + normal: "e17_cpufreq_decrease2.png"; + } + } + description { + state: "inactive" 0.0; + inherit: "default" 0.0; + visible: 0; + } + } + + part { + name: "increase_button"; + type: IMAGE; + mouse_events: 1; + + description { + state: "default" 0.0; + rel1 { + relative: 0.0 0.; + offset: 0 0; + } + rel2 { + relative: 1.0 0.375; + offset: -1 -1; + } + image { + normal: "e17_cpufreq_increase1.png"; + } + } + description { + state: "clicked" 0.0; + inherit: "default" 0.0; + image { + normal: "e17_cpufreq_increase2.png"; + } + } + description { + state: "inactive" 0.0; + inherit: "default" 0.0; + visible: 0; + } + } + + part { + name: "cpu"; + type: IMAGE; + mouse_events: 1; + + description { + state: "default" 0.0; + rel1 { + relative: 0.1953125 0.3671875; + offset: 0 0; + } + rel2 { + relative: 0.8359375 1.0; + offset: -1 -1; + } + image { + normal: "e17_cpufreq_cpu1.png"; + } + } + description { + state: "clicked" 0.0; + inherit: "default" 0.0; + image { + normal: "e17_cpufreq_cpu2.png"; + } + } + } + + part { + name: "readout"; + type: TEXT; + effect: SOFT_SHADOW; + mouse_events: 0; + description { + state: "default" 0.0; + rel1 { + relative: 0.5 0.7; + offset: 0 0; + } + rel2 { + relative: 0.5 0.7; + offset: 0 0; + } + color: 255 255 255 255; + color3: 0 0 0 32; + text { + text: "??? Ghz"; + font: "Edje Vera"; + size: 7; + align: 0.5 0.5; + min: 1 1; + } + } + } + + part { + name: "decrease"; + type: RECT; + description { + state: "default" 0.0; + visible: 1; + rel1 { + relative: 0.0 0.0; + offset: 0 0; + } + rel2 { + relative: 0.5 0.375; + offset: -1 -1; + } + color: 0 0 0 0; + } + description { + state: "inactive" 0.0; + inherit: "default" 0.0; + visible: 0; + } + } + + part { + name: "increase"; + type: RECT; + description { + state: "default" 0.0; + visible: 1; + rel1 { + relative: 0.5 0.0; + offset: 0 0; + } + rel2 { + relative: 1.0 0.375; + offset: -1 -1; + } + color: 0 0 0 0; + } + description { + state: "inactive" 0.0; + inherit: "default" 0.0; + visible: 0; + } + } + + } /* end parts */ + + programs { + program { + name: "next_governor"; + signal: "mouse,down,1"; + source: "cpu"; + action: SIGNAL_EMIT "next_governor" "governor"; + } + program { + name: "next_governor2"; + signal: "mouse,down,1"; + source: "cpu"; + action: STATE_SET "clicked" 0.0; + target: "cpu"; + } + program { + name: "next_governor3"; + signal: "mouse,up,1"; + source: "cpu"; + action: STATE_SET "default" 0.0; + target: "cpu"; + } + program { + name: "increase_frequency"; + signal: "mouse,down,1"; + source: "increase"; + action: SIGNAL_EMIT "increase_frequency" "frequency"; + } + program { + name: "increase_frequency2"; + signal: "mouse,down,1"; + source: "increase"; + action: STATE_SET "clicked" 0.0; + target: "increase_button"; + } + program { + name: "increase_frequency3"; + signal: "mouse,up,1"; + source: "increase"; + action: STATE_SET "default" 0.0; + target: "increase_button"; + } + program { + name: "decrease_frequency"; + signal: "mouse,down,1"; + source: "decrease"; + action: SIGNAL_EMIT "decrease_frequency" "frequency"; + } + program { + name: "decrease_frequency2"; + signal: "mouse,down,1"; + source: "decrease"; + action: STATE_SET "clicked" 0.0; + target: "decrease_button"; + } + program { + name: "decrease_frequency3"; + signal: "mouse,up,1"; + source: "decrease"; + action: STATE_SET "default" 0.0; + target: "decrease_button"; + } + } +} diff --git a/data/themes/images/Makefile.am b/data/themes/images/Makefile.am index c9d1936b7..2e03d31d7 100644 --- a/data/themes/images/Makefile.am +++ b/data/themes/images/Makefile.am @@ -255,5 +255,21 @@ e17_temperature_mid.png \ e17_temperature_overlay.png \ e17_gadman_indicator.png \ e17_gadman_overlay.png \ -e17_logo.png - +e17_logo.png \ +e17_cpufreq_freq00.png \ +e17_cpufreq_freq01.png \ +e17_cpufreq_freq02.png \ +e17_cpufreq_freq03.png \ +e17_cpufreq_freq04.png \ +e17_cpufreq_freq05.png \ +e17_cpufreq_freq06.png \ +e17_cpufreq_freq07.png \ +e17_cpufreq_freq08.png \ +e17_cpufreq_freq09.png \ +e17_cpufreq_freq10.png \ +e17_cpufreq_increase1.png \ +e17_cpufreq_increase2.png \ +e17_cpufreq_decrease1.png \ +e17_cpufreq_decrease2.png \ +e17_cpufreq_cpu1.png \ +e17_cpufreq_cpu2.png diff --git a/data/themes/images/e17_cpufreq_cpu1.png b/data/themes/images/e17_cpufreq_cpu1.png new file mode 100644 index 000000000..45e9acb63 Binary files /dev/null and b/data/themes/images/e17_cpufreq_cpu1.png differ diff --git a/data/themes/images/e17_cpufreq_cpu2.png b/data/themes/images/e17_cpufreq_cpu2.png new file mode 100644 index 000000000..12770b8d2 Binary files /dev/null and b/data/themes/images/e17_cpufreq_cpu2.png differ diff --git a/data/themes/images/e17_cpufreq_decrease1.png b/data/themes/images/e17_cpufreq_decrease1.png new file mode 100644 index 000000000..350c38414 Binary files /dev/null and b/data/themes/images/e17_cpufreq_decrease1.png differ diff --git a/data/themes/images/e17_cpufreq_decrease2.png b/data/themes/images/e17_cpufreq_decrease2.png new file mode 100644 index 000000000..dbd41b173 Binary files /dev/null and b/data/themes/images/e17_cpufreq_decrease2.png differ diff --git a/data/themes/images/e17_cpufreq_freq00.png b/data/themes/images/e17_cpufreq_freq00.png new file mode 100644 index 000000000..1f18ff84c Binary files /dev/null and b/data/themes/images/e17_cpufreq_freq00.png differ diff --git a/data/themes/images/e17_cpufreq_freq01.png b/data/themes/images/e17_cpufreq_freq01.png new file mode 100644 index 000000000..ac6f7ce52 Binary files /dev/null and b/data/themes/images/e17_cpufreq_freq01.png differ diff --git a/data/themes/images/e17_cpufreq_freq02.png b/data/themes/images/e17_cpufreq_freq02.png new file mode 100644 index 000000000..8d31ecc26 Binary files /dev/null and b/data/themes/images/e17_cpufreq_freq02.png differ diff --git a/data/themes/images/e17_cpufreq_freq03.png b/data/themes/images/e17_cpufreq_freq03.png new file mode 100644 index 000000000..481741f72 Binary files /dev/null and b/data/themes/images/e17_cpufreq_freq03.png differ diff --git a/data/themes/images/e17_cpufreq_freq04.png b/data/themes/images/e17_cpufreq_freq04.png new file mode 100644 index 000000000..f5b027f30 Binary files /dev/null and b/data/themes/images/e17_cpufreq_freq04.png differ diff --git a/data/themes/images/e17_cpufreq_freq05.png b/data/themes/images/e17_cpufreq_freq05.png new file mode 100644 index 000000000..7bc213431 Binary files /dev/null and b/data/themes/images/e17_cpufreq_freq05.png differ diff --git a/data/themes/images/e17_cpufreq_freq06.png b/data/themes/images/e17_cpufreq_freq06.png new file mode 100644 index 000000000..a47f3f2bb Binary files /dev/null and b/data/themes/images/e17_cpufreq_freq06.png differ diff --git a/data/themes/images/e17_cpufreq_freq07.png b/data/themes/images/e17_cpufreq_freq07.png new file mode 100644 index 000000000..5855f86aa Binary files /dev/null and b/data/themes/images/e17_cpufreq_freq07.png differ diff --git a/data/themes/images/e17_cpufreq_freq08.png b/data/themes/images/e17_cpufreq_freq08.png new file mode 100644 index 000000000..c9e60ecd6 Binary files /dev/null and b/data/themes/images/e17_cpufreq_freq08.png differ diff --git a/data/themes/images/e17_cpufreq_freq09.png b/data/themes/images/e17_cpufreq_freq09.png new file mode 100644 index 000000000..6350f8173 Binary files /dev/null and b/data/themes/images/e17_cpufreq_freq09.png differ diff --git a/data/themes/images/e17_cpufreq_freq10.png b/data/themes/images/e17_cpufreq_freq10.png new file mode 100644 index 000000000..79d420fd8 Binary files /dev/null and b/data/themes/images/e17_cpufreq_freq10.png differ diff --git a/data/themes/images/e17_cpufreq_increase1.png b/data/themes/images/e17_cpufreq_increase1.png new file mode 100644 index 000000000..b8a619837 Binary files /dev/null and b/data/themes/images/e17_cpufreq_increase1.png differ diff --git a/data/themes/images/e17_cpufreq_increase2.png b/data/themes/images/e17_cpufreq_increase2.png new file mode 100644 index 000000000..d7ea37cc2 Binary files /dev/null and b/data/themes/images/e17_cpufreq_increase2.png differ diff --git a/src/modules/Makefile.am b/src/modules/Makefile.am index 047fa7463..c563f95d6 100644 --- a/src/modules/Makefile.am +++ b/src/modules/Makefile.am @@ -6,4 +6,5 @@ dropshadow \ clock \ pager \ battery \ -temperature +temperature \ +cpufreq diff --git a/src/modules/cpufreq/Makefile.am b/src/modules/cpufreq/Makefile.am new file mode 100644 index 000000000..399a29d46 --- /dev/null +++ b/src/modules/cpufreq/Makefile.am @@ -0,0 +1,47 @@ +MAINTAINERCLEANFILES = Makefile.in +MODULE = cpufreq + +# data files for the module +filesdir = $(libdir)/enlightenment/modules/$(MODULE) +files_DATA = \ +module_icon.png +freqsetdir = $(libdir)/enlightenment/modules/$(MODULE) +freqset_DATA = \ +freqset + +EXTRA_DIST = $(files_DATA) + +# the module .so file +INCLUDES = -I. \ + -I$(top_srcdir) \ + -I$(includedir) \ + -I$(top_srcdir)$(MODULE) \ + -I$(top_srcdir)/src/bin \ + -I$(top_srcdir)/src/lib \ + -I$(top_srcdir)/src/modules \ + @e_cflags@ +pkgdir = $(libdir)/enlightenment/modules/$(MODULE)/$(MODULE_ARCH) +pkg_LTLIBRARIES = module.la +module_la_SOURCES = e_mod_main.c \ + e_mod_main.h +module_la_LIBADD = @e_libs@ @dlopen_libs@ +module_la_LDFLAGS = -module -avoid-version +module_la_DEPENDENCIES = $(top_builddir)/config.h + +all-local: freqset$(EXEEXT) +installed_su = $(pkgdir)/freqset$(EXEEXT) +setuid_root_mode = a=rx,u+s + +INSTALL_SU = \ + echo " $(INSTALL_PROGRAM_ENV) $(LIBTOOL) --mode=install install -m $(setuid_root_mode) freqset $(installed_su)"; \ + $(INSTALL_PROGRAM_ENV) $(LIBTOOL) --mode=install install -m $(setuid_root_mode) freqset $(installed_su); \ + #echo " chown root $(installed_su)"; \ + #chown root $(installed_su); \ + #echo " chmod $(setuid_root_mode) $(installed_su)"; \ + #chmod $(setuid_root_mode) $(installed_su) + +install-freqsetDATA: freqset$(EXEEXT) + @$(INSTALL_SU) + +noinst_PROGRAMS = freqset +freqset_SOURCES = freqset.c diff --git a/src/modules/cpufreq/e_mod_main.c b/src/modules/cpufreq/e_mod_main.c new file mode 100644 index 000000000..42492e288 --- /dev/null +++ b/src/modules/cpufreq/e_mod_main.c @@ -0,0 +1,1026 @@ +#include +#include +#include "e_mod_main.h" + +/* FIXME: need to handle performance and powersave convernors (only auto/manual now) + * FIXME: check permissions (can execute) before trying + * FIXME: display throttling state + * FIXME: if system doesnt support cpufreq - fade out + */ + +static Cpufreq *_cpufreq_new(E_Module *module); +static void _cpufreq_free(Cpufreq *cpufreq); +static void _cpufreq_set_governor(Cpufreq *cpufreq, const char *governor); +static void _cpufreq_menu_fast(void *data, E_Menu *m, E_Menu_Item *mi); +static void _cpufreq_menu_medium(void *data, E_Menu *m, E_Menu_Item *mi); +static void _cpufreq_menu_normal(void *data, E_Menu *m, E_Menu_Item *mi); +static void _cpufreq_menu_slow(void *data, E_Menu *m, E_Menu_Item *mi); +static void _cpufreq_menu_very_slow(void *data, E_Menu *m, E_Menu_Item *mi); +static void _cpufreq_menu_governor(void *data, E_Menu *m, E_Menu_Item *mi); +static void _cpufreq_menu_frequency(void *data, E_Menu *m, E_Menu_Item *mi); +static void _cpufreq_config_menu_new(Cpufreq *cpufreq); +static int _cpufreq_cb_check(void *data); + +static Status * _cpufreq_status_new(); +static void _cpufreq_status_free(Status *e); +static int _cpufreq_status_check_available(Status *e); +static int _cpufreq_status_check_current(Status *e); +static int _cpufreq_cb_sort(void *item1, void *item2); + +static Cpufreq_Face *_cpufreq_face_new(E_Container *con, Cpufreq *owner); +static void _cpufreq_face_free(Cpufreq_Face *face); +static void _cpufreq_face_menu_new(Cpufreq_Face *face); +static void _cpufreq_face_enable(Cpufreq_Face *face); +static void _cpufreq_face_disable(Cpufreq_Face *face); +static void _cpufreq_face_cb_gmc_change(void *data, E_Gadman_Client *gmc, E_Gadman_Change change); +static void _cpufreq_face_cb_menu_enabled(void *data, E_Menu *m, E_Menu_Item *mi); +static void _cpufreq_face_cb_menu_edit(void *data, E_Menu *m, E_Menu_Item *mi); +static void _cpufreq_face_cb_mouse_down(void *data, Evas *e, Evas_Object *obj, void *event_info); +static void _cpufreq_face_update_available(Cpufreq_Face *face); +static void _cpufreq_face_update_current(Cpufreq_Face *face); +static void _cpufreq_face_cb_set_frequency(void *data, Evas_Object *o, const char *emission, const char *source); +static void _cpufreq_face_cb_set_governor(void *data, Evas_Object *o, const char *emission, const char *source); + +static E_Config_DD *conf_edd; +static E_Config_DD *conf_face_edd; + +static int cpufreq_count; + +/* public module routines */ +void * +e_modapi_init(E_Module *module) +{ + Cpufreq *freq; + + if (module->api->version < E_MODULE_API_VERSION) + { + e_error_dialog_show(_("Module API Error"), + _("Error initializing Module: cpufreq\n" + "It requires a minimum module API version of: %i.\n" + "The module API advertized by Enlightenment is %i.\n" + "Aborting module."), + E_MODULE_API_VERSION, + module->api->version); + return NULL; + } + + freq = _cpufreq_new(module); + module->config_menu = freq->config_menu; + return freq; +} + +int +e_modapi_shutdown(E_Module *module) +{ + Cpufreq *cpufreq; + + if (module->config_menu) + module->config_menu = NULL; + + cpufreq = module->data; + if (cpufreq) + _cpufreq_free(cpufreq); + + return 1; +} + +int +e_modapi_save(E_Module *module) +{ + return 1; +} + +int +e_modapi_info(E_Module *module) +{ + char buf[4096]; + + module->label = strdup(_("CpuFreq")); + snprintf(buf, sizeof(buf), "%s/module_icon.png", e_module_dir_get(module)); + module->icon_file = strdup(buf); + return 1; +} + +int +e_modapi_about(E_Module *module) +{ + e_error_dialog_show(_("CPU Frequency Controller Module"), + _("A simple module to control the frequency of the system CPU. " + "This is especially useful to save power on laptops.")); + return 1; +} + +static Cpufreq * +_cpufreq_new(E_Module *module) +{ + Cpufreq *e; + Evas_List *managers, *l, *l2, *cl; + E_Menu_Item *mi; + char buf[4096]; + + cpufreq_count = 0; + e = E_NEW(Cpufreq, 1); + if (!e) return NULL; + + conf_face_edd = E_CONFIG_DD_NEW("Cpufreq_Config_Face", Config_Face); +#undef T +#undef D +#define T Config_Face +#define D conf_face_edd + E_CONFIG_VAL(D, T, enabled, INT); + + conf_edd = E_CONFIG_DD_NEW("Cpufreq_Config", Config); +#undef T +#undef D +#define T Config +#define D conf_edd + E_CONFIG_VAL(D, T, poll_time, DOUBLE); + E_CONFIG_LIST(D, T, faces, conf_face_edd); + + e->conf = e_config_domain_load("module.cpufreq", conf_edd); + if (!e->conf) + { + e->conf = E_NEW(Config, 1); + e->conf->poll_time = 2.0; + } + E_CONFIG_LIMIT(e->conf->poll_time, 0.5, 60.0); + + snprintf(buf, sizeof(buf), "%s/%s/freqset", e_module_dir_get(module), MODULE_ARCH); + buf[sizeof(buf) - 1] = 0; + e->set_exe_path = strdup(buf); + e->frequency_check_timer = ecore_timer_add(e->conf->poll_time, _cpufreq_cb_check, e); + e->status = _cpufreq_status_new(); + + _cpufreq_status_check_available(e->status); + _cpufreq_config_menu_new(e); + + managers = e_manager_list(); + cl = e->conf->faces; + for (l = managers; l; l = l->next) + { + E_Manager *man; + + man = l->data; + for (l2 = man->containers; l2; l2 = l2->next) + { + E_Container *con; + Cpufreq_Face *ef; + + con = l2->data; + ef = _cpufreq_face_new(con, e); + if (ef) + { + e->faces = evas_list_append(e->faces, ef); + + if (!cl) + { + ef->conf = E_NEW(Config_Face, 1); + ef->conf->enabled = 1; + e->conf->faces = evas_list_append(e->conf->faces, ef->conf); + } + else + { + ef->conf = cl->data; + cl = cl->next; + } + + _cpufreq_face_menu_new(ef); + + /* Add poll time menu to this face */ + mi = e_menu_item_new(ef->menu); + e_menu_item_label_set(mi, _("Set Poll Time")); + e_menu_item_submenu_set(mi, e->config_menu_poll); + + if (e->menu_governor) + { + /* Add governors menu to this face */ + mi = e_menu_item_new(ef->menu); + e_menu_item_label_set(mi, _("Set Controller")); + e_menu_item_submenu_set(mi, e->menu_governor); + } + + if (e->menu_frequency) + { + /* Add frequency menu to this face */ + mi = e_menu_item_new(ef->menu); + e_menu_item_label_set(mi, _("Set Speed")); + e_menu_item_submenu_set(mi, e->menu_frequency); + } + + /* Add this face to the main menu */ + mi = e_menu_item_new(e->config_menu); + e_menu_item_label_set(mi, con->name); + e_menu_item_submenu_set(mi, ef->menu); + + if (!ef->conf->enabled) + _cpufreq_face_disable(ef); + } + } + } + + _cpufreq_cb_check(e); + + return e; +} + +static void +_cpufreq_free(Cpufreq *e) +{ + Evas_List *l; + + E_CONFIG_DD_FREE(conf_edd); + E_CONFIG_DD_FREE(conf_face_edd); + + for (l = e->faces; l; l = l->next) + _cpufreq_face_free(l->data); + evas_list_free(e->faces); + + e_object_del(E_OBJECT(e->config_menu)); + e_object_del(E_OBJECT(e->config_menu_poll)); + e_object_del(E_OBJECT(e->menu_governor)); + e_object_del(E_OBJECT(e->menu_frequency)); + + ecore_timer_del(e->frequency_check_timer); + + _cpufreq_status_free(e->status); + + free(e->set_exe_path); +// while (e->conf->faces) +// { +// free(e->conf->faces->data); +// e->conf->faces = evas_list_remove_list(e->conf->faces, e->conf->faces); +// } + free(e->conf); + free(e); +} + +static void +_cpufreq_set_governor(Cpufreq *e, const char *governor) +{ + char buf[4096]; + int ret; + + snprintf(buf, sizeof(buf), + "%s %s %s", e->set_exe_path, "governor", governor); + ret = system(buf); + if (ret != 0) + { + e_error_dialog_show("CPU Frequency ERROR", + "There was an error trying to set the cpu frequency\n" + "governor via the module's setfreq utility."); + } +} + +static void +_cpufreq_set_frequency(Cpufreq *e, int frequency) +{ + char buf[4096]; + int ret; + + snprintf(buf, sizeof(buf), + "%s %s %i", e->set_exe_path, "frequency", frequency); + ret = system(buf); + if (ret != 0) + { + e_error_dialog_show("CPU Frequency ERROR", + "There was an error trying to set the cpu frequency\n" + "setting via the module's setfreq utility."); + } +} + +static void +_cpufreq_menu_fast(void *data, E_Menu *m, E_Menu_Item *mi) +{ + Cpufreq *e; + + e = data; + e->conf->poll_time = 0.5; + ecore_timer_del(e->frequency_check_timer); + e->frequency_check_timer = ecore_timer_add(e->conf->poll_time, _cpufreq_cb_check, e); + e_config_save_queue(); +} + +static void +_cpufreq_menu_medium(void *data, E_Menu *m, E_Menu_Item *mi) +{ + Cpufreq *e; + + e = data; + e->conf->poll_time = 1.0; + ecore_timer_del(e->frequency_check_timer); + e->frequency_check_timer = ecore_timer_add(e->conf->poll_time, _cpufreq_cb_check, e); + e_config_save_queue(); +} + +static void +_cpufreq_menu_normal(void *data, E_Menu *m, E_Menu_Item *mi) +{ + Cpufreq *e; + + e = data; + e->conf->poll_time = 2.0; + ecore_timer_del(e->frequency_check_timer); + e->frequency_check_timer = ecore_timer_add(e->conf->poll_time, _cpufreq_cb_check, e); + e_config_save_queue(); +} + +static void +_cpufreq_menu_slow(void *data, E_Menu *m, E_Menu_Item *mi) +{ + Cpufreq *e; + + e = data; + e->conf->poll_time = 5.0; + ecore_timer_del(e->frequency_check_timer); + e->frequency_check_timer = ecore_timer_add(e->conf->poll_time, _cpufreq_cb_check, e); + e_config_save_queue(); +} + +static void +_cpufreq_menu_very_slow(void *data, E_Menu *m, E_Menu_Item *mi) +{ + Cpufreq *e; + + e = data; + e->conf->poll_time = 30.0; + ecore_timer_del(e->frequency_check_timer); + e->frequency_check_timer = ecore_timer_add(e->conf->poll_time, _cpufreq_cb_check, e); + e_config_save_queue(); +} + +static void +_cpufreq_menu_governor(void *data, E_Menu *m, E_Menu_Item *mi) +{ + char *governor; + + governor = e_object_data_get(E_OBJECT(mi)); + if (governor) + { + _cpufreq_set_governor(data, governor); + } +} + +static void +_cpufreq_menu_frequency(void * data, E_Menu *m, E_Menu_Item *mi) +{ + int frequency; + + frequency = (int) e_object_data_get(E_OBJECT(mi)); + if (frequency > 0) + { + _cpufreq_set_frequency(data, frequency); + } +} + +static void +_cpufreq_config_menu_new(Cpufreq *e) +{ + E_Menu *mn; + E_Menu_Item *mi; + Evas_List *l; + char buf[256]; + + mn = e_menu_new(); + + mi = e_menu_item_new(mn); + e_menu_item_label_set(mi, _("Check Fast (0.5 sec)")); + e_menu_item_radio_set(mi, 1); + e_menu_item_radio_group_set(mi, 1); + if (e->conf->poll_time <= 0.5) e_menu_item_toggle_set(mi, 1); + e_menu_item_callback_set(mi, _cpufreq_menu_fast, e); + + mi = e_menu_item_new(mn); + e_menu_item_label_set(mi, _("Check Medium (1 sec)")); + e_menu_item_radio_set(mi, 1); + e_menu_item_radio_group_set(mi, 1); + if (e->conf->poll_time > 0.5) e_menu_item_toggle_set(mi, 1); + e_menu_item_callback_set(mi, _cpufreq_menu_medium, e); + + mi = e_menu_item_new(mn); + e_menu_item_label_set(mi, _("Check Normal (2 sec)")); + e_menu_item_radio_set(mi, 1); + e_menu_item_radio_group_set(mi, 1); + if (e->conf->poll_time >= 2.0) e_menu_item_toggle_set(mi, 1); + e_menu_item_callback_set(mi, _cpufreq_menu_normal, e); + + mi = e_menu_item_new(mn); + e_menu_item_label_set(mi, _("Check Slow (5 sec)")); + e_menu_item_radio_set(mi, 1); + e_menu_item_radio_group_set(mi, 1); + if (e->conf->poll_time >= 5.0) e_menu_item_toggle_set(mi, 1); + e_menu_item_callback_set(mi, _cpufreq_menu_slow, e); + + mi = e_menu_item_new(mn); + e_menu_item_label_set(mi, _("Check Very Slow (30 sec)")); + e_menu_item_radio_set(mi, 1); + e_menu_item_radio_group_set(mi, 1); + if (e->conf->poll_time >= 30.0) e_menu_item_toggle_set(mi, 1); + e_menu_item_callback_set(mi, _cpufreq_menu_very_slow, e); + + e->config_menu_poll = mn; + + if (e->status->governors) + { + mn = e_menu_new(); + + for (l = e->status->governors; l; l = l->next) + { + mi = e_menu_item_new(mn); + if (!strcmp(l->data, "userspace")) + e_menu_item_label_set(mi, _("Manual")); + else if (!strcmp(l->data, "ondemand")) + e_menu_item_label_set(mi, _("Automatic")); + e_menu_item_radio_set(mi, 1); + e_menu_item_radio_group_set(mi, 1); + e_object_data_set(E_OBJECT(mi), l->data); + e_menu_item_callback_set(mi, _cpufreq_menu_governor, e); + } + + e->menu_governor = mn; + } + + if (e->status->frequencies) + { + mn = e_menu_new(); + + /* FIXME: sotring ints in pointers for freq's? BAD! */ + for (l = e->status->frequencies; l; l = l->next) + { + int frequency; + + frequency = (int)l->data; + mi = e_menu_item_new(mn); + if (frequency < 1000000) + snprintf(buf, sizeof(buf), _("%i Mhz"), frequency / 1000); + else + snprintf(buf, sizeof(buf), _("%i.%i Ghz"), frequency / 1000000, (frequency % 1000000) / 1000); + buf[sizeof(buf) - 1] = 0; + e_menu_item_label_set(mi, buf); + e_menu_item_radio_set(mi, 1); + e_menu_item_radio_group_set(mi, 1); + e_object_data_set(E_OBJECT(mi), l->data); + e_menu_item_callback_set(mi, _cpufreq_menu_frequency, e); + } + } + + e->menu_frequency = mn; + + mn = e_menu_new(); + + mi = e_menu_item_new(mn); + e_menu_item_label_set(mi, _("Set Poll Time")); + e_menu_item_submenu_set(mi, e->config_menu_poll); + + if (e->menu_governor) + { + mi = e_menu_item_new(mn); + e_menu_item_label_set(mi, _("Set Controller")); + e_menu_item_submenu_set(mi, e->menu_governor); + } + + if (e->menu_frequency) + { + mi = e_menu_item_new(mn); + e_menu_item_label_set(mi, _("Set Speed")); + e_menu_item_submenu_set(mi, e->menu_frequency); + } + + e->config_menu = mn; +} + +static int +_cpufreq_cb_check(void *data) +{ + Cpufreq *e; + Cpufreq_Face *face; + Evas_List *l; + + e = data; + + if (_cpufreq_status_check_current(e->status)) + { + for (l = e->faces; l; l = l->next) + { + face = l->data; + _cpufreq_face_update_current(face); + } + } + + return 1; +} + +static Status * +_cpufreq_status_new() +{ + Status *e; + + e = E_NEW(Status, 1); + if (!e) return NULL; + + e->frequencies = NULL; + e->governors = NULL; + e->cur_frequency = 0; + e->can_set_frequency = 0; + e->cur_governor = NULL; + + return e; +} + +static void +_cpufreq_status_free(Status *e) +{ + Evas_List *l; + + if (e->frequencies) + evas_list_free(e->frequencies); + if (e->governors) + { + for (l = e->governors; l; l = l->next) + free(l->data); + evas_list_free(e->governors); + } + if (e->cur_governor) + free(e->cur_governor); + + free(e); +} + +static int +_cpufreq_cb_sort(void *item1, void *item2) +{ + int a, b; + + a = (int) item1; + b = (int) item2; + if (a < b) + return -1; + else if (a > b) + return 1; + else + return 0; +} + +static int +_cpufreq_status_check_available(Status *e) +{ + char buf[4096]; + FILE *f; + Evas_List *l; + + f = fopen("/sys/devices/system/cpu/cpu0/cpufreq/scaling_available_frequencies", "r"); + if (f) + { + char *freq; + + if (e->frequencies) + { + evas_list_free(e->frequencies); + e->frequencies = NULL; + } + + fgets(buf, sizeof(buf), f); + buf[sizeof(buf) - 1] = 0; + fclose(f); + + freq = strtok(buf, " "); + do + { + if (atoi(freq) != 0) + { + e->frequencies = evas_list_append(e->frequencies, + (void *) atoi(freq)); + } + freq = strtok(NULL, " "); + } + while (freq != NULL); + + // sort list + e->frequencies = evas_list_sort(e->frequencies, evas_list_count(e->frequencies), + _cpufreq_cb_sort); + } + + f = fopen("/sys/devices/system/cpu/cpu0/cpufreq/scaling_available_governors", "r"); + if (f) + { + char *gov; + + if (e->governors) + { + for (l = e->governors; l; l = l->next) + free(l->data); + evas_list_free(e->governors); + e->governors = NULL; + } + + fgets(buf, sizeof(buf), f); + buf[sizeof(buf) - 1] = 0; + fclose(f); + + gov = strtok(buf, " "); + do + { + while (isspace(*gov)) gov++; + if (strlen(gov) != 0) + { + if ((!strcmp(gov, "ondemand")) || + (!strcmp(gov, "userspace"))) + e->governors = evas_list_append(e->governors, strdup(gov)); + } + gov = strtok(NULL, " "); + } + while (gov != NULL); + + e->governors = evas_list_sort(e->governors, evas_list_count(e->governors), + (int (*)(void *, void *))strcmp); + } + + return 1; +} + +static int +_cpufreq_status_check_current(Status *e) +{ + char buf[4096]; + int i; + FILE *f; + int ret; + int frequency; + + ret = 0; + + f = fopen("/sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq", "r"); + if (f) + { + fgets(buf, sizeof(buf), f); buf[sizeof(buf) - 1] = 0; + fclose(f); + + frequency = atoi(buf); + if(frequency != e->cur_frequency) + ret = 1; + e->cur_frequency = frequency; + } + + f = fopen("/sys/devices/system/cpu/cpu0/cpufreq/scaling_setspeed", "r"); + if (f) + { + e->can_set_frequency = 1; + fclose(f); + } + else + { + e->can_set_frequency = 0; + } + + f = fopen("/sys/devices/system/cpu/cpu0/cpufreq/scaling_governor", "r"); + if (f) + { + fgets(buf, sizeof(buf), f); buf[sizeof(buf) - 1] = 0; + fclose(f); + + if ((e->cur_governor == NULL) || (strcmp(buf, e->cur_governor))) + { + ret = 1; + + if(e->cur_governor) + free(e->cur_governor); + e->cur_governor = strdup(buf); + + for (i = strlen(e->cur_governor) - 1; i >= 0; i--) + { + if (isspace(e->cur_governor[i])) + e->cur_governor[i] = 0; + else + break; + } + } + } + + return ret; +} + +static Cpufreq_Face * +_cpufreq_face_new(E_Container *con, Cpufreq *owner) +{ + Evas_Object *o; + Cpufreq_Face *ef; + + ef = E_NEW(Cpufreq_Face, 1); + if (!ef) return NULL; + + ef->con = con; + e_object_ref(E_OBJECT(con)); + ef->owner = owner; + + evas_event_freeze(con->bg_evas); + + o = edje_object_add(con->bg_evas); + ef->freq_object = o; + edje_object_file_set(o, + e_path_find(path_themes, "default.edj"), + "modules/cpufreq/main"); + edje_object_signal_callback_add(o, "next_governor", "governor", _cpufreq_face_cb_set_governor, owner); + edje_object_signal_callback_add(o, "increase_frequency", "frequency", _cpufreq_face_cb_set_frequency, owner); + edje_object_signal_callback_add(o, "decrease_frequency", "frequency", _cpufreq_face_cb_set_frequency, owner); + evas_object_show(o); + + o = evas_object_rectangle_add(con->bg_evas); + ef->event_object = o; + evas_object_layer_set(o, 0); + evas_object_repeat_events_set(o, 1); + evas_object_color_set(o, 0, 0, 0, 0); + evas_object_event_callback_add(o, EVAS_CALLBACK_MOUSE_DOWN, _cpufreq_face_cb_mouse_down, ef); + evas_object_show(o); + + ef->gmc = e_gadman_client_new(ef->con->gadman); + e_gadman_client_domain_set(ef->gmc, "module.cpufreq", cpufreq_count++); + e_gadman_client_policy_set(ef->gmc, E_GADMAN_POLICY_ANYWHERE | + E_GADMAN_POLICY_HMOVE | E_GADMAN_POLICY_VMOVE | + E_GADMAN_POLICY_HSIZE | E_GADMAN_POLICY_VSIZE); + e_gadman_client_min_size_set(ef->gmc, 4, 4); + e_gadman_client_max_size_set(ef->gmc, 128, 128); + /* This module needs a slightly higher min size */ + e_gadman_client_auto_size_set(ef->gmc, 40, 40); + e_gadman_client_align_set(ef->gmc, 1.0, 1.0); + e_gadman_client_resize(ef->gmc, 40, 40); + e_gadman_client_change_func_set(ef->gmc, _cpufreq_face_cb_gmc_change, ef); + e_gadman_client_load(ef->gmc); + + _cpufreq_face_update_available(ef); + + evas_event_thaw(con->bg_evas); + + return ef; +} + +static void +_cpufreq_face_free(Cpufreq_Face *ef) +{ + e_object_unref(E_OBJECT(ef->con)); + e_object_del(E_OBJECT(ef->gmc)); + e_object_del(E_OBJECT(ef->menu)); + evas_object_del(ef->freq_object); + evas_object_del(ef->event_object); + + free(ef->conf); + free(ef); + cpufreq_count--; +} + +static void +_cpufreq_face_menu_new(Cpufreq_Face *face) +{ + E_Menu *mn; + E_Menu_Item *mi; + + mn = e_menu_new(); + face->menu = mn; + + /* Enabled */ + /*mi = e_menu_item_new(mn); + e_menu_item_label_set(mi, "Enabled"); + e_menu_item_check_set(mi, 1); + if (face->conf->enabled) e_menu_item_toggle_set(mi, 1); + e_menu_item_callback_set(mi, _cpufreq_face_cb_menu_enabled, face); + */ + + /* Edit */ + mi = e_menu_item_new(mn); + e_menu_item_label_set(mi, "Edit Mode"); + e_menu_item_callback_set(mi, _cpufreq_face_cb_menu_edit, face); +} + +static void +_cpufreq_face_enable(Cpufreq_Face *face) +{ + face->conf->enabled = 1; + evas_object_show(face->freq_object); + evas_object_show(face->event_object); + e_config_save_queue(); +} + +static void +_cpufreq_face_disable(Cpufreq_Face *face) +{ + face->conf->enabled = 0; + evas_object_hide(face->freq_object); + evas_object_hide(face->event_object); + e_config_save_queue(); +} + +static void +_cpufreq_face_cb_gmc_change(void *data, E_Gadman_Client *gmc, E_Gadman_Change change) +{ + Cpufreq_Face *ef; + Evas_Coord x, y, w, h; + + ef = data; + switch (change) + { + case E_GADMAN_CHANGE_MOVE_RESIZE: + e_gadman_client_geometry_get(ef->gmc, &x, &y, &w, &h); + evas_object_move(ef->freq_object, x, y); + evas_object_move(ef->event_object, x, y); + evas_object_resize(ef->freq_object, w, h); + evas_object_resize(ef->event_object, w, h); + break; + case E_GADMAN_CHANGE_RAISE: + evas_object_raise(ef->freq_object); + evas_object_raise(ef->event_object); + break; + } +} + +static void +_cpufreq_face_cb_menu_enabled(void *data, E_Menu *m, E_Menu_Item *mi) +{ + Cpufreq_Face *face; + unsigned char enabled; + + face = data; + enabled = e_menu_item_toggle_get(mi); + if ((face->conf->enabled) && (!enabled)) + { + _cpufreq_face_disable(face); + } + else if ((!face->conf->enabled) && (enabled)) + { + _cpufreq_face_enable(face); + } +} + +static void +_cpufreq_face_cb_menu_edit(void *data, E_Menu *m, E_Menu_Item *mi) +{ + Cpufreq_Face *face; + + face = data; + e_gadman_mode_set(face->gmc->gadman, E_GADMAN_MODE_EDIT); +} + +static void +_cpufreq_face_cb_mouse_down(void *data, Evas *e, Evas_Object *obj, void *event_info) +{ + Evas_Event_Mouse_Down *ev; + Cpufreq_Face *ef; + + ev = event_info; + ef = data; + if (ev->button == 3) + { + e_menu_activate_mouse(ef->menu, e_zone_current_get(ef->con), + ev->output.x, ev->output.y, 1, 1, + E_MENU_POP_DIRECTION_DOWN); + e_util_container_fake_mouse_up_all_later(ef->con); + } +} + +static void +_cpufreq_face_update_available(Cpufreq_Face *face) +{ + Edje_Message_Int_Set *frequency_msg; + Edje_Message_String_Set *governor_msg; + Evas_List *l; + int i; + int count; + + count = evas_list_count(face->owner->status->frequencies); + frequency_msg = malloc(sizeof(Edje_Message_Int_Set) + (count - 1) * sizeof(int)); + frequency_msg->count = count; + for (l = face->owner->status->frequencies, i = 0; l; l = l->next, i++) + { + frequency_msg->val[i] = (int) l->data; + } + edje_object_message_send(face->freq_object, EDJE_MESSAGE_INT_SET, 1, frequency_msg); + free(frequency_msg); + + count = evas_list_count(face->owner->status->governors); + governor_msg = malloc(sizeof(Edje_Message_String_Set) + (count - 1) * sizeof(char *)); + governor_msg->count = count; + for (l = face->owner->status->governors, i = 0; l; l = l->next, i++) + governor_msg->str[i] = (char *) l->data; + edje_object_message_send(face->freq_object, EDJE_MESSAGE_STRING_SET, 2, governor_msg); + free(governor_msg); +} + +static void +_cpufreq_face_update_current(Cpufreq_Face *face) +{ + Edje_Message_Int_Set *frequency_msg; + Edje_Message_String governor_msg; + + frequency_msg = malloc(sizeof(Edje_Message_Int_Set) + sizeof(int)); + frequency_msg->count = 2; + frequency_msg->val[0] = face->owner->status->cur_frequency; + frequency_msg->val[1] = face->owner->status->can_set_frequency; + edje_object_message_send(face->freq_object, EDJE_MESSAGE_INT_SET, 3, frequency_msg); + free(frequency_msg); + + governor_msg.str = face->owner->status->cur_governor; + edje_object_message_send(face->freq_object, EDJE_MESSAGE_STRING, 4, &governor_msg); + + if (face->owner->menu_frequency) + { + Evas_List *l; + + for (l = face->owner->menu_frequency->items; l; l = l->next) + { + E_Menu_Item *mi; + int freq; + + mi = l->data; + freq = (int)e_object_data_get(E_OBJECT(mi)); + if (freq == face->owner->status->cur_frequency) + { + e_menu_item_toggle_set(mi, 1); + break; + } + } + } + if (face->owner->menu_governor) + { + Evas_List *l; + + for (l = face->owner->menu_governor->items; l; l = l->next) + { + E_Menu_Item *mi; + char *gov; + + mi = l->data; + gov = (char *)e_object_data_get(E_OBJECT(mi)); + if ((face->owner->status->can_set_frequency) && + (!strcmp(gov, "userspace"))) + { + e_menu_item_toggle_set(mi, 1); + break; + } + else if ((!face->owner->status->can_set_frequency) && + (!strcmp(gov, "ondemand"))) + { + e_menu_item_toggle_set(mi, 1); + break; + } + } + } +} + +static void +_cpufreq_face_cb_set_frequency(void *data, Evas_Object *obj, const char *emission, const char *src) +{ + int pid; + Cpufreq *e; + Evas_List *l; + int next_frequency = 0; + char buf[128]; + + e = data; + + for (l = e->status->frequencies; l; l = l->next) + { + if (e->status->cur_frequency == (int) l->data) + { + if (!strcmp(emission, "increase_frequency")) + { + if (l->next) + next_frequency = (int) l->next->data; + break; + } + else if (!strcmp(emission, "decrease_frequency")) + { + if (l->prev) + next_frequency = (int) l->prev->data; + break; + } + else + break; + } + } + + if (next_frequency != 0) + _cpufreq_set_frequency(e, next_frequency); +} + +static void +_cpufreq_face_cb_set_governor(void *data, Evas_Object *obj, const char *emission, const char *src) +{ + int pid; + Cpufreq *e; + Evas_List *l; + char *next_governor = NULL; + + e = data; + + for (l = e->status->governors; l; l = l->next) + { + if (!strcmp(l->data, e->status->cur_governor)) + { + if (l->next) + next_governor = l->next->data; + else + next_governor = e->status->governors->data; + break; + } + } + + if (next_governor != NULL) + _cpufreq_set_governor(e, next_governor); +} diff --git a/src/modules/cpufreq/e_mod_main.h b/src/modules/cpufreq/e_mod_main.h new file mode 100644 index 000000000..667df298c --- /dev/null +++ b/src/modules/cpufreq/e_mod_main.h @@ -0,0 +1,69 @@ +#ifndef E_MOD_MAIN_H +#define E_MOD_MAIN_H + +#include +#include + +typedef struct _Status Status; +typedef struct _Config Config; +typedef struct _Config_Face Config_Face; +typedef struct _Cpufreq Cpufreq; +typedef struct _Cpufreq_Face Cpufreq_Face; + +struct _Status +{ + Evas_List *frequencies; + Evas_List *governors; + int cur_frequency; + int can_set_frequency; + char *cur_governor; +}; + +struct _Config +{ + double poll_time; + Evas_List *faces; +}; + +struct _Config_Face +{ + unsigned char enabled; +}; + +struct _Cpufreq +{ + E_Menu *config_menu; + E_Menu *config_menu_poll; + E_Menu *menu_governor; + E_Menu *menu_frequency; + Evas_List *faces; + + Config *conf; + Status *status; + + char *set_exe_path; + + Ecore_Timer *frequency_check_timer; +}; + +struct _Cpufreq_Face +{ + E_Container *con; + + E_Menu *menu; + Config_Face *conf; + Cpufreq *owner; + + Evas_Object *freq_object; + Evas_Object *event_object; + + E_Gadman_Client *gmc; +}; + +EAPI void *init (E_Module *module); +EAPI int shutdown (E_Module *module); +EAPI int save (E_Module *module); +EAPI int info (E_Module *module); +EAPI int about (E_Module *module); + +#endif diff --git a/src/modules/cpufreq/freqset.c b/src/modules/cpufreq/freqset.c new file mode 100644 index 000000000..da07e1924 --- /dev/null +++ b/src/modules/cpufreq/freqset.c @@ -0,0 +1,57 @@ +#include + +int +main(int argc, char *argv[]) +{ + int new_frequency = 0; + char *new_governor = NULL; + char buf[4096]; + FILE *f; + + if (argc != 3) + { + fprintf(stderr, "Invalid command. Syntax:\n"); + fprintf(stderr, "\tfreqset \n"); + return 1; + } + + if (seteuid(0)) + { + fprintf(stderr, "Unable to assume root privileges\n"); + } + + if (!strcmp(argv[1], "frequency")) + { + new_frequency = atoi(argv[2]); + + f = fopen("/sys/devices/system/cpu/cpu0/cpufreq/scaling_setspeed", "w"); + if (!f) + { + fprintf(stderr, "Unable to open frequency interface for writing.\n"); + return 1; + } + fprintf(f, "%d\n", new_frequency); + fclose(f); + + return 0; + } + else if (!strcmp(argv[1], "governor")) + { + f = fopen("/sys/devices/system/cpu/cpu0/cpufreq/scaling_governor", "w"); + if (!f) + { + fprintf(stderr, "Unable to open governor interface for writing.\n"); + return 1; + } + fprintf(f, "%s\n", argv[2]); + fclose(f); + + return 0; + } + else + { + fprintf(stderr, "Unknown command.\n"); + return 1; + } + seteuid(-1); +} diff --git a/src/modules/cpufreq/module_icon.png b/src/modules/cpufreq/module_icon.png new file mode 100644 index 000000000..3173ee0de Binary files /dev/null and b/src/modules/cpufreq/module_icon.png differ diff --git a/src/modules/temperature/e_mod_main.c b/src/modules/temperature/e_mod_main.c index 2ae0b980c..6589ed34f 100644 --- a/src/modules/temperature/e_mod_main.c +++ b/src/modules/temperature/e_mod_main.c @@ -660,7 +660,7 @@ _temperature_face_new(E_Container *con) e_gadman_client_min_size_set(ef->gmc, 4, 4); e_gadman_client_max_size_set(ef->gmc, 128, 128); e_gadman_client_auto_size_set(ef->gmc, 40, 40); - e_gadman_client_align_set(ef->gmc, 0.9, 1.0); + e_gadman_client_align_set(ef->gmc, 1.0, 1.0); e_gadman_client_resize(ef->gmc, 40, 40); e_gadman_client_change_func_set(ef->gmc, _temperature_face_cb_gmc_change, ef); e_gadman_client_load(ef->gmc);