Chinaunix首页 | 论坛 | 博客
  • 博客访问: 691426
  • 博文数量: 478
  • 博客积分: 0
  • 博客等级: 民兵
  • 技术积分: 4826
  • 用 户 组: 普通用户
  • 注册时间: 2014-06-28 11:12
  • 认证徽章:
文章分类

全部博文(478)

文章存档

2019年(1)

2018年(27)

2017年(21)

2016年(171)

2015年(258)

我的朋友

分类: Android平台

2016-10-28 21:19:00

http://blog.csdn.net/hbk320/article/details/48275369?locationNum=2&fps=1
此文章是网上看到的,在MTK平台基础上的背光控制流程的分析。个人觉得写得比较详细,于是截取部分内容转载出来。

不过话说在前头,对于lcd而言,决定显示效果的有几个因素:pwm,gama(屏幕灰度),饱和度,对比度 。如果单单改变了pwm的调制范围(如0--255改为0--100),用示波器可以看到pwm占空比的变化。但是,肉眼看到的效果还是没有任何变化,因为gama的因素的作用,这时也要相应的修改gama的值,或者把lcd 的gama屏蔽,才能看到修改效果。

细节的框架图:



由此可见光系统从上到下依次分为Java APP层、java 框架层、本地层和驱动层。下面就来看APP层,先给出调节背光的应用界面:



此功能在settings--->display--->brightness下面,可知有自动调节和手动调节背光亮度的功能,其中手动是通过进度条(slider)来调节的,此应用对应的布局文件为\packages\apps\Settings\res\layout\preference_dialog_brightness.xml

 

1.     Lights应用层

1.1   设置背光亮度调节范围

 

[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. \packages\apps\Settings\src\com\android\settings\BrightnessPreference.java  
  2.    
  3.   // Backlight range is from 0 - 255. Need tomake sure that user  
  4.     // doesn't set the backlight to 0 and getstuck  
  5.     private int mScreenBrightnessDim =  
  6.                  getContext().getResources().getInteger(com.android.internal.R.integer.config_screenBrightnessDim);  
  7. private staticfinal int MAXIMUM_BACKLIGHT = android.os.Power.BRIGHTNESS_ON;  
  8.    
  9.     @Override  
  10.     protected void onBindDialogView(View view){  
  11.         super.onBindDialogView(view);  
  12.    
  13.         mSeekBar = getSeekBar(view);  
  14.         mSeekBar.setMax(MAXIMUM_BACKLIGHT -mScreenBrightnessDim);  
  15.         mOldBrightness = getBrightness(0);  
  16.         mSeekBar.setProgress(mOldBrightness -mScreenBrightnessDim);  
  17.    
  18.         mCheckBox =(CheckBox)view.findViewById(R.id.automatic_mode);  
  19.         if (mAutomaticAvailable) {  
  20.             mCheckBox.setOnCheckedChangeListener(this);  
  21.             mOldAutomatic =getBrightnessMode(0);  
  22.             mCheckBox.setChecked(mOldAutomatic!= 0);  
  23.         } else {  
  24.             mCheckBox.setVisibility(View.GONE);  
  25.         }  
  26.        mSeekBar.setOnSeekBarChangeListener(this);  
  27. }  


(1)         getContext().getResources().getInteger(com.Android.internal.R.integer.config_screenBrightnessDim)的值

在\frameworks\base\core\res\res\values\config.xml下赋值,如下:


[html] view plaincopy在CODE上查看代码片派生到我的代码片
  1.   
  2. 20  


可见背光亮度最小值是20,不能设置为0,否则会关闭背光的显示。

 

(2)          android.os.Power.BRIGHTNESS_ON的值

在\frameworks\base\core\java\android\os\Power.java中定义:


[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. /** 
  2.      * Brightness value for fully off 
  3.      */  
  4.     public static final int BRIGHTNESS_OFF = 0;  
  5.    
  6.     /** 
  7.      * Brightness value for dim backlight 
  8.      */  
  9.     public static final int BRIGHTNESS_DIM =20;  
  10.    
  11.     /** 
  12.      * Brightness value for fully on 
  13.      */  
  14.     public static final int BRIGHTNESS_ON =255;  
  15.    
  16.     /** 
  17.      * Brightness value to use when battery islow 
  18.      */  
  19. public staticfinal int BRIGHTNESS_LOW_BATTERY = 10;  



由此可见设置的背光亮度调节范围为20~255。

 

1.2   设置背光亮度

 

[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. public voidonProgressChanged(SeekBar seekBar, int progress,  
  2.             boolean fromTouch) {  
  3.         setBrightness(progress +mScreenBrightnessDim);  
  4. }  
  5. progress表示滑动条的值。  
  6.    
  7.   private void setBrightness(int brightness) {  
  8.         try {  
  9.             IPowerManager power =IPowerManager.Stub.asInterface(  
  10.                    ServiceManager.getService("power"));  
  11.             //Only set backlight value whenscreen is on  
  12.             if (power != null &&power.isScreenOn()) {  
  13.                 power.setBacklightBrightness(brightness);  
  14.             }  
  15.         } catch (RemoteException doe) {  
  16.              
  17.         }  
  18. }  


通过ServiceManager获得power服务,然后通过power服务设置背光亮度

 

1.3   背光亮度初始值

frameworks\base\packages\SettingsProvider\src\com\android\providers\settings\DatabaseHelper.java


[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. private voidloadSystemSettings(SQLiteDatabase db) {  
  2.       SQLiteStatement stmt = null;  
  3.       try {  
  4.                                         ……….  
  5.                                         loadIntegerSetting(stmt,Settings.System.SCREEN_BRIGHTNESS,  
  6.                  R.integer.def_screen_brightness);  
  7.    
  8.          loadBooleanSetting(stmt,Settings.System.SCREEN_BRIGHTNESS_MODE,  
  9.                  R.bool.def_screen_brightness_automatic_mode);  
  10.                                         ……………..  
  11.      } finally {  
  12.           if (stmt != null) stmt.close();  
  13.       }  
  14.   }  


def_screen_brightness的值在下面定义:

\frameworks\base\packages\SettingsProvider\res\values\ defaults.xml


[html] view plaincopy在CODE上查看代码片派生到我的代码片
  1. 102  
  2. false  


可知默认亮度值为102

 

2.     Lights框架层(java框架层和antive框架层)

接着1.2节,设备背光亮度的power.setBacklightBrightness() 在文件

\frameworks\base\core\java\android\os\IPowerManager.aidl中定义,如下:


[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. interfaceIPowerManager  
  2. {  
  3.               ……  
  4.               // sets the brightness of thebacklights (screen, keyboard, button) 0-255  
  5.     void setBacklightBrightness(intbrightness);  
  6.     void setBacklightBrightnessOff(booleanenable);  
  7.     void setMaxBrightness(int brightness);  
  8.               ……….  
  9. }  


IPowerManager.aidl,android系统提供了一种描述语言来定义具有跨进程访问能力的服务接口,这种描述语言称为Android接口描述语言(Android Interface Definition Language, AIDL)。以AIDL定义的服务接口文件以aidl为后缀名,在编译是,编译系统会将它们转换成java文件,这是需要在\frameworks\base\Android.mk

文件中添加对应的aidl文件,才会转换为java文件的,如:


[plain] view plaincopy在CODE上查看代码片派生到我的代码片
  1. LOCAL_SRC_FILES +=\  
  2. ……………  
  3. core/java/android/os/IPermissionController.aidl\  
  4.               core/java/android/os/IPowerManager.aidl\  
  5.               core/java/android/os/IRemoteCallback.aidl\  
  6. …………….  


然后再对它们进行编译。通常用于访问硬件的服务接口定义在\frameworks\base\core\java\android\os下。

 

IPowerManager只是提供服务的接口,具体的实在

frameworks\base\core\java\android\os\PowerManager.java中,如下:

  

[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. /** 
  2.    * sets the brightness of the backlights(screen, keyboard, button). 
  3.    * 
  4.    * @param brightness value from 0 to 255 
  5.    * 
  6.    * {@hide} 
  7.    */  
  8.   public void setBacklightBrightness(intbrightness)  
  9.   {  
  10.       try {  
  11.           mService.setBacklightBrightness(brightness);  
  12.       } catch (RemoteException e) {  
  13.       }  


这里调用PowerManagerService的接口,


[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. frameworks\base\services\java\com\android\server\PowerManagerService.java,如下:  
  2.     public void setBacklightBrightness(intbrightness) {  
  3.        mContext.enforceCallingOrSelfPermission(android.Manifest.permission.DEVICE_POWER,null);  
  4.         // Don't let applications turn thescreen all the way off  
  5.         synchronized (mLocks) {  
  6.             brightness = Math.max(brightness,mScreenBrightnessDim);  
  7.             if (mMaxBrightness > 0) {  
  8.                 if (brightness >mMaxBrightness) {  
  9.                     brightness =mMaxBrightness;  
  10.                 }  
  11.             }  
  12.             mLcdLight.setBrightness(brightness);  
  13.             //We won't adjust Button/KeyboardBKL here for the time being, see CR[ALPS00132847]  
  14.             //mKeyboardLight.setBrightness(mKeyboardVisible? brightness : 0);  
  15.            //mButtonLight.setBrightness(brightness);  
  16.             long identity =Binder.clearCallingIdentity();  
  17.             try {  
  18.                mBatteryStats.noteScreenBrightness(brightness);  
  19.             } catch (RemoteException e) {  
  20.                 Slog.w(TAG,"RemoteException calling noteScreenBrightness onBatteryStatsService", e);  
  21.             } finally {  
  22.                Binder.restoreCallingIdentity(identity);  
  23.             }  
  24.    
  25.             // update our animation state  
  26.             synchronized (mLocks) {  
  27.                 mScreenBrightness.targetValue =brightness;  
  28.                mScreenBrightness.jumpToTargetLocked();  
  29.             }  
  30.         }  
  31.     }  


(1)  mLcdLight赋值


[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. …………..  
  2. static final int LIGHT_ID_BACKLIGHT = 0;  
  3. static final intLIGHT_ID_KEYBOARD = 1;  
  4. static final intLIGHT_ID_BUTTONS = 2;  
  5. static final intLIGHT_ID_BATTERY = 3;  
  6.   
  7. mLcdLight = lights.getLight(LightsService.LIGHT_ID_BACKLIGHT);  


(2)  setBrightness()

此函数位于frameworks\base\services\java\com\android\server\LightsService.java下,调用setBrightness()--->setLightLocked()--->setLight_native()。

 

LightsService.java声明的本地方法,也就是JNI接口函数有:


[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. private staticnative int init_native();  
  2.     private static native voidfinalize_native(int ptr);  
  3.    
  4.     private static native void setLight_native(intptr, int light, int color, int mode,  
  5.             int onMS, int offMS, intbrightnessMode);  


这些本地方法在

frameworks\base\services\jni\com_android_server_LightsService.cpp下实现,先来看Andorid Java 和 C 函数的映射表数组:


  1. staticJNINativeMethod method_table[] = {  
  2.     { "init_native", "()I",(void*)init_native },  
  3.     { "finalize_native","(I)V", (void*)finalize_native },  
  4.     { "setLight_native","(IIIIIII)V", (void*)setLight_native },  
  5. };  


JNINativeMethod结构体在dalvik\libnativehelper\include\nativehelper\jni.h


  1. typedef struct {  
  2. const char* name;  
  3. const char*signature;  
  4. void* fnPtr;  
  5. } JNINativeMethod;  


第一个变量name是Java中函数的名字。

第二个变量signature,用字符串是描述了函数的参数和返回值

第三个变量fnPtr是函数指针,指向C/C++函数。

其中比较难以理解的是第二个参数,例如

"()V"

"(II)V"

"(Ljava/lang/String;Ljava/lang/String;)V"

实际上这些字符是与函数的参数类型一一对应的。

"()" 中的字符表示参数,后面的则代表返回值。例如"()V" 就表示void Func();

"(II)V" 表示 void Func(int, int);

详细可参考:http://blog.csdn.net/loongembedded/article/details/41355353

 

由此可见Java函数对应的CPP函数名字是一样的,在

frameworks\base\services\jni\com_android_server_LightsService.cpp中定义:

(1)  init_native()


  1. static jintinit_native(JNIEnv *env, jobject clazz)  
  2. {  
  3.     int err;  
  4.     hw_module_t* module;  
  5.     Devices* devices;  
  6.      
  7.     devices =(Devices*)malloc(sizeof(Devices));  
  8.    
  9.     err =hw_get_module(LIGHTS_HARDWARE_MODULE_ID, (hw_module_t const**)&module);  
  10.     if (err == 0) {  
  11.        devices->lights[LIGHT_INDEX_BACKLIGHT]  
  12.                 = get_device(module,LIGHT_ID_BACKLIGHT);  
  13.        devices->lights[LIGHT_INDEX_KEYBOARD]  
  14.                 = get_device(module,LIGHT_ID_KEYBOARD);  
  15.         devices->lights[LIGHT_INDEX_BUTTONS]  
  16.                 = get_device(module,LIGHT_ID_BUTTONS);  
  17.         devices->lights[LIGHT_INDEX_BATTERY]  
  18.                 = get_device(module,LIGHT_ID_BATTERY);  
  19.         devices->lights[LIGHT_INDEX_NOTIFICATIONS]  
  20.                 = get_device(module,LIGHT_ID_NOTIFICATIONS);  
  21.        devices->lights[LIGHT_INDEX_ATTENTION]  
  22.                 = get_device(module,LIGHT_ID_ATTENTION);  
  23.         devices->lights[LIGHT_INDEX_BLUETOOTH]  
  24.                 = get_device(module,LIGHT_ID_BLUETOOTH);  
  25.         devices->lights[LIGHT_INDEX_WIFI]  
  26.                 = get_device(module,LIGHT_ID_WIFI);  
  27.     } else {  
  28.         memset(devices, 0, sizeof(Devices));  
  29.     }  
  30.    
  31.     return (jint)devices;  
  32. }  



这里重点介绍hw_get_module()函数,声明如下:


  1. int hw_get_module(const char *id, const struct hw_module_t **module);  


id是输入参数,表示要加载的硬件抽象层模块ID;module是输出参数,如加载成功,它指向一个自定义的硬件抽象层模块结构体。函数返回值为0表示加载成功。


  1. #defineHAL_LIBRARY_PATH1 "/system/lib/hw"  
  2. #defineHAL_LIBRARY_PATH2 "/vendor/lib/hw"  
  3. #defineHAL_LIBRARY_PATH3 "/system/lib"  


此函数回到这些路径下查找lights硬件抽象层模块lights.default.so并加载。

 

(2)  finalize_native()


  1. static voidfinalize_native(JNIEnv *env, jobject clazz, int ptr)  
  2. {  
  3.     Devices* devices = (Devices*)ptr;  
  4.     if (devices == NULL) {  
  5.         return;  
  6.     }  
  7.    
  8.     free(devices);  
  9. }  


(3)  setLight_native()


  1. static voidsetLight_native(JNIEnv *env, jobject clazz, int ptr,  
  2.         int light, int colorARGB, intflashMode, int onMS, int offMS, int brightnessMode)  
  3. {  
  4.     Devices* devices = (Devices*)ptr;  
  5.     light_state_t state;  
  6.    
  7.     if (light < 0 || light >= LIGHT_COUNT|| devices->lights[light] == NULL) {  
  8.         return ;  
  9.     }  
  10.    
  11.     memset(&state, 0,sizeof(light_state_t));  
  12.     state.color = colorARGB;  
  13.     state.flashMode = flashMode;  
  14.     state.flashOnMS = onMS;  
  15.     state.flashOffMS = offMS;  
  16.     state.brightnessMode = brightnessMode;  
  17.    
  18.     devices->lights[light]->set_light(devices->lights[light],&state);  
  19. }  


devices->lights[light]->set_light(devices->lights[light],&state);这里就是调用HAL层的函数。


3.     Lights硬件抽象层(HAL)

先来介绍这部分比较重要的结构体

3.1   light_state_t结构体

在hardware\libhardware\include\hardware\lights.h下定义:


  1. /** 
  2.  * The parameters that can be set for a givenlight. 
  3.  * 
  4.  * Not all lights must support allparameters.  If you 
  5.  * can do something backward-compatible, youshould. 
  6.  */  
  7. structlight_state_t {  
  8.     /** 
  9.      * The color of the LED in ARGB. 
  10.      * 
  11.      * Do your best here. 
  12.      *  - If your light can only do red or green, if they ask for blue, 
  13.      *    you should do green. 
  14.      *  - If you can only do a brightness ramp, then use this formula: 
  15.      *     unsigned char brightness = ((77*((color>>16)&0x00ff)) 
  16.      *              +(150*((color>>8)&0x00ff)) + (29*(color&0x00ff))) >> 8; 
  17.      *  - If you can only do on or off, 0 is off, anything else is on. 
  18.      * 
  19.      * The high byte should be ignored.  Callers will set it to 0xff (which 
  20.      * would correspond to 255 alpha). 
  21.      */  
  22.     unsigned int color;  
  23.    
  24.     /** 
  25.      * See the LIGHT_FLASH_* constants 
  26.      */  
  27.     int flashMode;  
  28.     int flashOnMS;  
  29.     int flashOffMS;  
  30.    
  31.     /** 
  32.      * Policy used by the framework to managethe light's brightness. 
  33.      * Currently the values areBRIGHTNESS_MODE_USER and BRIGHTNESS_MODE_SENSOR. 
  34.      */  
  35.     int brightnessMode;  
  36. };  


这里每个成员都有详细的解释,这里指强调几点:

(1)  flashMode成员


  1. /************************************************************************* 
  2.  * Flash modes for the flashMode field oflight_state_t. 
  3.  */  
  4.    
  5. #defineLIGHT_FLASH_NONE            0  
  6.    
  7. /** 
  8.  * To flash the light at a given rate, setflashMode to LIGHT_FLASH_TIMED, 
  9.  * and then flashOnMS should be set to thenumber of milliseconds to turn 
  10.  * the light on, followed by the number ofmilliseconds to turn the light 
  11.  * off. 
  12.  */  
  13. #defineLIGHT_FLASH_TIMED           1  
  14.    
  15. /** 
  16.  * To flash the light using hardware assist,set flashMode to 
  17.  * the hardware mode. 
  18.  */  
  19. #defineLIGHT_FLASH_HARDWARE        2  


表示LED等闪的模式,如果不需要闪烁为LIGHT_FLASH_NONE;如果需要软件来控制闪烁为LIGHT_FLASH_TIMED,这时也需要适当flashOnMS和flashOffMS的值;如果由硬件来控制闪烁的效果则为LIGHT_FLASH_HARDWARE。

 

(2)  brightnessMode成员


  1. /** 
  2.  * Light brightness is managed by a usersetting. 
  3.  */  
  4. #defineBRIGHTNESS_MODE_USER        0  
  5.    
  6. /** 
  7.  * Light brightness is managed by a lightsensor. 
  8.  */  
  9. #defineBRIGHTNESS_MODE_SENSOR      1  


BRIGHTNESS_MODE_USER表示由用户来设置背光,BRIGHTNESS_MODE_SENSOR表示有光传感器来自动调节背光,对应图4的Automatic brightness。

 

3.2   hw_module_t

在hardware\libhardware\include\hardware\hardware.h下定义:


  1. /* 
  2.  * Value for the hw_module_t.tag field 
  3.  */  
  4.    
  5. #defineMAKE_TAG_CONSTANT(A,B,C,D) (((A) << 24) | ((B) << 16) | ((C)<< 8) | (D))  
  6.    
  7. #defineHARDWARE_MODULE_TAG MAKE_TAG_CONSTANT('H', 'W', 'M', 'T')  
  8. #defineHARDWARE_DEVICE_TAG MAKE_TAG_CONSTANT('H', 'W', 'D', 'T')  
  9. /** 
  10.  * Every hardware module must have a datastructure named HAL_MODULE_INFO_SYM 
  11.  * and the fields of this data structure mustbegin with hw_module_t 
  12.  * followed by module specific information. 
  13.  */  
  14. typedef structhw_module_t {  
  15.     /** tag must be initialized toHARDWARE_MODULE_TAG */  
  16.     uint32_t tag;  
  17.    
  18.     /** major version number for the module */  
  19.     uint16_t version_major;  
  20.    
  21.     /** minor version number of the module */  
  22.     uint16_t version_minor;  
  23.    
  24.     /** Identifier of module */  
  25.     const char *id;  
  26.    
  27.     /**Name of this module */  
  28.     const char *name;  
  29.    
  30.     /** Author/owner/implementor of the module*/  
  31.     const char *author;  
  32.    
  33.     /** Modules methods */  
  34.     struct hw_module_methods_t* methods;  
  35.    
  36.     /** module's dso */  
  37.     void* dso;  
  38.    
  39.     /** padding to 128 bytes, reserved forfuture use */  
  40.     uint32_t reserved[32-7];  
  41.    
  42. } hw_module_t;  


需要重点注意几点:

(1)  每个硬件抽象层都必须有个名为HAL_MODULE_INFO_SYM的结构体,而且它的第1个成员变量类型必须是hw_module_t。

(2)  结构体hw_module_t的成员变量dso用来保存加载硬件抽象层模块后得到的句柄值。前面提到,每一个硬件抽象层模块都对应有一个动态链接库文件。加载硬件抽象层模块的过程实际上就是调用dlopen函数来加载与其对应的动态链接库文件的过程。在调用dlclose函数来卸载这个硬件抽象层模块时,要用到这个句柄值,因此,我们在加载时需要将它保存起来。


(3)  methods


  1. typedef structhw_module_methods_t {  
  2.     /** Open a specific device */  
  3.     int (*open)(const struct hw_module_t*module, const char* id,  
  4.             struct hw_device_t** device);  
  5.    
  6. }hw_module_methods_t;  


Open函数指针用来打开硬件抽象层模块的设备,参数module表示要打开的设备所在的模块;参数id表示要打开的设备的ID;参数device是一个输出参数,用来描述已经打开的设备。因为一个硬件抽象层模块可能包含多个设备,因为此在调用open的时候需要执行它的ID。

 

hw_device_t结构体的定义如下:


  1. /** 
  2.  * Every device data structure must begin withhw_device_t 
  3.  * followed by module specific public methodsand attributes. 
  4.  */  
  5. typedef structhw_device_t {  
  6.     /** tag must be initialized toHARDWARE_DEVICE_TAG */  
  7.     uint32_t tag;  
  8.    
  9.     /** version number for hw_device_t */  
  10.     uint32_t version;  
  11.    
  12.     /** reference to the module this devicebelongs to */  
  13.     struct hw_module_t* module;  
  14.    
  15.     /** padding reserved for future use */  
  16.     uint32_t reserved[12];  
  17.    
  18.     /** Close this device */  
  19.     int (*close)(struct hw_device_t* device);  
  20.    
  21. } hw_device_t;  


需要注意几点:

1)     硬件抽象层模块中的每个设备都必须自定义一个设备结构体,而人气它的第1个成员变量类型必须是hw_device_t。

2)     close用来关闭一个设备。

 

根据上面结构体的定义可知,硬件抽象层中的设备是由其所在的模块提供的接口open来打开的,而关闭是由设备本身结构体提供的close接口来完成的。

 

3.3   light_device_t

在hardware\libhardware\include\hardware\lights.h下定义:


  1. structlight_device_t {  
  2.     struct hw_device_t common;  
  3.    
  4.     /** 
  5.      * Set the provided lights to the providedvalues. 
  6.      * 
  7.      * Returns: 0 on succes, error code onfailure. 
  8.      */  
  9.     int (*set_light)(struct light_device_t*dev,  
  10.             struct light_state_t const* state);  
  11. };  


下面给出mediatek\source\hardware\liblights\lights.c中相关的部分:


  1. /** 
  2.  * module methods 
  3.  */  
  4.    
  5. /** Open a newinstance of a lights device using name */  
  6. static intopen_lights(const struct hw_module_t* module, char const* name,  
  7.         struct hw_device_t** device)  
  8. {  
  9.     int (*set_light)(struct light_device_t*dev,  
  10.             struct light_state_t const* state);  
  11.    
  12.     if (0 == strcmp(LIGHT_ID_BACKLIGHT, name)){  
  13.         set_light =set_light_backlight;  
  14.     }  
  15.     elseif (0 == strcmp(LIGHT_ID_KEYBOARD, name)) {  
  16.         set_light = set_light_keyboard;  
  17.     }  
  18.     else if (0 == strcmp(LIGHT_ID_BUTTONS,name)) {  
  19.         set_light = set_light_buttons;  
  20.     }  
  21.     else if (0 == strcmp(LIGHT_ID_BATTERY,name)) {  
  22.         set_light = set_light_battery;  
  23.     }  
  24.     else if (0 ==strcmp(LIGHT_ID_NOTIFICATIONS, name)) {  
  25.         set_light = set_light_notifications;  
  26.     }  
  27.     else if (0 == strcmp(LIGHT_ID_ATTENTION,name)) {  
  28.         set_light = set_light_attention;  
  29.     }  
  30.     else {  
  31.        return -EINVAL;  
  32.     }  
  33.    
  34.     pthread_once(&g_init, init_globals);  
  35.    
  36.     struct light_device_t *dev =malloc(sizeof(struct light_device_t));  
  37.     memset(dev, 0, sizeof(*dev));  
  38.    
  39.     dev->common.tag = HARDWARE_DEVICE_TAG;  
  40.     dev->common.version = 0;  
  41.     dev->common.module = (structhw_module_t*)module;  
  42.     dev->common.close = (int (*)(structhw_device_t*))close_lights;  
  43.     dev->set_light = set_light;  
  44.    
  45.     *device = (struct hw_device_t*)dev;  
  46.     return 0;  
  47. }  
  48.    
  49.    
  50. static structhw_module_methods_t lights_module_methods = {  
  51.     .open = open_lights,  
  52. };  
  53.    
  54. /* 
  55.  * The lights Module 
  56.  */  
  57. const structhw_module_t HAL_MODULE_INFO_SYM = {  
  58.     .tag = HARDWARE_MODULE_TAG,  
  59.     .version_major = 1,  
  60.     .version_minor = 0,  
  61.     .id = LIGHTS_HARDWARE_MODULE_ID,  
  62.     .name = "MTK lights Module",  
  63.     .author = "MediaTek",  
  64.     .methods = &lights_module_methods,  
  65. };  


结合第2节的setLight_native()--->set_light (),对应调用的是set_light_backlight来设置背光。

 

3.4   set_light_backlight()


  1. /* LCD BACKLIGHT*/  
  2. char const*constLCD_FILE  
  3.         = "/sys/class/leds/lcd-backlight/brightness";  
  4.    
  5. static int  
  6. set_light_backlight(structlight_device_t* dev,  
  7.         struct light_state_t const* state)  
  8. {  
  9.     int err = 0;  
  10.     int brightness = rgb_to_brightness(state);// 将rgb亮度转化为亮度  
  11.     pthread_mutex_lock(&g_lock);  
  12. g_backlight = brightness;  
  13. //将数值写入sys文件系统的brightness文件  
  14.     err = write_int(LCD_FILE, brightness);  
  15.     if (g_haveTrackballLight) {  
  16.         handle_trackball_light_locked(dev);  
  17.     }  
  18.     pthread_mutex_unlock(&g_lock);  
  19.     return err;  
  20. }  


此函数主要是把新的背光亮度值brightness写入到/sys/class/leds/lcd-backlight/brightness文件中,比如103,然后LED驱动再读取此值,然后调节背光。


  1. static int  
  2. write_int(charconst* path, int value)  
  3. {  
  4.     int fd;  
  5.    
  6. #ifdefLIGHTS_INFO_ON  
  7.               LOGD("write %d to %s",value, path);  
  8. #endif  
  9.    
  10.     fd = open(path, O_RDWR);  
  11.     if (fd >= 0) {  
  12.         char buffer[20];  
  13.         int bytes = sprintf(buffer,"%d\n", value);  
  14.         int amt = write(fd, buffer, bytes);  
  15.         close(fd);  
  16.         return amt == -1 ? -errno : 0;  
  17.     } else {  
  18.         return -errno;  
  19.     }  
  20. }  


我们也可以通过echo(写)和cat(读)来设置背光亮度,如下图:




4.     Lights驱动层

mediatek\config\hsimobile77_ics2\ProjectConfig.mkCUSTOM_KERNEL_LEDS=mt65xx

对于MTK平台,

根据上面的介绍,背光驱动提供的用于调节亮度接口是:/sys/class/leds/lcd-backlight/brightness。这个接口有LED驱动注册得来的的,源码位于Kernel/driver/leds/led-class.c中,下面给出其中一部分:

 

表示leds class的属性文件、权限和支持的操作


  1. static struct device_attributeled_class_attrs[] = {  
  2.               __ATTR(brightness,0644, led_brightness_show, led_brightness_store),  
  3.               __ATTR(max_brightness, 0444,led_max_brightness_show, NULL),  
  4. #ifdefCONFIG_LEDS_TRIGGERS  
  5.               __ATTR(trigger, 0644,led_trigger_show, led_trigger_store),  
  6. #endif  
  7.               __ATTR_NULL,  
  8. };  
  9.    
  10. static int __initleds_init(void)  
  11. {  
  12.               leds_class =class_create(THIS_MODULE, "leds");  
  13.               if (IS_ERR(leds_class))  
  14.                              returnPTR_ERR(leds_class);  
  15.               leds_class->suspend =led_suspend;  
  16.               leds_class->resume =led_resume;  
  17.               leds_class->dev_attrs =led_class_attrs;  
  18.               return 0;  
  19. }  
  20. static void __exitleds_exit(void)  
  21. {  
  22.               class_destroy(leds_class);  
  23. }  
  24.    
  25. subsys_initcall(leds_init);  
  26. module_exit(leds_exit);  


这里主要是通过subsys_initcall来进行各种子系统的初始化。

 

Led-class.c文件只是实现了提供上层的接口,至于真正操作硬件的驱动程序,可以给出其源码路径为:(硬件操作其实就是脉宽调制(PWM)),mediatek\source\kernel\drivers\leds\leds.c

 

3.4节的set_light_backlight()通过write()把背光值写入到/sys/class/leds/lcd-backlight/brightness文件后,会触发调用led_brightness_store函数,经过led_brightness_store()--->led_set_brightness()--->led_cdev->brightness_set(led_cdev,value)的调用流程,最后调用到mt65xx_led_set(),这是通过mt65xx_leds_probe()的赋值语句知道的:


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


这样我们就来看mt65xx_led_set()函数


  1. static voidmt65xx_led_set(struct led_classdev *led_cdev, enum led_brightness level)  
  2. {  
  3.               struct mt65xx_led_data *led_data =  
  4.                              container_of(led_cdev,struct mt65xx_led_data, cdev);  
  5.    
  6.               // do something only when level ischanged  
  7.               if (led_data->level != level) {  
  8.                              led_data->level= level;  
  9.                              if(strcmp(led_data->cust.name,"lcd-backlight"))  
  10.                              {  
  11.                                                          schedule_work(&led_data->work);  
  12.                              }else  
  13.                              {  
  14.                                                          LEDS_DEBUG("[LED]SetBacklight directly %d at time %lu\n",led_data->level,jiffies);  
  15.                                                          mt65xx_led_set_cust(&led_data->cust,led_data->level);         
  16.                              }  
  17.               }  
  18. }  



调用mt65xx_led_set_cust()来实现,此函数的参数led_data->cust



  1. struct PWM_config  
  2. {  
  3.               int clock_source;  
  4.               int div;  
  5.               int low_duration;  
  6.               int High_duration;  
  7. };  
  8.    
  9. structcust_mt65xx_led {  
  10.               char                 *name;  
  11.               enum mt65xx_led_mode  mode;  
  12.               int                   data;  
  13.  struct PWM_config config_data;  
  14. };  
  15.    
  16. static structcust_mt65xx_led cust_led_list[MT65XX_LED_TYPE_TOTAL] = {  
  17.               {"red",               MT65XX_LED_MODE_NONE, -1,{0}},  
  18.               {"green",             MT65XX_LED_MODE_NONE, -1,{0}},  
  19.               {"blue",              MT65XX_LED_MODE_NONE, -1,{0}},  
  20.               {"jogball-backlight", MT65XX_LED_MODE_NONE,-1,{0}},  
  21.               {"keyboard-backlight",MT65XX_LED_MODE_NONE,-1,{0}},  
  22.               {"button-backlight",  MT65XX_LED_MODE_PMIC,MT65XX_LED_PMIC_BUTTON,{0}},  
  23. //           {"lcd-backlight",     MT65XX_LED_MODE_CUST,(int)Cust_SetBacklight,{0}},  
  24.               {"lcd-backlight",     MT65XX_LED_MODE_PWM,PWM1,{0}},           
  25. };  
  26.    
  27. structcust_mt65xx_led *get_cust_led_list(void)  
  28. {  
  29.               return cust_led_list;  
  30. }  



参数led_data->level就是当前要设置的背光值。

 

mt65xx_led_set_cust()--->backlight_set_pwm()--->pwm_set_spec_config()

 

在调试过程遇到的问题:

(1)  cust_mt65xx_ledcust_led_list全局结构体数组的修改

修改之前:{"lcd-backlight",     MT65XX_LED_MODE_GPIO,GPIO84,{0}},

因为我们是采用CPU的PWM1来控制背光的的,所以修改为:

{"lcd-backlight",     MT65XX_LED_MODE_PWM,PWM1,{0}},

可是进入系统后直接就是黑屏,为什么呢?根据调试信息知道/sys/class/leds/lcd-backlight/brightness文件的值为255,255是最大值,应该是最亮才对啊,但为什么是255就会黑屏呢?

看backlight_set_pwm()函数体下面的部分:


  1. if(level>0&& level <= 32)  
  2.               {  
  3.                              pwm_setting.PWM_MODE_FIFO_REGS.SEND_DATA0=  (1 << level) - 1 ;  
  4.                              pwm_setting.PWM_MODE_FIFO_REGS.SEND_DATA1= 0 ;  
  5.                              pwm_set_spec_config(&pwm_setting);  
  6.               }else if(level>32 &&level <=64)  
  7.               {  
  8.                              level -= 32;  
  9.                              pwm_setting.PWM_MODE_FIFO_REGS.SEND_DATA0=  0xFFFFFFFF ;  
  10.                              pwm_setting.PWM_MODE_FIFO_REGS.SEND_DATA1= (1 << level) - 1;  
  11.                              pwm_set_spec_config(&pwm_setting);  
  12.               }else  
  13.               {  
  14.                              LEDS_DEBUG("[LED]Errorlevel in backlight\n");  
  15.                              mt_set_pwm_disable(pwm_setting.pwm_no);  
  16.                              mt_power_off(pwm_setting.pwm_no);  
  17.               }  


因为level=255,所以就直接执行了关屏的动作,如果要搞清楚为什么level>64就要关屏,就要详细看MT6577的PWM部分了。

 

(2)  修改brightness_mapping()

上面出现在leve=255关屏的情况,为解决此问题就需要修改brightness_mapping()函数,看了为了确保上层设置0~255的情况下,是需要brightness_mapping函数的映射的,下面给出其实现部分:


  1. unsigned intbrightness_mapping(unsigned int level)  
  2. {  
  3.     unsigned int mapped_level;  
  4.     mapped_level = level;  
  5.      return mapped_level;  
  6. }  


很简单吧,为了解决此问题,我们改为:

mapped_level =level/4;

 

5.     Lights硬件层

参考我之前介绍的部分:

http://blog.csdn.net/loongembedded/article/details/38540297

 

6.     编译

./mk n ub、 ./mk n k和./mk bootimage,然后更新uboot_hsimobile77_ics2.bin和boot.img即可

 

参考:

mtk led

http://blog.csdn.net/mcgrady_tracy/article/details/41285213

 

android系统开发(七)-背光模块

http://blog.csdn.net/jiajie961/article/details/6030405

 

【从应用层到Framework】android LCD、键盘灯的背光亮度设置

http://blog.sina.com.cn/s/blog_40d475e901014wkt.html

 

Android中背光系统架构

http://blog.csdn.net/yinwei520/article/details/6817528

 

Android LCD和键盘背光亮度数据流分析

http://blog.csdn.net/wealoong/article/details/7759178

 

lights从上到下的流程

http://blog.csdn.net/zhangchiytu/article/details/7958513

顶 1
阅读(1500) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
评论热议
请登录后评论。

登录 注册