1 /* disp_edp.c
2 *
3 * Copyright (c) 2007-2017 Allwinnertech Co., Ltd.
4 * Author: zhengxiaobin <zhengxiaobin@allwinnertech.com>
5 *
6 * register edp
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
11 */
12
13 #include "disp_edp.h"
14
15 #if defined(SUPPORT_EDP)
16
17 #define EDP_POWER_NUM 2
18
19 struct disp_edp_private_data {
20 u32 enabled;
21 u32 edp_index; /*edp module index*/
22 bool suspended;
23 enum disp_tv_mode mode;
24 struct disp_video_timings *video_info;
25 struct disp_tv_func edp_func;
26 struct clk *clk;
27 struct clk *clk_bus;
28 struct reset_control *reset;
29 u32 irq_no;
30 u32 frame_per_sec;
31 u32 usec_per_line;
32 u32 judge_line;
33 u32 edp_pwm_used;
34 u32 edp_pwm_ch;
35 u32 edp_pwm_freq;
36 u32 edp_pwm_pol;
37 bool bl_enabled;
38 u32 bl_need_enabled;
39 u32 backlight_dimming;
40 struct {
41 uintptr_t dev;
42 u32 channel;
43 u32 polarity;
44 u32 period_ns;
45 u32 duty_ns;
46 u32 enabled;
47 } pwm_info;
48 u32 backlight_bright;
49 bool edp_bl_en_used;
50 struct disp_gpio_info edp_bl_en;
51 int edp_bl_gpio_hdl;
52 char edp_bl_en_power[32];
53 u32 edp_power_used[EDP_POWER_NUM];
54 char edp_power[EDP_POWER_NUM][32];
55 };
56
57 /*global static variable*/
58 static u32 g_edp_used;
59 static struct disp_device *g_pedp_devices;
60 static struct disp_edp_private_data *g_pedp_private;
61 static spinlock_t g_edp_data_lock;
62 static s32 disp_edp_set_bright(struct disp_device *edp, u32 bright);
63 static s32 disp_edp_get_bright(struct disp_device *edp);
64 static s32 disp_edp_backlight_enable(struct disp_device *edp);
65 static s32 disp_edp_backlight_disable(struct disp_device *edp);
66 static s32 disp_edp_pwm_enable(struct disp_device *edp);
67 static s32 disp_edp_pwm_disable(struct disp_device *edp);
68
69 /**
70 * @name disp_edp_get_priv
71 * @brief get disp_edp_private_data of disp_device
72 * @param[IN] p_edp: disp_device var
73 * @param[OUT] none
74 * @return 0 if success,otherwise fail
75 */
76 static struct disp_edp_private_data *
disp_edp_get_priv(struct disp_device * p_edp)77 disp_edp_get_priv(struct disp_device *p_edp)
78 {
79 if (p_edp == NULL) {
80 DE_WRN("NULL hdl!\n");
81 return NULL;
82 }
83
84 return (struct disp_edp_private_data *)p_edp->priv_data;
85 }
86
disp_edp_get_fps(struct disp_device * p_edp)87 s32 disp_edp_get_fps(struct disp_device *p_edp)
88 {
89 struct disp_edp_private_data *p_edpp = disp_edp_get_priv(p_edp);
90
91 if ((p_edp == NULL) || (p_edpp == NULL)) {
92 DE_WRN("p_edp set func null hdl!\n");
93 return 0;
94 }
95
96 return p_edpp->frame_per_sec;
97 }
98
disp_edp_resume(struct disp_device * p_edp)99 s32 disp_edp_resume(struct disp_device *p_edp)
100 {
101 s32 ret = 0;
102 struct disp_edp_private_data *p_edpp = disp_edp_get_priv(p_edp);
103
104 if ((p_edp == NULL) || (p_edpp == NULL)) {
105 DE_WRN("disp set func null hdl!\n");
106 return DIS_FAIL;
107 }
108
109 if (p_edpp->suspended == true) {
110 if (p_edpp->edp_func.tv_resume)
111 ret = p_edpp->edp_func.tv_resume(p_edpp->edp_index);
112 p_edpp->suspended = false;
113 }
114 return ret;
115 }
116
disp_edp_suspend(struct disp_device * p_edp)117 s32 disp_edp_suspend(struct disp_device *p_edp)
118 {
119 s32 ret = 0;
120 struct disp_edp_private_data *p_edpp = disp_edp_get_priv(p_edp);
121
122 if ((p_edp == NULL) || (p_edpp == NULL)) {
123 DE_WRN("disp set func null hdl!\n");
124 return DIS_FAIL;
125 }
126
127 if (p_edpp->suspended == false) {
128 p_edpp->suspended = true;
129 if (p_edpp->edp_func.tv_suspend)
130 ret = p_edpp->edp_func.tv_suspend(p_edpp->edp_index);
131 }
132
133 return ret;
134 }
135
cal_real_frame_period(struct disp_device * p_edp)136 static s32 cal_real_frame_period(struct disp_device *p_edp)
137 {
138 struct disp_edp_private_data *p_edpp = disp_edp_get_priv(p_edp);
139 unsigned long long temp = 0;
140
141 if ((p_edp == NULL) || (p_edpp == NULL)) {
142 DE_WRN("disp set func null hdl!\n");
143 return DIS_FAIL;
144 }
145
146 if (!p_edpp->edp_func.tv_get_startdelay) {
147 DE_WRN("null tv_get_startdelay\n");
148 return DIS_FAIL;
149 }
150
151 temp = ONE_SEC * p_edp->timings.hor_total_time *
152 p_edp->timings.ver_total_time;
153
154 do_div(temp, p_edp->timings.pixel_clk);
155
156 p_edp->timings.frame_period = temp;
157
158 p_edp->timings.start_delay =
159 p_edpp->edp_func.tv_get_startdelay(p_edpp->edp_index);
160
161 DE_INF("frame_period:%lld,start_delay:%d\n",
162 p_edp->timings.frame_period, p_edp->timings.start_delay);
163
164 return 0;
165 }
166
disp_edp_get_input_csc(struct disp_device * p_edp)167 s32 disp_edp_get_input_csc(struct disp_device *p_edp)
168 {
169 struct disp_edp_private_data *p_edpp = disp_edp_get_priv(p_edp);
170
171 if ((p_edp == NULL) || (p_edpp == NULL)) {
172 DE_WRN("null hdl!\n");
173 return 0;
174 }
175
176 if (p_edpp->edp_func.tv_get_input_csc == NULL)
177 return 0;
178
179 return p_edpp->edp_func.tv_get_input_csc(p_edpp->edp_index);
180 }
181
182
183
edp_calc_judge_line(struct disp_device * p_edp)184 static s32 edp_calc_judge_line(struct disp_device *p_edp)
185 {
186 struct disp_edp_private_data *p_edpp = disp_edp_get_priv(p_edp);
187
188 int start_delay, usec_start_delay;
189 int usec_judge_point;
190 int pixel_clk;
191
192 if (!p_edpp || !p_edp) {
193 DE_WRN("edp init null hdl!\n");
194 return DIS_FAIL;
195 }
196
197 pixel_clk = p_edpp->video_info->pixel_clk;
198
199 if (p_edpp->usec_per_line == 0) {
200
201 /*
202 * usec_per_line = 1 / fps / vt * 1000000
203 * = 1 / (pixel_clk / vt / ht) / vt * 1000000
204 * = ht / pixel_clk * 1000000
205 */
206 p_edpp->frame_per_sec = pixel_clk /
207 p_edpp->video_info->hor_total_time /
208 p_edpp->video_info->ver_total_time;
209 p_edpp->usec_per_line =
210 p_edpp->video_info->hor_total_time * 1000000 / pixel_clk;
211 }
212
213 if (p_edpp->judge_line == 0) {
214 start_delay =
215 p_edpp->edp_func.tv_get_startdelay(p_edpp->edp_index);
216 usec_start_delay = start_delay * p_edpp->usec_per_line;
217 if (usec_start_delay <= 200)
218 usec_judge_point = usec_start_delay * 3 / 7;
219 else if (usec_start_delay <= 400)
220 usec_judge_point = usec_start_delay / 2;
221 else
222 usec_judge_point = 200;
223 p_edpp->judge_line = usec_judge_point / p_edpp->usec_per_line;
224 }
225
226 return 0;
227 }
228
disp_edp_power_enable(struct disp_device * edp,u32 power_id)229 static s32 disp_edp_power_enable(struct disp_device *edp, u32 power_id)
230 {
231 int ret;
232 struct disp_edp_private_data *edpp = disp_edp_get_priv(edp);
233
234 if (!edp || !edpp) {
235 DE_WRN("NULL hdl!\n");
236 return DIS_FAIL;
237 }
238
239 ret = disp_sys_power_enable(edpp->edp_regulator[power_id]);
240 if (ret)
241 return DIS_FAIL;
242
243 return DIS_SUCCESS;
244 }
245
disp_edp_power_disable(struct disp_device * edp,u32 power_id)246 static s32 disp_edp_power_disable(struct disp_device *edp, u32 power_id)
247 {
248 int ret;
249 struct disp_edp_private_data *edpp = disp_edp_get_priv(edp);
250
251 if (!edp || !edpp) {
252 DE_WRN("NULL hdl!\n");
253 return DIS_FAIL;
254 }
255
256 ret = disp_sys_power_disable(edpp->edp_regulator[power_id]);
257 if (ret)
258 return DIS_FAIL;
259
260 return DIS_SUCCESS;
261 }
262
263 #if defined(__LINUX_PLAT__)
disp_edp_event_proc(int irq,void * parg)264 static s32 disp_edp_event_proc(int irq, void *parg)
265 #else
266 static s32 disp_edp_event_proc(void *parg)
267 #endif
268 {
269 struct disp_device *p_edp = (struct disp_device *)parg;
270 struct disp_manager *mgr = NULL;
271 struct disp_edp_private_data *p_edpp = disp_edp_get_priv(p_edp);
272 int cur_line;
273 int start_delay;
274
275 if (p_edp == NULL || p_edpp == NULL)
276 return DISP_IRQ_RETURN;
277
278 if (p_edpp->edp_func.tv_irq_query(p_edpp->edp_index)) {
279 cur_line = p_edpp->edp_func.tv_get_cur_line(p_edpp->edp_index);
280 start_delay =
281 p_edpp->edp_func.tv_get_startdelay(p_edpp->edp_index);
282
283 mgr = p_edp->manager;
284 if (mgr == NULL)
285 return DISP_IRQ_RETURN;
286
287 if (cur_line <= (start_delay - 4))
288 sync_event_proc(mgr->disp, false);
289 else
290 sync_event_proc(mgr->disp, true);
291 }
292
293 return DISP_IRQ_RETURN;
294 }
295
296
disp_edp_is_enabled(struct disp_device * p_edp)297 s32 disp_edp_is_enabled(struct disp_device *p_edp)
298 {
299 struct disp_edp_private_data *p_edpp = disp_edp_get_priv(p_edp);
300
301 if ((p_edp == NULL) || (p_edpp == NULL)) {
302 DE_WRN("edp set func null hdl!\n");
303 return DIS_FAIL;
304 }
305
306 return p_edpp->enabled;
307 }
308
309
310
311 /**
312 * @name :disp_edp_set_func
313 * @brief :set edp lowlevel function
314 * @param[IN] :p_edp:disp_device
315 * @param[OUT] :func:lowlevel function
316 * @return :0 if success else fail
317 */
disp_edp_set_func(struct disp_device * p_edp,struct disp_tv_func * func)318 s32 disp_edp_set_func(struct disp_device *p_edp,
319 struct disp_tv_func *func)
320 {
321 struct disp_edp_private_data *p_edpp = disp_edp_get_priv(p_edp);
322
323 if ((p_edp == NULL) || (p_edpp == NULL) || (func == NULL)) {
324 DE_WRN("edp set func null hdl!\n");
325 DE_WRN("%s,point p_edp = %p, point p_edpp = %p\n", __func__,
326 p_edp, p_edpp);
327 return DIS_FAIL;
328 }
329 p_edpp->edp_func.tv_enable = func->tv_enable;
330 p_edpp->edp_func.tv_disable = func->tv_disable;
331 p_edpp->edp_func.tv_suspend = func->tv_suspend;
332 p_edpp->edp_func.tv_resume = func->tv_resume;
333 p_edpp->edp_func.tv_get_input_csc = func->tv_get_input_csc;
334 p_edpp->edp_func.tv_irq_enable = func->tv_irq_enable;
335 p_edpp->edp_func.tv_irq_query = func->tv_irq_query;
336 p_edpp->edp_func.tv_get_startdelay = func->tv_get_startdelay;
337 p_edpp->edp_func.tv_get_cur_line = func->tv_get_cur_line;
338 p_edpp->edp_func.tv_get_video_timing_info =
339 func->tv_get_video_timing_info;
340 p_edpp->edp_func.tv_show_builtin_patten = func->tv_show_builtin_patten;
341
342 return 0;
343 }
344
345
edp_parse_panel_para(struct disp_edp_private_data * p_edpp,struct disp_video_timings * p_info)346 s32 edp_parse_panel_para(struct disp_edp_private_data *p_edpp,
347 struct disp_video_timings *p_info)
348 {
349 s32 ret = -1;
350 s32 fun_ret = -1;
351 s32 value = 1;
352 char primary_key[20], sub_name[25];
353 u32 fps = 0, i = 0;
354 struct disp_gpio_info *gpio_info;
355
356 if (!p_info || !p_edpp)
357 goto OUT;
358
359 sprintf(primary_key, "edp%d", p_edpp->edp_index);
360
361 ret = disp_sys_script_get_item(primary_key, "edp_used", &value, 1);
362 if (ret != 1 && value == 0)
363 return fun_ret;
364
365 memset(p_info, 0, sizeof(struct disp_video_timings));
366
367 ret = disp_sys_script_get_item(primary_key, "edp_x", &value, 1);
368 if (ret == 1)
369 p_info->x_res = value;
370
371 ret = disp_sys_script_get_item(primary_key, "edp_y", &value, 1);
372 if (ret == 1)
373 p_info->y_res = value;
374
375 ret = disp_sys_script_get_item(primary_key, "edp_hbp", &value, 1);
376 if (ret == 1)
377 p_info->hor_back_porch = value;
378
379 ret = disp_sys_script_get_item(primary_key, "edp_ht", &value, 1);
380 if (ret == 1)
381 p_info->hor_total_time = value;
382
383 ret = disp_sys_script_get_item(primary_key, "edp_hspw", &value, 1);
384 if (ret == 1)
385 p_info->hor_sync_time = value;
386
387 ret = disp_sys_script_get_item(primary_key, "edp_vt", &value, 1);
388 if (ret == 1)
389 p_info->ver_total_time = value;
390
391 ret = disp_sys_script_get_item(primary_key, "edp_vspw", &value, 1);
392 if (ret == 1)
393 p_info->ver_sync_time = value;
394
395 ret = disp_sys_script_get_item(primary_key, "edp_vbp", &value, 1);
396 if (ret == 1)
397 p_info->ver_back_porch = value;
398
399 ret = disp_sys_script_get_item(primary_key, "edp_fps", &value, 1);
400 if (ret == 1)
401 fps = value;
402
403 p_info->pixel_clk =
404 p_info->hor_total_time * p_info->ver_total_time * fps;
405
406 ret = disp_sys_script_get_item(primary_key, "edp_pwm_used", &value, 1);
407 if (ret == 1)
408 p_edpp->edp_pwm_used = value;
409
410 ret = disp_sys_script_get_item(primary_key, "edp_pwm_ch", &value, 1);
411 if (ret == 1)
412 p_edpp->edp_pwm_ch = value;
413
414 ret = disp_sys_script_get_item(primary_key, "edp_pwm_freq", &value, 1);
415 if (ret == 1)
416 p_edpp->edp_pwm_freq = value;
417
418 ret = disp_sys_script_get_item(primary_key, "edp_pwm_pol", &value, 1);
419 if (ret == 1)
420 p_edpp->edp_pwm_pol = value;
421
422 p_edpp->edp_bl_en_used = 0;
423 gpio_info = &(p_edpp->edp_bl_en);
424 ret = disp_sys_script_get_item(primary_key, "edp_bl_en",
425 (int *)gpio_info, 3);
426 if (ret == 3)
427 p_edpp->edp_bl_en_used = 1;
428
429 sprintf(sub_name, "edp_bl_en_power");
430 ret = disp_sys_script_get_item(primary_key, sub_name,
431 (int *)p_edpp->edp_bl_en_power, 2);
432
433 sprintf(sub_name, "edp_default_backlight");
434 ret = disp_sys_script_get_item(primary_key, sub_name, &value, 1);
435 if (ret == 1) {
436 value = (value > 256) ? 256 : value;
437 p_edpp->backlight_bright = value;
438 } else {
439 p_edpp->backlight_bright = 197;
440 }
441
442 for (i = 0; i < EDP_POWER_NUM; i++) {
443 if (i == 0)
444 sprintf(sub_name, "edp_power");
445 else
446 sprintf(sub_name, "edp_power%d", i);
447 p_edpp->edp_power_used[i] = 0;
448 ret = disp_sys_script_get_item(
449 primary_key, sub_name, (int *)(p_edpp->edp_power[i]), 2);
450 if (ret == 2)
451 p_edpp->edp_power_used[i] = 1;
452 }
453
454 fun_ret = 0;
455 OUT:
456 return fun_ret;
457 }
458
459
460 /**
461 * @name :disp_edp_init
462 * @brief :get sys_config.
463 * @param[IN] :p_edp:disp_device
464 * @param[OUT] :none
465 * @return :0 if success else fail
466 */
disp_edp_init(struct disp_device * p_edp)467 static s32 disp_edp_init(struct disp_device *p_edp)
468 {
469 struct disp_edp_private_data *p_edpp = disp_edp_get_priv(p_edp);
470 s32 ret = -1;
471 __u64 backlight_bright;
472 __u64 period_ns, duty_ns;
473
474 if (!p_edp || !p_edpp) {
475 DE_WRN("edp init null hdl!\n");
476 return DIS_FAIL;
477 }
478 ret = edp_parse_panel_para(p_edpp, &p_edp->timings);
479 if (ret != 0)
480 goto OUT;
481 if (p_edpp->edp_pwm_used) {
482 p_edpp->pwm_info.channel = p_edpp->edp_pwm_ch;
483 p_edpp->pwm_info.polarity = p_edpp->edp_pwm_pol;
484 p_edpp->pwm_info.dev = disp_sys_pwm_request(p_edpp->edp_pwm_ch);
485 if (p_edpp->edp_pwm_freq != 0) {
486 period_ns = 1000 * 1000 * 1000 / p_edpp->edp_pwm_freq;
487 } else {
488 DE_WRN("edp%d.edp_pwm_freq is ZERO\n",
489 p_edpp->edp_index);
490 /*default 1khz*/
491 period_ns = 1000 * 1000 * 1000 / 1000;
492 }
493
494 backlight_bright = p_edpp->backlight_bright;
495
496 duty_ns = (backlight_bright * period_ns) / 256;
497 disp_sys_pwm_set_polarity(p_edpp->pwm_info.dev,
498 p_edpp->pwm_info.polarity);
499 p_edpp->pwm_info.duty_ns = duty_ns;
500 p_edpp->pwm_info.period_ns = period_ns;
501 }
502 OUT:
503 return ret;
504 }
505
disp_edp_disable(struct disp_device * p_edp)506 s32 disp_edp_disable(struct disp_device *p_edp)
507 {
508 struct disp_edp_private_data *p_edpp = disp_edp_get_priv(p_edp);
509 unsigned long flags;
510 struct disp_manager *mgr = NULL;
511
512 if ((p_edp == NULL) || (p_edpp == NULL)) {
513 DE_WRN("edp set func null hdl!\n");
514 return DIS_FAIL;
515 }
516
517 mgr = p_edp->manager;
518 if (!mgr) {
519 DE_WRN("edp%d's mgr is NULL\n", p_edp->disp);
520 return DIS_FAIL;
521 }
522
523 if (p_edpp->enabled == 0) {
524 DE_WRN("edp%d is already closed\n", p_edp->disp);
525 return DIS_FAIL;
526 }
527
528 if (p_edpp->edp_func.tv_disable == NULL) {
529 DE_WRN("tv_func.tv_disable is NULL\n");
530 return -1;
531 }
532
533 spin_lock_irqsave(&g_edp_data_lock, flags);
534 p_edpp->enabled = 0;
535 spin_unlock_irqrestore(&g_edp_data_lock, flags);
536
537 p_edpp->edp_func.tv_disable(p_edpp->edp_index);
538
539 if (mgr->disable)
540 mgr->disable(mgr);
541
542 p_edpp->edp_func.tv_irq_enable(p_edpp->edp_index, 0, 0);
543
544 disp_al_edp_disable(p_edp->hwdev_index);
545
546 disp_sys_disable_irq(p_edpp->irq_no);
547 disp_sys_unregister_irq(p_edpp->irq_no, disp_edp_event_proc,
548 (void *)p_edp);
549 disp_edp_pwm_disable(p_edp);
550
551 disp_delay_ms(1000);
552 return 0;
553 }
554
disp_edp_exit(struct disp_device * p_edp)555 static s32 disp_edp_exit(struct disp_device *p_edp)
556 {
557 struct disp_edp_private_data *p_edpp = disp_edp_get_priv(p_edp);
558
559 if (!p_edp || !p_edpp) {
560 DE_WRN("edp init null hdl!\n");
561 return DIS_FAIL;
562 }
563
564 disp_edp_disable(p_edp);
565 kfree(p_edp);
566 kfree(p_edpp);
567 return 0;
568 }
569
disp_edp_get_mode(struct disp_device * p_edp)570 s32 disp_edp_get_mode(struct disp_device *p_edp)
571 {
572 struct disp_edp_private_data *p_edpp = disp_edp_get_priv(p_edp);
573 enum disp_tv_mode tv_mode;
574
575 if ((p_edp == NULL) || (p_edpp == NULL)) {
576 DE_WRN("edp set mode null hdl!\n");
577 return DIS_FAIL;
578 }
579
580 if (p_edpp->edp_func.tv_get_mode == NULL) {
581 DE_WRN("tv_get_mode is null!\n");
582 return DIS_FAIL;
583 }
584
585 tv_mode = p_edpp->edp_func.tv_get_mode(p_edpp->edp_index);
586 if (tv_mode != p_edpp->mode)
587 p_edpp->mode = tv_mode;
588
589 return p_edpp->mode;
590 }
591
disp_edp_set_mode(struct disp_device * p_edp,enum disp_tv_mode tv_mode)592 s32 disp_edp_set_mode(struct disp_device *p_edp, enum disp_tv_mode tv_mode)
593 {
594 s32 ret = 0;
595 struct disp_edp_private_data *p_edpp = disp_edp_get_priv(p_edp);
596
597 if ((p_edp == NULL) || (p_edpp == NULL)) {
598 DE_WRN("edp set mode null hdl!\n");
599 return DIS_FAIL;
600 }
601
602 if (p_edpp->edp_func.tv_set_mode == NULL) {
603 DE_WRN("tv_set_mode is null!\n");
604 return DIS_FAIL;
605 }
606
607 ret = p_edpp->edp_func.tv_set_mode(p_edpp->edp_index, tv_mode);
608 if (ret == 0)
609 p_edpp->mode = tv_mode;
610
611 return ret;
612 }
613
614 /**
615 * @name :disp_edp_enable
616 * @brief :enable edp,tcon,register irq,set manager
617 * @param[IN] :p_edp disp_device
618 * @return :0 if success
619 */
disp_edp_enable(struct disp_device * p_edp)620 s32 disp_edp_enable(struct disp_device *p_edp)
621 {
622 unsigned long flags;
623 struct disp_edp_private_data *p_edpp = disp_edp_get_priv(p_edp);
624 struct disp_manager *mgr = NULL;
625 s32 ret = -1;
626 u32 bl, i;
627
628 if ((p_edp == NULL) || (p_edpp == NULL)) {
629 DE_WRN("edp set func null hdl!\n");
630 return DIS_FAIL;
631 }
632 DE_INF("%s, disp%d\n", __func__, p_edp->disp);
633
634 if (p_edpp->enabled) {
635 DE_WRN("edp%d is already enable\n", p_edp->disp);
636 return DIS_FAIL;
637 }
638
639 if (p_edpp->edp_func.tv_get_video_timing_info == NULL) {
640 DE_WRN("tv_get_video_timing_info func is null\n");
641 return DIS_FAIL;
642 }
643
644 p_edpp->edp_func.tv_get_video_timing_info(p_edpp->edp_index,
645 &(p_edpp->video_info));
646
647 if (p_edpp->video_info == NULL) {
648 DE_WRN("video info is null\n");
649 return DIS_FAIL;
650 }
651
652 memcpy(&p_edp->timings, p_edpp->video_info,
653 sizeof(struct disp_video_timings));
654
655 mgr = p_edp->manager;
656 if (!mgr) {
657 DE_WRN("edp%d's mgr is NULL\n", p_edp->disp);
658 return DIS_FAIL;
659 }
660
661 edp_calc_judge_line(p_edp);
662
663 if (mgr->enable)
664 mgr->enable(mgr);
665
666 ret = cal_real_frame_period(p_edp);
667 if (ret)
668 DE_WRN("cal_real_frame_period fail\n");
669
670 for (i = 0; i < EDP_POWER_NUM; i++) {
671 ret = disp_sys_power_enable(p_edpp->edp_regulator[i]);
672 if (ret)
673 return DIS_FAIL;
674 }
675
676 disp_al_edp_cfg(p_edp->hwdev_index, p_edpp->frame_per_sec,
677 p_edpp->edp_index);
678
679 if (p_edpp->edp_func.tv_enable != NULL) {
680 ret = p_edpp->edp_func.tv_enable(p_edpp->edp_index);
681 if (ret) {
682 DE_WRN("edp enable func fail\n");
683 goto EXIT;
684 }
685 } else {
686 DE_WRN("edp enable func is NULL\n");
687 goto EXIT;
688 }
689
690 disp_sys_register_irq(p_edpp->irq_no, 0, disp_edp_event_proc,
691 (void *)p_edp, 0, 0);
692 disp_sys_enable_irq(p_edpp->irq_no);
693
694 p_edpp->edp_func.tv_irq_enable(p_edpp->edp_index, 0, 1);
695
696 disp_edp_pwm_enable(p_edp);
697
698 disp_edp_backlight_enable(p_edp);
699
700 spin_lock_irqsave(&g_edp_data_lock, flags);
701 p_edpp->enabled = 1;
702 spin_unlock_irqrestore(&g_edp_data_lock, flags);
703
704 bl = disp_edp_get_bright(p_edp);
705 disp_edp_set_bright(p_edp, bl);
706 EXIT:
707
708 return ret;
709 }
710
disp_edp_set_bright(struct disp_device * edp,u32 bright)711 s32 disp_edp_set_bright(struct disp_device *edp, u32 bright)
712 {
713 u32 duty_ns;
714 __u64 backlight_bright = bright;
715 __u64 backlight_dimming;
716 __u64 period_ns;
717 struct disp_edp_private_data *edpp = disp_edp_get_priv(edp);
718 unsigned long flags;
719 bool bright_update = false;
720 struct disp_manager *mgr = NULL;
721 struct disp_smbl *smbl = NULL;
722
723 if (!edp || !edpp) {
724 DE_WRN("NULL hdl!\n");
725 return DIS_FAIL;
726 }
727 mgr = edp->manager;
728 if (!mgr) {
729 DE_WRN("NULL hdl!\n");
730 return DIS_FAIL;
731 }
732 smbl = mgr->smbl;
733
734 spin_lock_irqsave(&g_edp_data_lock, flags);
735 backlight_bright = (backlight_bright > 255) ? 255 : backlight_bright;
736 if (edpp->backlight_bright != backlight_bright) {
737 bright_update = true;
738 edpp->backlight_bright = backlight_bright;
739 }
740 spin_unlock_irqrestore(&g_edp_data_lock, flags);
741 if (bright_update && smbl)
742 smbl->update_backlight(smbl, backlight_bright);
743
744 if (edpp->pwm_info.dev) {
745 backlight_bright = edpp->backlight_bright;
746 if (backlight_bright != 0)
747 backlight_bright += 1;
748
749 edpp->backlight_dimming = (edpp->backlight_dimming == 0)
750 ? 256
751 : edpp->backlight_dimming;
752 backlight_dimming = edpp->backlight_dimming;
753 period_ns = edpp->pwm_info.period_ns;
754 duty_ns =
755 (backlight_bright * backlight_dimming * period_ns / 256 +
756 128) /
757 256;
758 edpp->pwm_info.duty_ns = duty_ns;
759 disp_sys_pwm_config(edpp->pwm_info.dev, duty_ns, period_ns);
760 }
761
762 return DIS_SUCCESS;
763 }
764
disp_edp_get_bright(struct disp_device * edp)765 s32 disp_edp_get_bright(struct disp_device *edp)
766 {
767 struct disp_edp_private_data *edpp = disp_edp_get_priv(edp);
768
769 if (!edp || !edpp) {
770 DE_WRN("NULL hdl!\n");
771 return DIS_FAIL;
772 }
773
774 return edpp->backlight_bright;
775 }
776
disp_edp_sw_enable(struct disp_device * p_edp)777 s32 disp_edp_sw_enable(struct disp_device *p_edp)
778 {
779 struct disp_manager *mgr = NULL;
780 unsigned long flags;
781 struct disp_edp_private_data *p_edpp = disp_edp_get_priv(p_edp);
782 struct pwm_device *pwm_dev = NULL;
783
784 if (!p_edp || !p_edpp) {
785 DE_WRN("p_edp init null hdl!\n");
786 return DIS_FAIL;
787 }
788
789 mgr = p_edp->manager;
790 if (!mgr) {
791 DE_WRN("edp%d's mgr is NULL\n", p_edp->disp);
792 return DIS_FAIL;
793 }
794
795 if (p_edpp->enabled == 1) {
796 DE_WRN("edp%d is already open\n", p_edp->disp);
797 return DIS_FAIL;
798 }
799
800
801 if (p_edpp->edp_func.tv_irq_enable == NULL) {
802 DE_WRN("edp_func.tv_irq_enable is null\n");
803 return DIS_FAIL;
804 }
805
806 p_edpp->edp_func.tv_get_video_timing_info(p_edpp->edp_index,
807 &(p_edpp->video_info));
808
809 if (p_edpp->video_info == NULL) {
810 DE_WRN("video info is null\n");
811 return DIS_FAIL;
812 }
813
814 memcpy(&p_edp->timings, p_edpp->video_info,
815 sizeof(struct disp_video_timings));
816
817 edp_calc_judge_line(p_edp);
818
819 if (cal_real_frame_period(p_edp) != 0)
820 DE_WRN("cal_real_frame_period fail\n");
821
822 if (mgr->sw_enable)
823 mgr->sw_enable(mgr);
824
825 if (p_edpp->edp_pwm_used && p_edpp->pwm_info.dev) {
826 pwm_dev = (struct pwm_device *)p_edpp->pwm_info.dev;
827 pwm_dev->state.enabled = true;
828 pwm_dev->state.period = p_edpp->pwm_info.period_ns;
829 pwm_dev->state.duty_cycle = p_edpp->pwm_info.duty_ns;
830 pwm_dev->state.polarity = p_edpp->pwm_info.polarity;
831 }
832
833 p_edpp->edp_func.tv_irq_enable(p_edpp->edp_index, 0, 0);
834 disp_sys_register_irq(p_edpp->irq_no, 0, disp_edp_event_proc,
835 (void *)p_edp, 0, 0);
836 disp_sys_enable_irq(p_edpp->irq_no);
837 p_edpp->edp_func.tv_irq_enable(p_edpp->edp_index, 0, 1);
838
839 spin_lock_irqsave(&g_edp_data_lock, flags);
840 p_edpp->enabled = 1;
841 spin_unlock_irqrestore(&g_edp_data_lock, flags);
842 return 0;
843 }
844
disp_edp_get_status(struct disp_device * dispdev)845 s32 disp_edp_get_status(struct disp_device *dispdev)
846 {
847 s32 ret = 0;
848 /*fifo flow status*/
849 return ret;
850 }
851
disp_edp_usec_before_vblank(struct disp_device * p_edp)852 u32 disp_edp_usec_before_vblank(struct disp_device *p_edp)
853 {
854 int cur_line;
855 int start_delay;
856 u32 usec = 0;
857 struct disp_video_timings *timings;
858 u32 usec_per_line;
859 struct disp_edp_private_data *p_edpp = disp_edp_get_priv(p_edp);
860
861 if (!p_edp || !p_edpp) {
862 DE_WRN("NULL hdl\n");
863 goto OUT;
864 }
865
866 start_delay = p_edpp->edp_func.tv_get_startdelay(p_edpp->edp_index);
867
868 cur_line = p_edpp->edp_func.tv_get_cur_line(p_edpp->edp_index);
869 if (cur_line > (start_delay - 4)) {
870 timings = &p_edp->timings;
871 usec_per_line = timings->hor_total_time *
872 1000000 / timings->pixel_clk;
873 usec = (timings->ver_total_time - cur_line + 1) * usec_per_line;
874 }
875
876 OUT:
877 return usec;
878 }
879
disp_edp_is_in_safe_period(struct disp_device * p_edp)880 bool disp_edp_is_in_safe_period(struct disp_device *p_edp)
881 {
882 struct disp_edp_private_data *p_edpp = disp_edp_get_priv(p_edp);
883 int start_delay, cur_line;
884 bool ret = true;
885
886 if (!p_edp || !p_edpp) {
887 DE_WRN("NULL hdl\n");
888 goto OUT;
889 }
890
891 start_delay = p_edpp->edp_func.tv_get_startdelay(p_edpp->edp_index);
892
893 cur_line = p_edpp->edp_func.tv_get_cur_line(p_edpp->edp_index);
894
895 if (cur_line >= start_delay)
896 ret = false;
897
898 OUT:
899 return ret;
900 }
901
disp_edp_set_static_config(struct disp_device * p_edp,struct disp_device_config * config)902 static s32 disp_edp_set_static_config(struct disp_device *p_edp,
903 struct disp_device_config *config)
904 {
905 return 0;
906 }
907
disp_edp_get_static_config(struct disp_device * p_edp,struct disp_device_config * config)908 static s32 disp_edp_get_static_config(struct disp_device *p_edp,
909 struct disp_device_config *config)
910 {
911 int ret = 0;
912 struct disp_edp_private_data *p_edpp = disp_edp_get_priv(p_edp);
913
914 if ((p_edp == NULL) || (p_edpp == NULL)) {
915 DE_WRN("p_edp set func null hdl!\n");
916 goto OUT;
917 }
918
919 config->type = p_edp->type;
920 config->format = DISP_CSC_TYPE_RGB;
921 OUT:
922 return ret;
923 }
924
disp_edp_set_bright_dimming(struct disp_device * edp,u32 dimming)925 static s32 disp_edp_set_bright_dimming(struct disp_device *edp, u32 dimming)
926 {
927 struct disp_edp_private_data *edpp = disp_edp_get_priv(edp);
928 u32 bl = 0;
929
930 if (!edp || !edpp) {
931 DE_WRN("NULL hdl!\n");
932 return DIS_FAIL;
933 }
934
935 dimming = dimming > 256?256:dimming;
936 edpp->backlight_dimming = dimming;
937 bl = disp_edp_get_bright(edp);
938 disp_edp_set_bright(edp, bl);
939
940 return DIS_SUCCESS;
941 }
942
disp_edp_backlight_enable(struct disp_device * edp)943 static s32 disp_edp_backlight_enable(struct disp_device *edp)
944 {
945 struct disp_gpio_info gpio_info;
946 struct disp_edp_private_data *edpp = disp_edp_get_priv(edp);
947 unsigned long flags;
948 unsigned int bl;
949
950 if (!edp || !edpp) {
951 DE_WRN("NULL hdl!\n");
952 return DIS_FAIL;
953 }
954
955 spin_lock_irqsave(&g_edp_data_lock, flags);
956 if (edpp->bl_enabled) {
957 spin_unlock_irqrestore(&g_edp_data_lock, flags);
958 return -EBUSY;
959 }
960
961 edpp->bl_need_enabled = 1;
962 edpp->bl_enabled = true;
963 spin_unlock_irqrestore(&g_edp_data_lock, flags);
964
965 if (edpp->edp_bl_en_used) {
966 if (edpp->edp_bl_regulator)
967 regulator_enable(edpp->edp_bl_regulator);
968
969 memcpy(&gpio_info, &(edpp->edp_bl_en),
970 sizeof(struct disp_gpio_info));
971
972 disp_sys_gpio_request(&gpio_info);
973 }
974 bl = disp_edp_get_bright(edp);
975 disp_edp_set_bright(edp, bl);
976
977 return 0;
978 }
979
disp_edp_backlight_disable(struct disp_device * edp)980 static s32 disp_edp_backlight_disable(struct disp_device *edp)
981 {
982 struct disp_edp_private_data *edpp = disp_edp_get_priv(edp);
983 unsigned long flags;
984 struct disp_gpio_info gpio_info;
985
986 if (!edp || !edpp) {
987 DE_WRN("NULL hdl!\n");
988 return DIS_FAIL;
989 }
990
991 spin_lock_irqsave(&g_edp_data_lock, flags);
992 if (!edpp->bl_enabled) {
993 spin_unlock_irqrestore(&g_edp_data_lock, flags);
994 return -EBUSY;
995 }
996
997 edpp->bl_enabled = false;
998 spin_unlock_irqrestore(&g_edp_data_lock, flags);
999
1000 if (!edpp->edp_bl_en_used)
1001 return 0;
1002
1003 memcpy(&gpio_info, &edpp->edp_bl_en, sizeof(struct disp_gpio_info));
1004
1005 disp_sys_gpio_release(&gpio_info);
1006 disp_sys_power_disable(edpp->edp_bl_regulator);
1007
1008 return 0;
1009 }
1010
disp_edp_pwm_enable(struct disp_device * edp)1011 static s32 disp_edp_pwm_enable(struct disp_device *edp)
1012 {
1013 struct disp_edp_private_data *edpp = disp_edp_get_priv(edp);
1014
1015 if (!edp || !edpp) {
1016 DE_WRN("NULL hdl!\n");
1017 return DIS_FAIL;
1018 }
1019
1020 if (edpp->pwm_info.dev)
1021 return disp_sys_pwm_enable(edpp->pwm_info.dev);
1022
1023 DE_WRN("pwm device hdl is NULL\n");
1024
1025 return DIS_FAIL;
1026 }
1027
disp_edp_pwm_disable(struct disp_device * edp)1028 static s32 disp_edp_pwm_disable(struct disp_device *edp)
1029 {
1030 struct disp_edp_private_data *edpp = disp_edp_get_priv(edp);
1031 s32 ret = -1;
1032 struct pwm_device *pwm_dev;
1033
1034 if (!edp || !edpp) {
1035 DE_WRN("NULL hdl!\n");
1036 return DIS_FAIL;
1037 }
1038
1039 if (edpp->pwm_info.dev) {
1040 ret = disp_sys_pwm_disable(edpp->pwm_info.dev);
1041 pwm_dev = (struct pwm_device *)edpp->pwm_info.dev;
1042 /*following is for reset pwm state purpose*/
1043 disp_sys_pwm_config(edpp->pwm_info.dev,
1044 pwm_dev->state.duty_cycle - 1,
1045 pwm_dev->state.period);
1046 disp_sys_pwm_set_polarity(edpp->pwm_info.dev,
1047 !edpp->pwm_info.polarity);
1048 return ret;
1049 }
1050
1051 DE_WRN("pwm device hdl is NULL\n");
1052
1053 return DIS_FAIL;
1054 }
1055
disp_edp_show_builtin_patten(struct disp_device * edp,u32 patten)1056 void disp_edp_show_builtin_patten(struct disp_device *edp, u32 patten)
1057 {
1058 struct disp_edp_private_data *p_edpp = disp_edp_get_priv(edp);
1059
1060 if (p_edpp->edp_func.tv_show_builtin_patten)
1061 p_edpp->edp_func.tv_show_builtin_patten(p_edpp->edp_index,
1062 patten);
1063 }
1064
1065 /**
1066 * @name :disp_init_edp
1067 * @brief :register edp device
1068 * @param[IN] :para init parameter
1069 * @param[OUT] :none
1070 * @return :0 if success otherwise fail
1071 */
disp_init_edp(struct disp_bsp_init_para * para)1072 s32 disp_init_edp(struct disp_bsp_init_para *para)
1073 {
1074 u32 num_devices_support_edp = 0;
1075 s32 ret = 0;
1076 u32 disp = 0, edp_index = 0;
1077 struct disp_device *p_edp;
1078 struct disp_edp_private_data *p_edpp;
1079 u32 num_devices;
1080 u32 hwdev_index = 0;
1081
1082 DE_INF("disp_init_edp\n");
1083 spin_lock_init(&g_edp_data_lock);
1084
1085 g_edp_used = 1;
1086
1087 DE_INF("%s\n", __func__);
1088
1089 num_devices = bsp_disp_feat_get_num_devices();
1090
1091 for (hwdev_index = 0; hwdev_index < num_devices; hwdev_index++) {
1092 if (bsp_disp_feat_is_supported_output_types(
1093 hwdev_index, DISP_OUTPUT_TYPE_EDP))
1094 ++num_devices_support_edp;
1095 }
1096
1097 g_pedp_devices =
1098 kmalloc(sizeof(struct disp_device) * num_devices_support_edp,
1099 GFP_KERNEL | __GFP_ZERO);
1100
1101 if (g_pedp_devices == NULL) {
1102 DE_WRN("malloc memory for g_pedp_devices fail!\n");
1103 goto malloc_err;
1104 }
1105
1106 g_pedp_private = kmalloc_array(num_devices_support_edp, sizeof(*p_edpp),
1107 GFP_KERNEL | __GFP_ZERO);
1108 if (g_pedp_private == NULL) {
1109 DE_WRN("malloc memory for g_pedp_private fail!\n");
1110 goto malloc_err;
1111 }
1112
1113 disp = 0;
1114 for (hwdev_index = 0; hwdev_index < num_devices; hwdev_index++) {
1115 if (!bsp_disp_feat_is_supported_output_types(
1116 hwdev_index, DISP_OUTPUT_TYPE_EDP)) {
1117 continue;
1118 }
1119
1120 if (para->boot_info.type == DISP_OUTPUT_TYPE_EDP &&
1121 edp_index == 0)
1122 disp = para->boot_info.disp;
1123 p_edp = &g_pedp_devices[edp_index];
1124 p_edpp = &g_pedp_private[edp_index];
1125 p_edp->priv_data = (void *)p_edpp;
1126
1127 p_edp->disp = disp;
1128 p_edp->hwdev_index = hwdev_index;
1129 sprintf(p_edp->name, "edp%d", edp_index);
1130 p_edp->type = DISP_OUTPUT_TYPE_EDP;
1131 p_edpp->irq_no = para->irq_no[DISP_MOD_LCD0 + hwdev_index];
1132 p_edpp->clk = para->mclk[DISP_MOD_LCD0 + hwdev_index];
1133 p_edpp->edp_index = edp_index;
1134 /*function register*/
1135 p_edp->set_manager = disp_device_set_manager;
1136 p_edp->unset_manager = disp_device_unset_manager;
1137 p_edp->get_resolution = disp_device_get_resolution;
1138 p_edp->get_timings = disp_device_get_timings;
1139 p_edp->is_interlace = disp_device_is_interlace;
1140 p_edp->init = disp_edp_init;
1141 p_edp->exit = disp_edp_exit;
1142 p_edp->set_tv_func = disp_edp_set_func;
1143 p_edp->enable = disp_edp_enable;
1144 p_edp->disable = disp_edp_disable;
1145 p_edp->is_enabled = disp_edp_is_enabled;
1146 p_edp->sw_enable = disp_edp_sw_enable;
1147 p_edp->get_input_csc = disp_edp_get_input_csc;
1148 p_edp->suspend = disp_edp_suspend;
1149 p_edp->resume = disp_edp_resume;
1150 p_edp->get_fps = disp_edp_get_fps;
1151 p_edp->get_status = disp_edp_get_status;
1152 p_edp->is_in_safe_period = disp_edp_is_in_safe_period;
1153 p_edp->usec_before_vblank = disp_edp_usec_before_vblank;
1154 p_edp->set_static_config = disp_edp_set_static_config;
1155 p_edp->get_static_config = disp_edp_get_static_config;
1156 p_edp->backlight_enable = disp_edp_backlight_enable;
1157 p_edp->backlight_disable = disp_edp_backlight_disable;
1158 p_edp->set_bright = disp_edp_set_bright;
1159 p_edp->get_bright = disp_edp_get_bright;
1160 p_edp->set_bright_dimming = disp_edp_set_bright_dimming;
1161 p_edp->pwm_enable = disp_edp_pwm_enable;
1162 p_edp->pwm_disable = disp_edp_pwm_disable;
1163 p_edp->power_enable = disp_edp_power_enable;
1164 p_edp->power_disable = disp_edp_power_disable;
1165 p_edp->show_builtin_patten = disp_edp_show_builtin_patten;
1166 ret = p_edp->init(p_edp);
1167 if (ret != 0) {
1168 DE_INF("edp %d %d is not used\n", disp, hwdev_index);
1169 ++disp;
1170 if (edp_index <= num_devices_support_edp - 1)
1171 ++edp_index;
1172 continue;
1173 }
1174
1175 disp_device_register(p_edp);
1176 DE_INF("register edp %d %d\n", disp, hwdev_index);
1177 ++disp;
1178 if (edp_index <= num_devices_support_edp - 1)
1179 ++edp_index;
1180 }
1181 if (ret == 0)
1182 goto exit;
1183
1184 malloc_err:
1185 if (g_pedp_devices != NULL)
1186 kfree(g_pedp_devices);
1187 if (g_pedp_private != NULL)
1188 kfree(g_pedp_private);
1189 g_pedp_devices = NULL;
1190 g_pedp_private = NULL;
1191 exit:
1192 return ret;
1193 }
1194
1195 /**
1196 * @name :disp_exit_edp
1197 * @brief :exit edp module
1198 * @param[IN] :
1199 * @param[OUT] :
1200 * @return :
1201 */
disp_exit_edp(void)1202 s32 disp_exit_edp(void)
1203 {
1204 s32 ret = 0;
1205
1206 DE_WRN("\n");
1207 /*TODO*/
1208 return ret;
1209 }
1210
disp_edp_get_cur_line(struct disp_device * p_edp)1211 int disp_edp_get_cur_line(struct disp_device *p_edp)
1212 {
1213 struct disp_edp_private_data *p_edpp = disp_edp_get_priv(p_edp);
1214
1215 if ((p_edp == NULL) || (p_edpp == NULL))
1216 return DIS_FAIL;
1217
1218 return p_edpp->edp_func.tv_get_cur_line(p_edpp->edp_index);
1219 }
1220
1221 #endif /*endif SUPPORT_EDP */
1222