2 * Framebuffer driver for TI OMAP boards
4 * Copyright (C) 2004 Nokia Corporation
5 * Author: Imre Deak <imre.deak@nokia.com>
8 * Alex McMains <aam@ridgerun.com> - Original driver
9 * Juha Yrjola <juha.yrjola@nokia.com> - Original driver and improvements
10 * Dirk Behme <dirk.behme@de.bosch.com> - changes for 2.6 kernel API
11 * Texas Instruments - H3 support
13 * This program is free software; you can redistribute it and/or modify it
14 * under the terms of the GNU General Public License as published by the
15 * Free Software Foundation; either version 2 of the License, or (at your
16 * option) any later version.
18 * This program is distributed in the hope that it will be useful, but
19 * WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 * General Public License for more details.
23 * You should have received a copy of the GNU General Public License along
24 * with this program; if not, write to the Free Software Foundation, Inc.,
25 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
27 #include <linux/platform_device.h>
29 #include <linux/uaccess.h>
32 #include <mach/omapfb.h>
37 #define MODULE_NAME "omapfb"
39 static unsigned int def_accel
;
40 static unsigned long def_vram
[OMAPFB_PLANE_NUM
];
41 static unsigned int def_vram_cnt
;
42 static unsigned long def_vxres
;
43 static unsigned long def_vyres
;
44 static unsigned int def_rotate
;
45 static unsigned int def_mirror
;
47 #ifdef CONFIG_FB_OMAP_MANUAL_UPDATE
48 static int manual_update
= 1;
50 static int manual_update
;
53 static struct platform_device
*fbdev_pdev
;
54 static struct lcd_panel
*fbdev_panel
;
55 static struct omapfb_device
*omapfb_dev
;
57 struct caps_table_struct
{
62 static struct caps_table_struct ctrl_caps
[] = {
63 { OMAPFB_CAPS_MANUAL_UPDATE
, "manual update" },
64 { OMAPFB_CAPS_TEARSYNC
, "tearing synchronization" },
65 { OMAPFB_CAPS_PLANE_RELOCATE_MEM
, "relocate plane memory" },
66 { OMAPFB_CAPS_PLANE_SCALE
, "scale plane" },
67 { OMAPFB_CAPS_WINDOW_PIXEL_DOUBLE
, "pixel double window" },
68 { OMAPFB_CAPS_WINDOW_SCALE
, "scale window" },
69 { OMAPFB_CAPS_WINDOW_OVERLAY
, "overlay window" },
70 { OMAPFB_CAPS_SET_BACKLIGHT
, "backlight setting" },
73 static struct caps_table_struct color_caps
[] = {
74 { 1 << OMAPFB_COLOR_RGB565
, "RGB565", },
75 { 1 << OMAPFB_COLOR_YUV422
, "YUV422", },
76 { 1 << OMAPFB_COLOR_YUV420
, "YUV420", },
77 { 1 << OMAPFB_COLOR_CLUT_8BPP
, "CLUT8", },
78 { 1 << OMAPFB_COLOR_CLUT_4BPP
, "CLUT4", },
79 { 1 << OMAPFB_COLOR_CLUT_2BPP
, "CLUT2", },
80 { 1 << OMAPFB_COLOR_CLUT_1BPP
, "CLUT1", },
81 { 1 << OMAPFB_COLOR_RGB444
, "RGB444", },
82 { 1 << OMAPFB_COLOR_YUY422
, "YUY422", },
86 * ---------------------------------------------------------------------------
88 * ---------------------------------------------------------------------------
90 extern struct lcd_ctrl hwa742_ctrl
;
91 extern struct lcd_ctrl blizzard_ctrl
;
93 static const struct lcd_ctrl
*ctrls
[] = {
94 #ifdef CONFIG_ARCH_OMAP1
100 #ifdef CONFIG_FB_OMAP_LCDC_HWA742
103 #ifdef CONFIG_FB_OMAP_LCDC_BLIZZARD
108 #ifdef CONFIG_FB_OMAP_LCDC_EXTERNAL
109 #ifdef CONFIG_ARCH_OMAP1
110 extern struct lcd_ctrl_extif omap1_ext_if
;
112 extern struct lcd_ctrl_extif omap2_ext_if
;
116 static void omapfb_rqueue_lock(struct omapfb_device
*fbdev
)
118 mutex_lock(&fbdev
->rqueue_mutex
);
121 static void omapfb_rqueue_unlock(struct omapfb_device
*fbdev
)
123 mutex_unlock(&fbdev
->rqueue_mutex
);
127 * ---------------------------------------------------------------------------
128 * LCD controller and LCD DMA
129 * ---------------------------------------------------------------------------
131 /* Lookup table to map elem size to elem type. */
132 static const int dma_elem_type
[] = {
134 OMAP_DMA_DATA_TYPE_S8
,
135 OMAP_DMA_DATA_TYPE_S16
,
137 OMAP_DMA_DATA_TYPE_S32
,
141 * Allocate resources needed for LCD controller and LCD DMA operations. Video
142 * memory is allocated from system memory according to the virtual display
143 * size, except if a bigger memory size is specified explicitly as a kernel
146 static int ctrl_init(struct omapfb_device
*fbdev
)
151 /* kernel/module vram parameters override boot tags/board config */
153 for (i
= 0; i
< def_vram_cnt
; i
++)
154 fbdev
->mem_desc
.region
[i
].size
=
155 PAGE_ALIGN(def_vram
[i
]);
156 fbdev
->mem_desc
.region_cnt
= i
;
158 struct omapfb_platform_data
*conf
;
160 conf
= fbdev
->dev
->platform_data
;
161 fbdev
->mem_desc
= conf
->mem_desc
;
164 if (!fbdev
->mem_desc
.region_cnt
) {
165 struct lcd_panel
*panel
= fbdev
->panel
;
167 int bpp
= panel
->bpp
;
169 /* 12 bpp is packed in 16 bits */
172 def_size
= def_vxres
* def_vyres
* bpp
/ 8;
173 fbdev
->mem_desc
.region_cnt
= 1;
174 fbdev
->mem_desc
.region
[0].size
= PAGE_ALIGN(def_size
);
176 r
= fbdev
->ctrl
->init(fbdev
, 0, &fbdev
->mem_desc
);
178 dev_err(fbdev
->dev
, "controller initialization failed (%d)\n",
184 for (i
= 0; i
< fbdev
->mem_desc
.region_cnt
; i
++) {
185 dev_dbg(fbdev
->dev
, "region%d phys %08x virt %p size=%lu\n",
187 fbdev
->mem_desc
.region
[i
].paddr
,
188 fbdev
->mem_desc
.region
[i
].vaddr
,
189 fbdev
->mem_desc
.region
[i
].size
);
195 static void ctrl_cleanup(struct omapfb_device
*fbdev
)
197 fbdev
->ctrl
->cleanup();
200 /* Must be called with fbdev->rqueue_mutex held. */
201 static int ctrl_change_mode(struct fb_info
*fbi
)
204 unsigned long offset
;
205 struct omapfb_plane_struct
*plane
= fbi
->par
;
206 struct omapfb_device
*fbdev
= plane
->fbdev
;
207 struct fb_var_screeninfo
*var
= &fbi
->var
;
209 offset
= var
->yoffset
* fbi
->fix
.line_length
+
210 var
->xoffset
* var
->bits_per_pixel
/ 8;
212 if (fbdev
->ctrl
->sync
)
214 r
= fbdev
->ctrl
->setup_plane(plane
->idx
, plane
->info
.channel_out
,
215 offset
, var
->xres_virtual
,
216 plane
->info
.pos_x
, plane
->info
.pos_y
,
217 var
->xres
, var
->yres
, plane
->color_mode
);
218 if (fbdev
->ctrl
->set_scale
!= NULL
)
219 r
= fbdev
->ctrl
->set_scale(plane
->idx
,
220 var
->xres
, var
->yres
,
221 plane
->info
.out_width
,
222 plane
->info
.out_height
);
228 * ---------------------------------------------------------------------------
229 * fbdev framework callbacks and the ioctl interface
230 * ---------------------------------------------------------------------------
232 /* Called each time the omapfb device is opened */
233 static int omapfb_open(struct fb_info
*info
, int user
)
238 static void omapfb_sync(struct fb_info
*info
);
240 /* Called when the omapfb device is closed. We make sure that any pending
241 * gfx DMA operations are ended, before we return. */
242 static int omapfb_release(struct fb_info
*info
, int user
)
248 /* Store a single color palette entry into a pseudo palette or the hardware
249 * palette if one is available. For now we support only 16bpp and thus store
250 * the entry only to the pseudo palette.
252 static int _setcolreg(struct fb_info
*info
, u_int regno
, u_int red
, u_int green
,
253 u_int blue
, u_int transp
, int update_hw_pal
)
255 struct omapfb_plane_struct
*plane
= info
->par
;
256 struct omapfb_device
*fbdev
= plane
->fbdev
;
257 struct fb_var_screeninfo
*var
= &info
->var
;
260 switch (plane
->color_mode
) {
261 case OMAPFB_COLOR_YUV422
:
262 case OMAPFB_COLOR_YUV420
:
263 case OMAPFB_COLOR_YUY422
:
266 case OMAPFB_COLOR_CLUT_8BPP
:
267 case OMAPFB_COLOR_CLUT_4BPP
:
268 case OMAPFB_COLOR_CLUT_2BPP
:
269 case OMAPFB_COLOR_CLUT_1BPP
:
270 if (fbdev
->ctrl
->setcolreg
)
271 r
= fbdev
->ctrl
->setcolreg(regno
, red
, green
, blue
,
272 transp
, update_hw_pal
);
274 case OMAPFB_COLOR_RGB565
:
275 case OMAPFB_COLOR_RGB444
:
286 pal
= ((red
>> (16 - var
->red
.length
)) <<
288 ((green
>> (16 - var
->green
.length
)) <<
290 (blue
>> (16 - var
->blue
.length
));
291 ((u32
*)(info
->pseudo_palette
))[regno
] = pal
;
300 static int omapfb_setcolreg(u_int regno
, u_int red
, u_int green
, u_int blue
,
301 u_int transp
, struct fb_info
*info
)
303 return _setcolreg(info
, regno
, red
, green
, blue
, transp
, 1);
306 static int omapfb_setcmap(struct fb_cmap
*cmap
, struct fb_info
*info
)
309 u16
*red
, *green
, *blue
, *transp
;
315 transp
= cmap
->transp
;
318 for (count
= 0; count
< cmap
->len
; count
++) {
321 r
= _setcolreg(info
, index
++, *red
++, *green
++, *blue
++, trans
,
322 count
== cmap
->len
- 1);
330 static int omapfb_update_full_screen(struct fb_info
*fbi
);
332 static int omapfb_blank(int blank
, struct fb_info
*fbi
)
334 struct omapfb_plane_struct
*plane
= fbi
->par
;
335 struct omapfb_device
*fbdev
= plane
->fbdev
;
339 omapfb_rqueue_lock(fbdev
);
341 case VESA_NO_BLANKING
:
342 if (fbdev
->state
== OMAPFB_SUSPENDED
) {
343 if (fbdev
->ctrl
->resume
)
344 fbdev
->ctrl
->resume();
345 fbdev
->panel
->enable(fbdev
->panel
);
346 fbdev
->state
= OMAPFB_ACTIVE
;
347 if (fbdev
->ctrl
->get_update_mode() ==
348 OMAPFB_MANUAL_UPDATE
)
353 if (fbdev
->state
== OMAPFB_ACTIVE
) {
354 fbdev
->panel
->disable(fbdev
->panel
);
355 if (fbdev
->ctrl
->suspend
)
356 fbdev
->ctrl
->suspend();
357 fbdev
->state
= OMAPFB_SUSPENDED
;
363 omapfb_rqueue_unlock(fbdev
);
365 if (r
== 0 && do_update
)
366 r
= omapfb_update_full_screen(fbi
);
371 static void omapfb_sync(struct fb_info
*fbi
)
373 struct omapfb_plane_struct
*plane
= fbi
->par
;
374 struct omapfb_device
*fbdev
= plane
->fbdev
;
376 omapfb_rqueue_lock(fbdev
);
377 if (fbdev
->ctrl
->sync
)
379 omapfb_rqueue_unlock(fbdev
);
383 * Set fb_info.fix fields and also updates fbdev.
384 * When calling this fb_info.var must be set up already.
386 static void set_fb_fix(struct fb_info
*fbi
)
388 struct fb_fix_screeninfo
*fix
= &fbi
->fix
;
389 struct fb_var_screeninfo
*var
= &fbi
->var
;
390 struct omapfb_plane_struct
*plane
= fbi
->par
;
391 struct omapfb_mem_region
*rg
;
394 rg
= &plane
->fbdev
->mem_desc
.region
[plane
->idx
];
395 fbi
->screen_base
= (char __iomem
*)rg
->vaddr
;
396 fix
->smem_start
= rg
->paddr
;
397 fix
->smem_len
= rg
->size
;
399 fix
->type
= FB_TYPE_PACKED_PIXELS
;
400 bpp
= var
->bits_per_pixel
;
402 fix
->visual
= FB_VISUAL_PSEUDOCOLOR
;
403 else switch (var
->bits_per_pixel
) {
406 fix
->visual
= FB_VISUAL_TRUECOLOR
;
407 /* 12bpp is stored in 16 bits */
414 fix
->visual
= FB_VISUAL_PSEUDOCOLOR
;
417 fix
->accel
= FB_ACCEL_OMAP1610
;
418 fix
->line_length
= var
->xres_virtual
* bpp
/ 8;
421 static int set_color_mode(struct omapfb_plane_struct
*plane
,
422 struct fb_var_screeninfo
*var
)
424 switch (var
->nonstd
) {
427 case OMAPFB_COLOR_YUV422
:
428 var
->bits_per_pixel
= 16;
429 plane
->color_mode
= var
->nonstd
;
431 case OMAPFB_COLOR_YUV420
:
432 var
->bits_per_pixel
= 12;
433 plane
->color_mode
= var
->nonstd
;
435 case OMAPFB_COLOR_YUY422
:
436 var
->bits_per_pixel
= 16;
437 plane
->color_mode
= var
->nonstd
;
443 switch (var
->bits_per_pixel
) {
445 plane
->color_mode
= OMAPFB_COLOR_CLUT_1BPP
;
448 plane
->color_mode
= OMAPFB_COLOR_CLUT_2BPP
;
451 plane
->color_mode
= OMAPFB_COLOR_CLUT_4BPP
;
454 plane
->color_mode
= OMAPFB_COLOR_CLUT_8BPP
;
457 var
->bits_per_pixel
= 16;
458 plane
->color_mode
= OMAPFB_COLOR_RGB444
;
461 plane
->color_mode
= OMAPFB_COLOR_RGB565
;
469 * Check the values in var against our capabilities and in case of out of
470 * bound values try to adjust them.
472 static int set_fb_var(struct fb_info
*fbi
,
473 struct fb_var_screeninfo
*var
)
476 unsigned long max_frame_size
;
477 unsigned long line_size
;
478 int xres_min
, xres_max
;
479 int yres_min
, yres_max
;
480 struct omapfb_plane_struct
*plane
= fbi
->par
;
481 struct omapfb_device
*fbdev
= plane
->fbdev
;
482 struct lcd_panel
*panel
= fbdev
->panel
;
484 if (set_color_mode(plane
, var
) < 0)
487 bpp
= var
->bits_per_pixel
;
488 if (plane
->color_mode
== OMAPFB_COLOR_RGB444
)
491 switch (var
->rotate
) {
494 xres_min
= OMAPFB_PLANE_XRES_MIN
;
495 xres_max
= panel
->x_res
;
496 yres_min
= OMAPFB_PLANE_YRES_MIN
;
497 yres_max
= panel
->y_res
;
498 if (cpu_is_omap15xx()) {
499 var
->xres
= panel
->x_res
;
500 var
->yres
= panel
->y_res
;
505 xres_min
= OMAPFB_PLANE_YRES_MIN
;
506 xres_max
= panel
->y_res
;
507 yres_min
= OMAPFB_PLANE_XRES_MIN
;
508 yres_max
= panel
->x_res
;
509 if (cpu_is_omap15xx()) {
510 var
->xres
= panel
->y_res
;
511 var
->yres
= panel
->x_res
;
518 if (var
->xres
< xres_min
)
519 var
->xres
= xres_min
;
520 if (var
->yres
< yres_min
)
521 var
->yres
= yres_min
;
522 if (var
->xres
> xres_max
)
523 var
->xres
= xres_max
;
524 if (var
->yres
> yres_max
)
525 var
->yres
= yres_max
;
527 if (var
->xres_virtual
< var
->xres
)
528 var
->xres_virtual
= var
->xres
;
529 if (var
->yres_virtual
< var
->yres
)
530 var
->yres_virtual
= var
->yres
;
531 max_frame_size
= fbdev
->mem_desc
.region
[plane
->idx
].size
;
532 line_size
= var
->xres_virtual
* bpp
/ 8;
533 if (line_size
* var
->yres_virtual
> max_frame_size
) {
534 /* Try to keep yres_virtual first */
535 line_size
= max_frame_size
/ var
->yres_virtual
;
536 var
->xres_virtual
= line_size
* 8 / bpp
;
537 if (var
->xres_virtual
< var
->xres
) {
538 /* Still doesn't fit. Shrink yres_virtual too */
539 var
->xres_virtual
= var
->xres
;
540 line_size
= var
->xres
* bpp
/ 8;
541 var
->yres_virtual
= max_frame_size
/ line_size
;
543 /* Recheck this, as the virtual size changed. */
544 if (var
->xres_virtual
< var
->xres
)
545 var
->xres
= var
->xres_virtual
;
546 if (var
->yres_virtual
< var
->yres
)
547 var
->yres
= var
->yres_virtual
;
548 if (var
->xres
< xres_min
|| var
->yres
< yres_min
)
551 if (var
->xres
+ var
->xoffset
> var
->xres_virtual
)
552 var
->xoffset
= var
->xres_virtual
- var
->xres
;
553 if (var
->yres
+ var
->yoffset
> var
->yres_virtual
)
554 var
->yoffset
= var
->yres_virtual
- var
->yres
;
555 line_size
= var
->xres
* bpp
/ 8;
557 if (plane
->color_mode
== OMAPFB_COLOR_RGB444
) {
558 var
->red
.offset
= 8; var
->red
.length
= 4;
559 var
->red
.msb_right
= 0;
560 var
->green
.offset
= 4; var
->green
.length
= 4;
561 var
->green
.msb_right
= 0;
562 var
->blue
.offset
= 0; var
->blue
.length
= 4;
563 var
->blue
.msb_right
= 0;
565 var
->red
.offset
= 11; var
->red
.length
= 5;
566 var
->red
.msb_right
= 0;
567 var
->green
.offset
= 5; var
->green
.length
= 6;
568 var
->green
.msb_right
= 0;
569 var
->blue
.offset
= 0; var
->blue
.length
= 5;
570 var
->blue
.msb_right
= 0;
577 /* pixclock in ps, the rest in pixclock */
578 var
->pixclock
= 10000000 / (panel
->pixel_clock
/ 100);
579 var
->left_margin
= panel
->hfp
;
580 var
->right_margin
= panel
->hbp
;
581 var
->upper_margin
= panel
->vfp
;
582 var
->lower_margin
= panel
->vbp
;
583 var
->hsync_len
= panel
->hsw
;
584 var
->vsync_len
= panel
->vsw
;
586 /* TODO: get these from panel->config */
587 var
->vmode
= FB_VMODE_NONINTERLACED
;
594 /* Set rotation (0, 90, 180, 270 degree), and switch to the new mode. */
595 static void omapfb_rotate(struct fb_info
*fbi
, int rotate
)
597 struct omapfb_plane_struct
*plane
= fbi
->par
;
598 struct omapfb_device
*fbdev
= plane
->fbdev
;
600 omapfb_rqueue_lock(fbdev
);
601 if (cpu_is_omap15xx() && rotate
!= fbi
->var
.rotate
) {
602 struct fb_var_screeninfo
*new_var
= &fbdev
->new_var
;
604 memcpy(new_var
, &fbi
->var
, sizeof(*new_var
));
605 new_var
->rotate
= rotate
;
606 if (set_fb_var(fbi
, new_var
) == 0 &&
607 memcmp(new_var
, &fbi
->var
, sizeof(*new_var
))) {
608 memcpy(&fbi
->var
, new_var
, sizeof(*new_var
));
609 ctrl_change_mode(fbi
);
612 omapfb_rqueue_unlock(fbdev
);
616 * Set new x,y offsets in the virtual display for the visible area and switch
619 static int omapfb_pan_display(struct fb_var_screeninfo
*var
,
622 struct omapfb_plane_struct
*plane
= fbi
->par
;
623 struct omapfb_device
*fbdev
= plane
->fbdev
;
626 omapfb_rqueue_lock(fbdev
);
627 if (var
->xoffset
!= fbi
->var
.xoffset
||
628 var
->yoffset
!= fbi
->var
.yoffset
) {
629 struct fb_var_screeninfo
*new_var
= &fbdev
->new_var
;
631 memcpy(new_var
, &fbi
->var
, sizeof(*new_var
));
632 new_var
->xoffset
= var
->xoffset
;
633 new_var
->yoffset
= var
->yoffset
;
634 if (set_fb_var(fbi
, new_var
))
637 memcpy(&fbi
->var
, new_var
, sizeof(*new_var
));
638 ctrl_change_mode(fbi
);
641 omapfb_rqueue_unlock(fbdev
);
646 /* Set mirror to vertical axis and switch to the new mode. */
647 static int omapfb_mirror(struct fb_info
*fbi
, int mirror
)
649 struct omapfb_plane_struct
*plane
= fbi
->par
;
650 struct omapfb_device
*fbdev
= plane
->fbdev
;
653 omapfb_rqueue_lock(fbdev
);
654 mirror
= mirror
? 1 : 0;
655 if (cpu_is_omap15xx())
657 else if (mirror
!= plane
->info
.mirror
) {
658 plane
->info
.mirror
= mirror
;
659 r
= ctrl_change_mode(fbi
);
661 omapfb_rqueue_unlock(fbdev
);
667 * Check values in var, try to adjust them in case of out of bound values if
668 * possible, or return error.
670 static int omapfb_check_var(struct fb_var_screeninfo
*var
, struct fb_info
*fbi
)
672 struct omapfb_plane_struct
*plane
= fbi
->par
;
673 struct omapfb_device
*fbdev
= plane
->fbdev
;
676 omapfb_rqueue_lock(fbdev
);
677 if (fbdev
->ctrl
->sync
!= NULL
)
679 r
= set_fb_var(fbi
, var
);
680 omapfb_rqueue_unlock(fbdev
);
686 * Switch to a new mode. The parameters for it has been check already by
689 static int omapfb_set_par(struct fb_info
*fbi
)
691 struct omapfb_plane_struct
*plane
= fbi
->par
;
692 struct omapfb_device
*fbdev
= plane
->fbdev
;
695 omapfb_rqueue_lock(fbdev
);
697 r
= ctrl_change_mode(fbi
);
698 omapfb_rqueue_unlock(fbdev
);
703 int omapfb_update_window_async(struct fb_info
*fbi
,
704 struct omapfb_update_window
*win
,
705 void (*callback
)(void *),
708 struct omapfb_plane_struct
*plane
= fbi
->par
;
709 struct omapfb_device
*fbdev
= plane
->fbdev
;
710 struct fb_var_screeninfo
*var
;
713 if (win
->x
>= var
->xres
|| win
->y
>= var
->yres
||
714 win
->out_x
> var
->xres
|| win
->out_y
>= var
->yres
)
717 if (!fbdev
->ctrl
->update_window
||
718 fbdev
->ctrl
->get_update_mode() != OMAPFB_MANUAL_UPDATE
)
721 if (win
->x
+ win
->width
>= var
->xres
)
722 win
->width
= var
->xres
- win
->x
;
723 if (win
->y
+ win
->height
>= var
->yres
)
724 win
->height
= var
->yres
- win
->y
;
725 /* The out sizes should be cropped to the LCD size */
726 if (win
->out_x
+ win
->out_width
> fbdev
->panel
->x_res
)
727 win
->out_width
= fbdev
->panel
->x_res
- win
->out_x
;
728 if (win
->out_y
+ win
->out_height
> fbdev
->panel
->y_res
)
729 win
->out_height
= fbdev
->panel
->y_res
- win
->out_y
;
730 if (!win
->width
|| !win
->height
|| !win
->out_width
|| !win
->out_height
)
733 return fbdev
->ctrl
->update_window(fbi
, win
, callback
, callback_data
);
735 EXPORT_SYMBOL(omapfb_update_window_async
);
737 static int omapfb_update_win(struct fb_info
*fbi
,
738 struct omapfb_update_window
*win
)
740 struct omapfb_plane_struct
*plane
= fbi
->par
;
743 omapfb_rqueue_lock(plane
->fbdev
);
744 ret
= omapfb_update_window_async(fbi
, win
, NULL
, NULL
);
745 omapfb_rqueue_unlock(plane
->fbdev
);
750 static int omapfb_update_full_screen(struct fb_info
*fbi
)
752 struct omapfb_plane_struct
*plane
= fbi
->par
;
753 struct omapfb_device
*fbdev
= plane
->fbdev
;
754 struct omapfb_update_window win
;
757 if (!fbdev
->ctrl
->update_window
||
758 fbdev
->ctrl
->get_update_mode() != OMAPFB_MANUAL_UPDATE
)
763 win
.width
= fbi
->var
.xres
;
764 win
.height
= fbi
->var
.yres
;
767 win
.out_width
= fbi
->var
.xres
;
768 win
.out_height
= fbi
->var
.yres
;
771 omapfb_rqueue_lock(fbdev
);
772 r
= fbdev
->ctrl
->update_window(fbi
, &win
, NULL
, NULL
);
773 omapfb_rqueue_unlock(fbdev
);
778 static int omapfb_setup_plane(struct fb_info
*fbi
, struct omapfb_plane_info
*pi
)
780 struct omapfb_plane_struct
*plane
= fbi
->par
;
781 struct omapfb_device
*fbdev
= plane
->fbdev
;
782 struct lcd_panel
*panel
= fbdev
->panel
;
783 struct omapfb_plane_info old_info
;
786 if (pi
->pos_x
+ pi
->out_width
> panel
->x_res
||
787 pi
->pos_y
+ pi
->out_height
> panel
->y_res
)
790 omapfb_rqueue_lock(fbdev
);
791 if (pi
->enabled
&& !fbdev
->mem_desc
.region
[plane
->idx
].size
) {
793 * This plane's memory was freed, can't enable it
794 * until it's reallocated.
799 old_info
= plane
->info
;
802 r
= ctrl_change_mode(fbi
);
804 plane
->info
= old_info
;
808 r
= fbdev
->ctrl
->enable_plane(plane
->idx
, pi
->enabled
);
810 plane
->info
= old_info
;
814 omapfb_rqueue_unlock(fbdev
);
818 static int omapfb_query_plane(struct fb_info
*fbi
, struct omapfb_plane_info
*pi
)
820 struct omapfb_plane_struct
*plane
= fbi
->par
;
826 static int omapfb_setup_mem(struct fb_info
*fbi
, struct omapfb_mem_info
*mi
)
828 struct omapfb_plane_struct
*plane
= fbi
->par
;
829 struct omapfb_device
*fbdev
= plane
->fbdev
;
830 struct omapfb_mem_region
*rg
= &fbdev
->mem_desc
.region
[plane
->idx
];
834 if (fbdev
->ctrl
->setup_mem
== NULL
)
836 if (mi
->type
> OMAPFB_MEMTYPE_MAX
)
839 size
= PAGE_ALIGN(mi
->size
);
840 omapfb_rqueue_lock(fbdev
);
841 if (plane
->info
.enabled
) {
845 if (rg
->size
!= size
|| rg
->type
!= mi
->type
) {
846 struct fb_var_screeninfo
*new_var
= &fbdev
->new_var
;
847 unsigned long old_size
= rg
->size
;
848 u8 old_type
= rg
->type
;
854 * size == 0 is a special case, for which we
855 * don't check / adjust the screen parameters.
856 * This isn't a problem since the plane can't
857 * be reenabled unless its size is > 0.
859 if (old_size
!= size
&& size
) {
861 memcpy(new_var
, &fbi
->var
, sizeof(*new_var
));
862 r
= set_fb_var(fbi
, new_var
);
868 if (fbdev
->ctrl
->sync
)
870 r
= fbdev
->ctrl
->setup_mem(plane
->idx
, size
, mi
->type
, &paddr
);
872 /* Revert changes. */
879 if (old_size
!= size
) {
881 memcpy(&fbi
->var
, new_var
, sizeof(fbi
->var
));
885 * Set these explicitly to indicate that the
886 * plane memory is dealloce'd, the other
887 * screen parameters in var / fix are invalid.
889 fbi
->fix
.smem_start
= 0;
890 fbi
->fix
.smem_len
= 0;
895 omapfb_rqueue_unlock(fbdev
);
900 static int omapfb_query_mem(struct fb_info
*fbi
, struct omapfb_mem_info
*mi
)
902 struct omapfb_plane_struct
*plane
= fbi
->par
;
903 struct omapfb_device
*fbdev
= plane
->fbdev
;
904 struct omapfb_mem_region
*rg
;
906 rg
= &fbdev
->mem_desc
.region
[plane
->idx
];
907 memset(mi
, 0, sizeof(*mi
));
914 static int omapfb_set_color_key(struct omapfb_device
*fbdev
,
915 struct omapfb_color_key
*ck
)
919 if (!fbdev
->ctrl
->set_color_key
)
922 omapfb_rqueue_lock(fbdev
);
923 r
= fbdev
->ctrl
->set_color_key(ck
);
924 omapfb_rqueue_unlock(fbdev
);
929 static int omapfb_get_color_key(struct omapfb_device
*fbdev
,
930 struct omapfb_color_key
*ck
)
934 if (!fbdev
->ctrl
->get_color_key
)
937 omapfb_rqueue_lock(fbdev
);
938 r
= fbdev
->ctrl
->get_color_key(ck
);
939 omapfb_rqueue_unlock(fbdev
);
944 static struct blocking_notifier_head omapfb_client_list
[OMAPFB_PLANE_NUM
];
945 static int notifier_inited
;
947 static void omapfb_init_notifier(void)
951 for (i
= 0; i
< OMAPFB_PLANE_NUM
; i
++)
952 BLOCKING_INIT_NOTIFIER_HEAD(&omapfb_client_list
[i
]);
955 int omapfb_register_client(struct omapfb_notifier_block
*omapfb_nb
,
956 omapfb_notifier_callback_t callback
,
961 if ((unsigned)omapfb_nb
->plane_idx
> OMAPFB_PLANE_NUM
)
964 if (!notifier_inited
) {
965 omapfb_init_notifier();
969 omapfb_nb
->nb
.notifier_call
= (int (*)(struct notifier_block
*,
970 unsigned long, void *))callback
;
971 omapfb_nb
->data
= callback_data
;
972 r
= blocking_notifier_chain_register(
973 &omapfb_client_list
[omapfb_nb
->plane_idx
],
977 if (omapfb_dev
!= NULL
&&
978 omapfb_dev
->ctrl
&& omapfb_dev
->ctrl
->bind_client
) {
979 omapfb_dev
->ctrl
->bind_client(omapfb_nb
);
984 EXPORT_SYMBOL(omapfb_register_client
);
986 int omapfb_unregister_client(struct omapfb_notifier_block
*omapfb_nb
)
988 return blocking_notifier_chain_unregister(
989 &omapfb_client_list
[omapfb_nb
->plane_idx
], &omapfb_nb
->nb
);
991 EXPORT_SYMBOL(omapfb_unregister_client
);
993 void omapfb_notify_clients(struct omapfb_device
*fbdev
, unsigned long event
)
997 if (!notifier_inited
)
998 /* no client registered yet */
1001 for (i
= 0; i
< OMAPFB_PLANE_NUM
; i
++)
1002 blocking_notifier_call_chain(&omapfb_client_list
[i
], event
,
1005 EXPORT_SYMBOL(omapfb_notify_clients
);
1007 static int omapfb_set_update_mode(struct omapfb_device
*fbdev
,
1008 enum omapfb_update_mode mode
)
1012 omapfb_rqueue_lock(fbdev
);
1013 r
= fbdev
->ctrl
->set_update_mode(mode
);
1014 omapfb_rqueue_unlock(fbdev
);
1019 static enum omapfb_update_mode
omapfb_get_update_mode(struct omapfb_device
*fbdev
)
1023 omapfb_rqueue_lock(fbdev
);
1024 r
= fbdev
->ctrl
->get_update_mode();
1025 omapfb_rqueue_unlock(fbdev
);
1030 static void omapfb_get_caps(struct omapfb_device
*fbdev
, int plane
,
1031 struct omapfb_caps
*caps
)
1033 memset(caps
, 0, sizeof(*caps
));
1034 fbdev
->ctrl
->get_caps(plane
, caps
);
1035 caps
->ctrl
|= fbdev
->panel
->get_caps(fbdev
->panel
);
1038 /* For lcd testing */
1039 void omapfb_write_first_pixel(struct omapfb_device
*fbdev
, u16 pixval
)
1041 omapfb_rqueue_lock(fbdev
);
1042 *(u16
*)fbdev
->mem_desc
.region
[0].vaddr
= pixval
;
1043 if (fbdev
->ctrl
->get_update_mode() == OMAPFB_MANUAL_UPDATE
) {
1044 struct omapfb_update_window win
;
1046 memset(&win
, 0, sizeof(win
));
1051 fbdev
->ctrl
->update_window(fbdev
->fb_info
[0], &win
, NULL
, NULL
);
1053 omapfb_rqueue_unlock(fbdev
);
1055 EXPORT_SYMBOL(omapfb_write_first_pixel
);
1058 * Ioctl interface. Part of the kernel mode frame buffer API is duplicated
1059 * here to be accessible by user mode code.
1061 static int omapfb_ioctl(struct fb_info
*fbi
, unsigned int cmd
,
1064 struct omapfb_plane_struct
*plane
= fbi
->par
;
1065 struct omapfb_device
*fbdev
= plane
->fbdev
;
1066 struct fb_ops
*ops
= fbi
->fbops
;
1068 struct omapfb_update_window update_window
;
1069 struct omapfb_plane_info plane_info
;
1070 struct omapfb_mem_info mem_info
;
1071 struct omapfb_color_key color_key
;
1072 enum omapfb_update_mode update_mode
;
1073 struct omapfb_caps caps
;
1074 unsigned int mirror
;
1083 if (get_user(p
.mirror
, (int __user
*)arg
))
1086 omapfb_mirror(fbi
, p
.mirror
);
1088 case OMAPFB_SYNC_GFX
:
1093 case OMAPFB_SET_UPDATE_MODE
:
1094 if (get_user(p
.update_mode
, (int __user
*)arg
))
1097 r
= omapfb_set_update_mode(fbdev
, p
.update_mode
);
1099 case OMAPFB_GET_UPDATE_MODE
:
1100 p
.update_mode
= omapfb_get_update_mode(fbdev
);
1101 if (put_user(p
.update_mode
,
1102 (enum omapfb_update_mode __user
*)arg
))
1105 case OMAPFB_UPDATE_WINDOW_OLD
:
1106 if (copy_from_user(&p
.update_window
, (void __user
*)arg
,
1107 sizeof(struct omapfb_update_window_old
)))
1110 struct omapfb_update_window
*u
= &p
.update_window
;
1113 u
->out_width
= u
->width
;
1114 u
->out_height
= u
->height
;
1115 memset(u
->reserved
, 0, sizeof(u
->reserved
));
1116 r
= omapfb_update_win(fbi
, u
);
1119 case OMAPFB_UPDATE_WINDOW
:
1120 if (copy_from_user(&p
.update_window
, (void __user
*)arg
,
1121 sizeof(p
.update_window
)))
1124 r
= omapfb_update_win(fbi
, &p
.update_window
);
1126 case OMAPFB_SETUP_PLANE
:
1127 if (copy_from_user(&p
.plane_info
, (void __user
*)arg
,
1128 sizeof(p
.plane_info
)))
1131 r
= omapfb_setup_plane(fbi
, &p
.plane_info
);
1133 case OMAPFB_QUERY_PLANE
:
1134 if ((r
= omapfb_query_plane(fbi
, &p
.plane_info
)) < 0)
1136 if (copy_to_user((void __user
*)arg
, &p
.plane_info
,
1137 sizeof(p
.plane_info
)))
1140 case OMAPFB_SETUP_MEM
:
1141 if (copy_from_user(&p
.mem_info
, (void __user
*)arg
,
1142 sizeof(p
.mem_info
)))
1145 r
= omapfb_setup_mem(fbi
, &p
.mem_info
);
1147 case OMAPFB_QUERY_MEM
:
1148 if ((r
= omapfb_query_mem(fbi
, &p
.mem_info
)) < 0)
1150 if (copy_to_user((void __user
*)arg
, &p
.mem_info
,
1151 sizeof(p
.mem_info
)))
1154 case OMAPFB_SET_COLOR_KEY
:
1155 if (copy_from_user(&p
.color_key
, (void __user
*)arg
,
1156 sizeof(p
.color_key
)))
1159 r
= omapfb_set_color_key(fbdev
, &p
.color_key
);
1161 case OMAPFB_GET_COLOR_KEY
:
1162 if ((r
= omapfb_get_color_key(fbdev
, &p
.color_key
)) < 0)
1164 if (copy_to_user((void __user
*)arg
, &p
.color_key
,
1165 sizeof(p
.color_key
)))
1168 case OMAPFB_GET_CAPS
:
1169 omapfb_get_caps(fbdev
, plane
->idx
, &p
.caps
);
1170 if (copy_to_user((void __user
*)arg
, &p
.caps
, sizeof(p
.caps
)))
1173 case OMAPFB_LCD_TEST
:
1177 if (get_user(test_num
, (int __user
*)arg
)) {
1181 if (!fbdev
->panel
->run_test
) {
1185 r
= fbdev
->panel
->run_test(fbdev
->panel
, test_num
);
1188 case OMAPFB_CTRL_TEST
:
1192 if (get_user(test_num
, (int __user
*)arg
)) {
1196 if (!fbdev
->ctrl
->run_test
) {
1200 r
= fbdev
->ctrl
->run_test(test_num
);
1210 static int omapfb_mmap(struct fb_info
*info
, struct vm_area_struct
*vma
)
1212 struct omapfb_plane_struct
*plane
= info
->par
;
1213 struct omapfb_device
*fbdev
= plane
->fbdev
;
1216 omapfb_rqueue_lock(fbdev
);
1217 r
= fbdev
->ctrl
->mmap(info
, vma
);
1218 omapfb_rqueue_unlock(fbdev
);
1224 * Callback table for the frame buffer framework. Some of these pointers
1225 * will be changed according to the current setting of fb_info->accel_flags.
1227 static struct fb_ops omapfb_ops
= {
1228 .owner
= THIS_MODULE
,
1229 .fb_open
= omapfb_open
,
1230 .fb_release
= omapfb_release
,
1231 .fb_setcolreg
= omapfb_setcolreg
,
1232 .fb_setcmap
= omapfb_setcmap
,
1233 .fb_fillrect
= cfb_fillrect
,
1234 .fb_copyarea
= cfb_copyarea
,
1235 .fb_imageblit
= cfb_imageblit
,
1236 .fb_blank
= omapfb_blank
,
1237 .fb_ioctl
= omapfb_ioctl
,
1238 .fb_check_var
= omapfb_check_var
,
1239 .fb_set_par
= omapfb_set_par
,
1240 .fb_rotate
= omapfb_rotate
,
1241 .fb_pan_display
= omapfb_pan_display
,
1245 * ---------------------------------------------------------------------------
1247 * ---------------------------------------------------------------------------
1249 /* omapfbX sysfs entries */
1250 static ssize_t
omapfb_show_caps_num(struct device
*dev
,
1251 struct device_attribute
*attr
, char *buf
)
1253 struct omapfb_device
*fbdev
= (struct omapfb_device
*)dev
->driver_data
;
1256 struct omapfb_caps caps
;
1260 while (size
< PAGE_SIZE
&& plane
< OMAPFB_PLANE_NUM
) {
1261 omapfb_get_caps(fbdev
, plane
, &caps
);
1262 size
+= snprintf(&buf
[size
], PAGE_SIZE
- size
,
1263 "plane#%d %#010x %#010x %#010x\n",
1264 plane
, caps
.ctrl
, caps
.plane_color
, caps
.wnd_color
);
1270 static ssize_t
omapfb_show_caps_text(struct device
*dev
,
1271 struct device_attribute
*attr
, char *buf
)
1273 struct omapfb_device
*fbdev
= (struct omapfb_device
*)dev
->driver_data
;
1275 struct omapfb_caps caps
;
1281 while (size
< PAGE_SIZE
&& plane
< OMAPFB_PLANE_NUM
) {
1282 omapfb_get_caps(fbdev
, plane
, &caps
);
1283 size
+= snprintf(&buf
[size
], PAGE_SIZE
- size
,
1284 "plane#%d:\n", plane
);
1285 for (i
= 0; i
< ARRAY_SIZE(ctrl_caps
) &&
1286 size
< PAGE_SIZE
; i
++) {
1287 if (ctrl_caps
[i
].flag
& caps
.ctrl
)
1288 size
+= snprintf(&buf
[size
], PAGE_SIZE
- size
,
1289 " %s\n", ctrl_caps
[i
].name
);
1291 size
+= snprintf(&buf
[size
], PAGE_SIZE
- size
,
1292 " plane colors:\n");
1293 for (i
= 0; i
< ARRAY_SIZE(color_caps
) &&
1294 size
< PAGE_SIZE
; i
++) {
1295 if (color_caps
[i
].flag
& caps
.plane_color
)
1296 size
+= snprintf(&buf
[size
], PAGE_SIZE
- size
,
1297 " %s\n", color_caps
[i
].name
);
1299 size
+= snprintf(&buf
[size
], PAGE_SIZE
- size
,
1300 " window colors:\n");
1301 for (i
= 0; i
< ARRAY_SIZE(color_caps
) &&
1302 size
< PAGE_SIZE
; i
++) {
1303 if (color_caps
[i
].flag
& caps
.wnd_color
)
1304 size
+= snprintf(&buf
[size
], PAGE_SIZE
- size
,
1305 " %s\n", color_caps
[i
].name
);
1313 static DEVICE_ATTR(caps_num
, 0444, omapfb_show_caps_num
, NULL
);
1314 static DEVICE_ATTR(caps_text
, 0444, omapfb_show_caps_text
, NULL
);
1316 /* panel sysfs entries */
1317 static ssize_t
omapfb_show_panel_name(struct device
*dev
,
1318 struct device_attribute
*attr
, char *buf
)
1320 struct omapfb_device
*fbdev
= (struct omapfb_device
*)dev
->driver_data
;
1322 return snprintf(buf
, PAGE_SIZE
, "%s\n", fbdev
->panel
->name
);
1325 static ssize_t
omapfb_show_bklight_level(struct device
*dev
,
1326 struct device_attribute
*attr
,
1329 struct omapfb_device
*fbdev
= (struct omapfb_device
*)dev
->driver_data
;
1332 if (fbdev
->panel
->get_bklight_level
) {
1333 r
= snprintf(buf
, PAGE_SIZE
, "%d\n",
1334 fbdev
->panel
->get_bklight_level(fbdev
->panel
));
1340 static ssize_t
omapfb_store_bklight_level(struct device
*dev
,
1341 struct device_attribute
*attr
,
1342 const char *buf
, size_t size
)
1344 struct omapfb_device
*fbdev
= (struct omapfb_device
*)dev
->driver_data
;
1347 if (fbdev
->panel
->set_bklight_level
) {
1350 if (sscanf(buf
, "%10d", &level
) == 1) {
1351 r
= fbdev
->panel
->set_bklight_level(fbdev
->panel
,
1357 return r
? r
: size
;
1360 static ssize_t
omapfb_show_bklight_max(struct device
*dev
,
1361 struct device_attribute
*attr
, char *buf
)
1363 struct omapfb_device
*fbdev
= (struct omapfb_device
*)dev
->driver_data
;
1366 if (fbdev
->panel
->get_bklight_level
) {
1367 r
= snprintf(buf
, PAGE_SIZE
, "%d\n",
1368 fbdev
->panel
->get_bklight_max(fbdev
->panel
));
1374 static struct device_attribute dev_attr_panel_name
=
1375 __ATTR(name
, 0444, omapfb_show_panel_name
, NULL
);
1376 static DEVICE_ATTR(backlight_level
, 0664,
1377 omapfb_show_bklight_level
, omapfb_store_bklight_level
);
1378 static DEVICE_ATTR(backlight_max
, 0444, omapfb_show_bklight_max
, NULL
);
1380 static struct attribute
*panel_attrs
[] = {
1381 &dev_attr_panel_name
.attr
,
1382 &dev_attr_backlight_level
.attr
,
1383 &dev_attr_backlight_max
.attr
,
1387 static struct attribute_group panel_attr_grp
= {
1389 .attrs
= panel_attrs
,
1392 /* ctrl sysfs entries */
1393 static ssize_t
omapfb_show_ctrl_name(struct device
*dev
,
1394 struct device_attribute
*attr
, char *buf
)
1396 struct omapfb_device
*fbdev
= (struct omapfb_device
*)dev
->driver_data
;
1398 return snprintf(buf
, PAGE_SIZE
, "%s\n", fbdev
->ctrl
->name
);
1401 static struct device_attribute dev_attr_ctrl_name
=
1402 __ATTR(name
, 0444, omapfb_show_ctrl_name
, NULL
);
1404 static struct attribute
*ctrl_attrs
[] = {
1405 &dev_attr_ctrl_name
.attr
,
1409 static struct attribute_group ctrl_attr_grp
= {
1411 .attrs
= ctrl_attrs
,
1414 static int omapfb_register_sysfs(struct omapfb_device
*fbdev
)
1418 if ((r
= device_create_file(fbdev
->dev
, &dev_attr_caps_num
)))
1421 if ((r
= device_create_file(fbdev
->dev
, &dev_attr_caps_text
)))
1424 if ((r
= sysfs_create_group(&fbdev
->dev
->kobj
, &panel_attr_grp
)))
1427 if ((r
= sysfs_create_group(&fbdev
->dev
->kobj
, &ctrl_attr_grp
)))
1432 sysfs_remove_group(&fbdev
->dev
->kobj
, &panel_attr_grp
);
1434 device_remove_file(fbdev
->dev
, &dev_attr_caps_text
);
1436 device_remove_file(fbdev
->dev
, &dev_attr_caps_num
);
1438 dev_err(fbdev
->dev
, "unable to register sysfs interface\n");
1442 static void omapfb_unregister_sysfs(struct omapfb_device
*fbdev
)
1444 sysfs_remove_group(&fbdev
->dev
->kobj
, &ctrl_attr_grp
);
1445 sysfs_remove_group(&fbdev
->dev
->kobj
, &panel_attr_grp
);
1446 device_remove_file(fbdev
->dev
, &dev_attr_caps_num
);
1447 device_remove_file(fbdev
->dev
, &dev_attr_caps_text
);
1451 * ---------------------------------------------------------------------------
1453 * ---------------------------------------------------------------------------
1455 /* Initialize system fb_info object and set the default video mode.
1456 * The frame buffer memory already allocated by lcddma_init
1458 static int fbinfo_init(struct omapfb_device
*fbdev
, struct fb_info
*info
)
1460 struct fb_var_screeninfo
*var
= &info
->var
;
1461 struct fb_fix_screeninfo
*fix
= &info
->fix
;
1464 info
->fbops
= &omapfb_ops
;
1465 info
->flags
= FBINFO_FLAG_DEFAULT
;
1467 strncpy(fix
->id
, MODULE_NAME
, sizeof(fix
->id
));
1469 info
->pseudo_palette
= fbdev
->pseudo_palette
;
1471 var
->accel_flags
= def_accel
? FB_ACCELF_TEXT
: 0;
1472 var
->xres
= def_vxres
;
1473 var
->yres
= def_vyres
;
1474 var
->xres_virtual
= def_vxres
;
1475 var
->yres_virtual
= def_vyres
;
1476 var
->rotate
= def_rotate
;
1477 var
->bits_per_pixel
= fbdev
->panel
->bpp
;
1479 set_fb_var(info
, var
);
1482 r
= fb_alloc_cmap(&info
->cmap
, 16, 0);
1484 dev_err(fbdev
->dev
, "unable to allocate color map memory\n");
1489 /* Release the fb_info object */
1490 static void fbinfo_cleanup(struct omapfb_device
*fbdev
, struct fb_info
*fbi
)
1492 fb_dealloc_cmap(&fbi
->cmap
);
1495 static void planes_cleanup(struct omapfb_device
*fbdev
)
1499 for (i
= 0; i
< fbdev
->mem_desc
.region_cnt
; i
++) {
1500 if (fbdev
->fb_info
[i
] == NULL
)
1502 fbinfo_cleanup(fbdev
, fbdev
->fb_info
[i
]);
1503 framebuffer_release(fbdev
->fb_info
[i
]);
1507 static int planes_init(struct omapfb_device
*fbdev
)
1509 struct fb_info
*fbi
;
1513 for (i
= 0; i
< fbdev
->mem_desc
.region_cnt
; i
++) {
1514 struct omapfb_plane_struct
*plane
;
1515 fbi
= framebuffer_alloc(sizeof(struct omapfb_plane_struct
),
1519 "unable to allocate memory for plane info\n");
1520 planes_cleanup(fbdev
);
1525 plane
->fbdev
= fbdev
;
1526 plane
->info
.mirror
= def_mirror
;
1527 fbdev
->fb_info
[i
] = fbi
;
1529 if ((r
= fbinfo_init(fbdev
, fbi
)) < 0) {
1530 framebuffer_release(fbi
);
1531 planes_cleanup(fbdev
);
1534 plane
->info
.out_width
= fbi
->var
.xres
;
1535 plane
->info
.out_height
= fbi
->var
.yres
;
1541 * Free driver resources. Can be called to rollback an aborted initialization
1544 static void omapfb_free_resources(struct omapfb_device
*fbdev
, int state
)
1550 for (i
= 0; i
< fbdev
->mem_desc
.region_cnt
; i
++)
1551 unregister_framebuffer(fbdev
->fb_info
[i
]);
1553 omapfb_unregister_sysfs(fbdev
);
1555 fbdev
->panel
->disable(fbdev
->panel
);
1557 omapfb_set_update_mode(fbdev
, OMAPFB_UPDATE_DISABLED
);
1559 planes_cleanup(fbdev
);
1561 ctrl_cleanup(fbdev
);
1563 fbdev
->panel
->cleanup(fbdev
->panel
);
1565 dev_set_drvdata(fbdev
->dev
, NULL
);
1568 /* nothing to free */
1575 static int omapfb_find_ctrl(struct omapfb_device
*fbdev
)
1577 struct omapfb_platform_data
*conf
;
1581 conf
= fbdev
->dev
->platform_data
;
1585 strncpy(name
, conf
->lcd
.ctrl_name
, sizeof(name
) - 1);
1586 name
[sizeof(name
) - 1] = '\0';
1588 if (strcmp(name
, "internal") == 0) {
1589 fbdev
->ctrl
= fbdev
->int_ctrl
;
1593 for (i
= 0; i
< ARRAY_SIZE(ctrls
); i
++) {
1594 dev_dbg(fbdev
->dev
, "ctrl %s\n", ctrls
[i
]->name
);
1595 if (strcmp(ctrls
[i
]->name
, name
) == 0) {
1596 fbdev
->ctrl
= ctrls
[i
];
1601 if (fbdev
->ctrl
== NULL
) {
1602 dev_dbg(fbdev
->dev
, "ctrl %s not supported\n", name
);
1609 static void check_required_callbacks(struct omapfb_device
*fbdev
)
1611 #define _C(x) (fbdev->ctrl->x != NULL)
1612 #define _P(x) (fbdev->panel->x != NULL)
1613 BUG_ON(fbdev
->ctrl
== NULL
|| fbdev
->panel
== NULL
);
1614 BUG_ON(!(_C(init
) && _C(cleanup
) && _C(get_caps
) &&
1615 _C(set_update_mode
) && _C(setup_plane
) && _C(enable_plane
) &&
1616 _P(init
) && _P(cleanup
) && _P(enable
) && _P(disable
) &&
1623 * Called by LDM binding to probe and attach a new device.
1624 * Initialization sequence:
1625 * 1. allocate system omapfb_device structure
1626 * 2. select controller type according to platform configuration
1628 * 3. init LCD controller and LCD DMA
1629 * 4. init system fb_info structure for all planes
1630 * 5. setup video mode for first plane and enable it
1631 * 6. enable LCD panel
1632 * 7. register sysfs attributes
1633 * OMAPFB_ACTIVE: register system fb_info structure for all planes
1635 static int omapfb_do_probe(struct platform_device
*pdev
,
1636 struct lcd_panel
*panel
)
1638 struct omapfb_device
*fbdev
= NULL
;
1640 unsigned long phz
, hhz
, vhz
;
1647 if (pdev
->num_resources
!= 0) {
1648 dev_err(&pdev
->dev
, "probed for an unknown device\n");
1653 if (pdev
->dev
.platform_data
== NULL
) {
1654 dev_err(&pdev
->dev
, "missing platform data\n");
1659 fbdev
= kzalloc(sizeof(struct omapfb_device
), GFP_KERNEL
);
1660 if (fbdev
== NULL
) {
1662 "unable to allocate memory for device info\n");
1668 fbdev
->dev
= &pdev
->dev
;
1669 fbdev
->panel
= panel
;
1670 platform_set_drvdata(pdev
, fbdev
);
1672 mutex_init(&fbdev
->rqueue_mutex
);
1674 #ifdef CONFIG_ARCH_OMAP1
1675 fbdev
->int_ctrl
= &omap1_int_ctrl
;
1676 #ifdef CONFIG_FB_OMAP_LCDC_EXTERNAL
1677 fbdev
->ext_if
= &omap1_ext_if
;
1680 fbdev
->int_ctrl
= &omap2_int_ctrl
;
1681 #ifdef CONFIG_FB_OMAP_LCDC_EXTERNAL
1682 fbdev
->ext_if
= &omap2_ext_if
;
1685 if (omapfb_find_ctrl(fbdev
) < 0) {
1687 "LCD controller not found, board not supported\n");
1692 r
= fbdev
->panel
->init(fbdev
->panel
, fbdev
);
1696 pr_info("omapfb: configured for panel %s\n", fbdev
->panel
->name
);
1698 def_vxres
= def_vxres
? : fbdev
->panel
->x_res
;
1699 def_vyres
= def_vyres
? : fbdev
->panel
->y_res
;
1703 r
= ctrl_init(fbdev
);
1706 if (fbdev
->ctrl
->mmap
!= NULL
)
1707 omapfb_ops
.fb_mmap
= omapfb_mmap
;
1710 check_required_callbacks(fbdev
);
1712 r
= planes_init(fbdev
);
1717 #ifdef CONFIG_FB_OMAP_DMA_TUNE
1718 /* Set DMA priority for EMIFF access to highest */
1719 if (cpu_class_is_omap1())
1720 omap_set_dma_priority(0, OMAP_DMA_PORT_EMIFF
, 15);
1723 r
= ctrl_change_mode(fbdev
->fb_info
[0]);
1725 dev_err(fbdev
->dev
, "mode setting failed\n");
1729 /* GFX plane is enabled by default */
1730 r
= fbdev
->ctrl
->enable_plane(OMAPFB_PLANE_GFX
, 1);
1734 omapfb_set_update_mode(fbdev
, manual_update
?
1735 OMAPFB_MANUAL_UPDATE
: OMAPFB_AUTO_UPDATE
);
1738 r
= fbdev
->panel
->enable(fbdev
->panel
);
1743 r
= omapfb_register_sysfs(fbdev
);
1749 for (i
= 0; i
< fbdev
->mem_desc
.region_cnt
; i
++) {
1750 r
= register_framebuffer(fbdev
->fb_info
[i
]);
1753 "registering framebuffer %d failed\n", i
);
1756 vram
+= fbdev
->mem_desc
.region
[i
].size
;
1759 fbdev
->state
= OMAPFB_ACTIVE
;
1761 panel
= fbdev
->panel
;
1762 phz
= panel
->pixel_clock
* 1000;
1763 hhz
= phz
* 10 / (panel
->hfp
+ panel
->x_res
+ panel
->hbp
+ panel
->hsw
);
1764 vhz
= hhz
/ (panel
->vfp
+ panel
->y_res
+ panel
->vbp
+ panel
->vsw
);
1768 pr_info("omapfb: Framebuffer initialized. Total vram %lu planes %d\n",
1769 vram
, fbdev
->mem_desc
.region_cnt
);
1770 pr_info("omapfb: Pixclock %lu kHz hfreq %lu.%lu kHz "
1771 "vfreq %lu.%lu Hz\n",
1772 phz
/ 1000, hhz
/ 10000, hhz
% 10, vhz
/ 10, vhz
% 10);
1777 omapfb_free_resources(fbdev
, init_state
);
1782 static int omapfb_probe(struct platform_device
*pdev
)
1784 BUG_ON(fbdev_pdev
!= NULL
);
1786 /* Delay actual initialization until the LCD is registered */
1788 if (fbdev_panel
!= NULL
)
1789 omapfb_do_probe(fbdev_pdev
, fbdev_panel
);
1793 void omapfb_register_panel(struct lcd_panel
*panel
)
1795 BUG_ON(fbdev_panel
!= NULL
);
1797 fbdev_panel
= panel
;
1798 if (fbdev_pdev
!= NULL
)
1799 omapfb_do_probe(fbdev_pdev
, fbdev_panel
);
1802 /* Called when the device is being detached from the driver */
1803 static int omapfb_remove(struct platform_device
*pdev
)
1805 struct omapfb_device
*fbdev
= platform_get_drvdata(pdev
);
1806 enum omapfb_state saved_state
= fbdev
->state
;
1808 /* FIXME: wait till completion of pending events */
1810 fbdev
->state
= OMAPFB_DISABLED
;
1811 omapfb_free_resources(fbdev
, saved_state
);
1817 static int omapfb_suspend(struct platform_device
*pdev
, pm_message_t mesg
)
1819 struct omapfb_device
*fbdev
= platform_get_drvdata(pdev
);
1821 omapfb_blank(VESA_POWERDOWN
, fbdev
->fb_info
[0]);
1827 static int omapfb_resume(struct platform_device
*pdev
)
1829 struct omapfb_device
*fbdev
= platform_get_drvdata(pdev
);
1831 omapfb_blank(VESA_NO_BLANKING
, fbdev
->fb_info
[0]);
1835 static struct platform_driver omapfb_driver
= {
1836 .probe
= omapfb_probe
,
1837 .remove
= omapfb_remove
,
1838 .suspend
= omapfb_suspend
,
1839 .resume
= omapfb_resume
,
1841 .name
= MODULE_NAME
,
1842 .owner
= THIS_MODULE
,
1848 /* Process kernel command line parameters */
1849 static int __init
omapfb_setup(char *options
)
1851 char *this_opt
= NULL
;
1854 pr_debug("omapfb: options %s\n", options
);
1856 if (!options
|| !*options
)
1859 while (!r
&& (this_opt
= strsep(&options
, ",")) != NULL
) {
1860 if (!strncmp(this_opt
, "accel", 5))
1862 else if (!strncmp(this_opt
, "vram:", 5)) {
1865 vram
= (simple_strtoul(this_opt
+ 5, &suffix
, 0));
1866 switch (suffix
[0]) {
1878 pr_debug("omapfb: invalid vram suffix %c\n",
1882 def_vram
[def_vram_cnt
++] = vram
;
1884 else if (!strncmp(this_opt
, "vxres:", 6))
1885 def_vxres
= simple_strtoul(this_opt
+ 6, NULL
, 0);
1886 else if (!strncmp(this_opt
, "vyres:", 6))
1887 def_vyres
= simple_strtoul(this_opt
+ 6, NULL
, 0);
1888 else if (!strncmp(this_opt
, "rotate:", 7))
1889 def_rotate
= (simple_strtoul(this_opt
+ 7, NULL
, 0));
1890 else if (!strncmp(this_opt
, "mirror:", 7))
1891 def_mirror
= (simple_strtoul(this_opt
+ 7, NULL
, 0));
1892 else if (!strncmp(this_opt
, "manual_update", 13))
1895 pr_debug("omapfb: invalid option\n");
1905 /* Register both the driver and the device */
1906 static int __init
omapfb_init(void)
1911 if (fb_get_options("omapfb", &option
))
1913 omapfb_setup(option
);
1915 /* Register the driver with LDM */
1916 if (platform_driver_register(&omapfb_driver
)) {
1917 pr_debug("failed to register omapfb driver\n");
1924 static void __exit
omapfb_cleanup(void)
1926 platform_driver_unregister(&omapfb_driver
);
1929 module_param_named(accel
, def_accel
, uint
, 0664);
1930 module_param_array_named(vram
, def_vram
, ulong
, &def_vram_cnt
, 0664);
1931 module_param_named(vxres
, def_vxres
, long, 0664);
1932 module_param_named(vyres
, def_vyres
, long, 0664);
1933 module_param_named(rotate
, def_rotate
, uint
, 0664);
1934 module_param_named(mirror
, def_mirror
, uint
, 0664);
1935 module_param_named(manual_update
, manual_update
, bool, 0664);
1937 module_init(omapfb_init
);
1938 module_exit(omapfb_cleanup
);
1940 MODULE_DESCRIPTION("TI OMAP framebuffer driver");
1941 MODULE_AUTHOR("Imre Deak <imre.deak@nokia.com>");
1942 MODULE_LICENSE("GPL");