ude506.c

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

        if ( destDdbId != UGL_DEFAULT_ID )
             break;

        } while ( uglClipListGet (gc, &clipRect, &pRegionRect) == UGL_STATUS_OK );

    return (UGL_STATUS_OK);
}




/*
 *  uglEpson8BitBitmapCreate - Create a bitmap for use in rendering images. 
 */
UGL_DDB *uglEpson8BitBitmapCreate
(
    UGL_UGI_DRIVER       * pDriver,	/* device context */
    UGL_DIB              * pDib,  	/* DIB to use for creation of a bitmap */
    UGL_DIB_CREATE_MODE    createMode, 	/* control bitmap initialization  */
    UGL_UINT32             initValue,    /* value to initialize DDB */
    UGL_MEM_POOL_ID        poolId        /* memory pool to contain bitmap */
)
{
    UGL_GENERIC_DRIVER   * pGenDriver = (UGL_GENERIC_DRIVER *)pDriver;
    UGL_EPSON_DDB        * pEpsonDdb  = UGL_NULL;
    UGL_GEN_DDB          * pDdb       = UGL_NULL;
    UINT32                 imageSize  = 0;
    UGL_RECT               srcRect;
    UGL_POINT              dstPt;
    UGL_BOOL               vram;
    UGL_INT16              stride;

    /* Reconcile memory pool */
    if (poolId == UGL_VIDEO_MEM_POOL_ID)
    {
        if (pGenDriver->videoMemPoolId == UGL_NULL)
            return( UGL_NULL );

        poolId = pGenDriver->videoMemPoolId;

	vram = UGL_TRUE;
    }
    else
	vram = UGL_FALSE;

    stride = ( ( ( pDib->width + 7 ) / 8 ) * 8 ) * sizeof( UGL_UINT8 );

    /* Get size of image */
    imageSize = pDib->height * stride;

    /* If image size is zero, illegal - return UGL_NULL */
    if ( imageSize == 0 ) return( UGL_NULL );

    /* Allocate the pBitmap structure. */
    pEpsonDdb = (UGL_EPSON_DDB *) uglMemCalloc ( poolId, 1, ( ( ( sizeof(UGL_EPSON_DDB)
                                                 + imageSize ) + 7 ) / 8 * 8 ) );

    if ( pEpsonDdb )
    {
        /* Initialize the header information. */
        pDdb                = (UGL_GEN_DDB *)pEpsonDdb;
        pDdb->header.width  = pDib->width;
        pDdb->header.height = pDib->height;
        pDdb->header.type   = UGL_DDB_TYPE;
        pDdb->colorDepth    = pDriver->pMode->colorDepth;
        pDdb->stride        = stride;

        /* image must be quad-word aligned */
        pDdb->image  = (void *) ( ( (int)pDdb + sizeof(UGL_EPSON_DDB) + 7 ) / 8 * 8 );
        pEpsonDdb->vram = vram;

        /* Initialize the DDB */
        switch (createMode)
        {
            case UGL_DIB_INIT_DATA:
            {
                int status;
	        srcRect.left   = srcRect.top  = 0;
	        srcRect.right  = pDib->width - 1;
	        srcRect.bottom = pDib->height - 1;
                dstPt.x        = dstPt.y = 0;

	        status = (*pDriver->bitmapWrite) ( pDriver, pDib, &srcRect, 
                                                   (UGL_DDB_ID)pDdb, &dstPt );
                if ( status == UGL_STATUS_ERROR )
                {
                   /* bitmap write failed, abort */
                   uglMemFree( pDdb );
                   return( UGL_NULL );
                }
                break;
	    }

            case UGL_DIB_INIT_VALUE:
		bfill( pDdb->image, pDdb->header.height * pDdb->stride, 
		       initValue );
                break;

            case UGL_DIB_INIT_NONE:
            default:
                break;
 	}
    }

    return( (UGL_DDB *) pDdb );
}

/*
 *  uglEpsonPageCreate - Create a page.
 */
UGL_PAGE * uglEpsonPageCreate
(
    UGL_UGI_DRIVER * pDriver
)
{
    UGL_PAGE  * pPage = UGL_NULL;
    UGL_DDB   * pDdb  = UGL_NULL;
    UGL_DIB     dib;

    if( UGL_NULL == ( pPage = (UGL_PAGE *)UGL_CALLOC( 1, sizeof(UGL_PAGE) ) ) )
	return( pPage );

    dib.height      = pDriver->pMode->height; 
    dib.width       = pDriver->pMode->width;
    dib.stride      = pDriver->pMode->width;
    dib.colorFormat = UGL_DEVICE_COLOR;
    dib.imageFormat = UGL_DIB_INDEXED_8;
    dib.pImage      = UGL_NULL;
    dib.pClut       = UGL_NULL;
    dib.clutSize    = 0;

    pDdb = (*pDriver->bitmapCreate) ( pDriver, &dib, UGL_DIB_INIT_VALUE,
				      0, UGL_VIDEO_MEM_POOL_ID );

    if( UGL_NULL == pDdb )
    { 
	UGL_FREE( pPage );
	return( UGL_NULL );
    }

    pPage->pDdb = pDdb;

    return( pPage );
}



/*
 *  uglEpsonPageDestroy - Destroy a page.
 */
UGL_STATUS uglEpsonPageDestroy
(
    UGL_UGI_DRIVER  * pDriver,
    UGL_PAGE        * pPage
)
{
    UGL_GENERIC_DRIVER *pGenDriver = (UGL_GENERIC_DRIVER *) pDriver;
    UGL_STATUS         status      = UGL_STATUS_ERROR;

    if ( pPage == pGenDriver->pVisiblePage || pPage == pGenDriver->pDrawPage )
         return ( status );

    status = (*pDriver->bitmapDestroy) ( pDriver, pPage->pDdb );

    UGL_FREE( pPage );

    return( status );
}



/*
 *  uglEpsonPageDrawSet - Set active drawing page.
 */
UGL_STATUS uglEpsonPageDrawSet
(
    UGL_UGI_DRIVER * pDriver,
    UGL_PAGE       * pPage
)
{

    UGL_GENERIC_DRIVER * pGenDriver = (UGL_GENERIC_DRIVER *)pDriver;

    pGenDriver->pDrawPage = pPage;

    return(UGL_STATUS_OK);
}



/*
 *  uglEpsonPageDrawGet - Get the active drawing page.
 */
UGL_STATUS uglEpsonPageDrawGet
(
    UGL_UGI_DRIVER *  pDriver,
    UGL_PAGE       ** pPage
)
{
    UGL_GENERIC_DRIVER * pGenDriver = (UGL_GENERIC_DRIVER *) pDriver;

    *pPage = pGenDriver->pDrawPage;

    return( UGL_STATUS_OK );
}



/*
 *  uglEpsonPageVisibleSet - Set the active display page.
 */
UGL_STATUS uglEpsonPageVisibleSet
(
    UGL_UGI_DRIVER * pDriver,
    UGL_PAGE       * pPage
)
{
    UGL_GENERIC_DRIVER * pGenDriver = (UGL_GENERIC_DRIVER *) pDriver;
    UGL_UINT32           address;

    address = (UGL_UINT32) ((UGL_GEN_DDB *) pPage->pDdb)->image - 
	      (UGL_UINT32) pGenDriver->fbAddress;

    address >>= 2;

    /* Make sure the Accelerator is not doing anything */
    if ( pGenDriver->gpBusy == UGL_TRUE )
	 if ( UGL_STATUS_OK != (*pGenDriver->gpWait) (pGenDriver) )
	      return( UGL_STATUS_ERROR );

    pGenDriver->pVisiblePage = pPage;

    return( UGL_STATUS_OK );
}



/*
 *  uglEpsonPageVisibleGet - Get the active display page.
 */
UGL_STATUS uglEpsonPageVisibleGet
(
    UGL_UGI_DRIVER *  pDriver,
    UGL_PAGE       ** pPage
)
{
    UGL_GENERIC_DRIVER * pGenDriver = (UGL_GENERIC_DRIVER *) pDriver;

    *pPage = pGenDriver->pVisiblePage;

    return ( UGL_STATUS_OK );
}



/*
 *  uglEpsonPageCopy - Copy the contents of one page to another.
 */
UGL_STATUS uglEpsonPageCopy
(
    UGL_UGI_DRIVER  * pDriver,
    UGL_PAGE        * srcPage,
    UGL_PAGE        * destPage
)
{
    UGL_STATUS status = UGL_STATUS_ERROR;
    UGL_RECT   sourceRect;
    UGL_POINT  destPoint;

    sourceRect.left   = 0;
    sourceRect.top    = 0;
    sourceRect.right  = srcPage->pDdb->width  - 1;
    sourceRect.bottom = srcPage->pDdb->height - 1;

    destPoint.x = 0;
    destPoint.y = 0;

    /* do the blt */
    status = (*pDriver->bitmapBlt) ( pDriver, srcPage->pDdb, &sourceRect, 
				     destPage->pDdb, &destPoint );

    return ( status );
}



/*
 *  uglEpsonSetRegs - Initialize registers.
 */
UGL_LOCAL void uglEpsonSetRegs(void)
{
   UGL_UINT16 i = 0;

   /* set register data to target display device */ 
   while( epsonModeTable[0].InitEpsonRegs[i][0] != 0xFFFF )
   {
       uglWriteByte( (UGL_UINT8 *) ( epsonModeTable[0].InitEpsonRegs[i][0] + pciBaseAddress ),
                     epsonModeTable[0].InitEpsonRegs[i][1] );
       i++;
   } 

   /* prevent showing garbage on display, clear the screen */
   uglWriteByte( (UGL_UINT8 *) (LUT_MODE_REG + pciBaseAddress ), 0x0); 
   uglWriteByte( (UGL_UINT8 *) ( LUT_ADDRESS_REG + pciBaseAddress ), 0x0 );

   for (i = 0; i < 256; ++i)
   {
       uglWriteByte( (UGL_UINT8 *) ( LUT_DATA_REG + pciBaseAddress ), 0x0 );
       uglWriteByte( (UGL_UINT8 *) ( LUT_DATA_REG + pciBaseAddress ), 0x0 );
       uglWriteByte( (UGL_UINT8 *) ( LUT_DATA_REG + pciBaseAddress ), 0x0 );
   } 
}




/*
* uglEpson8BitModeSet
*/
UGL_STATUS uglEpson8BitModeSet
(
    UGL_UGI_DRIVER * pDriver, 
    UGL_MODE       * pMode
)
{
    UGL_GENERIC_DRIVER * pGenDriver = (UGL_GENERIC_DRIVER *)pDriver;
    UGL_INT32            index;
    UGL_BOOL             allocate;
    UGL_EPSON_DDB      * pDdb;

    /* First time through, pMode will be NULL */
    if ( pDriver->pMode == UGL_NULL )
       allocate = UGL_TRUE;
    else
       allocate = UGL_FALSE;


    /* check if there is a rotation */ 
    if ( 
         (pEpsonModeTable->Flags) & mfR90 || 
         (pEpsonModeTable->Flags) & mfR270 
       )
       pDevModes->width       = pEpsonModeTable->StridePixels;/* Virtual window width */
    else
       pDevModes->width       = pEpsonModeTable->Width;

    pDevModes->height      = pEpsonModeTable->Height;
    pDevModes->colorDepth  = pEpsonModeTable->Bpp;
    pDevModes->refreshRate = pEpsonModeTable->Frequency;

    if ( ( pEpsonModeTable->Flags ) & mfLCD )
       pDevModes->monitorType = UGL_MODE_FLAT_PANEL;
    else