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

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

Windows CE

开发平台：

Windows_Unix

tchpdd.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) 2002. Samsung Electronics, co. ltd  All rights reserved.
  8. Module Name:
  10.   tchpdd.cpp
  12. Abstract:
  14.   This module contains the DDSI implementation and PDD support routines
  15.   for the touch panel for the P2 implementation.
  17. Functions:
  19.   TouchDriverCalibrationPointGet
  20.   DdsiTouchPanelGetDeviceCaps
  21.   DdsiTouchPanelSetMode
  22.   DdsiTouchPanelEnable
  23.   DdsiTouchPanelDisable
  24.   DdsiTouchPanelAttach
  25.   DdsiTouchPanelDetach
  26.   DdsiTouchPanelGetPoint
  27.   DdsiTouchPanelPowerHandler
  29. Notes:
  32. Revision History:
  35. --*/
  37. #define DBGPOINTS1 1
  38. #define TRACE_TIP_STATE
  40. #include    <windows.h>
  41. #include <types.h>
  42. #include    <memory.h>
  43. #include    <nkintr.h>
  44. #include    <oalintr.h>
  45. #include    <tchddsi.h>
  46. #include    <tchpdd.h>
  47. #include    <drv_glob.h>
  48. //#include    <p2debug.h>
  50. #include    <S2440.H>
  51. #include  "reg.h"
  53. #define SYS_TIMER_PRESCALER 24
  54. //#define SYS_TIMER_DIVIDER 4 // 2
  55. //#define OEM_CLOCK_FREQ (S2440PCLK / (SYS_TIMER_PRESCALER+1) / SYS_TIMER_DIVIDER)
  57. #define JYLEE_TEST 0
  58. #define JYLEE_TEST1 0
  60. //#define TFT240_320 1
  61. //#define TFT640_480 4
  62. //#define LCD_TYPE TFT240_320
  63. //#define LCD_TYPE TFT640_480
  65. #if ( LCD_TYPE == TFT640_480 )
  66. #define ADC_DELAY_TIME 65530
  67. #else
  68. #define ADC_DELAY_TIME 40000 // yhkim
  69. #endif
  71. DWORD gIntrTouch = SYSINTR_TOUCH;
  72. DWORD gIntrTouchChanged = SYSINTR_TOUCH_CHANGED;
  74. #ifdef TRACE_TIP_STATE
  75. BOOL PenIsUp = TRUE;
  76. #endif
  78. #if defined(MIPS) || defined(PPC821) || defined(PPC823) || defined(ARM) || defined(SH4)
  79. #define PAGE_MASK 0x0fff
  80. #define PAGE_SIZE 0x1000
  81. volatile static PVOID pTmpRegs;
  82. #endif
  84. static void TouchPanelPowerOff();
  85. static void TouchPanelPowerOn();
  86. static BOOL Touch_Timer0_Setup(void) ;
  88. static BOOL Touch_Pen_filtering(INT *px, INT *py);
  90. // The MDD requires a minimum of MIN_CAL_COUNT consecutive samples before
  91. // it will return a calibration coordinate to GWE.  This value is defined
  92. // in the PDD so that each OEM can control the behaviour of the touch
  93. // panel and still use the Microsoft supplied MDD.  Note that the extern "C"
  94. // is required so that the variable name doesn't get decorated, and
  95. // since we have an initializer the 'extern' is actually ignored and
  96. // space is allocated.
  97. extern "C" const int MIN_CAL_COUNT = 40;
  99. INT CurrentSampleRateSetting = 0; // Low sample rate setting
  101. // @globalvar PTCHAUD_ASIC_REGISTERS | v_pTchAudAsicRegisters | Pointer to Asic regs
  103. PTCHAUD_ASIC_REGISTERS              v_pTchAudAsicRegisters = NULL;
  105. // @globalvar PTOUCHPANEL_POINT_SAMPLE | v_pPenSamples | Pointer to pen samples area
  106. PDRIVER_GLOBALS      v_pDriverGlobals = NULL;
  108. volatile static PVOID v_pCpuRegs = NULL;
  110. TOUCH_PANEL_SAMPLE_FLAGS SampleFlags;
  112. #ifdef CHECK_RATE
  113.     UINT32 tmp_leds = 0x55;
  114. #endif
  116. // Mutex to prevent contention with audio while accessing shared registers
  117. static HANDLE v_hTchAudMutex;
  119. // Global flag to indicate whether we are in power handler routine, so
  120. // we know to avoid system calls.
  121. static BOOL bInPowerHandler = FALSE;
  124. // Macros for aquiring semaphore for shared access to ASIC registers. If
  125. // we are in the power handler routines, we don't need/want to aquire semaphore,
  126. // since we are serialized at that point, and can't make any system calls.
  127. #define TCHAUD_SEM_LOCK()  
  128.     if (!bInPowerHandler) { 
  129.         DEBUGMSG(ZONE_TIPSTATE,(TEXT("TchPDD Getting semaphore...rn"))); 
  130.         TchAudLock(v_hTchAudMutex, &(v_pDriverGlobals->tch.semaphore)); 
  131.     }
  132. #define TCHAUD_SEM_UNLOCK() 
  133.     if (!bInPowerHandler) { 
  134.         DEBUGMSG(ZONE_TIPSTATE,(TEXT("TchPDD Releasing semaphore...rn"))); 
  135.         TchAudUnlock(v_hTchAudMutex, &(v_pDriverGlobals->tch.semaphore)); 
  136.     }
  138. // Macros for accessing registers on the touch audio ASIC.  The code for
  139. // these functions is in drvlib so it can be shared between touch and audio.
  140. #define ASIC_READ_REG(reg, pval) 
  141.     TchAudReadReg(reg, pval, v_pTchAudAsicRegisters, bInPowerHandler)
  142. #define ASIC_WRITE_REG(reg, val) 
  143.     TchAudWriteReg(reg, val, v_pTchAudAsicRegisters, bInPowerHandler)
  144. #define ASIC_AND_REG(reg, val) 
  145.     TchAudAndReg(reg, val, v_pTchAudAsicRegisters, bInPowerHandler)
  146. #define ASIC_OR_REG(reg, val) 
  147.     TchAudOrReg(reg, val, v_pTchAudAsicRegisters, bInPowerHandler)
  150. volatile IOPreg *v_pIOPregs;
  151. volatile ADCreg *v_pADCregs;
  152. volatile PWMreg *v_pPWMregs;
  153. volatile INTreg *v_pINTregs;    
  155. volatile unsigned short xbuf[10], ybuf[10];
  156. static unsigned int touch_down = 1;
  158. //#define ADCPRS  49 // 200Mhz
  159. #define ADCPRS  49 // 200Mhz
  160. //#define ADCPRS  65 // 532Mhz
  162. /*++
  164. Routine Description:
  166.     Deallocates the virtual memory reserved for the Touch/Audio Asic registers,
  167.     and the pen samples dma area.
  169. Arguments:
  171.     None.
  174. Return Value:
  176.     None.
  178. Autodoc Information:
  180.     @doc IN_TOUCH_DDSI INTERNAL DRIVERS PDD TOUCH_PANEL
  182.     @func VOID | PddpTouchPanelDeallocateVm |
  183.     Deallocates the virtual memory reserved for the Touch/Audio Asic registers,
  184.     and the pen samples dma area.
  186. --*/
  187. static
  188. void
  189. PddpTouchPanelDeallocateVm(
  190.     VOID
  191.     )
  192. {
  193.     if(v_pIOPregs)
  194.     {
  195.         VirtualFree((void*)v_pIOPregs, sizeof(IOPreg), MEM_RELEASE);
  196.         v_pIOPregs=NULL;
  197.     }
  198.     if(v_pADCregs)
  199.     {   
  200.         VirtualFree((void*)v_pADCregs, sizeof(ADCreg), MEM_RELEASE);
  201.         v_pADCregs = NULL;
  202.     }        
  203.     if ( v_pDriverGlobals )
  204.     {
  205.         VirtualFree( v_pDriverGlobals,
  206.                      DRIVER_GLOBALS_PHYSICAL_MEMORY_SIZE ,
  207.                      MEM_RELEASE
  208.                     );
  209.         v_pDriverGlobals = NULL;
  210.     }    
  211. }
  213. //
  214. // PDD Internal Support Routines
  215. //
  217. /*++
  218.     @doc IN_TOUCH_DDSI INTERNAL DRIVERS PDD TOUCH_PANEL
  220.     @func VOID | PddpTouchPanelGetSamples |
  221.     Copies from the pen dma area the most recent point sample into the location
  222.     pointed to by pPointSamples.  During the copy the sample information is
  223.     adjusted to be consistent with the 12 bit pen data format.
  224.     Has the side effect of reinitializing ioPenPointer if we are near the
  225.     end of the pen sample area.
  226. --*/
  227. static
  228. void
  229. PddpTouchPanelGetSamples(
  230.     PTOUCHPANEL_POINT_SAMPLE pPointSamples //@PARM Pointer to where the samples will be stored.
  231.     )
  232. {
  233.     // ULONG   devDrvPointer;
  234.     ULONG   irg;
  236.     //
  237.     // Copy the samples to our buffer munging the data for the 12 bit
  238.     //  pen data format.
  239.     //
  241.     for ( irg = 0; irg < NUMBER_SAMPLES_PER_POINT; irg++ )
  242.     {
  243.         pPointSamples[ irg ].XSample = xbuf[irg];
  244.         pPointSamples[ irg ].YSample = ybuf[irg];
  245.     }
  246. }
  248. /*++
  250. Routine Description:
  252.     Gathers the most recent sample and evaluates the sample returing
  253.     the determined tip state and the `best guess' for the X and Y coordinates.
  255.     Note: Determined empirically that the variance of the X coordinate of the
  256.           first sample from all other samples is large enough that in order
  257.           to keep the nominal variance small, we discard the first sample.
  259.           Cases of a light touch that locks the ADC into
  260.           seeing X and Y coordinate samples of 0x277 regardless of how the pen
  261.           moves or presses have been seen. XXXXX
  264. Arguments:
  266.     pTipState   Pointer to where the tip state information will be returned.
  268.     pUnCalX     Pointer to where the x coordinate will be returned.
  270.     pUnCalY     Pointer to where the y coordinate will be returned.
  272. Return Value:
  274.     None.
  276. Autodoc Information:
  278.     @doc IN_TOUCH_DDI INTERNAL DRIVERS PDD TOUCH_PANEL
  280.     @func VOID | PddpTouchPanelEvaluateSamples |
  281.     Gathers the most recent sample and evaluates the sample returing
  282.     the determined tip state and the `best guess' for the X and Y coordinates.
  284. --*/
  285. static
  286. void
  287. PddpTouchPanelEvaluateSamples(
  288.     TOUCH_PANEL_SAMPLE_FLAGS *pSampleFlags, //@PARM Pointer to where the tip state information will be returned.
  289.     INT *pUncalX,      //@PARM Pointer to where the x coordinate will be returned.
  290. INT *pUncalY       //@PARM Pointer to where the y coordinate will be returned.
  292.     )
  293. {
  294.     LONG    dlXDiff0;
  295.     LONG    dlXDiff1;
  296.     LONG    dlXDiff2;
  297.     LONG    dlYDiff0;
  298.     LONG    dlYDiff1;
  299.     LONG    dlYDiff2;
  301.     TOUCHPANEL_POINT_SAMPLES rgPointSamples;
  303.     //
  304.     // Get the sample.
  305.     //
  307.     PddpTouchPanelGetSamples( rgPointSamples );
  310.     //
  311.     // Calcuate the differences for the X samples and insure that
  312.     // the resulting number is positive.
  313.     //
  315.     dlXDiff0 = rgPointSamples[ 0 ].XSample - rgPointSamples[ 1 ].XSample;
  316.     dlXDiff1 = rgPointSamples[ 1 ].XSample - rgPointSamples[ 2 ].XSample;
  317.     dlXDiff2 = rgPointSamples[ 2 ].XSample - rgPointSamples[ 0 ].XSample;
  318.     dlXDiff0 = dlXDiff0 > 0  ? dlXDiff0 : -dlXDiff0;
  319.     dlXDiff1 = dlXDiff1 > 0  ? dlXDiff1 : -dlXDiff1;
  320.     dlXDiff2 = dlXDiff2 > 0  ? dlXDiff2 : -dlXDiff2;
  322.     //
  323.     // Calcuate the differences for the Y samples and insure that
  324.     // the resulting number is positive.
  325.     //
  327.     dlYDiff0 = rgPointSamples[ 0 ].YSample - rgPointSamples[ 1 ].YSample;
  328.     dlYDiff1 = rgPointSamples[ 1 ].YSample - rgPointSamples[ 2 ].YSample;
  329.     dlYDiff2 = rgPointSamples[ 2 ].YSample - rgPointSamples[ 0 ].YSample;
  330.     dlYDiff0 = dlYDiff0 > 0  ? dlYDiff0 : -dlYDiff0;
  331.     dlYDiff1 = dlYDiff1 > 0  ? dlYDiff1 : -dlYDiff1;
  332.     dlYDiff2 = dlYDiff2 > 0  ? dlYDiff2 : -dlYDiff2;
  334.     //
  335.     // The final X coordinate is the average of coordinates of
  336.     // the two MIN of the differences.
  337.     //
  339.     if ( dlXDiff0 < dlXDiff1 )
  340.     {
  341.         if ( dlXDiff2 < dlXDiff0 )
  342.         {
  344.             *pUncalX = (ULONG)( ( ( rgPointSamples[ 0 ].XSample + rgPointSamples[ 2 ].XSample ) >> 1 ) );
  345.         }
  346.         else
  347.         {
  349.             *pUncalX = (ULONG)( ( ( rgPointSamples[ 0 ].XSample + rgPointSamples[ 1 ].XSample ) >> 1 ) );
  350.         }
  351.     }
  352.     else if ( dlXDiff2 < dlXDiff1 )
  353.     {
  355.             *pUncalX = (ULONG)( ( ( rgPointSamples[ 0 ].XSample + rgPointSamples[ 2 ].XSample ) >> 1 ) );
  356.     }
  357.     else
  358.     {
  360.             *pUncalX = (ULONG)( ( ( rgPointSamples[ 1 ].XSample + rgPointSamples[ 2 ].XSample ) >> 1 ) );
  361.     }
  363.     //
  364.     //
  365.     // The final Y coordinate is the average of coordinates of
  366.     // the two MIN of the differences.
  367.     //
  369.     if ( dlYDiff0 < dlYDiff1 )
  370.     {
  371.         if ( dlYDiff2 < dlYDiff0 )
  372.         {
  374.             *pUncalY = (ULONG)( ( ( rgPointSamples[ 0 ].YSample + rgPointSamples[ 2 ].YSample ) >> 1 ) );
  375.         }
  376.         else
  377.         {
  379.             *pUncalY = (ULONG)( ( ( rgPointSamples[ 0 ].YSample + rgPointSamples[ 1 ].YSample ) >> 1 ) );
  380.         }
  381.     }
  382.     else if ( dlYDiff2 < dlYDiff1 )
  383.     {
  385.             *pUncalY = (ULONG)( ( ( rgPointSamples[ 0 ].YSample + rgPointSamples[ 2 ].YSample ) >> 1 ) );
  386.     }
  387.     else
  388.     {
  390.             *pUncalY = (ULONG)( ( ( rgPointSamples[ 1 ].YSample + rgPointSamples[ 2 ].YSample ) >> 1 ) );
  391.     }
  393.     //
  394.     // Validate the coordinates and set the tip state accordingly.
  395.     //
  397.     if ( dlXDiff0 > DELTA_X_COORD_VARIANCE ||
  398.          dlXDiff1 > DELTA_X_COORD_VARIANCE ||
  399.          dlXDiff2 > DELTA_X_COORD_VARIANCE ||
  400.          dlYDiff0 > DELTA_Y_COORD_VARIANCE ||
  401.          dlYDiff1 > DELTA_Y_COORD_VARIANCE ||
  402.          dlYDiff2 > DELTA_Y_COORD_VARIANCE )
  403.     {
  405. //#ifdef DBGPOINTS1
  406.         DEBUGMSG( ZONE_SAMPLES, (TEXT("Sample 0: X 0x%x Y 0x%xrn"),
  407.                rgPointSamples[ 0 ].XSample, rgPointSamples[ 0 ].YSample) );
  408.         DEBUGMSG( ZONE_SAMPLES, (TEXT("Sample 1: X 0x%x Y 0x%xrn"),
  409.                rgPointSamples[ 1 ].XSample, rgPointSamples[ 1 ].YSample) );
  410.         DEBUGMSG( ZONE_SAMPLES, (TEXT("Sample 2: X 0x%x Y 0x%xrn"),
  411.                rgPointSamples[ 2 ].XSample, rgPointSamples[ 2 ].YSample) );
  414.         if ( dlXDiff0 > DELTA_X_COORD_VARIANCE )
  415.             DEBUGMSG( ZONE_SAMPLES, (TEXT("XDiff0 too large 0x%xrn"), dlXDiff0) );
  416.         if ( dlXDiff1 > DELTA_X_COORD_VARIANCE )
  417.             DEBUGMSG( ZONE_SAMPLES, (TEXT("XDiff1 too large 0x%xrn"), dlXDiff1) );
  418.         if ( dlXDiff2 > DELTA_X_COORD_VARIANCE )
  419.             DEBUGMSG( ZONE_SAMPLES, (TEXT("XDiff2 too large 0x%xrn"), dlXDiff2) );
  421.         if ( dlYDiff0 > DELTA_Y_COORD_VARIANCE )
  422.             DEBUGMSG( ZONE_SAMPLES, (TEXT("YDiff0 too large 0x%xrn"), dlYDiff0) );
  423.         if ( dlYDiff1 > DELTA_Y_COORD_VARIANCE )
  424.             DEBUGMSG( ZONE_SAMPLES, (TEXT("YDiff1 too large 0x%xrn"), dlYDiff1) );
  425.         if ( dlYDiff2 > DELTA_Y_COORD_VARIANCE )
  426.             DEBUGMSG( ZONE_SAMPLES, (TEXT("YDiff2 too large 0x%xrn"), dlYDiff2) );
  428. //#endif // DBGPOINTS1
  430.     }
  431.     else
  432.     {
  433.         //
  434.         // Sample is valid. Set tip state accordingly.
  435.         //
  436. *pSampleFlags = TouchSampleValidFlag | TouchSampleDownFlag;
  437.     }
  439.     DEBUGMSG( ZONE_SAMPLES, (TEXT("Filtered - SampleFlags: 0x%x X: 0x%x Y: 0x%xrn"),
  440.            *pSampleFlags, *pUncalX, *pUncalY) );
  442. }
  444. //
  445. // PddpSetupPenDownIntr()
  446. //
  447. // Set up the UCB to give pen down interrupts.  If EnableIntr flag is set, enable
  448. // the interrupt, otherwise, leave it disabled.  Note: - Caller must hold semaphore
  449. // when this function is called to protect access to the shared UCB registers.
  450. //
  451. BOOL
  452. PddpSetupPenDownIntr(BOOL EnableIntr)
  453. {
  454. // USHORT intrMask;
  456.     // I don't know why we enable the interrupt here.
  457.     
  458.     
  459.     //
  460.     // Setup ADC register
  461.     //
  463. // kang code
  464.     // Enable Prescaler,Prescaler,AIN5/7 fix,Normal,Disable read start,No operation
  465.     // Down,YM:GND,YP:AIN5,XM:Hi-z,XP:AIN7,XP pullup En,Normal,Waiting for interrupt mode
  466. // kang code end
  467.     // Down Int, YMON:0, nYPON:1, XMON:0;nXPON:1, Pullup:1, Auto Conv.,Waiting.
  468.     v_pADCregs->rADCTSC =(0<<8)|(1<<7)|(1<<6)|(0<<5)|(1<<4)|(0<<3)|(0<<2)|(3);
  469.     //v_pADCregs->rADCTSC=(1<<3)|(1<<2);
  470.     v_pADCregs->rADCDLY = ADC_DELAY_TIME;//default value for delay.    
  471.     v_pADCregs->rADCCON = (1<<14)|(ADCPRS<<6)|(7<<3); //setup channel, ADCPRS, Touch Input
  473. return TRUE;
  475. }
  477. //
  478. // PddpDisableClearPenDownIntr(void)
  479. //
  480. // Tell the UCB to clear pen down interrupts
  481. //
  482. BOOL
  483. PddpDisableClearPenDownIntr(void)
  484. {
  485.     // Acquire semaphore to prevent contention with audio driver while accessing UCB regs
  486.     TCHAUD_SEM_LOCK();
  488.     // Clear bit 12 in UCB address 3 to disable interrupts on falling tspx (tspx_fal_int)
  489.     // Read data from UCB address 0x03
  490.     if (! ASIC_AND_REG(3, ~((USHORT)0x1000)))
  491.         goto error_return;
  493.     // Clear the pen down interrupt
  494.     // Write UCB address 4 bit 12 to a 0
  495.     if (! ASIC_WRITE_REG(4, 0))
  496.         goto error_return;
  498.     // Write UCB address 4 bit 12 to a 1, to clear tspx interrupts
  499.     if (! ASIC_WRITE_REG(4, 0x1000))
  500.         goto error_return;
  502.     TCHAUD_SEM_UNLOCK();
  503.     return TRUE;
  505. error_return:
  506.     RETAILMSG(1,(TEXT("TchPdd: Error accessing UCB register!rn")));
  507.     TCHAUD_SEM_UNLOCK();
  508.     return FALSE;
  509. }
  511. //
  512. // DDSI Implementation
  513. //
  516. // @DOC EX_TOUCH_DDSI EXTERNAL DRIVERS TOUCH_DRIVER
  517. /* @FUNC   BOOL | TouchDriverCalibrationPointGet |
  519. Gives a single calibration point.
  521. @XREF
  522. <l TouchPanelReadCalibrationPoint.TouchPanelReadCalibrationPoint>
  523. <l TouchPanelSetCalibration.TouchPanelSetCalibration>
  524. <l TouchPanelReadCalibrationAbort.TouchPanelReadCalibrationAbort>
  527. @COMM
  529. This function is called to get a single calibration point, in screen
  530. coordinates, when the input system is calibrating the touch driver.  The input system
  531. will then draw a target on the screen for the user to press on.
  533. The driver may use the cDisplayX and cDisplayY to compute a coordinate.
  534. It does not need to remember this computed value internally since it will
  535. be passed back when the input system has collected all of the points and
  536. calls <l TouchPanelSetCalibration.TouchPanelSetCalibration>.
  538. */
  540. extern "C"
  541. BOOL
  542. TouchDriverCalibrationPointGet(
  543. TPDC_CALIBRATION_POINT *pTCP //@PARM pointer to returned calibration point
  544. )
  545. {
  546.     
  547. INT32 cDisplayWidth = pTCP -> cDisplayWidth;
  548. INT32 cDisplayHeight = pTCP -> cDisplayHeight;
  550. int CalibrationRadiusX = cDisplayWidth/20;
  551. int CalibrationRadiusY = cDisplayHeight/20;
  553. switch (pTCP -> PointNumber)
  554. {
  555. case 0:
  556. pTCP -> CalibrationX = cDisplayWidth/2;
  557. pTCP -> CalibrationY = cDisplayHeight/2;
  558. break;
  560. case 1:
  561. pTCP -> CalibrationX = CalibrationRadiusX*2;
  562. pTCP -> CalibrationY = CalibrationRadiusY*2;
  563. break;
  565. case 2:
  566. pTCP -> CalibrationX = CalibrationRadiusX*2;
  567. pTCP -> CalibrationY = cDisplayHeight - CalibrationRadiusY*2;
  568. break;
  570. case 3:
  571. pTCP -> CalibrationX = cDisplayWidth - CalibrationRadiusX*2;
  572. pTCP -> CalibrationY = cDisplayHeight - CalibrationRadiusY*2;
  573. break;
  575. case 4:
  576. pTCP -> CalibrationX = cDisplayWidth - CalibrationRadiusX*2;
  577. pTCP -> CalibrationY = CalibrationRadiusY*2;
  578. break;
  580. default:
  581. pTCP -> CalibrationX = cDisplayWidth/2;
  582. pTCP -> CalibrationY = cDisplayHeight/2;
  583. SetLastError(ERROR_INVALID_PARAMETER);
  584. return FALSE;
  587. }
  588. RETAILMSG(0,(TEXT("TouchDriverCalibrationPointGetrn")));
  589. RETAILMSG(0,(TEXT("cDisplayWidth : %4Xrn"),cDisplayWidth));
  590. RETAILMSG(0,(TEXT("cDisplayHeight : %4Xrn"),cDisplayHeight));
  591. RETAILMSG(0,(TEXT("CalibrationRadiusX : %4drn"),CalibrationRadiusX));
  592. RETAILMSG(0,(TEXT("CalibrationRadiusY : %4drn"),CalibrationRadiusY));
  593. RETAILMSG(0,(TEXT("pTCP -> PointNumber : %4drn"),pTCP -> PointNumber));
  594. RETAILMSG(0,(TEXT("pTCP -> CalibrationX : %4drn"),pTCP -> CalibrationX));
  595. RETAILMSG(0,(TEXT("pTCP -> CalibrationY : %4drn"),pTCP -> CalibrationY));
  596. return TRUE;
  597. }
  602. // @doc EX_TOUCH_DDSI EXTERNAL DRIVERS DDSI TOUCH_PANEL
  603. //
  604. // @func ULONG | DdsiTouchPanelGetDeviceCaps |
  605. //
  606. // Queries capabilities about the physical touch panel device.
  607. //
  608. // @parm ULONG | iIndex |
  609. //
  610. // Specifies the capability to query. They are one of the following:
  611. //
  612. // @flag TPDC_SAMPLERATE_ID |
  613. // The sample rate.
  614. // @flag TPDC_CALIBRATIONPOINTS_ID |
  615. // The X and Y coordinates used for calibration.
  616. // @flag TPDC_CALIBRATIONDATA_ID |
  617. // The X and Y coordinates used for calibration mapping.
  618. //
  619. // @parm LPVOID | lpOutput |
  620. // Points to the memory location(s) where the queried information
  621. // will be placed. The format of the memory referenced depends on
  622. // the setting of iIndex. If 0, returns the number of words
  623. // required for the output data.
  624. //
  625. // @rdesc
  626. // The return values is set to the amount of information supplied and depends
  627. // on the setting of the iIndex argument.
  628. //
  629. // @comm
  630. // Implemented in the PDD.
  631. //
  633. extern "C"
  634. BOOL
  635. DdsiTouchPanelGetDeviceCaps(
  636. INT iIndex,
  637.     LPVOID  lpOutput
  638.     )
  639. {
  640. if ( lpOutput == NULL )
  641. {
  642. ERRORMSG(1, (__TEXT("TouchPanelGetDeviceCaps: invalid parameter.rn")));
  643. SetLastError(ERROR_INVALID_PARAMETER);
  644. DebugBreak();
  645. return FALSE;
  646. }
  648. switch ( iIndex )
  649. {
  650. case TPDC_SAMPLE_RATE_ID:
  651. {
  652. TPDC_SAMPLE_RATE *pTSR = (TPDC_SAMPLE_RATE*)lpOutput;
  654. pTSR -> SamplesPerSecondLow = TOUCHPANEL_SAMPLE_RATE_LOW;
  655. pTSR -> SamplesPerSecondHigh = TOUCHPANEL_SAMPLE_RATE_HIGH;
  656. pTSR -> CurrentSampleRateSetting = CurrentSampleRateSetting;
  657. }
  658. break;
  660. case TPDC_CALIBRATION_POINT_COUNT_ID:
  661. {
  662. TPDC_CALIBRATION_POINT_COUNT *pTCPC = (TPDC_CALIBRATION_POINT_COUNT*)lpOutput;
  664. pTCPC -> flags = 0;
  665. pTCPC -> cCalibrationPoints = 5;
  666. }
  667. break;
  669. case TPDC_CALIBRATION_POINT_ID:
  670. return(TouchDriverCalibrationPointGet((TPDC_CALIBRATION_POINT*)lpOutput));
  672. default:
  673. ERRORMSG(1, (__TEXT("TouchPanelGetDeviceCaps: invalid parameter.rn")));
  674. SetLastError(ERROR_INVALID_PARAMETER);
  675. DebugBreak();
  676. return FALSE;
  678. }
  680. return TRUE;
  681. }
  685. //
  686. // @doc EX_TOUCH_DDSI EXTERNAL DRIVERS DDSI TOUCH_PANEL
  687. //
  688. // @func BOOL | DdsiTouchPanelSetMode |
  689. // Sets information about the physical touch panel device.
  690. //
  691. // @parm ULONG | iIndex |
  692. // Specifies the mode to set. They are one of the following:
  693. //
  694. // @flag TPSM_SAMPLERATE_HIGH_ID |
  695. // Sets the sample rate to the high rate.
  696. // @flag TPSM_SAMPLERATE_LOW_ID |
  697. // Sets the sample rate to the low rate.
  698. //
  699. // @parm LPVOID | lpInput |
  700. // Points to the memory location(s) where the update information
  701. // resides. The format of the memory referenced depends on the
  702. // Points to the memory location(s) where the queried information
  703. // will be placed.
  704. //
  705. // @rdesc
  706. // If the function succeeds the return value is TRUE, otherwise, it is FALSE.
  707. //
  708. // @comm
  709. // Implemented in the PDD.
  710. //
  712. BOOL
  713. DdsiTouchPanelSetMode(
  714. INT iIndex,
  715.     LPVOID  lpInput
  716.     )
  717. {
  718.     BOOL  ReturnCode = FALSE;
  720.     switch ( iIndex )
  721.     {
  722.         case TPSM_SAMPLERATE_LOW_ID:
  723.         case TPSM_SAMPLERATE_HIGH_ID:
  724.             SetLastError( ERROR_SUCCESS );
  725.             ReturnCode = TRUE;
  726.             break;
  728.         default:
  729.             SetLastError( ERROR_INVALID_PARAMETER );
  730.             break;
  731.     }
  734.     return ( ReturnCode );
  735. }
  737. //
  738. // @doc EX_TOUCH_DDSI EXTERNAL DRIVERS DDSI TOUCH_PANEL
  739. //
  740. // @func BOOL | DdsiTouchPanelEnable |
  741. // Powers up and initializes the touch panel hardware for operation.
  742. //
  743. // @rdesc
  744. // If the function succeeds, the return value is TRUE; otherwise, it is FALSE.
  745. //
  746. // @comm
  747. // Implemented in the PDD.
  748. //
  750. BOOL
  751. DdsiTouchPanelEnable(
  752.     VOID
  753.     )
  754. {
  755.     BOOL    Ret;
  757.     if(v_pIOPregs == NULL) {
  758.      v_pIOPregs = (volatile IOPreg *) 
  759.      VirtualAlloc(0,sizeof(IOPreg),MEM_RESERVE, PAGE_NOACCESS);
  760.      if(v_pIOPregs == NULL) {
  761.      ERRORMSG(1,(TEXT("For IOPreg: VirtualAlloc failed!rn")));
  762.     return (FALSE);
  763.     }
  764.      else {
  765.      if(!VirtualCopy((PVOID)v_pIOPregs,(PVOID)(IOP_BASE),sizeof(IOPreg),
  766.      PAGE_READWRITE | PAGE_NOCACHE )) {
  767.     ERRORMSG(1,(TEXT("For pIOPregs: VirtualCopy failed!rn")));
  768.                 PddpTouchPanelDeallocateVm();
  769.      return (FALSE);
  770.      }
  771.     }
  772. }
  775.     if(v_pADCregs == NULL) {
  776.      v_pADCregs = (volatile ADCreg *) 
  777.      VirtualAlloc(0,sizeof(ADCreg),MEM_RESERVE, PAGE_NOACCESS);
  778.      if(v_pADCregs == NULL) {
  779.      ERRORMSG(1,(TEXT("For ADCreg: VirtualAlloc failed!rn")));
  780.     return (FALSE);
  781.     }
  782.      else {
  783.      if(!VirtualCopy((PVOID)v_pADCregs,(PVOID)(ADC_BASE),sizeof(ADCreg),
  784.      PAGE_READWRITE | PAGE_NOCACHE )) {
  785.     ERRORMSG(1,(TEXT("For pADCregs: VirtualCopy failed!rn")));
  786.                 PddpTouchPanelDeallocateVm();
  787.      return (FALSE);
  788.      }
  789.     }
  790. }
  792.     if(v_pPWMregs == NULL) {
  793.      v_pPWMregs = (volatile PWMreg *) 
  794.      VirtualAlloc(0,sizeof(PWMreg),MEM_RESERVE, PAGE_NOACCESS);
  795.      if(v_pPWMregs == NULL) {
  796.      ERRORMSG(1,(TEXT("For PWMreg: VirtualAlloc failed!rn")));
  797.     return (FALSE);
  798.     }
  799.      else {
  800.      if(!VirtualCopy((PVOID)v_pPWMregs,(PVOID)(PWM_BASE),sizeof(PWMreg),
  801.      PAGE_READWRITE | PAGE_NOCACHE )) {
  802.     ERRORMSG(1,(TEXT("For PWMreg: VirtualCopy failed!rn")));
  803.      return (FALSE);
  804.      }
  805.     }
  806. }
  809.     if(v_pINTregs == NULL) {
  810.      v_pINTregs = (volatile INTreg *) 
  811.      VirtualAlloc(0,sizeof(INTreg),MEM_RESERVE, PAGE_NOACCESS);
  812.      if(v_pINTregs == NULL) {
  813.      ERRORMSG(1,(TEXT("For INTreg: VirtualAlloc failed!rn")));
  814.     return (FALSE);
  815.     }
  816.      else {
  817.      if(!VirtualCopy((PVOID)v_pINTregs,(PVOID)(INT_BASE),sizeof(INTreg),
  818.      PAGE_READWRITE | PAGE_NOCACHE )) {
  819.     ERRORMSG(1,(TEXT("For INTreg: VirtualCopy failed!rn")));
  820.      return (FALSE);
  821.      }
  822.     }
  823. }
  824.     //
  825.     // If the address space of the client process doesn't yet have the
  826.     //  mapping to the pen dma area; map it.  If the mapping fails
  827.     //  we return FALSE
  828.     //
  830.     if ( v_pDriverGlobals == NULL )
  831.     {
  832.         v_pDriverGlobals =
  833.             (PDRIVER_GLOBALS)
  834.                   VirtualAlloc( 0,
  835.                                 DRIVER_GLOBALS_PHYSICAL_MEMORY_SIZE,
  836.                                 MEM_RESERVE,
  837.                                 PAGE_NOACCESS
  838.                               );
  839.         if ( v_pDriverGlobals == NULL )
  840.         {
  841.             DEBUGMSG( ZONE_ERROR, (TEXT( "TouchPanelEnable: VirtualAlloc failed!rn")) );
  842.             PddpTouchPanelDeallocateVm();
  843.             return ( FALSE );
  844.         }
  846.         Ret = VirtualCopy( (LPVOID)v_pDriverGlobals,
  847.                            (LPVOID)DRIVER_GLOBALS_PHYSICAL_MEMORY_START,
  848.                            DRIVER_GLOBALS_PHYSICAL_MEMORY_SIZE,
  849.                            PAGE_READWRITE | PAGE_NOCACHE
  850.                            );
  852.         if ( Ret == FALSE )
  853.         {
  854.             DEBUGMSG( ZONE_ERROR, (TEXT( "TouchPanelEnable: VirtualCopy failed!rn")) );
  855.             PddpTouchPanelDeallocateVm();
  856.             return ( FALSE );
  857.         }
  858.     }
  860.     // Set up mutex for access to shared registers
  861.     if ((v_hTchAudMutex = CreateMutex(NULL, FALSE, TCHAUD_MUTEX_NAME)) == NULL) {
  862.         DEBUGMSG(ZONE_ERROR, (TEXT("TouchPanelEnable: Error %u in CreateMutexrn"),
  863.                               GetLastError()));
  864.         return ( FALSE );
  865.     }
  868.     // Power on touch panel
  869.     TouchPanelPowerOn();
  871.     // Setup pen down interrupts, but leave ints disabled until InterruptEnable().
  872.     TCHAUD_SEM_LOCK();
  873.     PddpSetupPenDownIntr(FALSE);
  874.     TCHAUD_SEM_UNLOCK();
  876.     return( TRUE );     // we always succeed!!!!!!
  877. }
  881. // @doc EX_TOUCH_DDSI EXTERNAL DRIVERS DDSI TOUCH_PANEL
  882. //
  883. // @func ULONG | DdsiTouchPanelDisable |
  884. // Powers down the touch panel device.
  885. //
  886. // @comm
  887. // Implemented in the PDD.
  888. //
  890. VOID
  891. DdsiTouchPanelDisable(
  892.     VOID
  893.     )
  894. {
  895.     //
  896.     // Check pointers in case the enable failed.
  897.     //
  898.     if(v_pADCregs == NULL) 
  899.         return ;
  901.     TouchPanelPowerOff();  // Power down the device
  903.     PddpTouchPanelDeallocateVm();  // free up any resources
  904. }
  906. //
  907. // @doc EX_TOUCH_DDSI EXTERNAL DRIVERS DDSI TOUCH_PANEL
  908. //
  909. // @func LONG | DdsiTouchPanelAttach |
  910. // This routine no longer does anything.  All functionallity has been moved
  911. // from here into DdsiTouchPanelEnable to allow this code to be statically
  912. // linked with GWE rather than existing as a DLL.  Technically, when built
  913. // as a DLL we should keep an attach count and only allow touh.dll to be
  914. // loaded once.  But, since we are loaded at boot time by GWE, there is
  915. // no real concern about multiple loads (unless gwe has a bug!).
  916. //
  917. // @rdesc
  918. // Always returns 0
  919. //
  920. // @comm
  921. // Implemented in the PDD.
  922. //
  924. LONG
  925. DdsiTouchPanelAttach(
  926.     VOID
  927.     )
  928. {
  929.     return( 1 );
  930. }
  933. //
  934. // @doc EX_TOUCH_DDSI EXTERNAL DRIVERS DDSI TOUCH_PANEL
  935. //
  936. // @func LONG | DdsiTouchPanelDetach |
  937. // See the descrition for attach.  All functionallity has been moved into
  938. // DdsiTouchPanelDisable.
  939. //
  940. // @rdesc
  941. // The updated global counter.  If the initializations failed, the returned
  942. // count is 0.
  943. //
  944. // @comm
  945. // Implemented in the PDD.
  946. //
  949. LONG
  950. DdsiTouchPanelDetach(
  951.     VOID
  952.     )
  953. {
  954.     return ( 0 );
  955. }
  957. #define COODI_Y
  959. //
  960. // @doc EX_TOUCH_DDSI EXTERNAL DRIVERS DDSI TOUCH_PANEL
  961. //
  962. // @func void | DdsiTouchPanelGetPoint |
  963. // Returns the most recently acquired point and its associated tip state
  964. // information.
  965. //
  966. // @parm PDDSI_TOUCHPANEL_TIPSTATE | pTipState |
  967. // Pointer to where the tip state information will be returned.
  968. // @parm PLONG | pUnCalX |
  969. // Pointer to where the x coordinate will be returned.
  970. // @parm PLONG | pUnCalY |
  971. // Pointer to where the y coordinate will be returned.
  972. //
  973. // @comm
  974. // Implmented in the PDD.
  975. //
  976. #if ( LCD_TYPE == TFT640_480 )
  977. #define TOUCH_MAX_X 890
  978. #define TOUCH_MIN_X 125
  979. #define TOUCH_MAX_Y 860
  980. #define TOUCH_MIN_Y 140
  982. #define TOUCH_X 640
  983. #define TOUCH_Y 480
  984. #else 
  985. #define TOUCH_MAX_X 900 // 950
  986. #define TOUCH_MIN_X 100 // 90
  987. #define TOUCH_MAX_Y 920 // 960 // 910
  988. #define TOUCH_MIN_Y 100 // 70 //50
  990. #define TOUCH_X 240
  991. #define TOUCH_Y 320
  992. #endif
  994. #define TOUCH_ERR 50
  996. static int second = 0;
  998. VOID Touch_CoordinateConversion(INT *px, INT *py)
  999. {
  1000. INT TmpX, TmpY;
  1001. INT TmpX0, TmpY0;
  1003. TmpX0 = *px; TmpY0 = *py;
  1005. TmpX = (*px >= TOUCH_MAX_X) ? (TOUCH_MAX_X-1) : *px;
  1006. TmpY = (*py >= TOUCH_MAX_Y) ? (TOUCH_MAX_Y-1) : *py;
  1008. TmpX -= TOUCH_MIN_X;
  1009.     TmpY -= TOUCH_MIN_Y;
  1010.     
  1011.     TmpX = (TmpX) ? TmpX : 0;
  1012.     TmpY = (TmpY) ? TmpY : 0;
  1013.     
  1014. *px = ((TmpX * TOUCH_X) / (TOUCH_MAX_X-TOUCH_MIN_X))*4;
  1015. *py = ((TmpY * TOUCH_Y) / (TOUCH_MAX_Y-TOUCH_MIN_Y))*4;
  1017. return;
  1018. }
  1021. VOID
  1022. DdsiTouchPanelGetPoint(
  1023. TOUCH_PANEL_SAMPLE_FLAGS *pTipStateFlags,
  1024. INT *pUncalX,
  1025. INT *pUncalY
  1026.     )
  1027. {
  1028. ULONG status;
  1029. // USHORT ioAdcCntr;
  1030. // USHORT intrMask;
  1031. static int SampleCount = 0;
  1032. static TOUCH_PANEL_SAMPLE_FLAGS PrevStateFlags = TouchSampleIgnore;
  1033. static INT PrevX = 0;
  1034. static INT PrevY = 0;
  1035. TOUCH_PANEL_SAMPLE_FLAGS TmpStateFlags;
  1036. INT TmpX = 0;
  1037. INT TmpY = 0;
  1038. int i;
  1039.     
  1040.     //RETAILMSG(1, (TEXT(":::::::::::: DdsiTouchPanelGetPoint routine !!!rn")));
  1042.     // Read the status passed back by the HAL
  1043.     status = READ_REGISTER_ULONG( &(v_pDriverGlobals->tch.status) );
  1045.     if(status == TOUCH_PEN_UP) {
  1046. v_pADCregs->rADCTSC = 0xD3; // Set stylus down interrupt
  1047. *pTipStateFlags = TouchSampleValidFlag;
  1048. *pUncalX = PrevX;
  1049. *pUncalY = PrevY;
  1050. InterruptDone( gIntrTouchChanged );
  1051. RETAILMSG(0, (TEXT("8 - (%d, %d) 0x%Xrn"), *pUncalX, *pUncalY, *pTipStateFlags));
  1052.     }
  1053.     else if(status == TOUCH_PEN_DOWN){
  1054. *pTipStateFlags = TouchSampleIgnore;
  1055. *pUncalX = PrevX;
  1056. *pUncalY = PrevY;
  1057. Touch_Timer0_Setup();
  1058. InterruptDone( gIntrTouchChanged );
  1060. RETAILMSG(0, (TEXT("9 - (%d, %d) 0x%Xrn"), *pUncalX, *pUncalY, *pTipStateFlags));
  1061. }
  1062. else {
  1063. if( (v_pADCregs->rADCDAT0 & 0x8000) || (v_pADCregs->rADCDAT1 & 0x8000) ){
  1064. v_pADCregs->rADCTSC = 0xD3; // Set stylus down interrupt
  1065. *pTipStateFlags = TouchSampleValidFlag;
  1066. *pUncalX = PrevX;
  1067. *pUncalY = PrevY;
  1068. InterruptDone( gIntrTouchChanged );
  1069. RETAILMSG(0, (TEXT("91 - (%d, %d) 0x%Xrn"), *pUncalX, *pUncalY, *pTipStateFlags));
  1070. }
  1071. else{ // charlie
  1072. // <Auto X-Position and Y-Position Read>
  1074. for (i =0; i < 3; i++) {
  1075. // v_pADCregs->rADCTSC=(0<<8)|(1<<7)|(1<<6)|(0<<5)|(1<<4)|(1<<3)|(1<<2)|(0);
  1076. v_pADCregs->rADCTSC=(1<<3)|(1<<2);
  1077. // Stylus Down,Don't care,Don't care,Don't care,Don't care,XP pullup Dis,Auto,No operation
  1078. v_pADCregs->rADCCON|=0x1; // Start Auto conversion
  1080. while(v_pADCregs->rADCCON & 0x1); //check if Enable_start is low
  1081. while(!(0x8000&v_pADCregs->rADCCON)); // Check ECFLG
  1083. ybuf[i] = 0x3ff - (0x3ff & v_pADCregs->rADCDAT0);
  1084. xbuf[i] = 0x3ff & v_pADCregs->rADCDAT1;
  1085. }
  1087.   PddpTouchPanelEvaluateSamples( &TmpStateFlags, &TmpX, &TmpY);
  1090. v_pADCregs->rADCTSC=(1<<8)|(1<<7)|(1<<6)|(0<<5)|(1<<4)|(0<<3)|(0<<2)|(3);
  1092. Touch_CoordinateConversion(&TmpX, &TmpY);    
  1095. if (Touch_Pen_filtering(&TmpX, &TmpY)) // Valid touch pen
  1096.     {
  1097.      //RETAILMSG(1, (TEXT("valid touch penrn")));
  1098. *pTipStateFlags = TouchSampleValidFlag | TouchSampleDownFlag;
  1099. *pTipStateFlags &= ~TouchSampleIgnore;
  1100. }
  1101. else // Invalid touch pen 
  1102. {
  1103.      //RETAILMSG(1, (TEXT("invalid touch penrn")));
  1104. *pTipStateFlags = TouchSampleValidFlag;
  1105. *pTipStateFlags |= TouchSampleIgnore;
  1106. }
  1107. *pUncalX = PrevX = TmpX;
  1108. *pUncalY = PrevY = TmpY;
  1110.     InterruptDone( gIntrTouch );
  1111.    
  1112.     RETAILMSG(0, (TEXT("0 - (%d, %d) 0x%Xrn"), *pUncalX, *pUncalY, *pTipStateFlags));
  1114. }
  1115. }
  1117.     return;
  1119. }
  1121. #define FILTER_LIMIT 25
  1123. static BOOL
  1124. Touch_Pen_filtering(INT *px, INT *py)
  1125. {
  1126. BOOL RetVal = TRUE;
  1127. // TRUE  : Valid pen sample
  1128. // FALSE : Invalid pen sample
  1129. static int count = 0;
  1130. static INT x[2], y[2];
  1131. INT TmpX, TmpY;
  1132. INT dx, dy;
  1135. count++;
  1137. if (count > 2) 
  1138. { // apply filtering rule
  1140. count = 2;
  1142. // average between x,y[0] and *px,y
  1143. TmpX = (x[0] + *px) / 2;
  1144. TmpY = (y[0] + *py) / 2;
  1146. // difference between x,y[1] and TmpX,Y
  1147. dx = (x[1] > TmpX) ? (x[1] - TmpX) : (TmpX - x[1]);
  1148. dy = (y[1] > TmpY) ? (y[1] - TmpY) : (TmpY - y[1]);
  1150. if ((dx > FILTER_LIMIT) || (dy > FILTER_LIMIT)) {
  1151. // Invalid pen sample
  1152. *px = x[1];
  1153. *py = y[1]; // previous valid sample
  1155. RetVal = FALSE;
  1156. count = 0;
  1157. } 
  1158. else
  1159. {
  1160. // Valid pen sample
  1161. x[0] = x[1]; y[0] = y[1];
  1162. x[1] = *px; y[1] = *py; // reserve pen samples
  1164. RetVal = TRUE;
  1165. //RETAILMSG(1, (TEXT("RetVal = TRUErn")));
  1166. }
  1168. } else { // till 2 samples, no filtering rule
  1170. x[0] = x[1]; y[0] = y[1];
  1171. x[1] = *px; y[1] = *py; // reserve pen samples
  1173. RetVal = FALSE; // <- TRUE jylee 2003.03.04 
  1174. }
  1176. //if (RetVal==FALSE) {
  1177. //}
  1179. return RetVal;
  1180. }
  1184. /*++
  1186.  @func VOID | DdsiTouchPanelPowerHandler |
  1187.  System power state notification.
  1189.  @parm BOOL | bOff | TRUE, the system is powering off; FALSE, the system is powering up.
  1191.  @comm
  1192.  This routine is called in a kernel context and may not make any system
  1193.  calls whatsoever.  It may read and write its own memory and that's about
  1194.  it.  This routine is called by the MDD and also serves as an internal
  1195.  helper routine for touch enable/disable.
  1197.  @devnote This routine will run in kernel context, and may not make
  1198.  any system calls.  If you can any subroutines inside here, make sure
  1199.  that they also follow this restriction.
  1201. --*/
  1202. void
  1203. DdsiTouchPanelPowerHandler(
  1204. BOOL bOff
  1205. )
  1206. {
  1207.     // USHORT mask;
  1209.     // Set flag so we know to avoid system calls
  1210.     bInPowerHandler = TRUE;
  1212.     if (bOff) {
  1213.         TouchPanelPowerOff();
  1214.     }
  1215.     else {
  1216.         TouchPanelPowerOn();
  1217.         PddpSetupPenDownIntr(TRUE);
  1218.     }
  1220.     bInPowerHandler = FALSE;
  1221. }
  1223. static void
  1224. TouchPanelPowerOff()
  1225. {
  1226.     // Powering down, stop DMA and power off touch screen
  1227.     RETAILMSG(0,(TEXT("Touch Power Offrn")));
  1228. }
  1231. static void
  1232. TouchPanelPowerOn()
  1233. {
  1234.     DWORD tmp = 0;
  1236. v_pIOPregs->rGPGCON &= ~((0x3 << 16));   
  1237. v_pIOPregs->rGPGCON |=  ((0x2 << 16)); /* External Interrupt #16 Enable */
  1240. v_pIOPregs->rEXTINT2 &= ~(0x7 << 8); // Configure EINT18 as Both Edge Mode
  1241. v_pIOPregs->rEXTINT2 |=  (0x7 << 8);
  1243. v_pIOPregs->rEINTPEND  = (1 << 16);
  1244. v_pIOPregs->rEINTMASK &= ~(1 << 16);
  1246. RETAILMSG(1,(TEXT("SDMMC config set rGPGCON: %xrn"), v_pIOPregs->rGPGCON));   
  1249.     RETAILMSG(1,(TEXT("Touch Initrn")));
  1251.     //
  1252.     // Setup GPIOs for touch
  1253.     // 
  1254.     
  1255.     // Clear GPG15, 14, 13, 12
  1256.     v_pIOPregs->rGPGCON &= ~((0x03 << 30)|(0x03 << 28)|(0x03 << 26)|(0x03 << 24));
  1257.     // Set GPG15 to use as nYPON, GPG14 to use as YMON, GPG13 to use as nXPON, GPG12 to use as XMON
  1258.     v_pIOPregs->rGPGCON |= ((0x01 << 30)|(0x01 << 28)|(0x01 << 26)|(0x01 << 24));
  1259.     // Disable full up function
  1260.     v_pIOPregs->rGPGUP |= ((0x01 << 15)|(0x01 << 14)|(0x01 << 13)|(0x01 << 12));
  1261.     
  1262.     //
  1263.     // Setup ADC register
  1264.     //
  1266.     // Down Int, YMON:0, nYPON:1, XMON:0;nXPON:1, Pullup:1, Auto Conv.,Waiting.
  1267.     v_pADCregs->rADCTSC = (0<<8)|(1<<7)|(1<<6)|(0<<5)|(1<<4)|(0<<3)|(0<<2)|(3);
  1268.     //v_pADCregs->rADCTSC=(1<<3)|(1<<2);
  1269. v_pADCregs->rADCDLY = ADC_DELAY_TIME;//default value for delay.    
  1270.     v_pADCregs->rADCCON = (1<<14)|(ADCPRS<<6)|(7<<3); //setup channel, ADCPRS, Touch Input
  1272. /*
  1273. RETAILMSG(1, (TEXT("v_pIOPregs->rGPBCON = 0x%Xrn"), v_pIOPregs->rGPBCON));
  1274. RETAILMSG(1, (TEXT("v_pIOPregs->rGPBDAT = 0x%Xrn"), v_pIOPregs->rGPBDAT));
  1275. RETAILMSG(1, (TEXT("v_pIOPregs->rGPBUP = 0x%Xrn"), v_pIOPregs->rGPBUP));
  1277. RETAILMSG(1, (TEXT("S2440PCLK = %drn"), S2440PCLK));
  1278. RETAILMSG(1, (TEXT("v_pPWMregs->rTCFG0 = 0x%Xrn"), v_pPWMregs->rTCFG0));
  1279. RETAILMSG(1, (TEXT("v_pPWMregs->rTCFG1 = 0x%Xrn"), v_pPWMregs->rTCFG1));
  1280. RETAILMSG(1, (TEXT("v_pPWMregs->rTCON = 0x%Xrn"), v_pPWMregs->rTCON));
  1281. RETAILMSG(1, (TEXT("v_pPWMregs->rTCNTB0 = 0x%Xrn"), v_pPWMregs->rTCNTB0));
  1282. RETAILMSG(1, (TEXT("v_pPWMregs->rTCMPB0 = 0x%Xrn"), v_pPWMregs->rTCMPB0));
  1283. RETAILMSG(1, (TEXT("v_pPWMregs->rTCNTO0 = 0x%Xrn"), v_pPWMregs->rTCNTO0));
  1284. RETAILMSG(1, (TEXT("v_pPWMregs->rTCNTB1 = 0x%Xrn"), v_pPWMregs->rTCNTB1));
  1285. RETAILMSG(1, (TEXT("v_pPWMregs->rTCMPB1 = 0x%Xrn"), v_pPWMregs->rTCMPB1));
  1286. RETAILMSG(1, (TEXT("v_pPWMregs->rTCNTO1 = 0x%Xrn"), v_pPWMregs->rTCNTO1));
  1287. RETAILMSG(1, (TEXT("v_pPWMregs->rTCNTB2 = 0x%Xrn"), v_pPWMregs->rTCNTB2));
  1288. RETAILMSG(1, (TEXT("v_pPWMregs->rTCMPB2 = 0x%Xrn"), v_pPWMregs->rTCMPB2));
  1289. RETAILMSG(1, (TEXT("v_pPWMregs->rTCNTO2 = 0x%Xrn"), v_pPWMregs->rTCNTO2));
  1290. RETAILMSG(1, (TEXT("v_pPWMregs->rTCNTB3 = 0x%Xrn"), v_pPWMregs->rTCNTB3));
  1291. RETAILMSG(1, (TEXT("v_pPWMregs->rTCMPB3 = 0x%Xrn"), v_pPWMregs->rTCMPB3));
  1292. RETAILMSG(1, (TEXT("v_pPWMregs->rTCNTO3 = 0x%Xrn"), v_pPWMregs->rTCNTO3));
  1293. RETAILMSG(1, (TEXT("v_pPWMregs->rTCNTB4 = 0x%Xrn"), v_pPWMregs->rTCNTB4));
  1294. RETAILMSG(1, (TEXT("v_pPWMregs->rTCNTO4 = 0x%Xrn"), v_pPWMregs->rTCNTO4));
  1295. */
  1296. return ;
  1297. }
  1300. static BOOL Touch_Timer0_Setup(void) {
  1301. unsigned int TmpTCON;
  1303.     //
  1304.     // We use Timer1 of PWM as OS Clock.
  1306.     // Disable Timer1 Init..
  1307.     v_pINTregs->rINTMSK |= BIT_TIMER1;     // Mask timer1 interrupt.
  1308.     v_pINTregs->rSRCPND = BIT_TIMER1;     // Clear pending bit
  1309.     v_pINTregs->rINTPND = BIT_TIMER1;
  1311.     //we operate our board with PCLK=203M/4 = 50750000Hz (50.75 Mhz)    
  1312. v_pPWMregs->rTCFG0 &= ~(0xff); /* Prescaler 1's Value */
  1313.     v_pPWMregs->rTCFG0 |= (PRESCALER); // prescaler value = 24 + 1
  1314.    v_pPWMregs->rTCFG1 &= ~(0xf<<4);
  1315. #if( SYS_TIMER_DIVIDER == 2 )
  1316.    v_pPWMregs->rTCFG1  |=  (0   << 4); /* 1/2 */
  1317. #elif ( SYS_TIMER_DIVIDER == 4 )
  1318.    v_pPWMregs->rTCFG1  |=  (1   << 4); /* 1/4 */
  1319. #elif ( SYS_TIMER_DIVIDER == 8 )
  1320.    v_pPWMregs->rTCFG1  |=  (2   << 4); /* 1/8 */
  1321. #elif ( SYS_TIMER_DIVIDER == 16 )
  1322.    v_pPWMregs->rTCFG1  |=  (3   << 4); /* 1/16 */
  1323. #endif
  1324. //    v_pPWMregs->rTCNTB1 = 1000; // about 10 ms(203M/4/2/(255+1))=10ms  
  1325.     v_pPWMregs->rTCNTB1 = (10 * (S2440PCLK / (PRESCALER+1) / SYS_TIMER_DIVIDER)) / 1000; // 10msec, Charlie
  1327.     v_pPWMregs->rTCMPB1 = 0;   
  1329. TmpTCON = v_pPWMregs->rTCON; // get TCON value to temp TCON register
  1330. TmpTCON &= ~0xf00;      // clear fields of Timer 1 
  1331. TmpTCON |= 0x200;      // interval mode(auto reload), update TCVNTB4, stop 
  1332. v_pPWMregs->rTCON = TmpTCON; // put the value to TCON register
  1334. TmpTCON = v_pPWMregs->rTCON; // get TCON value to temp TCON register
  1335. TmpTCON &= ~0xf00;      // clear fields of Timer 1 
  1336. TmpTCON |= 0x100;      // interval mode, no operation, start for Timer 4 
  1337. v_pPWMregs->rTCON = TmpTCON; // put the value to TCON register
  1339.     v_pINTregs->rINTMSK &= ~BIT_TIMER1;    
  1340.  
  1341.   return TRUE;   
  1342. }