开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
s3c2440disp.cpp
资源名称：SMDK2440.rar　[点击查看]
上传用户：qiulin1960
上传日期：2013-10-16
资源大小：2844k
文件大小：27k
源码类别：

Windows CE

开发平台：

Windows_Unix

s3c2440disp.cpp：源码内容
  1. /*++
  2. THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
  3. ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
  4. THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
  5. PARTICULAR PURPOSE.
  6. Copyright (c) 2001. Samsung Electronics, co. ltd  All rights reserved.
  8. Module Name:  
  10. Abstract:
  12. This file implements the S3C2440 LCD function
  14. rev:
  15. 2002.4.4 : First S3C2410 version (kwangyoon LEE, kwangyoon@samsung.com)
  17. 2002.1.31 : CE.NET port (kwangyoon LEE, kwangyoon@samsung.com)
  19. Notes: 
  20. --*/
  22. #include "precomp.h"
  23. #ifdef CLEARTYPE
  24. #include <ctblt.h>
  25. #endif
  26. #include <aablt.h>
  28. DWORD gdwLCDVirtualFrameBase;
  30. INSTANTIATE_GPE_ZONES(0x3,"MGDI Driver","unused1","unused2") // Start with errors and warnings
  32. static GPE *gGPE = (GPE*)NULL;
  33. static ulong gBitMasks[] = { 0xF800, 0x07E0, 0x001F }; // 565 MODE
  35. static TCHAR gszBaseInstance[256] = _T("Drivers\Display\S3C2440\CONFIG");
  37. #define dim(x)                                  (sizeof(x) / sizeof(x[0]))
  39. // This prototype avoids problems exporting from .lib
  40. BOOL APIENTRY GPEEnableDriver(ULONG engineVersion, ULONG cj, DRVENABLEDATA *data,
  41.   PENGCALLBACKS  engineCallbacks);
  43. // GWES will invoke this routine once prior to making any other calls into the driver.
  44. // This routine needs to save its instance path information and return TRUE.  If it
  45. // returns FALSE, GWES will abort the display initialization.
  46. BOOL APIENTRY
  47. DisplayInit(LPCTSTR pszInstance, DWORD dwNumMonitors)
  48. {
  49. DWORD dwStatus;
  50. HKEY hkDisplay;
  51. BOOL fOk = FALSE;
  53.     RETAILMSG(0, (_T("SALCD2: display instance '%s', num monitors %drn"),
  54.      pszInstance != NULL ? pszInstance : _T("<NULL>"), dwNumMonitors));
  56.     if(pszInstance != NULL) {
  57.         _tcsncpy(gszBaseInstance, pszInstance, dim(gszBaseInstance));
  58.     }
  60. // sanity check the path by making sure it exists
  61. dwStatus = RegOpenKeyEx(HKEY_LOCAL_MACHINE, gszBaseInstance, 0, 0, &hkDisplay);
  62. if(dwStatus == ERROR_SUCCESS) {
  63. RegCloseKey(hkDisplay);
  64. fOk = TRUE;
  65. } else {
  66. RETAILMSG(0, (_T("SALCD2: DisplayInit: can't open '%s'rn"), gszBaseInstance));
  67. }
  69.     return fOk;
  70. }
  72. BOOL APIENTRY DrvEnableDriver(ULONG engineVersion, ULONG cj, DRVENABLEDATA *data,
  73.   PENGCALLBACKS  engineCallbacks)
  74. {
  75. BOOL fOk = FALSE;
  77. // make sure we know where our registry configuration is
  78. if(gszBaseInstance[0] != 0) {
  79. fOk = GPEEnableDriver(engineVersion, cj, data, engineCallbacks);
  80. }
  82. return fOk;
  83. }
  85. //
  86. // Main entry point for a GPE-compliant driver
  87. //
  89. GPE *GetGPE(void)
  90. {
  91. if (!gGPE)
  92. {
  93. gGPE = new S3C2440DISP();
  94. }
  96. return gGPE;
  97. }
  99. #if (LCD_TYPE == TFT640_480)
  100. WORD TempBuffer[641][480];
  101. #elif (LCD_TYPE == TFT240_320)
  102. WORD TempBuffer[241][320];
  103. #endif
  106. S3C2440DISP::S3C2440DISP (void)
  107. {
  108. RETAILMSG(0, (TEXT("++S3C2440DISP::S3C2440DISPrn")));
  110. // setup up display mode related constants
  111. #if (LCD_TYPE == TFT640_480)
  112. m_nScreenWidth  = 640;
  113. m_nScreenHeight = 480;
  114. #elif (LCD_TYPE == TFT240_320)
  115. m_nScreenWidth  = 240;
  116. m_nScreenHeight = 320;
  117. #endif
  118. m_colorDepth = 16;
  119. m_cbScanLineLength = m_nScreenWidth * 2;
  120. m_FrameBufferSize = m_nScreenHeight * m_cbScanLineLength;
  122. // memory map register access window, frame buffer, and program LCD controller
  123. InitializeHardware();
  125. #ifdef ROTATE
  126. m_iRotate = 0;
  127. SetRotateParms();
  128. #endif //ROTATE
  130. // setup ModeInfo structure
  131. m_ModeInfo.modeId = 0;
  132. m_ModeInfo.width = m_nScreenWidth;
  133. m_ModeInfo.height = m_nScreenHeight;
  134. m_ModeInfo.Bpp = m_colorDepth;
  135. m_ModeInfo.format = gpe16Bpp;
  136. m_ModeInfo.frequency = 60; // ?
  137. m_pMode = &m_ModeInfo;
  139. // allocate primary display surface
  140. #ifdef  ROTATE
  141. m_pPrimarySurface = new GPESurfRotate(m_nScreenWidthSave, m_nScreenHeightSave, (void*)(m_VirtualFrameBuffer), m_cbScanLineLength, m_ModeInfo.format);
  142. #else
  143. m_pPrimarySurface = new GPESurf(m_nScreenWidth, m_nScreenHeight, (void*)(m_VirtualFrameBuffer), m_cbScanLineLength, m_ModeInfo.format);
  144. #endif //!ROTATE
  145. memset ((void*)m_pPrimarySurface->Buffer(), 0x0, m_FrameBufferSize);
  147. // init cursor related vars
  148. m_CursorVisible = FALSE;
  149. m_CursorDisabled = TRUE;
  150. m_CursorForcedOff = FALSE;
  151. memset (&m_CursorRect, 0x0, sizeof(m_CursorRect));
  152. m_CursorBackingStore = NULL;
  153. m_CursorXorShape = NULL;
  154. m_CursorAndShape = NULL;
  156. #ifdef CLEARTYPE
  157. HKEY  hKey;
  158. DWORD dwValue;
  159. ULONG ulGamma = DEFAULT_CT_GAMMA;
  161. if (ERROR_SUCCESS == RegCreateKeyEx(HKEY_LOCAL_MACHINE,szGamma,0, NULL,0,0,0,&hKey,&dwValue))
  162. {
  163.     if (dwValue == REG_OPENED_EXISTING_KEY)
  164.     {
  165. DWORD dwType = REG_DWORD;
  166. DWORD dwSize = sizeof(LONG);
  167. if (ERROR_SUCCESS == RegQueryValueEx(hKey,szGammaValue,0,&dwType,(BYTE *)&dwValue,&dwSize))
  168. {
  169.     ulGamma = dwValue;
  170. }
  171.     } 
  172.     else if (dwValue == REG_CREATED_NEW_KEY )
  173.     {
  174. RegSetValueEx(hKey,szGammaValue,0,REG_DWORD,(BYTE *)&ulGamma,sizeof(DWORD));
  175.     }
  176.     RegCloseKey(hKey);
  177. }
  179. SetClearTypeBltGamma(ulGamma);
  180. SetClearTypeBltMasks(gBitMasks[0], gBitMasks[1], gBitMasks[2]);
  181. #endif //CLEARTYPE
  183. RETAILMSG(0, (TEXT("--S3C2440DISP::S3C2440DISPrn")));
  184. }
  186. void S3C2440DISP::InitializeHardware (void)
  187. {
  188. WORD *ptr;
  189. DWORD index;
  190. HKEY hkDisplay = NULL;
  191. DWORD dwLCDPhysicalFrameBase;
  192. DWORD dwStatus, dwType, dwSize;
  194. RETAILMSG(0, (_T("++S3C2440DISP::InitializeHardwarern")));
  196. // open the registry key and read our configuration
  197. dwStatus = RegOpenKeyEx(HKEY_LOCAL_MACHINE, gszBaseInstance, 0, 0, &hkDisplay);
  198. dwType = REG_DWORD;
  200. if(dwStatus == ERROR_SUCCESS && dwType == REG_DWORD) {
  201. dwSize = sizeof(DWORD);
  202. dwStatus = RegQueryValueEx(hkDisplay, _T("LCDVirtualFrameBase"), NULL, &dwType, 
  203. (LPBYTE) &gdwLCDVirtualFrameBase, &dwSize);
  204. }
  205. if(dwStatus == ERROR_SUCCESS && dwType == REG_DWORD) {
  206. dwSize = sizeof(DWORD);
  207. dwStatus = RegQueryValueEx(hkDisplay, _T("LCDPhysicalFrameBase"), NULL, &dwType, 
  208. (LPBYTE) &dwLCDPhysicalFrameBase, &dwSize);
  209. }
  211. // close the registry key
  212. if(hkDisplay != NULL) {
  213. RegCloseKey(hkDisplay);
  214. }
  216. // did we get everything?
  217. if(dwStatus != ERROR_SUCCESS) {
  218. RETAILMSG(0, (_T("SALCD2: InitializeHardware: couldn't get registry configurationrn")));
  219. return;
  220. }
  222. // map frame buffer into process space memory
  223. #if (LCD_TYPE == TFT640_480)
  224. m_VirtualFrameBuffer = (DWORD)VirtualAlloc(0, (0xA0000), MEM_RESERVE, PAGE_NOACCESS);
  225. if (m_VirtualFrameBuffer == NULL) 
  226. {
  227.     RETAILMSG(0,(TEXT("m_VirtualFrameBuffer is not allocatednr")));
  228. return;
  229. }
  230. else if (!VirtualCopy((PVOID)m_VirtualFrameBuffer, (PVOID)gdwLCDVirtualFrameBase, (0xA0000), PAGE_READWRITE | PAGE_NOCACHE))
  231. {
  232.     RETAILMSG(0, (TEXT("m_VirtualFrameBuffer is not mappednr")));
  233.      VirtualFree((PVOID)m_VirtualFrameBuffer, 0, MEM_RELEASE);
  234.      return;
  235. }
  236. #elif (LCD_TYPE == TFT240_320)
  237. m_VirtualFrameBuffer = (DWORD)VirtualAlloc(0, (0x30000), MEM_RESERVE, PAGE_NOACCESS);
  238. if (m_VirtualFrameBuffer == NULL) 
  239. {
  240.     RETAILMSG(0,(TEXT("m_VirtualFrameBuffer is not allocatednr")));
  241. return;
  242. }
  243. else if (!VirtualCopy((PVOID)m_VirtualFrameBuffer, (PVOID)gdwLCDVirtualFrameBase, (0x30000), PAGE_READWRITE | PAGE_NOCACHE))
  244. {
  245.     RETAILMSG(0, (TEXT("m_VirtualFrameBuffer is not mappednr")));
  246.      VirtualFree((PVOID)m_VirtualFrameBuffer, 0, MEM_RELEASE);
  247.      return;
  248. }
  249. #endif
  250. RETAILMSG(0, (TEXT("m_VirtualFrameBuffer is mapped at %x(PHY : %x)nr"), m_VirtualFrameBuffer, gdwLCDVirtualFrameBase));
  251. RETAILMSG(0, (TEXT("Clearing frame buffer !!!nr")));
  253. ptr = (WORD *)m_VirtualFrameBuffer;
  255. // clear rest of frame buffer out
  256. #if (LCD_TYPE == TFT640_480)
  257. for (index = 0; index < 640*480; index++)
  258. {
  259. if(index < 640*120)
  260. {
  261. ptr[index] = 0xf800;
  262. }
  263. else if(index < 640*120*2)
  264. {
  265. ptr[index] = 0x07e0;
  266. }
  267. else if(index < 640*120*3)
  268. {
  269. ptr[index] = 0x001f;
  270. }
  271. else
  272. {
  273. ptr[index] = 0xffff;
  274. }
  275. }
  276. #elif (LCD_TYPE == TFT240_320)
  277. for (index = 0; index < 320*240; index++)
  278. {
  279. if(index < 3200)
  280. {
  281. ptr[index] = 0xf800;
  282. }
  283. else if(index < 6400)
  284. {
  285. ptr[index] = 0x07e0;
  286. }
  287. else if(index < 9600)
  288. {
  289. ptr[index] = 0x001f;
  290. }
  291. else
  292. {
  293. ptr[index] = 0xffff;
  294. }
  295. }
  296. #endif
  297. RETAILMSG(1, (_T("--S3C2440DISP::InitializeHardwarern")));
  298. }
  300. SCODE S3C2440DISP::SetMode (INT modeId, HPALETTE *palette)
  301. {
  302. RETAILMSG(0, (TEXT("++S3C2440DISP::SetModern")));
  304. if (modeId != 0)
  305. {
  306. RETAILMSG(0, (TEXT("S3C2440DISP::SetMode Want mode %d, only have mode 0rn"),modeId));
  307. return E_INVALIDARG;
  308. }
  310. if (palette)
  311. {
  312. *palette = EngCreatePalette (PAL_BITFIELDS, 0, NULL, gBitMasks[0], gBitMasks[1], gBitMasks[2]);
  313. }
  315. RETAILMSG(0, (TEXT("--S3C2440DISP::SetModern")));
  317. return S_OK;
  318. }
  320. SCODE S3C2440DISP::GetModeInfo(GPEMode *mode, INT modeNumber)
  321. {
  322. RETAILMSG(0, (TEXT("++S3C2440DISP::GetModeInforn")));
  324. if (modeNumber != 0)
  325. {
  326. return E_INVALIDARG;
  327. }
  329. *mode = m_ModeInfo;
  331. RETAILMSG(0, (TEXT("--S3C2440DISP::GetModeInforn")));
  333. return S_OK;
  334. }
  336. int S3C2440DISP::NumModes()
  337. {
  338. RETAILMSG(0, (TEXT("++S3C2440DISP::NumModesrn")));
  339. RETAILMSG(0, (TEXT("--S3C2440DISP::NumModesrn")));
  340. return 1;
  341. }
  343. void S3C2440DISP::CursorOn (void)
  344. {
  345. UCHAR *ptrScreen = (UCHAR*)m_pPrimarySurface->Buffer();
  346. UCHAR *ptrLine;
  347. UCHAR *cbsLine;
  348. #ifndef ROTATE
  349. UCHAR *xorLine;
  350. UCHAR *andLine;
  351. #endif //!ROTATE
  352. int x, y;
  354. if (!m_CursorForcedOff && !m_CursorDisabled && !m_CursorVisible)
  355. {
  356. #ifdef ROTATE
  357. RECTL rSave;
  358. int   iRotate;
  359. #endif //ROTATE
  361. if (!m_CursorBackingStore)
  362. {
  363. RETAILMSG(0, (TEXT("S3C2440DISP::CursorOn - No backing store availablern")));
  364. return;
  365. }
  366. #ifdef ROTATE
  367. rSave = m_CursorRect;
  368. RotateRectl(&m_CursorRect);
  369. #endif //ROTATE
  371. for (y = m_CursorRect.top; y < m_CursorRect.bottom; y++)
  372. {
  373. if (y < 0)
  374. {
  375. continue;
  376. }
  377. #ifdef ROTATE
  378. if (y >= m_nScreenHeightSave)
  379. #else
  380. if (y >= m_nScreenHeight)
  381. #endif //ROTATE
  382. {
  383. break;
  384. }
  386. ptrLine = &ptrScreen[y * m_pPrimarySurface->Stride()];
  387. cbsLine = &m_CursorBackingStore[(y - m_CursorRect.top) * (m_CursorSize.x * (m_colorDepth >> 3))];
  388. #ifndef ROTATE
  389. xorLine = &m_CursorXorShape[(y - m_CursorRect.top) * m_CursorSize.x];
  390. andLine = &m_CursorAndShape[(y - m_CursorRect.top) * m_CursorSize.x];
  391. #endif //!ROTATE
  393. for (x = m_CursorRect.left; x < m_CursorRect.right; x++)
  394. {
  395. if (x < 0)
  396. {
  397. continue;
  398. }
  399. #ifdef ROTATE
  400. if (x >= m_nScreenWidthSave)
  401. #else
  402. if (x >= m_nScreenWidth)
  403. #endif //!ROTATE
  404. {
  405. break;
  406. }
  407. #ifdef ROTATE
  408. switch (m_iRotate)
  409. {
  410. case DMDO_0:
  411. iRotate = (y - m_CursorRect.top)*m_CursorSize.x + x - m_CursorRect.left;
  412. break;
  413. case DMDO_90:
  414. iRotate = (x - m_CursorRect.left)*m_CursorSize.x + m_CursorSize.y - 1 - (y - m_CursorRect.top);   
  415. break;
  416. case DMDO_180:
  417. iRotate = (m_CursorSize.y - 1 - (y - m_CursorRect.top))*m_CursorSize.x + m_CursorSize.x - 1 - (x - m_CursorRect.left);
  418. break;
  419. case DMDO_270:
  420. iRotate = (m_CursorSize.x -1 - (x - m_CursorRect.left))*m_CursorSize.x + y - m_CursorRect.top;
  421. break;
  422. default:
  423.     iRotate = (y - m_CursorRect.top)*m_CursorSize.x + x - m_CursorRect.left;
  424. break;
  425. }
  426. #endif //ROTATE
  427. cbsLine[(x - m_CursorRect.left) * (m_colorDepth >> 3)] = ptrLine[x * (m_colorDepth >> 3)];
  428. #ifdef ROTATE
  429. ptrLine[x * (m_colorDepth >> 3)] &= m_CursorAndShape[iRotate];
  430. ptrLine[x * (m_colorDepth >> 3)] ^= m_CursorXorShape[iRotate];
  431. #else 
  432. ptrLine[x * (m_colorDepth >> 3)] &= andLine[x - m_CursorRect.left];
  433. ptrLine[x * (m_colorDepth >> 3)] ^= xorLine[x - m_CursorRect.left];
  434. #endif //ROTATE
  435. if (m_colorDepth > 8)
  436. {
  437. cbsLine[(x - m_CursorRect.left) * (m_colorDepth >> 3) + 1] = ptrLine[x * (m_colorDepth >> 3) + 1];
  438. #ifdef ROTATE
  439.                 ptrLine[x * (m_colorDepth >> 3) + 1] &= m_CursorAndShape[iRotate];
  440. ptrLine[x * (m_colorDepth >> 3) + 1] ^= m_CursorXorShape[iRotate];
  441. #else
  442. ptrLine[x * (m_colorDepth >> 3) + 1] &= andLine[x - m_CursorRect.left];
  443. ptrLine[x * (m_colorDepth >> 3) + 1] ^= xorLine[x - m_CursorRect.left];
  444. #endif //ROTATE
  445. if (m_colorDepth > 16)
  446. {
  447. cbsLine[(x - m_CursorRect.left) * (m_colorDepth >> 3) + 2] = ptrLine[x * (m_colorDepth >> 3) + 2];
  448. #ifdef ROTATE
  449. ptrLine[x * (m_colorDepth >> 3) + 2] &= m_CursorAndShape[iRotate];
  450. ptrLine[x * (m_colorDepth >> 3) + 2] ^= m_CursorXorShape[iRotate];
  451. #else
  452. ptrLine[x * (m_colorDepth >> 3) + 2] &= andLine[x - m_CursorRect.left];
  453. ptrLine[x * (m_colorDepth >> 3) + 2] ^= xorLine[x - m_CursorRect.left];
  454. #endif //ROTATE
  455. }
  456. }
  457. }
  458. }
  459. #ifdef ROTATE
  460. m_CursorRect = rSave;
  461. #endif 
  462. m_CursorVisible = TRUE;
  463. }
  464. }
  466. void S3C2440DISP::CursorOff (void)
  467. {
  468. UCHAR *ptrScreen = (UCHAR*)m_pPrimarySurface->Buffer();
  469. UCHAR *ptrLine;
  470. UCHAR *cbsLine;
  471. int x, y;
  473. if (!m_CursorForcedOff && !m_CursorDisabled && m_CursorVisible)
  474. {
  475. #ifdef ROTATE
  476. RECTL rSave;
  477. #endif //ROTATE
  479. if (!m_CursorBackingStore)
  480. {
  481. RETAILMSG(0, (TEXT("S3C2440DISP::CursorOff - No backing store availablern")));
  482. return;
  483. }
  484. #ifdef ROTATE
  485. rSave = m_CursorRect;
  486. RotateRectl(&m_CursorRect);
  487. #endif //ROTATE
  489. for (y = m_CursorRect.top; y < m_CursorRect.bottom; y++)
  490. {
  491. // clip to displayable screen area (top/bottom)
  492. if (y < 0)
  493. {
  494. continue;
  495. }
  496. #ifndef ROTATE
  497. if (y >= m_nScreenHeight)
  498. #else 
  499. if (y >= m_nScreenHeightSave)
  500. #endif //!ROTATE
  501. {
  502. break;
  503. }
  505. ptrLine = &ptrScreen[y * m_pPrimarySurface->Stride()];
  506. cbsLine = &m_CursorBackingStore[(y - m_CursorRect.top) * (m_CursorSize.x * (m_colorDepth >> 3))];
  508. for (x = m_CursorRect.left; x < m_CursorRect.right; x++)
  509. {
  510. // clip to displayable screen area (left/right)
  511. if (x < 0)
  512. {
  513. continue;
  514. }
  515. #ifndef ROTATE
  516. if (x >= m_nScreenWidth)
  517. #else
  518. if (x>= m_nScreenWidthSave)
  519. #endif //!ROTATE
  520. {
  521. break;
  522. }
  524. ptrLine[x * (m_colorDepth >> 3)] = cbsLine[(x - m_CursorRect.left) * (m_colorDepth >> 3)];
  525. if (m_colorDepth > 8)
  526. {
  527. ptrLine[x * (m_colorDepth >> 3) + 1] = cbsLine[(x - m_CursorRect.left) * (m_colorDepth >> 3) + 1];
  528. if (m_colorDepth > 16)
  529. {
  530. ptrLine[x * (m_colorDepth >> 3) + 2] = cbsLine[(x - m_CursorRect.left) * (m_colorDepth >> 3) + 2];
  531. }
  532. }
  533. }
  534. }
  535. #ifdef ROTATE
  536. m_CursorRect = rSave;
  537. #endif //ROTATE
  538. m_CursorVisible = FALSE;
  539. }
  540. }
  542. SCODE S3C2440DISP::SetPointerShape(GPESurf *pMask, GPESurf *pColorSurf, INT xHot, INT yHot, INT cX, INT cY)
  543. {
  544. UCHAR *andPtr; // input pointer
  545. UCHAR *xorPtr; // input pointer
  546. UCHAR *andLine; // output pointer
  547. UCHAR *xorLine; // output pointer
  548. char bAnd;
  549. char bXor;
  550. int row;
  551. int col;
  552. int i;
  553. int bitMask;
  555. RETAILMSG(0, (TEXT("S3C2440DISP::SetPointerShape(0x%X, 0x%X, %d, %d, %d, %d)rn"),pMask, pColorSurf, xHot, yHot, cX, cY));
  557. // turn current cursor off
  558. CursorOff();
  560. // release memory associated with old cursor
  561. if (m_CursorBackingStore)
  562. {
  563. delete (void*)m_CursorBackingStore;
  564. m_CursorBackingStore = NULL;
  565. }
  566. if (m_CursorXorShape)
  567. {
  568. delete (void*)m_CursorXorShape;
  569.         m_CursorXorShape = NULL;
  570. }
  571. if (m_CursorAndShape)
  572. {
  573. delete (void*)m_CursorAndShape;
  574.         m_CursorAndShape = NULL;
  575. }
  577. if (!pMask) // do we have a new cursor shape
  578. {
  579. m_CursorDisabled = TRUE; // no, so tag as disabled
  580. }
  581. else
  582. {
  583. m_CursorDisabled = FALSE; // yes, so tag as not disabled
  585. // allocate memory based on new cursor size
  586.         m_CursorBackingStore = new UCHAR[(cX * (m_colorDepth >> 3)) * cY];
  587.         m_CursorXorShape = new UCHAR[cX * cY];
  588.         m_CursorAndShape = new UCHAR[cX * cY];
  590. // store size and hotspot for new cursor
  591. m_CursorSize.x = cX;
  592. m_CursorSize.y = cY;
  593. m_CursorHotspot.x = xHot;
  594. m_CursorHotspot.y = yHot;
  596. andPtr = (UCHAR*)pMask->Buffer();
  597. xorPtr = (UCHAR*)pMask->Buffer() + (cY * pMask->Stride());
  599. // store OR and AND mask for new cursor
  600. for (row = 0; row < cY; row++)
  601. {
  602. andLine = &m_CursorAndShape[cX * row];
  603. xorLine = &m_CursorXorShape[cX * row];
  605. for (col = 0; col < cX / 8; col++)
  606. {
  607. bAnd = andPtr[row * pMask->Stride() + col];
  608. bXor = xorPtr[row * pMask->Stride() + col];
  610. for (bitMask = 0x0080, i = 0; i < 8; bitMask >>= 1, i++)
  611. {
  612. andLine[(col * 8) + i] = bAnd & bitMask ? 0xFF : 0x00;
  613. xorLine[(col * 8) + i] = bXor & bitMask ? 0xFF : 0x00;
  614. }
  615. }
  616. }
  617. }
  619. return S_OK;
  620. }
  622. SCODE S3C2440DISP::MovePointer(INT xPosition, INT yPosition)
  623. {
  624. RETAILMSG(0, (TEXT("S3C2440DISP::MovePointer(%d, %d)rn"), xPosition, yPosition));
  626. CursorOff();
  628. if (xPosition != -1 || yPosition != -1)
  629. {
  630. // compute new cursor rect
  631. m_CursorRect.left = xPosition - m_CursorHotspot.x;
  632. m_CursorRect.right = m_CursorRect.left + m_CursorSize.x;
  633. m_CursorRect.top = yPosition - m_CursorHotspot.y;
  634. m_CursorRect.bottom = m_CursorRect.top + m_CursorSize.y;
  636. CursorOn();
  637. }
  639. return S_OK;
  640. }
  642. void S3C2440DISP::WaitForNotBusy(void)
  643. {
  644. RETAILMSG(0, (TEXT("S3C2440DISP::WaitForNotBusyrn")));
  645. return;
  646. }
  648. int S3C2440DISP::IsBusy(void)
  649. {
  650. RETAILMSG(0, (TEXT("S3C2440DISP::IsBusyrn")));
  651. return 0;
  652. }
  654. void S3C2440DISP::GetPhysicalVideoMemory(unsigned long *physicalMemoryBase, unsigned long *videoMemorySize)
  655. {
  656. RETAILMSG(0, (TEXT("S3C2440DISP::GetPhysicalVideoMemoryrn")));
  658. *physicalMemoryBase = gdwLCDVirtualFrameBase;
  659. *videoMemorySize = m_cbScanLineLength * m_nScreenHeight;
  660. }
  662. SCODE S3C2440DISP::AllocSurface(GPESurf **surface, INT width, INT height, EGPEFormat format, INT surfaceFlags)
  663. {
  664. RETAILMSG(0, (TEXT("S3C2440DISP::AllocSurfacern")));
  666. if (surfaceFlags & GPE_REQUIRE_VIDEO_MEMORY)
  667. {
  668. return E_OUTOFMEMORY;
  669. }
  671. // Allocate from system memory
  672. *surface = new GPESurf(width, height, format);
  674. if (*surface != NULL)
  675. {
  676. // Check that the bits were allocated succesfully
  677. if (((*surface)->Buffer()) == NULL)
  678. {
  679. delete *surface; // Clean up
  680. }
  681. else
  682. {
  683. return S_OK;
  684. }
  685. }
  686. return E_OUTOFMEMORY;
  687. }
  689. SCODE S3C2440DISP::WrappedEmulatedLine (GPELineParms *lineParameters)
  690. {
  691. SCODE retval;
  692. RECT bounds;
  693. int N_plus_1; // Minor length of bounding rect + 1
  695. // calculate the bounding-rect to determine overlap with cursor
  696. if (lineParameters->dN) // The line has a diagonal component (we'll refresh the bounding rect)
  697. {
  698. N_plus_1 = 2 + ((lineParameters->cPels * lineParameters->dN) / lineParameters->dM);
  699. }
  700. else
  701. {
  702. N_plus_1 = 1;
  703. }
  705. switch(lineParameters->iDir)
  706. {
  707. case 0:
  708. bounds.left = lineParameters->xStart;
  709. bounds.top = lineParameters->yStart;
  710. bounds.right = lineParameters->xStart + lineParameters->cPels + 1;
  711. bounds.bottom = bounds.top + N_plus_1;
  712. break;
  713. case 1:
  714. bounds.left = lineParameters->xStart;
  715. bounds.top = lineParameters->yStart;
  716. bounds.bottom = lineParameters->yStart + lineParameters->cPels + 1;
  717. bounds.right = bounds.left + N_plus_1;
  718. break;
  719. case 2:
  720. bounds.right = lineParameters->xStart + 1;
  721. bounds.top = lineParameters->yStart;
  722. bounds.bottom = lineParameters->yStart + lineParameters->cPels + 1;
  723. bounds.left = bounds.right - N_plus_1;
  724. break;
  725. case 3:
  726. bounds.right = lineParameters->xStart + 1;
  727. bounds.top = lineParameters->yStart;
  728. bounds.left = lineParameters->xStart - lineParameters->cPels;
  729. bounds.bottom = bounds.top + N_plus_1;
  730. break;
  731. case 4:
  732. bounds.right = lineParameters->xStart + 1;
  733. bounds.bottom = lineParameters->yStart + 1;
  734. bounds.left = lineParameters->xStart - lineParameters->cPels;
  735. bounds.top = bounds.bottom - N_plus_1;
  736. break;
  737. case 5:
  738. bounds.right = lineParameters->xStart + 1;
  739. bounds.bottom = lineParameters->yStart + 1;
  740. bounds.top = lineParameters->yStart - lineParameters->cPels;
  741. bounds.left = bounds.right - N_plus_1;
  742. break;
  743. case 6:
  744. bounds.left = lineParameters->xStart;
  745. bounds.bottom = lineParameters->yStart + 1;
  746. bounds.top = lineParameters->yStart - lineParameters->cPels;
  747. bounds.right = bounds.left + N_plus_1;
  748. break;
  749. case 7:
  750. bounds.left = lineParameters->xStart;
  751. bounds.bottom = lineParameters->yStart + 1;
  752. bounds.right = lineParameters->xStart + lineParameters->cPels + 1;
  753. bounds.top = bounds.bottom - N_plus_1;
  754. break;
  755. default:
  756. RETAILMSG(0, (TEXT("Invalid direction: %drn"), lineParameters->iDir));
  757. return E_INVALIDARG;
  758. }
  760. // check for line overlap with cursor and turn off cursor if overlaps
  761. if (m_CursorVisible && !m_CursorDisabled &&
  762. m_CursorRect.top < bounds.bottom && m_CursorRect.bottom > bounds.top &&
  763. m_CursorRect.left < bounds.right && m_CursorRect.right > bounds.left)
  764. {
  765. CursorOff();
  766. m_CursorForcedOff = TRUE;
  767. }
  769. // do emulated line
  770. retval = EmulatedLine (lineParameters);
  772. // se if cursor was forced off because of overlap with line bouneds and turn back on
  773. if (m_CursorForcedOff)
  774. {
  775. m_CursorForcedOff = FALSE;
  776. CursorOn();
  777. }
  779. return retval;
  781. }
  783. SCODE S3C2440DISP::Line(GPELineParms *lineParameters, EGPEPhase phase)
  784. {
  785. RETAILMSG(0, (TEXT("S3C2440DISP::Linern")));
  787. if (phase == gpeSingle || phase == gpePrepare)
  788. {
  790. if ((lineParameters->pDst != m_pPrimarySurface))
  791. {
  792. lineParameters->pLine = EmulatedLine;
  793. }
  794. else
  795. {
  796. lineParameters->pLine = (SCODE (GPE::*)(struct GPELineParms *)) WrappedEmulatedLine;
  797. }
  798. }
  799. return S_OK;
  800. }
  802. SCODE S3C2440DISP::BltPrepare(GPEBltParms *blitParameters)
  803. {
  804. RECTL rectl;
  806. RETAILMSG(0, (TEXT("S3C2440DISP::BltPreparern")));
  808. // default to base EmulatedBlt routine
  809. blitParameters->pBlt = EmulatedBlt;
  811. // see if we need to deal with cursor
  812. if (m_CursorVisible && !m_CursorDisabled)
  813. {
  814. // check for destination overlap with cursor and turn off cursor if overlaps
  815. if (blitParameters->pDst == m_pPrimarySurface) // only care if dest is main display surface
  816. {
  817. if (blitParameters->prclDst != NULL) // make sure there is a valid prclDst
  818. {
  819. rectl = *blitParameters->prclDst; // if so, use it
  820. }
  821. else
  822. {
  823. rectl = m_CursorRect; // if not, use the Cursor rect - this forces the cursor to be turned off in this case
  824. }
  826. if (m_CursorRect.top < rectl.bottom && m_CursorRect.bottom > rectl.top &&
  827. m_CursorRect.left < rectl.right && m_CursorRect.right > rectl.left)
  828. {
  829. CursorOff();
  830. m_CursorForcedOff = TRUE;
  831. }
  832. }
  834. // check for source overlap with cursor and turn off cursor if overlaps
  835. if (blitParameters->pSrc == m_pPrimarySurface) // only care if source is main display surface
  836. {
  837. if (blitParameters->prclSrc != NULL) // make sure there is a valid prclSrc
  838. {
  839. rectl = *blitParameters->prclSrc; // if so, use it
  840. }
  841. else
  842. {
  843. rectl = m_CursorRect; // if not, use the CUrsor rect - this forces the cursor to be turned off in this case
  844. }
  845. if (m_CursorRect.top < rectl.bottom && m_CursorRect.bottom > rectl.top &&
  846. m_CursorRect.left < rectl.right && m_CursorRect.right > rectl.left)
  847. {
  848. CursorOff();
  849. m_CursorForcedOff = TRUE;
  850. }
  851. }
  852. }
  854. #ifdef ROTATE
  855.     if (m_iRotate && (blitParameters->pDst == m_pPrimarySurface || blitParameters->pSrc == m_pPrimarySurface))
  856.     {
  857.         blitParameters->pBlt = (SCODE (GPE::*)(GPEBltParms *))EmulatedBltRotate;
  858.     }
  859. #endif //ROTATE
  861. #ifdef CLEARTYPE
  862. if (((blitParameters->rop4 & 0xffff) == 0xaaf0 ) && (blitParameters->pMask->Format() == gpe8Bpp))
  863. {
  864.     switch (m_colorDepth)
  865.     {
  866.     case 16:
  867.   blitParameters->pBlt = (SCODE (GPE::*)(struct GPEBltParms *)) ClearTypeBlt::ClearTypeBltDst16;
  868. return S_OK;
  869.     case 24:
  870. blitParameters->pBlt = (SCODE (GPE::*)(struct GPEBltParms *)) ClearTypeBlt::ClearTypeBltDst24;
  871. return S_OK;
  872.     case 32:
  873. blitParameters->pBlt = (SCODE (GPE::*)(struct GPEBltParms *)) ClearTypeBlt::ClearTypeBltDst32;
  874. return S_OK;
  875.     default:
  876. break;
  877.     }
  878. }
  879. #endif //CLEARTYPE
  881. // see if there are any optimized software blits available
  882. EmulatedBltSelect02(blitParameters);
  883. EmulatedBltSelect08(blitParameters);
  884. EmulatedBltSelect16(blitParameters);
  886. return S_OK;
  887. }
  889. SCODE S3C2440DISP::BltComplete(GPEBltParms *blitParameters)
  890. {
  891. RETAILMSG(0, (TEXT("S3C2440DISP::BltCompletern")));
  893. // see if cursor was forced off because of overlap with source or destination and turn back on
  894. if (m_CursorForcedOff)
  895. {
  896. m_CursorForcedOff = FALSE;
  897. CursorOn();
  898. }
  900. return S_OK;
  901. }
  903. INT S3C2440DISP::InVBlank(void)
  904. {
  905. RETAILMSG(0, (TEXT("S3C2440DISP::InVBlankrn")));
  906. return 0;
  907. }
  909. SCODE S3C2440DISP::SetPalette(const PALETTEENTRY *source, USHORT firstEntry, USHORT numEntries)
  910. {
  911. RETAILMSG(0, (TEXT("S3C2440DISP::SetPalettern")));
  913. if (firstEntry < 0 || firstEntry + numEntries > 256 || source == NULL)
  914. {
  915. return E_INVALIDARG;
  916. }
  918. return S_OK;
  919. }
  921. ULONG S3C2440DISP::GetGraphicsCaps()
  922. {
  923.     
  924. #ifdef  CLEARTYPE
  925. return GCAPS_GRAY16 | GCAPS_CLEARTYPE;
  926. #else
  927. return  GCAPS_GRAY16;
  928. #endif 
  929. }
  931. void RegisterDDHALAPI(void)
  932. {
  933. return; // no DDHAL support
  934. }
  936. #if defined(CLEARTYPE) || defined(ROTATE)
  937. //extern GetGammaValue(ULONG * pGamma);
  938. //extern SetGammaValue(ULONG ulGamma, BOOL bUpdateReg);
  940. ULONG  S3C2440DISP::DrvEscape(
  941.                         SURFOBJ *pso,
  942.                         ULONG    iEsc,
  943.                         ULONG    cjIn,
  944.                         PVOID    pvIn,
  945.                         ULONG    cjOut,
  946.                         PVOID    pvOut)
  947. {
  948. /*
  949.     if (iEsc == DRVESC_GETGAMMAVALUE)
  950.     {
  951. return GetGammaValue((ULONG *)pvOut);
  952.     }
  953.     else if (iEsc == DRVESC_SETGAMMAVALUE)
  954.     {
  955. return SetGammaValue(cjIn, *(BOOL *)pvIn);
  956.     }
  957. */
  958. #ifdef ROTATE
  959.     if (iEsc == DRVESC_GETSCREENROTATION)
  960.     {
  961.         *(int *)pvOut = ((DMDO_0 | DMDO_90 | DMDO_180 | DMDO_270) << 8) | ((BYTE)m_iRotate);
  962.         return DISP_CHANGE_SUCCESSFUL; 
  963.     }
  964.     else if (iEsc == DRVESC_SETSCREENROTATION)
  965.     {
  966.         if ((cjIn == DMDO_0) ||
  967.            (cjIn == DMDO_90) ||
  968.            (cjIn == DMDO_180) ||
  969.            (cjIn == DMDO_270) )
  970.            {
  971.                return DynRotate(cjIn);
  972.            }
  973.         return DISP_CHANGE_BADMODE;
  974.     }
  975. #endif //ROTATE & ROTATE
  976.     
  977.     return 0;
  978. }
  979. #endif //CLEARTYPE
  981. ULONG *APIENTRY DrvGetMasks(DHPDEV dhpdev)
  982. {
  983. return gBitMasks;
  984. }
  986. #ifdef ROTATE
  987. void S3C2440DISP::SetRotateParms()
  988. {
  989.     int iswap;
  990.     switch(m_iRotate)
  991.     {
  992.     case DMDO_0:
  993. m_nScreenHeightSave = m_nScreenHeight;
  994. m_nScreenWidthSave = m_nScreenWidth;
  995. break;
  996.     case DMDO_180:
  997. m_nScreenHeightSave = m_nScreenHeight;
  998. m_nScreenWidthSave = m_nScreenWidth;
  999. break;
  1000. case DMDO_90:
  1001. case DMDO_270:
  1002. iswap = m_nScreenHeight;
  1003. m_nScreenHeight = m_nScreenWidth;
  1004. m_nScreenWidth = iswap;
  1005.     m_nScreenHeightSave = m_nScreenWidth;
  1006.     m_nScreenWidthSave = m_nScreenHeight;
  1007. break;
  1008. default:
  1009.    m_nScreenHeightSave = m_nScreenHeight;
  1010. m_nScreenWidthSave = m_nScreenWidth;
  1011. break;
  1012.     }
  1013. return;
  1014. }
  1016. LONG S3C2440DISP::DynRotate(int angle)
  1017. {
  1018.     GPESurfRotate *pSurf = (GPESurfRotate *)m_pPrimarySurface;
  1019. if (angle == m_iRotate)
  1020. return DISP_CHANGE_SUCCESSFUL;
  1022. m_iRotate = angle;
  1024. switch(m_iRotate)
  1025.     {
  1026.     case DMDO_0:
  1027.     case DMDO_180:
  1028. m_nScreenHeight = m_nScreenHeightSave;
  1029. m_nScreenWidth = m_nScreenWidthSave;
  1030. break;
  1031. case DMDO_90:
  1032. case DMDO_270:
  1033. m_nScreenHeight = m_nScreenWidthSave;
  1034. m_nScreenWidth = m_nScreenHeightSave;
  1035. break;
  1036.     }
  1038. m_pMode->width = m_nScreenWidth;
  1039. m_pMode->height = m_nScreenHeight;
  1040. pSurf->SetRotation(m_nScreenWidth, m_nScreenHeight, angle);
  1042. return DISP_CHANGE_SUCCESSFUL;
  1043. }
  1044. #endif //ROTATE