lcdgpe.cpp

AU1100嵌入式处理器lcd显示驱动程序

		case 3: return 8; break;
		case 4: return 12; break;
		case 5: return 16; break;
		default:return -1; break;
	}
}

/********************************************************************/
Au1100LCD::Au1100LCD()
{
	PHYSICAL_ADDRESS	PhysAddr;
	int DispAtInit, Rotation;
	int panel = 0;

	DEBUGMSG (1, (TEXT("Au1100LCD::Au1100LCD!!!\r\n") ));

#ifdef DDRAW_ENABLE
   m_pModeEx = NULL;
   m_dwPhysicalModeID = 0;
#endif // DDRAW_ENABLE

	// platform specific code to determine panel
	// should set panel variable appropriately
#ifdef PLATFORM_AU1100LCD_PANEL_SELECT_CODE
	PLATFORM_AU1100LCD_PANEL_SELECT_CODE
#endif

	if (panel >= NUM_PANELS) {
		panel = 0;
	}

	m_mode = &panels[panel];

	RETAILMSG(1,(TEXT("\r\n\r\nUsing panel %d %s\r\n\r\n"),
		panel, m_mode->description));

	m_ModeInfo.modeId = 0;
	switch (m_mode->mode_control & LCD_CONTROL_SM)
	{
	case LCD_CONTROL_SM_0:
		m_ModeInfo.width = (m_mode->mode_horztiming & LCD_HORZTIMING_PPL) + 1;
		m_ModeInfo.height = (m_mode->mode_verttiming & LCD_VERTTIMING_LPP) + 1;
		if (isDSTN(m_mode->mode_control)) m_ModeInfo.height *= 2;
		m_iRotate = DMDO_0;
		break;
	case LCD_CONTROL_SM_180:
		m_ModeInfo.width = (m_mode->mode_horztiming & LCD_HORZTIMING_PPL) + 1;
		m_ModeInfo.height = (m_mode->mode_verttiming & LCD_VERTTIMING_LPP) + 1;
		if (isDSTN(m_mode->mode_control)) m_ModeInfo.height *= 2;
		m_iRotate = DMDO_180;
		break;
	case LCD_CONTROL_SM_90:
		m_ModeInfo.height = (m_mode->mode_horztiming & LCD_HORZTIMING_PPL) + 1;
		m_ModeInfo.width = (m_mode->mode_verttiming & LCD_VERTTIMING_LPP) + 1;
		if (isDSTN(m_mode->mode_control)) m_ModeInfo.width *= 2;
		m_iRotate = DMDO_90;
		break;
	case LCD_CONTROL_SM_270:
		m_ModeInfo.height = (m_mode->mode_horztiming & LCD_HORZTIMING_PPL) + 1;
		m_ModeInfo.width = (m_mode->mode_verttiming & LCD_VERTTIMING_LPP) + 1;
		if (isDSTN(m_mode->mode_control)) m_ModeInfo.width *= 2;
		m_iRotate = DMDO_270;
		break;
	}

	m_ModeInfo.Bpp = getBpp(m_mode->mode_control);
	if (m_ModeInfo.Bpp == 12) m_ModeInfo.Bpp = 16;
	m_ModeInfo.frequency = 70; /* FIX ? !! */
	switch (m_ModeInfo.Bpp)
	{
		case 1: m_ModeInfo.format = gpe1Bpp; break;
		case 2: m_ModeInfo.format = gpe2Bpp; break;
		case 4: m_ModeInfo.format = gpe4Bpp; break;
		case 8: m_ModeInfo.format = gpe8Bpp; break;
		case 16: m_ModeInfo.format = gpe16Bpp; break;
		default: m_ModeInfo.format = gpeUndefined; break;
	}
	/* FIX!!! only works for 8/16 bpp */
	m_LineSizeInBytes = ((m_ModeInfo.width * m_ModeInfo.Bpp)/8);
    m_nBytesPerPixel = m_ModeInfo.Bpp/8;

	/*
	 * Panel dimensions x bpp must be divisible by 32
	 */
	if (((m_ModeInfo.height * m_ModeInfo.Bpp) % 32) != 0) RETAILMSG(1, (TEXT("VERT %% 32\r\n")));
	if (((m_ModeInfo.width * m_ModeInfo.Bpp) % 32) != 0) RETAILMSG(1, (TEXT("HORZ %% 32\r\n")));

	m_nScreenHeight = m_ModeInfo.height;
	m_nScreenWidth = m_ModeInfo.width;
	
	DispAtInit = 1;
	Rotation = 0;

	RETAILMSG(1, (TEXT("Width: %d\r\n"), m_ModeInfo.width));
	RETAILMSG(1, (TEXT("Height: %d\r\n"), m_ModeInfo.height));
	RETAILMSG(1, (TEXT("Bpp: %d\r\n"), m_ModeInfo.Bpp));

	/*
	 * Allocate LCD framebuffer from system memory
	 */
	m_FbSize = (m_ModeInfo.width * m_ModeInfo.height * m_ModeInfo.Bpp) / 8;
	RETAILMSG(1, (TEXT("fbsize: %d, %08x\r\n"), m_FbSize, m_FbSize));

	/*
	 * See LCD Performance App note regarding ALIGNment
	 */
#define ALIGN 0x00200000

	/*
	 * Allocate a contiguous chunk of properly aligned RAM for FB
	 */
	m_FbSize = ALIGN;
	m_pLAW = (PUCHAR)AllocPhysMem(
		/*cbSize*/		   	ALIGN,
		/*fdwProtect*/	   	PAGE_READWRITE | PAGE_NOCACHE,
		/*dwAlignmentMask*/	(ALIGN-1),
		/*dwFlags */ 	  	0,
		/*pPhysicalAddres*/	&m_pFb);
	RETAILMSG(1,(TEXT("AllocPhysMem(): p=%08X v=%08X\r\n"), m_pFb, m_pLAW));
	if (m_pLAW == NULL)
	{
		RETAILMSG(1,(TEXT("\n\rERROR: Unable to AllocPhysMem()\n\r")));
		return;
	}

	PhysAddr.LowPart = m_pFb;
	PhysAddr.HighPart = 0;
#if 1
	m_pLAW = (PUCHAR)MmMapIoSpace(PhysAddr, m_FbSize, FALSE);
#else
	m_pLAW = (PUCHAR)HalCreateBlockMapping(PhysAddr, m_FbSize, FALSE);
#endif
	if (!m_pLAW)
		RETAILMSG(1,(TEXT("Failed to map Frame buffer memory!!!\r\n")));

   RETAILMSG(1, (TEXT("frame buffer phys 0x%08x, virt 0x%08x\r\n"), m_pFb, m_pLAW ));

	/*
	 * Map in Au1100 LCD controller registers
	 */
	PhysAddr.LowPart = LCD_PHYS_ADDR;
	PhysAddr.HighPart = 0;

	m_Reg = (AU1100_LCD *)MmMapIoSpace(PhysAddr, sizeof(AU1100_LCD), FALSE);
	if (!m_Reg)
		RETAILMSG(1,(TEXT("Fail to Map Au1100 LCD registers!\r\n")));

	/* map in toy registers */
	PhysAddr.LowPart = SYS_PHYS_ADDR;
	PhysAddr.HighPart = 0;

	m_Sys = (AU1X00_SYS *)MmMapIoSpace(PhysAddr, sizeof(*m_Sys), FALSE);
	if (!m_Sys)
		RETAILMSG(1,(TEXT("Fail to Map TOY registers!\r\n")));
	else
	{
		/* set freqctrl now to allow more time to stabilize */
		uint32 sys_clksrc;
		sys_clksrc = (m_Sys->clksrc & ~0x000003e0); /* zero-out out LCD bits */
		sys_clksrc |= m_mode->mode_toyclksrc;
		m_Sys->clksrc = sys_clksrc;
		RETAILMSG(1,(TEXT("&clksrc: %08X\r\n"), &m_Sys->clksrc));
		/* FIX!!! add check to make sure auxpll is what is expected! */
	}

	/* Set Registry Active with display info */
	Registry R;
	R.SetNumber(Registry::ActiveWidth, m_ModeInfo.width);
	R.SetNumber(Registry::ActiveHeight, m_ModeInfo.height);
	R.SetNumber(Registry::ActiveBpp, m_ModeInfo.Bpp);
	R.SetNumber(Registry::ActiveRefresh, m_ModeInfo.frequency);
	R.SetNumber(Registry::ActiveRotation, Rotation);
	R.SetNumber(Registry::ActiveFlags, DispAtInit);

    m_bCursorForcedOff = FALSE;

#ifdef SHOW_FRAMERATE
    m_bShowFrameRate = TRUE;
    m_dwFrameCount = m_dwFrames = m_dwFramesLast = 0;
    m_dwFrameTime = GetTickCount();
#endif

   RETAILMSG(1, (TEXT("Au1100LCD:: done!\r\n")));
}

/********************************************************************/
Au1100LCD::~Au1100LCD ()
{
   DEBUGMSG (1, (TEXT("~Au1100LCD\r\n") ));
#if 0
   if (m_pbVMem)
      VirtualFree((void*)m_pbVMem, 0, MEM_RELEASE), m_pbVMem = NULL;

   if (m_Reg)
      VirtualFree((void*)m_Reg, 0, MEM_RELEASE), m_Reg = NULL;

   if (m_pwBlt)
      VirtualFree((void*)m_pwBlt, 0, MEM_RELEASE), m_pwBlt = NULL;
#endif
}

/********************************************************************/
int
Au1100LCD::NumModes()
{
	return 1;
}

/********************************************************************/
int
Au1100LCD::GetBpp()
{
	return m_ModeInfo.Bpp;
}

/********************************************************************/
SCODE
Au1100LCD::GetModeInfo(
	GPEMode *pMode,
	int modeNo )
{
	if (modeNo != 0)
		return E_INVALIDARG;

	*pMode = m_ModeInfo;

	return S_OK;
}

#ifdef DDRAW_ENABLE

/********************************************************************/
SCODE
Au1100LCD::GetModeInfoEx(
   GPEModeEx *pModeEx,
   int modeNo )
{
    if( modeNo != 0 )
        return E_INVALIDARG;

    *pModeEx = *(GPEModeEx *) &m_ModeInfo;

	DEBUGMSG(1, (L"GetModeInfoEx: modeId %u, width %u, height %u, bpp %u, format %u\r\n",
		m_ModeInfo.modeId, m_ModeInfo.width, m_ModeInfo.height, 
		m_ModeInfo.Bpp, m_ModeInfo.format));

	return S_OK;
}
#endif DDRAW_ENABLE

/********************************************************************/
void Au1100LCD::GetPhysicalVideoMemory (
	unsigned long *pPhysicalMemoryBase,
	unsigned long *pVideoMemorySize )
{
	*pPhysicalMemoryBase = (unsigned long)m_pFb;
	*pVideoMemorySize    = m_FbSize;
}

#ifdef DDRAW_ENABLE

/********************************************************************/
void Au1100LCD::GetVirtualVideoMemory (
	unsigned long *pVirtualMemoryBase,
	unsigned long *pVideoMemorySize )
{
	*pVirtualMemoryBase = (unsigned long)m_pLAW;
	*pVideoMemorySize   = m_FbSize;
}

/********************************************************************/
SCODE Au1100LCD::SetMode( int modeId, HPALETTE *pPalette )
{
    return SetMode(modeId, pPalette, TRUE);
}

SCODE Au1100LCD::SetMode( int modeId, HPALETTE *pPalette, BOOL bChangeGDISurfaceMode )

#else // not DDRAW_ENABLE

/********************************************************************/
SCODE
Au1100LCD::SetMode( int modeId, HPALETTE *pPalette )

#endif DDRAW_ENABLE
{
	SCODE sc;
	int i;

	DEBUGMSG(1, (TEXT("Au1100LCD::SetMode(%d,0x%X)\r\n"), modeId, pPalette));

	/* Check to see if mode already set */
	if (modeId != 0)
	{
		return	E_INVALIDARG;
	}

	if (m_pMode)
	{
		return	S_OK;
	}

	m_pMode = &m_ModeInfo;

#ifdef DDRAW_ENABLE
    // m_dwPhysicalModeID should be updated whenever the hardware抯 display mode changes,
    // regardless of whether or not the pixel format of the GDI primary surface has changed.
    m_dwPhysicalModeID = modeId;

	// do not update GDI primary surface if false
	if (!bChangeGDISurfaceMode)
	{
		WaitForVBlank();

		DEBUGMSG( 1,(TEXT("Leaving Wrap8bpp::SetMode, bChangeGDISurfaceMode=%x\r\n"), bChangeGDISurfaceMode));

		return S_OK;
	}
#endif

	SetRegisters();

	RETAILMSG(1, (TEXT("lcd_control: %08X\r\n"), m_Reg->control));
	RETAILMSG(1, (TEXT("lcd_intstatus: %08X\r\n"), m_Reg->intstatus));
	RETAILMSG(1, (TEXT("lcd_intenable: %08X\r\n"), m_Reg->intenable));
	RETAILMSG(1, (TEXT("lcd_horztiming: %08X\r\n"), m_Reg->horztiming));
	RETAILMSG(1, (TEXT("lcd_verttiming: %08X\r\n"), m_Reg->verttiming));
	RETAILMSG(1, (TEXT("lcd_clkcontrol: %08X\r\n"), m_Reg->clkcontrol));
	RETAILMSG(1, (TEXT("lcd_words: %08X\r\n"), m_Reg->words));
	RETAILMSG(1, (TEXT("lcd_dmaaddr0: %08X\r\n"), m_Reg->dmaaddr0));
	RETAILMSG(1, (TEXT("lcd_dmaaddr1: %08X\r\n"), m_Reg->dmaaddr1));
	RETAILMSG(1, (TEXT("fb virtaddr: %08X\r\n"), m_pLAW));

/***********/
	// set the palette if pPalette is not NULL
	if (pPalette)
	{
		RETAILMSG(1, (TEXT("EngCreatePalette:%d\r\n"), m_pMode->Bpp));
		switch (m_pMode->Bpp)
		{
			case 8:
				*pPalette =
				EngCreatePalette (PAL_INDEXED,
				256,
				(ULONG*)rgbIdentity,
				0,
				0,
				0);
				break;

			case 16:
				*pPalette =
				EngCreatePalette (PAL_BITFIELDS,
				0,
				NULL,
				((unsigned long *)(m_mode->mode_bitmask))[0],  // R
				((unsigned long *)(m_mode->mode_bitmask))[1],  // G
				((unsigned long *)(m_mode->mode_bitmask))[2]); // B
				break;
		}
	}

	// initialize palette
	if (m_pMode->Bpp != 8)
	{
		for (i = 0; i < 256; i++)
		{