path: root/xorg-server/hw/kdrive/via/viadraw.c

/*
 * Copyright © 2004 Ralph Thomas
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation, and that the name of Ralph Thomas not be used in
 * advertising or publicity pertaining to distribution of the software without
 * specific, written prior permission.  Ralph Thomas makes no
 * representations about the suitability of this software for any purpose.  It
 * is provided "as is" without express or implied warranty.
 *
 * RALPH THOMAS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
 * EVENT SHALL RALPH THOMAS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 */
/*
** VIA CLE266 driver
** Copyright 2004 (C) Ralph Thomas <ralpht@gmail.com>
**
** http://www.viatech.com.tw/
**
** This code is for accelerated drawing of solids and accelerated
** copies. Note that there is currently no software FIFO implemented,
** and no documentation on any hardware FIFO.
*/

#include "via.h"
#include "viadraw.h"
#include "via_regs.h"
#include <sched.h>
#include "kdrive.h"
#include "kaa.h"

/*
** A global to contain card information between calls into this file.
** XXX: This is totally brain-damaged. Why don't I get the information
**      I want in viaSolid/viaCopy/viaDoneXXX?
*/
static ViaCardInfo* card;

/*
** Translation table from GC raster operation values into ROP3 values
** that the VIA chip understands.
**
** viaPatternRop is used by viaPrepareSolid.
** viaCopyRop is used by viaPrepareCopy.
*/
CARD8 viaPatternRop[16] = {
	/* GXclear      */	0x00,	/* ROP_0	0 */
	/* GXand        */	0xA0,	/* ROP_DPa	src AND dst */
	/* GXandReverse */	0x50,	/* ROP_PDna	src AND NOT dst */
	/* GXcopy       */	0xF0,	/* ROP_P	src */
	/* GXandInverted*/	0x0A,	/* ROP_DPna	NOT src AND dst */
	/* GXnoop       */	0xAA,	/* ROP_D	dst */
	/* GXxor        */	0x5A,	/* ROP_DPx	src XOR dst */
	/* GXor         */	0xFA,	/* ROP_DPo	src OR dst */
	/* GXnor        */	0x05,	/* ROP_DPon	NOT src AND NOT dst */
	/* GXequiv      */	0xA5,	/* ROP_PDxn	NOT src XOR dst */
	/* GXinvert     */	0x55,	/* ROP_Dn	NOT dst */
	/* GXorReverse  */	0xF5,	/* ROP_PDno	src OR NOT dst */
	/* GXcopyInverted*/	0x0F, 	/* ROP_Pn	NOT src */
	/* GXorInverted */	0xAF,	/* ROP_DPno	NOT src OR dst */
	/* GXnand       */	0x5F,	/* ROP_DPan	NOT src OR NOT dst */
	/* GXset        */	0xFF,	/* ROP_1	1 */
};

CARD8 viaCopyRop[16] = {
	/* GXclear	*/	0x00,	/* ROP_0	0 */
	/* GXand	*/	0x88,	/* ROP_DSa	src AND dst */
	/* GXandReverse	*/	0x44,	/* ROP_SDna	src AND NOT dst */
	/* GXcopy	*/	0xCC,	/* ROP_S	src */
	/* GXandInverted*/	0x22,	/* ROP_DSna	NOT src AND dst */
	/* GXnoop	*/	0xAA,	/* ROP_D	dst */
	/* GXxor	*/	0x66,	/* ROP_DSx	src XOR dst */
	/* GXor		*/	0xEE,	/* ROP_DSo	src OR dst */
	/* GXnor	*/	0x11,	/* ROP_DSon	NOT src AND NOT dst */
	/* GXequiv	*/	0x99,	/* ROP_DSxn	NOT src XOR dst */
	/* GXinvert	*/	0x55,	/* ROP_Dn	NOT dst */
	/* GXorReverse	*/	0xDD,	/* ROP_SDno	src OR NOT dst */
	/* GXcopyInverted*/	0x33,	/* ROP_Sn	NOT src */
	/* GXorInverted	*/	0xBB,	/* ROP_DSno	NOT src OR dst */
	/* GXnand	*/	0x77,	/* ROP_DSan	NOT src OR NOT dst */
	/* GXset	*/	0xFF,	/* ROP_1	1 */
};

/*
** void viaWaitIdle( ViaCardInfo* viac )
**
** Description:
**	Block up the CPU while waiting for the last command sent to
**	the chip to complete. As an experiment I'm going to try to
**	yield my process to others instead of just tight looping.
**
** Arguments:
**	viac	VIA-driver specific chip information
**
** Return:
**	None.
*/
void
viaWaitIdle( ViaCardInfo* viac ) {
	while( INREG32( VIA_REG_STATUS ) & VIA_BUSY )
		sched_yield();
}

/*
** void viaDrawSync( ScreenPtr pScreen, int marker )
**
** Description:
**	Block until the graphics chip has finished all outstanding drawing
**	operations and the framebuffer contents is static.
**
** Arguments:
**	pScreen		Pointer to screen strucutre for the screen we're
**			waiting for drawing to end on.
**
** Return:
**	None.
*/
static void
viaWaitMarker( ScreenPtr pScreen, int marker ) {
	KdScreenPriv( pScreen );
	ViaCardInfo* viac = pScreenPriv->card->driver;

	viaWaitIdle( viac );
}


/*
** Bool viaPrepareSolid( PixmapPtr pPixmap, int alu, Pixel planemask, Pixel fg )
**
** Description:
**	Decide if the specified solid fill operation can be accelerated or not,
**	and if the fill can be accelerated, prepare the hardware for doing it.
**
** Arguments:
**	pPixmap		Pixmap to draw solid into.
**	alu		Raster operation to draw using, these are the same
**			values which get set by XSetFunction(3X). See the
**			Xlib PM p. 140 for a list of raster operations as
**			well as descriptions.
**	planemask	This is the GC plane mask. We only copy bits which
**			match the plane mask.
**	fg		The foreground pixel of the GC, the pixel to draw in.
**
** Return:
**	TRUE	This operation can be accelerated, call viaSolid to actually
**		have it drawn.
**	FALSE	This operation cannot be accelerated, fall back to software.
**
** See Also:
**	viaSolid - the function which actually draws the solid.
*/
static Bool
viaPrepareSolid( PixmapPtr pPixmap, int alu, Pixel planeMask, Pixel fg ) {
	ScreenPtr pScreen = pPixmap->drawable.pScreen;
	KdScreenPriv( pScreen );
	ViaCardInfo* viac = pScreenPriv->card->driver;

	/*
	** We don't accelerate when the plane mask is not everything.
	*/
	if( ~planeMask & FbFullMask( pPixmap->drawable.depth ) ) return FALSE;

	/*
	** Compose the command, then store the composed command and color
	** in the viac structure so that when viaSolid gets called we can
	** write them out.
	*/
	viac->savedCommand = VIA_GEC_BLT | VIA_GEC_FIXCOLOR_PAT |
			     (viaPatternRop[alu]  << 24); 
	viac->savedFgColor = fg;

	/*
	** Store pointer to chip information, due to brain-damaged KAA.
	*/
	card = viac;

	return TRUE;
}

/*
** void viaSolid( int x1, int y1, int x2, int y2 )
**
** Description:
**	Perform a solid fill, using the data that was stored by viaPrepareSolid.
**
** Arguments:
**	x1	x-coordinate of fill origin
**	y1	y-coordinate of fill origin
**	x2	x-coordinate of fill end point
**	y2	y-coordinate of fill end point
**
** Return:
**	None.
**
** See Also:
**	viaPrepareSolid - the function that composes the GE command and saves
**			  the color for us.
*/
static void
viaSolid( int x1, int y1, int x2, int y2 ) {
	ViaCardInfo* viac = card;
	int w = x2 - x1; int h = y2 - y1;

	if( !viac ) return;
	if( !w || !h ) return;

	/*
	** Wait for the card to finish the current draw.
	*/
	viaWaitIdle( viac );

	/*
	** Do the draw.
	*/
	OUTREG32( VIA_REG_DSTPOS, ((y1 << 16) | x1) );
	OUTREG32( VIA_REG_DIMENSION, (((h - 1) << 16) | (w - 1)) );
	OUTREG32( VIA_REG_FGCOLOR, viac->savedFgColor );
	OUTREG32( VIA_REG_GECMD, viac->savedCommand );
}

/*
** void viaDoneSolid
**
** Description:
**	Finish up drawing of the solid.
**
** Arguments:
**	None.
**
** Return:
**	None.
*/
static void
viaDoneSolid(void) {
}

/*
** Bool viaPrepareCopy( PixmapPtr pSrcPixmap, PixmapPtr pDestPixmap, int dx,
**			int dy, int alu, Pixel planeMask )
**
** Description:
**	Set up the VIA chip for a BitBlt.
**
** Arguments:
**	pSrcPixmap	the source pixmap to copy from
**	pDestPixmap	the destination pixmap to copy to
**	dx		direction of copy in x
**	dy		direction of copy in y
**	alu		Raster operation to draw using, these are the same
**			values which get set by XSetFunction(3X). See the
**			Xlib PM p. 140 for a list of raster operations as
**			well as descriptions.
**	planeMask	This is the GC plane mask. We only copy bits which
**			match the plane mask.
**
** Return:
**	TRUE	the requested copy operation can be accelerated using hardware,
**		call viaCopy next.
**	FALSE	the requested copy operation cannot be accelerated using
**		hardware - fallback to software.
**
** See Also:
**	viaCopy	- the function which does the actual copy.
*/
static Bool
viaPrepareCopy( PixmapPtr pSrcPixmap, PixmapPtr pDestPixmap, int dx, int dy,
		int alu, Pixel planeMask ) {
	ScreenPtr pScreen = pDestPixmap->drawable.pScreen;
	KdScreenPriv( pScreen );
	ViaCardInfo* viac = pScreenPriv->card->driver;

	/*
	** Don't accelerate when the plane mask is set.
	*/
	if( ~planeMask & FbFullMask( pDestPixmap->drawable.depth ) ) return FALSE;

	viac->savedCommand = VIA_GEC_BLT | (viaCopyRop[alu] << 24);

	if( dx < 0 ) viac->savedCommand |= VIA_GEC_DECX;
	if( dy < 0 ) viac->savedCommand |= VIA_GEC_DECY;

	/*
	** Store pointer to chip structure, due to brain-damaged KAA.
	*/
	card = viac;

	return TRUE;
}

/*
** void viaCopy( int srcX, int srcY, int dstX, int dstY, int w, int h )
**
** Description:
**	Perform a BitBlt from one screen area to another.
**
** Arguments:
**	srcX	source x-coordinate
**	srcY	source y-coordinate
**	dstX	destination x-coordinate
**	dstY	destination y-coordinate
**	w	width of area to copy (pixels)
**	h	height of area to copy (pixels)
**
** Return:
**	None.
**
** See Also:
**	viaPrepareCopy	- the function which sets up for the copy.
*/
static void
viaCopy( int srcX, int srcY, int dstX, int dstY, int w, int h ) {
	ViaCardInfo* viac = card;

	if( !viac ) return;
	if( !w | !h ) return;

	/*
	** XXX: Check these two "if"s out.
	*/
	if( viac->savedCommand & VIA_GEC_DECX ) {
		srcX += ( w - 1 );
		dstX += ( w - 1 );
	}

	if( viac->savedCommand & VIA_GEC_DECY ) {
		srcY += ( h - 1 );
		dstY += ( h - 1 );
	}

	OUTREG32( VIA_REG_SRCPOS, ((srcY << 16) | srcX) );
	OUTREG32( VIA_REG_DSTPOS, ((dstY << 16) | dstX) );
	OUTREG32( VIA_REG_DIMENSION, (((h - 1) << 16) | (w - 1)) );
	OUTREG32( VIA_REG_GECMD, viac->savedCommand );
}

/*
** void viaDoneCopy()
**
** Description:
**	Finish up the copy.
**
** Arguments:
**	None.
**
** Return:
**	None.
*/
static void
viaDoneCopy(void) {
}


/*
** Bool viaDrawInit( ScreenPtr pScreen )
**
** Description:
**	Initialize the 2D acceleration hardware and register the KAA
**	acceleration layer with the VIA acceleration functions (above).
**
** Arguments:
**	pScreen		Pointer to screen structure for the screen we're
**			enabling acceleration on.
**
** Return:
**	TRUE	initialization and setup of KAA acceleration was successful.
**	FALSE	initialization and setup of KAA acceleration failed.
*/
Bool
viaDrawInit( ScreenPtr pScreen ) {
	KdScreenPriv( pScreen );
	ViaCardInfo* viac = pScreenPriv->card->driver;
	ViaScreenInfo* vias = pScreenPriv->card->driver;
	CARD32 geMode = 0;

	if( !viac ) return FALSE;
	DebugF( "viac->mapBase = 0x%x\n", viac->mapBase );

	/*
	** We reset the 2D engine to a known state by setting all of it's
	** registers to zero.
	*/
	OUTREG32( VIA_REG_GEMODE, 0x0 );
	OUTREG32( VIA_REG_SRCPOS, 0x0 );
	OUTREG32( VIA_REG_DSTPOS, 0x0 );
	OUTREG32( VIA_REG_DIMENSION, 0x0 );
	OUTREG32( VIA_REG_PATADDR, 0x0 );
	OUTREG32( VIA_REG_FGCOLOR, 0x0 );
	OUTREG32( VIA_REG_BGCOLOR, 0x0 );
	OUTREG32( VIA_REG_CLIPTL, 0x0 );
	OUTREG32( VIA_REG_CLIPBR, 0x0 );
	OUTREG32( VIA_REG_OFFSET, 0x0 );
	OUTREG32( VIA_REG_KEYCONTROL, 0x0 );
	OUTREG32( VIA_REG_SRCBASE, 0x0 );
	OUTREG32( VIA_REG_DSTBASE, 0x0 );
	OUTREG32( VIA_REG_PITCH, 0x0 );
	OUTREG32( VIA_REG_MONOPAT0, 0x0 );
	OUTREG32( VIA_REG_MONOPAT1, 0x0 );

	/*
	** Set the GE mode up.
	** XXX: What happens in 24bpp mode?
	*/
	switch( pScreenPriv->screen->fb[0].bitsPerPixel ) {
	  case 16:
		geMode = VIA_GEM_16bpp;
		break;
	  case 32:
		geMode = VIA_GEM_32bpp;
		break;
	  default:
		geMode = VIA_GEM_8bpp;
		break;
	}

	OUTREG32( VIA_REG_GEMODE, geMode );

	/*
	** Set the source and destination base addresses, and set pitch.
	*/
	OUTREG32( VIA_REG_SRCBASE, 0x0 );
	OUTREG32( VIA_REG_DSTBASE, 0x0 );
	OUTREG32( VIA_REG_PITCH, VIA_PITCH_ENABLE |
	       ((pScreen->width * pScreenPriv->screen->fb[0].bitsPerPixel >> 3) >> 3) |
               (((pScreen->width * pScreenPriv->screen->fb[0].bitsPerPixel >> 3) >> 3) << 16));

	DebugF( "Initialized 2D engine!\n" );

	memset(&vias->kaa, 0, sizeof(KaaScreenInfoRec));
	vias->kaa.waitMarker	= viaWaitMarker;
	vias->kaa.PrepareSolid	= viaPrepareSolid;
	vias->kaa.Solid		= viaSolid;
	vias->kaa.DoneSolid	= viaDoneSolid;
	vias->kaa.PrepareCopy	= viaPrepareCopy;
	vias->kaa.Copy		= viaCopy;
	vias->kaa.DoneCopy	= viaDoneCopy;

	return kaaDrawInit( pScreen, &vias->kaa );
}

/*
** void viaDrawEnable( ScreenPtr pScreen )
**
** Description:
**	Enable accelerated drawing on the specified screen.
**
** Arguments:
**	pScreen		Pointer to screen structure for the screen we're
**			enabling acceleration on.
**
** Return:
**	None.
*/
void
viaDrawEnable( ScreenPtr pScreen ) {
	kaaMarkSync( pScreen );
}

/*
** void viaDrawDisable( ScreenPtr pScreen )
**
** Description:
**	Disable accelerated drawing to the specified screen.
**
** Arguments:
**	pScreen		Pointer to screen structure for the screen we're
**			disabling acceleration on.
**
** Return:
**	None
*/
void
viaDrawDisable( ScreenPtr pScreen ) {
}

/*
** void viaDrawFini( ScreenPtr pScreen )
**
** Description:
**	Shutdown accelerated drawing and free associated strucures and
**	resources.
**
** Arguments:
**	pScreen		Pointer to screen structure for the screen we're
**			disabling acceleration on.
**
** Return:
**	None.
*/
void
viaDrawFini( ScreenPtr pScreen ) {
}