liblights: build liblights from source, based on MAD, fixed by Dinolek for m2 mini, ported to m2note

mtk/liblights/Android.mk

@@ -0,0 +1,33 @@
+# Copyright (C) 2008 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.
+
+
+LOCAL_PATH:= $(call my-dir)
+# HAL module implemenation, not prelinked and stored in
+# hw/<COPYPIX_HARDWARE_MODULE_ID>.<ro.board.platform>.so
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := lights.c
+LOCAL_MULTILIB := both
+
+LOCAL_MODULE_TAGS := optional
+LOCAL_PRELINK_MODULE := false
+LOCAL_MODULE_RELATIVE_PATH := hw
+LOCAL_PROPRIETARY_MODULE := true
+
+LOCAL_SHARED_LIBRARIES := liblog
+
+LOCAL_MODULE := lights.$(TARGET_BOARD_PLATFORM)
+
+include $(BUILD_SHARED_LIBRARY)

mtk/liblights/lights.c

@@ -0,0 +1,256 @@
+/*
+ * Copyright (C) 2017 The M.A.D. Team
+ * Fixed for M2 Mini by Dinolek
+ * Ported to M2 Note by Moyster
+ *
+ * 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 "Lights"
+
+#include <cutils/log.h>
+
+#include <stdlib.h>
+#include <pthread.h>
+#include <stdint.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <fcntl.h>
+
+#include <sys/ioctl.h>
+#include <sys/types.h>
+
+#include <hardware/lights.h>
+
+static pthread_once_t g_init = PTHREAD_ONCE_INIT;
+static pthread_mutex_t g_lock = PTHREAD_MUTEX_INITIALIZER;
+
+static struct light_state_t g_attention;
+static struct light_state_t g_notification;
+
+char const *const LCD_FILE = "/sys/class/leds/lcd-backlight/brightness";
+char const *const LEDS_FILE   = "/sys/class/leds/button-backlight/trigger";
+
+/* device methods */
+void init_globals(void)
+{
+    /* init the mutex */
+    pthread_mutex_init(&g_lock, NULL);
+}
+
+static int write_int(char const *path, int value)
+{
+    int fd;
+    static int already_warned;
+
+    fd = open(path, O_RDWR);
+    if (fd >= 0) {
+	char buffer[20];
+	int bytes = snprintf(buffer, sizeof(buffer), "%d\n", value);
+	ssize_t amt = write(fd, buffer, (size_t)bytes);
+
+	close(fd);
+	return amt == -1 ? -errno : 0;
+    } else {
+	if (already_warned == 0) {
+	    ALOGE("Write_int failed to open %s\n", path);
+	    already_warned = 1;
+	}
+	return -errno;
+    }
+}
+
+static int write_str(char const *path, char *str)
+{
+    int fd;
+
+    fd = open(path, O_WRONLY);
+    if (fd >= 0) {
+	char buffer[20];
+	int bytes = snprintf(buffer, sizeof(buffer), "%s", str);
+	ssize_t amt = write(fd, buffer, (size_t)bytes);
+
+	close(fd);
+	return amt == -1 ? -errno : 0;
+    } else {
+	return -errno;
+    }
+}
+
+static int is_lit(struct light_state_t const *state)
+{
+    return state->color & 0x00ffffff;
+}
+
+
+static int rgb_to_brightness(struct light_state_t const *state)
+{
+    int color = state->color & 0x00ffffff;
+
+    return ((77*((color>>16)&0x00ff))
+	    + (150*((color>>8)&0x00ff)) + (29*(color&0x00ff))) >> 8;
+}
+
+static int set_speaker_light_locked(struct light_device_t *dev,
+	struct light_state_t const *state)
+{
+    if (!dev)
+	return -1;
+    if (state) {
+	write_str(LEDS_FILE, "timer");
+    }
+    return 0;
+}
+
+static int unset_speaker_light_locked(struct light_device_t *dev)
+{
+    if (!dev)
+	return -1;
+    write_str(LEDS_FILE, "none");
+    return 0;
+}
+
+static void handle_speaker_light_locked(struct light_device_t *dev)
+{
+    if (is_lit(&g_attention))
+	set_speaker_light_locked(dev, &g_attention);
+    else if (is_lit(&g_notification))
+	set_speaker_light_locked(dev, &g_notification);
+    else
+	unset_speaker_light_locked(dev);
+}
+
+static int set_light_notifications(struct light_device_t *dev,
+	struct light_state_t const *state)
+{
+    pthread_mutex_lock(&g_lock);
+
+    unsigned int brightness;
+    unsigned int color;
+    unsigned int rgb[3];
+
+    g_notification = *state;
+
+    /* If a brightness has been applied by the user */
+    brightness = (g_notification.color & 0xFF000000) >> 24;
+    if (brightness > 0 && brightness < 0xFF) {
+
+	/* Retrieve each of the RGB colors */
+	color = g_notification.color & 0x00FFFFFF;
+	rgb[0] = (color >> 16) & 0xFF;
+	rgb[1] = (color >> 8) & 0xFF;
+	rgb[2] = color & 0xFF;
+
+	/* Apply the brightness level */
+	if (rgb[0] > 0)
+	    rgb[0] = (rgb[0] * brightness) / 0xFF;
+	if (rgb[1] > 0)
+	    rgb[1] = (rgb[1] * brightness) / 0xFF;
+	if (rgb[2] > 0)
+	    rgb[2] = (rgb[2] * brightness) / 0xFF;
+
+	/* Update with the new color */
+	g_notification.color = (rgb[0] << 16) + (rgb[1] << 8) + rgb[2];
+    }
+
+    handle_speaker_light_locked(dev);
+    pthread_mutex_unlock(&g_lock);
+    return 0;
+}
+
+static int set_light_attention(struct light_device_t *dev,
+	struct light_state_t const *state)
+{
+    pthread_mutex_lock(&g_lock);
+    g_attention = *state;
+    handle_speaker_light_locked(dev);
+    pthread_mutex_unlock(&g_lock);
+    return 0;
+}
+
+static int set_light_backlight(struct light_device_t *dev,
+	struct light_state_t const *state)
+{
+    if (!dev) {
+	return -1;
+    }
+    int err = 0;
+    int brightness = rgb_to_brightness(state);
+
+    pthread_mutex_lock(&g_lock);
+    err = write_int(LCD_FILE, brightness);
+    pthread_mutex_unlock(&g_lock);
+    return err;
+}
+
+/* Close the lights device */
+static int close_lights(struct light_device_t *dev)
+{
+    if (dev) {
+	free(dev);
+    }
+    return 0;
+}
+
+/* module methods */
+/* Open a new instance of a lights device using name */
+static int open_lights(const struct hw_module_t *module, char const *name,
+		       struct hw_device_t **device)
+{
+    int (*set_light)(struct light_device_t *dev,
+	    struct light_state_t const *state);
+
+    if (strcmp(LIGHT_ID_BACKLIGHT, name) == 0)
+	set_light = set_light_backlight;
+    else if (strcmp(LIGHT_ID_NOTIFICATIONS, name) == 0)
+	set_light = set_light_notifications;
+    else if (strcmp(LIGHT_ID_ATTENTION, name) == 0)
+	set_light = set_light_attention;
+    else
+	return -EINVAL;
+
+    pthread_once(&g_init, init_globals);
+
+    struct light_device_t *dev = malloc(sizeof(struct light_device_t));
+
+    if (!dev)
+	return -ENOMEM;
+
+    memset(dev, 0, sizeof(*dev));
+
+    dev->common.tag = HARDWARE_DEVICE_TAG;
+    dev->common.version = 0;
+    dev->common.module = (struct hw_module_t *)module;
+    dev->common.close = (int (*)(struct hw_device_t *))close_lights;
+    dev->set_light = set_light;
+
+    *device = (struct hw_device_t *)dev;
+    return 0;
+}
+
+static struct hw_module_methods_t lights_module_methods = {
+    .open = open_lights,
+};
+
+/* The lights Module */
+struct hw_module_t HAL_MODULE_INFO_SYM = {
+    .tag = HARDWARE_MODULE_TAG,
+    .version_major = 1,
+    .version_minor = 0,
+    .id = LIGHTS_HARDWARE_MODULE_ID,
+    .name = "Meizu Lights Module",
+    .author = "Mediatek",
+    .methods = &lights_module_methods,
+};

product/meizu.mk

@@ -5,4 +5,5 @@ PRODUCT_PACKAGES += \
 
 # Doze
 PRODUCT_PACKAGES += \
-    MeizuDoze
+    MeizuDoze \
+    lights.$(TARGET_BOARD_PLATFORM)