ude506ind8.c

atmel9200 vxworks bsp

    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 );
    }

#endif /* EPSON_ACCEL_BITMAP  */


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

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

    }




/*****************************************************************************
*
* uglEpsonCreateModes
*
*/
UGL_LOCAL UGL_STATUS uglEpsonCreateModes
    (
    UGL_UGI_DRIVER * pDriver 
    )
    {
    int                  i;
    UGL_EPSON_DRIVER  *  pEpsonDriver = (UGL_EPSON_DRIVER *)pDriver;
    UGL_MODE          *  pModes;
 
    /* Allocate mode list data structure */
    pModes = UGL_MALLOC(sizeof(UGL_MODE) * NELEMENTS(epsonModeTable));
    pEpsonDriver->pModes = pModes;

    for (i = 0; i < NELEMENTS(epsonModeTable); i++) 
        {
        /* check if there is a rotation */ 
        if ((epsonModeTable[i].ModeInfo.Flags) & mfR90 || 
            (epsonModeTable[i].ModeInfo.Flags) & mfR270)
            pModes[i].width = epsonModeTable[i].ModeInfo.StridePixels;
        else
            pModes[i].width = epsonModeTable[i].ModeInfo.Width;

        pModes[i].height      = epsonModeTable[i].ModeInfo.Height;
        pModes[i].colorDepth  = epsonModeTable[i].ModeInfo.Bpp;
        pModes[i].refreshRate = epsonModeTable[i].ModeInfo.Frequency;

        if ((epsonModeTable[i].ModeInfo.Flags ) & mfLCD )
           pModes[i].monitorType = UGL_MODE_FLAT_PANEL;
        else
           pModes[i].monitorType = UGL_MODE_CRT;

        pModes[i].flags = UGL_MODE_INDEXED_COLOR;
        }

    return(UGL_STATUS_OK);
}
    

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

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

    index = uglGenericModeFind (pEpsonDriver->pModes, pMode, NELEMENTS(epsonModeTable));
    
    if ( index > -1 )
       pDriver->pMode = &pEpsonDriver->pModes[index];

    else
	return( UGL_STATUS_ERROR );

    /* Select appropriate bitblt for mode */

#ifdef EPSON_ACCEL_BITMAP
    if ( (epsonModeTable[index].ModeInfo.Flags) & mfHWBLT )
        pDriver->bitmapBlt                = uglEpson8BitBitmapBlt;
    else
        pDriver->bitmapBlt                = uglGeneric8BitBitmapBlt;
#endif /*  EPSON_ACCEL_BITMAP */
    
    /* map frame buffer address */
     pGenDriver->fbAddress = (UGL_UINT8 *) ( pciBaseAddress + FRAME_BUFFER_OFFSET );

    /* initialize registers */
    uglEpsonSetRegs(index);


    /* Create pageZero (mandatory) */
    if ( allocate == UGL_TRUE )
        {
	pDriver->pPageZero       = (UGL_PAGE *)      UGL_CALLOC(1, sizeof(UGL_PAGE));
	pDdb                     = (UGL_EPSON_DDB *) UGL_CALLOC(1, sizeof(UGL_EPSON_DDB));
	pDriver->pPageZero->pDdb = (UGL_DDB *)       pDdb;
        }

    pDriver->pPageZero->pDdb->height                        = pMode->height;
    pDriver->pPageZero->pDdb->width                         = pMode->width;
    pDriver->pPageZero->pDdb->type                          = UGL_DDB_TYPE;
    pGenDriver->pVisiblePage                                = pDriver->pPageZero;
    pGenDriver->pDrawPage                                   = pDriver->pPageZero;
    ((UGL_GEN_DDB   *)pDriver->pPageZero->pDdb)->stride     = pMode->width;
    ((UGL_GEN_DDB   *)pDriver->pPageZero->pDdb)->colorDepth = pMode->colorDepth;
    ((UGL_EPSON_DDB *)pDriver->pPageZero->pDdb)->vram       = UGL_TRUE;
    ((UGL_GEN_DDB   *)pDriver->pPageZero->pDdb)->image      = pGenDriver->fbAddress;

    /* Make sure the graphics processor is ready to go*/
    uglEpsonGpWait(pGenDriver);


    /* Clear the screen */
    memset( pGenDriver->fbAddress, 0x0, pDriver->pMode->width * 
            pDriver->pMode->height * (pDriver->pMode->colorDepth / 8));

    return(UGL_STATUS_OK);
    }
    



/*****************************************************************************
*
*  uglEpson8BitModeAvailGet - Get the available graphics modes from driver.
* 
*/
UGL_LOCAL UGL_STATUS uglEpson8BitModeAvailGet 
    (
    UGL_UGI_DRIVER  *  pDriver, 
    UGL_UINT32      *  pNumModes, 
    const UGL_MODE  ** pModeArray
    )
    {

     UGL_EPSON_DRIVER  *  pEpsonDriver = (UGL_EPSON_DRIVER *)pDriver;

    *pModeArray = pEpsonDriver->pModes;
    *pNumModes  = NELEMENTS(epsonModeTable);

    return( UGL_STATUS_OK );
    }

#ifdef INCLUDE_UGL_DOUBLE_BUFFERING
/*****************************************************************************
*
* uglEpsonPageCreate - Create a page.
*
*
*
*/
UGL_LOCAL 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_LOCAL 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_LOCAL 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_LOCAL 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_LOCAL 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_LOCAL 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_LOCAL 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 );
    }
#endif /* INCLUDE_UGL_DOUBLE_BUFFERING */