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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
overlay_hires.c
资源名称：tcpmp.rar　[点击查看]
上传用户：wstnjxml
上传日期：2014-04-03
资源大小：7248k
文件大小：21k
源码类别：

Windows CE

开发平台：

C/C++

overlay_hires.c：源码内容
  1. /*****************************************************************************
  2.  *
  3.  * This program is free software ; you can redistribute it and/or modify
  4.  * it under the terms of the GNU General Public License as published by
  5.  * the Free Software Foundation; either version 2 of the License, or
  6.  * (at your option) any later version.
  7.  *
  8.  * This program is distributed in the hope that it will be useful,
  9.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11.  * GNU General Public License for more details.
  12.  *
  13.  * You should have received a copy of the GNU General Public License
  14.  * along with this program; if not, write to the Free Software
  15.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16.  *
  17.  * $Id: overlay_hires.c 543 2006-01-07 22:06:24Z picard $
  18.  *
  19.  * The Core Pocket Media Player
  20.  * Copyright (c) 2004-2005 Gabor Kovacs
  21.  *
  22.  ****************************************************************************/
  24. #include "../common.h"
  26. #if defined(TARGET_PALMOS)
  28. #include "../palmos/pace.h"
  30. #ifdef HAVE_PALMONE_SDK
  31. #include <68K/System/PalmDisplayExtent.h>
  32. static UInt16 DEX = sysInvalidRefNum;
  33. #endif
  35. #undef CPU_TYPE
  36. #define CPU_TYPE CPU_68K
  37. #include "RotationMgrLib.h"
  38. static UInt16 RotM = sysInvalidRefNum;
  40. typedef struct xscaledesc
  41. {
  42. uint32_t Next;
  43. uint32_t Base;
  44. uint32_t Id;
  45. uint32_t Cmd;
  47. } xscaledesc;
  49. typedef struct hiresbuffer
  50. {
  51. block Buffer;
  52. uint32_t DescPhy;
  53. xscaledesc* Desc;
  54. uint32_t SurfacePhy;
  55. uint8_t* Surface;
  57. } hiresbuffer;
  59. #define MAGIC 0xBABE0000
  61. #define XSCALE_LCD_BASE 0x44000000
  63. #define LCCR0 (0x000/4)
  64. #define LCCR1 (0x004/4)
  65. #define LCCR2 (0x008/4)
  66. #define LCCR3 (0x00C/4)
  67. #define LCCR4 (0x010/4)
  68. #define LCCR5 (0x014/4)
  69. #define LCSR0 (0x038/4)
  70. #define LCSR1 (0x034/4)
  71. #define FBR0 (0x020/4)
  72. #define FDADR0 (0x200/4)
  73. #define FSADR0 (0x204/4)
  74. #define FIDR0 (0x208/4)
  76. #define OMAP_LCD_BASE 0xfffec000
  77. #define OMAP_DMA_BASE 0xfffedb00
  78. #define OMAP_PAL_SIZE 32
  80. #define OMAP_CONTROL 0
  81. #define OMAP_TIMING0 1
  82. #define OMAP_TIMING1 2
  83. #define OMAP_TIMING2 3
  84. #define OMAP_STATUS  4
  86. #define OMAP_DMA_CONTROL 0
  87. #define OMAP_DMA_TOP_L 1
  88. #define OMAP_DMA_TOP_U 2
  89. #define OMAP_DMA_BOTTOM_L 3
  90. #define OMAP_DMA_BOTTOM_U 4
  92. typedef struct hires hires;
  93. typedef int (*hiresfunc)(hires* This);
  95. struct hires
  96. {
  97. overlay Overlay;
  98. bool_t UseLocking;
  99. bool_t Locked;
  100. char* Bits;
  101. int Offset;
  102. int BufferCount;
  103. hiresbuffer Buffer[3];
  104. int Next;
  105. int PhyWidth;
  106. int PhyHeight;
  107. int SurfaceSize;
  108. int SurfaceOffset;
  109. int OrigPitch;
  110. uint32_t OrigPhy;
  111. uint32_t OrigPhyEnd;
  112. int Border[4];
  113. volatile uint32_t* Regs;
  114. volatile uint16_t* Regs2;
  115. int Caps;
  116. int Model;
  117. bool_t UseBorder;
  118. bool_t TripleBuffer;
  119. bool_t LowLevelFailed;
  120. hiresfunc LowLevelAlloc;
  121. hiresfunc LowLevelGet;
  122. hiresfunc LowLevelGetOrig;
  123. hiresfunc LowLevelSetOrig;
  124. hiresfunc LowLevelFlip;
  125. };
  127. static char* GetBits()
  128. {
  129. BitmapType* Bitmap;
  130. WinHandle Win = WinGetDisplayWindow();
  131. if (!Win)
  132. return NULL;
  134. Bitmap = WinGetBitmap(Win);
  135. if (!Bitmap)
  136. return NULL;
  138. return BmpGetBits(Bitmap);
  139. }
  141. static bool_t ProcessRawInfo(video* Video,char* Bits,char* RawBits,int Width,int Height,int Pitch,int* Offset,bool_t MovedSIP)
  142. {
  143. int Dir = GetOrientation();
  145. Video->Pitch = Pitch;
  147. if (Width > Height) // native landscape device
  148. Dir = CombineDir(Dir,DIR_SWAPXY|DIR_MIRRORUPDOWN,0);
  150. // trust GetBits() if it's inside the Raw buffer
  151. if (Bits >= RawBits && Bits < RawBits + Height*Pitch) 
  152. return 0; 
  154. if (!MovedSIP && Dir==0) // assuming working GetBits() with RotM in native mode
  155. return 0; 
  157. if (Dir & DIR_SWAPXY)
  158. SwapInt(&Video->Width,&Video->Height);
  160. if (Width > Height) // native landscape device
  161. {
  162. if ((Dir & DIR_SWAPXY)==0 ? GetHandedness() : (Dir & DIR_MIRRORLEFTRIGHT)!=0)
  163. *Offset = (Width-Video->Width)*(Video->Pixel.BitCount >> 3);
  164. }
  165. else 
  166. {
  167. // native portrait device
  168. if ((Dir & DIR_SWAPXY) && MovedSIP) // don't adjust for RotM (SIP stays on native bottom)
  169. {
  170. // assuming taskbar and SIP is in the upper part of the screen in landscape mode
  171. if (Height > 320+32 && Video->Height <= 320+32 && DIASupported() && !DIAGet(DIA_SIP))
  172. Height = 320+32; // closed slider on Tungsten T3
  173. *Offset = (Height-Video->Height)*Pitch;
  174. }
  175. }
  177. Video->Direction = Dir;
  178. return 1;
  179. }
  181. char* QueryScreen(video* Video,int* Offset,int* Mode)
  182. {
  183. char* Bits = GetBits(); 
  184. QueryDesktop(Video);
  185. *Offset = 0;
  186. if (Mode) *Mode = 0;
  188. #ifdef HAVE_PALMONE_SDK
  189. if (DEX != sysInvalidRefNum)
  190. {
  191. UInt16 Pitch;
  192. Coord Width,Height;
  193. char* RawBits = DexGetDisplayAddress(DEX);
  194. if (RawBits)
  195. {
  196. DexGetDisplayDimensions(DEX,&Width,&Height,&Pitch);
  197. if (ProcessRawInfo(Video,Bits,RawBits,Width,Height,Pitch,Offset,1))
  198. {
  199. if (Mode) *Mode = 1;
  200. return RawBits;
  201. }
  202. }
  203. }
  204. #endif
  206. if (RotM != sysInvalidRefNum)
  207. {
  208. UInt32 RawBits;
  209. UInt32 Width,Height,Pitch;
  211. if (RotationMgrAttributeGet(RotM,kRotationMgrAttrDisplayAddress,&RawBits)==errNone && RawBits &&
  212. RotationMgrAttributeGet(RotM,kRotationMgrAttrDisplayWidth,&Width)==errNone &&
  213. RotationMgrAttributeGet(RotM,kRotationMgrAttrDisplayHeight,&Height)==errNone &&
  214. RotationMgrAttributeGet(RotM,kRotationMgrAttrDisplayRowBytes,&Pitch)==errNone &&
  215. ProcessRawInfo(Video,Bits,(char*)RawBits,Width,Height,Pitch,Offset,0))
  216. {
  217. if (Mode) *Mode = 2;
  218. return (char*)RawBits;
  219. }
  220. }
  222. if (Video->Pitch < Video->Width*(Video->Pixel.BitCount/8))
  223. return NULL;
  225. return Bits;
  226. }
  228. static int BufferFree(hires* p)
  229. {
  230. int n;
  231. for (n=0;n<p->BufferCount;++n)
  232. FreeBlock(&p->Buffer[n].Buffer);
  233. p->BufferCount = 0;
  234. memset(&p->Buffer,0,sizeof(p->Buffer));
  235. return ERR_NONE;
  236. }
  238. static int Init(hires* p)
  239. {
  240. int Mode;
  241. p->Overlay.SetFX = BLITFX_AVOIDTEARING;
  242. p->UseLocking = 0;
  244. if (QueryPlatform(PLATFORM_MODEL)==MODEL_ZODIAC)
  245. {
  246. int Dir = GetOrientation();
  247. if (Dir & DIR_SWAPXY)
  248. {
  249. p->Overlay.SetFX |= BLITFX_VMEMROTATED;
  250. if (Dir & DIR_MIRRORLEFTRIGHT)
  251. p->Overlay.SetFX |= BLITFX_VMEMUPDOWN;
  252. }
  253. }
  255. p->Bits = QueryScreen(&p->Overlay.Output.Format.Video,&p->Offset,&Mode);
  256. if (!p->Bits)
  257. return ERR_INVALID_PARAM;
  259. if (!Mode)
  260. p->Bits = NULL; // use GetBits() during Lock()
  262. p->OrigPitch = p->Overlay.Output.Format.Video.Pitch;
  263. p->Next = 0;
  264. p->LowLevelFailed = 0;
  265. return ERR_NONE;
  266. }
  268. static void Hide(hires* p)
  269. {
  270. if (p->Overlay.Overlay)
  271. {
  272. p->LowLevelSetOrig(p);
  273. p->Overlay.Overlay = 0;
  274. p->Overlay.Output.Format.Video.Pitch = p->OrigPitch;
  275. }
  276. }
  278. static void Done(hires* p)
  279. {
  280. Hide(p);
  281. BufferFree(p);
  282. }
  284. static int UpdateAlloc(hires* p)
  285. {
  286. int MaxCount = 1;
  287. if (p->TripleBuffer)
  288. MaxCount = 3;
  290. if (p->UseBorder)
  291. {
  292. p->SurfaceSize = (p->PhyWidth+p->Border[0]+p->Border[1])*(p->PhyHeight+p->Border[2]+p->Border[3])*2;
  293. p->SurfaceOffset = ((p->PhyWidth+p->Border[0]+p->Border[1])*p->Border[2]+p->Border[0])*2;
  294. }
  295. else
  296. {
  297. p->SurfaceSize = p->PhyWidth*p->PhyHeight*2;
  298. p->SurfaceOffset = 0;
  299. }
  301. while (p->BufferCount<MaxCount)
  302. if (p->LowLevelAlloc(p) == ERR_NONE)
  303. ++p->BufferCount;
  304. else
  305. break;
  307. if (p->BufferCount==2)
  308. {
  309. FreeBlock(&p->Buffer[1].Buffer);
  310. --p->BufferCount;
  311. }
  313. if (!p->BufferCount)
  314. return ERR_OUT_OF_MEMORY;
  315. return ERR_NONE;
  316. }
  318. static int Update(hires* p)
  319. {
  320. if (p->Overlay.FullScreenViewport && (p->UseBorder || p->TripleBuffer) && 
  321. !p->LowLevelFailed && (p->Overlay.Overlay || (p->LowLevelGetOrig && p->LowLevelGetOrig(p)==ERR_NONE)))
  322. {
  323. p->Overlay.Overlay = 1;
  324. if (UpdateAlloc(p)!=ERR_NONE || (p->BufferCount<3 && !p->UseBorder))
  325. {
  326. Hide(p);
  327. p->LowLevelFailed = 1;
  328. BufferFree(p);
  329. }
  330. else
  331. {
  332. int n;
  333. for (n=0;n<p->BufferCount;++n)
  334. memset(p->Buffer[n].Surface,0,p->SurfaceSize);
  335. }
  336. }
  337. else
  338. Hide(p);
  340. p->Overlay.DoPowerOff = p->Overlay.Overlay;
  341. return OverlayUpdateAlign(&p->Overlay);
  342. }
  344. static int Show(hires* p)
  345. {
  346. if (!p->Overlay.Show && p->Overlay.Overlay)
  347. {
  348. p->LowLevelSetOrig(p);
  349. p->Next = 0;
  350. }
  351. return ERR_NONE;
  352. }
  354. static int Reset(hires* p)
  355. {
  356. int Pitch = p->Overlay.Output.Format.Video.Pitch;
  357. Init(p);
  358. if (p->Overlay.Overlay)
  359. p->Overlay.Output.Format.Video.Pitch = Pitch;
  360. return ERR_NONE;
  361. }
  363. static int Lock(hires* p, planes Planes, bool_t OnlyAligned)
  364. {
  365. if (p->Overlay.Overlay)
  366. {
  367. int Next = p->Next+1;
  368. if (Next == p->BufferCount) 
  369. Next = 0;
  371. // use new buffer only if it's not the current
  372. if (p->LowLevelGet(p) != Next) 
  373. p->Next = Next;
  375. Planes[0] = p->Buffer[p->Next].Surface + p->SurfaceOffset;
  376. }
  377. else
  378. if (p->UseLocking && p->Overlay.CurrTime>=0 &&  // don't use locking with benchmark
  379. (Planes[0] = WinScreenLock(p->Overlay.Dirty?winLockCopy:winLockDontCare)) != NULL)
  380. p->Locked = 1;
  381. else
  382. if (p->Bits)
  383. Planes[0] = p->Bits + p->Offset;
  384. else
  385. {
  386. char* Bits = GetBits();
  387. if (!Bits)
  388. return ERR_DEVICE_ERROR;
  389. Planes[0] = Bits;
  390. }
  391. return ERR_NONE;
  392. }
  394. static int Unlock(hires* p)
  395. {
  396. if (p->Overlay.Overlay)
  397. return p->LowLevelFlip(p);
  398. else
  399. if (p->Locked)
  400. WinScreenUnlock();
  401. return ERR_NONE;
  402. }
  404. //-------------------------------------------------------------------------------
  406. static int XScaleGetOrig(hires* p)
  407. {
  408. int ReTry = 0;
  409. do
  410. {
  411. ThreadSleep(2);
  412. if (++ReTry == 5) return ERR_NOT_SUPPORTED;
  413. }
  414. while (!(p->Regs[LCCR0] & 1)); // again if lcd disabled
  416. p->PhyWidth = (p->Regs[LCCR1] & 0x3FF)+1;
  417. p->PhyHeight = (p->Regs[LCCR2] & 0x3FF)+1;
  419. if (p->Overlay.Output.Format.Video.Width > p->PhyWidth ||
  420. p->Overlay.Output.Format.Video.Height > p->PhyHeight)
  421. return ERR_NOT_SUPPORTED; // this shouldn't happen
  423. p->OrigPhy = p->Regs[FDADR0];
  424. if (!p->OrigPhy)
  425. return ERR_NOT_SUPPORTED; // this shouldn't happen
  427. // assuming physical direction and size is already correct
  428. p->Overlay.Output.Format.Video.Pitch = p->PhyWidth*2;
  429. if (p->UseBorder)
  430. p->Overlay.Output.Format.Video.Pitch += (p->Border[0]+p->Border[1])*2;
  432. return ERR_NONE;
  433. }
  435. static int XScaleAlloc(hires* p)
  436. {
  437. hiresbuffer* Buffer = p->Buffer+p->BufferCount;
  438. if (!AllocBlock(16+sizeof(xscaledesc)+256+p->SurfaceSize,&Buffer->Buffer,0,HEAP_ANYWR))
  439. return ERR_OUT_OF_MEMORY;
  440. Buffer->Desc = (xscaledesc*)ALIGN16((uintptr_t)Buffer->Buffer.Ptr);
  441. Buffer->DescPhy = MemVirtToPhy(Buffer->Desc);
  442. if (!Buffer->DescPhy)
  443. {
  444. FreeBlock(&Buffer->Buffer);
  445. return ERR_NOT_SUPPORTED;
  446. }
  447. Buffer->Surface = (uint8_t*)Buffer->Desc+sizeof(xscaledesc)+256;
  448. Buffer->SurfacePhy = Buffer->DescPhy+sizeof(xscaledesc)+256; 
  449. Buffer->Desc->Base = Buffer->SurfacePhy;
  450. Buffer->Desc->Id = MAGIC|(p->BufferCount << 4); 
  451. Buffer->Desc->Next = Buffer->DescPhy; 
  452. Buffer->Desc->Cmd = p->SurfaceSize | (1<<21);
  453. return ERR_NONE;
  454. }
  456. static int XScaleGet(hires* p)
  457. {
  458. int Id = p->Regs[FIDR0] & ~15;
  459. uint32_t Phy = p->Regs[FDADR0] & ~15;
  461. if ((Id & 0xFFFF0000) == MAGIC)
  462. return (Id >> 4) & 0xFF;
  464. if (Phy == p->OrigPhy || Phy == p->OrigPhy+sizeof(xscaledesc))
  465. return -1;
  467. p->OrigPhy = Phy; // changed...
  468. return -1; 
  469. }
  471. static void XScaleQuickDisable(hires* p)
  472. {
  473. int n = p->Regs[LCCR0];
  474. n &= ~(1<<10); //DIS
  475. n &= ~1;    //ENB
  476. p->Regs[LCCR0] = n;
  477. ThreadSleep(1);
  478. }
  480. static void XScaleDisable(hires* p)
  481. {
  482. int i;
  483. int n = p->Regs[LCCR0];
  484. if (n & 1)
  485. {
  486. n |= 1<<10; //DIS
  487. p->Regs[LCCR0] = n;
  489. for (i=0;i<30;++i)
  490. {
  491. if (!(p->Regs[LCCR0] & 1)) 
  492. break;
  493. ThreadSleep(1);
  494. }
  496. if (i==30)
  497. XScaleQuickDisable(p);
  498. }
  499. }
  501. static void XScaleEnable(hires* p,uint32_t Phy)
  502. {
  503. int n = p->Regs[LCCR0];
  504. n &= ~(1<<10); //DIS
  505. n |= 1; //EN;
  506. p->Regs[FBR0] = 0;
  507. p->Regs[FDADR0] = Phy;
  508. p->Regs[LCCR0] = n;
  509. ThreadSleep(1);
  510. }
  512. static NOINLINE bool_t TimeAdjust(volatile uint32_t* p,int x,int left,int right,bool_t UseBorder)
  513. {
  514. int o1,o2;
  515. uint32_t n;
  516. uint32_t v = *p;
  518. if (UseBorder)
  519. x += left+right;
  520. --x;
  521. n = v & 0x3FF;
  522. if ((int)n == x)
  523. return 0;
  525. v &= ~0x3FF;
  526. v |= x;
  528. x -= n;
  529. if (x>=left)
  530. o1 = left;
  531. else
  532. if (x<=-left)
  533. o1 = -left;
  534. else
  535. o1 = x >> 1;
  536. o2 = x - o1;
  538. n = (v >> 16) & 0xFF;
  539. v &= ~0xFF0000;
  540. v |= (n-o2) << 16; 
  542. n = (v >> 24) & 0xFF;
  543. v &= ~0xFF000000;
  544. v |= (n-o1) << 24; 
  546. *p = v;
  547. return 1;
  548. }
  550. static NOINLINE bool_t Adjust(hires* p,volatile uint32_t* p1,volatile uint32_t* p2,bool_t UseBorder)
  551. {
  552. bool_t Changed;
  553. Changed = TimeAdjust(p1,p->PhyWidth,p->Border[0],p->Border[1],UseBorder);
  554. Changed = TimeAdjust(p2,p->PhyHeight,p->Border[2],p->Border[3],UseBorder) || Changed;
  555. return Changed;
  556. }
  558. static void XScaleChange(hires* p,uint32_t Phy,bool_t UseBorder)
  559. {
  560. XScaleDisable(p);
  561. if (Adjust(p,&p->Regs[LCCR1],&p->Regs[LCCR2],UseBorder))
  562. {
  563. // PXA270 bug. need to enable/disable twice
  564. XScaleEnable(p,Phy);
  565. XScaleDisable(p);
  566. }
  567. XScaleEnable(p,Phy);
  568. }
  570. static int XScaleSetOrig(hires* p)
  571. {
  572. if (XScaleGet(p)>=0)
  573. XScaleChange(p,p->OrigPhy,0);
  574. return ERR_NONE;
  575. }
  577. static int XScaleFlip(hires* p)
  578. {
  579. uint32_t DescPhy = p->Buffer[p->Next].DescPhy;
  580. p->Buffer[p->Next].Desc->Next = DescPhy; // close chain
  582. if (!(p->Regs[LCCR0] & 1)) // is lcd enabled?
  583. return ERR_DEVICE_ERROR;
  585. if (XScaleGet(p)<0)
  586. XScaleChange(p,DescPhy,p->UseBorder);
  587. else
  588. {
  589. // modify last frames tail to new frame
  590. int Current = p->Next-1;
  591. if (Current<0)
  592. Current = p->BufferCount-1;
  593. p->Buffer[Current].Desc->Next = DescPhy;
  594. }
  595. return ERR_NONE;
  596. }
  598. //-------------------------------------------------------------------------------
  600. static int OMAPGetOrig(hires* p)
  601. {
  602. int ReTry = 0;
  603. do
  604. {
  605. ThreadSleep(1);
  606. if (++ReTry == 5) return ERR_NOT_SUPPORTED;
  607. }
  608. while (!(p->Regs[OMAP_CONTROL] & 1)); // again if lcd disabled
  610. p->PhyWidth = (p->Regs[OMAP_TIMING0] & 0x3FF)+1;
  611. p->PhyHeight = (p->Regs[OMAP_TIMING1] & 0x3FF)+1;
  613. if (p->Overlay.Output.Format.Video.Width > p->PhyWidth ||
  614. p->Overlay.Output.Format.Video.Height > p->PhyHeight)
  615. return ERR_NOT_SUPPORTED; // this shouldn't happen
  617. p->OrigPhy = (p->Regs2[OMAP_DMA_TOP_U] << 16) | p->Regs2[OMAP_DMA_TOP_L];
  618. p->OrigPhyEnd = (p->Regs2[OMAP_DMA_BOTTOM_U] << 16) | p->Regs2[OMAP_DMA_BOTTOM_L];
  620. if (!p->OrigPhy)
  621. return ERR_NOT_SUPPORTED; // this shouldn't happen
  623. // assuming physical direction and size is already correct
  624. p->Overlay.Output.Format.Video.Pitch = p->PhyWidth*2;
  625. if (p->UseBorder)
  626. p->Overlay.Output.Format.Video.Pitch += (p->Border[0]+p->Border[1])*2;
  627. return ERR_NONE;
  628. }
  630. static int OMAPAlloc(hires* p)
  631. {
  632. hiresbuffer* Buffer = p->Buffer+p->BufferCount;
  633. if (!AllocBlock(p->SurfaceSize+16+OMAP_PAL_SIZE,&Buffer->Buffer,0,HEAP_ANYWR))
  634. return ERR_OUT_OF_MEMORY;
  635. Buffer->Surface = (uint8_t*)ALIGN16((uintptr_t)Buffer->Buffer.Ptr)+OMAP_PAL_SIZE;
  637. memset(Buffer->Surface-OMAP_PAL_SIZE,0,OMAP_PAL_SIZE); //clear palette
  638. Buffer->Surface[-OMAP_PAL_SIZE+1] = 0x40; //set 16bit mode framebuffer
  640. Buffer->SurfacePhy = MemVirtToPhy(Buffer->Surface);
  641. if (!Buffer->SurfacePhy)
  642. {
  643. FreeBlock(&Buffer->Buffer);
  644. return ERR_NOT_SUPPORTED;
  645. }
  646. return ERR_NONE;
  647. }
  649. static int OMAPGet(hires* p)
  650. {
  651. uint32_t Phy = p->Regs2[OMAP_DMA_TOP_L] | (p->Regs2[OMAP_DMA_TOP_U] << 16);
  652. int n;
  654. for (n=0;n<p->BufferCount;++n)
  655. if (Phy == p->Buffer[n].SurfacePhy-OMAP_PAL_SIZE)
  656. return 0;
  658. p->OrigPhy = Phy;
  659. return -1; 
  660. }
  662. static void OMAPDisable(hires* p)
  663. {
  664. int i;
  665. int n = p->Regs[OMAP_CONTROL];
  666. if (n & 1)
  667. {
  668. n &= ~1;
  669. p->Regs[OMAP_CONTROL] = n;
  671. for (i=0;i<50;++i)
  672. {
  673. if (p->Regs[OMAP_STATUS] & 1) 
  674. break;
  675. ThreadSleep(1);
  676. }
  677. }
  678. }
  680. static void OMAPEnable(hires* p)
  681. {
  682. int v = p->Regs[OMAP_CONTROL];
  683. v |= 1;
  684. p->Regs[OMAP_CONTROL] = v;
  685. ThreadSleep(1);
  686. }
  688. static void OMAPChange(hires* p,uint32_t Phy,uint32_t PhyEnd,bool_t UseBorder)
  689. {
  690. bool_t Old = (p->Regs[OMAP_CONTROL] & 1);
  691. OMAPDisable(p);
  692. Adjust(p,&p->Regs[OMAP_TIMING0],&p->Regs[OMAP_TIMING1],UseBorder);
  693. p->Regs2[OMAP_DMA_TOP_U] = (uint16_t)(Phy >> 16);
  694. p->Regs2[OMAP_DMA_TOP_L] = (uint16_t)(Phy);
  695. p->Regs2[OMAP_DMA_BOTTOM_U] = (uint16_t)(PhyEnd >> 16);
  696. p->Regs2[OMAP_DMA_BOTTOM_L] = (uint16_t)(PhyEnd);
  697. if (Old) OMAPEnable(p);
  698. }
  700. static int OMAPSetOrig(hires* p)
  701. {
  702. if (OMAPGet(p)>=0)
  703. OMAPChange(p,p->OrigPhy,p->OrigPhyEnd,0);
  704. return ERR_NONE;
  705. }
  707. static int OMAPFlip(hires* p)
  708. {
  709. if (!(p->Regs[OMAP_CONTROL] & 1)) // is lcd enabled?
  710. return ERR_DEVICE_ERROR;
  712. if (OMAPGet(p)<0)
  713. OMAPChange(p,p->Buffer[0].SurfacePhy-OMAP_PAL_SIZE,p->Buffer[0].SurfacePhy+p->SurfaceSize-2,p->UseBorder);
  714. return ERR_NONE;
  715. }
  717. //-------------------------------------------------------------------------------
  719. static const datatable Params[] = 
  720. {
  721. { HIRES_TRIPLEBUFFER, TYPE_BOOL, DF_SETUP|DF_CHECKLIST },
  722. { HIRES_USEBORDER, TYPE_BOOL, DF_SETUP|DF_CHECKLIST },
  723. { HIRES_USEBORDER_INFO, TYPE_LABEL, DF_SETUP },
  725. DATATABLE_END(HIRES_ID)
  726. };
  728. static int Enum(hires* p, int* No, datadef* Param)
  729. {
  730. int Result;
  731. if (OverlayEnum(&p->Overlay,No,Param)==ERR_NONE)
  732. return ERR_NONE;
  733. Result = NodeEnumTable(No,Param,Params);
  734. if (Result==ERR_NONE)
  735. {
  736. if (Param->No == HIRES_TRIPLEBUFFER && (!p->Regs || !(p->Caps & CAPS_ARM_XSCALE)))
  737. Param->Flags |= DF_HIDDEN;
  738. if (Param->No == HIRES_USEBORDER && !p->Regs)
  739. Param->Flags |= DF_HIDDEN;
  740. }
  741. return Result;
  742. }
  744. static int Get(hires* p,int No,void* Data,int Size)
  745. {
  746. int Result = OverlayGet(&p->Overlay,No,Data,Size);
  747. switch (No) 
  748. {
  749. case HIRES_TRIPLEBUFFER: GETVALUE(p->TripleBuffer,bool_t); break;
  750. case HIRES_USEBORDER: GETVALUE(p->UseBorder,bool_t); break;
  751. }
  752. return Result;
  753. }
  755. static int UpdateLowLevel(hires* p)
  756. {
  757. p->LowLevelFailed = 0;
  758. Hide(p);
  759. BufferFree(p);
  760. OverlayUpdateFX(&p->Overlay,1);
  761. return ERR_NONE;
  762. }
  764. static int Set(hires* p,int No,const void* Data,int Size)
  765. {
  766. int Result = OverlaySet(&p->Overlay,No,Data,Size);
  767. switch (No)
  768. {
  769. case HIRES_TRIPLEBUFFER: SETVALUECMP(p->TripleBuffer,bool_t,UpdateLowLevel(p),EqBool); break;
  770. case HIRES_USEBORDER: SETVALUECMP(p->UseBorder,bool_t,UpdateLowLevel(p),EqBool); break;
  771. }
  772. return Result;
  773. }
  775. extern bool_t SwapLandscape;
  777. static int Create(hires* p)
  778. {
  779. p->Overlay.Node.Enum = (nodeenum)Enum;
  780. p->Overlay.Node.Get = (nodeget)Get;
  781. p->Overlay.Node.Set = (nodeset)Set;
  782. p->Overlay.Init = (ovlfunc)Init;
  783. p->Overlay.Done = (ovldone)Done;
  784. p->Overlay.Reset = (ovlfunc)Reset;
  785. p->Overlay.Lock = (ovllock)Lock;
  786. p->Overlay.Unlock = (ovlfunc)Unlock;
  787. p->Overlay.UpdateShow = (ovlfunc)Show;
  788. p->Overlay.Update = (ovlfunc)Update;
  790. p->Caps = QueryPlatform(PLATFORM_CAPS);
  791. if (p->Caps & CAPS_ARM_XSCALE)
  792. {
  793. p->Regs = (volatile uint32_t*)MemPhyToVirt(XSCALE_LCD_BASE);
  794. if (p->Regs)
  795. {
  796. p->LowLevelGet = XScaleGet;
  797. p->LowLevelGetOrig = XScaleGetOrig;
  798. p->LowLevelSetOrig = XScaleSetOrig;
  799. p->LowLevelFlip = XScaleFlip;
  800. p->LowLevelAlloc = XScaleAlloc;
  801. p->Border[0] = 2;
  802. p->Border[1] = 2;
  803. p->Border[2] = p->Border[3] = 2;
  804. }
  805. }
  806. else
  807. {
  808. p->Regs = (volatile uint32_t*)MemPhyToVirt(OMAP_LCD_BASE);
  809. p->Regs2 = (volatile uint16_t*)MemPhyToVirt(OMAP_DMA_BASE);
  810. if (!p->Regs || !p->Regs2)
  811. {
  812. p->Regs = NULL;
  813. p->Regs2 = NULL;
  814. }
  815. else
  816. {
  817. p->LowLevelGet = OMAPGet;
  818. p->LowLevelGetOrig = OMAPGetOrig;
  819. p->LowLevelSetOrig = OMAPSetOrig;
  820. p->LowLevelFlip = OMAPFlip;
  821. p->LowLevelAlloc = OMAPAlloc;
  822. p->Border[0] = 14; // OMAP width has to be multiple of 16
  823. p->Border[1] = 2;
  824. p->Border[2] = p->Border[3] = 2;
  825. }
  826. }
  828. p->Model = QueryPlatform(PLATFORM_MODEL);
  829. // don't use triple buffering on 320x320 devices by default
  830. p->TripleBuffer = (Context()->StartUpMemory > 3*1024*1024) &&
  831. (p->Model==MODEL_TUNGSTEN_T3 ||
  832. p->Model==MODEL_TUNGSTEN_T5 ||
  833. p->Model==MODEL_PALM_TX ||
  834. p->Model==MODEL_LIFEDRIVE);
  836. // only device always supporting borderless mode is LifeDrive (?)
  837. p->UseBorder = 
  838. p->Model==MODEL_LIFEDRIVE ||
  839. p->Model==MODEL_PALM_TX;
  840. return ERR_NONE;
  841. }
  843. static const nodedef HIRES = 
  844. {
  845. sizeof(hires)|CF_GLOBAL|CF_SETTINGS,
  846. HIRES_ID,
  847. OVERLAY_CLASS,
  848. PRI_DEFAULT+10,
  849. (nodecreate)Create,
  850. };
  852. void OverlayHIRES_Init() 
  853. {
  854. #ifdef HAVE_PALMONE_SDK
  855. if (SysLibFind(dexLibName, &DEX) == sysErrLibNotFound)
  856. SysLibLoad(dexLibType, dexLibCreator, &DEX);
  857. if (DEX != sysInvalidRefNum && SysLibOpen(DEX)!=errNone)
  858. DEX = sysInvalidRefNum;
  859. #endif
  861. if (SysLibFind(kRotationMgrLibName, &RotM) == sysErrLibNotFound)
  862. SysLibLoad(kRotationMgrLibType, kRotationMgrLibCreator, &RotM);
  863. if (RotM != sysInvalidRefNum && SysLibOpen(RotM)!=errNone)
  864. RotM = sysInvalidRefNum;
  866. if (RotM != sysInvalidRefNum)
  867. {
  868. UInt32 Width,Height;
  869. if (RotationMgrAttributeGet(RotM,kRotationMgrAttrDisplayWidth,&Width)==errNone &&
  870. RotationMgrAttributeGet(RotM,kRotationMgrAttrDisplayHeight,&Height)==errNone &&
  871. Width < Height) // native portrait -> landscape modes are swapped by Mobile Stream
  872. SwapLandscape = 1;
  873. }
  875. NodeRegisterClass(&HIRES);
  876. }
  878. void OverlayHIRES_Done() 
  879. {
  880. NodeUnRegisterClass(HIRES_ID);
  882. #ifdef HAVE_PALMONE_SDK
  883. if (DEX != sysInvalidRefNum)
  884. {
  885. SysLibClose(DEX);
  886. DEX = sysInvalidRefNum;
  887. }
  888. #endif
  889. if (RotM != sysInvalidRefNum)
  890. {
  891. SysLibClose(RotM);
  892. RotM = sysInvalidRefNum;
  893. }
  894. }
  896. #endif