tidtv_userkeycodeparser.c

ti的数字电视芯片 tvp9000的源码

/*******************************************************************************
*	@ModuleName	::	TiDTV_UserKeyCodeParser.c
*	
*	@Copyright	::	Copyright 2005- Texas Instruments, Inc.
*	
*	@Description::	User defined IR Key Code Dispatcher & Parsers
*	
*	@History	::
*---------------------------------------
*	07-24-2005	W.Shi	Created
*******************************************************************************/

#include	<stdio.h>
#include	<string.h>
#include	"ucos_ii.h"

#include	"TvpArch.h"
#include	"TvpDefs.h"
#include	"Tvp9000.h"
#include	"TvpError.h"
#include	"TvpInt.h"
#include	"TvpHdm.h"
#include	"TvpInt926.h"
#include	"TvpUarts.h"
#include	"TvpEbi.h"
#include	"TvpTpp.h"
#include	"TvpIrrf.h"
#include	"TvpGpio.h"
#include	"TvpVideo.h"
#include	"TvpAudio.h"
#include	"TvpEncoder.h"

#include	"TiDTV_DataType.h"
#include	"TiDTV_SysCtrl.h"
#include	"TiDTV_UserApi.h"
#include	"TiDTV_Buffers.h"
#include	"TiDTV_PSIP.h"
#include	"TVP9K_I2C_Def.h"
#include	"TVP9K_NV_Def.h"
#include	"TiDTV_GLib.h"
#include	"TiDTV_GUI.h"
#include	"TiDTV_GuiApi.h"
#include	"TiDTV_McuComm.h"
#include	"TiDTV_IrKey.h"
#include	"TiDTV_AvInput.h"


OS_STK TiDTV_SleepTimerTaskStack[TI_DTV_SLEEP_TIMER_TASK_STACK_SIZE];
void TiDTV_SleepTimerTask(void *pArg);

/*******************************************************************************
*	@RoutineName:: TiDTV_KeyCodeDispatch
*
*	@Description:: Key code dispatcher
*
*	@Input		:: none
*
*	@Output		:: none
*
*	@Return		:: none
*******************************************************************************/
void TiDTV_KeyCodeDispatch(void)
{
	INT8U uCosRetStatus;
	int k;
	
	// check all Hot Keys
	if ((TiDTV_MenuTaskStatus() == OS_NO_ERR) &&
   		(TiDTV_KeyBuf.CurKeyCode == TI_DTV_IR_KEY_INPUT ||
   		 TiDTV_KeyBuf.CurKeyCode == TI_DTV_IR_KEY_SLEEP ||
   		 TiDTV_KeyBuf.CurKeyCode == TI_DTV_IR_KEY_ASPECT ||
   		 TiDTV_KeyBuf.CurKeyCode == TI_DTV_IR_KEY_PIC_MODE ||
   		 TiDTV_KeyBuf.CurKeyCode == TI_DTV_IR_KEY_CUSTOM1 ||
   		 TiDTV_KeyBuf.CurKeyCode == TI_DTV_IR_KEY_CC))
	{
		return;	// ignore the hot keys when Menu Task is running
	}
	
	// check all Numeric Keys
	if (TiDTV_KeyBuf.CurKeyCode != TI_DTV_IR_KEY_SELECT &&
		(TiDTV_KeyBuf.CurKeyCode < TI_DTV_IR_KEY_0 ||
		 TiDTV_KeyBuf.CurKeyCode > TI_DTV_IR_KEY_10))
		TiDTV_KeyBuf.NumDigitKey = 0;	// reset number of Digits Key
	
	switch (TiDTV_KeyBuf.CurKeyCode) {
		case TI_DTV_IR_KEY_POWER:	// Power ON/OFF
			TiDTV_PowerOff();
			break;
			
		case TI_DTV_IR_KEY_MTS:
			TiDTV_FirmwareUpdate();	// Firmware update
			break;
			
		case TI_DTV_IR_KEY_JUMP:
			if (TiDTV_SysCtrl.AvInput == TI_DTV_AV_INPUT_DTV) {	// Digital TV Channels
				// save current Program Table Index, and set the new Index
				k = TiDTV_SysCtrl.CurProgTableIdx;
				TiDTV_SysCtrl.CurProgTableIdx = TiDTV_SysCtrl.PreviousProgTableIdx;
				TiDTV_SysCtrl.PreviousProgTableIdx = k;
				
				k = TiDTV_SysCtrl.CurProgramIdx;
				TiDTV_SysCtrl.CurProgramIdx = TiDTV_SysCtrl.PreviousProgramIdx;
				TiDTV_SysCtrl.PreviousProgramIdx = k;
				
				// Physical TV Channel number
				k = TiDTV_SysCtrl.CurProgTableIdx;
				TiDTV_SysCtrl.CurPhyChanDTV = TiDTV_ProgTable[k].RfChanNo;
				TiDTV_ChangeDtvRfChan(TiDTV_SysCtrl.CurPhyChanDTV, 0);
			} else if (TiDTV_SysCtrl.AvInput == TI_DTV_AV_INPUT_A_VIDEO1) {	// Analog TV Channels
				// Set to Analog TV Channel
				k = TiDTV_SysCtrl.CurPhyChanATV;
				TiDTV_SysCtrl.CurPhyChanATV = TiDTV_SysCtrl.PreviousPhyChanATV;
				TiDTV_SysCtrl.PreviousPhyChanATV = k;
				TiDTV_SetTunerPhyChan(TiDTV_SysCtrl.CurPhyChanATV);
			}
			break;
			
		case TI_DTV_IR_KEY_SLEEP:
			TiDTV_SysCtrl.SleepTime = 5;	// Sleep time in Minutes
			TiDTV_SleepTimerTaskStartup();
			break;
			
		case TI_DTV_IR_KEY_ASPECT:	// 4:3/16:9/Non-Liner
			if (TiDTV_SysCtrl.ScaleMethod == TVP_VID_FILL_SCREEN)
				TiDTV_SysCtrl.ScaleMethod = TVP_VID_CURTAIN;
			else
				TiDTV_SysCtrl.ScaleMethod = TVP_VID_FILL_SCREEN;
			
			if (TiDTV_SysCtrl.AvInput == TI_DTV_AV_INPUT_DTV) {	// D-TV
				TiDTV_VideoConfig();	// Re-Configure the Video Controller
				tvpVidModPrefOut((TvpVidARMethod) TiDTV_SysCtrl.ScaleMethod);
			} else {
				TiDTV_StartNV();
			}
			break;
			
		case TI_DTV_IR_KEY_MENU:	// Menu
			// check if Menu Task is valid ?
			if (TiDTV_MenuTaskStatus() == OS_NO_ERR) {
				// if Menu Handling Task is Running,
				// then Clean up the Menu Operation handling task
				TiDTV_MenuTaskCleanup();
			} else {
				// Create and start the Menu handling Task
				TiDTV_MenuTaskStartup();
			}
			break;
			
		default:
			if ((TI_DTV_IR_KEY_CH_UP <= TiDTV_KeyBuf.CurKeyCode &&
					TiDTV_KeyBuf.CurKeyCode <= TI_DTV_IR_KEY_DISP_INF) ||
				(TiDTV_MenuTaskStatus() != OS_NO_ERR &&
					((TI_DTV_IR_KEY_0 <= TiDTV_KeyBuf.CurKeyCode &&
					  TiDTV_KeyBuf.CurKeyCode <= TI_DTV_IR_KEY_9) ||
					  TiDTV_KeyBuf.CurKeyCode == TI_DTV_IR_KEY_SELECT ||
					  (TiDTV_KeyBuf.CurKeyCode == TI_DTV_IR_KEY_10 &&
					   TiDTV_SysCtrl.AvInput == TI_DTV_AV_INPUT_DTV &&
					   TiDTV_KeyBuf.NumDigitKey > 0))))
			{
				if (TiDTV_CheckAutoTvChanScanTaskStatus() != OS_NO_ERR) {
					// only when it is not doing Auto TV Channel Scan
					// check if Prompt Message Task is running ?
					if (TiDTV_PromptMsgTaskStatus() == OS_NO_ERR) {
						// if Prompt Message Task is Running,
						// then Pass the key code to Prompt Message Task
						OSFlagPost(pTiDTV_SysFLAG, TI_DTV_PROMPT_MSG_KEY_READY, OS_FLAG_SET, &uCosRetStatus);
					} else {
						// Create and start the Prompt Message handling Task
						TiDTV_PromptMsgTaskStartup();
					}
				}
			} else if (TiDTV_MenuTaskStatus() == OS_NO_ERR) {
				// Pass the key code to DTV Menu operation:
				// if DTV Menu is valid, let DTV Menu Task know there is a Key pressed
				OSFlagPost(pTiDTV_SysFLAG, TI_DTV_MENU_KEY_READY, OS_FLAG_SET, &uCosRetStatus);
			} else {
				// Signal the Event Flag to the Root Task
				OSFlagPost(pTiDTV_SysFLAG, TI_DTV_ROOT_TASK_CTRL, OS_FLAG_SET, &uCosRetStatus);
			}
			break;
	}
}

/*******************************************************************************
*	@RoutineName:: TiDTV_PowerOff
*
*	@Description:: Power Off procedure
*
*	@Input		:: none
*
*	@Output		:: none
*
*	@Return		:: none
*******************************************************************************/
void TiDTV_PowerOff(void)
{
	OSTimeDly(1 * OS_TICKS_PER_SEC);	// wait for a while
	TiDTV_I2cWriteByte(0, 0, 0xD8, 1, 0x31, 0x00, OS_TICKS_PER_SEC / 2);
}

/*******************************************************************************
*	@RoutineName:: TiDTV_SleepTimerTaskStartup
*
*	@Description:: Sleep timer Task Start up
*
*	@Input		:: none
*
*	@Output		:: none
*
*	@Return		:: none
*******************************************************************************/
void TiDTV_SleepTimerTaskStartup(void)
{
	OSTaskDel(TI_DTV_SLEEP_TIMER_TASK_PRIORITY);
	
	// pop-up Menu for user selections for Sleep Time
	OSTaskCreate(TiDTV_SleepTimerTask,
				(void *) NULL,
				&TiDTV_SleepTimerTaskStack[TI_DTV_SLEEP_TIMER_TASK_STACK_SIZE - 1],
				TI_DTV_SLEEP_TIMER_TASK_PRIORITY);
}

/*******************************************************************************
*	@RoutineName:: TiDTV_SleepTimerTaskCleanup
*
*	@Description:: Clean up the Sleep Timer handling task
*
*	@Input		:: none
*
*	@Output		:: none
*
*	@Return		:: none
*******************************************************************************/
void TiDTV_SleepTimerTaskCleanup(void)
{
	TiDTV_SysCtrl.SleepTime = 0;	// Sleep time in Minutes
	OSTaskDel(TI_DTV_SLEEP_TIMER_TASK_PRIORITY);
}

/*******************************************************************************
*	@RoutineName:: TiDTV_SleepTimerTask
*
*	@Description:: The entry of SleepTimer handling task
*
*	@Input		::
*		void *pArg	: pointer to the Aruguments
*
*	@Output		:: none
*
*	@Return		:: none
*******************************************************************************/
void TiDTV_SleepTimerTask(void *pArg)
{
	INT8U SleepTime;
	char WorkString[10];
	
	while (TiDTV_SysCtrl.SleepTime > 10) {
		// wait for 10 minutes
		OSTimeDly(10 * 60 * OS_TICKS_PER_SEC);
		TiDTV_SysCtrl.SleepTime -= 10;
	}
	
	while (TiDTV_SysCtrl.SleepTime > 1) {
		// wait for 1 minutes
		OSTimeDly(60 * OS_TICKS_PER_SEC);
		TiDTV_SysCtrl.SleepTime--;
	}
	
	if (TiDTV_SysCtrl.SleepTime > 0) {
		TiDTV_SysCtrl.SleepTime = 0;
		SleepTime = 60;		// 1 minute
		while (SleepTime > 0) {
			// wait for 1 second
			OSTimeDly(OS_TICKS_PER_SEC);
			
			// use Top Window
			TiDTV_OsdSetDrawWindow(&TiDTV_OsdScreenAux, &TiDTV_OsdScreenAux.pOsdWindows[0]);
			TiDTV_OsdSetCharColor(&TiDTV_OsdScreenAux, TI_DTV_COLOR_BRIGHT_GREEN, 0);
			TiDTV_OsdMove(&TiDTV_OsdScreenAux, 30, 0);
			TiDTV_OsdDrawAsciiStr(&TiDTV_OsdScreenAux, (char *) pTiDTV_GuiMsg[5]);
			TiDTV_OsdMoveOffset(&TiDTV_OsdScreenAux, 30, 0);
			TiDTV_MyInt2Str(SleepTime, WorkString, 2, ' ');
			TiDTV_OsdDrawAsciiStr(&TiDTV_OsdScreenAux, WorkString);
			TiDTV_OsdMoveOffset(&TiDTV_OsdScreenAux, 30, 0);
			TiDTV_OsdDrawAsciiStr(&TiDTV_OsdScreenAux, (char *) pTiDTV_GuiMsg[6]);
			
			SleepTime--;
		}
		
		TiDTV_PowerOff();
	}
	
	OSTaskDel(TI_DTV_SLEEP_TIMER_TASK_PRIORITY);
}

/*******************************************************************************
*	@RoutineName:: TiDTV_FirmwareUpdate
*
*	@Description:: Firmware update
*
*	@Input		:: none
*
*	@Output		:: none
*
*	@Return		::
*		int	: 0 = OK, -1 = NG
*******************************************************************************/
int TiDTV_FirmwareUpdate(void)
{
	UCHAR *pUartRxDataBuf = TiDTV_VideoFrameBuf0, *pWorkUCHAR;
	USHORT BlockNo, TotalNumBlock;
	int    RxDataSize, RetStatus, TotalNumBytes = 0;
	USHORT MakerID, DeviceID[3];
	
	tvpFiqDisable();			// disable FIQ
	TiDTV_OsdBackColorCtrl(1);	// force Backgound Color
	
//	TiDTV_UartWrite(7, "Start\r\n", 0);
	do {
		RetStatus = TiDTV_UartReadSize(1030, &RxDataSize, pUartRxDataBuf, 0);
		pUartRxDataBuf[0] = 'A';
		pUartRxDataBuf[1] = 'K';
		TiDTV_UartWrite(6, pUartRxDataBuf, 0);
		BlockNo = (pUartRxDataBuf[2] << 8) | pUartRxDataBuf[3];
		TotalNumBlock = (pUartRxDataBuf[4] << 8) | pUartRxDataBuf[5];
		TotalNumBytes += RxDataSize - 6;
		pUartRxDataBuf += RxDataSize;
	} while (RxDataSize == 1030 && BlockNo != TotalNumBlock &&
			TotalNumBytes < 0x400000);
	
	tvpIrqDisable();			// disable IRQ
	TiDTV_FlashMemGetDeviceID(&MakerID, DeviceID);
	RetStatus = TiDTV_FlashMemEraseChip();
	if (RetStatus == TI_DTV_E_OK) {
		pUartRxDataBuf = TiDTV_VideoFrameBuf0;
		pWorkUCHAR = TiDTV_VideoFrameBuf2;
		for (BlockNo = 0; BlockNo < TotalNumBlock; BlockNo++) {
			memmove(pWorkUCHAR, pUartRxDataBuf + 6, 1024);
			pUartRxDataBuf += 1030;
			pWorkUCHAR += 1024;
		}
		
		RetStatus = TiDTV_FlashMemProgram((USHORT *) TI_DTV_FLASH_BASE_ADDR,
							(USHORT *) TiDTV_VideoFrameBuf2, TotalNumBytes);
	}
	
	return RetStatus;
}