1 /* linux/drivers/video/s3c-fb.c
3 * Copyright 2008 Openmoko Inc.
4 * Copyright 2008 Simtec Electronics
5 * Ben Dooks <ben@simtec.co.uk>
6 * http://armlinux.simtec.co.uk/
8 * Samsung SoC Framebuffer driver
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License version 2 as
12 * published by the Free Software Foundation.
15 #include <linux/kernel.h>
16 #include <linux/module.h>
17 #include <linux/platform_device.h>
18 #include <linux/dma-mapping.h>
19 #include <linux/init.h>
20 #include <linux/gfp.h>
21 #include <linux/clk.h>
26 #include <mach/regs-fb.h>
29 /* This driver will export a number of framebuffer interfaces depending
30 * on the configuration passed in via the platform data. Each fb instance
31 * maps to a hardware window. Currently there is no support for runtime
32 * setting of the alpha-blending functions that each window has, so only
33 * window 0 is actually useful.
35 * Window 0 is treated specially, it is used for the basis of the LCD
36 * output timings and as the control for the output power-down state.
39 /* note, some of the functions that get called are derived from including
40 * <mach/regs-fb.h> as they are specific to the architecture that the code
44 #ifdef CONFIG_FB_S3C_DEBUG_REGWRITE
46 #define writel(v, r) do { \
47 printk(KERN_DEBUG "%s: %08x => %p\n", __func__, (unsigned int)v, r); \
48 __raw_writel(v, r); } while(0)
49 #endif /* FB_S3C_DEBUG_REGWRITE */
54 * struct s3c_fb_win - per window private data for each framebuffer.
55 * @windata: The platform data supplied for the window configuration.
56 * @parent: The hardware that this window is part of.
57 * @fbinfo: Pointer pack to the framebuffer info for this window.
58 * @palette_buffer: Buffer/cache to hold palette entries.
59 * @pseudo_palette: For use in TRUECOLOUR modes for entries 0..15/
60 * @index: The window number of this window.
61 * @palette: The bitfields for changing r/g/b into a hardware palette entry.
64 struct s3c_fb_pd_win
*windata
;
65 struct s3c_fb
*parent
;
66 struct fb_info
*fbinfo
;
67 struct s3c_fb_palette palette
;
70 u32 pseudo_palette
[16];
75 * struct s3c_fb - overall hardware state of the hardware
76 * @dev: The device that we bound to, for printing, etc.
77 * @regs_res: The resource we claimed for the IO registers.
78 * @bus_clk: The clk (hclk) feeding our interface and possibly pixclk.
79 * @regs: The mapped hardware registers.
80 * @enabled: A bitmask of enabled hardware windows.
81 * @pdata: The platform configuration data passed with the device.
82 * @windows: The hardware windows that have been claimed.
86 struct resource
*regs_res
;
90 unsigned char enabled
;
92 struct s3c_fb_platdata
*pdata
;
93 struct s3c_fb_win
*windows
[S3C_FB_MAX_WIN
];
97 * s3c_fb_win_has_palette() - determine if a mode has a palette
98 * @win: The window number being queried.
99 * @bpp: The number of bits per pixel to test.
101 * Work out if the given window supports palletised data at the specified bpp.
103 static int s3c_fb_win_has_palette(unsigned int win
, unsigned int bpp
)
105 return s3c_fb_win_pal_size(win
) <= (1 << bpp
);
109 * s3c_fb_check_var() - framebuffer layer request to verify a given mode.
110 * @var: The screen information to verify.
111 * @info: The framebuffer device.
113 * Framebuffer layer call to verify the given information and allow us to
114 * update various information depending on the hardware capabilities.
116 static int s3c_fb_check_var(struct fb_var_screeninfo
*var
,
117 struct fb_info
*info
)
119 struct s3c_fb_win
*win
= info
->par
;
120 struct s3c_fb_pd_win
*windata
= win
->windata
;
121 struct s3c_fb
*sfb
= win
->parent
;
123 dev_dbg(sfb
->dev
, "checking parameters\n");
125 var
->xres_virtual
= max((unsigned int)windata
->virtual_x
, var
->xres
);
126 var
->yres_virtual
= max((unsigned int)windata
->virtual_y
, var
->yres
);
128 if (!s3c_fb_validate_win_bpp(win
->index
, var
->bits_per_pixel
)) {
129 dev_dbg(sfb
->dev
, "win %d: unsupported bpp %d\n",
130 win
->index
, var
->bits_per_pixel
);
134 /* always ensure these are zero, for drop through cases below */
135 var
->transp
.offset
= 0;
136 var
->transp
.length
= 0;
138 switch (var
->bits_per_pixel
) {
143 if (!s3c_fb_win_has_palette(win
->index
, var
->bits_per_pixel
)) {
144 /* non palletised, A:1,R:2,G:3,B:2 mode */
146 var
->green
.offset
= 2;
147 var
->blue
.offset
= 0;
149 var
->green
.length
= 3;
150 var
->blue
.length
= 2;
151 var
->transp
.offset
= 7;
152 var
->transp
.length
= 1;
155 var
->red
.length
= var
->bits_per_pixel
;
156 var
->green
= var
->red
;
157 var
->blue
= var
->red
;
162 /* 666 with one bit alpha/transparency */
163 var
->transp
.offset
= 18;
164 var
->transp
.length
= 1;
166 var
->bits_per_pixel
= 32;
169 var
->red
.offset
= 12;
170 var
->green
.offset
= 6;
171 var
->blue
.offset
= 0;
173 var
->green
.length
= 6;
174 var
->blue
.length
= 6;
178 /* 16 bpp, 565 format */
179 var
->red
.offset
= 11;
180 var
->green
.offset
= 5;
181 var
->blue
.offset
= 0;
183 var
->green
.length
= 6;
184 var
->blue
.length
= 5;
189 var
->transp
.length
= var
->bits_per_pixel
- 24;
190 var
->transp
.offset
= 24;
193 /* our 24bpp is unpacked, so 32bpp */
194 var
->bits_per_pixel
= 32;
196 var
->red
.offset
= 16;
198 var
->green
.offset
= 8;
199 var
->green
.length
= 8;
200 var
->blue
.offset
= 0;
201 var
->blue
.length
= 8;
205 dev_err(sfb
->dev
, "invalid bpp\n");
208 dev_dbg(sfb
->dev
, "%s: verified parameters\n", __func__
);
213 * s3c_fb_calc_pixclk() - calculate the divider to create the pixel clock.
214 * @sfb: The hardware state.
215 * @pixclock: The pixel clock wanted, in picoseconds.
217 * Given the specified pixel clock, work out the necessary divider to get
218 * close to the output frequency.
220 static int s3c_fb_calc_pixclk(struct s3c_fb
*sfb
, unsigned int pixclk
)
222 unsigned long clk
= clk_get_rate(sfb
->bus_clk
);
223 unsigned long long tmp
;
226 tmp
= (unsigned long long)clk
;
229 do_div(tmp
, 1000000000UL);
230 result
= (unsigned int)tmp
/ 1000;
232 dev_dbg(sfb
->dev
, "pixclk=%u, clk=%lu, div=%d (%lu)\n",
233 pixclk
, clk
, result
, clk
/ result
);
239 * s3c_fb_align_word() - align pixel count to word boundary
240 * @bpp: The number of bits per pixel
241 * @pix: The value to be aligned.
243 * Align the given pixel count so that it will start on an 32bit word
246 static int s3c_fb_align_word(unsigned int bpp
, unsigned int pix
)
253 pix_per_word
= (8 * 32) / bpp
;
254 return ALIGN(pix
, pix_per_word
);
258 * s3c_fb_set_par() - framebuffer request to set new framebuffer state.
259 * @info: The framebuffer to change.
261 * Framebuffer layer request to set a new mode for the specified framebuffer
263 static int s3c_fb_set_par(struct fb_info
*info
)
265 struct fb_var_screeninfo
*var
= &info
->var
;
266 struct s3c_fb_win
*win
= info
->par
;
267 struct s3c_fb
*sfb
= win
->parent
;
268 void __iomem
*regs
= sfb
->regs
;
269 int win_no
= win
->index
;
274 dev_dbg(sfb
->dev
, "setting framebuffer parameters\n");
276 switch (var
->bits_per_pixel
) {
281 info
->fix
.visual
= FB_VISUAL_TRUECOLOR
;
284 if (s3c_fb_win_has_palette(win_no
, 8))
285 info
->fix
.visual
= FB_VISUAL_PSEUDOCOLOR
;
287 info
->fix
.visual
= FB_VISUAL_TRUECOLOR
;
290 info
->fix
.visual
= FB_VISUAL_MONO01
;
293 info
->fix
.visual
= FB_VISUAL_PSEUDOCOLOR
;
297 info
->fix
.line_length
= (var
->xres_virtual
* var
->bits_per_pixel
) / 8;
299 /* disable the window whilst we update it */
300 writel(0, regs
+ WINCON(win_no
));
302 /* use window 0 as the basis for the lcd output timings */
305 clkdiv
= s3c_fb_calc_pixclk(sfb
, var
->pixclock
);
307 data
= sfb
->pdata
->vidcon0
;
308 data
&= ~(VIDCON0_CLKVAL_F_MASK
| VIDCON0_CLKDIR
);
311 data
|= VIDCON0_CLKVAL_F(clkdiv
-1) | VIDCON0_CLKDIR
;
313 data
&= ~VIDCON0_CLKDIR
; /* 1:1 clock */
315 /* write the timing data to the panel */
317 data
|= VIDCON0_ENVID
| VIDCON0_ENVID_F
;
318 writel(data
, regs
+ VIDCON0
);
320 data
= VIDTCON0_VBPD(var
->upper_margin
- 1) |
321 VIDTCON0_VFPD(var
->lower_margin
- 1) |
322 VIDTCON0_VSPW(var
->vsync_len
- 1);
324 writel(data
, regs
+ VIDTCON0
);
326 data
= VIDTCON1_HBPD(var
->left_margin
- 1) |
327 VIDTCON1_HFPD(var
->right_margin
- 1) |
328 VIDTCON1_HSPW(var
->hsync_len
- 1);
330 writel(data
, regs
+ VIDTCON1
);
332 data
= VIDTCON2_LINEVAL(var
->yres
- 1) |
333 VIDTCON2_HOZVAL(var
->xres
- 1);
334 writel(data
, regs
+ VIDTCON2
);
337 /* write the buffer address */
339 writel(info
->fix
.smem_start
, regs
+ VIDW_BUF_START(win_no
));
341 data
= info
->fix
.smem_start
+ info
->fix
.line_length
* var
->yres
;
342 writel(data
, regs
+ VIDW_BUF_END(win_no
));
344 pagewidth
= (var
->xres
* var
->bits_per_pixel
) >> 3;
345 data
= VIDW_BUF_SIZE_OFFSET(info
->fix
.line_length
- pagewidth
) |
346 VIDW_BUF_SIZE_PAGEWIDTH(pagewidth
);
347 writel(data
, regs
+ VIDW_BUF_SIZE(win_no
));
349 /* write 'OSD' registers to control position of framebuffer */
351 data
= VIDOSDxA_TOPLEFT_X(0) | VIDOSDxA_TOPLEFT_Y(0);
352 writel(data
, regs
+ VIDOSD_A(win_no
));
354 data
= VIDOSDxB_BOTRIGHT_X(s3c_fb_align_word(var
->bits_per_pixel
,
356 VIDOSDxB_BOTRIGHT_Y(var
->yres
- 1);
358 writel(data
, regs
+ VIDOSD_B(win_no
));
360 data
= var
->xres
* var
->yres
;
364 osdc_data
= VIDISD14C_ALPHA1_R(0xf) |
365 VIDISD14C_ALPHA1_G(0xf) |
366 VIDISD14C_ALPHA1_B(0xf);
368 if (s3c_fb_has_osd_d(win_no
)) {
369 writel(data
, regs
+ VIDOSD_D(win_no
));
370 writel(osdc_data
, regs
+ VIDOSD_C(win_no
));
372 writel(data
, regs
+ VIDOSD_C(win_no
));
374 data
= WINCONx_ENWIN
;
376 /* note, since we have to round up the bits-per-pixel, we end up
377 * relying on the bitfield information for r/g/b/a to work out
378 * exactly which mode of operation is intended. */
380 switch (var
->bits_per_pixel
) {
382 data
|= WINCON0_BPPMODE_1BPP
;
383 data
|= WINCONx_BITSWP
;
384 data
|= WINCONx_BURSTLEN_4WORD
;
387 data
|= WINCON0_BPPMODE_2BPP
;
388 data
|= WINCONx_BITSWP
;
389 data
|= WINCONx_BURSTLEN_8WORD
;
392 data
|= WINCON0_BPPMODE_4BPP
;
393 data
|= WINCONx_BITSWP
;
394 data
|= WINCONx_BURSTLEN_8WORD
;
397 if (var
->transp
.length
!= 0)
398 data
|= WINCON1_BPPMODE_8BPP_1232
;
400 data
|= WINCON0_BPPMODE_8BPP_PALETTE
;
401 data
|= WINCONx_BURSTLEN_8WORD
;
402 data
|= WINCONx_BYTSWP
;
405 if (var
->transp
.length
!= 0)
406 data
|= WINCON1_BPPMODE_16BPP_A1555
;
408 data
|= WINCON0_BPPMODE_16BPP_565
;
409 data
|= WINCONx_HAWSWP
;
410 data
|= WINCONx_BURSTLEN_16WORD
;
414 if (var
->red
.length
== 6) {
415 if (var
->transp
.length
!= 0)
416 data
|= WINCON1_BPPMODE_19BPP_A1666
;
418 data
|= WINCON1_BPPMODE_18BPP_666
;
419 } else if (var
->transp
.length
== 1)
420 data
|= WINCON1_BPPMODE_25BPP_A1888
422 else if (var
->transp
.length
== 4)
423 data
|= WINCON1_BPPMODE_28BPP_A4888
424 | WINCON1_BLD_PIX
| WINCON1_ALPHA_SEL
;
426 data
|= WINCON0_BPPMODE_24BPP_888
;
428 data
|= WINCONx_BURSTLEN_16WORD
;
432 /* It has no color key control register for window0 */
434 u32 keycon0_data
= 0, keycon1_data
= 0;
436 keycon0_data
= ~(WxKEYCON0_KEYBL_EN
|
438 WxKEYCON0_DIRCON
) | WxKEYCON0_COMPKEY(0);
440 keycon1_data
= WxKEYCON1_COLVAL(0xffffff);
442 writel(keycon0_data
, regs
+ WxKEYCONy(win_no
-1, 0));
443 writel(keycon1_data
, regs
+ WxKEYCONy(win_no
-1, 1));
446 writel(data
, regs
+ WINCON(win_no
));
447 writel(0x0, regs
+ WINxMAP(win_no
));
453 * s3c_fb_update_palette() - set or schedule a palette update.
454 * @sfb: The hardware information.
455 * @win: The window being updated.
456 * @reg: The palette index being changed.
457 * @value: The computed palette value.
459 * Change the value of a palette register, either by directly writing to
460 * the palette (this requires the palette RAM to be disconnected from the
461 * hardware whilst this is in progress) or schedule the update for later.
463 * At the moment, since we have no VSYNC interrupt support, we simply set
464 * the palette entry directly.
466 static void s3c_fb_update_palette(struct s3c_fb
*sfb
,
467 struct s3c_fb_win
*win
,
471 void __iomem
*palreg
;
474 palreg
= sfb
->regs
+ s3c_fb_pal_reg(win
->index
, reg
);
476 dev_dbg(sfb
->dev
, "%s: win %d, reg %d (%p): %08x\n",
477 __func__
, win
->index
, reg
, palreg
, value
);
479 win
->palette_buffer
[reg
] = value
;
481 palcon
= readl(sfb
->regs
+ WPALCON
);
482 writel(palcon
| WPALCON_PAL_UPDATE
, sfb
->regs
+ WPALCON
);
484 if (s3c_fb_pal_is16(win
->index
))
485 writew(value
, palreg
);
487 writel(value
, palreg
);
489 writel(palcon
, sfb
->regs
+ WPALCON
);
492 static inline unsigned int chan_to_field(unsigned int chan
,
493 struct fb_bitfield
*bf
)
496 chan
>>= 16 - bf
->length
;
497 return chan
<< bf
->offset
;
501 * s3c_fb_setcolreg() - framebuffer layer request to change palette.
502 * @regno: The palette index to change.
503 * @red: The red field for the palette data.
504 * @green: The green field for the palette data.
505 * @blue: The blue field for the palette data.
506 * @trans: The transparency (alpha) field for the palette data.
507 * @info: The framebuffer being changed.
509 static int s3c_fb_setcolreg(unsigned regno
,
510 unsigned red
, unsigned green
, unsigned blue
,
511 unsigned transp
, struct fb_info
*info
)
513 struct s3c_fb_win
*win
= info
->par
;
514 struct s3c_fb
*sfb
= win
->parent
;
517 dev_dbg(sfb
->dev
, "%s: win %d: %d => rgb=%d/%d/%d\n",
518 __func__
, win
->index
, regno
, red
, green
, blue
);
520 switch (info
->fix
.visual
) {
521 case FB_VISUAL_TRUECOLOR
:
522 /* true-colour, use pseudo-palette */
525 u32
*pal
= info
->pseudo_palette
;
527 val
= chan_to_field(red
, &info
->var
.red
);
528 val
|= chan_to_field(green
, &info
->var
.green
);
529 val
|= chan_to_field(blue
, &info
->var
.blue
);
535 case FB_VISUAL_PSEUDOCOLOR
:
536 if (regno
< s3c_fb_win_pal_size(win
->index
)) {
537 val
= chan_to_field(red
, &win
->palette
.r
);
538 val
|= chan_to_field(green
, &win
->palette
.g
);
539 val
|= chan_to_field(blue
, &win
->palette
.b
);
541 s3c_fb_update_palette(sfb
, win
, regno
, val
);
547 return 1; /* unknown type */
554 * s3c_fb_enable() - Set the state of the main LCD output
555 * @sfb: The main framebuffer state.
556 * @enable: The state to set.
558 static void s3c_fb_enable(struct s3c_fb
*sfb
, int enable
)
560 u32 vidcon0
= readl(sfb
->regs
+ VIDCON0
);
563 vidcon0
|= VIDCON0_ENVID
| VIDCON0_ENVID_F
;
565 /* see the note in the framebuffer datasheet about
566 * why you cannot take both of these bits down at the
569 if (!(vidcon0
& VIDCON0_ENVID
))
572 vidcon0
|= VIDCON0_ENVID
;
573 vidcon0
&= ~VIDCON0_ENVID_F
;
576 writel(vidcon0
, sfb
->regs
+ VIDCON0
);
580 * s3c_fb_blank() - blank or unblank the given window
581 * @blank_mode: The blank state from FB_BLANK_*
582 * @info: The framebuffer to blank.
584 * Framebuffer layer request to change the power state.
586 static int s3c_fb_blank(int blank_mode
, struct fb_info
*info
)
588 struct s3c_fb_win
*win
= info
->par
;
589 struct s3c_fb
*sfb
= win
->parent
;
590 unsigned int index
= win
->index
;
593 dev_dbg(sfb
->dev
, "blank mode %d\n", blank_mode
);
595 wincon
= readl(sfb
->regs
+ WINCON(index
));
597 switch (blank_mode
) {
598 case FB_BLANK_POWERDOWN
:
599 wincon
&= ~WINCONx_ENWIN
;
600 sfb
->enabled
&= ~(1 << index
);
601 /* fall through to FB_BLANK_NORMAL */
603 case FB_BLANK_NORMAL
:
604 /* disable the DMA and display 0x0 (black) */
605 writel(WINxMAP_MAP
| WINxMAP_MAP_COLOUR(0x0),
606 sfb
->regs
+ WINxMAP(index
));
609 case FB_BLANK_UNBLANK
:
610 writel(0x0, sfb
->regs
+ WINxMAP(index
));
611 wincon
|= WINCONx_ENWIN
;
612 sfb
->enabled
|= (1 << index
);
615 case FB_BLANK_VSYNC_SUSPEND
:
616 case FB_BLANK_HSYNC_SUSPEND
:
621 writel(wincon
, sfb
->regs
+ WINCON(index
));
623 /* Check the enabled state to see if we need to be running the
624 * main LCD interface, as if there are no active windows then
625 * it is highly likely that we also do not need to output
629 /* We could do something like the following code, but the current
630 * system of using framebuffer events means that we cannot make
631 * the distinction between just window 0 being inactive and all
632 * the windows being down.
634 * s3c_fb_enable(sfb, sfb->enabled ? 1 : 0);
637 /* we're stuck with this until we can do something about overriding
638 * the power control using the blanking event for a single fb.
641 s3c_fb_enable(sfb
, blank_mode
!= FB_BLANK_POWERDOWN
? 1 : 0);
646 static struct fb_ops s3c_fb_ops
= {
647 .owner
= THIS_MODULE
,
648 .fb_check_var
= s3c_fb_check_var
,
649 .fb_set_par
= s3c_fb_set_par
,
650 .fb_blank
= s3c_fb_blank
,
651 .fb_setcolreg
= s3c_fb_setcolreg
,
652 .fb_fillrect
= cfb_fillrect
,
653 .fb_copyarea
= cfb_copyarea
,
654 .fb_imageblit
= cfb_imageblit
,
658 * s3c_fb_alloc_memory() - allocate display memory for framebuffer window
659 * @sfb: The base resources for the hardware.
660 * @win: The window to initialise memory for.
662 * Allocate memory for the given framebuffer.
664 static int __devinit
s3c_fb_alloc_memory(struct s3c_fb
*sfb
,
665 struct s3c_fb_win
*win
)
667 struct s3c_fb_pd_win
*windata
= win
->windata
;
668 unsigned int real_size
, virt_size
, size
;
669 struct fb_info
*fbi
= win
->fbinfo
;
672 dev_dbg(sfb
->dev
, "allocating memory for display\n");
674 real_size
= windata
->win_mode
.xres
* windata
->win_mode
.yres
;
675 virt_size
= windata
->virtual_x
* windata
->virtual_y
;
677 dev_dbg(sfb
->dev
, "real_size=%u (%u.%u), virt_size=%u (%u.%u)\n",
678 real_size
, windata
->win_mode
.xres
, windata
->win_mode
.yres
,
679 virt_size
, windata
->virtual_x
, windata
->virtual_y
);
681 size
= (real_size
> virt_size
) ? real_size
: virt_size
;
682 size
*= (windata
->max_bpp
> 16) ? 32 : windata
->max_bpp
;
685 fbi
->fix
.smem_len
= size
;
686 size
= PAGE_ALIGN(size
);
688 dev_dbg(sfb
->dev
, "want %u bytes for window\n", size
);
690 fbi
->screen_base
= dma_alloc_writecombine(sfb
->dev
, size
,
691 &map_dma
, GFP_KERNEL
);
692 if (!fbi
->screen_base
)
695 dev_dbg(sfb
->dev
, "mapped %x to %p\n",
696 (unsigned int)map_dma
, fbi
->screen_base
);
698 memset(fbi
->screen_base
, 0x0, size
);
699 fbi
->fix
.smem_start
= map_dma
;
705 * s3c_fb_free_memory() - free the display memory for the given window
706 * @sfb: The base resources for the hardware.
707 * @win: The window to free the display memory for.
709 * Free the display memory allocated by s3c_fb_alloc_memory().
711 static void s3c_fb_free_memory(struct s3c_fb
*sfb
, struct s3c_fb_win
*win
)
713 struct fb_info
*fbi
= win
->fbinfo
;
715 dma_free_writecombine(sfb
->dev
, PAGE_ALIGN(fbi
->fix
.smem_len
),
716 fbi
->screen_base
, fbi
->fix
.smem_start
);
720 * s3c_fb_release_win() - release resources for a framebuffer window.
721 * @win: The window to cleanup the resources for.
723 * Release the resources that where claimed for the hardware window,
724 * such as the framebuffer instance and any memory claimed for it.
726 static void s3c_fb_release_win(struct s3c_fb
*sfb
, struct s3c_fb_win
*win
)
729 unregister_framebuffer(win
->fbinfo
);
730 fb_dealloc_cmap(&win
->fbinfo
->cmap
);
731 s3c_fb_free_memory(sfb
, win
);
732 framebuffer_release(win
->fbinfo
);
737 * s3c_fb_probe_win() - register an hardware window
738 * @sfb: The base resources for the hardware
739 * @res: Pointer to where to place the resultant window.
741 * Allocate and do the basic initialisation for one of the hardware's graphics
744 static int __devinit
s3c_fb_probe_win(struct s3c_fb
*sfb
, unsigned int win_no
,
745 struct s3c_fb_win
**res
)
747 struct fb_var_screeninfo
*var
;
748 struct fb_videomode
*initmode
;
749 struct s3c_fb_pd_win
*windata
;
750 struct s3c_fb_win
*win
;
751 struct fb_info
*fbinfo
;
755 dev_dbg(sfb
->dev
, "probing window %d\n", win_no
);
757 palette_size
= s3c_fb_win_pal_size(win_no
);
759 fbinfo
= framebuffer_alloc(sizeof(struct s3c_fb_win
) +
760 palette_size
* sizeof(u32
), sfb
->dev
);
762 dev_err(sfb
->dev
, "failed to allocate framebuffer\n");
766 windata
= sfb
->pdata
->win
[win_no
];
767 initmode
= &windata
->win_mode
;
769 WARN_ON(windata
->max_bpp
== 0);
770 WARN_ON(windata
->win_mode
.xres
== 0);
771 WARN_ON(windata
->win_mode
.yres
== 0);
775 win
->fbinfo
= fbinfo
;
777 win
->windata
= windata
;
779 win
->palette_buffer
= (u32
*)(win
+ 1);
781 ret
= s3c_fb_alloc_memory(sfb
, win
);
783 dev_err(sfb
->dev
, "failed to allocate display memory\n");
787 /* setup the r/b/g positions for the window's palette */
788 s3c_fb_init_palette(win_no
, &win
->palette
);
790 /* setup the initial video mode from the window */
791 fb_videomode_to_var(&fbinfo
->var
, initmode
);
793 fbinfo
->fix
.type
= FB_TYPE_PACKED_PIXELS
;
794 fbinfo
->fix
.accel
= FB_ACCEL_NONE
;
795 fbinfo
->var
.activate
= FB_ACTIVATE_NOW
;
796 fbinfo
->var
.vmode
= FB_VMODE_NONINTERLACED
;
797 fbinfo
->var
.bits_per_pixel
= windata
->default_bpp
;
798 fbinfo
->fbops
= &s3c_fb_ops
;
799 fbinfo
->flags
= FBINFO_FLAG_DEFAULT
;
800 fbinfo
->pseudo_palette
= &win
->pseudo_palette
;
802 /* prepare to actually start the framebuffer */
804 ret
= s3c_fb_check_var(&fbinfo
->var
, fbinfo
);
806 dev_err(sfb
->dev
, "check_var failed on initial video params\n");
810 /* create initial colour map */
812 ret
= fb_alloc_cmap(&fbinfo
->cmap
, s3c_fb_win_pal_size(win_no
), 1);
814 fb_set_cmap(&fbinfo
->cmap
, fbinfo
);
816 dev_err(sfb
->dev
, "failed to allocate fb cmap\n");
818 s3c_fb_set_par(fbinfo
);
820 dev_dbg(sfb
->dev
, "about to register framebuffer\n");
822 /* run the check_var and set_par on our configuration. */
824 ret
= register_framebuffer(fbinfo
);
826 dev_err(sfb
->dev
, "failed to register framebuffer\n");
831 dev_info(sfb
->dev
, "window %d: fb %s\n", win_no
, fbinfo
->fix
.id
);
837 * s3c_fb_clear_win() - clear hardware window registers.
838 * @sfb: The base resources for the hardware.
839 * @win: The window to process.
841 * Reset the specific window registers to a known state.
843 static void s3c_fb_clear_win(struct s3c_fb
*sfb
, int win
)
845 void __iomem
*regs
= sfb
->regs
;
847 writel(0, regs
+ WINCON(win
));
848 writel(0xffffff, regs
+ WxKEYCONy(win
, 0));
849 writel(0xffffff, regs
+ WxKEYCONy(win
, 1));
851 writel(0, regs
+ VIDOSD_A(win
));
852 writel(0, regs
+ VIDOSD_B(win
));
853 writel(0, regs
+ VIDOSD_C(win
));
856 static int __devinit
s3c_fb_probe(struct platform_device
*pdev
)
858 struct device
*dev
= &pdev
->dev
;
859 struct s3c_fb_platdata
*pd
;
861 struct resource
*res
;
865 pd
= pdev
->dev
.platform_data
;
867 dev_err(dev
, "no platform data specified\n");
871 sfb
= kzalloc(sizeof(struct s3c_fb
), GFP_KERNEL
);
873 dev_err(dev
, "no memory for framebuffers\n");
880 sfb
->bus_clk
= clk_get(dev
, "lcd");
881 if (IS_ERR(sfb
->bus_clk
)) {
882 dev_err(dev
, "failed to get bus clock\n");
886 clk_enable(sfb
->bus_clk
);
888 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
890 dev_err(dev
, "failed to find registers\n");
895 sfb
->regs_res
= request_mem_region(res
->start
, resource_size(res
),
897 if (!sfb
->regs_res
) {
898 dev_err(dev
, "failed to claim register region\n");
903 sfb
->regs
= ioremap(res
->start
, resource_size(res
));
905 dev_err(dev
, "failed to map registers\n");
910 dev_dbg(dev
, "got resources (regs %p), probing windows\n", sfb
->regs
);
912 /* setup gpio and output polarity controls */
916 writel(pd
->vidcon1
, sfb
->regs
+ VIDCON1
);
918 /* zero all windows before we do anything */
920 for (win
= 0; win
< S3C_FB_MAX_WIN
; win
++)
921 s3c_fb_clear_win(sfb
, win
);
923 /* we have the register setup, start allocating framebuffers */
925 for (win
= 0; win
< S3C_FB_MAX_WIN
; win
++) {
929 ret
= s3c_fb_probe_win(sfb
, win
, &sfb
->windows
[win
]);
931 dev_err(dev
, "failed to create window %d\n", win
);
932 for (; win
>= 0; win
--)
933 s3c_fb_release_win(sfb
, sfb
->windows
[win
]);
938 platform_set_drvdata(pdev
, sfb
);
946 release_resource(sfb
->regs_res
);
947 kfree(sfb
->regs_res
);
950 clk_disable(sfb
->bus_clk
);
951 clk_put(sfb
->bus_clk
);
959 * s3c_fb_remove() - Cleanup on module finalisation
960 * @pdev: The platform device we are bound to.
962 * Shutdown and then release all the resources that the driver allocated
965 static int __devexit
s3c_fb_remove(struct platform_device
*pdev
)
967 struct s3c_fb
*sfb
= platform_get_drvdata(pdev
);
970 for (win
= 0; win
<= S3C_FB_MAX_WIN
; win
++)
971 if (sfb
->windows
[win
])
972 s3c_fb_release_win(sfb
, sfb
->windows
[win
]);
976 clk_disable(sfb
->bus_clk
);
977 clk_put(sfb
->bus_clk
);
979 release_resource(sfb
->regs_res
);
980 kfree(sfb
->regs_res
);
988 static int s3c_fb_suspend(struct platform_device
*pdev
, pm_message_t state
)
990 struct s3c_fb
*sfb
= platform_get_drvdata(pdev
);
991 struct s3c_fb_win
*win
;
994 for (win_no
= S3C_FB_MAX_WIN
; win_no
>= 0; win_no
--) {
995 win
= sfb
->windows
[win_no
];
999 /* use the blank function to push into power-down */
1000 s3c_fb_blank(FB_BLANK_POWERDOWN
, win
->fbinfo
);
1003 clk_disable(sfb
->bus_clk
);
1007 static int s3c_fb_resume(struct platform_device
*pdev
)
1009 struct s3c_fb
*sfb
= platform_get_drvdata(pdev
);
1010 struct s3c_fb_platdata
*pd
= sfb
->pdata
;
1011 struct s3c_fb_win
*win
;
1014 clk_enable(sfb
->bus_clk
);
1016 /* setup registers */
1017 writel(pd
->vidcon1
, sfb
->regs
+ VIDCON1
);
1019 /* zero all windows before we do anything */
1020 for (win_no
= 0; win_no
< S3C_FB_MAX_WIN
; win_no
++)
1021 s3c_fb_clear_win(sfb
, win_no
);
1023 /* restore framebuffers */
1024 for (win_no
= 0; win_no
< S3C_FB_MAX_WIN
; win_no
++) {
1025 win
= sfb
->windows
[win_no
];
1029 dev_dbg(&pdev
->dev
, "resuming window %d\n", win_no
);
1030 s3c_fb_set_par(win
->fbinfo
);
1036 #define s3c_fb_suspend NULL
1037 #define s3c_fb_resume NULL
1040 static struct platform_driver s3c_fb_driver
= {
1041 .probe
= s3c_fb_probe
,
1042 .remove
= s3c_fb_remove
,
1043 .suspend
= s3c_fb_suspend
,
1044 .resume
= s3c_fb_resume
,
1047 .owner
= THIS_MODULE
,
1051 static int __init
s3c_fb_init(void)
1053 return platform_driver_register(&s3c_fb_driver
);
1056 static void __exit
s3c_fb_cleanup(void)
1058 platform_driver_unregister(&s3c_fb_driver
);
1061 module_init(s3c_fb_init
);
1062 module_exit(s3c_fb_cleanup
);
1064 MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>");
1065 MODULE_DESCRIPTION("Samsung S3C SoC Framebuffer driver");
1066 MODULE_LICENSE("GPL");
1067 MODULE_ALIAS("platform:s3c-fb");