MiPad4/android_device_xiaomi_sdm660-common
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

sdm660-common: Adapt Light Hal for commonized sdm660 tree

Browse source 
Change-Id: If08b3cfc5e4e5bb35b39d6616d0fd974a709e61d
This commit is contained in:
Demon000 2020-04-14 09:29:09 +02:00 committed by OdSazib
parent 6f854132da
commit 5b63d5c3fb
No known key found for this signature in database
GPG key ID: CB336514F9F5CF69
3 changed files with 108 additions and 139 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

181
light/Light.cpp
View file

@ -17,31 +17,35 @@
#define LOG_TAG "android.hardware.light@2.0-service.xiaomi_sdm660" #define LOG_TAG "android.hardware.light@2.0-service.xiaomi_sdm660"
#include <log/log.h> #include <log/log.h>
#include <fstream>
#include "Light.h" #include "Light.h"
#include <fstream> namespace android {
namespace hardware {
namespace light {
namespace V2_0 {
namespace implementation {
#define LEDS "/sys/class/leds/" #define LEDS "/sys/class/leds/"
#define LCD_LED LEDS "lcd-backlight/" #define LCD_LED LEDS "lcd-backlight/"
#define WHITE_LED LEDS "white/"
#define BLINK "blink"
#define BRIGHTNESS "brightness" #define BRIGHTNESS "brightness"
#define MAX_BRIGHTNESS "max_brightness" #define WHITE LEDS "white/"
#define BLINK "blink"
#define DUTY_PCTS "duty_pcts" #define DUTY_PCTS "duty_pcts"
#define PAUSE_HI "pause_hi" #define PAUSE_HI "pause_hi"
#define PAUSE_LO "pause_lo" #define PAUSE_LO "pause_lo"
#define RAMP_STEP_MS "ramp_step_ms" #define RAMP_STEP_MS "ramp_step_ms"
#define START_IDX "start_idx" #define START_IDX "start_idx"
#define MAX_LED_BRIGHTNESS 255
#define MAX_LCD_BRIGHTNESS 4095
/* /*
* 15 duty percent steps. * 8 duty percent steps.
*/ */
#define RAMP_STEPS 15 #define RAMP_STEPS 15
/* /*
* Each step will stay on for 150ms by default. * Each step will stay on for 50ms by default.
*/ */
#define RAMP_STEP_DURATION 150 #define RAMP_STEP_DURATION 150
/* /*
@ -49,44 +53,25 @@
*/ */
static int32_t BRIGHTNESS_RAMP[RAMP_STEPS] = {0, 12, 25, 37, 50, 72, 85, 100, 85, 72, 50, 37, 25, 12, 0}; static int32_t BRIGHTNESS_RAMP[RAMP_STEPS] = {0, 12, 25, 37, 50, 72, 85, 100, 85, 72, 50, 37, 25, 12, 0};
namespace {
/* /*
* Write value to path and close file. * Write value to path and close file.
*/ */
static void set(std::string path, std::string value) { static void set(std::string path, std::string value) {
std::ofstream file(path); std::ofstream file(path);
/* Only write brightness value if stream is open, alive & well */
if (!file.is_open()) { if (file.is_open()) {
ALOGW("failed to write %s to %s", value.c_str(), path.c_str()); file << value;
} else {
/* Fire a warning a bail out */
ALOGE("failed to write %s to %s", value.c_str(), path.c_str());
return; return;
} }
file << value;
} }
static void set(std::string path, int value) { static void set(std::string path, int value) {
set(path, std::to_string(value)); set(path, std::to_string(value));
} }
static int get(std::string path) {
std::ifstream file(path);
int value;
if (!file.is_open()) {
ALOGW("failed to read from %s", path.c_str());
return 0;
}
file >> value;
return value;
}
static int getMaxBrightness(std::string path) {
int value = get(path);
ALOGW("Got max brightness %d", value);
return value;
}
static uint32_t getBrightness(const LightState& state) { static uint32_t getBrightness(const LightState& state) {
uint32_t alpha, red, green, blue; uint32_t alpha, red, green, blue;
@ -110,19 +95,6 @@ static uint32_t getBrightness(const LightState& state) {
return (77 * red + 150 * green + 29 * blue) >> 8; return (77 * red + 150 * green + 29 * blue) >> 8;
} }
static inline uint32_t scaleBrightness(uint32_t brightness, uint32_t maxBrightness) {
return brightness * maxBrightness / 0xFF;
}
static inline uint32_t getScaledBrightness(const LightState& state, uint32_t maxBrightness) {
return scaleBrightness(getBrightness(state), maxBrightness);
}
static void handleBacklight(const LightState& state) {
uint32_t brightness = getScaledBrightness(state, getMaxBrightness(LCD_LED MAX_BRIGHTNESS));
set(LCD_LED BRIGHTNESS, brightness);
}
/* /*
* Scale each value of the brightness ramp according to the * Scale each value of the brightness ramp according to the
* brightness of the color. * brightness of the color.
@ -138,11 +110,24 @@ static std::string getScaledRamp(uint32_t brightness) {
return ramp; return ramp;
} }
static void handleNotification(const LightState& state) { static inline uint32_t scaleBrightness(uint32_t brightness, uint32_t maxBrightness) {
uint32_t whiteBrightness = getScaledBrightness(state, getMaxBrightness(WHITE_LED MAX_BRIGHTNESS)); return brightness * maxBrightness / 0xFF;
}
/* Disable blinking */ static inline uint32_t getScaledBrightness(const LightState& state, uint32_t maxBrightness) {
set(WHITE_LED BLINK, 0); return scaleBrightness(getBrightness(state), maxBrightness);
}
static void handleXiaomiBacklight(Type /*type*/, const LightState& state) {
uint32_t brightness = getScaledBrightness(state, MAX_LCD_BRIGHTNESS);
set(LCD_LED BRIGHTNESS, brightness);
}
static void setNotification(const LightState& state) {
uint32_t whiteBrightness = getScaledBrightness(state, MAX_LED_BRIGHTNESS);
/* Turn off the leds (initially) */
set(WHITE BLINK, 0);
if (state.flashMode == Flash::TIMED) { if (state.flashMode == Flash::TIMED) {
/* /*
@ -155,21 +140,18 @@ static void handleNotification(const LightState& state) {
int32_t pauseLo = state.flashOffMs; int32_t pauseLo = state.flashOffMs;
if (pauseHi < 0) { if (pauseHi < 0) {
//stepDuration = state.flashOnMs / (RAMP_STEPS * 2);
pauseHi = 0; pauseHi = 0;
} }
/* White */ /* White */
set(WHITE_LED START_IDX, 0 * RAMP_STEPS); set(WHITE BLINK, 1);
set(WHITE_LED DUTY_PCTS, getScaledRamp(whiteBrightness)); set(WHITE START_IDX, 0 * RAMP_STEPS);
set(WHITE_LED PAUSE_LO, pauseLo); set(WHITE DUTY_PCTS, getScaledRamp(whiteBrightness));
set(WHITE_LED PAUSE_HI, pauseHi); set(WHITE PAUSE_LO, pauseLo);
set(WHITE_LED RAMP_STEP_MS, stepDuration); set(WHITE PAUSE_HI, pauseHi);
set(WHITE RAMP_STEP_MS, stepDuration);
/* Enable blinking */
set(WHITE_LED BLINK, 1);
} else { } else {
set(WHITE_LED BRIGHTNESS, whiteBrightness); set(WHITE BRIGHTNESS, whiteBrightness);
} }
} }
@ -177,61 +159,60 @@ static inline bool isLit(const LightState& state) {
return state.color & 0x00ffffff; return state.color & 0x00ffffff;
} }
/* Keep sorted in the order of importance. */ /*
static std::vector<LightBackend> backends = { * Keep sorted in the order of importance.
{ Type::ATTENTION, handleNotification }, */
{ Type::NOTIFICATIONS, handleNotification }, static const LightState offState = {};
{ Type::BATTERY, handleNotification }, static std::vector<std::pair<Type, LightState>> notificationStates = {
{ Type::BACKLIGHT, handleBacklight }, { Type::ATTENTION, offState },
{ Type::NOTIFICATIONS, offState },
{ Type::BATTERY, offState },
}; };
} // anonymous namespace static void handleXiaomiNotification(Type type, const LightState& state) {
for(auto it : notificationStates) {
if (it.first == type) {
it.second = state;
}
namespace android { if (isLit(it.second)) {
namespace hardware { setNotification(it.second);
namespace light { return;
namespace V2_0 { }
namespace implementation { }
setNotification(offState);
}
static std::map<Type, std::function<void(Type type, const LightState&)>> lights = {
{Type::BACKLIGHT, handleXiaomiBacklight},
{Type::NOTIFICATIONS, handleXiaomiNotification},
{Type::BATTERY, handleXiaomiNotification},
{Type::ATTENTION, handleXiaomiNotification},
};
Light::Light() {}
Return<Status> Light::setLight(Type type, const LightState& state) { Return<Status> Light::setLight(Type type, const LightState& state) {
LightStateHandler handler = nullptr; auto it = lights.find(type);
/* Lock global mutex until light state is updated. */ if (it == lights.end()) {
std::lock_guard<std::mutex> lock(globalLock);
/* Update the cached state value for the current type. */
for (LightBackend& backend : backends) {
if (backend.type == type) {
backend.state = state;
handler = backend.handler;
}
}
/* If no handler has been found, then the type is not supported. */
if (!handler) {
return Status::LIGHT_NOT_SUPPORTED; return Status::LIGHT_NOT_SUPPORTED;
} }
/* Light up the type with the highest priority that matches the current handler. */ /*
for (LightBackend& backend : backends) { * Lock global mutex until light state is updated.
if (handler == backend.handler && isLit(backend.state)) { */
handler(backend.state);
return Status::SUCCESS;
}
}
/* If no type has been lit up, then turn off the hardware. */
handler(state);
std::lock_guard<std::mutex> lock(globalLock);
it->second(type, state);
return Status::SUCCESS; return Status::SUCCESS;
} }
Return<void> Light::getSupportedTypes(getSupportedTypes_cb _hidl_cb) { Return<void> Light::getSupportedTypes(getSupportedTypes_cb _hidl_cb) {
std::vector<Type> types; std::vector<Type> types;
for (const LightBackend& backend : backends) { for (auto const& light : lights) types.push_back(light.first);
types.push_back(backend.type);
}
_hidl_cb(types); _hidl_cb(types);

34
light/Light.h
View file

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2018 The Xiaomi-SDM660 Project * Copyright (C) 2017 The LineageOS Project
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -13,7 +13,6 @@
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
#ifndef ANDROID_HARDWARE_LIGHT_V2_0_LIGHT_H #ifndef ANDROID_HARDWARE_LIGHT_V2_0_LIGHT_H
#define ANDROID_HARDWARE_LIGHT_V2_0_LIGHT_H #define ANDROID_HARDWARE_LIGHT_V2_0_LIGHT_H
@ -22,27 +21,6 @@
#include <hidl/Status.h> #include <hidl/Status.h>
#include <map> #include <map>
#include <mutex> #include <mutex>
#include <vector>
using ::android::hardware::Return;
using ::android::hardware::Void;
using ::android::hardware::light::V2_0::Flash;
using ::android::hardware::light::V2_0::ILight;
using ::android::hardware::light::V2_0::LightState;
using ::android::hardware::light::V2_0::Status;
using ::android::hardware::light::V2_0::Type;
typedef void (*LightStateHandler)(const LightState&);
struct LightBackend {
Type type;
LightState state;
LightStateHandler handler;
LightBackend(Type type, LightStateHandler handler) : type(type), handler(handler) {
this->state.color = 0xff000000;
}
};
namespace android { namespace android {
namespace hardware { namespace hardware {
@ -50,8 +28,18 @@ namespace light {
namespace V2_0 { namespace V2_0 {
namespace implementation { namespace implementation {
using ::android::hardware::Return;
using ::android::hardware::Void;
using ::android::hardware::hidl_vec;
using ::android::hardware::light::V2_0::ILight;
using ::android::hardware::light::V2_0::LightState;
using ::android::hardware::light::V2_0::Status;
using ::android::hardware::light::V2_0::Type;
class Light : public ILight { class Light : public ILight {
public: public:
Light();
Return<Status> setLight(Type type, const LightState& state) override; Return<Status> setLight(Type type, const LightState& state) override;
Return<void> getSupportedTypes(getSupportedTypes_cb _hidl_cb) override; Return<void> getSupportedTypes(getSupportedTypes_cb _hidl_cb) override;

2
light/service.cpp
View file

@ -31,7 +31,7 @@ using android::sp;
using android::status_t; using android::status_t;
int main() { int main() {
sp<ILight> service = new Light(); android::sp<ILight> service = new Light();
configureRpcThreadpool(1, true); configureRpcThreadpool(1, true);