blt.cpp

Sm501 VGA芯片wince下驱动代码

		color = pBltParms->solidColor;
		if (pBltParms->pLookup)
			color = (pBltParms->pLookup)[color];
		if (pBltParms->pConvert)
			color = (pBltParms->pColorConverter->*(pBltParms->pConvert))(color);

		dwTransp = TRANSPARENCY_ENABLE
			| SRC_CONTROL_TRANSP
			| MATCH_PIXEL_TRANSP;
	}

#ifdef CMDLISTHBLT
    int    dwhostlinesize=Bytes8PerScan/4;
    DWORD  dwhostsize=(dimY-1)*dwhostlinesize;

    VALIDATE_SLOT(cmd_ptr, (24+(dwhostlinesize+2)*dimY+16));
    
    INSERTCMD_STATUS(cmd_ptr,
        FIELD_GET_MASK(CMD_INTPR_STATUS, 2D_ENGINE) |
        FIELD_GET_MASK(CMD_INTPR_STATUS, 2D_FIFO) |
        FIELD_GET_MASK(CMD_INTPR_STATUS, 2D_SETUP) |
        FIELD_GET_MASK(CMD_INTPR_STATUS, CSC_STATUS) |
        FIELD_GET_MASK(CMD_INTPR_STATUS, COMMAND_FIFO) |
        FIELD_GET_MASK(CMD_INTPR_STATUS, 2D_MEMORY_FIFO) ,
        FIELD_INIT(CMD_INTPR_STATUS, 2D_ENGINE, IDLE) |
        FIELD_INIT(CMD_INTPR_STATUS, 2D_FIFO, EMPTY) |
        FIELD_INIT(CMD_INTPR_STATUS, 2D_SETUP, IDLE) |
        FIELD_INIT(CMD_INTPR_STATUS, CSC_STATUS, IDLE) |
        FIELD_INIT(CMD_INTPR_STATUS, COMMAND_FIFO, EMPTY) |
        FIELD_INIT(CMD_INTPR_STATUS, 2D_MEMORY_FIFO, EMPTY)
        );
    INSERTCMD_LOADREG_D(cmd_ptr,   
        REG(DE_PITCH),
        FIELD_INIT_VAL(DE_PITCH, DESTINATION, dstWidth) |
        FIELD_INIT_VAL(DE_PITCH, SOURCE, dstWidth)
        );
    INSERTCMD_LOADREG_D(cmd_ptr, 
        REG(DE_WINDOW_WIDTH),
        FIELD_INIT_VAL(DE_WINDOW_WIDTH, DESTINATION, dstWidth) |
        FIELD_INIT_VAL(DE_WINDOW_WIDTH, SOURCE, dstWidth)
        );
    INSERTCMD_LOADREG_D(cmd_ptr,
        REG(DE_WINDOW_DESTINATION_BASE),
        ((SMISurf*) (pBltParms->pDst))->OffsetInVideoMemory()
        );
    if (pBltParms->bltFlags & BLT_TRANSPARENT)
    {
        INSERTCMD_LOADREG_D(cmd_ptr,
            REG(DE_COLOR_COMPARE),
            FIELD_INIT_VAL(DE_COLOR_COMPARE, COLOR, color)
            );
    }
    INSERTCMD_LOADREG_D(cmd_ptr,
        REG(DE_SOURCE),
        FIELD_INIT_VAL(DE_SOURCE, X_K1, 0) |
        FIELD_INIT_VAL(DE_SOURCE, Y_K2, srcY)
        );
    INSERTCMD_LOADREG_D(cmd_ptr,
        REG(DE_DESTINATION),
        FIELD_INIT_VAL(DE_DESTINATION, X, dstX) |
        FIELD_INIT_VAL(DE_DESTINATION, Y, dstY)
        );
    INSERTCMD_LOADREG_D(cmd_ptr,
        REG(DE_DIMENSION),
        FIELD_INIT_VAL(DE_DIMENSION, X, dimX) |
        FIELD_INIT_VAL(DE_DIMENSION, Y_ET, dimY)
        );
    INSERTCMD_LOADREG_D(cmd_ptr,
        REG(DE_CONTROL),
        FIELD_INIT(DE_CONTROL, STATUS, START) |
        FIELD_INIT(DE_CONTROL, UPDATE_DESTINATION_X, DISABLE) |
        FIELD_INIT(DE_CONTROL, QUICK_START, DISABLE) |
        FIELD_INIT(DE_CONTROL, DIRECTION, LEFT_TO_RIGHT) |
        FIELD_INIT(DE_CONTROL, HOST, COLOR) |
        FIELD_INIT(DE_CONTROL, COMMAND, HOST_WRITE) |
        dwTransp |
        FIELD_INIT(DE_CONTROL, ROP_SELECT, ROP3) |
        FIELD_INIT_VAL(DE_CONTROL, ROP, (pBltParms->rop4 & 0xFF))
        );
    
#else //------- CMDLISTHBLT --------	
    WaitForNotBusy();

	POKE_32(DE_WINDOW_DESTINATION_BASE,
		FIELD_VALUE(0, DE_WINDOW_DESTINATION_BASE, EXT, m_SMISettings.m_bUMA) |
		FIELD_VALUE(0, DE_WINDOW_DESTINATION_BASE, ADDRESS, 
			VgxSurfAddr(((SMISurf*) (pBltParms->pDst))->OffsetInVideoMemory())) |
		0);

	reg_SourceXY = srcY; // Src X always 0
	reg_DestXY   = (dstX << 16) | dstY;
	reg_DimXY    = (dimX << 16) | dimY;
	if (pBltParms->bltFlags & BLT_TRANSPARENT)
		reg_ColorCmp   = color;
 // Problem is on the Xscale 64bit PCI system. Data is 
// transfering in 64bit ( 2 (32bit) sets). The 1st set has byte enable & the 2nd set doesn't have.
// Which means 2 sets of DPR registers get written if the DPR register does not have byte enble
// status check. Our DPR34 and DPR38 registers does not have byte enble status check. 
// Therefore we need to save and restore DPR34 and DPR38 every time we write to DPR30 & DPR3C. 
// FW 7/26/05
	Pattern = PEEK_32(DPR+0x38);
	reg_RowPitch    = (dstWidth << 16) | dstWidth;
	reg_WindowWidth = (dstWidth << 16) | dstWidth;
	reg_PatternHigh = Pattern;
	reg_ROPCommand = (pBltParms->rop4 & 0xFF)
				   | CMD_HOSTBLT_WRITE
				   | dwTransp
				   | START_DRAWING_ENGINE;
#endif //CMDLISTHBLT
#if 1
	if (srcStride < 0)
	{
        // if the bitmap is from bottom to top, the first line need to special handling.
		if (nLong)
        {
#ifdef CMDLISTHBLT
            INSERTCMD_LOADREG_E(cmd_ptr, REG(DE_DATAPORT), ( nLong/4) );
#endif
            for (i=0;i<(nLong/4);i++)
            {
                memcpy(&m_ulSrc, (pSrcBuffer + i*4), 4);
#ifdef CMDLISTHBLT
                INSERTCMD_LOADDATA(cmd_ptr, m_ulSrc );
#else  //CMDLISTHBLT
                *(PULONG) m_pMMIO = m_ulSrc;
#endif
			}
#ifdef CMDLISTHBLT
            INSERTCMD_PADQWORD(cmd_ptr, ( nLong/4) );
#endif
		}
		if (BytesRemain)
		{
            memcpy(abyRemain, pSrcBuffer+nLong, BytesRemain);
#ifdef CMDLISTHBLT
            INSERTCMD_LOADREG_E(cmd_ptr, REG(DE_DATAPORT), 2 );
            INSERTCMD_LOADDATA(cmd_ptr, *(PULONG)abyRemain );
            INSERTCMD_LOADDATA(cmd_ptr, *(PULONG)(abyRemain+4) );
#else  //CMDLISTHBLT
			*(PULONG) m_pMMIO = *(PULONG)abyRemain;
			*(PULONG) m_pMMIO = *(PULONG)(abyRemain+4);
#endif //CMDLISTHBLT
		}
        pSrcBuffer += srcStride;
	}

#ifdef CMDLISTHBLT
    if (dimY>1) //aviod INSERTCMD_LOADREG_E() with counter 0 which cause hang
    {
        if (0) //Media player hang if transfer size is too big. dwhostsize< HOST_DATAPORT_SIZE/4) 
            //&& (dwhostsize < CMDLISTBUF_SIZE/4-4*CMD_STRIDE_DWORD))
        {
            INSERTCMD_LOADREG_E(cmd_ptr, REG(DE_DATAPORT), dwhostsize );
            for (i = 1; i < dimY; i++)
            {
                for (j=0;j<dwhostlinesize;j++)
                {
                    memcpy(&m_ulSrc, pSrcBuffer+j*4, 4);
                    INSERTCMD_LOADDATA(cmd_ptr, m_ulSrc );
                }
                pSrcBuffer += srcStride;
            }
            INSERTCMD_PADQWORD(cmd_ptr, dwhostsize );
        }
        else
        {
            for (i = 1; i < dimY; i++)
            {
                INSERTCMD_LOADREG_E(cmd_ptr, REG(DE_DATAPORT), dwhostlinesize );
                for (j=0;j<dwhostlinesize;j++)
                {
                    memcpy(&m_ulSrc, pSrcBuffer+j*4, 4);
                    INSERTCMD_LOADDATA(cmd_ptr, m_ulSrc );
                }
                INSERTCMD_PADQWORD(cmd_ptr, dwhostlinesize );
                pSrcBuffer += srcStride;
            }
        }
    }
#else  //CMDLISTHBLT
	for (i = 1; i < dimY; i++)
	{
		for (j=0;j<(Bytes8PerScan/4);j++)
		{
			memcpy(&m_ulSrc, pSrcBuffer+j*4, 4);
            *(PULONG) m_pMMIO = m_ulSrc;
		}
		pSrcBuffer += srcStride;
	}
#endif //CMDLISTHBLT

	if (srcStride > 0)
	{
        // if the bitmap is from top to bottom, the last line need to special handling.
		if (nLong)
		{
#ifdef CMDLISTHBLT
            INSERTCMD_LOADREG_E(cmd_ptr, REG(DE_DATAPORT), ( nLong/4) );
#endif
			for (i=0;i<(nLong/4);i++)
			{
				memcpy(&m_ulSrc, (pSrcBuffer + i*4), 4);
#ifdef CMDLISTHBLT
                INSERTCMD_LOADDATA(cmd_ptr, m_ulSrc );
#else  //CMDLISTHBLT
				*(PULONG) m_pMMIO = m_ulSrc;
#endif //CMDLISTHBLT
			}
#ifdef CMDLISTHBLT
            INSERTCMD_PADQWORD(cmd_ptr, ( nLong/4) );
#endif
		}
		if (BytesRemain)
		{
            memcpy(abyRemain, pSrcBuffer+nLong, BytesRemain);
#ifdef CMDLISTHBLT
            INSERTCMD_LOADREG_E(cmd_ptr, REG(DE_DATAPORT), 2 );
            INSERTCMD_LOADDATA(cmd_ptr, *(PULONG)abyRemain );
            INSERTCMD_LOADDATA(cmd_ptr, *(PULONG)(abyRemain+4) );
#else  //CMDLISTHBLT
			*(PULONG) m_pMMIO = *(PULONG)abyRemain;
			*(PULONG) m_pMMIO = *(PULONG)(abyRemain+4);
#endif //CMDLISTHBLT
		}
    }

#ifdef CMDLISTHBLT
    INSERTCMD_FINISH(cmd_ptr, 0);
    
    STOP_CI();
    WAIT_CI_STOP();
    
    INSERTCMD_NOP(last_finish_ptr);
    
    last_finish_ptr = cmd_ptr - CMD_STRIDE_DWORD;
    
    FLUSH_CMD();

    START_CI("CMDList HostBlt");

#endif //CMDLISTHBLT

#else 
	if (srcStride < 0)
	{
        // if the bitmap is from bottom to top, the first line need to special handling.
		memcpy(m_pMMIO, pSrcBuffer, nLong);
        if (BytesRemain) {
            memcpy(abyRemain, pSrcBuffer+nLong, BytesRemain);
			memcpy(m_pMMIO, abyRemain, 8);
        }

        pSrcBuffer += srcStride;
    }
    for (i=1; i < dimY; i++) 
    {
		memcpy(m_pMMIO, pSrcBuffer, Bytes8PerScan);
		pSrcBuffer += srcStride;
    }

	if (srcStride > 0)
	{
        // if the bitmap is from top to bottom, the last line need to special handling.
		memcpy(m_pMMIO, pSrcBuffer, nLong);
        if (BytesRemain) {
            memcpy(abyRemain, pSrcBuffer+nLong, BytesRemain);
			memcpy(m_pMMIO, abyRemain, 8);
        }
    }
#endif

//	RETAILMSG(1, (_T("SMI:: -SrcCopy\r\n")));
	return(S_OK);
}

SCODE SMI::CSCSrcCopy(GPEBltParms *pBltParms)
{
    DWORD origSrcDimX, origSrcDimY, origDestDimX, origDestDimY;
    DWORD ScaleXn, ScaleXd, ScaleYn, ScaleYd;
    DWORD SrcTn, SrcTd, SrcLn, SrcLd;
    DWORD SrcRn, SrcRd, SrcBn, SrcBd;
    DWORD SrcDimX, SrcDimY, DestDimX, DestDimY;
	DWORD SrcFormat, DstFormat, HFilter, VFilter, byOrder;
	DWORD SrcYBase, SrcUBase, SrcVBase, SrcYPitch, SrcUVPitch, SrcBpp;
	DWORD DestBase, DestPitch, DestHeight, DestWidth, DestBpp;

	BLTRECT bd;
	BLTRECT *pd = &bd;

	if (!(pBltParms->xPositive && pBltParms->yPositive))
		return EmulatedBlt(pBltParms);
	
	pd->rSrc = *pBltParms->prclSrc;
	pd->rOrigSrc = *pBltParms->prclSrc;
	pd->rDest = *pBltParms->prclDst;
	pd->rOrigDest = *pBltParms->prclDst;

	SrcBpp = EGPEFormatToBpp[((SMISurf*) (pBltParms->pSrc))->Format()] / 8;
	SrcYBase = ((SMISurf*) (pBltParms->pSrc))->OffsetInVideoMemory();
	SrcUBase = ((SMISurf*) (pBltParms->pSrc))->OffsetInVideoMemory();
	SrcVBase = ((SMISurf*) (pBltParms->pSrc))->OffsetInVideoMemory();
	DestBase = ((SMISurf*) (pBltParms->pDst))->OffsetInVideoMemory();
	SrcYPitch = ((SMISurf*) (pBltParms->pSrc))->AlignedWidth() * SrcBpp;
	SrcUVPitch = ((SMISurf*) (pBltParms->pSrc))->AlignedWidth() * SrcBpp;

	DestBpp = EGPEFormatToBpp[((SMISurf*) (pBltParms->pDst))->Format()] / 8;
	DestPitch = ((SMISurf*) (pBltParms->pDst))->AlignedWidth() * DestBpp;
	DestHeight = ((SMISurf*) (pBltParms->pDst))->Height();
	DestWidth = ((SMISurf*) (pBltParms->pDst))->Width();


	byOrder = 0;
	switch (SrcBpp)
	{
	case 2:
		SrcFormat = CSC_CONTROL_SOURCE_FORMAT_RGB565;			
		break;
	case 4:
		SrcFormat = CSC_CONTROL_SOURCE_FORMAT_RGB8888;
		break;
	default:
        DEBUGMSG(1, (TEXT("SMI::CSCSrcCopy - Unsupported screen bit-depth (%d)\r\n"), 
    	    	m_nScreenBpp));
       	return EmulatedBlt(pBltParms);
	}

	switch (DestBpp)
	{
	case 2:
		DstFormat = CSC_CONTROL_DESTINATION_FORMAT_RGB565;
		break;
	case 4:
		DstFormat = CSC_CONTROL_DESTINATION_FORMAT_RGB8888;
		break;
	default:
		DEBUGMSG(1, (TEXT("ERROR! SMI::CSCSrcCopy() - CSC Dst Format Unsupported - iDestBpp = %d\r\n"),DestBpp));
       	return EmulatedBlt(pBltParms);
		break;		
	}

	HFilter = CSC_CONTROL_HORIZONTAL_FILTER_ENABLE;
	VFilter = CSC_CONTROL_VERTICAL_FILTER_ENABLE;

	if ((pd->rOrigSrc.right == 0) &&
		(pd->rOrigSrc.left == 0) &&
		(pd->rOrigSrc.bottom == 0) &&
		(pd->rOrigSrc.top == 0))
	{
		pd->rOrigSrc = pd->rSrc;
	}

	if ((pd->rOrigDest.right == 0) &&
		(pd->rOrigDest.left == 0) &&
		(pd->rOrigDest.bottom == 0) &&
		(pd->rOrigDest.top == 0))
	{
		pd->rOrigDest = pd->rDest;
	}

    origSrcDimX = pd->rOrigSrc.right - pd->rOrigSrc.left;
    origSrcDimY = pd->rOrigSrc.bottom - pd->rOrigSrc.top;

    origDestDimX = pd->rOrigDest.right - pd->rOrigDest.left;
    origDestDimY = pd->rOrigDest.bottom - pd->rOrigDest.top;

	if ((origSrcDimX <= 1) ||
		(origSrcDimY <= 1) ||
		(origDestDimX <= 1) ||
		(origDestDimY <= 1))
		return EmulatedBlt(pBltParms);		
                    
    ScaleXn = (origSrcDimX-1)/(origDestDimX-1);
    ScaleXd = ((origSrcDimX-1)<<13)/(origDestDimX-1) - (ScaleXn<<13);

    ScaleYn = (origSrcDimY-1)/(origDestDimY-1);
    ScaleYd = ((origSrcDimY-1)<<13)/(origDestDimY-1) - (ScaleYn<<13);            

    SrcLn = pd->rSrc.left;
    SrcLd = 0;

    SrcRn = pd->rSrc.right;
    SrcRd = 0;

    SrcTn = pd->rSrc.top;
    SrcTd = 0;

    SrcBn = pd->rSrc.bottom;
    SrcBd = 0;

    SrcDimX = pd->rSrc.right - pd->rSrc.left;
    SrcDimY = pd->rSrc.bottom - pd->rSrc.top;

    DestDimX = pd->rDest.right - pd->rDest.left;
    DestDimY = pd->rDest.bottom - pd->rDest.top;

	WaitForNotBusy();

  	POKE_32(CSC_CONSTANTS, 
		FIELD_VALUE(0, CSC_CONSTANTS, Y, 0) |
		FIELD_VALUE(0, CSC_CONSTANTS, R, 0) |
		FIELD_VALUE(0, CSC_CONSTANTS, G, 0) |
		FIELD_VALUE(0, CSC_CONSTANTS, B, 0) |
		0);

	POKE_32(CSC_Y_SOURCE_X, 
		FIELD_VALUE(0, CSC_Y_SOURCE_X, INTEGER, SrcLn) |
		FIELD_VALUE(0, CSC_Y_SOURCE_X, FRACTION, SrcLd) |
		0);