Commit | Line | Data |
---|---|---|
6fa3eb70 S |
1 | #include <linux/kernel.h> |
2 | #include <linux/delay.h> | |
3 | #include <linux/types.h> | |
4 | #include <linux/xlog.h> | |
5 | #include <linux/mutex.h> | |
6 | #include <mach/mt_clkmgr.h> | |
7 | ||
8 | #include "ddp_drv.h" | |
9 | #include "ddp_reg.h" | |
10 | #include "ddp_debug.h" | |
11 | #include "ddp_bls.h" | |
12 | #include "disp_drv.h" | |
13 | #include "ddp_hal.h" | |
14 | ||
15 | #include <cust_leds.h> | |
16 | #include <cust_leds_def.h> | |
17 | ||
18 | #define DDP_GAMMA_SUPPORT | |
19 | ||
20 | #define POLLING_TIME_OUT 1000 | |
21 | ||
22 | #define PWM_DEFAULT_DIV_VALUE 0x0 | |
23 | ||
24 | unsigned int bls_dbg_log = 0; | |
25 | #define BLS_DBG(string, args...) if(bls_dbg_log) printk("[BLS]"string,##args) // default off, use "adb shell "echo dbg_log:1 > sys/kernel/debug/dispsys" to enable | |
26 | #define BLS_MSG(string, args...) printk("[BLS]"string,##args) // default on, important msg, not err | |
27 | #define BLS_ERR(string, args...) printk("[BLS]error:"string,##args) //default on, err msg | |
28 | ||
29 | #if !defined(CONFIG_MTK_AAL_SUPPORT) | |
30 | #ifdef USE_DISP_BLS_MUTEX | |
31 | static int gBLSMutexID = 3; | |
32 | #endif | |
33 | static int gBLSPowerOn = 0; | |
34 | #endif | |
35 | static int gMaxLevel = 1023; | |
36 | static int gPWMDiv = PWM_DEFAULT_DIV_VALUE; | |
37 | ||
38 | static DEFINE_MUTEX(backlight_mutex); | |
39 | ||
40 | static DISPLAY_PWM_T g_pwm_lut; | |
41 | static DISPLAY_GAMMA_T g_gamma_lut; | |
42 | static DISPLAY_GAMMA_T g_gamma_index = | |
43 | { | |
44 | entry: | |
45 | { | |
46 | { | |
47 | 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 60, 64, 68, 72, 76, 80, 84, 88, 92, 96, | |
48 | 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144, 148, 152, 156, 160, 164, 168, 172, 176, 180, 184, 188, 192, 196, | |
49 | 200, 204, 208, 212, 216, 220, 224, 228, 232, 236, 240, 244, 248, 252, 256, 260, 264, 268, 272, 276, 280, 284, 288, 292, 296, | |
50 | 300, 304, 308, 312, 316, 320, 324, 328, 332, 336, 340, 344, 348, 352, 356, 360, 364, 368, 372, 376, 380, 384, 388, 392, 396, | |
51 | 400, 404, 408, 412, 416, 420, 424, 428, 432, 436, 440, 444, 448, 452, 456, 460, 464, 468, 472, 476, 480, 484, 488, 492, 496, | |
52 | 500, 504, 508, 512, 516, 520, 524, 528, 532, 536, 540, 544, 548, 552, 556, 560, 564, 568, 572, 576, 580, 584, 588, 592, 596, | |
53 | 600, 604, 608, 612, 616, 620, 624, 628, 632, 636, 640, 644, 648, 652, 656, 660, 664, 668, 672, 676, 680, 684, 688, 692, 696, | |
54 | 700, 704, 708, 712, 716, 720, 724, 728, 732, 736, 740, 744, 748, 752, 756, 760, 764, 768, 772, 776, 780, 784, 788, 792, 796, | |
55 | 800, 804, 808, 812, 816, 820, 824, 828, 832, 836, 840, 844, 848, 852, 856, 860, 864, 868, 872, 876, 880, 884, 888, 892, 896, | |
56 | 900, 904, 908, 912, 916, 920, 924, 928, 932, 936, 940, 944, 948, 952, 956, 960, 964, 968, 972, 976, 980, 984, 988, 992, 996, | |
57 | 1000, 1004, 1008, 1012, 1016, 1020, 1023 | |
58 | }, | |
59 | { | |
60 | 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 60, 64, 68, 72, 76, 80, 84, 88, 92, 96, | |
61 | 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144, 148, 152, 156, 160, 164, 168, 172, 176, 180, 184, 188, 192, 196, | |
62 | 200, 204, 208, 212, 216, 220, 224, 228, 232, 236, 240, 244, 248, 252, 256, 260, 264, 268, 272, 276, 280, 284, 288, 292, 296, | |
63 | 300, 304, 308, 312, 316, 320, 324, 328, 332, 336, 340, 344, 348, 352, 356, 360, 364, 368, 372, 376, 380, 384, 388, 392, 396, | |
64 | 400, 404, 408, 412, 416, 420, 424, 428, 432, 436, 440, 444, 448, 452, 456, 460, 464, 468, 472, 476, 480, 484, 488, 492, 496, | |
65 | 500, 504, 508, 512, 516, 520, 524, 528, 532, 536, 540, 544, 548, 552, 556, 560, 564, 568, 572, 576, 580, 584, 588, 592, 596, | |
66 | 600, 604, 608, 612, 616, 620, 624, 628, 632, 636, 640, 644, 648, 652, 656, 660, 664, 668, 672, 676, 680, 684, 688, 692, 696, | |
67 | 700, 704, 708, 712, 716, 720, 724, 728, 732, 736, 740, 744, 748, 752, 756, 760, 764, 768, 772, 776, 780, 784, 788, 792, 796, | |
68 | 800, 804, 808, 812, 816, 820, 824, 828, 832, 836, 840, 844, 848, 852, 856, 860, 864, 868, 872, 876, 880, 884, 888, 892, 896, | |
69 | 900, 904, 908, 912, 916, 920, 924, 928, 932, 936, 940, 944, 948, 952, 956, 960, 964, 968, 972, 976, 980, 984, 988, 992, 996, | |
70 | 1000, 1004, 1008, 1012, 1016, 1020, 1023 | |
71 | }, | |
72 | { | |
73 | 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 60, 64, 68, 72, 76, 80, 84, 88, 92, 96, | |
74 | 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144, 148, 152, 156, 160, 164, 168, 172, 176, 180, 184, 188, 192, 196, | |
75 | 200, 204, 208, 212, 216, 220, 224, 228, 232, 236, 240, 244, 248, 252, 256, 260, 264, 268, 272, 276, 280, 284, 288, 292, 296, | |
76 | 300, 304, 308, 312, 316, 320, 324, 328, 332, 336, 340, 344, 348, 352, 356, 360, 364, 368, 372, 376, 380, 384, 388, 392, 396, | |
77 | 400, 404, 408, 412, 416, 420, 424, 428, 432, 436, 440, 444, 448, 452, 456, 460, 464, 468, 472, 476, 480, 484, 488, 492, 496, | |
78 | 500, 504, 508, 512, 516, 520, 524, 528, 532, 536, 540, 544, 548, 552, 556, 560, 564, 568, 572, 576, 580, 584, 588, 592, 596, | |
79 | 600, 604, 608, 612, 616, 620, 624, 628, 632, 636, 640, 644, 648, 652, 656, 660, 664, 668, 672, 676, 680, 684, 688, 692, 696, | |
80 | 700, 704, 708, 712, 716, 720, 724, 728, 732, 736, 740, 744, 748, 752, 756, 760, 764, 768, 772, 776, 780, 784, 788, 792, 796, | |
81 | 800, 804, 808, 812, 816, 820, 824, 828, 832, 836, 840, 844, 848, 852, 856, 860, 864, 868, 872, 876, 880, 884, 888, 892, 896, | |
82 | 900, 904, 908, 912, 916, 920, 924, 928, 932, 936, 940, 944, 948, 952, 956, 960, 964, 968, 972, 976, 980, 984, 988, 992, 996, | |
83 | 1000, 1004, 1008, 1012, 1016, 1020, 1023 | |
84 | } | |
85 | } | |
86 | }; | |
87 | ||
88 | DISPLAY_GAMMA_T * get_gamma_index(void) | |
89 | { | |
90 | BLS_DBG("get_gamma_index!\n"); | |
91 | return &g_gamma_index; | |
92 | } | |
93 | ||
94 | DISPLAY_PWM_T * get_pwm_lut(void) | |
95 | { | |
96 | BLS_DBG("get_pwm_lut!\n"); | |
97 | return &g_pwm_lut; | |
98 | } | |
99 | ||
4b9e9796 S |
100 | /* [FEATURE]-Mod-BEGIN by TCTSZ.yaohui.zeng, 2015/04/20,use customized brightness_mapping()*/ |
101 | //static unsigned int brightness_mapping(unsigned int level); | |
102 | extern unsigned int brightness_mapping(unsigned int level); | |
103 | /* [FEATURE]-Mod-END by TCTSZ.yaohui.zeng, 2015/04/20*/ | |
104 | ||
6fa3eb70 S |
105 | void disp_onConfig_bls(DISP_AAL_PARAM *param) |
106 | { | |
107 | unsigned long prevSetting = DISP_REG_GET(DISP_REG_BLS_BLS_SETTING); | |
108 | unsigned int regVal; | |
109 | unsigned int level = brightness_mapping(param->pwmDuty); | |
110 | ||
111 | BLS_DBG("disp_onConfig_bls!\n"); | |
112 | ||
113 | BLS_DBG("pwm duty = %lu => %u \n", param->pwmDuty, level); | |
114 | regVal = DISP_REG_GET(DISP_REG_BLS_EN); | |
115 | if (level == 0) | |
116 | { | |
117 | DISP_REG_SET(DISP_REG_BLS_PWM_DUTY, 0); | |
118 | if (regVal & 0x10000) | |
119 | DISP_REG_SET(DISP_REG_BLS_EN, regVal & 0xFFFEFFFF); | |
120 | } | |
121 | else | |
122 | { | |
123 | DISP_REG_SET(DISP_REG_BLS_PWM_DUTY, level); | |
124 | if (!(regVal & 0x10000)) | |
125 | DISP_REG_SET(DISP_REG_BLS_EN, regVal | 0x10000); | |
126 | } | |
127 | ||
128 | ||
129 | BLS_DBG("bls setting = %lu\n", param->setting); | |
130 | ||
131 | if (param->setting & ENUM_FUNC_BLS) | |
132 | { | |
133 | BLS_DBG("distion threshold = %lu\n", param->maxClrDistThd); | |
134 | BLS_DBG("predistion threshold = %lu\n", param->preDistThd); | |
135 | // TODO: BLS porting | |
136 | } | |
137 | ||
138 | if (prevSetting & 0x10100) | |
139 | { | |
140 | // TODO: BLS porting | |
141 | } | |
142 | else if (param->setting & ENUM_FUNC_BLS) | |
143 | { | |
144 | disp_set_aal_alarm(1); | |
145 | } | |
146 | ||
147 | } | |
148 | ||
4b9e9796 S |
149 | /* [FEATURE]-Mod-BEGIN by TCTSZ.yaohui.zeng, 2015/04/20,use customized brightness_mapping()*/ |
150 | /* | |
6fa3eb70 S |
151 | static unsigned int brightness_mapping(unsigned int level) |
152 | { | |
153 | unsigned int mapped_level; | |
154 | ||
155 | mapped_level = level; | |
156 | ||
157 | if (mapped_level > gMaxLevel) | |
158 | mapped_level = gMaxLevel; | |
159 | ||
160 | return mapped_level; | |
161 | } | |
4b9e9796 S |
162 | */ |
163 | /* [FEATURE]-Mod-END by TCTSZ.yaohui.zeng, 2015/04/20*/ | |
6fa3eb70 S |
164 | |
165 | #if !defined(CONFIG_MTK_AAL_SUPPORT) | |
166 | #ifdef USE_DISP_BLS_MUTEX | |
167 | static int disp_poll_for_reg(unsigned int addr, unsigned int value, unsigned int mask, unsigned int timeout) | |
168 | { | |
169 | unsigned int cnt = 0; | |
170 | ||
171 | while ((DISP_REG_GET(addr) & mask) != value) | |
172 | { | |
173 | msleep(1); | |
174 | cnt++; | |
175 | if (cnt > timeout) | |
176 | { | |
177 | return -1; | |
178 | } | |
179 | } | |
180 | ||
181 | return 0; | |
182 | } | |
183 | ||
184 | ||
185 | static int disp_bls_get_mutex(void) | |
186 | { | |
187 | if (gBLSMutexID < 0) | |
188 | return -1; | |
189 | ||
190 | DISP_REG_SET(DISP_REG_CONFIG_MUTEX(gBLSMutexID), 1); | |
191 | if(disp_poll_for_reg(DISP_REG_CONFIG_MUTEX(gBLSMutexID), 0x2, 0x2, POLLING_TIME_OUT)) | |
192 | { | |
193 | BLS_ERR("get mutex timeout! \n"); | |
194 | disp_dump_reg(DISP_MODULE_CONFIG); | |
195 | return -1; | |
196 | } | |
197 | return 0; | |
198 | } | |
199 | ||
200 | static int disp_bls_release_mutex(void) | |
201 | { | |
202 | if (gBLSMutexID < 0) | |
203 | return -1; | |
204 | ||
205 | DISP_REG_SET(DISP_REG_CONFIG_MUTEX(gBLSMutexID), 0); | |
206 | if(disp_poll_for_reg(DISP_REG_CONFIG_MUTEX(gBLSMutexID), 0, 0x2, POLLING_TIME_OUT)) | |
207 | { | |
208 | BLS_ERR("release mutex timeout! \n"); | |
209 | disp_dump_reg(DISP_MODULE_CONFIG); | |
210 | return -1; | |
211 | } | |
212 | return 0; | |
213 | } | |
214 | #endif | |
215 | #endif | |
216 | ||
217 | void disp_bls_update_gamma_lut(void) | |
218 | { | |
219 | #if defined(DDP_GAMMA_SUPPORT) | |
220 | int index, i; | |
221 | unsigned long CurVal, Count; | |
222 | ||
223 | BLS_MSG("disp_bls_update_gamma_lut!\n"); | |
224 | ||
225 | if (DISP_REG_GET(DISP_REG_BLS_EN) & 0x1) | |
226 | { | |
227 | BLS_ERR("try to update gamma lut while BLS is active\n"); | |
228 | return; | |
229 | } | |
230 | ||
231 | // init gamma table | |
232 | for(index = 0; index < 3; index++) | |
233 | { | |
234 | for(Count = 0; Count < 257 ; Count++) | |
235 | { | |
236 | g_gamma_lut.entry[index][Count] = g_gamma_index.entry[index][Count]; | |
237 | } | |
238 | } | |
239 | ||
240 | DISP_REG_SET(DISP_REG_BLS_LUT_UPDATE, 0x1); | |
241 | ||
242 | for (i = 0; i < 256 ; i++) | |
243 | { | |
244 | CurVal = (((g_gamma_lut.entry[0][i]&0x3FF)<<20) | ((g_gamma_lut.entry[1][i]&0x3FF)<<10) | (g_gamma_lut.entry[2][i]&0x3FF)); | |
245 | DISP_REG_SET(DISP_REG_BLS_GAMMA_LUT(i), CurVal); | |
246 | BLS_DBG("[%d] GAMMA LUT = 0x%x, (%lu, %lu, %lu)\n", i, DISP_REG_GET(DISP_REG_BLS_GAMMA_LUT(i)), | |
247 | g_gamma_lut.entry[0][i], g_gamma_lut.entry[1][i], g_gamma_lut.entry[2][i]); | |
248 | } | |
249 | ||
250 | /* Set Gamma Last point*/ | |
251 | DISP_REG_SET(DISP_REG_BLS_GAMMA_SETTING, 0x00000001); | |
252 | ||
253 | // set gamma last index | |
254 | CurVal = (((g_gamma_lut.entry[0][256]&0x3FF)<<20) | ((g_gamma_lut.entry[1][256]&0x3FF)<<10) | (g_gamma_lut.entry[2][256]&0x3FF)); | |
255 | DISP_REG_SET(DISP_REG_BLS_GAMMA_BOUNDARY, CurVal); | |
256 | ||
257 | DISP_REG_SET(DISP_REG_BLS_LUT_UPDATE, 0); | |
258 | #endif | |
259 | } | |
260 | ||
261 | void disp_bls_update_pwm_lut(void) | |
262 | { | |
263 | int i; | |
264 | unsigned int regValue; | |
265 | ||
266 | BLS_MSG("disp_bls_update_pwm_lut!\n"); | |
267 | ||
268 | regValue = DISP_REG_GET(DISP_REG_BLS_EN); | |
269 | if (regValue & 0x1) { | |
270 | BLS_ERR("update PWM LUT while BLS func enabled!\n"); | |
271 | disp_dump_reg(DISP_MODULE_BLS); | |
272 | } | |
273 | //DISP_REG_SET(DISP_REG_BLS_EN, (regValue & 0x00010000)); | |
274 | ||
275 | for (i = 0; i < PWM_LUT_ENTRY; i++) | |
276 | { | |
277 | DISP_REG_SET(DISP_REG_BLS_LUMINANCE(i), g_pwm_lut.entry[i]); | |
278 | BLS_DBG("[%d] PWM LUT = 0x%x (%lu)\n", i, DISP_REG_GET(DISP_REG_BLS_LUMINANCE(i)), g_pwm_lut.entry[i]); | |
279 | ||
280 | } | |
281 | DISP_REG_SET(DISP_REG_BLS_LUMINANCE_255, g_pwm_lut.entry[PWM_LUT_ENTRY-1]); | |
282 | //DISP_REG_SET(DISP_REG_BLS_EN, regValue); | |
283 | } | |
284 | ||
285 | void disp_bls_init(unsigned int srcWidth, unsigned int srcHeight) | |
286 | { | |
287 | struct cust_mt65xx_led *cust_led_list = get_cust_led_list(); | |
288 | struct cust_mt65xx_led *cust = NULL; | |
289 | struct PWM_config *config_data = NULL; | |
290 | ||
291 | if(cust_led_list) | |
292 | { | |
293 | cust = &cust_led_list[MT65XX_LED_TYPE_LCD]; | |
294 | if((strcmp(cust->name,"lcd-backlight") == 0) && (cust->mode == MT65XX_LED_MODE_CUST_BLS_PWM)) | |
295 | { | |
296 | config_data = &cust->config_data; | |
297 | if (config_data->clock_source >= 0 && config_data->clock_source <= 3) | |
298 | { | |
299 | unsigned int regVal = DISP_REG_GET(CLK_CFG_1); | |
300 | clkmux_sel(MT_MUX_PWM, config_data->clock_source, "DISP_PWM"); | |
301 | BLS_DBG("disp_bls_init : CLK_CFG_1 0x%x => 0x%x\n", regVal, DISP_REG_GET(CLK_CFG_1)); | |
302 | } | |
303 | gPWMDiv = (config_data->div == 0) ? PWM_DEFAULT_DIV_VALUE : config_data->div; | |
304 | gPWMDiv &= 0x3FF; | |
305 | BLS_MSG("disp_bls_init : PWM config data (%d,%d)\n", config_data->clock_source, config_data->div); | |
306 | } | |
307 | } | |
308 | ||
309 | BLS_DBG("disp_bls_init : srcWidth = %d, srcHeight = %d\n", srcWidth, srcHeight); | |
310 | BLS_MSG("disp_bls_init : BLS_EN=0x%x, PWM_DUTY=%d, PWM_DUTY_RD=%d, CG=0x%x, %d, %d\n", | |
311 | DISP_REG_GET(DISP_REG_BLS_EN), | |
312 | DISP_REG_GET(DISP_REG_BLS_PWM_DUTY), | |
313 | DISP_REG_GET(DISP_REG_BLS_PWM_DUTY_RD), | |
314 | DISP_REG_GET(DISP_REG_CONFIG_MMSYS_CG_CON0), | |
315 | clock_is_on(MT_CG_DISP0_MDP_BLS_26M), | |
316 | clock_is_on(MT_CG_DISP0_DISP_BLS)); | |
317 | ||
318 | DISP_REG_SET(DISP_REG_BLS_SRC_SIZE, (srcHeight << 16) | srcWidth); | |
319 | DISP_REG_SET(DISP_REG_BLS_PWM_CON, 0x0 | (gPWMDiv << 16)); | |
320 | DISP_REG_SET(DISP_REG_BLS_BLS_SETTING, 0x0); | |
321 | DISP_REG_SET(DISP_REG_BLS_INTEN, 0xF); | |
322 | if (!(DISP_REG_GET(DISP_REG_BLS_EN) & 0x10000)) | |
323 | DISP_REG_SET(DISP_REG_BLS_PWM_DUTY, 0); | |
324 | ||
325 | disp_bls_update_gamma_lut(); | |
326 | //disp_bls_update_pwm_lut(); | |
327 | ||
328 | disp_bls_config_full(srcWidth, srcHeight); | |
329 | ||
330 | if (dbg_log) | |
331 | disp_dump_reg(DISP_MODULE_BLS); | |
332 | } | |
333 | ||
334 | int disp_bls_config(void) | |
335 | { | |
336 | #if !defined(CONFIG_MTK_AAL_SUPPORT) | |
337 | struct cust_mt65xx_led *cust_led_list = get_cust_led_list(); | |
338 | struct cust_mt65xx_led *cust = NULL; | |
339 | struct PWM_config *config_data = NULL; | |
340 | ||
341 | if(cust_led_list) | |
342 | { | |
343 | cust = &cust_led_list[MT65XX_LED_TYPE_LCD]; | |
344 | if((strcmp(cust->name,"lcd-backlight") == 0) && (cust->mode == MT65XX_LED_MODE_CUST_BLS_PWM)) | |
345 | { | |
346 | config_data = &cust->config_data; | |
347 | if (config_data->clock_source >= 0 && config_data->clock_source <= 3) | |
348 | { | |
349 | unsigned int regVal = DISP_REG_GET(CLK_CFG_1); | |
350 | clkmux_sel(MT_MUX_PWM, config_data->clock_source, "DISP_PWM"); | |
351 | BLS_DBG("disp_bls_init : CLK_CFG_1 0x%x => 0x%x\n", regVal, DISP_REG_GET(CLK_CFG_1)); | |
352 | } | |
353 | gPWMDiv = (config_data->div == 0) ? PWM_DEFAULT_DIV_VALUE : config_data->div; | |
354 | gPWMDiv &= 0x3FF; | |
355 | BLS_MSG("disp_bls_config : PWM config data (%d,%d)\n", config_data->clock_source, config_data->div); | |
356 | } | |
357 | } | |
358 | ||
359 | if (!clock_is_on(MT_CG_DISP0_MDP_BLS_26M) || !gBLSPowerOn) | |
360 | { | |
361 | BLS_MSG("disp_bls_config: enable clock\n"); | |
362 | enable_clock(MT_CG_DISP0_SMI_LARB0, "DDP"); | |
363 | enable_clock(MT_CG_DISP0_MDP_BLS_26M , "DDP"); | |
364 | gBLSPowerOn = 1; | |
365 | } | |
366 | ||
367 | BLS_MSG("disp_bls_config : BLS_EN=0x%x, PWM_DUTY=%d, PWM_DUTY_RD=%d, CG=0x%x, %d, %d\n", | |
368 | DISP_REG_GET(DISP_REG_BLS_EN), | |
369 | DISP_REG_GET(DISP_REG_BLS_PWM_DUTY), | |
370 | DISP_REG_GET(DISP_REG_BLS_PWM_DUTY_RD), | |
371 | DISP_REG_GET(DISP_REG_CONFIG_MMSYS_CG_CON0), | |
372 | clock_is_on(MT_CG_DISP0_MDP_BLS_26M), | |
373 | clock_is_on(MT_CG_DISP0_DISP_BLS)); | |
374 | ||
375 | #ifdef USE_DISP_BLS_MUTEX | |
376 | BLS_MSG("disp_bls_config : gBLSMutexID = %d\n", gBLSMutexID); | |
377 | ||
378 | DISP_REG_SET(DISP_REG_CONFIG_MUTEX_RST(gBLSMutexID), 1); | |
379 | DISP_REG_SET(DISP_REG_CONFIG_MUTEX_RST(gBLSMutexID), 0); | |
380 | DISP_REG_SET(DISP_REG_CONFIG_MUTEX_MOD(gBLSMutexID), 0x200); // BLS | |
381 | DISP_REG_SET(DISP_REG_CONFIG_MUTEX_SOF(gBLSMutexID), 0); // single mode | |
382 | DISP_REG_SET(DISP_REG_CONFIG_MUTEX_EN(gBLSMutexID), 1); | |
383 | ||
384 | if (disp_bls_get_mutex() == 0) | |
385 | { | |
386 | ||
387 | #else | |
388 | BLS_MSG("disp_bls_config\n"); | |
389 | DISP_REG_SET(DISP_REG_BLS_DEBUG, 0x3); | |
390 | #endif | |
391 | ||
392 | if (!(DISP_REG_GET(DISP_REG_BLS_EN) & 0x10000)) | |
393 | DISP_REG_SET(DISP_REG_BLS_PWM_DUTY, 0); | |
394 | DISP_REG_SET(DISP_REG_BLS_PWM_CON, 0x0 | (gPWMDiv << 16)); | |
395 | //DISP_REG_SET(DISP_REG_BLS_EN, 0x00010001); //Enable BLS_EN | |
396 | ||
397 | #ifdef USE_DISP_BLS_MUTEX | |
398 | ||
399 | if (disp_bls_release_mutex() == 0) | |
400 | return 0; | |
401 | } | |
402 | return -1; | |
403 | #else | |
404 | DISP_REG_SET(DISP_REG_BLS_DEBUG, 0x0); | |
405 | #endif | |
406 | ||
407 | #endif | |
408 | BLS_MSG("disp_bls_config:-\n"); | |
409 | return 0; | |
410 | } | |
411 | ||
412 | void disp_bls_config_full(unsigned int width, unsigned int height) | |
413 | { | |
414 | unsigned int regVal; | |
415 | unsigned int dither_bpp = DISP_GetOutputBPPforDithering(); | |
416 | ||
417 | BLS_DBG("disp_bls_config_full, width=%d, height=%d, reg=0x%x \n", | |
418 | width, height, ((height<<16) + width)); | |
419 | ||
420 | //DISP_REG_SET(DISP_REG_BLS_DEBUG ,0x00000003); | |
421 | ||
422 | #if defined(DDP_GAMMA_SUPPORT) | |
423 | DISP_REG_SET(DISP_REG_BLS_BLS_SETTING ,0x00100007); | |
424 | #else | |
425 | DISP_REG_SET(DISP_REG_BLS_BLS_SETTING ,0x00100000); | |
426 | #endif | |
427 | DISP_REG_SET(DISP_REG_BLS_SRC_SIZE ,((height<<16) + width)); | |
428 | DISP_REG_SET(DISP_REG_BLS_GAMMA_SETTING ,0x00000001); | |
429 | DISP_REG_SET(DISP_REG_BLS_GAMMA_BOUNDARY ,0x3fffffff); | |
430 | ||
431 | /* BLS Luminance LUT */ | |
432 | DISP_REG_SET(DISP_REG_BLS_LUMINANCE(0) ,0x00000000); | |
433 | DISP_REG_SET(DISP_REG_BLS_LUMINANCE(1) ,0x00000004); | |
434 | DISP_REG_SET(DISP_REG_BLS_LUMINANCE(2) ,0x00000010); | |
435 | DISP_REG_SET(DISP_REG_BLS_LUMINANCE(3) ,0x00000024); | |
436 | DISP_REG_SET(DISP_REG_BLS_LUMINANCE(4) ,0x00000040); | |
437 | DISP_REG_SET(DISP_REG_BLS_LUMINANCE(5) ,0x00000064); | |
438 | DISP_REG_SET(DISP_REG_BLS_LUMINANCE(6) ,0x00000090); | |
439 | DISP_REG_SET(DISP_REG_BLS_LUMINANCE(7) ,0x000000C4); | |
440 | DISP_REG_SET(DISP_REG_BLS_LUMINANCE(8) ,0x00000100); | |
441 | DISP_REG_SET(DISP_REG_BLS_LUMINANCE(9) ,0x00000144); | |
442 | DISP_REG_SET(DISP_REG_BLS_LUMINANCE(10) ,0x00000190); | |
443 | DISP_REG_SET(DISP_REG_BLS_LUMINANCE(11) ,0x000001E4); | |
444 | DISP_REG_SET(DISP_REG_BLS_LUMINANCE(12) ,0x00000240); | |
445 | DISP_REG_SET(DISP_REG_BLS_LUMINANCE(13) ,0x00000244); | |
446 | DISP_REG_SET(DISP_REG_BLS_LUMINANCE(14) ,0x00000310); | |
447 | DISP_REG_SET(DISP_REG_BLS_LUMINANCE(15) ,0x00000384); | |
448 | DISP_REG_SET(DISP_REG_BLS_LUMINANCE(16) ,0x00000400); | |
449 | DISP_REG_SET(DISP_REG_BLS_LUMINANCE(17) ,0x00000484); | |
450 | DISP_REG_SET(DISP_REG_BLS_LUMINANCE(18) ,0x00000510); | |
451 | DISP_REG_SET(DISP_REG_BLS_LUMINANCE(19) ,0x000005A4); | |
452 | DISP_REG_SET(DISP_REG_BLS_LUMINANCE(20) ,0x00000640); | |
453 | DISP_REG_SET(DISP_REG_BLS_LUMINANCE(21) ,0x000006E4); | |
454 | DISP_REG_SET(DISP_REG_BLS_LUMINANCE(22) ,0x00000790); | |
455 | DISP_REG_SET(DISP_REG_BLS_LUMINANCE(23) ,0x00000843); | |
456 | DISP_REG_SET(DISP_REG_BLS_LUMINANCE(24) ,0x000008FF); | |
457 | DISP_REG_SET(DISP_REG_BLS_LUMINANCE(25) ,0x000009C3); | |
458 | DISP_REG_SET(DISP_REG_BLS_LUMINANCE(26) ,0x00000A8F); | |
459 | DISP_REG_SET(DISP_REG_BLS_LUMINANCE(27) ,0x00000B63); | |
460 | DISP_REG_SET(DISP_REG_BLS_LUMINANCE(28) ,0x00000C3F); | |
461 | DISP_REG_SET(DISP_REG_BLS_LUMINANCE(29) ,0x00000D23); | |
462 | DISP_REG_SET(DISP_REG_BLS_LUMINANCE(30) ,0x00000E0F); | |
463 | DISP_REG_SET(DISP_REG_BLS_LUMINANCE(31) ,0x00000F03); | |
464 | DISP_REG_SET(DISP_REG_BLS_LUMINANCE(32) ,0x00000FFF); | |
465 | /* BLS Luminance 255 */ | |
466 | DISP_REG_SET(DISP_REG_BLS_LUMINANCE_255 ,0x00000FDF); | |
467 | ||
468 | /* Dither */ | |
469 | DISP_REG_SET(DISP_REG_BLS_DITHER(5) ,0x00000000); | |
470 | DISP_REG_SET(DISP_REG_BLS_DITHER(6) ,0x00003004); | |
471 | DISP_REG_SET(DISP_REG_BLS_DITHER(7) ,0x00000000); | |
472 | DISP_REG_SET(DISP_REG_BLS_DITHER(8) ,0x00000000); | |
473 | DISP_REG_SET(DISP_REG_BLS_DITHER(9) ,0x00000000); | |
474 | DISP_REG_SET(DISP_REG_BLS_DITHER(10) ,0x00000000); | |
475 | DISP_REG_SET(DISP_REG_BLS_DITHER(11) ,0x00000000); | |
476 | DISP_REG_SET(DISP_REG_BLS_DITHER(12) ,0x00000011); | |
477 | DISP_REG_SET(DISP_REG_BLS_DITHER(13) ,0x00000000); | |
478 | DISP_REG_SET(DISP_REG_BLS_DITHER(14) ,0x00000000); | |
479 | /* output RGB888 */ | |
480 | if (dither_bpp == 16) // 565 | |
481 | { | |
482 | DISP_REG_SET(DISP_REG_BLS_DITHER(15), 0x50500001); | |
483 | DISP_REG_SET(DISP_REG_BLS_DITHER(16), 0x50504040); | |
484 | DISP_REG_SET(DISP_REG_BLS_DITHER(0), 0x00000001); | |
485 | } | |
486 | else if (dither_bpp == 18) // 666 | |
487 | { | |
488 | DISP_REG_SET(DISP_REG_BLS_DITHER(15), 0x40400001); | |
489 | DISP_REG_SET(DISP_REG_BLS_DITHER(16), 0x40404040); | |
490 | DISP_REG_SET(DISP_REG_BLS_DITHER(0), 0x00000001); | |
491 | } | |
492 | else if (dither_bpp == 24) // 888 | |
493 | { | |
494 | DISP_REG_SET(DISP_REG_BLS_DITHER(15), 0x20200001); | |
495 | DISP_REG_SET(DISP_REG_BLS_DITHER(16), 0x20202020); | |
496 | DISP_REG_SET(DISP_REG_BLS_DITHER(0), 0x00000001); | |
497 | } | |
498 | else | |
499 | { | |
500 | BLS_MSG("error diter bpp = %d\n", dither_bpp); | |
501 | DISP_REG_SET(DISP_REG_BLS_DITHER(0), 0x00000000); | |
502 | } | |
503 | ||
504 | ||
505 | DISP_REG_SET(DISP_REG_BLS_INTEN ,0x0000000f); // no scene change | |
506 | ||
507 | regVal = DISP_REG_GET(DISP_REG_BLS_EN); | |
508 | if (regVal & 0x10000) // PWM_EN has been enabled | |
509 | DISP_REG_SET(DISP_REG_BLS_EN ,0x00010001); | |
510 | else // on resume | |
511 | DISP_REG_SET(DISP_REG_BLS_EN ,0x00000001); | |
512 | ||
513 | //DISP_REG_SET(DISP_REG_BLS_EN ,0x00000001); | |
514 | ||
515 | //DISP_REG_SET(DISP_REG_BLS_DEBUG ,0x00000000); | |
516 | } | |
517 | ||
518 | ||
519 | int disp_bls_set_max_backlight_(unsigned int level) | |
520 | { | |
521 | mutex_lock(&backlight_mutex); | |
522 | BLS_MSG("disp_bls_set_max_backlight: level = %d, current level = %d\n", level * 1023 / 255, gMaxLevel); | |
523 | //PWM duty input = PWM_DUTY_IN / 1024 | |
524 | gMaxLevel = level * 1023 / 255; | |
525 | mutex_unlock(&backlight_mutex); | |
526 | return 0; | |
527 | } | |
528 | ||
529 | ||
530 | int disp_bls_get_max_backlight(void) | |
531 | { | |
532 | int max_bl; | |
533 | ||
534 | mutex_lock(&backlight_mutex); | |
535 | max_bl = gMaxLevel; | |
536 | mutex_unlock(&backlight_mutex); | |
537 | ||
538 | return max_bl; | |
539 | } | |
540 | ||
541 | ||
542 | #if !defined(CONFIG_MTK_AAL_SUPPORT) | |
543 | int disp_bls_set_backlight(unsigned int level) | |
544 | { | |
545 | unsigned int regVal; | |
546 | unsigned int mapped_level; | |
547 | BLS_MSG("disp_bls_set_backlight: %d, gBLSPowerOn = %d\n", level, gBLSPowerOn); | |
548 | ||
549 | mutex_lock(&backlight_mutex); | |
550 | ||
551 | // if (level && (!clock_is_on(MT_CG_DISP0_MDP_BLS_26M) || !gBLSPowerOn)) | |
552 | // { | |
553 | // disp_bls_config(); | |
554 | // } | |
555 | #ifdef USE_DISP_BLS_MUTEX | |
556 | disp_bls_get_mutex(); | |
557 | #else | |
558 | DISP_REG_SET(DISP_REG_BLS_DEBUG, 0x3); | |
559 | #endif | |
560 | ||
561 | mapped_level = brightness_mapping(level); | |
562 | BLS_MSG("after mapping, mapped_level: %d\n", mapped_level); | |
563 | DISP_REG_SET(DISP_REG_BLS_PWM_DUTY, mapped_level); | |
564 | if(level != 0) | |
565 | { | |
566 | regVal = DISP_REG_GET(DISP_REG_BLS_EN); | |
567 | if (!(regVal & 0x10000)) | |
568 | DISP_REG_SET(DISP_REG_BLS_EN, regVal | 0x10000); | |
569 | } | |
570 | else | |
571 | { | |
572 | regVal = DISP_REG_GET(DISP_REG_BLS_EN); | |
573 | if (regVal & 0x10000) | |
574 | DISP_REG_SET(DISP_REG_BLS_EN, regVal & 0xFFFEFFFF); | |
575 | } | |
576 | BLS_MSG("after SET, PWM_DUTY: %d\n", DISP_REG_GET(DISP_REG_BLS_PWM_DUTY)); | |
577 | ||
578 | #ifdef USE_DISP_BLS_MUTEX | |
579 | disp_bls_release_mutex(); | |
580 | #else | |
581 | DISP_REG_SET(DISP_REG_BLS_DEBUG, 0x0); | |
582 | #endif | |
583 | ||
584 | // if (!level && (clock_is_on(MT_CG_DISP0_MDP_BLS_26M) && gBLSPowerOn)) | |
585 | // { | |
586 | // BLS_MSG("disp_bls_set_backlight: disable clock\n"); | |
587 | // disable_clock(MT_CG_DISP0_MDP_BLS_26M , "DDP"); | |
588 | // disable_clock(MT_CG_DISP0_SMI_LARB0 , "DDP"); | |
589 | // gBLSPowerOn = 0; | |
590 | // } | |
591 | mutex_unlock(&backlight_mutex); | |
592 | return 0; | |
593 | } | |
594 | #else | |
595 | int disp_bls_set_backlight(unsigned int level) | |
596 | { | |
597 | DISP_AAL_PARAM *param; | |
598 | BLS_MSG("disp_bls_set_backlight: %d\n", level); | |
599 | ||
600 | mutex_lock(&backlight_mutex); | |
601 | disp_aal_lock(); | |
602 | param = get_aal_config(); | |
603 | param->pwmDuty = level; | |
604 | disp_aal_unlock(); | |
605 | mutex_unlock(&backlight_mutex); | |
606 | return 0; | |
607 | } | |
608 | #endif | |
609 | static unsigned long prev_debug = 0; | |
610 | void disp_bls_contrl_directly(bool enable) | |
611 | { | |
612 | if(!prev_debug) | |
613 | { | |
614 | prev_debug = DISP_REG_GET(DISP_REG_BLS_DEBUG); | |
615 | } | |
616 | ||
617 | if(enable) | |
618 | { | |
619 | DISP_REG_SET(DISP_REG_BLS_DEBUG, prev_debug); | |
620 | DISP_REG_SET(DISP_REG_BLS_PWM_DUTY, 0); | |
621 | DISP_REG_SET(DISP_REG_BLS_EN,0x00010001); | |
622 | } | |
623 | else | |
624 | { | |
625 | DISP_REG_SET(DISP_REG_BLS_DEBUG, 0x3); | |
626 | DISP_REG_SET(DISP_REG_BLS_PWM_DUTY, 0); | |
627 | DISP_REG_SET(DISP_REG_BLS_EN, 0); | |
628 | } | |
629 | } | |
630 |