sm8450-common: Add hals.conf to load sensors.xiaomi to odm and move notifier to subdir

Change-Id: I9e16531e60fa6a0122330ee352cddd0840feb39c

sensors/sensor-notifier/notifiers/AodNotifier.cpp

@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2024 The LineageOS Project
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#define LOG_TAG "AodNotifier"
+
+#include "AodNotifier.h"
+
+#include <android-base/logging.h>
+#include <android-base/unique_fd.h>
+#include <display/drm/mi_disp.h>
+#include <poll.h>
+#include <sys/ioctl.h>
+
+#include "SensorNotifierUtils.h"
+
+static const std::string kDispFeatureDevice = "/dev/mi_display/disp_feature";
+
+using android::hardware::Return;
+using android::hardware::Void;
+using android::hardware::sensors::V1_0::Event;
+
+namespace {
+
+void requestDozeBrightness(int fd, __u32 doze_brightness) {
+    disp_doze_brightness_req req;
+    req.base.flag = 0;
+    req.base.disp_id = MI_DISP_PRIMARY;
+    req.doze_brightness = doze_brightness;
+    ioctl(fd, MI_DISP_IOCTL_SET_DOZE_BRIGHTNESS, &req);
+}
+
+class AodSensorCallback : public IEventQueueCallback {
+  public:
+    AodSensorCallback() {
+        disp_fd_ = android::base::unique_fd(open(kDispFeatureDevice.c_str(), O_RDWR));
+        if (disp_fd_.get() == -1) {
+            LOG(ERROR) << "failed to open " << kDispFeatureDevice;
+        }
+    }
+
+    Return<void> onEvent(const Event& e) {
+        requestDozeBrightness(disp_fd_.get(), (e.u.scalar == 3 || e.u.scalar == 5)
+                                                      ? DOZE_BRIGHTNESS_LBM
+                                                      : DOZE_BRIGHTNESS_HBM);
+        return Void();
+    }
+
+  private:
+    android::base::unique_fd disp_fd_;
+};
+
+}  // namespace
+
+AodNotifier::AodNotifier(sp<ISensorManager> manager) : SensorNotifier(manager) {
+    initializeSensorQueue("xiaomi.sensor.aod", true, new AodSensorCallback());
+}
+
+AodNotifier::~AodNotifier() {
+    deactivate();
+}
+
+void AodNotifier::notify() {
+    Result res;
+
+    android::base::unique_fd disp_fd_ =
+            android::base::unique_fd(open(kDispFeatureDevice.c_str(), O_RDWR));
+    if (disp_fd_.get() == -1) {
+        LOG(ERROR) << "failed to open " << kDispFeatureDevice;
+    }
+
+    // Register for power events
+    disp_event_req req;
+    req.base.flag = 0;
+    req.base.disp_id = MI_DISP_PRIMARY;
+    req.type = MI_DISP_EVENT_POWER;
+    ioctl(disp_fd_.get(), MI_DISP_IOCTL_REGISTER_EVENT, &req);
+
+    struct pollfd dispEventPoll = {
+            .fd = disp_fd_.get(),
+            .events = POLLIN,
+            .revents = 0,
+    };
+
+    while (mActive) {
+        int rc = poll(&dispEventPoll, 1, -1);
+        if (rc < 0) {
+            LOG(ERROR) << "failed to poll " << kDispFeatureDevice << ", err: " << rc;
+            continue;
+        }
+
+        struct disp_event_resp* response = parseDispEvent(disp_fd_.get());
+        if (response == nullptr) {
+            continue;
+        }
+
+        if (response->base.type != MI_DISP_EVENT_POWER) {
+            LOG(ERROR) << "unexpected display event: " << response->base.type;
+            continue;
+        }
+
+        int value = response->data[0];
+        LOG(VERBOSE) << "received data: " << std::bitset<8>(value);
+
+        switch (response->data[0]) {
+            case MI_DISP_POWER_LP1:
+                FALLTHROUGH_INTENDED;
+            case MI_DISP_POWER_LP2:
+                res = mQueue->enableSensor(mSensorHandle, 20000 /* sample period */,
+                                           0 /* latency */);
+                if (res != Result::OK) {
+                    LOG(ERROR) << "failed to enable sensor";
+                }
+                break;
+            case MI_DISP_POWER_ON:
+                requestDozeBrightness(disp_fd_.get(), DOZE_TO_NORMAL);
+                FALLTHROUGH_INTENDED;
+            default:
+                res = mQueue->disableSensor(mSensorHandle);
+                if (res != Result::OK) {
+                    LOG(DEBUG) << "failed to disable sensor";
+                }
+                break;
+        }
+    }
+}

sensors/sensor-notifier/notifiers/AodNotifier.h

@@ -0,0 +1,18 @@
+/*
+ * Copyright (C) 2024 The LineageOS Project
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include "SensorNotifier.h"
+
+class AodNotifier : public SensorNotifier {
+  public:
+    AodNotifier(sp<ISensorManager> manager);
+    ~AodNotifier();
+
+  protected:
+    void notify();
+};

sensors/sensor-notifier/notifiers/LightNotifier.cpp

@@ -0,0 +1,150 @@
+/*
+ * Copyright (C) 2024 The LineageOS Project
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#define LOG_TAG "LightNotifier"
+
+#include "LightNotifier.h"
+
+#include <android-base/logging.h>
+#include <android-base/properties.h>
+#include <android-base/unique_fd.h>
+#include <display/drm/mi_disp.h>
+#include <poll.h>
+#include <sys/ioctl.h>
+
+#include "SensorNotifierUtils.h"
+#include "SscCalApi.h"
+
+static const std::string kDispFeatureDevice = "/dev/mi_display/disp_feature";
+
+LightNotifier::LightNotifier(sp<ISensorManager> manager) : SensorNotifier(manager) {
+    std::stringstream lightSensorsPrimary(
+            android::base::GetProperty("ro.vendor.sensors.notifier.light_sensors.primary", ""));
+    std::stringstream lightSensorsSecondary(
+            android::base::GetProperty("ro.vendor.sensors.notifier.light_sensors.secondary", ""));
+
+    std::string sensor;
+    while (std::getline(lightSensorsPrimary, sensor, ',')) {
+        mLightSensorsPrimary.push_back(std::stoi(sensor));
+    }
+    while (std::getline(lightSensorsSecondary, sensor, ',')) {
+        mLightSensorsSecondary.push_back(std::stoi(sensor));
+    }
+}
+
+LightNotifier::~LightNotifier() {
+    deactivate();
+}
+
+void LightNotifier::notify() {
+    if (mLightSensorsPrimary.empty() && mLightSensorsSecondary.empty()) {
+        LOG(DEBUG) << "no light sensors to notify defined, skip light notifications";
+        mActive = false;
+        return;
+    }
+
+    android::base::unique_fd disp_fd_ =
+            android::base::unique_fd(open(kDispFeatureDevice.c_str(), O_RDWR));
+    if (disp_fd_.get() == -1) {
+        LOG(ERROR) << "failed to open " << kDispFeatureDevice;
+        mActive = false;
+        return;
+    }
+
+    std::vector<disp_display_type> displays;
+    if (!mLightSensorsPrimary.empty()) {
+        displays.push_back(MI_DISP_PRIMARY);
+    }
+    if (!mLightSensorsSecondary.empty()) {
+        displays.push_back(MI_DISP_SECONDARY);
+    }
+
+    const std::vector<disp_event_type> notifyEvents = {MI_DISP_EVENT_POWER, MI_DISP_EVENT_FPS,
+                                                       MI_DISP_EVENT_51_BRIGHTNESS,
+                                                       MI_DISP_EVENT_HBM, MI_DISP_EVENT_DC};
+
+    // Register for events
+    for (const disp_display_type& display : displays) {
+        for (const disp_event_type& event : notifyEvents) {
+            disp_event_req req;
+            req.base.flag = 0;
+            req.base.disp_id = display;
+            req.type = event;
+            ioctl(disp_fd_.get(), MI_DISP_IOCTL_REGISTER_EVENT, &req);
+        }
+    }
+
+    struct pollfd dispEventPoll = {
+            .fd = disp_fd_.get(),
+            .events = POLLIN,
+    };
+
+    _oem_msg* msg = new _oem_msg;
+    notify_t notifyType;
+    float value;
+
+    while (mActive) {
+        int rc = poll(&dispEventPoll, 1, -1);
+        if (rc < 0) {
+            LOG(ERROR) << "failed to poll " << kDispFeatureDevice << ", err: " << rc;
+            continue;
+        }
+
+        struct disp_event_resp* response = parseDispEvent(disp_fd_.get());
+        if (response == nullptr) {
+            continue;
+        }
+
+        std::vector<int>& sensorsToNotify = mLightSensorsPrimary;
+        switch (response->base.disp_id) {
+            case MI_DISP_PRIMARY:
+                break;
+            case MI_DISP_SECONDARY:
+                sensorsToNotify = mLightSensorsSecondary;
+                break;
+            default:
+                LOG(ERROR) << "got notified for unknown display: " << response->base.disp_id;
+                continue;
+        }
+
+        switch (response->base.type) {
+            case MI_DISP_EVENT_POWER:
+                notifyType = POWER_STATE;
+                value = response->data[0];
+                break;
+            case MI_DISP_EVENT_FPS:
+                notifyType = DISPLAY_FREQUENCY;
+                value = response->data[0];
+                break;
+            case MI_DISP_EVENT_51_BRIGHTNESS:
+                notifyType = BRIGHTNESS;
+                value = *(uint16_t*)response->data;
+                break;
+            case MI_DISP_EVENT_HBM:
+                notifyType = BRIGHTNESS;
+                value = response->data[0] ? -1 : -2;
+                break;
+            case MI_DISP_EVENT_DC:
+                notifyType = DC_STATE;
+                value = response->data[0];
+                break;
+            default:
+                LOG(ERROR) << "got unknown event: " << response->base.type;
+                continue;
+        };
+
+        for (const auto sensorId : sensorsToNotify) {
+            msg->sensorType = sensorId;
+            msg->notifyType = notifyType;
+            msg->notifyTypeFloat = notifyType;
+            msg->value = value;
+            msg->unknown1 = 1;
+            msg->unknown2 = 5;
+
+            SscCalApiWrapper::getInstance().processMsg(msg);
+        }
+    }
+}

sensors/sensor-notifier/notifiers/LightNotifier.h

@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2024 The LineageOS Project
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <android-base/unique_fd.h>
+
+#include "SensorNotifier.h"
+
+class LightNotifier : public SensorNotifier {
+  public:
+    LightNotifier(sp<ISensorManager> manager);
+    ~LightNotifier();
+
+  protected:
+    void notify();
+
+  private:
+    std::vector<int> mLightSensorsPrimary;
+    std::vector<int> mLightSensorsSecondary;
+};

sensors/sensor-notifier/notifiers/NonUiNotifier.cpp

@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2024 The LineageOS Project
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#define LOG_TAG "NonUiNotifier"
+
+#include "NonUiNotifier.h"
+
+#include <android-base/logging.h>
+#include <android-base/unique_fd.h>
+#include <linux/xiaomi_touch.h>
+#include <poll.h>
+#include <sys/ioctl.h>
+
+#include "SensorNotifierUtils.h"
+
+static const std::string kTouchDevice = "/dev/xiaomi-touch";
+
+using android::hardware::Return;
+using android::hardware::Void;
+using android::hardware::sensors::V1_0::Event;
+
+namespace {
+
+class NonUiSensorCallback : public IEventQueueCallback {
+  public:
+    NonUiSensorCallback() {
+        touch_fd_ = android::base::unique_fd(open(kTouchDevice.c_str(), O_RDWR));
+        if (touch_fd_.get() == -1) {
+            LOG(ERROR) << "failed to open " << kTouchDevice;
+        }
+    }
+
+    Return<void> onEvent(const Event& e) {
+        int buf[MAX_BUF_SIZE] = {0, Touch_Nonui_Mode, static_cast<int>(e.u.scalar)};
+        ioctl(touch_fd_.get(), TOUCH_IOC_SET_CUR_VALUE, &buf);
+
+        return Void();
+    }
+
+  private:
+    android::base::unique_fd touch_fd_;
+};
+
+}  // namespace
+
+NonUiNotifier::NonUiNotifier(sp<ISensorManager> manager) : SensorNotifier(manager) {
+    initializeSensorQueue("xiaomi.sensor.nonui", true, new NonUiSensorCallback());
+}
+
+NonUiNotifier::~NonUiNotifier() {
+    deactivate();
+}
+
+void NonUiNotifier::notify() {
+    Result res;
+
+    // Enable states of touchscreen sensors
+    const std::vector<const char*> paths = {
+            "/sys/class/touch/touch_dev/fod_longpress_gesture_enabled",
+            "/sys/class/touch/touch_dev/gesture_single_tap_enabled",
+            "/sys/class/touch/touch_dev/gesture_double_tap_enabled"};
+
+    pollfd* pollfds = new pollfd[paths.size()];
+    for (size_t i = 0; i < paths.size(); ++i) {
+        int fd = open(paths[i], O_RDONLY);
+        if (fd < 0) {
+            LOG(ERROR) << "failed to open " << paths[i] << " , err: " << fd;
+            mActive = false;
+            return;
+        }
+
+        pollfds[i].fd = fd;
+        pollfds[i].events = POLLPRI;
+    }
+
+    while (mActive) {
+        int rc = poll(pollfds, paths.size(), -1);
+        if (rc < 0) {
+            LOG(ERROR) << "failed to poll, err: " << rc;
+            continue;
+        }
+
+        bool enabled = false;
+        for (size_t i = 0; i < paths.size(); ++i) {
+            enabled = enabled || readBool(pollfds[i].fd);
+        }
+        if (enabled) {
+            res = mQueue->enableSensor(mSensorHandle, 20000 /* sample period */, 0 /* latency */);
+            if (res != Result::OK) {
+                LOG(ERROR) << "failed to enable sensor";
+            }
+        } else {
+            res = mQueue->disableSensor(mSensorHandle);
+            if (res != Result::OK) {
+                LOG(DEBUG) << "failed to disable sensor";
+            }
+        }
+    }
+}

sensors/sensor-notifier/notifiers/NonUiNotifier.h

@@ -0,0 +1,18 @@
+/*
+ * Copyright (C) 2024 The LineageOS Project
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include "SensorNotifier.h"
+
+class NonUiNotifier : public SensorNotifier {
+  public:
+    NonUiNotifier(sp<ISensorManager> manager);
+    ~NonUiNotifier();
+
+  protected:
+    void notify();
+};