1 /*
2 * Allwinner SoCs display driver.
3 *
4 * Copyright (c) 2007-2017 Allwinnertech Co., Ltd.
5 *
6 * This software is licensed under the terms of the GNU General Public
7 * License version 2, as published by the Free Software Foundation, and
8 * may be copied, distributed, and modified under those terms.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 */
16
17 #include "disp_display.h"
18 #include "disp_rtwb.h"
19 #include "../disp_trace.h"
20
21 struct disp_dev_t gdisp;
22
bsp_disp_init(struct disp_bsp_init_para * para)23 s32 bsp_disp_init(struct disp_bsp_init_para *para)
24 {
25 u32 num_screens, disp;
26
27 memset(&gdisp, 0x00, sizeof(struct disp_dev_t));
28 memcpy(&gdisp.init_para, para, sizeof(struct disp_bsp_init_para));
29 para->shadow_protect = bsp_disp_shadow_protect;
30 disp_init_feat(¶->feat_init);
31
32 num_screens = bsp_disp_feat_get_num_screens();
33 for (disp = 0; disp < num_screens; disp++) {
34 spin_lock_init(&gdisp.screen[disp].flag_lock);
35 tasklet_init(&gdisp.screen[disp].tasklet, disp_tasklet,
36 (unsigned long)disp);
37 }
38
39 disp_init_al(para);
40 #if defined (DE_VERSION_V33X)
41 disp_al_init_tcon(para);
42 #endif
43 disp_init_lcd(para);
44 #if defined(SUPPORT_HDMI)
45 disp_init_hdmi(para);
46 #endif
47 #if defined(SUPPORT_TV)
48 disp_init_tv_para(para);
49 #endif
50 #if defined(SUPPORT_RTWB)
51 disp_init_rtwb(para);
52 #endif
53
54 #if defined(SUPPORT_EDP)
55 disp_init_edp(para);
56 #endif /*endif SUPPORT_EDP */
57
58 #if defined (DE_VERSION_V33X)
59 disp_init_irq_util(para->irq_no[DISP_MOD_DE]);
60 #endif
61
62 #if defined(SUPPORT_VDPO)
63 disp_init_vdpo(para);
64 #endif
65 disp_init_mgr(para);
66 #if defined(CONFIG_DISP2_SUNXI_SUPPORT_ENAHNCE)
67 disp_init_enhance(para);
68 #endif
69 #if defined(CONFIG_DISP2_SUNXI_SUPPORT_SMBL)
70 disp_init_smbl(para);
71 #endif
72 disp_init_capture(para);
73
74 #if defined(CONFIG_SUNXI_DISP2_FB_ROTATION_SUPPORT)
75 disp_init_rotation_sw(para);
76 #endif
77
78 #if defined(SUPPORT_WB)
79 disp_init_format_convert_manager(para);
80 #endif
81 #if defined SUPPORT_EINK
82 disp_init_eink(para);
83 #endif
84
85 disp_init_connections(para);
86
87 return DIS_SUCCESS;
88 }
89
bsp_disp_exit(u32 mode)90 s32 bsp_disp_exit(u32 mode)
91 {
92 #if defined SUPPORT_EINK
93 disp_exit_eink();
94 #endif
95 #if defined(SUPPORT_WB)
96 disp_exit_format_convert_manager();
97 #endif
98 disp_exit_capture();
99 #if defined(CONFIG_DISP2_SUNXI_SUPPORT_SMBL)
100 disp_exit_smbl();
101 #endif
102 #if defined(CONFIG_DISP2_SUNXI_SUPPORT_ENAHNCE)
103 disp_exit_enhance();
104 #endif
105 disp_exit_mgr();
106 #if defined(SUPPORT_HDMI)
107 disp_exit_hdmi();
108 #endif
109
110 #if defined(SUPPORT_VDPO)
111 disp_exit_vdpo();
112 #endif
113 disp_exit_lcd();
114 disp_exit_al();
115
116 disp_exit_feat();
117
118 return DIS_SUCCESS;
119 }
120
bsp_disp_open(void)121 s32 bsp_disp_open(void)
122 {
123 return DIS_SUCCESS;
124 }
125
bsp_disp_close(void)126 s32 bsp_disp_close(void)
127 {
128 return DIS_SUCCESS;
129 }
130
disp_device_attached(int disp_mgr,int disp_dev,struct disp_device_config * config)131 s32 disp_device_attached(int disp_mgr, int disp_dev,
132 struct disp_device_config *config)
133 {
134 struct disp_manager *mgr = NULL;
135 struct disp_device *dispdev = NULL;
136
137 mgr = disp_get_layer_manager(disp_mgr);
138 if (!mgr)
139 return -1;
140
141 /* no need to attch */
142 if (mgr->device && (config->type == mgr->device->type))
143 return 0;
144
145 /* detach manager and device first */
146 if (mgr->device) {
147 dispdev = mgr->device;
148 if (dispdev->is_enabled && dispdev->is_enabled(dispdev)
149 && dispdev->disable)
150 dispdev->disable(dispdev);
151 if (dispdev->unset_manager)
152 dispdev->unset_manager(dispdev);
153 }
154
155 dispdev = disp_device_get(disp_dev, config->type);
156 if (dispdev && dispdev->set_manager) {
157 dispdev->set_manager(dispdev, mgr);
158 DE_WRN("attached ok, mgr%d<-->device%d, type=%d\n",
159 disp_mgr, disp_dev, (u32)config->type);
160 if (dispdev->set_static_config)
161 dispdev->set_static_config(dispdev, config);
162 return 0;
163 }
164
165 return -1;
166 }
167
disp_device_attached_and_enable(int disp_mgr,int disp_dev,struct disp_device_config * config)168 s32 disp_device_attached_and_enable(int disp_mgr, int disp_dev,
169 struct disp_device_config *config)
170 {
171 struct disp_manager *mgr = NULL;
172 struct disp_device *dispdev = NULL;
173 int ret = 0;
174
175 mgr = disp_get_layer_manager(disp_mgr);
176 if (!mgr)
177 return -1;
178
179 if (mgr->device && mgr->device->type != config->type) {
180 if (mgr->device->is_enabled(mgr->device))
181 mgr->device->disable(mgr->device);
182
183 if (mgr->device->unset_manager)
184 mgr->device->unset_manager(mgr->device);
185 }
186
187 if ((!mgr->device) && (config->type != DISP_OUTPUT_TYPE_NONE)) {
188 dispdev = disp_device_get(disp_dev, config->type);
189 if (dispdev && dispdev->set_manager) {
190 dispdev->set_manager(dispdev, mgr);
191 } else {
192 ret = -1;
193 goto exit;
194 }
195 }
196
197 if (mgr->device) {
198 disp_config_update_t update = DISP_NORMAL_UPDATE;
199
200 if (mgr->device->check_config_dirty)
201 update = mgr->device->check_config_dirty(mgr->device,
202 config);
203
204 if (update == DISP_NORMAL_UPDATE) {
205 static char const *fmt_name[] = {
206 "rgb",
207 "yuv444",
208 "yuv422",
209 "yuv420"
210 };
211 static char const *bits_name[] = {
212 "8bits",
213 "10bits",
214 "12bits",
215 "16bits"
216 };
217 if (mgr->device->is_enabled(mgr->device))
218 mgr->device->disable(mgr->device);
219
220 if (mgr->device->set_static_config)
221 ret = mgr->device->set_static_config(mgr->device,
222 config);
223 if (ret != 0)
224 goto exit;
225
226 if (config->type == DISP_OUTPUT_TYPE_TV)
227 disp_delay_ms(300);
228
229 if (config->type == DISP_OUTPUT_TYPE_HDMI)
230 disp_delay_ms(1000);
231
232 ret = mgr->device->enable(mgr->device);
233 DE_WRN("attached %s, mgr%d<-->dev%d\n",
234 (ret == 0) ? "ok" : "fail",
235 disp_mgr, disp_dev);
236 DE_WRN("type:%d,mode:%d,fmt:%s,bits:%s,eotf:%d,cs:%d dvi_hdmi:%d, range:%d scan:%d ratio:%d\n",
237 config->type,
238 config->mode,
239 (config->format < 4) ?
240 fmt_name[config->format] : "undef",
241 (config->bits < 4) ?
242 bits_name[config->bits] : "undef",
243 config->eotf,
244 config->cs,
245 config->dvi_hdmi,
246 config->range,
247 config->scan,
248 config->aspect_ratio);
249 if (ret != 0)
250 goto exit;
251
252 } else if (update == DISP_SMOOTH_UPDATE) {
253 if (mgr->device->set_static_config)
254 ret = mgr->device->set_static_config(mgr->device,
255 config);
256 mgr->device->smooth_enable(mgr->device);
257 if (ret != 0)
258 goto exit;
259 }
260 }
261
262 return 0;
263
264 exit:
265 return ret;
266 }
267
disp_device_detach(int disp_mgr,int disp_dev,enum disp_output_type output_type)268 s32 disp_device_detach(int disp_mgr, int disp_dev,
269 enum disp_output_type output_type)
270 {
271 struct disp_manager *mgr = NULL;
272 struct disp_device *dispdev = NULL;
273
274 mgr = disp_get_layer_manager(disp_mgr);
275 if (!mgr) {
276 DE_WRN("get mgr%d fail\n", disp_mgr);
277 return -1;
278 }
279
280 dispdev = disp_device_get(disp_dev, output_type);
281 if (!dispdev) {
282 DE_WRN("get device%d fail\n", disp_dev);
283 return -1;
284 }
285
286 if (mgr->device == dispdev) {
287 if (dispdev->disable)
288 dispdev->disable(dispdev);
289 if (dispdev->unset_manager)
290 dispdev->unset_manager(dispdev);
291 }
292
293 return 0;
294 }
295
bsp_disp_device_switch(int disp,enum disp_output_type output_type,enum disp_output_type mode)296 s32 bsp_disp_device_switch(int disp, enum disp_output_type output_type,
297 enum disp_output_type mode)
298 {
299 int num_screens = 0;
300 int disp_dev;
301 int ret = -1;
302 struct disp_device_config config;
303 memset(&config, 0, sizeof(struct disp_device_config));
304
305 config.type = output_type;
306 config.mode = (enum disp_tv_mode)mode;
307 config.format = (output_type == DISP_OUTPUT_TYPE_LCD) ?
308 DISP_CSC_TYPE_RGB : DISP_CSC_TYPE_YUV444;
309 config.bits = DISP_DATA_8BITS;
310 config.eotf = DISP_EOTF_GAMMA22;
311
312 if (config.type == DISP_OUTPUT_TYPE_HDMI) {
313 if (config.mode >= DISP_TV_MOD_720P_50HZ)
314 config.cs = DISP_BT709;
315 else
316 config.cs = DISP_BT601;
317
318 config.eotf = DISP_EOTF_GAMMA22;
319 }
320
321 config.dvi_hdmi = DISP_HDMI;
322 config.range = DISP_COLOR_RANGE_16_235;
323 config.scan = DISP_SCANINFO_NO_DATA;
324 config.aspect_ratio = 8;
325
326 ret = disp_device_attached_and_enable(disp, disp, &config);
327 if (ret != 0) {
328 num_screens = bsp_disp_feat_get_num_screens();
329 for (disp_dev = 0; disp_dev < num_screens; disp_dev++) {
330 ret = disp_device_attached_and_enable(disp,
331 disp_dev,
332 &config);
333 if (ret == 0)
334 break;
335 }
336 }
337
338 return ret;
339 }
340
bsp_disp_device_set_config(int disp,struct disp_device_config * config)341 s32 bsp_disp_device_set_config(int disp, struct disp_device_config *config)
342 {
343 int num_screens = 0;
344 int disp_dev;
345 int ret = -1;
346
347 if ((config->dvi_hdmi != DISP_DVI) && (config->dvi_hdmi != DISP_HDMI))
348 config->dvi_hdmi = DISP_HDMI;
349 if (config->range > 2)
350 config->range = 0;
351 if (config->scan > 2)
352 config->scan = 0;
353 if (!config->aspect_ratio)
354 config->aspect_ratio = 8;
355 if ((config->type == DISP_OUTPUT_TYPE_HDMI)
356 && (!config->cs)) {
357 if (config->mode >= DISP_TV_MOD_720P_50HZ)
358 config->cs = DISP_BT709;
359 else
360 config->cs = DISP_BT601;
361
362 if (!config->eotf)
363 config->eotf = DISP_EOTF_GAMMA22;
364 }
365
366 ret = disp_device_attached_and_enable(disp, disp, config);
367 if (ret != 0) {
368 num_screens = bsp_disp_feat_get_num_screens();
369 for (disp_dev = 0; disp_dev < num_screens; disp_dev++) {
370 ret = disp_device_attached_and_enable(disp,
371 disp_dev,
372 config);
373 if (ret == 0)
374 break;
375 }
376 }
377
378 return ret;
379 }
380
381 #ifdef CONFIG_EINK_PANEL_UESD
bsp_disp_eink_update(struct disp_eink_manager * manager,struct disp_layer_config_inner * config,unsigned int layer_num,enum eink_update_mode mode,struct area_info * update_area)382 s32 bsp_disp_eink_update(struct disp_eink_manager *manager,
383 struct disp_layer_config_inner *config,
384 unsigned int layer_num,
385 enum eink_update_mode mode,
386 struct area_info *update_area)
387 {
388 int ret = -1;
389 struct area_info area;
390
391 memcpy(&area, update_area, sizeof(struct area_info));
392
393 if (manager)
394 ret = manager->eink_update(manager, config, layer_num,
395 mode, area);
396 else
397 __debug("eink manager is NULL!\n");
398
399 return ret;
400 }
401
bsp_disp_eink_set_temperature(struct disp_eink_manager * manager,unsigned int temp)402 s32 bsp_disp_eink_set_temperature(struct disp_eink_manager *manager,
403 unsigned int temp)
404 {
405 s32 ret = -1;
406
407 if (manager)
408 ret = manager->set_temperature(manager, temp);
409 else
410 pr_err("eink manager is NULL!\n");
411
412 return ret;
413 }
414
bsp_disp_eink_get_temperature(struct disp_eink_manager * manager)415 s32 bsp_disp_eink_get_temperature(struct disp_eink_manager *manager)
416 {
417 s32 ret = -1;
418
419 if (manager)
420 ret = manager->get_temperature(manager);
421 else
422 pr_err("eink manager is NULL!\n");
423
424 return ret;
425 }
426
bsp_disp_eink_op_skip(struct disp_eink_manager * manager,unsigned int skip)427 s32 bsp_disp_eink_op_skip(struct disp_eink_manager *manager, unsigned int skip)
428 {
429 s32 ret = -1;
430
431 if (manager)
432 ret = manager->op_skip(manager, skip);
433 else
434 pr_err("eink manager is NULL!\n");
435
436 return ret;
437 }
438 #endif
439
disp_init_connections(struct disp_bsp_init_para * para)440 s32 disp_init_connections(struct disp_bsp_init_para *para)
441 {
442 u32 disp = 0;
443 u32 num_screens = 0;
444 u32 num_layers = 0, layer_id = 0;
445 u32 i = 0;
446
447 DE_INF("disp_init_connections\n");
448
449 num_screens = bsp_disp_feat_get_num_screens();
450 for (disp = 0; disp < num_screens; disp++) {
451 struct disp_manager *mgr;
452 struct disp_layer *lyr;
453 struct disp_device *dispdev = NULL;
454 #if defined(CONFIG_DISP2_SUNXI_SUPPORT_ENAHNCE)
455 struct disp_enhance *enhance = NULL;
456 #endif
457 #if defined(CONFIG_DISP2_SUNXI_SUPPORT_SMBL)
458 struct disp_smbl *smbl = NULL;
459 #endif
460 struct disp_capture *cptr = NULL;
461 #if defined(CONFIG_SUNXI_DISP2_FB_ROTATION_SUPPORT)
462 struct disp_rotation_sw *rot_sw = NULL;
463 #endif
464
465 mgr = disp_get_layer_manager(disp);
466 if (!mgr)
467 continue;
468
469 /* connect layer & it's manager */
470 num_layers = bsp_disp_feat_get_num_layers(disp);
471 for (layer_id = 0; layer_id < num_layers; layer_id++) {
472 lyr = disp_get_layer_1(disp, layer_id);
473 if (lyr != NULL)
474 lyr->set_manager(lyr, mgr);
475 }
476
477 if ((para->boot_info.sync == 1)
478 && (disp == para->boot_info.disp)
479 && (para->boot_info.type == DISP_OUTPUT_TYPE_LCD)) {
480 /* connect device & it's manager */
481 dispdev = disp_device_get(disp, DISP_OUTPUT_TYPE_LCD);
482 if ((dispdev) && (dispdev->set_manager)) {
483 dispdev->set_manager(dispdev, mgr);
484 } else {
485 for (i = 0; i < num_screens; i++) {
486 dispdev =
487 disp_device_get(i,
488 DISP_OUTPUT_TYPE_LCD);
489 if ((dispdev)
490 && (dispdev->set_manager)) {
491 dispdev->set_manager(dispdev,
492 mgr);
493 break;
494 }
495 }
496 }
497 } else if (para->boot_info.sync == 0) {
498 dispdev = disp_device_get(disp, DISP_OUTPUT_TYPE_LCD);
499 if ((dispdev) && (dispdev->set_manager))
500 dispdev->set_manager(dispdev, mgr);
501 mgr->enable_iommu(mgr, true);
502 }
503
504 #if defined(CONFIG_DISP2_SUNXI_SUPPORT_ENAHNCE)
505 enhance = disp_get_enhance(disp);
506 if (enhance && (enhance->set_manager))
507 enhance->set_manager(enhance, mgr);
508 #endif
509
510 #if defined(CONFIG_DISP2_SUNXI_SUPPORT_SMBL)
511 smbl = disp_get_smbl(disp);
512 if (smbl && (smbl->set_manager))
513 smbl->set_manager(smbl, mgr);
514 #endif
515
516 cptr = disp_get_capture(disp);
517 if (cptr && (cptr->set_manager))
518 cptr->set_manager(cptr, mgr);
519
520 #if defined(CONFIG_SUNXI_DISP2_FB_ROTATION_SUPPORT)
521 rot_sw = disp_get_rotation_sw(disp);
522 if (rot_sw && (rot_sw->set_manager))
523 rot_sw->set_manager(rot_sw, mgr);
524 #endif
525 }
526
527 return 0;
528 }
529
530 /*s32 bsp_disp_check_device_enabled(struct disp_bsp_init_para *para)
531 {
532 int ret = 0;
533 int enabled = 0;
534
535 if ((para->boot_info.sync == 1)
536 && (para->boot_info.type != DISP_OUTPUT_TYPE_NONE)) {
537 int num_screens = 0;
538 int disp = para->boot_info.disp;
539 int disp_dev = disp;
540 enum disp_output_type type =
541 (enum disp_output_type)para->boot_info.type;
542 enum disp_tv_mode mode =
543 (enum disp_tv_mode)para->boot_info.mode;
544 enum disp_csc_type format =
545 (enum disp_csc_type)para->boot_info.format;
546 enum disp_data_bits bits =
547 (enum disp_data_bits)para->boot_info.bits;
548 enum disp_color_space cs =
549 (enum disp_color_space)para->boot_info.cs;
550 enum disp_eotf eotf = (enum disp_eotf)para->boot_info.eotf;
551 struct disp_manager *mgr = NULL;
552
553 mgr = disp_get_layer_manager(disp);
554 if (!mgr) {
555 enabled = 0;
556 goto exit;
557 }
558 */
559
560 /* attach manager and display device */
561 /* ret = disp_device_attached(disp, disp_dev, type, mode);
562 if (ret != 0) {
563 num_screens = bsp_disp_feat_get_num_screens();
564 for (disp_dev = 0; disp_dev < num_screens; disp_dev++) {
565 ret =
566 disp_device_attached(disp, disp_dev, type,
567 mode);
568 if (ret == 0)
569 break;
570 }
571 }
572 */
573
574 /* enable display device(only software) */
575 /*if (ret != 0) {*/
576 /* attach fail */
577 /* DE_WRN("Can't find device(%d) for manager %d\n",
578 (int)type, disp);
579 goto exit;
580 }
581
582 if (mgr->device->check_if_enabled &&
583 mgr->device->check_if_enabled(mgr->device)) {
584 enabled = 1;
585 }
586 }
587
588 exit:
589 return enabled;
590 }
591 */
592
bsp_disp_sync_with_hw(struct disp_bsp_init_para * para)593 s32 bsp_disp_sync_with_hw(struct disp_bsp_init_para *para)
594 {
595 if ((para->boot_info.sync == 1)
596 && (para->boot_info.type != DISP_OUTPUT_TYPE_NONE)) {
597 int num_screens = 0;
598 int disp = para->boot_info.disp;
599 int disp_dev = disp;
600 enum disp_output_type type =
601 (enum disp_output_type)para->boot_info.type;
602 enum disp_tv_mode mode =
603 (enum disp_tv_mode)para->boot_info.mode;
604 enum disp_csc_type format =
605 (enum disp_csc_type)para->boot_info.format;
606 enum disp_data_bits bits =
607 (enum disp_data_bits)para->boot_info.bits;
608 enum disp_color_space cs =
609 (enum disp_color_space)para->boot_info.cs;
610 enum disp_eotf eotf = (enum disp_eotf)para->boot_info.eotf;
611
612 int ret = -1;
613 struct disp_manager *mgr = NULL;
614
615 struct disp_device_config config;
616 memset(&config, 0, sizeof(struct disp_device_config));
617
618 config.type = type;
619 config.mode = mode;
620 config.format = format;
621 config.bits = bits;
622 config.eotf = eotf;
623 config.cs = cs;
624 config.dvi_hdmi = para->boot_info.dvi_hdmi;
625 config.range = para->boot_info.range;
626 config.scan = para->boot_info.scan;
627 config.aspect_ratio = para->boot_info.aspect_ratio;
628
629 if ((config.dvi_hdmi != DISP_DVI) && (config.dvi_hdmi != DISP_HDMI))
630 config.dvi_hdmi = DISP_HDMI;
631 if (config.range > 2)
632 config.range = 0;
633 if (config.scan > 2)
634 config.scan = 0;
635 if (!config.aspect_ratio)
636 config.aspect_ratio = 8;
637
638 mgr = disp_get_layer_manager(disp);
639 if (!mgr)
640 return -1;
641
642 /* attach manager and display device */
643 ret = disp_device_attached(disp, disp_dev, &config);
644 if (ret != 0) {
645 num_screens = bsp_disp_feat_get_num_screens();
646 for (disp_dev = 0; disp_dev < num_screens; disp_dev++) {
647 ret =
648 disp_device_attached(disp, disp_dev, &config);
649 if (ret == 0)
650 break;
651 }
652 }
653
654 /* enable display device(only software) */
655 if (ret != 0) {
656 /* attach fail */
657 DE_WRN("Can't find device(%d) for manager %d\n",
658 (int)type, disp);
659 return -1;
660 }
661 if (mgr->device && mgr->device->sw_enable) {
662 if (mgr->device->set_mode)
663 mgr->device->set_mode(mgr->device, mode);
664 else if (mgr->device->set_static_config)
665 mgr->device->set_static_config(mgr->device,
666 &config);
667 return mgr->device->sw_enable(mgr->device);
668 }
669 }
670
671 return -1;
672 }
673
674 /***********************************************************
675 *
676 * interrupt proc
677 *
678 ***********************************************************/
bsp_disp_cfg_get(u32 disp)679 static s32 bsp_disp_cfg_get(u32 disp)
680 {
681 return gdisp.screen[disp].cfg_cnt;
682 }
683
bsp_disp_shadow_protect(u32 disp,bool protect)684 s32 bsp_disp_shadow_protect(u32 disp, bool protect)
685 {
686 s32 ret = -1;
687 u32 cnt = 0;
688 u32 max_cnt = 50;
689 u32 delay = 10; /* us */
690 unsigned long flags;
691
692 if (protect) {
693 while ((ret != 0) && (cnt < max_cnt)) {
694 spin_lock_irqsave(&gdisp.screen[disp].flag_lock, flags);
695 cnt++;
696 if (gdisp.screen[disp].have_cfg_reg == false) {
697 gdisp.screen[disp].cfg_cnt++;
698 ret = 0;
699 }
700 spin_unlock_irqrestore(&gdisp.screen[disp].flag_lock,
701 flags);
702 if (ret != 0)
703 disp_delay_us(delay);
704 }
705
706 if (ret != 0) {
707 DE_INF("wait for reg load finish time out\n");
708 spin_lock_irqsave(&gdisp.screen[disp].flag_lock, flags);
709 gdisp.screen[disp].cfg_cnt++;
710 spin_unlock_irqrestore(&gdisp.screen[disp].flag_lock,
711 flags);
712 }
713 } else {
714 spin_lock_irqsave(&gdisp.screen[disp].flag_lock, flags);
715 gdisp.screen[disp].cfg_cnt--;
716 spin_unlock_irqrestore(&gdisp.screen[disp].flag_lock, flags);
717 }
718 __inf("sel=%d, protect:%d, cnt=%d\n", disp, protect,
719 gdisp.screen[disp].cfg_cnt);
720 return DIS_SUCCESS;
721 }
722
723 EXPORT_SYMBOL(bsp_disp_shadow_protect);
724
bsp_disp_vsync_event_enable(u32 disp,bool enable)725 s32 bsp_disp_vsync_event_enable(u32 disp, bool enable)
726 {
727 gdisp.screen[disp].vsync_event_en = enable;
728
729 return DIS_SUCCESS;
730 }
731
disp_sync_all(u32 disp,bool sync)732 static s32 disp_sync_all(u32 disp, bool sync)
733 {
734 struct disp_manager *mgr;
735 struct disp_device *dispdev;
736
737 DISP_TRACE_INT2("frame-skip", disp, sync ? 0 : 1);
738
739 mgr = disp_get_layer_manager(disp);
740 if (!mgr) {
741 DE_WRN("get mgr%d fail\n", disp);
742 } else {
743 dispdev = mgr->device;
744 if (mgr->sync)
745 mgr->sync(mgr, sync);
746 if (dispdev && dispdev->get_status) {
747 if (dispdev->get_status(dispdev) != 0)
748 gdisp.screen[disp].health_info.error_cnt++;
749 }
750 if (sync == true)
751 mgr->enable_iommu(mgr, true);
752 }
753
754 return 0;
755 }
756
757 #if defined(__LINUX_PLAT__)
758 /* return 10fps */
bsp_disp_get_fps(u32 disp)759 s32 bsp_disp_get_fps(u32 disp)
760 {
761 u32 pre_time_index, cur_time_index;
762 u32 pre_time, cur_time;
763 u32 fps = 0xff;
764
765 pre_time_index = gdisp.screen[disp].health_info.sync_time_index;
766 cur_time_index =
767 (pre_time_index == 0) ?
768 (DEBUG_TIME_SIZE - 1) : (pre_time_index - 1);
769
770 pre_time = gdisp.screen[disp].health_info.sync_time[pre_time_index];
771 cur_time = gdisp.screen[disp].health_info.sync_time[cur_time_index];
772
773
774 /* HZ:timer interrupt times in 1 sec */
775 /* jiffies:increase 1 when timer interrupt occur. */
776 /* jiffies/HZ:current kernel boot time(second). */
777 /* 1000MS / ((cur_time_jiffies/HZ - pre_time_jiffes/HZ)*1000) */
778
779 if (pre_time != cur_time)
780 fps = MSEC_PER_SEC * HZ / (cur_time - pre_time);
781
782 return fps;
783 }
784
disp_sync_checkin(u32 disp)785 static void disp_sync_checkin(u32 disp)
786 {
787 u32 index = gdisp.screen[disp].health_info.sync_time_index;
788
789 gdisp.screen[disp].health_info.sync_time[index] = jiffies;
790 index++;
791 index = (index >= DEBUG_TIME_SIZE) ? 0 : index;
792 gdisp.screen[disp].health_info.sync_time_index = index;
793 }
794
bsp_disp_get_health_info(u32 disp,struct disp_health_info * info)795 s32 bsp_disp_get_health_info(u32 disp, struct disp_health_info *info)
796 {
797 if (info)
798 memcpy(info, &gdisp.screen[disp].health_info,
799 sizeof(struct disp_health_info));
800 return 0;
801 }
802 #endif
803
sync_event_proc(u32 disp,bool timeout)804 void sync_event_proc(u32 disp, bool timeout)
805 {
806 int ret;
807 unsigned long flags;
808
809 gdisp.screen[disp].health_info.irq_cnt++;
810
811 DISP_TRACE_INT2("vsync-irq", disp,
812 gdisp.screen[disp].health_info.irq_cnt & 0x01);
813
814 if (!disp_feat_is_using_rcq(disp)) {
815 if (!timeout)
816 disp_sync_checkin(disp);
817 else
818 gdisp.screen[disp].health_info.skip_cnt++;
819
820
821 spin_lock_irqsave(&gdisp.screen[disp].flag_lock, flags);
822 if ((bsp_disp_cfg_get(disp) == 0) && (!timeout)) {
823 gdisp.screen[disp].have_cfg_reg = true;
824 spin_unlock_irqrestore(&gdisp.screen[disp].flag_lock, flags);
825
826 disp_sync_all(disp, true);
827 gdisp.screen[disp].have_cfg_reg = false;
828 if (gdisp.init_para.disp_int_process)
829 gdisp.init_para.disp_int_process(disp);
830
831 } else {
832 spin_unlock_irqrestore(&gdisp.screen[disp].flag_lock, flags);
833 disp_sync_all(disp, false);
834 }
835 DISP_TRACE_INT2("vsync-timeout", disp, timeout ? 1 : 0);
836
837 if (gdisp.screen[disp].vsync_event_en && gdisp.init_para.vsync_event) {
838 ret = gdisp.init_para.vsync_event(disp);
839 if (ret == 0)
840 gdisp.screen[disp].health_info.vsync_cnt++;
841 else
842 gdisp.screen[disp].health_info.vsync_skip_cnt++;
843
844 }
845 tasklet_schedule(&gdisp.screen[disp].tasklet);
846 } else {
847 struct disp_manager *mgr;
848
849 mgr = disp_get_layer_manager(disp);
850 if (!timeout)
851 disp_sync_checkin(disp);
852
853
854 if (gdisp.init_para.disp_int_process)
855 gdisp.init_para.disp_int_process(disp);
856
857 if (gdisp.screen[disp].vsync_event_en && gdisp.init_para.vsync_event) {
858 ret = gdisp.init_para.vsync_event(disp);
859 if (ret == 0)
860 gdisp.screen[disp].health_info.vsync_cnt++;
861 else
862 gdisp.screen[disp].health_info.vsync_skip_cnt++;
863
864 }
865 tasklet_schedule(&gdisp.screen[disp].tasklet);
866 }
867 }
868
bsp_disp_get_output_type(u32 disp)869 s32 bsp_disp_get_output_type(u32 disp)
870 {
871 struct disp_manager *mgr = disp_get_layer_manager(disp);
872
873 if (mgr) {
874 struct disp_device *dispdev = mgr->device;
875
876 if (dispdev && dispdev->is_enabled
877 && dispdev->is_enabled(dispdev))
878 return dispdev->type;
879 }
880
881 return DISP_OUTPUT_TYPE_NONE;
882 }
883
disp_tasklet(unsigned long data)884 void disp_tasklet(unsigned long data)
885 {
886 struct disp_manager *mgr;
887 u32 disp = (u32)data;
888
889 mgr = disp_get_layer_manager(disp);
890 if (!mgr) {
891 DE_WRN("get mgr%d fail\n", disp);
892 } else {
893 if (mgr->tasklet)
894 mgr->tasklet(mgr);
895 }
896 }
897
898 #ifdef CONFIG_DEVFREQ_DRAM_FREQ_IN_VSYNC
bsp_disp_get_vb_time(void)899 s32 bsp_disp_get_vb_time(void)
900 {
901 u32 num_screens, screen_id;
902 struct disp_video_timings tt;
903 u32 vb_time = 0;
904
905 num_screens = bsp_disp_feat_get_num_screens();
906 for (screen_id = 0; screen_id < num_screens; screen_id++) {
907 if (bsp_disp_get_output_type(screen_id)
908 == DISP_OUTPUT_TYPE_LCD) {
909 struct disp_device *lcd;
910 u32 time_per_line = 0;
911 u32 start_delay = 0;
912
913 lcd = disp_get_lcd(screen_id);
914 if (!lcd)
915 DE_WRN("get lcd%d fail\n", screen_id);
916
917 if (lcd && lcd->get_timings) {
918 u32 fps = 0;
919
920 lcd->get_timings(lcd, &tt);
921 if ((tt.ver_total_time != 0)
922 && (tt.hor_total_time != 0))
923 fps =
924 tt.pixel_clk * 1000 /
925 (tt.ver_total_time *
926 tt.hor_total_time);
927 start_delay = tt.ver_total_time - tt.y_res - 10;
928 fps = (fps == 0) ? 60 : fps;
929 time_per_line =
930 1000000 / fps / tt.ver_total_time;
931 vb_time = (start_delay) * time_per_line;
932 }
933 }
934 /* add hdmi support ? */
935 }
936 return vb_time;
937 }
938
939 /* returns: us */
bsp_disp_get_next_vb_time(void)940 s32 bsp_disp_get_next_vb_time(void)
941 {
942 u32 cur_line;
943 u32 num_screens, screen_id;
944 struct disp_video_timings tt;
945 u32 next_time = 16000;
946
947 num_screens = bsp_disp_feat_get_num_screens();
948 for (screen_id = 0; screen_id < num_screens; screen_id++) {
949 if (bsp_disp_get_output_type(screen_id)
950 == DISP_OUTPUT_TYPE_LCD) {
951 struct disp_device *lcd;
952 u32 time_per_line = 0;
953 struct disp_panel_para info;
954
955 memset(&info, 0, sizeof(struct disp_panel_para));
956 lcd = disp_get_lcd(screen_id);
957 if (lcd && lcd->get_panel_info)
958 lcd->get_panel_info(lcd, &info);
959 cur_line = disp_al_lcd_get_cur_line(screen_id, &info);
960 if (!lcd)
961 DE_WRN("get lcd%d fail\n", screen_id);
962
963 if (info.lcd_if != LCD_IF_EDP) {
964 if (lcd && lcd->get_timings) {
965 u32 fps = 0;
966
967 lcd->get_timings(lcd, &tt);
968 if ((tt.ver_total_time != 0)
969 && (tt.hor_total_time != 0))
970 fps =
971 tt.pixel_clk * 1000 /
972 (tt.ver_total_time *
973 tt.hor_total_time);
974 fps = (fps == 0) ? 60 : fps;
975 time_per_line =
976 1000000 / fps / tt.ver_total_time;
977 next_time =
978 (tt.ver_total_time -
979 cur_line) * time_per_line;
980 }
981 }
982 }
983 /* add hdmi support ? */
984 }
985 return next_time;
986 }
987
bsp_disp_is_in_vb(void)988 s32 bsp_disp_is_in_vb(void)
989 {
990 u32 num_screens, screen_id;
991 s32 ret = 1;
992
993 num_screens = bsp_disp_feat_get_num_screens();
994 for (screen_id = 0; screen_id < num_screens; screen_id++) {
995 if (bsp_disp_get_output_type(screen_id)
996 == DISP_OUTPUT_TYPE_LCD) {
997 struct disp_device *lcd;
998 struct disp_panel_para info;
999
1000 lcd = disp_get_lcd(screen_id);
1001 if (!lcd)
1002 DE_WRN("get lcd%d fail\n", screen_id);
1003
1004 memset(&info, 0, sizeof(struct disp_panel_para));
1005 if (lcd && lcd->get_panel_info)
1006 lcd->get_panel_info(lcd, &info);
1007 ret =
1008 disp_al_lcd_query_irq(screen_id, LCD_IRQ_TCON0_VBLK,
1009 &info);
1010 } else if (bsp_disp_get_output_type(screen_id) ==
1011 DISP_OUTPUT_TYPE_HDMI) {
1012 /* FIXME: add hdmi */
1013 }
1014 }
1015 return ret;
1016 }
1017 #endif
1018
1019
bsp_disp_get_screen_physical_width(u32 disp)1020 s32 bsp_disp_get_screen_physical_width(u32 disp)
1021 {
1022 s32 width = 0, height = 0;
1023 struct disp_manager *mgr = NULL;
1024
1025 mgr = disp_get_layer_manager(disp);
1026 if (mgr && mgr->device && mgr->device->get_dimensions)
1027 mgr->device->get_dimensions(mgr->device, &width, &height);
1028
1029 return width;
1030 }
1031
bsp_disp_get_screen_physical_height(u32 disp)1032 s32 bsp_disp_get_screen_physical_height(u32 disp)
1033 {
1034 s32 width = 0, height = 0;
1035 struct disp_manager *mgr = NULL;
1036
1037 mgr = disp_get_layer_manager(disp);
1038 if (mgr && mgr->device && mgr->device->get_dimensions)
1039 mgr->device->get_dimensions(mgr->device, &width, &height);
1040
1041 return height;
1042 }
1043
bsp_disp_get_screen_width(u32 disp)1044 s32 bsp_disp_get_screen_width(u32 disp)
1045 {
1046 s32 width = 0;
1047 /* FIXME */
1048 return width;
1049 }
1050
bsp_disp_get_screen_height(u32 disp)1051 s32 bsp_disp_get_screen_height(u32 disp)
1052 {
1053 s32 height = 0;
1054 /* FIXME */
1055
1056 return height;
1057 }
1058
bsp_disp_get_screen_width_from_output_type(u32 disp,u32 output_type,u32 output_mode)1059 s32 bsp_disp_get_screen_width_from_output_type(u32 disp, u32 output_type,
1060 u32 output_mode)
1061 {
1062 u32 width = 800, height = 480;
1063 struct disp_device *dispdev;
1064
1065 if (output_type == DISP_OUTPUT_TYPE_LCD) {
1066 struct disp_manager *mgr;
1067
1068 mgr = disp_get_layer_manager(disp);
1069 if (mgr && mgr->device && mgr->device->get_resolution) {
1070 mgr->device->get_resolution(mgr->device, &width,
1071 &height);
1072 }
1073 } else if (output_type == DISP_OUTPUT_TYPE_EDP) {
1074 dispdev = disp_device_get(disp, DISP_OUTPUT_TYPE_EDP);
1075 if (dispdev)
1076 dispdev->get_resolution(dispdev, &width, &height);
1077 } else if ((output_type == DISP_OUTPUT_TYPE_HDMI)
1078 || (output_type == DISP_OUTPUT_TYPE_TV)
1079 || (output_type == DISP_OUTPUT_TYPE_VGA)
1080 || (output_type == DISP_OUTPUT_TYPE_RTWB)
1081 || (output_type == DISP_OUTPUT_TYPE_VDPO)) {
1082 switch (output_mode) {
1083 case DISP_TV_MOD_NTSC:
1084 case DISP_TV_MOD_480I:
1085 case DISP_TV_MOD_480P:
1086 width = 720;
1087 height = 480;
1088 break;
1089 case DISP_TV_MOD_PAL:
1090 case DISP_TV_MOD_576I:
1091 case DISP_TV_MOD_576P:
1092 width = 720;
1093 height = 576;
1094 break;
1095 case DISP_TV_MOD_720P_50HZ:
1096 case DISP_TV_MOD_720P_60HZ:
1097 width = 1280;
1098 height = 720;
1099 break;
1100 case DISP_TV_MOD_1080P_50HZ:
1101 case DISP_TV_MOD_1080P_60HZ:
1102 case DISP_TV_MOD_1080P_30HZ:
1103 case DISP_TV_MOD_1080P_25HZ:
1104 case DISP_TV_MOD_1080P_24HZ:
1105 case DISP_TV_MOD_1080I_50HZ:
1106 case DISP_TV_MOD_1080I_60HZ:
1107 width = 1920;
1108 height = 1080;
1109 break;
1110 case DISP_TV_MOD_1080_1920P_60HZ:
1111 width = 1080;
1112 height = 1920;
1113 break;
1114 case DISP_TV_MOD_3840_2160P_60HZ:
1115 case DISP_TV_MOD_3840_2160P_30HZ:
1116 case DISP_TV_MOD_3840_2160P_25HZ:
1117 case DISP_TV_MOD_3840_2160P_24HZ:
1118 width = 3840;
1119 height = 2160;
1120 break;
1121 case DISP_TV_MOD_4096_2160P_24HZ:
1122 case DISP_TV_MOD_4096_2160P_25HZ:
1123 case DISP_TV_MOD_4096_2160P_30HZ:
1124 case DISP_TV_MOD_4096_2160P_50HZ:
1125 case DISP_TV_MOD_4096_2160P_60HZ:
1126 width = 4096;
1127 height = 2160;
1128 break;
1129 case DISP_VGA_MOD_800_600P_60:
1130 width = 800;
1131 height = 600;
1132 break;
1133 case DISP_VGA_MOD_1024_768P_60:
1134 width = 1024;
1135 height = 768;
1136 break;
1137 case DISP_VGA_MOD_1280_768P_60:
1138 width = 1280;
1139 height = 768;
1140 break;
1141 case DISP_VGA_MOD_1280_800P_60:
1142 width = 1280;
1143 height = 800;
1144 break;
1145 case DISP_VGA_MOD_1366_768P_60:
1146 width = 1366;
1147 height = 768;
1148 break;
1149 case DISP_VGA_MOD_1440_900P_60:
1150 width = 1440;
1151 height = 900;
1152 break;
1153 case DISP_TV_MOD_1440_2560P_70HZ:
1154 width = 1440;
1155 height = 2560;
1156 break;
1157 case DISP_VGA_MOD_1920_1080P_60:
1158 width = 1920;
1159 height = 1080;
1160 break;
1161 case DISP_VGA_MOD_1920_1200P_60:
1162 width = 1920;
1163 height = 1200;
1164 break;
1165 case DISP_VGA_MOD_1280_720P_60:
1166 width = 1280;
1167 height = 720;
1168 break;
1169 case DISP_VGA_MOD_1600_900P_60:
1170 width = 1600;
1171 height = 900;
1172 break;
1173 case DISP_TV_MOD_2560_1440P_60HZ:
1174 width = 2560;
1175 height = 1440;
1176 break;
1177 case DISP_TV_MOD_3840_1080P_30:
1178 width = 3840;
1179 height = 1080;
1180 break;
1181 }
1182 }
1183 /* FIXME: add other output device res */
1184
1185 return width;
1186 }
1187
bsp_disp_get_screen_height_from_output_type(u32 disp,u32 output_type,u32 output_mode)1188 s32 bsp_disp_get_screen_height_from_output_type(u32 disp, u32 output_type,
1189 u32 output_mode)
1190 {
1191 u32 width = 800, height = 480;
1192 struct disp_device *dispdev;
1193
1194 if (output_type == DISP_OUTPUT_TYPE_LCD) {
1195 struct disp_manager *mgr;
1196
1197 mgr = disp_get_layer_manager(disp);
1198 if (mgr && mgr->device && mgr->device->get_resolution) {
1199 mgr->device->get_resolution(mgr->device, &width,
1200 &height);
1201 }
1202 } else if (output_type == DISP_OUTPUT_TYPE_EDP) {
1203 dispdev = disp_device_get(disp, DISP_OUTPUT_TYPE_EDP);
1204 if (dispdev)
1205 dispdev->get_resolution(dispdev, &width, &height);
1206 } else if ((output_type == DISP_OUTPUT_TYPE_HDMI)
1207 || (output_type == DISP_OUTPUT_TYPE_TV)
1208 || (output_type == DISP_OUTPUT_TYPE_VGA)
1209 || (output_type == DISP_OUTPUT_TYPE_RTWB)
1210 || (output_type == DISP_OUTPUT_TYPE_VDPO)) {
1211 switch (output_mode) {
1212 case DISP_TV_MOD_NTSC:
1213 case DISP_TV_MOD_480I:
1214 case DISP_TV_MOD_480P:
1215 width = 720;
1216 height = 480;
1217 break;
1218 case DISP_TV_MOD_PAL:
1219 case DISP_TV_MOD_576I:
1220 case DISP_TV_MOD_576P:
1221 width = 720;
1222 height = 576;
1223 break;
1224 case DISP_TV_MOD_720P_50HZ:
1225 case DISP_TV_MOD_720P_60HZ:
1226 width = 1280;
1227 height = 720;
1228 break;
1229 case DISP_TV_MOD_1080P_50HZ:
1230 case DISP_TV_MOD_1080P_60HZ:
1231 case DISP_TV_MOD_1080P_30HZ:
1232 case DISP_TV_MOD_1080P_25HZ:
1233 case DISP_TV_MOD_1080P_24HZ:
1234 case DISP_TV_MOD_1080I_50HZ:
1235 case DISP_TV_MOD_1080I_60HZ:
1236 width = 1920;
1237 height = 1080;
1238 break;
1239 case DISP_TV_MOD_1080_1920P_60HZ:
1240 width = 1080;
1241 height = 1920;
1242 break;
1243 case DISP_TV_MOD_3840_2160P_60HZ:
1244 case DISP_TV_MOD_3840_2160P_30HZ:
1245 case DISP_TV_MOD_3840_2160P_25HZ:
1246 case DISP_TV_MOD_3840_2160P_24HZ:
1247 width = 3840;
1248 height = 2160;
1249 break;
1250 case DISP_TV_MOD_4096_2160P_24HZ:
1251 case DISP_TV_MOD_4096_2160P_25HZ:
1252 case DISP_TV_MOD_4096_2160P_30HZ:
1253 case DISP_TV_MOD_4096_2160P_50HZ:
1254 case DISP_TV_MOD_4096_2160P_60HZ:
1255 width = 4096;
1256 height = 2160;
1257 break;
1258 case DISP_VGA_MOD_800_600P_60:
1259 width = 800;
1260 height = 600;
1261 break;
1262 case DISP_VGA_MOD_1024_768P_60:
1263 width = 1024;
1264 height = 768;
1265 break;
1266 case DISP_VGA_MOD_1280_768P_60:
1267 width = 1280;
1268 height = 768;
1269 break;
1270 case DISP_VGA_MOD_1280_800P_60:
1271 width = 1280;
1272 height = 800;
1273 break;
1274 case DISP_VGA_MOD_1366_768P_60:
1275 width = 1366;
1276 height = 768;
1277 break;
1278 case DISP_VGA_MOD_1440_900P_60:
1279 width = 1440;
1280 height = 900;
1281 break;
1282 case DISP_TV_MOD_1440_2560P_70HZ:
1283 width = 1440;
1284 height = 2560;
1285 break;
1286 case DISP_VGA_MOD_1920_1080P_60:
1287 width = 1920;
1288 height = 1080;
1289 break;
1290 case DISP_VGA_MOD_1920_1200P_60:
1291 width = 1920;
1292 height = 1200;
1293 break;
1294 case DISP_VGA_MOD_1280_720P_60:
1295 width = 1280;
1296 height = 720;
1297 break;
1298 case DISP_VGA_MOD_1600_900P_60:
1299 width = 1600;
1300 height = 900;
1301 break;
1302 case DISP_TV_MOD_2560_1440P_60HZ:
1303 width = 2560;
1304 height = 1440;
1305 break;
1306 case DISP_TV_MOD_3840_1080P_30:
1307 width = 3840;
1308 height = 1080;
1309 break;
1310 }
1311 }
1312 /* FIXME: add other output device res */
1313
1314 return height;
1315 }
1316
bsp_disp_set_hdmi_func(struct disp_device_func * func)1317 s32 bsp_disp_set_hdmi_func(struct disp_device_func *func)
1318 {
1319 u32 disp = 0;
1320 u32 num_screens = 0;
1321 s32 ret = 0, registered_cnt = 0;
1322
1323 num_screens = bsp_disp_feat_get_num_screens();
1324 for (disp = 0; disp < num_screens; disp++) {
1325 struct disp_device *hdmi;
1326
1327 hdmi = disp_device_find(disp, DISP_OUTPUT_TYPE_HDMI);
1328 if (hdmi) {
1329 if (hdmi->set_func) {
1330 ret = hdmi->set_func(hdmi, func);
1331 if (ret == 0)
1332 registered_cnt++;
1333 } else {
1334 pr_err("disp hdmi device is NOT registered!\n");
1335 return -1;
1336 }
1337 }
1338 }
1339 if (registered_cnt != 0) {
1340 DE_INF("registered!!\n");
1341 gdisp.hdmi_registered = 1;
1342 if (gdisp.init_para.start_process)
1343 gdisp.init_para.start_process();
1344
1345 return 0;
1346 } else {
1347 pr_err("NO hdmi funcs to registered!!!\n");
1348 }
1349
1350 return -1;
1351 }
1352
bsp_disp_set_vdpo_func(struct disp_tv_func * func)1353 s32 bsp_disp_set_vdpo_func(struct disp_tv_func *func)
1354 {
1355 u32 disp = 0;
1356 u32 num_screens = 0;
1357 s32 ret = 0, registered_cnt = 0;
1358
1359 num_screens = bsp_disp_feat_get_num_screens();
1360 for (disp = 0; disp < num_screens; disp++) {
1361 struct disp_device *vdpo;
1362
1363 vdpo = disp_device_find(disp, DISP_OUTPUT_TYPE_VDPO);
1364 if (vdpo) {
1365 if (vdpo->set_tv_func)
1366 ret = vdpo->set_tv_func(vdpo, func);
1367 if (ret == 0)
1368 registered_cnt++;
1369 }
1370 }
1371
1372 if (registered_cnt != 0) {
1373 DE_INF("registered!!\n");
1374 gdisp.vdpo_registered = 1;
1375 if (gdisp.init_para.start_process)
1376 gdisp.init_para.start_process();
1377
1378 return 0;
1379 }
1380
1381 return -1;
1382 }
1383
bsp_disp_set_edp_func(struct disp_tv_func * func)1384 s32 bsp_disp_set_edp_func(struct disp_tv_func *func)
1385 {
1386 u32 disp = 0;
1387 u32 num_screens = 0;
1388 s32 ret = 0, registered_cnt = 0;
1389
1390 num_screens = bsp_disp_feat_get_num_screens();
1391 for (disp = 0; disp < num_screens; disp++) {
1392 struct disp_device *edp;
1393
1394 edp = disp_device_find(disp, DISP_OUTPUT_TYPE_EDP);
1395 if (edp) {
1396 if (edp->set_tv_func)
1397 ret = edp->set_tv_func(edp, func);
1398 if (ret == 0)
1399 registered_cnt++;
1400 }
1401 }
1402
1403 if (registered_cnt != 0) {
1404 DE_INF("edp registered!!\n");
1405 gdisp.edp_registered = 1;
1406 if (gdisp.init_para.start_process)
1407 gdisp.init_para.start_process();
1408
1409 return 0;
1410 }
1411
1412 return -1;
1413 }
1414
bsp_disp_hdmi_check_support_mode(u32 disp,enum disp_output_type mode)1415 s32 bsp_disp_hdmi_check_support_mode(u32 disp, enum disp_output_type mode)
1416 {
1417 u32 num_screens = 0;
1418 s32 ret = 0;
1419
1420 num_screens = bsp_disp_feat_get_num_screens();
1421 for (disp = 0; disp < num_screens; disp++) {
1422 struct disp_device *hdmi;
1423
1424 hdmi = disp_device_find(disp, DISP_OUTPUT_TYPE_HDMI);
1425 if (hdmi && hdmi->check_support_mode) {
1426 ret = hdmi->check_support_mode(hdmi, (u32) mode);
1427 break;
1428 }
1429 }
1430
1431 return ret;
1432 }
1433
bsp_disp_hdmi_set_detect(bool hpd)1434 s32 bsp_disp_hdmi_set_detect(bool hpd)
1435 {
1436 u32 num_screens = 0;
1437 u32 disp;
1438 s32 ret = 0;
1439
1440 num_screens = bsp_disp_feat_get_num_screens();
1441 for (disp = 0; disp < num_screens; disp++) {
1442 struct disp_device *hdmi;
1443
1444 hdmi = disp_device_find(disp, DISP_OUTPUT_TYPE_HDMI);
1445 if (hdmi && hdmi->set_detect) {
1446 ret = hdmi->set_detect(hdmi, hpd);
1447 break;
1448 }
1449 }
1450
1451 return ret;
1452 }
1453
bsp_disp_hdmi_cec_standby_request(void)1454 s32 bsp_disp_hdmi_cec_standby_request(void)
1455 {
1456 u32 num_screens = 0;
1457 s32 ret = 0;
1458 u32 disp;
1459
1460 num_screens = bsp_disp_feat_get_num_screens();
1461 for (disp = 0; disp < num_screens; disp++) {
1462 struct disp_device *hdmi;
1463
1464 hdmi = disp_device_find(disp, DISP_OUTPUT_TYPE_HDMI);
1465 if (hdmi && hdmi->cec_standby_request) {
1466 ret = hdmi->cec_standby_request(hdmi);
1467 break;
1468 }
1469 }
1470
1471 return ret;
1472 }
1473
bsp_disp_hdmi_cec_send_one_touch_play(void)1474 s32 bsp_disp_hdmi_cec_send_one_touch_play(void)
1475 {
1476 u32 num_screens = 0;
1477 s32 ret = 0;
1478 u32 disp;
1479
1480 num_screens = bsp_disp_feat_get_num_screens();
1481 for (disp = 0; disp < num_screens; disp++) {
1482 struct disp_device *hdmi;
1483
1484 hdmi = disp_device_find(disp, DISP_OUTPUT_TYPE_HDMI);
1485 if (hdmi && hdmi->cec_send_one_touch_play) {
1486 ret = hdmi->cec_send_one_touch_play(hdmi);
1487 break;
1488 }
1489 }
1490
1491 return ret;
1492 }
1493
bsp_disp_hdmi_get_color_format(void)1494 s32 bsp_disp_hdmi_get_color_format(void)
1495 {
1496 u32 num_screens = 0;
1497 s32 ret = 0;
1498 u32 disp;
1499
1500 num_screens = bsp_disp_feat_get_num_screens();
1501 for (disp = 0; disp < num_screens; disp++) {
1502 struct disp_device *hdmi;
1503
1504 hdmi = disp_device_find(disp, DISP_OUTPUT_TYPE_HDMI);
1505 if (hdmi && hdmi->get_input_csc) {
1506 ret = hdmi->get_input_csc(hdmi);
1507 break;
1508 }
1509 }
1510
1511 return ret;
1512
1513 }
1514
bsp_disp_tv_set_hpd(u32 state)1515 s32 bsp_disp_tv_set_hpd(u32 state)
1516 {
1517 #if defined SUPPORT_TV
1518
1519 u32 disp = 0, num_screens = 0;
1520 s32 ret = 0;
1521 struct disp_device *ptv = NULL;
1522
1523 num_screens = bsp_disp_feat_get_num_screens();
1524 for (disp = 0; disp < num_screens; disp++) {
1525 ptv = disp_device_find(disp, DISP_OUTPUT_TYPE_TV);
1526 if (ptv) {
1527 ret = disp_tv_set_hpd(ptv, state);
1528 } else {
1529 ret &= ret;
1530 /* DE_WRN("'ptv is null\n"); */
1531 continue;
1532 }
1533 }
1534
1535 if (ret != 0) {
1536 DE_WRN("'tv set hpd is fail!\n");
1537 return -1;
1538 }
1539 #endif
1540
1541 return 0;
1542 }
1543
bsp_disp_tv_register(struct disp_tv_func * func)1544 s32 bsp_disp_tv_register(struct disp_tv_func *func)
1545 {
1546 #if defined SUPPORT_TV
1547 u32 disp = 0;
1548 u32 num_screens = 0;
1549 s32 ret = 0, registered_cnt = 0;
1550 struct disp_device *dispdev = NULL;
1551
1552 num_screens = bsp_disp_feat_get_num_screens();
1553 disp_init_tv();
1554 for (disp = 0; disp < num_screens; disp++) {
1555 dispdev = disp_device_find(disp, DISP_OUTPUT_TYPE_TV);
1556 if (dispdev && dispdev->set_tv_func) {
1557 ret = dispdev->set_tv_func(dispdev, func);
1558 if (ret == 0)
1559 registered_cnt++;
1560 }
1561 }
1562
1563 #if defined(SUPPORT_VGA)
1564 disp_init_vga();
1565 for (disp = 0; disp < num_screens; disp++) {
1566 dispdev = disp_device_find(disp, DISP_OUTPUT_TYPE_VGA);
1567 if (dispdev && dispdev->set_tv_func) {
1568 ret = dispdev->set_tv_func(dispdev, func);
1569 if (ret == 0)
1570 registered_cnt++;
1571 }
1572 }
1573 #endif
1574 if (registered_cnt != 0) {
1575 gdisp.tv_registered = 1;
1576 if (gdisp.init_para.start_process)
1577 gdisp.init_para.start_process();
1578 }
1579 #endif
1580 return 0;
1581 }
1582
bsp_disp_lcd_set_panel_funs(char * name,struct disp_lcd_panel_fun * lcd_cfg)1583 s32 bsp_disp_lcd_set_panel_funs(char *name, struct disp_lcd_panel_fun *lcd_cfg)
1584 {
1585 struct disp_device *lcd;
1586 u32 num_screens;
1587 u32 screen_id;
1588 u32 registered_cnt = 0;
1589
1590 num_screens = bsp_disp_feat_get_num_screens();
1591 for (screen_id = 0; screen_id < num_screens; screen_id++) {
1592 lcd = disp_get_lcd(screen_id);
1593 if (lcd && (lcd->set_panel_func)) {
1594 if (!lcd->set_panel_func(lcd, name, lcd_cfg)) {
1595 gdisp.lcd_registered[screen_id] = 1;
1596 registered_cnt++;
1597 DE_INF("panel driver %s register\n", name);
1598 }
1599 }
1600 }
1601
1602 return 0;
1603 }
1604
LCD_OPEN_FUNC(u32 disp,LCD_FUNC func,u32 delay)1605 void LCD_OPEN_FUNC(u32 disp, LCD_FUNC func, u32 delay)
1606 {
1607 struct disp_device *lcd;
1608
1609 lcd = disp_get_lcd(disp);
1610
1611 if (lcd && lcd->set_open_func)
1612 lcd->set_open_func(lcd, func, delay);
1613 }
1614
LCD_CLOSE_FUNC(u32 disp,LCD_FUNC func,u32 delay)1615 void LCD_CLOSE_FUNC(u32 disp, LCD_FUNC func, u32 delay)
1616 {
1617 struct disp_device *lcd;
1618
1619 lcd = disp_get_lcd(disp);
1620
1621 if (lcd && lcd->set_close_func)
1622 lcd->set_close_func(lcd, func, delay);
1623 }
1624
bsp_disp_get_lcd_registered(u32 disp)1625 s32 bsp_disp_get_lcd_registered(u32 disp)
1626 {
1627 return gdisp.lcd_registered[disp];
1628 }
1629
bsp_disp_get_hdmi_registered(void)1630 s32 bsp_disp_get_hdmi_registered(void)
1631 {
1632 return gdisp.hdmi_registered;
1633 }
1634
bsp_disp_get_tv_registered(void)1635 s32 bsp_disp_get_tv_registered(void)
1636 {
1637 return gdisp.tv_registered;
1638 }
1639
bsp_disp_lcd_backlight_enable(u32 disp)1640 s32 bsp_disp_lcd_backlight_enable(u32 disp)
1641 {
1642 s32 ret = -1;
1643 struct disp_device *lcd;
1644
1645 lcd = disp_get_lcd(disp);
1646 if (lcd == NULL)
1647 return ret;
1648
1649 if (lcd->backlight_enable)
1650 ret = lcd->backlight_enable(lcd);
1651
1652 return ret;
1653 }
1654
bsp_disp_lcd_backlight_disable(u32 disp)1655 s32 bsp_disp_lcd_backlight_disable(u32 disp)
1656 {
1657 s32 ret = -1;
1658 struct disp_device *lcd;
1659
1660 lcd = disp_get_lcd(disp);
1661 if (lcd == NULL)
1662 return ret;
1663
1664 if (lcd && lcd->backlight_disable)
1665 ret = lcd->backlight_disable(lcd);
1666
1667 return ret;
1668 }
1669
bsp_disp_lcd_pwm_enable(u32 disp)1670 s32 bsp_disp_lcd_pwm_enable(u32 disp)
1671 {
1672 s32 ret = -1;
1673 struct disp_device *lcd;
1674
1675 lcd = disp_get_lcd(disp);
1676 if (lcd == NULL)
1677 return ret;
1678
1679 if (lcd && lcd->pwm_enable)
1680 ret = lcd->pwm_enable(lcd);
1681
1682 return ret;
1683 }
1684
bsp_disp_lcd_pwm_disable(u32 disp)1685 s32 bsp_disp_lcd_pwm_disable(u32 disp)
1686 {
1687 s32 ret = -1;
1688 struct disp_device *lcd;
1689
1690 lcd = disp_get_lcd(disp);
1691 if (lcd == NULL)
1692 return ret;
1693
1694 if (lcd && lcd->pwm_disable)
1695 ret = lcd->pwm_disable(lcd);
1696
1697 return ret;
1698 }
1699
bsp_disp_lcd_power_enable(u32 disp,u32 power_id)1700 s32 bsp_disp_lcd_power_enable(u32 disp, u32 power_id)
1701 {
1702 s32 ret = -1;
1703 struct disp_device *lcd;
1704
1705 lcd = disp_get_lcd(disp);
1706 if (lcd == NULL)
1707 return ret;
1708
1709 if (lcd && lcd->power_enable)
1710 ret = lcd->power_enable(lcd, power_id);
1711
1712 return ret;
1713 }
1714
bsp_disp_lcd_power_disable(u32 disp,u32 power_id)1715 s32 bsp_disp_lcd_power_disable(u32 disp, u32 power_id)
1716 {
1717 s32 ret = -1;
1718 struct disp_device *lcd;
1719
1720 lcd = disp_get_lcd(disp);
1721 if (lcd == NULL)
1722 return ret;
1723
1724 if (lcd && lcd->power_disable)
1725 ret = lcd->power_disable(lcd, power_id);
1726
1727 return ret;
1728 }
1729
bsp_disp_lcd_set_bright(u32 disp,u32 bright)1730 s32 bsp_disp_lcd_set_bright(u32 disp, u32 bright)
1731 {
1732 s32 ret = -1;
1733 struct disp_device *lcd;
1734
1735 lcd = disp_get_lcd(disp);
1736 if (lcd == NULL)
1737 return ret;
1738
1739 if (lcd && lcd->set_bright)
1740 ret = lcd->set_bright(lcd, bright);
1741
1742 return ret;
1743 }
1744
bsp_disp_lcd_get_bright(u32 disp)1745 s32 bsp_disp_lcd_get_bright(u32 disp)
1746 {
1747 u32 bright = 0;
1748 struct disp_device *lcd;
1749
1750 lcd = disp_get_lcd(disp);
1751 if (lcd && lcd->get_bright)
1752 bright = lcd->get_bright(lcd);
1753
1754 return bright;
1755 }
1756
bsp_disp_lcd_tcon_enable(u32 disp)1757 s32 bsp_disp_lcd_tcon_enable(u32 disp)
1758 {
1759 int ret = -1;
1760 struct disp_device *lcd;
1761 struct disp_device *lcd_slave;
1762
1763 struct disp_panel_para *panel_info =
1764 kmalloc(sizeof(struct disp_panel_para), GFP_KERNEL | __GFP_ZERO);
1765
1766 if (panel_info == NULL)
1767 goto OUT;
1768
1769 lcd = disp_get_lcd(disp);
1770 if (lcd == NULL)
1771 goto FREE_INFO;
1772
1773 if (lcd && lcd->get_panel_info)
1774 ret = lcd->get_panel_info(lcd, panel_info);
1775
1776 if (ret != 0)
1777 goto FREE_INFO;
1778
1779 if (panel_info->lcd_tcon_mode == DISP_TCON_SLAVE_MODE) {
1780 ret = 0;
1781 goto FREE_INFO;
1782 }
1783
1784 if (lcd && lcd->tcon_enable)
1785 ret = lcd->tcon_enable(lcd);
1786
1787 if (panel_info->lcd_tcon_mode <= DISP_TCON_MASTER_SYNC_EVERY_FRAME &&
1788 panel_info->lcd_tcon_mode >= DISP_TCON_MASTER_SYNC_AT_FIRST_TIME) {
1789 lcd_slave = disp_get_lcd(panel_info->lcd_slave_tcon_num);
1790 if (lcd_slave == NULL)
1791 goto FREE_INFO;
1792 if (lcd_slave && lcd_slave->tcon_enable)
1793 ret = lcd_slave->tcon_enable(lcd_slave);
1794 }
1795
1796 FREE_INFO:
1797 if (panel_info != NULL)
1798 kfree(panel_info);
1799 OUT:
1800 return ret;
1801 }
1802
bsp_disp_lcd_tcon_disable(u32 disp)1803 s32 bsp_disp_lcd_tcon_disable(u32 disp)
1804 {
1805 int ret = -1;
1806 struct disp_device *lcd;
1807 struct disp_device *lcd_slave;
1808
1809 struct disp_panel_para *panel_info =
1810 kmalloc(sizeof(struct disp_panel_para), GFP_KERNEL | __GFP_ZERO);
1811
1812 if (panel_info == NULL)
1813 goto OUT;
1814
1815 lcd = disp_get_lcd(disp);
1816 if (lcd == NULL)
1817 goto FREE_INFO;
1818
1819 if (lcd && lcd->get_panel_info)
1820 ret = lcd->get_panel_info(lcd, panel_info);
1821
1822 if (ret != 0)
1823 goto FREE_INFO;
1824
1825 if (lcd && lcd->tcon_disable)
1826 ret = lcd->tcon_disable(lcd);
1827
1828 if (panel_info->lcd_tcon_mode <= DISP_TCON_MASTER_SYNC_EVERY_FRAME &&
1829 panel_info->lcd_tcon_mode >= DISP_TCON_MASTER_SYNC_AT_FIRST_TIME) {
1830 lcd_slave = disp_get_lcd(panel_info->lcd_slave_tcon_num);
1831 if (lcd_slave == NULL)
1832 goto FREE_INFO;
1833 if (lcd_slave && lcd_slave->tcon_disable)
1834 ret = lcd_slave->tcon_disable(lcd_slave);
1835 }
1836
1837 FREE_INFO:
1838 if (panel_info != NULL)
1839 kfree(panel_info);
1840 OUT:
1841 return ret;
1842 }
1843
bsp_disp_lcd_pin_cfg(u32 disp,u32 en)1844 s32 bsp_disp_lcd_pin_cfg(u32 disp, u32 en)
1845 {
1846 int ret = -1;
1847 struct disp_device *lcd;
1848
1849 lcd = disp_get_lcd(disp);
1850 if (lcd && lcd->pin_cfg)
1851 ret = lcd->pin_cfg(lcd, en);
1852
1853 return ret;
1854 }
1855
bsp_disp_lcd_gpio_set_value(u32 disp,u32 io_index,u32 value)1856 s32 bsp_disp_lcd_gpio_set_value(u32 disp, u32 io_index, u32 value)
1857 {
1858 int ret = -1;
1859 struct disp_device *lcd;
1860
1861 lcd = disp_get_lcd(disp);
1862 if (lcd && lcd->gpio_set_value)
1863 ret = lcd->gpio_set_value(lcd, io_index, value);
1864
1865 return ret;
1866 }
1867
bsp_disp_lcd_gpio_set_direction(u32 disp,unsigned int io_index,u32 direction)1868 s32 bsp_disp_lcd_gpio_set_direction(u32 disp, unsigned int io_index,
1869 u32 direction)
1870 {
1871 int ret = -1;
1872 struct disp_device *lcd;
1873
1874 lcd = disp_get_lcd(disp);
1875 if (lcd && lcd->gpio_set_direction)
1876 ret = lcd->gpio_set_direction(lcd, io_index, direction);
1877
1878 return ret;
1879 }
1880
bsp_disp_get_panel_info(u32 disp,struct disp_panel_para * info)1881 s32 bsp_disp_get_panel_info(u32 disp, struct disp_panel_para *info)
1882 {
1883 struct disp_device *lcd;
1884
1885 lcd = disp_get_lcd(disp);
1886 if (!lcd)
1887 DE_WRN("get lcd%d fail\n", disp);
1888
1889 if (lcd && lcd->get_panel_info)
1890 return lcd->get_panel_info(lcd, info);
1891
1892 return DIS_FAIL;
1893 }
1894
bsp_disp_get_display_size(u32 disp,unsigned int * width,unsigned int * height)1895 int bsp_disp_get_display_size(u32 disp, unsigned int *width,
1896 unsigned int *height)
1897 {
1898 return disp_al_get_display_size(disp, width, height);
1899 }
1900 #if defined(SUPPORT_DSI)
1901 /**
1902 * @name :bsp_disp_lcd_dsi_mode_switch
1903 * @brief :dsi module mode switch
1904 * @param[IN] :cmd_en: command mode enable
1905 * @param[IN] :lp_en: lower power mode enable
1906 * @return :0 if success
1907 */
bsp_disp_lcd_dsi_mode_switch(u32 disp,u32 cmd_en,u32 lp_en)1908 s32 bsp_disp_lcd_dsi_mode_switch(u32 disp, u32 cmd_en, u32 lp_en)
1909 {
1910 s32 ret = -1;
1911 struct disp_panel_para *panel_info =
1912 kmalloc(sizeof(struct disp_panel_para), GFP_KERNEL | __GFP_ZERO);
1913
1914 ret = bsp_disp_get_panel_info(disp, panel_info);
1915 if (ret == DIS_FAIL) {
1916 DE_WRN("%s:Get panel info failed\n", __func__);
1917 goto OUT;
1918 }
1919
1920 if (panel_info->lcd_tcon_mode == DISP_TCON_SLAVE_MODE)
1921 goto OUT;
1922
1923 ret = dsi_mode_switch(disp, cmd_en, lp_en);
1924 if (panel_info->lcd_tcon_mode == DISP_TCON_DUAL_DSI &&
1925 disp + 1 < DEVICE_DSI_NUM)
1926 ret = dsi_mode_switch(disp + 1, cmd_en, lp_en);
1927 else if (panel_info->lcd_tcon_mode != DISP_TCON_NORMAL_MODE &&
1928 panel_info->lcd_tcon_mode != DISP_TCON_DUAL_DSI)
1929 ret = dsi_mode_switch(panel_info->lcd_slave_tcon_num, cmd_en,
1930 lp_en);
1931 OUT:
1932 kfree(panel_info);
1933 return ret;
1934 }
1935
bsp_disp_lcd_dsi_clk_enable(u32 disp,u32 en)1936 s32 bsp_disp_lcd_dsi_clk_enable(u32 disp, u32 en)
1937 {
1938 s32 ret = -1;
1939 struct disp_panel_para *panel_info =
1940 kmalloc(sizeof(struct disp_panel_para), GFP_KERNEL | __GFP_ZERO);
1941
1942 ret = bsp_disp_get_panel_info(disp, panel_info);
1943 if (ret == DIS_FAIL) {
1944 DE_WRN("%s:Get panel info failed\n", __func__);
1945 goto OUT;
1946 }
1947
1948 if (panel_info->lcd_tcon_mode == DISP_TCON_SLAVE_MODE)
1949 goto OUT;
1950
1951 ret = dsi_clk_enable(disp, en);
1952 if (panel_info->lcd_tcon_mode == DISP_TCON_DUAL_DSI &&
1953 disp + 1 < DEVICE_DSI_NUM)
1954 ret = dsi_clk_enable(disp + 1, en);
1955 else if (panel_info->lcd_tcon_mode != DISP_TCON_NORMAL_MODE &&
1956 panel_info->lcd_tcon_mode != DISP_TCON_DUAL_DSI)
1957 ret = dsi_clk_enable(panel_info->lcd_slave_tcon_num, en);
1958 OUT:
1959 kfree(panel_info);
1960 return ret;
1961 }
1962
bsp_disp_lcd_dsi_dcs_wr(u32 disp,u8 command,u8 * para,u32 para_num)1963 s32 bsp_disp_lcd_dsi_dcs_wr(u32 disp, u8 command, u8 *para, u32 para_num)
1964 {
1965 s32 ret = -1;
1966 struct disp_panel_para *panel_info =
1967 kmalloc(sizeof(struct disp_panel_para), GFP_KERNEL | __GFP_ZERO);
1968
1969 ret = bsp_disp_get_panel_info(disp, panel_info);
1970 if (ret == DIS_FAIL) {
1971 DE_WRN("%s:Get panel info failed\n", __func__);
1972 goto OUT;
1973 }
1974
1975 if (panel_info->lcd_tcon_mode == DISP_TCON_SLAVE_MODE)
1976 goto OUT;
1977
1978 ret = dsi_dcs_wr(disp, command, para, para_num);
1979 if (panel_info->lcd_tcon_mode == DISP_TCON_DUAL_DSI &&
1980 disp + 1 < DEVICE_DSI_NUM &&
1981 panel_info->lcd_dsi_port_num == DISP_LCD_DSI_SINGLE_PORT)
1982 ret = dsi_dcs_wr(disp + 1, command, para, para_num);
1983 else if (panel_info->lcd_tcon_mode != DISP_TCON_NORMAL_MODE &&
1984 panel_info->lcd_tcon_mode != DISP_TCON_DUAL_DSI)
1985 ret = dsi_dcs_wr(panel_info->lcd_slave_tcon_num, command, para,
1986 para_num);
1987 OUT:
1988 kfree(panel_info);
1989 return ret;
1990 }
1991
bsp_disp_lcd_dsi_gen_wr(u32 disp,u8 command,u8 * para,u32 para_num)1992 s32 bsp_disp_lcd_dsi_gen_wr(u32 disp, u8 command, u8 *para, u32 para_num)
1993 {
1994 s32 ret = -1;
1995 struct disp_panel_para *panel_info =
1996 kmalloc(sizeof(struct disp_panel_para), GFP_KERNEL | __GFP_ZERO);
1997
1998 ret = bsp_disp_get_panel_info(disp, panel_info);
1999 if (ret == DIS_FAIL) {
2000 DE_WRN("%s:Get panel info failed\n", __func__);
2001 goto OUT;
2002 }
2003
2004 if (panel_info->lcd_tcon_mode == DISP_TCON_SLAVE_MODE)
2005 goto OUT;
2006
2007 ret = dsi_gen_wr(disp, command, para, para_num);
2008 if (panel_info->lcd_tcon_mode == DISP_TCON_DUAL_DSI &&
2009 disp + 1 < DEVICE_DSI_NUM &&
2010 panel_info->lcd_dsi_port_num == DISP_LCD_DSI_SINGLE_PORT)
2011 ret = dsi_gen_wr(disp + 1, command, para, para_num);
2012 else if (panel_info->lcd_tcon_mode != DISP_TCON_NORMAL_MODE &&
2013 panel_info->lcd_tcon_mode != DISP_TCON_DUAL_DSI)
2014 ret = dsi_gen_wr(panel_info->lcd_slave_tcon_num, command, para,
2015 para_num);
2016 OUT:
2017 kfree(panel_info);
2018 return ret;
2019 }
2020
bsp_disp_lcd_dsi_gen_short_read(u32 sel,u8 * para_p,u8 para_num,u8 * result)2021 s32 bsp_disp_lcd_dsi_gen_short_read(u32 sel, u8 *para_p, u8 para_num,
2022 u8 *result)
2023 {
2024 s32 ret = -1;
2025
2026 if (!result || !para_p || para_num > 2) {
2027 DE_WRN("Wrong para!\n");
2028 goto OUT;
2029 }
2030 ret = dsi_gen_short_rd(sel, para_p, para_num, result);
2031 OUT:
2032 return ret;
2033 }
2034
bsp_disp_lcd_dsi_dcs_read(u32 sel,u8 cmd,u8 * result,u32 * num_p)2035 s32 bsp_disp_lcd_dsi_dcs_read(u32 sel, u8 cmd, u8 *result, u32 *num_p)
2036 {
2037 s32 ret = -1;
2038
2039 if (!result || !num_p) {
2040 DE_WRN("Wrong para!\n");
2041 goto OUT;
2042 }
2043 ret = dsi_dcs_rd(sel, cmd, result, num_p);
2044 OUT:
2045 return ret;
2046 }
2047
bsp_disp_lcd_set_max_ret_size(u32 sel,u32 size)2048 s32 bsp_disp_lcd_set_max_ret_size(u32 sel, u32 size)
2049 {
2050 return dsi_set_max_ret_size(sel, size);
2051 }
2052 #endif /*endif SUPPORT_DSI */
2053