Initial import

1 files changed, 268 insertions, 0 deletions

diff --git a/indicator-powersave.patch b/indicator-powersave.patch
new file mode 100644
index 000000000000..2762b2e514a1
--- /dev/null
+++ b/indicator-powersave.patch
@@ -0,0 +1,268 @@
+--- indicator-cpufreq/bin/indicator-cpufreq-selector	2014-12-27 02:48:58.330816000 +0900
++++ indicator-cpufreq/bin/indicator-cpufreq-selector	2014-12-27 02:25:45.903998358 +0900
+@@ -21,6 +21,8 @@
+ import dbus.service
+ import dbus.mainloop.glib
+ 
++import subprocess
++
+ from indicator_cpufreq import cpufreq
+ 
+ class PermissionDeniedByPolicy(dbus.DBusException):
+@@ -42,6 +44,15 @@
+         self._package_operation_in_progress = False
+ 
+     @dbus.service.method(dbus_interface='com.ubuntu.IndicatorCpufreqSelector',
++        in_signature='as',
++        out_signature='',
++        sender_keyword='sender',
++        connection_keyword='conn')
++    def SetThrottle(self, throttle, sender=None, conn=None):
++        self._check_polkit_privilege(sender, conn, 'com.ubuntu.indicatorcpufreqselector.setthrottle')
++        error = subprocess.Popen(["/bin/sh", "throttle", throttle])
++
++    @dbus.service.method(dbus_interface='com.ubuntu.IndicatorCpufreqSelector',
+         in_signature='auu',
+         out_signature='',
+         sender_keyword='sender',
+@@ -61,6 +72,33 @@
+         for cpu in cpus:
+             error = cpufreq.modify_policy_governor(cpu, governor)
+ 
++    @dbus.service.method(dbus_interface='com.ubuntu.IndicatorCpufreqSelector',
++        in_signature='as',
++        out_signature='',
++        sender_keyword='sender',
++        connection_keyword='conn')
++    def SetPSTurbo(self, psturbo, sender=None, conn=None):
++        self._check_polkit_privilege(sender, conn, 'com.ubuntu.indicatorcpufreqselector.setpsturbo')
++        error = subprocess.Popen(["/bin/sh", "throttle", psturbo])
++
++    @dbus.service.method(dbus_interface='com.ubuntu.IndicatorCpufreqSelector',
++        in_signature='as',
++        out_signature='',
++        sender_keyword='sender',
++        connection_keyword='conn')
++    def SetHyperthreads(self, hyperthreads, sender=None, conn=None):
++        self._check_polkit_privilege(sender, conn, 'com.ubuntu.indicatorcpufreqselector.sethyperthreads')
++        error = subprocess.Popen(["/bin/sh", "throttle", hyperthreads])
++
++    @dbus.service.method(dbus_interface='com.ubuntu.IndicatorCpufreqSelector',
++        in_signature='as',
++        out_signature='',
++        sender_keyword='sender',
++        connection_keyword='conn')
++    def SetGPUThrottle(self, gputhrottle, sender=None, conn=None):
++        self._check_polkit_privilege(sender, conn, 'com.ubuntu.indicatorcpufreqselector.setgputhrottle')
++        error = subprocess.Popen(["/bin/sh", "throttle", gputhrottle])
++
+     def _check_polkit_privilege(self, sender, conn, privilege):
+         '''Verify that sender has a given PolicyKit privilege.
+ 
+--- indicator-cpufreq/indicator_cpufreq/com.ubuntu.indicatorcpufreq.policy.in	2014-12-27 02:48:58.330816000 +0900
++++ indicator-cpufreq/indicator_cpufreq/com.ubuntu.indicatorcpufreq.policy.in	2014-12-27 02:29:19.809678757 +0900
+@@ -13,13 +13,55 @@
+   <vendor_url>https://launchpad.net/indicator-cpufreq</vendor_url>
+   <icon_name>indicator-cpufreq</icon_name>
+ 
++  <action id="com.ubuntu.indicatorcpufreqselector.setthrottle">
++    <_description>Change device powersaving settings</_description>
++    <_message>System policy prevents you from changing system throttle.</_message>
++
++    <defaults>
++      <allow_inactive>no</allow_inactive>
++      <allow_active>yes</allow_active>
++    </defaults>
++  </action>
++
+   <action id="com.ubuntu.indicatorcpufreqselector.setfrequencyscaling">
+     <_description>Change CPU frequency scaling</_description>
+     <_message>System policy prevents you from changing CPU frequency scaling.</_message>
+ 
+     <defaults>
+       <allow_inactive>no</allow_inactive>
+-      <allow_active>auth_admin_keep</allow_active>
++      <allow_active>yes</allow_active>
++    </defaults>
++  </action>
++
++  <action id="com.ubuntu.indicatorcpufreqselector.setpsturbo">
++    <_description>Change Intel P-State Turbo settings</_description>
++    <_message>System policy prevents you from changing P-State Turbo.</_message>
++
++    <defaults>
++      <allow_inactive>no</allow_inactive>
++      <allow_active>yes</allow_active>
++    </defaults>
++  </action>
++
++  <action id="com.ubuntu.indicatorcpufreqselector.sethyperthreads">
++    <_description>Change hyperthreading settings</_description>
++    <_message>System policy prevents you from changing hyperthreading.</_message>
++
++    <defaults>
++      <allow_inactive>no</allow_inactive>
++      <allow_active>yes</allow_active>
+     </defaults>
+   </action>
++
++  <action id="com.ubuntu.indicatorcpufreqselector.setgputhrottle">
++    <_description>Change GPU throttle settings</_description>
++    <_message>System policy prevents you from changing GPU throttle.</_message>
++
++    <defaults>
++      <allow_inactive>no</allow_inactive>
++      <allow_active>yes</allow_active>
++    </defaults>
++  </action>
++
++
+ </policyconfig>
+--- indicator-cpufreq/indicator_cpufreq/indicator.py	2014-12-27 02:48:58.330816000 +0900
++++ indicator-cpufreq/indicator_cpufreq/indicator.py	2014-12-27 02:47:58.102868291 +0900
+@@ -29,6 +29,10 @@
+ from gettext import gettext as _
+ #gettext.textdomain('indicator-cpufreq')
+ 
++
++def readable_throttle(t):
++        return t
++
+ def readable_frequency(f):
+     # temp hack for properly displaying intel turbo mode (actual freq + 1000kHz)
+     label = _("%s GHz") % locale.format(_("%.2f"), f / 1.0e6)
+@@ -50,6 +54,15 @@
+     else:
+         return g
+ 
++def readable_psturbo(t):
++        return t
++
++def readable_hyperthreads(h):
++        return h
++
++def readable_gputhrottles(gt):
++        return gt
++
+ class MyIndicator(object):
+     def __init__(self, show_frequency=False):
+         self.show_frequency = show_frequency
+@@ -70,29 +83,91 @@
+         while cpufreq.cpu_exists(maxcpu) == 0:
+             maxcpu += 1
+         self.cpus = range(maxcpu)
+         
++        # throttle menu items
++        throttles = ['full', 'cut']
++        throtmenu = Gtk.Menu()
++        throtm = Gtk.MenuItem("System Throttle")
++        throtm.set_submenu(throtmenu)
++        for toggle in throttles:
++            menu_item = Gtk.RadioMenuItem.new_with_label(group, readable_throttle(toggle))
++            group = menu_item.get_group()
++            throtmenu.append(menu_item)
++            menu_item.connect('activate', self.select_activated, 'throttle', toggle)
++            self.select_items[toggle] = menu_item
++        menu.append(throtm)
++
++        menu.append(Gtk.SeparatorMenuItem())
++
+         # frequency menu items
+         #freqs = cpufreq.get_available_frequencies(self.cpus[0])
+         freqs = reversed(sorted(set(cpufreq.get_available_frequencies(self.cpus[0]))))
++        freqmenu = Gtk.Menu()
++        freqm = Gtk.MenuItem("CPU Frequency")
++        freqm.set_submenu(freqmenu)
+         for freq in freqs:
+             menu_item = Gtk.RadioMenuItem.new_with_label(group, readable_frequency(freq))
+             group = menu_item.get_group()
+-            menu.append(menu_item)
++            freqmenu.append(menu_item)
+             menu_item.connect("activate", self.select_activated, 'frequency', freq)
+             self.select_items[freq] = menu_item
++        menu.append(freqm)
+ 
+-        menu.append(Gtk.SeparatorMenuItem())
+-
+         # governor menu items
+         governors = cpufreq.get_available_governors(self.cpus[0])
++        govmenu = Gtk.Menu()
++        govm = Gtk.MenuItem("CPU Governor")
++        govm.set_submenu(govmenu)
+         for governor in governors:
+             if governor == 'userspace':
+                 continue
+             menu_item = Gtk.RadioMenuItem.new_with_label(group, readable_governor(governor))
+             group = menu_item.get_group()
+-            menu.append(menu_item)
++            govmenu.append(menu_item)
+             menu_item.connect('activate', self.select_activated, 'governor', governor)
+             self.select_items[governor] = menu_item
++        menu.append(govm)
++
++        # p-state turbo menu items
++        psturbo = ['on', 'off']
++        pstmenu = Gtk.Menu()
++        pstm = Gtk.MenuItem("P-State Turbo")
++        pstm.set_submenu(pstmenu)
++        for toggle in psturbo:
++            menu_item = Gtk.RadioMenuItem.new_with_label(group, readable_psturbo(toggle))
++            group = menu_item.get_group()
++            pstmenu.append(menu_item)
++            menu_item.connect('activate', self.select_activated, 'psturbo', toggle)
++            self.select_items[toggle] = menu_item
++        menu.append(pstm)
++
++        # hyperthreading menu items
++        hyperthreads = ['on', 'off']
++        htmenu = Gtk.Menu()
++        htm = Gtk.MenuItem("Hyperthreads")
++        htm.set_submenu(htmenu)
++        for toggle in hyperthreads:
++            menu_item = Gtk.RadioMenuItem.new_with_label(group, readable_hyperthreads(toggle))
++            group = menu_item.get_group()
++            htmenu.append(menu_item)
++            menu_item.connect('activate', self.select_activated, 'hyperthreads', toggle)
++            self.select_items[toggle] = menu_item
++        menu.append(htm)
++
++        menu.append(Gtk.SeparatorMenuItem())
++
++        # gpu runtime pm menu items
++        gputhrottles = ['full', 'cut']
++        gpumenu = Gtk.Menu()
++        gpum = Gtk.MenuItem("GPU Throttle")
++        gpum.set_submenu(gpumenu)
++        for toggle in gputhrottles:
++            menu_item = Gtk.RadioMenuItem.new_with_label(group, readable_gputhrottles(toggle))
++            group = menu_item.get_group()
++            gpumenu.append(menu_item)
++            menu_item.connect('activate', self.select_activated, 'gputhrottle', toggle)
++            self.select_items[toggle] = menu_item
++        menu.append(gpum)
+ 
+         menu.show_all()        
+         self.ind.set_menu(menu)
+@@ -134,9 +210,21 @@
+             bus = dbus.SystemBus()
+             proxy = bus.get_object("com.ubuntu.IndicatorCpufreqSelector", "/Selector", introspect=False)
+             cpus = [dbus.UInt32(cpu) for cpu in self.cpus]
+-            if select == 'frequency':
++            if select == 'throttle':
++                proxy.SetThrottle(value,
++                    dbus_interface='com.ubuntu.IndicatorCpufreqSelector')
++            elif select == 'frequency':
+                 proxy.SetFrequency(cpus, dbus.UInt32(value),
+                     dbus_interface='com.ubuntu.IndicatorCpufreqSelector')
++            elif select == 'psturbo':
++                proxy.SetPSTurbo("turbo-" + value,
++                    dbus_interface='com.ubuntu.IndicatorCpufreqSelector')
++            elif select == 'hyperthreads':
++                proxy.SetHyperthreads("ht-" + value,
++                    dbus_interface='com.ubuntu.IndicatorCpufreqSelector')
++            elif select == 'gputhrottle':
++                proxy.SetGPUThrottle("gpu-" + value,
++                    dbus_interface='com.ubuntu.IndicatorCpufreqSelector')
+             else:
+                 proxy.SetGovernor(cpus, value,
+                     dbus_interface='com.ubuntu.IndicatorCpufreqSelector')