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 <video/omapdss.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 bool def_mirror
;
49 static bool auto_update
;
50 static unsigned int auto_update_freq
;
51 module_param(auto_update
, bool, 0);
52 module_param(auto_update_freq
, uint
, 0644);
56 module_param_named(debug
, omapfb_debug
, bool, 0644);
57 static bool omapfb_test_pattern
;
58 module_param_named(test
, omapfb_test_pattern
, bool, 0644);
61 static int omapfb_fb_init(struct omapfb2_device
*fbdev
, struct fb_info
*fbi
);
62 static int omapfb_get_recommended_bpp(struct omapfb2_device
*fbdev
,
63 struct omap_dss_device
*dssdev
);
66 static void draw_pixel(struct fb_info
*fbi
, int x
, int y
, unsigned color
)
68 struct fb_var_screeninfo
*var
= &fbi
->var
;
69 struct fb_fix_screeninfo
*fix
= &fbi
->fix
;
70 void __iomem
*addr
= fbi
->screen_base
;
71 const unsigned bytespp
= var
->bits_per_pixel
>> 3;
72 const unsigned line_len
= fix
->line_length
/ bytespp
;
74 int r
= (color
>> 16) & 0xff;
75 int g
= (color
>> 8) & 0xff;
76 int b
= (color
>> 0) & 0xff;
78 if (var
->bits_per_pixel
== 16) {
79 u16 __iomem
*p
= (u16 __iomem
*)addr
;
80 p
+= y
* line_len
+ x
;
86 __raw_writew((r
<< 11) | (g
<< 5) | (b
<< 0), p
);
87 } else if (var
->bits_per_pixel
== 24) {
88 u8 __iomem
*p
= (u8 __iomem
*)addr
;
89 p
+= (y
* line_len
+ x
) * 3;
91 __raw_writeb(b
, p
+ 0);
92 __raw_writeb(g
, p
+ 1);
93 __raw_writeb(r
, p
+ 2);
94 } else if (var
->bits_per_pixel
== 32) {
95 u32 __iomem
*p
= (u32 __iomem
*)addr
;
96 p
+= y
* line_len
+ x
;
97 __raw_writel(color
, p
);
101 static void fill_fb(struct fb_info
*fbi
)
103 struct fb_var_screeninfo
*var
= &fbi
->var
;
104 const short w
= var
->xres_virtual
;
105 const short h
= var
->yres_virtual
;
106 void __iomem
*addr
= fbi
->screen_base
;
112 DBG("fill_fb %dx%d, line_len %d bytes\n", w
, h
, fbi
->fix
.line_length
);
114 for (y
= 0; y
< h
; y
++) {
115 for (x
= 0; x
< w
; x
++) {
116 if (x
< 20 && y
< 20)
117 draw_pixel(fbi
, x
, y
, 0xffffff);
118 else if (x
< 20 && (y
> 20 && y
< h
- 20))
119 draw_pixel(fbi
, x
, y
, 0xff);
120 else if (y
< 20 && (x
> 20 && x
< w
- 20))
121 draw_pixel(fbi
, x
, y
, 0xff00);
122 else if (x
> w
- 20 && (y
> 20 && y
< h
- 20))
123 draw_pixel(fbi
, x
, y
, 0xff0000);
124 else if (y
> h
- 20 && (x
> 20 && x
< w
- 20))
125 draw_pixel(fbi
, x
, y
, 0xffff00);
126 else if (x
== 20 || x
== w
- 20 ||
127 y
== 20 || y
== h
- 20)
128 draw_pixel(fbi
, x
, y
, 0xffffff);
129 else if (x
== y
|| w
- x
== h
- y
)
130 draw_pixel(fbi
, x
, y
, 0xff00ff);
131 else if (w
- x
== y
|| x
== h
- y
)
132 draw_pixel(fbi
, x
, y
, 0x00ffff);
133 else if (x
> 20 && y
> 20 && x
< w
- 20 && y
< h
- 20) {
135 unsigned r
= 0, g
= 0, b
= 0;
137 if (var
->bits_per_pixel
== 16) {
139 b
= (y
% 32) * 256 / 32;
141 g
= (y
% 64) * 256 / 64;
143 r
= (y
% 32) * 256 / 32;
152 c
= (r
<< 16) | (g
<< 8) | (b
<< 0);
153 draw_pixel(fbi
, x
, y
, c
);
155 draw_pixel(fbi
, x
, y
, 0);
162 static unsigned omapfb_get_vrfb_offset(const struct omapfb_info
*ofbi
, int rot
)
164 const struct vrfb
*vrfb
= &ofbi
->region
->vrfb
;
172 offset
= vrfb
->yoffset
;
175 offset
= vrfb
->yoffset
* OMAP_VRFB_LINE_LEN
+ vrfb
->xoffset
;
178 offset
= vrfb
->xoffset
* OMAP_VRFB_LINE_LEN
;
184 offset
*= vrfb
->bytespp
;
189 static u32
omapfb_get_region_rot_paddr(const struct omapfb_info
*ofbi
, int rot
)
191 if (ofbi
->rotation_type
== OMAP_DSS_ROT_VRFB
) {
192 return ofbi
->region
->vrfb
.paddr
[rot
]
193 + omapfb_get_vrfb_offset(ofbi
, rot
);
195 return ofbi
->region
->paddr
;
199 static u32
omapfb_get_region_paddr(const struct omapfb_info
*ofbi
)
201 if (ofbi
->rotation_type
== OMAP_DSS_ROT_VRFB
)
202 return ofbi
->region
->vrfb
.paddr
[0];
204 return ofbi
->region
->paddr
;
207 static void __iomem
*omapfb_get_region_vaddr(const struct omapfb_info
*ofbi
)
209 if (ofbi
->rotation_type
== OMAP_DSS_ROT_VRFB
)
210 return ofbi
->region
->vrfb
.vaddr
[0];
212 return ofbi
->region
->vaddr
;
215 static struct omapfb_colormode omapfb_colormodes
[] = {
217 .dssmode
= OMAP_DSS_COLOR_UYVY
,
218 .bits_per_pixel
= 16,
219 .nonstd
= OMAPFB_COLOR_YUV422
,
221 .dssmode
= OMAP_DSS_COLOR_YUV2
,
222 .bits_per_pixel
= 16,
223 .nonstd
= OMAPFB_COLOR_YUY422
,
225 .dssmode
= OMAP_DSS_COLOR_ARGB16
,
226 .bits_per_pixel
= 16,
227 .red
= { .length
= 4, .offset
= 8, .msb_right
= 0 },
228 .green
= { .length
= 4, .offset
= 4, .msb_right
= 0 },
229 .blue
= { .length
= 4, .offset
= 0, .msb_right
= 0 },
230 .transp
= { .length
= 4, .offset
= 12, .msb_right
= 0 },
232 .dssmode
= OMAP_DSS_COLOR_RGB16
,
233 .bits_per_pixel
= 16,
234 .red
= { .length
= 5, .offset
= 11, .msb_right
= 0 },
235 .green
= { .length
= 6, .offset
= 5, .msb_right
= 0 },
236 .blue
= { .length
= 5, .offset
= 0, .msb_right
= 0 },
237 .transp
= { .length
= 0, .offset
= 0, .msb_right
= 0 },
239 .dssmode
= OMAP_DSS_COLOR_RGB24P
,
240 .bits_per_pixel
= 24,
241 .red
= { .length
= 8, .offset
= 16, .msb_right
= 0 },
242 .green
= { .length
= 8, .offset
= 8, .msb_right
= 0 },
243 .blue
= { .length
= 8, .offset
= 0, .msb_right
= 0 },
244 .transp
= { .length
= 0, .offset
= 0, .msb_right
= 0 },
246 .dssmode
= OMAP_DSS_COLOR_RGB24U
,
247 .bits_per_pixel
= 32,
248 .red
= { .length
= 8, .offset
= 16, .msb_right
= 0 },
249 .green
= { .length
= 8, .offset
= 8, .msb_right
= 0 },
250 .blue
= { .length
= 8, .offset
= 0, .msb_right
= 0 },
251 .transp
= { .length
= 0, .offset
= 0, .msb_right
= 0 },
253 .dssmode
= OMAP_DSS_COLOR_ARGB32
,
254 .bits_per_pixel
= 32,
255 .red
= { .length
= 8, .offset
= 16, .msb_right
= 0 },
256 .green
= { .length
= 8, .offset
= 8, .msb_right
= 0 },
257 .blue
= { .length
= 8, .offset
= 0, .msb_right
= 0 },
258 .transp
= { .length
= 8, .offset
= 24, .msb_right
= 0 },
260 .dssmode
= OMAP_DSS_COLOR_RGBA32
,
261 .bits_per_pixel
= 32,
262 .red
= { .length
= 8, .offset
= 24, .msb_right
= 0 },
263 .green
= { .length
= 8, .offset
= 16, .msb_right
= 0 },
264 .blue
= { .length
= 8, .offset
= 8, .msb_right
= 0 },
265 .transp
= { .length
= 8, .offset
= 0, .msb_right
= 0 },
267 .dssmode
= OMAP_DSS_COLOR_RGBX32
,
268 .bits_per_pixel
= 32,
269 .red
= { .length
= 8, .offset
= 24, .msb_right
= 0 },
270 .green
= { .length
= 8, .offset
= 16, .msb_right
= 0 },
271 .blue
= { .length
= 8, .offset
= 8, .msb_right
= 0 },
272 .transp
= { .length
= 0, .offset
= 0, .msb_right
= 0 },
276 static bool cmp_var_to_colormode(struct fb_var_screeninfo
*var
,
277 struct omapfb_colormode
*color
)
279 bool cmp_component(struct fb_bitfield
*f1
, struct fb_bitfield
*f2
)
281 return f1
->length
== f2
->length
&&
282 f1
->offset
== f2
->offset
&&
283 f1
->msb_right
== f2
->msb_right
;
286 if (var
->bits_per_pixel
== 0 ||
287 var
->red
.length
== 0 ||
288 var
->blue
.length
== 0 ||
289 var
->green
.length
== 0)
292 return var
->bits_per_pixel
== color
->bits_per_pixel
&&
293 cmp_component(&var
->red
, &color
->red
) &&
294 cmp_component(&var
->green
, &color
->green
) &&
295 cmp_component(&var
->blue
, &color
->blue
) &&
296 cmp_component(&var
->transp
, &color
->transp
);
299 static void assign_colormode_to_var(struct fb_var_screeninfo
*var
,
300 struct omapfb_colormode
*color
)
302 var
->bits_per_pixel
= color
->bits_per_pixel
;
303 var
->nonstd
= color
->nonstd
;
304 var
->red
= color
->red
;
305 var
->green
= color
->green
;
306 var
->blue
= color
->blue
;
307 var
->transp
= color
->transp
;
310 static int fb_mode_to_dss_mode(struct fb_var_screeninfo
*var
,
311 enum omap_color_mode
*mode
)
313 enum omap_color_mode dssmode
;
316 /* first match with nonstd field */
318 for (i
= 0; i
< ARRAY_SIZE(omapfb_colormodes
); ++i
) {
319 struct omapfb_colormode
*m
= &omapfb_colormodes
[i
];
320 if (var
->nonstd
== m
->nonstd
) {
321 assign_colormode_to_var(var
, m
);
330 /* then try exact match of bpp and colors */
331 for (i
= 0; i
< ARRAY_SIZE(omapfb_colormodes
); ++i
) {
332 struct omapfb_colormode
*m
= &omapfb_colormodes
[i
];
333 if (cmp_var_to_colormode(var
, m
)) {
334 assign_colormode_to_var(var
, m
);
340 /* match with bpp if user has not filled color fields
342 switch (var
->bits_per_pixel
) {
344 dssmode
= OMAP_DSS_COLOR_CLUT1
;
347 dssmode
= OMAP_DSS_COLOR_CLUT2
;
350 dssmode
= OMAP_DSS_COLOR_CLUT4
;
353 dssmode
= OMAP_DSS_COLOR_CLUT8
;
356 dssmode
= OMAP_DSS_COLOR_RGB12U
;
359 dssmode
= OMAP_DSS_COLOR_RGB16
;
362 dssmode
= OMAP_DSS_COLOR_RGB24P
;
365 dssmode
= OMAP_DSS_COLOR_RGB24U
;
371 for (i
= 0; i
< ARRAY_SIZE(omapfb_colormodes
); ++i
) {
372 struct omapfb_colormode
*m
= &omapfb_colormodes
[i
];
373 if (dssmode
== m
->dssmode
) {
374 assign_colormode_to_var(var
, m
);
383 static int check_fb_res_bounds(struct fb_var_screeninfo
*var
)
385 int xres_min
= OMAPFB_PLANE_XRES_MIN
;
387 int yres_min
= OMAPFB_PLANE_YRES_MIN
;
390 /* XXX: some applications seem to set virtual res to 0. */
391 if (var
->xres_virtual
== 0)
392 var
->xres_virtual
= var
->xres
;
394 if (var
->yres_virtual
== 0)
395 var
->yres_virtual
= var
->yres
;
397 if (var
->xres_virtual
< xres_min
|| var
->yres_virtual
< yres_min
)
400 if (var
->xres
< xres_min
)
401 var
->xres
= xres_min
;
402 if (var
->yres
< yres_min
)
403 var
->yres
= yres_min
;
404 if (var
->xres
> xres_max
)
405 var
->xres
= xres_max
;
406 if (var
->yres
> yres_max
)
407 var
->yres
= yres_max
;
409 if (var
->xres
> var
->xres_virtual
)
410 var
->xres
= var
->xres_virtual
;
411 if (var
->yres
> var
->yres_virtual
)
412 var
->yres
= var
->yres_virtual
;
417 static void shrink_height(unsigned long max_frame_size
,
418 struct fb_var_screeninfo
*var
)
420 DBG("can't fit FB into memory, reducing y\n");
421 var
->yres_virtual
= max_frame_size
/
422 (var
->xres_virtual
* var
->bits_per_pixel
>> 3);
424 if (var
->yres_virtual
< OMAPFB_PLANE_YRES_MIN
)
425 var
->yres_virtual
= OMAPFB_PLANE_YRES_MIN
;
427 if (var
->yres
> var
->yres_virtual
)
428 var
->yres
= var
->yres_virtual
;
431 static void shrink_width(unsigned long max_frame_size
,
432 struct fb_var_screeninfo
*var
)
434 DBG("can't fit FB into memory, reducing x\n");
435 var
->xres_virtual
= max_frame_size
/ var
->yres_virtual
/
436 (var
->bits_per_pixel
>> 3);
438 if (var
->xres_virtual
< OMAPFB_PLANE_XRES_MIN
)
439 var
->xres_virtual
= OMAPFB_PLANE_XRES_MIN
;
441 if (var
->xres
> var
->xres_virtual
)
442 var
->xres
= var
->xres_virtual
;
445 static int check_vrfb_fb_size(unsigned long region_size
,
446 const struct fb_var_screeninfo
*var
)
448 unsigned long min_phys_size
= omap_vrfb_min_phys_size(var
->xres_virtual
,
449 var
->yres_virtual
, var
->bits_per_pixel
>> 3);
451 return min_phys_size
> region_size
? -EINVAL
: 0;
454 static int check_fb_size(const struct omapfb_info
*ofbi
,
455 struct fb_var_screeninfo
*var
)
457 unsigned long max_frame_size
= ofbi
->region
->size
;
458 int bytespp
= var
->bits_per_pixel
>> 3;
459 unsigned long line_size
= var
->xres_virtual
* bytespp
;
461 if (ofbi
->rotation_type
== OMAP_DSS_ROT_VRFB
) {
462 /* One needs to check for both VRFB and OMAPFB limitations. */
463 if (check_vrfb_fb_size(max_frame_size
, var
))
464 shrink_height(omap_vrfb_max_height(
465 max_frame_size
, var
->xres_virtual
, bytespp
) *
468 if (check_vrfb_fb_size(max_frame_size
, var
)) {
469 DBG("cannot fit FB to memory\n");
476 DBG("max frame size %lu, line size %lu\n", max_frame_size
, line_size
);
478 if (line_size
* var
->yres_virtual
> max_frame_size
)
479 shrink_height(max_frame_size
, var
);
481 if (line_size
* var
->yres_virtual
> max_frame_size
) {
482 shrink_width(max_frame_size
, var
);
483 line_size
= var
->xres_virtual
* bytespp
;
486 if (line_size
* var
->yres_virtual
> max_frame_size
) {
487 DBG("cannot fit FB to memory\n");
495 * Consider if VRFB assisted rotation is in use and if the virtual space for
496 * the zero degree view needs to be mapped. The need for mapping also acts as
497 * the trigger for setting up the hardware on the context in question. This
498 * ensures that one does not attempt to access the virtual view before the
499 * hardware is serving the address translations.
501 static int setup_vrfb_rotation(struct fb_info
*fbi
)
503 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
504 struct omapfb2_mem_region
*rg
= ofbi
->region
;
505 struct vrfb
*vrfb
= &rg
->vrfb
;
506 struct fb_var_screeninfo
*var
= &fbi
->var
;
507 struct fb_fix_screeninfo
*fix
= &fbi
->fix
;
510 enum omap_color_mode mode
;
514 if (!rg
->size
|| ofbi
->rotation_type
!= OMAP_DSS_ROT_VRFB
)
517 DBG("setup_vrfb_rotation\n");
519 r
= fb_mode_to_dss_mode(var
, &mode
);
523 bytespp
= var
->bits_per_pixel
>> 3;
525 yuv_mode
= mode
== OMAP_DSS_COLOR_YUV2
|| mode
== OMAP_DSS_COLOR_UYVY
;
527 /* We need to reconfigure VRFB if the resolution changes, if yuv mode
528 * is enabled/disabled, or if bytes per pixel changes */
530 /* XXX we shouldn't allow this when framebuffer is mmapped */
534 if (yuv_mode
!= vrfb
->yuv_mode
)
536 else if (bytespp
!= vrfb
->bytespp
)
538 else if (vrfb
->xres
!= var
->xres_virtual
||
539 vrfb
->yres
!= var
->yres_virtual
)
542 if (vrfb
->vaddr
[0] && reconf
) {
543 fbi
->screen_base
= NULL
;
546 iounmap(vrfb
->vaddr
[0]);
547 vrfb
->vaddr
[0] = NULL
;
548 DBG("setup_vrfb_rotation: reset fb\n");
554 omap_vrfb_setup(&rg
->vrfb
, rg
->paddr
,
559 /* Now one can ioremap the 0 angle view */
560 r
= omap_vrfb_map_angle(vrfb
, var
->yres_virtual
, 0);
564 /* used by open/write in fbmem.c */
565 fbi
->screen_base
= ofbi
->region
->vrfb
.vaddr
[0];
567 fix
->smem_start
= ofbi
->region
->vrfb
.paddr
[0];
569 switch (var
->nonstd
) {
570 case OMAPFB_COLOR_YUV422
:
571 case OMAPFB_COLOR_YUY422
:
573 (OMAP_VRFB_LINE_LEN
* var
->bits_per_pixel
) >> 2;
577 (OMAP_VRFB_LINE_LEN
* var
->bits_per_pixel
) >> 3;
581 fix
->smem_len
= var
->yres_virtual
* fix
->line_length
;
586 int dss_mode_to_fb_mode(enum omap_color_mode dssmode
,
587 struct fb_var_screeninfo
*var
)
591 for (i
= 0; i
< ARRAY_SIZE(omapfb_colormodes
); ++i
) {
592 struct omapfb_colormode
*mode
= &omapfb_colormodes
[i
];
593 if (dssmode
== mode
->dssmode
) {
594 assign_colormode_to_var(var
, mode
);
601 void set_fb_fix(struct fb_info
*fbi
)
603 struct fb_fix_screeninfo
*fix
= &fbi
->fix
;
604 struct fb_var_screeninfo
*var
= &fbi
->var
;
605 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
606 struct omapfb2_mem_region
*rg
= ofbi
->region
;
610 /* used by open/write in fbmem.c */
611 fbi
->screen_base
= (char __iomem
*)omapfb_get_region_vaddr(ofbi
);
613 /* used by mmap in fbmem.c */
614 if (ofbi
->rotation_type
== OMAP_DSS_ROT_VRFB
) {
615 switch (var
->nonstd
) {
616 case OMAPFB_COLOR_YUV422
:
617 case OMAPFB_COLOR_YUY422
:
619 (OMAP_VRFB_LINE_LEN
* var
->bits_per_pixel
) >> 2;
623 (OMAP_VRFB_LINE_LEN
* var
->bits_per_pixel
) >> 3;
627 fix
->smem_len
= var
->yres_virtual
* fix
->line_length
;
630 (var
->xres_virtual
* var
->bits_per_pixel
) >> 3;
631 fix
->smem_len
= rg
->size
;
634 fix
->smem_start
= omapfb_get_region_paddr(ofbi
);
636 fix
->type
= FB_TYPE_PACKED_PIXELS
;
639 fix
->visual
= FB_VISUAL_PSEUDOCOLOR
;
641 switch (var
->bits_per_pixel
) {
646 fix
->visual
= FB_VISUAL_TRUECOLOR
;
647 /* 12bpp is stored in 16 bits */
653 fix
->visual
= FB_VISUAL_PSEUDOCOLOR
;
658 fix
->accel
= FB_ACCEL_NONE
;
664 /* check new var and possibly modify it to be ok */
665 int check_fb_var(struct fb_info
*fbi
, struct fb_var_screeninfo
*var
)
667 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
668 struct omap_dss_device
*display
= fb2display(fbi
);
669 enum omap_color_mode mode
= 0;
673 DBG("check_fb_var %d\n", ofbi
->id
);
675 WARN_ON(!atomic_read(&ofbi
->region
->lock_count
));
677 r
= fb_mode_to_dss_mode(var
, &mode
);
679 DBG("cannot convert var to omap dss mode\n");
683 for (i
= 0; i
< ofbi
->num_overlays
; ++i
) {
684 if ((ofbi
->overlays
[i
]->supported_modes
& mode
) == 0) {
685 DBG("invalid mode\n");
693 if (check_fb_res_bounds(var
))
696 /* When no memory is allocated ignore the size check */
697 if (ofbi
->region
->size
!= 0 && check_fb_size(ofbi
, var
))
700 if (var
->xres
+ var
->xoffset
> var
->xres_virtual
)
701 var
->xoffset
= var
->xres_virtual
- var
->xres
;
702 if (var
->yres
+ var
->yoffset
> var
->yres_virtual
)
703 var
->yoffset
= var
->yres_virtual
- var
->yres
;
705 DBG("xres = %d, yres = %d, vxres = %d, vyres = %d\n",
706 var
->xres
, var
->yres
,
707 var
->xres_virtual
, var
->yres_virtual
);
709 if (display
&& display
->driver
->get_dimensions
) {
711 display
->driver
->get_dimensions(display
, &w
, &h
);
712 var
->width
= DIV_ROUND_CLOSEST(w
, 1000);
713 var
->height
= DIV_ROUND_CLOSEST(h
, 1000);
721 if (display
&& display
->driver
->get_timings
) {
722 struct omap_video_timings timings
;
723 display
->driver
->get_timings(display
, &timings
);
725 /* pixclock in ps, the rest in pixclock */
726 var
->pixclock
= timings
.pixel_clock
!= 0 ?
727 KHZ2PICOS(timings
.pixel_clock
) :
729 var
->left_margin
= timings
.hbp
;
730 var
->right_margin
= timings
.hfp
;
731 var
->upper_margin
= timings
.vbp
;
732 var
->lower_margin
= timings
.vfp
;
733 var
->hsync_len
= timings
.hsw
;
734 var
->vsync_len
= timings
.vsw
;
737 var
->left_margin
= 0;
738 var
->right_margin
= 0;
739 var
->upper_margin
= 0;
740 var
->lower_margin
= 0;
745 /* TODO: get these from panel->config */
746 var
->vmode
= FB_VMODE_NONINTERLACED
;
753 * ---------------------------------------------------------------------------
754 * fbdev framework callbacks
755 * ---------------------------------------------------------------------------
757 static int omapfb_open(struct fb_info
*fbi
, int user
)
762 static int omapfb_release(struct fb_info
*fbi
, int user
)
767 static unsigned calc_rotation_offset_dma(const struct fb_var_screeninfo
*var
,
768 const struct fb_fix_screeninfo
*fix
, int rotation
)
772 offset
= var
->yoffset
* fix
->line_length
+
773 var
->xoffset
* (var
->bits_per_pixel
>> 3);
778 static unsigned calc_rotation_offset_vrfb(const struct fb_var_screeninfo
*var
,
779 const struct fb_fix_screeninfo
*fix
, int rotation
)
783 if (rotation
== FB_ROTATE_UD
)
784 offset
= (var
->yres_virtual
- var
->yres
) *
786 else if (rotation
== FB_ROTATE_CW
)
787 offset
= (var
->yres_virtual
- var
->yres
) *
788 (var
->bits_per_pixel
>> 3);
792 if (rotation
== FB_ROTATE_UR
)
793 offset
+= var
->yoffset
* fix
->line_length
+
794 var
->xoffset
* (var
->bits_per_pixel
>> 3);
795 else if (rotation
== FB_ROTATE_UD
)
796 offset
-= var
->yoffset
* fix
->line_length
+
797 var
->xoffset
* (var
->bits_per_pixel
>> 3);
798 else if (rotation
== FB_ROTATE_CW
)
799 offset
-= var
->xoffset
* fix
->line_length
+
800 var
->yoffset
* (var
->bits_per_pixel
>> 3);
801 else if (rotation
== FB_ROTATE_CCW
)
802 offset
+= var
->xoffset
* fix
->line_length
+
803 var
->yoffset
* (var
->bits_per_pixel
>> 3);
808 static void omapfb_calc_addr(const struct omapfb_info
*ofbi
,
809 const struct fb_var_screeninfo
*var
,
810 const struct fb_fix_screeninfo
*fix
,
811 int rotation
, u32
*paddr
)
816 if (ofbi
->rotation_type
== OMAP_DSS_ROT_VRFB
)
817 data_start_p
= omapfb_get_region_rot_paddr(ofbi
, rotation
);
819 data_start_p
= omapfb_get_region_paddr(ofbi
);
821 if (ofbi
->rotation_type
== OMAP_DSS_ROT_VRFB
)
822 offset
= calc_rotation_offset_vrfb(var
, fix
, rotation
);
824 offset
= calc_rotation_offset_dma(var
, fix
, rotation
);
826 data_start_p
+= offset
;
829 DBG("offset %d, %d = %d\n",
830 var
->xoffset
, var
->yoffset
, offset
);
832 DBG("paddr %x\n", data_start_p
);
834 *paddr
= data_start_p
;
837 /* setup overlay according to the fb */
838 int omapfb_setup_overlay(struct fb_info
*fbi
, struct omap_overlay
*ovl
,
839 u16 posx
, u16 posy
, u16 outw
, u16 outh
)
842 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
843 struct fb_var_screeninfo
*var
= &fbi
->var
;
844 struct fb_fix_screeninfo
*fix
= &fbi
->fix
;
845 enum omap_color_mode mode
= 0;
846 u32 data_start_p
= 0;
847 struct omap_overlay_info info
;
851 int rotation
= var
->rotate
;
854 WARN_ON(!atomic_read(&ofbi
->region
->lock_count
));
856 for (i
= 0; i
< ofbi
->num_overlays
; i
++) {
857 if (ovl
!= ofbi
->overlays
[i
])
860 rotation
= (rotation
+ ofbi
->rotation
[i
]) % 4;
864 DBG("setup_overlay %d, posx %d, posy %d, outw %d, outh %d\n", ofbi
->id
,
865 posx
, posy
, outw
, outh
);
867 if (rotation
== FB_ROTATE_CW
|| rotation
== FB_ROTATE_CCW
) {
875 if (ofbi
->region
->size
)
876 omapfb_calc_addr(ofbi
, var
, fix
, rotation
, &data_start_p
);
878 r
= fb_mode_to_dss_mode(var
, &mode
);
880 DBG("fb_mode_to_dss_mode failed");
884 switch (var
->nonstd
) {
885 case OMAPFB_COLOR_YUV422
:
886 case OMAPFB_COLOR_YUY422
:
887 if (ofbi
->rotation_type
== OMAP_DSS_ROT_VRFB
) {
888 screen_width
= fix
->line_length
889 / (var
->bits_per_pixel
>> 2);
893 screen_width
= fix
->line_length
/ (var
->bits_per_pixel
>> 3);
897 ovl
->get_overlay_info(ovl
, &info
);
899 if (ofbi
->rotation_type
== OMAP_DSS_ROT_VRFB
)
902 mirror
= ofbi
->mirror
;
904 info
.paddr
= data_start_p
;
905 info
.screen_width
= screen_width
;
908 info
.color_mode
= mode
;
909 info
.rotation_type
= ofbi
->rotation_type
;
910 info
.rotation
= rotation
;
911 info
.mirror
= mirror
;
915 info
.out_width
= outw
;
916 info
.out_height
= outh
;
918 r
= ovl
->set_overlay_info(ovl
, &info
);
920 DBG("ovl->setup_overlay_info failed\n");
927 DBG("setup_overlay failed\n");
931 /* apply var to the overlay */
932 int omapfb_apply_changes(struct fb_info
*fbi
, int init
)
935 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
936 struct fb_var_screeninfo
*var
= &fbi
->var
;
937 struct omap_overlay
*ovl
;
943 if (omapfb_test_pattern
)
947 WARN_ON(!atomic_read(&ofbi
->region
->lock_count
));
949 for (i
= 0; i
< ofbi
->num_overlays
; i
++) {
950 ovl
= ofbi
->overlays
[i
];
952 DBG("apply_changes, fb %d, ovl %d\n", ofbi
->id
, ovl
->id
);
954 if (ofbi
->region
->size
== 0) {
955 /* the fb is not available. disable the overlay */
956 omapfb_overlay_enable(ovl
, 0);
957 if (!init
&& ovl
->manager
)
958 ovl
->manager
->apply(ovl
->manager
);
962 if (init
|| (ovl
->caps
& OMAP_DSS_OVL_CAP_SCALE
) == 0) {
963 int rotation
= (var
->rotate
+ ofbi
->rotation
[i
]) % 4;
964 if (rotation
== FB_ROTATE_CW
||
965 rotation
== FB_ROTATE_CCW
) {
973 outw
= ovl
->info
.out_width
;
974 outh
= ovl
->info
.out_height
;
981 posx
= ovl
->info
.pos_x
;
982 posy
= ovl
->info
.pos_y
;
985 r
= omapfb_setup_overlay(fbi
, ovl
, posx
, posy
, outw
, outh
);
989 if (!init
&& ovl
->manager
)
990 ovl
->manager
->apply(ovl
->manager
);
994 DBG("apply_changes failed\n");
998 /* checks var and eventually tweaks it to something supported,
999 * DO NOT MODIFY PAR */
1000 static int omapfb_check_var(struct fb_var_screeninfo
*var
, struct fb_info
*fbi
)
1002 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
1005 DBG("check_var(%d)\n", FB2OFB(fbi
)->id
);
1007 omapfb_get_mem_region(ofbi
->region
);
1009 r
= check_fb_var(fbi
, var
);
1011 omapfb_put_mem_region(ofbi
->region
);
1016 /* set the video mode according to info->var */
1017 static int omapfb_set_par(struct fb_info
*fbi
)
1019 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
1022 DBG("set_par(%d)\n", FB2OFB(fbi
)->id
);
1024 omapfb_get_mem_region(ofbi
->region
);
1028 r
= setup_vrfb_rotation(fbi
);
1032 r
= omapfb_apply_changes(fbi
, 0);
1035 omapfb_put_mem_region(ofbi
->region
);
1040 static int omapfb_pan_display(struct fb_var_screeninfo
*var
,
1041 struct fb_info
*fbi
)
1043 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
1044 struct fb_var_screeninfo new_var
;
1047 DBG("pan_display(%d)\n", FB2OFB(fbi
)->id
);
1049 if (var
->xoffset
== fbi
->var
.xoffset
&&
1050 var
->yoffset
== fbi
->var
.yoffset
)
1054 new_var
.xoffset
= var
->xoffset
;
1055 new_var
.yoffset
= var
->yoffset
;
1059 omapfb_get_mem_region(ofbi
->region
);
1061 r
= omapfb_apply_changes(fbi
, 0);
1063 omapfb_put_mem_region(ofbi
->region
);
1068 static void mmap_user_open(struct vm_area_struct
*vma
)
1070 struct omapfb2_mem_region
*rg
= vma
->vm_private_data
;
1072 omapfb_get_mem_region(rg
);
1073 atomic_inc(&rg
->map_count
);
1074 omapfb_put_mem_region(rg
);
1077 static void mmap_user_close(struct vm_area_struct
*vma
)
1079 struct omapfb2_mem_region
*rg
= vma
->vm_private_data
;
1081 omapfb_get_mem_region(rg
);
1082 atomic_dec(&rg
->map_count
);
1083 omapfb_put_mem_region(rg
);
1086 static struct vm_operations_struct mmap_user_ops
= {
1087 .open
= mmap_user_open
,
1088 .close
= mmap_user_close
,
1091 static int omapfb_mmap(struct fb_info
*fbi
, struct vm_area_struct
*vma
)
1093 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
1094 struct fb_fix_screeninfo
*fix
= &fbi
->fix
;
1095 struct omapfb2_mem_region
*rg
;
1097 unsigned long start
;
1101 if (vma
->vm_end
- vma
->vm_start
== 0)
1103 if (vma
->vm_pgoff
> (~0UL >> PAGE_SHIFT
))
1105 off
= vma
->vm_pgoff
<< PAGE_SHIFT
;
1107 rg
= omapfb_get_mem_region(ofbi
->region
);
1109 start
= omapfb_get_region_paddr(ofbi
);
1110 len
= fix
->smem_len
;
1113 if ((vma
->vm_end
- vma
->vm_start
+ off
) > len
)
1118 DBG("user mmap region start %lx, len %d, off %lx\n", start
, len
, off
);
1120 vma
->vm_pgoff
= off
>> PAGE_SHIFT
;
1121 vma
->vm_flags
|= VM_IO
| VM_RESERVED
;
1122 vma
->vm_page_prot
= pgprot_writecombine(vma
->vm_page_prot
);
1123 vma
->vm_ops
= &mmap_user_ops
;
1124 vma
->vm_private_data
= rg
;
1125 if (io_remap_pfn_range(vma
, vma
->vm_start
, off
>> PAGE_SHIFT
,
1126 vma
->vm_end
- vma
->vm_start
,
1127 vma
->vm_page_prot
)) {
1132 /* vm_ops.open won't be called for mmap itself. */
1133 atomic_inc(&rg
->map_count
);
1135 omapfb_put_mem_region(rg
);
1140 omapfb_put_mem_region(ofbi
->region
);
1145 /* Store a single color palette entry into a pseudo palette or the hardware
1146 * palette if one is available. For now we support only 16bpp and thus store
1147 * the entry only to the pseudo palette.
1149 static int _setcolreg(struct fb_info
*fbi
, u_int regno
, u_int red
, u_int green
,
1150 u_int blue
, u_int transp
, int update_hw_pal
)
1152 /*struct omapfb_info *ofbi = FB2OFB(fbi);*/
1153 /*struct omapfb2_device *fbdev = ofbi->fbdev;*/
1154 struct fb_var_screeninfo
*var
= &fbi
->var
;
1157 enum omapfb_color_format mode
= OMAPFB_COLOR_RGB24U
; /* XXX */
1159 /*switch (plane->color_mode) {*/
1161 case OMAPFB_COLOR_YUV422
:
1162 case OMAPFB_COLOR_YUV420
:
1163 case OMAPFB_COLOR_YUY422
:
1166 case OMAPFB_COLOR_CLUT_8BPP
:
1167 case OMAPFB_COLOR_CLUT_4BPP
:
1168 case OMAPFB_COLOR_CLUT_2BPP
:
1169 case OMAPFB_COLOR_CLUT_1BPP
:
1171 if (fbdev->ctrl->setcolreg)
1172 r = fbdev->ctrl->setcolreg(regno, red, green, blue,
1173 transp, update_hw_pal);
1178 case OMAPFB_COLOR_RGB565
:
1179 case OMAPFB_COLOR_RGB444
:
1180 case OMAPFB_COLOR_RGB24P
:
1181 case OMAPFB_COLOR_RGB24U
:
1187 pal
= ((red
>> (16 - var
->red
.length
)) <<
1189 ((green
>> (16 - var
->green
.length
)) <<
1190 var
->green
.offset
) |
1191 (blue
>> (16 - var
->blue
.length
));
1192 ((u32
*)(fbi
->pseudo_palette
))[regno
] = pal
;
1201 static int omapfb_setcolreg(u_int regno
, u_int red
, u_int green
, u_int blue
,
1202 u_int transp
, struct fb_info
*info
)
1206 return _setcolreg(info
, regno
, red
, green
, blue
, transp
, 1);
1209 static int omapfb_setcmap(struct fb_cmap
*cmap
, struct fb_info
*info
)
1211 int count
, index
, r
;
1212 u16
*red
, *green
, *blue
, *transp
;
1218 green
= cmap
->green
;
1220 transp
= cmap
->transp
;
1221 index
= cmap
->start
;
1223 for (count
= 0; count
< cmap
->len
; count
++) {
1226 r
= _setcolreg(info
, index
++, *red
++, *green
++, *blue
++, trans
,
1227 count
== cmap
->len
- 1);
1235 static int omapfb_blank(int blank
, struct fb_info
*fbi
)
1237 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
1238 struct omapfb2_device
*fbdev
= ofbi
->fbdev
;
1239 struct omap_dss_device
*display
= fb2display(fbi
);
1240 struct omapfb_display_data
*d
;
1248 d
= get_display_data(fbdev
, display
);
1251 case FB_BLANK_UNBLANK
:
1252 if (display
->state
!= OMAP_DSS_DISPLAY_SUSPENDED
)
1255 if (display
->driver
->resume
)
1256 r
= display
->driver
->resume(display
);
1258 if ((display
->caps
& OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE
) &&
1259 d
->update_mode
== OMAPFB_AUTO_UPDATE
&&
1260 !d
->auto_update_work_enabled
)
1261 omapfb_start_auto_update(fbdev
, display
);
1265 case FB_BLANK_NORMAL
:
1266 /* FB_BLANK_NORMAL could be implemented.
1267 * Needs DSS additions. */
1268 case FB_BLANK_VSYNC_SUSPEND
:
1269 case FB_BLANK_HSYNC_SUSPEND
:
1270 case FB_BLANK_POWERDOWN
:
1271 if (display
->state
!= OMAP_DSS_DISPLAY_ACTIVE
)
1274 if (d
->auto_update_work_enabled
)
1275 omapfb_stop_auto_update(fbdev
, display
);
1277 if (display
->driver
->suspend
)
1278 r
= display
->driver
->suspend(display
);
1287 omapfb_unlock(fbdev
);
1293 /* XXX fb_read and fb_write are needed for VRFB */
1294 ssize_t
omapfb_write(struct fb_info
*info
, const char __user
*buf
,
1295 size_t count
, loff_t
*ppos
)
1297 DBG("omapfb_write %d, %lu\n", count
, (unsigned long)*ppos
);
1298 /* XXX needed for VRFB */
1303 static struct fb_ops omapfb_ops
= {
1304 .owner
= THIS_MODULE
,
1305 .fb_open
= omapfb_open
,
1306 .fb_release
= omapfb_release
,
1307 .fb_fillrect
= cfb_fillrect
,
1308 .fb_copyarea
= cfb_copyarea
,
1309 .fb_imageblit
= cfb_imageblit
,
1310 .fb_blank
= omapfb_blank
,
1311 .fb_ioctl
= omapfb_ioctl
,
1312 .fb_check_var
= omapfb_check_var
,
1313 .fb_set_par
= omapfb_set_par
,
1314 .fb_pan_display
= omapfb_pan_display
,
1315 .fb_mmap
= omapfb_mmap
,
1316 .fb_setcolreg
= omapfb_setcolreg
,
1317 .fb_setcmap
= omapfb_setcmap
,
1318 /*.fb_write = omapfb_write,*/
1321 static void omapfb_free_fbmem(struct fb_info
*fbi
)
1323 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
1324 struct omapfb2_device
*fbdev
= ofbi
->fbdev
;
1325 struct omapfb2_mem_region
*rg
;
1329 WARN_ON(atomic_read(&rg
->map_count
));
1332 if (omap_vram_free(rg
->paddr
, rg
->size
))
1333 dev_err(fbdev
->dev
, "VRAM FREE failed\n");
1338 if (ofbi
->rotation_type
== OMAP_DSS_ROT_VRFB
) {
1339 /* unmap the 0 angle rotation */
1340 if (rg
->vrfb
.vaddr
[0]) {
1341 iounmap(rg
->vrfb
.vaddr
[0]);
1342 omap_vrfb_release_ctx(&rg
->vrfb
);
1343 rg
->vrfb
.vaddr
[0] = NULL
;
1353 static void clear_fb_info(struct fb_info
*fbi
)
1355 memset(&fbi
->var
, 0, sizeof(fbi
->var
));
1356 memset(&fbi
->fix
, 0, sizeof(fbi
->fix
));
1357 strlcpy(fbi
->fix
.id
, MODULE_NAME
, sizeof(fbi
->fix
.id
));
1360 static int omapfb_free_all_fbmem(struct omapfb2_device
*fbdev
)
1364 DBG("free all fbmem\n");
1366 for (i
= 0; i
< fbdev
->num_fbs
; i
++) {
1367 struct fb_info
*fbi
= fbdev
->fbs
[i
];
1368 omapfb_free_fbmem(fbi
);
1375 static int omapfb_alloc_fbmem(struct fb_info
*fbi
, unsigned long size
,
1376 unsigned long paddr
)
1378 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
1379 struct omapfb2_device
*fbdev
= ofbi
->fbdev
;
1380 struct omapfb2_mem_region
*rg
;
1381 void __iomem
*vaddr
;
1388 memset(&rg
->vrfb
, 0, sizeof rg
->vrfb
);
1394 size
= PAGE_ALIGN(size
);
1397 DBG("allocating %lu bytes for fb %d\n", size
, ofbi
->id
);
1398 r
= omap_vram_alloc(OMAP_VRAM_MEMTYPE_SDRAM
, size
, &paddr
);
1400 DBG("reserving %lu bytes at %lx for fb %d\n", size
, paddr
,
1402 r
= omap_vram_reserve(paddr
, size
);
1406 dev_err(fbdev
->dev
, "failed to allocate framebuffer\n");
1410 if (ofbi
->rotation_type
!= OMAP_DSS_ROT_VRFB
) {
1411 vaddr
= ioremap_wc(paddr
, size
);
1414 dev_err(fbdev
->dev
, "failed to ioremap framebuffer\n");
1415 omap_vram_free(paddr
, size
);
1419 DBG("allocated VRAM paddr %lx, vaddr %p\n", paddr
, vaddr
);
1421 r
= omap_vrfb_request_ctx(&rg
->vrfb
);
1423 dev_err(fbdev
->dev
, "vrfb create ctx failed\n");
1438 /* allocate fbmem using display resolution as reference */
1439 static int omapfb_alloc_fbmem_display(struct fb_info
*fbi
, unsigned long size
,
1440 unsigned long paddr
)
1442 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
1443 struct omapfb2_device
*fbdev
= ofbi
->fbdev
;
1444 struct omap_dss_device
*display
;
1447 display
= fb2display(fbi
);
1452 switch (omapfb_get_recommended_bpp(fbdev
, display
)) {
1467 display
->driver
->get_resolution(display
, &w
, &h
);
1469 if (ofbi
->rotation_type
== OMAP_DSS_ROT_VRFB
) {
1470 size
= max(omap_vrfb_min_phys_size(w
, h
, bytespp
),
1471 omap_vrfb_min_phys_size(h
, w
, bytespp
));
1473 DBG("adjusting fb mem size for VRFB, %u -> %lu\n",
1474 w
* h
* bytespp
, size
);
1476 size
= w
* h
* bytespp
;
1483 return omapfb_alloc_fbmem(fbi
, size
, paddr
);
1486 static enum omap_color_mode
fb_format_to_dss_mode(enum omapfb_color_format fmt
)
1488 enum omap_color_mode mode
;
1491 case OMAPFB_COLOR_RGB565
:
1492 mode
= OMAP_DSS_COLOR_RGB16
;
1494 case OMAPFB_COLOR_YUV422
:
1495 mode
= OMAP_DSS_COLOR_YUV2
;
1497 case OMAPFB_COLOR_CLUT_8BPP
:
1498 mode
= OMAP_DSS_COLOR_CLUT8
;
1500 case OMAPFB_COLOR_CLUT_4BPP
:
1501 mode
= OMAP_DSS_COLOR_CLUT4
;
1503 case OMAPFB_COLOR_CLUT_2BPP
:
1504 mode
= OMAP_DSS_COLOR_CLUT2
;
1506 case OMAPFB_COLOR_CLUT_1BPP
:
1507 mode
= OMAP_DSS_COLOR_CLUT1
;
1509 case OMAPFB_COLOR_RGB444
:
1510 mode
= OMAP_DSS_COLOR_RGB12U
;
1512 case OMAPFB_COLOR_YUY422
:
1513 mode
= OMAP_DSS_COLOR_UYVY
;
1515 case OMAPFB_COLOR_ARGB16
:
1516 mode
= OMAP_DSS_COLOR_ARGB16
;
1518 case OMAPFB_COLOR_RGB24U
:
1519 mode
= OMAP_DSS_COLOR_RGB24U
;
1521 case OMAPFB_COLOR_RGB24P
:
1522 mode
= OMAP_DSS_COLOR_RGB24P
;
1524 case OMAPFB_COLOR_ARGB32
:
1525 mode
= OMAP_DSS_COLOR_ARGB32
;
1527 case OMAPFB_COLOR_RGBA32
:
1528 mode
= OMAP_DSS_COLOR_RGBA32
;
1530 case OMAPFB_COLOR_RGBX32
:
1531 mode
= OMAP_DSS_COLOR_RGBX32
;
1540 static int omapfb_parse_vram_param(const char *param
, int max_entries
,
1541 unsigned long *sizes
, unsigned long *paddrs
)
1545 unsigned long paddr
= 0;
1548 start
= (char *)param
;
1553 fbnum
= simple_strtoul(p
, &p
, 10);
1561 if (fbnum
>= max_entries
)
1564 size
= memparse(p
+ 1, &p
);
1572 paddr
= simple_strtoul(p
+ 1, &p
, 16);
1579 paddrs
[fbnum
] = paddr
;
1580 sizes
[fbnum
] = size
;
1596 static int omapfb_allocate_all_fbs(struct omapfb2_device
*fbdev
)
1599 unsigned long vram_sizes
[10];
1600 unsigned long vram_paddrs
[10];
1602 memset(&vram_sizes
, 0, sizeof(vram_sizes
));
1603 memset(&vram_paddrs
, 0, sizeof(vram_paddrs
));
1605 if (def_vram
&& omapfb_parse_vram_param(def_vram
, 10,
1606 vram_sizes
, vram_paddrs
)) {
1607 dev_err(fbdev
->dev
, "failed to parse vram parameter\n");
1609 memset(&vram_sizes
, 0, sizeof(vram_sizes
));
1610 memset(&vram_paddrs
, 0, sizeof(vram_paddrs
));
1613 if (fbdev
->dev
->platform_data
) {
1614 struct omapfb_platform_data
*opd
;
1615 opd
= fbdev
->dev
->platform_data
;
1616 for (i
= 0; i
< opd
->mem_desc
.region_cnt
; ++i
) {
1617 if (!vram_sizes
[i
]) {
1619 unsigned long paddr
;
1621 size
= opd
->mem_desc
.region
[i
].size
;
1622 paddr
= opd
->mem_desc
.region
[i
].paddr
;
1624 vram_sizes
[i
] = size
;
1625 vram_paddrs
[i
] = paddr
;
1630 for (i
= 0; i
< fbdev
->num_fbs
; i
++) {
1631 /* allocate memory automatically only for fb0, or if
1632 * excplicitly defined with vram or plat data option */
1633 if (i
== 0 || vram_sizes
[i
] != 0) {
1634 r
= omapfb_alloc_fbmem_display(fbdev
->fbs
[i
],
1635 vram_sizes
[i
], vram_paddrs
[i
]);
1642 for (i
= 0; i
< fbdev
->num_fbs
; i
++) {
1643 struct omapfb_info
*ofbi
= FB2OFB(fbdev
->fbs
[i
]);
1644 struct omapfb2_mem_region
*rg
;
1647 DBG("region%d phys %08x virt %p size=%lu\n",
1657 int omapfb_realloc_fbmem(struct fb_info
*fbi
, unsigned long size
, int type
)
1659 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
1660 struct omapfb2_device
*fbdev
= ofbi
->fbdev
;
1661 struct omap_dss_device
*display
= fb2display(fbi
);
1662 struct omapfb2_mem_region
*rg
= ofbi
->region
;
1663 unsigned long old_size
= rg
->size
;
1664 unsigned long old_paddr
= rg
->paddr
;
1665 int old_type
= rg
->type
;
1668 if (type
> OMAPFB_MEMTYPE_MAX
)
1671 size
= PAGE_ALIGN(size
);
1673 if (old_size
== size
&& old_type
== type
)
1676 if (display
&& display
->driver
->sync
)
1677 display
->driver
->sync(display
);
1679 omapfb_free_fbmem(fbi
);
1686 r
= omapfb_alloc_fbmem(fbi
, size
, 0);
1690 omapfb_alloc_fbmem(fbi
, old_size
, old_paddr
);
1698 if (old_size
== size
)
1701 if (old_size
== 0) {
1702 DBG("initializing fb %d\n", ofbi
->id
);
1703 r
= omapfb_fb_init(fbdev
, fbi
);
1705 DBG("omapfb_fb_init failed\n");
1708 r
= omapfb_apply_changes(fbi
, 1);
1710 DBG("omapfb_apply_changes failed\n");
1714 struct fb_var_screeninfo new_var
;
1715 memcpy(&new_var
, &fbi
->var
, sizeof(new_var
));
1716 r
= check_fb_var(fbi
, &new_var
);
1719 memcpy(&fbi
->var
, &new_var
, sizeof(fbi
->var
));
1721 r
= setup_vrfb_rotation(fbi
);
1728 omapfb_free_fbmem(fbi
);
1733 static void omapfb_auto_update_work(struct work_struct
*work
)
1735 struct omap_dss_device
*dssdev
;
1736 struct omap_dss_driver
*dssdrv
;
1737 struct omapfb_display_data
*d
;
1740 struct omapfb2_device
*fbdev
;
1742 d
= container_of(work
, struct omapfb_display_data
,
1743 auto_update_work
.work
);
1746 dssdrv
= dssdev
->driver
;
1749 if (!dssdrv
|| !dssdrv
->update
)
1753 dssdrv
->sync(dssdev
);
1755 dssdrv
->get_resolution(dssdev
, &w
, &h
);
1756 dssdrv
->update(dssdev
, 0, 0, w
, h
);
1758 freq
= auto_update_freq
;
1761 queue_delayed_work(fbdev
->auto_update_wq
,
1762 &d
->auto_update_work
, HZ
/ freq
);
1765 void omapfb_start_auto_update(struct omapfb2_device
*fbdev
,
1766 struct omap_dss_device
*display
)
1768 struct omapfb_display_data
*d
;
1770 if (fbdev
->auto_update_wq
== NULL
) {
1771 struct workqueue_struct
*wq
;
1773 wq
= create_singlethread_workqueue("omapfb_auto_update");
1776 dev_err(fbdev
->dev
, "Failed to create workqueue for "
1781 fbdev
->auto_update_wq
= wq
;
1784 d
= get_display_data(fbdev
, display
);
1786 INIT_DELAYED_WORK(&d
->auto_update_work
, omapfb_auto_update_work
);
1788 d
->auto_update_work_enabled
= true;
1790 omapfb_auto_update_work(&d
->auto_update_work
.work
);
1793 void omapfb_stop_auto_update(struct omapfb2_device
*fbdev
,
1794 struct omap_dss_device
*display
)
1796 struct omapfb_display_data
*d
;
1798 d
= get_display_data(fbdev
, display
);
1800 cancel_delayed_work_sync(&d
->auto_update_work
);
1802 d
->auto_update_work_enabled
= false;
1805 /* initialize fb_info, var, fix to something sane based on the display */
1806 static int omapfb_fb_init(struct omapfb2_device
*fbdev
, struct fb_info
*fbi
)
1808 struct fb_var_screeninfo
*var
= &fbi
->var
;
1809 struct omap_dss_device
*display
= fb2display(fbi
);
1810 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
1813 fbi
->fbops
= &omapfb_ops
;
1814 fbi
->flags
= FBINFO_FLAG_DEFAULT
;
1815 fbi
->pseudo_palette
= fbdev
->pseudo_palette
;
1817 if (ofbi
->region
->size
== 0) {
1823 var
->bits_per_pixel
= 0;
1825 var
->rotate
= def_rotate
;
1828 * Check if there is a default color format set in the board file,
1829 * and use this format instead the default deducted from the
1832 if (fbdev
->dev
->platform_data
) {
1833 struct omapfb_platform_data
*opd
;
1836 opd
= fbdev
->dev
->platform_data
;
1837 if (opd
->mem_desc
.region
[id
].format_used
) {
1838 enum omap_color_mode mode
;
1839 enum omapfb_color_format format
;
1841 format
= opd
->mem_desc
.region
[id
].format
;
1842 mode
= fb_format_to_dss_mode(format
);
1847 r
= dss_mode_to_fb_mode(mode
, var
);
1855 int rotation
= (var
->rotate
+ ofbi
->rotation
[0]) % 4;
1857 display
->driver
->get_resolution(display
, &w
, &h
);
1859 if (rotation
== FB_ROTATE_CW
||
1860 rotation
== FB_ROTATE_CCW
) {
1868 var
->xres_virtual
= var
->xres
;
1869 var
->yres_virtual
= var
->yres
;
1871 if (!var
->bits_per_pixel
) {
1872 switch (omapfb_get_recommended_bpp(fbdev
, display
)) {
1874 var
->bits_per_pixel
= 16;
1877 var
->bits_per_pixel
= 32;
1880 dev_err(fbdev
->dev
, "illegal display "
1886 /* if there's no display, let's just guess some basic values */
1889 var
->xres_virtual
= var
->xres
;
1890 var
->yres_virtual
= var
->yres
;
1891 if (!var
->bits_per_pixel
)
1892 var
->bits_per_pixel
= 16;
1895 r
= check_fb_var(fbi
, var
);
1900 r
= setup_vrfb_rotation(fbi
);
1904 r
= fb_alloc_cmap(&fbi
->cmap
, 256, 0);
1906 dev_err(fbdev
->dev
, "unable to allocate color map memory\n");
1912 static void fbinfo_cleanup(struct omapfb2_device
*fbdev
, struct fb_info
*fbi
)
1914 fb_dealloc_cmap(&fbi
->cmap
);
1918 static void omapfb_free_resources(struct omapfb2_device
*fbdev
)
1922 DBG("free_resources\n");
1927 for (i
= 0; i
< fbdev
->num_fbs
; i
++)
1928 unregister_framebuffer(fbdev
->fbs
[i
]);
1930 /* free the reserved fbmem */
1931 omapfb_free_all_fbmem(fbdev
);
1933 for (i
= 0; i
< fbdev
->num_fbs
; i
++) {
1934 fbinfo_cleanup(fbdev
, fbdev
->fbs
[i
]);
1935 framebuffer_release(fbdev
->fbs
[i
]);
1938 for (i
= 0; i
< fbdev
->num_displays
; i
++) {
1939 struct omap_dss_device
*dssdev
= fbdev
->displays
[i
].dssdev
;
1941 if (fbdev
->displays
[i
].auto_update_work_enabled
)
1942 omapfb_stop_auto_update(fbdev
, dssdev
);
1944 if (dssdev
->state
!= OMAP_DSS_DISPLAY_DISABLED
)
1945 dssdev
->driver
->disable(dssdev
);
1947 omap_dss_put_device(dssdev
);
1950 if (fbdev
->auto_update_wq
!= NULL
) {
1951 flush_workqueue(fbdev
->auto_update_wq
);
1952 destroy_workqueue(fbdev
->auto_update_wq
);
1953 fbdev
->auto_update_wq
= NULL
;
1956 dev_set_drvdata(fbdev
->dev
, NULL
);
1960 static int omapfb_create_framebuffers(struct omapfb2_device
*fbdev
)
1966 DBG("create %d framebuffers\n", CONFIG_FB_OMAP2_NUM_FBS
);
1968 /* allocate fb_infos */
1969 for (i
= 0; i
< CONFIG_FB_OMAP2_NUM_FBS
; i
++) {
1970 struct fb_info
*fbi
;
1971 struct omapfb_info
*ofbi
;
1973 fbi
= framebuffer_alloc(sizeof(struct omapfb_info
),
1978 "unable to allocate memory for plane info\n");
1984 fbdev
->fbs
[i
] = fbi
;
1987 ofbi
->fbdev
= fbdev
;
1990 ofbi
->region
= &fbdev
->regions
[i
];
1991 ofbi
->region
->id
= i
;
1992 init_rwsem(&ofbi
->region
->lock
);
1994 /* assign these early, so that fb alloc can use them */
1995 ofbi
->rotation_type
= def_vrfb
? OMAP_DSS_ROT_VRFB
:
1997 ofbi
->mirror
= def_mirror
;
2002 DBG("fb_infos allocated\n");
2004 /* assign overlays for the fbs */
2005 for (i
= 0; i
< min(fbdev
->num_fbs
, fbdev
->num_overlays
); i
++) {
2006 struct omapfb_info
*ofbi
= FB2OFB(fbdev
->fbs
[i
]);
2008 ofbi
->overlays
[0] = fbdev
->overlays
[i
];
2009 ofbi
->num_overlays
= 1;
2012 /* allocate fb memories */
2013 r
= omapfb_allocate_all_fbs(fbdev
);
2015 dev_err(fbdev
->dev
, "failed to allocate fbmem\n");
2019 DBG("fbmems allocated\n");
2021 /* setup fb_infos */
2022 for (i
= 0; i
< fbdev
->num_fbs
; i
++) {
2023 struct fb_info
*fbi
= fbdev
->fbs
[i
];
2024 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
2026 omapfb_get_mem_region(ofbi
->region
);
2027 r
= omapfb_fb_init(fbdev
, fbi
);
2028 omapfb_put_mem_region(ofbi
->region
);
2031 dev_err(fbdev
->dev
, "failed to setup fb_info\n");
2036 DBG("fb_infos initialized\n");
2038 for (i
= 0; i
< fbdev
->num_fbs
; i
++) {
2039 r
= register_framebuffer(fbdev
->fbs
[i
]);
2042 "registering framebuffer %d failed\n", i
);
2047 DBG("framebuffers registered\n");
2049 for (i
= 0; i
< fbdev
->num_fbs
; i
++) {
2050 struct fb_info
*fbi
= fbdev
->fbs
[i
];
2051 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
2053 omapfb_get_mem_region(ofbi
->region
);
2054 r
= omapfb_apply_changes(fbi
, 1);
2055 omapfb_put_mem_region(ofbi
->region
);
2058 dev_err(fbdev
->dev
, "failed to change mode\n");
2064 if (fbdev
->num_fbs
> 0) {
2065 struct omapfb_info
*ofbi
= FB2OFB(fbdev
->fbs
[0]);
2067 if (ofbi
->num_overlays
> 0) {
2068 struct omap_overlay
*ovl
= ofbi
->overlays
[0];
2070 r
= omapfb_overlay_enable(ovl
, 1);
2074 "failed to enable overlay\n");
2080 DBG("create_framebuffers done\n");
2085 static int omapfb_mode_to_timings(const char *mode_str
,
2086 struct omap_video_timings
*timings
, u8
*bpp
)
2088 struct fb_info
*fbi
;
2089 struct fb_var_screeninfo
*var
;
2090 struct fb_ops
*fbops
;
2093 #ifdef CONFIG_OMAP2_DSS_VENC
2094 if (strcmp(mode_str
, "pal") == 0) {
2095 *timings
= omap_dss_pal_timings
;
2098 } else if (strcmp(mode_str
, "ntsc") == 0) {
2099 *timings
= omap_dss_ntsc_timings
;
2105 /* this is quite a hack, but I wanted to use the modedb and for
2106 * that we need fb_info and var, so we create dummy ones */
2113 fbi
= kzalloc(sizeof(*fbi
), GFP_KERNEL
);
2119 var
= kzalloc(sizeof(*var
), GFP_KERNEL
);
2125 fbops
= kzalloc(sizeof(*fbops
), GFP_KERNEL
);
2126 if (fbops
== NULL
) {
2133 r
= fb_find_mode(var
, fbi
, mode_str
, NULL
, 0, NULL
, 24);
2139 timings
->pixel_clock
= PICOS2KHZ(var
->pixclock
);
2140 timings
->hbp
= var
->left_margin
;
2141 timings
->hfp
= var
->right_margin
;
2142 timings
->vbp
= var
->upper_margin
;
2143 timings
->vfp
= var
->lower_margin
;
2144 timings
->hsw
= var
->hsync_len
;
2145 timings
->vsw
= var
->vsync_len
;
2146 timings
->x_res
= var
->xres
;
2147 timings
->y_res
= var
->yres
;
2149 switch (var
->bits_per_pixel
) {
2170 static int omapfb_set_def_mode(struct omapfb2_device
*fbdev
,
2171 struct omap_dss_device
*display
, char *mode_str
)
2175 struct omap_video_timings timings
, temp_timings
;
2176 struct omapfb_display_data
*d
;
2178 r
= omapfb_mode_to_timings(mode_str
, &timings
, &bpp
);
2182 d
= get_display_data(fbdev
, display
);
2183 d
->bpp_override
= bpp
;
2185 if (display
->driver
->check_timings
) {
2186 r
= display
->driver
->check_timings(display
, &timings
);
2190 /* If check_timings is not present compare xres and yres */
2191 if (display
->driver
->get_timings
) {
2192 display
->driver
->get_timings(display
, &temp_timings
);
2194 if (temp_timings
.x_res
!= timings
.x_res
||
2195 temp_timings
.y_res
!= timings
.y_res
)
2200 if (display
->driver
->set_timings
)
2201 display
->driver
->set_timings(display
, &timings
);
2206 static int omapfb_get_recommended_bpp(struct omapfb2_device
*fbdev
,
2207 struct omap_dss_device
*dssdev
)
2209 struct omapfb_display_data
*d
;
2211 BUG_ON(dssdev
->driver
->get_recommended_bpp
== NULL
);
2213 d
= get_display_data(fbdev
, dssdev
);
2215 if (d
->bpp_override
!= 0)
2216 return d
->bpp_override
;
2218 return dssdev
->driver
->get_recommended_bpp(dssdev
);
2221 static int omapfb_parse_def_modes(struct omapfb2_device
*fbdev
)
2223 char *str
, *options
, *this_opt
;
2226 str
= kstrdup(def_mode
, GFP_KERNEL
);
2231 while (!r
&& (this_opt
= strsep(&options
, ",")) != NULL
) {
2232 char *p
, *display_str
, *mode_str
;
2233 struct omap_dss_device
*display
;
2236 p
= strchr(this_opt
, ':');
2243 display_str
= this_opt
;
2247 for (i
= 0; i
< fbdev
->num_displays
; ++i
) {
2248 if (strcmp(fbdev
->displays
[i
].dssdev
->name
,
2249 display_str
) == 0) {
2250 display
= fbdev
->displays
[i
].dssdev
;
2260 r
= omapfb_set_def_mode(fbdev
, display
, mode_str
);
2270 static void fb_videomode_to_omap_timings(struct fb_videomode
*m
,
2271 struct omap_video_timings
*t
)
2275 t
->pixel_clock
= PICOS2KHZ(m
->pixclock
);
2276 t
->hsw
= m
->hsync_len
;
2277 t
->hfp
= m
->right_margin
;
2278 t
->hbp
= m
->left_margin
;
2279 t
->vsw
= m
->vsync_len
;
2280 t
->vfp
= m
->lower_margin
;
2281 t
->vbp
= m
->upper_margin
;
2284 static int omapfb_find_best_mode(struct omap_dss_device
*display
,
2285 struct omap_video_timings
*timings
)
2287 struct fb_monspecs
*specs
;
2289 int r
, i
, best_xres
, best_idx
, len
;
2291 if (!display
->driver
->read_edid
)
2295 edid
= kmalloc(len
, GFP_KERNEL
);
2297 r
= display
->driver
->read_edid(display
, edid
, len
);
2301 specs
= kzalloc(sizeof(*specs
), GFP_KERNEL
);
2303 fb_edid_to_monspecs(edid
, specs
);
2306 fb_edid_add_monspecs(edid
+ 0x80, specs
);
2311 for (i
= 0; i
< specs
->modedb_len
; ++i
) {
2312 struct fb_videomode
*m
;
2313 struct omap_video_timings t
;
2315 m
= &specs
->modedb
[i
];
2317 if (m
->pixclock
== 0)
2320 /* skip repeated pixel modes */
2321 if (m
->xres
== 2880 || m
->xres
== 1440)
2324 fb_videomode_to_omap_timings(m
, &t
);
2326 r
= display
->driver
->check_timings(display
, &t
);
2327 if (r
== 0 && best_xres
< m
->xres
) {
2328 best_xres
= m
->xres
;
2333 if (best_xres
== 0) {
2338 fb_videomode_to_omap_timings(&specs
->modedb
[best_idx
], timings
);
2343 fb_destroy_modedb(specs
->modedb
);
2351 static int omapfb_init_display(struct omapfb2_device
*fbdev
,
2352 struct omap_dss_device
*dssdev
)
2354 struct omap_dss_driver
*dssdrv
= dssdev
->driver
;
2355 struct omapfb_display_data
*d
;
2358 r
= dssdrv
->enable(dssdev
);
2360 dev_warn(fbdev
->dev
, "Failed to enable display '%s'\n",
2365 d
= get_display_data(fbdev
, dssdev
);
2369 if (dssdev
->caps
& OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE
) {
2373 omapfb_start_auto_update(fbdev
, dssdev
);
2374 d
->update_mode
= OMAPFB_AUTO_UPDATE
;
2376 d
->update_mode
= OMAPFB_MANUAL_UPDATE
;
2379 if (dssdrv
->enable_te
) {
2380 r
= dssdrv
->enable_te(dssdev
, 1);
2382 dev_err(fbdev
->dev
, "Failed to set TE\n");
2387 dssdrv
->get_resolution(dssdev
, &w
, &h
);
2388 r
= dssdrv
->update(dssdev
, 0, 0, w
, h
);
2391 "Failed to update display\n");
2395 d
->update_mode
= OMAPFB_AUTO_UPDATE
;
2401 static int omapfb_probe(struct platform_device
*pdev
)
2403 struct omapfb2_device
*fbdev
= NULL
;
2406 struct omap_overlay
*ovl
;
2407 struct omap_dss_device
*def_display
;
2408 struct omap_dss_device
*dssdev
;
2410 DBG("omapfb_probe\n");
2412 if (pdev
->num_resources
!= 0) {
2413 dev_err(&pdev
->dev
, "probed for an unknown device\n");
2418 fbdev
= kzalloc(sizeof(struct omapfb2_device
), GFP_KERNEL
);
2419 if (fbdev
== NULL
) {
2424 /* TODO : Replace cpu check with omap_has_vrfb once HAS_FEATURE
2425 * available for OMAP2 and OMAP3
2427 if (def_vrfb
&& !cpu_is_omap24xx() && !cpu_is_omap34xx()) {
2429 dev_warn(&pdev
->dev
, "VRFB is not supported on this hardware, "
2430 "ignoring the module parameter vrfb=y\n");
2434 mutex_init(&fbdev
->mtx
);
2436 fbdev
->dev
= &pdev
->dev
;
2437 platform_set_drvdata(pdev
, fbdev
);
2440 fbdev
->num_displays
= 0;
2442 for_each_dss_dev(dssdev
) {
2443 struct omapfb_display_data
*d
;
2445 omap_dss_get_device(dssdev
);
2447 if (!dssdev
->driver
) {
2448 dev_warn(&pdev
->dev
, "no driver for display: %s\n",
2450 omap_dss_put_device(dssdev
);
2454 d
= &fbdev
->displays
[fbdev
->num_displays
++];
2456 if (dssdev
->caps
& OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE
)
2457 d
->update_mode
= OMAPFB_MANUAL_UPDATE
;
2459 d
->update_mode
= OMAPFB_AUTO_UPDATE
;
2465 if (fbdev
->num_displays
== 0) {
2466 dev_err(&pdev
->dev
, "no displays\n");
2471 fbdev
->num_overlays
= omap_dss_get_num_overlays();
2472 for (i
= 0; i
< fbdev
->num_overlays
; i
++)
2473 fbdev
->overlays
[i
] = omap_dss_get_overlay(i
);
2475 fbdev
->num_managers
= omap_dss_get_num_overlay_managers();
2476 for (i
= 0; i
< fbdev
->num_managers
; i
++)
2477 fbdev
->managers
[i
] = omap_dss_get_overlay_manager(i
);
2479 /* gfx overlay should be the default one. find a display
2480 * connected to that, and use it as default display */
2481 ovl
= omap_dss_get_overlay(0);
2482 if (ovl
->manager
&& ovl
->manager
->device
) {
2483 def_display
= ovl
->manager
->device
;
2485 dev_warn(&pdev
->dev
, "cannot find default display\n");
2489 if (def_mode
&& strlen(def_mode
) > 0) {
2490 if (omapfb_parse_def_modes(fbdev
))
2491 dev_warn(&pdev
->dev
, "cannot parse default modes\n");
2492 } else if (def_display
&& def_display
->driver
->set_timings
&&
2493 def_display
->driver
->check_timings
) {
2494 struct omap_video_timings t
;
2496 r
= omapfb_find_best_mode(def_display
, &t
);
2499 def_display
->driver
->set_timings(def_display
, &t
);
2502 r
= omapfb_create_framebuffers(fbdev
);
2506 for (i
= 0; i
< fbdev
->num_managers
; i
++) {
2507 struct omap_overlay_manager
*mgr
;
2508 mgr
= fbdev
->managers
[i
];
2509 r
= mgr
->apply(mgr
);
2511 dev_warn(fbdev
->dev
, "failed to apply dispc config\n");
2514 DBG("mgr->apply'ed\n");
2517 r
= omapfb_init_display(fbdev
, def_display
);
2520 "failed to initialize default "
2526 DBG("create sysfs for fbs\n");
2527 r
= omapfb_create_sysfs(fbdev
);
2529 dev_err(fbdev
->dev
, "failed to create sysfs entries\n");
2536 omapfb_free_resources(fbdev
);
2538 dev_err(&pdev
->dev
, "failed to setup omapfb\n");
2542 static int omapfb_remove(struct platform_device
*pdev
)
2544 struct omapfb2_device
*fbdev
= platform_get_drvdata(pdev
);
2546 /* FIXME: wait till completion of pending events */
2548 omapfb_remove_sysfs(fbdev
);
2550 omapfb_free_resources(fbdev
);
2555 static struct platform_driver omapfb_driver
= {
2556 .probe
= omapfb_probe
,
2557 .remove
= omapfb_remove
,
2560 .owner
= THIS_MODULE
,
2564 static int __init
omapfb_init(void)
2566 DBG("omapfb_init\n");
2568 if (platform_driver_register(&omapfb_driver
)) {
2569 printk(KERN_ERR
"failed to register omapfb driver\n");
2576 static void __exit
omapfb_exit(void)
2578 DBG("omapfb_exit\n");
2579 platform_driver_unregister(&omapfb_driver
);
2582 module_param_named(mode
, def_mode
, charp
, 0);
2583 module_param_named(vram
, def_vram
, charp
, 0);
2584 module_param_named(rotate
, def_rotate
, int, 0);
2585 module_param_named(vrfb
, def_vrfb
, bool, 0);
2586 module_param_named(mirror
, def_mirror
, bool, 0);
2588 /* late_initcall to let panel/ctrl drivers loaded first.
2589 * I guess better option would be a more dynamic approach,
2590 * so that omapfb reacts to new panels when they are loaded */
2591 late_initcall(omapfb_init
);
2592 /*module_init(omapfb_init);*/
2593 module_exit(omapfb_exit
);
2595 MODULE_AUTHOR("Tomi Valkeinen <tomi.valkeinen@nokia.com>");
2596 MODULE_DESCRIPTION("OMAP2/3 Framebuffer");
2597 MODULE_LICENSE("GPL v2");