Merge lp:~sforshee/powerd/thermal-shutdown into lp:powerd

[Seth Forshee]

Add thermal shutdown support

Add thermal shutdown support

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:88
http://jenkins.qa.ubuntu.com/job/powerd-ci/108/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/powerd-saucy-armhf-ci/62
        deb: http://jenkins.qa.ubuntu.com/job/powerd-saucy-armhf-ci/62/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins:8080/job/powerd-ci/108/rebuild

review: Approve (continuous-integration)

[lp:~sforshee/powerd/thermal-shutdown]

89. By Seth Forshee on 2013-08-30

Merge with autobrightness

90. By Seth Forshee on 2013-08-30

power-source: Read thermal shutdown temperature from device config

Unmerged revisions

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2013-08-09 19:53:58 +0000
+++ CMakeLists.txt	2013-08-30 13:59:21 +0000
@@ -33,11 +33,17 @@
 )
 SET_SOURCE_FILES_PROPERTIES(${CMAKE_CURRENT_BINARY_DIR}/src/${POWERD_GENERATED_SOURCES} PROPERTIES GENERATED 1)
 
+set(POWERD_DEVICE_CONFIGS_PATH "${CMAKE_INSTALL_PREFIX}/share/powerd/device_configs")
+FILE(GLOB device_config_files "${CMAKE_CURRENT_SOURCE_DIR}/data/device_configs/*.xml")
+add_definitions(-DPOWERD_DEVICE_CONFIGS_PATH=\"${POWERD_DEVICE_CONFIGS_PATH}\")
+
 set(
   SRCS
 
   src/powerd.cpp
+  src/autobrightness.c
   src/backlight.c
+  src/device-config.c
   src/display.c
   src/display-request.c
   src/log.c
@@ -46,6 +52,7 @@
   src/powerd-client.c
   src/powerd-object.c
   src/powerd-sensors.cpp
+  src/spline.c
   src/stats.c
   src/util.c
   src/${GDBUS_NAME}.c
@@ -104,6 +111,7 @@
   ${GIO-UNIX_LIBRARIES}
   ${PHABLET_LIBRARIES}
   "-lubuntu_application_api"
+  "-landroid-properties"
   ${LIBUDEV_LIBRARIES}
   ${UPOWER_GLIB_LIBRARIES}
   ${UUID_LIBRARIES}
@@ -115,3 +123,8 @@
   LIBRARY DESTINATION lib
   ARCHIVE DESTINATION lib/static
 )
+
+install(
+  FILES ${device_config_files}
+  DESTINATION ${POWERD_DEVICE_CONFIGS_PATH}
+)

=== added directory 'data/device_configs'
=== added file 'data/device_configs/config-default.xml'
--- data/device_configs/config-default.xml	1970-01-01 00:00:00 +0000
+++ data/device_configs/config-default.xml	2013-08-30 13:59:21 +0000
@@ -0,0 +1,69 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+** Copyright 2009, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+-->
+
+<!-- These resources are around just to allow their values to be customized
+     for different hardware and product builds.  Do not translate. -->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- Flag indicating whether the we should enable the automatic brightness in Settings.
+         Software implementation will be used if config_hardware_auto_brightness_available is not set -->
+    <bool name="config_automatic_brightness_available">false</bool>
+
+    <!-- Display low battery warning when battery level dips to this value.
+         Also, the battery stats are flushed to disk when we hit this level.  -->
+    <integer name="config_criticalBatteryWarningLevel">4</integer>
+
+    <!-- Shutdown if the battery temperature exceeds (this value * 0.1) Celsius. -->
+    <integer name="config_shutdownBatteryTemperature">680</integer>
+
+    <!-- Array of light sensor LUX values to define our levels for auto backlight brightness support.
+         The N entries of this array define N + 1 control points as follows:
+         (1-based arrays)
+
+         Point 1:            (0, value[1]):             lux <= 0
+         Point 2:     (level[1], value[2]):  0        < lux <= level[1]
+         Point 3:     (level[2], value[3]):  level[2] < lux <= level[3]
+         ...
+         Point N+1: (level[N], value[N+1]):  level[N] < lux
+
+         The control points must be strictly increasing.  Each control point
+         corresponds to an entry in the brightness backlight values arrays.
+         For example, if LUX == level[1] (first element of the levels array)
+         then the brightness will be determined by value[2] (second element
+         of the brightness values array).
+
+         Spline interpolation is used to determine the auto-brightness
+         backlight values for LUX levels between these control points.
+
+         Must be overridden in platform specific overlays -->
+    <integer-array name="config_autoBrightnessLevels">
+    </integer-array>
+
+    <!-- Screen brightness used to dim the screen when the user activity
+         timeout expires.  May be less than the minimum allowed brightness setting
+         that can be set by the user. -->
+    <integer name="config_screenBrightnessDim">10</integer>
+
+    <!-- Array of output values for LCD backlight corresponding to the LUX values
+         in the config_autoBrightnessLevels array.  This array should have size one greater
+         than the size of the config_autoBrightnessLevels array.
+         The brightness values must be between 0 and 255 and be non-decreasing.
+         This must be overridden in platform specific overlays -->
+    <integer-array name="config_autoBrightnessLcdBacklightValues">
+    </integer-array>
+</resources>

=== added file 'data/device_configs/config-grouper.xml'
--- data/device_configs/config-grouper.xml	1970-01-01 00:00:00 +0000
+++ data/device_configs/config-grouper.xml	2013-08-30 13:59:21 +0000
@@ -0,0 +1,75 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+** Copyright 2009, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+-->
+
+<!-- These resources are around just to allow their values to be customized
+     for different hardware and product builds. -->
+<resources>
+    <!-- Flag indicating whether the we should enable the automatic brightness in Settings.
+         Software implementation will be used if config_hardware_auto_brightness_available is not set -->
+    <bool name="config_automatic_brightness_available">true</bool>
+
+    <!-- Array of light sensor LUX values to define our levels for auto backlight brightness support.
+         The N entries of this array define N  1 zones as follows:
+
+         Zone 0:        0 <= LUX < array[0]
+         Zone 1:        array[0] <= LUX < array[1]
+         ...
+         Zone N:        array[N - 1] <= LUX < array[N]
+         Zone N + 1     array[N] <= LUX < infinity
+
+         Must be overridden in platform specific overlays -->
+    <integer-array name="config_autoBrightnessLevels">
+        <item>5</item>
+        <item>15</item>
+        <item>50</item>
+        <item>100</item>
+        <item>200</item>
+        <item>400</item>
+        <item>1000</item>
+        <item>2000</item>
+        <item>3000</item>
+        <item>5000</item>
+        <item>10000</item>
+        <item>30000</item>
+    </integer-array>
+
+
+    <!-- Array of output values for LCD backlight corresponding to the LUX values
+         in the config_autoBrightnessLevels array.  This array should have size one greater
+         than the size of the config_autoBrightnessLevels array.
+         This must be overridden in platform specific overlays -->
+    <integer-array name="config_autoBrightnessLcdBacklightValues">
+        <item>5</item>    <!-- 0-5 -->
+        <item>20</item>   <!-- 5-15 -->
+        <item>30</item>   <!-- 15-50 -->
+        <item>40</item>   <!-- 50-100 -->
+        <item>50</item>   <!-- 100-200 -->
+        <item>60</item>   <!-- 200-400 -->
+        <item>70</item>   <!-- 400-1000 -->
+        <item>80</item>   <!-- 1000-2000 -->
+        <item>130</item>  <!-- 2000-3000 -->
+        <item>180</item>  <!-- 3000-5000 -->
+        <item>255</item>  <!-- 5000-10000 -->
+        <item>255</item>  <!-- 10000-30000 -->
+        <item>255</item>  <!-- 30000+ -->
+    </integer-array>
+
+    <!-- Minimum screen brightness allowed by the power manager. -->
+    <integer name="config_screenBrightnessDim">5</integer>
+</resources>

=== added file 'data/device_configs/config-maguro.xml'
--- data/device_configs/config-maguro.xml	1970-01-01 00:00:00 +0000
+++ data/device_configs/config-maguro.xml	2013-08-30 13:59:21 +0000
@@ -0,0 +1,88 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+** Copyright 2011, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+-->
+
+<!-- These resources are around just to allow their values to be customized
+     for different hardware and product builds. -->
+<resources>
+    <!-- Flag indicating whether we should enable the automatic brightness in Settings.
+         config_hardware_automatic_brightness_available is not set, so we will use software implementation -->
+    <bool name="config_automatic_brightness_available">true</bool>
+
+    <!-- Array of light sensor LUX values to define our levels for auto backlight brightness support.
+         The N entries of this array define N + 1 zones as follows:
+
+         Zone 0:        0 <= LUX < array[0]
+         Zone 1:        array[0] <= LUX < array[1]
+         ...
+         Zone N:        array[N - 1] <= LUX < array[N]
+         Zone N + 1:    array[N] <= LUX < infinity
+
+         Must be overridden in platform specific overlays -->
+    <integer-array name="config_autoBrightnessLevels">
+        <item>6</item>
+	<item>9</item>
+	<item>14</item>
+	<item>20</item>
+	<item>30</item>
+	<item>46</item>
+	<item>68</item>
+        <item>103</item>
+	<item>154</item>
+        <item>231</item>
+	<item>346</item>
+	<item>519</item>
+	<item>778</item>
+	<item>1168</item>
+	<item>1752</item>
+	<item>2627</item>
+	<item>3941</item>
+        <item>5912</item>
+	<item>8867</item>
+    </integer-array>
+
+    <!-- Array of output values for LCD backlight corresponding to the LUX values
+         in the config_autoBrightnessLevels array.  This array should have size one greater
+         than the size of the config_autoBrightnessLevels array.
+    -->
+    <integer-array name="config_autoBrightnessLcdBacklightValues">
+        <item>19</item>
+	<item>23</item>
+	<item>26</item>
+	<item>30</item>
+	<item>34</item>
+	<item>39</item>
+	<item>45</item>
+        <item>51</item>
+        <item>59</item>
+        <item>67</item>
+        <item>77</item>
+        <item>88</item>
+	<item>101</item>
+	<item>116</item>
+	<item>133</item>
+	<item>152</item>
+	<item>174</item>
+	<item>199</item>
+	<item>228</item>
+        <item>250</item>
+    </integer-array>
+
+    <!-- Minimum screen brightness allowed by the power manager. -->
+    <integer name="config_screenBrightnessDim">10</integer>
+</resources>

=== added file 'data/device_configs/config-mako.xml'
--- data/device_configs/config-mako.xml	1970-01-01 00:00:00 +0000
+++ data/device_configs/config-mako.xml	2013-08-30 13:59:21 +0000
@@ -0,0 +1,75 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+** Copyright 2012, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+-->
+
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+
+    <!-- Flag indicating whether the we should enable the automatic brightness in Settings.
+         Software implementation will be used if config_hardware_auto_brightness_available is not set -->
+    <bool name="config_automatic_brightness_available">true</bool>
+
+    <!-- Array of light sensor LUX values to define our levels for auto backlight brightness support.
+         The N entries of this array define N  1 zones as follows:
+
+         Zone 0:        0 <= LUX < array[0]
+         Zone 1:        array[0] <= LUX < array[1]
+         ...
+         Zone N:        array[N - 1] <= LUX < array[N]
+         Zone N + 1     array[N] <= LUX < infinity
+
+         Must be overridden in platform specific overlays -->
+    <integer-array name="config_autoBrightnessLevels">
+        <item>10</item>
+        <item>50</item>
+        <item>100</item>
+        <item>200</item>
+        <item>400</item>
+        <item>500</item>
+        <item>800</item>
+        <item>1000</item>
+        <item>1600</item>
+        <item>3000</item>
+        <item>10000</item>
+    </integer-array>
+
+    <!-- Array of output values for LCD backlight corresponding to the LUX values
+         in the config_autoBrightnessLevels array.  This array should have size one greater
+         than the size of the config_autoBrightnessLevels array.
+         This must be overridden in platform specific overlays -->
+    <integer-array name="config_autoBrightnessLcdBacklightValues">
+        <item>14</item>   <!-- 0-10 -->
+        <item>28</item>   <!-- 10-50 -->
+        <item>37</item>   <!-- 50-100 -->
+        <item>51</item>   <!-- 100-200 -->
+        <item>71</item>   <!-- 200-400 -->
+        <item>80</item>   <!-- 400-500 -->
+        <item>96</item>   <!-- 500-800 -->
+        <item>108</item>  <!-- 800-1000 -->
+        <item>144</item>  <!-- 1000-1600 -->
+        <item>181</item>  <!-- 1600-3000 -->
+        <item>254</item>  <!-- 3000-10000 -->
+        <item>255</item>  <!-- 10000+ -->
+    </integer-array>
+
+    <!-- Minimum screen brightness allowed by the power manager. -->
+    <integer name="config_screenBrightnessDim">1</integer>
+
+    <!-- Shutdown if the battery temperature exceeds (this value * 0.1) Celsius. -->
+    <integer name="config_shutdownBatteryTemperature">600</integer>
+
+</resources>

=== added file 'data/device_configs/config-manta.xml'
--- data/device_configs/config-manta.xml	1970-01-01 00:00:00 +0000
+++ data/device_configs/config-manta.xml	2013-08-30 13:59:21 +0000
@@ -0,0 +1,74 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+** Copyright 2009, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+-->
+
+<!-- These resources are around just to allow their values to be customized
+     for different hardware and product builds. -->
+<resources>
+    <!-- Flag indicating whether we should enable the automatic brightness in Settings.
+         config_hardware_automatic_brightness_available is not set, so we will use software implementation -->
+    <bool name="config_automatic_brightness_available">true</bool>
+
+    <!-- Array of light sensor LUX values to define our levels for auto backlight brightness support.
+         The N entries of this array define N + 1 control points as follows:
+         (1-based arrays)
+
+         Point 1:            (0, value[1]):             lux <= 0
+         Point 2:     (level[1], value[2]):  0        < lux <= level[1]
+         Point 3:     (level[2], value[3]):  level[2] < lux <= level[3]
+         ...
+         Point N+1: (level[N], value[N+1]):  level[N] < lux
+
+         The control points must be strictly increasing.  Each control point
+         corresponds to an entry in the brightness backlight values arrays.
+         For example, if LUX == level[1] (first element of the levels array)
+         then the brightness will be determined by value[2] (second element
+         of the brightness values array).
+
+         Spline interpolation is used to determine the auto-brightness
+         backlight values for LUX levels between these control points.
+
+         Must be overridden in platform specific overlays -->
+    <integer-array name="config_autoBrightnessLevels">
+        <item>10</item>      <!-- Pitch black 0, and 9 is next possible value. -->
+        <item>30</item>      <!-- Sensor in dark office: 60, well lit: 220 -->
+        <item>90</item>      <!-- Sensor in dark office: 60, well lit: 220 -->
+        <item>15000</item>   <!-- Screen under direct sunlight, but not sensor. -->
+        <item>225000</item>  <!-- Sensor under direct sunlight. -->
+    </integer-array>
+
+    <!-- Array of output values for LCD backlight corresponding to the LUX values
+         in the config_autoBrightnessLevels array.  This array should have size one greater
+         than the size of the config_autoBrightnessLevels array.
+         The brightness values must be between 0 and 255 and be non-decreasing.
+         This must be overridden in platform specific overlays -->
+    <integer-array name="config_autoBrightnessLcdBacklightValues">
+        <item>10</item>
+        <item>13</item>
+        <item>65</item>
+        <item>85</item>
+        <item>220</item>
+        <item>255</item>
+    </integer-array>
+
+    <!-- Screen brightness used to dim the screen when the user activity
+         timeout expires.  May be less than the minimum allowed brightness setting
+         that can be set by the user. -->
+    <integer name="config_screenBrightnessDim">2</integer>
+
+</resources>

=== modified file 'debian/control'
--- debian/control	2013-08-03 08:21:09 +0000
+++ debian/control	2013-08-30 13:59:21 +0000
@@ -8,6 +8,7 @@
                libhybris-dev,
                libudev-dev,
                python,
+               libandroid-properties-dev,
                libplatform-api1-dev,
                libupower-glib-dev,
                uuid-dev,

=== added file 'src/autobrightness.c'
--- src/autobrightness.c	1970-01-01 00:00:00 +0000
+++ src/autobrightness.c	2013-08-30 13:59:21 +0000
@@ -0,0 +1,357 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This file is part of powerd.
+ *
+ * powerd 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; version 3.
+ *
+ * powerd 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 program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdlib.h>
+#include <errno.h>
+#include <math.h>
+#include <glib.h>
+
+#include "powerd-internal.h"
+#include "device-config.h"
+#include "log.h"
+#include "spline.h"
+
+/*
+ * Autobrightness Control Algorithm
+ *
+ * Automatic backlight adjustments should respond quickly to changes in
+ * the ambient brightness without constantly adjusting for minor or
+ * transient changes in ambient brightness. The following mechanisms are
+ * employed to maintain this balance.
+ *
+ * EXPONENTIAL SMOOTHING
+ *
+ * Rather than processing incoming lux values directly, an exponential
+ * moving average is calculated using an algorithm based off of the
+ * formulation known as "Brown's simple exponential smoothing" [1]:
+ *
+ *   S(n) = a * x(n) + (1 - a) * S(n - 1)
+ *        = S(n - 1) + a * (x(n) - S(n - 1))
+ *
+ * where 0 <= a <= 1. To make smoothing time-based, a is calculated
+ * based on the amount of time spent at a given lux value.
+ *
+ *   delta_t = t(n) - t(n - 1)
+ *   a(n) = delta_t / (C + delta_t)
+ *
+ * This gives decreasing weight to older samples. Smaller values of C
+ * will cause faster decay of old samples, giving a faster response
+ * time, while larger values of C create slower decay and give more
+ * filtering of transient events.
+ *
+ * This code usese two moving averages, one which responds slowly to
+ * changes and another which responds quickly. The slow average is used
+ * to detect the trend with less sensitivity to transient events, while
+ * the fast average is used for picking the brightness once we've
+ * decided to change it.
+ *
+ * HYSTERESIS
+ *
+ * To avoid making constant adjustments to screen brightness in response
+ * to small changes in ambient lighting conditions, the change in lux is
+ * required to exceed some threshold before changing screen brightness.
+ *
+ * DEBOUNCING
+ *
+ * Changes in ambient brightness which exceed the hysteresis threshold
+ * must do so for some minimum amount of time before any changes in
+ * screen brightness will be made. This "debounces" the incoming lux
+ * values and also helps to filter out transient changes in ambient
+ * conditions.
+ *
+ * [1] http://en.wikipedia.org/wiki/Exponential_smoothing
+ */
+
+#define SMOOTHING_FACTOR_SLOW 2000.0f
+#define SMOOTHING_FACTOR_FAST 200.0f
+#define HYSTERESIS_FACTOR 0.10f
+#define DEBOUNCE_MS 4000
+
+enum ab_state {
+    AB_STATE_DISABLED,
+    AB_STATE_INITIALIZING,
+    AB_STATE_IDLE,      /* Idle, nothing to do */
+    AB_STATE_DEBOUNCE,  /* Debouncing lux change */
+};
+
+struct ab_status {
+    enum ab_state state;
+    guint source_id;
+    double last_lux, applied_lux;
+    double average_slow, average_fast;
+    gint64 last_lux_ms;
+    struct ab_spline *spline;
+};
+
+static gboolean ab_supported = FALSE;
+static struct ab_status ab_status;
+struct spline *ab_spline;
+
+static gint64 get_ms(void)
+{
+    return g_get_monotonic_time() / 1000;
+}
+
+static double aggregate_lux(double old_average, double new_lux,
+                            double smoothing_factor, double time_delta)
+{
+    double alpha;
+    if (time_delta < 0.0f)
+        time_delta = 0.0f;
+    alpha = time_delta / (smoothing_factor + time_delta);
+    return old_average + alpha * (new_lux - old_average);
+}
+
+static enum ab_state process_state_debounce(guint *delay_ms)
+{
+    gint64 now;
+    double time_delta;
+    double slow_lux, fast_lux;
+    double hysteresis, slow_delta, fast_delta;
+    enum ab_state next;
+   
+    next = AB_STATE_IDLE;
+    *delay_ms = 0;
+
+    now = get_ms();
+    time_delta = (double)(now - ab_status.last_lux_ms);
+    slow_lux = aggregate_lux(ab_status.average_slow, ab_status.last_lux,
+                             SMOOTHING_FACTOR_SLOW, time_delta);
+    fast_lux = aggregate_lux(ab_status.average_fast, ab_status.last_lux,
+                             SMOOTHING_FACTOR_FAST, time_delta);
+    powerd_debug("%lld slow avg %f fast avg %f last %f",
+                 now, slow_lux, fast_lux, ab_status.last_lux);
+
+    /*
+     * Require that both slow and fast averages exceed hysteresis,
+     * and in the same direction.
+     */
+    hysteresis = ab_status.applied_lux * HYSTERESIS_FACTOR;
+    if (hysteresis < 2)
+        hysteresis = 2;
+    slow_delta = slow_lux - ab_status.applied_lux;
+    fast_delta = fast_lux - ab_status.applied_lux;
+    if ((slow_delta >= hysteresis && fast_delta >= hysteresis) ||
+        (-slow_delta >= hysteresis && -fast_delta >= hysteresis)) {
+        int brightness = (int)(spline_interpolate(ab_spline, fast_lux) + 0.5);
+        powerd_debug("set brightness %d", brightness);
+        powerd_set_brightness(brightness);
+        ab_status.applied_lux = fast_lux;
+    }
+
+    hysteresis = ab_status.last_lux * HYSTERESIS_FACTOR;
+    if (hysteresis < 2)
+        hysteresis = 2;
+    if (fabs(fast_lux - ab_status.last_lux) >= hysteresis) {
+        /*
+         * Average should settle near the last reported lux. If
+         * it hasn't made it there yet, continue debouncing.
+         */
+        next = AB_STATE_DEBOUNCE;
+        *delay_ms = DEBOUNCE_MS;
+    }
+
+    return next;
+}
+
+static gboolean ab_process(gpointer unused)
+{
+    guint delay = 0;
+
+    ab_status.source_id = 0;
+
+    switch (ab_status.state) {
+    case AB_STATE_DISABLED:
+    case AB_STATE_INITIALIZING:
+    case AB_STATE_IDLE:
+        /* Nothing to do */
+        break;
+    case AB_STATE_DEBOUNCE:
+        ab_status.state = process_state_debounce(&delay);
+        break;
+    default:
+        powerd_warn("Unexpected autobrightness state %d\n", ab_status.state);
+        ab_status.state = AB_STATE_IDLE;
+        break;
+    }
+
+    if (delay != 0 && ab_status.state != AB_STATE_IDLE)
+        ab_status.source_id = g_timeout_add(delay, ab_process, NULL);
+    return FALSE;
+}
+
+static gboolean handle_new_lux(gpointer data)
+{
+    gint64 now;
+    double lux;
+
+    if (!ab_supported)
+        return FALSE;
+
+    now = get_ms();
+    lux = *(double *)data;
+    g_free(data);
+
+    if (ab_status.state == AB_STATE_DISABLED)
+        return FALSE;
+
+    if (ab_status.state == AB_STATE_INITIALIZING) {
+        int brightness = (int)(spline_interpolate(ab_spline, lux) + 0.5);
+        powerd_debug("set brightness %d", brightness);
+        powerd_set_brightness(brightness);
+
+        ab_status.average_slow = lux;
+        ab_status.average_fast = lux;
+        ab_status.applied_lux = lux;
+        ab_status.state = AB_STATE_IDLE;
+    } else {
+        double time_delta;
+        /* Ignore duplicates */
+        if (lux == ab_status.last_lux)
+            return FALSE;
+        time_delta = (double)(now - ab_status.last_lux_ms);
+        ab_status.average_slow = aggregate_lux(ab_status.average_slow, lux,
+                                               SMOOTHING_FACTOR_SLOW,
+                                               time_delta);
+        ab_status.average_fast = aggregate_lux(ab_status.average_fast, lux,
+                                               SMOOTHING_FACTOR_FAST,
+                                               time_delta);
+    }
+    ab_status.last_lux = lux;
+    ab_status.last_lux_ms = now;
+
+    if (ab_status.state == AB_STATE_IDLE) {
+        ab_status.state = AB_STATE_DEBOUNCE;
+        ab_status.source_id = g_timeout_add(DEBOUNCE_MS, ab_process, NULL);
+    }
+
+    return FALSE;
+}
+
+void powerd_new_als_event(double lux)
+{
+    double *p_lux = g_memdup(&lux, sizeof(lux));
+    g_timeout_add(0, handle_new_lux, p_lux);
+}
+
+/* Must be run from main loop */
+void powerd_autobrightness_enable(void)
+{
+    /* Must not leave disabled state if we can't map lux to brightness */
+    if (!ab_supported)
+        return;
+
+    if (ab_status.state == AB_STATE_DISABLED) {
+        ab_status.state = AB_STATE_INITIALIZING;
+        powerd_sensors_als_enable();
+    }
+}
+
+/* Must be run from main loop */
+void powerd_autobrightness_disable(void)
+{
+    if (ab_status.state != AB_STATE_DISABLED) {
+        ab_status.state = AB_STATE_DISABLED;
+        powerd_sensors_als_disable();
+        if (ab_status.source_id != 0)
+            g_source_remove(ab_status.source_id);
+    }
+}
+
+int powerd_autobrightness_init(void)
+{
+    GValue v = G_VALUE_INIT;
+    GArray *levels = NULL, *lux = NULL;
+    double (*mappings)[2] = NULL;
+    int i;
+    int ret = -ENODEV;
+
+    if (device_config_get("automatic_brightness_available", &v)) {
+        powerd_info("Could not determine platform autobrightness capability, disabling");
+        goto error;
+    }
+
+    if (!G_VALUE_HOLDS_BOOLEAN(&v) || !g_value_get_boolean(&v)) {
+        powerd_info("Platform does not support autobrightness, disabling");
+        goto error;
+    }
+    g_value_unset(&v);
+
+    if (device_config_get("autoBrightnessLevels", &v)) {
+        powerd_info("No device-specific autobrightness lux table defined, disabling");
+        goto error;
+    }
+    if (G_VALUE_HOLDS_BOXED(&v))
+        lux = g_value_dup_boxed(&v);
+    g_value_unset(&v);
+    if (!lux || lux->len == 0) {
+        powerd_info("Invalid autobrighness lux levels, disabling");
+        goto error;
+    }
+
+    if (device_config_get("autoBrightnessLcdBacklightValues", &v)) {
+        powerd_info("No device-specific autobrightness backlight levels defined, disabling");
+        goto error;
+    }
+    if (G_VALUE_HOLDS_BOXED(&v))
+        levels = g_value_dup_boxed(&v);
+    g_value_unset(&v);
+    if (!levels || levels->len == 0) {
+        powerd_info("Invalid autobrighness backlight levels, disabling");
+        goto error;
+    }
+
+    /* We should have one more backlight level than lux values */
+    if (levels->len != lux->len + 1) {
+        powerd_info("Invalid lux->brightness mappings, autobrightness disabled");
+        goto error;
+    }
+
+    mappings = g_malloc(2 * sizeof(double) * levels->len);
+    for (i = 0; i < levels->len; i++) {
+        mappings[i][0] = (double)((i == 0) ? 0 : g_array_index(lux, guint, i-1));
+        mappings[i][1] = (double)g_array_index(levels, guint, i);
+    }
+
+    ab_status.state = AB_STATE_DISABLED;
+    ab_spline = spline_new(mappings, levels->len);
+    if (!ab_spline) {
+        ret = -ENOMEM;
+        goto error;
+    }
+    g_free(mappings);
+    ab_supported = TRUE;
+    return 0;
+
+error:
+    if (levels)
+        g_array_unref(levels);
+    if (lux)
+        g_array_unref(lux);
+    if (mappings)
+        g_free(mappings);
+    return ret;
+}
+
+void powerd_autobrightness_deinit(void)
+{
+    powerd_autobrightness_disable();
+    ab_supported = FALSE;
+    if (ab_spline)
+        spline_free(ab_spline);
+}

=== added file 'src/device-config.c'
--- src/device-config.c	1970-01-01 00:00:00 +0000
+++ src/device-config.c	2013-08-30 13:59:21 +0000
@@ -0,0 +1,407 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This file is part of powerd.
+ *
+ * powerd 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; version 3.
+ *
+ * powerd 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 program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#include <glib.h>
+#include <glib-object.h>
+#include <hybris/properties/properties.h>
+
+#include "powerd-internal.h"
+#include "device-config.h"
+#include "log.h"
+
+/*
+ * Android defines various device-specific parameters in files named
+ * config.xml. The general structure of the tags is:
+ *
+ *   <type name="config_foo">...</type>
+ *
+ * This will define a config option named "foo" of type "type". Types
+ * for arrays are included. For example, the following defines an
+ * array of integers:
+ *
+ *   <integer-array name="config_myIntArray">
+ *     <item>0</item>
+ *     <item>1</item>
+ *   </integer-array>
+ *
+ * In powerd we are only interested in a few specific variables. The
+ * code here offers fairly general parsing of the config files, but
+ * handling of only a few specific types is present.
+ */
+
+enum elem_type {
+    ELEM_TYPE_NONE,
+    ELEM_TYPE_BOOL,
+    ELEM_TYPE_INT,
+    ELEM_TYPE_STRING,
+    ELEM_TYPE_FRACTION,
+    ELEM_TYPE_DIMENSION,
+    ELEM_TYPE_INT_ARRAY,
+    ELEM_TYPE_STRING_ARRAY,
+    ELEM_TYPE_ITEM,
+
+    NUM_ELEM_TYPES
+};
+
+static const char *elem_strs[NUM_ELEM_TYPES] = {
+    [ELEM_TYPE_BOOL]          = "bool",
+    [ELEM_TYPE_INT]           = "integer",
+    [ELEM_TYPE_STRING]        = "string",
+    [ELEM_TYPE_FRACTION]      = "fraction",
+    [ELEM_TYPE_DIMENSION]     = "dimen",
+    [ELEM_TYPE_INT_ARRAY]     = "integer-array",
+    [ELEM_TYPE_STRING_ARRAY]  = "string-array",
+    [ELEM_TYPE_ITEM]          = "item",
+};
+
+struct parser_state {
+    enum elem_type type;
+    gboolean in_item;
+    gchar *name;
+    GValue value;
+};
+
+static struct parser_state state = {
+    .value = G_VALUE_INIT,
+};
+static GHashTable *config_hash;
+
+static enum elem_type get_elem_type(const gchar *name)
+{
+    int i;
+    for (i = 0; i < NUM_ELEM_TYPES; i++) {
+        if (elem_strs[i] && !strcmp(name, elem_strs[i]))
+            break;
+    }
+    if (i >= NUM_ELEM_TYPES)
+        return ELEM_TYPE_NONE;
+    return i;
+}
+
+static const gchar *get_elem_name(const gchar **attr_names,
+                                  const gchar **attr_values)
+{
+    int i;
+    for (i = 0; attr_names[i]; i++) {
+        if (!strcmp(attr_names[i], "name"))
+            break;
+    }
+    if (!attr_names[i])
+        return NULL;
+    return attr_values[i];
+}
+
+static void on_start_elem(GMarkupParseContext *context, const gchar *name,
+                          const gchar **attr_names, const gchar **attr_values,
+                          gpointer user_data, GError **error)
+{
+    const gchar *config_name;
+    enum elem_type type;
+
+    type = get_elem_type(name);
+    if (type == ELEM_TYPE_NONE)
+        return;
+    if (type == ELEM_TYPE_ITEM) {
+        if (state.type == ELEM_TYPE_INT_ARRAY ||
+            state.type == ELEM_TYPE_STRING_ARRAY)
+            state.in_item = TRUE;
+        return;
+    }
+    if (state.type != ELEM_TYPE_NONE) {
+        g_set_error(error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
+                    "Nested elements not supported");
+        return;
+    }
+
+    config_name = get_elem_name(attr_names, attr_values);
+    if (!config_name)
+        return;
+    /* Strip leading "config_" if present, not all vars have it */
+    if (!strncmp(config_name, "config_", 7))
+        config_name += 7;
+
+    switch (type) {
+    case ELEM_TYPE_BOOL:
+        g_value_init(&state.value, G_TYPE_BOOLEAN);
+        break;
+    case ELEM_TYPE_INT:
+        g_value_init(&state.value, G_TYPE_UINT);
+        break;
+    case ELEM_TYPE_INT_ARRAY:
+        {
+            GArray *a;
+            g_value_init(&state.value, G_TYPE_ARRAY);
+            a = g_array_new(FALSE, FALSE, sizeof(guint32));
+            g_value_set_boxed(&state.value, a);
+            break;
+        }
+    default:
+        /* Type not supported at this time */
+        return;
+    }
+
+    state.type = type;
+    state.in_item = FALSE;
+    state.name = g_strdup(config_name);
+}
+
+static void on_end_elem(GMarkupParseContext *context, const gchar *name,
+                        gpointer user_data, GError **error)
+{
+    enum elem_type type;
+    GValue *value;
+
+    if (state.type == ELEM_TYPE_NONE)
+        return;
+
+    type = get_elem_type(name);
+    if (type == ELEM_TYPE_NONE)
+        return;
+    if (type == ELEM_TYPE_ITEM) {
+        state.in_item = FALSE;
+        return;
+    }
+
+    if (type == state.type) {
+        value = g_new0(GValue, 1);
+        g_value_init(value, G_VALUE_TYPE(&state.value));
+        g_value_copy(&state.value, value);
+        g_hash_table_replace(config_hash, state.name, value);
+        /* Note: state.name is not freed as it is used for hash table key */
+    } else {
+        g_set_error(error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
+                    "Start and end element types don't match");
+        g_free(state.name);
+    }
+
+    state.type = ELEM_TYPE_NONE;
+    state.name = NULL;
+    g_value_unset(&state.value);
+}
+
+/* WARNING: pt_text is not nul-terminated */
+static void on_text(GMarkupParseContext *context, const gchar *pt_text,
+                    gsize text_len, gpointer user_data, GError **error)
+{
+    gchar *text = g_strndup(pt_text, text_len);
+    switch (state.type) {
+    case ELEM_TYPE_BOOL:
+        {
+            gboolean value;
+            if (!G_VALUE_HOLDS_BOOLEAN(&state.value)) {
+                g_warning("Incorrect GValue type");
+                break;
+            }
+            value = !g_ascii_strcasecmp(text, "true");
+            g_value_set_boolean(&state.value, value);
+            break;
+        }
+    case ELEM_TYPE_INT:
+        {
+            guint value;
+            gchar *endp;
+            if (!G_VALUE_HOLDS_UINT(&state.value)) {
+                g_warning("Incorrect GValue type");
+                break;
+            }
+            value = (guint)g_ascii_strtoll(text, &endp, 0);
+            if (endp - text == text_len)
+                g_value_set_uint(&state.value, value);
+            break;
+        }
+    case ELEM_TYPE_INT_ARRAY:
+        {
+            GArray *a;
+            guint value;
+            gchar *endp;
+            if (!state.in_item)
+                break;
+            if (!G_VALUE_HOLDS_BOXED(&state.value)) {
+                g_warning("Incorrect GValue type");
+                break;
+            }
+            value = (guint)g_ascii_strtoll(text, &endp, 0);
+            if (endp - text == text_len) {
+                a = g_value_get_boxed(&state.value);
+                g_array_append_val(a, value);
+            }
+        }
+        break;
+    default:
+        break;
+    }
+    g_free(text);
+}
+
+static GMarkupParser parser = {
+    .start_element  = on_start_elem,
+    .end_element    = on_end_elem,
+    .text           = on_text,
+};
+
+static void config_hash_destroy_key(gpointer data)
+{
+    g_free(data);
+}
+
+static void config_hash_destroy_value(gpointer data)
+{
+    GValue *v = data;
+    if (G_VALUE_HOLDS_BOXED(v)) {
+        /* Currently only boxed data is arrays */
+        GArray *a = g_value_get_boxed(v);
+        g_array_free(a, TRUE);
+    }
+    g_value_unset(v);
+    g_free(v);
+}
+
+static int process_config(const char *fname)
+{
+    int fd, ret = 0;
+    gchar *buf = NULL;
+    int buf_len;
+    ssize_t len;
+    GMarkupParseContext *context = NULL;
+    GError *error;
+
+    fd = open(fname, O_RDONLY);
+    if (fd == -1) {
+        powerd_warn("Could not open device config %s: %s",
+                    fname, strerror(errno));
+        return -errno;
+    }
+
+    buf_len = (int)sysconf(_SC_PAGESIZE);
+    buf = malloc(buf_len);
+    if (!buf) {
+        ret = -ENOMEM;
+        goto out;
+    }
+
+    context = g_markup_parse_context_new(&parser, 0, NULL, NULL);
+    do {
+        len = read(fd, buf, buf_len);
+        if (len == 0)
+            break;
+        if (len == -1) {
+            if (errno == EINTR)
+                continue;
+            powerd_warn("Error reading %s: %s", fname, strerror(errno));
+            ret = -errno;
+            break;
+        }
+
+        error = NULL;
+        if (!g_markup_parse_context_parse(context, buf, len, &error)) {
+            powerd_warn("Failed parsing device config %s\n", fname);
+            if (error) {
+                powerd_warn("%s", error->message);
+                g_error_free(error);
+            }
+            ret = -EIO;
+        }
+    } while (!ret);
+
+out:
+    if (context)
+        g_markup_parse_context_free(context);
+    if (buf)
+        free(buf);
+    close(fd);
+    return ret;
+}
+
+/*
+ * Get the device config option specified by @name. The leading
+ * "config_" characters should be stripped from the name if present.
+ * Returns 0 if the given variable is found.
+ *
+ * @value should be an initialized GValue. On success, the value of
+ * the variable will be copied to the GValue, and the caller is
+ * responsible for freeing the memory. E.g.:
+ *
+ *   GValue v = G_VALUE_INIT;
+ *   if (!device_config_get("myVar", &v)) {
+ *       do_something_with_value(&v);
+ *       g_value_unset(&v);
+ *   }
+ */
+int device_config_get(const char *name, GValue *value)
+{
+    GValue *v;
+
+    if (!config_hash)
+        return -ENODEV;
+
+    v = g_hash_table_lookup(config_hash, name);
+    if (!v)
+        return -ENOENT;
+
+    g_value_init(value, G_VALUE_TYPE(v));
+    g_value_copy(v, value);
+    return 0;
+}
+
+void device_config_init(void)
+{
+    char device[PROP_VALUE_MAX];
+    char *xml_path;
+
+    if (!property_get("ro.product.device", device, NULL)) {
+        powerd_warn("Could not determine device, running without config");
+        return;
+    }
+    powerd_info("Running on %s\n", device);
+
+    config_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
+                                        config_hash_destroy_key,
+                                        config_hash_destroy_value);
+
+    /*
+     * Always start with config-default.xml for defaults, then
+     * the device-specific config
+     */
+    if (process_config(POWERD_DEVICE_CONFIGS_PATH "/config-default.xml"))
+        goto error;
+    xml_path = g_strdup_printf("%s/config-%s.xml",
+                               POWERD_DEVICE_CONFIGS_PATH, device);
+    if (process_config(xml_path))
+        goto error;
+    g_free(xml_path);
+    return;
+
+error:
+    device_config_deinit();
+}
+
+void device_config_deinit(void)
+{
+    if (config_hash) {
+        g_hash_table_destroy(config_hash);
+        config_hash = NULL;
+    }
+}

=== added file 'src/device-config.h'
--- src/device-config.h	1970-01-01 00:00:00 +0000
+++ src/device-config.h	2013-08-30 13:59:21 +0000
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This file is part of powerd.
+ *
+ * powerd 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; version 3.
+ *
+ * powerd 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 program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __DEVICE_CONFIG_H__
+#define __DEVICE_CONFIG_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void device_config_init(void);
+void device_config_deinit(void);
+int device_config_get(const char *name, GValue *value);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __DEVICE_CONFIG_H__ */

=== modified file 'src/display.c'
--- src/display.c	2013-07-29 16:05:34 +0000
+++ src/display.c	2013-08-30 13:59:21 +0000
@@ -36,11 +36,17 @@
 
 #include "powerd.h"
 #include "powerd-internal.h"
+#include "device-config.h"
 #include "log.h"
 
 /* Treat "don't care" display state as off */
 #define DISPLAY_STATE_OFF POWERD_DISPLAY_STATE_DONT_CARE
 
+/* Autobrightness only enabled when bright && !disabled */
+#define AB_ENABLED_MASK (POWERD_DISPLAY_FLAG_BRIGHT | \
+                         POWERD_DISPLAY_FLAG_DISABLE_AUTOBRIGHTNESS)
+#define AB_ENABLED      POWERD_DISPLAY_FLAG_BRIGHT
+
 static gint saved_brightness = 255;
 static gint target_brightness;
 static gint dim_brightness;
@@ -92,10 +98,18 @@
     return display_state_strs[state];
 }
 
-static void turn_on_display(void) {
+static gboolean ab_enabled(guint32 flags)
+{
+    return (flags & AB_ENABLED_MASK) == AB_ENABLED;
+}
+
+static void turn_on_display(gboolean autobrightness) {
     powerd_debug("turning on display");
     sf_unblank(0);
-    powerd_set_brightness(target_brightness);
+    if (autobrightness)
+        powerd_autobrightness_enable();
+    else
+        powerd_set_brightness(target_brightness);
 }
 
 gboolean powerd_display_enabled(void)
@@ -127,19 +141,25 @@
 static void update_display_state(struct powerd_display_request *req)
 {
     enum powerd_display_state state = req->state;
+    gboolean use_ab, using_ab;
     int applied_state;
     int ret;
     int hw_brightness;
 
+    use_ab = ab_enabled(req->flags);
+    using_ab = ab_enabled(internal_state.flags);
+
     hw_brightness = powerd_get_brightness();
     if (hw_brightness < 0)
         hw_brightness = saved_brightness;
 
-    if ((internal_state.flags & POWERD_DISPLAY_FLAG_BRIGHT) &&
-        (hw_brightness != 0))
+    if (!using_ab && hw_brightness != 0 &&
+        (internal_state.flags & POWERD_DISPLAY_FLAG_BRIGHT))
         saved_brightness = hw_brightness;
-    target_brightness = get_target_brightness((!!(req->flags & POWERD_DISPLAY_FLAG_BRIGHT)),
-            hw_brightness);
+    if (!use_ab)
+        target_brightness = get_target_brightness(
+                    !!(req->flags & POWERD_DISPLAY_FLAG_BRIGHT),
+                    hw_brightness);
 
     applied_state = screen_off_overrides ? DISPLAY_STATE_OFF : state;
 
@@ -151,6 +171,8 @@
         }
 
         powerd_debug("turning off display");
+        if (using_ab)
+            powerd_autobrightness_disable();
         powerd_set_brightness(0);
         sf_blank(0);
 
@@ -179,12 +201,21 @@
              * Otherwise we can turn on the screen right away.
              */
             if (fb_state == FB_AWAKE)
-                turn_on_display();
+                turn_on_display(use_ab);
         } else {
             /* Only changing brightness */
-            if ((req->flags & POWERD_DISPLAY_FLAG_BRIGHT) !=
-                (internal_state.flags & POWERD_DISPLAY_FLAG_BRIGHT))
-                powerd_set_brightness(target_brightness);
+            if (use_ab) {
+                if (!using_ab)
+                    powerd_autobrightness_enable();
+            } else {
+                if (using_ab) {
+                    powerd_autobrightness_disable();
+                    powerd_set_brightness(target_brightness);
+                } else if ((req->flags & POWERD_DISPLAY_FLAG_BRIGHT) !=
+                           (internal_state.flags & POWERD_DISPLAY_FLAG_BRIGHT)) {
+                    powerd_set_brightness(target_brightness);
+                }
+            }
         }
         break;
     default:
@@ -198,7 +229,6 @@
 static void update_flags(guint32 flags)
 {
     int prox_enabled, internal_prox_enabled;
-    /* XXX: Handle autobrightness flag */
 
     prox_enabled = (flags & POWERD_DISPLAY_FLAG_USE_PROXIMITY);
     internal_prox_enabled = (internal_state.flags & POWERD_DISPLAY_FLAG_USE_PROXIMITY);
@@ -323,7 +353,7 @@
     fb_state = (enum fb_state)data;
     powerd_debug("fb state %s", fb_state == FB_SLEEP ? "sleep" : "awake");
     if (fb_state == FB_AWAKE && powerd_display_enabled())
-        turn_on_display();
+        turn_on_display(ab_enabled(internal_state.flags));
     return FALSE;
 }
 
@@ -350,14 +380,17 @@
 int powerd_display_init(void)
 {
     GError *error;
+    GValue v = G_VALUE_INIT;
     int brightness, max_brightness;
 
     /*
      * Warning: much hand waving follows
      *
      * Right now there's no coherent system brightness policy, so we
-     * just do the best we can. For "dim" brightness we just go with
-     * 5% of maximum. For "bright" brightness, it's more complicated.
+     * just do the best we can. For "dim" brightness we try to read
+     * the value from the Android config files, otherwise we just go
+     * with 5% of maximum. For "bright" brightness, it's more
+     * complicated.
      *
      * Our first preference for the bright value is whatever the screen
      * is currently set to. However, the screen could be off or dimmed
@@ -365,15 +398,23 @@
      * happens.
      */
 
+    if (!device_config_get("screenBrightnessDim", &v)) {
+        if (G_VALUE_HOLDS_UINT(&v))
+            dim_brightness = (int)g_value_get_uint(&v);
+        g_value_unset(&v);
+    }
+
     max_brightness = powerd_get_max_brightness();
 
     if (max_brightness <= 0) {
         powerd_warn("Could not read maximum brightness, guessing at dim/bright values");
-        dim_brightness = 5;
         saved_brightness = 100;
+        if (dim_brightness == 0)
+            dim_brightness = 5;
     } else {
-        dim_brightness = max_brightness / 20;
         saved_brightness = (3 * max_brightness) / 4;
+        if (dim_brightness == 0)
+            dim_brightness = max_brightness / 20;
     }
 
     brightness = powerd_get_brightness();

=== modified file 'src/power-source.c'
--- src/power-source.c	2013-07-12 21:12:31 +0000
+++ src/power-source.c	2013-08-30 13:59:21 +0000
@@ -21,9 +21,11 @@
 #include <libupower-glib/upower.h>
 
 #include "powerd-internal.h"
+#include "device-config.h"
 #include "log.h"
 
 static UpClient *up_client;
+double shutdown_temp = 68.0f;
 
 static void up_device_changed_cb(UpClient *client, UpDevice *device,
                                  gpointer unused)
@@ -31,13 +33,14 @@
     gboolean on_battery;
     GPtrArray *devices;
     int i;
-    gboolean shutdown = TRUE;
+    gboolean low_batt_shutdown = TRUE;
+    gboolean thermal_shutdown = FALSE;
 
     g_object_get(up_client,
                  "on_battery", &on_battery,
                  NULL);
     if (!on_battery)
-        return;
+        low_batt_shutdown = FALSE;
     devices = up_client_get_devices(up_client);
     for (i = 0; i < devices->len; i++) {
         UpDevice *device = g_ptr_array_index(devices, i);
@@ -48,21 +51,25 @@
                      "is-present", &is_present,
                      NULL);
         if (kind == UP_DEVICE_KIND_BATTERY && is_present) {
-            double percentage;
+            double percentage, temp;
             g_object_get(device,
                          "percentage", &percentage,
+                         "temperature", &temp,
                          NULL);
             /*
              * Android shuts down when percentage reaches 0. We
              * use 1% to leave a little more headroom.
              */
-            if (percentage > 1.0) {
-                shutdown = FALSE;
+            if (percentage > 1.0)
+                low_batt_shutdown = FALSE;
+            if (temp >= shutdown_temp) {
+                powerd_warn("Critical battery temperature %f\n", temp);
+                thermal_shutdown = TRUE;
                 break;
             }
         }
     }
-    if (shutdown) {
+    if (low_batt_shutdown || thermal_shutdown) {
         powerd_warn("Initiating emergency shutdown");
         powerd_shutdown();
     }
@@ -70,7 +77,19 @@
 
 int powerd_ps_init(void)
 {
+    GValue v = G_VALUE_INIT;
     gboolean ret;
+
+    /*
+     * Override default shutdown temperature with device-specific
+     * value, if avaialable
+     */
+    if (!device_config_get("shutdownBatteryTemperature", &v) &&
+        G_VALUE_HOLDS_UINT(&v)) {
+        shutdown_temp = (double)g_value_get_uint(&v) / 10.0f;
+        g_value_unset(&v);
+    }
+
     up_client = up_client_new();
     if (!up_client) {
         powerd_warn("Could not allocate upower client");

=== modified file 'src/powerd-internal.h'
--- src/powerd-internal.h	2013-08-12 04:45:17 +0000
+++ src/powerd-internal.h	2013-08-30 13:59:21 +0000
@@ -57,6 +57,13 @@
 void powerd_dbus_init_complete(void);
 int powerd_is_mainloop(void);
 
+/* Autobrightness functions */
+void powerd_new_als_event(double lux);
+void powerd_autobrightness_enable(void);
+void powerd_autobrightness_disable(void);
+int powerd_autobrightness_init(void);
+void powerd_autobrightness_deinit(void);
+
 /* Backlight functions */
 int powerd_backlight_init(void);
 void powerd_backlight_deinit(void);
@@ -147,6 +154,8 @@
 /* Sensor functions */
 void powerd_sensors_proximity_enable(void);
 void powerd_sensors_proximity_disable(void);
+void powerd_sensors_als_enable(void);
+void powerd_sensors_als_disable(void);
 
 /* Power source functions */
 int powerd_ps_init(void);

=== modified file 'src/powerd-sensors.cpp'
--- src/powerd-sensors.cpp	2013-06-07 23:02:23 +0000
+++ src/powerd-sensors.cpp	2013-08-30 13:59:21 +0000
@@ -21,10 +21,13 @@
 
 #include "powerd-internal.h"
 #include "powerd-sensors.h"
+#include "log.h"
 
+#include <ubuntu/application/sensors/light.h>
 #include <ubuntu/application/sensors/proximity.h>
 
 UASensorsProximity* prox_sensor;
+UASensorsLight* light_sensor;
 
 void on_new_proximity_event(UASProximityEvent *event, void *context)
 {
@@ -53,13 +56,40 @@
     ua_sensors_proximity_disable(prox_sensor);
 }
 
+void on_new_als_event(UASLightEvent *event, void *context)
+{
+    float lux = uas_light_event_get_light(event);
+    powerd_new_als_event(lux);
+}
+
+void powerd_sensors_als_enable(void)
+{
+    if (light_sensor)
+        ua_sensors_light_enable(light_sensor);
+}
+
+void powerd_sensors_als_disable(void)
+{
+    if (light_sensor)
+        ua_sensors_light_disable(light_sensor);
+}
+
 void powerd_sensors_init(void)
 {
     prox_sensor = ua_sensors_proximity_new();
-
     if (prox_sensor != NULL) {
         ua_sensors_proximity_set_reading_cb(prox_sensor,
                                             on_new_proximity_event,
                                             NULL);
+    } else {
+        powerd_warn("Failed to allocate proximity sensor");
+    }
+
+    light_sensor = ua_sensors_light_new();
+    if (light_sensor) {
+        ua_sensors_light_set_reading_cb(light_sensor, on_new_als_event,
+                                        NULL);
+    } else {
+        powerd_warn("Failed to allocate ambient light sensor");
     }
 }

=== modified file 'src/powerd.cpp'
--- src/powerd.cpp	2013-08-09 19:53:58 +0000
+++ src/powerd.cpp	2013-08-30 13:59:21 +0000
@@ -40,6 +40,7 @@
 #include "powerd-object.h"
 #include "powerd-dbus.h"
 #include "powerd-sensors.h"
+#include "device-config.h"
 #include "log.h"
 
 #include <hybris/input/input_stack_compatibility_layer.h>
@@ -471,6 +472,9 @@
     powerd_debug("Activity Timeout is %d seconds\n", activity_timeout);
     powerd_debug("Auto-dim Timeout is %d seconds\n", dim_timeout);
 
+    /* Init this first, data is used by other inits */
+    device_config_init();
+
     libsuspend_init(0);
     powerd_stats_init();
     powerd_client_init();
@@ -478,6 +482,7 @@
     display_request_init();
     dbus_name_watch_init();
     powerd_backlight_init();
+    powerd_autobrightness_init();
     powerd_display_init();
     powerd_sensors_init();
     powerd_ps_init();
@@ -497,6 +502,9 @@
     android_input_stack_initialize(&listener, &config);
     android_input_stack_start();
 
+    /* Config use should be done during init, okay to free now */
+    device_config_deinit();
+
     /* This needs to be the first thing to run on the main loop */
     g_idle_add_full(G_PRIORITY_HIGH, main_init, NULL, NULL);
 
@@ -509,6 +517,7 @@
 
     powerd_ps_deinit();
     dbus_name_watch_deinit();
+    powerd_autobrightness_deinit();
     powerd_backlight_deinit();
     display_request_deinit();
     power_request_deinit();

=== added file 'src/spline.c'
--- src/spline.c	1970-01-01 00:00:00 +0000
+++ src/spline.c	2013-08-30 13:59:21 +0000
@@ -0,0 +1,140 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This file is part of powerd.
+ *
+ * powerd 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; version 3.
+ *
+ * powerd 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 program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct spline_params {
+    double k, m;
+};
+
+struct spline {
+    double (*points)[2];
+    int n;
+    struct spline_params params[0];
+};
+
+int spline_sort_comp(const void *a, const void *b)
+{
+    double x1 = *(double *)a;
+    double x2 = *(double *)b;
+    return (int)(x1 - x2);
+}
+
+/*
+ * Initializes a monotone cubic Hermite spline for interpolating
+ * between the input points, using the Fritsch–Carlson method.
+ *
+ *   http://en.wikipedia.org/wiki/Monotone_cubic_interpolation
+ *
+ * The interpolated points are guaranteed to have piecewise
+ * monotonicity, and will be fully monotone if the input points
+ * are monotone.
+ */
+struct spline *spline_new(double (*points)[2], int num_points)
+{
+    struct spline *s;
+    struct spline_params *param;
+    double (*p)[2];
+    int i;
+    double alpha, beta, prev_beta;
+
+    s = malloc(sizeof(struct spline) +
+               sizeof(struct spline_params) * num_points);
+    if (!s)
+        return NULL;
+    s->points = malloc(2 * sizeof(double) * num_points);
+    if (!s->points) {
+        free(s);
+        return NULL;
+    }
+    s->n = num_points;
+
+    /*
+     * Input points are likely to already be in order of increasing
+     * x, but sort them just in case.
+     */
+    memcpy(s->points, points, 2 * sizeof(double) * num_points);
+    qsort(s->points, num_points, 2 * sizeof(double), spline_sort_comp);
+
+    p = s->points;
+    param = s->params;
+
+    for (i = 0; i < s->n - 1; i++)
+        param[i].k = (p[i+1][1] - p[i][1]) / (p[i+1][0] - p[i][0]);
+
+    param[0].m = param[0].k;
+    for (i = 1; i < s->n; i++)
+        param[i].m = (param[i-1].k + param[i].k) / 2;
+    param[s->n - 1].m = param[s->n - 2].k;
+
+    beta = 0;
+    for (i = 0; i < s->n - 1; i++) {
+        if (p[i][1] == p[i+1][1]) {
+            param[i].m = 0;
+            param[++i].m = 0;
+            beta = 0;
+            continue;
+        }
+        prev_beta = beta;
+        alpha = param[i].m / param[i].k;
+        beta = param[i+1].m / param[i].k;
+        if (alpha < 0 || prev_beta < 0) {
+            param[i].m = 0;
+            continue;
+        }
+        if (alpha > 3)
+            param[i].m = 3 * param[i].k;
+        if (beta > 3)
+            param[i+1].m = 3 * param[i].k;
+    }
+
+    return s;
+}
+
+void spline_free(struct spline *s)
+{
+    free(s->points);
+    free(s);
+}
+
+double spline_interpolate(struct spline *s, double x)
+{
+    int i;
+    double h, t, ret;
+
+    for (i = 0; i < s->n - 1; i++) {
+        if (x >= s->points[i][0] && x < s->points[i+1][0])
+            break;
+    }
+
+    /* Handle out-of-bounds and boundary cases */
+    if (i == 0 && x <= s->points[0][0])
+        return s->points[0][1];
+    if (i >= s->n - 1)
+        return s->points[s->n - 1][1];
+
+    h = s->points[i+1][0] - s->points[i][0];
+    t = (x - s->points[i][0]) / h;
+    ret = s->points[i][1] * (1 + t * t * (2 * t - 3));
+    ret += h * s->params[i].m * t * (1 + t * (t - 2));
+    ret += s->points[i+1][1] * t * t * (3 - 2 * t);
+    ret += h * s->params[i+1].m * t * t * (t - 1);
+    return ret;
+}

=== added file 'src/spline.h'
--- src/spline.h	1970-01-01 00:00:00 +0000
+++ src/spline.h	2013-08-30 13:59:21 +0000
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2013 Canonical Ltd.
+ *
+ * This file is part of powerd.
+ *
+ * powerd 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; version 3.
+ *
+ * powerd 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 program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __SPLINE_H__
+#define __SPLINE_H__
+
+struct spline;
+
+struct spline *spline_new(double (*points)[2], int num_points);
+void spline_free(struct spline *s);
+double spline_interpolate(struct spline *s, double x);
+
+#endif