2 * SuperH Mobile LCDC Framebuffer
4 * Copyright (c) 2008 Magnus Damm
6 * This file is subject to the terms and conditions of the GNU General Public
7 * License. See the file "COPYING" in the main directory of this archive
11 #include <linux/kernel.h>
12 #include <linux/init.h>
13 #include <linux/delay.h>
15 #include <linux/clk.h>
16 #include <linux/pm_runtime.h>
17 #include <linux/platform_device.h>
18 #include <linux/dma-mapping.h>
19 #include <linux/interrupt.h>
20 #include <linux/vmalloc.h>
21 #include <linux/ioctl.h>
22 #include <linux/slab.h>
23 #include <linux/console.h>
24 #include <video/sh_mobile_lcdc.h>
25 #include <asm/atomic.h>
27 #include "sh_mobile_lcdcfb.h"
29 #define SIDE_B_OFFSET 0x1000
30 #define MIRROR_OFFSET 0x2000
32 /* shared registers */
34 #define _LDDCKSTPR 0x414
37 #define _LDCNT1R 0x470
38 #define _LDCNT2R 0x474
39 #define _LDRCNTR 0x478
41 #define _LDDWD0R 0x800
46 /* shared registers and their order for context save/restore */
47 static int lcdc_shared_regs
[] = {
55 #define NR_SHARED_REGS ARRAY_SIZE(lcdc_shared_regs)
57 #define DEFAULT_XRES 1280
58 #define DEFAULT_YRES 1024
60 static unsigned long lcdc_offs_mainlcd
[NR_CH_REGS
] = {
79 static unsigned long lcdc_offs_sublcd
[NR_CH_REGS
] = {
97 #define START_LCDC 0x00000001
98 #define LCDC_RESET 0x00000100
99 #define DISPLAY_BEU 0x00000008
100 #define LCDC_ENABLE 0x00000001
101 #define LDINTR_FE 0x00000400
102 #define LDINTR_VSE 0x00000200
103 #define LDINTR_VEE 0x00000100
104 #define LDINTR_FS 0x00000004
105 #define LDINTR_VSS 0x00000002
106 #define LDINTR_VES 0x00000001
107 #define LDRCNTR_SRS 0x00020000
108 #define LDRCNTR_SRC 0x00010000
109 #define LDRCNTR_MRS 0x00000002
110 #define LDRCNTR_MRC 0x00000001
111 #define LDSR_MRS 0x00000100
113 static const struct fb_videomode default_720p
= {
127 .sync
= FB_SYNC_VERT_HIGH_ACT
| FB_SYNC_HOR_HIGH_ACT
,
130 struct sh_mobile_lcdc_priv
{
136 unsigned long lddckr
;
137 struct sh_mobile_lcdc_chan ch
[2];
138 struct notifier_block notifier
;
139 unsigned long saved_shared_regs
[NR_SHARED_REGS
];
143 static bool banked(int reg_nr
)
162 static void lcdc_write_chan(struct sh_mobile_lcdc_chan
*chan
,
163 int reg_nr
, unsigned long data
)
165 iowrite32(data
, chan
->lcdc
->base
+ chan
->reg_offs
[reg_nr
]);
167 iowrite32(data
, chan
->lcdc
->base
+ chan
->reg_offs
[reg_nr
] +
171 static void lcdc_write_chan_mirror(struct sh_mobile_lcdc_chan
*chan
,
172 int reg_nr
, unsigned long data
)
174 iowrite32(data
, chan
->lcdc
->base
+ chan
->reg_offs
[reg_nr
] +
178 static unsigned long lcdc_read_chan(struct sh_mobile_lcdc_chan
*chan
,
181 return ioread32(chan
->lcdc
->base
+ chan
->reg_offs
[reg_nr
]);
184 static void lcdc_write(struct sh_mobile_lcdc_priv
*priv
,
185 unsigned long reg_offs
, unsigned long data
)
187 iowrite32(data
, priv
->base
+ reg_offs
);
190 static unsigned long lcdc_read(struct sh_mobile_lcdc_priv
*priv
,
191 unsigned long reg_offs
)
193 return ioread32(priv
->base
+ reg_offs
);
196 static void lcdc_wait_bit(struct sh_mobile_lcdc_priv
*priv
,
197 unsigned long reg_offs
,
198 unsigned long mask
, unsigned long until
)
200 while ((lcdc_read(priv
, reg_offs
) & mask
) != until
)
204 static int lcdc_chan_is_sublcd(struct sh_mobile_lcdc_chan
*chan
)
206 return chan
->cfg
.chan
== LCDC_CHAN_SUBLCD
;
209 static void lcdc_sys_write_index(void *handle
, unsigned long data
)
211 struct sh_mobile_lcdc_chan
*ch
= handle
;
213 lcdc_write(ch
->lcdc
, _LDDWD0R
, data
| 0x10000000);
214 lcdc_wait_bit(ch
->lcdc
, _LDSR
, 2, 0);
215 lcdc_write(ch
->lcdc
, _LDDWAR
, 1 | (lcdc_chan_is_sublcd(ch
) ? 2 : 0));
216 lcdc_wait_bit(ch
->lcdc
, _LDSR
, 2, 0);
219 static void lcdc_sys_write_data(void *handle
, unsigned long data
)
221 struct sh_mobile_lcdc_chan
*ch
= handle
;
223 lcdc_write(ch
->lcdc
, _LDDWD0R
, data
| 0x11000000);
224 lcdc_wait_bit(ch
->lcdc
, _LDSR
, 2, 0);
225 lcdc_write(ch
->lcdc
, _LDDWAR
, 1 | (lcdc_chan_is_sublcd(ch
) ? 2 : 0));
226 lcdc_wait_bit(ch
->lcdc
, _LDSR
, 2, 0);
229 static unsigned long lcdc_sys_read_data(void *handle
)
231 struct sh_mobile_lcdc_chan
*ch
= handle
;
233 lcdc_write(ch
->lcdc
, _LDDRDR
, 0x01000000);
234 lcdc_wait_bit(ch
->lcdc
, _LDSR
, 2, 0);
235 lcdc_write(ch
->lcdc
, _LDDRAR
, 1 | (lcdc_chan_is_sublcd(ch
) ? 2 : 0));
237 lcdc_wait_bit(ch
->lcdc
, _LDSR
, 2, 0);
239 return lcdc_read(ch
->lcdc
, _LDDRDR
) & 0x3ffff;
242 struct sh_mobile_lcdc_sys_bus_ops sh_mobile_lcdc_sys_bus_ops
= {
243 lcdc_sys_write_index
,
248 static void sh_mobile_lcdc_clk_on(struct sh_mobile_lcdc_priv
*priv
)
250 if (atomic_inc_and_test(&priv
->hw_usecnt
)) {
251 pm_runtime_get_sync(priv
->dev
);
253 clk_enable(priv
->dot_clk
);
257 static void sh_mobile_lcdc_clk_off(struct sh_mobile_lcdc_priv
*priv
)
259 if (atomic_sub_return(1, &priv
->hw_usecnt
) == -1) {
261 clk_disable(priv
->dot_clk
);
262 pm_runtime_put(priv
->dev
);
266 static int sh_mobile_lcdc_sginit(struct fb_info
*info
,
267 struct list_head
*pagelist
)
269 struct sh_mobile_lcdc_chan
*ch
= info
->par
;
270 unsigned int nr_pages_max
= info
->fix
.smem_len
>> PAGE_SHIFT
;
274 sg_init_table(ch
->sglist
, nr_pages_max
);
276 list_for_each_entry(page
, pagelist
, lru
)
277 sg_set_page(&ch
->sglist
[nr_pages
++], page
, PAGE_SIZE
, 0);
282 static void sh_mobile_lcdc_deferred_io(struct fb_info
*info
,
283 struct list_head
*pagelist
)
285 struct sh_mobile_lcdc_chan
*ch
= info
->par
;
286 struct sh_mobile_lcdc_board_cfg
*bcfg
= &ch
->cfg
.board_cfg
;
288 /* enable clocks before accessing hardware */
289 sh_mobile_lcdc_clk_on(ch
->lcdc
);
292 * It's possible to get here without anything on the pagelist via
293 * sh_mobile_lcdc_deferred_io_touch() or via a userspace fsync()
294 * invocation. In the former case, the acceleration routines are
295 * stepped in to when using the framebuffer console causing the
296 * workqueue to be scheduled without any dirty pages on the list.
298 * Despite this, a panel update is still needed given that the
299 * acceleration routines have their own methods for writing in
300 * that still need to be updated.
302 * The fsync() and empty pagelist case could be optimized for,
303 * but we don't bother, as any application exhibiting such
304 * behaviour is fundamentally broken anyways.
306 if (!list_empty(pagelist
)) {
307 unsigned int nr_pages
= sh_mobile_lcdc_sginit(info
, pagelist
);
309 /* trigger panel update */
310 dma_map_sg(info
->dev
, ch
->sglist
, nr_pages
, DMA_TO_DEVICE
);
311 if (bcfg
->start_transfer
)
312 bcfg
->start_transfer(bcfg
->board_data
, ch
,
313 &sh_mobile_lcdc_sys_bus_ops
);
314 lcdc_write_chan(ch
, LDSM2R
, 1);
315 dma_unmap_sg(info
->dev
, ch
->sglist
, nr_pages
, DMA_TO_DEVICE
);
317 if (bcfg
->start_transfer
)
318 bcfg
->start_transfer(bcfg
->board_data
, ch
,
319 &sh_mobile_lcdc_sys_bus_ops
);
320 lcdc_write_chan(ch
, LDSM2R
, 1);
324 static void sh_mobile_lcdc_deferred_io_touch(struct fb_info
*info
)
326 struct fb_deferred_io
*fbdefio
= info
->fbdefio
;
329 schedule_delayed_work(&info
->deferred_work
, fbdefio
->delay
);
332 static irqreturn_t
sh_mobile_lcdc_irq(int irq
, void *data
)
334 struct sh_mobile_lcdc_priv
*priv
= data
;
335 struct sh_mobile_lcdc_chan
*ch
;
337 unsigned long ldintr
;
341 /* acknowledge interrupt */
342 ldintr
= tmp
= lcdc_read(priv
, _LDINTR
);
344 * disable further VSYNC End IRQs, preserve all other enabled IRQs,
345 * write 0 to bits 0-6 to ack all triggered IRQs.
347 tmp
&= 0xffffff00 & ~LDINTR_VEE
;
348 lcdc_write(priv
, _LDINTR
, tmp
);
350 /* figure out if this interrupt is for main or sub lcd */
351 is_sub
= (lcdc_read(priv
, _LDSR
) & (1 << 10)) ? 1 : 0;
353 /* wake up channel and disable clocks */
354 for (k
= 0; k
< ARRAY_SIZE(priv
->ch
); k
++) {
361 if (ldintr
& LDINTR_FS
) {
362 if (is_sub
== lcdc_chan_is_sublcd(ch
)) {
364 wake_up(&ch
->frame_end_wait
);
366 sh_mobile_lcdc_clk_off(priv
);
371 if (ldintr
& LDINTR_VES
)
372 complete(&ch
->vsync_completion
);
378 static void sh_mobile_lcdc_start_stop(struct sh_mobile_lcdc_priv
*priv
,
381 unsigned long tmp
= lcdc_read(priv
, _LDCNT2R
);
384 /* start or stop the lcdc */
386 lcdc_write(priv
, _LDCNT2R
, tmp
| START_LCDC
);
388 lcdc_write(priv
, _LDCNT2R
, tmp
& ~START_LCDC
);
390 /* wait until power is applied/stopped on all channels */
391 for (k
= 0; k
< ARRAY_SIZE(priv
->ch
); k
++)
392 if (lcdc_read(priv
, _LDCNT2R
) & priv
->ch
[k
].enabled
)
394 tmp
= lcdc_read_chan(&priv
->ch
[k
], LDPMR
) & 3;
395 if (start
&& tmp
== 3)
397 if (!start
&& tmp
== 0)
403 lcdc_write(priv
, _LDDCKSTPR
, 1); /* stop dotclock */
406 static void sh_mobile_lcdc_geometry(struct sh_mobile_lcdc_chan
*ch
)
408 struct fb_var_screeninfo
*var
= &ch
->info
->var
, *display_var
= &ch
->display_var
;
409 unsigned long h_total
, hsync_pos
, display_h_total
;
412 tmp
= ch
->ldmt1r_value
;
413 tmp
|= (var
->sync
& FB_SYNC_VERT_HIGH_ACT
) ? 0 : 1 << 28;
414 tmp
|= (var
->sync
& FB_SYNC_HOR_HIGH_ACT
) ? 0 : 1 << 27;
415 tmp
|= (ch
->cfg
.flags
& LCDC_FLAGS_DWPOL
) ? 1 << 26 : 0;
416 tmp
|= (ch
->cfg
.flags
& LCDC_FLAGS_DIPOL
) ? 1 << 25 : 0;
417 tmp
|= (ch
->cfg
.flags
& LCDC_FLAGS_DAPOL
) ? 1 << 24 : 0;
418 tmp
|= (ch
->cfg
.flags
& LCDC_FLAGS_HSCNT
) ? 1 << 17 : 0;
419 tmp
|= (ch
->cfg
.flags
& LCDC_FLAGS_DWCNT
) ? 1 << 16 : 0;
420 lcdc_write_chan(ch
, LDMT1R
, tmp
);
423 lcdc_write_chan(ch
, LDMT2R
, ch
->cfg
.sys_bus_cfg
.ldmt2r
);
424 lcdc_write_chan(ch
, LDMT3R
, ch
->cfg
.sys_bus_cfg
.ldmt3r
);
426 /* horizontal configuration */
427 h_total
= display_var
->xres
+ display_var
->hsync_len
+
428 display_var
->left_margin
+ display_var
->right_margin
;
429 tmp
= h_total
/ 8; /* HTCN */
430 tmp
|= (min(display_var
->xres
, var
->xres
) / 8) << 16; /* HDCN */
431 lcdc_write_chan(ch
, LDHCNR
, tmp
);
433 hsync_pos
= display_var
->xres
+ display_var
->right_margin
;
434 tmp
= hsync_pos
/ 8; /* HSYNP */
435 tmp
|= (display_var
->hsync_len
/ 8) << 16; /* HSYNW */
436 lcdc_write_chan(ch
, LDHSYNR
, tmp
);
438 /* vertical configuration */
439 tmp
= display_var
->yres
+ display_var
->vsync_len
+
440 display_var
->upper_margin
+ display_var
->lower_margin
; /* VTLN */
441 tmp
|= min(display_var
->yres
, var
->yres
) << 16; /* VDLN */
442 lcdc_write_chan(ch
, LDVLNR
, tmp
);
444 tmp
= display_var
->yres
+ display_var
->lower_margin
; /* VSYNP */
445 tmp
|= display_var
->vsync_len
<< 16; /* VSYNW */
446 lcdc_write_chan(ch
, LDVSYNR
, tmp
);
448 /* Adjust horizontal synchronisation for HDMI */
449 display_h_total
= display_var
->xres
+ display_var
->hsync_len
+
450 display_var
->left_margin
+ display_var
->right_margin
;
451 tmp
= ((display_var
->xres
& 7) << 24) |
452 ((display_h_total
& 7) << 16) |
453 ((display_var
->hsync_len
& 7) << 8) |
455 lcdc_write_chan(ch
, LDHAJR
, tmp
);
458 static int sh_mobile_lcdc_start(struct sh_mobile_lcdc_priv
*priv
)
460 struct sh_mobile_lcdc_chan
*ch
;
461 struct sh_mobile_lcdc_board_cfg
*board_cfg
;
466 /* enable clocks before accessing the hardware */
467 for (k
= 0; k
< ARRAY_SIZE(priv
->ch
); k
++)
468 if (priv
->ch
[k
].enabled
)
469 sh_mobile_lcdc_clk_on(priv
);
472 lcdc_write(priv
, _LDCNT2R
, lcdc_read(priv
, _LDCNT2R
) | LCDC_RESET
);
473 lcdc_wait_bit(priv
, _LDCNT2R
, LCDC_RESET
, 0);
475 /* enable LCDC channels */
476 tmp
= lcdc_read(priv
, _LDCNT2R
);
477 tmp
|= priv
->ch
[0].enabled
;
478 tmp
|= priv
->ch
[1].enabled
;
479 lcdc_write(priv
, _LDCNT2R
, tmp
);
481 /* read data from external memory, avoid using the BEU for now */
482 lcdc_write(priv
, _LDCNT2R
, lcdc_read(priv
, _LDCNT2R
) & ~DISPLAY_BEU
);
484 /* stop the lcdc first */
485 sh_mobile_lcdc_start_stop(priv
, 0);
487 /* configure clocks */
489 for (k
= 0; k
< ARRAY_SIZE(priv
->ch
); k
++) {
492 if (!priv
->ch
[k
].enabled
)
495 m
= ch
->cfg
.clock_divider
;
501 tmp
|= m
<< (lcdc_chan_is_sublcd(ch
) ? 8 : 0);
503 /* FIXME: sh7724 can only use 42, 48, 54 and 60 for the divider denominator */
504 lcdc_write_chan(ch
, LDDCKPAT1R
, 0);
505 lcdc_write_chan(ch
, LDDCKPAT2R
, (1 << (m
/2)) - 1);
508 lcdc_write(priv
, _LDDCKR
, tmp
);
510 /* start dotclock again */
511 lcdc_write(priv
, _LDDCKSTPR
, 0);
512 lcdc_wait_bit(priv
, _LDDCKSTPR
, ~0, 0);
514 /* interrupts are disabled to begin with */
515 lcdc_write(priv
, _LDINTR
, 0);
517 for (k
= 0; k
< ARRAY_SIZE(priv
->ch
); k
++) {
523 sh_mobile_lcdc_geometry(ch
);
526 lcdc_write_chan(ch
, LDPMR
, 0);
528 board_cfg
= &ch
->cfg
.board_cfg
;
529 if (board_cfg
->setup_sys
)
530 ret
= board_cfg
->setup_sys(board_cfg
->board_data
, ch
,
531 &sh_mobile_lcdc_sys_bus_ops
);
536 /* word and long word swap */
537 lcdc_write(priv
, _LDDDSR
, lcdc_read(priv
, _LDDDSR
) | 6);
539 for (k
= 0; k
< ARRAY_SIZE(priv
->ch
); k
++) {
542 if (!priv
->ch
[k
].enabled
)
545 /* set bpp format in PKF[4:0] */
546 tmp
= lcdc_read_chan(ch
, LDDFR
);
548 tmp
|= (ch
->info
->var
.bits_per_pixel
== 16) ? 3 : 0;
549 lcdc_write_chan(ch
, LDDFR
, tmp
);
551 /* point out our frame buffer */
552 lcdc_write_chan(ch
, LDSA1R
, ch
->info
->fix
.smem_start
);
555 lcdc_write_chan(ch
, LDMLSR
, ch
->info
->fix
.line_length
);
557 /* setup deferred io if SYS bus */
558 tmp
= ch
->cfg
.sys_bus_cfg
.deferred_io_msec
;
559 if (ch
->ldmt1r_value
& (1 << 12) && tmp
) {
560 ch
->defio
.deferred_io
= sh_mobile_lcdc_deferred_io
;
561 ch
->defio
.delay
= msecs_to_jiffies(tmp
);
562 ch
->info
->fbdefio
= &ch
->defio
;
563 fb_deferred_io_init(ch
->info
);
566 lcdc_write_chan(ch
, LDSM1R
, 1);
568 /* enable "Frame End Interrupt Enable" bit */
569 lcdc_write(priv
, _LDINTR
, LDINTR_FE
);
572 /* continuous read mode */
573 lcdc_write_chan(ch
, LDSM1R
, 0);
578 lcdc_write(priv
, _LDCNT1R
, LCDC_ENABLE
);
581 sh_mobile_lcdc_start_stop(priv
, 1);
584 /* tell the board code to enable the panel */
585 for (k
= 0; k
< ARRAY_SIZE(priv
->ch
); k
++) {
590 board_cfg
= &ch
->cfg
.board_cfg
;
591 if (try_module_get(board_cfg
->owner
) && board_cfg
->display_on
) {
592 board_cfg
->display_on(board_cfg
->board_data
, ch
->info
);
593 module_put(board_cfg
->owner
);
600 static void sh_mobile_lcdc_stop(struct sh_mobile_lcdc_priv
*priv
)
602 struct sh_mobile_lcdc_chan
*ch
;
603 struct sh_mobile_lcdc_board_cfg
*board_cfg
;
606 /* clean up deferred io and ask board code to disable panel */
607 for (k
= 0; k
< ARRAY_SIZE(priv
->ch
); k
++) {
613 * flush frame, and wait for frame end interrupt
614 * clean up deferred io and enable clock
616 if (ch
->info
&& ch
->info
->fbdefio
) {
618 schedule_delayed_work(&ch
->info
->deferred_work
, 0);
619 wait_event(ch
->frame_end_wait
, ch
->frame_end
);
620 fb_deferred_io_cleanup(ch
->info
);
621 ch
->info
->fbdefio
= NULL
;
622 sh_mobile_lcdc_clk_on(priv
);
625 board_cfg
= &ch
->cfg
.board_cfg
;
626 if (try_module_get(board_cfg
->owner
) && board_cfg
->display_off
) {
627 board_cfg
->display_off(board_cfg
->board_data
);
628 module_put(board_cfg
->owner
);
634 sh_mobile_lcdc_start_stop(priv
, 0);
639 for (k
= 0; k
< ARRAY_SIZE(priv
->ch
); k
++)
640 if (priv
->ch
[k
].enabled
)
641 sh_mobile_lcdc_clk_off(priv
);
644 static int sh_mobile_lcdc_check_interface(struct sh_mobile_lcdc_chan
*ch
)
648 switch (ch
->cfg
.interface_type
) {
649 case RGB8
: ifm
= 0; miftyp
= 0; break;
650 case RGB9
: ifm
= 0; miftyp
= 4; break;
651 case RGB12A
: ifm
= 0; miftyp
= 5; break;
652 case RGB12B
: ifm
= 0; miftyp
= 6; break;
653 case RGB16
: ifm
= 0; miftyp
= 7; break;
654 case RGB18
: ifm
= 0; miftyp
= 10; break;
655 case RGB24
: ifm
= 0; miftyp
= 11; break;
656 case SYS8A
: ifm
= 1; miftyp
= 0; break;
657 case SYS8B
: ifm
= 1; miftyp
= 1; break;
658 case SYS8C
: ifm
= 1; miftyp
= 2; break;
659 case SYS8D
: ifm
= 1; miftyp
= 3; break;
660 case SYS9
: ifm
= 1; miftyp
= 4; break;
661 case SYS12
: ifm
= 1; miftyp
= 5; break;
662 case SYS16A
: ifm
= 1; miftyp
= 7; break;
663 case SYS16B
: ifm
= 1; miftyp
= 8; break;
664 case SYS16C
: ifm
= 1; miftyp
= 9; break;
665 case SYS18
: ifm
= 1; miftyp
= 10; break;
666 case SYS24
: ifm
= 1; miftyp
= 11; break;
670 /* SUBLCD only supports SYS interface */
671 if (lcdc_chan_is_sublcd(ch
)) {
678 ch
->ldmt1r_value
= (ifm
<< 12) | miftyp
;
684 static int sh_mobile_lcdc_setup_clocks(struct platform_device
*pdev
,
686 struct sh_mobile_lcdc_priv
*priv
)
691 switch (clock_source
) {
692 case LCDC_CLK_BUS
: str
= "bus_clk"; icksel
= 0; break;
693 case LCDC_CLK_PERIPHERAL
: str
= "peripheral_clk"; icksel
= 1; break;
694 case LCDC_CLK_EXTERNAL
: str
= NULL
; icksel
= 2; break;
699 priv
->lddckr
= icksel
<< 16;
702 priv
->dot_clk
= clk_get(&pdev
->dev
, str
);
703 if (IS_ERR(priv
->dot_clk
)) {
704 dev_err(&pdev
->dev
, "cannot get dot clock %s\n", str
);
705 return PTR_ERR(priv
->dot_clk
);
709 /* Runtime PM support involves two step for this driver:
710 * 1) Enable Runtime PM
711 * 2) Force Runtime PM Resume since hardware is accessed from probe()
713 priv
->dev
= &pdev
->dev
;
714 pm_runtime_enable(priv
->dev
);
715 pm_runtime_resume(priv
->dev
);
719 static int sh_mobile_lcdc_setcolreg(u_int regno
,
720 u_int red
, u_int green
, u_int blue
,
721 u_int transp
, struct fb_info
*info
)
723 u32
*palette
= info
->pseudo_palette
;
725 if (regno
>= PALETTE_NR
)
728 /* only FB_VISUAL_TRUECOLOR supported */
730 red
>>= 16 - info
->var
.red
.length
;
731 green
>>= 16 - info
->var
.green
.length
;
732 blue
>>= 16 - info
->var
.blue
.length
;
733 transp
>>= 16 - info
->var
.transp
.length
;
735 palette
[regno
] = (red
<< info
->var
.red
.offset
) |
736 (green
<< info
->var
.green
.offset
) |
737 (blue
<< info
->var
.blue
.offset
) |
738 (transp
<< info
->var
.transp
.offset
);
743 static struct fb_fix_screeninfo sh_mobile_lcdc_fix
= {
744 .id
= "SH Mobile LCDC",
745 .type
= FB_TYPE_PACKED_PIXELS
,
746 .visual
= FB_VISUAL_TRUECOLOR
,
747 .accel
= FB_ACCEL_NONE
,
753 static void sh_mobile_lcdc_fillrect(struct fb_info
*info
,
754 const struct fb_fillrect
*rect
)
756 sys_fillrect(info
, rect
);
757 sh_mobile_lcdc_deferred_io_touch(info
);
760 static void sh_mobile_lcdc_copyarea(struct fb_info
*info
,
761 const struct fb_copyarea
*area
)
763 sys_copyarea(info
, area
);
764 sh_mobile_lcdc_deferred_io_touch(info
);
767 static void sh_mobile_lcdc_imageblit(struct fb_info
*info
,
768 const struct fb_image
*image
)
770 sys_imageblit(info
, image
);
771 sh_mobile_lcdc_deferred_io_touch(info
);
774 static int sh_mobile_fb_pan_display(struct fb_var_screeninfo
*var
,
775 struct fb_info
*info
)
777 struct sh_mobile_lcdc_chan
*ch
= info
->par
;
778 struct sh_mobile_lcdc_priv
*priv
= ch
->lcdc
;
779 unsigned long ldrcntr
;
780 unsigned long new_pan_offset
;
782 new_pan_offset
= (var
->yoffset
* info
->fix
.line_length
) +
783 (var
->xoffset
* (info
->var
.bits_per_pixel
/ 8));
785 if (new_pan_offset
== ch
->pan_offset
)
786 return 0; /* No change, do nothing */
788 ldrcntr
= lcdc_read(priv
, _LDRCNTR
);
790 /* Set the source address for the next refresh */
791 lcdc_write_chan_mirror(ch
, LDSA1R
, ch
->dma_handle
+ new_pan_offset
);
792 if (lcdc_chan_is_sublcd(ch
))
793 lcdc_write(ch
->lcdc
, _LDRCNTR
, ldrcntr
^ LDRCNTR_SRS
);
795 lcdc_write(ch
->lcdc
, _LDRCNTR
, ldrcntr
^ LDRCNTR_MRS
);
797 ch
->pan_offset
= new_pan_offset
;
799 sh_mobile_lcdc_deferred_io_touch(info
);
804 static int sh_mobile_wait_for_vsync(struct fb_info
*info
)
806 struct sh_mobile_lcdc_chan
*ch
= info
->par
;
807 unsigned long ldintr
;
810 /* Enable VSync End interrupt */
811 ldintr
= lcdc_read(ch
->lcdc
, _LDINTR
);
812 ldintr
|= LDINTR_VEE
;
813 lcdc_write(ch
->lcdc
, _LDINTR
, ldintr
);
815 ret
= wait_for_completion_interruptible_timeout(&ch
->vsync_completion
,
816 msecs_to_jiffies(100));
823 static int sh_mobile_ioctl(struct fb_info
*info
, unsigned int cmd
,
829 case FBIO_WAITFORVSYNC
:
830 retval
= sh_mobile_wait_for_vsync(info
);
834 retval
= -ENOIOCTLCMD
;
840 static void sh_mobile_fb_reconfig(struct fb_info
*info
)
842 struct sh_mobile_lcdc_chan
*ch
= info
->par
;
843 struct fb_videomode mode1
, mode2
;
844 struct fb_event event
;
845 int evnt
= FB_EVENT_MODE_CHANGE_ALL
;
847 if (ch
->use_count
> 1 || (ch
->use_count
== 1 && !info
->fbcon_par
))
848 /* More framebuffer users are active */
851 fb_var_to_videomode(&mode1
, &ch
->display_var
);
852 fb_var_to_videomode(&mode2
, &info
->var
);
854 if (fb_mode_is_equal(&mode1
, &mode2
))
857 /* Display has been re-plugged, framebuffer is free now, reconfigure */
858 if (fb_set_var(info
, &ch
->display_var
) < 0)
859 /* Couldn't reconfigure, hopefully, can continue as before */
862 info
->fix
.line_length
= mode2
.xres
* (ch
->cfg
.bpp
/ 8);
865 * fb_set_var() calls the notifier change internally, only if
866 * FBINFO_MISC_USEREVENT flag is set. Since we do not want to fake a
867 * user event, we have to call the chain ourselves.
871 fb_notifier_call_chain(evnt
, &event
);
875 * Locking: both .fb_release() and .fb_open() are called with info->lock held if
876 * user == 1, or with console sem held, if user == 0.
878 static int sh_mobile_release(struct fb_info
*info
, int user
)
880 struct sh_mobile_lcdc_chan
*ch
= info
->par
;
882 mutex_lock(&ch
->open_lock
);
883 dev_dbg(info
->dev
, "%s(): %d users\n", __func__
, ch
->use_count
);
887 /* Nothing to reconfigure, when called from fbcon */
889 acquire_console_sem();
890 sh_mobile_fb_reconfig(info
);
891 release_console_sem();
894 mutex_unlock(&ch
->open_lock
);
899 static int sh_mobile_open(struct fb_info
*info
, int user
)
901 struct sh_mobile_lcdc_chan
*ch
= info
->par
;
903 mutex_lock(&ch
->open_lock
);
906 dev_dbg(info
->dev
, "%s(): %d users\n", __func__
, ch
->use_count
);
907 mutex_unlock(&ch
->open_lock
);
912 static int sh_mobile_check_var(struct fb_var_screeninfo
*var
, struct fb_info
*info
)
914 struct sh_mobile_lcdc_chan
*ch
= info
->par
;
916 if (var
->xres
< 160 || var
->xres
> 1920 ||
917 var
->yres
< 120 || var
->yres
> 1080 ||
918 var
->left_margin
< 32 || var
->left_margin
> 320 ||
919 var
->right_margin
< 12 || var
->right_margin
> 240 ||
920 var
->upper_margin
< 12 || var
->upper_margin
> 120 ||
921 var
->lower_margin
< 1 || var
->lower_margin
> 64 ||
922 var
->hsync_len
< 32 || var
->hsync_len
> 240 ||
923 var
->vsync_len
< 2 || var
->vsync_len
> 64 ||
924 var
->pixclock
< 6000 || var
->pixclock
> 40000 ||
925 var
->xres
* var
->yres
* (ch
->cfg
.bpp
/ 8) * 2 > info
->fix
.smem_len
) {
926 dev_warn(info
->dev
, "Invalid info: %u %u %u %u %u %u %u %u %u!\n",
927 var
->xres
, var
->yres
,
928 var
->left_margin
, var
->right_margin
,
929 var
->upper_margin
, var
->lower_margin
,
930 var
->hsync_len
, var
->vsync_len
,
937 static struct fb_ops sh_mobile_lcdc_ops
= {
938 .owner
= THIS_MODULE
,
939 .fb_setcolreg
= sh_mobile_lcdc_setcolreg
,
940 .fb_read
= fb_sys_read
,
941 .fb_write
= fb_sys_write
,
942 .fb_fillrect
= sh_mobile_lcdc_fillrect
,
943 .fb_copyarea
= sh_mobile_lcdc_copyarea
,
944 .fb_imageblit
= sh_mobile_lcdc_imageblit
,
945 .fb_pan_display
= sh_mobile_fb_pan_display
,
946 .fb_ioctl
= sh_mobile_ioctl
,
947 .fb_open
= sh_mobile_open
,
948 .fb_release
= sh_mobile_release
,
949 .fb_check_var
= sh_mobile_check_var
,
952 static int sh_mobile_lcdc_set_bpp(struct fb_var_screeninfo
*var
, int bpp
)
955 case 16: /* PKF[4:0] = 00011 - RGB 565 */
956 var
->red
.offset
= 11;
958 var
->green
.offset
= 5;
959 var
->green
.length
= 6;
960 var
->blue
.offset
= 0;
961 var
->blue
.length
= 5;
962 var
->transp
.offset
= 0;
963 var
->transp
.length
= 0;
966 case 32: /* PKF[4:0] = 00000 - RGB 888
967 * sh7722 pdf says 00RRGGBB but reality is GGBB00RR
968 * this may be because LDDDSR has word swap enabled..
972 var
->green
.offset
= 24;
973 var
->green
.length
= 8;
974 var
->blue
.offset
= 16;
975 var
->blue
.length
= 8;
976 var
->transp
.offset
= 0;
977 var
->transp
.length
= 0;
982 var
->bits_per_pixel
= bpp
;
983 var
->red
.msb_right
= 0;
984 var
->green
.msb_right
= 0;
985 var
->blue
.msb_right
= 0;
986 var
->transp
.msb_right
= 0;
990 static int sh_mobile_lcdc_suspend(struct device
*dev
)
992 struct platform_device
*pdev
= to_platform_device(dev
);
994 sh_mobile_lcdc_stop(platform_get_drvdata(pdev
));
998 static int sh_mobile_lcdc_resume(struct device
*dev
)
1000 struct platform_device
*pdev
= to_platform_device(dev
);
1002 return sh_mobile_lcdc_start(platform_get_drvdata(pdev
));
1005 static int sh_mobile_lcdc_runtime_suspend(struct device
*dev
)
1007 struct platform_device
*pdev
= to_platform_device(dev
);
1008 struct sh_mobile_lcdc_priv
*p
= platform_get_drvdata(pdev
);
1009 struct sh_mobile_lcdc_chan
*ch
;
1012 /* save per-channel registers */
1013 for (k
= 0; k
< ARRAY_SIZE(p
->ch
); k
++) {
1017 for (n
= 0; n
< NR_CH_REGS
; n
++)
1018 ch
->saved_ch_regs
[n
] = lcdc_read_chan(ch
, n
);
1021 /* save shared registers */
1022 for (n
= 0; n
< NR_SHARED_REGS
; n
++)
1023 p
->saved_shared_regs
[n
] = lcdc_read(p
, lcdc_shared_regs
[n
]);
1025 /* turn off LCDC hardware */
1026 lcdc_write(p
, _LDCNT1R
, 0);
1030 static int sh_mobile_lcdc_runtime_resume(struct device
*dev
)
1032 struct platform_device
*pdev
= to_platform_device(dev
);
1033 struct sh_mobile_lcdc_priv
*p
= platform_get_drvdata(pdev
);
1034 struct sh_mobile_lcdc_chan
*ch
;
1037 /* restore per-channel registers */
1038 for (k
= 0; k
< ARRAY_SIZE(p
->ch
); k
++) {
1042 for (n
= 0; n
< NR_CH_REGS
; n
++)
1043 lcdc_write_chan(ch
, n
, ch
->saved_ch_regs
[n
]);
1046 /* restore shared registers */
1047 for (n
= 0; n
< NR_SHARED_REGS
; n
++)
1048 lcdc_write(p
, lcdc_shared_regs
[n
], p
->saved_shared_regs
[n
]);
1053 static const struct dev_pm_ops sh_mobile_lcdc_dev_pm_ops
= {
1054 .suspend
= sh_mobile_lcdc_suspend
,
1055 .resume
= sh_mobile_lcdc_resume
,
1056 .runtime_suspend
= sh_mobile_lcdc_runtime_suspend
,
1057 .runtime_resume
= sh_mobile_lcdc_runtime_resume
,
1060 /* locking: called with info->lock held */
1061 static int sh_mobile_lcdc_notify(struct notifier_block
*nb
,
1062 unsigned long action
, void *data
)
1064 struct fb_event
*event
= data
;
1065 struct fb_info
*info
= event
->info
;
1066 struct sh_mobile_lcdc_chan
*ch
= info
->par
;
1067 struct sh_mobile_lcdc_board_cfg
*board_cfg
= &ch
->cfg
.board_cfg
;
1070 if (&ch
->lcdc
->notifier
!= nb
)
1073 dev_dbg(info
->dev
, "%s(): action = %lu, data = %p\n",
1074 __func__
, action
, event
->data
);
1077 case FB_EVENT_SUSPEND
:
1078 if (try_module_get(board_cfg
->owner
) && board_cfg
->display_off
) {
1079 board_cfg
->display_off(board_cfg
->board_data
);
1080 module_put(board_cfg
->owner
);
1082 pm_runtime_put(info
->device
);
1083 sh_mobile_lcdc_stop(ch
->lcdc
);
1085 case FB_EVENT_RESUME
:
1086 mutex_lock(&ch
->open_lock
);
1087 sh_mobile_fb_reconfig(info
);
1088 mutex_unlock(&ch
->open_lock
);
1090 /* HDMI must be enabled before LCDC configuration */
1091 if (try_module_get(board_cfg
->owner
) && board_cfg
->display_on
) {
1092 board_cfg
->display_on(board_cfg
->board_data
, info
);
1093 module_put(board_cfg
->owner
);
1096 ret
= sh_mobile_lcdc_start(ch
->lcdc
);
1098 pm_runtime_get_sync(info
->device
);
1104 static int sh_mobile_lcdc_remove(struct platform_device
*pdev
);
1106 static int __devinit
sh_mobile_lcdc_probe(struct platform_device
*pdev
)
1108 struct fb_info
*info
;
1109 struct sh_mobile_lcdc_priv
*priv
;
1110 struct sh_mobile_lcdc_info
*pdata
= pdev
->dev
.platform_data
;
1111 struct resource
*res
;
1117 dev_err(&pdev
->dev
, "no platform data defined\n");
1121 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
1122 i
= platform_get_irq(pdev
, 0);
1123 if (!res
|| i
< 0) {
1124 dev_err(&pdev
->dev
, "cannot get platform resources\n");
1128 priv
= kzalloc(sizeof(*priv
), GFP_KERNEL
);
1130 dev_err(&pdev
->dev
, "cannot allocate device data\n");
1134 platform_set_drvdata(pdev
, priv
);
1136 error
= request_irq(i
, sh_mobile_lcdc_irq
, IRQF_DISABLED
,
1137 dev_name(&pdev
->dev
), priv
);
1139 dev_err(&pdev
->dev
, "unable to request irq\n");
1144 atomic_set(&priv
->hw_usecnt
, -1);
1147 for (i
= 0; i
< ARRAY_SIZE(pdata
->ch
); i
++) {
1148 struct sh_mobile_lcdc_chan
*ch
= priv
->ch
+ j
;
1151 memcpy(&ch
->cfg
, &pdata
->ch
[i
], sizeof(pdata
->ch
[i
]));
1153 error
= sh_mobile_lcdc_check_interface(ch
);
1155 dev_err(&pdev
->dev
, "unsupported interface type\n");
1158 init_waitqueue_head(&ch
->frame_end_wait
);
1159 init_completion(&ch
->vsync_completion
);
1162 switch (pdata
->ch
[i
].chan
) {
1163 case LCDC_CHAN_MAINLCD
:
1164 ch
->enabled
= 1 << 1;
1165 ch
->reg_offs
= lcdc_offs_mainlcd
;
1168 case LCDC_CHAN_SUBLCD
:
1169 ch
->enabled
= 1 << 2;
1170 ch
->reg_offs
= lcdc_offs_sublcd
;
1177 dev_err(&pdev
->dev
, "no channels defined\n");
1182 priv
->base
= ioremap_nocache(res
->start
, resource_size(res
));
1186 error
= sh_mobile_lcdc_setup_clocks(pdev
, pdata
->clock_source
, priv
);
1188 dev_err(&pdev
->dev
, "unable to setup clocks\n");
1192 for (i
= 0; i
< j
; i
++) {
1193 struct fb_var_screeninfo
*var
;
1194 const struct fb_videomode
*lcd_cfg
, *max_cfg
= NULL
;
1195 struct sh_mobile_lcdc_chan
*ch
= priv
->ch
+ i
;
1196 struct sh_mobile_lcdc_chan_cfg
*cfg
= &ch
->cfg
;
1197 const struct fb_videomode
*mode
= cfg
->lcd_cfg
;
1198 unsigned long max_size
= 0;
1201 ch
->info
= framebuffer_alloc(0, &pdev
->dev
);
1203 dev_err(&pdev
->dev
, "unable to allocate fb_info\n");
1210 info
->fbops
= &sh_mobile_lcdc_ops
;
1213 mutex_init(&ch
->open_lock
);
1215 for (k
= 0, lcd_cfg
= mode
;
1216 k
< cfg
->num_cfg
&& lcd_cfg
;
1218 unsigned long size
= lcd_cfg
->yres
* lcd_cfg
->xres
;
1220 if (size
> max_size
) {
1227 max_size
= DEFAULT_XRES
* DEFAULT_YRES
;
1229 dev_dbg(&pdev
->dev
, "Found largest videomode %ux%u\n",
1230 max_cfg
->xres
, max_cfg
->yres
);
1232 info
->fix
= sh_mobile_lcdc_fix
;
1233 info
->fix
.smem_len
= max_size
* (cfg
->bpp
/ 8) * 2;
1236 mode
= &default_720p
;
1238 fb_videomode_to_var(var
, mode
);
1239 /* Default Y virtual resolution is 2x panel size */
1240 var
->yres_virtual
= var
->yres
* 2;
1241 var
->activate
= FB_ACTIVATE_NOW
;
1243 error
= sh_mobile_lcdc_set_bpp(var
, cfg
->bpp
);
1247 buf
= dma_alloc_coherent(&pdev
->dev
, info
->fix
.smem_len
,
1248 &ch
->dma_handle
, GFP_KERNEL
);
1250 dev_err(&pdev
->dev
, "unable to allocate buffer\n");
1255 info
->pseudo_palette
= &ch
->pseudo_palette
;
1256 info
->flags
= FBINFO_FLAG_DEFAULT
;
1258 error
= fb_alloc_cmap(&info
->cmap
, PALETTE_NR
, 0);
1260 dev_err(&pdev
->dev
, "unable to allocate cmap\n");
1261 dma_free_coherent(&pdev
->dev
, info
->fix
.smem_len
,
1262 buf
, ch
->dma_handle
);
1266 info
->fix
.smem_start
= ch
->dma_handle
;
1267 info
->fix
.line_length
= var
->xres
* (cfg
->bpp
/ 8);
1268 info
->screen_base
= buf
;
1269 info
->device
= &pdev
->dev
;
1270 ch
->display_var
= *var
;
1276 error
= sh_mobile_lcdc_start(priv
);
1278 dev_err(&pdev
->dev
, "unable to start hardware\n");
1282 for (i
= 0; i
< j
; i
++) {
1283 struct sh_mobile_lcdc_chan
*ch
= priv
->ch
+ i
;
1284 const struct fb_videomode
*mode
= ch
->cfg
.lcd_cfg
;
1287 mode
= &default_720p
;
1291 if (info
->fbdefio
) {
1292 ch
->sglist
= vmalloc(sizeof(struct scatterlist
) *
1293 info
->fix
.smem_len
>> PAGE_SHIFT
);
1295 dev_err(&pdev
->dev
, "cannot allocate sglist\n");
1300 fb_videomode_to_modelist(mode
, ch
->cfg
.num_cfg
, &info
->modelist
);
1301 error
= register_framebuffer(info
);
1306 "registered %s/%s as %dx%d %dbpp.\n",
1308 (ch
->cfg
.chan
== LCDC_CHAN_MAINLCD
) ?
1309 "mainlcd" : "sublcd",
1310 info
->var
.xres
, info
->var
.yres
,
1313 /* deferred io mode: disable clock to save power */
1314 if (info
->fbdefio
|| info
->state
== FBINFO_STATE_SUSPENDED
)
1315 sh_mobile_lcdc_clk_off(priv
);
1318 /* Failure ignored */
1319 priv
->notifier
.notifier_call
= sh_mobile_lcdc_notify
;
1320 fb_register_client(&priv
->notifier
);
1324 sh_mobile_lcdc_remove(pdev
);
1329 static int sh_mobile_lcdc_remove(struct platform_device
*pdev
)
1331 struct sh_mobile_lcdc_priv
*priv
= platform_get_drvdata(pdev
);
1332 struct fb_info
*info
;
1335 fb_unregister_client(&priv
->notifier
);
1337 for (i
= 0; i
< ARRAY_SIZE(priv
->ch
); i
++)
1338 if (priv
->ch
[i
].info
&& priv
->ch
[i
].info
->dev
)
1339 unregister_framebuffer(priv
->ch
[i
].info
);
1341 sh_mobile_lcdc_stop(priv
);
1343 for (i
= 0; i
< ARRAY_SIZE(priv
->ch
); i
++) {
1344 info
= priv
->ch
[i
].info
;
1346 if (!info
|| !info
->device
)
1349 if (priv
->ch
[i
].sglist
)
1350 vfree(priv
->ch
[i
].sglist
);
1352 if (info
->screen_base
)
1353 dma_free_coherent(&pdev
->dev
, info
->fix
.smem_len
,
1355 priv
->ch
[i
].dma_handle
);
1356 fb_dealloc_cmap(&info
->cmap
);
1357 framebuffer_release(info
);
1361 clk_put(priv
->dot_clk
);
1364 pm_runtime_disable(priv
->dev
);
1367 iounmap(priv
->base
);
1370 free_irq(priv
->irq
, priv
);
1375 static struct platform_driver sh_mobile_lcdc_driver
= {
1377 .name
= "sh_mobile_lcdc_fb",
1378 .owner
= THIS_MODULE
,
1379 .pm
= &sh_mobile_lcdc_dev_pm_ops
,
1381 .probe
= sh_mobile_lcdc_probe
,
1382 .remove
= sh_mobile_lcdc_remove
,
1385 static int __init
sh_mobile_lcdc_init(void)
1387 return platform_driver_register(&sh_mobile_lcdc_driver
);
1390 static void __exit
sh_mobile_lcdc_exit(void)
1392 platform_driver_unregister(&sh_mobile_lcdc_driver
);
1395 module_init(sh_mobile_lcdc_init
);
1396 module_exit(sh_mobile_lcdc_exit
);
1398 MODULE_DESCRIPTION("SuperH Mobile LCDC Framebuffer driver");
1399 MODULE_AUTHOR("Magnus Damm <damm@opensource.se>");
1400 MODULE_LICENSE("GPL v2");