[Feature] add GA346 baseline version
Change-Id: Ic62933698569507dcf98240cdf5d9931ae34348f
diff --git a/src/kernel/linux/v4.19/drivers/leds/leds-mtk-pwm.c b/src/kernel/linux/v4.19/drivers/leds/leds-mtk-pwm.c
new file mode 100644
index 0000000..ccaac70
--- /dev/null
+++ b/src/kernel/linux/v4.19/drivers/leds/leds-mtk-pwm.c
@@ -0,0 +1,572 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2018 MediaTek Inc.
+ *
+ */
+
+#include <linux/ctype.h>
+#include <linux/err.h>
+#include <linux/leds.h>
+#include <linux/leds_pwm.h>
+#include <linux/module.h>
+#include <linux/of_platform.h>
+#include <linux/platform_device.h>
+#include <linux/pwm.h>
+#include <linux/sched.h>
+#include <linux/sched/clock.h>
+#include <linux/slab.h>
+#include <linux/string.h>
+#include <linux/workqueue.h>
+
+
+/****************************************************************************
+ * variables
+ ***************************************************************************/
+
+struct mtk_leds_info;
+struct led_desp *leds_desp;
+
+static int led_pwm_level_set(struct led_classdev *led_cdev,
+ enum led_brightness brightness);
+
+struct led_pwm_info {
+ struct pwm_device *pwm;
+ struct led_pwm config;
+ unsigned long long duty;
+};
+
+struct led_debug_info {
+ unsigned long long current_t;
+ unsigned long long last_t;
+ char buffer[4096];
+ int count;
+};
+
+struct led_limit_info {
+
+ unsigned int limit_l;
+ u8 flag;
+ unsigned int current_l;
+ unsigned int last_l;
+};
+
+struct led_desp {
+ int index;
+ char name[16];
+};
+
+struct mtk_led_data {
+ struct led_desp desp;
+ struct led_classdev cdev;
+ struct led_pwm_info info;
+ int level;
+ int delay_on;
+ int delay_off;
+ int led_bits;
+ int trans_bits;
+ struct device_node *np;
+ struct mtk_leds_info *parent;
+ struct led_debug_info debug;
+ struct led_limit_info limit;
+ struct work_struct work;
+};
+
+struct mtk_leds_info {
+ struct device *dev;
+ struct mutex lock;
+ int nums;
+ struct mtk_led_data leds[0];
+ struct wakeup_source leds_suspend_lock;
+};
+
+static DEFINE_MUTEX(leds_mutex);
+
+
+/****************************************************************************
+ * DEBUG MACROS
+ ***************************************************************************/
+
+#define LEDS_DRV_TAG "[LED_DRV]"
+#define LEDS_DRV_INFO(format, args...) \
+ pr_info("%s:%s() line-%d: " format, \
+ LEDS_DRV_TAG, __func__, __LINE__, ## args)
+
+static void led_debug_log(struct mtk_led_data *s_led,
+ int level, int mappingLevel)
+{
+ unsigned long cur_time_mod = 0;
+ unsigned long long cur_time_display = 0;
+
+ s_led->debug.current_t = sched_clock();
+ cur_time_display = s_led->debug.current_t;
+ cur_time_mod = do_div(cur_time_display, 1000000000);
+
+ sprintf(s_led->debug.buffer + strlen(s_led->debug.buffer),
+ "T:%lld.%ld,L:%d map:%d ",
+ cur_time_display, cur_time_mod/1000000,
+ level, mappingLevel);
+
+ s_led->debug.count++;
+
+ if (level == 0 || s_led->debug.count >= 5 ||
+ (s_led->debug.current_t - s_led->debug.last_t) > 1000000000) {
+ LEDS_DRV_INFO("%s", s_led->debug.buffer);
+ s_led->debug.count = 0;
+ s_led->debug.buffer[strlen("[Light] Set directly ") +
+ strlen(s_led->cdev.name)] = '\0';
+ }
+
+ s_led->debug.last_t = sched_clock();
+}
+
+
+/****************************************************************************
+ * add API for temperature control
+ ***************************************************************************/
+
+struct led_desp *getLedDesp(char *name)
+{
+ while (leds_desp++) {
+ if (strcmp(name, leds_desp->name) == 0)
+ return leds_desp;
+ }
+ return NULL;
+}
+EXPORT_SYMBOL(getLedDesp);
+
+int setMaxBrightness(struct led_desp *desp, int percent, int enable)
+{
+ struct mtk_led_data *led_dat;
+ int limit_l, max_l;
+
+ if (!desp) {
+ LEDS_DRV_INFO("can not find leds by led_desp %s",
+ desp->name);
+ return -1;
+ }
+ led_dat = container_of(desp, struct mtk_led_data, desp);
+
+ if (!led_dat) {
+ LEDS_DRV_INFO("not support led %s CONTROL_BL_TEMPERATURE!",
+ desp->name);
+ return -1;
+ }
+ max_l = led_dat->cdev.max_brightness;
+ limit_l = (percent * max_l) / 100;
+ LEDS_DRV_INFO("name: %s, limit_l : %d, enable: %d",
+ desp->name, limit_l, enable);
+ if (enable) {
+ led_dat->limit.flag = 1;
+ led_dat->limit.limit_l = limit_l;
+ if (led_dat->limit.current_l != 0) {
+ if (led_dat->limit.limit_l < led_dat->limit.last_l) {
+ LEDS_DRV_INFO
+ ("set value control start! limit=%d\n",
+ led_dat->limit.limit_l);
+ led_dat->level = led_dat->limit.limit_l;
+ led_pwm_level_set(&led_dat->cdev,
+ led_dat->limit.limit_l);
+ } else {
+ led_pwm_level_set(&led_dat->cdev,
+ led_dat->limit.last_l);
+ }
+ }
+ } else {
+ led_dat->limit.flag = 0;
+ led_dat->limit.limit_l = (1 << led_dat->led_bits) - 1;
+
+ if (led_dat->limit.current_l != 0) {
+ LEDS_DRV_INFO("control temperature close:limit=%d\n",
+ led_dat->limit.limit_l);
+ led_pwm_level_set(&led_dat->cdev,
+ led_dat->limit.last_l);
+ }
+ }
+
+ return 0;
+
+}
+EXPORT_SYMBOL(setMaxBrightness);
+
+/****************************************************************************
+ * driver functions
+ ***************************************************************************/
+static void __led_pwm_set(struct led_pwm_info *led_info)
+{
+ int new_duty = led_info->duty;
+
+ pwm_config(led_info->pwm, new_duty, led_info->config.pwm_period_ns);
+ if (new_duty == 0)
+ pwm_disable(led_info->pwm);
+ else
+ pwm_enable(led_info->pwm);
+}
+
+static int led_pwm_set(struct mtk_led_data *led_dat,
+ unsigned int brightness)
+{
+ unsigned int max;
+ unsigned long long duty;
+
+ led_dat->level = brightness;
+ max = led_dat->cdev.max_brightness;
+ duty = led_dat->info.config.pwm_period_ns;
+ duty *= brightness;
+ LEDS_DRV_INFO("brightness=%d, max_brightness=%d, duty=%lld",
+ brightness, max, duty);
+ do_div(duty, max);
+
+ if (led_dat->info.config.active_low)
+ duty = led_dat->info.config.pwm_period_ns - duty;
+
+ led_dat->info.duty = duty;
+
+ __led_pwm_set(&led_dat->info);
+
+ return 0;
+}
+
+
+void mtk_led_work(struct work_struct *work)
+{
+ struct mtk_led_data *led_data =
+ container_of(work, struct mtk_led_data, work);
+
+ mutex_lock(&leds_mutex);
+ led_pwm_set(led_data, led_data->level);
+ mutex_unlock(&leds_mutex);
+}
+
+static int led_level_set(struct mtk_led_data *s_led,
+ enum led_brightness brightness)
+{
+
+ unsigned int mappingLevel = (
+ (((1 << s_led->trans_bits) - 1) * brightness
+ + (((1 << s_led->led_bits) - 1) / 2))
+ / ((1 << s_led->led_bits) - 1));
+
+ schedule_work(&s_led->work);
+ s_led->level = brightness;
+ led_debug_log(s_led, brightness, mappingLevel);
+ led_pwm_set(s_led, brightness);
+ return 0;
+}
+
+static int led_pwm_disable(struct led_pwm_info *led_info)
+{
+
+ pwm_config(led_info->pwm, 0, led_info->config.pwm_period_ns);
+ pwm_disable(led_info->pwm);
+
+ return 0;
+}
+
+static int led_pwm_level_set(struct led_classdev *led_cdev,
+ enum led_brightness brightness)
+{
+ struct mtk_led_data *led_dat =
+ container_of(led_cdev, struct mtk_led_data, cdev);
+
+ if (strcmp(led_dat->info.config.name, "lcd-backlight")) {
+ led_dat->limit.current_l = brightness;
+ if (led_dat->limit.flag) {
+ if (led_dat->limit.limit_l < led_dat->limit.current_l)
+ brightness = led_dat->limit.limit_l;
+ } else
+ led_dat->limit.last_l = brightness;
+ }
+ if (led_dat->level != brightness)
+ return led_level_set(led_dat, brightness);
+ return 0;
+}
+
+static void led_data_init(struct mtk_led_data *s_led)
+{
+ if (!strcmp(s_led->info.config.name, "lcd-backlight")) {
+ s_led->limit.last_l = 0;
+ s_led->limit.limit_l = 255;
+ s_led->limit.flag = 0;
+ s_led->limit.current_l = 0;
+ }
+ INIT_WORK(&s_led->work, mtk_led_work);
+ sprintf(s_led->debug.buffer + strlen(s_led->debug.buffer),
+ "[Light] Set %s directly ", s_led->info.config.name);
+
+}
+
+static int led_pwm_config_add(struct device *dev,
+ struct mtk_led_data *s_led)
+{
+ struct pwm_args pargs;
+ int ret = 0;
+
+ s_led->cdev.name = s_led->info.config.name;
+ s_led->cdev.default_trigger = s_led->info.config.default_trigger;
+ s_led->cdev.brightness = s_led->level;
+ s_led->cdev.max_brightness = s_led->info.config.max_brightness;
+ s_led->cdev.flags = LED_CORE_SUSPENDRESUME;
+ s_led->cdev.brightness_set_blocking = led_pwm_level_set;
+ ret = devm_led_classdev_register(dev, &(s_led->cdev));
+ LEDS_DRV_INFO("%s devm_led_classdev_register ok! ", s_led->cdev.name);
+
+ if (s_led->np != NULL)
+ s_led->info.pwm = devm_of_pwm_get(dev, s_led->np,
+ s_led->info.config.name);
+ else
+ s_led->info.pwm = devm_pwm_get(dev, s_led->info.config.name);
+ if (IS_ERR(s_led->info.pwm)) {
+ ret = PTR_ERR(s_led->info.pwm);
+ if (ret != -EPROBE_DEFER) {
+ dev_err(dev, "unable to request PWM for %s, err_code: %d\n",
+ s_led->info.config.name, ret);
+ goto err;
+ }
+ }
+
+ pwm_apply_args(s_led->info.pwm);
+ pwm_get_args(s_led->info.pwm, &pargs);
+
+ s_led->info.config.pwm_period_ns = pargs.period;
+ if (!s_led->info.config.pwm_period_ns && (pargs.period > 0))
+ s_led->info.config.pwm_period_ns = pargs.period;
+ LEDS_DRV_INFO("info.config.pwm_period_ns = %d!",
+ s_led->info.config.pwm_period_ns);
+
+ led_pwm_level_set(&s_led->cdev, s_led->cdev.brightness);
+ LEDS_DRV_INFO("set led pwm OK!");
+ return ret;
+
+ err:
+ dev_err(dev, "add pwm failed!\n");
+ ret = -ENOMEM;
+ return ret;
+
+}
+
+static int mtk_leds_parse_dt(struct device *dev,
+ struct mtk_leds_info *m_leds)
+{
+ struct device_node *leds_np, *child;
+ struct mtk_led_data *s_led;
+ int ret = 0, num = 0;
+ const char *state;
+
+ if (!dev->of_node) {
+ dev_err(dev, "Error load dts: node not exist!\n");
+ return ret;
+ }
+ leds_np = of_find_node_by_name(dev->of_node, "backlight");
+ if (!leds_np) {
+ dev_err(dev, "Error load dts node, node name error!\n");
+ return ret;
+ }
+
+ for_each_available_child_of_node(dev->of_node, child) {
+
+ s_led = &(m_leds->leds[num]);
+ ret = of_property_read_string(child, "label",
+ &(s_led->info.config.name));
+ if (ret) {
+ dev_err(dev, "Fail to read label property");
+ goto out_led_dt;
+ }
+ ret = of_property_read_string(child, "default-trigger",
+ &(s_led->info.config.default_trigger));
+ if (ret) {
+ dev_err(dev, "Fail to read default-trigger property");
+ goto out_led_dt;
+ }
+ ret = of_property_read_u8(child, "active-low",
+ &(s_led->info.config.active_low));
+ if (ret) {
+ dev_err(dev, "Fail to read active-low property\n");
+ goto out_led_dt;
+ }
+ ret = of_property_read_u32(child,
+ "led-bits", &(s_led->led_bits));
+ if (ret) {
+ LEDS_DRV_INFO("No led-bits, use default value 8");
+ s_led->led_bits = 8;
+ }
+ s_led->info.config.max_brightness =
+ (1 << s_led->led_bits) - 1;
+ ret = of_property_read_u8(child,
+ "limit-state", &(s_led->limit.flag));
+ if (ret) {
+ LEDS_DRV_INFO("No limit-state, use default value 0");
+ s_led->limit.flag = 0;
+ }
+ ret = of_property_read_u32(child,
+ "trans-bits", &(s_led->trans_bits));
+ if (ret) {
+ LEDS_DRV_INFO("No trans-bits, use default value 10");
+ s_led->trans_bits = 10;
+ }
+ ret = of_property_read_string(child, "default-state", &state);
+ if (!ret) {
+ if (!strcmp(state, "half"))
+ s_led->level =
+ s_led->info.config.max_brightness / 2;
+ else if (!strcmp(state, "on"))
+ s_led->level =
+ s_led->info.config.max_brightness;
+ else
+ s_led->level = 0;
+
+ } else
+ s_led->level = s_led->info.config.max_brightness;
+ LEDS_DRV_INFO("parse %d leds dt: %s, %s, %d, %d, %d\n",
+ num, s_led->info.config.name,
+ s_led->info.config.default_trigger,
+ s_led->info.config.active_low,
+ s_led->info.config.max_brightness,
+ s_led->led_bits);
+ s_led->np = child;
+ s_led->parent = m_leds;
+ s_led->desp.index = num;
+ strncpy(s_led->desp.name, s_led->info.config.name,
+ strlen(s_led->info.config.name));
+ leds_desp[num] = s_led->desp;
+ led_data_init(s_led);
+ led_pwm_config_add(dev, s_led);
+ led_pwm_level_set(&s_led->cdev, s_led->level);
+ num++;
+ }
+ m_leds->nums = num;
+ LEDS_DRV_INFO("load dts ok!");
+ return ret;
+out_led_dt:
+ dev_err(dev, "Error load dts node!\n");
+ of_node_put(child);
+ return ret;
+}
+
+
+/****************************************************************************
+ * driver functions
+ ***************************************************************************/
+
+static int mtk_leds_probe(struct platform_device *pdev)
+{
+
+ struct device *dev = &pdev->dev;
+ struct mtk_leds_info *m_leds;
+ int ret, nums;
+
+ LEDS_DRV_INFO("probe begain +++");
+
+ nums = of_get_child_count(dev->of_node);
+ LEDS_DRV_INFO("Load dts node nums: %d", nums);
+ m_leds = devm_kzalloc(dev, (sizeof(struct mtk_leds_info) +
+ (sizeof(struct mtk_led_data) * (nums))), GFP_KERNEL);
+ if (!m_leds)
+ goto err;
+ leds_desp = devm_kzalloc(dev,
+ (sizeof(struct led_desp) * (nums)), GFP_KERNEL);
+ if (!leds_desp)
+ goto err;
+
+ platform_set_drvdata(pdev, m_leds);
+ m_leds->dev = dev;
+ mutex_init(&m_leds->lock);
+ ret = mtk_leds_parse_dt(&(pdev->dev), m_leds);
+ if (ret) {
+ dev_err(&pdev->dev, "Failed to parse devicetree!\n");
+ goto err;
+ }
+
+ LEDS_DRV_INFO("probe end ---");
+ return 0;
+ err:
+ dev_err(&pdev->dev, "Failed to probe!\n");
+ ret = -ENOMEM;
+ return ret;
+}
+
+static int mtk_leds_remove(struct platform_device *pdev)
+{
+ int i;
+ struct mtk_leds_info *m_leds = dev_get_platdata(&pdev->dev);
+
+ if (m_leds)
+ return 0;
+ for (i = 0; i < m_leds->nums; i++) {
+ if (!m_leds->leds[i].parent)
+ continue;
+ led_classdev_unregister(&m_leds->leds[i].cdev);
+ cancel_work_sync(&m_leds->leds[i].work);
+ m_leds->leds[i].parent = NULL;
+ }
+ kfree(m_leds);
+ m_leds = NULL;
+
+ return 0;
+}
+
+static void mtk_leds_shutdown(struct platform_device *pdev)
+{
+ int i;
+ struct mtk_leds_info *m_leds = dev_get_platdata(&pdev->dev);
+
+ LEDS_DRV_INFO("Turn off backlight\n");
+
+ for (i = 0; m_leds && i < m_leds->nums; i++) {
+ if (!&(m_leds->leds[i]))
+ continue;
+ led_pwm_disable(&(m_leds->leds[i].info));
+ }
+
+}
+
+static const struct of_device_id of_mtk_pwm_leds_match[] = {
+ { .compatible = "mediatek,pwm-leds", },
+ {},
+};
+MODULE_DEVICE_TABLE(of, of_mtk_pwm_leds_match);
+
+static struct platform_driver mtk_pwm_leds_driver = {
+ .driver = {
+ .name = "mtk-pwm-leds",
+ .owner = THIS_MODULE,
+ .of_match_table = of_mtk_pwm_leds_match,
+ },
+ .probe = mtk_leds_probe,
+ .remove = mtk_leds_remove,
+ .shutdown = mtk_leds_shutdown,
+
+};
+
+static int __init mtk_leds_init(void)
+{
+ int ret;
+
+ LEDS_DRV_INFO("Leds init\n");
+ ret = platform_driver_register(&mtk_pwm_leds_driver);
+
+ if (ret) {
+ LEDS_DRV_INFO("driver register error: %d\n", ret);
+ return ret;
+ }
+
+ return ret;
+}
+
+static void __exit mtk_leds_exit(void)
+{
+ platform_driver_unregister(&mtk_pwm_leds_driver);
+}
+
+/* delay leds init, for (1)display has delayed to use clock upstream.
+ * (2)to fix repeat switch battary and power supply caused BL KE issue,
+ * battary calling bl .shutdown whitch need to call disp_pwm and display
+ * function and they not yet probe.
+ */
+late_initcall(mtk_leds_init);
+module_exit(mtk_leds_exit);
+
+MODULE_AUTHOR("Mediatek Corporation");
+MODULE_DESCRIPTION("MTK Disp PWM Backlight Driver");
+MODULE_LICENSE("GPL");
+
+