Merge bk://oe-devel.bkbits.net/openembedded

into  bkbits.net:/repos/n/nslu2-linux/openembedded

2005/06/18 17:25:59+02:00 uni-frankfurt.de!mickeyl
qte-2.3.10: bump revision

2005/06/18 17:24:52+02:00 uni-frankfurt.de!mickeyl
qte-2.3.10: update w100 patch. this version fixes the synchronization between software pixmaps and hardware rects as well as polyline accelleration. Patch courtesy Manuel Teira - thanks a lot.

2005/06/18 16:59:49+02:00 uni-frankfurt.de!mickeyl
Merge bk://oe-devel@oe-devel.bkbits.net/openembedded
into r2d2.tm.informatik.uni-frankfurt.de:/local/pkg/oe/packages

2005/06/18 00:31:37+02:00 uni-frankfurt.de!mickeyl
Merge bk://oe-devel@oe-devel.bkbits.net/openembedded
into r2d2.tm.informatik.uni-frankfurt.de:/local/pkg/oe/packages

2005/06/17 23:56:33+02:00 uni-frankfurt.de!mickeyl
Merge bk://oe-devel@oe-devel.bkbits.net/openembedded
into r2d2.tm.informatik.uni-frankfurt.de:/local/pkg/oe/packages

2005/06/17 21:09:22+02:00 uni-frankfurt.de!mickeyl
Merge bk://oe-devel@oe-devel.bkbits.net/openembedded
into r2d2.tm.informatik.uni-frankfurt.de:/local/pkg/oe/packages

2005/06/17 17:36:14+02:00 uni-frankfurt.de!mickeyl
add gtk2-port of the soundtracker, an AMIGA style module tracker program

BKrev: 42b44059pl_pr2jlFu8jPzCdKIgEfQ

1 files changed, 2108 insertions, 0 deletions

diff --git a/packages/qte/qte-2.3.10/c7x0-w100-accel.patch b/packages/qte/qte-2.3.10/c7x0-w100-accel.patch
index e69de29bb2..5cff74623a 100644
--- a/packages/qte/qte-2.3.10/c7x0-w100-accel.patch
+++ b/packages/qte/qte-2.3.10/c7x0-w100-accel.patch
@@ -0,0 +1,2108 @@
+ATI IMAGEON (W100) Accelerated support
+Manuel Teira <manuel.teira@telefonica.net>
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+--- qt-2.3.10/configure~w100
++++ qt-2.3.10/configure
+@@ -325,6 +325,9 @@
+    -accel-matrox)
+ 	QWS_ACCEL_MATROX=y
+ 	;;
++   -accel-w100)
++	QWS_ACCEL_W100=y
++	;;
+    -qvfb)
+ 	QWS_QVFB=y
+ 	;;
+@@ -726,6 +729,10 @@
+ then
+     QT_CXX="$QT_CXX -DQT_NO_QWS_MATROX"
+ fi
++if [ -z "$QWS_ACCEL_W100" -a -n "$EMB" ]
++then
++    QT_CXX="$QT_CXX -DQT_NO_QWS_W100"
++fi
+ if [ -z "$QWS_VNC" -a -n "$EMB" ]
+ then
+     QT_CXX="$QT_CXX -DQT_NO_QWS_VNC"
+@@ -1338,6 +1345,7 @@
+     -accel-voodoo3 ..... Enable Voodoo3 acceleration.
+     -accel-mach64 ...... Enable Mach64 acceleration.
+     -accel-matrox ...... Enable Matrox MGA acceleration.
++    -accel-w100 ........ Enable ATI Imageon w100 acceleration (experimental).
+     -qvfb .............. Enable X11-based Qt Virtual Frame Buffer.
+     -vnc ............... Enable VNC server (requires network module).
+ 
+@@ -1462,6 +1470,7 @@
+ [ "x$JPEG" = "xyes" ] && QT_LIBS="${QT_LIBS} -ljpeg"
+ [ "x$MNG" = "xyes" ] && QT_LIBS="${QT_LIBS} -lmng -ljpeg" # assume JNG support
+ [ "x$NAS_SOUND" = "xyes" ] && QT_LIBS="${QT_LIBS} -laudio -lXt" # Xt junk in audio library
++[ "x$QWS_ACCEL_W100" = "xy" ] && QT_LIBS="${QT_LIBS} -laticore" # Aticore W100 support
+ QT_LIBS="$L_FLAGS $R_FLAGS $QT_LIBS $l_FLAGS"
+ 
+ 
+--- qt-2.3.10/src/kernel/qgfxraster_qws.cpp~w100
++++ qt-2.3.10/src/kernel/qgfxraster_qws.cpp
+@@ -5945,6 +5945,10 @@
+ # include "qgfxmatrox_qws.cpp"
+ #endif
+ 
++#if !defined(QT_NO_QWS_W100)
++# include "qgfxw100_qws.cpp"
++#endif
++
+ #if !defined(QT_NO_QWS_VFB)
+ # include "qgfxvfb_qws.cpp"
+ #endif
+@@ -5999,6 +6003,9 @@
+ #if !defined(QT_NO_QWS_MATROX)
+     { "Matrox", qt_get_screen_matrox, 1 },
+ #endif
++#if !defined(QT_NO_QWS_W100)
++    { "W100", qt_get_screen_w100, 1 },
++#endif
+ #if !defined(QT_NO_QWS_TRANSFORMED)
+     { "Transformed", qt_get_screen_transformed, 0 },
+ #endif
+--- /dev/null
++++ qt-2.3.10/src/3rdparty/kernel/aticore/aticore.h
+@@ -0,0 +1,567 @@
++/*
++ * AtiCore 2D acceleration API
++ *
++ */
++
++#include <inttypes.h>
++#include <sys/types.h>
++
++#ifndef __W100API_H__
++#define __W100API_H__
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#define SolidRop_GXclear	0x00	/* 0 */
++#define SolidRop_GXand		0xa0	/* src AND dst */
++#define	SolidRop_GXandReverse	0x50	/* src AND NOT dst */
++#define	SolidRop_GXcopy		0xf0	/* src */
++#define SolidRop_GXandInverted	0x0a	/* NOT src AND dst */
++#define	SolidRop_GXnoop		0xaa	/* dst */
++#define	SolidRop_GXxor		0x5a	/* src XOR dst */
++#define	SolidRop_GXor		0xfa	/* src OR dst */
++#define	SolidRop_GXnor		0x05	/* NOT src AND NOT dst */
++#define	SolidRop_GXequiv	0xa5	/* NOT src XOR dst */
++#define	SolidRop_GXinvert	0x55	/* NOT dst */
++#define	SolidRop_GXorReverse	0xf5	/* src OR NOT dst */
++#define	SolidRop_GXcopyInverted	0x0f	/* NOT src */
++#define	SolidRop_GXorInverted	0xaf	/* NOT src OR dst */
++#define	SolidRop_GXnand		0x5f	/* NOT src OR NOT dst */
++#define	SolidRop_GXset		0xff	/* 1 */
++
++#define	BltRop_GXclear		0x00	/* 0 */
++#define	BltRop_GXand		0x88	/* src AND dst */
++#define	BltRop_GXandReverse	0x44	/* src AND NOT dst */
++#define	BltRop_GXcopy		0xcc	/* src */
++#define	BltRop_GXandInverted	0x22	/* NOT src AND dst */
++#define	BltRop_GXnoop		0xaa	/* dst */
++#define	BltRop_GXxor		0x66	/* src XOR dst */
++#define	BltRop_GXor		0xee	/* src OR dst */
++#define	BltRop_GXnor		0x11	/* NOT src AND NOT dst */
++#define	BltRop_GXequiv		0x99	/* NOT src XOR dst */
++#define	BltRop_GXinvert		0x55	/* NOT dst */
++#define	BltRop_GXorReverse	0xdd	/* src OR NOT dst */
++#define	BltRop_GXcopyInverted	0x33	/* NOT src */
++#define	BltRop_GXorInverted	0xbb	/* NOT src OR dst */
++#define	BltRop_GXnand		0x77	/* NOT src OR NOT dst */
++#define	BltRop_GXset		0xff	/* 1 */
++
++#define DSTTYPE_8BPP            2   //8bpp
++#define DSTTYPE_16BPP_1555	3   //16 bpp aRGB 1555
++#define DSTTYPE_16BPP_444	5   //16 bpp aRGB 4444
++
++#define SRCTYPE_1BPP_OPA        0       //mono (expanded to frgd, bkgd)
++#define SRCTYPE_1BPP_TRA        1       //mono (expanded to frgd, leave_alone)
++#define SRCTYPE_EQU_DST         3       //color (same as DST)
++#define SRCTYPE_SOLID_COLOR_BLT 4       //solid color for Blt (use frgd)
++#define SRCTYPE_4BPP            5       //4 bpp
++#define SRCTYPE_12BPP_PACKED    6       //12 bpp packed
++  
++#define ROP3_SRCCOPY		0xcc
++#define ROP3_PATCOPY		0xf0
++  
++#define OVLTYPE_YUV420          7
++#define OVLTYPE_RGB565          8
++
++#define DP_BRUSH_8x8MONOOPA     0 //8x8 mono pattern (expanded to frgd, bkgd )
++#define DP_BRUSH_8x8MONOTRA     1 //8x8 mono pattern (expanded to frgd, leave alone )
++#define DP_PEN_32x1MONOOPA      6 //32x1 mono pattern (expanded to frgd, bkgd)
++#define DP_PEN_32x1MONOTRA      7 //32x1 mono pattern (expanded to frgd, leave alone)
++#define DP_BRUSH_8x8COLOR       10 //8x8 color pattern
++#define DP_BRUSH_SOLIDCOLOR     13 //solid color pattern (frgd)
++#define DB_BRUSH_NONE           15 //No brush used
++
++  typedef struct {
++    int16_t XCoord;
++    int16_t YCoord;
++  } ATI_POINT;
++  
++  typedef struct {
++    int16_t XCoord;
++    int16_t YCoord;
++    int16_t Width;
++    int16_t Height;
++  } ATI_RECT;
++  
++  typedef struct {
++    int16_t X_Top_Left;                  // x coordinate of top left corner
++    int16_t Y_Top_Left;                  // y coordinate of top left corner
++    int16_t X_Bottom_Right;              // x coordinate of bottom right corner
++    int16_t Y_Bottom_Right;              // y coordinate of bottom right corner
++  } ATI_CLIPRECT;
++  
++  typedef struct {
++    uint32_t Count; 
++    uint8_t ScaleXFactor;
++    uint8_t ScaleYFactor;
++    uint8_t BlendOn;
++    uint8_t dummy1;
++  } ATI_STRETCH;
++  
++  typedef struct {
++    uint32_t *lpSrcBitmap;                /* サーフェスのオフセット */
++    uint16_t XCoord;                      /* +4  確定:サーフェス内のx座標 */
++    uint16_t YCoord;                      /* +6  確定:サーフェス内のy座標 */
++    uint16_t SrcPitch;                    /* +8  確定: */
++    uint16_t SrcHeight;                   /* +10 確定: */
++    uint16_t OverlayWidth;                /* オーバレイの幅(Srcと違う値にしても、動的に拡大縮小されたりはしない、意味あんの？) */
++    uint16_t OverlayHeight;
++    uint32_t lpOverlayKey;                /* +16 確定:謎(カラーキー？) */
++    uint8_t OverlayFormat;               /* +20 確定 */
++    uint8_t dummy1;
++    uint16_t dummy2;
++  } ATI_OVERLAYPROP;                      /* 24bytes? */
++  
++  typedef struct {
++    int HInvert;
++    int VInvert;
++  } ATI_EXTVIDEOPROP;
++  
++  typedef struct {
++    ATI_EXTVIDEOPROP ExtVideoProp;
++  } ATI_UNKNOWN1;
++  
++  typedef struct {
++    unsigned long clr_cmp_fcn_src   :3;
++    unsigned long                   :5;
++    unsigned long clr_cmp_fcn_dst   :3;
++    unsigned long                   :13;
++    unsigned long clr_cmp_src       :2;
++    unsigned long                   :6;
++  } clr_cmp_cntl_t;
++
++  typedef struct {
++    uint16_t x;
++    uint16_t y;
++    uint16_t w;
++    uint16_t h;
++    clr_cmp_cntl_t cmp_cntl;
++    unsigned long tcolour;
++  } transbitblt_t;
++
++  typedef struct {
++    uint32_t dummy1;
++    uint32_t dummy2;
++    uint8_t HExpansion;                   /* +8  確定 */
++    uint8_t VExpansion;                   /* +9  確定 */
++    uint8_t dummy3;
++    uint8_t dummy4;
++    uint8_t RConversion;                  /* +12 確定 */
++    uint8_t dummy5;
++    uint8_t dummy6;
++    uint8_t dummy7;
++    ATI_UNKNOWN1 x;
++  } ATI_EXTENDEDOVERLAYPROP;              /* 16byte? */
++  
++  /**
++   * AtiCore initialization.
++   * Sets up the shared memory area
++   * @return 1:success, 0:fail
++   */
++  int AtiCore_ProcessAttach( void );
++  
++  /**
++   * AtiCore finish.
++   *
++   * @return 1:success, 0:fail
++   */
++  int AtiCore_ProcessDetach( void );
++  
++  /**
++   * Allocates a surface on the internal RAM.
++   * Perhaps there's a way to indicate to allocate on the 
++   * internal RAM?
++   * @arg handle Reference to the returned surface handle
++   * @arg offset Returned offset of this surface on the video memory
++   * @arg size   Size (bytes) to be reserved (16 multiple)
++   * @arg direction 
++   * @return 1:success, 0:fail
++   */
++  int AtiCore_AllocateSurface( uint16_t *handle, uint32_t *offset,
++			       uint32_t size, uint32_t direction );
++  
++  /**
++   * Deallocates a given surface.
++   * @arg handle Handle to the allocated surface 
++   * (As returned by AllocateSurface)
++   * @return 1:success, 0:fail
++   */
++  int AtiCore_DestroySurface( uint16_t handle );
++
++  /**
++   * Sets the kind of Raster Operation.
++   * @param rop Raster operation to be performed
++   * @return 1:success, 0:fail
++   */
++  int AtiCore_SetRopOperation( uint32_t rop );
++  
++  /**
++   * Sets the destination type for raster operation.
++   * @param dsttype
++   * @return 1:success, 0:fail
++   */
++  int AtiCore_SetDstType( uint32_t dsttype );
++  
++  /**
++   * Sets the source type for raster operation.
++   * @param srctype
++   * @return 1:success, 0:fail
++   */
++  int AtiCore_SetSrcType( uint32_t srctype );
++  
++  /**
++   * Sets Source clipping rectangle.
++   * @param cliprect Rectangle to perform clipping.
++   * @return 1:success, 0:fail
++   */ 
++  int AtiCore_SetSrcClippingRect( ATI_CLIPRECT *cliprect );
++  
++  /**
++   * Sets Destination clipping rectangle.
++   * @param cliprect Rectangle to perform clipping.
++   * @return 1:success, 0:fail
++   */ 
++  int AtiCore_SetDstClippingRect(ATI_CLIPRECT *cliprect);
++  
++  /**
++   * Sets pitch and offset for source in a raster operation.
++   * @param pitch Pitch (line width) of source
++   * @param offset Offset of source
++   * @return 1:success, 0:fail
++   */
++  int AtiCore_SetSrcPitchOffset( int pitch, int offset );
++  
++  /**
++   * Sets pitch and offset destination source in a raster operation.
++   * @param pitch Pitch (line width) of destination
++   * @param offset Offset of destination (memory offset)
++   * @return 1:success, 0:fail
++   */
++  int AtiCore_SetDstPitchOffset( int pitch, int offset );
++  
++  /**
++   * Performs a BitBlt with source rotation.
++   * @param flags Rotation degree
++   * @param dstRect Rectangle for destination Bitblitting
++   * @param srcRect Rectangle for origin bitblitting
++   * @test Tested with specified flags parameter
++   */
++  int AtiCore_BitBltFilpRotate( int flags,
++				ATI_RECT *dstRect, 
++				ATI_RECT *srcRect);
++  
++  /**
++   * Performs a BitBlt with source stretching.
++   * @param option Unknown
++   * @param point Unknown
++   * @param srcRect Source blitting surface
++   * @test Untested
++   */
++  int AtiCore_StretchBlt( ATI_STRETCH *option,
++			  ATI_POINT *point, 
++			  ATI_RECT *srcRect);
++  
++  /**
++   * Waits for the FIFO to be idle at least msecs.
++   * @param msecs Maximum time to wait for FIFO to idle
++   * @return 1:success, 0:fail
++   * @test Untested
++   */
++  int AtiCore_WaitComplete( int msec );
++
++  /**
++   * Allocates a new overlay handle.
++   * @param   handle overlay
++   * @return  1:success, 0:fail
++   * @test Yes
++   */
++  int AtiCore_AllocOverlay( uint16_t *handle );
++
++  /**
++   * Deallocates a overlay handle.
++   * @param  handle overlay
++   * @return 1:success, 0:fail
++   * @test Yes
++   */
++  int AtiCore_ReleaseOverlay( uint16_t handle );
++
++  /**
++   * Sets up an overlay given a handle an a set of properties.
++   * @param handle Allocated handle to setup the overlay.
++   * @param props Overlay properties struct
++   * @return 1:success, 0:fail
++   */
++  int AtiCore_SetupOverlay( uint16_t handle, ATI_OVERLAYPROP *props );
++
++  /**
++   * Sets up extended overlay features.
++   * @param handle Allocated handle to an overlay
++   * @param props Extended overlay properties
++   * @return 1:success, 0:fail
++   */
++  int AtiCore_SetupOverlayExtended( uint16_t handle, 
++				    ATI_EXTENDEDOVERLAYPROP *props );
++
++  /**
++   * Enable/Disable an overlayed surface.
++   * @param   handle Overlay to be enabled/disabled
++   * @param   enable 1: Enable, 0: Disable
++   * @return  1:success, 0:fail
++   * @test Tested
++   */
++  int AtiCore_SetOverlayOnOff( uint16_t handle, int enable );
++
++  /**
++   * Sets up the overlay position for a given handle.
++   * @param handle Overlay Handle
++   * @param x X Coordinate (Seems to be a bug with x < 4 )
++   * @param y Y Coordinate
++   * @return 1:success, 0:fail
++   */
++  int AtiCore_SetOverlayPos( uint16_t handle, 
++			     uint16_t x, 
++			     uint16_t y );
++
++  /**
++   * Translates between physical/virtual addresses.
++   * @param offset VRAM offset to be translated
++   * @param viraddr Virtual address for VRAM
++   * @return 1:success,0:fail
++   */
++  int AtiCore_SetupMemoryTransfer( uint32_t offset, 
++				   uint32_t *viraddr );
++
++  /**
++   * Related with the previous one. It seems to be necesary to be called
++   * but I'm not sure of its function.
++   * @return 1:success, 0:fail
++   */
++  int AtiCore_TerminateMemoryTransfer( void );
++
++  /**
++   * Returns the frontbuffer pitch and offset.
++   * @param pitch Return value for the frontbuffer pitch (width)
++   * @param offset Return value for the frontbuffer offset
++   * @return 1:success, 0:fail
++   */
++  int AtiCore_GetFrontBufferPitchOffset( uint32_t *pitch, 
++					 uint32_t *offset );
++
++  /**
++   * Changes display brighness ?
++   * @param  brightness  -64...63
++   * @return 1:success, 0:fail
++   */
++  int AtiCore_SetDisplayBrightness( int brightness );
++
++  /**
++   * Returns the amount of available internal/external memory.
++   * @param  internal Pointer to return internal memory size
++   * @param  external Pointer to return external memory size
++   * @return 1:success, 0:fail
++   */
++  int GetAvailableVideoMem( uint32_t *internal, 
++			    uint32_t *external );
++
++/**
++ *
++ * 
++ *
++ 
++ {
++    (uint32_t) 0
++    (uint32_t) 0
++    (uint16_t) 480
++    (uint16_t) 640
++    (uint16_t) 480
++    (uint16_t) 640
++    (uint32_t) 5
++ */
++
++  typedef struct {
++    uint32_t	dummy1;
++    ATI_RECT	Size;
++    uint16_t	Width;
++    uint16_t	Height;
++    uint32_t	Flag;
++  } ATI_GRAPHICWINDOW;
++ 
++ int AtiCore_SetupGraphicWindow(void* );
++
++  /**
++   * It seems to be necessary after AtiCore_ProcessAttach
++   * @param mode: 0xaaab for portrait, 0xaaaa for landscape
++   * @return 1:success, 0:fail
++   */
++  int AtiCore_ProcessAttachSpecialMode( int mode );
++
++  /**
++   * Sets up the position of the Graphic viewport ?
++   * @param x X coordinate
++   * @param y Y coordinate
++   * @return 1:success, 0:fail
++   */
++  int AtiCore_SetGraphicWindowPos( int x, int y );
++
++  /**
++   * Get the graphic viewport position.
++   * @param x Pointer to xcoord placeholder
++   * @param y Pointer to ycoord placeholder
++   * @return 1:success, 0:fail
++   */
++  int AtiCore_GetGraphicWindowPos( int *x, int *y );
++
++  /**
++   * Sets up the frontbuffer position.
++   * @param offset VRAM offset to be used.
++   * @param x X Coordinate?
++   * @param y Y Coordinate?
++   * @return 1:success, 0:fail
++   */
++  int AtiCore_SetFrontBuffer( int offset, int x, int y );
++
++  /**
++   * Enable/Disable the frontbuffer?
++   * @param enable 1 enables/ 0 disables
++   * @return 1:success, 0:fail
++   */
++  int AtiCore_SetGraphicWindowOnOff( int enable );
++
++  /*
++   * Sets the foreground color.
++   * @param colour Color in 565 format (perhaps depends on the source format)
++   * @return 1:success, 0:fail
++   */
++  int AtiCore_SetFrgColour( int colour );
++
++  /*
++   * Sets the background colour.
++   * @param colour Colour in 565 format (perhaps depends on the source format)
++   * @return 1:success, 0:fail
++   */
++  int AtiCore_SetBkgColour( int colour );
++  
++  /**
++   * Changes the painting brush
++   * @param btype Type of brush to use
++   *        4: Uses the pattern
++   *        6: SolidLine
++   * @param pattern Pointer to a 32 bit pattern
++   * @return 1:success, 0:fail
++   * @test Some values for btype produces a kind of antialiasing line
++   */
++  int AtiCore_BrushType( int btype, unsigned int *pattern );
++
++  /**
++   * Performs a rectangle paint.
++   * @param nrects Number of rectangles to be painted
++   * @param rects Array of rectangles to be painted
++   * @return 1:success, 0:fail
++   * @test Tested with nrects==1
++   */
++  int AtiCore_PaintRect( int nrects , 
++			 ATI_RECT rects[] );
++
++  /**
++   * Draws a set of lines.
++   * @param npoints Number of points in the polyline set
++   * @param points  Pointer to an array of ATI_POINT
++   * @return 1:success, 0:fail
++   */
++  int AtiCore_Polyline( int npoints, ATI_POINT points[] );
++
++  int AtiCore_GetPitchOffsetProperty( void *, void *);
++
++  int AtiCore_CursorOnOff( int, int );
++
++  /**
++   * Performs a BitBlt ROP operation.
++   * @param unk Unknown (Always set to 1)
++   * @param dstrect Bounding destination rect
++   * @param srcrect Bounding source rect
++   * @return 1:success, 0:fail
++   */
++  int AtiCore_BitBlt( int unk, 
++		      ATI_RECT *dstrect, 
++		      ATI_RECT *srcrect );
++
++  /**
++   * Performs a Transparent BitBlt ROP operation.
++   * @param dstrect Transparent DstRect bitblt argument
++   * @param srcrect Transparent SrcRect bitblt argument
++   * @return 1:success, 0:fail
++   * @test Doesn't work. It sets to zero CLR_CMP_CNTL and CLR_CMP_MSK
++   */
++  int AtiCore_TransBitBlt( transbitblt_t *dstrect,
++			   transbitblt_t *srcrect );
++
++  int AtiCore_WakeUpCall( void );
++
++  /**
++   * Draws a set of pixels
++   * @param npoints Number of points to draw
++   * @param points Pointer to an array of ATI_POINT
++   * @return 1:success, 0:fail
++   */
++  int AtiCore_DrawPixel( int npoints, ATI_POINT *points );
++
++  int AtiCore_SetSysClk( unsigned short in0 );
++  int AtiCore_SetFastSysClk( unsigned short in0 );
++  int AtiCore_SetSlowSysClk( unsigned short in0 );
++
++  int AtiCore_GetCursorPos( unsigned long in0,
++			    unsigned short *x,
++			    unsigned short *y );
++  
++
++
++/* ================================================================ */
++/* from libqte.so.2.3.2 */
++/*
++AtiCore_AlphaBlend
++
++AtiCore_Flush
++AtiCore_GammaCorrection
++AtiCore_GetCRC
++AtiCore_GetCursorPos
++AtiCore_GetDeviceInfo
++AtiCore_GetGPIO_Data
++AtiCore_GetGraphicExtended
++AtiCore_GetGraphicWindowPos
++AtiCore_GetLargestVideoMemBlock
++AtiCore_GetLastError
++AtiCore_GetMultiCRC
++AtiCore_GetOverlayPos
++AtiCore_Host
++AtiCore_LoadCursorBitMap
++AtiCore_PolyScanline
++AtiCore_ProcessAttachMinimal(void)?
++AtiCore_ProcessDetachMinimal(void)?
++AtiCore_ProcessDetachSpecialMode
++AtiCore_ReadCfgReg
++AtiCore_ReadMem(int, int)?
++AtiCore_ReadReg(int, int)?
++AtiCore_ScanlineShading
++AtiCore_SetApertures
++AtiCore_SetBytePixelOrder
++AtiCore_SetCursorPos
++AtiCore_SetDisplayParameters
++AtiCore_SetDriverBehaviour
++AtiCore_SetGPIO_Data
++AtiCore_SetOverlayPosUsingGraphicWindowXY
++AtiCore_SetPartialCursor
++AtiCore_SetupGraphicExtended
++AtiCore_SetupPM4
++AtiCore_SmallText
++AtiCore_SubmitPM4Packet
++AtiCore_WriteCfgReg
++AtiCore_WriteMem
++AtiCore_WriteReg
++ */
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif
+--- /dev/null
++++ qt-2.3.10/src/kernel/qgfxw100_qws.cpp
+@@ -0,0 +1,1466 @@
++/***************************************************************************
++
++** Imageon driver for qte using libAticore
++** Manuel Teira( 2005 )
++** BUGS
++*  - Enable again internal memory surfaces.
++****************************************************************************/
++#include <unistd.h>
++#include <stdio.h>
++#include <stdlib.h>
++#include <errno.h>
++#include <string.h>
++#include <dirent.h>
++#include <fcntl.h>
++#include <sys/types.h>
++#include <sys/mman.h>
++#include <time.h>
++
++#include <qapplication.h>
++
++#ifndef __sparc__
++#include <sys/io.h>
++#endif
++
++#include "qgfxraster_qws.h"
++#include "qgfxlinuxfb_qws.h"
++#include <aticore/aticore.h>
++
++#include <stdarg.h>
++
++class W100Control {
++public:
++
++  typedef enum Loglevel {
++    ERROR = 0,
++    WARNING,
++    INFO
++  };
++
++  typedef enum Opcodes {
++    DRAWLINE = 1,
++    DRAWPOINT,
++    DRAWPOINTS,
++    FILLRECT,
++    SCROLL,
++    BITBLT,
++    POLYLINE,
++    EOO
++  };
++
++  typedef struct Opcode {
++    QString str;
++    int index;
++    bool accelerated;
++    int hits;
++    int misses;
++  };
++
++  static Opcode lOpcodes[];
++
++  static QString level2str( int level )
++  {
++    switch( level ) {
++    case ERROR:
++      return QString( "ERROR" );
++      break;
++    case WARNING:
++      return QString( "WARNING" );
++      break;
++    case INFO:
++      return QString( "INFO" );
++      break;
++    default:
++      return QString( "UNKNOWN" );
++      break;
++    }
++  }
++
++  W100Control():
++    m_loglevel( 0 ),
++    m_enabled( 0 )
++  {
++    m_loglevel = 0;
++    char *var;
++    if ( var = getenv( "W100_DEBUG" ) ) {
++      if ( strtol( var, 0, 0 ) == 1 ) {
++	m_enabled = 1;
++      }
++    }
++
++    if ( m_enabled ) {
++      if ( var = getenv( "W100_DEBUGLEVEL" ) ) {
++	if ( ( m_loglevel = strtol( var, 0, 0 ) ) < 0 ) {
++	  m_loglevel = 0;
++	}
++      }
++
++      QString path( "/mnt/card/w100/w100debug.log" );
++      if ( var = getenv( "W100_DEBUGPATH" ) ) {
++	path = QString( var ) + "/w100debug.log";
++      } 
++      m_logfile = fopen( path.latin1(), "w" );
++      if ( m_logfile == NULL ) m_enabled = 0;
++    }
++
++    Opcode *opcodePtr = lOpcodes;
++    int i = 1;
++    while ( opcodePtr->index != EOO ) {
++      if ( opcodePtr->index != i ) {
++	fprintf( stderr, "Opcode list is not ordered!!\n" );
++	abort();
++      }
++
++      QString varName = "W100_ACCEL_" + opcodePtr->str;
++      char *varPtr;
++      if ( ( varPtr = getenv( varName.latin1() ) )  ) {
++	if ( ( strtol( varPtr, NULL, 0 ) == 0 ) ||
++	     ( strcmp( varPtr, "false" ) == 0 ) )  {
++	  opcodePtr->accelerated = false;
++	}
++      }
++      opcodePtr++;
++      i++;
++    }
++  }
++
++  ~W100Control()
++  {
++    //Dump statistics about any opcode
++    Opcode *opcodePtr = lOpcodes;
++    while ( opcodePtr->index != EOO ) {
++      log( WARNING, "Opcode %s. Accelerated=%s. Hits=%d. Misses=%d",
++	   opcodePtr->str.latin1(),
++	   opcodePtr->accelerated ? "true" : "false",
++	   opcodePtr->hits,
++	   opcodePtr->misses );
++      opcodePtr++;
++    }
++    if ( m_enabled && m_logfile ) {
++      fclose( m_logfile );
++    }
++  }
++
++  bool accelerated( int opcode )
++  {
++    if ( opcode < EOO ) {
++      return lOpcodes[opcode].accelerated;
++    }
++    return false;
++  }
++
++  void addHit( int opcode )
++  {
++    lOpcodes[opcode].hits++;
++    ( *lastop ) = opcode;
++  }
++
++  int lastOp( void ) const
++  {
++    return ( *lastop );
++  }
++
++  void addMiss( int opcode )
++  {
++    lOpcodes[opcode].misses++;
++  }
++
++  void log( int level, const char *fmt, ... )
++  {
++    if ( m_enabled && ( level <= m_loglevel ) ) {
++      char buffer[1024];
++      va_list ap;
++      va_start( ap, fmt );
++      vsnprintf( buffer, 1023, fmt, ap );
++      va_end( ap );
++      fprintf( m_logfile, "%d:%s:%s\n", getpid(),
++	       level2str( level ).latin1(), 
++	       buffer );
++    }
++  }
++
++private:
++  FILE *m_logfile;
++  int m_loglevel;
++  bool m_enabled;
++};
++
++W100Control::Opcode W100Control::lOpcodes[] = {
++  { "DRAWLINE",   W100Control::DRAWLINE,   true, 0, 0 },
++  { "DRAWPOINT",  W100Control::DRAWPOINT,  true, 0, 0 },
++  { "DRAWPOINTS", W100Control::DRAWPOINTS, true, 0, 0 },
++  { "FILLRECT",   W100Control::FILLRECT,   true, 0, 0 },
++  { "SCROLL",     W100Control::SCROLL,     true, 0, 0 },
++  { "BITBLT",     W100Control::BITBLT,     true, 0, 0 },
++  { "POLYLINE",   W100Control::POLYLINE,   true, 0, 0 },
++  { ""      ,     W100Control::EOO,        false, 0, 0 }
++};
++
++W100Control control;
++
++static int W100_ProcessAttach( void )
++{
++  return( AtiCore_ProcessAttach() );
++}
++
++static int W100_ProcessDetach( void )
++{
++  return( AtiCore_ProcessDetach() );
++}
++
++static int W100_AllocateSurface( uint16_t *handle, uint32_t *offset,
++				 uint32_t size, uint32_t direction )
++{
++  int retcode = AtiCore_AllocateSurface( handle, offset, size, direction );
++  return( retcode );
++}
++
++static int W100_DestroySurface( uint16_t handle )
++{
++  int retcode = AtiCore_DestroySurface( handle );
++  return( retcode );
++}
++
++static int W100_DrawPixel( int npoints, ATI_POINT *points )
++{
++  return( AtiCore_DrawPixel( npoints, points ) );
++}
++
++static int W100_SetRopOperation( uint32_t rop )
++{
++  return( AtiCore_SetRopOperation( rop ) );
++}
++
++static int W100_SetDstType( uint32_t dtype )
++{
++  return( AtiCore_SetDstType( dtype ) );
++}
++
++static int W100_SetSrcType( uint32_t stype )
++{
++  return( AtiCore_SetSrcType( stype ) );
++}
++
++static int W100_SetSrcClippingRect( ATI_CLIPRECT *cliprect )
++{
++  return( AtiCore_SetSrcClippingRect( cliprect ) );
++}
++
++
++static int W100_SetDstClippingRect( ATI_CLIPRECT *cliprect )
++{
++  return( AtiCore_SetDstClippingRect( cliprect ) );
++}
++
++static int W100_SetSrcPitchOffset( int pitch, int offset )
++{
++  return( AtiCore_SetSrcPitchOffset( pitch, offset ) );
++}
++
++static int W100_SetDstPitchOffset( int pitch, int offset )
++{
++  return( AtiCore_SetDstPitchOffset( pitch, offset ) );
++}
++
++static int W100_BitBltFilpRotate( int flags, 
++				  ATI_RECT *dstRect,
++				  ATI_RECT *srcRect )
++{
++  return( AtiCore_BitBltFilpRotate( flags, dstRect, srcRect ) );
++}
++
++static int W100_StretchBlt( ATI_STRETCH *option,
++			    ATI_POINT *point,
++			    ATI_RECT *srcRect )
++{
++  return( AtiCore_StretchBlt( option, point, srcRect ) );
++}
++
++static int W100_WaitComplete( int msec )
++{
++  return( AtiCore_WaitComplete( msec ) );
++}
++
++static int W100_AllocOverlay( uint16_t *handle ) 
++{
++  return( AtiCore_AllocOverlay( handle ) );
++}
++
++static int W100_ReleaseOverlay( uint16_t handle )
++{
++  return( AtiCore_ReleaseOverlay( handle ) );
++}
++
++static int W100_SetupOverlay( uint16_t handle, ATI_OVERLAYPROP *prop )
++{
++  return( AtiCore_SetupOverlay( handle, prop ) );
++}
++
++static int W100_SetupOverlayExtended( uint16_t handle, ATI_EXTENDEDOVERLAYPROP *prop )
++{
++  return( AtiCore_SetupOverlayExtended( handle, prop ) );
++}
++
++static int W100_SetOverlayOnOff( uint16_t handle, int isShow )
++{
++  return( AtiCore_SetOverlayOnOff( handle, isShow ) );
++}
++
++static int W100_SetOverlayPos( uint16_t handle, uint16_t x, uint16_t y )
++{
++  return( AtiCore_SetOverlayPos( handle, x, y ) );
++}
++
++static int W100_SetupMemoryTransfer( uint32_t offset, uint32_t *regdata )
++{
++  return( AtiCore_SetupMemoryTransfer( offset, regdata ) );
++}
++
++static int W100_TerminateMemoryTransfer( void )
++{
++  return( AtiCore_TerminateMemoryTransfer() );
++}
++
++static int W100_GetFrontBufferPitchOffset( uint32_t *pitch, uint32_t *offset )
++{
++  return( AtiCore_GetFrontBufferPitchOffset( pitch, offset ) );
++}
++
++static int W100_SetDisplayBrightness( int bri )
++{
++  return( AtiCore_SetDisplayBrightness( bri ) );
++}
++
++static int W100_GetAvailableVideoMem( uint32_t *internal, uint32_t *external )
++{
++  return( GetAvailableVideoMem( internal, external ) );
++}
++
++static int W100_SetupGraphicWindow( ATI_GRAPHICWINDOW *win )
++{
++  return( AtiCore_SetupGraphicWindow( ( void * ) win ) );
++}
++
++static int W100_ProcessAttachSpecialMode( int mode )
++{
++  return( AtiCore_ProcessAttachSpecialMode( mode ) );
++}
++
++static int W100_SetGraphicWindowPos( int x, int y )
++{
++  return( AtiCore_SetGraphicWindowPos( x, y ) );
++}
++
++static int W100_SetFrontBuffer( int offset, int a, int b )
++{
++  return( AtiCore_SetFrontBuffer( offset, a, b ) );
++}
++
++static int W100_SetGraphicWindowOnOff( int val )
++{
++  return( AtiCore_SetGraphicWindowOnOff( val ) );
++}
++
++static unsigned long ccolor( unsigned int rgb )
++{
++  unsigned char r = ( rgb & 0xff0000 ) >> 19;
++  unsigned char g = ( rgb & 0xff00 ) >> 10;
++  unsigned char b = ( rgb & 0xff ) >> 3;
++  return ( ( ( ( unsigned short )0x1f & r ) << 11 ) |
++	   ( ( ( unsigned short )0x3f & g ) << 5 ) |
++	   ( ( ( unsigned short )0x1f & b ) )  ); 
++}
++
++static int W100_SetFrgColour( int val )
++{
++  return( AtiCore_SetFrgColour( ccolor( val ) ) );
++}
++
++static int W100_BrushType( int type, unsigned int pattern )
++{
++  return( AtiCore_BrushType( type, &pattern ) );
++}
++
++static int W100_PaintRect( int flags, ATI_RECT *rect )
++{
++  return( AtiCore_PaintRect( flags, rect ) );
++}
++
++static int W100_Polyline( int npoints, ATI_POINT *points )
++{
++  return( AtiCore_Polyline( npoints, points ) );
++}
++
++static int W100_GetPitchOffsetProperty( void *pitch, void *offset )
++{
++  return( AtiCore_GetPitchOffsetProperty( pitch, offset ) );
++}
++
++static int W100_CursorOnOff( int a, int b )
++{
++  return( AtiCore_CursorOnOff( a, b ) );
++}
++
++static int W100_BitBlt( int flags, ATI_RECT *dst, ATI_RECT *src )
++{
++  return( AtiCore_BitBlt( flags, dst, src ) );
++}
++
++static int W100_WakeUpCall( void )
++{
++  return( AtiCore_WakeUpCall() );
++}
++
++
++template <const int depth, const int type>
++class QGfxW100 : public QGfxRaster<depth,type> {
++
++public:
++  QGfxW100( unsigned char *b, int w, int h );
++  virtual void drawLine( int, int, int, int);
++  virtual void fillRect( int, int, int, int);
++  virtual void blt( int, int, int, int, int, int );
++  virtual void sync();
++  virtual void setOffset( int x, int y );
++  virtual void setPen( const QPen & p );
++  
++  virtual void drawPolyline( const QPointArray &, int, int );
++  virtual void drawPolygon( const QPointArray &, bool, int, int );
++  virtual void drawPoint( int, int );
++  virtual void drawPoints( const QPointArray &, int, int );
++  virtual void scroll( int, int, int, int, int, int );
++  
++
++private:
++  bool checkDest( bool setsrc = false );
++  bool checkSourceDest();
++};
++
++template<const int depth,const int type>
++QGfxW100<depth,type>::QGfxW100( unsigned char * b, int w, int h )
++  : QGfxRaster<depth,type>(b, w, h)
++{
++}
++
++
++template<const int depth,const int type>
++inline void QGfxW100<depth,type>::setOffset( int x, int y )
++{
++  QGfxRaster<depth,type>::setOffset( x, y );
++}
++
++static QString penStyleStr( const QPen &pen ) 
++{
++  QString res;
++  switch( pen.style() ) {
++  case Qt::NoPen:
++    res = "NoPen";
++    break;
++  case Qt::SolidLine:
++    res = "SolidLine";
++    break;
++  case Qt::DashLine:
++    res = "DashLine";
++    break;
++  case Qt::DotLine:
++    res = "DotLine";
++    break;
++  case Qt::DashDotLine:
++    res = "DashDotLine";
++    break;
++  case Qt::DashDotDotLine:
++    res = "DashDotDotLine";
++    break;
++  default:
++    res = "Unknown";
++  }
++  return res;
++}
++
++template<const int depth, const int type>
++inline void QGfxW100<depth,type>::setPen( const QPen &p )
++{
++  QGfxRaster<depth,type>::setPen( p );
++}
++
++template<const int depth,const int type>
++inline bool QGfxW100<depth,type>::checkSourceDest()
++{
++  if ( !checkDest() ) {
++    return FALSE;
++  }
++
++  int sourcepixelpitch;
++  ulong src_buffer_offset;
++  if ( this->srctype == this->SourcePen ) {
++    src_buffer_offset = -1;
++    return FALSE;
++  } else {
++    if ( !qt_screen->onCard( this->srcbits, src_buffer_offset ) ) {
++      return FALSE;
++    }
++    sourcepixelpitch = ( this->srclinestep * 8 ) / this->srcdepth;
++    W100_SetSrcPitchOffset( sourcepixelpitch,
++			    src_buffer_offset );
++  }
++  return TRUE;
++}
++
++template< const int depth, const int type>
++inline bool QGfxW100<depth, type>::checkDest( bool setsrc )
++{
++  //Main framebuffer should be registered as a hardware surface
++  ulong buffer_offset;
++  if ( !qt_screen->onCard( this->buffer, buffer_offset ) ) {
++    return FALSE;
++  }
++  int pixelstep = ( this->linestep() * 8 ) / depth;
++  W100_SetDstPitchOffset( pixelstep, buffer_offset );
++  if ( setsrc ) {
++    W100_SetSrcPitchOffset( pixelstep, buffer_offset );
++  }
++  return TRUE;
++}
++
++template<const int depth,const int type>
++void QGfxW100<depth,type>::drawLine( int x1, int y1, int x2, int y2 )
++{
++  // No point going any further if the window isn't visible
++  if( this->ncliprect < 1 ) {
++    return;
++  }
++
++  if ( !control.accelerated( W100Control::DRAWLINE ) ) {
++    control.addMiss( W100Control::DRAWLINE );
++    QGfxRaster<depth,type>::drawLine( x1, y1, x2, y2 );
++    return;
++  }
++
++  // Only handle 'normal' lines
++  if ( ( this->cpen.style() != this->SolidLine ) || 
++       ( this->myrop != this->CopyROP ) ||
++       ( this->cpen.width() > 1 ) ||
++       ( this->dashedLines ) ) {
++    control.addMiss( W100Control::DRAWLINE );
++    QGfxRaster<depth,type>::drawLine(x1,y1,x2,y2);
++    return;
++  }
++
++  // Stop anyone else trying to access optype/lastop/the graphics engine
++  // to avoid synchronization problems with other processes
++  QWSDisplay::grab( TRUE );
++  if ( !checkDest() ) {
++    QWSDisplay::ungrab();
++    control.addMiss( W100Control::DRAWLINE );
++    QGfxRaster<depth,type>::drawLine( x1, y1, x2, y2);
++    return;
++  }
++
++  // Note that the last operation used the 2d engine
++  ( *optype ) = 1;
++
++
++
++  // Add the offset of the gfx - used to make the origin the right
++  // place for windows
++  x1 = x1 + this->xoffs;
++  y1 = y1 + this->yoffs;
++  x2 = x2 + this->xoffs;
++  y2 = y2 + this->yoffs;
++
++  // Only cope with lines going from left to right
++  // - swap them round if this isn't TRUE
++  if ( x1 > x2 ) {
++    int x3 = x2;
++    int y3 = y2;
++    x2 = x1;
++    y2 = y1;
++    x1 = x3;
++    y1 = y3;
++  }
++
++  GFX_START( QRect( x1, 
++		    y1 < y2 ? y1 : y2, 
++		    ( x2 - x1  + 1 ), 
++		    QABS( y2 - y1 ) + 1 ) );
++
++  // The clip region is defined as a series of rectangles
++  // We repeatedly set up the hardware clip rectangle to one of
++  // these rectangles and re-draw the line - an alternative approach
++  // would be to clip to the rectangle in software
++    
++
++
++  /*
++   * Just a dirty hack. Comment it out for now
++   if ( this->dashedLines ) {
++   W100_BrushType( 4, 0xaaaaaaaa );
++   } else {
++   W100_BrushType( 6, 0 );
++   }
++   switch( this->cpen.style() ) {
++   case Qt::NoPen:
++   //W100DEBUG( "Using pen style NoPen" );
++   break;
++   case Qt::SolidLine:
++   //W100DEBUG( "Using pen style SolidLine" );
++   break;
++   case Qt::DashLine:
++   //W100DEBUG( "Using pen style DashLine" );
++   break;
++   case Qt::DotLine:
++   //W100DEBUG( "Using pen style DotLine" );
++   break;
++   case Qt::DashDotLine:
++   //W100DEBUG( "Using pen style DashDotLine" );
++   break;
++   case Qt::DashDotDotLine:
++   //W100DEBUG( "Using pen style DashDotDotLine" );
++   break;
++   default:
++   //W100DEBUG( "Using unknown type of pen" );
++   }
++  */
++
++  //if ( control.lastOp() != W100Control::DRAWLINE &&
++  //control.lastOp() != W100Control::POLYLINE ) {
++  W100_SetDstType( DSTTYPE_16BPP_1555 );
++  W100_SetSrcType( SRCTYPE_EQU_DST );
++  W100_SetRopOperation( ROP3_PATCOPY );
++  W100_BrushType( 6, 0 );
++  //}
++  W100_SetFrgColour( this->cpen.color().rgb() );
++  control.addHit( W100Control::DRAWLINE );
++
++  //The imageon seems not to write on the edge of the clip
++  //for the polyline op. 
++  //We are using a three points array repeating the last point
++  //to get the last single point painted.
++  ATI_POINT points[3];
++  points[0].XCoord = x1;
++  points[0].YCoord = y1;
++  points[1].XCoord = x2;
++  points[1].YCoord = y2;
++  points[2].XCoord = x2;
++  points[2].YCoord = y2;
++  for ( int loopc = 0 ; loopc < this->ncliprect; loopc++ ) {
++    ATI_CLIPRECT clip;
++    clip.X_Top_Left = this->cliprect[loopc].x();
++    clip.Y_Top_Left = this->cliprect[loopc].y();
++    clip.X_Bottom_Right = this->cliprect[loopc].right() + 1;
++    clip.Y_Bottom_Right = this->cliprect[loopc].bottom() + 1;
++    W100_SetDstClippingRect( &clip );
++
++    W100_Polyline( 3, points );
++  }
++
++  // Software mouse cursor stuff
++  GFX_END;
++
++  // Release display again - not doing so will cause Qt/Embedded applications
++  // to deadlock
++  QWSDisplay::ungrab();
++
++}
++
++
++template< const int depth, const int type >
++void QGfxW100< depth, type>::drawPolyline( const QPointArray &a, 
++					   int index, 
++					   int npoints )
++{
++
++  if ( ( this->ncliprect < 1 ) || ( npoints < 1 ) ) {
++    return;
++  }
++
++  if ( !control.accelerated( W100Control::POLYLINE ) ) {
++    control.addMiss( W100Control::POLYLINE );
++    QGfxRaster<depth,type>::drawPolyline( a, index, npoints );
++    return;
++  }
++
++  if ( this->cpen.style() != this->SolidLine ||
++       this->myrop != this->CopyROP ) {
++    control.addMiss( W100Control::POLYLINE );
++    QGfxRaster<depth,type>::drawPolyline( a, index, npoints );
++    return;
++  }
++
++  QWSDisplay::grab( TRUE );
++  if ( !checkDest() ) {
++    QWSDisplay::ungrab();
++    control.addMiss( W100Control::POLYLINE );
++    QGfxRaster<depth,type>::drawPolyline( a, index, npoints );
++    return;
++  }
++
++  ( *optype ) = 1;
++
++  //if ( control.lastOp() != W100Control::POLYLINE &&
++  //control.lastOp() != W100Control::DRAWLINE ) {
++
++  W100_SetDstType( DSTTYPE_16BPP_1555 );
++  W100_SetSrcType( SRCTYPE_EQU_DST );
++  W100_SetRopOperation( ROP3_PATCOPY );
++  W100_BrushType( 6, 0 );
++  
++  //}
++
++  W100_SetFrgColour( this->cpen.color().rgb() );
++
++  control.addHit( W100Control::POLYLINE );
++
++  ATI_POINT *points = new ATI_POINT[ npoints + 1 ];
++
++  for ( int i = 0; i < npoints; i++ ) {
++    points[i].XCoord = a[ i + index ].x() + this->xoffs;
++    points[i].YCoord = a[ i + index ].y() + this->yoffs;
++  }
++  //Hack to get the last point of the last line painted
++  points[ npoints ] = points[ npoints - 1 ];
++
++
++  GFX_START( clipbounds );
++  W100_SetFrgColour( this->cpen.color().rgb() );
++  W100_SetRopOperation( ROP3_PATCOPY );
++  for ( int loopc = 0; loopc < this->ncliprect; loopc++ ) {
++    ATI_CLIPRECT clip;
++    clip.X_Top_Left = this->cliprect[loopc].x();
++    clip.Y_Top_Left = this->cliprect[loopc].y();
++    clip.X_Bottom_Right = this->cliprect[loopc].right() + 1;
++    clip.Y_Bottom_Right = this->cliprect[loopc].bottom() + 1;
++    W100_SetDstClippingRect( &clip );
++    W100_Polyline( npoints + 1, points );
++  }
++  GFX_END;
++
++  delete [] points;
++    
++  QWSDisplay::ungrab();
++}
++
++template< const int depth, const int type >
++void QGfxW100< depth, type>::drawPolygon( const QPointArray &a, bool b, int c, int d )
++{
++  QGfxRaster<depth,type>::drawPolygon( a, b, c, d );
++}
++
++template< const int depth, const int type >
++void QGfxW100< depth, type>::drawPoint( int a, int b )
++{
++
++  if ( this->ncliprect < 1 ) {
++    //W100DEBUG( "ncliprect=%d", this->ncliprect );
++    return;
++  }
++
++  if ( !control.accelerated( W100Control::DRAWPOINT) ) {
++    control.addMiss( W100Control::DRAWPOINT );
++    QGfxRaster<depth,type>::drawPoint( a, b );
++    return;
++  }
++
++  if ( this->cpen.style() != this->SolidLine ||
++       this->myrop != this->CopyROP ) {
++    control.addMiss( W100Control::DRAWPOINT );
++    QGfxRaster<depth,type>::drawPoint( a, b );
++    return;
++  }
++
++  QWSDisplay::grab( TRUE );
++  if ( !checkDest() ) {
++    QWSDisplay::ungrab();
++    control.addMiss( W100Control::DRAWPOINT );
++    QGfxRaster<depth,type>::drawPoint( a, b );
++    return;
++  }
++
++  control.addHit( W100Control::DRAWPOINT );
++  ( *optype ) = 1;
++  
++  ATI_POINT point;
++  point.XCoord = a + this->xoffs;
++  point.YCoord = b + this->yoffs;
++
++  GFX_START( clipbounds );
++  W100_SetFrgColour( this->cpen.color().rgb() );
++  W100_SetRopOperation( ROP3_PATCOPY );
++  for ( int loopc = 0; loopc < this->ncliprect; loopc++ ) {
++    ATI_CLIPRECT clip;
++    clip.X_Top_Left = this->cliprect[loopc].x();
++    clip.Y_Top_Left = this->cliprect[loopc].y();
++    clip.X_Bottom_Right = this->cliprect[loopc].right() + 1;
++    clip.Y_Bottom_Right = this->cliprect[loopc].bottom() + 1;
++    W100_SetDstClippingRect( &clip );
++    W100_DrawPixel( 1, &point );
++  }
++  GFX_END;
++  QWSDisplay::ungrab();
++}
++
++template< const int depth, const int type >
++void QGfxW100< depth, type>::drawPoints( const QPointArray &a, 
++					 int index, 
++					 int npoints )
++{
++  if ( ( this->ncliprect < 1 ) || ( npoints < 1 ) ) {
++    return;
++  }
++
++  if ( !control.accelerated( W100Control::DRAWPOINTS ) ) {
++    control.addMiss( W100Control::DRAWPOINTS );
++    QGfxRaster<depth,type>::drawPoints( a, index, npoints );
++    return;
++  }
++
++  if ( this->cpen.style() != this->SolidLine ||
++       this->myrop != this->CopyROP ) {
++    control.addMiss( W100Control::DRAWPOINTS );
++    QGfxRaster<depth,type>::drawPoints( a, index, npoints );
++    return;
++  }
++
++  QWSDisplay::grab( TRUE );
++  if ( !checkDest() ) {
++    QWSDisplay::ungrab();
++    control.addMiss( W100Control::DRAWPOINTS );
++    QGfxRaster<depth,type>::drawPoints( a, index, npoints );
++    return;
++  }
++
++  control.addHit( W100Control::DRAWPOINTS );
++  ( *optype ) = 1;
++  
++  ATI_POINT *points = new ATI_POINT[ npoints ];
++  for ( int i = 0; i < npoints; i++ ) {
++    points[i].XCoord = a[ i + index ].x() + this->xoffs;
++    points[i].YCoord = a[ i + index ].y() + this->yoffs;
++  }
++
++  GFX_START( clipbounds );
++  W100_SetFrgColour( this->cpen.color().rgb() );
++  W100_SetRopOperation( ROP3_PATCOPY );
++  for ( int loopc = 0; loopc < this->ncliprect; loopc++ ) {
++    ATI_CLIPRECT clip;
++    clip.X_Top_Left = this->cliprect[loopc].x();
++    clip.Y_Top_Left = this->cliprect[loopc].y();
++    clip.X_Bottom_Right = this->cliprect[loopc].right() + 1;
++    clip.Y_Bottom_Right = this->cliprect[loopc].bottom() + 1;
++    W100_SetDstClippingRect( &clip );
++    W100_DrawPixel( npoints, points );
++  }
++  GFX_END;
++
++  delete [] points;
++  QWSDisplay::ungrab();
++}
++
++
++template< const int depth, const int type >
++void QGfxW100< depth, type>::scroll( int rx, int ry,
++				     int w, int h, 
++				     int sx, int sy )
++{
++  if ( !control.accelerated( W100Control::SCROLL ) ) {
++    control.addMiss( W100Control::SCROLL );
++    QGfxRaster<depth,type>::scroll( rx, ry, w, h, sx, sy );
++    return;
++  }
++
++  if ( this->ncliprect < 1 ) return;
++
++  if ( ( w < 1 )  || ( h < 1 ) ) return;
++
++  int dy = sy - ry;
++  int dx = sx - rx;
++
++  if ( dx == 0 && dy == 0 ) return;
++
++
++  QWSDisplay::grab( TRUE );
++
++  if ( checkDest( true ) ) {
++
++
++    rx += this->xoffs;
++    sx += this->xoffs;
++    ry += this->yoffs;
++    sy += this->yoffs;
++
++    GFX_START( QRect( QMIN( rx , sx  ),
++		      QMIN( ry , sy  ),
++		      w + QABS( dx ) + 1,
++		      h + QABS( dy ) + 1 ) );
++    ( *optype ) = 1;
++
++
++    //if ( control.lastOp() != W100Control::SCROLL ) {
++    W100_SetRopOperation( ROP3_SRCCOPY );
++    W100_SetDstType( DSTTYPE_16BPP_1555 );
++    W100_SetSrcType( SRCTYPE_EQU_DST );
++    //}
++
++    control.addHit( W100Control::SCROLL );
++
++    ATI_RECT srcrect, dstrect;
++
++    srcrect.XCoord = sx;
++    srcrect.YCoord = sy;
++    srcrect.Width = w;
++    srcrect.Height = h;
++    dstrect.XCoord = rx;
++    dstrect.YCoord = ry;
++    dstrect.Width = w;
++    dstrect.Height = h;
++
++    for ( int loopc = 0; loopc < this->ncliprect; loopc++ ) {
++      ATI_CLIPRECT clip;
++      clip.X_Top_Left     = this->cliprect[ loopc ].x();
++      clip.Y_Top_Left     = this->cliprect[ loopc ].y();
++      clip.X_Bottom_Right = this->cliprect[ loopc ].right() + 1;
++      clip.Y_Bottom_Right = this->cliprect[ loopc ].bottom() + 1;
++      W100_SetDstClippingRect( &clip );
++      W100_BitBlt( 1, &dstrect, &srcrect );
++    }
++    GFX_END;
++    QWSDisplay::ungrab();
++
++  } else {
++    QWSDisplay::ungrab();
++    // software fallback
++    control.addMiss( W100Control::SCROLL );
++    QGfxRaster<depth,type>::scroll( rx, ry, w, h, sx, sy );
++  }
++}
++
++
++  
++template< const int depth, const int type >
++void QGfxW100< depth, type>::fillRect( int rx, int ry, int w, int h )
++{
++
++  if ( w <= 0 || h <= 0 || this->ncliprect < 1 ) return;
++
++  if ( !control.accelerated( W100Control::FILLRECT ) ) {
++    control.addMiss( W100Control::FILLRECT );
++    QGfxRaster<depth,type>::fillRect( rx, ry, w, h );
++    return;
++  }
++
++  if ( ( this->cbrush.style() != this->NoBrush ) && 
++       ( this->cbrush.style() != this->SolidPattern ) ) {
++    control.addMiss( W100Control::FILLRECT );
++    QGfxRaster<depth,type>::fillRect( rx, ry, w, h );
++    return;
++  }
++
++  if ( !checkDest() || ( this->myrop != this->CopyROP ) ) {
++    control.addMiss( W100Control::FILLRECT );
++    QGfxRaster<depth,type>::fillRect(rx,ry,w,h);
++    return;
++  }
++
++  QWSDisplay::grab( TRUE );
++  rx += this->xoffs;
++  ry += this->yoffs;
++
++  GFX_START( QRect( rx, ry, w+1, h+1 ) );
++
++  ( *optype ) = 1;
++  control.log( W100Control::INFO, "QGfxW100::fillRect( +%d+%d %dx%d )",
++	       rx, ry, w, h );
++
++
++  //if ( control.lastOp() != W100Control::FILLRECT ) {
++  W100_SetDstType( DSTTYPE_16BPP_1555 );
++  W100_SetSrcType( SRCTYPE_EQU_DST );
++  W100_SetRopOperation( ROP3_PATCOPY );
++  W100_BrushType( 6, 0 );
++  //}
++  W100_SetFrgColour( this->cbrush.color().rgb() );
++
++  control.addHit( W100Control::FILLRECT );
++
++  if ( this->cbrush.style() != this->NoBrush ) {
++    //Using all the cliprects
++    for ( int loopc = 0; loopc < this->ncliprect; loopc++ ) {
++      ATI_CLIPRECT clip;
++      ATI_RECT rect;
++
++      clip.X_Top_Left     = this->cliprect[ loopc ].x();
++      clip.Y_Top_Left     = this->cliprect[ loopc ].y();
++      clip.X_Bottom_Right = this->cliprect[ loopc ].right() + 1;
++      clip.Y_Bottom_Right = this->cliprect[ loopc ].bottom() + 1;
++
++      W100_SetDstClippingRect( &clip );
++      rect.XCoord = rx;
++      rect.YCoord = ry;
++      rect.Width  = w;
++      rect.Height = h;
++      W100_PaintRect( 1, &rect );
++    }
++  }
++  GFX_END;
++      
++  QWSDisplay::ungrab();
++}
++
++template< const int depth, const int type >
++inline void QGfxW100< depth, type>::blt( int rx, int ry, 
++					 int w, int h,
++					 int sx, int sy )
++{
++  control.log( W100Control::INFO, "QGfxW100::blt( +%d+%d %dx%d )",
++	       rx, ry, w, h );
++  if ( !w || !h || this->ncliprect < 1 ) {
++    return;
++  }
++
++  if ( !control.accelerated( W100Control::BITBLT ) ) {
++    control.addMiss( W100Control::BITBLT );
++    QGfxRaster<depth,type>::blt(rx,ry,w,h,sx,sy);
++    return;
++  }
++
++  if ( this->alphatype == this->BigEndianMask ||
++       this->alphatype == this->LittleEndianMask ||
++       this->alphatype == this->SeparateAlpha ||
++       this->srctype == this->SourcePen ||
++       ( this->myrop != this->CopyROP ) ) {
++    control.addMiss( W100Control::BITBLT );
++    QGfxRaster<depth,type>::blt(rx,ry,w,h,sx,sy);
++    return;
++  }
++
++  if( ( this->srcdepth != 16 ) || this->alphatype != this->IgnoreAlpha ) {
++    control.addMiss( W100Control::BITBLT );
++    QGfxRaster<depth,type>::blt(rx,ry,w,h,sx,sy);
++    return;
++  }
++
++  QWSDisplay::grab( TRUE );
++
++  if( checkSourceDest() ) {
++    GFX_START( QRect( rx + xoffs, ry + yoffs , w+1, h+1 ) );
++    ( *optype ) = 1;
++
++    //if ( control.lastOp() != W100Control::BITBLT ) {
++    W100_SetRopOperation( ROP3_SRCCOPY );
++    W100_SetDstType( DSTTYPE_16BPP_1555 );
++    W100_SetSrcType( SRCTYPE_EQU_DST );
++    //}
++
++    control.addHit( W100Control::BITBLT );
++
++    ATI_RECT rect1;
++    ATI_RECT rect2;
++	
++    rect1.XCoord = this->srcwidgetoffs.x() + sx;
++    rect1.YCoord = this->srcwidgetoffs.y() + sy;
++    rect1.Width  = w;
++    rect1.Height = h;
++    rect2.XCoord = this->xoffs + rx;
++    rect2.YCoord = this->yoffs + ry;
++    rect2.Width = w;
++    rect2.Height = h;
++    for(int loopc = 0; loopc < this->ncliprect; loopc++ ) {
++      ATI_CLIPRECT clip;
++      clip.X_Top_Left     = this->cliprect[ loopc ].x();
++      clip.Y_Top_Left     = this->cliprect[ loopc ].y();
++      clip.X_Bottom_Right = this->cliprect[ loopc ].right() + 1;
++      clip.Y_Bottom_Right = this->cliprect[ loopc ].bottom() + 1;
++      W100_SetDstClippingRect( &clip );
++      W100_BitBlt( 1, &rect2, &rect1 );
++    }
++    GFX_END;
++      
++    QWSDisplay::ungrab();
++    return;
++  } else {
++    QWSDisplay::ungrab();
++    // software fallback
++    control.addMiss( W100Control::BITBLT );
++    QGfxRaster<depth,type>::blt( rx, ry, w, h, sx, sy );
++  }
++}
++
++
++template<const int depth,const int type>
++void QGfxW100<depth,type>::sync()
++{
++  W100_WaitComplete( -1 );
++}
++
++class QW100Screen : public QLinuxFbScreen {
++
++public:
++  class HWSurface {
++  public:
++    HWSurface( void ):
++      m_handle( 0 ),
++      m_offset( 0 ),
++      m_addr( 0 ),
++      m_size( 0 ),
++      m_internal( false ),
++      m_clientid( -1 ) {};
++    HWSurface( unsigned short handle,
++	       uint32_t sOffset,
++	       unsigned char *localAddr, 
++	       int amount,
++	       bool internal,
++	       int clientid ):
++      m_handle( handle ),
++      m_offset( sOffset ),
++      m_addr( localAddr ),
++      m_size( amount ),
++      m_internal( internal ),
++      m_clientid( clientid ) {};
++    HWSurface( uint32_t sOffset, 
++	       unsigned char *localAddr,
++	       bool internal,
++	       int amount ):
++      m_handle( 0 ),
++      m_offset( sOffset ),
++      m_addr( localAddr ),
++      m_size( amount ),
++      m_internal( internal ),
++      m_clientid( -1 ) {};
++    bool operator!=( HWSurface &other ) {
++      return( m_offset == other.getSOffset() );
++    };
++    HWSurface &operator=( const HWSurface &c ) {
++      m_handle = c.getHandle();
++      m_offset = c.getSOffset();
++      m_addr = c.getAddr();
++      m_size = c.getSize();
++      m_clientid= c.getCId();
++      m_internal = c.internal();
++      return( *this );
++    };
++    unsigned short getHandle( void ) const { return m_handle; };
++    uint32_t getSOffset( void ) const { return m_offset; };
++    unsigned char *getAddr( void ) const { return m_addr; };
++    unsigned int getSize( void ) const { return m_size; };
++    int getCId( void ) const { return m_clientid; };
++    bool internal( void ) const { return m_internal; };
++
++  private:
++    unsigned short m_handle;
++    uint32_t m_offset;
++    unsigned char *m_addr;
++    int m_size;
++    bool m_internal;
++    int m_clientid;
++  };
++    
++  QW100Screen( int display_id );
++  virtual ~QW100Screen();
++  virtual bool connect( const QString &spec );
++  virtual void disconnect( void );
++  virtual bool initDevice();
++  virtual void shutdownDevice();
++  virtual bool useOffscreen() { return TRUE; }
++  virtual QGfx * createGfx( unsigned char *, int, int, int, int);
++  virtual uchar *cache( int amount, int optim );
++  virtual void uncache( uchar *c );
++  virtual bool onCard( unsigned char *p ) const;
++  virtual bool onCard( unsigned char *p, ulong& offset ) const;
++  QMap< uchar*, HWSurface > *getPSurfaceMap( void ) const;
++  void clearCache( int clientId );
++protected:
++  static void clearCache( QScreen *instance, int clientId );
++  QMap< uchar*, HWSurface > surfaceMap;
++  int vramoffset;
++  virtual int pixmapLinestepAlignment() { return 128; }
++};
++
++QW100Screen::QW100Screen( int display_id )
++  :QLinuxFbScreen( display_id )
++{
++  vramoffset = ( w == 320 ) ? 0: 0x0f000000;
++  clearCacheFunc = &clearCache;
++}
++
++bool QW100Screen::connect( const QString &displaySpec )
++{
++
++  if ( QLinuxFbScreen::connect( displaySpec ) ) {
++    if ( W100_ProcessAttach() ) {
++      W100_ProcessAttachSpecialMode( ( w == 480 ) ? 0xaaab:0xaaaa );
++      surfaceMap.insert( 0, HWSurface( vramoffset, 
++				       data , false, 
++				       w*h*d/8 ) );
++      canaccel = TRUE;
++      return TRUE;
++    }
++  }
++  return FALSE;
++}
++
++void QW100Screen::disconnect( void )
++{
++  QLinuxFbScreen::disconnect();
++  W100_ProcessDetach();
++}
++
++QW100Screen::~QW100Screen()
++{
++}
++
++bool QW100Screen::initDevice()
++{
++  ATI_GRAPHICWINDOW win;
++  ATI_CLIPRECT      clip;
++  uint16_t overlay;
++  int ret;
++  uint32_t extm, intm;
++  W100_GetAvailableVideoMem( &intm, &extm );
++  ret = W100_CursorOnOff( 1, 0 );
++  ret = W100_CursorOnOff( 2, 0 );
++  ret = W100_CursorOnOff( 3, 0 );
++  win.dummy1 = 0;
++  win.Size.XCoord = 0;
++  win.Size.YCoord = 0;
++  win.Size.Width = w;
++  win.Size.Height = h;
++  win.Width = w > h ? h : w;
++  win.Height = w > h ? w : h;
++  win.Flag = DSTTYPE_16BPP_444; //(5)
++    
++  ret = W100_SetupGraphicWindow( &win );
++  if ( !ret ) {
++    return FALSE;
++  }
++  ret = W100_SetGraphicWindowPos( 0, 0 );
++
++  ret = W100_SetFrontBuffer( vramoffset, 0, 0 );
++  ret = W100_SetDstPitchOffset( w, vramoffset );
++  ret = W100_SetDstType( DSTTYPE_16BPP_444 );
++  ret = W100_SetSrcPitchOffset( w, vramoffset );
++  ret = W100_SetSrcType( SRCTYPE_SOLID_COLOR_BLT );
++  clip.X_Top_Left = 0;
++  clip.Y_Top_Left = 0;
++  clip.X_Bottom_Right = w;
++  clip.Y_Bottom_Right = h;
++  ret = W100_SetDstClippingRect( &clip );
++    
++  clip.X_Top_Left = 0xE000;
++  clip.Y_Top_Left = 0xE000;
++  clip.X_Bottom_Right = 0x1FFF;
++  clip.Y_Bottom_Right = 0x1FFF;
++    
++  ret = W100_SetSrcClippingRect( &clip );
++  ret = W100_SetRopOperation( ROP3_SRCCOPY );
++  ret = W100_SetGraphicWindowOnOff( 1 );
++    
++  ret = W100_AllocOverlay( &overlay );
++  ret = W100_SetOverlayOnOff( overlay, 0 );
++  ret = W100_ReleaseOverlay( overlay );
++  ret = W100_SetDstPitchOffset( w, vramoffset );
++  ret = W100_SetDstClippingRect( NULL );
++  
++  if ( QLinuxFbScreen::initDevice() ) {
++    //HACK
++    //Some sprite corruption seems to be avoided
++    //reserving some upper memory on the offscreen framebuffer memory
++    QLinuxFbScreen::cache( 65535 * 2, 0 );
++    return true;
++  }
++  return false;
++}
++
++void QW100Screen::shutdownDevice()
++{
++  QLinuxFbScreen::shutdownDevice();
++  W100_ProcessDetach();
++}
++
++QGfx *QW100Screen::createGfx( unsigned char *b,
++			      int w, int h, int d, int linestep )
++{
++  //We need ALL the gfx created to be QGfxW100 to allow software
++  //drawing syncing after hardware operations
++  QGfx * ret=0;
++  if ( false ) {
++#ifndef QT_NO_QWS_DEPTH_1
++  } else if ( d == 1 ) {
++    ret = new QGfxW100<1,0>( b, w, h );
++#endif
++#ifndef QT_NO_QWS_DEPTH_4
++  } else if ( d == 4 ) {
++    ret = new QGfxW100<4,0>( b, w, h );
++#endif
++#ifndef QT_NO_QWS_DEPTH_8
++  } else if ( d == 8 ) {
++    ret = new QGfxW100<8,0>( b, w, h );
++#endif
++#ifndef QT_NO_QWS_DEPTH_16    
++  } else if  ( d == 16 ) {
++    ret = new QGfxW100<16,0>( b, w, h );
++#endif
++#ifndef QT_NO_QWS_DEPTH_24
++  } else if ( d == 24 ) {
++    ret = new QGfxW100<24,0>( b, w, h );
++#endif
++#ifndef QT_NO_QWS_DEPTH_32
++  } else if ( d == 32 ) {
++    ret = new QGfxW100<32,0>( b, w, h );
++#endif
++  } else {
++    qFatal( "Unsupported depth %d\n", d );
++    ret = 0;
++  }
++
++  ret->setLineStep( linestep );
++  return ret;    
++}
++
++static int sinternal = 0;
++static int sexternal = 0;
++
++uchar *QW100Screen::cache( int amount, int optim )
++{
++  unsigned short hSurface = 0;
++  uint32_t surfaceOffset = 0;
++  uchar* localAddr = 0;
++  bool internal = false;
++
++  /* The size must have 0xF bit zeroed (16 multiple)*/
++  /* Perhaps this is not needed anymore, after setting
++   * QW100Screen::pixmapLinestepAlignment to 128
++   */
++  amount = ( amount & 0x0F ) ? ( amount | 0x10 ) & ~0x0F : amount;
++
++  /* Experimenting memory corruption with the
++   * internal AtiCore memory allocation routines
++   * disabled for now
++   */
++#if 1
++  if ( !( localAddr = QLinuxFbScreen::cache( amount, optim ) ) ) {
++    return( 0 );
++  }
++  surfaceOffset = vramoffset + ( uint32_t ) localAddr - ( uint32_t )data;
++
++#else
++  int retcode = 0;
++  qt_fbdpy->grab();
++  retcode = W100_AllocateSurface( &hSurface,
++				  &surfaceOffset,
++				  amount, 1 );
++  qt_fbdpy->ungrab();
++  if ( retcode ) {
++    internal = true;
++    W100_SetupMemoryTransfer( surfaceOffset, (uint32_t*) &localAddr );
++    W100_TerminateMemoryTransfer();
++  } else {
++    // Try to use the offscreen framebuffer memory
++    // to allocate the surface. Use the qgfxlinuxfb routines
++    if ( !( localAddr = QLinuxFbScreen::cache( amount, optim ) ) ) {
++      return( 0 );
++    }
++    //Distance between physical vram start and surface should be
++    //the same than distance between logical addresses
++    surfaceOffset = vramoffset + ( uint32_t ) localAddr - ( uint32_t ) data;
++  }
++#endif
++    
++  HWSurface surface( hSurface, surfaceOffset,
++		     localAddr, amount, 
++		     internal,
++		     qws_client_id );
++#if 0
++  if ( internal ) {
++    sinternal++;
++  } else {
++    sexternal++;
++  }
++#endif
++  surfaceMap.insert( surface.getAddr(), surface );
++  return( ( uchar* ) localAddr );
++}
++
++void QW100Screen::uncache( uchar *c )
++{
++  QMap< uchar*, HWSurface >::Iterator itr;
++  if ( ( itr = surfaceMap.find( c ) ) != surfaceMap.end() ) {
++    if ( itr.data().internal() ) {
++      qt_fbdpy->grab();
++      W100_DestroySurface( itr.data().getHandle() );
++      qt_fbdpy->ungrab();
++      --sinternal;
++    } else {
++      --sexternal;
++      QLinuxFbScreen::uncache( c );
++    }
++    surfaceMap.remove( itr );
++  } 
++}
++
++bool QW100Screen::onCard( uchar *p ) const
++{
++  QMap< uchar*, HWSurface >::ConstIterator itr = surfaceMap.begin();
++  for ( ; itr != surfaceMap.end(); itr++ ) {
++    uchar *begin;
++    if ( ( begin = itr.data().getAddr() ) <= p ) {
++      if ( ( itr.data().getSize() + begin ) >= p ) {
++	return TRUE;
++      }
++    }
++  }
++  return FALSE;
++}
++
++bool QW100Screen::onCard( unsigned char *p, ulong& offset ) const
++{
++  QMap< uchar*, HWSurface >::ConstIterator itr;
++  for ( itr = surfaceMap.begin(); itr != surfaceMap.end(); itr++ ) {
++    uchar *begin;
++    if ( ( begin = itr.data().getAddr() ) <= p ) {
++      if ( ( itr.data().getSize() + begin ) >= p ) {
++	offset = itr.data().getSOffset() + ( p - begin );
++	return TRUE;
++      }
++    }
++  }
++  return FALSE;
++}
++
++QMap< uchar*, QW100Screen::HWSurface > 
++*QW100Screen::getPSurfaceMap( void ) const
++{
++  return ( QMap<uchar*,HWSurface> *) &surfaceMap;
++}
++
++void QW100Screen::clearCache( int clientId )
++{
++  QMap< uchar*, HWSurface >::Iterator itr = surfaceMap.begin();
++  while ( itr != surfaceMap.end() ) {
++    if ( itr.data().getCId() == clientId ) {
++      if ( itr.data().internal() ) {
++	qt_fbdpy->grab();
++	W100_DestroySurface( itr.data().getHandle() );
++	qt_fbdpy->ungrab();
++	--sinternal;
++      } else {
++	QLinuxFbScreen::uncache( itr.data().getAddr() );
++	--sexternal;
++      }
++      surfaceMap.remove( itr );
++    }
++    itr++;
++  }
++}
++
++void QW100Screen::clearCache( QScreen *instance, int clientId )
++{
++  QW100Screen *screen = ( QW100Screen * )instance;
++  screen->clearCache( clientId );
++}
++
++extern bool qws_accel;
++
++extern "C" QScreen * qt_get_screen_w100( int display_id )
++{
++    return( new QW100Screen( display_id ) );
++}