2 * OMAP2 Remote Frame Buffer Interface support
4 * Copyright (C) 2005 Nokia Corporation
5 * Author: Juha Yrjölä <juha.yrjola@nokia.com>
6 * Imre Deak <imre.deak@nokia.com>
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2 of the License, or (at your
11 * option) any later version.
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
18 * You should have received a copy of the GNU General Public License along
19 * with this program; if not, write to the Free Software Foundation, Inc.,
20 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22 #include <linux/module.h>
23 #include <linux/delay.h>
24 #include <linux/i2c.h>
25 #include <linux/err.h>
26 #include <linux/interrupt.h>
27 #include <linux/clk.h>
33 /* To work around an RFBI transfer rate limitation */
34 #define OMAP_RFBI_RATE_LIMIT 1
36 #define RFBI_BASE 0x48050800
37 #define RFBI_REVISION 0x0000
38 #define RFBI_SYSCONFIG 0x0010
39 #define RFBI_SYSSTATUS 0x0014
40 #define RFBI_CONTROL 0x0040
41 #define RFBI_PIXEL_CNT 0x0044
42 #define RFBI_LINE_NUMBER 0x0048
43 #define RFBI_CMD 0x004c
44 #define RFBI_PARAM 0x0050
45 #define RFBI_DATA 0x0054
46 #define RFBI_READ 0x0058
47 #define RFBI_STATUS 0x005c
48 #define RFBI_CONFIG0 0x0060
49 #define RFBI_ONOFF_TIME0 0x0064
50 #define RFBI_CYCLE_TIME0 0x0068
51 #define RFBI_DATA_CYCLE1_0 0x006c
52 #define RFBI_DATA_CYCLE2_0 0x0070
53 #define RFBI_DATA_CYCLE3_0 0x0074
54 #define RFBI_VSYNC_WIDTH 0x0090
55 #define RFBI_HSYNC_WIDTH 0x0094
57 #define DISPC_BASE 0x48050400
58 #define DISPC_CONTROL 0x0040
59 #define DISPC_IRQ_FRAMEMASK 0x0001
63 void (*lcdc_callback
)(void *data
);
64 void *lcdc_callback_data
;
67 struct omapfb_device
*fbdev
;
70 unsigned tearsync_pin_cnt
;
71 unsigned tearsync_mode
;
74 static inline void rfbi_write_reg(int idx
, u32 val
)
76 __raw_writel(val
, rfbi
.base
+ idx
);
79 static inline u32
rfbi_read_reg(int idx
)
81 return __raw_readl(rfbi
.base
+ idx
);
84 static int rfbi_get_clocks(void)
86 rfbi
.dss_ick
= clk_get(&dispc
.fbdev
->dssdev
->dev
, "ick");
87 if (IS_ERR(rfbi
.dss_ick
)) {
88 dev_err(rfbi
.fbdev
->dev
, "can't get ick\n");
89 return PTR_ERR(rfbi
.dss_ick
);
92 rfbi
.dss1_fck
= clk_get(&dispc
.fbdev
->dssdev
->dev
, "dss1_fck");
93 if (IS_ERR(rfbi
.dss1_fck
)) {
94 dev_err(rfbi
.fbdev
->dev
, "can't get dss1_fck\n");
95 clk_put(rfbi
.dss_ick
);
96 return PTR_ERR(rfbi
.dss1_fck
);
102 static void rfbi_put_clocks(void)
104 clk_put(rfbi
.dss1_fck
);
105 clk_put(rfbi
.dss_ick
);
108 static void rfbi_enable_clocks(int enable
)
111 clk_enable(rfbi
.dss_ick
);
112 clk_enable(rfbi
.dss1_fck
);
114 clk_disable(rfbi
.dss1_fck
);
115 clk_disable(rfbi
.dss_ick
);
121 static void rfbi_print_timings(void)
126 l
= rfbi_read_reg(RFBI_CONFIG0
);
127 time
= 1000000000 / rfbi
.l4_khz
;
131 dev_dbg(rfbi
.fbdev
->dev
, "Tick time %u ps\n", time
);
132 l
= rfbi_read_reg(RFBI_ONOFF_TIME0
);
133 dev_dbg(rfbi
.fbdev
->dev
,
134 "CSONTIME %d, CSOFFTIME %d, WEONTIME %d, WEOFFTIME %d, "
135 "REONTIME %d, REOFFTIME %d\n",
136 l
& 0x0f, (l
>> 4) & 0x3f, (l
>> 10) & 0x0f, (l
>> 14) & 0x3f,
137 (l
>> 20) & 0x0f, (l
>> 24) & 0x3f);
139 l
= rfbi_read_reg(RFBI_CYCLE_TIME0
);
140 dev_dbg(rfbi
.fbdev
->dev
,
141 "WECYCLETIME %d, RECYCLETIME %d, CSPULSEWIDTH %d, "
143 (l
& 0x3f), (l
>> 6) & 0x3f, (l
>> 12) & 0x3f,
147 static void rfbi_print_timings(void) {}
150 static void rfbi_set_timings(const struct extif_timings
*t
)
154 BUG_ON(!t
->converted
);
156 rfbi_enable_clocks(1);
157 rfbi_write_reg(RFBI_ONOFF_TIME0
, t
->tim
[0]);
158 rfbi_write_reg(RFBI_CYCLE_TIME0
, t
->tim
[1]);
160 l
= rfbi_read_reg(RFBI_CONFIG0
);
162 l
|= (t
->tim
[2] ? 1 : 0) << 4;
163 rfbi_write_reg(RFBI_CONFIG0
, l
);
165 rfbi_print_timings();
166 rfbi_enable_clocks(0);
169 static void rfbi_get_clk_info(u32
*clk_period
, u32
*max_clk_div
)
171 *clk_period
= 1000000000 / rfbi
.l4_khz
;
175 static int ps_to_rfbi_ticks(int time
, int div
)
177 unsigned long tick_ps
;
180 /* Calculate in picosecs to yield more exact results */
181 tick_ps
= 1000000000 / (rfbi
.l4_khz
) * div
;
183 ret
= (time
+ tick_ps
- 1) / tick_ps
;
188 #ifdef OMAP_RFBI_RATE_LIMIT
189 static unsigned long rfbi_get_max_tx_rate(void)
191 unsigned long l4_rate
, dss1_rate
;
192 int min_l4_ticks
= 0;
195 /* According to TI this can't be calculated so make the
196 * adjustments for a couple of known frequencies and warn for
199 static const struct {
200 unsigned long l4_clk
; /* HZ */
201 unsigned long dss1_clk
; /* HZ */
202 unsigned long min_l4_ticks
;
204 { 55, 132, 7, }, /* 7.86 MPix/s */
205 { 110, 110, 12, }, /* 9.16 MPix/s */
206 { 110, 132, 10, }, /* 11 Mpix/s */
207 { 120, 120, 10, }, /* 12 Mpix/s */
208 { 133, 133, 10, }, /* 13.3 Mpix/s */
211 l4_rate
= rfbi
.l4_khz
/ 1000;
212 dss1_rate
= clk_get_rate(rfbi
.dss1_fck
) / 1000000;
214 for (i
= 0; i
< ARRAY_SIZE(ftab
); i
++) {
215 /* Use a window instead of an exact match, to account
216 * for different DPLL multiplier / divider pairs.
218 if (abs(ftab
[i
].l4_clk
- l4_rate
) < 3 &&
219 abs(ftab
[i
].dss1_clk
- dss1_rate
) < 3) {
220 min_l4_ticks
= ftab
[i
].min_l4_ticks
;
224 if (i
== ARRAY_SIZE(ftab
)) {
225 /* Can't be sure, return anyway the maximum not
226 * rate-limited. This might cause a problem only for the
227 * tearing synchronisation.
229 dev_err(rfbi
.fbdev
->dev
,
230 "can't determine maximum RFBI transfer rate\n");
231 return rfbi
.l4_khz
* 1000;
233 return rfbi
.l4_khz
* 1000 / min_l4_ticks
;
236 static int rfbi_get_max_tx_rate(void)
238 return rfbi
.l4_khz
* 1000;
243 static int rfbi_convert_timings(struct extif_timings
*t
)
246 int reon
, reoff
, weon
, weoff
, cson
, csoff
, cs_pulse
;
247 int actim
, recyc
, wecyc
;
248 int div
= t
->clk_div
;
250 if (div
<= 0 || div
> 2)
253 /* Make sure that after conversion it still holds that:
254 * weoff > weon, reoff > reon, recyc >= reoff, wecyc >= weoff,
255 * csoff > cson, csoff >= max(weoff, reoff), actim > reon
257 weon
= ps_to_rfbi_ticks(t
->we_on_time
, div
);
258 weoff
= ps_to_rfbi_ticks(t
->we_off_time
, div
);
266 reon
= ps_to_rfbi_ticks(t
->re_on_time
, div
);
267 reoff
= ps_to_rfbi_ticks(t
->re_off_time
, div
);
275 cson
= ps_to_rfbi_ticks(t
->cs_on_time
, div
);
276 csoff
= ps_to_rfbi_ticks(t
->cs_off_time
, div
);
279 if (csoff
< max(weoff
, reoff
))
280 csoff
= max(weoff
, reoff
);
295 actim
= ps_to_rfbi_ticks(t
->access_time
, div
);
301 wecyc
= ps_to_rfbi_ticks(t
->we_cycle_time
, div
);
307 recyc
= ps_to_rfbi_ticks(t
->re_cycle_time
, div
);
313 cs_pulse
= ps_to_rfbi_ticks(t
->cs_pulse_width
, div
);
331 static int rfbi_setup_tearsync(unsigned pin_cnt
,
332 unsigned hs_pulse_time
, unsigned vs_pulse_time
,
333 int hs_pol_inv
, int vs_pol_inv
, int extif_div
)
339 if (pin_cnt
!= 1 && pin_cnt
!= 2)
342 hs
= ps_to_rfbi_ticks(hs_pulse_time
, 1);
343 vs
= ps_to_rfbi_ticks(vs_pulse_time
, 1);
354 rfbi
.tearsync_pin_cnt
= pin_cnt
;
355 dev_dbg(rfbi
.fbdev
->dev
,
356 "setup_tearsync: pins %d hs %d vs %d hs_inv %d vs_inv %d\n",
357 pin_cnt
, hs
, vs
, hs_pol_inv
, vs_pol_inv
);
359 rfbi_enable_clocks(1);
360 rfbi_write_reg(RFBI_HSYNC_WIDTH
, hs
);
361 rfbi_write_reg(RFBI_VSYNC_WIDTH
, vs
);
363 l
= rfbi_read_reg(RFBI_CONFIG0
);
372 rfbi_enable_clocks(0);
377 static int rfbi_enable_tearsync(int enable
, unsigned line
)
381 dev_dbg(rfbi
.fbdev
->dev
, "tearsync %d line %d mode %d\n",
382 enable
, line
, rfbi
.tearsync_mode
);
383 if (line
> (1 << 11) - 1)
386 rfbi_enable_clocks(1);
387 l
= rfbi_read_reg(RFBI_CONFIG0
);
390 rfbi
.tearsync_mode
= rfbi
.tearsync_pin_cnt
;
391 l
|= rfbi
.tearsync_mode
<< 2;
393 rfbi
.tearsync_mode
= 0;
394 rfbi_write_reg(RFBI_CONFIG0
, l
);
395 rfbi_write_reg(RFBI_LINE_NUMBER
, line
);
396 rfbi_enable_clocks(0);
401 static void rfbi_write_command(const void *buf
, unsigned int len
)
403 rfbi_enable_clocks(1);
404 if (rfbi
.bits_per_cycle
== 16) {
407 for (; len
; len
-= 2)
408 rfbi_write_reg(RFBI_CMD
, *w
++);
411 BUG_ON(rfbi
.bits_per_cycle
!= 8);
413 rfbi_write_reg(RFBI_CMD
, *b
++);
415 rfbi_enable_clocks(0);
418 static void rfbi_read_data(void *buf
, unsigned int len
)
420 rfbi_enable_clocks(1);
421 if (rfbi
.bits_per_cycle
== 16) {
424 for (; len
; len
-= 2) {
425 rfbi_write_reg(RFBI_READ
, 0);
426 *w
++ = rfbi_read_reg(RFBI_READ
);
430 BUG_ON(rfbi
.bits_per_cycle
!= 8);
432 rfbi_write_reg(RFBI_READ
, 0);
433 *b
++ = rfbi_read_reg(RFBI_READ
);
436 rfbi_enable_clocks(0);
439 static void rfbi_write_data(const void *buf
, unsigned int len
)
441 rfbi_enable_clocks(1);
442 if (rfbi
.bits_per_cycle
== 16) {
445 for (; len
; len
-= 2)
446 rfbi_write_reg(RFBI_PARAM
, *w
++);
449 BUG_ON(rfbi
.bits_per_cycle
!= 8);
451 rfbi_write_reg(RFBI_PARAM
, *b
++);
453 rfbi_enable_clocks(0);
456 static void rfbi_transfer_area(int width
, int height
,
457 void (callback
)(void * data
), void *data
)
461 BUG_ON(callback
== NULL
);
463 rfbi_enable_clocks(1);
464 omap_dispc_set_lcd_size(width
, height
);
466 rfbi
.lcdc_callback
= callback
;
467 rfbi
.lcdc_callback_data
= data
;
469 rfbi_write_reg(RFBI_PIXEL_CNT
, width
* height
);
471 w
= rfbi_read_reg(RFBI_CONTROL
);
473 if (!rfbi
.tearsync_mode
)
474 w
|= 1 << 4; /* internal trigger, reset by HW */
475 rfbi_write_reg(RFBI_CONTROL
, w
);
477 omap_dispc_enable_lcd_out(1);
480 static inline void _stop_transfer(void)
484 w
= rfbi_read_reg(RFBI_CONTROL
);
485 rfbi_write_reg(RFBI_CONTROL
, w
& ~(1 << 0));
486 rfbi_enable_clocks(0);
489 static void rfbi_dma_callback(void *data
)
492 rfbi
.lcdc_callback(rfbi
.lcdc_callback_data
);
495 static void rfbi_set_bits_per_cycle(int bpc
)
499 rfbi_enable_clocks(1);
500 l
= rfbi_read_reg(RFBI_CONFIG0
);
512 rfbi_write_reg(RFBI_CONFIG0
, l
);
513 rfbi
.bits_per_cycle
= bpc
;
514 rfbi_enable_clocks(0);
517 static int rfbi_init(struct omapfb_device
*fbdev
)
523 rfbi
.base
= ioremap(RFBI_BASE
, SZ_1K
);
525 dev_err(fbdev
->dev
, "can't ioremap RFBI\n");
529 if ((r
= rfbi_get_clocks()) < 0)
531 rfbi_enable_clocks(1);
533 rfbi
.l4_khz
= clk_get_rate(rfbi
.dss_ick
) / 1000;
536 rfbi_write_reg(RFBI_SYSCONFIG
, 1 << 1);
537 while (!(rfbi_read_reg(RFBI_SYSSTATUS
) & (1 << 0)));
539 l
= rfbi_read_reg(RFBI_SYSCONFIG
);
540 /* Enable autoidle and smart-idle */
541 l
|= (1 << 0) | (2 << 3);
542 rfbi_write_reg(RFBI_SYSCONFIG
, l
);
544 /* 16-bit interface, ITE trigger mode, 16-bit data */
545 l
= (0x03 << 0) | (0x00 << 2) | (0x01 << 5) | (0x02 << 7);
546 l
|= (0 << 9) | (1 << 20) | (1 << 21);
547 rfbi_write_reg(RFBI_CONFIG0
, l
);
549 rfbi_write_reg(RFBI_DATA_CYCLE1_0
, 0x00000010);
551 l
= rfbi_read_reg(RFBI_CONTROL
);
552 /* Select CS0, clear bypass mode */
554 rfbi_write_reg(RFBI_CONTROL
, l
);
556 r
= omap_dispc_request_irq(DISPC_IRQ_FRAMEMASK
, rfbi_dma_callback
,
559 dev_err(fbdev
->dev
, "can't get DISPC irq\n");
560 rfbi_enable_clocks(0);
564 l
= rfbi_read_reg(RFBI_REVISION
);
565 pr_info("omapfb: RFBI version %d.%d initialized\n",
566 (l
>> 4) & 0x0f, l
& 0x0f);
568 rfbi_enable_clocks(0);
573 static void rfbi_cleanup(void)
575 omap_dispc_free_irq(DISPC_IRQ_FRAMEMASK
, rfbi_dma_callback
, NULL
);
580 const struct lcd_ctrl_extif omap2_ext_if
= {
582 .cleanup
= rfbi_cleanup
,
583 .get_clk_info
= rfbi_get_clk_info
,
584 .get_max_tx_rate
= rfbi_get_max_tx_rate
,
585 .set_bits_per_cycle
= rfbi_set_bits_per_cycle
,
586 .convert_timings
= rfbi_convert_timings
,
587 .set_timings
= rfbi_set_timings
,
588 .write_command
= rfbi_write_command
,
589 .read_data
= rfbi_read_data
,
590 .write_data
= rfbi_write_data
,
591 .transfer_area
= rfbi_transfer_area
,
592 .setup_tearsync
= rfbi_setup_tearsync
,
593 .enable_tearsync
= rfbi_enable_tearsync
,
595 .max_transmit_size
= (u32
) ~0,