2 * linux/drivers/video/omap2/dss/rfbi.c
4 * Copyright (C) 2009 Nokia Corporation
5 * Author: Tomi Valkeinen <tomi.valkeinen@nokia.com>
7 * Some code and ideas taken from drivers/video/omap/ driver
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License version 2 as published by
12 * the Free Software Foundation.
14 * This program is distributed in the hope that it will be useful, but WITHOUT
15 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
19 * You should have received a copy of the GNU General Public License along with
20 * this program. If not, see <http://www.gnu.org/licenses/>.
23 #define DSS_SUBSYS_NAME "RFBI"
25 #include <linux/kernel.h>
26 #include <linux/dma-mapping.h>
27 #include <linux/vmalloc.h>
28 #include <linux/clk.h>
30 #include <linux/delay.h>
31 #include <linux/kfifo.h>
32 #include <linux/ktime.h>
33 #include <linux/hrtimer.h>
34 #include <linux/seq_file.h>
35 #include <linux/semaphore.h>
36 #include <linux/platform_device.h>
38 #include <video/omapdss.h>
41 struct rfbi_reg
{ u16 idx
; };
43 #define RFBI_REG(idx) ((const struct rfbi_reg) { idx })
45 #define RFBI_REVISION RFBI_REG(0x0000)
46 #define RFBI_SYSCONFIG RFBI_REG(0x0010)
47 #define RFBI_SYSSTATUS RFBI_REG(0x0014)
48 #define RFBI_CONTROL RFBI_REG(0x0040)
49 #define RFBI_PIXEL_CNT RFBI_REG(0x0044)
50 #define RFBI_LINE_NUMBER RFBI_REG(0x0048)
51 #define RFBI_CMD RFBI_REG(0x004c)
52 #define RFBI_PARAM RFBI_REG(0x0050)
53 #define RFBI_DATA RFBI_REG(0x0054)
54 #define RFBI_READ RFBI_REG(0x0058)
55 #define RFBI_STATUS RFBI_REG(0x005c)
57 #define RFBI_CONFIG(n) RFBI_REG(0x0060 + (n)*0x18)
58 #define RFBI_ONOFF_TIME(n) RFBI_REG(0x0064 + (n)*0x18)
59 #define RFBI_CYCLE_TIME(n) RFBI_REG(0x0068 + (n)*0x18)
60 #define RFBI_DATA_CYCLE1(n) RFBI_REG(0x006c + (n)*0x18)
61 #define RFBI_DATA_CYCLE2(n) RFBI_REG(0x0070 + (n)*0x18)
62 #define RFBI_DATA_CYCLE3(n) RFBI_REG(0x0074 + (n)*0x18)
64 #define RFBI_VSYNC_WIDTH RFBI_REG(0x0090)
65 #define RFBI_HSYNC_WIDTH RFBI_REG(0x0094)
67 #define REG_FLD_MOD(idx, val, start, end) \
68 rfbi_write_reg(idx, FLD_MOD(rfbi_read_reg(idx), val, start, end))
70 enum omap_rfbi_cycleformat
{
71 OMAP_DSS_RFBI_CYCLEFORMAT_1_1
= 0,
72 OMAP_DSS_RFBI_CYCLEFORMAT_2_1
= 1,
73 OMAP_DSS_RFBI_CYCLEFORMAT_3_1
= 2,
74 OMAP_DSS_RFBI_CYCLEFORMAT_3_2
= 3,
77 enum omap_rfbi_datatype
{
78 OMAP_DSS_RFBI_DATATYPE_12
= 0,
79 OMAP_DSS_RFBI_DATATYPE_16
= 1,
80 OMAP_DSS_RFBI_DATATYPE_18
= 2,
81 OMAP_DSS_RFBI_DATATYPE_24
= 3,
84 enum omap_rfbi_parallelmode
{
85 OMAP_DSS_RFBI_PARALLELMODE_8
= 0,
86 OMAP_DSS_RFBI_PARALLELMODE_9
= 1,
87 OMAP_DSS_RFBI_PARALLELMODE_12
= 2,
88 OMAP_DSS_RFBI_PARALLELMODE_16
= 3,
91 static int rfbi_convert_timings(struct rfbi_timings
*t
);
92 static void rfbi_get_clk_info(u32
*clk_period
, u32
*max_clk_div
);
95 struct platform_device
*pdev
;
100 enum omap_rfbi_datatype datatype
;
101 enum omap_rfbi_parallelmode parallelmode
;
103 enum omap_rfbi_te_mode te_mode
;
106 void (*framedone_callback
)(void *data
);
107 void *framedone_callback_data
;
109 struct omap_dss_device
*dssdev
[2];
111 struct semaphore bus_lock
;
114 static inline void rfbi_write_reg(const struct rfbi_reg idx
, u32 val
)
116 __raw_writel(val
, rfbi
.base
+ idx
.idx
);
119 static inline u32
rfbi_read_reg(const struct rfbi_reg idx
)
121 return __raw_readl(rfbi
.base
+ idx
.idx
);
124 static void rfbi_enable_clocks(bool enable
)
127 dss_clk_enable(DSS_CLK_ICK
| DSS_CLK_FCK
);
129 dss_clk_disable(DSS_CLK_ICK
| DSS_CLK_FCK
);
132 void rfbi_bus_lock(void)
134 down(&rfbi
.bus_lock
);
136 EXPORT_SYMBOL(rfbi_bus_lock
);
138 void rfbi_bus_unlock(void)
142 EXPORT_SYMBOL(rfbi_bus_unlock
);
144 void omap_rfbi_write_command(const void *buf
, u32 len
)
146 switch (rfbi
.parallelmode
) {
147 case OMAP_DSS_RFBI_PARALLELMODE_8
:
151 rfbi_write_reg(RFBI_CMD
, *b
++);
155 case OMAP_DSS_RFBI_PARALLELMODE_16
:
159 for (; len
; len
-= 2)
160 rfbi_write_reg(RFBI_CMD
, *w
++);
164 case OMAP_DSS_RFBI_PARALLELMODE_9
:
165 case OMAP_DSS_RFBI_PARALLELMODE_12
:
170 EXPORT_SYMBOL(omap_rfbi_write_command
);
172 void omap_rfbi_read_data(void *buf
, u32 len
)
174 switch (rfbi
.parallelmode
) {
175 case OMAP_DSS_RFBI_PARALLELMODE_8
:
179 rfbi_write_reg(RFBI_READ
, 0);
180 *b
++ = rfbi_read_reg(RFBI_READ
);
185 case OMAP_DSS_RFBI_PARALLELMODE_16
:
189 for (; len
; len
-= 2) {
190 rfbi_write_reg(RFBI_READ
, 0);
191 *w
++ = rfbi_read_reg(RFBI_READ
);
196 case OMAP_DSS_RFBI_PARALLELMODE_9
:
197 case OMAP_DSS_RFBI_PARALLELMODE_12
:
202 EXPORT_SYMBOL(omap_rfbi_read_data
);
204 void omap_rfbi_write_data(const void *buf
, u32 len
)
206 switch (rfbi
.parallelmode
) {
207 case OMAP_DSS_RFBI_PARALLELMODE_8
:
211 rfbi_write_reg(RFBI_PARAM
, *b
++);
215 case OMAP_DSS_RFBI_PARALLELMODE_16
:
219 for (; len
; len
-= 2)
220 rfbi_write_reg(RFBI_PARAM
, *w
++);
224 case OMAP_DSS_RFBI_PARALLELMODE_9
:
225 case OMAP_DSS_RFBI_PARALLELMODE_12
:
231 EXPORT_SYMBOL(omap_rfbi_write_data
);
233 void omap_rfbi_write_pixels(const void __iomem
*buf
, int scr_width
,
237 int start_offset
= scr_width
* y
+ x
;
238 int horiz_offset
= scr_width
- w
;
241 if (rfbi
.datatype
== OMAP_DSS_RFBI_DATATYPE_16
&&
242 rfbi
.parallelmode
== OMAP_DSS_RFBI_PARALLELMODE_8
) {
243 const u16 __iomem
*pd
= buf
;
247 for (i
= 0; i
< w
; ++i
) {
248 const u8 __iomem
*b
= (const u8 __iomem
*)pd
;
249 rfbi_write_reg(RFBI_PARAM
, __raw_readb(b
+1));
250 rfbi_write_reg(RFBI_PARAM
, __raw_readb(b
+0));
255 } else if (rfbi
.datatype
== OMAP_DSS_RFBI_DATATYPE_24
&&
256 rfbi
.parallelmode
== OMAP_DSS_RFBI_PARALLELMODE_8
) {
257 const u32 __iomem
*pd
= buf
;
261 for (i
= 0; i
< w
; ++i
) {
262 const u8 __iomem
*b
= (const u8 __iomem
*)pd
;
263 rfbi_write_reg(RFBI_PARAM
, __raw_readb(b
+2));
264 rfbi_write_reg(RFBI_PARAM
, __raw_readb(b
+1));
265 rfbi_write_reg(RFBI_PARAM
, __raw_readb(b
+0));
270 } else if (rfbi
.datatype
== OMAP_DSS_RFBI_DATATYPE_16
&&
271 rfbi
.parallelmode
== OMAP_DSS_RFBI_PARALLELMODE_16
) {
272 const u16 __iomem
*pd
= buf
;
276 for (i
= 0; i
< w
; ++i
) {
277 rfbi_write_reg(RFBI_PARAM
, __raw_readw(pd
));
286 EXPORT_SYMBOL(omap_rfbi_write_pixels
);
288 static void rfbi_transfer_area(struct omap_dss_device
*dssdev
, u16 width
,
289 u16 height
, void (*callback
)(void *data
), void *data
)
293 /*BUG_ON(callback == 0);*/
294 BUG_ON(rfbi
.framedone_callback
!= NULL
);
296 DSSDBG("rfbi_transfer_area %dx%d\n", width
, height
);
298 dispc_set_lcd_size(dssdev
->manager
->id
, width
, height
);
300 dispc_enable_channel(dssdev
->manager
->id
, true);
302 rfbi
.framedone_callback
= callback
;
303 rfbi
.framedone_callback_data
= data
;
305 rfbi_write_reg(RFBI_PIXEL_CNT
, width
* height
);
307 l
= rfbi_read_reg(RFBI_CONTROL
);
308 l
= FLD_MOD(l
, 1, 0, 0); /* enable */
309 if (!rfbi
.te_enabled
)
310 l
= FLD_MOD(l
, 1, 4, 4); /* ITE */
312 rfbi_write_reg(RFBI_CONTROL
, l
);
315 static void framedone_callback(void *data
, u32 mask
)
317 void (*callback
)(void *data
);
319 DSSDBG("FRAMEDONE\n");
321 REG_FLD_MOD(RFBI_CONTROL
, 0, 0, 0);
323 callback
= rfbi
.framedone_callback
;
324 rfbi
.framedone_callback
= NULL
;
326 if (callback
!= NULL
)
327 callback(rfbi
.framedone_callback_data
);
331 static void rfbi_print_timings(void)
336 l
= rfbi_read_reg(RFBI_CONFIG(0));
337 time
= 1000000000 / rfbi
.l4_khz
;
341 DSSDBG("Tick time %u ps\n", time
);
342 l
= rfbi_read_reg(RFBI_ONOFF_TIME(0));
343 DSSDBG("CSONTIME %d, CSOFFTIME %d, WEONTIME %d, WEOFFTIME %d, "
344 "REONTIME %d, REOFFTIME %d\n",
345 l
& 0x0f, (l
>> 4) & 0x3f, (l
>> 10) & 0x0f, (l
>> 14) & 0x3f,
346 (l
>> 20) & 0x0f, (l
>> 24) & 0x3f);
348 l
= rfbi_read_reg(RFBI_CYCLE_TIME(0));
349 DSSDBG("WECYCLETIME %d, RECYCLETIME %d, CSPULSEWIDTH %d, "
351 (l
& 0x3f), (l
>> 6) & 0x3f, (l
>> 12) & 0x3f,
355 static void rfbi_print_timings(void) {}
361 static u32 extif_clk_period
;
363 static inline unsigned long round_to_extif_ticks(unsigned long ps
, int div
)
365 int bus_tick
= extif_clk_period
* div
;
366 return (ps
+ bus_tick
- 1) / bus_tick
* bus_tick
;
369 static int calc_reg_timing(struct rfbi_timings
*t
, int div
)
373 t
->cs_on_time
= round_to_extif_ticks(t
->cs_on_time
, div
);
375 t
->we_on_time
= round_to_extif_ticks(t
->we_on_time
, div
);
376 t
->we_off_time
= round_to_extif_ticks(t
->we_off_time
, div
);
377 t
->we_cycle_time
= round_to_extif_ticks(t
->we_cycle_time
, div
);
379 t
->re_on_time
= round_to_extif_ticks(t
->re_on_time
, div
);
380 t
->re_off_time
= round_to_extif_ticks(t
->re_off_time
, div
);
381 t
->re_cycle_time
= round_to_extif_ticks(t
->re_cycle_time
, div
);
383 t
->access_time
= round_to_extif_ticks(t
->access_time
, div
);
384 t
->cs_off_time
= round_to_extif_ticks(t
->cs_off_time
, div
);
385 t
->cs_pulse_width
= round_to_extif_ticks(t
->cs_pulse_width
, div
);
387 DSSDBG("[reg]cson %d csoff %d reon %d reoff %d\n",
388 t
->cs_on_time
, t
->cs_off_time
, t
->re_on_time
, t
->re_off_time
);
389 DSSDBG("[reg]weon %d weoff %d recyc %d wecyc %d\n",
390 t
->we_on_time
, t
->we_off_time
, t
->re_cycle_time
,
392 DSSDBG("[reg]rdaccess %d cspulse %d\n",
393 t
->access_time
, t
->cs_pulse_width
);
395 return rfbi_convert_timings(t
);
398 static int calc_extif_timings(struct rfbi_timings
*t
)
403 rfbi_get_clk_info(&extif_clk_period
, &max_clk_div
);
404 for (div
= 1; div
<= max_clk_div
; div
++) {
405 if (calc_reg_timing(t
, div
) == 0)
409 if (div
<= max_clk_div
)
412 DSSERR("can't setup timings\n");
417 static void rfbi_set_timings(int rfbi_module
, struct rfbi_timings
*t
)
422 r
= calc_extif_timings(t
);
424 DSSERR("Failed to calc timings\n");
427 BUG_ON(!t
->converted
);
429 rfbi_write_reg(RFBI_ONOFF_TIME(rfbi_module
), t
->tim
[0]);
430 rfbi_write_reg(RFBI_CYCLE_TIME(rfbi_module
), t
->tim
[1]);
432 /* TIMEGRANULARITY */
433 REG_FLD_MOD(RFBI_CONFIG(rfbi_module
),
434 (t
->tim
[2] ? 1 : 0), 4, 4);
436 rfbi_print_timings();
439 static int ps_to_rfbi_ticks(int time
, int div
)
441 unsigned long tick_ps
;
444 /* Calculate in picosecs to yield more exact results */
445 tick_ps
= 1000000000 / (rfbi
.l4_khz
) * div
;
447 ret
= (time
+ tick_ps
- 1) / tick_ps
;
452 static void rfbi_get_clk_info(u32
*clk_period
, u32
*max_clk_div
)
454 *clk_period
= 1000000000 / rfbi
.l4_khz
;
458 static int rfbi_convert_timings(struct rfbi_timings
*t
)
461 int reon
, reoff
, weon
, weoff
, cson
, csoff
, cs_pulse
;
462 int actim
, recyc
, wecyc
;
463 int div
= t
->clk_div
;
465 if (div
<= 0 || div
> 2)
468 /* Make sure that after conversion it still holds that:
469 * weoff > weon, reoff > reon, recyc >= reoff, wecyc >= weoff,
470 * csoff > cson, csoff >= max(weoff, reoff), actim > reon
472 weon
= ps_to_rfbi_ticks(t
->we_on_time
, div
);
473 weoff
= ps_to_rfbi_ticks(t
->we_off_time
, div
);
481 reon
= ps_to_rfbi_ticks(t
->re_on_time
, div
);
482 reoff
= ps_to_rfbi_ticks(t
->re_off_time
, div
);
490 cson
= ps_to_rfbi_ticks(t
->cs_on_time
, div
);
491 csoff
= ps_to_rfbi_ticks(t
->cs_off_time
, div
);
494 if (csoff
< max(weoff
, reoff
))
495 csoff
= max(weoff
, reoff
);
510 actim
= ps_to_rfbi_ticks(t
->access_time
, div
);
516 wecyc
= ps_to_rfbi_ticks(t
->we_cycle_time
, div
);
522 recyc
= ps_to_rfbi_ticks(t
->re_cycle_time
, div
);
528 cs_pulse
= ps_to_rfbi_ticks(t
->cs_pulse_width
, div
);
546 /* xxx FIX module selection missing */
547 int omap_rfbi_setup_te(enum omap_rfbi_te_mode mode
,
548 unsigned hs_pulse_time
, unsigned vs_pulse_time
,
549 int hs_pol_inv
, int vs_pol_inv
, int extif_div
)
555 hs
= ps_to_rfbi_ticks(hs_pulse_time
, 1);
556 vs
= ps_to_rfbi_ticks(vs_pulse_time
, 1);
559 if (mode
== OMAP_DSS_RFBI_TE_MODE_2
)
561 else /* OMAP_DSS_RFBI_TE_MODE_1 */
568 DSSDBG("setup_te: mode %d hs %d vs %d hs_inv %d vs_inv %d\n",
569 mode
, hs
, vs
, hs_pol_inv
, vs_pol_inv
);
571 rfbi_write_reg(RFBI_HSYNC_WIDTH
, hs
);
572 rfbi_write_reg(RFBI_VSYNC_WIDTH
, vs
);
574 l
= rfbi_read_reg(RFBI_CONFIG(0));
586 EXPORT_SYMBOL(omap_rfbi_setup_te
);
588 /* xxx FIX module selection missing */
589 int omap_rfbi_enable_te(bool enable
, unsigned line
)
593 DSSDBG("te %d line %d mode %d\n", enable
, line
, rfbi
.te_mode
);
594 if (line
> (1 << 11) - 1)
597 l
= rfbi_read_reg(RFBI_CONFIG(0));
601 l
|= rfbi
.te_mode
<< 2;
604 rfbi_write_reg(RFBI_CONFIG(0), l
);
605 rfbi_write_reg(RFBI_LINE_NUMBER
, line
);
609 EXPORT_SYMBOL(omap_rfbi_enable_te
);
611 static int rfbi_configure(int rfbi_module
, int bpp
, int lines
)
614 int cycle1
= 0, cycle2
= 0, cycle3
= 0;
615 enum omap_rfbi_cycleformat cycleformat
;
616 enum omap_rfbi_datatype datatype
;
617 enum omap_rfbi_parallelmode parallelmode
;
621 datatype
= OMAP_DSS_RFBI_DATATYPE_12
;
624 datatype
= OMAP_DSS_RFBI_DATATYPE_16
;
627 datatype
= OMAP_DSS_RFBI_DATATYPE_18
;
630 datatype
= OMAP_DSS_RFBI_DATATYPE_24
;
636 rfbi
.datatype
= datatype
;
640 parallelmode
= OMAP_DSS_RFBI_PARALLELMODE_8
;
643 parallelmode
= OMAP_DSS_RFBI_PARALLELMODE_9
;
646 parallelmode
= OMAP_DSS_RFBI_PARALLELMODE_12
;
649 parallelmode
= OMAP_DSS_RFBI_PARALLELMODE_16
;
655 rfbi
.parallelmode
= parallelmode
;
657 if ((bpp
% lines
) == 0) {
658 switch (bpp
/ lines
) {
660 cycleformat
= OMAP_DSS_RFBI_CYCLEFORMAT_1_1
;
663 cycleformat
= OMAP_DSS_RFBI_CYCLEFORMAT_2_1
;
666 cycleformat
= OMAP_DSS_RFBI_CYCLEFORMAT_3_1
;
672 } else if ((2 * bpp
% lines
) == 0) {
673 if ((2 * bpp
/ lines
) == 3)
674 cycleformat
= OMAP_DSS_RFBI_CYCLEFORMAT_3_2
;
684 switch (cycleformat
) {
685 case OMAP_DSS_RFBI_CYCLEFORMAT_1_1
:
689 case OMAP_DSS_RFBI_CYCLEFORMAT_2_1
:
694 case OMAP_DSS_RFBI_CYCLEFORMAT_3_1
:
700 case OMAP_DSS_RFBI_CYCLEFORMAT_3_2
:
702 cycle2
= (lines
/ 2) | ((lines
/ 2) << 16);
703 cycle3
= (lines
<< 16);
707 REG_FLD_MOD(RFBI_CONTROL
, 0, 3, 2); /* clear CS */
710 l
|= FLD_VAL(parallelmode
, 1, 0);
711 l
|= FLD_VAL(0, 3, 2); /* TRIGGERMODE: ITE */
712 l
|= FLD_VAL(0, 4, 4); /* TIMEGRANULARITY */
713 l
|= FLD_VAL(datatype
, 6, 5);
714 /* l |= FLD_VAL(2, 8, 7); */ /* L4FORMAT, 2pix/L4 */
715 l
|= FLD_VAL(0, 8, 7); /* L4FORMAT, 1pix/L4 */
716 l
|= FLD_VAL(cycleformat
, 10, 9);
717 l
|= FLD_VAL(0, 12, 11); /* UNUSEDBITS */
718 l
|= FLD_VAL(0, 16, 16); /* A0POLARITY */
719 l
|= FLD_VAL(0, 17, 17); /* REPOLARITY */
720 l
|= FLD_VAL(0, 18, 18); /* WEPOLARITY */
721 l
|= FLD_VAL(0, 19, 19); /* CSPOLARITY */
722 l
|= FLD_VAL(1, 20, 20); /* TE_VSYNC_POLARITY */
723 l
|= FLD_VAL(1, 21, 21); /* HSYNCPOLARITY */
724 rfbi_write_reg(RFBI_CONFIG(rfbi_module
), l
);
726 rfbi_write_reg(RFBI_DATA_CYCLE1(rfbi_module
), cycle1
);
727 rfbi_write_reg(RFBI_DATA_CYCLE2(rfbi_module
), cycle2
);
728 rfbi_write_reg(RFBI_DATA_CYCLE3(rfbi_module
), cycle3
);
731 l
= rfbi_read_reg(RFBI_CONTROL
);
732 l
= FLD_MOD(l
, rfbi_module
+1, 3, 2); /* Select CSx */
733 l
= FLD_MOD(l
, 0, 1, 1); /* clear bypass */
734 rfbi_write_reg(RFBI_CONTROL
, l
);
737 DSSDBG("RFBI config: bpp %d, lines %d, cycles: 0x%x 0x%x 0x%x\n",
738 bpp
, lines
, cycle1
, cycle2
, cycle3
);
743 int omap_rfbi_configure(struct omap_dss_device
*dssdev
, int pixel_size
,
746 return rfbi_configure(dssdev
->phy
.rfbi
.channel
, pixel_size
, data_lines
);
748 EXPORT_SYMBOL(omap_rfbi_configure
);
750 int omap_rfbi_prepare_update(struct omap_dss_device
*dssdev
,
751 u16
*x
, u16
*y
, u16
*w
, u16
*h
)
755 dssdev
->driver
->get_resolution(dssdev
, &dw
, &dh
);
757 if (*x
> dw
|| *y
> dh
)
769 if (*w
== 0 || *h
== 0)
772 if (dssdev
->manager
->caps
& OMAP_DSS_OVL_MGR_CAP_DISPC
) {
773 dss_setup_partial_planes(dssdev
, x
, y
, w
, h
, true);
774 dispc_set_lcd_size(dssdev
->manager
->id
, *w
, *h
);
779 EXPORT_SYMBOL(omap_rfbi_prepare_update
);
781 int omap_rfbi_update(struct omap_dss_device
*dssdev
,
782 u16 x
, u16 y
, u16 w
, u16 h
,
783 void (*callback
)(void *), void *data
)
785 if (dssdev
->manager
->caps
& OMAP_DSS_OVL_MGR_CAP_DISPC
) {
786 rfbi_transfer_area(dssdev
, w
, h
, callback
, data
);
788 struct omap_overlay
*ovl
;
792 ovl
= dssdev
->manager
->overlays
[0];
793 scr_width
= ovl
->info
.screen_width
;
794 addr
= ovl
->info
.vaddr
;
796 omap_rfbi_write_pixels(addr
, scr_width
, x
, y
, w
, h
);
803 EXPORT_SYMBOL(omap_rfbi_update
);
805 void rfbi_dump_regs(struct seq_file
*s
)
807 #define DUMPREG(r) seq_printf(s, "%-35s %08x\n", #r, rfbi_read_reg(r))
809 dss_clk_enable(DSS_CLK_ICK
| DSS_CLK_FCK
);
811 DUMPREG(RFBI_REVISION
);
812 DUMPREG(RFBI_SYSCONFIG
);
813 DUMPREG(RFBI_SYSSTATUS
);
814 DUMPREG(RFBI_CONTROL
);
815 DUMPREG(RFBI_PIXEL_CNT
);
816 DUMPREG(RFBI_LINE_NUMBER
);
821 DUMPREG(RFBI_STATUS
);
823 DUMPREG(RFBI_CONFIG(0));
824 DUMPREG(RFBI_ONOFF_TIME(0));
825 DUMPREG(RFBI_CYCLE_TIME(0));
826 DUMPREG(RFBI_DATA_CYCLE1(0));
827 DUMPREG(RFBI_DATA_CYCLE2(0));
828 DUMPREG(RFBI_DATA_CYCLE3(0));
830 DUMPREG(RFBI_CONFIG(1));
831 DUMPREG(RFBI_ONOFF_TIME(1));
832 DUMPREG(RFBI_CYCLE_TIME(1));
833 DUMPREG(RFBI_DATA_CYCLE1(1));
834 DUMPREG(RFBI_DATA_CYCLE2(1));
835 DUMPREG(RFBI_DATA_CYCLE3(1));
837 DUMPREG(RFBI_VSYNC_WIDTH
);
838 DUMPREG(RFBI_HSYNC_WIDTH
);
840 dss_clk_disable(DSS_CLK_ICK
| DSS_CLK_FCK
);
844 int omapdss_rfbi_display_enable(struct omap_dss_device
*dssdev
)
848 rfbi_enable_clocks(1);
850 r
= omap_dss_start_device(dssdev
);
852 DSSERR("failed to start device\n");
856 r
= omap_dispc_register_isr(framedone_callback
, NULL
,
857 DISPC_IRQ_FRAMEDONE
);
859 DSSERR("can't get FRAMEDONE irq\n");
863 dispc_set_lcd_display_type(dssdev
->manager
->id
,
864 OMAP_DSS_LCD_DISPLAY_TFT
);
866 dispc_set_parallel_interface_mode(dssdev
->manager
->id
,
867 OMAP_DSS_PARALLELMODE_RFBI
);
869 dispc_set_tft_data_lines(dssdev
->manager
->id
, dssdev
->ctrl
.pixel_size
);
871 rfbi_configure(dssdev
->phy
.rfbi
.channel
,
872 dssdev
->ctrl
.pixel_size
,
873 dssdev
->phy
.rfbi
.data_lines
);
875 rfbi_set_timings(dssdev
->phy
.rfbi
.channel
,
876 &dssdev
->ctrl
.rfbi_timings
);
881 omap_dss_stop_device(dssdev
);
885 EXPORT_SYMBOL(omapdss_rfbi_display_enable
);
887 void omapdss_rfbi_display_disable(struct omap_dss_device
*dssdev
)
889 omap_dispc_unregister_isr(framedone_callback
, NULL
,
890 DISPC_IRQ_FRAMEDONE
);
891 omap_dss_stop_device(dssdev
);
893 rfbi_enable_clocks(0);
895 EXPORT_SYMBOL(omapdss_rfbi_display_disable
);
897 int rfbi_init_display(struct omap_dss_device
*dssdev
)
899 rfbi
.dssdev
[dssdev
->phy
.rfbi
.channel
] = dssdev
;
900 dssdev
->caps
= OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE
;
904 /* RFBI HW IP initialisation */
905 static int omap_rfbihw_probe(struct platform_device
*pdev
)
909 struct resource
*rfbi_mem
;
913 sema_init(&rfbi
.bus_lock
, 1);
915 rfbi_mem
= platform_get_resource(rfbi
.pdev
, IORESOURCE_MEM
, 0);
917 DSSERR("can't get IORESOURCE_MEM RFBI\n");
920 rfbi
.base
= ioremap(rfbi_mem
->start
, resource_size(rfbi_mem
));
922 DSSERR("can't ioremap RFBI\n");
926 rfbi_enable_clocks(1);
930 rfbi
.l4_khz
= dss_clk_get_rate(DSS_CLK_ICK
) / 1000;
932 /* Enable autoidle and smart-idle */
933 l
= rfbi_read_reg(RFBI_SYSCONFIG
);
934 l
|= (1 << 0) | (2 << 3);
935 rfbi_write_reg(RFBI_SYSCONFIG
, l
);
937 rev
= rfbi_read_reg(RFBI_REVISION
);
938 dev_dbg(&pdev
->dev
, "OMAP RFBI rev %d.%d\n",
939 FLD_GET(rev
, 7, 4), FLD_GET(rev
, 3, 0));
941 rfbi_enable_clocks(0);
946 static int omap_rfbihw_remove(struct platform_device
*pdev
)
952 static struct platform_driver omap_rfbihw_driver
= {
953 .probe
= omap_rfbihw_probe
,
954 .remove
= omap_rfbihw_remove
,
956 .name
= "omapdss_rfbi",
957 .owner
= THIS_MODULE
,
961 int rfbi_init_platform_driver(void)
963 return platform_driver_register(&omap_rfbihw_driver
);
966 void rfbi_uninit_platform_driver(void)
968 return platform_driver_unregister(&omap_rfbihw_driver
);