ude506direct.c

atmel9200 vxworks bsp

                /* Same DDB and source left of destination */

                xStart = UGL_RECT_WIDTH(destRect) - 1;
                xEnd = -1;
                xIncrement = -1;
                }

            if (pSrcDdb != pDstDdb || srcRect.top >= destRect.top)
                {
                /* Different DDBs or source below destination */

                yStart = srcRect.top;
                yEnd = srcRect.bottom + 1;
                yIncrement = 1;
                }
            else
                {
                /* Same DDB and source above destination */

                yStart = srcRect.bottom;
                yEnd = srcRect.top - 1;
                yIncrement = -1;
                sourceFirstPixelIndex += sourceStride *
                                         (UGL_RECT_HEIGHT(destRect) - 1);
                sourceStride = -sourceStride;
                destFirstPixelIndex += destStride *
                                       (UGL_RECT_HEIGHT(destRect) - 1);
                destStride = -destStride;
                }

            pSourceData = (UGL_UINT16 *)pSourceData + sourceFirstPixelIndex;
            pDestData = (UGL_UINT16 *)pDestData + destFirstPixelIndex;

            /* wait for graphics processor */
	    if ( pDriver->gpBusy == UGL_TRUE )
	       if ( UGL_STATUS_OK != (*pDriver->gpWait) (pDriver) )
		  return( UGL_STATUS_ERROR );

	    if ( pDriver->gpBusy == UGL_TRUE)
               if ( UGL_STATUS_OK != (*pDriver->gpWait) (pDriver) )
		  return(UGL_STATUS_ERROR );

            if ( UGL_DISPLAY_ID == (UGL_DDB *)pSrcDdb && 
		 UGL_DISPLAY_ID == (UGL_DDB *)pDstDdb )
               uglEpson16BitFrameToFrameBitBlit( devId, pSourceData, &srcRect,
                                                sourceStride, pDestData, &destRect,
                                                destStride);

	    else if ((( UGL_EPSON_DDB * ) pSrcDdb )->vram == UGL_TRUE &&
		      (( UGL_EPSON_DDB * ) pDstDdb )->vram == UGL_TRUE)
                    uglEpson16BitFrameToFrameBitBlit( devId, pSourceData, &srcRect,
                                                     sourceStride, pDestData, &destRect,
                                                     destStride );

	    else if (((UGL_EPSON_DDB *)pSrcDdb)->vram == UGL_TRUE &&
		      UGL_DISPLAY_ID == (UGL_DDB *)pDstDdb )
                    uglEpson16BitFrameToFrameBitBlit( devId, pSourceData, &srcRect,
                                                     sourceStride, pDestData, &destRect,
                                                     destStride );

	    else if ( ( ( UGL_EPSON_DDB *)pDstDdb )->vram == UGL_TRUE &&
		      UGL_DISPLAY_ID == (UGL_DDB *)pSrcDdb)
                    uglEpson16BitFrameToFrameBitBlit(devId, pSourceData, &srcRect,
                                             sourceStride, pDestData, &destRect,
                                             destStride);
	    else
                    uglEpson16BitMemoryToFrameColorBitBlit( devId, pSourceData, 
                                                           &srcRect, sourceStride, 
                                                           pDestData, &destRect, 
                                                           destStride );
            }

        if ( destDdbId != UGL_DEFAULT_ID )
             break;

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

    return (UGL_STATUS_OK);
    }

#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_DIRECT_COLOR;
        }

    return(UGL_STATUS_OK);
}
    

/*****************************************************************************
*
* uglEpson16BitModeSet
*
*/
UGL_LOCAL UGL_STATUS uglEpson16BitModeSet
    (
    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;
    unsigned short *lcd_addr;
    unsigned int count,count1;
    unsigned short usColor;

    /* 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                = uglEpson16BitBitmapBlt;
    else
        pDriver->bitmapBlt                = uglGeneric16BitBitmapBlt;
#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 *//*dongliang error*/
    memset( pGenDriver->fbAddress, 0x0, pDriver->pMode->width * 
            pDriver->pMode->height * (pDriver->pMode->colorDepth / 8));  
      
    /*  memset( pGenDriver->fbAddress, 0xFFFF, 307200); */
/*    	lcd_addr=(unsigned short *)REG_LCD_DATA;
    	count1=307200;
    	usColor = 0x0;
    		for(count=0;count<count1;count++)	
	{
		*lcd_addr=usColor;
		lcd_addr++;
	}*/
    return(UGL_STATUS_OK);
    }
    



/*****************************************************************************
*
*  uglEpson16BitModeAvailGet - Get the available graphics modes from driver.
* 
 */
UGL_LOCAL UGL_STATUS uglEpson16BitModeAvailGet 
    (
    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

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


#endif /* INCLUDE_UGL_DOUBLE_BUFFERING */