//------------------------------------------------------------------------------ // // Function: disable_lcd_backlight // // This function disables the backlight for the LCD controller // UINT32 disable_lcd_backlight( void ) { HANDLE hTwl; //OALMSG(OAL_INFO, (L"disable_lcd_backlight+\r\n")); // Enable LEDA on TPS659XX hTwl = TWLOpen(); #ifdef BSP_EVM2 if(!IsLVDSMode()) TWLWriteByteReg(hTwl, TWL_LEDEN, 0x00); #else // The hardware design is completely backwards. In order // to disable the LED control signal, the LEDPWM signal must // be enabled 100% // Set LEDAON, LEDAPWM TWLWriteByteReg(hTwl, TWL_LEDEN, 0x11); // Set PWM registers to same value to trigger 100% duty cycle TWLWriteByteReg(hTwl, TWL_PWMAOFF, 0x00); TWLWriteByteReg(hTwl, TWL_PWMAON, 0x00); #endif TWLClose(hTwl); //OALMSG(OAL_INFO, (L"disable_lcd_backlight-\r\n")); return ERROR_SUCCESS; }
VOID WriteBaseOffset( ULONGLONG *pOffset ) { UCHAR val; // Write backup registers with secure time offset val = (UCHAR)(*pOffset >> 0); TWLWriteByteReg(s_rtc.hTWL, TWL_BACKUP_REG_A, val); val = (UCHAR)(*pOffset >> 8); TWLWriteByteReg(s_rtc.hTWL, TWL_BACKUP_REG_B, val); val = (UCHAR)(*pOffset >> 16); TWLWriteByteReg(s_rtc.hTWL, TWL_BACKUP_REG_C, val); val = (UCHAR)(*pOffset >> 24); TWLWriteByteReg(s_rtc.hTWL, TWL_BACKUP_REG_D, val); val = (UCHAR)(*pOffset >> 32); TWLWriteByteReg(s_rtc.hTWL, TWL_BACKUP_REG_E, val); val = (UCHAR)(*pOffset >> 40); TWLWriteByteReg(s_rtc.hTWL, TWL_BACKUP_REG_F, val); val = (UCHAR)(*pOffset >> 48); TWLWriteByteReg(s_rtc.hTWL, TWL_BACKUP_REG_G, val); val = (UCHAR)(*pOffset >> 56); TWLWriteByteReg(s_rtc.hTWL, TWL_BACKUP_REG_H, val); }
//------------------------------------------------------------------------------ // // Function: OEMSetAlarmTime // // This function is called by the kernel to set the real-time clock alarm. // BOOL OEMSetAlarmTime( SYSTEMTIME *pSystemTime ) { BOOL rc = FALSE; OALMSG(OAL_TIMER && OAL_FUNC, (L"+OEMSetAlarmTime(%s)\r\n", SystemTimeToString(pSystemTime))); if (s_rtc.initialized) { // Save time to global structure EnterCriticalSection(&s_rtc.cs); if (g_ResumeRTC) { OALIoCtlHalRtcTime(0, NULL, 0, NULL, 0, NULL); g_ResumeRTC = FALSE; } // Round to seconds pSystemTime->wMilliseconds = 0; // Convert to filetime if (NKSystemTimeToFileTime(pSystemTime, (FILETIME*)&s_rtc.alarmFiletime)) { UCHAR status; UCHAR bcdTime[6]; // Adjust alarm time by secure offset s_rtc.alarmFiletime = s_rtc.alarmFiletime - s_rtc.baseOffset; // Convert to BCD time format FiletimeToHWTime( s_rtc.alarmFiletime, bcdTime ); // Write alarm registers TWLWriteByteReg(s_rtc.hTWL, TWL_ALARM_YEARS_REG, bcdTime[5]); TWLWriteByteReg(s_rtc.hTWL, TWL_ALARM_MONTHS_REG, bcdTime[4]); TWLWriteByteReg(s_rtc.hTWL, TWL_ALARM_DAYS_REG, bcdTime[3]); TWLWriteByteReg(s_rtc.hTWL, TWL_ALARM_HOURS_REG, bcdTime[2]); TWLWriteByteReg(s_rtc.hTWL, TWL_ALARM_MINUTES_REG, bcdTime[1]); TWLWriteByteReg(s_rtc.hTWL, TWL_ALARM_SECONDS_REG, bcdTime[0]); // Set toggle bit to latch alarm registers TWLReadByteReg(s_rtc.hTWL, TWL_RTC_CTRL_REG, &status); status |= TWL_RTC_CTRL_RUN | TWL_RTC_CTRL_GET_TIME; TWLWriteByteReg(s_rtc.hTWL, TWL_RTC_CTRL_REG, status); // Done rc = TRUE; } LeaveCriticalSection(&s_rtc.cs); } return rc; }
//------------------------------------------------------------------------------ // // Function: enable_lcd_backlight // // This function enables the backlight for the LCD controller // UINT32 enable_lcd_backlight( void ) { void* hTwl; //OALMSG(OAL_INFO, (L"enable_lcd_backlight+\r\n")); // Enable LEDA on TPS659XX hTwl = TWLOpen(); #ifdef BSP_EVM2 TWLWriteByteReg(hTwl, TWL_LEDEN, 0x11); // Set PWM registers to same value to trigger 100% duty cycle //TWLWriteByteReg(hTwl, TWL_PWMAOFF, 0x00); //TWLWriteByteReg(hTwl, TWL_PWMAON, 0x00); if(!IsLVDSMode()) { TWLWriteByteReg(hTwl, TWL_PWMAOFF, 0x20); TWLWriteByteReg(hTwl, TWL_PWMAON, 0x01); } else { TWLWriteByteReg(hTwl, TWL_PWMAOFF, 0x7F); TWLWriteByteReg(hTwl, TWL_PWMAON, 0x7E); } #else // The hardware design is completely backwards. // In order to get 100% brightness, the LEDPWM must // be disabled. // Clear LEDAON, LEDAPWM TWLWriteByteReg(hTwl, TWL_LEDEN, 0x00); #endif TWLClose(hTwl); //OALMSG(OAL_INFO, (L"enable_lcd_backlight-\r\n")); return ERROR_SUCCESS; }
//------------------------------------------------------------------------------ // // Function: OALIoCtlHalRtcTime // // This function is called by RTC driver when time event interrupt // occurs. // BOOL OALIoCtlHalRtcTime( UINT32 code, VOID *pInBuffer, UINT32 inSize, VOID *pOutBuffer, UINT32 outSize, UINT32 *pOutSize ) { SYSTEMTIME baseSystemTime; UCHAR status; UCHAR bcdTime[6]; UNREFERENCED_PARAMETER(pOutSize); UNREFERENCED_PARAMETER(outSize); UNREFERENCED_PARAMETER(pOutBuffer); UNREFERENCED_PARAMETER(inSize); UNREFERENCED_PARAMETER(pInBuffer); UNREFERENCED_PARAMETER(code); OALMSG(OAL_TIMER && OAL_FUNC, (L"+OALIoCtlHalRtcTime()\r\n")); // The RTC in Triton2 is set to periodically sync with the kernel time // to ensure there is no clock drift. When a sync event is triggered, // the T2 RTC is used to set the base time in the kernel. EnterCriticalSection(&s_rtc.cs); // Set get time flag TWLReadByteReg(s_rtc.hTWL, TWL_RTC_CTRL_REG, &status); status |= TWL_RTC_CTRL_RUN | TWL_RTC_CTRL_GET_TIME; TWLWriteByteReg(s_rtc.hTWL, TWL_RTC_CTRL_REG, status); // Get date and time from RTC TWLReadByteReg(s_rtc.hTWL, TWL_YEARS_REG, &bcdTime[5]); TWLReadByteReg(s_rtc.hTWL, TWL_MONTHS_REG, &bcdTime[4]); TWLReadByteReg(s_rtc.hTWL, TWL_DAYS_REG, &bcdTime[3]); TWLReadByteReg(s_rtc.hTWL, TWL_HOURS_REG, &bcdTime[2]); TWLReadByteReg(s_rtc.hTWL, TWL_MINUTES_REG, &bcdTime[1]); TWLReadByteReg(s_rtc.hTWL, TWL_SECONDS_REG, &bcdTime[0]); // Convert current RTC date/time to FILETIME baseSystemTime.wYear = BCD2BIN(bcdTime[5]) + RTC_BASE_YEAR_MIN; baseSystemTime.wMonth = BCD2BIN(bcdTime[4]); baseSystemTime.wDay = BCD2BIN(bcdTime[3]); baseSystemTime.wHour = BCD2BIN(bcdTime[2]); baseSystemTime.wMinute = BCD2BIN(bcdTime[1]); baseSystemTime.wSecond = BCD2BIN(bcdTime[0]); baseSystemTime.wMilliseconds = 0; // Update the base filetime to match RTC NKSystemTimeToFileTime(&baseSystemTime, (FILETIME*)&s_rtc.baseFiletime); // Reset the tick count s_rtc.baseTickCount = OEMGetTickCount(); LeaveCriticalSection(&s_rtc.cs); return TRUE; }
//------------------------------------------------------------------------------ // // Function: OALIoCtlHalInitRTC // // This function is called by WinCE OS to initialize the time after boot. // Input buffer contains SYSTEMTIME structure with default time value. // // BOOL OALIoCtlHalInitRTC( UINT32 code, VOID *pInBuffer, UINT32 inSize, VOID *pOutBuffer, UINT32 outSize, UINT32 *pOutSize ) { BOOL rc = FALSE; SYSTEMTIME *pGivenTime = (LPSYSTEMTIME) pInBuffer; UCHAR bcdTime[6]; UCHAR status; UCHAR secure; UNREFERENCED_PARAMETER(pOutSize); UNREFERENCED_PARAMETER(outSize); UNREFERENCED_PARAMETER(pOutBuffer); UNREFERENCED_PARAMETER(inSize); UNREFERENCED_PARAMETER(code); OALMSG(OAL_TIMER && OAL_FUNC, (L"+OALIoCtlHalInitRTC()\r\n")); // Initialize RTC critical section InitializeCriticalSection(&s_rtc.cs); // Set CPU GPIO_64 (T2 MSECURE) to be output/high (unsecure) // This allows write access to the T2 RTC calendar/time registers // OMAP35XX GP only if( dwOEMHighSecurity == OEM_HIGH_SECURITY_GP ) { BSPSetT2MSECURE(TRUE); } // First read RTC status from Triton s_rtc.hTWL = TWLOpen(); if (s_rtc.hTWL == NULL) { OALMSG(OAL_ERROR, (L" OALIoCtlHalInitRTC(): Failed to open Triton\r\n")); goto cleanUp; } // Read secure registers for secure hash status = 0; TWLReadByteReg(s_rtc.hTWL, TWL_SECURED_REG_A, &secure); status |= secure; TWLReadByteReg(s_rtc.hTWL, TWL_SECURED_REG_B, &secure); status |= secure; TWLReadByteReg(s_rtc.hTWL, TWL_SECURED_REG_C, &secure); status |= secure; TWLReadByteReg(s_rtc.hTWL, TWL_SECURED_REG_D, &secure); status |= secure; OALMSG(OAL_TIMER && OAL_FUNC, (L" OALIoCtlHalInitRTC(): RTC TWL_SECURED_REG_= 0x%x\r\n", status)); #if 1 // brian // Not needed for CE embedded, only need to reset RTC if TWL/TPS PMIC is reset // Check for a clean boot of device - if so, reset date/time to system default (LTK2026) //pColdBoot = OALArgsQuery(OAL_ARGS_QUERY_COLDBOOT); //if ((pColdBoot != NULL) && *pColdBoot) // { OALMSG(OAL_TIMER && OAL_FUNC, (L" OALIoCtlHalInitRTC(): Clean boot, reset date time\r\n")); status = 0; // } #endif // Start RTC when it isn't running if (status == 0 && pGivenTime != NULL) { OALMSG(OAL_TIMER && OAL_FUNC, (L" OALIoCtlHalInitRTC(): Resetting RTC\r\n")); // Write power_up and alarm bits to clear power up flag (and any interrupt flag) TWLWriteByteReg(s_rtc.hTWL, TWL_RTC_STATUS_REG, TWL_RTC_STATUS_POWER_UP|TWL_RTC_STATUS_ALARM); // Convert system time to BCD bcdTime[5] = BIN2BCD(pGivenTime->wYear - RTC_BASE_YEAR_MIN); bcdTime[4] = BIN2BCD(pGivenTime->wMonth); bcdTime[3] = BIN2BCD(pGivenTime->wDay); bcdTime[2] = BIN2BCD(pGivenTime->wHour); bcdTime[1] = BIN2BCD(pGivenTime->wMinute); bcdTime[0] = BIN2BCD(pGivenTime->wSecond); // Initialize RTC with given values TWLWriteByteReg(s_rtc.hTWL, TWL_YEARS_REG, bcdTime[5]); TWLWriteByteReg(s_rtc.hTWL, TWL_MONTHS_REG, bcdTime[4]); TWLWriteByteReg(s_rtc.hTWL, TWL_DAYS_REG, bcdTime[3]); TWLWriteByteReg(s_rtc.hTWL, TWL_HOURS_REG, bcdTime[2]); TWLWriteByteReg(s_rtc.hTWL, TWL_MINUTES_REG, bcdTime[1]); TWLWriteByteReg(s_rtc.hTWL, TWL_SECONDS_REG, bcdTime[0]); // Enable RTC TWLWriteByteReg(s_rtc.hTWL, TWL_RTC_CTRL_REG, TWL_RTC_CTRL_RUN); // Write fake hash to secure regs TWLWriteByteReg(s_rtc.hTWL, TWL_SECURED_REG_A, 0xAA); TWLWriteByteReg(s_rtc.hTWL, TWL_SECURED_REG_B, 0xBB); TWLWriteByteReg(s_rtc.hTWL, TWL_SECURED_REG_C, 0xCC); TWLWriteByteReg(s_rtc.hTWL, TWL_SECURED_REG_D, 0xDD); // Convert given time initialization date/time to FILETIME NKSystemTimeToFileTime(pGivenTime, (FILETIME*)&s_rtc.baseFiletime); // Set a default value for base offset s_rtc.baseOffset = 0; // Save off base offset to the backup regs WriteBaseOffset( &s_rtc.baseOffset ); } else { SYSTEMTIME baseSystemTime; OALMSG(OAL_TIMER && OAL_FUNC, (L" OALIoCtlHalInitRTC(): Getting RTC\r\n")); // Set get time flag TWLReadByteReg(s_rtc.hTWL, TWL_RTC_CTRL_REG, &status); status |= TWL_RTC_CTRL_RUN | TWL_RTC_CTRL_GET_TIME; TWLWriteByteReg(s_rtc.hTWL, TWL_RTC_CTRL_REG, status); // Get date and time from RTC TWLReadByteReg(s_rtc.hTWL, TWL_YEARS_REG, &bcdTime[5]); TWLReadByteReg(s_rtc.hTWL, TWL_MONTHS_REG, &bcdTime[4]); TWLReadByteReg(s_rtc.hTWL, TWL_DAYS_REG, &bcdTime[3]); TWLReadByteReg(s_rtc.hTWL, TWL_HOURS_REG, &bcdTime[2]); TWLReadByteReg(s_rtc.hTWL, TWL_MINUTES_REG, &bcdTime[1]); TWLReadByteReg(s_rtc.hTWL, TWL_SECONDS_REG, &bcdTime[0]); // Convert current RTC date/time to FILETIME baseSystemTime.wYear = BCD2BIN(bcdTime[5]) + RTC_BASE_YEAR_MIN; baseSystemTime.wMonth = BCD2BIN(bcdTime[4]); baseSystemTime.wDay = BCD2BIN(bcdTime[3]); baseSystemTime.wHour = BCD2BIN(bcdTime[2]); baseSystemTime.wMinute = BCD2BIN(bcdTime[1]); baseSystemTime.wSecond = BCD2BIN(bcdTime[0]); baseSystemTime.wMilliseconds = 0; NKSystemTimeToFileTime(&baseSystemTime, (FILETIME*)&s_rtc.baseFiletime); // Read the offset from the backup regs ReadBaseOffset( &s_rtc.baseOffset ); } OALMSG(OAL_TIMER && OAL_FUNC, (L" OALIoCtlHalInitRTC(): RTC = %s\r\n", HWTimeToString(bcdTime))); // Now update RTC state values s_rtc.initialized = TRUE; s_rtc.baseTickCount = OEMGetTickCount(); // Success rc = TRUE; cleanUp: OALMSG(OAL_TIMER && OAL_FUNC, (L"-OALIoCtlHalInitRTC() rc = %d\r\n", rc)); return rc; }