dispdrvr.c

Xcale270Bsp包,wince平台

	pCameraApp->bFrame_available = (XllpCAMERA.block_header != XllpCAMERA.block_tail);
	LeaveCriticalSection(&CameraMutex);
}

void CameraStartVideoCapture()
{
	EnterCriticalSection(&CameraMutex);
	XllpCameraStartVideoCapture(&XllpCAMERA, 0);
	LeaveCriticalSection(&CameraMutex);
}

void CameraStopVideoCapture()
{
	EnterCriticalSection(&CameraMutex);
	XllpCameraStopVideoCapture(&XllpCAMERA);
	XllpCAMERA.capture_status &= ~XLLP_CAMERA_STATUS_VIDEO_CAPTURE_IN_PROCESS;
	LeaveCriticalSection(&CameraMutex);
}

void CameraCaptureStillImage()
{
	EnterCriticalSection(&CameraMutex);
	XllpCameraCaptureStillImage(&XllpCAMERA, 0);
	LeaveCriticalSection(&CameraMutex);
}


void InitCursor()
{
	gDrawCursorFlag = FALSE;
	gCursorRect.left = (DispDrvr_cxScreen - CURSOR_XSIZE) >> 1;
	gCursorRect.right = gCursorRect.left + CURSOR_XSIZE;
	gCursorRect.top = (DispDrvr_cyScreen - CURSOR_YSIZE) >> 1;
	gCursorRect.bottom = gCursorRect.top + CURSOR_YSIZE;
	gxHot = gyHot = 0;
	memset ((BYTE *)gCursorMask, 0xFF, sizeof(gCursorMask));
}
	

BOOL MapVirtualAddress()
{
///

	v_pDMAC = (P_XLLP_DMAC_T)VirtualAllocCopy(sizeof(XLLP_DMAC_T),"DispDrvrInitialize : v_pDMAC",(PVOID)(DMAC_BASE_U_VIRTUAL));
	if (!v_pDMAC)
	{
		Cleanup();
		return FALSE;
	}

	v_pI2C = (volatile unsigned int *)VirtualAllocCopy(sizeof(I2C_REGS),"DispDrvrInitialize : v_pOSTRegs",(PVOID)(I2C_BASE_U_VIRTUAL));
	if (!v_pI2C)
	{
		Cleanup();
		return FALSE;
	}

    v_pOSTRegs = (volatile unsigned int *)VirtualAllocCopy(sizeof(XLLP_OST_T),"DispDrvrInitialize : v_pOSTRegs",(PVOID)(OST_BASE_U_VIRTUAL));
	if (!v_pOSTRegs)
	{
		Cleanup();
		return FALSE;
	}
    v_pCIRegs = (volatile unsigned int *)VirtualAllocCopy(1024,"DispDrvrInitialize : v_pCIRegs",(PVOID)(CMRA_BASE_U_VIRTUAL));
	if (!v_pCIRegs)
	{
		Cleanup();
		return FALSE;
	}

    v_pCameraDescriptors = (volatile unsigned int *)VirtualAllocCopy(1024,"DispDrvrInitialize : v_pCameraDescriptors",(PVOID)(CAM_DMA_DESCRIPTOR_BASE_U_VIRTUAL));
	if (!v_pCameraDescriptors)
	{
		Cleanup();
		return FALSE;
	}

    v_pCameraDMABuffers = (volatile unsigned int *)VirtualAllocCopy(CAMERA_DMA_BUFFER_SIZE,"DispDrvrInitialize : v_pCameraDMABuffers",(PVOID)(CAM_DMA_BUFFER_U_VIRTUAL));
	if (!v_pCameraDMABuffers)
	{
		Cleanup();
		return FALSE;
	}

///
    v_pLcdRegs = (volatile LCDRegs *)VirtualAllocCopy(sizeof(LCDRegs),"DispDrvrInitialize : v_pLcdRegs",(PVOID)(LCD_BASE_U_VIRTUAL));
	if (!v_pLcdRegs)
	{
		Cleanup();
		return FALSE;
	}

	v_pClkRegs = (volatile XLLP_CLKMGR_T *)VirtualAllocCopy(sizeof(XLLP_CLKMGR_T),"DispDrvrInitialize : v_pClkRegs",(PVOID)(CLK_BASE_U_VIRTUAL));
	if (!v_pClkRegs)
	{
		Cleanup();
		return FALSE;
	}
	
	v_pGPIORegs = (volatile XLLP_GPIO_T *)VirtualAllocCopy(sizeof(XLLP_GPIO_T),"DispDrvrInitialize : v_pGPIORegs",(PVOID)(GPIO_BASE_U_VIRTUAL));
	if (!v_pGPIORegs)
	{
		Cleanup();
		return FALSE;
	}

	frameDescriptorCh0fd1 = (volatile LCD_FRAME_DESCRIPTOR *)VirtualAllocCopy(sizeof(LCD_FRAME_DESCRIPTOR), "DispDrvrInitialize : lcdFrameDescriptor", (PVOID)(DMA_CHANNEL_0_FRAME_DESCRIPTOR_BASE_VIRTUAL));
	if (!frameDescriptorCh0fd1)
	{
		Cleanup();
		return FALSE;
	}

	frameDescriptorCh0fd2 = (volatile LCD_FRAME_DESCRIPTOR *)VirtualAllocCopy(sizeof(LCD_FRAME_DESCRIPTOR), "DispDrvrInitialize : lcdFrameDescriptor", (PVOID)(DMA_CHANNEL_0_ALT_FRAME_DESCRIPTOR_BASE_VIRTUAL));
	if (!frameDescriptorCh0fd2)
	{
		Cleanup();
		return FALSE;
	}
	
	frameDescriptorCh1 = (volatile LCD_FRAME_DESCRIPTOR *)VirtualAllocCopy(sizeof(LCD_FRAME_DESCRIPTOR), "DispDrvrInitialize : lcdFrameDescriptor", (PVOID)(DMA_CHANNEL_1_FRAME_DESCRIPTOR_BASE_VIRTUAL));
	if (!frameDescriptorCh1)
	{
		Cleanup();
		return FALSE;
	}

	frameDescriptorPalette = (volatile LCD_FRAME_DESCRIPTOR *)VirtualAllocCopy(sizeof(LCD_FRAME_DESCRIPTOR), "DispDrvrInitialize : lcdFrameDescriptor", (PVOID)(PALETTE_FRAME_DESCRIPTOR_BASE_VIRTUAL));
	if (!frameDescriptorPalette)
	{
		Cleanup();
		return FALSE;
	}

	v_pPaletteBuffer=(volatile LCD_PALETTE *)VirtualAllocCopy(sizeof(LCD_PALETTE),"DispDrvrInitialize : v_pPaletteBuffer",(PVOID)PALETTE_BUFFER_BASE_VIRTUAL);
	if (!v_pPaletteBuffer)
	{
		Cleanup();
		return FALSE;
	}

	// Enter into Kernel mode to enable us to modify the section descriptor
	// so that we may set the bufferable bit.  This enables write coalescing
	// for frame buffer writes when using the section mapped address.
	// 
	// GAPI uses the section mapped address always.  


	SetKMode(TRUE);
	// Now configure the frame buffer's section descriptor.
	// The function GetDescriptorAddress shows how to obtain the correct descriptor address.
	// This descriptor is one of two descriptors that map the the frame buffer.
	// The first descriptor found maps the cached virtual address, while the second
	// descriptor found maps the uncached virtual address.  We want to modify the 
	// second descriptor, that which maps the uncached virtual address since the uncached virtual 
	// address is the address we've chosen to use throughout the codebase.
	//
	ConfigureFrameBufferSectionDescriptor(GetDescriptorAddress(FRAME_BUFFER_BASE_PHYSICAL));
	//
	// NOTE:
	// The section descriptor covers a 1MB section.  If the frame buffer ever exceeds 1MB
	// in size, you'll need to modify additional section descriptors.
	//
	
#ifdef IMGNOTALLKMODE

	SetKMode(FALSE);

	gFrameBuffer = (PBYTE)VirtualAllocCopy(frameBufferSize*NUM_FRAME_BUFFERS,"gFrameBuffer",(PVOID)(FRAME_BUFFER_0_BASE_VIRTUAL));
	if (!gFrameBuffer)
	{
		Cleanup();
		return FALSE;
	}	

	if (bDoRotation)
	{
		// if rotating the display, the actual frame buffer should be configured as bufferable for max write performance into the frame buffer.
		VirtualSetAttributes(gFrameBuffer, frameBufferSize*NUM_FRAME_BUFFERS, 4, 4, NULL);
	}
	else
	{
		// if not rotating the dispay, we can draw directly into the frame buffer, and use write-through cache mode to improve frame buffer throughput
		VirtualSetAttributes(gFrameBuffer, frameBufferSize*NUM_FRAME_BUFFERS, 8, 8, NULL);
	}

#else

	// The GDI will use the section mapped address for the frame buffer.
	// The cacheable/bufferable attributes are configured above in the call to ConfigureFrameBufferSectionDescriptor().
	gFrameBuffer = (PBYTE)(FRAME_BUFFER_0_BASE_VIRTUAL);

#endif

	gBlankFrameBuffer = (PBYTE) VirtualAlloc(0, frameBufferSize, MEM_RESERVE | MEM_COMMIT,PAGE_READWRITE);
	if (!gBlankFrameBuffer)
	{
		Cleanup();
		return FALSE;
	}

	v_pBoardLevelRegister=(volatile BLR_REGS *)VirtualAllocCopy(sizeof(BLR_REGS),"DispDrvrInitialize : v_pPaletteBuffer",(PVOID)FPGA_REGS_BASE_U_VIRTUAL);
	if (!v_pBoardLevelRegister)
	{
		Cleanup();
		return FALSE;
	}

	return TRUE;
}


// Free all the global memory resources
void Cleanup(void)
{
	if (v_pLcdRegs)
	{
		VirtualFree((PVOID)v_pLcdRegs,0,MEM_RELEASE);
		v_pLcdRegs = NULL;
	}
    if (v_pClkRegs)
	{
		VirtualFree((PVOID)v_pClkRegs,0,MEM_RELEASE);
		v_pLcdRegs = NULL;
	}
	if (v_pGPIORegs)
	{
		VirtualFree((PVOID)v_pGPIORegs,0,MEM_RELEASE);
		v_pGPIORegs = NULL;
	}

	if (frameDescriptorCh0fd1)
	{
		VirtualFree((PVOID)frameDescriptorCh0fd1,0,MEM_RELEASE);
		frameDescriptorCh0fd1 = NULL;
	}
	
    if (frameDescriptorCh0fd2)
	{
		VirtualFree((PVOID)frameDescriptorCh0fd2,0,MEM_RELEASE);
		frameDescriptorCh0fd2 = NULL;
	}
	
    if (frameDescriptorCh1)
	{
		VirtualFree((PVOID)frameDescriptorCh1,0,MEM_RELEASE);
		frameDescriptorCh1 = NULL;
	}

    if (frameDescriptorPalette)
	{
		VirtualFree((PVOID)frameDescriptorPalette,0,MEM_RELEASE);
		frameDescriptorPalette = NULL;
	}

	if (v_pPaletteBuffer)
	{
		VirtualFree((PVOID)v_pPaletteBuffer,0,MEM_RELEASE);
		v_pPaletteBuffer = NULL;
	}

    if (gFrameBuffer)
	{
		VirtualFree((PVOID)gFrameBuffer,0,MEM_RELEASE);
		gFrameBuffer = NULL;
	}

    if (v_pBoardLevelRegister)
	{
		VirtualFree((PVOID)v_pBoardLevelRegister,0,MEM_RELEASE);
		v_pBoardLevelRegister = NULL;
	}

    if (frameDescriptorCh2_YCbCr_Y)
	{
		VirtualFree((PVOID)frameDescriptorCh2_YCbCr_Y,0,MEM_RELEASE);
		frameDescriptorCh2_YCbCr_Y = NULL;
	}

    if (frameDescriptorCh3_YCbCr_Cb)
	{
		VirtualFree((PVOID)frameDescriptorCh3_YCbCr_Cb,0,MEM_RELEASE);
		frameDescriptorCh3_YCbCr_Cb = NULL;
	}

    if (frameDescriptorCh4_YCbCr_Cr)
	{
		VirtualFree((PVOID)frameDescriptorCh4_YCbCr_Cr,0,MEM_RELEASE);
		frameDescriptorCh4_YCbCr_Cr = NULL;
	}
}

void DispDrvrPowerHandler(BOOL	bOff)
{

	if(bOff) 
	{
		//新增调试信息
		RETAILMSG(1,(TEXT("Power Off LCD\r\n")));
		
		SHOW_DBGTRACE_SR(TEXT("+LCD driver: suspend\r\n"));

		// Copy the active frame buffer into a temporary buffer
		// because we are going to write over the active frame buffer
		// with a blank all black display.  When we restore the display
		// when we wake up, we want to be able to copy the original 
		// frame buffer back in.
		CopyFrameBuffer(TRUE);

		// Turn the display to black
		// and allow a few frames to display
		ClearFrameBuffer(FALSE);
		
		XllpLCDSuspend(&XllpLCD, Suspend_Graceful);

		SHOW_DBGTRACE_SR(TEXT("-LCD driver: suspend\r\n"));
		SHOW_DBGTRACE_SR_WAIT();

	}
	else
	{
		//新增调试信息
		RETAILMSG(1,(TEXT("Power On LCD\r\n")));	
		
		SHOW_DBGTRACE_SR(TEXT("+LCD driver: resume\r\n"));
		// Copy the original frame buffer back in.
		CopyFrameBuffer(FALSE);

		XllpLCDResume(&XllpLCD);
		
		SHOW_DBGTRACE_SR(TEXT("-LCD driver: resume\r\n"));
		SHOW_DBGTRACE_SR_WAIT();
		
	}
}

void CopyFrameBuffer(BOOL gDirection)
{
	DWORD i;
	unsigned *cfbp;
	unsigned *fbp;

	cfbp=(unsigned *)gBlankFrameBuffer;
	fbp=(unsigned *)gFrameBuffer+(activeFrameBuffer*frameBufferSize);


	for(i=0;i<(DispDrvr_cxScreen*DispDrvr_cyScreen*(bpp/8)/4);i++) 
	{

		if (gDirection)
		  *cfbp++ = *fbp++; 
		else 
		  *fbp++ = *cfbp++; 
	}	
}

void ClearFrameBuffer(BOOL color)
{

	DWORD i;
	unsigned *fbp;

	fbp=(unsigned *)gFrameBuffer+(activeFrameBuffer*frameBufferSize);
	for(i=0;i<(DispDrvr_cxScreen*DispDrvr_cyScreen*(bpp/8)/4);i++) 
	{
		if (color)
		  *fbp++ = 0xFFFFFFFF;   // Ones turn it white
		else	   
		  *fbp++ = 0x00000000;  // Zeros turn it black
	}

}

//**********************************************************************
//
//DispDrvrContrastControl:
//
//	Modify the contrast according to the Cmd parameter.
// Not supported
//

BOOL DispDrvrContrastControl(int Cmd,DWORD *pValue)
{
// currently does not support changing contrast in software. 
	return TRUE;
}

void DirtyRectDumpPortraitLoop_C(BYTE	*pDstBuf, BYTE  *pSrcBuf, DWORD	yTop, DWORD yBottom,
								 DWORD srcWidthB, DWORD	bytesPerRow, DWORD bytesPerPixel,
								 DWORD srcMarginWidth, DWORD dstMarginWidth) 
{
	DWORD   row,i,j;

	if ( bytesPerPixel != 2 ) {
		//not 16-bit
		for (i=0;i<srcWidthB/bytesPerPixel;i++) {
			for (row=yTop;row < yBottom;row++) {
				for (j=0;j<bytesPerPixel;j++) {
					*pDstBuf++=*(pSrcBuf+j);
				}
				pSrcBuf-=bytesPerRow;
			}
			pDstBuf+=dstMarginWidth;
			pSrcBuf+=srcMarginWidth+2;