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>

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 000000000..6ad4958f8
--- /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 000000000..1203475b3
--- /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 000000000..8a246ea05
--- /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;
+ 
+