Initial commit: Linux kernel 4.19 for Unplugged OS

This commit is contained in:
ziv committed 2025-10-06 13:52:42 +00:00
commit d30235b04c
80519 files changed
+35800681

No files matched your search

+81
View File
@@ -0,0 +1,81 @@
config MTK_LEDS
tristate "MediaTek LED Support"
depends on LEDS_CLASS
help
This selects the MediaTek(R) LEDs connected to MediaTek chips.
If you want to use MediaTek(R) LEDs support, say Y or M here.
If unsure, say N.
Mediatek LED module includes backlight,
indicate LED, keypad LED, button LED etc.
config LIGHTNESS_MAPPING_VALUE
int "Backlight brightness mapping value"
default 255
help
Backlight brightness mapping value, from 0 to 255.
config BACKLIGHT_SUPPORT_LP8557
bool "Support backlight lp8557 board"
default n
help
LED driver for LP8557 support.
Set y to support.
Set n to disable.
For pwm external backlight.
config BACKLIGHT_SUPPORT_LM3697
bool "LM3697(DW8832) Support"
default n
help
LED driver for lm3697(dw8832) support.
Set y to support.
Set n to disable.
Charge pump driver for external backlight.
config LEDS_MT6357
tristate "LED Support for Mediatek MT6357 PMIC"
depends on LEDS_CLASS
help
This option enables support for on-chip LED drivers found on
Mediatek MT6357 PMIC.
If you want to use MediaTek(R) LEDs support, say Y or M here.
If unsure, say N.
config LEDS_MTK_DISP
tristate "Mediatek display LED support"
depends on LEDS_CLASS
---help---
This option enables support for Mediatek display LEDs.
say 'y' to enable this
Set n to disable.
To compile this driver as a module, the module will be called leds-mtk-disp.
config LEDS_MTK_PWM
tristate "Mediatek pwm LED support"
depends on LEDS_CLASS
depends on PWM_MTK_DISP
help
This option enables support for Mediatek pwm LEDs.
say 'y' to enable this
To compile this driver as a module, choose 'M' here: the module
will be called leds-mtk-pwm.
config LEDS_MTK_I2C
tristate "Mediatek i2c LED support"
depends on LEDS_CLASS
help
This option enables support for Mediatek i2c LEDs.
say 'y' to enable this
To compile this driver as a module, choose 'M' here: the module
will be called leds-mtk-i2c.
config CONTROL_BL_TEMPERATURE
bool "Support backlight controlled by thermal"
---help---
This option enables support thermal to set max brightness.
Set y to support.
Set n to not support.
This option enables means thermal can set brightness by the api of led driver.
+32
View File
@@ -0,0 +1,32 @@
# SPDX-License-Identifier: GPL-2.0
ifdef CONFIG_LEDS_MTK_DISP
obj-$(CONFIG_LEDS_MTK_DISP) += leds-mtk-disp.o
else ifdef CONFIG_LEDS_MTK_PWM
obj-$(CONFIG_LEDS_MTK_PWM) += leds-mtk-pwm.o
else ifdef CONFIG_LEDS_MTK_I2C
obj-$(CONFIG_LEDS_MTK_I2C) += leds-mtk-i2c.o
else
ifeq (y, $(filter y, $(CONFIG_MACH_MT6765) $(CONFIG_MACH_MT6761)))
ccflags-y += -I$(srctree)/drivers/misc/mediatek/leds/mt6765
else ifeq (y, $(filter y, $(CONFIG_MACH_MT6853) $(CONFIG_MACH_MT6833)))
ccflags-y += -I$(srctree)/drivers/misc/mediatek/leds/mt6853
else
ccflags-y += -I$(srctree)/drivers/misc/mediatek/leds/$(MTK_PLATFORM)
endif
ccflags-y += -I$(srctree)/drivers/misc/mediatek/video/include
ccflags-y += -I$(srctree)/drivers/misc/mediatek/gate_ic
obj-$(CONFIG_MTK_LEDS) += mtk_leds_drv.o
ifeq (y, $(filter y, $(CONFIG_MACH_MT6765) $(CONFIG_MACH_MT6761)))
obj-y += $(subst ",,mt6765)/
else ifeq (y, $(filter y, $(CONFIG_MACH_MT6853) $(CONFIG_MACH_MT6833)))
obj-y += $(subst ",,mt6853)/
else
obj-y += $(subst ",,$(CONFIG_MTK_PLATFORM))/
endif
endif
obj-$(CONFIG_LEDS_MT6357) += leds-mt6357.o
obj-$(CONFIG_LEDS_MT6357) += mt_led_trigger.o
File diff suppressed because it is too large. Load diff
+538
View File
@@ -0,0 +1,538 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2018 MediaTek Inc.
*
*/
#include <linux/ctype.h>
#include <linux/kernel.h>
#include <linux/leds.h>
#include <linux/module.h>
#include <linux/of_platform.h>
#include <linux/platform_device.h>
#include <linux/sched.h>
#include <linux/sched/clock.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/workqueue.h>
#include "leds-mtk-disp.h"
#ifdef CONFIG_DRM_MEDIATEK
extern int mtkfb_set_backlight_level(unsigned int level);
#endif
#ifdef MET_USER_EVENT_SUPPORT
#include <mt-plat/met_drv.h>
#endif
#define CONFIG_LEDS_BRIGHTNESS_CHANGED
/****************************************************************************
* variables
***************************************************************************/
#undef pr_fmt
#define pr_fmt(fmt) KBUILD_MODNAME " %s(%d) :" fmt, __func__, __LINE__
struct mtk_leds_info;
static int led_level_set(struct led_classdev *led_cdev,
enum led_brightness brightness);
struct led_debug_info {
unsigned long long current_t;
unsigned long long last_t;
char buffer[4096];
int count;
};
struct led_desp {
int index;
char name[16];
};
struct leds_desp_info {
int lens;
struct led_desp *leds[0];
};
struct mtk_led_data {
struct led_desp desp;
struct led_conf_info conf;
int last_level;
int brightness;
struct mtk_leds_info *parent;
struct led_debug_info debug;
};
struct mtk_leds_info {
struct device *dev;
int nums;
struct mtk_led_data leds[0];
};
static DEFINE_MUTEX(leds_mutex);
struct leds_desp_info *leds_info;
static BLOCKING_NOTIFIER_HEAD(mtk_leds_chain_head);
int mtk_leds_register_notifier(struct notifier_block *nb)
{
return blocking_notifier_chain_register(&mtk_leds_chain_head, nb);
}
EXPORT_SYMBOL_GPL(mtk_leds_register_notifier);
int mtk_leds_unregister_notifier(struct notifier_block *nb)
{
return blocking_notifier_chain_unregister(&mtk_leds_chain_head, nb);
}
EXPORT_SYMBOL_GPL(mtk_leds_unregister_notifier);
int mtk_leds_call_notifier(unsigned long action, void *data)
{
return blocking_notifier_call_chain(&mtk_leds_chain_head, action, data);
}
EXPORT_SYMBOL_GPL(mtk_leds_call_notifier);
static int call_notifier(int event, struct mtk_led_data *led_dat)
{
int err;
err = mtk_leds_call_notifier(event, &led_dat->conf);
if (err)
pr_info("notifier_call_chain error\n");
return err;
}
/****************************************************************************
* DEBUG MACROS
***************************************************************************/
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;
int ret = 0;
s_led->debug.current_t = sched_clock();
cur_time_display = s_led->debug.current_t;
do_div(cur_time_display, 1000000);
cur_time_mod = do_div(cur_time_display, 1000);
ret = snprintf(s_led->debug.buffer + strlen(s_led->debug.buffer),
4095 - strlen(s_led->debug.buffer),
"T:%lld.%ld,L:%d L:%d map:%d ",
cur_time_display, cur_time_mod,
s_led->conf.cdev.brightness, level, mappingLevel);
s_led->debug.count++;
if (ret < 0 || ret >= 4096) {
pr_info("print log error!");
s_led->debug.count = 5;
}
if (level == 0 || s_led->debug.count >= 5 ||
(s_led->debug.current_t - s_led->debug.last_t) > 1000000000) {
pr_info("%s", s_led->debug.buffer);
s_led->debug.count = 0;
s_led->debug.buffer[strlen("[Light] Set directly ") +
strlen(s_led->conf.cdev.name)] = '\0';
}
s_led->debug.last_t = sched_clock();
}
static int getLedDespIndex(char *name)
{
int i = 0;
while (i < leds_info->lens) {
if (!strcmp(name, leds_info->leds[i]->name))
return i;
i++;
}
return -1;
}
/****************************************************************************
* driver functions
***************************************************************************/
static int led_level_disp_set(struct mtk_led_data *s_led,
int brightness)
{
brightness = min(brightness, s_led->conf.max_level);
if (brightness == s_led->conf.level)
return 0;
#ifdef CONFIG_DRM_MEDIATEK
mtkfb_set_backlight_level(brightness);
s_led->conf.level = brightness;
#endif
return 0;
}
/****************************************************************************
* add API for temperature control
***************************************************************************/
int mt_leds_max_brightness_set(char *name, int percent, bool enable)
{
struct mtk_led_data *led_dat;
int max_l = 0, index = -1, limit_l = 0, cur_l = 0;
index = getLedDespIndex(name);
if (index < 0) {
pr_notice("can not find leds by led_desp %s", name);
return -1;
}
led_dat = container_of(leds_info->leds[index],
struct mtk_led_data, desp);
max_l = led_dat->conf.cdev.max_brightness;
limit_l = (percent * max_l) / 100;
pr_info("before: name: %s, percent : %d, limit_l : %d, enable: %d",
leds_info->leds[index]->name, percent, limit_l, enable);
if (enable) {
led_dat->conf.max_level = limit_l;
cur_l = min(led_dat->last_level, limit_l);
} else if (!enable) {
led_dat->conf.max_level = max_l;
cur_l = led_dat->last_level;
}
#ifdef CONFIG_LEDS_BRIGHTNESS_CHANGED
call_notifier(3, led_dat);
#endif
if (led_dat->conf.cdev.brightness != 0)
led_level_disp_set(led_dat, cur_l);
pr_info("after: name: %s, cur_l : %d, max_level : %d",
led_dat->conf.cdev.name, cur_l, led_dat->conf.max_level);
return 0;
}
EXPORT_SYMBOL(mt_leds_max_brightness_set);
int mt_leds_brightness_set(char *name, int level)
{
struct mtk_led_data *led_dat;
int index, led_Level;
index = getLedDespIndex(name);
if (index < 0) {
pr_notice("can not find leds by led_desp %s", name);
return -1;
}
led_dat = container_of(leds_info->leds[index],
struct mtk_led_data, desp);
led_Level = (
(((1 << led_dat->conf.led_bits) - 1) * level
+ (((1 << led_dat->conf.trans_bits) - 1) / 2))
/ ((1 << led_dat->conf.trans_bits) - 1));
led_level_disp_set(led_dat, led_Level);
led_dat->last_level = led_Level;
return 0;
}
EXPORT_SYMBOL(mt_leds_brightness_set);
static int led_level_set(struct led_classdev *led_cdev,
enum led_brightness brightness)
{
int trans_level = 0;
struct led_conf_info *led_conf =
container_of(led_cdev, struct led_conf_info, cdev);
struct mtk_led_data *led_dat =
container_of(led_conf, struct mtk_led_data, conf);
if (led_dat->brightness == brightness)
return 0;
trans_level = (
(((1 << led_dat->conf.trans_bits) - 1) * brightness
+ (((1 << led_dat->conf.led_bits) - 1) / 2))
/ ((1 << led_dat->conf.led_bits) - 1));
led_debug_log(led_dat, brightness, trans_level);
#ifdef MET_USER_EVENT_SUPPORT
if (enable_met_backlight_tag())
output_met_backlight_tag(brightness);
#endif
led_dat->brightness = brightness;
#ifdef CONFIG_LEDS_BRIGHTNESS_CHANGED
call_notifier(1, led_dat);
#endif
#ifdef CONFIG_MTK_AAL_SUPPORT
disp_pq_notify_backlight_changed(trans_level);
#else
#ifdef CONFIG_MTK_SLD_SUPPORT
trans_level = disp_ccorr_change_backlight(trans_level);
brightness = (
(((1 << led_dat->conf.led_bits) - 1) * trans_level
+ (((1 << led_dat->conf.trans_bits) - 1) / 2))
/ ((1 << led_dat->conf.trans_bits) - 1));
led_dat->brightness = brightness;
#endif
led_level_disp_set(led_dat, brightness);
led_dat->last_level = brightness;
#endif
return 0;
}
static int led_data_init(struct device *dev, struct mtk_led_data *s_led)
{
int ret;
s_led->conf.cdev.flags = LED_CORE_SUSPENDRESUME;
s_led->conf.cdev.brightness_set_blocking = led_level_set;
s_led->brightness = s_led->conf.cdev.max_brightness;
s_led->conf.level = s_led->conf.cdev.max_brightness;
s_led->last_level = s_led->conf.cdev.max_brightness;
ret = devm_led_classdev_register(dev, &(s_led->conf.cdev));
if (ret < 0) {
pr_notice("led class register fail!");
return ret;
}
pr_info("%s devm_led_classdev_register ok! ", s_led->conf.cdev.name);
ret = snprintf(s_led->debug.buffer + strlen(s_led->debug.buffer),
4095 - strlen(s_led->debug.buffer),
"[Light] Set %s directly ", s_led->conf.cdev.name);
if (ret < 0 || ret >= 4096)
pr_info("print log init error!");
led_level_set(&s_led->conf.cdev, s_led->conf.cdev.brightness);
return 0;
}
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, level = 0;
const char *state;
leds_np = of_find_node_by_name(dev->of_node, "backlight");
if (!leds_np) {
pr_info("Error load dts node, node name error!");
ret = -EINVAL;
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->conf.cdev.name);
if (ret) {
pr_info("Fail to read label property");
ret = -EINVAL;
goto out_led_dt;
}
ret = of_property_read_u32(child,
"led-bits", &(s_led->conf.led_bits));
if (ret) {
pr_info("No led-bits, use default value 8");
s_led->conf.led_bits = 8;
}
s_led->conf.cdev.max_brightness =
(1 << s_led->conf.led_bits) - 1;
ret = of_property_read_u32(child,
"trans-bits", &(s_led->conf.trans_bits));
if (ret) {
pr_info("No trans-bits, use default value 10");
s_led->conf.trans_bits = 10;
}
ret = of_property_read_u32(child,
"max-brightness", &(s_led->conf.max_level));
if (ret) {
s_led->conf.max_level = s_led->conf.cdev.max_brightness;
pr_info("No max-brightness, use default: %d",
s_led->conf.max_level);
}
ret = of_property_read_string(child, "default-state", &state);
if (!ret) {
if (!strcmp(state, "half"))
level = s_led->conf.cdev.max_brightness / 2;
else if (!strcmp(state, "on"))
level = s_led->conf.cdev.max_brightness;
else
level = 0;
} else {
level = s_led->conf.cdev.max_brightness;
}
pr_info("parse %d leds dt: %s, %d, %d",
num, s_led->conf.cdev.name,
s_led->conf.max_level,
s_led->conf.led_bits);
strncpy(s_led->desp.name, s_led->conf.cdev.name,
strlen(s_led->conf.cdev.name));
s_led->desp.index = num;
leds_info->leds[num] = &s_led->desp;
s_led->conf.cdev.brightness = level;
ret = led_data_init(dev, s_led);
if (ret)
goto out_led_dt;
led_level_set(&s_led->conf.cdev, level);
num++;
}
m_leds->nums = num;
pr_info("load dts ok!");
return 0;
out_led_dt:
pr_notice("Error load dts node!");
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;
pr_info("probe begain +++");
nums = of_get_child_count(dev->of_node);
pr_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) {
ret = -ENOMEM;
goto err;
}
leds_info = devm_kzalloc(dev, (sizeof(struct leds_desp_info) +
sizeof(struct led_desp *) * (nums)),
GFP_KERNEL);
leds_info->lens = nums;
if (!leds_info) {
ret = -ENOMEM;
goto err;
}
ret = mtk_leds_parse_dt(&(pdev->dev), m_leds);
if (ret) {
pr_notice("Failed to parse devicetree!\n");
goto err;
}
platform_set_drvdata(pdev, m_leds);
m_leds->dev = dev;
pr_info("probe end ---");
return ret;
err:
pr_notice("Failed to probe!");
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].conf.cdev);
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);
pr_info("Turn off backlight\n");
for (i = 0; m_leds && i < m_leds->nums; i++) {
if (!&(m_leds->leds[i]))
continue;
#ifdef CONFIG_LEDS_BRIGHTNESS_CHANGED
call_notifier(2, &m_leds->leds[i]);
#ifdef CONFIG_MTK_AAL_SUPPORT
continue;
#endif
#endif
led_level_disp_set(&m_leds->leds[i], 0);
}
}
static const struct of_device_id of_mtk_disp_leds_match[] = {
{ .compatible = "mediatek,disp-leds", },
{},
};
MODULE_DEVICE_TABLE(of, of_mtk_disp_leds_match);
static struct platform_driver mtk_disp_leds_driver = {
.driver = {
.name = "mtk-disp-leds",
.of_match_table = of_mtk_disp_leds_match,
},
.probe = mtk_leds_probe,
.remove = mtk_leds_remove,
.shutdown = mtk_leds_shutdown,
};
static int __init mtk_leds_init(void)
{
int ret;
pr_info("Leds init");
ret = platform_driver_register(&mtk_disp_leds_driver);
if (ret) {
pr_info("driver register error: %d", ret);
return ret;
}
return ret;
}
static void __exit mtk_leds_exit(void)
{
platform_driver_unregister(&mtk_disp_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 Display Backlight Driver");
MODULE_LICENSE("GPL");
@@ -0,0 +1,29 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2018 MediaTek Inc.
*
*/
/****************************************************************************
* LED DRV functions
***************************************************************************/
extern struct led_conf_info {
int level;
int led_bits;
int trans_bits;
int max_level;
struct led_classdev cdev;
} led_conf_info;
int mtk_leds_register_notifier(struct notifier_block *nb);
int mtk_leds_unregister_notifier(struct notifier_block *nb);
int mt_leds_brightness_set(char *name, int bl_1024);
int mt_leds_max_brightness_set(char *name, int percent, bool enable);
extern int mtkfb_set_backlight_level(unsigned int level);
extern void disp_pq_notify_backlight_changed(int bl_1024);
extern int enable_met_backlight_tag(void);
extern int output_met_backlight_tag(int level);
extern int disp_ccorr_change_backlight(int bl_1024);
+519
View File
@@ -0,0 +1,519 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2018 MediaTek Inc.
*
*/
#include <linux/ctype.h>
#include <linux/delay.h>
#include <linux/i2c.h>
#include <linux/kernel.h>
#include <linux/leds.h>
#include <linux/module.h>
#include <linux/of_platform.h>
#include <linux/platform_device.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/sched.h>
#include <linux/sched/clock.h>
#include "leds-mtk-i2c.h"
#undef pr_fmt
#define pr_fmt(fmt) KBUILD_MODNAME " %s(%d) :" fmt, __func__, __LINE__
#ifdef MET_USER_EVENT_SUPPORT
#include <mt-plat/met_drv.h>
#endif
#define CONFIG_LEDS_BRIGHTNESS_CHANGED
/****************************************************************************
* variables
***************************************************************************/
struct led_debug_info {
unsigned long long current_t;
unsigned long long last_t;
char buffer[4096];
int count;
};
struct led_desp {
int index;
char name[16];
};
struct leds_desp_info {
int lens;
struct led_desp *leds[0];
};
struct mtk_led_data {
struct led_conf_info conf;
int last_brightness;
int last_level;
int hw_level;
struct led_desp desp;
struct led_debug_info debug;
};
struct mtk_leds_info {
int nums;
struct mtk_led_data leds[0];
};
struct leds_desp_info *leds_desp;
static DEFINE_MUTEX(leds_mutex);
static BLOCKING_NOTIFIER_HEAD(mtk_leds_chain_head);
static int led_level_i2c_set(struct mtk_led_data *s_led, int brightness);
int mtk_leds_register_notifier(struct notifier_block *nb)
{
return blocking_notifier_chain_register(&mtk_leds_chain_head, nb);
}
EXPORT_SYMBOL_GPL(mtk_leds_register_notifier);
int mtk_leds_unregister_notifier(struct notifier_block *nb)
{
return blocking_notifier_chain_unregister(&mtk_leds_chain_head, nb);
}
EXPORT_SYMBOL_GPL(mtk_leds_unregister_notifier);
int mtk_leds_call_notifier(unsigned long action, void *data)
{
return blocking_notifier_call_chain(&mtk_leds_chain_head, action, data);
}
EXPORT_SYMBOL_GPL(mtk_leds_call_notifier);
static int __maybe_unused call_notifier(int event, struct led_conf_info *led_info)
{
int err;
err = mtk_leds_call_notifier(event, led_info);
if (err)
dev_info(led_info->cdev.dev, "[ERROR] notifier_call_chain error\n");
return err;
}
/****************************************************************************
* Internal function
***************************************************************************/
static struct mtk_led_data *getLedData(char *name)
{
int i = 0;
struct mtk_led_data *led_dat;
while (i < leds_desp->lens) {
if (!strcmp(name, leds_desp->leds[i]->name))
break;
i++;
}
if (i == leds_desp->lens) {
pr_notice("can not find leds by led_desp %s", name);
return NULL;
}
led_dat = container_of(leds_desp->leds[i],
struct mtk_led_data, desp);
return led_dat;
}
static int brightness_maptolevel(struct led_conf_info *led_dat, int brightness)
{
return ((((1 << led_dat->trans_bits) - 1) * brightness
+ ((led_dat->cdev.max_brightness) / 2))
/ (led_dat->cdev.max_brightness));
}
/****************************************************************************
* add API for temperature control
***************************************************************************/
int mt_leds_max_brightness_set(char *name, int percent, bool enable)
{
struct mtk_led_data *led_dat;
int max_l = 0, limit_l = 0, cur_l = 0;
led_dat = getLedData(name);
if (!led_dat)
return -EINVAL;
max_l = (1 << led_dat->conf.trans_bits) - 1;
limit_l = (percent * max_l) / 100;
dev_info(led_dat->conf.cdev.dev,
"Set Led: %s, percent : %d, limit_l : %d, enable: %d",
led_dat->conf.cdev.name, percent, limit_l, enable);
if (enable) {
led_dat->conf.max_level = limit_l;
cur_l = min(led_dat->last_level, limit_l);
} else {
cur_l = led_dat->last_level;
led_dat->conf.max_level = max_l;
}
#ifdef CONFIG_LEDS_BRIGHTNESS_CHANGED
call_notifier(3, &led_dat->conf);
#endif
if (cur_l != 0)
led_level_i2c_set(led_dat, cur_l);
dev_info(led_dat->conf.cdev.dev,
"after: name: %s, cur_l : %d\n",
led_dat->conf.cdev.name, cur_l);
return 0;
}
EXPORT_SYMBOL(mt_leds_max_brightness_set);
int mt_leds_brightness_set(char *name, int level)
{
struct mtk_led_data *led_dat;
led_dat = getLedData(name);
if (!led_dat)
return -EINVAL;
led_level_i2c_set(led_dat, level);
led_dat->last_level = level;
return 0;
}
EXPORT_SYMBOL(mt_leds_brightness_set);
static void led_debug_log(struct mtk_led_data *s_led, int level)
{
unsigned long cur_time_mod = 0;
unsigned long long cur_time_display = 0;
int ret = 0;
int level_h, level_l;
s_led->debug.current_t = sched_clock();
cur_time_display = s_led->debug.current_t;
do_div(cur_time_display, 1000000);
cur_time_mod = do_div(cur_time_display, 1000);
level_h = (level & 0x7F8) >> 3;
level_l = level & 0x7;
ret = snprintf(s_led->debug.buffer + strlen(s_led->debug.buffer),
4095 - strlen(s_led->debug.buffer),
"T:%lld.%ld, B:%d L:%d, L:%0x H:%0x ",
cur_time_display, cur_time_mod,
s_led->last_brightness, level, level_l, level_h);
s_led->debug.count++;
if (ret < 0 || ret >= 4096) {
dev_info(s_led->conf.cdev.dev, "[ERROR] print log error!");
s_led->debug.count = 5;
}
if (level == 0 || s_led->debug.count >= 5 ||
(s_led->debug.current_t - s_led->debug.last_t) > 1000000000) {
dev_info(s_led->conf.cdev.dev, "%s", s_led->debug.buffer);
s_led->debug.count = 0;
s_led->debug.buffer[strlen("[Light] Set directly ") +
strlen(s_led->conf.cdev.name)] = '\0';
}
s_led->debug.last_t = sched_clock();
}
/****************************************************************************
* driver functions
***************************************************************************/
static int led_level_i2c_set(struct mtk_led_data *s_led, int level)
{
int level_l, level_h;
level = min(level, s_led->conf.max_level);
if (s_led->hw_level == level)
return 0;
#ifdef MET_USER_EVENT_SUPPORT
if (enable_met_backlight_tag())
output_met_backlight_tag(level);
#endif
level_h = (level >> 3) & 0xFF;
level_l = level & 0x7;
led_debug_log(s_led, level);
#ifdef CONFIG_MTK_GATE_IC
_gate_ic_backlight_set(level);
#endif
s_led->hw_level = level;
return 0;
}
static int led_level_set(struct led_classdev *led_cdev, enum led_brightness brightness)
{
int trans_level = 0;
struct led_conf_info *led_conf =
container_of(led_cdev, struct led_conf_info, cdev);
struct mtk_led_data *led_data =
container_of(led_conf, struct mtk_led_data, conf);
if (led_data->last_brightness == brightness)
return 0;
trans_level = brightness_maptolevel(led_conf, brightness);
pr_debug("set brightness: %d, %d", brightness, trans_level);
led_data->last_brightness = brightness;
#ifdef CONFIG_LEDS_BRIGHTNESS_CHANGED
call_notifier(1, led_conf);
#endif
#ifndef CONFIG_MTK_AAL_SUPPORT
led_level_i2c_set(led_data, trans_level);
led_data->last_level = trans_level;
#endif
return 0;
}
static int led_data_init(struct device *dev, struct mtk_led_data *s_led,
enum led_brightness brightness)
{
int ret;
int level;
s_led->conf.cdev.flags = LED_CORE_SUSPENDRESUME;
s_led->conf.cdev.brightness_set_blocking = led_level_set;
level = brightness_maptolevel(&s_led->conf, brightness);
ret = devm_led_classdev_register(dev, &(s_led->conf.cdev));
if (ret < 0) {
dev_info(dev, "[ERROR] led class register fail!\n");
return ret;
}
dev_info(dev, "%s devm_led_classdev_register ok, set brightness: %d!\n",
s_led->conf.cdev.name, level);
ret = snprintf(s_led->debug.buffer + strlen(s_led->debug.buffer),
4095 - strlen(s_led->debug.buffer),
"[Light] Set %s directly ", s_led->conf.cdev.name);
if (ret < 0 || ret >= 4096)
dev_info(dev, "[ERROR] print log init error!");
s_led->last_brightness = brightness;
s_led->last_level = level;
led_level_i2c_set(s_led, level);
return 0;
}
static int mtk_leds_parse_dt(struct device *dev, struct mtk_leds_info *m_leds)
{
struct device_node *child;
struct mtk_led_data *s_led;
int ret = 0;
const char *state;
int num = 0;
enum led_brightness brightness;
if (!dev->of_node) {
pr_notice("Error load dts: node not exist!\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->conf.cdev.name);
if (ret) {
dev_info(dev, "[ERROR] Fail to read label property\n");
goto out_led_dt;
}
ret = of_property_read_u32(child, "led-bits", &(s_led->conf.led_bits));
if (ret) {
dev_info(dev, "No led-bits, use default value 8\n");
s_led->conf.led_bits = 8;
}
ret = of_property_read_u32(child, "max-brightness",
&(s_led->conf.cdev.max_brightness));
if (ret) {
dev_info(dev, "No led-bits, use default value 8\n");
s_led->conf.cdev.max_brightness = (1 << s_led->conf.led_bits) - 1;
}
ret = of_property_read_u32(child, "trans-bits", &(s_led->conf.trans_bits));
if (ret) {
dev_info(dev, "No trans-bits, use default value 10\n");
s_led->conf.trans_bits = 10;
}
s_led->conf.max_level = (1 << s_led->conf.trans_bits) - 1;
ret = of_property_read_string(child, "default-state", &state);
if (!ret) {
if (!strcmp(state, "half"))
brightness = LED_HALF;
else if (!strcmp(state, "on"))
brightness = LED_FULL;
else
brightness = LED_OFF;
} else {
brightness = LED_FULL;
}
dev_info(dev, "parse %d leds dt: %s, %d, %d, %d\n",
num, s_led->conf.cdev.name,
s_led->conf.led_bits,
s_led->conf.trans_bits,
s_led->conf.max_level);
s_led->desp.index = num;
strncpy(s_led->desp.name, s_led->conf.cdev.name,
strlen(s_led->conf.cdev.name));
s_led->desp.index = num;
leds_desp->leds[num] = &s_led->desp;
s_led->last_brightness = 0;
ret = led_data_init(dev, s_led, brightness);
if (ret)
goto out_led_dt;
num++;
}
m_leds->nums = num;
dev_info(dev, "%s: load dts ok, num = %d!\n", __func__, num);
return 0;
out_led_dt:
dev_info(dev, "[ERROR] Error load dts node!\n");
return ret;
}
/****************************************************************************
* driver functions
***************************************************************************/
static int leds_i2c_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct mtk_leds_info *leds;
int ret, nums;
dev_info(dev, "begin probe i2c leds\n");
nums = of_get_child_count(dev->of_node);
leds = devm_kzalloc(dev, (sizeof(struct mtk_leds_info) +
(sizeof(struct mtk_led_data) * (nums))),
GFP_KERNEL);
if (!leds)
return -ENOMEM;
leds_desp = devm_kzalloc(dev, (sizeof(struct leds_desp_info) +
sizeof(struct led_desp *) * (nums)),
GFP_KERNEL);
leds_desp->lens = nums;
if (!leds_desp)
return -ENOMEM;
ret = mtk_leds_parse_dt(&(pdev->dev), leds);
if (ret) {
dev_info(dev, "[ERROR] Failed to parse devicetree!\n");
return ret;
}
dev_info(dev, "probe i2c leds end\n");
return ret;
}
static int leds_i2c_remove(struct platform_device *pdev)
{
int i;
struct mtk_leds_info *m_leds = dev_get_platdata(&pdev->dev);
for (i = 0; i < m_leds->nums; i++)
led_classdev_unregister(&m_leds->leds[i].conf.cdev);
kfree(m_leds);
m_leds = NULL;
return 0;
}
static void leds_i2c_shutdown(struct platform_device *pdev)
{
int i;
struct mtk_leds_info *m_leds = dev_get_platdata(&pdev->dev);
pr_info("Turn off backlight\n");
for (i = 0; m_leds && i < m_leds->nums; i++) {
#ifdef CONFIG_LEDS_BRIGHTNESS_CHANGED
call_notifier(2, &(m_leds->leds[i].conf));
#endif
led_level_i2c_set(&m_leds->leds[i], 0);
}
}
static const struct of_device_id of_leds_i2c_match[] = {
{ .compatible = "mediatek,i2c-leds", },
{},
};
MODULE_DEVICE_TABLE(of, of_leds_i2c_match);
static struct platform_driver i2c_leds_driver = {
.driver = {
.name = "mtk-i2c-leds",
.of_match_table = of_leds_i2c_match,
},
.probe = leds_i2c_probe,
.remove = leds_i2c_remove,
.shutdown = leds_i2c_shutdown,
};
static int __init mtk_leds_init(void)
{
int ret;
pr_info("Leds init\n");
ret = platform_driver_register(&i2c_leds_driver);
if (ret) {
pr_info("driver register error: %d\n", ret);
return ret;
}
return ret;
}
static void __exit mtk_leds_exit(void)
{
platform_driver_unregister(&i2c_leds_driver);
}
late_initcall(mtk_leds_init);
module_exit(mtk_leds_exit);
MODULE_AUTHOR("Mediatek Corporation");
MODULE_DESCRIPTION("MTK Display Backlight Driver");
MODULE_LICENSE("GPL");
+32
View File
@@ -0,0 +1,32 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2018 MediaTek Inc.
*
*/
/****************************************************************************
* LED DRV functions
***************************************************************************/
#include <linux/leds.h>
struct led_conf_info {
struct led_classdev cdev;
int led_bits;
int trans_bits;
int max_level;
};
int mt_leds_max_brightness_set(char *name, int percent, bool enable);
int mt_leds_brightness_set(char *name, int level);
int mtk_leds_register_notifier(struct notifier_block *nb);
int mtk_leds_unregister_notifier(struct notifier_block *nb);
extern int _gate_ic_i2c_write_bytes(unsigned char cmd, unsigned char writeData);
extern int _gate_ic_i2c_read_bytes(unsigned char cmd, unsigned char *returnData);
extern void _gate_ic_backlight_power_on(void);
extern void _gate_ic_backlight_set(unsigned int level);
+621
View File
@@ -0,0 +1,621 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2018 MediaTek Inc.
*
*/
#include <linux/ctype.h>
#include <linux/err.h>
#include <linux/kernel.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>
#include "leds-mtk-pwm.h"
#define CONFIG_LEDS_BRIGHTNESS_CHANGED
/****************************************************************************
* variables
***************************************************************************/
#undef pr_fmt
#define pr_fmt(fmt) KBUILD_MODNAME " %s(%d) :" fmt, __func__, __LINE__
struct mtk_leds_info;
static int led_level_set(struct led_classdev *led_cdev,
enum led_brightness brightness);
struct led_debug_info {
unsigned long long current_t;
unsigned long long last_t;
char buffer[4096];
int count;
};
struct led_desp {
int index;
char name[16];
};
struct leds_desp_info {
int lens;
struct led_desp *leds[0];
};
struct led_pwm_info {
struct pwm_device *pwm;
struct led_pwm config;
unsigned long long duty;
};
struct mtk_led_data {
struct led_desp desp;
struct led_conf_info conf;
int last_level;
int brightness;
struct led_pwm_info info;
struct mtk_leds_info *parent;
struct led_debug_info debug;
};
struct mtk_leds_info {
struct device *dev;
int nums;
struct mtk_led_data leds[0];
};
static DEFINE_MUTEX(leds_mutex);
struct leds_desp_info *leds_info;
static BLOCKING_NOTIFIER_HEAD(mtk_leds_chain_head);
int mtk_leds_register_notifier(struct notifier_block *nb)
{
return blocking_notifier_chain_register(&mtk_leds_chain_head, nb);
}
EXPORT_SYMBOL_GPL(mtk_leds_register_notifier);
int mtk_leds_unregister_notifier(struct notifier_block *nb)
{
return blocking_notifier_chain_unregister(&mtk_leds_chain_head, nb);
}
EXPORT_SYMBOL_GPL(mtk_leds_unregister_notifier);
int mtk_leds_call_notifier(unsigned long action, void *data)
{
return blocking_notifier_call_chain(&mtk_leds_chain_head, action, data);
}
EXPORT_SYMBOL_GPL(mtk_leds_call_notifier);
static int call_notifier(int event, struct mtk_led_data *led_dat)
{
int err;
err = mtk_leds_call_notifier(event, &led_dat->conf);
if (err)
pr_info("notifier_call_chain error\n");
return err;
}
/****************************************************************************
* DEBUG MACROS
***************************************************************************/
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;
int ret = 0;
s_led->debug.current_t = sched_clock();
cur_time_display = s_led->debug.current_t;
do_div(cur_time_display, 1000000);
cur_time_mod = do_div(cur_time_display, 1000);
ret = snprintf(s_led->debug.buffer + strlen(s_led->debug.buffer),
4095 - strlen(s_led->debug.buffer),
"T:%lld.%ld,L:%d L:%d map:%d ",
cur_time_display, cur_time_mod,
s_led->conf.cdev.brightness, level, mappingLevel);
s_led->debug.count++;
if (ret < 0 || ret >= 4096) {
pr_info("print log error!");
s_led->debug.count = 5;
}
if (level == 0 || s_led->debug.count >= 5 ||
(s_led->debug.current_t - s_led->debug.last_t) > 1000000000) {
pr_info("%s", s_led->debug.buffer);
s_led->debug.count = 0;
s_led->debug.buffer[strlen("[Light] Set directly ") +
strlen(s_led->conf.cdev.name)] = '\0';
}
s_led->debug.last_t = sched_clock();
}
static int getLedDespIndex(char *name)
{
int i = 0;
while (i < leds_info->lens) {
if (!strcmp(name, leds_info->leds[i]->name))
return i;
i++;
}
return -1;
}
/****************************************************************************
* driver functions
***************************************************************************/
static void __led_pwm_set(struct led_pwm_info *led_info)
{
int new_duty = led_info->duty;
mutex_lock(&leds_mutex);
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);
mutex_unlock(&leds_mutex);
}
static int led_level_pwm_set(struct mtk_led_data *led_dat,
int brightness)
{
unsigned int max;
unsigned long long duty;
brightness = min(brightness, led_dat->conf.max_level);
if (brightness == led_dat->conf.level)
return 0;
led_dat->conf.level = brightness;
max = (1 << led_dat->conf.trans_bits) - 1;
duty = led_dat->info.config.pwm_period_ns;
duty *= brightness;
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;
}
int mt_leds_brightness_set(char *name, int level)
{
struct mtk_led_data *led_dat;
int index;
index = getLedDespIndex(name);
if (index < 0) {
pr_notice("can not find leds by led_desp %s", name);
return -1;
}
led_dat = container_of(leds_info->leds[index],
struct mtk_led_data, desp);
led_level_pwm_set(led_dat, level);
led_dat->conf.level = level;
return 0;
}
EXPORT_SYMBOL(mt_leds_brightness_set);
#ifndef CONFIG_MTK_AAL_SUPPORT
static int led_pwm_disable(struct led_pwm_info *led_info)
{
mutex_lock(&leds_mutex);
pwm_config(led_info->pwm, 0, led_info->config.pwm_period_ns);
pwm_disable(led_info->pwm);
mutex_unlock(&leds_mutex);
return 0;
}
#endif
static int led_level_set(struct led_classdev *led_cdev,
enum led_brightness brightness)
{
int trans_level = 0;
struct led_conf_info *led_conf =
container_of(led_cdev, struct led_conf_info, cdev);
struct mtk_led_data *led_dat =
container_of(led_conf, struct mtk_led_data, conf);
if (led_dat->brightness == brightness)
return 0;
led_dat->brightness = brightness;
trans_level = (
(((1 << led_dat->conf.trans_bits) - 1) * brightness
+ (((1 << led_dat->conf.led_bits) - 1) / 2))
/ ((1 << led_dat->conf.led_bits) - 1));
led_debug_log(led_dat, brightness, trans_level);
#ifdef CONFIG_LEDS_BRIGHTNESS_CHANGED
call_notifier(1, led_dat);
#endif
#ifndef CONFIG_MTK_AAL_SUPPORT
led_level_pwm_set(led_dat, trans_level);
led_dat->last_level = trans_level;
#endif
return 0;
}
/****************************************************************************
* add API for temperature control
***************************************************************************/
int mt_leds_max_brightness_set(char *name, int percent, bool enable)
{
struct mtk_led_data *led_dat;
int max_l = 0, index = -1, limit_l = 0, cur_l = 0;
index = getLedDespIndex(name);
if (index < 0) {
pr_notice("can not find leds by led_desp %s", name);
return -1;
}
led_dat = container_of(leds_info->leds[index],
struct mtk_led_data, desp);
max_l = (1 << led_dat->conf.trans_bits) - 1;
limit_l = (percent * max_l) / 100;
pr_info("before: name: %s, percent : %d, limit_l : %d, enable: %d",
leds_info->leds[index]->name, percent, limit_l, enable);
if (enable) {
led_dat->conf.max_level = limit_l;
cur_l = min(led_dat->last_level, limit_l);
} else if (!enable) {
led_dat->conf.max_level = max_l;
cur_l = led_dat->last_level;
}
#ifdef CONFIG_LEDS_BRIGHTNESS_CHANGED
call_notifier(3, led_dat);
#endif
if (led_dat->conf.cdev.brightness != 0)
led_level_pwm_set(led_dat, cur_l);
pr_info("after: name: %s, cur_l : %d, max_level : %d",
led_dat->conf.cdev.name, cur_l, led_dat->conf.max_level);
return 0;
}
EXPORT_SYMBOL(mt_leds_max_brightness_set);
static int led_data_init(struct device *dev, struct mtk_led_data *s_led)
{
int ret;
s_led->conf.cdev.default_trigger = s_led->info.config.default_trigger;
s_led->conf.cdev.max_brightness = s_led->info.config.max_brightness;
s_led->conf.cdev.flags = LED_CORE_SUSPENDRESUME;
s_led->conf.cdev.brightness_set_blocking = led_level_set;
s_led->brightness = 0;
s_led->conf.level = 0;
s_led->last_level = 0;
ret = devm_led_classdev_register(dev, &(s_led->conf.cdev));
if (ret < 0) {
pr_notice("led class register fail!");
return ret;
}
pr_info("%s devm_led_classdev_register ok! ", s_led->conf.cdev.name);
ret = snprintf(s_led->debug.buffer + strlen(s_led->debug.buffer),
4095 - strlen(s_led->debug.buffer),
"[Light] Set %s directly ", s_led->conf.cdev.name);
if (ret < 0 || ret >= 4096)
pr_info("print log init error!");
return 0;
}
static int led_pwm_config_add(struct device *dev,
struct mtk_led_data *s_led, struct device_node *leds_np)
{
struct pwm_args pargs;
int ret = 0;
if (leds_np != NULL)
s_led->info.pwm = devm_of_pwm_get(dev, leds_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) {
pr_notice("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;
pr_info("set led pwm OK! info.config.pwm_period_ns = %d!",
s_led->info.config.pwm_period_ns);
return ret;
err:
pr_notice("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 *child;
struct mtk_led_data *s_led;
int ret = 0, num = 0, level = 0;
const char *state;
if (!dev->of_node) {
pr_notice("Error load dts: node not exist!\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->conf.cdev.name));
if (ret) {
pr_info("Fail to read label property");
goto out_led_dt;
}
ret = of_property_read_string(child, "pwm-names",
&(s_led->info.config.name));
if (ret) {
pr_info("Fail to read pwm-names property");
goto out_led_dt;
}
ret = of_property_read_string(child, "default-trigger",
&(s_led->info.config.default_trigger));
if (ret) {
pr_info("Fail to read default-trigger property");
s_led->info.config.default_trigger = NULL;
}
ret = of_property_read_u8(child, "active-low",
&(s_led->info.config.active_low));
if (ret)
pr_info("Fail to read active-low property\n");
ret = of_property_read_u32(child,
"led-bits", &(s_led->conf.led_bits));
if (ret) {
pr_info("No led-bits, use default value 8");
s_led->conf.led_bits = 8;
}
ret = of_property_read_u32(child,
"max-brightness", &(s_led->info.config.max_brightness));
if (ret) {
pr_info("No max-brightness, use default value 255");
s_led->info.config.max_brightness =
(1 << s_led->conf.led_bits) - 1;
}
ret = of_property_read_u32(child,
"trans-bits", &(s_led->conf.trans_bits));
if (ret) {
pr_info("No trans-bits, use default value 10");
s_led->conf.trans_bits = 10;
}
s_led->conf.max_level = (1 << s_led->conf.trans_bits) - 1;
ret = of_property_read_string(child, "default-state", &state);
if (!ret) {
if (!strcmp(state, "half"))
level = s_led->info.config.max_brightness / 2;
else if (!strcmp(state, "on"))
level = s_led->info.config.max_brightness;
else
level = s_led->conf.level = 0;
} else {
level = s_led->info.config.max_brightness;
}
pr_info("parse %s(%d) leds dt: %s, %s, %d, %d, %d\n",
s_led->conf.cdev.name, 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->conf.led_bits);
s_led->desp.index = num;
strncpy(s_led->desp.name, s_led->conf.cdev.name,
strlen(s_led->conf.cdev.name));
s_led->desp.index = num;
leds_info->leds[num] = &s_led->desp;
s_led->conf.cdev.brightness = level;
ret = led_data_init(dev, s_led);
if (ret)
goto out_led_dt;
led_pwm_config_add(dev, s_led, child);
led_level_set(&s_led->conf.cdev, level);
num++;
}
m_leds->nums = num;
pr_info("load dts ok!");
return ret;
out_led_dt:
pr_notice("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;
pr_info("probe begain +++");
nums = of_get_child_count(dev->of_node);
pr_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_info = devm_kzalloc(dev, (sizeof(struct leds_desp_info) +
sizeof(struct led_desp *) * (nums)),
GFP_KERNEL);
leds_info->lens = nums;
if (!leds_info) {
ret = -ENOMEM;
goto err;
}
platform_set_drvdata(pdev, m_leds);
m_leds->dev = dev;
ret = mtk_leds_parse_dt(&(pdev->dev), m_leds);
if (ret) {
pr_notice("Failed to parse devicetree!\n");
goto err;
}
pr_info("probe end ---");
return 0;
err:
pr_notice("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].conf.cdev);
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);
pr_info("Turn off backlight\n");
for (i = 0; m_leds && i < m_leds->nums; i++) {
if (!&(m_leds->leds[i]))
continue;
#ifdef CONFIG_LEDS_BRIGHTNESS_CHANGED
call_notifier(2, &(m_leds->leds[i]));
#ifdef CONFIG_MTK_AAL_SUPPORT
continue;
#else
led_pwm_disable(&(m_leds->leds[i].info));
#endif
#else
led_pwm_disable(&(m_leds->leds[i].info));
#endif
}
}
static const struct of_device_id of_mtk_pwm_leds_match[] = {
{ .compatible = "mediatek,disp-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;
pr_info("Leds init\n");
ret = platform_driver_register(&mtk_pwm_leds_driver);
if (ret) {
pr_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");
+25
View File
@@ -0,0 +1,25 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2018 MediaTek Inc.
*
*/
/****************************************************************************
* LED DRV functions
***************************************************************************/
#include <linux/leds.h>
extern struct led_conf_info {
int level;
int led_bits;
int trans_bits;
int max_level;
struct led_classdev cdev;
} led_conf_info;
int mtk_leds_register_notifier(struct notifier_block *nb);
int mtk_leds_unregister_notifier(struct notifier_block *nb);
int mt_leds_brightness_set(char *name, int bl_1024);
int mt_leds_max_brightness_set(char *name, int percent, bool enable);
@@ -0,0 +1,18 @@
#
# Copyright (C) 2015 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
obj-$(CONFIG_MTK_LEDS) := mtk_leds.o
obj-$(CONFIG_BACKLIGHT_SUPPORT_LM3697) += mtk_lm3697_driver.o
ccflags-y += -I$(srctree)/drivers/misc/mediatek/video/include
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,54 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _LEDS_HAL_H
#define _LEDS_HAL_H
#include "mtk_leds_sw.h"
/****************************************************************************
* LED HAL functions
***************************************************************************/
extern void mt_leds_wake_lock_init(void);
extern unsigned int mt_get_bl_brightness(void);
extern unsigned int mt_get_bl_duty(void);
extern unsigned int mt_get_bl_div(void);
extern unsigned int mt_get_bl_frequency(void);
extern unsigned int *mt_get_div_array(void);
extern void mt_set_bl_duty(unsigned int level);
extern void mt_set_bl_div(unsigned int div);
extern void mt_set_bl_frequency(unsigned int freq);
extern void mt_led_pwm_disable(int pwm_num);
extern int mt_brightness_set_pmic_duty_store(u32 level, u32 div);
extern void mt_backlight_set_pwm_duty(int pwm_num, u32 level, u32 div,
struct PWM_config *config_data);
extern void mt_backlight_set_pwm_div(int pwm_num, u32 level, u32 div,
struct PWM_config *config_data);
extern void mt_backlight_get_pwm_fsel(unsigned int bl_div,
unsigned int *bl_frequency);
extern void mt_store_pwm_register(unsigned int addr, unsigned int value);
extern unsigned int mt_show_pwm_register(unsigned int addr);
extern int mt_led_set_pwm(int pwm_num, struct nled_setting *led);
extern int mt_led_blink_pmic(enum mt65xx_led_pmic pmic_type,
struct nled_setting *led);
extern int mt_backlight_set_pwm(int pwm_num, u32 level, u32 div,
struct PWM_config *config_data);
extern int mt_brightness_set_pmic(enum mt65xx_led_pmic pmic_type, u32 level,
u32 div);
extern int mt_mt65xx_led_set_cust(struct cust_mt65xx_led *cust, int level);
extern void mt_mt65xx_led_work(struct work_struct *work);
extern void mt_mt65xx_led_set(struct led_classdev *led_cdev,
enum led_brightness level);
extern int mt_mt65xx_blink_set(struct led_classdev *led_cdev,
unsigned long *delay_on,
unsigned long *delay_off);
extern struct cust_mt65xx_led *mt_get_cust_led_list(void);
#if defined(CONFIG_BACKLIGHT_SUPPORT_LM3697)
extern int chargepump_set_backlight_level(unsigned int level);
#endif /* CONFIG_BACKLIGHT_SUPPORT_LM3697 */
#endif
@@ -0,0 +1,188 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _LEDS_SW_H
#define _LEDS_SW_H
/******************************************************************************
* LED & Backlight type defination
*****************************************************************************/
enum mt65xx_led_type {
MT65XX_LED_TYPE_RED = 0,
MT65XX_LED_TYPE_GREEN,
MT65XX_LED_TYPE_BLUE,
MT65XX_LED_TYPE_JOGBALL,
MT65XX_LED_TYPE_KEYBOARD,
MT65XX_LED_TYPE_BUTTON,
MT65XX_LED_TYPE_LCD,
MT65XX_LED_TYPE_TOTAL,
};
enum mt65xx_led_mode {
MT65XX_LED_MODE_NONE,
MT65XX_LED_MODE_PWM,
MT65XX_LED_MODE_GPIO,
MT65XX_LED_MODE_PMIC,
MT65XX_LED_MODE_CUST_LCM,
MT65XX_LED_MODE_CUST_BLS_PWM
};
/******************************************************************************
* for backlight
*****************************************************************************/
/* backlight call back function */
typedef int (*cust_brightness_set) (int level, int div);
typedef int (*cust_set_brightness) (int level);
/* 10bit backlight level */
#define LED_INCREASE_LED_LEVEL_MTKPATCH
#ifdef LED_INCREASE_LED_LEVEL_MTKPATCH
#define MT_LED_INTERNAL_LEVEL_BIT_CNT 10
#endif
/******************************************************************************
* for PMIC
*****************************************************************************/
enum mt65xx_led_pmic {
MT65XX_LED_PMIC_LCD_ISINK = 0,
MT65XX_LED_PMIC_NLED_ISINK_MIN = MT65XX_LED_PMIC_LCD_ISINK,
MT65XX_LED_PMIC_NLED_ISINK0,
MT65XX_LED_PMIC_NLED_ISINK1,
MT65XX_LED_PMIC_NLED_ISINK_MAX,
};
enum MT65XX_PMIC_ISINK_MODE {
ISINK_PWM_MODE = 0,
ISINK_BREATH_MODE = 1,
ISINK_REGISTER_MODE = 2
};
enum MT65XX_PMIC_ISINK_STEP {
ISINK_0 = 0, /* 4mA */
ISINK_1 = 1, /* 8mA */
ISINK_2 = 2, /* 12mA */
ISINK_3 = 3, /* 16mA */
ISINK_4 = 4, /* 20mA */
ISINK_5 = 5 /* 24mA */
};
enum MT65XX_PMIC_ISINK_FSEL {
/* 32K clock */
ISINK_1KHZ = 0,
ISINK_200HZ = 4,
ISINK_5HZ = 199,
ISINK_2HZ = 499,
ISINK_1HZ = 999,
ISINK_05HZ = 1999,
ISINK_02HZ = 4999,
ISINK_01HZ = 9999,
/* 2M clock */
ISINK_2M_20KHZ = 2,
ISINK_2M_1KHZ = 61,
ISINK_2M_200HZ = 311,
ISINK_2M_5HZ = 12499,
ISINK_2M_2HZ = 31249,
ISINK_2M_1HZ = 62499,
/* 128K clock */
ISINK_128K_500HZ = 0,
ISINK_128K_256HZ = 1,
ISINK_128K_167HZ = 2,
ISINK_128K_128HZ = 3,
ISINK_128K_100HZ = 4,
ISINK_128K_83HZ = 5,
ISINK_128K_50HZ = 9,
ISINK_128K_17HZ = 28,
};
/******************************************************************************
* for PWM
*****************************************************************************/
#define MIN_FRE_OLD_PWM 32 /* the min frequence when use old mode pwm by kHz */
#define BACKLIGHT_LEVEL_PWM_64_FIFO_MODE_SUPPORT 64
#define BACKLIGHT_LEVEL_PWM_256_SUPPORT 256
#define BACKLIGHT_LEVEL_PWM_MODE_CONFIG BACKLIGHT_LEVEL_PWM_256_SUPPORT
static inline unsigned int Cust_GetBacklightLevelSupport_byPWM(void)
{
return BACKLIGHT_LEVEL_PWM_MODE_CONFIG;
}
static inline unsigned int brightness_mapping(unsigned int level)
{
unsigned int mapped_level;
mapped_level = level;
return mapped_level;
}
struct PWM_config {
int clock_source;
int div;
int low_duration;
int High_duration;
bool pmic_pad;
};
/****************************************************************************
* sw data structures
***************************************************************************/
/**
* led customization data structure
* name : must the same as lights HAL
* mode : control mode
* data :
* PWM: pwm number
* GPIO: gpio id
* PMIC: enum mt65xx_led_pmic
* CUST: custom set brightness function pointer
* config_data: pwm config data
*/
struct cust_mt65xx_led {
char *name;
enum mt65xx_led_mode mode;
long data;
struct PWM_config config_data;
};
/**
* led device node structure with mtk extentions
* cdev: common led device structure
* cust: customization data from device tree
* work: workqueue for specialfied led device
* level: brightness level
* delay_on: on time if led is blinking
* delay_off: off time if led is blinking
*/
struct mt65xx_led_data {
struct led_classdev cdev;
struct cust_mt65xx_led cust;
struct work_struct work;
int level;
int delay_on;
int delay_off;
};
/**
* LED Variable Settings
* nled_mode: 0, off; 1, on; 2, blink
* blink_on_time: on time if led is blinking
* blink_off_time: off time if led is blinking
*/
#define NLED_OFF 0
#define NLED_ON 1
#define NLED_BLINK 2
struct nled_setting {
u8 nled_mode;
u32 blink_on_time;
u32 blink_off_time;
};
#endif /* _LEDS_SW_H */
@@ -0,0 +1,5 @@
# SPDX-License-Identifier: GPL-2.0
obj-$(CONFIG_MTK_LEDS) := mtk_leds.o
ccflags-y += -I$(srctree)/drivers/misc/mediatek/video/include
@@ -0,0 +1,809 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2018 MediaTek Inc.
*
*/
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/delay.h>
#include <linux/string.h>
#include <linux/ctype.h>
#include <linux/leds.h>
#include <linux/of.h>
/* #include <linux/leds-mt65xx.h> */
#include <linux/workqueue.h>
#include <linux/pm_wakeup.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <mtk_leds_sw.h>
#ifdef CONFIG_MTK_AAL_SUPPORT
#include <ddp_aal.h>
/* #include <linux/aee.h> */
#endif
#include <ddp_gamma.h>
#ifdef CONFIG_MTK_PWM
#include <mt-plat/mtk_pwm.h>
static unsigned int backlight_PWM_div_hal = CLK_DIV1;
#else
#define CLK_DIV1 1
#endif
#ifdef CONFIG_MTK_PMIC_NEW_ARCH
#include <mt-plat/upmu_common.h>
#endif
#include "mtk_leds_sw.h"
#include "mtk_leds_hal.h"
#include "ddp_pwm.h"
#include "mtkfb.h"
//#define MET_USER_EVENT_SUPPORT
#ifdef MET_USER_EVENT_SUPPORT
#include <mt-plat/met_drv.h>
#endif
#undef pr_fmt
#define pr_fmt(fmt) KBUILD_MODNAME " %s(%d) :" fmt, __func__, __LINE__
static DEFINE_MUTEX(leds_mutex);
static DEFINE_MUTEX(leds_pmic_mutex);
/****************************************************************************
* variables
***************************************************************************/
/* struct cust_mt65xx_led* bl_setting_hal = NULL; */
static unsigned int bl_brightness_hal = 102;
static unsigned int bl_duty_hal = 21;
static unsigned int bl_div_hal = CLK_DIV1;
static unsigned int bl_frequency_hal = 32000;
/* for button led don't do ISINK disable first time */
static int button_flag_isink1;
struct wakeup_source leds_suspend_lock;
char *leds_name[MT65XX_LED_TYPE_TOTAL] = {
"red",
"green",
"blue",
"jogball-backlight",
"keyboard-backlight",
"button-backlight",
"lcd-backlight",
};
struct cust_mt65xx_led *pled_dtsi;
/*****************PWM *************************************************/
#define PWM_DIV_NUM 8
static unsigned int div_array_hal[PWM_DIV_NUM] = {
1, 2, 4, 8, 16, 32, 64, 128 };
/****************************************************************************
* func:return global variables
***************************************************************************/
static unsigned long long current_t, last_time;
static int count;
static char buffer[4096] = "[BL] Set Backlight directly ";
static void backlight_debug_log(int level, int mappingLevel)
{
unsigned long cur_time_mod = 0;
unsigned long long cur_time_display = 0;
int ret = 0;
current_t = sched_clock();
cur_time_display = current_t;
do_div(cur_time_display, 1000000);
cur_time_mod = do_div(cur_time_display, 1000);
ret = snprintf(buffer + strlen(buffer),
4095 - strlen(buffer),
"T:%lld.%ld,L:%d map:%d ",
cur_time_display, cur_time_mod, level, mappingLevel);
count++;
if (ret < 0 || ret >= 4096) {
pr_info("print log error!");
count = 5;
}
if (level == 0 || count >= 5 ||
(current_t - last_time) > 1000000000) {
pr_info("%s", buffer);
count = 0;
buffer[strlen("[BL] Set Backlight directly ")] = '\0';
}
last_time = sched_clock();
}
void mt_leds_wake_lock_init(void)
{
// wakeup_source_init(&leds_suspend_lock, "leds wakelock");
}
unsigned int mt_get_bl_brightness(void)
{
return bl_brightness_hal;
}
unsigned int mt_get_bl_duty(void)
{
return bl_duty_hal;
}
unsigned int mt_get_bl_div(void)
{
return bl_div_hal;
}
unsigned int mt_get_bl_frequency(void)
{
return bl_frequency_hal;
}
unsigned int *mt_get_div_array(void)
{
return &div_array_hal[0];
}
void mt_set_bl_duty(unsigned int level)
{
bl_duty_hal = level;
}
void mt_set_bl_div(unsigned int div)
{
bl_div_hal = div;
}
void mt_set_bl_frequency(unsigned int freq)
{
bl_frequency_hal = freq;
}
struct cust_mt65xx_led *get_cust_led_dtsi(void)
{
struct device_node *led_node = NULL;
bool isSupportDTS = false;
int i, ret;
int mode, data;
int pwm_config[5] = { 0 };
if (pled_dtsi)
goto out;
/* this can allocat an new struct array */
pled_dtsi = kmalloc_array(MT65XX_LED_TYPE_TOTAL,
sizeof(struct cust_mt65xx_led), GFP_KERNEL);
if (pled_dtsi == NULL)
goto out;
for (i = 0; i < MT65XX_LED_TYPE_TOTAL; i++) {
char node_name[32] = "mediatek,";
if (strlen(node_name) + strlen(leds_name[i]) + 1 >
sizeof(node_name)) {
pr_info("buffer for %s%s not enough\n",
node_name, leds_name[i]);
pled_dtsi[i].mode = 0;
pled_dtsi[i].data = -1;
continue;
}
pled_dtsi[i].name = leds_name[i];
led_node = of_find_compatible_node(NULL, NULL,
strncat(node_name, leds_name[i],
sizeof(node_name) - strlen(node_name) - 1));
if (!led_node) {
pr_debug("Cannot find LED node from dts\n");
pled_dtsi[i].mode = 0;
pled_dtsi[i].data = -1;
} else {
isSupportDTS = true;
ret =
of_property_read_u32(led_node, "led_mode",
&mode);
if (!ret) {
pled_dtsi[i].mode = mode;
pr_info
("The %s's led mode is : %d\n",
pled_dtsi[i].name,
pled_dtsi[i].mode);
} else {
pr_info
("led dts can not get led mode");
pled_dtsi[i].mode = 0;
}
ret =
of_property_read_u32(led_node, "data",
&data);
if (!ret) {
pled_dtsi[i].data = data;
pr_info
("The %s's led data is : %ld\n",
pled_dtsi[i].name,
pled_dtsi[i].data);
} else {
pr_info
("led dts can not get led data");
pled_dtsi[i].data = -1;
}
ret =
of_property_read_u32_array(led_node,
"pwm_config",
pwm_config,
ARRAY_SIZE
(pwm_config));
if (!ret) {
pr_debug("%s's pwm cfg %d %d %d %d %d\n",
pled_dtsi[i].name, pwm_config[0],
pwm_config[1], pwm_config[2],
pwm_config[3], pwm_config[4]);
pled_dtsi[i].config_data.clock_source =
pwm_config[0];
pled_dtsi[i].config_data.div =
pwm_config[1];
pled_dtsi[i].config_data.low_duration =
pwm_config[2];
pled_dtsi[i].config_data.High_duration =
pwm_config[3];
pled_dtsi[i].config_data.pmic_pad =
pwm_config[4];
} else
pr_info
("led dts can't get pwm config\n");
switch (pled_dtsi[i].mode) {
case MT65XX_LED_MODE_CUST_LCM:
#if defined(CONFIG_BACKLIGHT_SUPPORT_LM3697)
pled_dtsi[i].data =
(long)chargepump_set_backlight_level;
pr_info
("BL set by chargepump\n");
#else
pled_dtsi[i].data =
(long)mtkfb_set_backlight_level;
#endif /* CONFIG_BACKLIGHT_SUPPORT_LM3697 */
pr_info
("kernel:the BL hw mode is LCM.\n");
break;
case MT65XX_LED_MODE_CUST_BLS_PWM:
pled_dtsi[i].data =
(long)disp_bls_set_backlight;
pr_info
("kernel:the BL hw mode is BLS.\n");
break;
default:
break;
}
}
}
if (!isSupportDTS) {
kfree(pled_dtsi);
pled_dtsi = NULL;
}
out:
return pled_dtsi;
}
struct cust_mt65xx_led *mt_get_cust_led_list(void)
{
struct cust_mt65xx_led *cust_led_list = get_cust_led_dtsi();
return cust_led_list;
}
/****************************************************************************
* internal functions
***************************************************************************/
static int brightness_mapto64(int level)
{
if (level < 30)
return (level >> 1) + 7;
else if (level <= 120)
return (level >> 2) + 14;
else if (level <= 160)
return level / 5 + 20;
else
return (level >> 3) + 33;
}
#ifdef CONFIG_MTK_PWM
static int time_array_hal[PWM_DIV_NUM] = {
256, 512, 1024, 2048, 4096, 8192, 16384, 32768 };
static int find_time_index(int time)
{
int index = 0;
while (index < 8) {
if (time < time_array_hal[index])
return index;
index++;
}
return PWM_DIV_NUM - 1;
}
#endif
int mt_led_set_pwm(int pwm_num, struct nled_setting *led)
{
#ifdef CONFIG_MTK_PWM
struct pwm_spec_config pwm_setting;
int time_index = 0;
memset(&pwm_setting, 0, sizeof(struct pwm_spec_config));
pwm_setting.pwm_no = pwm_num;
pwm_setting.mode = PWM_MODE_OLD;
pr_debug("led_set_pwm: mode=%d,pwm_no=%d\n", led->nled_mode,
pwm_num);
/* We won't choose 32K to be the clock src of old mode because of
* system performance. The setting here will be clock src = 26MHz,
* CLKSEL = 26M/1625 (i.e. 16K)
*/
pwm_setting.clk_src = PWM_CLK_OLD_MODE_32K;
pwm_setting.pmic_pad = 0;
switch (led->nled_mode) {
/* Actually, the setting still can not to turn off NLED. We should
* disable PWM to turn off NLED.
*/
case NLED_OFF:
pwm_setting.PWM_MODE_OLD_REGS.THRESH = 0;
pwm_setting.clk_div = CLK_DIV1;
pwm_setting.PWM_MODE_OLD_REGS.DATA_WIDTH = 100 / 2;
break;
case NLED_ON:
pwm_setting.PWM_MODE_OLD_REGS.THRESH = 30 / 2;
pwm_setting.clk_div = CLK_DIV1;
pwm_setting.PWM_MODE_OLD_REGS.DATA_WIDTH = 100 / 2;
break;
case NLED_BLINK:
pr_debug("LED blink on time = %d offtime = %d\n",
led->blink_on_time, led->blink_off_time);
time_index =
find_time_index(led->blink_on_time + led->blink_off_time);
pr_debug("LED div is %d\n", time_index);
pwm_setting.clk_div = time_index;
pwm_setting.PWM_MODE_OLD_REGS.DATA_WIDTH =
(led->blink_on_time +
led->blink_off_time) * MIN_FRE_OLD_PWM /
div_array_hal[time_index];
pwm_setting.PWM_MODE_OLD_REGS.THRESH =
(led->blink_on_time * 100) / (led->blink_on_time +
led->blink_off_time);
break;
default:
pr_debug("Invalid nled mode\n");
return -1;
}
pwm_setting.PWM_MODE_FIFO_REGS.IDLE_VALUE = 0;
pwm_setting.PWM_MODE_FIFO_REGS.GUARD_VALUE = 0;
pwm_setting.PWM_MODE_FIFO_REGS.GDURATION = 0;
pwm_setting.PWM_MODE_FIFO_REGS.WAVE_NUM = 0;
pwm_set_spec_config(&pwm_setting);
#endif
return 0;
}
int mt_backlight_set_pwm(int pwm_num, u32 level, u32 div,
struct PWM_config *config_data)
{
#ifdef CONFIG_MTK_PWM
struct pwm_spec_config pwm_setting;
unsigned int BacklightLevelSupport =
Cust_GetBacklightLevelSupport_byPWM();
pwm_setting.pwm_no = pwm_num;
if (BacklightLevelSupport == BACKLIGHT_LEVEL_PWM_256_SUPPORT)
pwm_setting.mode = PWM_MODE_OLD;
else
pwm_setting.mode = PWM_MODE_FIFO;
pwm_setting.pmic_pad = config_data->pmic_pad;
if (config_data->div) {
pwm_setting.clk_div = config_data->div;
backlight_PWM_div_hal = config_data->div;
} else
pwm_setting.clk_div = div;
if (BacklightLevelSupport == BACKLIGHT_LEVEL_PWM_256_SUPPORT) {
/* PWM_CLK_OLD_MODE_32K is block/1625 = 26M/1625 = 16KHz @ MT6571 */
if (config_data->clock_source)
pwm_setting.clk_src = PWM_CLK_OLD_MODE_BLOCK;
else
pwm_setting.clk_src = PWM_CLK_OLD_MODE_32K;
pwm_setting.PWM_MODE_OLD_REGS.IDLE_VALUE = 0;
pwm_setting.PWM_MODE_OLD_REGS.GUARD_VALUE = 0;
pwm_setting.PWM_MODE_OLD_REGS.GDURATION = 0;
pwm_setting.PWM_MODE_OLD_REGS.WAVE_NUM = 0;
/* 256 level */
pwm_setting.PWM_MODE_OLD_REGS.DATA_WIDTH = 255;
pwm_setting.PWM_MODE_OLD_REGS.THRESH = level;
pr_debug("[LEDS][%d]backlight_set_pwm:duty is %d/%d\n",
BacklightLevelSupport, level,
pwm_setting.PWM_MODE_OLD_REGS.DATA_WIDTH);
pr_debug("[LEDS][%d]backlight_set_pwm:clk_src/div is %d%d\n",
BacklightLevelSupport, pwm_setting.clk_src,
pwm_setting.clk_div);
if (level > 0 && level < 256) {
pwm_set_spec_config(&pwm_setting);
pr_debug
("[LEDS][%d]old mode: thres/data_width is %d/%d\n",
BacklightLevelSupport,
pwm_setting.PWM_MODE_OLD_REGS.THRESH,
pwm_setting.PWM_MODE_OLD_REGS.DATA_WIDTH);
} else {
pr_debug("[LEDS][%d]Error level in backlight\n",
BacklightLevelSupport);
mt_pwm_disable(pwm_setting.pwm_no,
config_data->pmic_pad);
}
return 0;
} else {
if (config_data->clock_source) {
pwm_setting.clk_src = PWM_CLK_NEW_MODE_BLOCK;
} else {
pwm_setting.clk_src =
PWM_CLK_NEW_MODE_BLOCK_DIV_BY_1625;
}
if (config_data->High_duration && config_data->low_duration) {
pwm_setting.PWM_MODE_FIFO_REGS.HDURATION =
config_data->High_duration;
pwm_setting.PWM_MODE_FIFO_REGS.LDURATION =
pwm_setting.PWM_MODE_FIFO_REGS.HDURATION;
} else {
pwm_setting.PWM_MODE_FIFO_REGS.HDURATION = 4;
pwm_setting.PWM_MODE_FIFO_REGS.LDURATION = 4;
}
pwm_setting.PWM_MODE_FIFO_REGS.IDLE_VALUE = 0;
pwm_setting.PWM_MODE_FIFO_REGS.GUARD_VALUE = 0;
pwm_setting.PWM_MODE_FIFO_REGS.STOP_BITPOS_VALUE = 31;
pwm_setting.PWM_MODE_FIFO_REGS.GDURATION =
(pwm_setting.PWM_MODE_FIFO_REGS.HDURATION + 1) * 32 - 1;
pwm_setting.PWM_MODE_FIFO_REGS.WAVE_NUM = 0;
pr_debug("%s :duty is %d\n", __func__, level);
pr_debug
("[LEDS]clk_src/div/high/low is %d%d%d%d\n",
pwm_setting.clk_src, pwm_setting.clk_div,
pwm_setting.PWM_MODE_FIFO_REGS.HDURATION,
pwm_setting.PWM_MODE_FIFO_REGS.LDURATION);
if (level > 0 && level <= 32) {
pwm_setting.PWM_MODE_FIFO_REGS.GUARD_VALUE = 0;
pwm_setting.PWM_MODE_FIFO_REGS.SEND_DATA0 =
(1 << level) - 1;
pwm_set_spec_config(&pwm_setting);
} else if (level > 32 && level <= 64) {
pwm_setting.PWM_MODE_FIFO_REGS.GUARD_VALUE = 1;
level -= 32;
pwm_setting.PWM_MODE_FIFO_REGS.SEND_DATA0 =
(1 << level) - 1;
pwm_set_spec_config(&pwm_setting);
} else {
pr_debug("[LEDS]Error level in backlight\n");
mt_pwm_disable(pwm_setting.pwm_no,
config_data->pmic_pad);
}
return 0;
}
#endif
return 0;
}
void mt_led_pwm_disable(int pwm_num)
{
#ifdef CONFIG_MTK_PWM
struct cust_mt65xx_led *cust_led_list = get_cust_led_dtsi();
mt_pwm_disable(pwm_num, cust_led_list->config_data.pmic_pad);
#endif
}
void mt_backlight_set_pwm_duty(int pwm_num, u32 level, u32 div,
struct PWM_config *config_data)
{
mt_backlight_set_pwm(pwm_num, level, div, config_data);
}
void mt_backlight_set_pwm_div(int pwm_num, u32 level, u32 div,
struct PWM_config *config_data)
{
mt_backlight_set_pwm(pwm_num, level, div, config_data);
}
void mt_backlight_get_pwm_fsel(unsigned int bl_div,
unsigned int *bl_frequency)
{
}
void mt_store_pwm_register(unsigned int addr, unsigned int value)
{
}
unsigned int mt_show_pwm_register(unsigned int addr)
{
return 0;
}
int mt_brightness_set_pmic(enum mt65xx_led_pmic pmic_type,
u32 level, u32 div)
{
pr_info("not support set brightness by pmic: PMIC#%d:%d\n", pmic_type, level);
return -1;
}
int mt_led_blink_pmic(enum mt65xx_led_pmic pmic_type, struct nled_setting *led)
{
pr_info("not support set blink by pmic: pmic_type=%d\n", pmic_type);
return -1;
}
int mt_brightness_set_pmic_duty_store(u32 level, u32 div)
{
return -1;
}
int mt_mt65xx_led_set_cust(struct cust_mt65xx_led *cust, int level)
{
struct nled_setting led_tmp_setting = { 0, 0, 0 };
int tmp_level = level;
static bool button_flag;
unsigned int BacklightLevelSupport =
Cust_GetBacklightLevelSupport_byPWM();
switch (cust->mode) {
case MT65XX_LED_MODE_PWM:
if (strcmp(cust->name, "lcd-backlight") == 0) {
bl_brightness_hal = level;
if (level == 0) {
#ifdef CONFIG_MTK_PWM
mt_pwm_disable(cust->data,
cust->config_data.pmic_pad);
#endif
} else {
if (BacklightLevelSupport ==
BACKLIGHT_LEVEL_PWM_256_SUPPORT)
level = brightness_mapping(tmp_level);
else
level = brightness_mapto64(tmp_level);
mt_backlight_set_pwm(cust->data, level,
bl_div_hal,
&cust->config_data);
}
bl_duty_hal = level;
} else {
if (level == 0) {
led_tmp_setting.nled_mode = NLED_OFF;
mt_led_set_pwm(cust->data, &led_tmp_setting);
#ifdef CONFIG_MTK_PWM
mt_pwm_disable(cust->data,
cust->config_data.pmic_pad);
#endif
} else {
led_tmp_setting.nled_mode = NLED_ON;
mt_led_set_pwm(cust->data, &led_tmp_setting);
}
}
return 1;
case MT65XX_LED_MODE_GPIO:
pr_debug("brightness_set_cust:go GPIO mode!!!!!\n");
return ((cust_set_brightness) (cust->data)) (level);
case MT65XX_LED_MODE_PMIC:
/* for button baclight used SINK channel, when set button ISINK,
* don't do disable other ISINK channel
*/
if ((strcmp(cust->name, "button-backlight") == 0)) {
if (button_flag == false) {
switch (cust->data) {
case MT65XX_LED_PMIC_NLED_ISINK1:
button_flag_isink1 = 1;
break;
default:
break;
}
button_flag = true;
}
}
return mt_brightness_set_pmic(cust->data, level, bl_div_hal);
case MT65XX_LED_MODE_CUST_LCM:
if (strcmp(cust->name, "lcd-backlight") == 0)
bl_brightness_hal = level;
pr_debug("brightness_set_cust:backlight control by LCM\n");
/* warning for this API revork */
return ((cust_brightness_set) (cust->data)) (level, bl_div_hal);
case MT65XX_LED_MODE_CUST_BLS_PWM:
if (strcmp(cust->name, "lcd-backlight") == 0)
bl_brightness_hal = level;
#ifdef MET_USER_EVENT_SUPPORT
if (enable_met_backlight_tag())
output_met_backlight_tag(level);
#endif
return ((cust_set_brightness) (cust->data)) (level);
case MT65XX_LED_MODE_NONE:
default:
break;
}
return -1;
}
void mt_mt65xx_led_work(struct work_struct *work)
{
struct mt65xx_led_data *led_data =
container_of(work, struct mt65xx_led_data, work);
pr_debug("%s:%d\n", led_data->cust.name, led_data->level);
mutex_lock(&leds_mutex);
mt_mt65xx_led_set_cust(&led_data->cust, led_data->level);
mutex_unlock(&leds_mutex);
}
void mt_mt65xx_led_set(struct led_classdev *led_cdev, enum led_brightness level)
{
struct mt65xx_led_data *led_data =
container_of(led_cdev, struct mt65xx_led_data, cdev);
/* unsigned long flags; */
/* spin_lock_irqsave(&leds_lock, flags); */
#ifdef CONFIG_MTK_AAL_SUPPORT
if (led_data->level != level) {
led_data->level = level;
if (strcmp(led_data->cust.name, "lcd-backlight") != 0) {
pr_debug("Set NLED directly %d at time %lu\n",
led_data->level, jiffies);
schedule_work(&led_data->work);
} else {
if (level != 0
&& level * CONFIG_LIGHTNESS_MAPPING_VALUE < 255) {
level = 1;
} else {
level =
(level * CONFIG_LIGHTNESS_MAPPING_VALUE) /
255;
}
backlight_debug_log(led_data->level, level);
disp_pq_notify_backlight_changed((((1 <<
MT_LED_INTERNAL_LEVEL_BIT_CNT)
- 1) * level +
127) / 255);
disp_aal_notify_backlight_changed((((1 <<
MT_LED_INTERNAL_LEVEL_BIT_CNT)
- 1) * level +
127) / 255);
}
}
#else
/* do something only when level is changed */
if (led_data->level != level) {
led_data->level = level;
if (strcmp(led_data->cust.name, "lcd-backlight") != 0) {
pr_debug("Set NLED directly %d at time %lu\n",
led_data->level, jiffies);
schedule_work(&led_data->work);
} else {
if (level != 0
&& level * CONFIG_LIGHTNESS_MAPPING_VALUE < 255) {
level = 1;
} else {
level =
(level * CONFIG_LIGHTNESS_MAPPING_VALUE) /
255;
}
backlight_debug_log(led_data->level, level);
disp_pq_notify_backlight_changed((((1 <<
MT_LED_INTERNAL_LEVEL_BIT_CNT)
- 1) * level +
127) / 255);
if (led_data->cust.mode == MT65XX_LED_MODE_CUST_BLS_PWM)
mt_mt65xx_led_set_cust(&led_data->cust,
((((1 << MT_LED_INTERNAL_LEVEL_BIT_CNT)
- 1) * level + 127) / 255));
else
mt_mt65xx_led_set_cust(&led_data->cust, level);
}
}
/* spin_unlock_irqrestore(&leds_lock, flags); */
#endif
/* if(0!=aee_kernel_Powerkey_is_press()) */
/* aee_kernel_wdt_kick_Powkey_api("mt_mt65xx_led_set",WDT_SETBY_Backlight); */
}
int mt_mt65xx_blink_set(struct led_classdev *led_cdev,
unsigned long *delay_on, unsigned long *delay_off)
{
struct mt65xx_led_data *led_data =
container_of(led_cdev, struct mt65xx_led_data, cdev);
static int got_wake_lock;
struct nled_setting nled_tmp_setting = { 0, 0, 0 };
/* only allow software blink when delay_on or delay_off changed */
if (*delay_on != led_data->delay_on
|| *delay_off != led_data->delay_off) {
led_data->delay_on = *delay_on;
led_data->delay_off = *delay_off;
if (led_data->delay_on && led_data->delay_off) {
led_data->level = 255;
/* AP PWM all support OLD mode */
if (led_data->cust.mode == MT65XX_LED_MODE_PWM) {
nled_tmp_setting.nled_mode = NLED_BLINK;
nled_tmp_setting.blink_off_time =
led_data->delay_off;
nled_tmp_setting.blink_on_time =
led_data->delay_on;
mt_led_set_pwm(led_data->cust.data,
&nled_tmp_setting);
return 0;
} else if ((led_data->cust.mode == MT65XX_LED_MODE_PMIC)
&& (led_data->cust.data ==
MT65XX_LED_PMIC_NLED_ISINK1)) {
nled_tmp_setting.nled_mode = NLED_BLINK;
nled_tmp_setting.blink_off_time =
led_data->delay_off;
nled_tmp_setting.blink_on_time =
led_data->delay_on;
mt_led_blink_pmic(led_data->cust.data,
&nled_tmp_setting);
return 0;
} else if (!got_wake_lock) {
__pm_stay_awake(&leds_suspend_lock);
got_wake_lock = 1;
}
} else if (!led_data->delay_on && !led_data->delay_off) {
/* AP PWM all support OLD mode */
if (led_data->cust.mode == MT65XX_LED_MODE_PWM) {
nled_tmp_setting.nled_mode = NLED_OFF;
mt_led_set_pwm(led_data->cust.data,
&nled_tmp_setting);
return 0;
} else if ((led_data->cust.mode == MT65XX_LED_MODE_PMIC)
&& (led_data->cust.data ==
MT65XX_LED_PMIC_NLED_ISINK1)) {
mt_brightness_set_pmic(led_data->cust.data, 0,
0);
return 0;
} else if (got_wake_lock) {
__pm_relax(&leds_suspend_lock);
got_wake_lock = 0;
}
}
return -1;
}
/* delay_on and delay_off are not changed */
return 0;
}
@@ -0,0 +1,56 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2015 MediaTek Inc.
*
*/
#ifndef _LEDS_HAL_H
#define _LEDS_HAL_H
#include "mtk_leds_sw.h"
/****************************************************************************
* LED HAL functions
***************************************************************************/
extern void mt_leds_wake_lock_init(void);
extern unsigned int mt_get_bl_brightness(void);
extern unsigned int mt_get_bl_duty(void);
extern unsigned int mt_get_bl_div(void);
extern unsigned int mt_get_bl_frequency(void);
extern unsigned int *mt_get_div_array(void);
extern void mt_set_bl_duty(unsigned int level);
extern void mt_set_bl_div(unsigned int div);
extern void mt_set_bl_frequency(unsigned int freq);
extern void mt_led_pwm_disable(int pwm_num);
extern int mt_brightness_set_pmic_duty_store(u32 level, u32 div);
extern void mt_backlight_set_pwm_duty(int pwm_num, u32 level, u32 div,
struct PWM_config *config_data);
extern void mt_backlight_set_pwm_div(int pwm_num, u32 level, u32 div,
struct PWM_config *config_data);
extern void mt_backlight_get_pwm_fsel(unsigned int bl_div,
unsigned int *bl_frequency);
extern void mt_store_pwm_register(unsigned int addr, unsigned int value);
extern unsigned int mt_show_pwm_register(unsigned int addr);
extern int mt_led_set_pwm(int pwm_num, struct nled_setting *led);
extern int mt_led_blink_pmic(enum mt65xx_led_pmic pmic_type,
struct nled_setting *led);
extern int mt_backlight_set_pwm(int pwm_num, u32 level, u32 div,
struct PWM_config *config_data);
extern int mt_brightness_set_pmic(enum mt65xx_led_pmic pmic_type, u32 level,
u32 div);
extern int mt_mt65xx_led_set_cust(struct cust_mt65xx_led *cust, int level);
extern void mt_mt65xx_led_work(struct work_struct *work);
extern void mt_mt65xx_led_set(struct led_classdev *led_cdev,
enum led_brightness level);
extern int mt_mt65xx_blink_set(struct led_classdev *led_cdev,
unsigned long *delay_on,
unsigned long *delay_off);
extern struct cust_mt65xx_led *mt_get_cust_led_list(void);
#if defined(CONFIG_BACKLIGHT_SUPPORT_LM3697)
extern int chargepump_set_backlight_level(unsigned int level);
#endif /* CONFIG_BACKLIGHT_SUPPORT_LM3697 */
#endif
@@ -0,0 +1,192 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2018 MediaTek Inc.
*
*/
#ifndef _LEDS_SW_H
#define _LEDS_SW_H
/******************************************************************************
* LED & Backlight type defination
*****************************************************************************/
enum mt65xx_led_type {
MT65XX_LED_TYPE_RED = 0,
MT65XX_LED_TYPE_GREEN,
MT65XX_LED_TYPE_BLUE,
MT65XX_LED_TYPE_JOGBALL,
MT65XX_LED_TYPE_KEYBOARD,
MT65XX_LED_TYPE_BUTTON,
MT65XX_LED_TYPE_LCD,
MT65XX_LED_TYPE_TOTAL,
};
enum mt65xx_led_mode {
MT65XX_LED_MODE_NONE,
MT65XX_LED_MODE_PWM,
MT65XX_LED_MODE_GPIO,
MT65XX_LED_MODE_PMIC,
MT65XX_LED_MODE_CUST_LCM,
MT65XX_LED_MODE_CUST_BLS_PWM
};
/******************************************************************************
* for backlight
*****************************************************************************/
/* backlight call back function */
typedef int (*cust_brightness_set) (int level, int div);
typedef int (*cust_set_brightness) (int level);
/* 10bit backlight level */
#define LED_INCREASE_LED_LEVEL_MTKPATCH
#ifdef LED_INCREASE_LED_LEVEL_MTKPATCH
#define MT_LED_INTERNAL_LEVEL_BIT_CNT 10
#endif
/******************************************************************************
* for PMIC
*****************************************************************************/
enum mt65xx_led_pmic {
MT65XX_LED_PMIC_LCD_ISINK = 0,
MT65XX_LED_PMIC_NLED_ISINK_MIN = MT65XX_LED_PMIC_LCD_ISINK,
MT65XX_LED_PMIC_NLED_ISINK0,
MT65XX_LED_PMIC_NLED_ISINK1,
MT65XX_LED_PMIC_NLED_ISINK2,
MT65XX_LED_PMIC_NLED_ISINK3,
MT65XX_LED_PMIC_NLED_ISINK_MAX,
};
enum MT65XX_PMIC_ISINK_MODE {
ISINK_PWM_MODE = 0,
ISINK_BREATH_MODE = 1,
ISINK_REGISTER_MODE = 2
};
enum MT65XX_PMIC_ISINK_STEP {
ISINK_0 = 0, /* 4mA */
ISINK_1 = 1, /* 8mA */
ISINK_2 = 2, /* 12mA */
ISINK_3 = 3, /* 16mA */
ISINK_4 = 4, /* 20mA */
ISINK_5 = 5 /* 24mA */
};
enum MT65XX_PMIC_ISINK_FSEL {
/* 32K clock */
ISINK_1KHZ = 0,
ISINK_200HZ = 4,
ISINK_5HZ = 199,
ISINK_2HZ = 499,
ISINK_1HZ = 999,
ISINK_05HZ = 1999,
ISINK_02HZ = 4999,
ISINK_01HZ = 9999,
/* 2M clock */
ISINK_2M_20KHZ = 2,
ISINK_2M_1KHZ = 61,
ISINK_2M_200HZ = 311,
ISINK_2M_5HZ = 12499,
ISINK_2M_2HZ = 31249,
ISINK_2M_1HZ = 62499,
/* 128K clock */
ISINK_128K_500HZ = 0,
ISINK_128K_256HZ = 1,
ISINK_128K_167HZ = 2,
ISINK_128K_128HZ = 3,
ISINK_128K_100HZ = 4,
ISINK_128K_83HZ = 5,
ISINK_128K_50HZ = 9,
ISINK_128K_17HZ = 28,
};
/******************************************************************************
* for PWM
*****************************************************************************/
#define MIN_FRE_OLD_PWM 32/* the min frequence when use old mode pwm by kHz */
#define BACKLIGHT_LEVEL_PWM_64_FIFO_MODE_SUPPORT 64
#define BACKLIGHT_LEVEL_PWM_256_SUPPORT 256
#define BACKLIGHT_LEVEL_PWM_MODE_CONFIG BACKLIGHT_LEVEL_PWM_256_SUPPORT
static inline unsigned int Cust_GetBacklightLevelSupport_byPWM(void)
{
return BACKLIGHT_LEVEL_PWM_MODE_CONFIG;
}
static inline unsigned int brightness_mapping(unsigned int level)
{
unsigned int mapped_level;
mapped_level = level;
return mapped_level;
}
struct PWM_config {
int clock_source;
int div;
int low_duration;
int High_duration;
bool pmic_pad;
};
/****************************************************************************
* sw data structures
***************************************************************************/
/**
* led customization data structure
* name : must the same as lights HAL
* mode : control mode
* data :
* PWM: pwm number
* GPIO: gpio id
* PMIC: enum mt65xx_led_pmic
* CUST: custom set brightness function pointer
* config_data: pwm config data
*/
struct cust_mt65xx_led {
char *name;
enum mt65xx_led_mode mode;
long data;
struct PWM_config config_data;
};
/**
* led device node structure with mtk extentions
* cdev: common led device structure
* cust: customization data from device tree
* work: workqueue for specialfied led device
* level: brightness level
* delay_on: on time if led is blinking
* delay_off: off time if led is blinking
*/
struct mt65xx_led_data {
struct led_classdev cdev;
struct cust_mt65xx_led cust;
struct work_struct work;
int level;
int delay_on;
int delay_off;
};
/**
* LED Variable Settings
* nled_mode: 0, off; 1, on; 2, blink
* blink_on_time: on time if led is blinking
* blink_off_time: off time if led is blinking
*/
#define NLED_OFF 0
#define NLED_ON 1
#define NLED_BLINK 2
struct nled_setting {
u8 nled_mode;
u32 blink_on_time;
u32 blink_off_time;
};
#endif /* _LEDS_SW_H */
@@ -0,0 +1,16 @@
#
# Copyright (C) 2015 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
obj-$(CONFIG_MTK_LEDS) := mtk_leds.o
ccflags-y += -I$(srctree)/drivers/misc/mediatek/video/include
@@ -0,0 +1,967 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/delay.h>
#include <linux/string.h>
#include <linux/ctype.h>
#include <linux/leds.h>
#include <linux/of.h>
#include <linux/workqueue.h>
#include <linux/pm_wakeup.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/sched/clock.h>
#ifdef CONFIG_MTK_AAL_SUPPORT
#include <ddp_aal.h>
/* #include <linux/aee.h> */
#endif
#ifdef CONFIG_MTK_PWM
#include <mt-plat/mtk_pwm.h>
#endif
#ifdef CONFIG_MTK_PMIC_NEW_ARCH
#include <mt-plat/upmu_common.h>
#endif
#ifdef CONFIG_MTK_FB
#include <ddp_gamma.h>
#include "ddp_pwm.h"
#include "mtkfb.h"
#endif
// #define MET_USER_EVENT_SUPPORT
#ifdef MET_USER_EVENT_SUPPORT
#include <mt-plat/met_drv.h>
#endif
#include "mtk_leds_sw.h"
#include "mtk_leds_hal.h"
#include "../mtk_leds_drv.h"
/* for LED&Backlight bringup, define the dummy API */
#ifndef CONFIG_MTK_PMIC_NEW_ARCH
u16 pmic_set_register_value(u32 flagname, u32 val)
{
return 0;
}
#endif
static DEFINE_MUTEX(leds_mutex);
static DEFINE_MUTEX(leds_pmic_mutex);
/****************************************************************************
* variables
***************************************************************************/
#define CLK_DIV1 0
static unsigned int bl_brightness_hal = 102;
#ifdef CONFIG_MTK_PWM
static unsigned int bl_duty_hal = 21;
#endif
static unsigned int bl_div_hal = CLK_DIV1;
/* for button led don't do ISINK disable first time */
static int button_flag_isink0;
static int button_flag_isink1;
struct wakeup_source leds_suspend_lock;
struct cust_mt65xx_led *pled_dtsi;
char *leds_name[MT65XX_LED_TYPE_TOTAL] = {
"red",
"green",
"blue",
"jogball-backlight",
"keyboard-backlight",
"button-backlight",
"lcd-backlight",
};
/****************************************************************************
* DEBUG MACROS
***************************************************************************/
static int debug_enable_led_hal = 1;
#define LEDS_DEBUG(format, args...) do { \
if (debug_enable_led_hal) { \
pr_debug("[LED]"format, ##args);\
} \
} while (0)
/*****************PWM *************************************************/
#define PWM_DIV_NUM 8
#ifdef CONFIG_MTK_PWM
static int time_array_hal[PWM_DIV_NUM] = {
256, 512, 1024, 2048, 4096, 8192, 16384, 32768 };
static unsigned int backlight_PWM_div_hal = CLK_DIV1;
static unsigned int div_array_hal[PWM_DIV_NUM] = {
1, 2, 4, 8, 16, 32, 64, 128 };
#endif
/****************************************************************************
* func:return global variables
***************************************************************************/
static unsigned long long current_t, last_time;
static int count;
static char buffer[4096] = "[BL] Set Backlight directly ";
static void backlight_debug_log(int level, int mappingLevel)
{
unsigned long cur_time_mod = 0;
unsigned long long cur_time_display = 0;
int ret = 0;
current_t = sched_clock();
cur_time_display = current_t;
do_div(cur_time_display, 1000000);
cur_time_mod = do_div(cur_time_display, 1000);
ret = snprintf(buffer + strlen(buffer),
4095 - strlen(buffer), "T:%lld.%ld,L:%d map:%d ",
cur_time_display, cur_time_mod, level, mappingLevel);
count++;
if (ret < 0 || ret >= 4096) {
pr_info("print log error!");
count = 5;
}
if (level == 0 || count >= 5 || (current_t - last_time) > 1000000000) {
LEDS_DEBUG("%s", buffer);
count = 0;
buffer[strlen("Set Backlight directly ")] = '\0';
}
last_time = sched_clock();
}
void mt_leds_wake_lock_init(void)
{
// wakeup_source_init(&leds_suspend_lock, "leds wakelock");
}
unsigned int *mt_get_div_array(void)
{
return &div_array_hal[0];
}
struct cust_mt65xx_led *get_cust_led_dtsi(void)
{
struct device_node *led_node = NULL;
bool isSupportDTS = false;
int i, ret;
int mode, data;
int pwm_config[5] = { 0 };
if (pled_dtsi)
goto out;
pr_info("[LED] %s pled_dtsi is null, load dts file\n", __func__);
pled_dtsi = kmalloc_array(MT65XX_LED_TYPE_TOTAL,
sizeof(struct cust_mt65xx_led), GFP_KERNEL);
if (pled_dtsi == NULL) {
LEDS_DEBUG("%s kmalloc fail\n", __func__);
goto out;
}
for (i = 0; i < MT65XX_LED_TYPE_TOTAL; i++) {
char node_name[32] = "mediatek,";
if (strlen(node_name) + strlen(leds_name[i]) + 1 >
sizeof(node_name)) {
LEDS_DEBUG("buffer for %s%s not enough\n",
node_name, leds_name[i]);
pled_dtsi[i].mode = 0;
pled_dtsi[i].data = -1;
continue;
}
pled_dtsi[i].name = leds_name[i];
led_node = of_find_compatible_node(NULL, NULL,
strncat(node_name, leds_name[i],
sizeof(node_name) - strlen(node_name) - 1));
if (!led_node) {
pr_info("[LED]Cannot find LED node from dts\n");
pled_dtsi[i].mode = 0;
pled_dtsi[i].data = -1;
continue;
}
isSupportDTS = true;
ret = of_property_read_u32(led_node, "led_mode", &mode);
if (!ret) {
pled_dtsi[i].mode = mode;
LEDS_DEBUG("The %s's led mode is : %d\n",
pled_dtsi[i].name, pled_dtsi[i].mode);
} else {
LEDS_DEBUG("led dts can not get %s led mode\n",
pled_dtsi[i].name);
pled_dtsi[i].mode = 0;
}
ret =
of_property_read_u32(led_node, "data",
&data);
if (!ret) {
pled_dtsi[i].data = data;
LEDS_DEBUG("The %s's led data is : %ld\n",
pled_dtsi[i].name, pled_dtsi[i].data);
} else {
LEDS_DEBUG("led dts can not get %s led data\n",
pled_dtsi[i].name);
pled_dtsi[i].data = -1;
}
ret = of_property_read_u32_array(led_node, "pwm_config",
pwm_config, ARRAY_SIZE(pwm_config));
if (!ret) {
LEDS_DEBUG("%s's pwm cfg %d %d %d %d %d\n",
pled_dtsi[i].name, pwm_config[0], pwm_config[1],
pwm_config[2], pwm_config[3], pwm_config[4]);
pled_dtsi[i].config_data.clock_source = pwm_config[0];
pled_dtsi[i].config_data.div = pwm_config[1];
pled_dtsi[i].config_data.low_duration = pwm_config[2];
pled_dtsi[i].config_data.High_duration = pwm_config[3];
pled_dtsi[i].config_data.pmic_pad = pwm_config[4];
} else
LEDS_DEBUG("led dts can't get pwm config\n");
switch (pled_dtsi[i].mode) {
case MT65XX_LED_MODE_CUST_LCM:
#if defined(CONFIG_BACKLIGHT_SUPPORT_LM3697)
pled_dtsi[i].data =
(long)chargepump_set_backlight_level;
LEDS_DEBUG("BL set by chargepump\n");
#else
pled_dtsi[i].data = (long)mtkfb_set_backlight_level;
#endif
LEDS_DEBUG("kernel:the BL hw mode is LCM.\n");
break;
case MT65XX_LED_MODE_CUST_BLS_PWM:
pled_dtsi[i].data = (long)disp_bls_set_backlight;
LEDS_DEBUG("kernel:the BL hw mode is BLS.\n");
break;
default:
break;
}
}
if (!isSupportDTS) {
kfree(pled_dtsi);
pled_dtsi = NULL;
}
out:
return pled_dtsi;
}
struct cust_mt65xx_led *mt_get_cust_led_list(void)
{
struct cust_mt65xx_led *cust_led_list = get_cust_led_dtsi();
return cust_led_list;
}
/****************************************************************************
* internal functions
***************************************************************************/
#ifdef CONFIG_MTK_PWM
static int brightness_mapto64(int level)
{
if (level < 30)
return (level >> 1) + 7;
else if (level <= 120)
return (level >> 2) + 14;
else if (level <= 160)
return level / 5 + 20;
else
return (level >> 3) + 33;
}
static int find_time_index(int time)
{
int index = 0;
while (index < 8) {
if (time < time_array_hal[index])
return index;
index++;
}
return PWM_DIV_NUM - 1;
}
#endif
int mt_led_set_pwm(int pwm_num, struct nled_setting *led)
{
#ifdef CONFIG_MTK_PWM
struct pwm_spec_config pwm_setting;
int time_index = 0;
memset(&pwm_setting, 0, sizeof(struct pwm_spec_config));
pwm_setting.pwm_no = pwm_num;
pwm_setting.mode = PWM_MODE_OLD;
LEDS_DEBUG("led_set_pwm: mode=%d,pwm_no=%d\n", led->nled_mode,
pwm_num);
/* We won't choose 32K to be the clock src of old mode because of
* system performance. The setting here will be clock src = 26MHz,
* CLKSEL = 26M/1625 (i.e. 16K)
*/
pwm_setting.clk_src = PWM_CLK_OLD_MODE_32K;
pwm_setting.pmic_pad = 0;
switch (led->nled_mode) {
/* Actually, the setting still can not to turn off NLED. We should
* disable PWM to turn off NLED.
*/
case NLED_OFF:
pwm_setting.PWM_MODE_OLD_REGS.THRESH = 0;
pwm_setting.clk_div = CLK_DIV1;
pwm_setting.PWM_MODE_OLD_REGS.DATA_WIDTH = 100 / 2;
break;
case NLED_ON:
pwm_setting.PWM_MODE_OLD_REGS.THRESH = 30 / 2;
pwm_setting.clk_div = CLK_DIV1;
pwm_setting.PWM_MODE_OLD_REGS.DATA_WIDTH = 100 / 2;
break;
case NLED_BLINK:
LEDS_DEBUG("LED blink on time = %d offtime = %d\n",
led->blink_on_time, led->blink_off_time);
time_index =
find_time_index(led->blink_on_time + led->blink_off_time);
LEDS_DEBUG("LED div is %d\n", time_index);
pwm_setting.clk_div = time_index;
pwm_setting.PWM_MODE_OLD_REGS.DATA_WIDTH =
(led->blink_on_time +
led->blink_off_time) * MIN_FRE_OLD_PWM /
div_array_hal[time_index];
pwm_setting.PWM_MODE_OLD_REGS.THRESH =
(led->blink_on_time * 100) / (led->blink_on_time +
led->blink_off_time);
break;
default:
LEDS_DEBUG("Invalid nled mode\n");
return -1;
}
pwm_setting.PWM_MODE_FIFO_REGS.IDLE_VALUE = 0;
pwm_setting.PWM_MODE_FIFO_REGS.GUARD_VALUE = 0;
pwm_setting.PWM_MODE_FIFO_REGS.GDURATION = 0;
pwm_setting.PWM_MODE_FIFO_REGS.WAVE_NUM = 0;
pwm_set_spec_config(&pwm_setting);
#endif
return 0;
}
/************************ led breath function*****************************/
/*************************************************************************
* func is to switch to breath mode from PWM mode of ISINK
* para: enable: 1 : breath mode; 0: PWM mode;
*************************************************************************/
#if 0
static int led_switch_breath_pmic(enum mt65xx_led_pmic pmic_type,
struct nled_setting *led, int enable)
{
/* int time_index = 0; */
/* int duty = 0; */
LEDS_DEBUG("led_blink_pmic: pmic_type=%d\n", pmic_type);
if ((pmic_type != MT65XX_LED_PMIC_NLED_ISINK0
&& pmic_type != MT65XX_LED_PMIC_NLED_ISINK1
&& pmic_type != MT65XX_LED_PMIC_NLED_ISINK2
&& pmic_type != MT65XX_LED_PMIC_NLED_ISINK3)
|| led->nled_mode != NLED_BLINK) {
return -1;
}
if (enable == 1) {
switch (pmic_type) {
case MT65XX_LED_PMIC_NLED_ISINK0:
pmic_set_register_value(PMIC_ISINK_CH0_MODE,
ISINK_BREATH_MODE);
pmic_set_register_value(PMIC_ISINK_CH0_STEP, ISINK_3);
pmic_set_register_value(PMIC_ISINK_BREATH0_TR1_SEL,
0x04);
pmic_set_register_value(PMIC_ISINK_BREATH0_TR2_SEL,
0x04);
pmic_set_register_value(PMIC_ISINK_BREATH0_TF1_SEL,
0x04);
pmic_set_register_value(PMIC_ISINK_BREATH0_TF2_SEL,
0x04);
pmic_set_register_value(PMIC_ISINK_BREATH0_TON_SEL,
0x02);
pmic_set_register_value(PMIC_ISINK_BREATH0_TOFF_SEL,
0x03);
pmic_set_register_value(PMIC_ISINK_DIM0_DUTY, 15);
pmic_set_register_value(PMIC_ISINK_DIM0_FSEL, 11);
break;
case MT65XX_LED_PMIC_NLED_ISINK1:
pmic_set_register_value(PMIC_ISINK_CH1_MODE,
ISINK_BREATH_MODE);
pmic_set_register_value(PMIC_ISINK_CH1_STEP, ISINK_3);
pmic_set_register_value(PMIC_ISINK_BREATH1_TR1_SEL,
0x04);
pmic_set_register_value(PMIC_ISINK_BREATH1_TR2_SEL,
0x04);
pmic_set_register_value(PMIC_ISINK_BREATH1_TF1_SEL,
0x04);
pmic_set_register_value(PMIC_ISINK_BREATH1_TF2_SEL,
0x04);
pmic_set_register_value(PMIC_ISINK_BREATH1_TON_SEL,
0x02);
pmic_set_register_value(PMIC_ISINK_BREATH1_TOFF_SEL,
0x03);
pmic_set_register_value(PMIC_ISINK_DIM1_DUTY, 15);
pmic_set_register_value(PMIC_ISINK_DIM1_FSEL, 11);
break;
case MT65XX_LED_PMIC_NLED_ISINK2:
pmic_set_register_value(PMIC_ISINK_CH2_MODE,
ISINK_BREATH_MODE);
pmic_set_register_value(PMIC_ISINK_CH2_STEP, ISINK_3);
pmic_set_register_value(PMIC_ISINK_BREATH2_TR1_SEL,
0x04);
pmic_set_register_value(PMIC_ISINK_BREATH2_TR2_SEL,
0x04);
pmic_set_register_value(PMIC_ISINK_BREATH2_TF1_SEL,
0x04);
pmic_set_register_value(PMIC_ISINK_BREATH2_TF2_SEL,
0x04);
pmic_set_register_value(PMIC_ISINK_BREATH2_TON_SEL,
0x02);
pmic_set_register_value(PMIC_ISINK_BREATH2_TOFF_SEL,
0x03);
pmic_set_register_value(PMIC_ISINK_DIM2_DUTY, 15);
pmic_set_register_value(PMIC_ISINK_DIM2_FSEL, 11);
break;
case MT65XX_LED_PMIC_NLED_ISINK3:
pmic_set_register_value(PMIC_ISINK_CH3_MODE,
ISINK_BREATH_MODE);
pmic_set_register_value(PMIC_ISINK_CH3_STEP, ISINK_3);
pmic_set_register_value(PMIC_ISINK_BREATH3_TR1_SEL,
0x04);
pmic_set_register_value(PMIC_ISINK_BREATH3_TR2_SEL,
0x04);
pmic_set_register_value(PMIC_ISINK_BREATH3_TF1_SEL,
0x04);
pmic_set_register_value(PMIC_ISINK_BREATH3_TF2_SEL,
0x04);
pmic_set_register_value(PMIC_ISINK_BREATH3_TON_SEL,
0x02);
pmic_set_register_value(PMIC_ISINK_BREATH3_TOFF_SEL,
0x03);
pmic_set_register_value(PMIC_ISINK_DIM3_DUTY, 15);
pmic_set_register_value(PMIC_ISINK_DIM3_FSEL, 11);
break;
default:
break;
}
} else {
switch (pmic_type) {
case MT65XX_LED_PMIC_NLED_ISINK0:
pmic_set_register_value(PMIC_ISINK_CH3_MODE,
ISINK_PWM_MODE);
break;
case MT65XX_LED_PMIC_NLED_ISINK0:
pmic_set_register_value(PMIC_ISINK_CH3_MODE,
ISINK_PWM_MODE);
break;
case MT65XX_LED_PMIC_NLED_ISINK0:
pmic_set_register_value(PMIC_ISINK_CH3_MODE,
ISINK_PWM_MODE);
break;
case MT65XX_LED_PMIC_NLED_ISINK0:
pmic_set_register_value(PMIC_ISINK_CH3_MODE,
ISINK_PWM_MODE);
break;
default:
break;
}
}
return 0;
}
#endif
#ifndef CONFIG_MTK_PMIC_CHIP_MT6358
#define PMIC_PERIOD_NUM 8
int pmic_period_array[] = { 2, 4, 6, 8, 10, 12, 20, 60 };
int pmic_freqsel_array[] = { 0, 1, 2, 3, 4, 5, 9, 28 };
static int find_time_index_pmic(int time_ms)
{
int i;
for (i = 0; i < PMIC_PERIOD_NUM; i++) {
if (time_ms <= pmic_period_array[i])
return i;
}
return PMIC_PERIOD_NUM - 1;
}
#endif
int mt_led_blink_pmic(enum mt65xx_led_pmic pmic_type, struct nled_setting *led)
{
#ifdef CONFIG_MTK_PMIC_CHIP_MT6358
LEDS_DEBUG("%s pmic_type = %d isink does not support this path\n",
__func__, pmic_type);
#else
int time_index = 0;
int duty = 0;
if (led->nled_mode != NLED_BLINK)
return -1;
LEDS_DEBUG("%s blink on time = %d offtime = %d\n", __func__,
led->blink_on_time, led->blink_off_time);
time_index =
find_time_index_pmic(led->blink_on_time + led->blink_off_time);
LEDS_DEBUG("LED index is %d freqsel=%d\n", time_index,
pmic_freqsel_array[time_index]);
duty = 256 * led->blink_on_time / (led->blink_on_time +
led->blink_off_time);
if (pmic_type > MT65XX_LED_PMIC_NLED_ISINK_MIN &&
pmic_type < MT65XX_LED_PMIC_NLED_ISINK_MAX)
pmic_set_register_value(PMIC_RG_DRV_128K_CK_PDN, 0x0);
switch (pmic_type) {
case MT65XX_LED_PMIC_NLED_ISINK0:
pmic_set_register_value(PMIC_ISINK_CH0_EN, NLED_OFF);
pmic_set_register_value(PMIC_RG_DRV_ISINK0_CK_PDN, 0);
pmic_set_register_value(PMIC_ISINK_CH0_MODE, ISINK_PWM_MODE);
pmic_set_register_value(PMIC_ISINK_CH0_STEP, ISINK_3);
pmic_set_register_value(PMIC_ISINK_DIM0_DUTY, duty);
pmic_set_register_value(PMIC_ISINK_DIM0_FSEL,
pmic_freqsel_array[time_index]);
pmic_set_register_value(PMIC_ISINK_CH0_BIAS_EN, NLED_ON);
pmic_set_register_value(PMIC_ISINK_CHOP0_EN, NLED_ON);
pmic_set_register_value(PMIC_ISINK_CH0_EN, NLED_ON);
break;
case MT65XX_LED_PMIC_NLED_ISINK1:
pmic_set_register_value(PMIC_ISINK_CH1_EN, NLED_OFF);
pmic_set_register_value(PMIC_RG_DRV_ISINK1_CK_PDN, 0);
pmic_set_register_value(PMIC_ISINK_CH1_MODE, ISINK_PWM_MODE);
pmic_set_register_value(PMIC_ISINK_CH1_STEP, ISINK_3);
pmic_set_register_value(PMIC_ISINK_DIM1_DUTY, duty);
pmic_set_register_value(PMIC_ISINK_DIM1_FSEL,
pmic_freqsel_array[time_index]);
pmic_set_register_value(PMIC_ISINK_CH1_BIAS_EN, NLED_ON);
pmic_set_register_value(PMIC_ISINK_CHOP1_EN, NLED_ON);
pmic_set_register_value(PMIC_ISINK_CH1_EN, NLED_ON);
break;
default:
LEDS_DEBUG("pmic_type %d is not handled\n", pmic_type);
break;
}
#endif
return 0;
}
int mt_backlight_set_pwm(int pwm_num, u32 level, u32 div,
struct PWM_config *config_data)
{
#ifdef CONFIG_MTK_PWM
struct pwm_spec_config pwm_setting;
unsigned int BacklightLevelSupport =
Cust_GetBacklightLevelSupport_byPWM();
pwm_setting.pwm_no = pwm_num;
if (BacklightLevelSupport == BACKLIGHT_LEVEL_PWM_256_SUPPORT)
pwm_setting.mode = PWM_MODE_OLD;
else
pwm_setting.mode = PWM_MODE_FIFO;
pwm_setting.pmic_pad = config_data->pmic_pad;
if (config_data->div) {
pwm_setting.clk_div = config_data->div;
backlight_PWM_div_hal = config_data->div;
} else
pwm_setting.clk_div = div;
if (BacklightLevelSupport == BACKLIGHT_LEVEL_PWM_256_SUPPORT) {
/* PWM_CLK_OLD_MODE_32K is block/1625 = 26M/1625 = 16KHz @ MT6571 */
if (config_data->clock_source)
pwm_setting.clk_src = PWM_CLK_OLD_MODE_BLOCK;
else
pwm_setting.clk_src = PWM_CLK_OLD_MODE_32K;
pwm_setting.PWM_MODE_OLD_REGS.IDLE_VALUE = 0;
pwm_setting.PWM_MODE_OLD_REGS.GUARD_VALUE = 0;
pwm_setting.PWM_MODE_OLD_REGS.GDURATION = 0;
pwm_setting.PWM_MODE_OLD_REGS.WAVE_NUM = 0;
pwm_setting.PWM_MODE_OLD_REGS.DATA_WIDTH = 255; /* 256 level */
pwm_setting.PWM_MODE_OLD_REGS.THRESH = level;
LEDS_DEBUG("[%d]backlight set pwm:duty is %d/%d\n",
BacklightLevelSupport, level,
pwm_setting.PWM_MODE_OLD_REGS.DATA_WIDTH);
LEDS_DEBUG("[%d]backlight set pwm:clk_src/div is %d%d\n",
BacklightLevelSupport, pwm_setting.clk_src,
pwm_setting.clk_div);
if (level > 0 && level < 256) {
pwm_set_spec_config(&pwm_setting);
LEDS_DEBUG
("[%d]old mode: thres/data_width is %d/%d\n",
BacklightLevelSupport,
pwm_setting.PWM_MODE_OLD_REGS.THRESH,
pwm_setting.PWM_MODE_OLD_REGS.DATA_WIDTH);
} else {
LEDS_DEBUG("[%d]Error level in backlight\n",
BacklightLevelSupport);
mt_pwm_disable(pwm_setting.pwm_no,
config_data->pmic_pad);
}
} else {
if (config_data->clock_source) {
pwm_setting.clk_src = PWM_CLK_NEW_MODE_BLOCK;
} else {
pwm_setting.clk_src =
PWM_CLK_NEW_MODE_BLOCK_DIV_BY_1625;
}
if (config_data->High_duration && config_data->low_duration) {
pwm_setting.PWM_MODE_FIFO_REGS.HDURATION =
config_data->High_duration;
pwm_setting.PWM_MODE_FIFO_REGS.LDURATION =
pwm_setting.PWM_MODE_FIFO_REGS.HDURATION;
} else {
pwm_setting.PWM_MODE_FIFO_REGS.HDURATION = 4;
pwm_setting.PWM_MODE_FIFO_REGS.LDURATION = 4;
}
pwm_setting.PWM_MODE_FIFO_REGS.IDLE_VALUE = 0;
pwm_setting.PWM_MODE_FIFO_REGS.GUARD_VALUE = 0;
pwm_setting.PWM_MODE_FIFO_REGS.STOP_BITPOS_VALUE = 31;
pwm_setting.PWM_MODE_FIFO_REGS.GDURATION =
(pwm_setting.PWM_MODE_FIFO_REGS.HDURATION + 1) * 32 - 1;
pwm_setting.PWM_MODE_FIFO_REGS.WAVE_NUM = 0;
LEDS_DEBUG("%s :duty is %d\n", __func__, level);
LEDS_DEBUG("clk_src/div/high/low is %d%d%d%d\n",
pwm_setting.clk_src, pwm_setting.clk_div,
pwm_setting.PWM_MODE_FIFO_REGS.HDURATION,
pwm_setting.PWM_MODE_FIFO_REGS.LDURATION);
if (level > 0 && level <= 32) {
pwm_setting.PWM_MODE_FIFO_REGS.GUARD_VALUE = 0;
pwm_setting.PWM_MODE_FIFO_REGS.SEND_DATA0 =
(1 << level) - 1;
pwm_set_spec_config(&pwm_setting);
} else if (level > 32 && level <= 64) {
pwm_setting.PWM_MODE_FIFO_REGS.GUARD_VALUE = 1;
level -= 32;
pwm_setting.PWM_MODE_FIFO_REGS.SEND_DATA0 =
(1 << level) - 1;
pwm_set_spec_config(&pwm_setting);
} else {
LEDS_DEBUG("Error level in backlight\n");
mt_pwm_disable(pwm_setting.pwm_no,
config_data->pmic_pad);
}
}
#endif
return 0;
}
void mt_led_pwm_disable(int pwm_num)
{
#ifdef CONFIG_MTK_PWM
struct cust_mt65xx_led *cust_led_list = get_cust_led_dtsi();
mt_pwm_disable(pwm_num, cust_led_list->config_data.pmic_pad);
#endif
}
int mt_brightness_set_pmic(enum mt65xx_led_pmic pmic_type, u32 level, u32 div)
{
#ifdef CONFIG_MTK_PMIC_CHIP_MT6358
LEDS_DEBUG("%s, pmic_type = %d isink does not support this path\n",
__func__, pmic_type);
#else
static bool first_time = true;
LEDS_DEBUG("%s pmic_type%d level%d\n", __func__, pmic_type, level);
mutex_lock(&leds_pmic_mutex);
if (pmic_type == MT65XX_LED_PMIC_NLED_ISINK0) {
/* button flag ==0, means this ISINK is not for button */
if ((button_flag_isink0 == 0) && (first_time == true)) {
/* sw workround for sync leds status */
if (button_flag_isink1 == 0)
// pmic_set_register_value(PMIC_ISINK_CH1_EN,
// NLED_OFF);
first_time = false;
}
pmic_set_register_value(PMIC_RG_DRV_128K_CK_PDN, 0x0);
pmic_set_register_value(PMIC_RG_DRV_ISINK0_CK_PDN, 0);
pmic_set_register_value(PMIC_ISINK_CH0_MODE, ISINK_PWM_MODE);
/* 16mA */
pmic_set_register_value(PMIC_ISINK_CH0_STEP, ISINK_3);
pmic_set_register_value(PMIC_ISINK_DIM0_DUTY, 255);
/* 1KHz */
pmic_set_register_value(PMIC_ISINK_DIM0_FSEL,
ISINK_128K_500HZ);
pmic_set_register_value(PMIC_ISINK_CH0_BIAS_EN, NLED_ON);
pmic_set_register_value(PMIC_ISINK_CHOP0_EN, NLED_ON);
if (level)
pmic_set_register_value(PMIC_ISINK_CH0_EN, NLED_ON);
else
pmic_set_register_value(PMIC_ISINK_CH0_EN, NLED_OFF);
mutex_unlock(&leds_pmic_mutex);
return 0;
} else if (pmic_type == MT65XX_LED_PMIC_NLED_ISINK1) {
/* button flag ==0, means this ISINK is not for button*/
if ((button_flag_isink1 == 0) && (first_time == true)) {
/* sw workround for sync leds status */
if (button_flag_isink0 == 0)
pmic_set_register_value(PMIC_ISINK_CH0_EN,
NLED_OFF);
first_time = false;
}
/* Disable power down */
pmic_set_register_value(PMIC_RG_DRV_128K_CK_PDN, 0x0);
pmic_set_register_value(PMIC_RG_DRV_ISINK1_CK_PDN, 0);
pmic_set_register_value(PMIC_ISINK_CH1_MODE, ISINK_PWM_MODE);
/* 16mA */
pmic_set_register_value(PMIC_ISINK_CH1_STEP, ISINK_3);
pmic_set_register_value(PMIC_ISINK_DIM1_DUTY, 255);
/* 1KHz */
pmic_set_register_value(PMIC_ISINK_DIM1_FSEL, ISINK_128K_500HZ);
pmic_set_register_value(PMIC_ISINK_CH1_BIAS_EN, NLED_ON);
pmic_set_register_value(PMIC_ISINK_CHOP1_EN, NLED_ON);
if (level)
pmic_set_register_value(PMIC_ISINK_CH1_EN, NLED_ON);
else
pmic_set_register_value(PMIC_ISINK_CH1_EN, NLED_OFF);
mutex_unlock(&leds_pmic_mutex);
return 0;
}
mutex_unlock(&leds_pmic_mutex);
#endif
return -1;
}
int mt_mt65xx_led_set_cust(struct cust_mt65xx_led *cust, int level)
{
#ifdef CONFIG_MTK_PWM
struct nled_setting led_tmp_setting = { 0, 0, 0 };
int tmp_level = level;
unsigned int BacklightLevelSupport =
Cust_GetBacklightLevelSupport_byPWM();
#endif
static bool button_flag;
switch (cust->mode) {
case MT65XX_LED_MODE_PWM:
#ifdef CONFIG_MTK_PWM
if (strcmp(cust->name, "lcd-backlight") == 0) {
bl_brightness_hal = level;
if (level == 0) {
mt_pwm_disable(cust->data,
cust->config_data.pmic_pad);
} else {
if (BacklightLevelSupport ==
BACKLIGHT_LEVEL_PWM_256_SUPPORT)
level = brightness_mapping(tmp_level);
else
level = brightness_mapto64(tmp_level);
mt_backlight_set_pwm(cust->data, level,
bl_div_hal, &cust->config_data);
}
bl_duty_hal = level;
} else {
if (level == 0) {
led_tmp_setting.nled_mode = NLED_OFF;
mt_led_set_pwm(cust->data, &led_tmp_setting);
mt_pwm_disable(cust->data,
cust->config_data.pmic_pad);
} else {
led_tmp_setting.nled_mode = NLED_ON;
mt_led_set_pwm(cust->data, &led_tmp_setting);
}
}
#endif
return 1;
case MT65XX_LED_MODE_GPIO:
LEDS_DEBUG("%s led GPIO mode!!\n", __func__);
return ((cust_set_brightness) (cust->data)) (level);
case MT65XX_LED_MODE_PMIC:
/* for button baclight used SINK channel, when set button ISINK,
* don't do disable other ISINK channel
*/
if ((strcmp(cust->name, "button-backlight") == 0)) {
if (button_flag == false) {
switch (cust->data) {
case MT65XX_LED_PMIC_NLED_ISINK0:
button_flag_isink0 = 1;
break;
case MT65XX_LED_PMIC_NLED_ISINK1:
button_flag_isink1 = 1;
break;
default:
break;
}
button_flag = true;
}
}
return mt_brightness_set_pmic(cust->data, level, bl_div_hal);
case MT65XX_LED_MODE_CUST_LCM:
if (strcmp(cust->name, "lcd-backlight") == 0)
bl_brightness_hal = level;
LEDS_DEBUG("%s backlight control by LCM\n", __func__);
/* warning for this API revork */
return ((cust_brightness_set) (cust->data)) (level, bl_div_hal);
case MT65XX_LED_MODE_CUST_BLS_PWM:
if (strcmp(cust->name, "lcd-backlight") == 0)
bl_brightness_hal = level;
#ifdef MET_USER_EVENT_SUPPORT
if (enable_met_backlight_tag())
output_met_backlight_tag(level);
#endif
return ((cust_set_brightness) (cust->data)) (level);
case MT65XX_LED_MODE_NONE:
default:
break;
}
return -1;
}
void mt_mt65xx_led_work(struct work_struct *work)
{
struct mt65xx_led_data *led_data =
container_of(work, struct mt65xx_led_data, work);
LEDS_DEBUG("%s:%d work start\n", led_data->cust.name, led_data->level);
mutex_lock(&leds_mutex);
mt_mt65xx_led_set_cust(&led_data->cust, led_data->level);
mutex_unlock(&leds_mutex);
}
void mt_mt65xx_led_set(struct led_classdev *led_cdev, enum led_brightness level)
{
struct mt65xx_led_data *led_data =
container_of(led_cdev, struct mt65xx_led_data, cdev);
/* unsigned long flags; */
/* spin_lock_irqsave(&leds_lock, flags); */
/* do something only when level is changed */
if (led_data->level == level) {
LEDS_DEBUG("no level change,do nothing\n");
return;
}
led_data->level = level;
if (strcmp(led_data->cust.name, "lcd-backlight") != 0) {
LEDS_DEBUG("Set NLED directly %d at time %lu\n",
led_data->level, jiffies);
schedule_work(&led_data->work);
return;
}
if (level != 0 && level * CONFIG_LIGHTNESS_MAPPING_VALUE < 255)
level = 1;
else
level = (level * CONFIG_LIGHTNESS_MAPPING_VALUE) / 255;
backlight_debug_log(led_data->level, level);
disp_pq_notify_backlight_changed((((1 << MT_LED_INTERNAL_LEVEL_BIT_CNT)
- 1) * level + 127) / 255);
#ifdef CONFIG_MTK_AAL_SUPPORT
disp_aal_notify_backlight_changed((((1 <<
MT_LED_INTERNAL_LEVEL_BIT_CNT)
- 1) * level + 127) / 255);
#else
if (led_data->cust.mode == MT65XX_LED_MODE_CUST_BLS_PWM)
mt_mt65xx_led_set_cust(&led_data->cust,
((((1 << MT_LED_INTERNAL_LEVEL_BIT_CNT)
- 1) * level + 127) / 255));
else
mt_mt65xx_led_set_cust(&led_data->cust, level);
#endif
}
/* spin_unlock_irqrestore(&leds_lock, flags); */
/* if(0!=aee_kernel_Powerkey_is_press()) */
/* aee_kernel_wdt_kick_Powkey_api("mt_mt65xx_led_set",WDT_SETBY_Backlight); */
int mt_mt65xx_blink_set(struct led_classdev *led_cdev,
unsigned long *delay_on, unsigned long *delay_off)
{
struct mt65xx_led_data *led_data =
container_of(led_cdev, struct mt65xx_led_data, cdev);
static int got_wake_lock;
struct nled_setting nled_tmp_setting = { 0, 0, 0 };
if ((*delay_on == led_data->delay_on)
&& (*delay_off == led_data->delay_off)) {
LEDS_DEBUG("blink para not changed,do nothing %ld %ld\n",
*delay_on, *delay_off);
return -1;
}
/* only allow software blink when delay_on or delay_off changed */
led_data->delay_on = *delay_on;
led_data->delay_off = *delay_off;
if (led_data->delay_on && led_data->delay_off) {
led_data->level = 255;
/* AP PWM all support OLD mode */
if (led_data->cust.mode == MT65XX_LED_MODE_PWM) {
nled_tmp_setting.nled_mode = NLED_BLINK;
nled_tmp_setting.blink_off_time =
led_data->delay_off;
nled_tmp_setting.blink_on_time =
led_data->delay_on;
mt_led_set_pwm(led_data->cust.data,
&nled_tmp_setting);
} else if (led_data->cust.mode == MT65XX_LED_MODE_PMIC) {
nled_tmp_setting.nled_mode = NLED_BLINK;
nled_tmp_setting.blink_off_time =
led_data->delay_off;
nled_tmp_setting.blink_on_time =
led_data->delay_on;
mt_led_blink_pmic(led_data->cust.data,
&nled_tmp_setting);
} else if (!got_wake_lock) {
__pm_stay_awake(&leds_suspend_lock);
got_wake_lock = 1;
}
} else if (!led_data->delay_on && led_data->delay_off) {
/* AP PWM all support OLD mode */
if (led_data->cust.mode == MT65XX_LED_MODE_PWM) {
nled_tmp_setting.nled_mode = NLED_OFF;
mt_led_set_pwm(led_data->cust.data,
&nled_tmp_setting);
} else if (led_data->cust.mode == MT65XX_LED_MODE_PMIC)
mt_brightness_set_pmic(led_data->cust.data, 0, 0);
else if (got_wake_lock) {
__pm_relax(&leds_suspend_lock);
got_wake_lock = 0;
}
} else if (led_data->delay_on && !led_data->delay_off) {
/* AP PWM all support OLD mode */
if (led_data->cust.mode == MT65XX_LED_MODE_PWM) {
nled_tmp_setting.nled_mode = NLED_ON;
mt_led_set_pwm(led_data->cust.data, &nled_tmp_setting);
} else if (led_data->cust.mode == MT65XX_LED_MODE_PMIC)
mt_brightness_set_pmic(led_data->cust.data, 1, 0);
else if (got_wake_lock) {
__pm_relax(&leds_suspend_lock);
got_wake_lock = 0;
}
} else
return -1;
return 0;
}
@@ -0,0 +1,37 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _LEDS_HAL_H
#define _LEDS_HAL_H
#include "mtk_leds_sw.h"
/****************************************************************************
* LED HAL functions
***************************************************************************/
extern void mt_leds_wake_lock_init(void);
extern unsigned int *mt_get_div_array(void);
extern void mt_led_pwm_disable(int pwm_num);
extern int mt_led_set_pwm(int pwm_num, struct nled_setting *led);
extern int mt_led_blink_pmic(enum mt65xx_led_pmic pmic_type,
struct nled_setting *led);
extern int mt_backlight_set_pwm(int pwm_num, u32 level, u32 div,
struct PWM_config *config_data);
extern int mt_brightness_set_pmic(enum mt65xx_led_pmic pmic_type, u32 level,
u32 div);
extern int mt_mt65xx_led_set_cust(struct cust_mt65xx_led *cust, int level);
extern void mt_mt65xx_led_work(struct work_struct *work);
extern void mt_mt65xx_led_set(struct led_classdev *led_cdev,
enum led_brightness level);
extern int mt_mt65xx_blink_set(struct led_classdev *led_cdev,
unsigned long *delay_on, unsigned long *delay_off);
extern struct cust_mt65xx_led *mt_get_cust_led_list(void);
#if defined(CONFIG_BACKLIGHT_SUPPORT_LM3697)
extern int chargepump_set_backlight_level(unsigned int level);
#endif
#endif
@@ -0,0 +1,190 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _LEDS_SW_H
#define _LEDS_SW_H
/******************************************************************************
* LED & Backlight type defination
*****************************************************************************/
enum mt65xx_led_type {
MT65XX_LED_TYPE_RED = 0,
MT65XX_LED_TYPE_GREEN,
MT65XX_LED_TYPE_BLUE,
MT65XX_LED_TYPE_JOGBALL,
MT65XX_LED_TYPE_KEYBOARD,
MT65XX_LED_TYPE_BUTTON,
MT65XX_LED_TYPE_LCD,
MT65XX_LED_TYPE_TOTAL,
};
enum mt65xx_led_mode {
MT65XX_LED_MODE_NONE,
MT65XX_LED_MODE_PWM,
MT65XX_LED_MODE_GPIO,
MT65XX_LED_MODE_PMIC,
MT65XX_LED_MODE_CUST_LCM,
MT65XX_LED_MODE_CUST_BLS_PWM
};
/******************************************************************************
* for backlight
*****************************************************************************/
/* backlight call back function */
typedef int (*cust_brightness_set) (int level, int div);
typedef int (*cust_set_brightness) (int level);
/* 10bit backlight level */
#define LED_INCREASE_LED_LEVEL_MTKPATCH
#ifdef LED_INCREASE_LED_LEVEL_MTKPATCH
#define MT_LED_INTERNAL_LEVEL_BIT_CNT 10
#endif
/******************************************************************************
* for PMIC
*****************************************************************************/
enum mt65xx_led_pmic {
MT65XX_LED_PMIC_LCD_ISINK = 0,
MT65XX_LED_PMIC_NLED_ISINK_MIN = MT65XX_LED_PMIC_LCD_ISINK,
MT65XX_LED_PMIC_NLED_ISINK0,
MT65XX_LED_PMIC_NLED_ISINK1,
MT65XX_LED_PMIC_NLED_ISINK2,
MT65XX_LED_PMIC_NLED_ISINK3,
MT65XX_LED_PMIC_NLED_ISINK_MAX,
};
enum MT65XX_PMIC_ISINK_MODE {
ISINK_PWM_MODE = 0,
ISINK_BREATH_MODE = 1,
ISINK_REGISTER_MODE = 2
};
enum MT65XX_PMIC_ISINK_STEP {
ISINK_0 = 0, /* 4mA */
ISINK_1 = 1, /* 8mA */
ISINK_2 = 2, /* 12mA */
ISINK_3 = 3, /* 16mA */
ISINK_4 = 4, /* 20mA */
ISINK_5 = 5 /* 24mA */
};
enum MT65XX_PMIC_ISINK_FSEL {
/* 32K clock */
ISINK_1KHZ = 0,
ISINK_200HZ = 4,
ISINK_5HZ = 199,
ISINK_2HZ = 499,
ISINK_1HZ = 999,
ISINK_05HZ = 1999,
ISINK_02HZ = 4999,
ISINK_01HZ = 9999,
/* 2M clock */
ISINK_2M_20KHZ = 2,
ISINK_2M_1KHZ = 61,
ISINK_2M_200HZ = 311,
ISINK_2M_5HZ = 12499,
ISINK_2M_2HZ = 31249,
ISINK_2M_1HZ = 62499,
/* 128K clock */
ISINK_128K_500HZ = 0,
ISINK_128K_256HZ = 1,
ISINK_128K_167HZ = 2,
ISINK_128K_128HZ = 3,
ISINK_128K_100HZ = 4,
ISINK_128K_83HZ = 5,
ISINK_128K_50HZ = 9,
ISINK_128K_17HZ = 28,
};
/******************************************************************************
* for PWM
*****************************************************************************/
/* the min frequence when use old mode pwm by kHz */
#define MIN_FRE_OLD_PWM 32
#define BACKLIGHT_LEVEL_PWM_64_FIFO_MODE_SUPPORT 64
#define BACKLIGHT_LEVEL_PWM_256_SUPPORT 256
#define BACKLIGHT_LEVEL_PWM_MODE_CONFIG BACKLIGHT_LEVEL_PWM_256_SUPPORT
static inline unsigned int Cust_GetBacklightLevelSupport_byPWM(void)
{
return BACKLIGHT_LEVEL_PWM_MODE_CONFIG;
}
static inline unsigned int brightness_mapping(unsigned int level)
{
unsigned int mapped_level;
mapped_level = level;
return mapped_level;
}
struct PWM_config {
int clock_source;
int div;
int low_duration;
int High_duration;
bool pmic_pad;
};
/****************************************************************************
* sw data structures
***************************************************************************/
/**
* led customization data structure
* name : must the same as lights HAL
* mode : control mode
* data :
* PWM: pwm number
* GPIO: gpio id
* PMIC: enum mt65xx_led_pmic
* CUST: custom set brightness function pointer
* config_data: pwm config data
*/
struct cust_mt65xx_led {
char *name;
enum mt65xx_led_mode mode;
long data;
struct PWM_config config_data;
};
/**
* led device node structure with mtk extentions
* cdev: common led device structure
* cust: customization data from device tree
* work: workqueue for specialfied led device
* level: brightness level
* delay_on: on time if led is blinking
* delay_off: off time if led is blinking
*/
struct mt65xx_led_data {
struct led_classdev cdev;
struct cust_mt65xx_led cust;
struct work_struct work;
int level;
int delay_on;
int delay_off;
};
/**
* LED Variable Settings
* nled_mode: 0, off; 1, on; 2, blink
* blink_on_time: on time if led is blinking
* blink_off_time: off time if led is blinking
*/
#define NLED_OFF 0
#define NLED_ON 1
#define NLED_BLINK 2
struct nled_setting {
u8 nled_mode;
u32 blink_on_time;
u32 blink_off_time;
};
#endif /* _LEDS_SW_H */
@@ -0,0 +1,5 @@
# SPDX-License-Identifier: GPL-2.0
obj-$(CONFIG_MTK_LEDS) := mtk_leds.o
ccflags-y += -I$(srctree)/drivers/misc/mediatek/video/include
@@ -0,0 +1,894 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2018 MediaTek Inc.
*
*/
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/delay.h>
#include <linux/string.h>
#include <linux/ctype.h>
#include <linux/leds.h>
#include <linux/of.h>
/* #include <linux/leds-mt65xx.h> */
#include <linux/workqueue.h>
#include <linux/pm_wakeup.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <mtk_leds_sw.h>
#ifdef CONFIG_MTK_AAL_SUPPORT
#include <ddp_aal.h>
/* #include <linux/aee.h> */
#endif
#include <ddp_gamma.h>
#ifdef CONFIG_MTK_PWM
#include <mt-plat/mtk_pwm.h>
static unsigned int backlight_PWM_div_hal = CLK_DIV1;
#else
#define CLK_DIV1 1
#endif
#ifdef CONFIG_MTK_PMIC_NEW_ARCH
#include <mt-plat/upmu_common.h>
#endif
#include "mtk_leds_sw.h"
#include "mtk_leds_hal.h"
#include "ddp_pwm.h"
#include "mtkfb.h"
//#define MET_USER_EVENT_SUPPORT
#ifdef MET_USER_EVENT_SUPPORT
#include <mt-plat/met_drv.h>
#endif
#undef pr_fmt
#define pr_fmt(fmt) KBUILD_MODNAME " %s(%d) :" fmt, __func__, __LINE__
static DEFINE_MUTEX(leds_mutex);
static DEFINE_MUTEX(leds_pmic_mutex);
/****************************************************************************
* variables
***************************************************************************/
/* struct cust_mt65xx_led* bl_setting_hal = NULL; */
static unsigned int bl_brightness_hal = 102;
static unsigned int bl_duty_hal = 21;
static unsigned int bl_div_hal = CLK_DIV1;
static unsigned int bl_frequency_hal = 32000;
/* for button led don't do ISINK disable first time */
static int button_flag_isink1;
struct wakeup_source leds_suspend_lock;
char *leds_name[MT65XX_LED_TYPE_TOTAL] = {
"red",
"green",
"blue",
"jogball-backlight",
"keyboard-backlight",
"button-backlight",
"lcd-backlight",
};
struct cust_mt65xx_led *pled_dtsi;
/*****************PWM *************************************************/
#define PWM_DIV_NUM 8
static unsigned int div_array_hal[PWM_DIV_NUM] = {
1, 2, 4, 8, 16, 32, 64, 128 };
/****************************************************************************
* func:return global variables
***************************************************************************/
static unsigned long long current_t, last_time;
static int count;
static char buffer[4096] = "[BL] Set Backlight directly ";
static void backlight_debug_log(int level, int mappingLevel)
{
unsigned long cur_time_mod = 0;
unsigned long long cur_time_display = 0;
int ret = 0;
current_t = sched_clock();
cur_time_display = current_t;
do_div(cur_time_display, 1000000);
cur_time_mod = do_div(cur_time_display, 1000);
ret = snprintf(buffer + strlen(buffer),
4095 - strlen(buffer), "T:%lld.%ld,L:%d map:%d ",
cur_time_display, cur_time_mod, level, mappingLevel);
count++;
if (ret < 0 || ret >= 4096) {
pr_info("print log error!");
count = 5;
}
if (level == 0 || count >= 5 ||
(current_t - last_time) > 1000000000) {
pr_info("%s", buffer);
count = 0;
buffer[strlen("[BL] Set Backlight directly ")] = '\0';
}
last_time = sched_clock();
}
void mt_leds_wake_lock_init(void)
{
// wakeup_source_init(&leds_suspend_lock, "leds wakelock");
}
unsigned int mt_get_bl_brightness(void)
{
return bl_brightness_hal;
}
unsigned int mt_get_bl_duty(void)
{
return bl_duty_hal;
}
unsigned int mt_get_bl_div(void)
{
return bl_div_hal;
}
unsigned int mt_get_bl_frequency(void)
{
return bl_frequency_hal;
}
unsigned int *mt_get_div_array(void)
{
return &div_array_hal[0];
}
void mt_set_bl_duty(unsigned int level)
{
bl_duty_hal = level;
}
void mt_set_bl_div(unsigned int div)
{
bl_div_hal = div;
}
void mt_set_bl_frequency(unsigned int freq)
{
bl_frequency_hal = freq;
}
struct cust_mt65xx_led *get_cust_led_dtsi(void)
{
struct device_node *led_node = NULL;
bool isSupportDTS = false;
int i, ret;
int mode, data;
int pwm_config[5] = { 0 };
if (pled_dtsi)
goto out;
/* this can allocat an new struct array */
pled_dtsi = kmalloc_array(MT65XX_LED_TYPE_TOTAL,
sizeof(struct cust_mt65xx_led), GFP_KERNEL);
if (pled_dtsi == NULL)
goto out;
for (i = 0; i < MT65XX_LED_TYPE_TOTAL; i++) {
char node_name[32] = "mediatek,";
if (strlen(node_name) + strlen(leds_name[i]) + 1 >
sizeof(node_name)) {
pr_info("buffer for %s%s not enough\n",
node_name, leds_name[i]);
pled_dtsi[i].mode = 0;
pled_dtsi[i].data = -1;
continue;
}
pled_dtsi[i].name = leds_name[i];
led_node = of_find_compatible_node(NULL, NULL,
strncat(node_name, leds_name[i],
sizeof(node_name) - strlen(node_name) - 1));
if (!led_node) {
pr_debug("Cannot find LED node from dts\n");
pled_dtsi[i].mode = 0;
pled_dtsi[i].data = -1;
} else {
isSupportDTS = true;
ret =
of_property_read_u32(led_node, "led_mode",
&mode);
if (!ret) {
pled_dtsi[i].mode = mode;
pr_info
("The %s's led mode is : %d\n",
pled_dtsi[i].name,
pled_dtsi[i].mode);
} else {
pr_info
("led dts can not get led mode");
pled_dtsi[i].mode = 0;
}
ret =
of_property_read_u32(led_node, "data",
&data);
if (!ret) {
pled_dtsi[i].data = data;
pr_info
("The %s's led data is : %ld\n",
pled_dtsi[i].name,
pled_dtsi[i].data);
} else {
pr_info
("led dts can not get led data");
pled_dtsi[i].data = -1;
}
ret =
of_property_read_u32_array(led_node,
"pwm_config",
pwm_config,
ARRAY_SIZE
(pwm_config));
if (!ret) {
pr_debug("%s's pwm cfg %d %d %d %d %d\n",
pled_dtsi[i].name, pwm_config[0],
pwm_config[1], pwm_config[2],
pwm_config[3], pwm_config[4]);
pled_dtsi[i].config_data.clock_source =
pwm_config[0];
pled_dtsi[i].config_data.div =
pwm_config[1];
pled_dtsi[i].config_data.low_duration =
pwm_config[2];
pled_dtsi[i].config_data.High_duration =
pwm_config[3];
pled_dtsi[i].config_data.pmic_pad =
pwm_config[4];
} else
pr_info
("led dts can't get pwm config\n");
switch (pled_dtsi[i].mode) {
case MT65XX_LED_MODE_CUST_LCM:
#if defined(CONFIG_BACKLIGHT_SUPPORT_LM3697)
pled_dtsi[i].data =
(long)chargepump_set_backlight_level;
pr_info
("BL set by chargepump\n");
#else
pled_dtsi[i].data =
(long)mtkfb_set_backlight_level;
#endif /* CONFIG_BACKLIGHT_SUPPORT_LM3697 */
pr_info
("kernel:the BL hw mode is LCM.\n");
break;
case MT65XX_LED_MODE_CUST_BLS_PWM:
pled_dtsi[i].data =
(long)disp_bls_set_backlight;
pr_info
("kernel:the BL hw mode is BLS.\n");
break;
default:
break;
}
}
}
if (!isSupportDTS) {
kfree(pled_dtsi);
pled_dtsi = NULL;
}
out:
return pled_dtsi;
}
struct cust_mt65xx_led *mt_get_cust_led_list(void)
{
struct cust_mt65xx_led *cust_led_list = get_cust_led_dtsi();
return cust_led_list;
}
/****************************************************************************
* internal functions
***************************************************************************/
static int brightness_mapto64(int level)
{
if (level < 30)
return (level >> 1) + 7;
else if (level <= 120)
return (level >> 2) + 14;
else if (level <= 160)
return level / 5 + 20;
else
return (level >> 3) + 33;
}
#ifdef CONFIG_MTK_PWM
static int time_array_hal[PWM_DIV_NUM] = {
256, 512, 1024, 2048, 4096, 8192, 16384, 32768 };
static int find_time_index(int time)
{
int index = 0;
while (index < 8) {
if (time < time_array_hal[index])
return index;
index++;
}
return PWM_DIV_NUM - 1;
}
#endif
int mt_led_set_pwm(int pwm_num, struct nled_setting *led)
{
#ifdef CONFIG_MTK_PWM
struct pwm_spec_config pwm_setting;
int time_index = 0;
memset(&pwm_setting, 0, sizeof(struct pwm_spec_config));
pwm_setting.pwm_no = pwm_num;
pwm_setting.mode = PWM_MODE_OLD;
pr_debug("led_set_pwm: mode=%d,pwm_no=%d\n", led->nled_mode,
pwm_num);
/* We won't choose 32K to be the clock src of old mode because of
* system performance. The setting here will be clock src = 26MHz,
* CLKSEL = 26M/1625 (i.e. 16K)
*/
pwm_setting.clk_src = PWM_CLK_OLD_MODE_32K;
pwm_setting.pmic_pad = 0;
switch (led->nled_mode) {
/* Actually, the setting still can not to turn off NLED. We should
* disable PWM to turn off NLED.
*/
case NLED_OFF:
pwm_setting.PWM_MODE_OLD_REGS.THRESH = 0;
pwm_setting.clk_div = CLK_DIV1;
pwm_setting.PWM_MODE_OLD_REGS.DATA_WIDTH = 100 / 2;
break;
case NLED_ON:
pwm_setting.PWM_MODE_OLD_REGS.THRESH = 30 / 2;
pwm_setting.clk_div = CLK_DIV1;
pwm_setting.PWM_MODE_OLD_REGS.DATA_WIDTH = 100 / 2;
break;
case NLED_BLINK:
pr_debug("LED blink on time = %d offtime = %d\n",
led->blink_on_time, led->blink_off_time);
time_index =
find_time_index(led->blink_on_time + led->blink_off_time);
pr_debug("LED div is %d\n", time_index);
pwm_setting.clk_div = time_index;
pwm_setting.PWM_MODE_OLD_REGS.DATA_WIDTH =
(led->blink_on_time +
led->blink_off_time) * MIN_FRE_OLD_PWM /
div_array_hal[time_index];
pwm_setting.PWM_MODE_OLD_REGS.THRESH =
(led->blink_on_time * 100) / (led->blink_on_time +
led->blink_off_time);
break;
default:
pr_debug("Invalid nled mode\n");
return -1;
}
pwm_setting.PWM_MODE_FIFO_REGS.IDLE_VALUE = 0;
pwm_setting.PWM_MODE_FIFO_REGS.GUARD_VALUE = 0;
pwm_setting.PWM_MODE_FIFO_REGS.GDURATION = 0;
pwm_setting.PWM_MODE_FIFO_REGS.WAVE_NUM = 0;
pwm_set_spec_config(&pwm_setting);
#endif
return 0;
}
#define PMIC_PERIOD_NUM 8
int pmic_period_array[] = { 2, 4, 6, 8, 10, 12, 20, 60 };
int pmic_freqsel_array[] = { 0, 1, 2, 3, 4, 5, 9, 28 };
static int find_time_index_pmic(int time_ms)
{
int i;
for (i = 0; i < PMIC_PERIOD_NUM; i++) {
if (time_ms <= pmic_period_array[i])
return i;
}
return PMIC_PERIOD_NUM - 1;
}
int mt_led_blink_pmic(enum mt65xx_led_pmic pmic_type, struct nled_setting *led)
{
int time_index = 0;
int duty = 0;
pr_debug("led_blink_pmic: pmic_type=%d\n", pmic_type);
if (led->nled_mode != NLED_BLINK)
return -1;
pr_debug("LED blink on time = %d offtime = %d\n",
led->blink_on_time, led->blink_off_time);
time_index =
find_time_index_pmic(led->blink_on_time + led->blink_off_time);
pr_debug("LED index is %d freqsel=%d\n", time_index,
pmic_freqsel_array[time_index]);
duty = 256 * led->blink_on_time / (led->blink_on_time +
led->blink_off_time);
if (pmic_type > MT65XX_LED_PMIC_NLED_ISINK_MIN &&
pmic_type < MT65XX_LED_PMIC_NLED_ISINK_MAX)
#ifdef CONFIG_MTK_PMIC_CHIP_MT6357
/* Disable power down */
pmic_set_register_value(PMIC_RG_DRV_128K_CK_PDN, 0x0);
#endif
switch (pmic_type) {
#ifdef CONFIG_MTK_PMIC_CHIP_MT6357
case MT65XX_LED_PMIC_NLED_ISINK1:
pmic_set_register_value(PMIC_ISINK_CH1_EN, NLED_OFF);
pmic_set_register_value(PMIC_RG_DRV_ISINK1_CK_PDN, 0);
pmic_set_register_value(PMIC_ISINK_CH1_MODE, ISINK_PWM_MODE);
pmic_set_register_value(PMIC_ISINK_CH1_STEP, ISINK_3);
pmic_set_register_value(PMIC_ISINK_DIM1_DUTY, duty);
pmic_set_register_value(PMIC_ISINK_DIM1_FSEL,
pmic_freqsel_array[time_index]);
pmic_set_register_value(PMIC_ISINK_CH1_BIAS_EN, NLED_ON);
pmic_set_register_value(PMIC_ISINK_CHOP1_EN, NLED_ON);
pmic_set_register_value(PMIC_ISINK_CH1_EN, NLED_ON);
break;
#endif
default:
pr_debug("[LEDS] pmic_type %d is not handled\n", pmic_type);
break;
}
return 0;
}
int mt_backlight_set_pwm(int pwm_num, u32 level, u32 div,
struct PWM_config *config_data)
{
#ifdef CONFIG_MTK_PWM
struct pwm_spec_config pwm_setting;
unsigned int BacklightLevelSupport =
Cust_GetBacklightLevelSupport_byPWM();
pwm_setting.pwm_no = pwm_num;
if (BacklightLevelSupport == BACKLIGHT_LEVEL_PWM_256_SUPPORT)
pwm_setting.mode = PWM_MODE_OLD;
else
pwm_setting.mode = PWM_MODE_FIFO;
pwm_setting.pmic_pad = config_data->pmic_pad;
if (config_data->div) {
pwm_setting.clk_div = config_data->div;
backlight_PWM_div_hal = config_data->div;
} else
pwm_setting.clk_div = div;
if (BacklightLevelSupport == BACKLIGHT_LEVEL_PWM_256_SUPPORT) {
/* PWM_CLK_OLD_MODE_32K is block/1625 = 26M/1625 = 16KHz @ MT6571 */
if (config_data->clock_source)
pwm_setting.clk_src = PWM_CLK_OLD_MODE_BLOCK;
else
pwm_setting.clk_src = PWM_CLK_OLD_MODE_32K;
pwm_setting.PWM_MODE_OLD_REGS.IDLE_VALUE = 0;
pwm_setting.PWM_MODE_OLD_REGS.GUARD_VALUE = 0;
pwm_setting.PWM_MODE_OLD_REGS.GDURATION = 0;
pwm_setting.PWM_MODE_OLD_REGS.WAVE_NUM = 0;
/* 256 level */
pwm_setting.PWM_MODE_OLD_REGS.DATA_WIDTH = 255;
pwm_setting.PWM_MODE_OLD_REGS.THRESH = level;
pr_debug("[LEDS][%d]backlight_set_pwm:duty is %d/%d\n",
BacklightLevelSupport, level,
pwm_setting.PWM_MODE_OLD_REGS.DATA_WIDTH);
pr_debug("[LEDS][%d]backlight_set_pwm:clk_src/div is %d%d\n",
BacklightLevelSupport, pwm_setting.clk_src,
pwm_setting.clk_div);
if (level > 0 && level < 256) {
pwm_set_spec_config(&pwm_setting);
pr_debug
("[LEDS][%d]old mode: thres/data_width is %d/%d\n",
BacklightLevelSupport,
pwm_setting.PWM_MODE_OLD_REGS.THRESH,
pwm_setting.PWM_MODE_OLD_REGS.DATA_WIDTH);
} else {
pr_debug("[LEDS][%d]Error level in backlight\n",
BacklightLevelSupport);
mt_pwm_disable(pwm_setting.pwm_no,
config_data->pmic_pad);
}
return 0;
} else {
if (config_data->clock_source) {
pwm_setting.clk_src = PWM_CLK_NEW_MODE_BLOCK;
} else {
pwm_setting.clk_src =
PWM_CLK_NEW_MODE_BLOCK_DIV_BY_1625;
}
if (config_data->High_duration && config_data->low_duration) {
pwm_setting.PWM_MODE_FIFO_REGS.HDURATION =
config_data->High_duration;
pwm_setting.PWM_MODE_FIFO_REGS.LDURATION =
pwm_setting.PWM_MODE_FIFO_REGS.HDURATION;
} else {
pwm_setting.PWM_MODE_FIFO_REGS.HDURATION = 4;
pwm_setting.PWM_MODE_FIFO_REGS.LDURATION = 4;
}
pwm_setting.PWM_MODE_FIFO_REGS.IDLE_VALUE = 0;
pwm_setting.PWM_MODE_FIFO_REGS.GUARD_VALUE = 0;
pwm_setting.PWM_MODE_FIFO_REGS.STOP_BITPOS_VALUE = 31;
pwm_setting.PWM_MODE_FIFO_REGS.GDURATION =
(pwm_setting.PWM_MODE_FIFO_REGS.HDURATION + 1) * 32 - 1;
pwm_setting.PWM_MODE_FIFO_REGS.WAVE_NUM = 0;
pr_debug("%s :duty is %d\n", __func__, level);
pr_debug
("[LEDS]clk_src/div/high/low is %d%d%d%d\n",
pwm_setting.clk_src, pwm_setting.clk_div,
pwm_setting.PWM_MODE_FIFO_REGS.HDURATION,
pwm_setting.PWM_MODE_FIFO_REGS.LDURATION);
if (level > 0 && level <= 32) {
pwm_setting.PWM_MODE_FIFO_REGS.GUARD_VALUE = 0;
pwm_setting.PWM_MODE_FIFO_REGS.SEND_DATA0 =
(1 << level) - 1;
pwm_set_spec_config(&pwm_setting);
} else if (level > 32 && level <= 64) {
pwm_setting.PWM_MODE_FIFO_REGS.GUARD_VALUE = 1;
level -= 32;
pwm_setting.PWM_MODE_FIFO_REGS.SEND_DATA0 =
(1 << level) - 1;
pwm_set_spec_config(&pwm_setting);
} else {
pr_debug("[LEDS]Error level in backlight\n");
mt_pwm_disable(pwm_setting.pwm_no,
config_data->pmic_pad);
}
return 0;
}
#endif
return 0;
}
void mt_led_pwm_disable(int pwm_num)
{
#ifdef CONFIG_MTK_PWM
struct cust_mt65xx_led *cust_led_list = get_cust_led_dtsi();
mt_pwm_disable(pwm_num, cust_led_list->config_data.pmic_pad);
#endif
}
void mt_backlight_set_pwm_duty(int pwm_num, u32 level, u32 div,
struct PWM_config *config_data)
{
mt_backlight_set_pwm(pwm_num, level, div, config_data);
}
void mt_backlight_set_pwm_div(int pwm_num, u32 level, u32 div,
struct PWM_config *config_data)
{
mt_backlight_set_pwm(pwm_num, level, div, config_data);
}
void mt_backlight_get_pwm_fsel(unsigned int bl_div,
unsigned int *bl_frequency)
{
}
void mt_store_pwm_register(unsigned int addr, unsigned int value)
{
}
unsigned int mt_show_pwm_register(unsigned int addr)
{
return 0;
}
int mt_brightness_set_pmic(enum mt65xx_led_pmic pmic_type,
u32 level, u32 div)
{
static bool first_time = true;
pr_debug("PMIC#%d:%d\n", pmic_type, level);
mutex_lock(&leds_pmic_mutex);
if (pmic_type == MT65XX_LED_PMIC_NLED_ISINK1) {
/* button flag ==0, means this ISINK is not for
* button backlight
*/
if ((button_flag_isink1 == 0) && (first_time == true)) {
/* sw workround for sync leds status */
first_time = false;
}
#ifdef CONFIG_MTK_PMIC_CHIP_MT6357
pmic_set_register_value(PMIC_RG_DRV_128K_CK_PDN, 0x0);
pmic_set_register_value(PMIC_RG_DRV_ISINK1_CK_PDN, 0);
pmic_set_register_value(PMIC_ISINK_CH1_MODE, ISINK_PWM_MODE);
pmic_set_register_value(PMIC_ISINK_CH1_STEP, ISINK_3);
pmic_set_register_value(PMIC_ISINK_DIM1_DUTY, 255);
pmic_set_register_value(PMIC_ISINK_DIM1_FSEL, ISINK_128K_500HZ);
pmic_set_register_value(PMIC_ISINK_CH1_BIAS_EN, NLED_ON);
pmic_set_register_value(PMIC_ISINK_CHOP1_EN, NLED_ON);
if (level)
pmic_set_register_value(PMIC_ISINK_CH1_EN, NLED_ON);
else
pmic_set_register_value(PMIC_ISINK_CH1_EN, NLED_OFF);
#endif
mutex_unlock(&leds_pmic_mutex);
return 0;
}
mutex_unlock(&leds_pmic_mutex);
return -1;
}
int mt_brightness_set_pmic_duty_store(u32 level, u32 div)
{
return -1;
}
int mt_mt65xx_led_set_cust(struct cust_mt65xx_led *cust, int level)
{
static bool button_flag;
struct nled_setting led_tmp_setting = { 0, 0, 0 };
int tmp_level = level;
unsigned int BacklightLevelSupport =
Cust_GetBacklightLevelSupport_byPWM();
switch (cust->mode) {
case MT65XX_LED_MODE_PWM:
if (strcmp(cust->name, "lcd-backlight") == 0) {
bl_brightness_hal = level;
if (level == 0) {
#ifdef CONFIG_MTK_PWM
mt_pwm_disable(cust->data,
cust->config_data.pmic_pad);
#endif
} else {
if (BacklightLevelSupport ==
BACKLIGHT_LEVEL_PWM_256_SUPPORT)
level = brightness_mapping(tmp_level);
else
level = brightness_mapto64(tmp_level);
mt_backlight_set_pwm(cust->data, level,
bl_div_hal,
&cust->config_data);
}
bl_duty_hal = level;
} else {
if (level == 0) {
led_tmp_setting.nled_mode = NLED_OFF;
mt_led_set_pwm(cust->data, &led_tmp_setting);
#ifdef CONFIG_MTK_PWM
mt_pwm_disable(cust->data,
cust->config_data.pmic_pad);
#endif
} else {
led_tmp_setting.nled_mode = NLED_ON;
mt_led_set_pwm(cust->data, &led_tmp_setting);
}
}
return 1;
case MT65XX_LED_MODE_GPIO:
pr_debug("brightness_set_cust:go GPIO mode!!!!!\n");
return ((cust_set_brightness) (cust->data)) (level);
case MT65XX_LED_MODE_PMIC:
/* for button baclight used SINK channel, when set button ISINK,
* don't do disable other ISINK channel
*/
if ((strcmp(cust->name, "button-backlight") == 0)) {
if (button_flag == false) {
switch (cust->data) {
case MT65XX_LED_PMIC_NLED_ISINK1:
button_flag_isink1 = 1;
break;
default:
break;
}
button_flag = true;
}
}
return mt_brightness_set_pmic(cust->data, level, bl_div_hal);
case MT65XX_LED_MODE_CUST_LCM:
if (strcmp(cust->name, "lcd-backlight") == 0)
bl_brightness_hal = level;
pr_debug("brightness_set_cust:backlight control by LCM\n");
/* warning for this API revork */
return ((cust_brightness_set) (cust->data)) (level, bl_div_hal);
case MT65XX_LED_MODE_CUST_BLS_PWM:
if (strcmp(cust->name, "lcd-backlight") == 0)
bl_brightness_hal = level;
#ifdef MET_USER_EVENT_SUPPORT
if (enable_met_backlight_tag())
output_met_backlight_tag(level);
#endif
return ((cust_set_brightness) (cust->data)) (level);
case MT65XX_LED_MODE_NONE:
default:
break;
}
return -1;
}
void mt_mt65xx_led_work(struct work_struct *work)
{
struct mt65xx_led_data *led_data =
container_of(work, struct mt65xx_led_data, work);
pr_debug("%s:%d\n", led_data->cust.name, led_data->level);
mutex_lock(&leds_mutex);
mt_mt65xx_led_set_cust(&led_data->cust, led_data->level);
mutex_unlock(&leds_mutex);
}
void mt_mt65xx_led_set(struct led_classdev *led_cdev, enum led_brightness level)
{
struct mt65xx_led_data *led_data =
container_of(led_cdev, struct mt65xx_led_data, cdev);
/* unsigned long flags; */
/* spin_lock_irqsave(&leds_lock, flags); */
#ifdef CONFIG_MTK_AAL_SUPPORT
if (led_data->level != level) {
led_data->level = level;
if (strcmp(led_data->cust.name, "lcd-backlight") != 0) {
pr_debug("Set NLED directly %d at time %lu\n",
led_data->level, jiffies);
schedule_work(&led_data->work);
} else {
if (level != 0
&& level * CONFIG_LIGHTNESS_MAPPING_VALUE < 255) {
level = 1;
} else {
level =
(level * CONFIG_LIGHTNESS_MAPPING_VALUE) /
255;
}
backlight_debug_log(led_data->level, level);
disp_pq_notify_backlight_changed((((1 <<
MT_LED_INTERNAL_LEVEL_BIT_CNT)
- 1) * level +
127) / 255);
disp_aal_notify_backlight_changed((((1 <<
MT_LED_INTERNAL_LEVEL_BIT_CNT)
- 1) * level +
127) / 255);
}
}
#else
/* do something only when level is changed */
if (led_data->level != level) {
led_data->level = level;
if (strcmp(led_data->cust.name, "lcd-backlight") != 0) {
pr_debug("Set NLED directly %d at time %lu\n",
led_data->level, jiffies);
schedule_work(&led_data->work);
} else {
if (level != 0
&& level * CONFIG_LIGHTNESS_MAPPING_VALUE < 255) {
level = 1;
} else {
level =
(level * CONFIG_LIGHTNESS_MAPPING_VALUE) /
255;
}
backlight_debug_log(led_data->level, level);
disp_pq_notify_backlight_changed((((1 <<
MT_LED_INTERNAL_LEVEL_BIT_CNT)
- 1) * level +
127) / 255);
if (led_data->cust.mode == MT65XX_LED_MODE_CUST_BLS_PWM)
mt_mt65xx_led_set_cust(&led_data->cust,
((((1 << MT_LED_INTERNAL_LEVEL_BIT_CNT)
- 1) * level + 127) / 255));
else
mt_mt65xx_led_set_cust(&led_data->cust, level);
}
}
/* spin_unlock_irqrestore(&leds_lock, flags); */
#endif
/* if(0!=aee_kernel_Powerkey_is_press()) */
/* aee_kernel_wdt_kick_Powkey_api("mt_mt65xx_led_set",WDT_SETBY_Backlight); */
}
int mt_mt65xx_blink_set(struct led_classdev *led_cdev,
unsigned long *delay_on, unsigned long *delay_off)
{
struct mt65xx_led_data *led_data =
container_of(led_cdev, struct mt65xx_led_data, cdev);
static int got_wake_lock;
struct nled_setting nled_tmp_setting = { 0, 0, 0 };
/* only allow software blink when delay_on or delay_off changed */
if (*delay_on != led_data->delay_on
|| *delay_off != led_data->delay_off) {
led_data->delay_on = *delay_on;
led_data->delay_off = *delay_off;
if (led_data->delay_on && led_data->delay_off) {
led_data->level = 255;
/* AP PWM all support OLD mode */
if (led_data->cust.mode == MT65XX_LED_MODE_PWM) {
nled_tmp_setting.nled_mode = NLED_BLINK;
nled_tmp_setting.blink_off_time =
led_data->delay_off;
nled_tmp_setting.blink_on_time =
led_data->delay_on;
mt_led_set_pwm(led_data->cust.data,
&nled_tmp_setting);
return 0;
} else if ((led_data->cust.mode == MT65XX_LED_MODE_PMIC)
&& (led_data->cust.data ==
MT65XX_LED_PMIC_NLED_ISINK1)) {
nled_tmp_setting.nled_mode = NLED_BLINK;
nled_tmp_setting.blink_off_time =
led_data->delay_off;
nled_tmp_setting.blink_on_time =
led_data->delay_on;
mt_led_blink_pmic(led_data->cust.data,
&nled_tmp_setting);
return 0;
} else if (!got_wake_lock) {
__pm_stay_awake(&leds_suspend_lock);
got_wake_lock = 1;
}
} else if (!led_data->delay_on && !led_data->delay_off) {
/* AP PWM all support OLD mode */
if (led_data->cust.mode == MT65XX_LED_MODE_PWM) {
nled_tmp_setting.nled_mode = NLED_OFF;
mt_led_set_pwm(led_data->cust.data,
&nled_tmp_setting);
return 0;
} else if ((led_data->cust.mode == MT65XX_LED_MODE_PMIC)
&& (led_data->cust.data ==
MT65XX_LED_PMIC_NLED_ISINK1)) {
mt_brightness_set_pmic(led_data->cust.data, 0,
0);
return 0;
} else if (got_wake_lock) {
__pm_relax(&leds_suspend_lock);
got_wake_lock = 0;
}
}
return -1;
}
/* delay_on and delay_off are not changed */
return 0;
}
@@ -0,0 +1,56 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2015 MediaTek Inc.
*
*/
#ifndef _LEDS_HAL_H
#define _LEDS_HAL_H
#include "mtk_leds_sw.h"
/****************************************************************************
* LED HAL functions
***************************************************************************/
extern void mt_leds_wake_lock_init(void);
extern unsigned int mt_get_bl_brightness(void);
extern unsigned int mt_get_bl_duty(void);
extern unsigned int mt_get_bl_div(void);
extern unsigned int mt_get_bl_frequency(void);
extern unsigned int *mt_get_div_array(void);
extern void mt_set_bl_duty(unsigned int level);
extern void mt_set_bl_div(unsigned int div);
extern void mt_set_bl_frequency(unsigned int freq);
extern void mt_led_pwm_disable(int pwm_num);
extern int mt_brightness_set_pmic_duty_store(u32 level, u32 div);
extern void mt_backlight_set_pwm_duty(int pwm_num, u32 level, u32 div,
struct PWM_config *config_data);
extern void mt_backlight_set_pwm_div(int pwm_num, u32 level, u32 div,
struct PWM_config *config_data);
extern void mt_backlight_get_pwm_fsel(unsigned int bl_div,
unsigned int *bl_frequency);
extern void mt_store_pwm_register(unsigned int addr, unsigned int value);
extern unsigned int mt_show_pwm_register(unsigned int addr);
extern int mt_led_set_pwm(int pwm_num, struct nled_setting *led);
extern int mt_led_blink_pmic(enum mt65xx_led_pmic pmic_type,
struct nled_setting *led);
extern int mt_backlight_set_pwm(int pwm_num, u32 level, u32 div,
struct PWM_config *config_data);
extern int mt_brightness_set_pmic(enum mt65xx_led_pmic pmic_type, u32 level,
u32 div);
extern int mt_mt65xx_led_set_cust(struct cust_mt65xx_led *cust, int level);
extern void mt_mt65xx_led_work(struct work_struct *work);
extern void mt_mt65xx_led_set(struct led_classdev *led_cdev,
enum led_brightness level);
extern int mt_mt65xx_blink_set(struct led_classdev *led_cdev,
unsigned long *delay_on,
unsigned long *delay_off);
extern struct cust_mt65xx_led *mt_get_cust_led_list(void);
#if defined(CONFIG_BACKLIGHT_SUPPORT_LM3697)
extern int chargepump_set_backlight_level(unsigned int level);
#endif /* CONFIG_BACKLIGHT_SUPPORT_LM3697 */
#endif
@@ -0,0 +1,192 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2018 MediaTek Inc.
*
*/
#ifndef _LEDS_SW_H
#define _LEDS_SW_H
/******************************************************************************
* LED & Backlight type defination
*****************************************************************************/
enum mt65xx_led_type {
MT65XX_LED_TYPE_RED = 0,
MT65XX_LED_TYPE_GREEN,
MT65XX_LED_TYPE_BLUE,
MT65XX_LED_TYPE_JOGBALL,
MT65XX_LED_TYPE_KEYBOARD,
MT65XX_LED_TYPE_BUTTON,
MT65XX_LED_TYPE_LCD,
MT65XX_LED_TYPE_TOTAL,
};
enum mt65xx_led_mode {
MT65XX_LED_MODE_NONE,
MT65XX_LED_MODE_PWM,
MT65XX_LED_MODE_GPIO,
MT65XX_LED_MODE_PMIC,
MT65XX_LED_MODE_CUST_LCM,
MT65XX_LED_MODE_CUST_BLS_PWM
};
/******************************************************************************
* for backlight
*****************************************************************************/
/* backlight call back function */
typedef int (*cust_brightness_set) (int level, int div);
typedef int (*cust_set_brightness) (int level);
/* 10bit backlight level */
#define LED_INCREASE_LED_LEVEL_MTKPATCH
#ifdef LED_INCREASE_LED_LEVEL_MTKPATCH
#define MT_LED_INTERNAL_LEVEL_BIT_CNT 10
#endif
/******************************************************************************
* for PMIC
*****************************************************************************/
enum mt65xx_led_pmic {
MT65XX_LED_PMIC_LCD_ISINK = 0,
MT65XX_LED_PMIC_NLED_ISINK_MIN = MT65XX_LED_PMIC_LCD_ISINK,
MT65XX_LED_PMIC_NLED_ISINK0,
MT65XX_LED_PMIC_NLED_ISINK1,
MT65XX_LED_PMIC_NLED_ISINK2,
MT65XX_LED_PMIC_NLED_ISINK3,
MT65XX_LED_PMIC_NLED_ISINK_MAX,
};
enum MT65XX_PMIC_ISINK_MODE {
ISINK_PWM_MODE = 0,
ISINK_BREATH_MODE = 1,
ISINK_REGISTER_MODE = 2
};
enum MT65XX_PMIC_ISINK_STEP {
ISINK_0 = 0, /* 4mA */
ISINK_1 = 1, /* 8mA */
ISINK_2 = 2, /* 12mA */
ISINK_3 = 3, /* 16mA */
ISINK_4 = 4, /* 20mA */
ISINK_5 = 5 /* 24mA */
};
enum MT65XX_PMIC_ISINK_FSEL {
/* 32K clock */
ISINK_1KHZ = 0,
ISINK_200HZ = 4,
ISINK_5HZ = 199,
ISINK_2HZ = 499,
ISINK_1HZ = 999,
ISINK_05HZ = 1999,
ISINK_02HZ = 4999,
ISINK_01HZ = 9999,
/* 2M clock */
ISINK_2M_20KHZ = 2,
ISINK_2M_1KHZ = 61,
ISINK_2M_200HZ = 311,
ISINK_2M_5HZ = 12499,
ISINK_2M_2HZ = 31249,
ISINK_2M_1HZ = 62499,
/* 128K clock */
ISINK_128K_500HZ = 0,
ISINK_128K_256HZ = 1,
ISINK_128K_167HZ = 2,
ISINK_128K_128HZ = 3,
ISINK_128K_100HZ = 4,
ISINK_128K_83HZ = 5,
ISINK_128K_50HZ = 9,
ISINK_128K_17HZ = 28,
};
/******************************************************************************
* for PWM
*****************************************************************************/
#define MIN_FRE_OLD_PWM 32/* the min frequence when use old mode pwm by kHz */
#define BACKLIGHT_LEVEL_PWM_64_FIFO_MODE_SUPPORT 64
#define BACKLIGHT_LEVEL_PWM_256_SUPPORT 256
#define BACKLIGHT_LEVEL_PWM_MODE_CONFIG BACKLIGHT_LEVEL_PWM_256_SUPPORT
static inline unsigned int Cust_GetBacklightLevelSupport_byPWM(void)
{
return BACKLIGHT_LEVEL_PWM_MODE_CONFIG;
}
static inline unsigned int brightness_mapping(unsigned int level)
{
unsigned int mapped_level;
mapped_level = level;
return mapped_level;
}
struct PWM_config {
int clock_source;
int div;
int low_duration;
int High_duration;
bool pmic_pad;
};
/****************************************************************************
* sw data structures
***************************************************************************/
/**
* led customization data structure
* name : must the same as lights HAL
* mode : control mode
* data :
* PWM: pwm number
* GPIO: gpio id
* PMIC: enum mt65xx_led_pmic
* CUST: custom set brightness function pointer
* config_data: pwm config data
*/
struct cust_mt65xx_led {
char *name;
enum mt65xx_led_mode mode;
long data;
struct PWM_config config_data;
};
/**
* led device node structure with mtk extentions
* cdev: common led device structure
* cust: customization data from device tree
* work: workqueue for specialfied led device
* level: brightness level
* delay_on: on time if led is blinking
* delay_off: off time if led is blinking
*/
struct mt65xx_led_data {
struct led_classdev cdev;
struct cust_mt65xx_led cust;
struct work_struct work;
int level;
int delay_on;
int delay_off;
};
/**
* LED Variable Settings
* nled_mode: 0, off; 1, on; 2, blink
* blink_on_time: on time if led is blinking
* blink_off_time: off time if led is blinking
*/
#define NLED_OFF 0
#define NLED_ON 1
#define NLED_BLINK 2
struct nled_setting {
u8 nled_mode;
u32 blink_on_time;
u32 blink_off_time;
};
#endif /* _LEDS_SW_H */
@@ -0,0 +1,16 @@
#
# Copyright (C) 2015 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
obj-$(CONFIG_MTK_LEDS) := mtk_leds.o
ccflags-y += -I$(srctree)/drivers/misc/mediatek/video/include
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,45 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2016 MediaTek Inc.
*/
#ifndef _LEDS_HAL_H
#define _LEDS_HAL_H
#include "mtk_leds_sw.h"
/****************************************************************************
* LED HAL functions
***************************************************************************/
extern void mt_leds_wake_lock_init(void);
extern unsigned int mt_get_bl_brightness(void);
extern unsigned int mt_get_bl_duty(void);
extern unsigned int mt_get_bl_div(void);
extern unsigned int mt_get_bl_frequency(void);
extern unsigned int *mt_get_div_array(void);
extern void mt_set_bl_duty(unsigned int level);
extern void mt_set_bl_div(unsigned int div);
extern void mt_set_bl_frequency(unsigned int freq);
extern void mt_led_pwm_disable(int pwm_num);
extern int mt_led_set_pwm(int pwm_num, struct nled_setting *led);
extern int mt_led_blink_pmic(enum mt65xx_led_pmic pmic_type,
struct nled_setting *led);
extern int mt_backlight_set_pwm(int pwm_num, u32 level, u32 div,
struct PWM_config *config_data);
extern int mt_brightness_set_pmic(enum mt65xx_led_pmic pmic_type, u32 level,
u32 div);
extern int mt_mt65xx_led_set_cust(struct cust_mt65xx_led *cust, int level);
extern void mt_mt65xx_led_work(struct work_struct *work);
extern void mt_mt65xx_led_set(struct led_classdev *led_cdev,
enum led_brightness level);
extern int mt_mt65xx_blink_set(struct led_classdev *led_cdev,
unsigned long *delay_on, unsigned long *delay_off);
extern struct cust_mt65xx_led *mt_get_cust_led_list(void);
#if defined(CONFIG_BACKLIGHT_SUPPORT_LM3697)
extern int chargepump_set_backlight_level(unsigned int level);
#endif
#endif
@@ -0,0 +1,191 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2016 MediaTek Inc.
*/
#ifndef _LEDS_SW_H
#define _LEDS_SW_H
/******************************************************************************
* LED & Backlight type defination
*****************************************************************************/
enum mt65xx_led_type {
MT65XX_LED_TYPE_RED = 0,
MT65XX_LED_TYPE_GREEN,
MT65XX_LED_TYPE_BLUE,
MT65XX_LED_TYPE_JOGBALL,
MT65XX_LED_TYPE_KEYBOARD,
MT65XX_LED_TYPE_BUTTON,
MT65XX_LED_TYPE_LCD,
MT65XX_LED_TYPE_TOTAL,
};
enum mt65xx_led_mode {
MT65XX_LED_MODE_NONE,
MT65XX_LED_MODE_PWM,
MT65XX_LED_MODE_GPIO,
MT65XX_LED_MODE_PMIC,
MT65XX_LED_MODE_CUST_LCM,
MT65XX_LED_MODE_CUST_BLS_PWM
};
/******************************************************************************
* for backlight
*****************************************************************************/
/* backlight call back function */
typedef int (*cust_brightness_set) (int level, int div);
typedef int (*cust_set_brightness) (int level);
/* 10bit backlight level */
#define LED_INCREASE_LED_LEVEL_MTKPATCH
#ifdef LED_INCREASE_LED_LEVEL_MTKPATCH
#define MT_LED_INTERNAL_LEVEL_BIT_CNT 10
#endif
/******************************************************************************
* for PMIC
*****************************************************************************/
enum mt65xx_led_pmic {
MT65XX_LED_PMIC_LCD_ISINK = 0,
MT65XX_LED_PMIC_NLED_ISINK_MIN = MT65XX_LED_PMIC_LCD_ISINK,
MT65XX_LED_PMIC_NLED_ISINK0,
MT65XX_LED_PMIC_NLED_ISINK1,
MT65XX_LED_PMIC_NLED_ISINK2,
MT65XX_LED_PMIC_NLED_ISINK3,
MT65XX_LED_PMIC_NLED_ISINK_MAX,
};
enum MT65XX_PMIC_ISINK_MODE {
ISINK_PWM_MODE = 0,
ISINK_BREATH_MODE = 1,
ISINK_REGISTER_MODE = 2
};
enum MT65XX_PMIC_ISINK_STEP {
ISINK_0 = 0, /* 4mA */
ISINK_1 = 1, /* 8mA */
ISINK_2 = 2, /* 12mA */
ISINK_3 = 3, /* 16mA */
ISINK_4 = 4, /* 20mA */
ISINK_5 = 5 /* 24mA */
};
enum MT65XX_PMIC_ISINK_FSEL {
/* 32K clock */
ISINK_1KHZ = 0,
ISINK_200HZ = 4,
ISINK_5HZ = 199,
ISINK_2HZ = 499,
ISINK_1HZ = 999,
ISINK_05HZ = 1999,
ISINK_02HZ = 4999,
ISINK_01HZ = 9999,
/* 2M clock */
ISINK_2M_20KHZ = 2,
ISINK_2M_1KHZ = 61,
ISINK_2M_200HZ = 311,
ISINK_2M_5HZ = 12499,
ISINK_2M_2HZ = 31249,
ISINK_2M_1HZ = 62499,
/* 128K clock */
ISINK_128K_500HZ = 0,
ISINK_128K_256HZ = 1,
ISINK_128K_167HZ = 2,
ISINK_128K_128HZ = 3,
ISINK_128K_100HZ = 4,
ISINK_128K_83HZ = 5,
ISINK_128K_50HZ = 9,
ISINK_128K_17HZ = 28,
};
/******************************************************************************
* for PWM
*****************************************************************************/
/* the min frequence when use old mode pwm by kHz */
#define MIN_FRE_OLD_PWM 32
#define BACKLIGHT_LEVEL_PWM_64_FIFO_MODE_SUPPORT 64
#define BACKLIGHT_LEVEL_PWM_256_SUPPORT 256
#define BACKLIGHT_LEVEL_PWM_MODE_CONFIG BACKLIGHT_LEVEL_PWM_256_SUPPORT
static inline unsigned int Cust_GetBacklightLevelSupport_byPWM(void)
{
return BACKLIGHT_LEVEL_PWM_MODE_CONFIG;
}
static inline unsigned int brightness_mapping(unsigned int level)
{
unsigned int mapped_level;
mapped_level = level;
return mapped_level;
}
struct PWM_config {
int clock_source;
int div;
int low_duration;
int High_duration;
bool pmic_pad;
};
/****************************************************************************
* sw data structures
***************************************************************************/
/**
* led customization data structure
* name : must the same as lights HAL
* mode : control mode
* data :
* PWM: pwm number
* GPIO: gpio id
* PMIC: enum mt65xx_led_pmic
* CUST: custom set brightness function pointer
* config_data: pwm config data
*/
struct cust_mt65xx_led {
char *name;
enum mt65xx_led_mode mode;
long data;
struct PWM_config config_data;
};
/**
* led device node structure with mtk extentions
* cdev: common led device structure
* cust: customization data from device tree
* work: workqueue for specialfied led device
* level: brightness level
* delay_on: on time if led is blinking
* delay_off: off time if led is blinking
*/
struct mt65xx_led_data {
struct led_classdev cdev;
struct cust_mt65xx_led cust;
struct work_struct work;
int level;
int delay_on;
int delay_off;
};
/**
* LED Variable Settings
* nled_mode: 0, off; 1, on; 2, blink
* blink_on_time: on time if led is blinking
* blink_off_time: off time if led is blinking
*/
#define NLED_OFF 0
#define NLED_ON 1
#define NLED_BLINK 2
struct nled_setting {
u8 nled_mode;
u32 blink_on_time;
u32 blink_off_time;
};
#endif /* _LEDS_SW_H */
@@ -0,0 +1,16 @@
#
# Copyright (C) 2015 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
obj-$(CONFIG_MTK_LEDS) := mtk_leds.o
ccflags-y += -I$(srctree)/drivers/misc/mediatek/video/include
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,47 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _LEDS_HAL_H
#define _LEDS_HAL_H
#include "mtk_leds_sw.h"
/****************************************************************************
* LED HAL functions
***************************************************************************/
extern void mt_leds_wake_lock_init(void);
extern unsigned int mt_get_bl_brightness(void);
extern unsigned int mt_get_bl_duty(void);
extern unsigned int mt_get_bl_div(void);
extern unsigned int mt_get_bl_frequency(void);
extern unsigned int *mt_get_div_array(void);
extern void mt_set_bl_duty(unsigned int level);
extern void mt_set_bl_div(unsigned int div);
extern void mt_set_bl_frequency(unsigned int freq);
extern void mt_led_pwm_disable(int pwm_num);
extern int mt_led_set_pwm(int pwm_num, struct nled_setting *led);
extern int mt_led_blink_pmic(enum mt65xx_led_pmic pmic_type,
struct nled_setting *led);
extern int mt_backlight_set_pwm(int pwm_num, u32 level, u32 div,
struct PWM_config *config_data);
extern int mt_brightness_set_pmic(enum mt65xx_led_pmic pmic_type, u32 level,
u32 div);
extern int mt_mt65xx_led_set_cust(struct cust_mt65xx_led *cust, int level);
extern void mt_mt65xx_led_work(struct work_struct *work);
extern void mt_mt65xx_led_set(struct led_classdev *led_cdev,
enum led_brightness level);
extern int mt_mt65xx_blink_set(struct led_classdev *led_cdev,
unsigned long *delay_on, unsigned long *delay_off);
extern struct cust_mt65xx_led *mt_get_cust_led_list(void);
#if defined(CONFIG_BACKLIGHT_SUPPORT_LM3697)
extern int chargepump_set_backlight_level(unsigned int level);
#endif
#endif
@@ -0,0 +1,193 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _LEDS_SW_H
#define _LEDS_SW_H
/******************************************************************************
* LED & Backlight type defination
*****************************************************************************/
enum mt65xx_led_type {
MT65XX_LED_TYPE_RED = 0,
MT65XX_LED_TYPE_GREEN,
MT65XX_LED_TYPE_BLUE,
MT65XX_LED_TYPE_JOGBALL,
MT65XX_LED_TYPE_KEYBOARD,
MT65XX_LED_TYPE_BUTTON,
MT65XX_LED_TYPE_LCD,
MT65XX_LED_TYPE_TOTAL,
};
enum mt65xx_led_mode {
MT65XX_LED_MODE_NONE,
MT65XX_LED_MODE_PWM,
MT65XX_LED_MODE_GPIO,
MT65XX_LED_MODE_PMIC,
MT65XX_LED_MODE_CUST_LCM,
MT65XX_LED_MODE_CUST_BLS_PWM
};
/******************************************************************************
* for backlight
*****************************************************************************/
/* backlight call back function */
typedef int (*cust_brightness_set) (int level, int div);
typedef int (*cust_set_brightness) (int level);
/* 10bit backlight level */
#define LED_INCREASE_LED_LEVEL_MTKPATCH
#ifdef LED_INCREASE_LED_LEVEL_MTKPATCH
#define MT_LED_INTERNAL_LEVEL_BIT_CNT 10
#endif
/******************************************************************************
* for PMIC
*****************************************************************************/
enum mt65xx_led_pmic {
MT65XX_LED_PMIC_LCD_ISINK = 0,
MT65XX_LED_PMIC_NLED_ISINK_MIN = MT65XX_LED_PMIC_LCD_ISINK,
MT65XX_LED_PMIC_NLED_ISINK0,
MT65XX_LED_PMIC_NLED_ISINK1,
MT65XX_LED_PMIC_NLED_ISINK2,
MT65XX_LED_PMIC_NLED_ISINK3,
MT65XX_LED_PMIC_NLED_ISINK_MAX,
};
enum MT65XX_PMIC_ISINK_MODE {
ISINK_PWM_MODE = 0,
ISINK_BREATH_MODE = 1,
ISINK_REGISTER_MODE = 2
};
enum MT65XX_PMIC_ISINK_STEP {
ISINK_0 = 0, /* 4mA */
ISINK_1 = 1, /* 8mA */
ISINK_2 = 2, /* 12mA */
ISINK_3 = 3, /* 16mA */
ISINK_4 = 4, /* 20mA */
ISINK_5 = 5 /* 24mA */
};
enum MT65XX_PMIC_ISINK_FSEL {
/* 32K clock */
ISINK_1KHZ = 0,
ISINK_200HZ = 4,
ISINK_5HZ = 199,
ISINK_2HZ = 499,
ISINK_1HZ = 999,
ISINK_05HZ = 1999,
ISINK_02HZ = 4999,
ISINK_01HZ = 9999,
/* 2M clock */
ISINK_2M_20KHZ = 2,
ISINK_2M_1KHZ = 61,
ISINK_2M_200HZ = 311,
ISINK_2M_5HZ = 12499,
ISINK_2M_2HZ = 31249,
ISINK_2M_1HZ = 62499,
/* 128K clock */
ISINK_128K_500HZ = 0,
ISINK_128K_256HZ = 1,
ISINK_128K_167HZ = 2,
ISINK_128K_128HZ = 3,
ISINK_128K_100HZ = 4,
ISINK_128K_83HZ = 5,
ISINK_128K_50HZ = 9,
ISINK_128K_17HZ = 28,
};
/******************************************************************************
* for PWM
*****************************************************************************/
/* the min frequence when use old mode pwm by kHz */
#define MIN_FRE_OLD_PWM 32
#define BACKLIGHT_LEVEL_PWM_64_FIFO_MODE_SUPPORT 64
#define BACKLIGHT_LEVEL_PWM_256_SUPPORT 256
#define BACKLIGHT_LEVEL_PWM_MODE_CONFIG BACKLIGHT_LEVEL_PWM_256_SUPPORT
static inline unsigned int Cust_GetBacklightLevelSupport_byPWM(void)
{
return BACKLIGHT_LEVEL_PWM_MODE_CONFIG;
}
static inline unsigned int brightness_mapping(unsigned int level)
{
unsigned int mapped_level;
mapped_level = level;
return mapped_level;
}
struct PWM_config {
int clock_source;
int div;
int low_duration;
int High_duration;
bool pmic_pad;
};
/****************************************************************************
* sw data structures
***************************************************************************/
/**
* led customization data structure
* name : must the same as lights HAL
* mode : control mode
* data :
* PWM: pwm number
* GPIO: gpio id
* PMIC: enum mt65xx_led_pmic
* CUST: custom set brightness function pointer
* config_data: pwm config data
*/
struct cust_mt65xx_led {
char *name;
enum mt65xx_led_mode mode;
long data;
struct PWM_config config_data;
};
/**
* led device node structure with mtk extentions
* cdev: common led device structure
* cust: customization data from device tree
* work: workqueue for specialfied led device
* level: brightness level
* delay_on: on time if led is blinking
* delay_off: off time if led is blinking
*/
struct mt65xx_led_data {
struct led_classdev cdev;
struct cust_mt65xx_led cust;
struct work_struct work;
int level;
int delay_on;
int delay_off;
};
/**
* LED Variable Settings
* nled_mode: 0, off; 1, on; 2, blink
* blink_on_time: on time if led is blinking
* blink_off_time: off time if led is blinking
*/
#define NLED_OFF 0
#define NLED_ON 1
#define NLED_BLINK 2
struct nled_setting {
u8 nled_mode;
u32 blink_on_time;
u32 blink_off_time;
};
#endif /* _LEDS_SW_H */
@@ -0,0 +1,16 @@
#
# Copyright (C) 2015 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
obj-$(CONFIG_MTK_LEDS) := mtk_leds.o
ccflags-y += -I$(srctree)/drivers/misc/mediatek/video/include
@@ -0,0 +1,971 @@
// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/delay.h>
#include <linux/string.h>
#include <linux/ctype.h>
#include <linux/leds.h>
#include <linux/of.h>
#include <linux/workqueue.h>
#include <linux/pm_wakeup.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/sched/clock.h>
#ifdef CONFIG_MTK_AAL_SUPPORT
#include <ddp_aal.h>
/* #include <linux/aee.h> */
#endif
#ifdef CONFIG_MTK_PWM
#include <mt-plat/mtk_pwm.h>
#endif
#ifdef CONFIG_MTK_PMIC_NEW_ARCH
#include <mt-plat/upmu_common.h>
#endif
#ifdef CONFIG_MTK_FB
#include <ddp_gamma.h>
#include "ddp_pwm.h"
#include "mtkfb.h"
#endif
#define MET_USER_EVENT_SUPPORT
#ifdef MET_USER_EVENT_SUPPORT
#include <mt-plat/met_drv.h>
#endif
#include "mtk_leds_sw.h"
#include "mtk_leds_hal.h"
#include "../mtk_leds_drv.h"
/* for LED&Backlight bringup, define the dummy API */
#ifndef CONFIG_MTK_PMIC_NEW_ARCH
u16 pmic_set_register_value(u32 flagname, u32 val)
{
return 0;
}
#endif
void disp_pq_notify_backlight_changed(int bl_1024);
//{
//}
static DEFINE_MUTEX(leds_mutex);
static DEFINE_MUTEX(leds_pmic_mutex);
/****************************************************************************
* variables
***************************************************************************/
#define CLK_DIV1 0
static unsigned int bl_brightness_hal = 102;
#ifdef CONFIG_MTK_PWM
static unsigned int bl_duty_hal = 21;
#endif
static unsigned int bl_div_hal = CLK_DIV1;
/* for button led don't do ISINK disable first time */
static int button_flag_isink0;
static int button_flag_isink1;
struct wakeup_source leds_suspend_lock;
struct cust_mt65xx_led *pled_dtsi;
char *leds_name[TYPE_TOTAL] = {
"red",
"green",
"blue",
"jogball-backlight",
"keyboard-backlight",
"button-backlight",
"lcd-backlight",
};
/****************************************************************************
* DEBUG MACROS
***************************************************************************/
#undef pr_fmt
#define pr_fmt(fmt) KBUILD_MODNAME " %s(%d) :" fmt, __func__, __LINE__
static int debug_enable_led_hal = 1;
#define LEDS_DEBUG(format, args...) do { \
if (debug_enable_led_hal) { \
pr_info("[LED]"format, ##args);\
} \
} while (0)
/*****************PWM *************************************************/
#define PWM_DIV_NUM 8
#ifdef CONFIG_MTK_PWM
static int time_array_hal[PWM_DIV_NUM] = {
256, 512, 1024, 2048, 4096, 8192, 16384, 32768 };
static unsigned int backlight_PWM_div_hal = CLK_DIV1;
static unsigned int div_array_hal[PWM_DIV_NUM] = {
1, 2, 4, 8, 16, 32, 64, 128 };
#endif
/****************************************************************************
* func:return global variables
***************************************************************************/
static unsigned long long current_t, last_time;
static int count;
static char buffer[4096] = "[BL] Set Backlight directly ";
static void backlight_debug_log(int level, int mappingLevel)
{
unsigned long cur_time_mod = 0;
unsigned long long cur_time_display = 0;
int ret = 0;
current_t = sched_clock();
cur_time_display = current_t;
do_div(cur_time_display, 1000000);
cur_time_mod = do_div(cur_time_display, 1000);
ret = snprintf(buffer + strlen(buffer),
4095 - strlen(buffer), "T:%lld.%ld,L:%d map:%d ",
cur_time_display, cur_time_mod, level, mappingLevel);
count++;
if (ret < 0 || ret >= 4096) {
pr_info("print log error!");
count = 5;
}
if (level == 0 || count >= 5 || (current_t - last_time) > 1000000000) {
LEDS_DEBUG("%s", buffer);
count = 0;
buffer[strlen("Set Backlight directly ")] = '\0';
}
last_time = sched_clock();
}
void mt_leds_wake_lock_init(void)
{
wakeup_source_init(&leds_suspend_lock, "leds wakelock");
}
struct cust_mt65xx_led *get_cust_led_dtsi(void)
{
struct device_node *led_node = NULL;
bool isSupportDTS = false;
int i, ret;
int mode, data;
int pwm_config[5] = { 0 };
if (pled_dtsi)
goto out;
pr_info("[LED] %s pled_dtsi is null, load dts file\n", __func__);
pled_dtsi = kmalloc_array(TYPE_TOTAL, sizeof(struct cust_mt65xx_led),
GFP_KERNEL);
if (pled_dtsi == NULL) {
LEDS_DEBUG("%s kmalloc fail\n", __func__);
goto out;
}
for (i = 0; i < TYPE_TOTAL; i++) {
char node_name[32] = "mediatek,";
if (strlen(node_name) + strlen(leds_name[i]) + 1 >
sizeof(node_name)) {
LEDS_DEBUG("buffer for %s%s not enough\n",
node_name, leds_name[i]);
pled_dtsi[i].mode = 0;
pled_dtsi[i].data = -1;
continue;
}
pled_dtsi[i].name = leds_name[i];
led_node = of_find_compatible_node(NULL, NULL,
strncat(node_name, leds_name[i],
sizeof(node_name) - strlen(node_name) - 1));
if (!led_node) {
pr_info("[LED]Cannot find LED node from dts\n");
pled_dtsi[i].mode = 0;
pled_dtsi[i].data = -1;
continue;
}
isSupportDTS = true;
ret = of_property_read_u32(led_node, "led_mode", &mode);
if (!ret) {
pled_dtsi[i].mode = mode;
LEDS_DEBUG("The %s's led mode is : %d\n",
pled_dtsi[i].name, pled_dtsi[i].mode);
} else {
LEDS_DEBUG("led dts can not get %s led mode\n",
pled_dtsi[i].name);
pled_dtsi[i].mode = 0;
}
ret =
of_property_read_u32(led_node, "data",
&data);
if (!ret) {
pled_dtsi[i].data = data;
LEDS_DEBUG("The %s's led data is : %ld\n",
pled_dtsi[i].name, pled_dtsi[i].data);
} else {
LEDS_DEBUG("led dts can not get %s led data\n",
pled_dtsi[i].name);
pled_dtsi[i].data = -1;
}
ret = of_property_read_u32_array(led_node, "pwm_config",
pwm_config, ARRAY_SIZE(pwm_config));
if (!ret) {
LEDS_DEBUG("%s's pwm cfg %d %d %d %d %d\n",
pled_dtsi[i].name, pwm_config[0], pwm_config[1],
pwm_config[2], pwm_config[3], pwm_config[4]);
pled_dtsi[i].config_data.clock_source = pwm_config[0];
pled_dtsi[i].config_data.div = pwm_config[1];
pled_dtsi[i].config_data.low_duration = pwm_config[2];
pled_dtsi[i].config_data.High_duration = pwm_config[3];
pled_dtsi[i].config_data.pmic_pad = pwm_config[4];
} else
LEDS_DEBUG("led dts can't get pwm config\n");
switch (pled_dtsi[i].mode) {
case MT65XX_LED_MODE_CUST_LCM:
#if defined(CONFIG_BACKLIGHT_SUPPORT_LM3697)
pled_dtsi[i].data =
(long)chargepump_set_backlight_level;
LEDS_DEBUG("BL set by chargepump\n");
#else
pled_dtsi[i].data = (long)mtkfb_set_backlight_level;
#endif
LEDS_DEBUG("kernel:the BL hw mode is LCM.\n");
break;
case MT65XX_LED_MODE_CUST_BLS_PWM:
pled_dtsi[i].data = (long)disp_bls_set_backlight;
LEDS_DEBUG("kernel:the BL hw mode is BLS.\n");
break;
default:
break;
}
}
if (!isSupportDTS) {
kfree(pled_dtsi);
pled_dtsi = NULL;
}
out:
return pled_dtsi;
}
struct cust_mt65xx_led *mt_get_cust_led_list(void)
{
struct cust_mt65xx_led *cust_led_list = get_cust_led_dtsi();
return cust_led_list;
}
/****************************************************************************
* internal functions
***************************************************************************/
#ifdef CONFIG_MTK_PWM
static int brightness_mapto64(int level)
{
if (level < 30)
return (level >> 1) + 7;
else if (level <= 120)
return (level >> 2) + 14;
else if (level <= 160)
return level / 5 + 20;
else
return (level >> 3) + 33;
}
static int find_time_index(int time)
{
int index = 0;
while (index < 8) {
if (time < time_array_hal[index])
return index;
index++;
}
return PWM_DIV_NUM - 1;
}
#endif
int mt_led_set_pwm(int pwm_num, struct nled_setting *led)
{
#ifdef CONFIG_MTK_PWM
struct pwm_spec_config pwm_setting;
int time_index = 0;
memset(&pwm_setting, 0, sizeof(struct pwm_spec_config));
pwm_setting.pwm_no = pwm_num;
pwm_setting.mode = PWM_MODE_OLD;
LEDS_DEBUG("led_set_pwm: mode=%d,pwm_no=%d\n", led->nled_mode,
pwm_num);
/* We won't choose 32K to be the clock src of old mode because of
* system performance. The setting here will be clock src = 26MHz,
* CLKSEL = 26M/1625 (i.e. 16K)
*/
pwm_setting.clk_src = PWM_CLK_OLD_MODE_32K;
pwm_setting.pmic_pad = 0;
switch (led->nled_mode) {
/* Actually, the setting still can not to turn off NLED. We should
* disable PWM to turn off NLED.
*/
case NLED_OFF:
pwm_setting.PWM_MODE_OLD_REGS.THRESH = 0;
pwm_setting.clk_div = CLK_DIV1;
pwm_setting.PWM_MODE_OLD_REGS.DATA_WIDTH = 100 / 2;
break;
case NLED_ON:
pwm_setting.PWM_MODE_OLD_REGS.THRESH = 30 / 2;
pwm_setting.clk_div = CLK_DIV1;
pwm_setting.PWM_MODE_OLD_REGS.DATA_WIDTH = 100 / 2;
break;
case NLED_BLINK:
LEDS_DEBUG("LED blink on time = %d offtime = %d\n",
led->blink_on_time, led->blink_off_time);
time_index =
find_time_index(led->blink_on_time + led->blink_off_time);
LEDS_DEBUG("LED div is %d\n", time_index);
pwm_setting.clk_div = time_index;
pwm_setting.PWM_MODE_OLD_REGS.DATA_WIDTH =
(led->blink_on_time +
led->blink_off_time) * MIN_FRE_OLD_PWM /
div_array_hal[time_index];
pwm_setting.PWM_MODE_OLD_REGS.THRESH =
(led->blink_on_time * 100) / (led->blink_on_time +
led->blink_off_time);
break;
default:
LEDS_DEBUG("Invalid nled mode\n");
return -1;
}
pwm_setting.PWM_MODE_FIFO_REGS.IDLE_VALUE = 0;
pwm_setting.PWM_MODE_FIFO_REGS.GUARD_VALUE = 0;
pwm_setting.PWM_MODE_FIFO_REGS.GDURATION = 0;
pwm_setting.PWM_MODE_FIFO_REGS.WAVE_NUM = 0;
pwm_set_spec_config(&pwm_setting);
#endif
return 0;
}
/************************ led breath function*****************************/
/*************************************************************************
* func is to switch to breath mode from PWM mode of ISINK
* para: enable: 1 : breath mode; 0: PWM mode;
*************************************************************************/
#if 0
static int led_switch_breath_pmic(enum mt65xx_led_pmic pmic_type,
struct nled_setting *led, int enable)
{
/* int time_index = 0; */
/* int duty = 0; */
LEDS_DEBUG("led_blink_pmic: pmic_type=%d\n", pmic_type);
if ((pmic_type != MT65XX_LED_PMIC_NLED_ISINK0
&& pmic_type != MT65XX_LED_PMIC_NLED_ISINK1
&& pmic_type != MT65XX_LED_PMIC_NLED_ISINK2
&& pmic_type != MT65XX_LED_PMIC_NLED_ISINK3)
|| led->nled_mode != NLED_BLINK) {
return -1;
}
if (enable == 1) {
switch (pmic_type) {
case MT65XX_LED_PMIC_NLED_ISINK0:
pmic_set_register_value(PMIC_ISINK_CH0_MODE,
ISINK_BREATH_MODE);
pmic_set_register_value(PMIC_ISINK_CH0_STEP, ISINK_3);
pmic_set_register_value(PMIC_ISINK_BREATH0_TR1_SEL,
0x04);
pmic_set_register_value(PMIC_ISINK_BREATH0_TR2_SEL,
0x04);
pmic_set_register_value(PMIC_ISINK_BREATH0_TF1_SEL,
0x04);
pmic_set_register_value(PMIC_ISINK_BREATH0_TF2_SEL,
0x04);
pmic_set_register_value(PMIC_ISINK_BREATH0_TON_SEL,
0x02);
pmic_set_register_value(PMIC_ISINK_BREATH0_TOFF_SEL,
0x03);
pmic_set_register_value(PMIC_ISINK_DIM0_DUTY, 15);
pmic_set_register_value(PMIC_ISINK_DIM0_FSEL, 11);
break;
case MT65XX_LED_PMIC_NLED_ISINK1:
pmic_set_register_value(PMIC_ISINK_CH1_MODE,
ISINK_BREATH_MODE);
pmic_set_register_value(PMIC_ISINK_CH1_STEP, ISINK_3);
pmic_set_register_value(PMIC_ISINK_BREATH1_TR1_SEL,
0x04);
pmic_set_register_value(PMIC_ISINK_BREATH1_TR2_SEL,
0x04);
pmic_set_register_value(PMIC_ISINK_BREATH1_TF1_SEL,
0x04);
pmic_set_register_value(PMIC_ISINK_BREATH1_TF2_SEL,
0x04);
pmic_set_register_value(PMIC_ISINK_BREATH1_TON_SEL,
0x02);
pmic_set_register_value(PMIC_ISINK_BREATH1_TOFF_SEL,
0x03);
pmic_set_register_value(PMIC_ISINK_DIM1_DUTY, 15);
pmic_set_register_value(PMIC_ISINK_DIM1_FSEL, 11);
break;
case MT65XX_LED_PMIC_NLED_ISINK2:
pmic_set_register_value(PMIC_ISINK_CH2_MODE,
ISINK_BREATH_MODE);
pmic_set_register_value(PMIC_ISINK_CH2_STEP, ISINK_3);
pmic_set_register_value(PMIC_ISINK_BREATH2_TR1_SEL,
0x04);
pmic_set_register_value(PMIC_ISINK_BREATH2_TR2_SEL,
0x04);
pmic_set_register_value(PMIC_ISINK_BREATH2_TF1_SEL,
0x04);
pmic_set_register_value(PMIC_ISINK_BREATH2_TF2_SEL,
0x04);
pmic_set_register_value(PMIC_ISINK_BREATH2_TON_SEL,
0x02);
pmic_set_register_value(PMIC_ISINK_BREATH2_TOFF_SEL,
0x03);
pmic_set_register_value(PMIC_ISINK_DIM2_DUTY, 15);
pmic_set_register_value(PMIC_ISINK_DIM2_FSEL, 11);
break;
case MT65XX_LED_PMIC_NLED_ISINK3:
pmic_set_register_value(PMIC_ISINK_CH3_MODE,
ISINK_BREATH_MODE);
pmic_set_register_value(PMIC_ISINK_CH3_STEP, ISINK_3);
pmic_set_register_value(PMIC_ISINK_BREATH3_TR1_SEL,
0x04);
pmic_set_register_value(PMIC_ISINK_BREATH3_TR2_SEL,
0x04);
pmic_set_register_value(PMIC_ISINK_BREATH3_TF1_SEL,
0x04);
pmic_set_register_value(PMIC_ISINK_BREATH3_TF2_SEL,
0x04);
pmic_set_register_value(PMIC_ISINK_BREATH3_TON_SEL,
0x02);
pmic_set_register_value(PMIC_ISINK_BREATH3_TOFF_SEL,
0x03);
pmic_set_register_value(PMIC_ISINK_DIM3_DUTY, 15);
pmic_set_register_value(PMIC_ISINK_DIM3_FSEL, 11);
break;
default:
break;
}
} else {
switch (pmic_type) {
case MT65XX_LED_PMIC_NLED_ISINK0:
pmic_set_register_value(PMIC_ISINK_CH3_MODE,
ISINK_PWM_MODE);
break;
case MT65XX_LED_PMIC_NLED_ISINK0:
pmic_set_register_value(PMIC_ISINK_CH3_MODE,
ISINK_PWM_MODE);
break;
case MT65XX_LED_PMIC_NLED_ISINK0:
pmic_set_register_value(PMIC_ISINK_CH3_MODE,
ISINK_PWM_MODE);
break;
case MT65XX_LED_PMIC_NLED_ISINK0:
pmic_set_register_value(PMIC_ISINK_CH3_MODE,
ISINK_PWM_MODE);
break;
default:
break;
}
}
return 0;
}
#endif
#ifdef CONFIG_MTK_PMIC_CHIP_MT6357
#define PMIC_PERIOD_NUM 8
int pmic_period_array[] = { 2, 4, 6, 8, 10, 12, 20, 60 };
int pmic_freqsel_array[] = { 0, 1, 2, 3, 4, 5, 9, 28 };
static int find_time_index_pmic(int time_ms)
{
int i;
for (i = 0; i < PMIC_PERIOD_NUM; i++) {
if (time_ms <= pmic_period_array[i])
return i;
}
return PMIC_PERIOD_NUM - 1;
}
#endif
int mt_led_blink_pmic(enum mt65xx_led_pmic pmic_type, struct nled_setting *led)
{
#ifndef CONFIG_MTK_PMIC_CHIP_MT6357
LEDS_DEBUG("%s pmic_type = %d isink does not support this path\n",
__func__, pmic_type);
#else
int time_index = 0;
int duty = 0;
if (led->nled_mode != NLED_BLINK)
return -1;
LEDS_DEBUG("%s blink on time = %d offtime = %d\n", __func__,
led->blink_on_time, led->blink_off_time);
time_index =
find_time_index_pmic(led->blink_on_time + led->blink_off_time);
LEDS_DEBUG("LED index is %d freqsel=%d\n", time_index,
pmic_freqsel_array[time_index]);
duty = 256 * led->blink_on_time / (led->blink_on_time +
led->blink_off_time);
if (pmic_type > MT65XX_LED_PMIC_NLED_ISINK_MIN &&
pmic_type < MT65XX_LED_PMIC_NLED_ISINK_MAX)
pmic_set_register_value(PMIC_RG_DRV_128K_CK_PDN, 0x0);
switch (pmic_type) {
case MT65XX_LED_PMIC_NLED_ISINK0:
pmic_set_register_value(PMIC_ISINK_CH0_EN, NLED_OFF);
pmic_set_register_value(PMIC_RG_DRV_ISINK0_CK_PDN, 0);
pmic_set_register_value(PMIC_ISINK_CH0_MODE, ISINK_PWM_MODE);
pmic_set_register_value(PMIC_ISINK_CH0_STEP, ISINK_3);
pmic_set_register_value(PMIC_ISINK_DIM0_DUTY, duty);
pmic_set_register_value(PMIC_ISINK_DIM0_FSEL,
pmic_freqsel_array[time_index]);
pmic_set_register_value(PMIC_ISINK_CH0_BIAS_EN, NLED_ON);
pmic_set_register_value(PMIC_ISINK_CHOP0_EN, NLED_ON);
pmic_set_register_value(PMIC_ISINK_CH0_EN, NLED_ON);
break;
case MT65XX_LED_PMIC_NLED_ISINK1:
pmic_set_register_value(PMIC_ISINK_CH1_EN, NLED_OFF);
pmic_set_register_value(PMIC_RG_DRV_ISINK1_CK_PDN, 0);
pmic_set_register_value(PMIC_ISINK_CH1_MODE, ISINK_PWM_MODE);
pmic_set_register_value(PMIC_ISINK_CH1_STEP, ISINK_3);
pmic_set_register_value(PMIC_ISINK_DIM1_DUTY, duty);
pmic_set_register_value(PMIC_ISINK_DIM1_FSEL,
pmic_freqsel_array[time_index]);
pmic_set_register_value(PMIC_ISINK_CH1_BIAS_EN, NLED_ON);
pmic_set_register_value(PMIC_ISINK_CHOP1_EN, NLED_ON);
pmic_set_register_value(PMIC_ISINK_CH1_EN, NLED_ON);
break;
default:
LEDS_DEBUG("pmic_type %d is not handled\n", pmic_type);
break;
}
#endif
return 0;
}
int mt_backlight_set_pwm(int pwm_num, u32 level, u32 div,
struct PWM_config *config_data)
{
#ifdef CONFIG_MTK_PWM
struct pwm_spec_config pwm_setting;
unsigned int BacklightLevelSupport =
Cust_GetBacklightLevelSupport_byPWM();
pwm_setting.pwm_no = pwm_num;
if (BacklightLevelSupport == BACKLIGHT_LEVEL_PWM_256_SUPPORT)
pwm_setting.mode = PWM_MODE_OLD;
else
pwm_setting.mode = PWM_MODE_FIFO;
pwm_setting.pmic_pad = config_data->pmic_pad;
if (config_data->div) {
pwm_setting.clk_div = config_data->div;
backlight_PWM_div_hal = config_data->div;
} else
pwm_setting.clk_div = div;
if (BacklightLevelSupport == BACKLIGHT_LEVEL_PWM_256_SUPPORT) {
/* PWM_CLK_OLD_MODE_32K is block/1625 = 26M/1625 = 16KHz @ MT6571 */
if (config_data->clock_source)
pwm_setting.clk_src = PWM_CLK_OLD_MODE_BLOCK;
else
pwm_setting.clk_src = PWM_CLK_OLD_MODE_32K;
pwm_setting.PWM_MODE_OLD_REGS.IDLE_VALUE = 0;
pwm_setting.PWM_MODE_OLD_REGS.GUARD_VALUE = 0;
pwm_setting.PWM_MODE_OLD_REGS.GDURATION = 0;
pwm_setting.PWM_MODE_OLD_REGS.WAVE_NUM = 0;
pwm_setting.PWM_MODE_OLD_REGS.DATA_WIDTH = 255; /* 256 level */
pwm_setting.PWM_MODE_OLD_REGS.THRESH = level;
LEDS_DEBUG("[%d]backlight set pwm:duty is %d/%d\n",
BacklightLevelSupport, level,
pwm_setting.PWM_MODE_OLD_REGS.DATA_WIDTH);
LEDS_DEBUG("[%d]backlight set pwm:clk_src/div is %d%d\n",
BacklightLevelSupport, pwm_setting.clk_src,
pwm_setting.clk_div);
if (level > 0 && level < 256) {
pwm_set_spec_config(&pwm_setting);
LEDS_DEBUG
("[%d]old mode: thres/data_width is %d/%d\n",
BacklightLevelSupport,
pwm_setting.PWM_MODE_OLD_REGS.THRESH,
pwm_setting.PWM_MODE_OLD_REGS.DATA_WIDTH);
} else {
LEDS_DEBUG("[%d]Error level in backlight\n",
BacklightLevelSupport);
mt_pwm_disable(pwm_setting.pwm_no,
config_data->pmic_pad);
}
} else {
if (config_data->clock_source) {
pwm_setting.clk_src = PWM_CLK_NEW_MODE_BLOCK;
} else {
pwm_setting.clk_src =
PWM_CLK_NEW_MODE_BLOCK_DIV_BY_1625;
}
if (config_data->High_duration && config_data->low_duration) {
pwm_setting.PWM_MODE_FIFO_REGS.HDURATION =
config_data->High_duration;
pwm_setting.PWM_MODE_FIFO_REGS.LDURATION =
pwm_setting.PWM_MODE_FIFO_REGS.HDURATION;
} else {
pwm_setting.PWM_MODE_FIFO_REGS.HDURATION = 4;
pwm_setting.PWM_MODE_FIFO_REGS.LDURATION = 4;
}
pwm_setting.PWM_MODE_FIFO_REGS.IDLE_VALUE = 0;
pwm_setting.PWM_MODE_FIFO_REGS.GUARD_VALUE = 0;
pwm_setting.PWM_MODE_FIFO_REGS.STOP_BITPOS_VALUE = 31;
pwm_setting.PWM_MODE_FIFO_REGS.GDURATION =
(pwm_setting.PWM_MODE_FIFO_REGS.HDURATION + 1) * 32 - 1;
pwm_setting.PWM_MODE_FIFO_REGS.WAVE_NUM = 0;
LEDS_DEBUG("%s :duty is %d\n", __func__, level);
LEDS_DEBUG("clk_src/div/high/low is %d%d%d%d\n",
pwm_setting.clk_src, pwm_setting.clk_div,
pwm_setting.PWM_MODE_FIFO_REGS.HDURATION,
pwm_setting.PWM_MODE_FIFO_REGS.LDURATION);
if (level > 0 && level <= 32) {
pwm_setting.PWM_MODE_FIFO_REGS.GUARD_VALUE = 0;
pwm_setting.PWM_MODE_FIFO_REGS.SEND_DATA0 =
(1 << level) - 1;
pwm_set_spec_config(&pwm_setting);
} else if (level > 32 && level <= 64) {
pwm_setting.PWM_MODE_FIFO_REGS.GUARD_VALUE = 1;
level -= 32;
pwm_setting.PWM_MODE_FIFO_REGS.SEND_DATA0 =
(1 << level) - 1;
pwm_set_spec_config(&pwm_setting);
} else {
LEDS_DEBUG("Error level in backlight\n");
mt_pwm_disable(pwm_setting.pwm_no,
config_data->pmic_pad);
}
}
#endif
return 0;
}
void mt_led_pwm_disable(int pwm_num)
{
#ifdef CONFIG_MTK_PWM
struct cust_mt65xx_led *cust_led_list = get_cust_led_dtsi();
mt_pwm_disable(pwm_num, cust_led_list->config_data.pmic_pad);
#endif
}
int mt_brightness_set_pmic(enum mt65xx_led_pmic pmic_type, u32 level, u32 div)
{
#ifndef CONFIG_MTK_PMIC_CHIP_MT6357
LEDS_DEBUG("%s, pmic_type = %d isink does not support this path\n",
__func__, pmic_type);
#else
static bool first_time = true;
LEDS_DEBUG("%s pmic_type%d level%d\n", __func__, pmic_type, level);
mutex_lock(&leds_pmic_mutex);
if (pmic_type == MT65XX_LED_PMIC_NLED_ISINK0) {
/* button flag ==0, means this ISINK is not for button */
if ((button_flag_isink0 == 0) && (first_time == true)) {
/* sw workround for sync leds status */
if (button_flag_isink1 == 0)
pmic_set_register_value(PMIC_ISINK_CH1_EN,
NLED_OFF);
first_time = false;
}
pmic_set_register_value(PMIC_RG_DRV_128K_CK_PDN, 0x0);
pmic_set_register_value(PMIC_RG_DRV_ISINK0_CK_PDN, 0);
pmic_set_register_value(PMIC_ISINK_CH0_MODE, ISINK_PWM_MODE);
/* 16mA */
pmic_set_register_value(PMIC_ISINK_CH0_STEP, ISINK_3);
pmic_set_register_value(PMIC_ISINK_DIM0_DUTY, 255);
/* 1KHz */
pmic_set_register_value(PMIC_ISINK_DIM0_FSEL,
ISINK_128K_500HZ);
pmic_set_register_value(PMIC_ISINK_CH0_BIAS_EN, NLED_ON);
pmic_set_register_value(PMIC_ISINK_CHOP0_EN, NLED_ON);
if (level)
pmic_set_register_value(PMIC_ISINK_CH0_EN, NLED_ON);
else
pmic_set_register_value(PMIC_ISINK_CH0_EN, NLED_OFF);
mutex_unlock(&leds_pmic_mutex);
return 0;
} else if (pmic_type == MT65XX_LED_PMIC_NLED_ISINK1) {
/* button flag ==0, means this ISINK is not for button*/
if ((button_flag_isink1 == 0) && (first_time == true)) {
/* sw workround for sync leds status */
if (button_flag_isink0 == 0)
pmic_set_register_value(PMIC_ISINK_CH0_EN,
NLED_OFF);
first_time = false;
}
/* Disable power down */
pmic_set_register_value(PMIC_RG_DRV_128K_CK_PDN, 0x0);
pmic_set_register_value(PMIC_RG_DRV_ISINK1_CK_PDN, 0);
pmic_set_register_value(PMIC_ISINK_CH1_MODE, ISINK_PWM_MODE);
/* 16mA */
pmic_set_register_value(PMIC_ISINK_CH1_STEP, ISINK_3);
pmic_set_register_value(PMIC_ISINK_DIM1_DUTY, 255);
/* 1KHz */
pmic_set_register_value(PMIC_ISINK_DIM1_FSEL, ISINK_128K_500HZ);
pmic_set_register_value(PMIC_ISINK_CH1_BIAS_EN, NLED_ON);
pmic_set_register_value(PMIC_ISINK_CHOP1_EN, NLED_ON);
if (level)
pmic_set_register_value(PMIC_ISINK_CH1_EN, NLED_ON);
else
pmic_set_register_value(PMIC_ISINK_CH1_EN, NLED_OFF);
mutex_unlock(&leds_pmic_mutex);
return 0;
}
mutex_unlock(&leds_pmic_mutex);
#endif
return -1;
}
int mt_mt65xx_led_set_cust(struct cust_mt65xx_led *cust, int level)
{
#ifdef CONFIG_MTK_PWM
struct nled_setting led_tmp_setting = { 0, 0, 0 };
int tmp_level = level;
unsigned int BacklightLevelSupport =
Cust_GetBacklightLevelSupport_byPWM();
#endif
static bool button_flag;
switch (cust->mode) {
case MT65XX_LED_MODE_PWM:
#ifdef CONFIG_MTK_PWM
if (strcmp(cust->name, "lcd-backlight") == 0) {
bl_brightness_hal = level;
if (level == 0) {
mt_pwm_disable(cust->data,
cust->config_data.pmic_pad);
} else {
if (BacklightLevelSupport ==
BACKLIGHT_LEVEL_PWM_256_SUPPORT)
level = brightness_mapping(tmp_level);
else
level = brightness_mapto64(tmp_level);
mt_backlight_set_pwm(cust->data, level,
bl_div_hal, &cust->config_data);
}
bl_duty_hal = level;
} else {
if (level == 0) {
led_tmp_setting.nled_mode = NLED_OFF;
mt_led_set_pwm(cust->data, &led_tmp_setting);
mt_pwm_disable(cust->data,
cust->config_data.pmic_pad);
} else {
led_tmp_setting.nled_mode = NLED_ON;
mt_led_set_pwm(cust->data, &led_tmp_setting);
}
}
#endif
return 1;
case MT65XX_LED_MODE_GPIO:
LEDS_DEBUG("%s led GPIO mode!!\n", __func__);
return ((cust_set_brightness) (cust->data)) (level);
case MT65XX_LED_MODE_PMIC:
/* for button baclight used SINK channel, when set button ISINK,
* don't do disable other ISINK channel
*/
if ((strcmp(cust->name, "button-backlight") == 0)) {
if (button_flag == false) {
switch (cust->data) {
case MT65XX_LED_PMIC_NLED_ISINK0:
button_flag_isink0 = 1;
break;
case MT65XX_LED_PMIC_NLED_ISINK1:
button_flag_isink1 = 1;
break;
default:
break;
}
button_flag = true;
}
}
return mt_brightness_set_pmic(cust->data, level, bl_div_hal);
case MT65XX_LED_MODE_CUST_LCM:
if (strcmp(cust->name, "lcd-backlight") == 0)
bl_brightness_hal = level;
LEDS_DEBUG("%s backlight control by LCM\n", __func__);
/* warning for this API revork */
return ((cust_brightness_set) (cust->data)) (level, bl_div_hal);
case MT65XX_LED_MODE_CUST_BLS_PWM:
if (strcmp(cust->name, "lcd-backlight") == 0)
bl_brightness_hal = level;
#ifdef MET_USER_EVENT_SUPPORT
if (enable_met_backlight_tag())
output_met_backlight_tag(level);
#endif
pr_info("[LED] disp_bls_set_backlight: %d", level);
return ((cust_set_brightness) (cust->data)) (level);
case MT65XX_LED_MODE_NONE:
default:
break;
}
return -1;
}
void mt_mt65xx_led_work(struct work_struct *work)
{
struct mt65xx_led_data *led_data =
container_of(work, struct mt65xx_led_data, work);
LEDS_DEBUG("%s:%d work start\n", led_data->cust.name, led_data->level);
mutex_lock(&leds_mutex);
mt_mt65xx_led_set_cust(&led_data->cust, led_data->level);
mutex_unlock(&leds_mutex);
}
void mt_mt65xx_led_set(struct led_classdev *led_cdev, enum led_brightness level)
{
int trans_level;
struct mt65xx_led_data *led_data =
container_of(led_cdev, struct mt65xx_led_data, cdev);
/* unsigned long flags; */
/* spin_lock_irqsave(&leds_lock, flags); */
/* do something only when level is changed */
if (led_data->level == level) {
LEDS_DEBUG("no level change,do nothing\n");
return;
}
led_data->level = level;
if (strcmp(led_data->cust.name, "lcd-backlight") != 0) {
LEDS_DEBUG("Set NLED directly %d at time %lu\n",
led_data->level, jiffies);
schedule_work(&led_data->work);
return;
}
if (level != 0 && level * CONFIG_LIGHTNESS_MAPPING_VALUE < 255)
level = 1;
else
level = (level * CONFIG_LIGHTNESS_MAPPING_VALUE) / 255;
backlight_debug_log(led_data->level, level);
trans_level = ((((1 << MT_LED_INTERNAL_LEVEL_BIT_CNT)
- 1) * level +
(((1 << 8) - 1) / 2))
/ ((1 << 8) - 1));
disp_pq_notify_backlight_changed(trans_level);
#ifdef CONFIG_MTK_AAL_SUPPORT
disp_aal_notify_backlight_changed(trans_level);
#else
if (led_data->cust.mode == MT65XX_LED_MODE_CUST_BLS_PWM)
mt_mt65xx_led_set_cust(&led_data->cust, trans_level);
else
mt_mt65xx_led_set_cust(&led_data->cust, level);
#endif
}
/* spin_unlock_irqrestore(&leds_lock, flags); */
/* if(0!=aee_kernel_Powerkey_is_press()) */
/* aee_kernel_wdt_kick_Powkey_api("mt_mt65xx_led_set",WDT_SETBY_Backlight); */
int mt_mt65xx_blink_set(struct led_classdev *led_cdev,
unsigned long *delay_on, unsigned long *delay_off)
{
struct mt65xx_led_data *led_data =
container_of(led_cdev, struct mt65xx_led_data, cdev);
static int got_wake_lock;
struct nled_setting nled_tmp_setting = { 0, 0, 0 };
if ((*delay_on == led_data->delay_on)
&& (*delay_off == led_data->delay_off)) {
LEDS_DEBUG("blink para not changed,do nothing %ld %ld\n",
*delay_on, *delay_off);
return -1;
}
/* only allow software blink when delay_on or delay_off changed */
led_data->delay_on = *delay_on;
led_data->delay_off = *delay_off;
if (led_data->delay_on && led_data->delay_off) {
led_data->level = 255;
/* AP PWM all support OLD mode */
if (led_data->cust.mode == MT65XX_LED_MODE_PWM) {
nled_tmp_setting.nled_mode = NLED_BLINK;
nled_tmp_setting.blink_off_time =
led_data->delay_off;
nled_tmp_setting.blink_on_time =
led_data->delay_on;
mt_led_set_pwm(led_data->cust.data,
&nled_tmp_setting);
} else if (led_data->cust.mode == MT65XX_LED_MODE_PMIC) {
nled_tmp_setting.nled_mode = NLED_BLINK;
nled_tmp_setting.blink_off_time =
led_data->delay_off;
nled_tmp_setting.blink_on_time =
led_data->delay_on;
mt_led_blink_pmic(led_data->cust.data,
&nled_tmp_setting);
} else if (!got_wake_lock) {
__pm_stay_awake(&leds_suspend_lock);
got_wake_lock = 1;
}
} else if (!led_data->delay_on && led_data->delay_off) {
/* AP PWM all support OLD mode */
if (led_data->cust.mode == MT65XX_LED_MODE_PWM) {
nled_tmp_setting.nled_mode = NLED_OFF;
mt_led_set_pwm(led_data->cust.data,
&nled_tmp_setting);
} else if (led_data->cust.mode == MT65XX_LED_MODE_PMIC)
mt_brightness_set_pmic(led_data->cust.data, 0, 0);
else if (got_wake_lock) {
__pm_relax(&leds_suspend_lock);
got_wake_lock = 0;
}
} else if (led_data->delay_on && !led_data->delay_off) {
/* AP PWM all support OLD mode */
if (led_data->cust.mode == MT65XX_LED_MODE_PWM) {
nled_tmp_setting.nled_mode = NLED_ON;
mt_led_set_pwm(led_data->cust.data, &nled_tmp_setting);
} else if (led_data->cust.mode == MT65XX_LED_MODE_PMIC)
mt_brightness_set_pmic(led_data->cust.data, 1, 0);
else if (got_wake_lock) {
__pm_relax(&leds_suspend_lock);
got_wake_lock = 0;
}
} else
return -1;
return 0;
}
@@ -0,0 +1,36 @@
// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _LEDS_HAL_H
#define _LEDS_HAL_H
#include "mtk_leds_sw.h"
/****************************************************************************
* LED HAL functions
***************************************************************************/
extern void mt_leds_wake_lock_init(void);
extern void mt_led_pwm_disable(int pwm_num);
extern int mt_led_set_pwm(int pwm_num, struct nled_setting *led);
extern int mt_led_blink_pmic(enum mt65xx_led_pmic pmic_type,
struct nled_setting *led);
extern int mt_backlight_set_pwm(int pwm_num, u32 level, u32 div,
struct PWM_config *config_data);
extern int mt_brightness_set_pmic(enum mt65xx_led_pmic pmic_type, u32 level,
u32 div);
extern int mt_mt65xx_led_set_cust(struct cust_mt65xx_led *cust, int level);
extern void mt_mt65xx_led_work(struct work_struct *work);
extern void mt_mt65xx_led_set(struct led_classdev *led_cdev,
enum led_brightness level);
extern int mt_mt65xx_blink_set(struct led_classdev *led_cdev,
unsigned long *delay_on, unsigned long *delay_off);
extern struct cust_mt65xx_led *mt_get_cust_led_list(void);
#if defined(CONFIG_BACKLIGHT_SUPPORT_LM3697)
extern int chargepump_set_backlight_level(unsigned int level);
#endif
#endif
@@ -0,0 +1,190 @@
// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _LEDS_SW_H
#define _LEDS_SW_H
/******************************************************************************
* LED & Backlight type defination
*****************************************************************************/
enum mt65xx_led_type {
TYPE_RED = 0,
TYPE_GREEN,
TYPE_BLUE,
TYPE_JOGBALL,
TYPE_KEYBOARD,
TYPE_BUTTON,
TYPE_LCD,
TYPE_TOTAL,
};
enum mt65xx_led_mode {
MT65XX_LED_MODE_NONE,
MT65XX_LED_MODE_PWM,
MT65XX_LED_MODE_GPIO,
MT65XX_LED_MODE_PMIC,
MT65XX_LED_MODE_CUST_LCM,
MT65XX_LED_MODE_CUST_BLS_PWM
};
/******************************************************************************
* for backlight
*****************************************************************************/
/* backlight call back function */
typedef int (*cust_brightness_set) (int level, int div);
typedef int (*cust_set_brightness) (int level);
/* 10bit backlight level */
#define LED_INCREASE_LED_LEVEL_MTKPATCH
#ifdef LED_INCREASE_LED_LEVEL_MTKPATCH
#define MT_LED_INTERNAL_LEVEL_BIT_CNT 10
#endif
/******************************************************************************
* for PMIC
*****************************************************************************/
enum mt65xx_led_pmic {
MT65XX_LED_PMIC_LCD_ISINK = 0,
MT65XX_LED_PMIC_NLED_ISINK_MIN = MT65XX_LED_PMIC_LCD_ISINK,
MT65XX_LED_PMIC_NLED_ISINK0,
MT65XX_LED_PMIC_NLED_ISINK1,
MT65XX_LED_PMIC_NLED_ISINK2,
MT65XX_LED_PMIC_NLED_ISINK3,
MT65XX_LED_PMIC_NLED_ISINK_MAX,
};
enum MT65XX_PMIC_ISINK_MODE {
ISINK_PWM_MODE = 0,
ISINK_BREATH_MODE = 1,
ISINK_REGISTER_MODE = 2
};
enum MT65XX_PMIC_ISINK_STEP {
ISINK_0 = 0, /* 4mA */
ISINK_1 = 1, /* 8mA */
ISINK_2 = 2, /* 12mA */
ISINK_3 = 3, /* 16mA */
ISINK_4 = 4, /* 20mA */
ISINK_5 = 5 /* 24mA */
};
enum MT65XX_PMIC_ISINK_FSEL {
/* 32K clock */
ISINK_1KHZ = 0,
ISINK_200HZ = 4,
ISINK_5HZ = 199,
ISINK_2HZ = 499,
ISINK_1HZ = 999,
ISINK_05HZ = 1999,
ISINK_02HZ = 4999,
ISINK_01HZ = 9999,
/* 2M clock */
ISINK_2M_20KHZ = 2,
ISINK_2M_1KHZ = 61,
ISINK_2M_200HZ = 311,
ISINK_2M_5HZ = 12499,
ISINK_2M_2HZ = 31249,
ISINK_2M_1HZ = 62499,
/* 128K clock */
ISINK_128K_500HZ = 0,
ISINK_128K_256HZ = 1,
ISINK_128K_167HZ = 2,
ISINK_128K_128HZ = 3,
ISINK_128K_100HZ = 4,
ISINK_128K_83HZ = 5,
ISINK_128K_50HZ = 9,
ISINK_128K_17HZ = 28,
};
/******************************************************************************
* for PWM
*****************************************************************************/
/* the min frequence when use old mode pwm by kHz */
#define MIN_FRE_OLD_PWM 32
#define BACKLIGHT_LEVEL_PWM_64_FIFO_MODE_SUPPORT 64
#define BACKLIGHT_LEVEL_PWM_256_SUPPORT 256
#define BACKLIGHT_LEVEL_PWM_MODE_CONFIG BACKLIGHT_LEVEL_PWM_256_SUPPORT
static inline unsigned int Cust_GetBacklightLevelSupport_byPWM(void)
{
return BACKLIGHT_LEVEL_PWM_MODE_CONFIG;
}
static inline unsigned int brightness_mapping(unsigned int level)
{
unsigned int mapped_level;
mapped_level = level;
return mapped_level;
}
struct PWM_config {
int clock_source;
int div;
int low_duration;
int High_duration;
bool pmic_pad;
};
/****************************************************************************
* sw data structures
***************************************************************************/
/**
* led customization data structure
* name : must the same as lights HAL
* mode : control mode
* data :
* PWM: pwm number
* GPIO: gpio id
* PMIC: enum mt65xx_led_pmic
* CUST: custom set brightness function pointer
* config_data: pwm config data
*/
struct cust_mt65xx_led {
char *name;
enum mt65xx_led_mode mode;
long data;
struct PWM_config config_data;
};
/**
* led device node structure with mtk extentions
* cdev: common led device structure
* cust: customization data from device tree
* work: workqueue for specialfied led device
* level: brightness level
* delay_on: on time if led is blinking
* delay_off: off time if led is blinking
*/
struct mt65xx_led_data {
struct led_classdev cdev;
struct cust_mt65xx_led cust;
struct work_struct work;
int level;
int delay_on;
int delay_off;
};
/**
* LED Variable Settings
* nled_mode: 0, off; 1, on; 2, blink
* blink_on_time: on time if led is blinking
* blink_off_time: off time if led is blinking
*/
#define NLED_OFF 0
#define NLED_ON 1
#define NLED_BLINK 2
struct nled_setting {
u8 nled_mode;
u32 blink_on_time;
u32 blink_off_time;
};
#endif /* _LEDS_SW_H */
@@ -0,0 +1,16 @@
#
# Copyright (C) 2015 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
obj-$(CONFIG_MTK_LEDS) := mtk_leds.o
ccflags-y += -I$(srctree)/drivers/misc/mediatek/video/include
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,44 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _LEDS_HAL_H
#define _LEDS_HAL_H
#include "mtk_leds_sw.h"
/****************************************************************************
* LED HAL functions
***************************************************************************/
extern void mt_leds_wake_lock_init(void);
extern unsigned int mt_get_bl_brightness(void);
extern unsigned int mt_get_bl_duty(void);
extern unsigned int mt_get_bl_div(void);
extern unsigned int mt_get_bl_frequency(void);
extern unsigned int *mt_get_div_array(void);
extern void mt_set_bl_duty(unsigned int level);
extern void mt_set_bl_div(unsigned int div);
extern void mt_set_bl_frequency(unsigned int freq);
extern void mt_led_pwm_disable(int pwm_num);
extern int mt_led_set_pwm(int pwm_num, struct nled_setting *led);
extern int mt_led_blink_pmic(enum mt65xx_led_pmic pmic_type,
struct nled_setting *led);
extern int mt_backlight_set_pwm(int pwm_num, u32 level, u32 div,
struct PWM_config *config_data);
extern int mt_brightness_set_pmic(enum mt65xx_led_pmic pmic_type, u32 level,
u32 div);
extern int mt_mt65xx_led_set_cust(struct cust_mt65xx_led *cust, int level);
extern void mt_mt65xx_led_work(struct work_struct *work);
extern void mt_mt65xx_led_set(struct led_classdev *led_cdev,
enum led_brightness level);
extern int mt_mt65xx_blink_set(struct led_classdev *led_cdev,
unsigned long *delay_on, unsigned long *delay_off);
extern struct cust_mt65xx_led *mt_get_cust_led_list(void);
#if defined(CONFIG_BACKLIGHT_SUPPORT_LM3697)
extern int chargepump_set_backlight_level(unsigned int level);
#endif
#endif
@@ -0,0 +1,191 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _LEDS_SW_H
#define _LEDS_SW_H
/******************************************************************************
* LED & Backlight type defination
*****************************************************************************/
enum mt65xx_led_type {
MT65XX_LED_TYPE_RED = 0,
MT65XX_LED_TYPE_GREEN,
MT65XX_LED_TYPE_BLUE,
MT65XX_LED_TYPE_JOGBALL,
MT65XX_LED_TYPE_KEYBOARD,
MT65XX_LED_TYPE_BUTTON,
MT65XX_LED_TYPE_LCD,
MT65XX_LED_TYPE_TOTAL,
};
enum mt65xx_led_mode {
MT65XX_LED_MODE_NONE,
MT65XX_LED_MODE_PWM,
MT65XX_LED_MODE_GPIO,
MT65XX_LED_MODE_PMIC,
MT65XX_LED_MODE_CUST_LCM,
MT65XX_LED_MODE_CUST_BLS_PWM
};
/******************************************************************************
* for backlight
*****************************************************************************/
/* backlight call back function */
typedef int (*cust_brightness_set) (int level, int div);
typedef int (*cust_set_brightness) (int level);
/* 10bit backlight level */
#define LED_INCREASE_LED_LEVEL_MTKPATCH
#ifdef LED_INCREASE_LED_LEVEL_MTKPATCH
#define MT_LED_INTERNAL_LEVEL_BIT_CNT 10
#endif
/******************************************************************************
* for PMIC
*****************************************************************************/
enum mt65xx_led_pmic {
MT65XX_LED_PMIC_LCD_ISINK = 0,
MT65XX_LED_PMIC_NLED_ISINK_MIN = MT65XX_LED_PMIC_LCD_ISINK,
MT65XX_LED_PMIC_NLED_ISINK0,
MT65XX_LED_PMIC_NLED_ISINK1,
MT65XX_LED_PMIC_NLED_ISINK2,
MT65XX_LED_PMIC_NLED_ISINK3,
MT65XX_LED_PMIC_NLED_ISINK_MAX,
};
enum MT65XX_PMIC_ISINK_MODE {
ISINK_PWM_MODE = 0,
ISINK_BREATH_MODE = 1,
ISINK_REGISTER_MODE = 2
};
enum MT65XX_PMIC_ISINK_STEP {
ISINK_0 = 0, /* 4mA */
ISINK_1 = 1, /* 8mA */
ISINK_2 = 2, /* 12mA */
ISINK_3 = 3, /* 16mA */
ISINK_4 = 4, /* 20mA */
ISINK_5 = 5 /* 24mA */
};
enum MT65XX_PMIC_ISINK_FSEL {
/* 32K clock */
ISINK_1KHZ = 0,
ISINK_200HZ = 4,
ISINK_5HZ = 199,
ISINK_2HZ = 499,
ISINK_1HZ = 999,
ISINK_05HZ = 1999,
ISINK_02HZ = 4999,
ISINK_01HZ = 9999,
/* 2M clock */
ISINK_2M_20KHZ = 2,
ISINK_2M_1KHZ = 61,
ISINK_2M_200HZ = 311,
ISINK_2M_5HZ = 12499,
ISINK_2M_2HZ = 31249,
ISINK_2M_1HZ = 62499,
/* 128K clock */
ISINK_128K_500HZ = 0,
ISINK_128K_256HZ = 1,
ISINK_128K_167HZ = 2,
ISINK_128K_128HZ = 3,
ISINK_128K_100HZ = 4,
ISINK_128K_83HZ = 5,
ISINK_128K_50HZ = 9,
ISINK_128K_17HZ = 28,
};
/******************************************************************************
* for PWM
*****************************************************************************/
/* the min frequence when use old mode pwm by kHz */
#define MIN_FRE_OLD_PWM 32
#define BACKLIGHT_LEVEL_PWM_64_FIFO_MODE_SUPPORT 64
#define BACKLIGHT_LEVEL_PWM_256_SUPPORT 256
#define BACKLIGHT_LEVEL_PWM_MODE_CONFIG BACKLIGHT_LEVEL_PWM_256_SUPPORT
static inline unsigned int Cust_GetBacklightLevelSupport_byPWM(void)
{
return BACKLIGHT_LEVEL_PWM_MODE_CONFIG;
}
static inline unsigned int brightness_mapping(unsigned int level)
{
unsigned int mapped_level;
mapped_level = level;
return mapped_level;
}
struct PWM_config {
int clock_source;
int div;
int low_duration;
int High_duration;
bool pmic_pad;
};
/****************************************************************************
* sw data structures
***************************************************************************/
/**
* led customization data structure
* name : must the same as lights HAL
* mode : control mode
* data :
* PWM: pwm number
* GPIO: gpio id
* PMIC: enum mt65xx_led_pmic
* CUST: custom set brightness function pointer
* config_data: pwm config data
*/
struct cust_mt65xx_led {
char *name;
enum mt65xx_led_mode mode;
long data;
int led_bits;
struct PWM_config config_data;
};
/**
* led device node structure with mtk extentions
* cdev: common led device structure
* cust: customization data from device tree
* work: workqueue for specialfied led device
* level: brightness level
* delay_on: on time if led is blinking
* delay_off: off time if led is blinking
*/
struct mt65xx_led_data {
struct led_classdev cdev;
struct cust_mt65xx_led cust;
struct work_struct work;
int level;
int delay_on;
int delay_off;
};
/**
* LED Variable Settings
* nled_mode: 0, off; 1, on; 2, blink
* blink_on_time: on time if led is blinking
* blink_off_time: off time if led is blinking
*/
#define NLED_OFF 0
#define NLED_ON 1
#define NLED_BLINK 2
struct nled_setting {
u8 nled_mode;
u32 blink_on_time;
u32 blink_off_time;
};
#endif /* _LEDS_SW_H */
+541
View File
@@ -0,0 +1,541 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2018 MediaTek Inc.
*
*/
#include <linux/init.h>
#include <linux/module.h>
#include <linux/device.h>
#include "mt_led_trigger.h"
const char *mt_led_trigger_mode_name[MT_LED_MODE_MAX] = {
"default_mode",
"register_mode",
"pwm_mode",
"breath_mode",
};
static ssize_t mt_led_register_attr_show(struct device *dev,
struct device_attribute *attr, char *buf);
static ssize_t mt_led_register_attr_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t cnt);
static const struct device_attribute mt_led_register_mode_attrs[] = {
__ATTR(soft_start_step, 0644,
mt_led_register_attr_show, mt_led_register_attr_store),
};
static ssize_t mt_led_register_attr_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct led_classdev *led_cdev = dev_get_drvdata(dev);
struct mt_led_info *info = (struct mt_led_info *)led_cdev;
int ret = 0;
ptrdiff_t cmd;
unsigned int value;
cmd = attr - mt_led_register_mode_attrs;
buf[0] = '\0';
dev_info(led_cdev->dev, "%s cmd = %d\n", __func__, (int)cmd);
switch (cmd) {
case REGISTER_MODE_ATTR_SFSTR:
ret = info->ops->get_current_step(info, &value);
if (ret < 0)
return ret;
break;
default:
return -EINVAL;
}
snprintf(buf, PAGE_SIZE, "%d\n", value);
return strlen(buf);
}
static ssize_t mt_led_register_attr_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t cnt)
{
struct led_classdev *led_cdev = dev_get_drvdata(dev);
struct mt_led_info *info = (struct mt_led_info *)led_cdev;
int ret = 0;
unsigned long value = 0;
ptrdiff_t cmd;
cmd = attr - mt_led_register_mode_attrs;
ret = kstrtoul(buf, 10, &value);
if (ret < 0)
return ret;
dev_info(led_cdev->dev, "%s cmd = %d\n", __func__, (int)cmd);
switch (cmd) {
case REGISTER_MODE_ATTR_SFSTR:
ret = info->ops->set_current_step(info, value);
if (ret < 0)
return ret;
break;
default:
break;
}
return cnt;
}
static int mt_led_register_activate(struct led_classdev *led)
{
struct mt_led_info *info = (struct mt_led_info *)led;
int i = 0, ret = 0;
if ((info->magic_code & MT_LED_MAGIC_MASK) == MT_LED_MAGIC_CODE &&
(info->magic_code & MT_LED_MAGIC_REGISTER_MODE) != 0) {
//check ops
if (info->ops == NULL) {
dev_notice(led->dev, "%s: operation is NULL\n", __func__);
return 0;
}
for (i = 0; i < ARRAY_SIZE(mt_led_register_mode_attrs); i++) {
ret = device_create_file(led->dev,
mt_led_register_mode_attrs + i);
if (ret < 0) {
dev_notice(led->dev,
"%s: create file fail %d\n",
__func__, i);
goto out_create_file;
}
}
ret = info->ops->change_mode(led, MT_LED_REGISTER_MODE);
if (ret < 0) {
dev_notice(led->dev, "%s: change mode fail\n", __func__);
goto out_change_mode;
}
return ret;
out_change_mode:
i = ARRAY_SIZE(mt_led_register_mode_attrs);
out_create_file:
while (--i > 0)
device_remove_file(led->dev, mt_led_register_mode_attrs + i);
} else
dev_notice(led->dev, "not Support MT REGISTER Trigger\n");
return ret;
}
static void mt_led_register_deactivate(struct led_classdev *led)
{
struct mt_led_info *info = (struct mt_led_info *)led;
int i = 0, ret = 0;
for (i = 0; i < ARRAY_SIZE(mt_led_register_mode_attrs); i++)
device_remove_file(led->dev, mt_led_register_mode_attrs + i);
ret = info->ops->change_mode(led, MT_LED_DEFAULT_MODE);
if (ret < 0)
dev_notice(led->dev, "%s change mode fail\n", __func__);
}
static ssize_t mt_led_pwm_attr_show(struct device *dev,
struct device_attribute *attr, char *buf);
static ssize_t mt_led_pwm_attr_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t cnt);
static const struct device_attribute mt_led_pwm_mode_attrs[] = {
__ATTR(pwm_dim_duty, 0644, mt_led_pwm_attr_show, mt_led_pwm_attr_store),
__ATTR(pwm_dim_freq, 0644, mt_led_pwm_attr_show, mt_led_pwm_attr_store),
__ATTR(list_duty, 0444, mt_led_pwm_attr_show, NULL),
__ATTR(list_freq, 0444, mt_led_pwm_attr_show, NULL),
};
static ssize_t mt_led_pwm_attr_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct led_classdev *led_cdev = dev_get_drvdata(dev);
struct mt_led_info *info = (struct mt_led_info *)led_cdev;
int ret = 0;
ptrdiff_t cmd = attr - mt_led_pwm_mode_attrs;
//no float in kernel
int precision = 10000;
int value_HZ;
unsigned int dim_duty;
unsigned int dim_freq;
buf[0] = '\0';
dev_info(led_cdev->dev, "%s cmd = %d\n", __func__, (int)cmd);
switch (cmd) {
case PWM_MODE_ATTR_DIM_DUTY:
ret = info->ops->get_pwm_dim_duty(info, &dim_duty);
if (ret < 0)
return ret;
snprintf(buf, PAGE_SIZE, "%d (0~255)\n", dim_duty);
break;
case PWM_MODE_ATTR_DIM_FREQ:
ret = info->ops->get_pwm_dim_freq(info, &dim_freq);
if (ret < 0)
return ret;
value_HZ = (1000*precision)/((dim_freq+1)*2);
snprintf(buf, PAGE_SIZE, "%d.%d Hz\n", value_HZ/precision, value_HZ%precision);
break;
case PWM_MODE_ATTR_LIST_DUTY:
ret = info->ops->list_pwm_duty(info, buf);
break;
case PWM_MODE_ATTR_LIST_FREQ:
ret = info->ops->list_pwm_freq(info, buf);
break;
default:
return -EINVAL;
}
if (ret < 0)
return ret;
return strlen(buf);
}
static ssize_t mt_led_pwm_attr_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t cnt)
{
struct led_classdev *led_cdev = dev_get_drvdata(dev);
struct mt_led_info *info = (struct mt_led_info *)led_cdev;
int ret = 0;
unsigned long value = 0;
ptrdiff_t cmd = attr - mt_led_pwm_mode_attrs;
ret = kstrtoul(buf, 10, &value);
if (ret < 0)
return ret;
dev_info(led_cdev->dev, "%s cmd = %d\n", __func__, (int)cmd);
switch (cmd) {
case PWM_MODE_ATTR_DIM_DUTY:
ret = info->ops->set_pwm_dim_duty(info, value);
break;
case PWM_MODE_ATTR_DIM_FREQ:
ret = info->ops->set_pwm_dim_freq(info, value);
break;
default:
return -EINVAL;
}
if (ret < 0)
return ret;
return cnt;
}
static int mt_led_pwm_activate(struct led_classdev *led)
{
struct mt_led_info *info = (struct mt_led_info *)led;
int i = 0, ret = 0;
if ((info->magic_code & MT_LED_MAGIC_MASK) == MT_LED_MAGIC_CODE &&
(info->magic_code & MT_LED_MAGIC_PWM_MODE) != 0) {
//check ops
if (info->ops == NULL) {
dev_notice(led->dev, "%s: operation is NULL\n", __func__);
return 0;
}
for (i = 0; i < ARRAY_SIZE(mt_led_pwm_mode_attrs); i++) {
ret = device_create_file(led->dev,
mt_led_pwm_mode_attrs + i);
if (ret < 0) {
dev_notice(led->dev,
"%s: create file fail %d\n",
__func__, i);
goto out_create_file;
}
}
ret = info->ops->change_mode(led, MT_LED_PWM_MODE);
if (ret < 0) {
dev_notice(led->dev, "%s change pwm_mode fail\n", __func__);
goto out_change_mode;
}
return ret;
out_change_mode:
i = ARRAY_SIZE(mt_led_pwm_mode_attrs);
out_create_file:
while (--i > 0)
device_remove_file(led->dev, mt_led_pwm_mode_attrs + i);
} else
dev_notice(led->dev, "Not Support MT PWM Trigger\n");
return ret;
}
static void mt_led_pwm_deactivate(struct led_classdev *led)
{
struct mt_led_info *info = (struct mt_led_info *)led;
int i = 0, ret = 0;
for (i = 0; i < ARRAY_SIZE(mt_led_pwm_mode_attrs); i++)
device_remove_file(led->dev, mt_led_pwm_mode_attrs + i);
ret = info->ops->change_mode(led, MT_LED_DEFAULT_MODE);
if (ret < 0)
dev_notice(led->dev, "%s change mode fail\n", __func__);
}
static ssize_t mt_led_breath_attr_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t cnt);
static ssize_t mt_led_breath_attr_show(struct device *dev,
struct device_attribute *attr, char *buf);
static const struct device_attribute mt_led_breath_mode_attrs[] = {
__ATTR(tr1, 0644, mt_led_breath_attr_show, mt_led_breath_attr_store),
__ATTR(tr2, 0644, mt_led_breath_attr_show, mt_led_breath_attr_store),
__ATTR(tf1, 0644, mt_led_breath_attr_show, mt_led_breath_attr_store),
__ATTR(tf2, 0644, mt_led_breath_attr_show, mt_led_breath_attr_store),
__ATTR(ton, 0644, mt_led_breath_attr_show, mt_led_breath_attr_store),
__ATTR(toff, 0644, mt_led_breath_attr_show, mt_led_breath_attr_store),
__ATTR(list_time, 0444, mt_led_breath_attr_show, NULL),
};
static ssize_t mt_led_breath_attr_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
int ret = 0;
ptrdiff_t cmd = attr - mt_led_breath_mode_attrs;
struct led_classdev *led_cdev = dev_get_drvdata(dev);
struct mt_led_info *info = (struct mt_led_info *)led_cdev;
unsigned int value;
buf[0] = '\0';
dev_info(led_cdev->dev, "%s cmd = %d\n", __func__, (int)cmd);
switch (cmd) {
case BREATH_MODE_ATTR_TR1:
ret = info->ops->get_breath_tr1(info, &value);
break;
case BREATH_MODE_ATTR_TR2:
ret = info->ops->get_breath_tr2(info, &value);
break;
case BREATH_MODE_ATTR_TF1:
ret = info->ops->get_breath_tf1(info, &value);
break;
case BREATH_MODE_ATTR_TF2:
ret = info->ops->get_breath_tf2(info, &value);
break;
case BREATH_MODE_ATTR_TON:
ret = info->ops->get_breath_ton(info, &value);
break;
case BREATH_MODE_ATTR_TOFF:
ret = info->ops->get_breath_toff(info, &value);
break;
default:
return -EINVAL;
}
if (ret < 0)
return ret;
snprintf(buf, PAGE_SIZE, "%d\n", value);
return strlen(buf);
}
static ssize_t mt_led_breath_attr_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t cnt)
{
struct led_classdev *led_cdev = dev_get_drvdata(dev);
struct mt_led_info *info = (struct mt_led_info *)led_cdev;
int ret = 0;
unsigned long value = 0;
ptrdiff_t cmd = attr - mt_led_breath_mode_attrs;
ret = kstrtoul(buf, 10, &value);
if (ret < 0)
return ret;
dev_info(led_cdev->dev, "%s cmd = %d\n", __func__, (int)cmd);
switch (cmd) {
case BREATH_MODE_ATTR_TR1:
ret = info->ops->set_breath_tr1(info, value);
break;
case BREATH_MODE_ATTR_TR2:
ret = info->ops->set_breath_tr2(info, value);
break;
case BREATH_MODE_ATTR_TF1:
ret = info->ops->set_breath_tf1(info, value);
break;
case BREATH_MODE_ATTR_TF2:
ret = info->ops->set_breath_tf2(info, value);
break;
case BREATH_MODE_ATTR_TON:
ret = info->ops->set_breath_ton(info, value);
break;
case BREATH_MODE_ATTR_TOFF:
ret = info->ops->set_breath_toff(info, value);
break;
default:
return -EINVAL;
}
if (ret < 0)
return ret;
return cnt;
}
static int mt_led_breath_activate(struct led_classdev *led)
{
struct mt_led_info *info = (struct mt_led_info *)led;
int i = 0, ret = 0;
if ((info->magic_code & MT_LED_MAGIC_MASK) == MT_LED_MAGIC_CODE &&
(info->magic_code & MT_LED_MAGIC_BREATH_MODE) != 0) {
//check ops
if (info->ops == NULL) {
dev_notice(led->dev, "%s: operation is NULL\n", __func__);
return 0;
}
for (i = 0; i < ARRAY_SIZE(mt_led_breath_mode_attrs); i++) {
ret = device_create_file(led->dev,
mt_led_breath_mode_attrs + i);
if (ret < 0) {
dev_notice(led->dev,
"%s: create file fail %d\n",
__func__, i);
goto out_create_file;
}
}
ret = info->ops->change_mode(led, MT_LED_BREATH_MODE);
if (ret < 0) {
dev_notice(led->dev, "%s change breath_mode fail: %d\n", __func__, ret);
goto out_change_mode;
}
return ret;
out_change_mode:
i = ARRAY_SIZE(mt_led_breath_mode_attrs);
out_create_file:
while (--i >= 0)
device_remove_file(
led->dev, mt_led_breath_mode_attrs + i);
} else
dev_notice(led->dev, "Not Support MT Breath Trigger\n");
return ret;
}
static void mt_led_breath_deactivate(struct led_classdev *led)
{
struct mt_led_info *info = (struct mt_led_info *)led;
int i = 0, ret = 0;
for (i = 0; i < ARRAY_SIZE(mt_led_breath_mode_attrs); i++)
device_remove_file(led->dev, mt_led_breath_mode_attrs + i);
ret = info->ops->change_mode(led, MT_LED_DEFAULT_MODE);
if (ret < 0)
dev_notice(led->dev, "%s change mode fail\n", __func__);
}
static struct led_trigger mt_led_trigger[] = {
{
.name = "register_mode",
.activate = mt_led_register_activate,
.deactivate = mt_led_register_deactivate,
},
{
.name = "pwm_mode",
.activate = mt_led_pwm_activate,
.deactivate = mt_led_pwm_deactivate,
},
{
.name = "breath_mode",
.activate = mt_led_breath_activate,
.deactivate = mt_led_breath_deactivate,
},
};
int mt_led_check_ops(struct mt_led_ops *ops)
{
if (!ops->get_current_step)
return -EINVAL;
if (!ops->set_current_step)
return -EINVAL;
if (!ops->get_pwm_dim_duty)
return -EINVAL;
if (!ops->set_pwm_dim_duty)
return -EINVAL;
if (!ops->get_pwm_dim_freq)
return -EINVAL;
if (!ops->set_pwm_dim_freq)
return -EINVAL;
if (!ops->get_breath_tr1)
return -EINVAL;
if (!ops->set_breath_tr1)
return -EINVAL;
if (!ops->get_breath_tr2)
return -EINVAL;
if (!ops->set_breath_tr2)
return -EINVAL;
if (!ops->get_breath_tf1)
return -EINVAL;
if (!ops->set_breath_tf1)
return -EINVAL;
if (!ops->get_breath_tf2)
return -EINVAL;
if (!ops->set_breath_tf2)
return -EINVAL;
if (!ops->get_breath_ton)
return -EINVAL;
if (!ops->set_breath_ton)
return -EINVAL;
if (!ops->get_breath_toff)
return -EINVAL;
if (!ops->set_breath_toff)
return -EINVAL;
if (!ops->list_pwm_duty)
return -EINVAL;
if (!ops->list_pwm_freq)
return -EINVAL;
return 0;
}
int mt_led_trigger_register(struct mt_led_ops *ops)
{
int i = 0, ret = 0;
ret = mt_led_check_ops(ops);
if (ret < 0) {
pr_notice("%s all ops need to be implment\n", __func__);
return -EINVAL;
}
for (i = 0; i < ARRAY_SIZE(mt_led_trigger); i++) {
ret = led_trigger_register(&mt_led_trigger[i]);
if (ret < 0) {
pr_notice("%s register led %d fail\n", __func__, i);
goto out_led_trigger;
}
}
return 0;
out_led_trigger:
while (--i > 0)
led_trigger_unregister(&mt_led_trigger[i]);
return -EINVAL;
}
void mt_led_trigger_unregister(void)
{
int i = 0;
for (i = 0; i < ARRAY_SIZE(mt_led_trigger); i++)
led_trigger_unregister(&mt_led_trigger[i]);
}
MODULE_AUTHOR("Mediatek Corporation>");
MODULE_DESCRIPTION("MT6357 PMIC LED Trigger");
MODULE_LICENSE("GPL");
MODULE_VERSION("1.0.0");
@@ -0,0 +1,94 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2018 MediaTek Inc.
*
*/
#ifndef _MT_LED_INFO
#define _MT_LED_INFO
#include <linux/leds.h>
#define MT_LED_MAGIC_CODE (5527890) /* 0x545505 */
#define MT_LED_MAGIC_MASK (0xffffff)
#define MT_LED_MAGIC_REGISTER_MODE (1 << 24)
#define MT_LED_MAGIC_PWM_MODE (1 << 25)
#define MT_LED_MAGIC_BREATH_MODE (1 << 26)
#define MT_LED_REGISTER_MAGIC_CODE (MT_LED_MAGIC_REGISTER_MODE|MT_LED_MAGIC_CODE)
#define MT_LED_PWM_MAGIC_CODE (MT_LED_MAGIC_PWM_MODE|MT_LED_MAGIC_CODE)
#define MT_LED_BREATH_MAGIC_CODE (MT_LED_MAGIC_BREATH_MODE|MT_LED_MAGIC_CODE)
#define MT_LED_ALL_MAGIC_CODE (MT_LED_MAGIC_REGISTER_MODE|MT_LED_MAGIC_PWM_MODE|\
MT_LED_MAGIC_BREATH_MODE|MT_LED_MAGIC_CODE)
enum {
REGISTER_MODE_ATTR_SFSTR,
};
enum {
PWM_MODE_ATTR_DIM_DUTY,
PWM_MODE_ATTR_DIM_FREQ,
PWM_MODE_ATTR_LIST_DUTY,
PWM_MODE_ATTR_LIST_FREQ,
};
enum {
BREATH_MODE_ATTR_TR1,
BREATH_MODE_ATTR_TR2,
BREATH_MODE_ATTR_TF1,
BREATH_MODE_ATTR_TF2,
BREATH_MODE_ATTR_TON,
BREATH_MODE_ATTR_TOFF,
BREATH_MODE_ATTR_LIST_TIME,
};
enum {
MT_LED_DEFAULT_MODE,
MT_LED_REGISTER_MODE,
MT_LED_PWM_MODE,
MT_LED_BREATH_MODE,
MT_LED_MODE_MAX,
};
extern const char *mt_led_trigger_mode_name[MT_LED_MODE_MAX];
struct mt_led_info;
struct mt_led_ops {
int (*change_mode)(struct led_classdev *led, int mode);
int (*get_current_step)(struct mt_led_info *info, int *value);
int (*set_current_step)(struct mt_led_info *info, int step);
int (*get_pwm_dim_duty)(struct mt_led_info *info, int *value);
int (*set_pwm_dim_duty)(struct mt_led_info *info, int duty);
int (*get_pwm_dim_freq)(struct mt_led_info *info, int *value);
int (*set_pwm_dim_freq)(struct mt_led_info *info, int freq);
int (*list_pwm_duty)(struct mt_led_info *info, char *buf);
int (*list_pwm_freq)(struct mt_led_info *info, char *buf);
int (*get_breath_tr1)(struct mt_led_info *info, int *value);
int (*get_breath_tr2)(struct mt_led_info *info, int *value);
int (*get_breath_tf1)(struct mt_led_info *info, int *value);
int (*get_breath_tf2)(struct mt_led_info *info, int *value);
int (*get_breath_ton)(struct mt_led_info *info, int *value);
int (*get_breath_toff)(struct mt_led_info *info, int *value);
int (*set_breath_tr1)(struct mt_led_info *info, int time);
int (*set_breath_tr2)(struct mt_led_info *info, int time);
int (*set_breath_tf1)(struct mt_led_info *info, int time);
int (*set_breath_tf2)(struct mt_led_info *info, int time);
int (*set_breath_ton)(struct mt_led_info *info, int time);
int (*set_breath_toff)(struct mt_led_info *info, int time);
};
struct mt_led_info {
struct led_classdev cdev;
struct mt_led_ops *ops;
uint32_t magic_code;
};
extern int mt_led_trigger_register(struct mt_led_ops *ops);
extern void mt_led_trigger_unregister(void);
#endif /* _MT_LED_INFO */
+646
View File
@@ -0,0 +1,646 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2018 MediaTek Inc.
*
*/
#include <linux/i2c.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/delay.h>
#include <linux/string.h>
#include <linux/ctype.h>
#include <linux/leds.h>
#include <linux/workqueue.h>
#include <linux/pm_wakeup.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <mtk_leds_hal.h>
#include <mtk_leds_drv.h>
#ifdef CONFIG_MTK_PWM
#include <mt-plat/mtk_pwm.h>
#endif
#ifdef CONFIG_MTK_AAL_SUPPORT
#include <ddp_aal.h>
#endif
#ifdef CONFIG_BACKLIGHT_SUPPORT_LP8557
#include <linux/of_gpio.h>
#include <linux/gpio.h>
#include <asm-generic/gpio.h>
#endif
#undef pr_fmt
#define pr_fmt(fmt) KBUILD_MODNAME " %s(%d) :" fmt, __func__, __LINE__
/****************************************************************************
* variables
***************************************************************************/
#ifndef CONFIG_MTK_PWM
#define CLK_DIV1 0
#endif
struct cust_mt65xx_led *bl_setting;
#ifndef CONFIG_MTK_AAL_SUPPORT
static unsigned int bl_div = CLK_DIV1;
#endif
#define PWM_DIV_NUM 8
static unsigned int div_array[PWM_DIV_NUM];
struct mt65xx_led_data *g_leds_data[MT65XX_LED_TYPE_TOTAL];
#ifdef CONFIG_BACKLIGHT_SUPPORT_LP8557
static unsigned int last_level1 = 102;
static struct i2c_client *g_client;
static int I2C_SET_FOR_BACKLIGHT = 350;
#endif
/****************************************************************************
* function prototypes
***************************************************************************/
#ifndef CONTROL_BL_TEMPERATURE
#define CONTROL_BL_TEMPERATURE
#endif
#define MT_LED_INTERNAL_LEVEL_BIT_CNT 10
/******************************************************************************
* for DISP backlight High resolution
*****************************************************************************/
#ifdef LED_INCREASE_LED_LEVEL_MTKPATCH
#define LED_INTERNAL_LEVEL_BIT_CNT 10
#endif
/* Fix dependency if CONFIG_MTK_LCM not ready */
void __weak disp_aal_notify_backlight_changed(int bl_1024) {};
bool __weak disp_aal_is_support(void) { return false; };
int __weak disp_bls_set_max_backlight(unsigned int level_1024) { return 0; };
int __weak disp_bls_set_backlight(int level_1024) { return 0; }
int __weak mtkfb_set_backlight_level(unsigned int level) { return 0; };
void __weak disp_pq_notify_backlight_changed(int bl_1024) {};
static int mt65xx_led_set_cust(struct cust_mt65xx_led *cust, int level);
/****************************************************************************
* add API for temperature control
***************************************************************************/
#ifdef CONTROL_BL_TEMPERATURE
/* define int limit for brightness limitation */
static unsigned int limit = 255;
static unsigned int limit_flag;
static unsigned int last_level;
static unsigned int current_level;
static DEFINE_MUTEX(bl_level_limit_mutex);
/****************************************************************************
* external functions for display
* this API add for control the power and temperature,
* if enabe=1, the value of brightness will smaller than max_level,
* whatever lightservice transfers to driver.
***************************************************************************/
int setMaxbrightness(int max_level, int enable)
{
#if !defined(CONFIG_MTK_AAL_SUPPORT)
struct cust_mt65xx_led *cust_led_list = mt_get_cust_led_list();
mutex_lock(&bl_level_limit_mutex);
if (enable == 1) {
limit_flag = 1;
limit = max_level;
mutex_unlock(&bl_level_limit_mutex);
if (current_level != 0) {
if (limit < last_level) {
pr_info
("Max brightness limit=%d\n", limit);
mt65xx_led_set_cust(&cust_led_list
[MT65XX_LED_TYPE_LCD],
limit);
} else {
mt65xx_led_set_cust(&cust_led_list
[MT65XX_LED_TYPE_LCD],
last_level);
}
}
} else {
limit_flag = 0;
limit = 255;
mutex_unlock(&bl_level_limit_mutex);
if (current_level != 0) {
pr_info("Control temperature close:limit=%d\n",
limit);
mt65xx_led_set_cust(&cust_led_list[MT65XX_LED_TYPE_LCD],
last_level);
}
}
#else
pr_info("Set max brightness go through AAL\n");
disp_bls_set_max_backlight(((((1 << LED_INTERNAL_LEVEL_BIT_CNT) -
1) * max_level + 127) / 255));
#endif /* endif CONFIG_MTK_AAL_SUPPORT */
return 0;
}
EXPORT_SYMBOL(setMaxbrightness);
#endif
/****************************************************************************
* internal functions
***************************************************************************/
static void get_div_array(void)
{
int i = 0;
unsigned int *temp = mt_get_div_array();
while (i < PWM_DIV_NUM) {
div_array[i] = *temp++;
pr_debug("div_array=%d\n", div_array[i]);
i++;
}
}
static int led_set_pwm(int pwm_num, struct nled_setting *led)
{
mt_led_set_pwm(pwm_num, led);
return 0;
}
static int mt65xx_led_set_cust(struct cust_mt65xx_led *cust, int level)
{
#ifdef CONTROL_BL_TEMPERATURE
mutex_lock(&bl_level_limit_mutex);
current_level = level;
if (limit_flag == 0) {
last_level = level;
} else {
if (limit < current_level)
level = limit;
}
mutex_unlock(&bl_level_limit_mutex);
#endif
#ifdef LED_INCREASE_LED_LEVEL_MTKPATCH
if (cust->mode == MT65XX_LED_MODE_CUST_BLS_PWM) {
mt_mt65xx_led_set_cust(cust,
((((1 << LED_INTERNAL_LEVEL_BIT_CNT) -
1) * level + 127) / 255));
} else {
mt_mt65xx_led_set_cust(cust, level);
}
#else
mt_mt65xx_led_set_cust(cust, level);
#endif
return -1;
}
static void mt65xx_led_set(struct led_classdev *led_cdev,
enum led_brightness level)
{
struct mt65xx_led_data *led_data =
container_of(led_cdev, struct mt65xx_led_data, cdev);
#ifdef CONFIG_BACKLIGHT_SUPPORT_LP8557
bool flag = FALSE;
int value = 0;
int retval;
struct device_node *node = NULL;
struct i2c_client *client = g_client;
value = i2c_smbus_read_byte_data(g_client, 0x10);
pr_debug("read_byte_data: 0x10 = %d\n", value);
node = of_find_compatible_node(NULL, NULL,
"mediatek,lcd-backlight");
if (node) {
I2C_SET_FOR_BACKLIGHT = of_get_named_gpio(node, "gpios", 0);
pr_debug("Led_i2c gpio num for power:%d\n",
I2C_SET_FOR_BACKLIGHT);
}
#endif
if (strcmp(led_data->cust.name, "lcd-backlight") == 0) {
#ifdef CONTROL_BL_TEMPERATURE
mutex_lock(&bl_level_limit_mutex);
current_level = level;
if (limit_flag == 0) {
last_level = level;
} else {
if (limit < current_level) {
level = limit;
pr_debug
("set backlight: control level=%d\n",
level);
}
}
mutex_unlock(&bl_level_limit_mutex);
#endif
}
#ifdef CONFIG_BACKLIGHT_SUPPORT_LP8557
retval = gpio_request(I2C_SET_FOR_BACKLIGHT, "i2c_set_for_backlight");
if (retval)
pr_debug("Request I2C gpio149 failed\n");
if (strcmp(led_data->cust.name, "lcd-backlight") == 0) {
if (level == 0) {
pr_debug("Level = %d, close the power\n", level);
i2c_smbus_write_byte_data(client, 0x00, 0);
gpio_direction_output(I2C_SET_FOR_BACKLIGHT, 0);
}
if (!last_level1 && level) {
pr_debug("Level = %d, open the power\n", level);
gpio_direction_output(I2C_SET_FOR_BACKLIGHT, 1);
mdelay(100);
i2c_smbus_write_byte_data(client, 0x10, 4);
flag = TRUE;
}
last_level1 = level;
}
gpio_free(I2C_SET_FOR_BACKLIGHT);
#endif
mt_mt65xx_led_set(led_cdev, level);
#ifdef CONFIG_BACKLIGHT_SUPPORT_LP8557
if (strcmp(led_data->cust.name, "lcd-backlight") == 0) {
if (flag) {
i2c_smbus_write_byte_data(client, 0x14, 0xdf);
i2c_smbus_write_byte_data(client, 0x04, 0xff);
i2c_smbus_write_byte_data(client, 0x00, 1);
}
}
#endif
}
static int mt65xx_blink_set(struct led_classdev *led_cdev,
unsigned long *delay_on, unsigned long *delay_off)
{
if (mt_mt65xx_blink_set(led_cdev, delay_on, delay_off))
return -1;
else
return 0;
}
/****************************************************************************
* external functions for display
***************************************************************************/
int mt65xx_leds_brightness_set(enum mt65xx_led_type type,
enum led_brightness level)
{
int val;
struct cust_mt65xx_led *cust_led_list = mt_get_cust_led_list();
#ifdef CONFIG_BACKLIGHT_SUPPORT_LP8557
bool flag = FALSE;
int value = 0;
int retval;
struct device_node *node = NULL;
struct i2c_client *client = g_client;
value = i2c_smbus_read_byte_data(g_client, 0x10);
pr_debug("LEDS:mt65xx_led_set:0x10 = %d\n", value);
node = of_find_compatible_node(NULL, NULL,
"mediatek,lcd-backlight");
if (node) {
I2C_SET_FOR_BACKLIGHT = of_get_named_gpio(node, "gpios", 0);
pr_debug("Led_i2c gpio num for power:%d\n",
I2C_SET_FOR_BACKLIGHT);
}
#endif
pr_debug("light type: #%d, level: %d\n", type, level);
if (type < 0 || type >= MT65XX_LED_TYPE_TOTAL)
return -1;
if (level > LED_FULL)
level = LED_FULL;
else if (level < 0)
level = 0;
#ifdef CONFIG_BACKLIGHT_SUPPORT_LP8557
retval = gpio_request(I2C_SET_FOR_BACKLIGHT, "i2c_set_for_backlight");
if (retval)
pr_debug("Request I2C gpio149 failed\n");
if (strcmp(cust_led_list[type].name, "lcd-backlight") == 0) {
if (level == 0) {
i2c_smbus_write_byte_data(client, 0x00, 0);
gpio_direction_output(I2C_SET_FOR_BACKLIGHT, 0);
}
if (!last_level1 && level) {
gpio_direction_output(I2C_SET_FOR_BACKLIGHT, 1);
mdelay(100);
i2c_smbus_write_byte_data(client, 0x10, 4);
flag = TRUE;
}
last_level1 = level;
}
gpio_free(I2C_SET_FOR_BACKLIGHT);
#endif
val = mt65xx_led_set_cust(&cust_led_list[type], level);
#ifdef CONFIG_BACKLIGHT_SUPPORT_LP8557
if (strcmp(cust_led_list[type].name, "lcd-backlight") == 0) {
if (flag) {
i2c_smbus_write_byte_data(client, 0x14, 0xdf);
i2c_smbus_write_byte_data(client, 0x04, 0xff);
i2c_smbus_write_byte_data(client, 0x00, 1);
}
}
#endif
return val;
}
EXPORT_SYMBOL(mt65xx_leds_brightness_set);
/****************************************************************************
* external functions for AAL
***************************************************************************/
int backlight_brightness_set(int level)
{
struct cust_mt65xx_led *cust_led_list = mt_get_cust_led_list();
if (level > ((1 << MT_LED_INTERNAL_LEVEL_BIT_CNT) - 1))
level = ((1 << MT_LED_INTERNAL_LEVEL_BIT_CNT) - 1);
else if (level < 0)
level = 0;
if (MT65XX_LED_MODE_CUST_BLS_PWM ==
cust_led_list[MT65XX_LED_TYPE_LCD].mode) {
#ifdef CONTROL_BL_TEMPERATURE
mutex_lock(&bl_level_limit_mutex);
current_level = (level >> (MT_LED_INTERNAL_LEVEL_BIT_CNT - 8));
if (limit_flag == 0) {
last_level = current_level;
} else {
if (limit < current_level) {
/* extend 8-bit limit to 10 bits */
level =
(limit <<
(MT_LED_INTERNAL_LEVEL_BIT_CNT -
8)) | (limit >> (16 -
MT_LED_INTERNAL_LEVEL_BIT_CNT));
}
}
mutex_unlock(&bl_level_limit_mutex);
#endif
return
mt_mt65xx_led_set_cust(&cust_led_list[MT65XX_LED_TYPE_LCD],
level);
} else {
return mt65xx_led_set_cust(&cust_led_list[MT65XX_LED_TYPE_LCD],
(level >>
(MT_LED_INTERNAL_LEVEL_BIT_CNT -
8)));
}
}
EXPORT_SYMBOL(backlight_brightness_set);
#ifdef CONFIG_BACKLIGHT_SUPPORT_LP8557
static int led_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id);
static int led_i2c_remove(struct i2c_client *client);
static const struct of_device_id lp855x_id[] = {
{.compatible = "mediatek,8173led_i2c"},
{.compatible = "ti,lp8557_led"},
{},
};
MODULE_DEVICE_TABLE(OF, lp855x_id);
static const struct i2c_device_id lp855x_i2c_id[] = {{"lp8557_led", 0}, {} };
struct i2c_driver led_i2c_driver = {
.probe = led_i2c_probe,
.remove = led_i2c_remove,
.driver = {
.name = "lp8557_led",
.owner = THIS_MODULE,
.of_match_table = of_match_ptr(lp855x_id),
},
.id_table = lp855x_i2c_id,
};
static int led_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
g_client = client;
return 0;
}
static int led_i2c_remove(struct i2c_client *client)
{
return 0;
}
#endif
/****************************************************************************
* driver functions
***************************************************************************/
static int mt65xx_leds_probe(struct platform_device *pdev)
{
int i;
int ret;
struct cust_mt65xx_led *cust_led_list = mt_get_cust_led_list();
if (!cust_led_list) {
pr_info("Get dts fail! Probe exit.\n");
ret = -1;
goto err_dts;
}
#ifdef CONFIG_BACKLIGHT_SUPPORT_LP8557
/*i2c_register_board_info(4, &leds_board_info, 1);*/
if (i2c_add_driver(&led_i2c_driver)) {
pr_debug("Unable to add led-i2c driver.\n");
return -1;
}
#endif
pr_debug("Probe begain!\n");
get_div_array();
for (i = 0; i < MT65XX_LED_TYPE_TOTAL; i++) {
if (cust_led_list[i].mode == MT65XX_LED_MODE_NONE) {
g_leds_data[i] = NULL;
continue;
}
g_leds_data[i] =
kzalloc(sizeof(struct mt65xx_led_data), GFP_KERNEL);
if (!g_leds_data[i]) {
ret = -ENOMEM;
goto err;
}
g_leds_data[i]->cust.mode = cust_led_list[i].mode;
g_leds_data[i]->cust.data = cust_led_list[i].data;
g_leds_data[i]->cust.name = cust_led_list[i].name;
g_leds_data[i]->cdev.name = cust_led_list[i].name;
g_leds_data[i]->cust.config_data = cust_led_list[i].config_data;
g_leds_data[i]->cdev.brightness_set = mt65xx_led_set;
g_leds_data[i]->cdev.blink_set = mt65xx_blink_set;
INIT_WORK(&g_leds_data[i]->work, mt_mt65xx_led_work);
ret = led_classdev_register(&pdev->dev, &g_leds_data[i]->cdev);
if (ret)
goto err;
}
#ifdef CONTROL_BL_TEMPERATURE
last_level = 0;
limit = 255;
limit_flag = 0;
current_level = 0;
pr_debug
("last_level= %d, limit= %d, limit_flag= %d, current_level= %d\n",
last_level, limit, limit_flag, current_level);
#endif
return 0;
err:
if (i) {
for (i = i - 1; i >= 0; i--) {
if (!g_leds_data[i])
continue;
led_classdev_unregister(&g_leds_data[i]->cdev);
cancel_work_sync(&g_leds_data[i]->work);
kfree(g_leds_data[i]);
g_leds_data[i] = NULL;
}
}
err_dts:
return ret;
}
static int mt65xx_leds_remove(struct platform_device *pdev)
{
int i;
for (i = 0; i < MT65XX_LED_TYPE_TOTAL; i++) {
if (!g_leds_data[i])
continue;
led_classdev_unregister(&g_leds_data[i]->cdev);
cancel_work_sync(&g_leds_data[i]->work);
kfree(g_leds_data[i]);
g_leds_data[i] = NULL;
}
return 0;
}
static void mt65xx_leds_shutdown(struct platform_device *pdev)
{
int i;
struct nled_setting led_tmp_setting = { NLED_OFF, 0, 0 };
pr_debug("Turn off backlight\n");
for (i = 0; i < MT65XX_LED_TYPE_TOTAL; i++) {
if (!g_leds_data[i])
continue;
switch (g_leds_data[i]->cust.mode) {
case MT65XX_LED_MODE_PWM:
if (strcmp(g_leds_data[i]->cust.name, "lcd-backlight")
== 0) {
mt_led_pwm_disable(g_leds_data[i]->cust.data);
} else {
led_set_pwm(g_leds_data[i]->cust.data,
&led_tmp_setting);
}
break;
/* case MT65XX_LED_MODE_GPIO: */
/* brightness_set_gpio(g_leds_data[i]->cust.data, 0); */
/* break; */
case MT65XX_LED_MODE_PMIC:
pr_debug("not support set brightness through pmic!!1\n");
break;
case MT65XX_LED_MODE_CUST_LCM:
pr_debug("Backlight control through LCM!!1\n");
#ifdef CONFIG_MTK_AAL_SUPPORT
disp_aal_notify_backlight_changed(0);
#else
((cust_brightness_set) (g_leds_data[i]->cust.data)) (0,
bl_div);
#endif
break;
case MT65XX_LED_MODE_CUST_BLS_PWM:
pr_debug("Backlight control through BLS!!1\n");
#ifdef CONFIG_MTK_AAL_SUPPORT
disp_aal_notify_backlight_changed(0);
#else
((cust_set_brightness) (g_leds_data[i]->cust.data)) (0);
#endif
break;
case MT65XX_LED_MODE_NONE:
default:
break;
}
}
}
static struct platform_driver mt65xx_leds_driver = {
.driver = {
.name = "leds-mt65xx",
.owner = THIS_MODULE,
},
.probe = mt65xx_leds_probe,
.remove = mt65xx_leds_remove,
/* .suspend = mt65xx_leds_suspend, */
.shutdown = mt65xx_leds_shutdown,
};
#ifdef CONFIG_OF
static struct platform_device mt65xx_leds_device = {
.name = "leds-mt65xx",
.id = -1
};
#endif
static int __init mt65xx_leds_init(void)
{
int ret;
pr_debug("Leds init\n");
#ifdef CONFIG_OF
ret = platform_device_register(&mt65xx_leds_device);
if (ret)
pr_debug("dev:E%d\n", ret);
#endif
ret = platform_driver_register(&mt65xx_leds_driver);
if (ret) {
pr_debug("drv:E%d\n", ret);
/* platform_device_unregister(&mt65xx_leds_device); */
return ret;
}
mt_leds_wake_lock_init();
return ret;
}
static void __exit mt65xx_leds_exit(void)
{
platform_driver_unregister(&mt65xx_leds_driver);
/* platform_device_unregister(&mt65xx_leds_device); */
}
//module_param(debug_enable_led, int, 0644);
/* 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(mt65xx_leds_init);
module_exit(mt65xx_leds_exit);
MODULE_AUTHOR("MediaTek Inc.");
MODULE_DESCRIPTION("LED driver for MediaTek MT65xx chip");
MODULE_LICENSE("GPL");
MODULE_ALIAS("leds-mt65xx");
+25
View File
@@ -0,0 +1,25 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2018 MediaTek Inc.
*
*/
#include <linux/leds.h>
#include <mtk_leds_hal.h>
/****************************************************************************
* LED DRV functions
***************************************************************************/
#ifdef CONTROL_BL_TEMPERATURE
int setMaxbrightness(int max_level, int enable);
#endif
extern int mt65xx_leds_brightness_set(enum mt65xx_led_type type,
enum led_brightness level);
#ifdef CONFIG_MTK_LEDS
extern int backlight_brightness_set(int level);
#else
#define backlight_brightness_set(level) do { } while (0)
#endif
extern int disp_bls_set_max_backlight(unsigned int level);