ude506.c

S1D13506windml下的驱动程序,支持vxworks5.4 支持tornado2.0 windml2.0

/***************************************************************************
 *                                                                         * 
 *  UDE506.C -- S1D13506 8 bpp WindML display driver.                      * 
 *  Copyright (c) 2000, 2001 Epson Research and Development, Inc.          *
 *  All Rights Reserved                                                    *
 *                                                                         *
 *  THIS SOURCE CODE IS FOR TEST ONLY.                                     *
 *                                                                         *
 ***************************************************************************/

/* includes */
#include "udepson.h"


/*
 * uglEpson8BitDevCreate
 */
UGL_UGI_DRIVER * uglEpsonDevCreate
(
    UGL_ORD    instance,
    UGL_UINT32 notUsed0,	/* intLevel */
    UGL_UINT32 notUsed1		/* intVector */
)
{
    UGL_EPSON_DRIVER   * pEpsonDriver;
    UGL_GENERIC_DRIVER * pGenDriver;
    UGL_UGI_DRIVER     * pDriver = UGL_NULL;
    UGL_STATUS           status  = UGL_STATUS_ERROR;
    UGL_UINT16           pciBus;
    UGL_UINT16           pciDevice;
    UGL_UINT16           pciFunc;

    pEpsonDriver = (UGL_EPSON_DRIVER   *)UGL_CALLOC(1, sizeof(UGL_EPSON_DRIVER ));

    if (UGL_NULL != pEpsonDriver)
    {

	/* Determine if chip is supported and present */
	if ( pciFindDevice ( UGL_EPSON_PCI_VENDOR_ID, UGL_EPSON_PCI_DEV_ID, 
			     instance, &pciBus, &pciDevice, &pciFunc) == OK 
           )
	{
	    pEpsonDriver->chipType = UGL_EPSON_PCI_DEV_ID;
	    pEpsonDriver->pciBus = pciBus;
	    pEpsonDriver->pciDevice = pciDevice;
	    pEpsonDriver->pciFunc = pciFunc;
	    pEpsonDriver->busType = UGL_EPSON_PCI;

	    status = UGL_STATUS_OK;
	}
	else
	{
	    status = UGL_STATUS_ERROR;
	}

	if ( status == UGL_STATUS_ERROR )
        {
	    UGL_FREE( pEpsonDriver );
	    return( UGL_NULL );
        }


	pGenDriver = (UGL_GENERIC_DRIVER *) pEpsonDriver;
        pDriver    = (UGL_UGI_DRIVER *)     pGenDriver;


	/* Initialize the driver (mandatory) */
        uglUgiDevInit(pDriver);
        uglEpson8BitModeSet( pDriver, pDevModes );

	/* Set Standard Driver API Functions */
        pDriver->bitmapCreate             = uglEpson8BitBitmapCreate;
	pDriver->modeSet	          = uglEpson8BitModeSet;
	pDriver->clutSet	          = uglEpson8BitClutSet;
	pDriver->clutGet                  = uglEpson8BitClutGet;
	pDriver->info                     = uglEpson8BitInfo;
 	pDriver->modeAvailGet             = uglEpson8BitModeAvailGet;
        pDriver->destroy                  = uglEpson8BitDevDestroy;
	pDriver->cursorHide               = uglEpsonCursorHide;
	pDriver->cursorMove               = uglEpsonCursorMove;
	pDriver->cursorShow               = uglEpsonCursorShow;
        if ( (pEpsonModeTable->Flags) & mfHWBLT )
        pDriver->bitmapBlt                = uglEpson8BitBitmapBlt;
        else
        pDriver->bitmapBlt                = uglGeneric8BitBitmapBlt;
        pDriver->bitmapDestroy	          = uglGeneric8BitBitmapDestroy;
        pDriver->bitmapRead	          = uglGeneric8BitBitmapRead;
        pDriver->bitmapWrite	          = uglGeneric8BitBitmapWrite;
        pDriver->bitmapStretchBlt         = uglGeneric8BitBitmapStretchBlt;
        pDriver->monoBitmapBlt            = uglGeneric8BitMonoBitmapBlt;
        pDriver->monoBitmapCreate         = uglGeneric8BitMonoBitmapCreate;
        pDriver->monoBitmapDestroy        = uglGeneric8BitMonoBitmapDestroy;
        pDriver->monoBitmapRead           = uglGeneric8BitMonoBitmapRead;
        pDriver->monoBitmapWrite          = uglGeneric8BitMonoBitmapWrite;
        pDriver->monoBitmapStretchBlt	  = uglGeneric8BitMonoBitmapStretchBlt;
        pDriver->transBitmapBlt           = uglGeneric8BitTransBitmapBlt;
        pDriver->transBitmapCreate        = uglGenericTransBitmapCreate;
        pDriver->transBitmapDestroy       = uglGenericTransBitmapDestroy;
        pDriver->transBitmapRead	  = uglGenericTransBitmapRead;
        pDriver->transBitmapWrite	  = uglGenericTransBitmapWrite;
        pDriver->transBitmapStretchBlt	  = uglGenericTransBitmapStretchBlt;
	pDriver->transBitmapCreateFromDdb = uglGenericTransBitmapCreateFromDdb;
	pDriver->colorAlloc               = uglGenericColorAllocIndexed;
	pDriver->colorFree                = uglGenericColorFreeIndexed;
	pDriver->colorConvert             = uglGeneric8BitColorConvert;
	pDriver->cursorBitmapCreate       = uglGenericCursorBitmapCreate;
	pDriver->cursorBitmapDestroy      = uglGenericCursorBitmapDestroy;
	pDriver->cursorInit               = uglGenericCursorInit;
	pDriver->cursorDeinit             = uglGenericCursorDeinit;
	pDriver->cursorImageGet           = uglGenericCursorImageGet;
	pDriver->cursorImageSet           = uglGenericCursorImageSet;
	pDriver->cursorPositionGet        = uglGenericCursorPositionGet;
	pDriver->cursorOff                = uglGenericCursorOff;
	pDriver->cursorOn                 = uglGenericCursorOn;
	pDriver->ellipse                  = uglGenericEllipse;
	pDriver->gcCopy                   = uglGenericGcCopy;
	pDriver->gcCreate                 = uglGenericGcCreate;
	pDriver->gcDestroy                = uglGenericGcDestroy;
	pDriver->gcSet                    = uglGenericGcSet;
	pDriver->line                     = uglGenericLine;
        pDriver->pixelGet                 = uglGeneric8BitPixelGet;
        pDriver->pixelSet                 = uglGeneric8BitPixelSet;
	pDriver->polygon                  = uglGenericPolygon;
	pDriver->rectangle                = uglGenericRectangle;
	pDriver->memPoolCreate            = uglGenericMemPoolCreate;
	pDriver->memPoolDestroy           = uglGenericMemPoolDestroy;
#ifdef INCLUDE_UGL_DOUBLE_BUFFERING
	pDriver->pageCopy                 = uglEpsonPageCopy;
	pDriver->pageCreate               = uglEpsonPageCreate;
        pDriver->pageDestroy              = uglEpsonPageDestroy;
	pDriver->pageDrawGet              = uglEpsonPageDrawGet;
	pDriver->pageDrawSet              = uglEpsonPageDrawSet;
	pDriver->pageVisibleGet           = uglEpsonPageVisibleGet;
	pDriver->pageVisibleSet           = uglEpsonPageVisibleSet;
#endif /* INCLUDE_UGL_DOUBLE_BUFFERING */

	/* Set Generic Driver Functions */
        pGenDriver->bresenhamLine         = uglGeneric8BitBresenhamLine;
        pGenDriver->fbPixelGet            = uglGeneric8BitFbPixelGet;
        pGenDriver->fbPixelSet            = uglGeneric8BitFbPixelSet;
 	pGenDriver->fill                  = uglGenericFill;
	pGenDriver->hLine	          = uglGeneric8BitHLine;
	pGenDriver->rectFill              = uglGenericRectFill;
	pGenDriver->vLine                 = uglGeneric8BitVLine;
	pGenDriver->gpWait                = uglEpsonGpWait;

        uglGenericClutCreate (pGenDriver, 256);
    }

    uglEpsonDisplayBuildNum(szVersion);

    return (pDriver);
}



/*
 *  uglEpsonDisplayBuildNum - show build number 
 */
UGL_LOCAL void uglEpsonDisplayBuildNum ( const char * szVersion )
{
    UGL_EPSON_BUILD   epsonBuild;
    char            * version;
    char              temp[5];

    epsonBuild.first_num   = 1;

    strncpy ( temp, szVersion+11, 5); 

    if ( ( version = (char *) strrchr(temp, '$')) != NULL )
    {
       version[0] = 0; 
       strncpy ( epsonBuild.second_num, temp, 5); 
    }

   printf( "\nEPSON S1D13506 8BPP WindML 2.0 Display Driver: Build %d.%d%s \n",epsonBuild.first_num, 
             buildNum, epsonBuild.second_num);
}



/*
 *  uglEpson8BitDevDestroy - Destroy instances of display drivers.
 */
UGL_STATUS uglEpson8BitDevDestroy
(
    UGL_UGI_DRIVER * pDriver
)
{
    UGL_GENERIC_DRIVER * pGenDriver = (UGL_GENERIC_DRIVER *)pDriver;

    if ( pDriver )
    {
	/* Clear the screen */
	memset( pGenDriver->fbAddress, 0x0, pDriver->pMode->width * 
	        pDriver->pMode->height * (pDriver->pMode->colorDepth / 8) );
	/* Delete any extensions */
	uglGenExtAllDelete( pDriver );
	uglGenericClutDestroy( pGenDriver );

	/* Deinitialize the driver (mandatory) */
	uglUgiDevDeinit(pDriver);
	UGL_FREE(pDriver->pPageZero->pDdb);
	UGL_FREE(pDriver->pPageZero);

	/* Free the driver */
	UGL_FREE(pDriver);

	return (UGL_STATUS_OK);
    }

    return ( UGL_STATUS_ERROR );

}



/*
 *  uglEpson8BitInfo - Retrieve information about the graphics stack and drivers.
 */
UGL_STATUS uglEpson8BitInfo
(
    UGL_UGI_DRIVER * pDriver,
    UGL_INFO_REQ     infoRequest,
    void           * info
)
{
    UGL_GENERIC_DRIVER *pGenDriver = (UGL_GENERIC_DRIVER *) pDriver;

    if ( pDriver->pMode == UGL_NULL ) return( UGL_STATUS_ERROR );

    switch (infoRequest)
    {
	case UGL_FB_INFO_REQ:
	{
	    UGL_FB_INFO *fbInfo = (UGL_FB_INFO *)info;
	    fbInfo->width       = pEpsonModeTable->Width;
	    fbInfo->height      = pEpsonModeTable->Height;
	    fbInfo->fbAddrs     = pGenDriver->fbAddress;
	    fbInfo->dsMemAmount = 0;
	    fbInfo->flags       = 0;
	}
	break;

	case UGL_COLOR_INFO_REQ:
	{
	    UGL_COLOR_INFO * colorInfo = (UGL_COLOR_INFO *)info;
	    colorInfo->cmodel          = UGL_CMODEL_INDEXED;
	    colorInfo->cspace          = UGL_CSPACE_RGB;
	    colorInfo->depth           = pEpsonModeTable->Bpp;
	    colorInfo->clutSize        = CLUT_SIZE;
	    colorInfo->flags           = UGL_CLUT_WRITE;
	}
	break;

	case UGL_MODE_INFO_REQ:
	    {
	    UGL_MODE_INFO * modeInfo = (UGL_MODE_INFO *)info;
            modeInfo->width = pEpsonModeTable->Width;
            modeInfo->height = pEpsonModeTable->Height;
            modeInfo->colorDepth = pEpsonModeTable->Bpp;
            modeInfo->clutSize = 256;
            modeInfo->colorModel = UGL_INDEXED_8;
            modeInfo->colorFormat = 0;
            modeInfo->fbAddress = pGenDriver->fbAddress;
            modeInfo->displayMemAvail = 0;
            modeInfo->flags = 0;
	    }
	    break;

	case UGL_EXT_INFO_REQ:
	    {

            #ifdef INCLUDE_UGL_JPEG
	    UGL_EXT_INFO * extInfo = (UGL_EXT_INFO *)info;
	    int version;
	    if (strcmp(extInfo->name, UGL_EXT_JPEG_NAME) == 0)
		{
		extInfo->pExt = (void *)uglGenJpegInit (
			       pDriver, &version);
		extInfo->version = version;
		}
	    else
            #endif /* INCLUDE_UGL_JPEG */

		return (UGL_STATUS_ERROR);
	    }
	    break;

	default:
	    return( UGL_STATUS_ERROR );
    }

    return( UGL_STATUS_OK );
}



/*
 *  uglEpsonGpWait - Wait for BitBLT to complete.
 */
UGL_STATUS uglEpsonGpWait
(
    UGL_GENERIC_DRIVER * pDriver
)
{
    UGL_UINT8  regData = 0;

    while (1)
    {
      regData = *(volatile unsigned short *) ( BITBLT_CTRL0 + pciBaseAddress );

      if ( 0 == (regData & 0x80) )
         break;
    }

    pDriver->gpBusy = UGL_FALSE;

    return( UGL_STATUS_OK );
}



/*
 *  uglEpson8BitClutEntryGet - Get a color from a color lookup table.
 */
UGL_STATUS uglEpson8BitClutGet
(
    UGL_DEVICE_ID   pDriver, 
    UGL_ORD         startIndex,
    UGL_ARGB      * pColors,
    UGL_SIZE        numColors
)
{
    return( uglGenericClutGet( (UGL_UGI_DRIVER *) pDriver, startIndex, 
                               pColors, numColors) );
}



/*
 *  uglEpson8BitClutSet - Initialize lookup table.
 */
UGL_STATUS uglEpson8BitClutSet
(
    UGL_DEVICE_ID   pDriver, 
    UGL_ORD         startIndex,
    UGL_ARGB      * pColors,
    UGL_SIZE        numColors
)
{
    UGL_UINT8  i;
    UGL_STATUS status;