wangxinfeng6666_749290079
文章：166 阅读：394060 评论：45 赞：1524
好友 私信 个人主页

原创 Windows CE LCD显示驱动简析(2)（转载）

2011-6-11 17:43 2897 9 9 分类: MCU/ 嵌入式

引自：http://blog.csdn.net/shevsten/archive/2010/04/16/5491866.aspx

现在就来看看我们需要实现的GPE继承类S3C2410DISP.
在ddi_if_cpp(\WINCE500\PUBLIC\COMMON\OAK\DRIVERS\DISPLAY\GPE)实现了一个SafeGetGPE函数,其代码如下:

view plaincopy to clipboardprint?
  1. GPE *  
  2. SafeGetGPE(  
  3.     HANDLE hDriver  
  4.     )  
  5. {  
  6.     GPE * pGPE = NULL;  
  7.   
  8.     __try  
  9.     {  
  10.         if ((hDriver != (HANDLE)SINGLE_DRIVER_HANDLE) && (pfnGetGPEPerCard != NULL))  
  11.         {  
  12.             pGPE = (*pfnGetGPEPerCard)((int)hDriver);  
  13.         }  
  14.         else  
  15.         {  
  16.             pGPE = GetGPE();  
  17.         }  
  18.     }  
  19.     __except (EXCEPTION_EXECUTE_HANDLER)  
  20.     {  
  21.         pGPE = NULL;  
  22.     }  
  23.   
  24.     return pGPE;  
  25. }  

这个函数考虑了多显示器的情况,而我们只有一个显示器,因此该函数实际上只是调用GetGPE函数,并将后者的返回值作为自己的返回值返回给调用者.
而GetGPE就实现在s3c2410x_lcd.cpp中,代码如下:
view plaincopy to clipboardprint?
  1. GPE *GetGPE(void)  
  2. {  
  3.     if (!gGPE)  
  4.     {  
  5.         gGPE = new S3C2410DISP();  
  6.     }  
  7.   
  8.     return gGPE;  
  9. }  

在 GetGPE函数中,获得了一个新生成的S3C2410DISP类实例的指针.在以后使用gGPE所指向的数据或函数时,得到的都是 S3C2410DISP类型变量的成员函数和函数,只有在S3C2410DISP未定义的部分,才使用父类或更上级类的数据成员和成员函数.
在 CE5.0的SMDK2410 BSP中,S3C2410DISP是GPE的继承类,而在CE 6.0的DEVICEEMULATOR BSP中的S3C2410DISP是DDGPE的继承类.DDGPE是GPE的继承类,支持了DirectDraw,由于2410LCD控制器不支持 DirectDraw,实际上DDGPE和GPE继承类没有区别.
获取GPE指针后,在微软已经实现的DDI函数中就会调用GPE类的成员函数来获取和实际显示硬件相关的信息和进行相应的操作.
接下来我们就来看看S3C2410DISP的具体成员:
1.S3C2410DISP的构造函数S3C2410DISP
这个函数首先设置一些显示参数,如LCD尺寸(240*320),缓冲区大小等.然和调用InitializeHardware进行LCD控制器初始化.
然后创建GPESurf类的实例m_pPrimarySurface,该类是GPE类实例的首要显示表面.显示表面的实质是显示屏幕上的所有像素点颜色数据在内存中的镜像.
接 着设置光标的属性,如果设置了CLEARTYPE(这里没有定义),则读取注册表Gamma亮度属性(如果有的话,否则使用默认值1500),这里实际用 的就是默认值,使用比较低的亮度来增加字体的对比度.最后设置24位颜色掩码(static ulong gBitMasks[] = { 0xF800, 0x07E0, 0x001F };  // 565 MODE)(实际上在SetMode函数中设置)
代码如下:
view plaincopy to clipboardprint?
  1. S3C2410DISP::S3C2410DISP (void)  
  2. {  
  3.     RETAILMSG(0, (TEXT("++S3C2410DISP::S3C2410DISP\r\n")));  
  4.     RETAILMSG(1, (TEXT("++S3C2410DISP::S3C2410DISP for GEC2410 LCD\r\n")));  
  5.     // setup up display mode related constants  
  6.     m_nScreenWidth = 240;  
  7.     m_nScreenHeight = 320;  
  8.     m_colorDepth = 16;  
  9.     m_cbScanLineLength = m_nScreenWidth * 2;  
  10.     m_FrameBufferSize = m_nScreenHeight * m_cbScanLineLength;  
  11.       
  12.     // memory map register access window, frame buffer, and program LCD controller  
  13.     InitializeHardware();  
  14.  
  15. #ifdef ROTATE  
  16.     m_iRotate = 0;  
  17.     SetRotateParms();  
  18. #endif //ROTATE   
  19.   
  20.     // setup ModeInfo structure  
  21.     m_ModeInfo.modeId = 0;  
  22.     m_ModeInfo.width = m_nScreenWidth;  
  23.     m_ModeInfo.height = m_nScreenHeight;  
  24.     m_ModeInfo.Bpp = m_colorDepth;  
  25.     m_ModeInfo.format = gpe16Bpp;  
  26.     m_ModeInfo.frequency = 60;  // ?  
  27.     m_pMode = &m_ModeInfo;  
  28.       
  29.     // allocate primary display surface  
  30. #ifdef  ROTATE  
  31.     m_pPrimarySurface = new GPESurfRotate(m_nScreenWidthSave, m_nScreenHeightSave, (void*)(m_VirtualFrameBuffer), m_cbScanLineLength, m_ModeInfo.format);  
  32. #else  
  33.     m_pPrimarySurface = new GPESurf(m_nScreenWidth, m_nScreenHeight, (void*)(m_VirtualFrameBuffer), m_cbScanLineLength, m_ModeInfo.format);   
  34. #endif //!ROTATE  
  35.   
  36.     if (m_pPrimarySurface)  
  37.     {  
  38.         memset ((void*)m_pPrimarySurface->Buffer(), 0x0, m_FrameBufferSize);  
  39.     }  
  40.   
  41.     // init cursor related vars  
  42.     m_CursorVisible = FALSE;  
  43.     m_CursorDisabled = TRUE;  
  44.     m_CursorForcedOff = FALSE;  
  45.     memset (&m_CursorRect, 0x0, sizeof(m_CursorRect));  
  46.     m_CursorBackingStore = NULL;  
  47.     m_CursorXorShape = NULL;  
  48.     m_CursorAndShape = NULL;  
  49.  
  50. #ifdef CLEARTYPE  
  51.     HKEY  hKey;  
  52.     DWORD dwValue;  
  53.     ULONG ulGamma = DEFAULT_CT_GAMMA;     
  54.       
  55.     if (ERROR_SUCCESS == RegCreateKeyEx(HKEY_LOCAL_MACHINE,szGamma,0, NULL,0,0,0,&hKey,&dwValue))  
  56.     {  
  57.         if (dwValue == REG_OPENED_EXISTING_KEY)  
  58.         {  
  59.         DWORD dwType = REG_DWORD;  
  60.         DWORD dwSize = sizeof(LONG);  
  61.         if (ERROR_SUCCESS == RegQueryValueEx(hKey,szGammaValue,0,&dwType,(BYTE *)&dwValue,&dwSize))  
  62.         {  
  63.             ulGamma = dwValue;  
  64.         }  
  65.         }   
  66.         else if (dwValue == REG_CREATED_NEW_KEY )  
  67.         {  
  68.         RegSetValueEx(hKey,szGammaValue,0,REG_DWORD,(BYTE *)&ulGamma,sizeof(DWORD));  
  69.         }  
  70.         RegCloseKey(hKey);  
  71.     }  
  72.   
  73.     SetClearTypeBltGamma(ulGamma);  
  74.     SetClearTypeBltMasks(gBitMasks[0], gBitMasks[1], gBitMasks[2]);  
  75. #endif //CLEARTYPE    
  76.   
  77.     RETAILMSG(0, (TEXT("--S3C2410DISP::S3C2410DISP\r\n")));  
  78. }  

其中调用了InitializeHardware来进行硬件初始化,InitializeHardware首先读取注册表获取物理和虚拟显示内存地址
即注册表中的
 "LCDVirtualFrameBase"=dword:ac100000
 "LCDPhysicalFrameBase"=dword:30100000
然后调用InitializeLCDRegisters初始化LCD控制器,最后分配内存空间给显示区域.
view plaincopy to clipboardprint?
  1. void S3C2410DISP::InitializeHardware (void)  
  2. {  
  3.     WORD *ptr;  
  4.     DWORD index;  
  5.     HKEY hkDisplay = NULL;  
  6.     DWORD dwLCDPhysicalFrameBase = 0;  
  7.     DWORD dwStatus, dwType, dwSize;  
  8.   
  9.     RETAILMSG(0, (_T("++S3C2410DISP::InitializeHardware\r\n")));  
  10.   
  11.     // open the registry key and read our configuration  
  12.     dwStatus = RegOpenKeyEx(HKEY_LOCAL_MACHINE, gszBaseInstance, 0, 0, &hkDisplay);  
  13.     dwType = REG_DWORD;  
  14.   
  15.     if(dwStatus == ERROR_SUCCESS && dwType == REG_DWORD) {  
  16.         dwSize = sizeof(DWORD);  
  17.         dwStatus = RegQueryValueEx(hkDisplay, _T("LCDVirtualFrameBase"), NULL, &dwType,   
  18.             (LPBYTE) &gdwLCDVirtualFrameBase, &dwSize);  
  19.     }  
  20.     if(dwStatus == ERROR_SUCCESS && dwType == REG_DWORD) {  
  21.         dwSize = sizeof(DWORD);  
  22.         dwStatus = RegQueryValueEx(hkDisplay, _T("LCDPhysicalFrameBase"), NULL, &dwType,   
  23.             (LPBYTE) &dwLCDPhysicalFrameBase, &dwSize);  
  24.     }  
  25.   
  26.     // close the registry key  
  27.     if(hkDisplay != NULL) {  
  28.         RegCloseKey(hkDisplay);  
  29.     }  
  30.   
  31.     // did we get everything?  
  32.     if(dwStatus != ERROR_SUCCESS) {  
  33.         RETAILMSG(0, (_T("SALCD2: InitializeHardware: couldn't get registry configuration\r\n")));  
  34.         return;  
  35.     }  
  36.   
  37.     // Initialize LCD registers.  
  38.     if (!InitializeLCDRegisters(dwLCDPhysicalFrameBase))  
  39.     {  
  40.         RETAILMSG(0, (_T("SALCD2: InitializeHardware: failed to initialize LCD registers.\r\n")));  
  41.         return;  
  42.     }  
  43.   
  44.     // map frame buffer into process space memory  
  45.     m_VirtualFrameBuffer = (DWORD)VirtualAlloc(0, (0x40000), MEM_RESERVE, PAGE_NOACCESS);  
  46.     if (m_VirtualFrameBuffer == NULL)   
  47.     {  
  48.         RETAILMSG(0,(TEXT("m_VirtualFrameBuffer is not allocated\n\r")));  
  49.         return;  
  50.     }  
  51.     else if (!VirtualCopy((PVOID)m_VirtualFrameBuffer, (PVOID)gdwLCDVirtualFrameBase, (0x40000), PAGE_READWRITE | PAGE_NOCACHE))  
  52.     {  
  53.         RETAILMSG(0, (TEXT("m_VirtualFrameBuffer is not mapped\n\r")));  
  54.         VirtualFree((PVOID)m_VirtualFrameBuffer, 0, MEM_RELEASE);  
  55.         return;  
  56.     }  
  57.   
  58.     RETAILMSG(0, (TEXT("m_VirtualFrameBuffer is mapped at %x(PHY : %x)\n\r"), m_VirtualFrameBuffer, gdwLCDVirtualFrameBase));  
  59.     RETAILMSG(0, (TEXT("Clearing frame buffer !!!\n\r")));  
  60.       
  61.     ptr = (WORD *)m_VirtualFrameBuffer;  
  62.   
  63.     // clear rest of frame buffer out  
  64.     for (index = 0; index < 320*240; index++)  
  65.     {  
  66.         if(index < 3200)  
  67.         {  
  68.             ptr[index] = 0xf800;  
  69.         }  
  70.         else if(index < 6400)  
  71.         {  
  72.             ptr[index] = 0x07e0;  
  73.         }  
  74.         else if(index < 9600)  
  75.         {  
  76.             ptr[index] = 0x001f;  
  77.         }  
  78.         else  
  79.         {  
  80.             ptr[index] = 0xffff;  
  81.         }  
  82.     }  
  83.   
  84.     RETAILMSG(0, (_T("--S3C2410DISP::InitializeHardware\r\n")));  
  85. }  

InitializeLCDRegisters就是初始化了LCD控制寄存器,具体内容和在eboot中的处理基本是一样的.
view plaincopy to clipboardprint?
  1. static BOOL InitializeLCDRegisters(DWORD dwPhysicalFrameBase)  
  2. {  
  3.     volatile S3C2410X_IOPORT_REG *s2410IOP = NULL;  
  4.     volatile S3C2410X_LCD_REG    *s2410LCD = NULL;  
  5.     PHYSICAL_ADDRESS pa;  
  6.   
  7.     // Map the s3c2410x register pointers.  
  8.     //  
  9.     pa.QuadPart = S3C2410X_BASE_REG_PA_IOPORT;  
  10.     s2410IOP = (S3C2410X_IOPORT_REG *) MmMapIoSpace(pa, sizeof(S3C2410X_IOPORT_REG), FALSE);  
  11.   
  12.     pa.QuadPart = S3C2410X_BASE_REG_PA_LCD;  
  13.     s2410LCD = (S3C2410X_LCD_REG *) MmMapIoSpace(pa, sizeof(S3C2410X_LCD_REG), FALSE);  
  14.   
  15.     if (!s2410IOP || !s2410LCD)  
  16.     {  
  17.         RETAILMSG(1, (TEXT("ERROR: s3c2410x_lcd: InitializeLCDRegisters failed.\r\n")));  
  18.         return(FALSE);  
  19.     }  
  20.   
  21.     // Set up the LCD controller registers to display a power-on bitmap image.  
  22.     //  
  23.     s2410IOP->GPCUP     = 0xFFFFFFFF;  
  24.     s2410IOP->GPCCON    = 0xAAAA56A9;  
  25.                                       
  26.     s2410IOP->GPDUP     = 0xFFFFFFFF;  
  27.     s2410IOP->GPDCON    = 0xAAAAAAAA;   
  28.   
  29.     s2410LCD->LCDCON1   =  (5           <<  8) |       /* VCLK = HCLK / ((CLKVAL + 1) * 2) -> About 7 Mhz  */  
  30.                            (0   <<  7)  |       /* 0 : Each Frame                                   */  
  31.                            (3           <<  5) |       /* TFT LCD Pannel                                   */  
  32.                            (12          <<  1) |       /* 16bpp Mode                                       */  
  33.                            (0           <<  0) ;       /* Disable LCD Output                               */  
  34.   
  35.     s2410LCD->LCDCON2   =  (2        << 24) |   /* VBPD          :   1                              */  
  36.                            (LCD_LINEVAL_TFT << 14) |   /* Vertical Size : 320 - 1                          */  
  37.                            (2        <<  6) |   /* VFPD          :   2                              */  
  38.                            (4        <<  0) ;   /* VSPW          :   1                              */  
  39.   
  40.     s2410LCD->LCDCON3   =  (8        << 19) |   /* HBPD          :   6                              */  
  41.                            (LCD_HOZVAL_TFT  <<  8) |   /* HOZVAL_TFT    : 240 - 1                          */  
  42.                            (8        <<  0) ;   /* HFPD          :   2                              */  
  43.   
  44.   
  45.     s2410LCD->LCDCON4   =  (LCD_MVAL        <<  8) |   /* MVAL          :  13                              */  
  46.                            (6        <<  0) ;   /* HSPW          :   4                              */  
  47.   
  48.     s2410LCD->LCDCON5   =  (0           << 12) |       /* BPP24BL       : LSB valid                        */  
  49.                            (1           << 11) |       /* FRM565 MODE   : 5:6:5 Format                     */  
  50.                            (0           << 10) |       /* INVVCLK       : VCLK Falling Edge                */  
  51.                            (0           <<  9) |       /* INVVLINE      : Inverted Polarity                */  
  52.                            (0           <<  8) |       /* INVVFRAME     : Inverted Polarity                */  
  53.                            (0           <<  7) |       /* INVVD         : Normal                           */  
  54.                            (0           <<  6) |       /* INVVDEN       : Normal                           */  
  55.                            (0           <<  5) |       /* INVPWREN      : Normal                           */  
  56.                            (0           <<  4) |       /* INVENDLINE    : Normal                           */  
  57.                            (0           <<  3) |       /* PWREN         : Disable PWREN                    */  
  58.                            (0           <<  2) |       /* ENLEND        : Disable LEND signal              */  
  59.                            (0           <<  1) |       /* BSWP          : Swap Disable                     */  
  60.                            (1           <<  0) ;       /* HWSWP         : Swap Enable                      */  
  61.   
  62.     s2410LCD->LCDSADDR1 = ((dwPhysicalFrameBase >> 22)     << 21) |   
  63.                           ((M5D(dwPhysicalFrameBase >> 1)) <<  0);  
  64.   
  65.     s2410LCD->LCDSADDR2 = M5D((dwPhysicalFrameBase + (LCD_XSIZE_TFT * LCD_YSIZE_TFT * 2)) >> 1);  
  66.   
  67.     s2410LCD->LCDSADDR3 = (((LCD_XSIZE_TFT - LCD_XSIZE_TFT) / 1) << 11) | (LCD_XSIZE_TFT / 1);          
  68.   
  69.     s2410LCD->LPCSEL   |= ~0x7;  
  70.   
  71.     s2410LCD->TPAL      = 0x0;          
  72.     s2410LCD->LCDCON1  |= 1;  
  73.   
  74.     // Unmap register buffers.  
  75.     //  
  76.     MmUnmapIoSpace((PVOID)s2410IOP, 0);  
  77.     MmUnmapIoSpace((PVOID)s2410LCD, 0);  
  78.   
  79.     return(TRUE);  
  80. }  

2.SetMode
SetMode成员函数负责设置一个显示设备及其驱动程序能支持的显示模式.
通过调用EngCreatePalette来设置RGB模式:
static ulong gBitMasks[] = { 0xF800, 0x07E0, 0x001F };  // 565 MODE
modeId是要设置的显示工作模式的索引号,由于只有一个显示设备,该值必须为0.
view plaincopy to clipboardprint?
  1. SCODE S3C2410DISP::SetMode (INT modeId, HPALETTE *palette)  
  2. {  
  3.     RETAILMSG(0, (TEXT("++S3C2410DISP::SetMode\r\n")));  
  4.   
  5.     if (modeId != 0)  
  6.     {  
  7.         RETAILMSG(0, (TEXT("S3C2410DISP::SetMode Want mode %d, only have mode 0\r\n"),modeId));  
  8.         return  E_INVALIDARG;  
  9.     }  
  10.   
  11.     if (palette)  
  12.     {  
  13.         *palette = EngCreatePalette (PAL_BITFIELDS, 0, NULL, gBitMasks[0], gBitMasks[1], gBitMasks[2]);  
  14.     }  
  15.   
  16.     RETAILMSG(0, (TEXT("--S3C2410DISP::SetMode\r\n")));  
  17.   
  18.     return S_OK;  
  19. }  

3.GetModeInfo
GetModeInfo 函数用于供调用者获取显示设备当前正在生效的显示工作模式,在S3C2410DISP类的GetModeInfo函数就是把m_ModeInfo成员所记 录的GPEMode数据复制给输出参数mode.函数另一个参数modeNumber指定要获取的模式的索引号,在S3C2410DISP类中,它必须取 值为0,因为当前的显示设备只支持一种显示模式.
view plaincopy to clipboardprint?
  1. SCODE S3C2410DISP::GetModeInfo(GPEMode *mode,   INT modeNumber)  
  2. {  
  3.     RETAILMSG(0, (TEXT("++S3C2410DISP::GetModeInfo\r\n")));  
  4.   
  5.     if (modeNumber != 0)  
  6.     {  
  7.         return E_INVALIDARG;  
  8.     }  
  9.   
  10.     *mode = m_ModeInfo;  
  11.   
  12.     RETAILMSG(0, (TEXT("--S3C2410DISP::GetModeInfo\r\n")));  
  13.   
  14.     return S_OK;  
  15. }  

4.NumModes
NumModes返回设备驱动程序所能支持的显示工作模式的数量.这里显然只能为1.函数简单返回1.
view plaincopy to clipboardprint?
  1. int S3C2410DISP::NumModes()  
  2. {  
  3.     RETAILMSG(0, (TEXT("++S3C2410DISP::NumModes\r\n")));  
  4.     RETAILMSG(0, (TEXT("--S3C2410DISP::NumModes\r\n")));  
  5.     return  1;  
  6. }  

5.CursorOn
显示光标.
m_CursorForcedOff:记录当前系统中是否暂时关断鼠标显示.
m_CursorDisabled:记录系统是否禁用光标.
m_CursorVisible:指示屏幕上光标当前在显示屏幕上是否可见.
当这个变量都不为真时,即光标处于显示状态.然和计算光标所处位置,如有有旋转设置,则计算相应的新的坐标.
view plaincopy to clipboardprint?
  1. void    S3C2410DISP::CursorOn (void)  
  2. {  
  3.     UCHAR   *ptrScreen = (UCHAR*)m_pPrimarySurface->Buffer();  
  4.     UCHAR   *ptrLine;  
  5.     UCHAR   *cbsLine;  
  6. #ifndef ROTATE  
  7.     UCHAR   *xorLine;  
  8.     UCHAR   *andLine;  
  9. #endif //!ROTATE      
  10.     int     x, y;  
  11.   
  12.     if (!m_CursorForcedOff && !m_CursorDisabled && !m_CursorVisible)  
  13.     {  
  14. #ifdef ROTATE  
  15.         RECTL rSave;  
  16.         int   iRotate;  
  17. #endif //ROTATE  
  18.   
  19.         if (!m_CursorBackingStore)  
  20.         {  
  21.             RETAILMSG(0, (TEXT("S3C2410DISP::CursorOn - No backing store available\r\n")));  
  22.             return;  
  23.         }  
  24. #ifdef ROTATE  
  25.         rSave = m_CursorRect;  
  26.         RotateRectl(&m_CursorRect);  
  27. #endif //ROTATE  
  28.   
  29.         for (y = m_CursorRect.top; y < m_CursorRect.bottom; y++)  
  30.         {  
  31.             if (y < 0)  
  32.             {  
  33.                 continue;  
  34.             }  
  35. #ifdef ROTATE  
  36.             if (y >= m_nScreenHeightSave)  
  37. #else  
  38.             if (y >= m_nScreenHeight)  
  39. #endif //ROTATE           
  40.             {  
  41.                 break;  
  42.             }  
  43.   
  44.             ptrLine = &ptrScreen[y * m_pPrimarySurface->Stride()];  
  45.             cbsLine = &m_CursorBackingStore[(y - m_CursorRect.top) * (m_CursorSize.x * (m_colorDepth >> 3))];  
  46. #ifndef ROTATE  
  47.             xorLine = &m_CursorXorShape[(y - m_CursorRect.top) * m_CursorSize.x];  
  48.             andLine = &m_CursorAndShape[(y - m_CursorRect.top) * m_CursorSize.x];  
  49. #endif //!ROTATE  
  50.   
  51.             for (x = m_CursorRect.left; x < m_CursorRect.right; x++)  
  52.             {  
  53.                 if (x < 0)  
  54.                 {  
  55.                     continue;  
  56.                 }  
  57. #ifdef ROTATE  
  58.                 if (x >= m_nScreenWidthSave)  
  59. #else  
  60.                 if (x >= m_nScreenWidth)  
  61. #endif //!ROTATE                  
  62.                 {  
  63.                     break;  
  64.                 }  
  65. #ifdef ROTATE  
  66.                 switch (m_iRotate)  
  67.                 {  
  68.                     case DMDO_0:  
  69.                         iRotate = (y - m_CursorRect.top)*m_CursorSize.x + x - m_CursorRect.left;  
  70.                         break;  
  71.                     case DMDO_90:  
  72.                         iRotate = (x - m_CursorRect.left)*m_CursorSize.x + m_CursorSize.y - 1 - (y - m_CursorRect.top);     
  73.                         break;  
  74.                     case DMDO_180:  
  75.                         iRotate = (m_CursorSize.y - 1 - (y - m_CursorRect.top))*m_CursorSize.x + m_CursorSize.x - 1 - (x - m_CursorRect.left);  
  76.                         break;  
  77.                     case DMDO_270:  
  78.                         iRotate = (m_CursorSize.x -1 - (x - m_CursorRect.left))*m_CursorSize.x + y - m_CursorRect.top;  
  79.                         break;  
  80.                     default:  
  81.                         iRotate = (y - m_CursorRect.top)*m_CursorSize.x + x - m_CursorRect.left;  
  82.                         break;  
  83.                 }  
  84. #endif //ROTATE                   
  85.                 cbsLine[(x - m_CursorRect.left) * (m_colorDepth >> 3)] = ptrLine[x * (m_colorDepth >> 3)];  
  86. #ifdef ROTATE  
  87.                 ptrLine[x * (m_colorDepth >> 3)] &= m_CursorAndShape[iRotate];  
  88.                 ptrLine[x * (m_colorDepth >> 3)] ^= m_CursorXorShape[iRotate];  
  89. #else   
  90.                 ptrLine[x * (m_colorDepth >> 3)] &= andLine[x - m_CursorRect.left];  
  91.                 ptrLine[x * (m_colorDepth >> 3)] ^= xorLine[x - m_CursorRect.left];  
  92. #endif //ROTATE               
  93.                 if (m_colorDepth > 8)  
  94.                 {  
  95.                     cbsLine[(x - m_CursorRect.left) * (m_colorDepth >> 3) + 1] = ptrLine[x * (m_colorDepth >> 3) + 1];  
  96. #ifdef ROTATE  
  97.                     ptrLine[x * (m_colorDepth >> 3) + 1] &= m_CursorAndShape[iRotate];  
  98.                     ptrLine[x * (m_colorDepth >> 3) + 1] ^= m_CursorXorShape[iRotate];                  
  99. #else  
  100.                     ptrLine[x * (m_colorDepth >> 3) + 1] &= andLine[x - m_CursorRect.left];  
  101.                     ptrLine[x * (m_colorDepth >> 3) + 1] ^= xorLine[x - m_CursorRect.left];  
  102. #endif //ROTATE                   
  103.                     if (m_colorDepth > 16)  
  104.                     {  
  105.                         cbsLine[(x - m_CursorRect.left) * (m_colorDepth >> 3) + 2] = ptrLine[x * (m_colorDepth >> 3) + 2];  
  106. #ifdef ROTATE  
  107.                         ptrLine[x * (m_colorDepth >> 3) + 2] &= m_CursorAndShape[iRotate];  
  108.                         ptrLine[x * (m_colorDepth >> 3) + 2] ^= m_CursorXorShape[iRotate];  
  109. #else  
  110.                         ptrLine[x * (m_colorDepth >> 3) + 2] &= andLine[x - m_CursorRect.left];  
  111.                         ptrLine[x * (m_colorDepth >> 3) + 2] ^= xorLine[x - m_CursorRect.left];  
  112. #endif //ROTATE                       
  113.                     }  
  114.                 }  
  115.             }  
  116.         }  
  117. #ifdef ROTATE  
  118.         m_CursorRect = rSave;  
  119. #endif   
  120.         m_CursorVisible = TRUE;  
  121.     }  
  122. }  

6.CursorOff
关闭光标.
CursorOff最后设置m_CursorVisible = FALSE;来关闭光标的显示.
view plaincopy to clipboardprint?
  1. void    S3C2410DISP::CursorOff (void)  
  2. {  
  3.     UCHAR   *ptrScreen = (UCHAR*)m_pPrimarySurface->Buffer();  
  4.     UCHAR   *ptrLine;  
  5.     UCHAR   *cbsLine;  
  6.     int     x, y;  
  7.   
  8.     if (!m_CursorForcedOff && !m_CursorDisabled && m_CursorVisible)  
  9.     {  
  10. #ifdef ROTATE  
  11.         RECTL rSave;  
  12. #endif //ROTATE  
  13.   
  14.         if (!m_CursorBackingStore)  
  15.         {  
  16.             RETAILMSG(0, (TEXT("S3C2410DISP::CursorOff - No backing store available\r\n")));  
  17.             return;  
  18.         }  
  19. #ifdef ROTATE  
  20.         rSave = m_CursorRect;  
  21.         RotateRectl(&m_CursorRect);  
  22. #endif //ROTATE  
  23.   
  24.         for (y = m_CursorRect.top; y < m_CursorRect.bottom; y++)  
  25.         {  
  26.             // clip to displayable screen area (top/bottom)  
  27.             if (y < 0)  
  28.             {  
  29.                 continue;  
  30.             }  
  31. #ifndef ROTATE  
  32.             if (y >= m_nScreenHeight)  
  33. #else   
  34.             if (y >= m_nScreenHeightSave)  
  35. #endif //!ROTATE  
  36.             {  
  37.                 break;  
  38.             }  
  39.   
  40.             ptrLine = &ptrScreen[y * m_pPrimarySurface->Stride()];  
  41.             cbsLine = &m_CursorBackingStore[(y - m_CursorRect.top) * (m_CursorSize.x * (m_colorDepth >> 3))];  
  42.   
  43.             for (x = m_CursorRect.left; x < m_CursorRect.right; x++)  
  44.             {  
  45.                 // clip to displayable screen area (left/right)  
  46.                 if (x < 0)  
  47.                 {  
  48.                     continue;  
  49.                 }  
  50. #ifndef ROTATE  
  51.                 if (x >= m_nScreenWidth)  
  52. #else  
  53.                 if (x>= m_nScreenWidthSave)  
  54. #endif //!ROTATE  
  55.                 {  
  56.                     break;  
  57.                 }  
  58.   
  59.                 ptrLine[x * (m_colorDepth >> 3)] = cbsLine[(x - m_CursorRect.left) * (m_colorDepth >> 3)];  
  60.                 if (m_colorDepth > 8)  
  61.                 {  
  62.                     ptrLine[x * (m_colorDepth >> 3) + 1] = cbsLine[(x - m_CursorRect.left) * (m_colorDepth >> 3) + 1];  
  63.                     if (m_colorDepth > 16)  
  64.                     {  
  65.                         ptrLine[x * (m_colorDepth >> 3) + 2] = cbsLine[(x - m_CursorRect.left) * (m_colorDepth >> 3) + 2];  
  66.                     }  
  67.                 }  
  68.             }  
  69.         }  
  70. #ifdef ROTATE  
  71.         m_CursorRect = rSave;  
  72. #endif //ROTATE  
  73.         m_CursorVisible = FALSE;  
  74.     }  
  75. }  

7.SetPointerShape
SetPointerShape用于设置显示屏幕上鼠标光标的形状,图案和位置.
pMask参数所指向的显示表面是构成鼠标光标形状轮廓的与-异掩模位图.pColorSurf是指向显示表面包含鼠标光标的颜色图案的位图,这里没有使用,不支持彩色鼠标光标.xHot和yHot是鼠标光标的热点位置.cX和cY是光标在显示屏幕上的大小.
view plaincopy to clipboardprint?
  1. SCODE   S3C2410DISP::SetPointerShape(GPESurf *pMask, GPESurf *pColorSurf, INT xHot, INT yHot, INT cX, INT cY)  
  2. {  
  3.     UCHAR   *andPtr;        // input pointer  
  4.     UCHAR   *xorPtr;        // input pointer  
  5.     UCHAR   *andLine;       // output pointer  
  6.     UCHAR   *xorLine;       // output pointer  
  7.     char    bAnd;  
  8.     char    bXor;  
  9.     int     row;  
  10.     int     col;  
  11.     int     i;  
  12.     int     bitMask;  
  13.   
  14.     RETAILMSG(0, (TEXT("S3C2410DISP::SetPointerShape(0x%X, 0x%X, %d, %d, %d, %d)\r\n"),pMask, pColorSurf, xHot, yHot, cX, cY));  
  15.   
  16.     // turn current cursor off  
  17.     CursorOff();  
  18.   
  19.     // release memory associated with old cursor  
  20.     if (m_CursorBackingStore)  
  21.     {  
  22.         delete (void*)m_CursorBackingStore;  
  23.         m_CursorBackingStore = NULL;  
  24.     }  
  25.     if (m_CursorXorShape)  
  26.     {  
  27.         delete (void*)m_CursorXorShape;  
  28.         m_CursorXorShape = NULL;  
  29.     }  
  30.     if (m_CursorAndShape)  
  31.     {  
  32.         delete (void*)m_CursorAndShape;  
  33.         m_CursorAndShape = NULL;  
  34.     }  
  35.   
  36.     if (!pMask)                         // do we have a new cursor shape  
  37.     {  
  38.         m_CursorDisabled = TRUE;        // no, so tag as disabled  
  39.     }  
  40.     else  
  41.     {  
  42.         m_CursorDisabled = FALSE;       // yes, so tag as not disabled  
  43.   
  44.         // allocate memory based on new cursor size  
  45.         m_CursorBackingStore = new UCHAR[(cX * (m_colorDepth >> 3)) * cY];  
  46.         m_CursorXorShape = new UCHAR[cX * cY];  
  47.         m_CursorAndShape = new UCHAR[cX * cY];  
  48.   
  49.         if (!m_CursorXorShape || !m_CursorAndShape)  
  50.         {  
  51.             return(ERROR_NOT_ENOUGH_MEMORY);  
  52.         }  
  53.   
  54.         // store size and hotspot for new cursor  
  55.         m_CursorSize.x = cX;  
  56.         m_CursorSize.y = cY;  
  57.         m_CursorHotspot.x = xHot;  
  58.         m_CursorHotspot.y = yHot;  
  59.   
  60.         andPtr = (UCHAR*)pMask->Buffer();  
  61.         xorPtr = (UCHAR*)pMask->Buffer() + (cY * pMask->Stride());  
  62.   
  63.         // store OR and AND mask for new cursor  
  64.         for (row = 0; row < cY; row++)  
  65.         {  
  66.             andLine = &m_CursorAndShape[cX * row];  
  67.             xorLine = &m_CursorXorShape[cX * row];  
  68.   
  69.             for (col = 0; col < cX / 8; col++)  
  70.             {  
  71.                 bAnd = andPtr[row * pMask->Stride() + col];  
  72.                 bXor = xorPtr[row * pMask->Stride() + col];  
  73.   
  74.                 for (bitMask = 0x0080, i = 0; i < 8; bitMask >>= 1, i++)  
  75.                 {  
  76.                     andLine[(col * 8) + i] = bAnd & bitMask ? 0xFF : 0x00;  
  77.                     xorLine[(col * 8) + i] = bXor & bitMask ? 0xFF : 0x00;  
  78.                 }  
  79.             }  
  80.         }  
  81.     }  
  82.   
  83.     return  S_OK;  
  84. }  

8.MovePointer

MovePointer用于将鼠标光标移动到指定的屏幕位置.参数xPosition和yPosition记录着光标到达新位置后的热点的坐标.

view plaincopy to clipboardprint?
  1. SCODE   S3C2410DISP::MovePointer(INT xPosition, INT yPosition)  
  2. {  
  3.     RETAILMSG(0, (TEXT("S3C2410DISP::MovePointer(%d, %d)\r\n"), xPosition, yPosition));  
  4.   
  5.     CursorOff();  
  6.   
  7.     if (xPosition != -1 || yPosition != -1)  
  8.     {  
  9.         // compute new cursor rect  
  10.         m_CursorRect.left = xPosition - m_CursorHotspot.x;  
  11.         m_CursorRect.right = m_CursorRect.left + m_CursorSize.x;  
  12.         m_CursorRect.top = yPosition - m_CursorHotspot.y;  
  13.         m_CursorRect.bottom = m_CursorRect.top + m_CursorSize.y;  
  14.   
  15.         CursorOn();  
  16.     }  
  17.   
  18.     return  S_OK;  
  19. }  

9.WaitForNotBusy
WaitForNotBusy用于等待显示设备空闲下来,直到显示设备可以接收新的操作指令WaitForNotBusy才返回.这个功能通常用于复杂而且功能强大的显示卡.而S3C2410的LCD控制器没有这么强的功能,因此该函数直接返回.
view plaincopy to clipboardprint?
  1. void    S3C2410DISP::WaitForNotBusy(void)  
  2. {  
  3.     RETAILMSG(0, (TEXT("S3C2410DISP::WaitForNotBusy\r\n")));  
  4.     return;  
  5. }  

10.IsBusy

IsBusy用于查询显示设备是否正忙,如果忙返回非0值,空闲返回0.同WaitForNotBusy一样,用于功能强大的显示控制器,这里直接返回0.

view plaincopy to clipboardprint?
  1. int     S3C2410DISP::IsBusy(void)  
  2. {  
  3.     RETAILMSG(0, (TEXT("S3C2410DISP::IsBusy\r\n")));  
  4.     return  0;  
  5. }  

11.GetPhysicalVideoMemory
GetPhysicalVideoMemory函数主要供DDHAL使用,用来获取显示内存的基地址和容量大小.
view plaincopy to clipboardprint?
  1. void    S3C2410DISP::GetPhysicalVideoMemory(unsigned long *physicalMemoryBase, unsigned long *videoMemorySize)  
  2. {  
  3.     RETAILMSG(0, (TEXT("S3C2410DISP::GetPhysicalVideoMemory\r\n")));  
  4.   
  5.     *physicalMemoryBase = gdwLCDVirtualFrameBase;  
  6.     *videoMemorySize = m_cbScanLineLength * m_nScreenHeight;  
  7. }  

12.AllocSurface
AllocSurface用于为显示设备构造显示表面,这里继承自GPE类.还有一种情况是继承自DDGPE类.这里即用于构造GPESurf类型的显示表面.
surface是输出参数,是构造所得的GPESurf对象指针的指针;width和height是要求显示表面的宽和高;format参数是构造显示表面的像素格式要求;surfaceFlags用于指定在哪里构造显示表面.
view plaincopy to clipboardprint?
  1. SCODE   S3C2410DISP::AllocSurface(GPESurf **surface, INT width, INT height, EGPEFormat format, INT surfaceFlags)  
  2. {  
  3.     RETAILMSG(0, (TEXT("S3C2410DISP::AllocSurface\r\n")));  
  4.   
  5.     if (surfaceFlags & GPE_REQUIRE_VIDEO_MEMORY)  
  6.     {  
  7.         return  E_OUTOFMEMORY;  
  8.     }  
  9.   
  10.     // Allocate from system memory  
  11.     *surface = new GPESurf(width, height, format);  
  12.   
  13.     if (*surface != NULL)  
  14.     {  
  15.         // Check that the bits were allocated succesfully  
  16.         if (((*surface)->Buffer()) == NULL)  
  17.         {  
  18.             delete *surface;                // Clean up  
  19.         }  
  20.         else  
  21.         {  
  22.             return S_OK;  
  23.         }  
  24.     }  
  25.     return E_OUTOFMEMORY;  
  26. }  

13.Line,WrappedEmulatedLine
Line 函数用于在显示表面上画直线段.由于S3C2410的LCD控制器不具备硬件加速能力,所以Line函数实现在非首要显示表面上画线时使用依靠软件实现的 默认画线函数GPE::EmulateLine;而在首要表面画线时,调用的是用户实现的WrappedEmulatedLine函数.封装的目的只是要 处理如果所画直线的范围矩形与鼠标光标的范围矩形重叠时,要先暂时消隐光标显示,待画完直线后在回复光标.
Line:
view plaincopy to clipboardprint?
  1. SCODE   S3C2410DISP::Line(GPELineParms *lineParameters, EGPEPhase phase)  
  2. {  
  3.     RETAILMSG(0, (TEXT("S3C2410DISP::Line\r\n")));  
  4.   
  5.     if (phase == gpeSingle || phase == gpePrepare)  
  6.     {  
  7.   
  8.         if ((lineParameters->pDst != m_pPrimarySurface))  
  9.         {  
  10.             lineParameters->pLine = EmulatedLine;  
  11.         }  
  12.         else  
  13.         {  
  14.             lineParameters->pLine = (SCODE (GPE::*)(struct GPELineParms *)) WrappedEmulatedLine;  
  15.         }  
  16.     }  
  17.     return S_OK;  
  18. }  

WrappedEmulatedLine
view plaincopy to clipboardprint?
  1. SCODE   S3C2410DISP::WrappedEmulatedLine (GPELineParms *lineParameters)  
  2. {  
  3.     SCODE   retval;  
  4.     RECT    bounds;  
  5.     int     N_plus_1;               // Minor length of bounding rect + 1  
  6.   
  7.     // calculate the bounding-rect to determine overlap with cursor  
  8.     if (lineParameters->dN)          // The line has a diagonal component (we'll refresh the bounding rect)  
  9.     {  
  10.         N_plus_1 = 2 + ((lineParameters->cPels * lineParameters->dN) / lineParameters->dM);  
  11.     }  
  12.     else  
  13.     {  
  14.         N_plus_1 = 1;  
  15.     }  
  16.   
  17.     switch(lineParameters->iDir)  
  18.     {  
  19.         case 0:  
  20.             bounds.left = lineParameters->xStart;  
  21.             bounds.top = lineParameters->yStart;  
  22.             bounds.right = lineParameters->xStart + lineParameters->cPels + 1;  
  23.             bounds.bottom = bounds.top + N_plus_1;  
  24.             break;  
  25.         case 1:  
  26.             bounds.left = lineParameters->xStart;  
  27.             bounds.top = lineParameters->yStart;  
  28.             bounds.bottom = lineParameters->yStart + lineParameters->cPels + 1;  
  29.             bounds.right = bounds.left + N_plus_1;  
  30.             break;  
  31.         case 2:  
  32.             bounds.right = lineParameters->xStart + 1;  
  33.             bounds.top = lineParameters->yStart;  
  34.             bounds.bottom = lineParameters->yStart + lineParameters->cPels + 1;  
  35.             bounds.left = bounds.right - N_plus_1;  
  36.             break;  
  37.         case 3:  
  38.             bounds.right = lineParameters->xStart + 1;  
  39.             bounds.top = lineParameters->yStart;  
  40.             bounds.left = lineParameters->xStart - lineParameters->cPels;  
  41.             bounds.bottom = bounds.top + N_plus_1;  
  42.             break;  
  43.         case 4:  
  44.             bounds.right = lineParameters->xStart + 1;  
  45.             bounds.bottom = lineParameters->yStart + 1;  
  46.             bounds.left = lineParameters->xStart - lineParameters->cPels;  
  47.             bounds.top = bounds.bottom - N_plus_1;  
  48.             break;  
  49.         case 5:  
  50.             bounds.right = lineParameters->xStart + 1;  
  51.             bounds.bottom = lineParameters->yStart + 1;  
  52.             bounds.top = lineParameters->yStart - lineParameters->cPels;  
  53.             bounds.left = bounds.right - N_plus_1;  
  54.             break;  
  55.         case 6:  
  56.             bounds.left = lineParameters->xStart;  
  57.             bounds.bottom = lineParameters->yStart + 1;  
  58.             bounds.top = lineParameters->yStart - lineParameters->cPels;  
  59.             bounds.right = bounds.left + N_plus_1;  
  60.             break;  
  61.         case 7:  
  62.             bounds.left = lineParameters->xStart;  
  63.             bounds.bottom = lineParameters->yStart + 1;  
  64.             bounds.right = lineParameters->xStart + lineParameters->cPels + 1;  
  65.             bounds.top = bounds.bottom - N_plus_1;  
  66.             break;  
  67.         default:  
  68.             RETAILMSG(0, (TEXT("Invalid direction: %d\r\n"), lineParameters->iDir));  
  69.             return E_INVALIDARG;  
  70.     }  
  71.   
  72.     // check for line overlap with cursor and turn off cursor if overlaps  
  73.     if (m_CursorVisible && !m_CursorDisabled &&  
  74.         m_CursorRect.top < bounds.bottom && m_CursorRect.bottom > bounds.top &&  
  75.         m_CursorRect.left < bounds.right && m_CursorRect.right > bounds.left)  
  76.     {  
  77.         CursorOff();  
  78.         m_CursorForcedOff = TRUE;  
  79.     }  
  80.   
  81.     // do emulated line  
  82.     retval = EmulatedLine (lineParameters);  
  83.   
  84.     // se if cursor was forced off because of overlap with line bouneds and turn back on  
  85.     if (m_CursorForcedOff)  
  86.     {  
  87.         m_CursorForcedOff = FALSE;  
  88.         CursorOn();  
  89.     }  
  90.   
  91.     return  retval;  
  92.   
  93. }  

14.BltPrepare,BltComplete
BltPrepare 和BltComplete都是GPE类的纯虚函数,用户定义的继承类必须实现这两个函数.分别为块传输做准备工作和为块传输"打扫战 场".BltPrepare函数负责向GPEBltParms*类型的参数传递一个负责具体块传输操作的函数指针.由于不支持硬件加速,这里无法做任何特 殊处理.只是将GPE默认的块传输函数复制给GPEBltParms结构的pBlt成员.GPE的EmulatedBlt函数类似于 EmulatedLine函数,是GPE类自带的用软件模拟实现的不具备硬件加速能力的默认块传输函数.BltPrepare的其余代码就是处理如果块传 输操作的源或目的显示表面其中有一个是首要显示表面,并且块传输区域的范围矩形与屏幕上鼠标光标的范围矩形发生重叠,则要暂时消隐鼠标光标.暂时消隐掉的 鼠标光标在块传输完成后由BltComplete函数负责恢复.
BltPrepare:
ROTATE和CLEARTYPE宏均未定义.
view plaincopy to clipboardprint?
  1. SCODE   S3C2410DISP::BltPrepare(GPEBltParms *blitParameters)  
  2. {  
  3.     RECTL   rectl;  
  4.   
  5.     RETAILMSG(0, (TEXT("S3C2410DISP::BltPrepare\r\n")));  
  6.   
  7.     // default to base EmulatedBlt routine  
  8.     blitParameters->pBlt = EmulatedBlt;  
  9.   
  10.     // see if we need to deal with cursor  
  11.     if (m_CursorVisible && !m_CursorDisabled)  
  12.     {  
  13.         // check for destination overlap with cursor and turn off cursor if overlaps  
  14.         if (blitParameters->pDst == m_pPrimarySurface)   // only care if dest is main display surface  
  15.         {  
  16.             if (blitParameters->prclDst != NULL)     // make sure there is a valid prclDst  
  17.             {  
  18.                 rectl = *blitParameters->prclDst;        // if so, use it  
  19.             }  
  20.             else  
  21.             {  
  22.                 rectl = m_CursorRect;                   // if not, use the Cursor rect - this forces the cursor to be turned off in this case  
  23.             }  
  24.   
  25.             if (m_CursorRect.top < rectl.bottom && m_CursorRect.bottom > rectl.top &&  
  26.                 m_CursorRect.left < rectl.right && m_CursorRect.right > rectl.left)  
  27.             {  
  28.                 CursorOff();  
  29.                 m_CursorForcedOff = TRUE;  
  30.             }  
  31.         }  
  32.   
  33.         // check for source overlap with cursor and turn off cursor if overlaps  
  34.         if (blitParameters->pSrc == m_pPrimarySurface)   // only care if source is main display surface  
  35.         {  
  36.             if (blitParameters->prclSrc != NULL)     // make sure there is a valid prclSrc  
  37.             {  
  38.                 rectl = *blitParameters->prclSrc;        // if so, use it  
  39.             }  
  40.             else  
  41.             {  
  42.                 rectl = m_CursorRect;                   // if not, use the CUrsor rect - this forces the cursor to be turned off in this case  
  43.             }  
  44.             if (m_CursorRect.top < rectl.bottom && m_CursorRect.bottom > rectl.top &&  
  45.                 m_CursorRect.left < rectl.right && m_CursorRect.right > rectl.left)  
  46.             {  
  47.                 CursorOff();  
  48.                 m_CursorForcedOff = TRUE;  
  49.             }  
  50.         }  
  51.     }  
  52.  
  53. #ifdef ROTATE  
  54.     if (m_iRotate && (blitParameters->pDst == m_pPrimarySurface || blitParameters->pSrc == m_pPrimarySurface))  
  55.     {  
  56.         blitParameters->pBlt = (SCODE (GPE::*)(GPEBltParms *))EmulatedBltRotate;  
  57.     }  
  58. #endif //ROTATE  
  59.  
  60.     #ifdef CLEARTYPE  
  61.     if (((blitParameters->rop4 & 0xffff) == 0xaaf0 ) && (blitParameters->pMask->Format() == gpe8Bpp))  
  62.     {  
  63.         switch (m_colorDepth)  
  64.         {  
  65.         case 16:  
  66.         blitParameters->pBlt = (SCODE (GPE::*)(struct GPEBltParms *)) ClearTypeBlt::ClearTypeBltDst16;  
  67.         return S_OK;  
  68.         case 24:  
  69. blitParameters->pBlt = (SCODE (GPE::*)(struct GPEBltParms *)) ClearTypeBlt::ClearTypeBltDst24;  
  70.         return S_OK;  
  71.         case 32:  
  72. blitParameters->pBlt = (SCODE (GPE::*)(struct GPEBltParms *)) ClearTypeBlt::ClearTypeBltDst32;  
  73.         return S_OK;  
  74.         default:  
  75.         break;  
  76.         }  
  77.     }  
  78. #endif //CLEARTYPE  
  79.   
  80.     // see if there are any optimized software blits available  
  81.     EmulatedBltSelect02(blitParameters);  
  82.     EmulatedBltSelect08(blitParameters);  
  83.     EmulatedBltSelect16(blitParameters);  
  84.   
  85.     return S_OK;  
  86. }  

BltComplete:
view plaincopy to clipboardprint?
  1. SCODE   S3C2410DISP::BltComplete(GPEBltParms *blitParameters)  
  2. {  
  3.     RETAILMSG(0, (TEXT("S3C2410DISP::BltComplete\r\n")));  
  4.   
  5.     // see if cursor was forced off because of overlap with source or destination and turn back on  
  6.     if (m_CursorForcedOff)  
  7.     {  
  8.         m_CursorForcedOff = FALSE;  
  9.         CursorOn();  
  10.     }  
  11.   
  12.     return S_OK;  
  13. }  

15.InVBlank
InVBlank用来查询显示设备当前时刻是否处在垂直空白阶段.垂直空白阶段指的是CRT类型的显示设备在显示完一帧后,电子枪从屏幕的右下角返回右上角的时间间隙.对于LCD没有这个特性可以利用,因此该函数直接返回0.
view plaincopy to clipboardprint?
  1. INT     S3C2410DISP::InVBlank(void)  
  2. {  
  3.     RETAILMSG(0, (TEXT("S3C2410DISP::InVBlank\r\n")));  
  4.     return 0;  
  5. }  

16.SetPalette
SetPalette用于对显示设备设置调色板.由于当前设备使用RGB565模式的颜色方案,因此不需要使用调色板.仅仅检查参数的有效性.
view plaincopy to clipboardprint?
  1. SCODE   S3C2410DISP::SetPalette(const PALETTEENTRY *source, USHORT firstEntry, USHORT numEntries)  
  2. {  
  3.     RETAILMSG(0, (TEXT("S3C2410DISP::SetPalette\r\n")));  
  4.   
  5.     if (firstEntry < 0 || firstEntry + numEntries > 256 || source == NULL)  
  6.     {  
  7.         return  E_INVALIDARG;  
  8.     }  
  9.   
  10.     return  S_OK;  
  11. }  

17.GetGraphicsCaps
GetGraphicsCaps用于向调用者返回显示设备和驱动程序所能支持的图形处理能力.
这里返回了GCAPS_GRAY16,表示显示设备和驱动程序具备字体反锯齿能力.
返回值可能的取值为以下宏定义或组合.如GCAPS_CLEARTYPE,ClearType技术是更高级的字体反锯齿的软件功能.
view plaincopy to clipboardprint?
  1. #define GCAPS_GRAY16                            0x01000000  
  2. #define GCAPS_CLEARTYPE                         0x00000100   
  3. #define GCAPS_CLEARTYPE_HORIZONTALY_STRIPED     0x00000200  
  4. #define GCAPS_TEXT_CAPS               (GCAPS_GRAY16 | GCAPS_CLEARTYPE | GCAPS_CLEARTYPE_HORIZONTALY_STRIPED)  

view plaincopy to clipboardprint?
  1. ULONG   S3C2410DISP::GetGraphicsCaps()  
  2. {  
  3.      
  4. #ifdef  CLEARTYPE  
  5.     return  GCAPS_GRAY16 | GCAPS_CLEARTYPE;  
  6. #else  
  7.     return  GCAPS_GRAY16;  
  8. #endif   
  9. }  

18.DrvEscape
DrvEscape 是DDI的同名函数DrvEscape的延续,用于获取一些特殊的,通过与设备无关的设备驱动程序接口获取不到的信息.DDI的DrvEscape函数完 成了部分与具体硬件无关的查询,而将需要依赖特定的显示设备硬件信息的交给设备驱动程序的DrvEscape函数.
这里实际上并未实现该函数(CLEARTYPE和ROTATE并未定义),如果定义了这两个宏,就进行Gamma数值和翻转状态的处理.
view plaincopy to clipboardprint?
  1. #if defined(CLEARTYPE) || defined(ROTATE)  
  2. extern GetGammaValue(ULONG * pGamma);  
  3. extern SetGammaValue(ULONG ulGamma, BOOL bUpdateReg);  
  4.   
  5. ULONG  S3C2410DISP::DrvEscape(  
  6.                         SURFOBJ *pso,  
  7.                         ULONG    iEsc,  
  8.                         ULONG    cjIn,  
  9.                         PVOID    pvIn,  
  10.                         ULONG    cjOut,  
  11.                         PVOID    pvOut)  
  12. {  
  13.     if (iEsc == DRVESC_GETGAMMAVALUE)  
  14.     {  
  15.     return GetGammaValue((ULONG *)pvOut);  
  16.     }  
  17.     else if (iEsc == DRVESC_SETGAMMAVALUE)  
  18.     {  
  19.     return SetGammaValue(cjIn, *(BOOL *)pvIn);  
  20.     }  
  21.  
  22. #ifdef ROTATE  
  23.     if (iEsc == DRVESC_GETSCREENROTATION)  
  24.     {  
  25.         *(int *)pvOut = ((DMDO_0 | DMDO_90 | DMDO_180 | DMDO_270) << 8) | ((BYTE)m_iRotate);  
  26.         return DISP_CHANGE_SUCCESSFUL;   
  27.     }  
  28.     else if (iEsc == DRVESC_SETSCREENROTATION)  
  29.     {  
  30.         if ((cjIn == DMDO_0) ||  
  31.            (cjIn == DMDO_90) ||  
  32.            (cjIn == DMDO_180) ||  
  33.            (cjIn == DMDO_270) )  
  34.            {  
  35.                return DynRotate(cjIn);  
  36.            }  
  37.         return DISP_CHANGE_BADMODE;  
  38.     }  
  39. #endif //ROTATE & ROTATE  
  40.       
  41.     return 0;  
  42. }  
  43. #endif //CLEARTYPE  

19.DrvGetMasks
DrvGetMasks是我们唯一一个需要直接实现的DDI函数.该函数用于获取显示设备的当前模式下的颜色掩码.直接返回全局数组的指针gBitMasks,就是之前提到过的565的RGB模式.
static ulong gBitMasks[] = { 0xF800, 0x07E0, 0x001F };  // 565 MODE
view plaincopy to clipboardprint?
  1. ULONG *APIENTRY DrvGetMasks(DHPDEV dhpdev)  
  2. {  
  3.     return gBitMasks;  
  4. }  

至此,GPE继承类S3C2410DISP需要实现的成员函数简单介绍到这里,还有和ClearType和Rotate相关的函数没有介绍,详情可以参考SMDK2410 BSP的显示驱动文件s3c2410x_lcd.cpp.
WinCE6.0 DEVICEEMULATOR BSP(基于s3c2410)的LCD驱动架构也基本类似,唯一大的区别就是使用了DDGPE继承类而不是直接继承GPE类,DDGPE类是GPE的继承 类,支持DirectDraw,由于2410的LCD控制器不支持DirectDraw,因此继承这两个类并无本质的区别.
关于显示驱动还有很多内容并未详细介绍,如DDI函数,GPESurf类,调色板等,需要继续学习.


写原创有奖励！2025面包板原创奖励正在进行中
PARTNER CONTENT
换一换> 更多>

文章评论（0条评论）

登录后参与讨论
wangxinfeng6666_749290079
文章：166 阅读：394060 评论：45 赞：1524
好友 私信 个人主页
EE直播间
更多
在线研讨会
更多
我要评论
0
9
关闭 站长推荐上一条 /4 下一条
  • 帖子
  • 博文