android 亮灯按钮,MTK6735(Android6.0)-按键灯的实现

一、按键灯的简介

最近调试一下按键灯，今天抽空顺便把的流程分析了一下。按键灯也是一种led,它的使用规则如命名一样，当按键按

下亮灯，如果一定时间不操作的话，一会会灭灯。其实这里的按键灯亮灭策略通常不是驱动来完成的，而是有用户空间来

控制。正如一句老话“驱动注重的不是策略，而是机制”；所以我们在编写驱动只需要完成led的点亮和熄灭功能即可。当

然在实际使用中我们会发现不是所有驱动都如此，有时候平台中也会添加一定的策略，这个本章不作分析。 调试按键灯，

当然首先从硬件开始。按键灯的原理图如下：

从原理图中我们发现，button-backlight是由两路ISINK控制的，ISNIK是一种类似于PWM的控制器，它可以发出类似PWM的信号，可以通过寄存器的配置 调整其占空比等参数，进入调节输出电流，从而控制led的亮度。

二、按键灯的驱动实现

1. 设备和驱动的匹配

//驱动文件中定义platform_driver

file:kernel-3.18/drivers/misc/mediatek/leds/leds_drv.c

#define USE_PINCTRL

#ifdef USE_PINCTRL

static const struct of_device_id leds_of_ids[] = {

{.compatible = "mediatek,leds-mt65xx",},

{}

};

#endif

static struct platform_driver mt65xx_leds_driver = {

.driver = {

.name = "leds-mt65xx",

.owner = THIS_MODULE,

#ifdef USE_PINCTRL

.of_match_table = leds_of_ids, //和dts中定义一致

#endif

},

.probe = mt65xx_leds_probe,

.remove = mt65xx_leds_remove,

/* .suspend = mt65xx_leds_suspend, */

.shutdown = mt65xx_leds_shutdown,

};//驱动模块的加载

static int __init mt65xx_leds_init(void)

{

ret = platform_driver_register(&mt65xx_leds_driver);

....

return ret;

}//dts中定义leds 的相关节点如:red,green,blue,keyboard-backlight,button-backlight等(后面会用到)

file:kernel-3.18/arch/arm/boot/dts/rlk6737m_35g_c_m0.dts

led0:led@0 {

compatible = "mediatek,red";

led_mode = <0>;

data = <1>;

pwm_config = <0 0 0 0 0>;

};

led1:led@1 {

compatible = "mediatek,green";

led_mode = <0>;

data = <1>;

pwm_config = <0 0 0 0 0>;

};

led2:led@2 {

compatible = "mediatek,blue";

led_mode = <0>;

data = <1>;

pwm_config = <0 0 0 0 0>;

};

led4:led@4 {

compatible = "mediatek,keyboard-backlight";

led_mode = <0>;

data = <1>;

pwm_config = <0 0 0 0 0>;

};

led5:led@5 {

compatible = "mediatek,button-backlight"; //这里着重分析按键灯button-backlight

led_mode = <3>;

data = <1>;

pwm_config = <0 0 0 0 0>;

};

led6:led@6 {

compatible = "mediatek,lcd-backlight";

led_mode = <5>;

data = <1>;

pwm_config = <0 0 0 0 0>;

};//dts中定义和platform_device相关的节点信息

file：kernel-3.18/arch/arm/boot/dts/mt6735m.dtsi

lightsystem: leds {

compatible = "mediatek,leds-mt65xx"; //这里的定义和上面platform_driver中定义的一致

};  上述dts中定义按键灯leds节点配置，内核起来后会解析dts生成相关的设备，并与驱动中的driver匹配，如果匹配成功就执行下面的probe

2.leds probe 函数实现

file:kernel-3.18/drivers/misc/mediatek/leds/leds_drv.c

static int mt65xx_leds_probe(struct platform_device *pdev)

{

int i;

int ret;/* rc; */

//进入probe后，会从dts中获取led节点的mode和data

struct cust_mt65xx_led *cust_led_list = mt_get_cust_led_list();

LEDS_DRV_DEBUG("%s\n", __func__);

get_div_array();

//MT65XX_LED_TYPE_TOTAL为改通用(common)驱动所支持灯的个数

for (i = 0; i < MT65XX_LED_TYPE_TOTAL; i++) {

//观察上面dts中mode如果mode为0(MT65XX_LED_MODE_NONE)，则遍历下个元素

if (cust_led_list[i].mode == MT65XX_LED_MODE_NONE) {

g_leds_data[i] = NULL;

continue;

}

...

//将dts中配置的mode，name ,data 保存起来后面会用到

//通过观察上面的button-backlight 的配置，得出其mode为3，data为1，name为button-backlight

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;/* bei add */

g_leds_data[i]->cdev.brightness_set = mt65xx_led_set; //设置led亮度的函数

//创建sys目录下的brightness等属性节点，提供给用户空间调用

ret = led_classdev_register(&pdev->dev, &g_leds_data[i]->cdev);

...

return 0;

...

}//后面会用到的一些结构的定义

file:kernel-3.18/drivers/misc/mediatek/leds/mt6735/leds_sw.h

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,

};

/**

* 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;

};

file:kernel-3.18/include/linux/leds.h

enum led_brightness {

LED_OFF= 0,

LED_HALF= 127,

LED_FULL= 255,

};

struct led_classdev {

const char*name;

enum led_brightness brightness;

enum led_brightness max_brightness;

int flags;

...

/* Set LED brightness level */

/* Must not sleep, use a workqueue if needed */

void(*brightness_set)(struct led_classdev *led_cdev,

enum led_brightness brightness);

/* Get LED brightness level */

enum led_brightness (*brightness_get)(struct led_classdev *led_cdev);

.....

struct device*dev;

const struct attribute_group**groups;

struct list_head node;/* LED Device list */

...

};file:kernel-3.18/drivers/misc/mediatek/leds/mt6735/leds.c

char *leds_name[MT65XX_LED_TYPE_TOTAL] = {

"red",

"green",

"blue",

"jogball-backlight",

"keyboard-backlight",

"button-backlight",

"lcd-backlight",

}3.从dts中获取各种led的配置信息

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;

}

struct cust_mt65xx_led *get_cust_led_dtsi(void)

{

struct device_node *led_node = NULL;

...

//MT65XX_LED_TYPE_TOTAL 为led数组长度，即可以支持led的个数

for (i = 0; i < MT65XX_LED_TYPE_TOTAL; i++) {

char node_name[32] = "mediatek,";

pled_dtsi[i].name = leds_name[i];

//使用"mediatek,button-backlight"寻找dtsi中定义的节点

led_node =

of_find_compatible_node(NULL, NULL,

strcat(node_name,

leds_name[i]));

if (!led_node) {

LEDS_DEBUG("Cannot find LED node from dts\n");

pled_dtsi[i].mode = 0;

pled_dtsi[i].data = -1;

} else {

isSupportDTS = true;

//读取led_mode值

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);

}

//读取led的data值

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);

}

...

return pled_dtsi;

}4. 创建相关的设备节点

**

* led_classdev_register - register a new object of led_classdev class.

* @parent: The device to register.

* @led_cdev: the led_classdev structure for this device.

*/

int led_classdev_register(struct device *parent, struct led_classdev *led_cdev)

{

led_cdev->dev = device_create_with_groups(leds_class, parent, 0,

led_cdev, led_cdev->groups,

"%s", led_cdev->name);

...

return 0;

}//device_create_with_groups的实现

file:kernel-3.18/drivers/base/core.c

/**

* device_create_with_groups - creates a device and registers it with sysfs

* @class: pointer to the struct class that this device should be registered to

* @parent: pointer to the parent struct device of this new device, if any

* @devt: the dev_t for the char device to be added

* @drvdata: the data to be added to the device for callbacks

* @groups: NULL-terminated list of attribute groups to be created

* @fmt: string for the device's name

*

* This function can be used by char device classes. A struct device

* will be created in sysfs, registered to the specified class.

* Additional attributes specified in the groups parameter will also

* be created automatically.

*

* A "dev" file will be created, showing the dev_t for the device, if

* the dev_t is not 0,0.

* If a pointer to a parent struct device is passed in, the newly created

* struct device will be a child of that device in sysfs.

* The pointer to the struct device will be returned from the call.

* Any further sysfs files that might be required can be created using this

* pointer.

*

* Returns &struct device pointer on success, or ERR_PTR() on error.

*

* Note: the struct class passed to this function must have previously

* been created with a call to class_create().

*/

struct device *device_create_with_groups(struct class *class,

struct device *parent, dev_t devt,

void *drvdata,

const struct attribute_group **groups,

const char *fmt, ...)

{

va_list vargs;

struct device *dev;

va_start(vargs, fmt);

dev = device_create_groups_vargs(class, parent, devt, drvdata, groups,

fmt, vargs);

va_end(vargs);

return dev;

}//device_create_groups_vargs 的实现

static struct device *

device_create_groups_vargs(struct class *class, struct device *parent,

dev_t devt, void *drvdata,

const struct attribute_group **groups,

const char *fmt, va_list args)

{

struct device *dev = NULL;

int retval = -ENODEV;

if (class == NULL || IS_ERR(class))

goto error;

dev = kzalloc(sizeof(*dev), GFP_KERNEL);

if (!dev) {

retval = -ENOMEM;

goto error;

}

device_initialize(dev);

dev->devt = devt;

dev->class = class;

dev->parent = parent;

dev->groups = groups;

dev->release = device_create_release;

dev_set_drvdata(dev, drvdata);

retval = kobject_set_name_vargs(&dev->kobj, fmt, args);

if (retval)

goto error;

retval = device_add(dev);

if (retval)

goto error;

return dev;

error:

put_device(dev);

return ERR_PTR(retval);

}//device_add的实现

int device_add(struct device *dev)

{

...

/* first, register with generic layer. */

/* we require the name to be set before, and pass NULL */

error = kobject_add(&dev->kobj, dev->kobj.parent, NULL);

if (error)

goto Error;

...

error = device_add_attrs(dev);

...

}device_add_attrs的实现这里将会调用device_add_groups，class->dev_groups 作为参数呗传入，此时节点/sys/class/leds/xxx/brightness 已经被

创建 这里的xxx 对应驱动中的red,green,button_backlight,

lcd-backlight ... 已经创建

static int device_add_attrs(struct device *dev)

{

struct class *class = dev->class;

const struct device_type *type = dev->type;

int error;

//这里class->dev_groups先前已经在led-class.c的leds_init中被赋值 leds_class->dev_groups = led_groups;

if (class) {

error = device_add_groups(dev, class->dev_groups);

if (error)

return error;

}

...

return 0;

}5、属性节点的读写方法定义

file:kernel-3.18/drivers/leds/led-class.c

static int __init leds_init(void)

{

leds_class = class_create(THIS_MODULE, "leds"); //创建class对象

...

leds_class->dev_groups = led_groups; //传入brightness节点参数,led属性节点组赋值给leds_class

...

return 0;

}再看led_groups的定义如下：

static const struct attribute_group *led_groups[] = {

&led_group,

#ifdef CONFIG_LEDS_TRIGGERS

&led_trigger_group,

#endif

NULL,

};

static const struct attribute_group led_group = {

.attrs = led_class_attrs,

};

static struct attribute *led_class_attrs[] = {

&dev_attr_brightness.attr,

&dev_attr_max_brightness.attr,

NULL,

};当用户空间读取属性节点时候，会直接输入当前亮度值

static ssize_t brightness_show(struct device *dev,

struct device_attribute *attr, char *buf)

{

struct led_classdev *led_cdev = dev_get_drvdata(dev);

/* no lock needed for this */

led_update_brightness(led_cdev);

return sprintf(buf, "%u\n", led_cdev->brightness);

}

static ssize_t brightness_store(struct device *dev,

struct device_attribute *attr, const char *buf, size_t size)

{

struct led_classdev *led_cdev = dev_get_drvdata(dev);

unsigned long state;

ssize_t ret = -EINVAL;

ret = kstrtoul(buf, 10, &state); //将传入的字符串转换为十进制

if (ret)

return ret;

if (state == LED_OFF)

led_trigger_remove(led_cdev);

__led_set_brightness(led_cdev, state); //设置灯的亮度(亮灭)

return size;

}定义brightness属性的变量

static DEVICE_ATTR_RW(brightness);6.button-backlight 亮灯的实现

通过上面节点的 /sys/class/leds/button-backlight/brightness 写方法brightness_store的定义可知，当brightness节点被用户空间写入后，将触发

执行__led_set_brightness，我们可以通过用户空间传入的参数调节灯的亮度，这里这里的传入参数范围0~255

这里的__led_set_brightness如下定义：

file:kernel-3.18/drivers/leds/leds.h

static inline void __led_set_brightness(struct led_classdev *led_cdev,

enum led_brightness value)

{

if (value > led_cdev->max_brightness)

value = led_cdev->max_brightness; //对传入的值作越界处理

led_cdev->brightness = value;

if (!(led_cdev->flags & LED_SUSPENDED))

led_cdev->brightness_set(led_cdev, value);//执行亮灯操作

}这个函数最终会调用led_cdev->brightness_set,而 led_cdev->brightness_set在leds_drv.c 中已经被赋值过如下：

file:kernel-3.18/drivers/misc/mediatek/leds/leds_drv.c

g_leds_data[i]->cdev.brightness_set = mt65xx_led_set;

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);

...

mt_mt65xx_led_set(led_cdev, level);

...

}file:kernel-3.18/drivers/misc/mediatek/leds/mt6735/leds.c

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) {

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);

} else {

if (level != 0

&& level * CONFIG_LIGHTNESS_MAPPING_VALUE < 255) {

level = 1;

} else {

level =

(level * CONFIG_LIGHTNESS_MAPPING_VALUE) /

255;

}

LEDS_DEBUG

("Set Backlight directly %d at time %lu, mapping level is %d\n",

led_data->level, jiffies, level);

if (MT65XX_LED_MODE_CUST_BLS_PWM == led_data->cust.mode) {

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

mt_mt65xx_led_set_cust(&led_data->cust, level);

}

}

}

}mt_mt65xx_led_set_cust的实现

file:kernel-3.18/drivers/misc/mediatek/leds/mt6735/leds.c

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) {

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);

}

}

return 1;

case MT65XX_LED_MODE_GPIO:

LEDS_DEBUG("brightness_set_cust:go GPIO mode!!!!!\n");

return ((cust_set_brightness) (cust->data)) (level);

//这里的MT65XX_LED_MODE_PMIC对应button-backlight的配置的mode=3

case MT65XX_LED_MODE_PMIC:

/* for button baclight used SINK channel, when set button ISINK,

don't do disable other ISINK channel */

//使用button-backlight的调用如下：

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;

case MT65XX_LED_PMIC_NLED_ISINK2:

button_flag_isink2 = 1;

break;

case MT65XX_LED_PMIC_NLED_ISINK3:

button_flag_isink3 = 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("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;

return ((cust_set_brightness) (cust->data)) (level);

case MT65XX_LED_MODE_NONE:

default:

break;

}

return -1;

}也就是说当用户对属性节点 /sys/class/leds/button-backlight/brightness 写入时最终调用mt_brightness_set_pmic函数，

mt_brightness_set_pmic的实现如下：

file:kernel-3.18/drivers/misc/mediatek/leds/mt6735/leds.c

int mt_brightness_set_pmic(enum mt65xx_led_pmic pmic_type, u32 level, u32 div)

{

static bool first_time = true;

LEDS_DEBUG("PMIC#%d:%d\n", pmic_type, level);

mutex_lock(&leds_pmic_mutex);

if (pmic_type == MT65XX_LED_PMIC_NLED_ISINK0) {

if ((button_flag_isink0 == 0) && (first_time == true)) {/* button

flag ==0, means this ISINK is not for button backlight */

if (button_flag_isink1 == 0)

pmic_set_register_value(PMIC_ISINK_CH1_EN, NLED_OFF);/* sw

workround for sync leds status */

if (button_flag_isink2 == 0)

pmic_set_register_value(PMIC_ISINK_CH2_EN,

NLED_OFF);

if (button_flag_isink3 == 0)

pmic_set_register_value(PMIC_ISINK_CH3_EN,

NLED_OFF);

first_time = false;

}

pmic_set_register_value(PMIC_RG_DRV_32K_CK_PDN, 0x0);/* Disable power down */

pmic_set_register_value(PMIC_RG_DRV_ISINK0_CK_PDN, 0);

pmic_set_register_value(PMIC_RG_DRV_ISINK0_CK_CKSEL, 0);

pmic_set_register_value(PMIC_ISINK_CH0_MODE, ISINK_PWM_MODE);

pmic_set_register_value(PMIC_ISINK_CH0_STEP, ISINK_3);/* 16mA */

pmic_set_register_value(PMIC_ISINK_DIM0_DUTY, 15);

pmic_set_register_value(PMIC_ISINK_DIM0_FSEL, ISINK_1KHZ);/* 1KHz */

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) {

if ((button_flag_isink1 == 0) && (first_time == true)) {/* button

flag ==0, means this ISINK is not for button backlight */

if (button_flag_isink0 == 0)

pmic_set_register_value(PMIC_ISINK_CH0_EN, NLED_OFF);/* sw

workround for sync leds status */

if (button_flag_isink2 == 0)

pmic_set_register_value(PMIC_ISINK_CH2_EN,

NLED_OFF);

if (button_flag_isink3 == 0)

pmic_set_register_value(PMIC_ISINK_CH3_EN,

NLED_OFF);

first_time = false;

}

pmic_set_register_value(PMIC_RG_DRV_32K_CK_PDN, 0x0);/* Disable power down */

pmic_set_register_value(PMIC_RG_DRV_ISINK1_CK_PDN, 0);

pmic_set_register_value(PMIC_RG_DRV_ISINK1_CK_CKSEL, 0);

pmic_set_register_value(PMIC_ISINK_CH1_MODE, ISINK_PWM_MODE);

pmic_set_register_value(PMIC_ISINK_CH1_STEP, ISINK_3);/* 16mA */

pmic_set_register_value(PMIC_ISINK_DIM1_DUTY, 15);

pmic_set_register_value(PMIC_ISINK_DIM1_FSEL, ISINK_1KHZ);/* 1KHz */

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);

return -1;

}上述pmic_set_register_value的操作就是对ISINK具体寄存器的操作，本文不作深入研究

三、总结 通过上述的分析，我们大致可以看出在mtk平台上leds系列的驱动流程大致如下，先在dts中定义各个led节点的配置，配 置如mode,name,data 预留给driver调用，然后创建common drver (通用驱动)对各个led统一管理，在通用驱动中各个不 同类型led 通过数组区分，common driver对各个led进行统一的设备注册，属性节点创建等。当然led的种类繁多还有充 电指示灯，呼吸灯等，在加上每种灯硬件配置不一样驱动实现方式也不同，这个需要另行分析了。