lq080v3dg01.c

2410/vxworks/tornado下的基本实验包括 serial,ramdrv,interrupt,multi-FTP,TCP,UDP-Under the basic experimental

/* LQ080V3DG01.c - LQ080V3DG01 LCD 16 bit driver  */

/* includes */

#include <string.h>
#include <ugl/ugl.h>
#include <ugl/driver/graphics/common/udcHwAbsLayer.h>
#include <ugl/driver/graphics/generic/udgen16.h>
#include <ugl/driver/graphics/MagicARM2410/LcdCtrl.h>
#include <ugl/driver/graphics/MagicARM2410/LQ080V3DG01.h>


#ifdef INCLUDE_UGL_EXT
#include <ugl/ext/common/uglext.h>
#endif /* INCLUDE_UGL_EXT */

#ifdef INCLUDE_UGL_JPEG
#include <ugl/driver/ext/jpeg/udgenjpg.h>
#endif /* INCLUDE_UGL_JPEG */


UGL_UINT32 lqRegBase;



/*******************************************************************************
*
* uglLQ16BitDevCreate
*
*
*/

UGL_UGI_DRIVER * uglLQ16BitDevCreate
(
    UGL_UINT32 instance,
    UGL_UINT32 param1,	/* intLevel */
    UGL_UINT32 param2	/* intVector */
)
{
    UGL_LQ_DRIVER * pLQDriver;
    UGL_GENERIC_DRIVER * pGenDriver;
    UGL_UGI_DRIVER * pDriver = UGL_NULL;
    int arg;
    UINT32 virtAdrs;
    int size = LCDFBSIZE;
    
    /* Chips&Tech only support I/O operations (except for bitblit) */
    if (instance > 0)
	return(UGL_NULL);

    /* Allocate device data structure from shared memory */
    pLQDriver = (UGL_LQ_DRIVER *)uglSharedMemAlloc(sizeof(UGL_LQ_DRIVER), UGL_MEM_CLEAR);

    if (UGL_NULL != pLQDriver)
    {
        pGenDriver = (UGL_GENERIC_DRIVER *)pLQDriver;
        pDriver = (UGL_UGI_DRIVER *)pGenDriver;

        pGenDriver->pWmlDevice = uglGraphicsDevOpen (0, 0, 0);
        if (pGenDriver->pWmlDevice == UGL_NULL)
        {
            uglSharedMemFree ((char *)pLQDriver);
            return (UGL_NULL);
        }

        if (uglGraphicsDevAccessCheck (pGenDriver->pWmlDevice,
                                       WINDML_DEVICE_BASE_ADRS_0, 
                                        &size, UGL_GRAPHICS_NAME) == UGL_STATUS_ERROR) 
        {
            uglSharedMemFree ((char *)pLQDriver);
            return (UGL_NULL);
        }

        /* Device found and it can be accessed */
        lqRegBase = (UGL_UINT32) pGenDriver->pWmlDevice->pRegBase;                    
        pLQDriver->chipType = pGenDriver->pWmlDevice->deviceID;

        arg = WINDML_IO_ENABLE | WINDML_MEM_ENABLE;
        uglGraphicsDevControl (pGenDriver->pWmlDevice, WINDML_ACCESS_MODE_SET,
                               &arg, sizeof(arg));
        
        /* Map physical memory to virtual */
        uglGraphicsDevMap (pGenDriver->pWmlDevice, 
                           (UINT32) pGenDriver->pWmlDevice->pPhysBaseAdrs0, 
                           size, &virtAdrs); 

        /* Set the base address of the frame buffer */
        pGenDriver->fbAddress = (void *)virtAdrs;
#ifdef UGL_BIG_ENDIAN
        pGenDriver->fbAddress = (void *)((char *)(pGenDriver->fbAddress) + 0x800000);
#endif
	/* Initialize the driver (mandatory) */
        uglUgiDevInit(pDriver);

	/* Set Standard Driver API Functions */
        pDriver->bitmapBlt		= uglGeneric16BitBitmapBlt;
        pDriver->bitmapCreate		= uglGeneric16BitBitmapCreate;
        pDriver->bitmapDestroy		= uglGeneric16BitBitmapDestroy;
        pDriver->bitmapRead		= uglGeneric16BitBitmapRead;
        pDriver->bitmapWrite		= uglGeneric16BitBitmapWrite;
        pDriver->bitmapStretchBlt	= uglGeneric16BitBitmapStretchBlt;
        
        /* lcd special function */
	    pDriver->modeAvailGet		= uglLQ16BitModeAvailGet;
	    pDriver->modeSet		= uglLQ16BitModeSet;
	    
        pDriver->monoBitmapBlt		= uglGeneric16BitMonoBitmapBlt;
        pDriver->monoBitmapCreate	= uglGeneric16BitMonoBitmapCreate;
        pDriver->monoBitmapDestroy	= uglGeneric16BitMonoBitmapDestroy;
        pDriver->monoBitmapRead		= uglGeneric16BitMonoBitmapRead;
        pDriver->monoBitmapWrite	= uglGeneric16BitMonoBitmapWrite;
        pDriver->monoBitmapStretchBlt	= uglGeneric16BitMonoBitmapStretchBlt;
        pDriver->transBitmapBlt		= uglGeneric16BitTransBitmapBlt;
        pDriver->transBitmapCreate	= uglGenericTransBitmapCreate;
        pDriver->transBitmapDestroy	= uglGenericTransBitmapDestroy;
        pDriver->transBitmapRead	= uglGenericTransBitmapRead;
        pDriver->transBitmapWrite	= uglGenericTransBitmapWrite;
        pDriver->transBitmapStretchBlt	= uglGeneric16BitTransBitmapStretchBlt;
	    pDriver->transBitmapCreateFromDdb = uglGenericTransBitmapCreateFromDdb;
	    pDriver->colorAlloc		= uglGenericColorAllocDirect;
	    pDriver->colorFree		= UGL_NULL;
	    pDriver->clutSet		= UGL_NULL;
	    pDriver->clutGet		= UGL_NULL;
	    pDriver->colorConvert	        = uglGeneric16BitColorConvert;
	    pDriver->cursorBitmapCreate	= uglGenericCursorBitmapCreate;
	    pDriver->cursorBitmapDestroy	= uglGenericCursorBitmapDestroy;
	    pDriver->cursorInit		= uglGenericCursorInit;
	    pDriver->cursorDeinit		= uglGenericCursorDeinit;
	    pDriver->cursorHide		= uglGenericCursorHide;
	    pDriver->cursorImageGet		= uglGenericCursorImageGet;
	    pDriver->cursorImageSet		= uglGenericCursorImageSet;
	    pDriver->cursorMove		= uglGenericCursorMove;
	    pDriver->cursorPositionGet	= uglGenericCursorPositionGet;
	    pDriver->cursorOff		= uglGenericCursorOff;
	    pDriver->cursorOn		= uglGenericCursorOn;
	    pDriver->cursorShow		= uglGenericCursorShow;
	    
	    /* lcd special functin */
        pDriver->destroy		= uglLQ16BitDevDestroy;
	    
	    pDriver->ellipse		= uglGenericEllipse;
	    pDriver->gcCopy			= uglGenericGcCopy;
	    pDriver->gcCreate		= uglGenericGcCreate;
	    pDriver->gcDestroy		= uglGenericGcDestroy;
	    pDriver->gcSet			= uglGenericGcSet;
	    
	    /* lcd special functin */
	    pDriver->info			= uglLQ16BitInfo;
	    
	    pDriver->line			= uglGenericLine;
        pDriver->pixelGet		= uglGeneric16BitPixelGet;
        pDriver->pixelSet		= uglGeneric16BitPixelSet;
	    pDriver->polygon		= uglGenericPolygon;
	    pDriver->rectangle		= uglGenericRectangle;
	    pDriver->pageCopy		= uglGenericPageCopy;
	    pDriver->pageCreate		= uglGenericPageCreate;
        pDriver->pageDestroy		= uglGenericPageDestroy;
	    pDriver->pageDrawGet		= uglGenericPageDrawGet;
	    
	    /* lcd special functin */
	    pDriver->pageDrawSet		= NULL; /* uglLQPageDrawSet; */
	    
	    pDriver->pageVisibleGet		= uglGenericPageVisibleGet;
	    
	    /* lcd special functin */
	    pDriver->pageVisibleSet		= NULL; /* uglLQPageVisibleSet; */
	    
	    pDriver->memPoolCreate		= uglGenericMemPoolCreate;
	    pDriver->memPoolDestroy		= uglGenericMemPoolDestroy;

	    /* Set Generic Driver Functions */
        pGenDriver->bresenhamLine	= uglGeneric16BitBresenhamLine;
        pGenDriver->fbPixelGet		= uglGeneric16BitFbPixelGet;
        pGenDriver->fbPixelSet		= uglGeneric16BitFbPixelSet;
	    pGenDriver->fill		= uglGeneric16BitFill;
	    pGenDriver->hLine		= uglGeneric16BitHLine;
	    pGenDriver->rectFill		= uglGeneric16BitRectFill;
	    pGenDriver->vLine		= uglGeneric16BitVLine;
	    
	    /* lcd special functin */
	    pGenDriver->gpWait		= uglLQgpWait;
        }

    return (pDriver);
    }

/*******************************************************************************
*
* uglLQ16BitDevDestroy
*
*/

UGL_STATUS uglLQ16BitDevDestroy
    (
    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));

#ifdef INCLUDE_UGL_EXT
	/* Delete any extensions */
	uglGenExtAllDelete (pDriver);
#endif /* INCLUDE_UGL_EXT */

	/* Deinitialize the driver (mandatory) */
	uglUgiDevDeinit(pDriver);

	UGL_FREE(pDriver->pPageZero->pDdb);

	UGL_FREE(pDriver->pPageZero);

        /* Close the device at the BSP level */
        uglGraphicsDevClose (pGenDriver->pWmlDevice);

        /* Free deice control data structure */
        uglSharedMemFree( ( char *) pDriver);

	return (UGL_STATUS_OK);
	}
    return (UGL_STATUS_ERROR);
    }

/**************************************************************************
*
* uglCT16BitInfo
*
*/

UGL_STATUS uglLQ16BitInfo
    (
    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 = pDriver->pMode->width;
	    fbInfo->height = pDriver->pMode->height;
	    fbInfo->fbAddrs = pGenDriver->fbAddress;
	    fbInfo->dsMemAmount = 0;
#ifdef INCLUDE_UGL_DOUBLE_BUFFERING
            fbInfo->flags = UGL_FB_PAGING_ENABLED;
#else
            fbInfo->flags = 0;
#endif /* INCLUDE_UGL_DOUBLE_BUFFERING */
	    }
	    break;

	case UGL_COLOR_INFO_REQ:
	    {
	    UGL_COLOR_INFO *colorInfo = (UGL_COLOR_INFO *)info;
	    colorInfo->cmodel = UGL_CMODEL_DIRECT;
	    colorInfo->cspace = UGL_CSPACE_RGB;
	    colorInfo->depth = pDriver->pMode->colorDepth;
	    colorInfo->clutSize = 0;
	    colorInfo->flags = 0;
	    }
	    break;

	case UGL_MODE_INFO_REQ:
	    {
	    UGL_MODE_INFO * modeInfo = (UGL_MODE_INFO *)info;
            modeInfo->width = pDriver->pMode->width;
            modeInfo->height = pDriver->pMode->height;
            modeInfo->colorDepth = pDriver->pMode->colorDepth;
            modeInfo->clutSize = 0;
            modeInfo->colorModel = UGL_DIRECT;
            modeInfo->colorFormat = UGL_RGB565;
            modeInfo->fbAddress = pGenDriver->fbAddress;
            modeInfo->displayMemAvail = 0;
	    modeInfo->flags = UGL_MODE_PAGING_ENABLED;
	    }
	    break;

        case UGL_EXT_INFO_REQ:
            {

#ifdef INCLUDE_UGL_EXT
        UGL_EXT_INFO * extInfo = (UGL_EXT_INFO *)info;
#endif /* INCLUDE_UGL_EXT */

#ifdef INCLUDE_UGL_JPEG
        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);
    }