summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorCarsten Schoenert <c.schoenert@gmail.com>2013-05-02 09:54:08 (GMT)
committer Peter Korsgaard <jacmet@sunsite.dk>2013-05-02 21:11:39 (GMT)
commitde341929676b6a1537de5e6140d6ab3c50482bac (patch)
tree5f293d0ad70eaa9eb4e0108d6438439b471d0837
parent8867c892ae8079ca78c64f8570ba65d6a730e8a4 (diff)
downloadbuildroot-de341929676b6a1537de5e6140d6ab3c50482bac.tar.gz
buildroot-de341929676b6a1537de5e6140d6ab3c50482bac.tar.bz2
directfb: fix error in *SetRegion* datatypes
DirectFB comes with incorrect declarations for *SetRegion* datatypes, this breaks the build for some GFX Drivers. Also there are some headers missend in the archive, this breaks some other modules of directfb that not covered yet by the autobuilders. And at least the configure script doesn't use a variable for the imlib2-config script. That breaks crossbuilds of directfb in most cases. Fixes: http://autobuild.buildroot.net/results/03465f0e14accc8d8f8fc2640b7a0dd8bec594e4 Signed-off-by: Carsten Schoenert <c.schoenert@gmail.com> Signed-off-by: Peter Korsgaard <jacmet@sunsite.dk>
-rw-r--r--package/directfb/directfb-fix-missing-davinci-voodoo-header.patch1726
-rw-r--r--package/directfb/directfb-imlib2-config.patch21
-rw-r--r--package/directfb/directfb-setregion-lock.patch92
3 files changed, 1839 insertions, 0 deletions
diff --git a/package/directfb/directfb-fix-missing-davinci-voodoo-header.patch b/package/directfb/directfb-fix-missing-davinci-voodoo-header.patch
new file mode 100644
index 0000000..6ad4958
--- /dev/null
+++ b/package/directfb/directfb-fix-missing-davinci-voodoo-header.patch
@@ -0,0 +1,1726 @@
+The archive of directfb-1.6.3 is still missing some header files against
+the tagged git tree of directfb. The following files are missing.
+
+gfxdrivers/davinci/davinci_c64x.h
+gfxdrivers/davinci/davincifb.h
+gfxdrivers/davinci/davinci_gfxdriver.h
+tests/voodoo/voodoo_test.h
+
+The headers of course are needed to be able to build every module of
+directfb. The headers are taken from the git tree of directfb
+http://git.directfb.org/?p=core/DirectFB.git;a=commit;h=38b784549bc59bb07c58bb29667cb658695d39a7,
+tag DIRECTFB_1_6_3, SHA1ID 38b784549bc59bb07c58bb29667cb658695d39a7.
+
+Signed-off-by: Carsten Schoenert <c.schoenert@gmail.com>
+
+diff -puNr -Naur directfb-1.6.3-orig/gfxdrivers/davinci/davinci_c64x.h directfb-1.6.3/gfxdrivers/davinci/davinci_c64x.h
+--- directfb-1.6.3-orig/gfxdrivers/davinci/davinci_c64x.h 1970-01-01 01:00:00.000000000 +0100
++++ directfb-1.6.3/gfxdrivers/davinci/davinci_c64x.h 2013-04-07 21:33:25.928530187 +0200
+@@ -0,0 +1,935 @@
++/*
++ TI Davinci driver - C64X+ DSP Library
++
++ (c) Copyright 2008 directfb.org
++ (c) Copyright 2007 Telio AG
++
++ Written by Denis Oliver Kropp <dok@directfb.org> and
++ Olaf Dreesen <olaf@directfb.org>.
++
++ All rights reserved.
++
++ This library is free software; you can redistribute it and/or
++ modify it under the terms of the GNU General Public License
++ version 2 as published by the Free Software Foundation.
++
++ This library is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++ General Public License for more details.
++
++ You should have received a copy of the GNU General Public
++ License along with this library; if not, write to the
++ Free Software Foundation, Inc., 59 Temple Place - Suite 330,
++ Boston, MA 02111-1307, USA.
++*/
++
++#ifndef __DAVINCI_C64X_H__
++#define __DAVINCI_C64X_H__
++
++#include <unistd.h>
++
++#include <directfb.h>
++
++#include <direct/messages.h>
++#include <direct/trace.h>
++
++#include <linux/c64x.h>
++
++#define mb() __asm__ __volatile__ ("" : : : "memory")
++
++/**********************************************************************************************************************/
++
++typedef struct {
++ int magic;
++
++ int fd;
++ c64xTaskControl *ctl;
++ void *mem;
++
++ c64xTask *QueueL;
++} DavinciC64x;
++
++typedef struct {
++ int magic;
++ unsigned int max_tasks;
++ unsigned int num_tasks;
++ c64xTask *tasks;
++} DavinciC64xTasks;
++
++typedef enum {
++ C64X_TEF_NONE = 0x0000,
++ C64X_TEF_RESET = 0x0001
++} DavinciC64xEmitFlags;
++
++/**********************************************************************************************************************/
++
++DFBResult davinci_c64x_open ( DavinciC64x *c64x );
++
++DFBResult davinci_c64x_close ( DavinciC64x *c64x );
++
++DFBResult davinci_c64x_wait_low( DavinciC64x *c64x );
++
++/**********************************************************************************************************************/
++
++DFBResult davinci_c64x_tasks_init ( DavinciC64xTasks *tasks,
++ unsigned int size );
++
++DFBResult davinci_c64x_tasks_destroy( DavinciC64xTasks *tasks );
++
++/**********************************************************************************************************************/
++
++DFBResult davinci_c64x_emit_tasks( DavinciC64x *c64x,
++ DavinciC64xTasks *tasks,
++ DavinciC64xEmitFlags flags );
++
++/**********************************************************************************************************************/
++
++static const char *state_names[] = { "DONE", "ERROR", "TODO", "RUNNING" };
++
++static inline c64xTask *
++c64x_get_task( DavinciC64x *c64x )
++{
++ c64xTaskControl *ctl = c64x->ctl;
++ uint32_t idx = ctl->QL_arm;
++ uint32_t next = (idx + 1) & C64X_QUEUE_MASK;
++ c64xTask *task = &c64x->QueueL[idx];
++ int loops = 0;
++ uint32_t idle = 0;
++
++ /* Wait for the entry (and next) to be processed by the DSP (rare case). */
++ while (task->c64x_flags & C64X_FLAG_TODO || ctl->QL_dsp == next) {
++ if (loops > 666 || (idle && ctl->idlecounter - idle > 666)) {
++ c64xTask *dsp_task = &c64x->QueueL[ctl->QL_dsp];
++
++ D_PERROR( "Davinci/C64X+: Blocked! [DSP %d / %d (%s), ARM %d / %d (%s)]\n",
++ ctl->QL_dsp,
++ (dsp_task->c64x_function >> 2) & 0x3fff,
++ state_names[dsp_task->c64x_function & 3],
++ ctl->QL_arm,
++ (task->c64x_function >> 2) & 0x3fff,
++ state_names[task->c64x_function & 3] );
++
++ break;
++ }
++
++ idle = ctl->idlecounter;
++
++ /* Queue is full, waiting 10-20ms should not be too bad. */
++ if (loops++ > 10)
++ usleep( 5000 );
++ }
++
++ return task;
++}
++
++static inline void
++c64x_submit_task( DavinciC64x *c64x, c64xTask *task )
++{
++ c64xTaskControl *ctl = c64x->ctl;
++ uint32_t idx = ctl->QL_arm;
++ uint32_t next = (idx + 1) & C64X_QUEUE_MASK;
++
++ mb();
++
++ ctl->QL_arm = next;
++
++ mb();
++}
++
++/**********************************************************************************************************************/
++
++static inline void
++davinci_c64x_wb_inv_range( DavinciC64x *c64x,
++ unsigned long start,
++ u32 length,
++ u32 func )
++{
++ c64xTask *task = c64x_get_task( c64x );
++
++ task->c64x_arg[0] = start;
++ task->c64x_arg[1] = length;
++ task->c64x_arg[2] = func;
++
++ task->c64x_function = C64X_WB_INV_RANGE | C64X_FLAG_TODO;
++
++ c64x_submit_task( c64x, task );
++}
++
++static inline void
++davinci_c64x_write_back_all( DavinciC64x *c64x )
++{
++ c64xTask *task = c64x_get_task( c64x );
++
++ task->c64x_function = C64X_WRITE_BACK_ALL | C64X_FLAG_TODO;
++
++ c64x_submit_task( c64x, task );
++}
++
++/**********************************************************************************************************************/
++
++static inline void
++davinci_c64x_load_block__L( DavinciC64xTasks *tasks,
++ unsigned long words,
++ u32 num,
++ u32 flags )
++{
++ c64xTask *task = &tasks->tasks[tasks->num_tasks];
++
++ D_ASSERT( tasks->num_tasks < tasks->max_tasks );
++
++ task->c64x_arg[0] = words;
++ task->c64x_arg[1] = num;
++ task->c64x_arg[2] = flags;
++
++ task->c64x_function = C64X_LOAD_BLOCK | C64X_FLAG_TODO;
++
++ tasks->num_tasks++;
++}
++
++static inline void
++davinci_c64x_load_block( DavinciC64x *c64x,
++ unsigned long words,
++ u32 num,
++ u32 flags )
++{
++ c64xTask *task = c64x_get_task( c64x );
++
++ task->c64x_arg[0] = words;
++ task->c64x_arg[1] = num;
++ task->c64x_arg[2] = flags;
++
++ task->c64x_function = C64X_LOAD_BLOCK | C64X_FLAG_TODO;
++
++ c64x_submit_task( c64x, task );
++}
++
++static inline void
++davinci_c64x_fetch_uyvy( DavinciC64x *c64x,
++ unsigned long dest,
++ unsigned long source,
++ u32 pitch,
++ u32 height,
++ u32 flags )
++{
++ c64xTask *task = c64x_get_task( c64x );
++
++ task->c64x_arg[0] = dest;
++ task->c64x_arg[1] = source;
++ task->c64x_arg[2] = pitch;
++ task->c64x_arg[3] = height;
++ task->c64x_arg[4] = flags;
++
++ task->c64x_function = C64X_FETCH_UYVY | C64X_FLAG_TODO;
++
++ c64x_submit_task( c64x, task );
++}
++
++static inline void
++davinci_c64x_mc( DavinciC64x *c64x,
++ unsigned long dest,
++ u32 dpitch,
++ unsigned long source0,
++ unsigned long source1,
++ u32 spitch,
++ u32 height,
++ int func )
++{
++ c64xTask *task = c64x_get_task( c64x );
++
++ task->c64x_arg[0] = dest;
++ task->c64x_arg[1] = dpitch;
++ task->c64x_arg[2] = source0;
++ task->c64x_arg[3] = source1;
++ task->c64x_arg[4] = spitch;
++ task->c64x_arg[5] = height;
++
++ task->c64x_function = func | C64X_FLAG_TODO;
++
++ c64x_submit_task( c64x, task );
++}
++
++static inline void
++davinci_c64x_put_idct_uyvy_16x16__L( DavinciC64xTasks *tasks,
++ unsigned long dest,
++ u32 pitch,
++ u32 flags )
++{
++ c64xTask *task = &tasks->tasks[tasks->num_tasks];
++
++ D_ASSERT( tasks->num_tasks < tasks->max_tasks );
++
++ task->c64x_arg[0] = dest;
++ task->c64x_arg[1] = pitch;
++ task->c64x_arg[2] = flags;
++
++ task->c64x_function = C64X_PUT_IDCT_UYVY_16x16 | C64X_FLAG_TODO;
++
++ tasks->num_tasks++;
++}
++
++static inline void
++davinci_c64x_put_idct_uyvy_16x16( DavinciC64x *c64x,
++ unsigned long dest,
++ u32 pitch,
++ u32 flags )
++{
++ c64xTask *task = c64x_get_task( c64x );
++
++ task->c64x_arg[0] = dest;
++ task->c64x_arg[1] = pitch;
++ task->c64x_arg[2] = flags;
++
++ task->c64x_function = C64X_PUT_IDCT_UYVY_16x16 | C64X_FLAG_TODO;
++
++ c64x_submit_task( c64x, task );
++}
++
++static inline void
++davinci_c64x_put_mc_uyvy_16x16__L( DavinciC64xTasks *tasks,
++ unsigned long dest,
++ u32 pitch,
++ u32 flags )
++{
++ c64xTask *task = &tasks->tasks[tasks->num_tasks];
++
++ D_ASSERT( tasks->num_tasks < tasks->max_tasks );
++
++ task->c64x_arg[0] = dest;
++ task->c64x_arg[1] = pitch;
++ task->c64x_arg[2] = flags;
++
++ task->c64x_function = C64X_PUT_MC_UYVY_16x16 | C64X_FLAG_TODO;
++
++ tasks->num_tasks++;
++}
++
++static inline void
++davinci_c64x_put_mc_uyvy_16x16( DavinciC64x *c64x,
++ unsigned long dest,
++ u32 pitch,
++ u32 flags )
++{
++ c64xTask *task = c64x_get_task( c64x );
++
++ task->c64x_arg[0] = dest;
++ task->c64x_arg[1] = pitch;
++ task->c64x_arg[2] = flags;
++
++ task->c64x_function = C64X_PUT_MC_UYVY_16x16 | C64X_FLAG_TODO;
++
++ c64x_submit_task( c64x, task );
++}
++
++static inline void
++davinci_c64x_put_sum_uyvy_16x16__L( DavinciC64xTasks *tasks,
++ unsigned long dest,
++ u32 pitch,
++ u32 flags )
++{
++ c64xTask *task = &tasks->tasks[tasks->num_tasks];
++
++ D_ASSERT( tasks->num_tasks < tasks->max_tasks );
++
++ task->c64x_arg[0] = dest;
++ task->c64x_arg[1] = pitch;
++ task->c64x_arg[2] = flags;
++
++ task->c64x_function = C64X_PUT_SUM_UYVY_16x16 | C64X_FLAG_TODO;
++
++ tasks->num_tasks++;
++}
++
++static inline void
++davinci_c64x_put_sum_uyvy_16x16( DavinciC64x *c64x,
++ unsigned long dest,
++ u32 pitch,
++ u32 flags )
++{
++ c64xTask *task = c64x_get_task( c64x );
++
++ task->c64x_arg[0] = dest;
++ task->c64x_arg[1] = pitch;
++ task->c64x_arg[2] = flags;
++
++ task->c64x_function = C64X_PUT_SUM_UYVY_16x16 | C64X_FLAG_TODO;
++
++ c64x_submit_task( c64x, task );
++}
++
++static inline void
++davinci_c64x_dva_begin_frame__L( DavinciC64xTasks *tasks,
++ u32 pitch,
++ unsigned long current,
++ unsigned long past,
++ unsigned long future,
++ u32 flags )
++{
++ c64xTask *task = &tasks->tasks[tasks->num_tasks];
++
++ D_ASSERT( tasks->num_tasks < tasks->max_tasks );
++
++ task->c64x_arg[0] = pitch;
++ task->c64x_arg[1] = current;
++ task->c64x_arg[2] = past;
++ task->c64x_arg[3] = future;
++ task->c64x_arg[4] = flags;
++
++ task->c64x_function = C64X_DVA_BEGIN_FRAME | C64X_FLAG_TODO;
++
++ tasks->num_tasks++;
++}
++
++static inline void
++davinci_c64x_dva_begin_frame( DavinciC64x *c64x,
++ u32 pitch,
++ unsigned long current,
++ unsigned long past,
++ unsigned long future,
++ u32 flags )
++{
++ c64xTask *task = c64x_get_task( c64x );
++
++ task->c64x_arg[0] = pitch;
++ task->c64x_arg[1] = current;
++ task->c64x_arg[2] = past;
++ task->c64x_arg[3] = future;
++ task->c64x_arg[4] = flags;
++
++ task->c64x_function = C64X_DVA_BEGIN_FRAME | C64X_FLAG_TODO;
++
++ c64x_submit_task( c64x, task );
++}
++
++static inline void
++davinci_c64x_dva_motion_block__L( DavinciC64xTasks *tasks,
++ unsigned long macroblock )
++{
++ c64xTask *task = &tasks->tasks[tasks->num_tasks];
++
++ D_ASSERT( tasks->num_tasks < tasks->max_tasks );
++
++ task->c64x_arg[0] = macroblock;
++
++ task->c64x_function = C64X_DVA_MOTION_BLOCK | C64X_FLAG_TODO;
++
++ tasks->num_tasks++;
++}
++
++static inline void
++davinci_c64x_dva_motion_block( DavinciC64x *c64x,
++ unsigned long macroblock )
++{
++ c64xTask *task = c64x_get_task( c64x );
++
++ task->c64x_arg[0] = macroblock;
++
++ task->c64x_function = C64X_DVA_MOTION_BLOCK | C64X_FLAG_TODO;
++
++ c64x_submit_task( c64x, task );
++}
++
++/**********************************************************************************************************************/
++
++static inline void
++davinci_c64x_dva_idct( DavinciC64x *c64x,
++ unsigned long dest,
++ u32 pitch,
++ unsigned long source )
++{
++ c64xTask *task = c64x_get_task( c64x );
++
++ task->c64x_arg[0] = dest;
++ task->c64x_arg[1] = pitch;
++ task->c64x_arg[2] = source;
++
++ task->c64x_function = C64X_DVA_IDCT | C64X_FLAG_TODO;
++
++ c64x_submit_task( c64x, task );
++}
++
++/**********************************************************************************************************************/
++
++static inline void
++davinci_c64x_put_uyvy_16x16( DavinciC64x *c64x,
++ unsigned long dest,
++ u32 pitch,
++ unsigned long source,
++ u32 flags )
++{
++ c64xTask *task = c64x_get_task( c64x );
++
++ task->c64x_arg[0] = dest;
++ task->c64x_arg[1] = pitch;
++ task->c64x_arg[2] = source;
++ task->c64x_arg[3] = flags;
++
++ task->c64x_function = C64X_PUT_UYVY_16x16 | C64X_FLAG_TODO;
++
++ c64x_submit_task( c64x, task );
++}
++
++static inline void
++davinci_c64x_dither_argb__L( DavinciC64xTasks *tasks,
++ unsigned long dst_rgb,
++ unsigned long dst_alpha,
++ u32 dst_pitch,
++ unsigned long source,
++ u32 src_pitch,
++ u32 width,
++ u32 height )
++{
++ c64xTask *task = &tasks->tasks[tasks->num_tasks];
++
++ D_ASSERT( tasks->num_tasks < tasks->max_tasks );
++
++ task->c64x_arg[0] = dst_rgb;
++ task->c64x_arg[1] = dst_alpha;
++ task->c64x_arg[2] = dst_pitch;
++ task->c64x_arg[3] = source;
++ task->c64x_arg[4] = src_pitch;
++ task->c64x_arg[5] = width;
++ task->c64x_arg[6] = height;
++
++ task->c64x_function = C64X_DITHER_ARGB | C64X_FLAG_TODO;
++
++ tasks->num_tasks++;
++}
++
++static inline void
++davinci_c64x_dither_argb( DavinciC64x *c64x,
++ unsigned long dst_rgb,
++ unsigned long dst_alpha,
++ u32 dst_pitch,
++ unsigned long source,
++ u32 src_pitch,
++ u32 width,
++ u32 height )
++{
++ c64xTask *task = c64x_get_task( c64x );
++
++ task->c64x_arg[0] = dst_rgb;
++ task->c64x_arg[1] = dst_alpha;
++ task->c64x_arg[2] = dst_pitch;
++ task->c64x_arg[3] = source;
++ task->c64x_arg[4] = src_pitch;
++ task->c64x_arg[5] = width;
++ task->c64x_arg[6] = height;
++
++ task->c64x_function = C64X_DITHER_ARGB | C64X_FLAG_TODO;
++
++ c64x_submit_task( c64x, task );
++}
++
++static inline void
++davinci_c64x_fill_16__L( DavinciC64xTasks *tasks,
++ unsigned long dest,
++ u32 pitch,
++ u32 width,
++ u32 height,
++ u32 value )
++{
++ c64xTask *task = &tasks->tasks[tasks->num_tasks];
++
++ D_ASSERT( tasks->num_tasks < tasks->max_tasks );
++
++ task->c64x_arg[0] = dest;
++ task->c64x_arg[1] = pitch;
++ task->c64x_arg[2] = width;
++ task->c64x_arg[3] = height;
++ task->c64x_arg[4] = value;
++
++ task->c64x_function = C64X_FILL_16 | C64X_FLAG_TODO;
++
++ tasks->num_tasks++;
++}
++
++static inline void
++davinci_c64x_fill_16( DavinciC64x *c64x,
++ unsigned long dest,
++ u32 pitch,
++ u32 width,
++ u32 height,
++ u32 value )
++{
++ c64xTask *task = c64x_get_task( c64x );
++
++ task->c64x_arg[0] = dest;
++ task->c64x_arg[1] = pitch;
++ task->c64x_arg[2] = width;
++ task->c64x_arg[3] = height;
++ task->c64x_arg[4] = value;
++
++ task->c64x_function = C64X_FILL_16 | C64X_FLAG_TODO;
++
++ c64x_submit_task( c64x, task );
++}
++
++static inline void
++davinci_c64x_fill_32__L( DavinciC64xTasks *tasks,
++ unsigned long dest,
++ u32 pitch,
++ u32 width,
++ u32 height,
++ u32 value )
++{
++ c64xTask *task = &tasks->tasks[tasks->num_tasks];
++
++ D_ASSERT( tasks->num_tasks < tasks->max_tasks );
++
++ task->c64x_arg[0] = dest;
++ task->c64x_arg[1] = pitch;
++ task->c64x_arg[2] = width;
++ task->c64x_arg[3] = height;
++ task->c64x_arg[4] = value;
++
++ task->c64x_function = C64X_FILL_32 | C64X_FLAG_TODO;
++
++ tasks->num_tasks++;
++}
++
++static inline void
++davinci_c64x_fill_32( DavinciC64x *c64x,
++ unsigned long dest,
++ u32 pitch,
++ u32 width,
++ u32 height,
++ u32 value )
++{
++ c64xTask *task = c64x_get_task( c64x );
++
++ task->c64x_arg[0] = dest;
++ task->c64x_arg[1] = pitch;
++ task->c64x_arg[2] = width;
++ task->c64x_arg[3] = height;
++ task->c64x_arg[4] = value;
++
++ task->c64x_function = C64X_FILL_32 | C64X_FLAG_TODO;
++
++ c64x_submit_task( c64x, task );
++}
++
++static inline void
++davinci_c64x_blit_16__L( DavinciC64xTasks *tasks,
++ unsigned long dest,
++ u32 dpitch,
++ unsigned long src,
++ u32 spitch,
++ u32 width,
++ u32 height )
++{
++ c64xTask *task = &tasks->tasks[tasks->num_tasks];
++
++ D_ASSERT( tasks->num_tasks < tasks->max_tasks );
++
++ task->c64x_arg[0] = dest;
++ task->c64x_arg[1] = dpitch;
++ task->c64x_arg[2] = src;
++ task->c64x_arg[3] = spitch;
++ task->c64x_arg[4] = width;
++ task->c64x_arg[5] = height;
++
++ task->c64x_function = C64X_COPY_16 | C64X_FLAG_TODO;
++
++ tasks->num_tasks++;
++}
++
++static inline void
++davinci_c64x_blit_16( DavinciC64x *c64x,
++ unsigned long dest,
++ u32 dpitch,
++ unsigned long src,
++ u32 spitch,
++ u32 width,
++ u32 height )
++{
++ c64xTask *task = c64x_get_task( c64x );
++
++ task->c64x_arg[0] = dest;
++ task->c64x_arg[1] = dpitch;
++ task->c64x_arg[2] = src;
++ task->c64x_arg[3] = spitch;
++ task->c64x_arg[4] = width;
++ task->c64x_arg[5] = height;
++
++ task->c64x_function = C64X_COPY_16 | C64X_FLAG_TODO;
++
++ c64x_submit_task( c64x, task );
++}
++
++static inline void
++davinci_c64x_blit_32__L( DavinciC64xTasks *tasks,
++ unsigned long dest,
++ u32 dpitch,
++ unsigned long src,
++ u32 spitch,
++ u32 width,
++ u32 height )
++{
++ c64xTask *task = &tasks->tasks[tasks->num_tasks];
++
++ D_ASSERT( tasks->num_tasks < tasks->max_tasks );
++
++ task->c64x_arg[0] = dest;
++ task->c64x_arg[1] = dpitch;
++ task->c64x_arg[2] = src;
++ task->c64x_arg[3] = spitch;
++ task->c64x_arg[4] = width;
++ task->c64x_arg[5] = height;
++
++ task->c64x_function = C64X_COPY_32 | C64X_FLAG_TODO;
++
++ tasks->num_tasks++;
++}
++
++static inline void
++davinci_c64x_blit_32( DavinciC64x *c64x,
++ unsigned long dest,
++ u32 dpitch,
++ unsigned long src,
++ u32 spitch,
++ u32 width,
++ u32 height )
++{
++ c64xTask *task = c64x_get_task( c64x );
++
++ task->c64x_arg[0] = dest;
++ task->c64x_arg[1] = dpitch;
++ task->c64x_arg[2] = src;
++ task->c64x_arg[3] = spitch;
++ task->c64x_arg[4] = width;
++ task->c64x_arg[5] = height;
++
++ task->c64x_function = C64X_COPY_32 | C64X_FLAG_TODO;
++
++ c64x_submit_task( c64x, task );
++}
++
++static inline void
++davinci_c64x_stretch_32__L( DavinciC64xTasks *tasks,
++ unsigned long dest,
++ u32 dpitch,
++ unsigned long src,
++ u32 spitch,
++ u32 dw,
++ u32 dh,
++ u32 sw,
++ u32 sh,
++ const DFBRegion *clip )
++{
++ c64xTask *task = &tasks->tasks[tasks->num_tasks];
++
++ D_ASSERT( tasks->num_tasks < tasks->max_tasks );
++
++ task->c64x_arg[0] = dest;
++ task->c64x_arg[1] = src;
++ task->c64x_arg[2] = dpitch | (spitch << 16);
++ task->c64x_arg[3] = dh | (dw << 16);
++ task->c64x_arg[4] = sh | (sw << 16);
++ task->c64x_arg[5] = clip->x2 | (clip->y2 << 16);
++ task->c64x_arg[6] = clip->x1 | (clip->y1 << 16);
++
++ if (sw > dw && sh > dh)
++ task->c64x_function = C64X_STRETCH_32_down | C64X_FLAG_TODO;
++ else
++ task->c64x_function = C64X_STRETCH_32_up | C64X_FLAG_TODO;
++
++ tasks->num_tasks++;
++}
++
++static inline void
++davinci_c64x_stretch_32( DavinciC64x *c64x,
++ unsigned long dest,
++ u32 dpitch,
++ unsigned long src,
++ u32 spitch,
++ u32 dw,
++ u32 dh,
++ u32 sw,
++ u32 sh,
++ const DFBRegion *clip )
++{
++ c64xTask *task = c64x_get_task( c64x );
++
++ task->c64x_arg[0] = dest;
++ task->c64x_arg[1] = src;
++ task->c64x_arg[2] = dpitch | (spitch << 16);
++ task->c64x_arg[3] = dh | (dw << 16);
++ task->c64x_arg[4] = sh | (sw << 16);
++ task->c64x_arg[5] = clip->x2 | (clip->y2 << 16);
++ task->c64x_arg[6] = clip->x1 | (clip->y1 << 16);
++
++ if (sw > dw && sh > dh)
++ task->c64x_function = C64X_STRETCH_32_down | C64X_FLAG_TODO;
++ else
++ task->c64x_function = C64X_STRETCH_32_up | C64X_FLAG_TODO;
++
++ c64x_submit_task( c64x, task );
++}
++
++static inline void
++davinci_c64x_blit_blend_32__L( DavinciC64xTasks *tasks,
++ u32 sub_func,
++ unsigned long dest,
++ u32 dpitch,
++ unsigned long src,
++ u32 spitch,
++ u32 width,
++ u32 height,
++ u32 argb,
++ u8 alpha )
++{
++ c64xTask *task = &tasks->tasks[tasks->num_tasks];
++
++ D_ASSERT( tasks->num_tasks < tasks->max_tasks );
++
++ task->c64x_arg[0] = dest;
++ task->c64x_arg[1] = dpitch;
++ task->c64x_arg[2] = src;
++ task->c64x_arg[3] = spitch;
++ task->c64x_arg[4] = width | (height << 16);
++ task->c64x_arg[5] = argb;
++ task->c64x_arg[6] = alpha;
++
++ task->c64x_function = (sub_func << 16) | C64X_BLEND_32 | C64X_FLAG_TODO;
++
++ tasks->num_tasks++;
++}
++
++static inline void
++davinci_c64x_blit_blend_32( DavinciC64x *c64x,
++ u32 sub_func,
++ unsigned long dest,
++ u32 dpitch,
++ unsigned long src,
++ u32 spitch,
++ u32 width,
++ u32 height,
++ u32 argb,
++ u8 alpha )
++{
++ c64xTask *task = c64x_get_task( c64x );
++
++ task->c64x_arg[0] = dest;
++ task->c64x_arg[1] = dpitch;
++ task->c64x_arg[2] = src;
++ task->c64x_arg[3] = spitch;
++ task->c64x_arg[4] = width | (height << 16);
++ task->c64x_arg[5] = argb;
++ task->c64x_arg[6] = alpha;
++
++ task->c64x_function = (sub_func << 16) | C64X_BLEND_32 | C64X_FLAG_TODO;
++
++ c64x_submit_task( c64x, task );
++}
++
++static inline void
++davinci_c64x_blit_keyed_16__L( DavinciC64xTasks *tasks,
++ unsigned long dest,
++ u32 dpitch,
++ unsigned long src,
++ u32 spitch,
++ u32 width,
++ u32 height,
++ u32 key,
++ u32 mask )
++{
++ c64xTask *task = &tasks->tasks[tasks->num_tasks];
++
++ D_ASSERT( tasks->num_tasks < tasks->max_tasks );
++
++ task->c64x_arg[0] = dest;
++ task->c64x_arg[1] = (dpitch << 16) | (spitch & 0xffff);
++ task->c64x_arg[2] = src;
++ task->c64x_arg[3] = width;
++ task->c64x_arg[4] = height;
++ task->c64x_arg[5] = key;
++ task->c64x_arg[6] = mask;
++
++ task->c64x_function = C64X_COPY_KEYED_16 | C64X_FLAG_TODO;
++
++ tasks->num_tasks++;
++}
++
++static inline void
++davinci_c64x_blit_keyed_16( DavinciC64x *c64x,
++ unsigned long dest,
++ u32 dpitch,
++ unsigned long src,
++ u32 spitch,
++ u32 width,
++ u32 height,
++ u32 key,
++ u32 mask )
++{
++ c64xTask *task = c64x_get_task( c64x );
++
++ task->c64x_arg[0] = dest;
++ task->c64x_arg[1] = (dpitch << 16) | (spitch & 0xffff);
++ task->c64x_arg[2] = src;
++ task->c64x_arg[3] = width;
++ task->c64x_arg[4] = height;
++ task->c64x_arg[5] = key;
++ task->c64x_arg[6] = mask;
++
++ task->c64x_function = C64X_COPY_KEYED_16 | C64X_FLAG_TODO;
++
++ c64x_submit_task( c64x, task );
++}
++
++static inline void
++davinci_c64x_blit_keyed_32__L( DavinciC64xTasks *tasks,
++ unsigned long dest,
++ u32 dpitch,
++ unsigned long src,
++ u32 spitch,
++ u32 width,
++ u32 height,
++ u32 key,
++ u32 mask )
++{
++ c64xTask *task = &tasks->tasks[tasks->num_tasks];
++
++ D_ASSERT( tasks->num_tasks < tasks->max_tasks );
++
++ task->c64x_arg[0] = dest;
++ task->c64x_arg[1] = (dpitch << 16) | (spitch & 0xffff);
++ task->c64x_arg[2] = src;
++ task->c64x_arg[3] = width;
++ task->c64x_arg[4] = height;
++ task->c64x_arg[5] = key;
++ task->c64x_arg[6] = mask;
++
++ task->c64x_function = C64X_COPY_KEYED_32 | C64X_FLAG_TODO;
++
++ tasks->num_tasks++;
++}
++
++static inline void
++davinci_c64x_blit_keyed_32( DavinciC64x *c64x,
++ unsigned long dest,
++ u32 dpitch,
++ unsigned long src,
++ u32 spitch,
++ u32 width,
++ u32 height,
++ u32 key,
++ u32 mask )
++{
++ c64xTask *task = c64x_get_task( c64x );
++
++ task->c64x_arg[0] = dest;
++ task->c64x_arg[1] = (dpitch << 16) | (spitch & 0xffff);
++ task->c64x_arg[2] = src;
++ task->c64x_arg[3] = width;
++ task->c64x_arg[4] = height;
++ task->c64x_arg[5] = key;
++ task->c64x_arg[6] = mask;
++
++ task->c64x_function = C64X_COPY_KEYED_32 | C64X_FLAG_TODO;
++
++ c64x_submit_task( c64x, task );
++}
++
++#endif
++
+diff -puNr -Naur directfb-1.6.3-orig/gfxdrivers/davinci/davincifb.h directfb-1.6.3/gfxdrivers/davinci/davincifb.h
+--- directfb-1.6.3-orig/gfxdrivers/davinci/davincifb.h 1970-01-01 01:00:00.000000000 +0100
++++ directfb-1.6.3/gfxdrivers/davinci/davincifb.h 2013-04-07 21:33:21.488622184 +0200
+@@ -0,0 +1,581 @@
++/*
++ * Copyright (C) 2006 Texas Instruments Inc
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option)any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++ *
++ * File: davincifb.h
++ */
++
++#ifndef DAVINVI_VPBE_H
++#define DAVINVI_VPBE_H
++
++/* include Linux files */
++#include <linux/fb.h>
++
++/* define the custom FBIO_WAITFORVSYNC ioctl */
++#define FBIO_WAITFORVSYNC _IOW('F', 0x20, u_int32_t)
++#define FBIO_SETATTRIBUTE _IOW('F', 0x21, struct fb_fillrect)
++
++/* Backported IOCTLS. */
++#define FBIO_SETPOSX _IOW('F', 0x22, u_int32_t)
++#define FBIO_SETPOSY _IOW('F', 0x23, u_int32_t)
++#define FBIO_SETZOOM _IOW('F', 0x24, struct zoom_params)
++#define FBIO_GETSTD _IOR('F', 0x25, u_int32_t)
++#define FBIO_RESIZER _IOW('F', 0x26, struct vpfe_resizer_params)
++#define FBIO_SYNC _IOW('F', 0x27, u_int32_t)
++
++typedef struct zoom_params {
++ u_int32_t window_id;
++ u_int32_t zoom_h;
++ u_int32_t zoom_v;
++} zoom_params_t;
++
++typedef struct vpfe_resizer_params
++{
++ u_int32_t rsz_cnt; //busy-lock
++ u_int32_t out_size; //busy-lock
++ u_int32_t in_start; //busy-lock
++ u_int32_t in_size; //busy-lock
++ u_int32_t sdr_inadd; //shadowed
++ u_int32_t sdr_inoff; //shadowed
++ u_int32_t sdr_outadd; //shadowed
++ u_int32_t sdr_outoff; //shadowed
++ u_int32_t hfilt[16]; //busy-lock
++ u_int32_t vfilt[16]; //busy-lock
++ u_int32_t yenh; //busy-lock
++} vpfe_resizer_params_t;
++
++typedef struct fb_set_start {
++ int offset; /* offset from smem_start */
++ unsigned long physical; /* absolute physical address when offset < 0 */
++
++ u_int64_t sync; /* input: target sync counter for change or 0 for no sync at all,
++ output: sync counter of actual change or 0 if still pending */
++} fb_set_start_t;
++
++
++#ifdef _IOC_TYPECHECK
++#undef _IOC_TYPECHECK
++#define _IOC_TYPECHECK(x) (sizeof(x))
++#endif
++
++#define RAM_CLUT_SIZE 256*3
++#define FBIO_ENABLE_DISABLE_WIN \
++ _IOW('F', 0x30, unsigned char)
++#define FBIO_SET_BITMAP_BLEND_FACTOR \
++ _IOW('F', 0x31, vpbe_bitmap_blend_params_t)
++#define FBIO_SET_BITMAP_WIN_RAM_CLUT \
++ _IOW('F', 0x32, unsigned char)*RAM_CLUT_SIZE)
++#define FBIO_ENABLE_DISABLE_ATTRIBUTE_WIN \
++ _IOW('F', 0x33, unsigned int)
++#define FBIO_GET_BLINK_INTERVAL \
++ _IOR('F', 0x34, vpbe_blink_option_t)
++#define FBIO_SET_BLINK_INTERVAL \
++ _IOW('F', 0x35, vpbe_blink_option_t)
++#define FBIO_GET_VIDEO_CONFIG_PARAMS \
++ _IOR('F', 0x36, vpbe_video_config_params_t)
++#define FBIO_SET_VIDEO_CONFIG_PARAMS \
++ _IOW('F', 0x37, vpbe_video_config_params_t)
++#define FBIO_GET_BITMAP_CONFIG_PARAMS \
++ _IOR('F', 0x38, vpbe_bitmap_config_params_t)
++#define FBIO_SET_BITMAP_CONFIG_PARAMS \
++ _IOW('F', 0x39, vpbe_bitmap_config_params_t)
++#define FBIO_SET_DCLK \
++ _IOW('F', 0x40, vpbe_dclk_t)
++#define FBIO_SET_INTERFACE \
++ _IOW('F', 0x41, unsigned char)
++#define FBIO_GET_INTERFACE \
++ _IOR('F', 0x42, unsigned char)
++#define FBIO_QUERY_TIMING \
++ _IOWR('F', 0x43, struct vpbe_mode_info)
++#define FBIO_SET_TIMING \
++ _IOW('F', 0x44, struct vpbe_fb_videomode)
++#define FBIO_GET_TIMING \
++ _IOR('F', 0x45, struct vpbe_fb_videomode)
++#define FBIO_SET_VENC_CLK_SOURCE \
++ _IOW('F', 0x46, unsigned char)
++#define FBIO_SET_BACKG_COLOR \
++ _IOW('F', 0x47, vpbe_backg_color_t)
++#define FBIO_ENABLE_DISPLAY \
++ _IOW('F', 0x48, unsigned char)
++#define FBIO_SETPOS \
++ _IOW('F', 0x49, u_int32_t)
++#define FBIO_SET_CURSOR \
++ _IOW('F', 0x50, struct fb_cursor)
++#define FBIO_SET_START \
++ _IOW('F', 0x66, struct fb_set_start)
++
++/*
++ * Defines and Constants
++ */
++#ifdef __KERNEL__
++#define DAVINCIFB_DEVICE "davincifb"
++#define DAVINCIFB_DRIVER "davincifb"
++
++#define MULTIPLE_BUFFERING 1
++
++#ifdef MULTIPLE_BUFFERING
++#define DOUBLE_BUF 2
++#define TRIPLE_BUF 3
++#else
++#define DOUBLE_BUF 1
++#define TRIPLE_BUF 1
++#endif
++
++/* usage: if (is_win(info->fix.id, OSD0)) ... */
++#define is_win(name, x) ((strcmp(name, x ## _FBNAME) == 0) ? 1 : 0)
++
++/*
++ * display controller register I/O routines
++ */
++u32 dispc_reg_in(u32 offset);
++u32 dispc_reg_out(u32 offset, u32 val);
++u32 dispc_reg_merge(u32 offset, u32 val, u32 mask);
++
++#endif /*__KERNEL__*/
++
++/* Error return codes */
++#define VPBE_INVALID_PARA_VALUE 700
++#define VPBE_WRONG_WINDOW_ID 701
++#define VPBE_CURRENTLY_IN_REQUIRED_MODE 702
++#define VPBE_INSUFFICIENT_CLUT_VALUES 703
++#define VPBE_CLUT_WRITE_TIMEOUT 704
++#define VPBE_VID0_BUF_ADR_NULL 705
++#define VPBE_WINDOW_NOT_DISABLED 706
++#define VPBE_WINDOW_NOT_ENABLED 707
++
++#ifndef __KERNEL__
++/* Window ID definations */
++#define OSD0 0
++#define VID0 1
++#define OSD1 2
++#define VID1 3
++#endif
++
++/* There are 4 framebuffers, each represented by an fb_info and
++ * a dm_win_info structure */
++#define OSD0_FBNAME "dm_osd0_fb"
++#define OSD1_FBNAME "dm_osd1_fb"
++#define VID0_FBNAME "dm_vid0_fb"
++#define VID1_FBNAME "dm_vid1_fb"
++
++/* FIXME: Digital LCD RGB matrix coefficients */
++#define DLCD_DGY_VAL 0
++#define DLCD_DRV_VAL 0
++#define DLCD_DGU_VAL 0
++#define DLCD_DBU_VAL 0
++
++/* Defines for bitmap format */
++#define VPBE_BITMAP_BIT_1 1
++#define VPBE_BITMAP_BIT_2 2
++#define VPBE_BITMAP_BIT_4 4
++#define VPBE_BITMAP_BIT_8 8
++#define VPBE_BITMAP_RGB565 16
++#define VPBE_VIDEO_YUV422 16
++#define VPBE_VIDEO_RGB888 24
++
++/* Defines foe cursor parameter validation*/
++#define MAX_CURSOR_WIDTH 0x3FF
++#define MAX_CURSOR_HEIGHT 0x1FF
++#define MAX_CURSOR_LINEWIDTH 7
++
++#define BASEX 0x80
++#define BASEY 0x12
++#define BASEX_DLCD 0x59
++#define BASEY_DLCD 0x22
++
++/*
++ * Enumerations
++ */
++/* Enum for blending factor */
++typedef enum vpbe_blend_factor {
++ OSD_CONTRIBUTION_ZERO = 0,
++ OSD_CONTRIBUTION_1_BY_8 = 1,
++ OSD_CONTRIBUTION_2_BY_8 = 2,
++ OSD_CONTRIBUTION_3_BY_8 = 3,
++ OSD_CONTRIBUTION_4_BY_8 = 4,
++ OSD_CONTRIBUTION_5_BY_8 = 5,
++ OSD_CONTRIBUTION_6_BY_8 = 6,
++ OSD_CONTRIBUTION_ONE = 7
++} vpbe_blend_factor_t;
++
++/* Enum for Boolean variables */
++typedef enum {
++ SET_0 = 0,
++ SET_1 = 1
++} CB_CR_ORDER, ATTRIBUTE, ROM_RAM_CLUT;
++
++/* Defines for Display Interface */
++#define PRGB 0
++#define COMPOSITE 1
++#define SVIDEO 2
++#define COMPONENT 3
++#define RGB 4
++#define YCC16 5
++#define YCC8 6
++#define SRGB 7
++#define EPSON 8
++#define CASIO1G 9
++#define UDISP 10
++#define STN 11
++#define VPBE_MAX_INTERFACES 12
++
++/* Defines for Display Mode */
++#define LCD 0
++#define NTSC 1
++#define PAL 2
++#define P525 3
++#define P625 4
++
++#define DEFAULT_MODE 0
++#define P480 0
++#define P400 1
++#define P350 2
++#define NON_EXISTING_MODE 255
++/* Enable/Disable enum */
++typedef enum {
++ VPBE_DISABLE = 0,
++ VPBE_ENABLE = 1
++} ATTENUATION, TRANSPARENCY, EXPANSION, BLINKING;
++
++typedef enum clk_source {
++ CLK_SOURCE_CLK27 = 0,
++ CLK_SOURCE_CLK54 = 1,
++ CLK_SOURCE_VPBECLK = 2
++} CLK_SOURCE;
++
++/*
++ * Structures and Union Definitions
++ */
++
++/* Structure for transparency and the blending factor for the bitmap window */
++typedef struct vpbe_bitmap_blend_params {
++ unsigned int colorkey; /* color key to be blend */
++ unsigned int enable_colorkeying; /* enable color keying */
++ unsigned int bf; /* valid range from 0 to 7 only. */
++} vpbe_bitmap_blend_params_t;
++
++/* Structure for window expansion */
++typedef struct vpbe_win_expansion {
++ EXPANSION horizontal;
++ EXPANSION vertical; /* 1: Enable 0:disable */
++} vpbe_win_expansion_t;
++
++/* Structure for OSD window blinking options */
++typedef struct vpbe_blink_option {
++ BLINKING blinking; /* 1: Enable blinking 0: Disable */
++ unsigned int interval; /* Valid only if blinking is 1 */
++} vpbe_blink_option_t;
++
++/* Structure for DCLK parameters */
++typedef struct vpbe_dclk {
++ unsigned char dclk_pattern_width;
++ unsigned int dclk_pattern0;
++ unsigned int dclk_pattern1;
++ unsigned int dclk_pattern2;
++ unsigned int dclk_pattern3;
++} vpbe_dclk_t;
++
++/* Structure for display format */
++typedef struct vpbe_display_format {
++ unsigned char interface; /* Output interface type */
++ unsigned char mode; /* output mode */
++} vpbe_display_format_t;
++
++/* Structure for background color */
++typedef struct vpbe_backg_color {
++ unsigned char clut_select; /* 2: RAM CLUT 1:ROM1 CLUT 0:ROM0 CLUT */
++ unsigned char color_offset; /* index of color */
++} vpbe_backg_color_t;
++
++/* Structure for Video window configurable parameters */
++typedef struct vpbe_video_config_params {
++ CB_CR_ORDER cb_cr_order; /*Cb/Cr order in input data for a pixel. */
++ /* 0: cb cr 1: cr cb */
++ vpbe_win_expansion_t exp_info; /* HZ/VT Expansion enable disable */
++} vpbe_video_config_params_t;
++
++/*Union of structures giving the CLUT index for the 1, 2, 4 bit bitmap values.*/
++typedef union vpbe_clut_idx {
++ struct _for_4bit_bimap {
++ unsigned char bitmap_val_0;
++ unsigned char bitmap_val_1;
++ unsigned char bitmap_val_2;
++ unsigned char bitmap_val_3;
++ unsigned char bitmap_val_4;
++ unsigned char bitmap_val_5;
++ unsigned char bitmap_val_6;
++ unsigned char bitmap_val_7;
++ unsigned char bitmap_val_8;
++ unsigned char bitmap_val_9;
++ unsigned char bitmap_val_10;
++ unsigned char bitmap_val_11;
++ unsigned char bitmap_val_12;
++ unsigned char bitmap_val_13;
++ unsigned char bitmap_val_14;
++ unsigned char bitmap_val_15;
++ } for_4bit_bimap;
++ struct _for_2bit_bimap {
++ unsigned char bitmap_val_0;
++ unsigned char dummy0[4];
++ unsigned char bitmap_val_1;
++ unsigned char dummy1[4];
++ unsigned char bitmap_val_2;
++ unsigned char dummy2[4];
++ unsigned char bitmap_val_3;
++ } for_2bit_bimap;
++ struct _for_1bit_bimap {
++ unsigned char bitmap_val_0;
++ unsigned char dummy0[14];
++ unsigned char bitmap_val_1;
++ } for_1bit_bimap;
++} vpbe_clut_idx_t;
++
++/* Structure for bitmap window configurable parameters */
++typedef struct vpbe_bitmap_config_params {
++ /* Only for bitmap width = 1,2,4 bits */
++ vpbe_clut_idx_t clut_idx;
++ /* Attenuation value for YUV o/p for bitmap window */
++ unsigned char attenuation_enable;
++ /* 0: ROM DM270, 1:ROM DM320, 2:RAM CLUT */
++ unsigned char clut_select;
++} vpbe_bitmap_config_params_t;
++
++/* Unioun for video/OSD configuration parameters */
++typedef union vpbe_conf_params {
++
++ struct vpbe_video_params {
++ CB_CR_ORDER cb_cr_order;
++ /* HZ/VT Expansion enable disable */
++ vpbe_win_expansion_t exp_info;
++ } video_params;
++
++ struct vpbe_bitmap_params {
++ /* Attenuation value for YUV o/p */
++ ATTENUATION attenuation_enable;
++ /* 0: ROM DM270, 1: ROM DM320, 2:RAM CLUT */
++ unsigned char clut_select;
++ /* Only for bitmap width = 1,2,4 bits */
++ vpbe_clut_idx_t clut_idx;
++ /* 0: OSD window is bitmap window */
++ /* 1: OSD window is attribute window */
++ ATTRIBUTE enable_attribute;
++ /* To hold bps value.
++ Used to switch back from attribute to bitmap. */
++ unsigned int stored_bits_per_pixel;
++ /* Blending information */
++ vpbe_bitmap_blend_params_t blend_info;
++ /* OSD Blinking information */
++ vpbe_blink_option_t blink_info;
++ } bitmap_params;
++
++} vpbe_conf_params_t;
++
++typedef struct vpbe_video_params vpbe_video_params_t;
++typedef struct vpbe_bitmap_params vpbe_bitmap_params_t;
++
++/* Structure to hold window position */
++typedef struct vpbe_window_position {
++ unsigned int xpos; /* X position of the window */
++ unsigned int ypos; /* Y position of the window */
++} vpbe_window_position_t;
++
++#ifdef __KERNEL__
++/* Structure for each window */
++typedef struct vpbe_dm_win_info {
++ struct fb_info info;
++ vpbe_window_position_t win_pos; /* X,Y position of window */
++ /* Size of window is already there in var_info structure. */
++
++ dma_addr_t fb_base_phys; /*framebuffer area */
++ unsigned int fb_base; /*window memory pointer */
++ unsigned int fb_size; /*memory size */
++ unsigned int pseudo_palette[17];
++ int alloc_fb_mem;
++ /*flag to identify if framebuffer area is fixed or not */
++ unsigned long sdram_address;
++ struct vpbe_dm_info *dm;
++ unsigned char window_enable; /*Additions for all windows */
++ zoom_params_t zoom; /*Zooming parameters */
++ unsigned char field_frame_select; /*To select Field or frame */
++ unsigned char numbufs; /*Number of buffers valid 2 or 3 */
++ vpbe_conf_params_t conf_params;
++ /*window configuration parameter union pointer */
++} vpbe_dm_win_info_t;
++#endif /*__KERNEL__*/
++
++/*
++ * Videmode structure for display interface and mode settings
++ */
++typedef struct vpbe_fb_videomode {
++ unsigned char name[10]; /* Mode name ( NTSC , PAL) */
++ unsigned int vmode; /* FB_MODE_INTERLACED or FB_MODE_NON_INTERLACED */
++ unsigned int xres; /* X Resolution of the display */
++ unsigned int yres; /* Y Resolution of the display */
++ unsigned int fps; /* frames per second */
++ /* Timing Parameters applicable for std = 0 only */
++ unsigned int left_margin;
++ unsigned int right_margin;
++ unsigned int upper_margin;
++ unsigned int lower_margin;
++ unsigned int hsync_len;
++ unsigned int vsync_len;
++ unsigned int sync; /* 0: hsync -ve/vsync -ve */
++ /*1: hsync -ve/vsync +ve */
++ /*2: hsync +ve/vsync -ve */
++ /*3: hsync +ve/vsync +ve */
++ unsigned int basepx; /* Display x,y start position */
++ unsigned int basepy;
++/* 1= Mode s available in modelist 0=Mode is not available in modelist */
++ unsigned int std;
++} vpbe_fb_videomode_t;
++
++/* Structure to interface videomode to application*/
++typedef struct vpbe_mode_info {
++ vpbe_fb_videomode_t vid_mode;
++ unsigned char interface;
++ unsigned char mode_idx;
++} vpbe_mode_info_t;
++
++#ifdef __KERNEL__
++/*
++ * Structure for the driver holding information of windows,
++ * memory base addresses etc.
++ */
++typedef struct vpbe_dm_info {
++ vpbe_dm_win_info_t *osd0;
++ vpbe_dm_win_info_t *osd1;
++ vpbe_dm_win_info_t *vid0;
++ vpbe_dm_win_info_t *vid1;
++
++/* to map the registers */
++ dma_addr_t mmio_base_phys;
++ unsigned int mmio_base;
++ unsigned int mmio_size;
++
++ wait_queue_head_t vsync_wait;
++ unsigned int vsync_cnt;
++ int timeout;
++
++ /* this is the function that configures the output device (NTSC/PAL/LCD)
++ * for the required output format (composite/s-video/component/rgb)
++ */
++ void (*output_device_config) (void);
++
++ struct device *dev;
++
++ vpbe_backg_color_t backg; /* background color */
++ vpbe_dclk_t dclk; /*DCLK parameters */
++ vpbe_display_format_t display; /*Display interface and mode */
++ vpbe_fb_videomode_t videomode; /*Cuurent videomode */
++ char ram_clut[256][3]; /*RAM CLUT array */
++ struct fb_cursor cursor; /* cursor config params from fb.h */
++/*Flag that indicates whether any of the display is enabled or not*/
++ int display_enable;
++} vpbe_dm_info_t;
++
++/*
++ * Functions Definitions for 'davincifb' module
++ */
++int vpbe_mem_alloc_window_buf(vpbe_dm_win_info_t *);
++int vpbe_mem_release_window_buf(vpbe_dm_win_info_t *);
++void init_display_function(vpbe_display_format_t *);
++int vpbe_mem_alloc_struct(vpbe_dm_win_info_t **);
++void set_vid0_default_conf(void);
++void set_vid1_default_conf(void);
++void set_osd0_default_conf(void);
++void set_osd1_default_conf(void);
++void set_cursor_default_conf(void);
++void set_dm_default_conf(void);
++void set_win_enable(char *, unsigned int);
++int within_vid0_limits(u32, u32, u32, u32);
++void vpbe_set_display_default(void);
++#ifdef __KERNEL__
++void set_win_position(char *, u32, u32, u32, u32);
++void change_win_param(int);
++void set_interlaced(char *, unsigned int);
++#endif /* __KERNEL__ */
++
++/*
++ * Function definations for 'osd' module
++ */
++
++int vpbe_enable_window(vpbe_dm_win_info_t *);
++int vpbe_disable_window(vpbe_dm_win_info_t *);
++int vpbe_vid_osd_select_field_frame(u8 *, u8);
++int vpbe_bitmap_set_blend_factor(u8 *, vpbe_bitmap_blend_params_t *);
++int vpbe_bitmap_set_ram_clut(void);
++int vpbe_enable_disable_attribute_window(u32);
++int vpbe_get_blinking(u8 *, vpbe_blink_option_t *);
++int vpbe_set_blinking(u8 *, vpbe_blink_option_t *);
++int vpbe_set_vid_params(u8 *, vpbe_video_config_params_t *);
++int vpbe_get_vid_params(u8 *, vpbe_video_config_params_t *);
++int vpbe_bitmap_get_params(u8 *, vpbe_bitmap_config_params_t *);
++int vpbe_bitmap_set_params(u8 *, vpbe_bitmap_config_params_t *);
++int vpbe_set_cursor_params(struct fb_cursor *);
++int vpbe_set_vid_expansion(vpbe_win_expansion_t *);
++int vpbe_set_dclk(vpbe_dclk_t *);
++int vpbe_set_display_format(vpbe_display_format_t *);
++int vpbe_set_backg_color(vpbe_backg_color_t *);
++int vpbe_set_interface(u8);
++int vpbe_query_mode(vpbe_mode_info_t *);
++int vpbe_set_mode(struct vpbe_fb_videomode *);
++int vpbe_set_venc_clk_source(u8);
++void set_vid0_default_conf(void);
++void set_osd0_default_conf(void);
++void set_vid1_default_conf(void);
++void set_osd1_default_conf(void);
++void set_cursor_default_conf(void);
++void set_dm_default_conf(void);
++/*
++ * Function definations for 'venc' module
++ */
++
++void davincifb_ntsc_composite_config(void);
++void davincifb_ntsc_svideo_config(void);
++void davincifb_ntsc_component_config(void);
++void davincifb_pal_composite_config(void);
++void davincifb_pal_svideo_config(void);
++void davincifb_pal_component_config(void);
++
++void vpbe_davincifb_ntsc_rgb_config(void);
++void vpbe_davincifb_pal_rgb_config(void);
++void vpbe_davincifb_525p_component_config(void);
++void vpbe_davincifb_625p_component_config(void);
++
++void vpbe_enable_venc(int);
++void vpbe_enable_dacs(int);
++/*
++ * Function definations for 'dlcd' module
++ */
++void vpbe_davincifb_480p_prgb_config(void);
++void vpbe_davincifb_400p_prgb_config(void);
++void vpbe_davincifb_350p_prgb_config(void);
++void vpbe_set_display_timing(struct vpbe_fb_videomode *);
++
++void vpbe_enable_lcd(int);
++/*
++ * Following functions are not implemented
++ */
++void vpbe_davincifb_default_ycc16_config(void);
++void vpbe_davincifb_default_ycc8_config(void);
++void vpbe_davincifb_default_srgb_config(void);
++void vpbe_davincifb_default_epson_config(void);
++void vpbe_davincifb_default_casio_config(void);
++void vpbe_davincifb_default_UDISP_config(void);
++void vpbe_davincifb_default_STN_config(void);
++#endif /*__KERNEL__*/
++
++#endif /* End of #ifndef DAVINCI_VPBE_H */
+diff -puNr -Naur directfb-1.6.3-orig/gfxdrivers/davinci/davinci_gfxdriver.h directfb-1.6.3/gfxdrivers/davinci/davinci_gfxdriver.h
+--- directfb-1.6.3-orig/gfxdrivers/davinci/davinci_gfxdriver.h 1970-01-01 01:00:00.000000000 +0100
++++ directfb-1.6.3/gfxdrivers/davinci/davinci_gfxdriver.h 2013-04-07 21:33:19.560662133 +0200
+@@ -0,0 +1,169 @@
++/*
++ TI Davinci driver - Graphics Driver
++
++ (c) Copyright 2007 Telio AG
++
++ Written by Denis Oliver Kropp <dok@directfb.org>
++
++ Code is derived from VMWare driver.
++
++ (c) Copyright 2001-2009 The world wide DirectFB Open Source Community (directfb.org)
++ (c) Copyright 2000-2004 Convergence (integrated media) GmbH
++
++ All rights reserved.
++
++ This library is free software; you can redistribute it and/or
++ modify it under the terms of the GNU Lesser General Public
++ License as published by the Free Software Foundation; either
++ version 2 of the License, or (at your option) any later version.
++
++ This library is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++ Lesser General Public License for more details.
++
++ You should have received a copy of the GNU Lesser General Public
++ License along with this library; if not, write to the
++ Free Software Foundation, Inc., 59 Temple Place - Suite 330,
++ Boston, MA 02111-1307, USA.
++*/
++
++#ifndef __DAVINCI_GFXDRIVER_H__
++#define __DAVINCI_GFXDRIVER_H__
++
++#include <sys/ioctl.h>
++#include <davincifb.h>
++
++#include <core/surface_buffer.h>
++
++#include "davincifb.h"
++
++#include "davinci_c64x.h"
++
++
++typedef struct {
++ /* validation flags */
++ int v_flags;
++
++ /* cached/computed values */
++ void *dst_addr;
++ unsigned long dst_phys;
++ unsigned int dst_size;
++ unsigned long dst_pitch;
++ DFBSurfacePixelFormat dst_format;
++ unsigned long dst_bpp;
++
++ void *src_addr;
++ unsigned long src_phys;
++ unsigned long src_pitch;
++ DFBSurfacePixelFormat src_format;
++ unsigned long src_bpp;
++
++ unsigned long source_mult;
++
++ unsigned long fillcolor;
++
++ int blit_blend_sub_function;
++ int draw_blend_sub_function;
++
++ DFBColor color;
++ unsigned long color_argb;
++ unsigned long colorkey;
++
++ DFBSurfaceBlittingFlags blitting_flags;
++
++ DFBRegion clip;
++
++ /** Add shared data here... **/
++ struct fb_fix_screeninfo fix[4];
++
++ CoreSurfacePool *osd_pool;
++ CoreSurfacePool *video_pool;
++
++ bool synced;
++} DavinciDeviceData;
++
++
++typedef struct {
++ int num;
++ int fd;
++ void *mem;
++ int size;
++} DavinciFB;
++
++typedef struct {
++ DavinciDeviceData *ddev;
++
++ CoreDFB *core;
++
++ CoreScreen *screen;
++ CoreLayer *osd;
++ CoreLayer *video;
++
++ DavinciFB fb[4];
++
++ DavinciC64x c64x;
++ bool c64x_present;
++
++ DavinciC64xTasks tasks;
++} DavinciDriverData;
++
++
++static inline DFBResult
++davincifb_pan_display( const DavinciFB *fb,
++ struct fb_var_screeninfo *var,
++ const CoreSurfaceBufferLock *lock,
++ DFBSurfaceFlipFlags flags,
++ int x,
++ int y )
++{
++ int ret;
++
++ if (lock) {
++#ifdef FBIO_SET_START
++ CoreSurfaceBuffer *buffer = lock->buffer;
++ struct fb_set_start set_start;
++
++ /* physical mode */
++ set_start.offset = -1;
++ set_start.sync = (flags & DSFLIP_ONSYNC) ? 1 : 0;
++
++ /* life's so easy */
++ set_start.physical = lock->phys + DFB_BYTES_PER_LINE( buffer->format, x ) + y * lock->pitch;
++
++ ret = ioctl( fb->fd, FBIO_SET_START, &set_start );
++ if (ret < 0)
++ D_DEBUG( "FBIO_SET_START (0x%08lx, sync %llu) failed!\n",
++ set_start.physical, set_start.sync );
++
++ if (ret == 0) {
++ if (flags & DSFLIP_WAIT)
++ ioctl( fb->fd, FBIO_WAITFORVSYNC );
++
++ return DFB_OK;
++ }
++
++ /* fallback */
++#endif
++ var->xoffset = x; /* poor version */
++ var->yoffset = y + lock->offset / lock->pitch;
++ }
++ else {
++ var->xoffset = x;
++ var->yoffset = y;
++ }
++
++ var->activate = /*(flags & DSFLIP_ONSYNC) ? FB_ACTIVATE_VBL :*/ FB_ACTIVATE_NOW;
++
++ ret = ioctl( fb->fd, FBIOPAN_DISPLAY, var );
++ if (ret)
++ D_PERROR( "Davinci/FB: FBIOPAN_DISPLAY (fb%d - %d,%d) failed!\n",
++ fb->num, var->xoffset, var->yoffset );
++
++ if (flags & DSFLIP_WAIT)
++ ioctl( fb->fd, FBIO_WAITFORVSYNC );
++
++ return DFB_OK;
++}
++
++#endif
+diff -puNr -Naur directfb-1.6.3-orig/tests/voodoo/voodoo_test.h directfb-1.6.3/tests/voodoo/voodoo_test.h
+--- directfb-1.6.3-orig/tests/voodoo/voodoo_test.h 1970-01-01 01:00:00.000000000 +0100
++++ directfb-1.6.3/tests/voodoo/voodoo_test.h 2013-04-07 21:33:31.824408024 +0200
+@@ -0,0 +1,10 @@
++#ifndef __VOODOO_TEST_H__
++#define __VOODOO_TEST_H__
++
++typedef enum {
++ VOODOO_TEST_INCREASE,
++ VOODOO_TEST_QUERY
++} VoodooTestCall;
++
++#endif
++
diff --git a/package/directfb/directfb-imlib2-config.patch b/package/directfb/directfb-imlib2-config.patch
new file mode 100644
index 0000000..1203475
--- /dev/null
+++ b/package/directfb/directfb-imlib2-config.patch
@@ -0,0 +1,21 @@
+Call the imlib2-conf variable that are set by ac_cv_path_IMLIB2_CONFIG
+with the absolute path because the imlib2-config file is not covered
+by the PATH variable.
+This is important for cross compiler that need to get the staging settings
+instead of the host settings.
+
+Signed-off-by: Carsten Schoenert <c.schoenert@gmail.com>
+
+--- directfb-1.6.3/configure.orig 2013-03-31 13:18:22.837560379 +0200
++++ directfb-1.6.3/configure 2013-03-31 13:23:40.177541099 +0200
+@@ -19816,8 +19816,8 @@ fi
+ $as_echo "$as_me: WARNING: *** Imlib2 library not found, building without Imlib2 support ***" >&2;}
+ imlib2="no"
+ else
+- IMLIB2_CFLAGS=`imlib2-config --cflags`
+- IMLIB2_LIBS=`imlib2-config --libs`
++ IMLIB2_CFLAGS=`$IMLIB2_CONFIG --cflags`
++ IMLIB2_LIBS=`$IMLIB2_CONFIG --libs`
+ imlib2="yes"
+ fi
+ fi
diff --git a/package/directfb/directfb-setregion-lock.patch b/package/directfb/directfb-setregion-lock.patch
new file mode 100644
index 0000000..8a246ea
--- /dev/null
+++ b/package/directfb/directfb-setregion-lock.patch
@@ -0,0 +1,92 @@
+This patch fixes builderrors while using '--with-gfxdrivers' and
+'--with-inputdrivers' with the current DirectFB version 1.6.3.
+
+Patch is taken from
+http://sources.gentoo.org/cgi-bin/viewvc.cgi/gentoo-x86/dev-libs/DirectFB/files/DirectFB-1.6.3-setregion.patch
+
+Signed-off-by: Carsten Schoenert <c.schoenert@gmail.com>
+
+--- directfb-1.6.3/gfxdrivers/cyber5k/cyber5k.c
++++ directfb-1.6.3/gfxdrivers/cyber5k/cyber5k.c
+@@ -636,7 +636,8 @@ osdSetRegion( CoreLayer
+ CoreLayerRegionConfigFlags updated,
+ CoreSurface *surface,
+ CorePalette *palette,
+- CoreSurfaceBufferLock *lock )
++ CoreSurfaceBufferLock *left_lock,
++ CoreSurfaceBufferLock *right_lock )
+ {
+ DFBResult ret;
+
+@@ -644,7 +645,7 @@ osdSetRegion( CoreLayer
+ ret = oldPrimaryFuncs.SetRegion( layer, oldPrimaryDriverData,
+ layer_data, region_data,
+ config, updated, surface,
+- palette, lock );
++ palette, left_lock, right_lock );
+ if (ret)
+ return ret;
+
+--- directfb-1.6.3/gfxdrivers/radeon/radeon_crtc1.c
++++ directfb-1.6.3/gfxdrivers/radeon/radeon_crtc1.c
+@@ -147,14 +147,15 @@ crtc1SetRegion( CoreLayer
+ CoreLayerRegionConfigFlags updated,
+ CoreSurface *surface,
+ CorePalette *palette,
+- CoreSurfaceBufferLock *lock )
++ CoreSurfaceBufferLock *left_lock,
++ CoreSurfaceBufferLock *right_lock )
+ {
+
+ if (updated & ~CLRCF_OPTIONS) {
+ return OldPrimaryLayerFuncs.SetRegion( layer,
+ OldPrimaryLayerDriverData,
+ layer_data, region_data,
+- config, updated, surface, palette, lock );
++ config, updated, surface, palette, left_lock, right_lock );
+ }
+
+ return DFB_OK;
+--- directfb-1.6.3/gfxdrivers/cle266/uc_primary.c
++++ directfb-1.6.3/gfxdrivers/cle266/uc_primary.c
+@@ -138,7 +138,8 @@ osdSetRegion( CoreLayer
+ CoreLayerRegionConfigFlags updated,
+ CoreSurface *surface,
+ CorePalette *palette,
+- CoreSurfaceBufferLock *lock )
++ CoreSurfaceBufferLock *left_lock,
++ CoreSurfaceBufferLock *right_lock )
+ {
+ DFBResult ret;
+ UcDriverData *ucdrv = (UcDriverData*) driver_data;
+@@ -147,7 +148,7 @@ osdSetRegion( CoreLayer
+ ret = ucOldPrimaryFuncs.SetRegion( layer, ucOldPrimaryDriverData,
+ layer_data, region_data,
+ config, updated, surface,
+- palette, lock );
++ palette, left_lock, right_lock );
+ if (ret)
+ return ret;
+
+--- directfb-1.6.3/gfxdrivers/unichrome/uc_primary.c
++++ directfb-1.6.3/gfxdrivers/unichrome/uc_primary.c
+@@ -135,7 +135,8 @@ osdSetRegion( CoreLayer
+ CoreLayerRegionConfigFlags updated,
+ CoreSurface *surface,
+ CorePalette *palette,
+- CoreSurfaceBufferLock *lock )
++ CoreSurfaceBufferLock *left_lock,
++ CoreSurfaceBufferLock *right_lock )
+ {
+ DFBResult ret;
+ UcDriverData *ucdrv = (UcDriverData*) driver_data;
+@@ -144,7 +145,7 @@ osdSetRegion( CoreLayer
+ ret = ucOldPrimaryFuncs.SetRegion( layer, ucOldPrimaryDriverData,
+ layer_data, region_data,
+ config, updated, surface,
+- palette, lock );
++ palette, left_lock, right_lock );
+ if (ret)
+ return ret;
+
+