2 * linux/drivers/video/omap2/omapfb-main.c
4 * Copyright (C) 2008 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 #include <linux/module.h>
24 #include <linux/delay.h>
25 #include <linux/slab.h>
27 #include <linux/dma-mapping.h>
28 #include <linux/vmalloc.h>
29 #include <linux/device.h>
30 #include <linux/platform_device.h>
31 #include <linux/omapfb.h>
33 #include <plat/display.h>
34 #include <plat/vram.h>
35 #include <plat/vrfb.h>
39 #define MODULE_NAME "omapfb"
41 #define OMAPFB_PLANE_XRES_MIN 8
42 #define OMAPFB_PLANE_YRES_MIN 8
44 static char *def_mode
;
45 static char *def_vram
;
47 static int def_rotate
;
48 static int def_mirror
;
51 unsigned int omapfb_debug
;
52 module_param_named(debug
, omapfb_debug
, bool, 0644);
53 static unsigned int omapfb_test_pattern
;
54 module_param_named(test
, omapfb_test_pattern
, bool, 0644);
57 static int omapfb_fb_init(struct omapfb2_device
*fbdev
, struct fb_info
*fbi
);
58 static int omapfb_get_recommended_bpp(struct omapfb2_device
*fbdev
,
59 struct omap_dss_device
*dssdev
);
62 static void draw_pixel(struct fb_info
*fbi
, int x
, int y
, unsigned color
)
64 struct fb_var_screeninfo
*var
= &fbi
->var
;
65 struct fb_fix_screeninfo
*fix
= &fbi
->fix
;
66 void __iomem
*addr
= fbi
->screen_base
;
67 const unsigned bytespp
= var
->bits_per_pixel
>> 3;
68 const unsigned line_len
= fix
->line_length
/ bytespp
;
70 int r
= (color
>> 16) & 0xff;
71 int g
= (color
>> 8) & 0xff;
72 int b
= (color
>> 0) & 0xff;
74 if (var
->bits_per_pixel
== 16) {
75 u16 __iomem
*p
= (u16 __iomem
*)addr
;
76 p
+= y
* line_len
+ x
;
82 __raw_writew((r
<< 11) | (g
<< 5) | (b
<< 0), p
);
83 } else if (var
->bits_per_pixel
== 24) {
84 u8 __iomem
*p
= (u8 __iomem
*)addr
;
85 p
+= (y
* line_len
+ x
) * 3;
87 __raw_writeb(b
, p
+ 0);
88 __raw_writeb(g
, p
+ 1);
89 __raw_writeb(r
, p
+ 2);
90 } else if (var
->bits_per_pixel
== 32) {
91 u32 __iomem
*p
= (u32 __iomem
*)addr
;
92 p
+= y
* line_len
+ x
;
93 __raw_writel(color
, p
);
97 static void fill_fb(struct fb_info
*fbi
)
99 struct fb_var_screeninfo
*var
= &fbi
->var
;
100 const short w
= var
->xres_virtual
;
101 const short h
= var
->yres_virtual
;
102 void __iomem
*addr
= fbi
->screen_base
;
108 DBG("fill_fb %dx%d, line_len %d bytes\n", w
, h
, fbi
->fix
.line_length
);
110 for (y
= 0; y
< h
; y
++) {
111 for (x
= 0; x
< w
; x
++) {
112 if (x
< 20 && y
< 20)
113 draw_pixel(fbi
, x
, y
, 0xffffff);
114 else if (x
< 20 && (y
> 20 && y
< h
- 20))
115 draw_pixel(fbi
, x
, y
, 0xff);
116 else if (y
< 20 && (x
> 20 && x
< w
- 20))
117 draw_pixel(fbi
, x
, y
, 0xff00);
118 else if (x
> w
- 20 && (y
> 20 && y
< h
- 20))
119 draw_pixel(fbi
, x
, y
, 0xff0000);
120 else if (y
> h
- 20 && (x
> 20 && x
< w
- 20))
121 draw_pixel(fbi
, x
, y
, 0xffff00);
122 else if (x
== 20 || x
== w
- 20 ||
123 y
== 20 || y
== h
- 20)
124 draw_pixel(fbi
, x
, y
, 0xffffff);
125 else if (x
== y
|| w
- x
== h
- y
)
126 draw_pixel(fbi
, x
, y
, 0xff00ff);
127 else if (w
- x
== y
|| x
== h
- y
)
128 draw_pixel(fbi
, x
, y
, 0x00ffff);
129 else if (x
> 20 && y
> 20 && x
< w
- 20 && y
< h
- 20) {
131 unsigned r
= 0, g
= 0, b
= 0;
133 if (var
->bits_per_pixel
== 16) {
135 b
= (y
% 32) * 256 / 32;
137 g
= (y
% 64) * 256 / 64;
139 r
= (y
% 32) * 256 / 32;
148 c
= (r
<< 16) | (g
<< 8) | (b
<< 0);
149 draw_pixel(fbi
, x
, y
, c
);
151 draw_pixel(fbi
, x
, y
, 0);
158 static unsigned omapfb_get_vrfb_offset(const struct omapfb_info
*ofbi
, int rot
)
160 const struct vrfb
*vrfb
= &ofbi
->region
->vrfb
;
168 offset
= vrfb
->yoffset
;
171 offset
= vrfb
->yoffset
* OMAP_VRFB_LINE_LEN
+ vrfb
->xoffset
;
174 offset
= vrfb
->xoffset
* OMAP_VRFB_LINE_LEN
;
180 offset
*= vrfb
->bytespp
;
185 static u32
omapfb_get_region_rot_paddr(const struct omapfb_info
*ofbi
, int rot
)
187 if (ofbi
->rotation_type
== OMAP_DSS_ROT_VRFB
) {
188 return ofbi
->region
->vrfb
.paddr
[rot
]
189 + omapfb_get_vrfb_offset(ofbi
, rot
);
191 return ofbi
->region
->paddr
;
195 static u32
omapfb_get_region_paddr(const struct omapfb_info
*ofbi
)
197 if (ofbi
->rotation_type
== OMAP_DSS_ROT_VRFB
)
198 return ofbi
->region
->vrfb
.paddr
[0];
200 return ofbi
->region
->paddr
;
203 static void __iomem
*omapfb_get_region_vaddr(const struct omapfb_info
*ofbi
)
205 if (ofbi
->rotation_type
== OMAP_DSS_ROT_VRFB
)
206 return ofbi
->region
->vrfb
.vaddr
[0];
208 return ofbi
->region
->vaddr
;
211 static struct omapfb_colormode omapfb_colormodes
[] = {
213 .dssmode
= OMAP_DSS_COLOR_UYVY
,
214 .bits_per_pixel
= 16,
215 .nonstd
= OMAPFB_COLOR_YUV422
,
217 .dssmode
= OMAP_DSS_COLOR_YUV2
,
218 .bits_per_pixel
= 16,
219 .nonstd
= OMAPFB_COLOR_YUY422
,
221 .dssmode
= OMAP_DSS_COLOR_ARGB16
,
222 .bits_per_pixel
= 16,
223 .red
= { .length
= 4, .offset
= 8, .msb_right
= 0 },
224 .green
= { .length
= 4, .offset
= 4, .msb_right
= 0 },
225 .blue
= { .length
= 4, .offset
= 0, .msb_right
= 0 },
226 .transp
= { .length
= 4, .offset
= 12, .msb_right
= 0 },
228 .dssmode
= OMAP_DSS_COLOR_RGB16
,
229 .bits_per_pixel
= 16,
230 .red
= { .length
= 5, .offset
= 11, .msb_right
= 0 },
231 .green
= { .length
= 6, .offset
= 5, .msb_right
= 0 },
232 .blue
= { .length
= 5, .offset
= 0, .msb_right
= 0 },
233 .transp
= { .length
= 0, .offset
= 0, .msb_right
= 0 },
235 .dssmode
= OMAP_DSS_COLOR_RGB24P
,
236 .bits_per_pixel
= 24,
237 .red
= { .length
= 8, .offset
= 16, .msb_right
= 0 },
238 .green
= { .length
= 8, .offset
= 8, .msb_right
= 0 },
239 .blue
= { .length
= 8, .offset
= 0, .msb_right
= 0 },
240 .transp
= { .length
= 0, .offset
= 0, .msb_right
= 0 },
242 .dssmode
= OMAP_DSS_COLOR_RGB24U
,
243 .bits_per_pixel
= 32,
244 .red
= { .length
= 8, .offset
= 16, .msb_right
= 0 },
245 .green
= { .length
= 8, .offset
= 8, .msb_right
= 0 },
246 .blue
= { .length
= 8, .offset
= 0, .msb_right
= 0 },
247 .transp
= { .length
= 0, .offset
= 0, .msb_right
= 0 },
249 .dssmode
= OMAP_DSS_COLOR_ARGB32
,
250 .bits_per_pixel
= 32,
251 .red
= { .length
= 8, .offset
= 16, .msb_right
= 0 },
252 .green
= { .length
= 8, .offset
= 8, .msb_right
= 0 },
253 .blue
= { .length
= 8, .offset
= 0, .msb_right
= 0 },
254 .transp
= { .length
= 8, .offset
= 24, .msb_right
= 0 },
256 .dssmode
= OMAP_DSS_COLOR_RGBA32
,
257 .bits_per_pixel
= 32,
258 .red
= { .length
= 8, .offset
= 24, .msb_right
= 0 },
259 .green
= { .length
= 8, .offset
= 16, .msb_right
= 0 },
260 .blue
= { .length
= 8, .offset
= 8, .msb_right
= 0 },
261 .transp
= { .length
= 8, .offset
= 0, .msb_right
= 0 },
263 .dssmode
= OMAP_DSS_COLOR_RGBX32
,
264 .bits_per_pixel
= 32,
265 .red
= { .length
= 8, .offset
= 24, .msb_right
= 0 },
266 .green
= { .length
= 8, .offset
= 16, .msb_right
= 0 },
267 .blue
= { .length
= 8, .offset
= 8, .msb_right
= 0 },
268 .transp
= { .length
= 0, .offset
= 0, .msb_right
= 0 },
272 static bool cmp_var_to_colormode(struct fb_var_screeninfo
*var
,
273 struct omapfb_colormode
*color
)
275 bool cmp_component(struct fb_bitfield
*f1
, struct fb_bitfield
*f2
)
277 return f1
->length
== f2
->length
&&
278 f1
->offset
== f2
->offset
&&
279 f1
->msb_right
== f2
->msb_right
;
282 if (var
->bits_per_pixel
== 0 ||
283 var
->red
.length
== 0 ||
284 var
->blue
.length
== 0 ||
285 var
->green
.length
== 0)
288 return var
->bits_per_pixel
== color
->bits_per_pixel
&&
289 cmp_component(&var
->red
, &color
->red
) &&
290 cmp_component(&var
->green
, &color
->green
) &&
291 cmp_component(&var
->blue
, &color
->blue
) &&
292 cmp_component(&var
->transp
, &color
->transp
);
295 static void assign_colormode_to_var(struct fb_var_screeninfo
*var
,
296 struct omapfb_colormode
*color
)
298 var
->bits_per_pixel
= color
->bits_per_pixel
;
299 var
->nonstd
= color
->nonstd
;
300 var
->red
= color
->red
;
301 var
->green
= color
->green
;
302 var
->blue
= color
->blue
;
303 var
->transp
= color
->transp
;
306 static int fb_mode_to_dss_mode(struct fb_var_screeninfo
*var
,
307 enum omap_color_mode
*mode
)
309 enum omap_color_mode dssmode
;
312 /* first match with nonstd field */
314 for (i
= 0; i
< ARRAY_SIZE(omapfb_colormodes
); ++i
) {
315 struct omapfb_colormode
*m
= &omapfb_colormodes
[i
];
316 if (var
->nonstd
== m
->nonstd
) {
317 assign_colormode_to_var(var
, m
);
326 /* then try exact match of bpp and colors */
327 for (i
= 0; i
< ARRAY_SIZE(omapfb_colormodes
); ++i
) {
328 struct omapfb_colormode
*m
= &omapfb_colormodes
[i
];
329 if (cmp_var_to_colormode(var
, m
)) {
330 assign_colormode_to_var(var
, m
);
336 /* match with bpp if user has not filled color fields
338 switch (var
->bits_per_pixel
) {
340 dssmode
= OMAP_DSS_COLOR_CLUT1
;
343 dssmode
= OMAP_DSS_COLOR_CLUT2
;
346 dssmode
= OMAP_DSS_COLOR_CLUT4
;
349 dssmode
= OMAP_DSS_COLOR_CLUT8
;
352 dssmode
= OMAP_DSS_COLOR_RGB12U
;
355 dssmode
= OMAP_DSS_COLOR_RGB16
;
358 dssmode
= OMAP_DSS_COLOR_RGB24P
;
361 dssmode
= OMAP_DSS_COLOR_RGB24U
;
367 for (i
= 0; i
< ARRAY_SIZE(omapfb_colormodes
); ++i
) {
368 struct omapfb_colormode
*m
= &omapfb_colormodes
[i
];
369 if (dssmode
== m
->dssmode
) {
370 assign_colormode_to_var(var
, m
);
379 static int check_fb_res_bounds(struct fb_var_screeninfo
*var
)
381 int xres_min
= OMAPFB_PLANE_XRES_MIN
;
383 int yres_min
= OMAPFB_PLANE_YRES_MIN
;
386 /* XXX: some applications seem to set virtual res to 0. */
387 if (var
->xres_virtual
== 0)
388 var
->xres_virtual
= var
->xres
;
390 if (var
->yres_virtual
== 0)
391 var
->yres_virtual
= var
->yres
;
393 if (var
->xres_virtual
< xres_min
|| var
->yres_virtual
< yres_min
)
396 if (var
->xres
< xres_min
)
397 var
->xres
= xres_min
;
398 if (var
->yres
< yres_min
)
399 var
->yres
= yres_min
;
400 if (var
->xres
> xres_max
)
401 var
->xres
= xres_max
;
402 if (var
->yres
> yres_max
)
403 var
->yres
= yres_max
;
405 if (var
->xres
> var
->xres_virtual
)
406 var
->xres
= var
->xres_virtual
;
407 if (var
->yres
> var
->yres_virtual
)
408 var
->yres
= var
->yres_virtual
;
413 static void shrink_height(unsigned long max_frame_size
,
414 struct fb_var_screeninfo
*var
)
416 DBG("can't fit FB into memory, reducing y\n");
417 var
->yres_virtual
= max_frame_size
/
418 (var
->xres_virtual
* var
->bits_per_pixel
>> 3);
420 if (var
->yres_virtual
< OMAPFB_PLANE_YRES_MIN
)
421 var
->yres_virtual
= OMAPFB_PLANE_YRES_MIN
;
423 if (var
->yres
> var
->yres_virtual
)
424 var
->yres
= var
->yres_virtual
;
427 static void shrink_width(unsigned long max_frame_size
,
428 struct fb_var_screeninfo
*var
)
430 DBG("can't fit FB into memory, reducing x\n");
431 var
->xres_virtual
= max_frame_size
/ var
->yres_virtual
/
432 (var
->bits_per_pixel
>> 3);
434 if (var
->xres_virtual
< OMAPFB_PLANE_XRES_MIN
)
435 var
->xres_virtual
= OMAPFB_PLANE_XRES_MIN
;
437 if (var
->xres
> var
->xres_virtual
)
438 var
->xres
= var
->xres_virtual
;
441 static int check_vrfb_fb_size(unsigned long region_size
,
442 const struct fb_var_screeninfo
*var
)
444 unsigned long min_phys_size
= omap_vrfb_min_phys_size(var
->xres_virtual
,
445 var
->yres_virtual
, var
->bits_per_pixel
>> 3);
447 return min_phys_size
> region_size
? -EINVAL
: 0;
450 static int check_fb_size(const struct omapfb_info
*ofbi
,
451 struct fb_var_screeninfo
*var
)
453 unsigned long max_frame_size
= ofbi
->region
->size
;
454 int bytespp
= var
->bits_per_pixel
>> 3;
455 unsigned long line_size
= var
->xres_virtual
* bytespp
;
457 if (ofbi
->rotation_type
== OMAP_DSS_ROT_VRFB
) {
458 /* One needs to check for both VRFB and OMAPFB limitations. */
459 if (check_vrfb_fb_size(max_frame_size
, var
))
460 shrink_height(omap_vrfb_max_height(
461 max_frame_size
, var
->xres_virtual
, bytespp
) *
464 if (check_vrfb_fb_size(max_frame_size
, var
)) {
465 DBG("cannot fit FB to memory\n");
472 DBG("max frame size %lu, line size %lu\n", max_frame_size
, line_size
);
474 if (line_size
* var
->yres_virtual
> max_frame_size
)
475 shrink_height(max_frame_size
, var
);
477 if (line_size
* var
->yres_virtual
> max_frame_size
) {
478 shrink_width(max_frame_size
, var
);
479 line_size
= var
->xres_virtual
* bytespp
;
482 if (line_size
* var
->yres_virtual
> max_frame_size
) {
483 DBG("cannot fit FB to memory\n");
491 * Consider if VRFB assisted rotation is in use and if the virtual space for
492 * the zero degree view needs to be mapped. The need for mapping also acts as
493 * the trigger for setting up the hardware on the context in question. This
494 * ensures that one does not attempt to access the virtual view before the
495 * hardware is serving the address translations.
497 static int setup_vrfb_rotation(struct fb_info
*fbi
)
499 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
500 struct omapfb2_mem_region
*rg
= ofbi
->region
;
501 struct vrfb
*vrfb
= &rg
->vrfb
;
502 struct fb_var_screeninfo
*var
= &fbi
->var
;
503 struct fb_fix_screeninfo
*fix
= &fbi
->fix
;
506 enum omap_color_mode mode
;
510 if (!rg
->size
|| ofbi
->rotation_type
!= OMAP_DSS_ROT_VRFB
)
513 DBG("setup_vrfb_rotation\n");
515 r
= fb_mode_to_dss_mode(var
, &mode
);
519 bytespp
= var
->bits_per_pixel
>> 3;
521 yuv_mode
= mode
== OMAP_DSS_COLOR_YUV2
|| mode
== OMAP_DSS_COLOR_UYVY
;
523 /* We need to reconfigure VRFB if the resolution changes, if yuv mode
524 * is enabled/disabled, or if bytes per pixel changes */
526 /* XXX we shouldn't allow this when framebuffer is mmapped */
530 if (yuv_mode
!= vrfb
->yuv_mode
)
532 else if (bytespp
!= vrfb
->bytespp
)
534 else if (vrfb
->xres
!= var
->xres_virtual
||
535 vrfb
->yres
!= var
->yres_virtual
)
538 if (vrfb
->vaddr
[0] && reconf
) {
539 fbi
->screen_base
= NULL
;
542 iounmap(vrfb
->vaddr
[0]);
543 vrfb
->vaddr
[0] = NULL
;
544 DBG("setup_vrfb_rotation: reset fb\n");
550 omap_vrfb_setup(&rg
->vrfb
, rg
->paddr
,
555 /* Now one can ioremap the 0 angle view */
556 r
= omap_vrfb_map_angle(vrfb
, var
->yres_virtual
, 0);
560 /* used by open/write in fbmem.c */
561 fbi
->screen_base
= ofbi
->region
->vrfb
.vaddr
[0];
563 fix
->smem_start
= ofbi
->region
->vrfb
.paddr
[0];
565 switch (var
->nonstd
) {
566 case OMAPFB_COLOR_YUV422
:
567 case OMAPFB_COLOR_YUY422
:
569 (OMAP_VRFB_LINE_LEN
* var
->bits_per_pixel
) >> 2;
573 (OMAP_VRFB_LINE_LEN
* var
->bits_per_pixel
) >> 3;
577 fix
->smem_len
= var
->yres_virtual
* fix
->line_length
;
582 int dss_mode_to_fb_mode(enum omap_color_mode dssmode
,
583 struct fb_var_screeninfo
*var
)
587 for (i
= 0; i
< ARRAY_SIZE(omapfb_colormodes
); ++i
) {
588 struct omapfb_colormode
*mode
= &omapfb_colormodes
[i
];
589 if (dssmode
== mode
->dssmode
) {
590 assign_colormode_to_var(var
, mode
);
597 void set_fb_fix(struct fb_info
*fbi
)
599 struct fb_fix_screeninfo
*fix
= &fbi
->fix
;
600 struct fb_var_screeninfo
*var
= &fbi
->var
;
601 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
602 struct omapfb2_mem_region
*rg
= ofbi
->region
;
606 /* used by open/write in fbmem.c */
607 fbi
->screen_base
= (char __iomem
*)omapfb_get_region_vaddr(ofbi
);
609 /* used by mmap in fbmem.c */
610 if (ofbi
->rotation_type
== OMAP_DSS_ROT_VRFB
) {
611 switch (var
->nonstd
) {
612 case OMAPFB_COLOR_YUV422
:
613 case OMAPFB_COLOR_YUY422
:
615 (OMAP_VRFB_LINE_LEN
* var
->bits_per_pixel
) >> 2;
619 (OMAP_VRFB_LINE_LEN
* var
->bits_per_pixel
) >> 3;
623 fix
->smem_len
= var
->yres_virtual
* fix
->line_length
;
626 (var
->xres_virtual
* var
->bits_per_pixel
) >> 3;
627 fix
->smem_len
= rg
->size
;
630 fix
->smem_start
= omapfb_get_region_paddr(ofbi
);
632 fix
->type
= FB_TYPE_PACKED_PIXELS
;
635 fix
->visual
= FB_VISUAL_PSEUDOCOLOR
;
637 switch (var
->bits_per_pixel
) {
642 fix
->visual
= FB_VISUAL_TRUECOLOR
;
643 /* 12bpp is stored in 16 bits */
649 fix
->visual
= FB_VISUAL_PSEUDOCOLOR
;
654 fix
->accel
= FB_ACCEL_NONE
;
660 /* check new var and possibly modify it to be ok */
661 int check_fb_var(struct fb_info
*fbi
, struct fb_var_screeninfo
*var
)
663 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
664 struct omap_dss_device
*display
= fb2display(fbi
);
665 enum omap_color_mode mode
= 0;
669 DBG("check_fb_var %d\n", ofbi
->id
);
671 WARN_ON(!atomic_read(&ofbi
->region
->lock_count
));
673 r
= fb_mode_to_dss_mode(var
, &mode
);
675 DBG("cannot convert var to omap dss mode\n");
679 for (i
= 0; i
< ofbi
->num_overlays
; ++i
) {
680 if ((ofbi
->overlays
[i
]->supported_modes
& mode
) == 0) {
681 DBG("invalid mode\n");
689 if (check_fb_res_bounds(var
))
692 /* When no memory is allocated ignore the size check */
693 if (ofbi
->region
->size
!= 0 && check_fb_size(ofbi
, var
))
696 if (var
->xres
+ var
->xoffset
> var
->xres_virtual
)
697 var
->xoffset
= var
->xres_virtual
- var
->xres
;
698 if (var
->yres
+ var
->yoffset
> var
->yres_virtual
)
699 var
->yoffset
= var
->yres_virtual
- var
->yres
;
701 DBG("xres = %d, yres = %d, vxres = %d, vyres = %d\n",
702 var
->xres
, var
->yres
,
703 var
->xres_virtual
, var
->yres_virtual
);
709 if (display
&& display
->driver
->get_timings
) {
710 struct omap_video_timings timings
;
711 display
->driver
->get_timings(display
, &timings
);
713 /* pixclock in ps, the rest in pixclock */
714 var
->pixclock
= timings
.pixel_clock
!= 0 ?
715 KHZ2PICOS(timings
.pixel_clock
) :
717 var
->left_margin
= timings
.hfp
;
718 var
->right_margin
= timings
.hbp
;
719 var
->upper_margin
= timings
.vfp
;
720 var
->lower_margin
= timings
.vbp
;
721 var
->hsync_len
= timings
.hsw
;
722 var
->vsync_len
= timings
.vsw
;
725 var
->left_margin
= 0;
726 var
->right_margin
= 0;
727 var
->upper_margin
= 0;
728 var
->lower_margin
= 0;
733 /* TODO: get these from panel->config */
734 var
->vmode
= FB_VMODE_NONINTERLACED
;
741 * ---------------------------------------------------------------------------
742 * fbdev framework callbacks
743 * ---------------------------------------------------------------------------
745 static int omapfb_open(struct fb_info
*fbi
, int user
)
750 static int omapfb_release(struct fb_info
*fbi
, int user
)
753 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
754 struct omapfb2_device
*fbdev
= ofbi
->fbdev
;
755 struct omap_dss_device
*display
= fb2display(fbi
);
757 DBG("Closing fb with plane index %d\n", ofbi
->id
);
761 if (display
&& display
->get_update_mode
&& display
->update
) {
762 /* XXX this update should be removed, I think. But it's
763 * good for debugging */
764 if (display
->get_update_mode(display
) ==
765 OMAP_DSS_UPDATE_MANUAL
) {
769 display
->sync(display
);
771 display
->get_resolution(display
, &w
, &h
);
772 display
->update(display
, 0, 0, w
, h
);
776 if (display
&& display
->sync
)
777 display
->sync(display
);
779 omapfb_unlock(fbdev
);
784 static unsigned calc_rotation_offset_dma(const struct fb_var_screeninfo
*var
,
785 const struct fb_fix_screeninfo
*fix
, int rotation
)
789 offset
= var
->yoffset
* fix
->line_length
+
790 var
->xoffset
* (var
->bits_per_pixel
>> 3);
795 static unsigned calc_rotation_offset_vrfb(const struct fb_var_screeninfo
*var
,
796 const struct fb_fix_screeninfo
*fix
, int rotation
)
800 if (rotation
== FB_ROTATE_UD
)
801 offset
= (var
->yres_virtual
- var
->yres
) *
803 else if (rotation
== FB_ROTATE_CW
)
804 offset
= (var
->yres_virtual
- var
->yres
) *
805 (var
->bits_per_pixel
>> 3);
809 if (rotation
== FB_ROTATE_UR
)
810 offset
+= var
->yoffset
* fix
->line_length
+
811 var
->xoffset
* (var
->bits_per_pixel
>> 3);
812 else if (rotation
== FB_ROTATE_UD
)
813 offset
-= var
->yoffset
* fix
->line_length
+
814 var
->xoffset
* (var
->bits_per_pixel
>> 3);
815 else if (rotation
== FB_ROTATE_CW
)
816 offset
-= var
->xoffset
* fix
->line_length
+
817 var
->yoffset
* (var
->bits_per_pixel
>> 3);
818 else if (rotation
== FB_ROTATE_CCW
)
819 offset
+= var
->xoffset
* fix
->line_length
+
820 var
->yoffset
* (var
->bits_per_pixel
>> 3);
825 static void omapfb_calc_addr(const struct omapfb_info
*ofbi
,
826 const struct fb_var_screeninfo
*var
,
827 const struct fb_fix_screeninfo
*fix
,
828 int rotation
, u32
*paddr
, void __iomem
**vaddr
)
831 void __iomem
*data_start_v
;
834 if (ofbi
->rotation_type
== OMAP_DSS_ROT_VRFB
) {
835 data_start_p
= omapfb_get_region_rot_paddr(ofbi
, rotation
);
838 data_start_p
= omapfb_get_region_paddr(ofbi
);
839 data_start_v
= omapfb_get_region_vaddr(ofbi
);
842 if (ofbi
->rotation_type
== OMAP_DSS_ROT_VRFB
)
843 offset
= calc_rotation_offset_vrfb(var
, fix
, rotation
);
845 offset
= calc_rotation_offset_dma(var
, fix
, rotation
);
847 data_start_p
+= offset
;
848 data_start_v
+= offset
;
851 DBG("offset %d, %d = %d\n",
852 var
->xoffset
, var
->yoffset
, offset
);
854 DBG("paddr %x, vaddr %p\n", data_start_p
, data_start_v
);
856 *paddr
= data_start_p
;
857 *vaddr
= data_start_v
;
860 /* setup overlay according to the fb */
861 int omapfb_setup_overlay(struct fb_info
*fbi
, struct omap_overlay
*ovl
,
862 u16 posx
, u16 posy
, u16 outw
, u16 outh
)
865 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
866 struct fb_var_screeninfo
*var
= &fbi
->var
;
867 struct fb_fix_screeninfo
*fix
= &fbi
->fix
;
868 enum omap_color_mode mode
= 0;
869 u32 data_start_p
= 0;
870 void __iomem
*data_start_v
= NULL
;
871 struct omap_overlay_info info
;
875 int rotation
= var
->rotate
;
878 WARN_ON(!atomic_read(&ofbi
->region
->lock_count
));
880 for (i
= 0; i
< ofbi
->num_overlays
; i
++) {
881 if (ovl
!= ofbi
->overlays
[i
])
884 rotation
= (rotation
+ ofbi
->rotation
[i
]) % 4;
888 DBG("setup_overlay %d, posx %d, posy %d, outw %d, outh %d\n", ofbi
->id
,
889 posx
, posy
, outw
, outh
);
891 if (rotation
== FB_ROTATE_CW
|| rotation
== FB_ROTATE_CCW
) {
899 if (ofbi
->region
->size
)
900 omapfb_calc_addr(ofbi
, var
, fix
, rotation
,
901 &data_start_p
, &data_start_v
);
903 r
= fb_mode_to_dss_mode(var
, &mode
);
905 DBG("fb_mode_to_dss_mode failed");
909 switch (var
->nonstd
) {
910 case OMAPFB_COLOR_YUV422
:
911 case OMAPFB_COLOR_YUY422
:
912 if (ofbi
->rotation_type
== OMAP_DSS_ROT_VRFB
) {
913 screen_width
= fix
->line_length
914 / (var
->bits_per_pixel
>> 2);
918 screen_width
= fix
->line_length
/ (var
->bits_per_pixel
>> 3);
922 ovl
->get_overlay_info(ovl
, &info
);
924 if (ofbi
->rotation_type
== OMAP_DSS_ROT_VRFB
)
927 mirror
= ofbi
->mirror
;
929 info
.paddr
= data_start_p
;
930 info
.vaddr
= data_start_v
;
931 info
.screen_width
= screen_width
;
934 info
.color_mode
= mode
;
935 info
.rotation_type
= ofbi
->rotation_type
;
936 info
.rotation
= rotation
;
937 info
.mirror
= mirror
;
941 info
.out_width
= outw
;
942 info
.out_height
= outh
;
944 r
= ovl
->set_overlay_info(ovl
, &info
);
946 DBG("ovl->setup_overlay_info failed\n");
953 DBG("setup_overlay failed\n");
957 /* apply var to the overlay */
958 int omapfb_apply_changes(struct fb_info
*fbi
, int init
)
961 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
962 struct fb_var_screeninfo
*var
= &fbi
->var
;
963 struct omap_overlay
*ovl
;
969 if (omapfb_test_pattern
)
973 WARN_ON(!atomic_read(&ofbi
->region
->lock_count
));
975 for (i
= 0; i
< ofbi
->num_overlays
; i
++) {
976 ovl
= ofbi
->overlays
[i
];
978 DBG("apply_changes, fb %d, ovl %d\n", ofbi
->id
, ovl
->id
);
980 if (ofbi
->region
->size
== 0) {
981 /* the fb is not available. disable the overlay */
982 omapfb_overlay_enable(ovl
, 0);
983 if (!init
&& ovl
->manager
)
984 ovl
->manager
->apply(ovl
->manager
);
988 if (init
|| (ovl
->caps
& OMAP_DSS_OVL_CAP_SCALE
) == 0) {
989 int rotation
= (var
->rotate
+ ofbi
->rotation
[i
]) % 4;
990 if (rotation
== FB_ROTATE_CW
||
991 rotation
== FB_ROTATE_CCW
) {
999 outw
= ovl
->info
.out_width
;
1000 outh
= ovl
->info
.out_height
;
1007 posx
= ovl
->info
.pos_x
;
1008 posy
= ovl
->info
.pos_y
;
1011 r
= omapfb_setup_overlay(fbi
, ovl
, posx
, posy
, outw
, outh
);
1015 if (!init
&& ovl
->manager
)
1016 ovl
->manager
->apply(ovl
->manager
);
1020 DBG("apply_changes failed\n");
1024 /* checks var and eventually tweaks it to something supported,
1025 * DO NOT MODIFY PAR */
1026 static int omapfb_check_var(struct fb_var_screeninfo
*var
, struct fb_info
*fbi
)
1028 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
1031 DBG("check_var(%d)\n", FB2OFB(fbi
)->id
);
1033 omapfb_get_mem_region(ofbi
->region
);
1035 r
= check_fb_var(fbi
, var
);
1037 omapfb_put_mem_region(ofbi
->region
);
1042 /* set the video mode according to info->var */
1043 static int omapfb_set_par(struct fb_info
*fbi
)
1045 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
1048 DBG("set_par(%d)\n", FB2OFB(fbi
)->id
);
1050 omapfb_get_mem_region(ofbi
->region
);
1054 r
= setup_vrfb_rotation(fbi
);
1058 r
= omapfb_apply_changes(fbi
, 0);
1061 omapfb_put_mem_region(ofbi
->region
);
1066 static int omapfb_pan_display(struct fb_var_screeninfo
*var
,
1067 struct fb_info
*fbi
)
1069 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
1070 struct fb_var_screeninfo new_var
;
1073 DBG("pan_display(%d)\n", FB2OFB(fbi
)->id
);
1075 if (var
->xoffset
== fbi
->var
.xoffset
&&
1076 var
->yoffset
== fbi
->var
.yoffset
)
1080 new_var
.xoffset
= var
->xoffset
;
1081 new_var
.yoffset
= var
->yoffset
;
1085 omapfb_get_mem_region(ofbi
->region
);
1087 r
= omapfb_apply_changes(fbi
, 0);
1089 omapfb_put_mem_region(ofbi
->region
);
1094 static void mmap_user_open(struct vm_area_struct
*vma
)
1096 struct omapfb2_mem_region
*rg
= vma
->vm_private_data
;
1098 omapfb_get_mem_region(rg
);
1099 atomic_inc(&rg
->map_count
);
1100 omapfb_put_mem_region(rg
);
1103 static void mmap_user_close(struct vm_area_struct
*vma
)
1105 struct omapfb2_mem_region
*rg
= vma
->vm_private_data
;
1107 omapfb_get_mem_region(rg
);
1108 atomic_dec(&rg
->map_count
);
1109 omapfb_put_mem_region(rg
);
1112 static struct vm_operations_struct mmap_user_ops
= {
1113 .open
= mmap_user_open
,
1114 .close
= mmap_user_close
,
1117 static int omapfb_mmap(struct fb_info
*fbi
, struct vm_area_struct
*vma
)
1119 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
1120 struct fb_fix_screeninfo
*fix
= &fbi
->fix
;
1121 struct omapfb2_mem_region
*rg
;
1123 unsigned long start
;
1127 if (vma
->vm_end
- vma
->vm_start
== 0)
1129 if (vma
->vm_pgoff
> (~0UL >> PAGE_SHIFT
))
1131 off
= vma
->vm_pgoff
<< PAGE_SHIFT
;
1133 rg
= omapfb_get_mem_region(ofbi
->region
);
1135 start
= omapfb_get_region_paddr(ofbi
);
1136 len
= fix
->smem_len
;
1139 if ((vma
->vm_end
- vma
->vm_start
+ off
) > len
)
1144 DBG("user mmap region start %lx, len %d, off %lx\n", start
, len
, off
);
1146 vma
->vm_pgoff
= off
>> PAGE_SHIFT
;
1147 vma
->vm_flags
|= VM_IO
| VM_RESERVED
;
1148 vma
->vm_page_prot
= pgprot_writecombine(vma
->vm_page_prot
);
1149 vma
->vm_ops
= &mmap_user_ops
;
1150 vma
->vm_private_data
= rg
;
1151 if (io_remap_pfn_range(vma
, vma
->vm_start
, off
>> PAGE_SHIFT
,
1152 vma
->vm_end
- vma
->vm_start
,
1153 vma
->vm_page_prot
)) {
1158 /* vm_ops.open won't be called for mmap itself. */
1159 atomic_inc(&rg
->map_count
);
1161 omapfb_put_mem_region(rg
);
1166 omapfb_put_mem_region(ofbi
->region
);
1171 /* Store a single color palette entry into a pseudo palette or the hardware
1172 * palette if one is available. For now we support only 16bpp and thus store
1173 * the entry only to the pseudo palette.
1175 static int _setcolreg(struct fb_info
*fbi
, u_int regno
, u_int red
, u_int green
,
1176 u_int blue
, u_int transp
, int update_hw_pal
)
1178 /*struct omapfb_info *ofbi = FB2OFB(fbi);*/
1179 /*struct omapfb2_device *fbdev = ofbi->fbdev;*/
1180 struct fb_var_screeninfo
*var
= &fbi
->var
;
1183 enum omapfb_color_format mode
= OMAPFB_COLOR_RGB24U
; /* XXX */
1185 /*switch (plane->color_mode) {*/
1187 case OMAPFB_COLOR_YUV422
:
1188 case OMAPFB_COLOR_YUV420
:
1189 case OMAPFB_COLOR_YUY422
:
1192 case OMAPFB_COLOR_CLUT_8BPP
:
1193 case OMAPFB_COLOR_CLUT_4BPP
:
1194 case OMAPFB_COLOR_CLUT_2BPP
:
1195 case OMAPFB_COLOR_CLUT_1BPP
:
1197 if (fbdev->ctrl->setcolreg)
1198 r = fbdev->ctrl->setcolreg(regno, red, green, blue,
1199 transp, update_hw_pal);
1204 case OMAPFB_COLOR_RGB565
:
1205 case OMAPFB_COLOR_RGB444
:
1206 case OMAPFB_COLOR_RGB24P
:
1207 case OMAPFB_COLOR_RGB24U
:
1213 pal
= ((red
>> (16 - var
->red
.length
)) <<
1215 ((green
>> (16 - var
->green
.length
)) <<
1216 var
->green
.offset
) |
1217 (blue
>> (16 - var
->blue
.length
));
1218 ((u32
*)(fbi
->pseudo_palette
))[regno
] = pal
;
1227 static int omapfb_setcolreg(u_int regno
, u_int red
, u_int green
, u_int blue
,
1228 u_int transp
, struct fb_info
*info
)
1232 return _setcolreg(info
, regno
, red
, green
, blue
, transp
, 1);
1235 static int omapfb_setcmap(struct fb_cmap
*cmap
, struct fb_info
*info
)
1237 int count
, index
, r
;
1238 u16
*red
, *green
, *blue
, *transp
;
1244 green
= cmap
->green
;
1246 transp
= cmap
->transp
;
1247 index
= cmap
->start
;
1249 for (count
= 0; count
< cmap
->len
; count
++) {
1252 r
= _setcolreg(info
, index
++, *red
++, *green
++, *blue
++, trans
,
1253 count
== cmap
->len
- 1);
1261 static int omapfb_blank(int blank
, struct fb_info
*fbi
)
1263 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
1264 struct omapfb2_device
*fbdev
= ofbi
->fbdev
;
1265 struct omap_dss_device
*display
= fb2display(fbi
);
1275 case FB_BLANK_UNBLANK
:
1276 if (display
->state
!= OMAP_DSS_DISPLAY_SUSPENDED
)
1279 if (display
->driver
->resume
)
1280 r
= display
->driver
->resume(display
);
1282 if (r
== 0 && display
->driver
->get_update_mode
&&
1283 display
->driver
->get_update_mode(display
) ==
1284 OMAP_DSS_UPDATE_MANUAL
)
1289 case FB_BLANK_NORMAL
:
1290 /* FB_BLANK_NORMAL could be implemented.
1291 * Needs DSS additions. */
1292 case FB_BLANK_VSYNC_SUSPEND
:
1293 case FB_BLANK_HSYNC_SUSPEND
:
1294 case FB_BLANK_POWERDOWN
:
1295 if (display
->state
!= OMAP_DSS_DISPLAY_ACTIVE
)
1298 if (display
->driver
->suspend
)
1299 r
= display
->driver
->suspend(display
);
1308 omapfb_unlock(fbdev
);
1310 if (r
== 0 && do_update
&& display
->driver
->update
) {
1312 display
->driver
->get_resolution(display
, &w
, &h
);
1314 r
= display
->driver
->update(display
, 0, 0, w
, h
);
1321 /* XXX fb_read and fb_write are needed for VRFB */
1322 ssize_t
omapfb_write(struct fb_info
*info
, const char __user
*buf
,
1323 size_t count
, loff_t
*ppos
)
1325 DBG("omapfb_write %d, %lu\n", count
, (unsigned long)*ppos
);
1326 /* XXX needed for VRFB */
1331 static struct fb_ops omapfb_ops
= {
1332 .owner
= THIS_MODULE
,
1333 .fb_open
= omapfb_open
,
1334 .fb_release
= omapfb_release
,
1335 .fb_fillrect
= cfb_fillrect
,
1336 .fb_copyarea
= cfb_copyarea
,
1337 .fb_imageblit
= cfb_imageblit
,
1338 .fb_blank
= omapfb_blank
,
1339 .fb_ioctl
= omapfb_ioctl
,
1340 .fb_check_var
= omapfb_check_var
,
1341 .fb_set_par
= omapfb_set_par
,
1342 .fb_pan_display
= omapfb_pan_display
,
1343 .fb_mmap
= omapfb_mmap
,
1344 .fb_setcolreg
= omapfb_setcolreg
,
1345 .fb_setcmap
= omapfb_setcmap
,
1346 /*.fb_write = omapfb_write,*/
1349 static void omapfb_free_fbmem(struct fb_info
*fbi
)
1351 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
1352 struct omapfb2_device
*fbdev
= ofbi
->fbdev
;
1353 struct omapfb2_mem_region
*rg
;
1357 WARN_ON(atomic_read(&rg
->map_count
));
1360 if (omap_vram_free(rg
->paddr
, rg
->size
))
1361 dev_err(fbdev
->dev
, "VRAM FREE failed\n");
1366 if (ofbi
->rotation_type
== OMAP_DSS_ROT_VRFB
) {
1367 /* unmap the 0 angle rotation */
1368 if (rg
->vrfb
.vaddr
[0]) {
1369 iounmap(rg
->vrfb
.vaddr
[0]);
1370 omap_vrfb_release_ctx(&rg
->vrfb
);
1371 rg
->vrfb
.vaddr
[0] = NULL
;
1381 static void clear_fb_info(struct fb_info
*fbi
)
1383 memset(&fbi
->var
, 0, sizeof(fbi
->var
));
1384 memset(&fbi
->fix
, 0, sizeof(fbi
->fix
));
1385 strlcpy(fbi
->fix
.id
, MODULE_NAME
, sizeof(fbi
->fix
.id
));
1388 static int omapfb_free_all_fbmem(struct omapfb2_device
*fbdev
)
1392 DBG("free all fbmem\n");
1394 for (i
= 0; i
< fbdev
->num_fbs
; i
++) {
1395 struct fb_info
*fbi
= fbdev
->fbs
[i
];
1396 omapfb_free_fbmem(fbi
);
1403 static int omapfb_alloc_fbmem(struct fb_info
*fbi
, unsigned long size
,
1404 unsigned long paddr
)
1406 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
1407 struct omapfb2_device
*fbdev
= ofbi
->fbdev
;
1408 struct omapfb2_mem_region
*rg
;
1409 void __iomem
*vaddr
;
1416 memset(&rg
->vrfb
, 0, sizeof rg
->vrfb
);
1422 size
= PAGE_ALIGN(size
);
1425 DBG("allocating %lu bytes for fb %d\n", size
, ofbi
->id
);
1426 r
= omap_vram_alloc(OMAP_VRAM_MEMTYPE_SDRAM
, size
, &paddr
);
1428 DBG("reserving %lu bytes at %lx for fb %d\n", size
, paddr
,
1430 r
= omap_vram_reserve(paddr
, size
);
1434 dev_err(fbdev
->dev
, "failed to allocate framebuffer\n");
1438 if (ofbi
->rotation_type
!= OMAP_DSS_ROT_VRFB
) {
1439 vaddr
= ioremap_wc(paddr
, size
);
1442 dev_err(fbdev
->dev
, "failed to ioremap framebuffer\n");
1443 omap_vram_free(paddr
, size
);
1447 DBG("allocated VRAM paddr %lx, vaddr %p\n", paddr
, vaddr
);
1449 r
= omap_vrfb_request_ctx(&rg
->vrfb
);
1451 dev_err(fbdev
->dev
, "vrfb create ctx failed\n");
1466 /* allocate fbmem using display resolution as reference */
1467 static int omapfb_alloc_fbmem_display(struct fb_info
*fbi
, unsigned long size
,
1468 unsigned long paddr
)
1470 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
1471 struct omapfb2_device
*fbdev
= ofbi
->fbdev
;
1472 struct omap_dss_device
*display
;
1475 display
= fb2display(fbi
);
1480 switch (omapfb_get_recommended_bpp(fbdev
, display
)) {
1495 display
->driver
->get_resolution(display
, &w
, &h
);
1497 if (ofbi
->rotation_type
== OMAP_DSS_ROT_VRFB
) {
1498 size
= max(omap_vrfb_min_phys_size(w
, h
, bytespp
),
1499 omap_vrfb_min_phys_size(h
, w
, bytespp
));
1501 DBG("adjusting fb mem size for VRFB, %u -> %lu\n",
1502 w
* h
* bytespp
, size
);
1504 size
= w
* h
* bytespp
;
1511 return omapfb_alloc_fbmem(fbi
, size
, paddr
);
1514 static enum omap_color_mode
fb_format_to_dss_mode(enum omapfb_color_format fmt
)
1516 enum omap_color_mode mode
;
1519 case OMAPFB_COLOR_RGB565
:
1520 mode
= OMAP_DSS_COLOR_RGB16
;
1522 case OMAPFB_COLOR_YUV422
:
1523 mode
= OMAP_DSS_COLOR_YUV2
;
1525 case OMAPFB_COLOR_CLUT_8BPP
:
1526 mode
= OMAP_DSS_COLOR_CLUT8
;
1528 case OMAPFB_COLOR_CLUT_4BPP
:
1529 mode
= OMAP_DSS_COLOR_CLUT4
;
1531 case OMAPFB_COLOR_CLUT_2BPP
:
1532 mode
= OMAP_DSS_COLOR_CLUT2
;
1534 case OMAPFB_COLOR_CLUT_1BPP
:
1535 mode
= OMAP_DSS_COLOR_CLUT1
;
1537 case OMAPFB_COLOR_RGB444
:
1538 mode
= OMAP_DSS_COLOR_RGB12U
;
1540 case OMAPFB_COLOR_YUY422
:
1541 mode
= OMAP_DSS_COLOR_UYVY
;
1543 case OMAPFB_COLOR_ARGB16
:
1544 mode
= OMAP_DSS_COLOR_ARGB16
;
1546 case OMAPFB_COLOR_RGB24U
:
1547 mode
= OMAP_DSS_COLOR_RGB24U
;
1549 case OMAPFB_COLOR_RGB24P
:
1550 mode
= OMAP_DSS_COLOR_RGB24P
;
1552 case OMAPFB_COLOR_ARGB32
:
1553 mode
= OMAP_DSS_COLOR_ARGB32
;
1555 case OMAPFB_COLOR_RGBA32
:
1556 mode
= OMAP_DSS_COLOR_RGBA32
;
1558 case OMAPFB_COLOR_RGBX32
:
1559 mode
= OMAP_DSS_COLOR_RGBX32
;
1568 static int omapfb_parse_vram_param(const char *param
, int max_entries
,
1569 unsigned long *sizes
, unsigned long *paddrs
)
1573 unsigned long paddr
= 0;
1576 start
= (char *)param
;
1581 fbnum
= simple_strtoul(p
, &p
, 10);
1589 if (fbnum
>= max_entries
)
1592 size
= memparse(p
+ 1, &p
);
1600 paddr
= simple_strtoul(p
+ 1, &p
, 16);
1607 paddrs
[fbnum
] = paddr
;
1608 sizes
[fbnum
] = size
;
1624 static int omapfb_allocate_all_fbs(struct omapfb2_device
*fbdev
)
1627 unsigned long vram_sizes
[10];
1628 unsigned long vram_paddrs
[10];
1630 memset(&vram_sizes
, 0, sizeof(vram_sizes
));
1631 memset(&vram_paddrs
, 0, sizeof(vram_paddrs
));
1633 if (def_vram
&& omapfb_parse_vram_param(def_vram
, 10,
1634 vram_sizes
, vram_paddrs
)) {
1635 dev_err(fbdev
->dev
, "failed to parse vram parameter\n");
1637 memset(&vram_sizes
, 0, sizeof(vram_sizes
));
1638 memset(&vram_paddrs
, 0, sizeof(vram_paddrs
));
1641 if (fbdev
->dev
->platform_data
) {
1642 struct omapfb_platform_data
*opd
;
1643 opd
= fbdev
->dev
->platform_data
;
1644 for (i
= 0; i
< opd
->mem_desc
.region_cnt
; ++i
) {
1645 if (!vram_sizes
[i
]) {
1647 unsigned long paddr
;
1649 size
= opd
->mem_desc
.region
[i
].size
;
1650 paddr
= opd
->mem_desc
.region
[i
].paddr
;
1652 vram_sizes
[i
] = size
;
1653 vram_paddrs
[i
] = paddr
;
1658 for (i
= 0; i
< fbdev
->num_fbs
; i
++) {
1659 /* allocate memory automatically only for fb0, or if
1660 * excplicitly defined with vram or plat data option */
1661 if (i
== 0 || vram_sizes
[i
] != 0) {
1662 r
= omapfb_alloc_fbmem_display(fbdev
->fbs
[i
],
1663 vram_sizes
[i
], vram_paddrs
[i
]);
1670 for (i
= 0; i
< fbdev
->num_fbs
; i
++) {
1671 struct omapfb_info
*ofbi
= FB2OFB(fbdev
->fbs
[i
]);
1672 struct omapfb2_mem_region
*rg
;
1675 DBG("region%d phys %08x virt %p size=%lu\n",
1685 int omapfb_realloc_fbmem(struct fb_info
*fbi
, unsigned long size
, int type
)
1687 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
1688 struct omapfb2_device
*fbdev
= ofbi
->fbdev
;
1689 struct omap_dss_device
*display
= fb2display(fbi
);
1690 struct omapfb2_mem_region
*rg
= ofbi
->region
;
1691 unsigned long old_size
= rg
->size
;
1692 unsigned long old_paddr
= rg
->paddr
;
1693 int old_type
= rg
->type
;
1696 if (type
> OMAPFB_MEMTYPE_MAX
)
1699 size
= PAGE_ALIGN(size
);
1701 if (old_size
== size
&& old_type
== type
)
1704 if (display
&& display
->driver
->sync
)
1705 display
->driver
->sync(display
);
1707 omapfb_free_fbmem(fbi
);
1714 r
= omapfb_alloc_fbmem(fbi
, size
, 0);
1718 omapfb_alloc_fbmem(fbi
, old_size
, old_paddr
);
1726 if (old_size
== size
)
1729 if (old_size
== 0) {
1730 DBG("initializing fb %d\n", ofbi
->id
);
1731 r
= omapfb_fb_init(fbdev
, fbi
);
1733 DBG("omapfb_fb_init failed\n");
1736 r
= omapfb_apply_changes(fbi
, 1);
1738 DBG("omapfb_apply_changes failed\n");
1742 struct fb_var_screeninfo new_var
;
1743 memcpy(&new_var
, &fbi
->var
, sizeof(new_var
));
1744 r
= check_fb_var(fbi
, &new_var
);
1747 memcpy(&fbi
->var
, &new_var
, sizeof(fbi
->var
));
1749 r
= setup_vrfb_rotation(fbi
);
1756 omapfb_free_fbmem(fbi
);
1761 /* initialize fb_info, var, fix to something sane based on the display */
1762 static int omapfb_fb_init(struct omapfb2_device
*fbdev
, struct fb_info
*fbi
)
1764 struct fb_var_screeninfo
*var
= &fbi
->var
;
1765 struct omap_dss_device
*display
= fb2display(fbi
);
1766 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
1769 fbi
->fbops
= &omapfb_ops
;
1770 fbi
->flags
= FBINFO_FLAG_DEFAULT
;
1771 fbi
->pseudo_palette
= fbdev
->pseudo_palette
;
1773 if (ofbi
->region
->size
== 0) {
1779 var
->bits_per_pixel
= 0;
1781 var
->rotate
= def_rotate
;
1784 * Check if there is a default color format set in the board file,
1785 * and use this format instead the default deducted from the
1788 if (fbdev
->dev
->platform_data
) {
1789 struct omapfb_platform_data
*opd
;
1792 opd
= fbdev
->dev
->platform_data
;
1793 if (opd
->mem_desc
.region
[id
].format_used
) {
1794 enum omap_color_mode mode
;
1795 enum omapfb_color_format format
;
1797 format
= opd
->mem_desc
.region
[id
].format
;
1798 mode
= fb_format_to_dss_mode(format
);
1803 r
= dss_mode_to_fb_mode(mode
, var
);
1811 int rotation
= (var
->rotate
+ ofbi
->rotation
[0]) % 4;
1813 display
->driver
->get_resolution(display
, &w
, &h
);
1815 if (rotation
== FB_ROTATE_CW
||
1816 rotation
== FB_ROTATE_CCW
) {
1824 var
->xres_virtual
= var
->xres
;
1825 var
->yres_virtual
= var
->yres
;
1827 if (!var
->bits_per_pixel
) {
1828 switch (omapfb_get_recommended_bpp(fbdev
, display
)) {
1830 var
->bits_per_pixel
= 16;
1833 var
->bits_per_pixel
= 32;
1836 dev_err(fbdev
->dev
, "illegal display "
1842 /* if there's no display, let's just guess some basic values */
1845 var
->xres_virtual
= var
->xres
;
1846 var
->yres_virtual
= var
->yres
;
1847 if (!var
->bits_per_pixel
)
1848 var
->bits_per_pixel
= 16;
1851 r
= check_fb_var(fbi
, var
);
1856 r
= setup_vrfb_rotation(fbi
);
1860 r
= fb_alloc_cmap(&fbi
->cmap
, 256, 0);
1862 dev_err(fbdev
->dev
, "unable to allocate color map memory\n");
1868 static void fbinfo_cleanup(struct omapfb2_device
*fbdev
, struct fb_info
*fbi
)
1870 fb_dealloc_cmap(&fbi
->cmap
);
1874 static void omapfb_free_resources(struct omapfb2_device
*fbdev
)
1878 DBG("free_resources\n");
1883 for (i
= 0; i
< fbdev
->num_fbs
; i
++)
1884 unregister_framebuffer(fbdev
->fbs
[i
]);
1886 /* free the reserved fbmem */
1887 omapfb_free_all_fbmem(fbdev
);
1889 for (i
= 0; i
< fbdev
->num_fbs
; i
++) {
1890 fbinfo_cleanup(fbdev
, fbdev
->fbs
[i
]);
1891 framebuffer_release(fbdev
->fbs
[i
]);
1894 for (i
= 0; i
< fbdev
->num_displays
; i
++) {
1895 if (fbdev
->displays
[i
]->state
!= OMAP_DSS_DISPLAY_DISABLED
)
1896 fbdev
->displays
[i
]->driver
->disable(fbdev
->displays
[i
]);
1898 omap_dss_put_device(fbdev
->displays
[i
]);
1901 dev_set_drvdata(fbdev
->dev
, NULL
);
1905 static int omapfb_create_framebuffers(struct omapfb2_device
*fbdev
)
1911 DBG("create %d framebuffers\n", CONFIG_FB_OMAP2_NUM_FBS
);
1913 /* allocate fb_infos */
1914 for (i
= 0; i
< CONFIG_FB_OMAP2_NUM_FBS
; i
++) {
1915 struct fb_info
*fbi
;
1916 struct omapfb_info
*ofbi
;
1918 fbi
= framebuffer_alloc(sizeof(struct omapfb_info
),
1923 "unable to allocate memory for plane info\n");
1929 fbdev
->fbs
[i
] = fbi
;
1932 ofbi
->fbdev
= fbdev
;
1935 ofbi
->region
= &fbdev
->regions
[i
];
1936 ofbi
->region
->id
= i
;
1937 init_rwsem(&ofbi
->region
->lock
);
1939 /* assign these early, so that fb alloc can use them */
1940 ofbi
->rotation_type
= def_vrfb
? OMAP_DSS_ROT_VRFB
:
1942 ofbi
->mirror
= def_mirror
;
1947 DBG("fb_infos allocated\n");
1949 /* assign overlays for the fbs */
1950 for (i
= 0; i
< min(fbdev
->num_fbs
, fbdev
->num_overlays
); i
++) {
1951 struct omapfb_info
*ofbi
= FB2OFB(fbdev
->fbs
[i
]);
1953 ofbi
->overlays
[0] = fbdev
->overlays
[i
];
1954 ofbi
->num_overlays
= 1;
1957 /* allocate fb memories */
1958 r
= omapfb_allocate_all_fbs(fbdev
);
1960 dev_err(fbdev
->dev
, "failed to allocate fbmem\n");
1964 DBG("fbmems allocated\n");
1966 /* setup fb_infos */
1967 for (i
= 0; i
< fbdev
->num_fbs
; i
++) {
1968 struct fb_info
*fbi
= fbdev
->fbs
[i
];
1969 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
1971 omapfb_get_mem_region(ofbi
->region
);
1972 r
= omapfb_fb_init(fbdev
, fbi
);
1973 omapfb_put_mem_region(ofbi
->region
);
1976 dev_err(fbdev
->dev
, "failed to setup fb_info\n");
1981 DBG("fb_infos initialized\n");
1983 for (i
= 0; i
< fbdev
->num_fbs
; i
++) {
1984 r
= register_framebuffer(fbdev
->fbs
[i
]);
1987 "registering framebuffer %d failed\n", i
);
1992 DBG("framebuffers registered\n");
1994 for (i
= 0; i
< fbdev
->num_fbs
; i
++) {
1995 struct fb_info
*fbi
= fbdev
->fbs
[i
];
1996 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
1998 omapfb_get_mem_region(ofbi
->region
);
1999 r
= omapfb_apply_changes(fbi
, 1);
2000 omapfb_put_mem_region(ofbi
->region
);
2003 dev_err(fbdev
->dev
, "failed to change mode\n");
2008 DBG("create sysfs for fbs\n");
2009 r
= omapfb_create_sysfs(fbdev
);
2011 dev_err(fbdev
->dev
, "failed to create sysfs entries\n");
2016 if (fbdev
->num_fbs
> 0) {
2017 struct omapfb_info
*ofbi
= FB2OFB(fbdev
->fbs
[0]);
2019 if (ofbi
->num_overlays
> 0) {
2020 struct omap_overlay
*ovl
= ofbi
->overlays
[0];
2022 r
= omapfb_overlay_enable(ovl
, 1);
2026 "failed to enable overlay\n");
2032 DBG("create_framebuffers done\n");
2037 static int omapfb_mode_to_timings(const char *mode_str
,
2038 struct omap_video_timings
*timings
, u8
*bpp
)
2041 struct fb_var_screeninfo var
;
2042 struct fb_ops fbops
;
2045 #ifdef CONFIG_OMAP2_DSS_VENC
2046 if (strcmp(mode_str
, "pal") == 0) {
2047 *timings
= omap_dss_pal_timings
;
2050 } else if (strcmp(mode_str
, "ntsc") == 0) {
2051 *timings
= omap_dss_ntsc_timings
;
2057 /* this is quite a hack, but I wanted to use the modedb and for
2058 * that we need fb_info and var, so we create dummy ones */
2060 memset(&fbi
, 0, sizeof(fbi
));
2061 memset(&var
, 0, sizeof(var
));
2062 memset(&fbops
, 0, sizeof(fbops
));
2065 r
= fb_find_mode(&var
, &fbi
, mode_str
, NULL
, 0, NULL
, 24);
2068 timings
->pixel_clock
= PICOS2KHZ(var
.pixclock
);
2069 timings
->hfp
= var
.left_margin
;
2070 timings
->hbp
= var
.right_margin
;
2071 timings
->vfp
= var
.upper_margin
;
2072 timings
->vbp
= var
.lower_margin
;
2073 timings
->hsw
= var
.hsync_len
;
2074 timings
->vsw
= var
.vsync_len
;
2075 timings
->x_res
= var
.xres
;
2076 timings
->y_res
= var
.yres
;
2078 switch (var
.bits_per_pixel
) {
2095 static int omapfb_set_def_mode(struct omapfb2_device
*fbdev
,
2096 struct omap_dss_device
*display
, char *mode_str
)
2100 struct omap_video_timings timings
;
2102 r
= omapfb_mode_to_timings(mode_str
, &timings
, &bpp
);
2106 fbdev
->bpp_overrides
[fbdev
->num_bpp_overrides
].dssdev
= display
;
2107 fbdev
->bpp_overrides
[fbdev
->num_bpp_overrides
].bpp
= bpp
;
2108 ++fbdev
->num_bpp_overrides
;
2110 if (!display
->driver
->check_timings
|| !display
->driver
->set_timings
)
2113 r
= display
->driver
->check_timings(display
, &timings
);
2117 display
->driver
->set_timings(display
, &timings
);
2122 static int omapfb_get_recommended_bpp(struct omapfb2_device
*fbdev
,
2123 struct omap_dss_device
*dssdev
)
2127 BUG_ON(dssdev
->driver
->get_recommended_bpp
== NULL
);
2129 for (i
= 0; i
< fbdev
->num_bpp_overrides
; ++i
) {
2130 if (dssdev
== fbdev
->bpp_overrides
[i
].dssdev
)
2131 return fbdev
->bpp_overrides
[i
].bpp
;
2134 return dssdev
->driver
->get_recommended_bpp(dssdev
);
2137 static int omapfb_parse_def_modes(struct omapfb2_device
*fbdev
)
2139 char *str
, *options
, *this_opt
;
2142 str
= kmalloc(strlen(def_mode
) + 1, GFP_KERNEL
);
2143 strcpy(str
, def_mode
);
2146 while (!r
&& (this_opt
= strsep(&options
, ",")) != NULL
) {
2147 char *p
, *display_str
, *mode_str
;
2148 struct omap_dss_device
*display
;
2151 p
= strchr(this_opt
, ':');
2158 display_str
= this_opt
;
2162 for (i
= 0; i
< fbdev
->num_displays
; ++i
) {
2163 if (strcmp(fbdev
->displays
[i
]->name
,
2164 display_str
) == 0) {
2165 display
= fbdev
->displays
[i
];
2175 r
= omapfb_set_def_mode(fbdev
, display
, mode_str
);
2185 static int omapfb_probe(struct platform_device
*pdev
)
2187 struct omapfb2_device
*fbdev
= NULL
;
2190 struct omap_overlay
*ovl
;
2191 struct omap_dss_device
*def_display
;
2192 struct omap_dss_device
*dssdev
;
2194 DBG("omapfb_probe\n");
2196 if (pdev
->num_resources
!= 0) {
2197 dev_err(&pdev
->dev
, "probed for an unknown device\n");
2202 fbdev
= kzalloc(sizeof(struct omapfb2_device
), GFP_KERNEL
);
2203 if (fbdev
== NULL
) {
2208 mutex_init(&fbdev
->mtx
);
2210 fbdev
->dev
= &pdev
->dev
;
2211 platform_set_drvdata(pdev
, fbdev
);
2214 fbdev
->num_displays
= 0;
2216 for_each_dss_dev(dssdev
) {
2217 omap_dss_get_device(dssdev
);
2219 if (!dssdev
->driver
) {
2220 dev_err(&pdev
->dev
, "no driver for display\n");
2224 fbdev
->displays
[fbdev
->num_displays
++] = dssdev
;
2230 if (fbdev
->num_displays
== 0) {
2231 dev_err(&pdev
->dev
, "no displays\n");
2236 fbdev
->num_overlays
= omap_dss_get_num_overlays();
2237 for (i
= 0; i
< fbdev
->num_overlays
; i
++)
2238 fbdev
->overlays
[i
] = omap_dss_get_overlay(i
);
2240 fbdev
->num_managers
= omap_dss_get_num_overlay_managers();
2241 for (i
= 0; i
< fbdev
->num_managers
; i
++)
2242 fbdev
->managers
[i
] = omap_dss_get_overlay_manager(i
);
2244 if (def_mode
&& strlen(def_mode
) > 0) {
2245 if (omapfb_parse_def_modes(fbdev
))
2246 dev_warn(&pdev
->dev
, "cannot parse default modes\n");
2249 r
= omapfb_create_framebuffers(fbdev
);
2253 for (i
= 0; i
< fbdev
->num_managers
; i
++) {
2254 struct omap_overlay_manager
*mgr
;
2255 mgr
= fbdev
->managers
[i
];
2256 r
= mgr
->apply(mgr
);
2258 dev_warn(fbdev
->dev
, "failed to apply dispc config\n");
2261 DBG("mgr->apply'ed\n");
2263 /* gfx overlay should be the default one. find a display
2264 * connected to that, and use it as default display */
2265 ovl
= omap_dss_get_overlay(0);
2266 if (ovl
->manager
&& ovl
->manager
->device
) {
2267 def_display
= ovl
->manager
->device
;
2269 dev_warn(&pdev
->dev
, "cannot find default display\n");
2274 struct omap_dss_driver
*dssdrv
= def_display
->driver
;
2276 r
= def_display
->driver
->enable(def_display
);
2278 dev_warn(fbdev
->dev
, "Failed to enable display '%s'\n",
2283 if (def_display
->caps
& OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE
) {
2285 if (dssdrv
->enable_te
)
2286 dssdrv
->enable_te(def_display
, 1);
2287 if (dssdrv
->set_update_mode
)
2288 dssdrv
->set_update_mode(def_display
,
2289 OMAP_DSS_UPDATE_MANUAL
);
2291 dssdrv
->get_resolution(def_display
, &w
, &h
);
2292 def_display
->driver
->update(def_display
, 0, 0, w
, h
);
2294 if (dssdrv
->set_update_mode
)
2295 dssdrv
->set_update_mode(def_display
,
2296 OMAP_DSS_UPDATE_AUTO
);
2303 omapfb_free_resources(fbdev
);
2305 dev_err(&pdev
->dev
, "failed to setup omapfb\n");
2309 static int omapfb_remove(struct platform_device
*pdev
)
2311 struct omapfb2_device
*fbdev
= platform_get_drvdata(pdev
);
2313 /* FIXME: wait till completion of pending events */
2315 omapfb_remove_sysfs(fbdev
);
2317 omapfb_free_resources(fbdev
);
2322 static struct platform_driver omapfb_driver
= {
2323 .probe
= omapfb_probe
,
2324 .remove
= omapfb_remove
,
2327 .owner
= THIS_MODULE
,
2331 static int __init
omapfb_init(void)
2333 DBG("omapfb_init\n");
2335 if (platform_driver_register(&omapfb_driver
)) {
2336 printk(KERN_ERR
"failed to register omapfb driver\n");
2343 static void __exit
omapfb_exit(void)
2345 DBG("omapfb_exit\n");
2346 platform_driver_unregister(&omapfb_driver
);
2349 module_param_named(mode
, def_mode
, charp
, 0);
2350 module_param_named(vram
, def_vram
, charp
, 0);
2351 module_param_named(rotate
, def_rotate
, int, 0);
2352 module_param_named(vrfb
, def_vrfb
, bool, 0);
2353 module_param_named(mirror
, def_mirror
, bool, 0);
2355 /* late_initcall to let panel/ctrl drivers loaded first.
2356 * I guess better option would be a more dynamic approach,
2357 * so that omapfb reacts to new panels when they are loaded */
2358 late_initcall(omapfb_init
);
2359 /*module_init(omapfb_init);*/
2360 module_exit(omapfb_exit
);
2362 MODULE_AUTHOR("Tomi Valkeinen <tomi.valkeinen@nokia.com>");
2363 MODULE_DESCRIPTION("OMAP2/3 Framebuffer");
2364 MODULE_LICENSE("GPL v2");