projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
import PULS_20160108
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / misc / mediatek / video / mt8127 / mt8127 / dpi1_drv.c
1 #define ENABLE_DPI1_INTERRUPT 0
2 #define ENABLE_DPI1_REFRESH_RATE_LOG 0
3
4 #if ENABLE_DPI1_REFRESH_RATE_LOG && !ENABLE_DPI1_INTERRUPT
5 #error "ENABLE_DPI1_REFRESH_RATE_LOG should be also ENABLE_DPI1_INTERRUPT"
6 #endif
7
8 #if defined(CONFIG_MTK_HDMI_SUPPORT) && !ENABLE_DPI1_INTERRUPT
9 //#error "enable CONFIG_MTK_HDMI_SUPPORT should be also ENABLE_DPI1_INTERRUPT"
10 #endif
11
12 #include <linux/kernel.h>
13 #include <linux/string.h>
14 #include <linux/hrtimer.h>
15 #include <asm/io.h>
16 #include <disp_drv_log.h>
17 #include <linux/wait.h>
18 #include <linux/interrupt.h>
19 #include <linux/sched.h>
20 #include <linux/delay.h>
21 #include "disp_drv_platform.h"
22
23 #include "dpi_reg.h"
24 #include "dsi_reg.h"
25 #include "dpi1_drv.h"
26 #include "lcd_drv.h"
27 #include <mach/mt_clkmgr.h>
28
29
30 #if ENABLE_DPI1_INTERRUPT
31 //#include <linux/interrupt.h>
32 //#include <linux/wait.h>
33
34 #include <mach/irqs.h>
35 #include "mtkfb.h"
36 #endif
37 static wait_queue_head_t _vsync_wait_queue_dpi;
38 static bool dpi_vsync = false;
39 static bool wait_dpi_vsync = false;
40 static struct hrtimer hrtimer_vsync_dpi;
41 #include <linux/module.h>
42
43 #include <mach/sync_write.h>
44 #ifdef OUTREG32
45 #undef OUTREG32
46 #define OUTREG32(x, y) mt65xx_reg_sync_writel(y, x)
47 #endif
48
49 #ifndef OUTREGBIT
50 #define OUTREGBIT(TYPE,REG,bit,value) \
51 do { \
52 TYPE r = *((TYPE*)&INREG32(&REG)); \
53 r.bit = value; \
54 OUTREG32(&REG, AS_UINT32(&r)); \
55 } while (0)
56 #endif
57
58
59 static PDPI_REGS const DPI1_REG = (PDPI_REGS)(DPI1_BASE);
60 static PDSI_PHY_REGS const DSI_PHY_REG_DPI = (PDSI_PHY_REGS)(MIPI_CONFIG_BASE + 0x800);
61 static UINT32 const PLL_SOURCE = APMIXEDSYS_BASE + 0x44;
62 static BOOL s_isDpiPowerOn = FALSE;
63 static DPI_REGS regBackup;
64 static void (*dpiIntCallback)(DISP_INTERRUPT_EVENTS);
65
66 #define DPI1_REG_OFFSET(r) offsetof(DPI_REGS, r)
67 #define REG_ADDR(base, offset) (((BYTE *)(base)) + (offset))
68
69 const UINT32 BACKUP_DPI1_REG_OFFSETS[] =
70 {
71 DPI1_REG_OFFSET(INT_ENABLE),
72 DPI1_REG_OFFSET(SIZE),
73 DPI1_REG_OFFSET(OUTPUT_SETTING),
74
75 DPI1_REG_OFFSET(TGEN_HWIDTH),
76 DPI1_REG_OFFSET(TGEN_HPORCH),
77
78 DPI1_REG_OFFSET(TGEN_VWIDTH_LODD),
79 DPI1_REG_OFFSET(TGEN_VPORCH_LODD),
80
81 DPI1_REG_OFFSET(TGEN_VWIDTH_LEVEN),
82 DPI1_REG_OFFSET(TGEN_VPORCH_LEVEN),
83 DPI1_REG_OFFSET(TGEN_VWIDTH_RODD),
84
85 DPI1_REG_OFFSET(TGEN_VPORCH_RODD),
86 DPI1_REG_OFFSET(TGEN_VWIDTH_REVEN),
87
88 DPI1_REG_OFFSET(TGEN_VPORCH_REVEN),
89 DPI1_REG_OFFSET(ESAV_VTIM_LODD),
90 DPI1_REG_OFFSET(ESAV_VTIM_LEVEN),
91
92 DPI1_REG_OFFSET(ESAV_VTIM_RODD),
93 DPI1_REG_OFFSET(ESAV_VTIM_REVEN),
94
95
96 DPI1_REG_OFFSET(ESAV_FTIM),
97 DPI1_REG_OFFSET(BG_HCNTL),
98
99 DPI1_REG_OFFSET(BG_VCNTL),
100 DPI1_REG_OFFSET(BG_COLOR),
101 //DPI1_REG_OFFSET(TGEN_POL),
102 DPI1_REG_OFFSET(EMBSYNC_SETTING),
103
104 DPI1_REG_OFFSET(CNTL),
105 };
106
107 static void _BackupDPIRegisters(void)
108 {
109 DPI_REGS *reg = &regBackup;
110 UINT32 i;
111
112 for (i = 0; i < ARY_SIZE(BACKUP_DPI1_REG_OFFSETS); ++ i)
113 {
114 OUTREG32(REG_ADDR(reg, BACKUP_DPI1_REG_OFFSETS[i]),
115 AS_UINT32(REG_ADDR(DPI1_REG, BACKUP_DPI1_REG_OFFSETS[i])));
116 }
117 }
118
119 static void _RestoreDPIRegisters(void)
120 {
121 DPI_REGS *reg = &regBackup;
122 UINT32 i;
123
124 for (i = 0; i < ARY_SIZE(BACKUP_DPI1_REG_OFFSETS); ++ i)
125 {
126 OUTREG32(REG_ADDR(DPI1_REG, BACKUP_DPI1_REG_OFFSETS[i]),
127 AS_UINT32(REG_ADDR(reg, BACKUP_DPI1_REG_OFFSETS[i])));
128 }
129 }
130
131 static void _ResetBackupedDPIRegisterValues(void)
132 {
133 DPI_REGS *regs = &regBackup;
134 memset((void*)regs, 0, sizeof(DPI_REGS));
135
136 OUTREG32(&regs->OUTPUT_SETTING, 0x00000101);
137 }
138
139
140 #if ENABLE_DPI1_REFRESH_RATE_LOG
141 static void _DPI1_LogRefreshRate(DPI1_REG_INTERRUPT status)
142 {
143 static unsigned long prevUs = 0xFFFFFFFF;
144
145 if (status.VSYNC)
146 {
147 struct timeval curr;
148 do_gettimeofday(&curr);
149
150 if (prevUs < curr.tv_usec)
151 {
152 DISP_LOG_PRINT(ANDROID_LOG_INFO, "DPI1", "Receive 1 vsync in %lu us\n",
153 curr.tv_usec - prevUs);
154 }
155 prevUs = curr.tv_usec;
156 }
157 }
158 #else
159 #define _DPI1_LogRefreshRate(x) do {} while(0)
160 #endif
161
162 extern void dsi_handle_esd_recovery(void);
163
164 void DPI1_DisableIrq(void)
165 {
166 DPI_REG_INTERRUPT enInt = DPI1_REG->INT_ENABLE;
167 enInt.VSYNC = 0;
168 OUTREG32(&DPI1_REG->INT_ENABLE, AS_UINT32(&enInt));
169 }
170 void DPI1_EnableIrq(void)
171 {
172 DPI_REG_INTERRUPT enInt = DPI1_REG->INT_ENABLE;
173 enInt.VSYNC = 1;
174 OUTREG32(&DPI1_REG->INT_ENABLE, AS_UINT32(&enInt));
175 }
176
177 #if ENABLE_DPI1_INTERRUPT
178 static irqreturn_t _DPI1_InterruptHandler(int irq, void *dev_id)
179 {
180 static int counter = 0;
181 DPI_REG_INTERRUPT status = DPI1_REG->INT_STATUS;
182 // if (status.FIFO_EMPTY) ++ counter;
183
184 if(status.VSYNC)
185 {
186 if(dpiIntCallback)
187 dpiIntCallback(DISP_DPI1_VSYNC_INT);
188
189 if(wait_dpi_vsync){
190 if(-1 != hrtimer_try_to_cancel(&hrtimer_vsync_dpi)){
191 dpi_vsync = true;
192 // hrtimer_try_to_cancel(&hrtimer_vsync_dpi);
193 wake_up_interruptible(&_vsync_wait_queue_dpi);
194 }
195 }
196 }
197
198 if (status.VSYNC && counter) {
199 DISP_LOG_PRINT(ANDROID_LOG_ERROR, "DPI1", "[Error] DPI FIFO is empty, "
200 "received %d times interrupt !!!\n", counter);
201 counter = 0;
202 }
203
204 _DPI1_LogRefreshRate(status);
205 OUTREG32(&DPI1_REG->INT_STATUS, 0);
206 return IRQ_HANDLED;
207 }
208 #endif
209
210 #define VSYNC_US_TO_NS(x) (x * 1000)
211 unsigned int vsync_timer_dpi1 = 0;
212 void DPI1_WaitVSYNC(void)
213 {
214 wait_dpi_vsync = true;
215 hrtimer_start(&hrtimer_vsync_dpi, ktime_set(0, VSYNC_US_TO_NS(vsync_timer_dpi1)), HRTIMER_MODE_REL);
216 wait_event_interruptible(_vsync_wait_queue_dpi, dpi_vsync);
217 dpi_vsync = false;
218 wait_dpi_vsync = false;
219 }
220
221 void DPI1_PauseVSYNC(bool enable)
222 {
223 }
224
225 enum hrtimer_restart dpi1_vsync_hrtimer_func(struct hrtimer *timer)
226 {
227 // long long ret;
228 if(wait_dpi_vsync)
229 {
230 dpi_vsync = true;
231 wake_up_interruptible(&_vsync_wait_queue_dpi);
232 // printk("hrtimer Vsync, and wake up\n");
233 }
234 // ret = hrtimer_forward_now(timer, ktime_set(0, VSYNC_US_TO_NS(vsync_timer_dpi1)));
235 // printk("hrtimer callback\n");
236 return HRTIMER_NORESTART;
237 }
238
239 void DPI1_InitVSYNC(unsigned int vsync_interval)
240 {
241 ktime_t ktime;
242 vsync_timer_dpi1 = vsync_interval;
243 ktime = ktime_set(0, VSYNC_US_TO_NS(vsync_timer_dpi1));
244 hrtimer_init(&hrtimer_vsync_dpi, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
245 hrtimer_vsync_dpi.function = dpi1_vsync_hrtimer_func;
246 // hrtimer_start(&hrtimer_vsync_dpi, ktime, HRTIMER_MODE_REL);
247 }
248
249 DPI_STATUS DPI1_Init(BOOL isDpiPoweredOn)
250 {
251 //DPI1_REG_CNTL cntl;
252 //DPI1_REG_EMBSYNC_SETTING embsync;
253 DPI_REG_EN en = DPI1_REG->DPI_EN;
254
255 if (isDpiPoweredOn) {
256 _BackupDPIRegisters();
257 } else {
258 _ResetBackupedDPIRegisterValues();
259 }
260
261 /*DPI1_PowerOn();*/
262
263 en.EN_TEST_PATERN_CTRL= 1;
264 OUTREG32(&DPI1_REG->DPI_EN, AS_UINT32(&en));
265
266 #if 0
267 OUTREG32(DPI1_BASE+ 0x64, 0x400);//
268 OUTREG32(DPI1_BASE+ 0x6C, 0x400);//
269 OUTREG32(DPI1_BASE+ 0x74, 0x400);//
270 OUTREG32(DPI1_BASE+ 0x8C, 0x0FFF0000);//
271 OUTREG32(DPI1_BASE+ 0x90, 0x0FFF0000);//
272 MASKREG32(DISPSYS_BASE + 0x60, 0x1, 0x1); // [1]: DPI0_I2X_EN
273 // 0: DPI0 IO is single edge mode
274 //1: DPI0 IO is dual edge mode
275 #endif
276
277 MASKREG32(DISPSYS_BASE + 0x60, 0xb03, 0xb03);
278
279 //OUTREG32(DPI1_BASE+ 0x10, 0x000001A0);//DPI_CON
280 //OUTREG32(DPI1_BASE+ 0x14, 0x00000101);//DPI_CLKCON
281 //OUTREG32(DPI1_BASE+ 0x18, 0x02d00500);//DPI_SIZE 720x1280
282 //OUTREG32(DPI1_BASE+ 0x1c, 0x00000028);//DPI_TGEN_HWIDTH 40
283 //OUTREG32(DPI1_BASE+ 0x20, 0x01b800dc);//DPI_TGEN_HPORCH BACK:220 FRONT:440
284 //OUTREG32(DPI1_BASE+ 0x24, 0x00000005);//DPI_TGEN_VWIDTH_LODD 5
285 //OUTREG32(DPI1_BASE+ 0x28, 0x00050014);//DPI_TGEN_VPORCH_LODD BACK:20 FRONT:5
286 //OUTREG32(DPI1_BASE+ 0x44, 0x00001e00);//DPI_ESAV_VTIM_L WIDTH:30 lines
287 //DPI1_ESAVVTimingControlLeft(0, 0x1E, 0, 0);
288
289 //OUTREG32(DPI1_BASE+ 0x64, 0x1ead1f53);//DPI_MATRIX_COEFF_SET0
290 //OUTREG32(DPI1_BASE+ 0x68, 0x01320200);//DPI_MATRIX_COEFF_SET1
291 //OUTREG32(DPI1_BASE+ 0x6c, 0x00750259);//DPI_MATRIX_COEFF_SET2
292 //OUTREG32(DPI1_BASE+ 0x70, 0x1e530200);//DPI_MATRIX_COEFF_SET3
293 //OUTREG32(DPI1_BASE+ 0x74, 0x00001fa0);//DPI_MATRIX_COEFF_SET4
294 //DPI1_MatrixCoef(0x1F53, 0x1EAD, 0x0200, 0x0132, 0x0259, 0x0075, 0x0200, 0x1E53, 0x1FA0);
295
296 //OUTREG32(DPI1_BASE+ 0x78, 0x00000000);//DPI_MATRIX_PREADD_SET0
297 //OUTREG32(DPI1_BASE+ 0x7c, 0x00000000);//DPI_MATRIX_PREADD_SET1
298 //DPI1_MatrixPreOffset(0, 0, 0);
299
300 //OUTREG32(DPI1_BASE+ 0x80, 0x00000800);//DPI_MATRIX_POSTADD_SET0
301 //OUTREG32(DPI1_BASE+ 0x84, 0x00000800);//DPI_MATRIX_POSTADD_SET1
302 //DPI1_MatrixPostOffset(0x0800, 0, 0x0800);
303
304 //OUTREG32(DPI1_BASE+ 0x88, 0x00000000);//DPI_CLPF_SETTING
305 //DPI1_CLPFSetting(0, FALSE);
306
307 //OUTREG32(DPI1_BASE+ 0x8c, 0x0f000100);//DPI_Y_LIMIT 256 - 3840
308 //OUTREG32(DPI1_BASE+ 0x90, 0x0f000100);//DPI_C_LIMIT 256 - 3840
309 //DPI1_SetChannelLimit(0x0100, 0x0F00, 0x0100, 0x0F00);
310
311 //OUTREG32(DPI1_BASE+ 0x9c, 0x00000007);//DPI_EMBSYNC_SETTING
312 //DPI1_EmbeddedSyncSetting(TRUE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE);
313
314 //OUTREG32(DPI1_BASE+ 0xa8, 0x00000600);//DPI_OUTPUT_SETTING OUT_YC_MAP
315 //DPI1_OutputSetting(DPI_OUTPUT_BIT_NUM_8BITS, FALSE, DPI_OUTPUT_CHANNEL_SWAP_RGB, DPI_OUTPUT_YC_MAP_CY);
316
317 //OUTREG32(DPI1_BASE+ 0xb4, 0x11223341);//DPI_PATTERN
318 //DPI1_EnableColorBar();
319
320 //OUTREG32(DPI1_BASE + 0x0, 0x00000001);//
321 //DPI1_EnableClk();
322
323 #if 0
324 cntl = DPI1_REG->CNTL;
325 cntl.EMBSYNC_EN = 1;
326 OUTREG32(&DPI1_REG->CNTL, AS_UINT32(&cntl));
327
328 embsync = DPI1_REG->EMBSYNC_SETTING;
329 embsync.ESAV_CODE_MAN = 0;
330 embsync.EMBVSYNC_G_Y = 1;
331 embsync.EMBVSYNC_R_CR= 1;
332 embsync.EMBVSYNC_B_CB= 1;
333 OUTREG32(&DPI1_REG->EMBSYNC_SETTING, AS_UINT32(&embsync));
334 #endif
335
336 #if ENABLE_DPI1_INTERRUPT
337 if (request_irq(MT8127_DPI_IRQ_ID,
338 _DPI1_InterruptHandler, IRQF_TRIGGER_LOW, "mtkdpi", NULL) < 0)
339 {
340 DISP_LOG_PRINT(ANDROID_LOG_INFO, "DPI1", "[ERROR] fail to request DPI irq\n");
341 return DPI_STATUS_ERROR;
342 }
343
344 {
345 DPI_REG_INTERRUPT enInt = DPI1_REG->INT_ENABLE;
346 enInt.VSYNC = 1;
347 OUTREG32(&DPI1_REG->INT_ENABLE, AS_UINT32(&enInt));
348 }
349 #endif
350 LCD_W2M_NeedLimiteSpeed(TRUE);
351 return DPI_STATUS_OK;
352 }
353 EXPORT_SYMBOL(DPI1_Init);
354
355 DPI_STATUS DPI1_FreeIRQ(void)
356 {
357 #if ENABLE_DPI1_INTERRUPT
358 free_irq(MT8127_DPI_IRQ_ID, NULL);
359 #endif
360 return DPI_STATUS_OK;
361 }
362 EXPORT_SYMBOL(DPI1_FreeIRQ);
363
364 DPI_STATUS DPI1_Deinit(void)
365 {
366 DPI1_DisableClk();
367 DPI1_PowerOff();
368
369 return DPI_STATUS_OK;
370 }
371 EXPORT_SYMBOL(DPI1_Deinit);
372
373 void DPI1_mipi_switch(bool on)
374 {
375 if(on)
376 {
377 // may call enable_mipi(), but do this in DPI1_Init_PLL
378 }
379 else
380 {
381 #ifdef DPI1_MIPI_API
382 disable_mipi(MT65XX_MIPI_TX, "DPI");
383 #endif
384 }
385 }
386
387 #ifndef BULID_UBOOT
388 extern UINT32 FB_Addr;
389 #endif
390
391 DPI_STATUS DPI1_Init_PLL(HDMI_VIDEO_RESOLUTION resolution)
392 {
393 //DPI1 PLL
394 DRV_SetReg32(TVDPLL_PWR_CON0, (0x1 << 0)); //PLL_PWR_ON
395 udelay(2);
396 DRV_ClrReg32(TVDPLL_PWR_CON0, (0x1 << 1)); //PLL_ISO_EN
397 switch(resolution)
398 {
399 case HDMI_VIDEO_720x480p_60Hz:
400 #ifdef CONFIG_MTK_MT8193_HDMI_SUPPORT
401 case HDMI_VIDEO_720x576p_50Hz:
402 #endif
403 {
404 OUTREG32(TVDPLL_CON1, 0x80109d89);
405 OUTREG32(TVDPLL_CON0, 0x80800081);
406 break;
407 }
408 case HDMI_VIDEO_1920x1080p_30Hz:
409 #ifdef CONFIG_MTK_MT8193_HDMI_SUPPORT
410 case HDMI_VIDEO_1280x720p_50Hz:
411 case HDMI_VIDEO_1920x1080i_50Hz:
412 case HDMI_VIDEO_1920x1080p_25Hz:
413 case HDMI_VIDEO_1920x1080p_24Hz:
414 case HDMI_VIDEO_1920x1080p_50Hz:
415 #endif
416 {
417 OUTREG32(TVDPLL_CON1, 0x800b6c4e);
418 OUTREG32(TVDPLL_CON0, 0x80000081);
419 break;
420 }
421
422 case HDMI_VIDEO_1280x720p_60Hz:
423 #ifdef CONFIG_MTK_MT8193_HDMI_SUPPORT
424 case HDMI_VIDEO_1920x1080i_60Hz:
425 case HDMI_VIDEO_1920x1080p_23Hz:
426 case HDMI_VIDEO_1920x1080p_29Hz:
427 case HDMI_VIDEO_1920x1080p_60Hz:
428 #endif
429 {
430 OUTREG32(TVDPLL_CON1, 0x800b6964);
431 OUTREG32(TVDPLL_CON0, 0x80000081);
432 break;
433 }
434
435 default:
436 {
437 printk("[DPI1] not supported format, %s, %d, format = %d\n", __func__, __LINE__, resolution);
438 break;
439 }
440 }
441
442 udelay(20);
443
444 return DPI_STATUS_OK;
445 }
446
447 EXPORT_SYMBOL(DPI1_Init_PLL);
448
449 DPI_STATUS DPI1_Set_DrivingCurrent(LCM_PARAMS *lcm_params)
450 {
451 DISP_LOG_PRINT(ANDROID_LOG_WARN, "DPI1", "DPI1_Set_DrivingCurrent not implement for 6575");
452 return DPI_STATUS_OK;
453 }
454
455 DPI_STATUS DPI1_PowerOn()
456 {
457 int ret = 0;
458
459 #ifndef CONFIG_MT6589_FPGA
460 printk("[DPI1] %s,isDpiPowerOn %d\n", __func__,s_isDpiPowerOn);
461 if (!s_isDpiPowerOn)
462 {
463 #if 1 // FIXME
464 ret += enable_clock(MT_CG_DISP1_DPI1_DIGITAL_LANE, "DPI1");
465 ret += enable_clock(MT_CG_DISP1_DPI1_ENGINE, "DPI1");
466 ret += enable_clock(MT_CG_DISP1_HDMI_PIXEL_CLOCK, "DPI1");
467 ret += enable_clock(MT_CG_DISP1_HDMI_PLL_CLOCK, "DPI1");
468 ret += enable_clock(MT_CG_DISP1_HDMI_AUDIO_CLOCK, "DPI1");
469 ret += enable_clock(MT_CG_DISP1_HDMI_SPDIF_CLOCK, "DPI1");
470
471
472 if(1 == ret)
473 {
474 DISP_LOG_PRINT(ANDROID_LOG_ERROR, "DPI", "power manager API return FALSE\n");
475 }
476 #endif
477 _RestoreDPIRegisters();
478 s_isDpiPowerOn = TRUE;
479 }
480 #endif
481 return DPI_STATUS_OK;
482 }
483
484 DPI_STATUS DPI1_PowerOff()
485 {
486 int ret = 0;
487 #ifndef CONFIG_MT6589_FPGA
488 printk("[DPI1] %s,isDpiPowerOn %d\n", __func__,s_isDpiPowerOn);
489 if (s_isDpiPowerOn)
490 {
491 //int ret = TRUE;
492 _BackupDPIRegisters();
493 #if 1 // FIXME
494 ret += disable_clock(MT_CG_DISP1_DPI1_DIGITAL_LANE, "DPI1");
495 ret += disable_clock(MT_CG_DISP1_DPI1_ENGINE, "DPI1");
496 ret += disable_clock(MT_CG_DISP1_HDMI_PIXEL_CLOCK, "DPI1");
497 ret += disable_clock(MT_CG_DISP1_HDMI_PLL_CLOCK, "DPI1");
498 ret += disable_clock(MT_CG_DISP1_HDMI_AUDIO_CLOCK, "DPI1");
499 ret += disable_clock(MT_CG_DISP1_HDMI_SPDIF_CLOCK, "DPI1");
500
501
502 if(1 == ret)
503 {
504 DISP_LOG_PRINT(ANDROID_LOG_ERROR, "DPI", "power manager API return FALSE\n");
505 }
506 #endif
507 s_isDpiPowerOn = FALSE;
508 }
509 #endif
510 return DPI_STATUS_OK;
511 }
512
513 EXPORT_SYMBOL(DPI1_PowerOn);
514
515 EXPORT_SYMBOL(DPI1_PowerOff);
516
517 DPI_STATUS DPI1_EnableClk()
518 {
519 DPI_REG_EN en = DPI1_REG->DPI_EN;
520 en.EN = 1;
521 OUTREG32(&DPI1_REG->DPI_EN, AS_UINT32(&en));
522 //release mutex0
523 //#ifndef BUILD_UBOOT
524 #if 0
525 OUTREG32(DISP_MUTEX_BASE + 0x24, 0);
526 while((INREG32(DISP_MUTEX_BASE + 0x24)&0x02)!=0){} // polling until mutex lock complete
527 #endif
528 return DPI_STATUS_OK;
529 }
530 EXPORT_SYMBOL(DPI1_EnableClk);
531
532 DPI_STATUS DPI1_DisableClk()
533 {
534 DPI_REG_EN en = DPI1_REG->DPI_EN;
535 en.EN = 0;
536 OUTREG32(&DPI1_REG->DPI_EN, AS_UINT32(&en));
537
538 return DPI_STATUS_OK;
539 }
540 EXPORT_SYMBOL(DPI1_DisableClk);
541
542 DPI_STATUS DPI1_EnableSeqOutput(BOOL enable)
543 {
544 return DPI_STATUS_OK;
545 }
546 EXPORT_SYMBOL(DPI1_EnableSeqOutput);
547
548 DPI_STATUS DPI1_SetRGBOrder(DPI_RGB_ORDER input, DPI_RGB_ORDER output)
549 {
550 return DPI_STATUS_OK;
551 }
552 EXPORT_SYMBOL(DPI1_SetRGBOrder);
553
554 DPI_STATUS DPI1_ConfigPixelClk(DPI_POLARITY polarity, UINT32 divisor, UINT32 duty)
555 {
556 DPI_REG_OUTPUT_SETTING ctrl = DPI1_REG->OUTPUT_SETTING;
557 DPI_REG_CLKCNTL clkctrl = DPI1_REG->DPI_CLKCON;
558 /*
559 ASSERT(divisor >= 2);
560 ASSERT(duty > 0 && duty < divisor);
561
562 ctrl.POLARITY = (DPI_POLARITY_FALLING == polarity) ? 1 : 0;
563 ctrl.DIVISOR = divisor - 1;
564 ctrl.DUTY = duty;
565 */
566
567 ctrl.CLK_POL = (DPI_POLARITY_FALLING == polarity) ? 1 : 0;
568 clkctrl.DPI_CKOUT_DIV = 1;
569 clkctrl.EDGE_SEL_EN = 0;
570 OUTREG32(&DPI1_REG->OUTPUT_SETTING, AS_UINT32(&ctrl));
571 OUTREG32(&DPI1_REG->DPI_CLKCON , AS_UINT32(&clkctrl));
572
573 return DPI_STATUS_OK;
574 }
575 EXPORT_SYMBOL(DPI1_ConfigPixelClk);
576
577 DPI_STATUS DPI1_ConfigHDMI()
578 {
579 DPI_REG_CNTL ctrl = DPI1_REG->CNTL;
580 ctrl.YUV422_EN = 1;
581 ctrl.RGB2YUV_EN = 1;
582 ctrl.EMBSYNC_EN = 1;
583 OUTREG32(&DPI1_REG->CNTL, AS_UINT32(&ctrl));
584
585 return DPI_STATUS_OK;
586 }
587 EXPORT_SYMBOL(DPI1_ConfigHDMI);
588 DPI_STATUS DPI1_ColorSpace_Enable(UINT8 ColorSpace)
589 {
590 DPI_REG_CNTL ctrl = DPI1_REG->CNTL;
591 DPI_REG_OUTPUT_SETTING output = DPI1_REG->OUTPUT_SETTING;
592
593 if((YCBCR_444 == ColorSpace) || (YCBCR_444_FULL == ColorSpace)) //YUV444
594 {
595 ctrl.YUV422_EN = 0;
596 ctrl.RGB2YUV_EN= 1;
597 ctrl.IN_RB_SWAP = 0;
598 output.CH_SWAP = 5;
599 }
600 else if((YCBCR_422 == ColorSpace) || (YCBCR_422_FULL == ColorSpace)) //YUV422
601 {
602 ctrl.YUV422_EN = 1;
603 ctrl.RGB2YUV_EN= 1;
604 ctrl.IN_RB_SWAP = 1;
605 output.CH_SWAP = 0;
606 }
607 else //RGB
608 {
609 ctrl.YUV422_EN = 0;
610 ctrl.RGB2YUV_EN= 0;
611 ctrl.IN_RB_SWAP = 0;
612 output.CH_SWAP = 0;
613 }
614 OUTREG32(&DPI1_REG->OUTPUT_SETTING, AS_UINT32(&output));
615 OUTREG32(&DPI1_REG->CNTL, AS_UINT32(&ctrl));
616
617 return DPI_STATUS_OK;
618 }
619 EXPORT_SYMBOL(DPI1_ColorSpace_Enable);
620
621 DPI_STATUS DPI1_Config_Ctrl(BOOL fg3DFrame, BOOL fgInterlace)
622 {
623 DPI_REG_CNTL ctrl = DPI1_REG->CNTL;
624 ctrl.TDFP_EN = fg3DFrame;
625 ctrl.INTL_EN = fgInterlace;
626
627 OUTREG32(&DPI1_REG->CNTL, AS_UINT32(&ctrl));
628
629 return DPI_STATUS_OK;
630 }
631 EXPORT_SYMBOL(DPI1_Config_Ctrl);
632
633 DPI_STATUS DPI1_ConfigDataEnable(DPI_POLARITY polarity)
634 {
635
636 DPI_REG_OUTPUT_SETTING pol = DPI1_REG->OUTPUT_SETTING;
637 pol.DE_POL = (DPI_POLARITY_FALLING == polarity) ? 1 : 0;
638 OUTREG32(&DPI1_REG->OUTPUT_SETTING, AS_UINT32(&pol));
639
640 return DPI_STATUS_OK;
641 }
642 EXPORT_SYMBOL(DPI1_ConfigDataEnable);
643
644 DPI_STATUS DPI1_ConfigVsync(DPI_POLARITY polarity, UINT32 pulseWidth, UINT32 backPorch,
645 UINT32 frontPorch)
646 {
647 DPI_REG_TGEN_VWIDTH_LODD vwidth_lodd = DPI1_REG->TGEN_VWIDTH_LODD;
648 DPI_REG_TGEN_VPORCH_LODD vporch_lodd = DPI1_REG->TGEN_VPORCH_LODD;
649 DPI_REG_OUTPUT_SETTING pol = DPI1_REG->OUTPUT_SETTING;
650
651 pol.VSYNC_POL = (DPI_POLARITY_FALLING == polarity) ? 1 : 0;
652 vwidth_lodd.VPW_LODD = pulseWidth;
653 vporch_lodd.VBP_LODD= backPorch;
654 vporch_lodd.VFP_LODD= frontPorch;
655
656 OUTREG32(&DPI1_REG->OUTPUT_SETTING, AS_UINT32(&pol));
657 OUTREG32(&DPI1_REG->TGEN_VWIDTH_LODD, AS_UINT32(&vwidth_lodd));
658 OUTREG32(&DPI1_REG->TGEN_VPORCH_LODD, AS_UINT32(&vporch_lodd));
659
660 return DPI_STATUS_OK;
661 }
662 EXPORT_SYMBOL(DPI1_ConfigVsync);
663
664 DPI_STATUS DPI1_ConfigVsync_LEVEN(UINT32 pulseWidth, UINT32 backPorch, UINT32 frontPorch, BOOL fgInterlace)
665 {
666 DPI_REG_TGEN_VWIDTH_LEVEN vwidth_leven = DPI1_REG->TGEN_VWIDTH_LEVEN;
667 DPI_REG_TGEN_VPORCH_LEVEN vporch_leven = DPI1_REG->TGEN_VPORCH_LEVEN;
668
669 vwidth_leven.VPW_LEVEN = pulseWidth;
670 vwidth_leven.VPW_HALF_LEVEN = fgInterlace;
671 vporch_leven.VBP_LEVEN = backPorch;
672 //vporch_leven.VFP_HALF_LEVEN = fgInterlace;
673 vporch_leven.VFP_LEVEN = frontPorch;
674
675 OUTREG32(&DPI1_REG->TGEN_VWIDTH_LEVEN, AS_UINT32(&vwidth_leven));
676 OUTREG32(&DPI1_REG->TGEN_VPORCH_LEVEN, AS_UINT32(&vporch_leven));
677
678 return DPI_STATUS_OK;
679 }
680
681 EXPORT_SYMBOL(DPI1_ConfigVsync_LEVEN);
682
683 DPI_STATUS DPI1_ConfigVsync_RODD(UINT32 pulseWidth, UINT32 backPorch, UINT32 frontPorch)
684 {
685 DPI_REG_TGEN_VWIDTH_RODD vwidth_rodd = DPI1_REG->TGEN_VWIDTH_RODD;
686 DPI_REG_TGEN_VPORCH_RODD vporch_rodd = DPI1_REG->TGEN_VPORCH_RODD;
687
688 vwidth_rodd.VPW_RODD = pulseWidth;
689 vporch_rodd.VBP_RODD = backPorch;
690 vporch_rodd.VFP_RODD = frontPorch;
691
692 OUTREG32(&DPI1_REG->TGEN_VWIDTH_RODD, AS_UINT32(&vwidth_rodd));
693 OUTREG32(&DPI1_REG->TGEN_VPORCH_RODD, AS_UINT32(&vporch_rodd));
694
695 return DPI_STATUS_OK;
696 }
697
698 EXPORT_SYMBOL(DPI1_ConfigVsync_RODD);
699
700 DPI_STATUS DPI1_ConfigVsync_REVEN(UINT32 pulseWidth, UINT32 backPorch, UINT32 frontPorch, BOOL fgInterlace)
701 {
702 DPI_REG_TGEN_VWIDTH_REVEN vwidth_reven = DPI1_REG->TGEN_VWIDTH_REVEN;
703 DPI_REG_TGEN_VPORCH_REVEN vporch_reven = DPI1_REG->TGEN_VPORCH_REVEN;
704
705 vwidth_reven.VPW_REVEN = pulseWidth;
706 vwidth_reven.VPW_HALF_REVEN = fgInterlace;
707 vporch_reven.VBP_REVEN = backPorch;
708 //vporch_reven.VFP_HALF_REVEN = fgInterlace;
709 vporch_reven.VFP_REVEN = frontPorch;
710
711 OUTREG32(&DPI1_REG->TGEN_VWIDTH_REVEN, AS_UINT32(&vwidth_reven));
712 OUTREG32(&DPI1_REG->TGEN_VPORCH_REVEN, AS_UINT32(&vporch_reven));
713
714 return DPI_STATUS_OK;
715 }
716 EXPORT_SYMBOL(DPI1_ConfigVsync_REVEN);
717
718 DPI_STATUS DPI1_SW_Reset(UINT32 Reset)
719 {
720 OUTREG32(&DPI1_REG->DPI_RST, Reset);
721
722 return DPI_STATUS_OK;
723 }
724 EXPORT_SYMBOL(DPI1_SW_Reset);
725
726 DPI_STATUS DPI1_ConfigHsync(DPI_POLARITY polarity, UINT32 pulseWidth, UINT32 backPorch,
727 UINT32 frontPorch)
728 {
729 DPI_REG_TGEN_HPORCH hporch = DPI1_REG->TGEN_HPORCH;
730 DPI_REG_OUTPUT_SETTING pol = DPI1_REG->OUTPUT_SETTING;
731
732 pol.HSYNC_POL = (DPI_POLARITY_FALLING == polarity) ? 1 : 0;
733 //DPI1_REG->TGEN_HWIDTH = pulseWidth;
734 OUTREG32(&DPI1_REG->TGEN_HWIDTH,pulseWidth);
735 hporch.HBP = backPorch;
736 hporch.HFP = frontPorch;
737
738 OUTREG32(&DPI1_REG->OUTPUT_SETTING, AS_UINT32(&pol));
739 OUTREG32(&DPI1_REG->TGEN_HPORCH, AS_UINT32(&hporch));
740
741 return DPI_STATUS_OK;
742 }
743 EXPORT_SYMBOL(DPI1_ConfigHsync);
744
745 DPI_STATUS DPI1_FBEnable(DPI_FB_ID id, BOOL enable)
746 {
747 return DPI_STATUS_OK;
748 }
749 EXPORT_SYMBOL(DPI1_FBEnable);
750
751 DPI_STATUS DPI1_FBSyncFlipWithLCD(BOOL enable)
752 {
753 return DPI_STATUS_OK;
754 }
755 EXPORT_SYMBOL(DPI1_FBSyncFlipWithLCD);
756
757 DPI_STATUS DPI1_SetDSIMode(BOOL enable)
758 {
759 return DPI_STATUS_OK;
760 }
761
762
763 BOOL DPI1_IsDSIMode(void)
764 {
765 // return DPI1_REG->CNTL.DSI_MODE ? TRUE : FALSE;
766 return FALSE;
767 }
768
769
770 DPI_STATUS DPI1_FBSetFormat(DPI_FB_FORMAT format)
771 {
772 return DPI_STATUS_OK;
773 }
774 EXPORT_SYMBOL(DPI1_FBSetFormat);
775
776 DPI_FB_FORMAT DPI1_FBGetFormat(void)
777 {
778 return 0;
779 }
780 EXPORT_SYMBOL(DPI1_FBGetFormat);
781
782
783 DPI_STATUS DPI1_FBSetSize(UINT32 width, UINT32 height)
784 {
785 DPI_REG_SIZE size;
786 size.WIDTH = width;
787 size.HEIGHT = height;
788
789 OUTREG32(&DPI1_REG->SIZE, AS_UINT32(&size));
790
791 return DPI_STATUS_OK;
792 }
793 EXPORT_SYMBOL(DPI1_FBSetSize);
794
795 DPI_STATUS DPI1_FBSetAddress(DPI_FB_ID id, UINT32 address)
796 {
797 return DPI_STATUS_OK;
798 }
799 EXPORT_SYMBOL(DPI1_FBSetAddress);
800
801 DPI_STATUS DPI1_FBSetPitch(DPI_FB_ID id, UINT32 pitchInByte)
802 {
803 return DPI_STATUS_OK;
804 }
805 EXPORT_SYMBOL(DPI1_FBSetPitch);
806
807 DPI_STATUS DPI1_SetFifoThreshold(UINT32 low, UINT32 high)
808 {
809 return DPI_STATUS_OK;
810 }
811 EXPORT_SYMBOL(DPI1_SetFifoThreshold);
812
813
814 DPI_STATUS DPI1_DumpRegisters(void)
815 {
816 UINT32 i;
817
818 DISP_LOG_PRINT(ANDROID_LOG_WARN, "DPI1", "---------- Start dump DPI1 registers ----------\n");
819
820 for (i = 0; i < sizeof(DPI_REGS); i += 4)
821 {
822 DISP_LOG_PRINT(ANDROID_LOG_WARN, "DPI1", "DPI1+%04x : 0x%08x\n", i, INREG32(DPI1_BASE + i));
823 }
824
825 return DPI_STATUS_OK;
826 }
827
828 EXPORT_SYMBOL(DPI1_DumpRegisters);
829
830 UINT32 DPI1_GetCurrentFB(void)
831 {
832 return 0;
833 }
834 EXPORT_SYMBOL(DPI1_GetCurrentFB);
835
836 DPI_STATUS DPI1_Capture_Framebuffer(unsigned int pvbuf, unsigned int bpp)
837 {
838 #if 0
839 unsigned int i = 0;
840 unsigned char *fbv;
841 unsigned int fbsize = 0;
842 unsigned int dpi_fb_bpp = 0;
843 unsigned int w,h;
844 BOOL dpi_needPowerOff = FALSE;
845 if(!s_isDpiPowerOn){
846 DPI1_PowerOn();
847 dpi_needPowerOff = TRUE;
848 LCD_WaitForNotBusy();
849 LCD_WaitDPIIndication(FALSE);
850 LCD_FBReset();
851 LCD_StartTransfer(TRUE);
852 LCD_WaitDPIIndication(TRUE);
853 }
854
855 if(pvbuf == 0 || bpp == 0)
856 {
857 DISP_LOG_PRINT(ANDROID_LOG_ERROR, "DPI", "DPI1_Capture_Framebuffer, ERROR, parameters wrong: pvbuf=0x%08x, bpp=%d\n", pvbuf, bpp);
858 return DPI_STATUS_OK;
859 }
860
861 if(DPI1_FBGetFormat() == DPI_FB_FORMAT_RGB565)
862 {
863 dpi_fb_bpp = 16;
864 }
865 else if(DPI1_FBGetFormat() == DPI_FB_FORMAT_RGB888)
866 {
867 dpi_fb_bpp = 24;
868 }
869 else
870 {
871 DISP_LOG_PRINT(ANDROID_LOG_ERROR, "DPI", "DPI1_Capture_Framebuffer, ERROR, dpi_fb_bpp is wrong: %d\n", dpi_fb_bpp);
872 return DPI_STATUS_OK;
873 }
874
875 w = DISP_GetScreenWidth();
876 h = DISP_GetScreenHeight();
877 fbsize = w*h*dpi_fb_bpp/8;
878 if(dpi_needPowerOff)
879 fbv = (unsigned char*)ioremap_cached((unsigned int)DPI1_REG->FB[0].ADDR, fbsize);
880 else
881 fbv = (unsigned char*)ioremap_cached((unsigned int)DPI1_REG->FB[DPI1_GetCurrentFB()].ADDR, fbsize);
882
883 DISP_LOG_PRINT(ANDROID_LOG_INFO, "DPI", "current fb count is %d\n", DPI1_GetCurrentFB());
884
885 if(bpp == 32 && dpi_fb_bpp == 24)
886 {
887 if(0 == strncmp(CONFIG_MTK_LCM_PHYSICAL_ROTATION, "180", 3)){
888 unsigned int pix_count = w * h - 1;
889 for(i = 0;i < w*h; i++)
890 {
891 *(unsigned int*)(pvbuf+ (pix_count - i) * 4) = 0xff000000|fbv[i*3]|(fbv[i*3+1]<<8)|(fbv[i*3+2]<<16);
892 }
893 }
894 else{
895 for(i = 0;i < w*h; i++)
896 {
897 *(unsigned int*)(pvbuf+i*4) = 0xff000000|fbv[i*3]|(fbv[i*3+1]<<8)|(fbv[i*3+2]<<16);
898 }
899 }
900 }
901 else if(bpp == 32 && dpi_fb_bpp == 16)
902 {
903 unsigned int t;
904 unsigned short* fbvt = (unsigned short*)fbv;
905
906 if(0 == strncmp(CONFIG_MTK_LCM_PHYSICAL_ROTATION, "180", 3)){
907 unsigned int pix_count = w * h - 1;
908
909 for(i = 0;i < w*h; i++)
910 {
911 t = fbvt[i];
912 *(unsigned int*)(pvbuf+ (pix_count - i) * 4) = 0xff000000|((t&0x001F)<<3)|((t&0x07E0)<<5)|((t&0xF800)<<8);
913 }
914 }
915 else{
916 for(i = 0;i < w*h; i++)
917 {
918 t = fbvt[i];
919 *(unsigned int*)(pvbuf+i*4) = 0xff000000|((t&0x001F)<<3)|((t&0x07E0)<<5)|((t&0xF800)<<8);
920 }
921 }
922 }
923 else if(bpp == 16 && dpi_fb_bpp == 16)
924 {
925 if(0 == strncmp(CONFIG_MTK_LCM_PHYSICAL_ROTATION, "180", 3)){
926 unsigned int pix_count = w * h - 1;
927 unsigned short* fbvt = (unsigned short*)fbv;
928 for(i = 0;i < w*h; i++)
929 {
930 *(unsigned short*)(pvbuf+ (pix_count - i) * 2) = fbvt[i];
931 }
932 }
933 else
934 memcpy((void*)pvbuf, (void*)fbv, fbsize);
935 }
936 else if(bpp == 16 && dpi_fb_bpp == 24)
937 {
938 if(0 == strncmp(CONFIG_MTK_LCM_PHYSICAL_ROTATION, "180", 3)){
939 unsigned int pix_count = w * h - 1;
940 for(i = 0;i < w*h; i++)
941 {
942 *(unsigned short*)(pvbuf+ (pix_count - i) * 2) = ((fbv[i*3+0]&0xF8)>>3)|
943 ((fbv[i*3+1]&0xFC)<<3)|
944 ((fbv[i*3+2]&0xF8)<<8);
945 }
946 }
947 else{
948 for(i = 0;i < w*h; i++)
949 {
950 *(unsigned short*)(pvbuf+i*2) = ((fbv[i*3+0]&0xF8)>>3)|
951 ((fbv[i*3+1]&0xFC)<<3)|
952 ((fbv[i*3+2]&0xF8)<<8);
953 }
954 }
955 }
956 else
957 {
958 DISP_LOG_PRINT(ANDROID_LOG_ERROR, "DPI", "DPI1_Capture_Framebuffer, bpp:%d & dpi_fb_bpp:%d is not supported now\n", bpp, dpi_fb_bpp);
959 }
960
961 iounmap(fbv);
962
963 if(dpi_needPowerOff){
964 DPI1_PowerOff();
965 }
966 #endif
967
968 return DPI_STATUS_OK;
969 }
970
971 DPI_STATUS DPI1_EnableInterrupt(DISP_INTERRUPT_EVENTS eventID)
972 {
973 #if ENABLE_DPI1_INTERRUPT
974 switch(eventID)
975 {
976 case DISP_DPI_VSYNC_INT:
977 //DPI1_REG->INT_ENABLE.VSYNC = 1;
978 OUTREGBIT(DPI_REG_INTERRUPT,DPI1_REG->INT_ENABLE,VSYNC,1);
979 break;
980 default:
981 return DPI_STATUS_ERROR;
982 }
983
984 return DPI_STATUS_OK;
985 #else
986 ///TODO: warning log here
987 return DPI_STATUS_ERROR;
988 #endif
989 }
990
991
992 DPI_STATUS DPI1_SetInterruptCallback(void (*pCB)(DISP_INTERRUPT_EVENTS))
993 {
994 dpiIntCallback = pCB;
995
996 return DPI_STATUS_OK;
997 }
998
999
1000 DPI_STATUS DPI1_FMDesense_Query(void)
1001 {
1002 return DPI_STATUS_ERROR;
1003 }
1004
1005 DPI_STATUS DPI1_FM_Desense(unsigned long freq)
1006 {
1007 return DPI_STATUS_OK;
1008 }
1009
1010 DPI_STATUS DPI1_Reset_CLK(void)
1011 {
1012 return DPI_STATUS_OK;
1013 }
1014
1015 DPI_STATUS DPI1_Get_Default_CLK(unsigned int *clk)
1016 {
1017 return DPI_STATUS_OK;
1018 }
1019
1020 DPI_STATUS DPI1_Get_Current_CLK(unsigned int *clk)
1021 {
1022 return DPI_STATUS_OK;
1023 }
1024
1025 DPI_STATUS DPI1_Change_CLK(unsigned int clk)
1026 {
1027 return DPI_STATUS_OK;
1028 }
1029
1030 DPI_STATUS DPI1_EnableColorBar(void)
1031 {
1032 /*
1033 DPI_REG_PATTERN pattern = DPI1_REG->PATTERN;
1034
1035 pattern.PAT_EN = 1;
1036 pattern.PAT_SEL = 4; // Color Bar
1037
1038 OUTREG32(&DPI1_REG->PATTERN, AS_UINT32(&pattern));
1039 */
1040 OUTREG32(DPI1_BASE+0xf00, 0x41);
1041
1042
1043 return DPI_STATUS_OK;
1044 }
1045 EXPORT_SYMBOL(DPI1_EnableColorBar);
1046
1047 DPI_STATUS DPI1_EnableBlackScreen(void)
1048 {
1049
1050 /*
1051 DPI_REG_PATTERN pattern = DPI1_REG->PATTERN;
1052
1053 pattern.PAT_EN = 1;
1054 pattern.PAT_SEL = 5; // User defined color
1055 pattern.PAT_R_MAN = 0;
1056 pattern.PAT_G_MAN = 0;
1057 pattern.PAT_B_MAN = 0;
1058
1059 OUTREG32(&DPI1_REG->PATTERN, AS_UINT32(&pattern));
1060 */
1061 return DPI_STATUS_OK;
1062 }
1063 EXPORT_SYMBOL(DPI1_EnableBlackScreen);
1064
1065 DPI_STATUS DPI1_DisableInternalPattern(void)
1066 {
1067 /*
1068 DPI_REG_PATTERN pattern = DPI1_REG->PATTERN;
1069
1070 pattern.PAT_EN = 0;
1071
1072 OUTREG32(&DPI1_REG->PATTERN, AS_UINT32(&pattern));
1073 */
1074 return DPI_STATUS_OK;
1075 }
1076 EXPORT_SYMBOL(DPI1_DisableInternalPattern);
1077
1078 DPI_STATUS DPI1_MatrixCoef(UINT16 c00, UINT16 c01, UINT16 c02,
1079 UINT16 c10, UINT16 c11, UINT16 c12,
1080 UINT16 c20, UINT16 c21, UINT16 c22)
1081 {
1082
1083 /*
1084 DPI_REG_MATRIX_COEFF_SET0 set0 = DPI1_REG->MATRIX_COEFF_SET0;
1085 DPI_REG_MATRIX_COEFF_SET1 set1 = DPI1_REG->MATRIX_COEFF_SET1;
1086 DPI_REG_MATRIX_COEFF_SET2 set2 = DPI1_REG->MATRIX_COEFF_SET2;
1087 DPI_REG_MATRIX_COEFF_SET3 set3 = DPI1_REG->MATRIX_COEFF_SET3;
1088 DPI_REG_MATRIX_COEFF_SET4 set4 = DPI1_REG->MATRIX_COEFF_SET4;
1089
1090 set0.MATRIX_C00 = c00; set0.MATRIX_C01 = c01;
1091 set1.MATRIX_C02 = c02; set1.MATRIX_C10 = c10;
1092 set2.MATRIX_C11 = c11; set2.MATRIX_C12 = c12;
1093 set3.MATRIX_C20 = c20; set3.MATRIX_C21 = c21;
1094 set4.MATRIX_C22 = c22;
1095
1096 OUTREG32(&DPI1_REG->MATRIX_COEFF_SET0, AS_UINT32(&set0));
1097 OUTREG32(&DPI1_REG->MATRIX_COEFF_SET1, AS_UINT32(&set1));
1098 OUTREG32(&DPI1_REG->MATRIX_COEFF_SET2, AS_UINT32(&set2));
1099 OUTREG32(&DPI1_REG->MATRIX_COEFF_SET3, AS_UINT32(&set3));
1100 OUTREG32(&DPI1_REG->MATRIX_COEFF_SET4, AS_UINT32(&set4));
1101 */
1102 return DPI_STATUS_OK;
1103 }
1104 EXPORT_SYMBOL(DPI1_MatrixCoef);
1105
1106 DPI_STATUS DPI1_MatrixPreOffset(UINT16 preAdd0, UINT16 preAdd1, UINT16 preAdd2)
1107 {
1108 /*
1109 DPI_REG_MATRIX_PREADD_SET0 set0 = DPI1_REG->MATRIX_PREADD_SET0;
1110 DPI_REG_MATRIX_PREADD_SET1 set1 = DPI1_REG->MATRIX_PREADD_SET1;
1111
1112 set0.MATRIX_PRE_ADD_0 = preAdd0; set0.MATRIX_PRE_ADD_1 = preAdd1;
1113 set1.MATRIX_PRE_ADD_2 = preAdd2;
1114
1115 OUTREG32(&DPI1_REG->MATRIX_PREADD_SET0, AS_UINT32(&set0));
1116 OUTREG32(&DPI1_REG->MATRIX_PREADD_SET1, AS_UINT32(&set1));
1117 */
1118 return DPI_STATUS_OK;
1119 }
1120 EXPORT_SYMBOL(DPI1_MatrixPreOffset);
1121
1122 DPI_STATUS DPI1_MatrixPostOffset(UINT16 postAdd0, UINT16 postAdd1, UINT16 postAdd2)
1123 {
1124 /*
1125 DPI_REG_MATRIX_POSTADD_SET0 set0 = DPI1_REG->MATRIX_POSTADD_SET0;
1126 DPI_REG_MATRIX_POSTADD_SET1 set1 = DPI1_REG->MATRIX_POSTADD_SET1;
1127
1128 set0.MATRIX_POST_ADD_0 = postAdd0; set0.MATRIX_POST_ADD_1 = postAdd1;
1129 set1.MATRIX_POST_ADD_2 = postAdd2;
1130
1131 OUTREG32(&DPI1_REG->MATRIX_POSTADD_SET0, AS_UINT32(&set0));
1132 OUTREG32(&DPI1_REG->MATRIX_POSTADD_SET1, AS_UINT32(&set1));
1133 */
1134 return DPI_STATUS_OK;
1135 }
1136 EXPORT_SYMBOL(DPI1_MatrixPostOffset);
1137
1138 DPI_STATUS DPI1_SetChannelLimit(UINT16 yBottom, UINT16 yTop, UINT16 cBottom, UINT16 cTop)
1139 {
1140 DPI_REG_Y_LIMIT y = DPI1_REG->Y_LIMIT;
1141 DPI_REG_C_LIMIT c = DPI1_REG->C_LIMIT;
1142
1143 y.Y_LIMIT_BOT = yBottom;
1144 y.Y_LIMIT_TOP = yTop;
1145 c.C_LIMIT_BOT = cBottom;
1146 c.C_LIMIT_TOP = cTop;
1147
1148 OUTREG32(&DPI1_REG->Y_LIMIT, AS_UINT32(&y));
1149 OUTREG32(&DPI1_REG->C_LIMIT, AS_UINT32(&c));
1150
1151 return DPI_STATUS_OK;
1152 }
1153 EXPORT_SYMBOL(DPI1_SetChannelLimit);
1154
1155 DPI_STATUS DPI1_CLPFSetting(UINT8 clpfType, BOOL roundingEnable)
1156 {
1157 DPI_REG_CLPF_SETTING setting = DPI1_REG->CLPF_SETTING;
1158
1159 setting.CLPF_TYPE = clpfType;
1160 setting.ROUND_EN = roundingEnable ? 1 : 0;
1161
1162 OUTREG32(&DPI1_REG->CLPF_SETTING, AS_UINT32(&setting));
1163
1164 return DPI_STATUS_OK;
1165 }
1166 EXPORT_SYMBOL(DPI1_CLPFSetting);
1167
1168 DPI_STATUS DPI1_EmbeddedSyncSetting(BOOL embSync_R_Cr, BOOL embSync_G_Y, BOOL embSync_B_Cb,
1169 BOOL esavFInv, BOOL esavVInv, BOOL esavHInv,
1170 BOOL esavCodeMan)
1171 {
1172 DPI_REG_EMBSYNC_SETTING setting = DPI1_REG->EMBSYNC_SETTING;
1173
1174 setting.EMBVSYNC_R_CR = embSync_R_Cr ? 1 : 0;
1175 setting.EMBVSYNC_G_Y = embSync_G_Y ? 1 : 0;
1176 setting.EMBVSYNC_B_CB = embSync_B_Cb ? 1 : 0;
1177 setting.ESAV_F_INV = esavFInv ? 1 : 0;
1178 setting.ESAV_V_INV = esavVInv ? 1 : 0;
1179 setting.ESAV_H_INV = esavHInv ? 1 : 0;
1180 setting.ESAV_CODE_MAN = esavCodeMan ? 1 : 0;
1181
1182 OUTREG32(&DPI1_REG->EMBSYNC_SETTING, AS_UINT32(&setting));
1183
1184 return DPI_STATUS_OK;
1185 }
1186 EXPORT_SYMBOL(DPI1_EmbeddedSyncSetting);
1187
1188 DPI_STATUS DPI1_OutputSetting(DPI_OUTPUT_BIT_NUM outBitNum, BOOL outBitSwap, DPI_OUTPUT_CHANNEL_SWAP outChSwap, DPI_OUTPUT_YC_MAP outYCMap)
1189 {
1190 DPI_REG_OUTPUT_SETTING setting = DPI1_REG->OUTPUT_SETTING;
1191
1192 setting.OUT_BIT = outBitNum;
1193 setting.BIT_SWAP = outBitSwap ? 1 : 0;
1194 setting.CH_SWAP = outChSwap;
1195 setting.YC_MAP = outYCMap;
1196
1197 OUTREG32(&DPI1_REG->OUTPUT_SETTING, AS_UINT32(&setting));
1198
1199 return DPI_STATUS_OK;
1200 }
1201 EXPORT_SYMBOL(DPI1_OutputSetting);
1202
1203 DPI_STATUS DPI1_ESAVVTimingControlLeft(UINT16 offsetOdd, UINT16 widthOdd, UINT16 offsetEven, UINT16 widthEven)
1204 {
1205 DPI_REG_ESAV_VTIM_LODD setting1 = DPI1_REG->ESAV_VTIM_LODD;
1206 DPI_REG_ESAV_VTIM_LEVEN setting2 = DPI1_REG->ESAV_VTIM_LEVEN;
1207
1208 setting1.ESAV_VOFST_LODD = offsetOdd;
1209 setting1.ESAV_VWID_LODD = widthOdd;
1210 setting2.ESAV_VOFST_LEVEN = offsetEven;
1211 setting2.ESAV_VWID_LEVEN = widthEven;
1212
1213
1214 OUTREG32(&DPI1_REG->ESAV_VTIM_LODD, AS_UINT32(&setting1));
1215 OUTREG32(&DPI1_REG->ESAV_VTIM_LEVEN, AS_UINT32(&setting2));
1216 return DPI_STATUS_OK;
1217 }
1218 EXPORT_SYMBOL(DPI1_ESAVVTimingControlLeft);
1219
1220 DPI_STATUS DPI1_ESAVVTimingControlRight(UINT16 offsetOdd, UINT16 widthOdd, UINT16 offsetEven, UINT16 widthEven)
1221 {
1222 DPI_REG_ESAV_VTIM_RODD setting1 = DPI1_REG->ESAV_VTIM_RODD;
1223 DPI_REG_ESAV_VTIM_REVEN setting2 = DPI1_REG->ESAV_VTIM_REVEN;
1224
1225 setting1.ESAV_VOFST_RODD = offsetOdd;
1226 setting1.ESAV_VWID_RODD = widthOdd;
1227 setting2.ESAV_VOFST_REVEN = offsetEven;
1228 setting2.ESAV_VWID_REVEN = widthEven;
1229
1230 OUTREG32(&DPI1_REG->ESAV_VTIM_RODD, AS_UINT32(&setting1));
1231 OUTREG32(&DPI1_REG->ESAV_VTIM_REVEN, AS_UINT32(&setting2));
1232
1233 return DPI_STATUS_OK;
1234 }
1235 EXPORT_SYMBOL(DPI1_ESAVVTimingControlRight);
1236
1237
1238 DPI_STATUS DPI1_Config_ColorSpace(UINT8 ColorSpace, UINT8 HDMI_Res)
1239 {
1240 UINT8 i=0;
1241 DPI_REG_CNTL ctrl = DPI1_REG->CNTL;
1242
1243 printk("[DPI1] DPI1_Config_ColorSpace: ColorSpace[%d] / HDMI Resolution[%d] \n", ColorSpace, HDMI_Res);
1244
1245 if((HDMI_Res == 0) || (HDMI_Res == 1)) //SD
1246 {
1247 i = 1;
1248 }
1249 else //HD
1250 {
1251 i = 0;
1252 }
1253
1254 //DPI1_MatrixCoef(dpi1_coef[i][0][0], dpi1_coef[i][0][1], dpi1_coef[i][0][2],
1255 // dpi1_coef[i][1][0], dpi1_coef[i][1][1], dpi1_coef[i][1][2],
1256 // dpi1_coef[i][2][0], dpi1_coef[i][2][1], dpi1_coef[i][2][2]);
1257 //DPI1_MatrixPreOffset(dpi1_coef[i][3][0], dpi1_coef[i][3][1], dpi1_coef[i][3][2]);
1258 //DPI1_MatrixPostOffset(dpi1_coef[i][4][1], dpi1_coef[i][4][0], dpi1_coef[i][4][2]);
1259
1260 ctrl.R601_SEL = i ;
1261 if((YCBCR_444 == ColorSpace) || (YCBCR_444_FULL == ColorSpace)) //YUV444
1262 {
1263 ctrl.YUV422_EN = 0;
1264 ctrl.RGB2YUV_EN= 1;
1265 }
1266 else if((YCBCR_422 == ColorSpace) || (YCBCR_422_FULL == ColorSpace)) //YUV422
1267 {
1268 ctrl.YUV422_EN = 1;
1269 ctrl.RGB2YUV_EN= 1;
1270 }
1271 else //RGB
1272 {
1273 ctrl.YUV422_EN = 0;
1274 ctrl.RGB2YUV_EN= 0;
1275 ctrl.R601_SEL = 0;
1276 }
1277 OUTREG32(&DPI1_REG->CNTL, AS_UINT32(&ctrl));
1278
1279 //DPI1_ColorSpace_Enable(ColorSpace);
1280
1281 return DPI_STATUS_OK;
1282 }
1283
1284 EXPORT_SYMBOL(DPI1_Config_ColorSpace);
1285
1286 BOOL DPI1_IS_TOP_FIELD(void)
1287 {
1288 if(DPI1_REG->STATUS.FIELD == 0)
1289 return TRUE;
1290 else
1291 return FALSE;
1292
1293 }
1294 EXPORT_SYMBOL(DPI1_IS_TOP_FIELD);
1295
1296
kernel source for telekom puls (alcatel/mediatek)