From 217c85f5d6191816aa60d2b6f295b4f488e6300c Mon Sep 17 00:00:00 2001 From: Erfan Abdi Date: Fri, 16 Apr 2021 03:11:08 +0430 Subject: [PATCH] berlna: Add lights hal * Based on motorola sdm632 Change-Id: If4fe7a661e532de13b86b80a6dd18c0281172e7d --- BoardConfig.mk | 3 + device.mk | 9 +- lights/Android.bp | 53 ++++++ lights/aidl/Lights.cpp | 160 ++++++++++++++++++ lights/aidl/Lights.h | 56 ++++++ lights/aidl/android.hardware.lights.berlna.rc | 17 ++ .../aidl/android.hardware.lights.berlna.xml | 6 + lights/aidl/main.cpp | 37 ++++ lights/hidl/Light.cpp | 140 +++++++++++++++ lights/hidl/Light.h | 55 ++++++ ...droid.hardware.light@2.0-service.berlna.rc | 16 ++ ...roid.hardware.light@2.0-service.berlna.xml | 11 ++ lights/hidl/service.cpp | 50 ++++++ .../lineage/res/res/values/config.xml | 37 ++++ sepolicy/vendor/file_contexts | 3 + sepolicy/vendor/genfs_contexts | 2 + sepolicy/vendor/hal_light_default.te | 5 + 17 files changed, 659 insertions(+), 1 deletion(-) create mode 100644 lights/Android.bp create mode 100644 lights/aidl/Lights.cpp create mode 100644 lights/aidl/Lights.h create mode 100644 lights/aidl/android.hardware.lights.berlna.rc create mode 100644 lights/aidl/android.hardware.lights.berlna.xml create mode 100644 lights/aidl/main.cpp create mode 100644 lights/hidl/Light.cpp create mode 100644 lights/hidl/Light.h create mode 100644 lights/hidl/android.hardware.light@2.0-service.berlna.rc create mode 100644 lights/hidl/android.hardware.light@2.0-service.berlna.xml create mode 100644 lights/hidl/service.cpp create mode 100644 overlay-lineage/lineage-sdk/lineage/res/res/values/config.xml create mode 100644 sepolicy/vendor/file_contexts create mode 100644 sepolicy/vendor/genfs_contexts create mode 100644 sepolicy/vendor/hal_light_default.te diff --git a/BoardConfig.mk b/BoardConfig.mk index 3efcce3..e3b948e 100644 --- a/BoardConfig.mk +++ b/BoardConfig.mk @@ -61,5 +61,8 @@ TARGET_RECOVERY_UI_MARGIN_HEIGHT := 90 # Security VENDOR_SECURITY_PATCH := 2023-01-01 +# SELinux +BOARD_SEPOLICY_DIRS += $(DEVICE_PATH)/sepolicy/vendor + # inherit from the proprietary version include vendor/motorola/berlna/BoardConfigVendor.mk diff --git a/device.mk b/device.mk index ffca0bb..9da627c 100644 --- a/device.mk +++ b/device.mk @@ -31,7 +31,10 @@ PRODUCT_SHIPPING_API_LEVEL := 30 # Inherit from motorola sm7325-common $(call inherit-product, device/motorola/sm7325-common/sm7325.mk) -# Overlay +# Overlays +DEVICE_PACKAGE_OVERLAYS += \ + $(LOCAL_PATH)/overlay-lineage + PRODUCT_PACKAGES += \ FrameworksResBerlna \ LineageSystemUIBerlna \ @@ -74,6 +77,10 @@ PRODUCT_COPY_FILES += \ $(LOCAL_PATH)/media/media_profiles_yupik_v0.xml:$(TARGET_COPY_OUT_VENDOR)/etc/media_profiles_yupik_v0.xml \ $(LOCAL_PATH)/media/media_profiles_yupik_v1.xml:$(TARGET_COPY_OUT_VENDOR)/etc/media_profiles_yupik_v1.xml +# Lights +PRODUCT_PACKAGES += \ + android.hardware.lights-service.berlna + # NFC PRODUCT_PACKAGES += \ android.hardware.nfc@1.2.vendor \ diff --git a/lights/Android.bp b/lights/Android.bp new file mode 100644 index 0000000..fb9bdba --- /dev/null +++ b/lights/Android.bp @@ -0,0 +1,53 @@ +// +// Copyright (C) 2019-2020 The LineageOS 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. + +cc_binary { + name: "android.hardware.light@2.0-service.berlna", + defaults: ["hidl_defaults"], + init_rc: ["hidl/android.hardware.light@2.0-service.berlna.rc"], + vintf_fragments: ["hidl/android.hardware.light@2.0-service.berlna.xml"], + srcs: [ + "hidl/service.cpp", + "hidl/Light.cpp", + ], + shared_libs: [ + "libbase", + "libhidlbase", + "liblog", + "libutils", + "android.hardware.light@2.0", + ], + relative_install_path: "hw", + vendor: true, +} + +cc_binary { + name: "android.hardware.lights-service.berlna", + relative_install_path: "hw", + init_rc: ["aidl/android.hardware.lights.berlna.rc"], + vintf_fragments: ["aidl/android.hardware.lights.berlna.xml"], + vendor: true, + shared_libs: [ + "libbase", + "liblog", + "libhardware", + "libbinder_ndk", + "android.hardware.light-ndk_platform", + ], + srcs: [ + "aidl/Lights.cpp", + "aidl/main.cpp", + ], +} diff --git a/lights/aidl/Lights.cpp b/lights/aidl/Lights.cpp new file mode 100644 index 0000000..04ea9e3 --- /dev/null +++ b/lights/aidl/Lights.cpp @@ -0,0 +1,160 @@ +/* + * Copyright (C) 2019 The Android Open Source Project + * Copyright (C) 2020-2021 The LineageOS 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. + */ + +#define LOG_TAG "android.hardware.lights-service.berlna" + +#include "Lights.h" +#include +#include + +namespace { + +/* clang-format off */ +#define PPCAT_NX(A, B) A/B +#define PPCAT(A, B) PPCAT_NX(A, B) +#define STRINGIFY_INNER(x) #x +#define STRINGIFY(x) STRINGIFY_INNER(x) + +#define LEDS(x) PPCAT(/sys/class/leds, x) +#define WHITE_ATTR(x) STRINGIFY(PPCAT(LEDS(charging), x)) +/* clang-format on */ + +using ::android::base::ReadFileToString; +using ::android::base::WriteStringToFile; + +// Default max brightness +constexpr auto kDefaultMaxLedBrightness = 255; + +// Write value to path and close file. +bool WriteToFile(const std::string& path, uint32_t content) { + return WriteStringToFile(std::to_string(content), path); +} + +uint32_t RgbaToBrightness(uint32_t color) { + // Extract brightness from AARRGGBB. + uint32_t alpha = (color >> 24) & 0xFF; + + // Retrieve each of the RGB colors + uint32_t red = (color >> 16) & 0xFF; + uint32_t green = (color >> 8) & 0xFF; + uint32_t blue = color & 0xFF; + + // Scale RGB colors if a brightness has been applied by the user + if (alpha != 0xFF && alpha != 0) { + red = red * alpha / 0xFF; + green = green * alpha / 0xFF; + blue = blue * alpha / 0xFF; + } + + return (77 * red + 150 * green + 29 * blue) >> 8; +} + +inline uint32_t RgbaToBrightness(uint32_t color, uint32_t max_brightness) { + return RgbaToBrightness(color) * max_brightness / 0xFF; +} + +inline bool IsLit(uint32_t color) { + return color & 0x00ffffff; +} + +} // anonymous namespace + +namespace aidl { +namespace android { +namespace hardware { +namespace light { + +Lights::Lights() { + std::map> lights_{ + {(int)LightType::NOTIFICATIONS, + [this](auto&&... args) { setLightNotification(args...); }}, + {(int)LightType::BATTERY, [this](auto&&... args) { setLightNotification(args...); }}, + {(int)LightType::BACKLIGHT, {}}}; + + std::vector availableLights; + for (auto const& pair : lights_) { + int id = pair.first; + HwLight hwLight{}; + hwLight.id = id; + availableLights.emplace_back(hwLight); + } + mAvailableLights = availableLights; + mLights = lights_; + + std::string buf; + + if (ReadFileToString(WHITE_ATTR(max_brightness), &buf)) { + max_led_brightness_ = std::stoi(buf); + } else { + max_led_brightness_ = kDefaultMaxLedBrightness; + LOG(ERROR) << "Failed to read max LED brightness, fallback to " << kDefaultMaxLedBrightness; + } +} + +ndk::ScopedAStatus Lights::setLightState(int id, const HwLightState& state) { + auto it = mLights.find(id); + if (it == mLights.end()) { + LOG(ERROR) << "Light not supported"; + return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); + } + + it->second(id, state); + + return ndk::ScopedAStatus::ok(); +} + +ndk::ScopedAStatus Lights::getLights(std::vector* lights) { + for (auto i = mAvailableLights.begin(); i != mAvailableLights.end(); i++) { + lights->push_back(*i); + } + return ndk::ScopedAStatus::ok(); +} + +void Lights::setLightNotification(int id, const HwLightState& state) { + bool found = false; + for (auto&& [cur_id, cur_state] : notif_states_) { + if (cur_id == id) { + cur_state = state; + } + + // Fallback to battery light + if (!found && (cur_id == (int)LightType::BATTERY || IsLit(cur_state.color))) { + found = true; + LOG(DEBUG) << __func__ << ": id=" << id; + applyNotificationState(cur_state); + } + } +} + +void Lights::applyNotificationState(const HwLightState& state) { + int brightness = RgbaToBrightness(state.color, max_led_brightness_); + + // Turn off the leds (initially) + WriteToFile(WHITE_ATTR(breath), 0); + if (state.flashMode == FlashMode::TIMED && state.flashOnMs > 0 && state.flashOffMs > 0) { + WriteToFile(WHITE_ATTR(delay_on), static_cast(state.flashOnMs)); + WriteToFile(WHITE_ATTR(delay_off), static_cast(state.flashOffMs)); + WriteToFile(WHITE_ATTR(breath), 1); + } else { + WriteToFile(WHITE_ATTR(brightness), brightness); + } +} + +} // namespace light +} // namespace hardware +} // namespace android +} // namespace aidl diff --git a/lights/aidl/Lights.h b/lights/aidl/Lights.h new file mode 100644 index 0000000..d634988 --- /dev/null +++ b/lights/aidl/Lights.h @@ -0,0 +1,56 @@ +/* + * Copyright (C) 2020 The Android Open Source Project + * Copyright (C) 2020-2021 The LineageOS 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. + */ + +#pragma once + +#include +#include +#include +#include +#include + +namespace aidl { +namespace android { +namespace hardware { +namespace light { + +class Lights : public BnLights { + public: + Lights(); + ndk::ScopedAStatus setLightState(int id, const HwLightState& state) override; + ndk::ScopedAStatus getLights(std::vector* types) override; + + private: + void setLightNotification(int id, const HwLightState& state); + void applyNotificationState(const HwLightState& state); + + uint32_t max_led_brightness_; + + std::map> mLights; + std::vector mAvailableLights; + + // Keep sorted in the order of importance. + std::array, 2> notif_states_ = {{ + {(int)LightType::NOTIFICATIONS, {}}, + {(int)LightType::BATTERY, {}}, + }}; +}; + +} // namespace light +} // namespace hardware +} // namespace android +} // namespace aidl diff --git a/lights/aidl/android.hardware.lights.berlna.rc b/lights/aidl/android.hardware.lights.berlna.rc new file mode 100644 index 0000000..4b77288 --- /dev/null +++ b/lights/aidl/android.hardware.lights.berlna.rc @@ -0,0 +1,17 @@ +service vendor.light /vendor/bin/hw/android.hardware.lights-service.berlna + class hal + user system + group system + shutdown critical + +on boot + # Change ownership and permission for leds backlight + chmod 0664 /sys/class/leds/lcd-backlight/brightness + chown system system /sys/class/leds/charging/brightness + chmod 0664 /sys/class/leds/charging/brightness + chown system system /sys/class/leds/charging/breath + chmod 660 /sys/class/leds/charging/breath + chown system system /sys/class/leds/charging/delay_off + chmod 660 /sys/class/leds/charging/delay_off + chown system system /sys/class/leds/charging/delay_on + chmod 660 /sys/class/leds/charging/delay_on diff --git a/lights/aidl/android.hardware.lights.berlna.xml b/lights/aidl/android.hardware.lights.berlna.xml new file mode 100644 index 0000000..db604d6 --- /dev/null +++ b/lights/aidl/android.hardware.lights.berlna.xml @@ -0,0 +1,6 @@ + + + android.hardware.light + ILights/default + + diff --git a/lights/aidl/main.cpp b/lights/aidl/main.cpp new file mode 100644 index 0000000..8509bfb --- /dev/null +++ b/lights/aidl/main.cpp @@ -0,0 +1,37 @@ +/* + * Copyright (C) 2020 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. + */ + +#include +#include +#include +#include "Lights.h" + +using ::aidl::android::hardware::light::Lights; + +int main() { + ABinderProcess_setThreadPoolMaxThreadCount(0); + std::shared_ptr lights = ndk::SharedRefBase::make(); + if (!lights) { + return EXIT_FAILURE; + } + + const std::string instance = std::string() + Lights::descriptor + "/default"; + binder_status_t status = AServiceManager_addService(lights->asBinder().get(), instance.c_str()); + CHECK(status == STATUS_OK); + + ABinderProcess_joinThreadPool(); + return EXIT_FAILURE; // should not reached +} diff --git a/lights/hidl/Light.cpp b/lights/hidl/Light.cpp new file mode 100644 index 0000000..e6c5cc2 --- /dev/null +++ b/lights/hidl/Light.cpp @@ -0,0 +1,140 @@ +/* + * Copyright (C) 2017 The LineageOS 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. + */ + +#define LOG_TAG "android.hardware.light@2.0-service.berlna" + +#include + +#include "Light.h" + +#include + +namespace android { +namespace hardware { +namespace light { +namespace V2_0 { +namespace implementation { + +#define LEDS "/sys/class/leds/" + +#define LCD_LED LEDS "lcd-backlight/" +#define CHARGING_LED LEDS "charging/" + +#define BRIGHTNESS "brightness" +#define BREATH "breath" +#define DELAY_OFF "delay_off" +#define DELAY_ON "delay_on" + +/* + * Write value to path and close file. + */ +static void set(std::string path, std::string value) { + std::ofstream file(path); + + if (!file.is_open()) { + ALOGE("failed to write %s to %s", value.c_str(), path.c_str()); + return; + } + + file << value; +} + +static void set(std::string path, int value) { + set(path, std::to_string(value)); +} + +static uint32_t rgbToBrightness(const LightState& state) { + uint32_t color = state.color & 0x00ffffff; + return ((77 * ((color >> 16) & 0xff)) + (150 * ((color >> 8) & 0xff)) + + (29 * (color & 0xff))) >> 8; +} + +static void handleBacklight(const LightState& state) { + uint32_t brightness = rgbToBrightness(state); + set(LCD_LED BRIGHTNESS, brightness); +} + +static void handleNotification(const LightState& state) { + uint32_t alpha, brightness; + + /* + * Extract brightness from AARRGGBB. + */ + alpha = (state.color >> 24) & 0xFF; + brightness = rgbToBrightness(state); + + /* + * Scale brightness if the Alpha brightness is not 0xFF. + */ + if (alpha != 0xFF) + brightness = (brightness * alpha) / 0xFF; + + /* Disable blinking. */ + set(CHARGING_LED BREATH, 0); + + if (state.flashMode == Flash::TIMED) { + /* Set LED */ + set(CHARGING_LED DELAY_OFF, state.flashOffMs); + set(CHARGING_LED DELAY_ON, state.flashOnMs); + + /* Enable blinking. */ + set(CHARGING_LED BREATH, 1); + } else { + set(CHARGING_LED BRIGHTNESS, brightness); + } +} + +static std::map> lights = { + {Type::BACKLIGHT, handleBacklight}, + {Type::BATTERY, handleNotification}, + {Type::NOTIFICATIONS, handleNotification}, + {Type::ATTENTION, handleNotification}, +}; + +Light::Light() {} + +Return Light::setLight(Type type, const LightState& state) { + auto it = lights.find(type); + + if (it == lights.end()) { + return Status::LIGHT_NOT_SUPPORTED; + } + + /* + * Lock global mutex until light state is updated. + */ + std::lock_guard lock(globalLock); + + it->second(state); + + return Status::SUCCESS; +} + +Return Light::getSupportedTypes(getSupportedTypes_cb _hidl_cb) { + std::vector types; + + for (auto const& light : lights) types.push_back(light.first); + + _hidl_cb(types); + + return Void(); +} + +} // namespace implementation +} // namespace V2_0 +} // namespace light +} // namespace hardware +} // namespace android diff --git a/lights/hidl/Light.h b/lights/hidl/Light.h new file mode 100644 index 0000000..5b3d0ef --- /dev/null +++ b/lights/hidl/Light.h @@ -0,0 +1,55 @@ +/* + * Copyright (C) 2017 The LineageOS 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. + */ +#ifndef ANDROID_HARDWARE_LIGHT_V2_0_LIGHT_H +#define ANDROID_HARDWARE_LIGHT_V2_0_LIGHT_H + +#include +#include +#include +#include + +namespace android { +namespace hardware { +namespace light { +namespace V2_0 { +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 { + public: + Light(); + + Return setLight(Type type, const LightState& state) override; + Return getSupportedTypes(getSupportedTypes_cb _hidl_cb) override; + + private: + std::mutex globalLock; +}; + +} // namespace implementation +} // namespace V2_0 +} // namespace light +} // namespace hardware +} // namespace android + +#endif // ANDROID_HARDWARE_LIGHT_V2_0_LIGHT_H diff --git a/lights/hidl/android.hardware.light@2.0-service.berlna.rc b/lights/hidl/android.hardware.light@2.0-service.berlna.rc new file mode 100644 index 0000000..e549f67 --- /dev/null +++ b/lights/hidl/android.hardware.light@2.0-service.berlna.rc @@ -0,0 +1,16 @@ +service vendor.light-hal-2-0 /vendor/bin/hw/android.hardware.light@2.0-service.berlna + class hal + user system + group system + +on boot + # Change ownership and permission for leds backlight + chmod 0664 /sys/class/leds/lcd-backlight/brightness + chown system system /sys/class/leds/charging/brightness + chmod 0664 /sys/class/leds/charging/brightness + chown system system /sys/class/leds/charging/breath + chmod 660 /sys/class/leds/charging/breath + chown system system /sys/class/leds/charging/delay_off + chmod 660 /sys/class/leds/charging/delay_off + chown system system /sys/class/leds/charging/delay_on + chmod 660 /sys/class/leds/charging/delay_on diff --git a/lights/hidl/android.hardware.light@2.0-service.berlna.xml b/lights/hidl/android.hardware.light@2.0-service.berlna.xml new file mode 100644 index 0000000..98b3794 --- /dev/null +++ b/lights/hidl/android.hardware.light@2.0-service.berlna.xml @@ -0,0 +1,11 @@ + + + android.hardware.light + hwbinder + 2.0 + + ILight + default + + + \ No newline at end of file diff --git a/lights/hidl/service.cpp b/lights/hidl/service.cpp new file mode 100644 index 0000000..b6afccf --- /dev/null +++ b/lights/hidl/service.cpp @@ -0,0 +1,50 @@ +/* + * Copyright 2017 The LineageOS 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. + */ + +#define LOG_TAG "android.hardware.light@2.0-service.berlna" + +#include + +#include "Light.h" + +using android::hardware::configureRpcThreadpool; +using android::hardware::joinRpcThreadpool; + +using android::hardware::light::V2_0::ILight; +using android::hardware::light::V2_0::implementation::Light; + +using android::OK; +using android::sp; +using android::status_t; + +int main() { + android::sp service = new Light(); + + configureRpcThreadpool(1, true); + + status_t status = service->registerAsService(); + if (status != OK) { + ALOGE("Cannot register Light HAL service."); + return 1; + } + + ALOGI("Light HAL service ready."); + + joinRpcThreadpool(); + + ALOGI("Light HAL service failed to join thread pool."); + return 1; +} diff --git a/overlay-lineage/lineage-sdk/lineage/res/res/values/config.xml b/overlay-lineage/lineage-sdk/lineage/res/res/values/config.xml new file mode 100644 index 0000000..269150b --- /dev/null +++ b/overlay-lineage/lineage-sdk/lineage/res/res/values/config.xml @@ -0,0 +1,37 @@ + + + + + + 248 + + diff --git a/sepolicy/vendor/file_contexts b/sepolicy/vendor/file_contexts new file mode 100644 index 0000000..cde83d0 --- /dev/null +++ b/sepolicy/vendor/file_contexts @@ -0,0 +1,3 @@ +# HAL Services +/(vendor|system/vendor)/bin/hw/android\.hardware\.lights-service\.berlna u:object_r:hal_light_default_exec:s0 +/(vendor|system/vendor)/bin/hw/android\.hardware\.light@2\.0-service\.berlna u:object_r:hal_light_default_exec:s0 diff --git a/sepolicy/vendor/genfs_contexts b/sepolicy/vendor/genfs_contexts new file mode 100644 index 0000000..1539482 --- /dev/null +++ b/sepolicy/vendor/genfs_contexts @@ -0,0 +1,2 @@ +# Lights +genfscon sysfs /devices/platform/soc/c440000.qcom,spmi/spmi-0/spmi0-05/c440000.qcom,spmi:qcom,pm8150l@5:qcom,leds@d000/leds/charging u:object_r:sysfs_leds:s0 diff --git a/sepolicy/vendor/hal_light_default.te b/sepolicy/vendor/hal_light_default.te new file mode 100644 index 0000000..50ede18 --- /dev/null +++ b/sepolicy/vendor/hal_light_default.te @@ -0,0 +1,5 @@ +allow hal_light_default { + sysfs_leds +}:file rw_file_perms; + +r_dir_file(hal_light_default, sysfs_leds)