2 * linux/drivers/video/omap2/omapfb-ioctl.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/>.
24 #include <linux/device.h>
25 #include <linux/uaccess.h>
26 #include <linux/platform_device.h>
28 #include <linux/omapfb.h>
29 #include <linux/vmalloc.h>
31 #include <plat/display.h>
32 #include <plat/vrfb.h>
33 #include <plat/vram.h>
37 static u8
get_mem_idx(struct omapfb_info
*ofbi
)
39 if (ofbi
->id
== ofbi
->region
->id
)
42 return OMAPFB_MEM_IDX_ENABLED
| ofbi
->region
->id
;
45 static struct omapfb2_mem_region
*get_mem_region(struct omapfb_info
*ofbi
,
48 struct omapfb2_device
*fbdev
= ofbi
->fbdev
;
50 if (mem_idx
& OMAPFB_MEM_IDX_ENABLED
)
51 mem_idx
&= OMAPFB_MEM_IDX_MASK
;
55 if (mem_idx
>= fbdev
->num_fbs
)
58 return &fbdev
->regions
[mem_idx
];
61 static int omapfb_setup_plane(struct fb_info
*fbi
, struct omapfb_plane_info
*pi
)
63 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
64 struct omapfb2_device
*fbdev
= ofbi
->fbdev
;
65 struct omap_overlay
*ovl
;
66 struct omap_overlay_info old_info
;
67 struct omapfb2_mem_region
*old_rg
, *new_rg
;
70 DBG("omapfb_setup_plane\n");
72 if (ofbi
->num_overlays
!= 1) {
77 ovl
= ofbi
->overlays
[0];
79 old_rg
= ofbi
->region
;
80 new_rg
= get_mem_region(ofbi
, pi
->mem_idx
);
86 /* Take the locks in a specific order to keep lockdep happy */
87 if (old_rg
->id
< new_rg
->id
) {
88 omapfb_get_mem_region(old_rg
);
89 omapfb_get_mem_region(new_rg
);
90 } else if (new_rg
->id
< old_rg
->id
) {
91 omapfb_get_mem_region(new_rg
);
92 omapfb_get_mem_region(old_rg
);
94 omapfb_get_mem_region(old_rg
);
96 if (pi
->enabled
&& !new_rg
->size
) {
98 * This plane's memory was freed, can't enable it
99 * until it's reallocated.
105 ovl
->get_overlay_info(ovl
, &old_info
);
107 if (old_rg
!= new_rg
) {
108 ofbi
->region
= new_rg
;
113 struct omap_overlay_info info
;
115 r
= omapfb_setup_overlay(fbi
, ovl
, pi
->pos_x
, pi
->pos_y
,
116 pi
->out_width
, pi
->out_height
);
120 ovl
->get_overlay_info(ovl
, &info
);
123 info
.enabled
= pi
->enabled
;
124 r
= ovl
->set_overlay_info(ovl
, &info
);
129 struct omap_overlay_info info
;
131 ovl
->get_overlay_info(ovl
, &info
);
133 info
.enabled
= pi
->enabled
;
134 info
.pos_x
= pi
->pos_x
;
135 info
.pos_y
= pi
->pos_y
;
136 info
.out_width
= pi
->out_width
;
137 info
.out_height
= pi
->out_height
;
139 r
= ovl
->set_overlay_info(ovl
, &info
);
145 ovl
->manager
->apply(ovl
->manager
);
147 /* Release the locks in a specific order to keep lockdep happy */
148 if (old_rg
->id
> new_rg
->id
) {
149 omapfb_put_mem_region(old_rg
);
150 omapfb_put_mem_region(new_rg
);
151 } else if (new_rg
->id
> old_rg
->id
) {
152 omapfb_put_mem_region(new_rg
);
153 omapfb_put_mem_region(old_rg
);
155 omapfb_put_mem_region(old_rg
);
160 if (old_rg
!= new_rg
) {
161 ofbi
->region
= old_rg
;
165 ovl
->set_overlay_info(ovl
, &old_info
);
167 /* Release the locks in a specific order to keep lockdep happy */
168 if (old_rg
->id
> new_rg
->id
) {
169 omapfb_put_mem_region(old_rg
);
170 omapfb_put_mem_region(new_rg
);
171 } else if (new_rg
->id
> old_rg
->id
) {
172 omapfb_put_mem_region(new_rg
);
173 omapfb_put_mem_region(old_rg
);
175 omapfb_put_mem_region(old_rg
);
177 dev_err(fbdev
->dev
, "setup_plane failed\n");
182 static int omapfb_query_plane(struct fb_info
*fbi
, struct omapfb_plane_info
*pi
)
184 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
186 if (ofbi
->num_overlays
!= 1) {
187 memset(pi
, 0, sizeof(*pi
));
189 struct omap_overlay
*ovl
;
190 struct omap_overlay_info
*ovli
;
192 ovl
= ofbi
->overlays
[0];
195 pi
->pos_x
= ovli
->pos_x
;
196 pi
->pos_y
= ovli
->pos_y
;
197 pi
->enabled
= ovli
->enabled
;
200 pi
->mem_idx
= get_mem_idx(ofbi
);
201 pi
->out_width
= ovli
->out_width
;
202 pi
->out_height
= ovli
->out_height
;
208 static int omapfb_setup_mem(struct fb_info
*fbi
, struct omapfb_mem_info
*mi
)
210 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
211 struct omapfb2_device
*fbdev
= ofbi
->fbdev
;
212 struct omapfb2_mem_region
*rg
;
216 if (mi
->type
> OMAPFB_MEMTYPE_MAX
)
219 size
= PAGE_ALIGN(mi
->size
);
223 down_write_nested(&rg
->lock
, rg
->id
);
224 atomic_inc(&rg
->lock_count
);
226 if (atomic_read(&rg
->map_count
)) {
231 for (i
= 0; i
< fbdev
->num_fbs
; i
++) {
232 struct omapfb_info
*ofbi2
= FB2OFB(fbdev
->fbs
[i
]);
235 if (ofbi2
->region
!= rg
)
238 for (j
= 0; j
< ofbi2
->num_overlays
; j
++) {
239 if (ofbi2
->overlays
[j
]->info
.enabled
) {
246 if (rg
->size
!= size
|| rg
->type
!= mi
->type
) {
247 r
= omapfb_realloc_fbmem(fbi
, size
, mi
->type
);
249 dev_err(fbdev
->dev
, "realloc fbmem failed\n");
255 atomic_dec(&rg
->lock_count
);
261 static int omapfb_query_mem(struct fb_info
*fbi
, struct omapfb_mem_info
*mi
)
263 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
264 struct omapfb2_mem_region
*rg
;
266 rg
= omapfb_get_mem_region(ofbi
->region
);
267 memset(mi
, 0, sizeof(*mi
));
272 omapfb_put_mem_region(rg
);
277 static int omapfb_update_window_nolock(struct fb_info
*fbi
,
278 u32 x
, u32 y
, u32 w
, u32 h
)
280 struct omap_dss_device
*display
= fb2display(fbi
);
286 if (w
== 0 || h
== 0)
289 display
->driver
->get_resolution(display
, &dw
, &dh
);
291 if (x
+ w
> dw
|| y
+ h
> dh
)
294 return display
->driver
->update(display
, x
, y
, w
, h
);
297 /* This function is exported for SGX driver use */
298 int omapfb_update_window(struct fb_info
*fbi
,
299 u32 x
, u32 y
, u32 w
, u32 h
)
301 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
302 struct omapfb2_device
*fbdev
= ofbi
->fbdev
;
305 if (!lock_fb_info(fbi
))
309 r
= omapfb_update_window_nolock(fbi
, x
, y
, w
, h
);
311 omapfb_unlock(fbdev
);
316 EXPORT_SYMBOL(omapfb_update_window
);
318 static int omapfb_set_update_mode(struct fb_info
*fbi
,
319 enum omapfb_update_mode mode
)
321 struct omap_dss_device
*display
= fb2display(fbi
);
322 enum omap_dss_update_mode um
;
325 if (!display
|| !display
->driver
->set_update_mode
)
329 case OMAPFB_UPDATE_DISABLED
:
330 um
= OMAP_DSS_UPDATE_DISABLED
;
333 case OMAPFB_AUTO_UPDATE
:
334 um
= OMAP_DSS_UPDATE_AUTO
;
337 case OMAPFB_MANUAL_UPDATE
:
338 um
= OMAP_DSS_UPDATE_MANUAL
;
345 r
= display
->driver
->set_update_mode(display
, um
);
350 static int omapfb_get_update_mode(struct fb_info
*fbi
,
351 enum omapfb_update_mode
*mode
)
353 struct omap_dss_device
*display
= fb2display(fbi
);
354 enum omap_dss_update_mode m
;
359 if (!display
->driver
->get_update_mode
) {
360 *mode
= OMAPFB_AUTO_UPDATE
;
364 m
= display
->driver
->get_update_mode(display
);
367 case OMAP_DSS_UPDATE_DISABLED
:
368 *mode
= OMAPFB_UPDATE_DISABLED
;
370 case OMAP_DSS_UPDATE_AUTO
:
371 *mode
= OMAPFB_AUTO_UPDATE
;
373 case OMAP_DSS_UPDATE_MANUAL
:
374 *mode
= OMAPFB_MANUAL_UPDATE
;
383 static struct omapfb_color_key omapfb_color_keys
[2];
385 static int _omapfb_set_color_key(struct omap_overlay_manager
*mgr
,
386 struct omapfb_color_key
*ck
)
388 struct omap_overlay_manager_info info
;
389 enum omap_dss_trans_key_type kt
;
392 mgr
->get_manager_info(mgr
, &info
);
394 if (ck
->key_type
== OMAPFB_COLOR_KEY_DISABLED
) {
395 info
.trans_enabled
= false;
396 omapfb_color_keys
[mgr
->id
] = *ck
;
398 r
= mgr
->set_manager_info(mgr
, &info
);
407 switch (ck
->key_type
) {
408 case OMAPFB_COLOR_KEY_GFX_DST
:
409 kt
= OMAP_DSS_COLOR_KEY_GFX_DST
;
411 case OMAPFB_COLOR_KEY_VID_SRC
:
412 kt
= OMAP_DSS_COLOR_KEY_VID_SRC
;
418 info
.default_color
= ck
->background
;
419 info
.trans_key
= ck
->trans_key
;
420 info
.trans_key_type
= kt
;
421 info
.trans_enabled
= true;
423 omapfb_color_keys
[mgr
->id
] = *ck
;
425 r
= mgr
->set_manager_info(mgr
, &info
);
434 static int omapfb_set_color_key(struct fb_info
*fbi
,
435 struct omapfb_color_key
*ck
)
437 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
438 struct omapfb2_device
*fbdev
= ofbi
->fbdev
;
441 struct omap_overlay_manager
*mgr
= NULL
;
445 for (i
= 0; i
< ofbi
->num_overlays
; i
++) {
446 if (ofbi
->overlays
[i
]->manager
) {
447 mgr
= ofbi
->overlays
[i
]->manager
;
457 r
= _omapfb_set_color_key(mgr
, ck
);
459 omapfb_unlock(fbdev
);
464 static int omapfb_get_color_key(struct fb_info
*fbi
,
465 struct omapfb_color_key
*ck
)
467 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
468 struct omapfb2_device
*fbdev
= ofbi
->fbdev
;
469 struct omap_overlay_manager
*mgr
= NULL
;
475 for (i
= 0; i
< ofbi
->num_overlays
; i
++) {
476 if (ofbi
->overlays
[i
]->manager
) {
477 mgr
= ofbi
->overlays
[i
]->manager
;
487 *ck
= omapfb_color_keys
[mgr
->id
];
489 omapfb_unlock(fbdev
);
494 static int omapfb_memory_read(struct fb_info
*fbi
,
495 struct omapfb_memory_read
*mr
)
497 struct omap_dss_device
*display
= fb2display(fbi
);
501 if (!display
|| !display
->driver
->memory_read
)
504 if (!access_ok(VERIFY_WRITE
, mr
->buffer
, mr
->buffer_size
))
507 if (mr
->w
* mr
->h
* 3 > mr
->buffer_size
)
510 buf
= vmalloc(mr
->buffer_size
);
512 DBG("vmalloc failed\n");
516 r
= display
->driver
->memory_read(display
, buf
, mr
->buffer_size
,
517 mr
->x
, mr
->y
, mr
->w
, mr
->h
);
520 if (copy_to_user(mr
->buffer
, buf
, mr
->buffer_size
))
529 static int omapfb_get_ovl_colormode(struct omapfb2_device
*fbdev
,
530 struct omapfb_ovl_colormode
*mode
)
532 int ovl_idx
= mode
->overlay_idx
;
533 int mode_idx
= mode
->mode_idx
;
534 struct omap_overlay
*ovl
;
535 enum omap_color_mode supported_modes
;
536 struct fb_var_screeninfo var
;
539 if (ovl_idx
>= fbdev
->num_overlays
)
541 ovl
= fbdev
->overlays
[ovl_idx
];
542 supported_modes
= ovl
->supported_modes
;
544 mode_idx
= mode
->mode_idx
;
546 for (i
= 0; i
< sizeof(supported_modes
) * 8; i
++) {
547 if (!(supported_modes
& (1 << i
)))
550 * It's possible that the FB doesn't support a mode
551 * that is supported by the overlay, so call the
554 if (dss_mode_to_fb_mode(1 << i
, &var
) < 0)
562 if (i
== sizeof(supported_modes
) * 8)
565 mode
->bits_per_pixel
= var
.bits_per_pixel
;
566 mode
->nonstd
= var
.nonstd
;
568 mode
->green
= var
.green
;
569 mode
->blue
= var
.blue
;
570 mode
->transp
= var
.transp
;
575 static int omapfb_wait_for_go(struct fb_info
*fbi
)
577 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
581 for (i
= 0; i
< ofbi
->num_overlays
; ++i
) {
582 struct omap_overlay
*ovl
= ofbi
->overlays
[i
];
583 r
= ovl
->wait_for_go(ovl
);
591 int omapfb_ioctl(struct fb_info
*fbi
, unsigned int cmd
, unsigned long arg
)
593 struct omapfb_info
*ofbi
= FB2OFB(fbi
);
594 struct omapfb2_device
*fbdev
= ofbi
->fbdev
;
595 struct omap_dss_device
*display
= fb2display(fbi
);
598 struct omapfb_update_window_old uwnd_o
;
599 struct omapfb_update_window uwnd
;
600 struct omapfb_plane_info plane_info
;
601 struct omapfb_caps caps
;
602 struct omapfb_mem_info mem_info
;
603 struct omapfb_color_key color_key
;
604 struct omapfb_ovl_colormode ovl_colormode
;
605 enum omapfb_update_mode update_mode
;
607 struct omapfb_memory_read memory_read
;
608 struct omapfb_vram_info vram_info
;
609 struct omapfb_tearsync_info tearsync_info
;
610 struct omapfb_display_info display_info
;
617 case OMAPFB_SYNC_GFX
:
618 DBG("ioctl SYNC_GFX\n");
619 if (!display
|| !display
->driver
->sync
) {
620 /* DSS1 never returns an error here, so we neither */
625 r
= display
->driver
->sync(display
);
628 case OMAPFB_UPDATE_WINDOW_OLD
:
629 DBG("ioctl UPDATE_WINDOW_OLD\n");
630 if (!display
|| !display
->driver
->update
) {
635 if (copy_from_user(&p
.uwnd_o
,
642 r
= omapfb_update_window_nolock(fbi
, p
.uwnd_o
.x
, p
.uwnd_o
.y
,
643 p
.uwnd_o
.width
, p
.uwnd_o
.height
);
646 case OMAPFB_UPDATE_WINDOW
:
647 DBG("ioctl UPDATE_WINDOW\n");
648 if (!display
|| !display
->driver
->update
) {
653 if (copy_from_user(&p
.uwnd
, (void __user
*)arg
,
659 r
= omapfb_update_window_nolock(fbi
, p
.uwnd
.x
, p
.uwnd
.y
,
660 p
.uwnd
.width
, p
.uwnd
.height
);
663 case OMAPFB_SETUP_PLANE
:
664 DBG("ioctl SETUP_PLANE\n");
665 if (copy_from_user(&p
.plane_info
, (void __user
*)arg
,
666 sizeof(p
.plane_info
)))
669 r
= omapfb_setup_plane(fbi
, &p
.plane_info
);
672 case OMAPFB_QUERY_PLANE
:
673 DBG("ioctl QUERY_PLANE\n");
674 r
= omapfb_query_plane(fbi
, &p
.plane_info
);
677 if (copy_to_user((void __user
*)arg
, &p
.plane_info
,
678 sizeof(p
.plane_info
)))
682 case OMAPFB_SETUP_MEM
:
683 DBG("ioctl SETUP_MEM\n");
684 if (copy_from_user(&p
.mem_info
, (void __user
*)arg
,
688 r
= omapfb_setup_mem(fbi
, &p
.mem_info
);
691 case OMAPFB_QUERY_MEM
:
692 DBG("ioctl QUERY_MEM\n");
693 r
= omapfb_query_mem(fbi
, &p
.mem_info
);
696 if (copy_to_user((void __user
*)arg
, &p
.mem_info
,
701 case OMAPFB_GET_CAPS
:
702 DBG("ioctl GET_CAPS\n");
708 memset(&p
.caps
, 0, sizeof(p
.caps
));
709 if (display
->caps
& OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE
)
710 p
.caps
.ctrl
|= OMAPFB_CAPS_MANUAL_UPDATE
;
711 if (display
->caps
& OMAP_DSS_DISPLAY_CAP_TEAR_ELIM
)
712 p
.caps
.ctrl
|= OMAPFB_CAPS_TEARSYNC
;
714 if (copy_to_user((void __user
*)arg
, &p
.caps
, sizeof(p
.caps
)))
718 case OMAPFB_GET_OVERLAY_COLORMODE
:
719 DBG("ioctl GET_OVERLAY_COLORMODE\n");
720 if (copy_from_user(&p
.ovl_colormode
, (void __user
*)arg
,
721 sizeof(p
.ovl_colormode
))) {
725 r
= omapfb_get_ovl_colormode(fbdev
, &p
.ovl_colormode
);
728 if (copy_to_user((void __user
*)arg
, &p
.ovl_colormode
,
729 sizeof(p
.ovl_colormode
)))
733 case OMAPFB_SET_UPDATE_MODE
:
734 DBG("ioctl SET_UPDATE_MODE\n");
735 if (get_user(p
.update_mode
, (int __user
*)arg
))
738 r
= omapfb_set_update_mode(fbi
, p
.update_mode
);
741 case OMAPFB_GET_UPDATE_MODE
:
742 DBG("ioctl GET_UPDATE_MODE\n");
743 r
= omapfb_get_update_mode(fbi
, &p
.update_mode
);
746 if (put_user(p
.update_mode
,
747 (enum omapfb_update_mode __user
*)arg
))
751 case OMAPFB_SET_COLOR_KEY
:
752 DBG("ioctl SET_COLOR_KEY\n");
753 if (copy_from_user(&p
.color_key
, (void __user
*)arg
,
754 sizeof(p
.color_key
)))
757 r
= omapfb_set_color_key(fbi
, &p
.color_key
);
760 case OMAPFB_GET_COLOR_KEY
:
761 DBG("ioctl GET_COLOR_KEY\n");
762 r
= omapfb_get_color_key(fbi
, &p
.color_key
);
765 if (copy_to_user((void __user
*)arg
, &p
.color_key
,
766 sizeof(p
.color_key
)))
770 case FBIO_WAITFORVSYNC
:
771 if (get_user(p
.crt
, (__u32 __user
*)arg
)) {
781 case OMAPFB_WAITFORVSYNC
:
782 DBG("ioctl WAITFORVSYNC\n");
788 r
= display
->manager
->wait_for_vsync(display
->manager
);
791 case OMAPFB_WAITFORGO
:
792 DBG("ioctl WAITFORGO\n");
798 r
= omapfb_wait_for_go(fbi
);
801 /* LCD and CTRL tests do the same thing for backward
803 case OMAPFB_LCD_TEST
:
804 DBG("ioctl LCD_TEST\n");
805 if (get_user(p
.test_num
, (int __user
*)arg
)) {
809 if (!display
|| !display
->driver
->run_test
) {
814 r
= display
->driver
->run_test(display
, p
.test_num
);
818 case OMAPFB_CTRL_TEST
:
819 DBG("ioctl CTRL_TEST\n");
820 if (get_user(p
.test_num
, (int __user
*)arg
)) {
824 if (!display
|| !display
->driver
->run_test
) {
829 r
= display
->driver
->run_test(display
, p
.test_num
);
833 case OMAPFB_MEMORY_READ
:
834 DBG("ioctl MEMORY_READ\n");
836 if (copy_from_user(&p
.memory_read
, (void __user
*)arg
,
837 sizeof(p
.memory_read
))) {
842 r
= omapfb_memory_read(fbi
, &p
.memory_read
);
846 case OMAPFB_GET_VRAM_INFO
: {
847 unsigned long vram
, free
, largest
;
849 DBG("ioctl GET_VRAM_INFO\n");
851 omap_vram_get_info(&vram
, &free
, &largest
);
852 p
.vram_info
.total
= vram
;
853 p
.vram_info
.free
= free
;
854 p
.vram_info
.largest_free_block
= largest
;
856 if (copy_to_user((void __user
*)arg
, &p
.vram_info
,
857 sizeof(p
.vram_info
)))
862 case OMAPFB_SET_TEARSYNC
: {
863 DBG("ioctl SET_TEARSYNC\n");
865 if (copy_from_user(&p
.tearsync_info
, (void __user
*)arg
,
866 sizeof(p
.tearsync_info
))) {
871 if (!display
|| !display
->driver
->enable_te
) {
876 r
= display
->driver
->enable_te(display
,
877 !!p
.tearsync_info
.enabled
);
882 case OMAPFB_GET_DISPLAY_INFO
: {
885 DBG("ioctl GET_DISPLAY_INFO\n");
887 if (display
== NULL
) {
892 display
->driver
->get_resolution(display
, &xres
, &yres
);
894 p
.display_info
.xres
= xres
;
895 p
.display_info
.yres
= yres
;
896 p
.display_info
.width
= 0;
897 p
.display_info
.height
= 0;
899 if (copy_to_user((void __user
*)arg
, &p
.display_info
,
900 sizeof(p
.display_info
)))
906 dev_err(fbdev
->dev
, "Unknown ioctl 0x%x\n", cmd
);
911 DBG("ioctl failed: %d\n", r
);