androidLCD和键盘背光亮度设置

素颜马尾好姑娘i 2022-09-29 13:00 234阅读 0赞

亮度设置  
 应用设计  
1.1 设置进度条范围  
背光设置是在：设置->声音和显示->亮度，通过进度条来设置的。

文件：packages/apps/Settings/src/com/android/settings/BrightnessPreference.java

private static final int MINIMUM\_BACKLIGHT = android.os.Power.BRIGHTNESS\_DIM + 10;

private static final int MAXIMUM\_BACKLIGHT = android.os.Power.BRIGHTNESS\_ON;

mSeekBar.setMax(MAXIMUM\_BACKLIGHT - MINIMUM\_BACKLIGHT);

设置进度条的范围，BRIGHTNESS\_DIM = 20  BRIGHTNESS\_ON=255，它们的定义在：

frameworks/base/core/java/android/os/Power.java

1.2 设置亮度  
文件：packages/apps/Settings/src/com/android/settings/BrightnessPreference.java

public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) \{

setMode(isChecked ? Settings.System.SCREEN\_BRIGHTNESS\_MODE\_AUTOMATIC

: Settings.System.SCREEN\_BRIGHTNESS\_MODE\_MANUAL);

if (!isChecked) \{

setBrightness(mSeekBar.getProgress() + MINIMUM\_BACKLIGHT);

private void setBrightness(int brightness) \{

try \{

IPowerManager power = IPowerManager.Stub.asInterface(

ServiceManager.getService("power"));

if (power != null) \{

power.setBacklightBrightness(brightness);

\} catch (RemoteException doe) \{

由以上代码可知，brightness的范围是：20~255;代码通过服务管理器(ServiceManager)获得power服务，然后通过power服务设置亮度。

power.setBacklightBrightness的定义在：

rameworks/base/core/java/android/os/IPowerManager.aidl.java

frameworks/base/core/java/android/os/PowerManager.java

2， Power服务  
文件：frameworks/base/core/java/android/os/Power.java

/\*\*

\* Brightness value for dim backlight

\*/

public static final int BRIGHTNESS\_DIM = 20;

/\*\*

\* Brightness value for fully on

\*/

public static final int BRIGHTNESS\_ON = 255;

文件：frameworks/base/core/java/android/os/PowerManager.java

/\*\*

\* sets the brightness of the backlights (screen, keyboard, button).

\* @param brightness value from 0 to 255

\* [\{@hide][hide]\}

\*/

public void setBacklightBrightness(int brightness)

try \{

mService.setBacklightBrightness(brightness);

\} catch (RemoteException e) \{

电源管理器(powermager)将brightness转给电源服务，该服务位置如下：

文件：frameworks/base/services/java/com/android/server/PowerManagerService.java

public void setBacklightBrightness(int brightness) \{

mContext.enforceCallingOrSelfPermission(android.Manifest.permission.DEVICE\_POWER, null);

// Don't let applications turn the screen all the way off

brightness = Math.max(brightness, Power.BRIGHTNESS\_DIM);

mHardware.setLightBrightness\_UNCHECKED(HardwareService.LIGHT\_ID\_BACKLIGHT, brightness,

HardwareService.BRIGHTNESS\_MODE\_USER);

mHardware.setLightBrightness\_UNCHECKED(HardwareService.LIGHT\_ID\_KEYBOARD,

(mKeyboardVisible ? brightness : 0), HardwareService.BRIGHTNESS\_MODE\_USER);

mHardware.setLightBrightness\_UNCHECKED(HardwareService.LIGHT\_ID\_BUTTONS, brightness,

HardwareService.BRIGHTNESS\_MODE\_USER);

long identity = Binder.clearCallingIdentity();

try \{

mBatteryStats.noteScreenBrightness(brightness);

\} catch (RemoteException e) \{

Log.w(TAG, "RemoteException calling noteScreenBrightness on BatteryStatsService", e);

\} finally \{

Binder.restoreCallingIdentity(identity);

// update our animation state

if (ANIMATE\_SCREEN\_LIGHTS) \{

mScreenBrightness.curValue = brightness;

mScreenBrightness.animating = false;

mScreenBrightness.targetValue = -1;

if (ANIMATE\_KEYBOARD\_LIGHTS) \{

mKeyboardBrightness.curValue = brightness;

mKeyboardBrightness.animating = false;

mKeyboardBrightness.targetValue = -1;

if (ANIMATE\_BUTTON\_LIGHTS) \{

mButtonBrightness.curValue = brightness;

mButtonBrightness.animating = false;

mButtonBrightness.targetValue = -1;

由以上代码可知，同时设置了背光、键盘、按钮的亮度。mHardware 是硬件服务，通过该服务调用底层与设备打交道的C/C++代码，setLightBrightness\_UNCHECKED原型如下：

文件：frameworks/base/services/java/com/android/server/HardwareService.java

void setLightBrightness\_UNCHECKED(int light, int brightness, int brightnessMode) \{

int b = brightness & 0x000000ff;

b = 0xff000000 | (b << 16) | (b << 8) | b;

setLight\_native(mNativePointer, light, b, LIGHT\_FLASH\_NONE, 0, 0, brightnessMode);

参数说明：int light 表示类型，选项如下：

static final int LIGHT\_ID\_BACKLIGHT = 0;

static final int LIGHT\_ID\_KEYBOARD = 1;

static final int LIGHT\_ID\_BUTTONS = 2;

static final int LIGHT\_ID\_BATTERY = 3;

static final int LIGHT\_ID\_NOTIFICATIONS = 4;

static final int LIGHT\_ID\_ATTENTION = 5;

int brightness 表示亮度值

int brightnessMode 表示亮度的控制模式，选项如下：

/\*\*

\* Light brightness is managed by a user setting.

\*/

static final int BRIGHTNESS\_MODE\_USER = 0;

/\*\*

\* Light brightness is managed by a light sensor.

\*/

static final int BRIGHTNESS\_MODE\_SENSOR = 1;

由代码：

int b = brightness & 0x000000ff;

b = 0xff000000 | (b << 16) | (b << 8) | b;

可知，亮度值在此进行了修改，即亮度值的格式变成：FFRRGGBB，FF是没有的，RR、GG、BB分别是256色的红绿蓝，并且红绿蓝的值都是一样的亮度值。

3 硬件调用  
3.1获取硬件  
文件：frameworks/base/services/jni/com\_android\_server\_HardwareService.cpp

enum \{

LIGHT\_INDEX\_BACKLIGHT = 0,

LIGHT\_INDEX\_KEYBOARD = 1,

LIGHT\_INDEX\_BUTTONS = 2,

LIGHT\_INDEX\_BATTERY = 3,

LIGHT\_INDEX\_NOTIFICATIONS = 4,

LIGHT\_INDEX\_ATTENTION = 5,

LIGHT\_COUNT

\};

\#define LIGHTS\_HARDWARE\_MODULE\_ID "lights"

static jint init\_native(JNIEnv \*env, jobject clazz)

int err;

hw\_module\_t\* module;

Devices\* devices;

devices = (Devices\*)malloc(sizeof(Devices));

err = hw\_get\_module(LIGHTS\_HARDWARE\_MODULE\_ID, (hw\_module\_t const\*\*)&module);

if (err == 0) \{

devices->lights\[LIGHT\_INDEX\_BACKLIGHT\]

= get\_device(module, LIGHT\_ID\_BACKLIGHT);

devices->lights\[LIGHT\_INDEX\_KEYBOARD\]

= get\_device(module, LIGHT\_ID\_KEYBOARD);

devices->lights\[LIGHT\_INDEX\_BUTTONS\]

= get\_device(module, LIGHT\_ID\_BUTTONS);

devices->lights\[LIGHT\_INDEX\_BATTERY\]

= get\_device(module, LIGHT\_ID\_BATTERY);

devices->lights\[LIGHT\_INDEX\_NOTIFICATIONS\]

= get\_device(module, LIGHT\_ID\_NOTIFICATIONS);

devices->lights\[LIGHT\_INDEX\_ATTENTION\]

= get\_device(module, LIGHT\_ID\_ATTENTION);

\} else \{

memset(devices, 0, sizeof(Devices));

return (jint)devices;

用hw\_get\_module获取ID为LIGHTS\_HARDWARE\_MODULE\_ID的硬件模块，该模块含有6个不同类型的亮度控制。

hw\_get\_module 的实现原理，如下：

文件：hardware/libhardware/Hardware.c

\#define HAL\_LIBRARY\_PATH "/system/lib/hw"

static const char \*variant\_keys\[\] = \{

"ro.hardware",  /\* This goes first so that it can pick up a different

file on the emulator. \*/

"ro.product.board",

"ro.board.platform",

"ro.arch"

\};

static const int HAL\_VARIANT\_KEYS\_COUNT =

(sizeof(variant\_keys)/sizeof(variant\_keys\[0\]));

int hw\_get\_module(const char \*id, const struct hw\_module\_t \*\*module)

int status;

int i;

const struct hw\_module\_t \*hmi = NULL;

char prop\[PATH\_MAX\];

char path\[PATH\_MAX\];

/\*

\* Here we rely on the fact that calling dlopen multiple times on

\* the same .so will simply increment a refcount (and not load

\* a new copy of the library).

\* We also assume that dlopen() is thread-safe.

\*/

/\* Loop through the configuration variants looking for a module \*/

for (i=0 ; i<HAL\_VARIANT\_KEYS\_COUNT+1 ; i++) \{

if (i < HAL\_VARIANT\_KEYS\_COUNT) \{

if (property\_get(variant\_keys\[i\], prop, NULL) == 0) \{

continue;

snprintf(path, sizeof(path), "%s/%s.%s.so",

HAL\_LIBRARY\_PATH, id, prop);

\} else \{

snprintf(path, sizeof(path), "%s/%s.default.so",

HAL\_LIBRARY\_PATH, id);

if (access(path, R\_OK)) \{

continue;

/\* we found a library matching this id/variant \*/

break;

status = -ENOENT;

if (i < HAL\_VARIANT\_KEYS\_COUNT+1) \{

/\* load the module, if this fails, we're doomed, and we should not try

\* to load a different variant. \*/

status = load(id, path, module);

return status;

property\_get(variant\_keys\[i\], prop, NULL) 会按如下顺序去获取如下变量所对应的值，然后返回给prop：

"ro.hardware",  /\* This goes first so that it can pick up a different

file on the emulator. \*/

"ro.product.board",

"ro.board.platform",

"ro.arch"

它们对应的变量为：

"ro.product.board=$TARGET\_BOOTLOADER\_BOARD\_NAME"

"ro.board.platform=$TARGET\_BOARD\_PLATFORM"

如vendor/htc/dream-open/BoardConfig.mk里定义的TARGET\_BOARD\_PLATFORM := msm7k，则prop返回” msm7k ”，所以path = /system/lib/hw/lights. msm7k.so，也就是说要获取的硬件模块为lights. msm7k.so。

3.2调用硬件

setLight\_native对应的jni C/C++代码是：

文件：frameworks/base/services/jni/com\_android\_server\_HardwareService.cpp

static void setLight\_native(JNIEnv \*env, jobject clazz, int ptr,

int light, int colorARGB, int flashMode, int onMS, int offMS, int brightnessMode)

Devices\* devices = (Devices\*)ptr;

light\_state\_t state;

if (light < 0 || light >= LIGHT\_COUNT || devices->lights\[light\] == NULL) \{

return ;

memset(&state, 0, sizeof(light\_state\_t));

state.color = colorARGB;

state.flashMode = flashMode;

state.flashOnMS = onMS;

state.flashOffMS = offMS;

state.brightnessMode = brightnessMode;

devices->lights\[light\]->set\_light(devices->lights\[light\], &state);

通过light标识找到对应的light设备，然后再设置亮度。

3.3 硬件原型  
msm7k的lights对应的硬件原型是在：hardware/msm7k/liblights

文件：hardware/msm7k/liblights/Android.mk

LOCAL\_MODULE\_PATH := $(TARGET\_OUT\_SHARED\_LIBRARIES)/hw

LOCAL\_MODULE := lights.$(TARGET\_BOARD\_PLATFORM)

也就是生成模块：/system/lib/hw/lights. msm7k.so

文件：hardware/msm7k/liblights/lights.c

/\*\* Open a new instance of a lights device using name \*/

static int open\_lights(const struct hw\_module\_t\* module, char const\* name,

struct hw\_device\_t\*\* device)

int (\*set\_light)(struct light\_device\_t\* dev,

struct light\_state\_t const\* state);

if (0 == strcmp(LIGHT\_ID\_BACKLIGHT, name)) \{

set\_light = set\_light\_backlight;

else if (0 == strcmp(LIGHT\_ID\_KEYBOARD, name)) \{

set\_light = set\_light\_keyboard;

else if (0 == strcmp(LIGHT\_ID\_BUTTONS, name)) \{

set\_light = set\_light\_buttons;

else if (0 == strcmp(LIGHT\_ID\_BATTERY, name)) \{

set\_light = set\_light\_battery;

else if (0 == strcmp(LIGHT\_ID\_NOTIFICATIONS, name)) \{

set\_light = set\_light\_notifications;

else if (0 == strcmp(LIGHT\_ID\_ATTENTION, name)) \{

set\_light = set\_light\_attention;

else \{

return -EINVAL;

pthread\_once(&g\_init, init\_globals);

struct light\_device\_t \*dev = malloc(sizeof(struct light\_device\_t));

memset(dev, 0, sizeof(\*dev));

dev->common.tag = HARDWARE\_DEVICE\_TAG;

dev->common.version = 0;

dev->common.module = (struct hw\_module\_t\*)module;

dev->common.close = (int (\*)(struct hw\_device\_t\*))close\_lights;

dev->set\_light = set\_light;

\*device = (struct hw\_device\_t\*)dev;

return 0;

static struct hw\_module\_methods\_t lights\_module\_methods = \{

.open =  open\_lights,

\};

以上代码对应的是：

devices->lights\[LIGHT\_INDEX\_BACKLIGHT\]

= get\_device(module, LIGHT\_ID\_BACKLIGHT);

devices->lights\[LIGHT\_INDEX\_KEYBOARD\]

= get\_device(module, LIGHT\_ID\_KEYBOARD);

devices->lights\[LIGHT\_INDEX\_BUTTONS\]

= get\_device(module, LIGHT\_ID\_BUTTONS);

devices->lights\[LIGHT\_INDEX\_BATTERY\]

= get\_device(module, LIGHT\_ID\_BATTERY);

devices->lights\[LIGHT\_INDEX\_NOTIFICATIONS\]

= get\_device(module, LIGHT\_ID\_NOTIFICATIONS);

devices->lights\[LIGHT\_INDEX\_ATTENTION\]

= get\_device(module, LIGHT\_ID\_ATTENTION);

也就是说，对不同的亮度设置给予了不同的设置函数。

举例，背光设置，背光对应的代码如下：

char const\*const LCD\_FILE

= "/sys/class/leds/lcd-backlight/brightness";

static int

rgb\_to\_brightness(struct light\_state\_t const\* state)

int color = state->color & 0x00ffffff;

return ((77\*((color>>16)&0x00ff))

+ (150\*((color>>8)&0x00ff)) + (29\*(color&0x00ff))) >> 8;

static int

set\_light\_backlight(struct light\_device\_t\* dev,

struct light\_state\_t const\* state)

int err = 0;

int brightness = rgb\_to\_brightness(state);

pthread\_mutex\_lock(&g\_lock);

g\_backlight = brightness;

err = write\_int(LCD\_FILE, brightness);

if (g\_haveTrackballLight) \{

handle\_trackball\_light\_locked(dev);

pthread\_mutex\_unlock(&g\_lock);

return err;

也就是往文件/sys/class/leds/lcd-backlight/brightness写入亮度值，然后驱动会根据该文件更改背光的亮度。LCD\_FILE的路径根据实际情况更改，同时需要在init.rc 修改其权限，使其可写rgb\_to\_brightness也根据实际更改，比如要直接亮度值控制，那只要获取r,g,b其中的一个值就行了，如：

static int

rgb\_to\_brightness(struct light\_state\_t const\* state)

int color = state->color & 0x000000ff;

return color;

4，led类驱动

4.1，驱动创建leds类，系统启动时执行leds\_init在目录/sys/class/创建子目录leds

kernel/drivers/leds/Led-class.c

static int \_\_init leds\_init(void)  
\{  
 leds\_class = class\_create(THIS\_MODULE, "leds");  
 if (IS\_ERR(leds\_class))  
  return PTR\_ERR(leds\_class);  
 leds\_class->suspend = led\_suspend;  
 leds\_class->resume = led\_resume;  
 return 0;  
\}

4.2，led\_classdev\_register，调用这个函数就在目录/sys/class/leds创建子目录led\_cdev->name和属性文件brightness

对brightness文件写就执行led\_brightness\_store，对brightness文件读就执行led\_brightness\_show，为下面的lcd，led注册做好准备

kernel/drivers/leds/Led-class.c

static ssize\_t led\_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 led\_brightness\_store(struct device \*dev,  
  struct device\_attribute \*attr, const char \*buf, size\_t size)  
\{  
 struct led\_classdev \*led\_cdev = dev\_get\_drvdata(dev);  
 ssize\_t ret = -EINVAL;  
 char \*after;  
 unsigned long state = simple\_strtoul(buf, &after, 10);  
 size\_t count = after - buf;

if (\*after && isspace(\*after))  
  count++;

if (count == size) \{  
  ret = count;

if (state == LED\_OFF)  
   led\_trigger\_remove(led\_cdev);  
  led\_set\_brightness(led\_cdev, state);  
 \}

return ret;  
\}

static DEVICE\_ATTR(brightness, 0644, led\_brightness\_show, led\_brightness\_store);

/\*\*  
 \* 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)  
\{  
 int rc;

led\_cdev->dev = device\_create(leds\_class, parent, 0, led\_cdev,  
          "%s", led\_cdev->name);  
 if (IS\_ERR(led\_cdev->dev))  
  return PTR\_ERR(led\_cdev->dev);

/\* register the attributes \*/  
 rc = device\_create\_file(led\_cdev->dev, &dev\_attr\_brightness);  
 if (rc)  
  goto err\_out;

\#ifdef CONFIG\_LEDS\_TRIGGERS  
 init\_rwsem(&led\_cdev->trigger\_lock);  
\#endif  
 /\* add to the list of leds \*/  
 down\_write(&leds\_list\_lock);  
 list\_add\_tail(&led\_cdev->node, &leds\_list);  
 up\_write(&leds\_list\_lock);

led\_update\_brightness(led\_cdev);

\#ifdef CONFIG\_LEDS\_TRIGGERS  
 rc = device\_create\_file(led\_cdev->dev, &dev\_attr\_trigger);  
 if (rc)  
  goto err\_out\_led\_list;

led\_trigger\_set\_default(led\_cdev);  
\#endif

printk(KERN\_INFO "Registered led device: %s/n",  
   led\_cdev->name);

return 0;

\#ifdef CONFIG\_LEDS\_TRIGGERS  
err\_out\_led\_list:  
 device\_remove\_file(led\_cdev->dev, &dev\_attr\_brightness);  
 list\_del(&led\_cdev->node);  
\#endif  
err\_out:  
 device\_unregister(led\_cdev->dev);  
 return rc;  
\}  
EXPORT\_SYMBOL\_GPL(led\_classdev\_register);

4.3，lcd驱动调用led\_classdev\_register，在目录/sys/class/leds创建子目录lcd-backlight和属性文件brightness

kernel/drivers/video/msm/Msm\_fb.c

static int lcd\_backlight\_registered;

static void msm\_fb\_set\_bl\_brightness(struct led\_classdev \*led\_cdev,  
     enum led\_brightness value)  
\{  
 struct msm\_fb\_data\_type \*mfd = dev\_get\_drvdata(led\_cdev->dev->parent);  
 int bl\_lvl;

if (value > MAX\_BACKLIGHT\_BRIGHTNESS)  
  value = MAX\_BACKLIGHT\_BRIGHTNESS;

/\* This maps android backlight level 0 to 255 into  
    driver backlight level 0 to bl\_max with rounding \*/  
 bl\_lvl = (2 \* value \* mfd->panel\_info.bl\_max + MAX\_BACKLIGHT\_BRIGHTNESS)  
  /(2 \* MAX\_BACKLIGHT\_BRIGHTNESS);

if (!bl\_lvl && value)  
  bl\_lvl = 1;

msm\_fb\_set\_backlight(mfd, bl\_lvl, 1);  
\}

static struct led\_classdev backlight\_led = \{  
 .name  = "lcd-backlight",  
 .brightness = MAX\_BACKLIGHT\_BRIGHTNESS,  
 .brightness\_set = msm\_fb\_set\_bl\_brightness,  
\};

if (!lcd\_backlight\_registered) \{  
  if (led\_classdev\_register(&pdev->dev, &backlight\_led))  
   printk(KERN\_ERR "led\_classdev\_register failed/n");  
  else  
   lcd\_backlight\_registered = 1;  
 \}

就在目录/sys/class/leds创建子目录 lcd-backlight和属性文件brightness

当按键或者来的或者改变lcd亮度时，上层对属性文件/sys/class/leds/lcd-backlight/brightness写入背光的亮度数值就

调用led\_brightness\_store

调用simple\_strtoul(buf, &after, 10);将输入的字符串转换为10进制的数字

执行led\_set\_brightness

执行led\_cdev->brightness\_set(led\_cdev, value

调用msm\_fb\_set\_bl\_brightness ，因为  .brightness\_set = msm\_fb\_set\_bl\_brightness,

/\* This maps android backlight level 0 to 255 into    driver backlight level 0 to bl\_max with rounding \*/  
 bl\_lvl = (2 \* value \* mfd->panel\_info.bl\_max + MAX\_BACKLIGHT\_BRIGHTNESS)  /(2 \* MAX\_BACKLIGHT\_BRIGHTNESS);  
将输入的0--255转换为IC的0--bl\_max

调用 msm\_fb\_set\_backlight(mfd, bl\_lvl, 1);

最终改变LCD的背光驱动电路的设置，调节LCD的背光的亮度

4.4 键盘背光灯

上层对属性文件/sys/class/leds/keyboard-backlight/brightness写入背光的亮度数值

(kernel/drivers/leds/Leds-msm-pmic.c

\#define MAX\_KEYPAD\_BL\_LEVEL 16

static void msm\_keypad\_bl\_led\_set(struct led\_classdev \*led\_cdev,  
 enum led\_brightness value)  
\{  
 int ret;

ret = pmic\_set\_led\_intensity(LED\_KEYPAD, value / MAX\_KEYPAD\_BL\_LEVEL);  
 if (ret)  
  dev\_err(led\_cdev->dev, "can't set keypad backlight/n");  
\}

static struct led\_classdev msm\_kp\_bl\_led = \{  
 .name   = "keyboard-backlight",  
 .brightness\_set  = msm\_keypad\_bl\_led\_set,  
 .brightness  = LED\_OFF,  
\};

static int msm\_pmic\_led\_probe(struct platform\_device \*pdev)  
\{  
 int rc;

rc = led\_classdev\_register(&pdev->dev, &msm\_kp\_bl\_led);  
 if (rc) \{  
  dev\_err(&pdev->dev, "unable to register led class driver/n");  
  return rc;  
 \}  
 msm\_keypad\_bl\_led\_set(&msm\_kp\_bl\_led, LED\_OFF);  
 return rc;  
\}

static int \_\_devexit msm\_pmic\_led\_remove(struct platform\_device \*pdev)  
\{  
 led\_classdev\_unregister(&msm\_kp\_bl\_led);

return 0;  
\}

\#ifdef CONFIG\_PM  
static int msm\_pmic\_led\_suspend(struct platform\_device \*dev,  
  pm\_message\_t state)  
\{  
 led\_classdev\_suspend(&msm\_kp\_bl\_led);

return 0;  
\}

static int msm\_pmic\_led\_resume(struct platform\_device \*dev)  
\{  
 led\_classdev\_resume(&msm\_kp\_bl\_led);

return 0;  
\}  
\#else  
\#define msm\_pmic\_led\_suspend NULL  
\#define msm\_pmic\_led\_resume NULL  
\#endif

static struct platform\_driver msm\_pmic\_led\_driver = \{  
 .probe  = msm\_pmic\_led\_probe,  
 .remove  = \_\_devexit\_p(msm\_pmic\_led\_remove),  
 .suspend = msm\_pmic\_led\_suspend,  
 .resume  = msm\_pmic\_led\_resume,  
 .driver  = \{  
  .name = "pmic-leds",  
  .owner = THIS\_MODULE,  
 \},  
\};

static int \_\_init msm\_pmic\_led\_init(void)  
\{  
 return platform\_driver\_register(&msm\_pmic\_led\_driver);  
\}  
module\_init(msm\_pmic\_led\_init);

static void \_\_exit msm\_pmic\_led\_exit(void)  
\{  
 platform\_driver\_unregister(&msm\_pmic\_led\_driver);  
\}  
module\_exit(msm\_pmic\_led\_exit);

MODULE\_DESCRIPTION("MSM PMIC LEDs driver");  
MODULE\_LICENSE("GPL v2");  
MODULE\_ALIAS("platform:p

系统行动执行msm\_pmic\_led\_init(void)  
调用 platform\_driver\_register(&msm\_pmic\_led\_driver);

调用msm\_pmic\_led\_probe

调用 led\_classdev\_register(&pdev->dev, &msm\_kp\_bl\_led);

就在目录/sys/class/leds创建子目录 keyboard-backlight和属性文件brightness

当按键时，上层对属性文件/sys/class/leds/keyboard-backlight/brightness写入背光的亮度数值就

调用led\_brightness\_store

调用simple\_strtoul(buf, &after, 10);将输入的字符串转换为10进制的数字

执行led\_set\_brightness

执行led\_cdev->brightness\_set(led\_cdev, value

调用msm\_keypad\_bl\_led\_set ，因为 .brightness\_set  = msm\_keypad\_bl\_led\_set,

调用 ret = pmic\_set\_led\_intensity(LED\_KEYPAD, value / MAX\_KEYPAD\_BL\_LEVEL);  
最终改变LED驱动电路的设置，调节LED的亮度