control.c

以ST公司CPU为核心的彩色电视机的完整源程序。

/********************* SGS-THOMSON MICROELECTRONICS ************************
FILENAME     : CONTROL.C
VERSION      : V1.0
DATE         : JAN 1999
AUTHOR(s)    : ASHISH RUDOLA/ DEEPAK DOSHI
PROCESSOR    : ST92195
DESCRIPTION  : This module contains functions for processing user commands.
MODIFICATIONS:
   -
*****************************************************************************/
#include "utility.h"
#include "control.h"
#include "audio.h"
#include "channel.h"
#include "command.h"
#include "display.h"
#include "menuctrl.h"
#include "register.h"
#include "service.h"
#include "timer.h"
#include "autosrch.h"
#include "tuning.h"
#include "video.h"
#include "eeprom.h"
#include "i2c_bus.h"
#include "sleep.h"
#include "source.h" 
#include "label.h"
#include "tv_glob.h" 


/*****************************************************************************
INPUTS     : ON_STATE - Set if the chassis is in the nominal ON state
             SERVICE_DISPLAY - Set if service mode active
             MENU_DISPLAY - Set if menu system open
             Current command
OUTPUTS    : command_flags - Cleared (commands have been processed)
             see get_command
             see process_service_command
             see process_menu_command
             see process_normal_TV_command
DESCRIPTION: Check the current state of the TV chassis an process commands
             accordingly. This function is called whenever a command has been
             received or if no commands are being received.
*****************************************************************************/
void process_command(void)
{
	unsigned char current_command;		/* Temporary storage */

	/* Get the current command if any */
/*	current_command = get_command();	 \* command.c */
		get_command();
		current_command = command;

	/*  cold start power key   */
	if ((!(tv_flags & ENABLE_POWER))&&(command_flags & COMMAND_NEW)) 
	{
 		if (current_command >= COMMAND_1 && current_command <=COMMAND_9)
 		{
 			channel = current_command; 
 			write_eeprom(EEPROM_LAST_CHANNEL,channel);
			read_label(); /*ASHISH*/

			tv_flags |= ENABLE_POWER; 
		}
		if(current_command == COMMAND_CHANNEL_UP ||current_command == COMMAND_CHANNEL_DOWN
			||current_command == COMMAND_0 || current_command == COMMAND_POWER)
		{
			channel = read_eeprom(EEPROM_LAST_CHANNEL);
			tv_flags |= ENABLE_POWER; 
		}
	}

	/* Handles commands which apply when the chassis is in the ON state. If
	the chassis is in the nominal OFF state, process only the power command */
	if (tv_flags & ON_STATE)
	{
		
		/* Handle commands which do apply when the service mode is active */
       if (display_request_flags & SERVICE_DISPLAY)
				process_service_command(current_command); /* service.c */
		
		/* Handle commands which do apply when menu is active */
		if (display_request_flags & MENU_DISPLAY)
            process_menu_command(current_command);	 /* menuctrl.c */

		/* Handle normal TV commands */
		process_normal_TV_command(current_command);
	}
	/* Clear command flags (flag commands have been processed) */
	command_flags = command_flags & ~(COMMAND_NEW | COMMAND_VALID);
}

/*****************************************************************************
INPUTS     : Current command if any
             COMMAND_VALID - Set if the current command is valid
             COMMAND_NEW - Set if the current command is a new one
OUTPUTS    : see specific functions called by this function.
DESCRIPTION: This function processes normal TV commands. This function also
             handles periodic command time-outs that occur when no commands
             are being received.
*****************************************************************************/
void process_normal_TV_command(unsigned char current_command)
{
	/* Handle digit commands time-out (in case one digit has been pressed) */

 	if(source == TUNER) //feman : remove teletext
		update_digit_entry(current_command);   

	/* Check if there is one command available */
	if (command_flags & COMMAND_VALID)
	  {


	/* Check commands which do require key-down repeating... */
		switch (current_command)
		{
	        case COMMAND_CHANNEL_UP:
//			 	if(!(tv_flags & TELETEXT_ACTIVE)) //feman : remove teletext 
                if(source != TUNER)  
						return;
					channel_up();		  /* channel.c */
				update_repeat_timer((CHANNEL_UP_NORMAL_TIME << 8) |	CHANNEL_UP_INITIAL_TIME);
			break;                                  
	
	        case COMMAND_CHANNEL_DOWN:
                if(source != TUNER)  
    					return;
//			 	if(!(tv_flags & TELETEXT_ACTIVE))
	    			channel_down();		  /* channel.c */
				update_repeat_timer((CHANNEL_DOWN_NORMAL_TIME << 8) | CHANNEL_DOWN_INITIAL_TIME);
			break;                                  

	        case COMMAND_RIGHT:
//			 	if(!(tv_flags & TELETEXT_ACTIVE))
    	        volume_up();
			    update_repeat_timer((VOLUME_UP_NORMAL_TIME << 8) | VOLUME_UP_INITIAL_TIME);
			break;                                  
		
			case COMMAND_LEFT:
//			 	if(!(tv_flags & TELETEXT_ACTIVE))
            	volume_down();
    			update_repeat_timer((VOLUME_DOWN_NORMAL_TIME << 8) | VOLUME_DOWN_INITIAL_TIME);
			break;                   

		}
		
		if (command_flags & COMMAND_NEW)
		{
            command_flags = command_flags & ~(COMMAND_NEW | COMMAND_VALID);
  			

			switch (current_command)
			{
                case COMMAND_POWER:
    				tv_flags = tv_flags ^ ENABLE_POWER;
		    		break;   
                               

				case COMMAND_RECALL:

                  display_request_flags = display_request_flags ^ STATUS_DISPLAY;
                  display_request_flags &= ~(PROGRAM_DISPLAY | SLEEP_DISPLAY | NORMAL_DISPLAY|COMMERCIAL_DISPLAY);
                  slow_timers[STATUS_TIMER] = STATUS_TIME_OUT;   
               	break;            

 				case COMMAND_SLEEP:

 					if (display_request_flags & SLEEP_DISPLAY)
 						increment_sleep_timer();
 					display_request_flags |= (SLEEP_DISPLAY | REFRESH_DISPLAY);
                    display_request_flags &= ~(PROGRAM_DISPLAY | STATUS_DISPLAY | NORMAL_DISPLAY|COMMERCIAL_DISPLAY);
 					slow_timers[STATUS_TIMER] = STATUS_TIME_OUT;
 				break; 

 				case COMMAND_VSM:
					write_normal_video();
 					display_request_flags |= (NORMAL_DISPLAY | REFRESH_DISPLAY);
 				  	display_request_flags &= ~(NORMAL_ON_DISPLAY | PROGRAM_DISPLAY | STATUS_DISPLAY | SLEEP_DISPLAY|COMMERCIAL_DISPLAY);
 					slow_timers[STATUS_TIMER] = STATUS_TIME_OUT;
				    update_repeat_timer((CHANNEL_UP_NORMAL_TIME << 8) | CHANNEL_UP_INITIAL_TIME);
 				break; 
                
                case COMMAND_TWO_DIGIT :
                    if(source != TUNER)  
						return;
    				slow_timers[DIGIT_TIMER] = DIGIT_TIME_OUT;
 					slow_timers[STATUS_TIMER] = STATUS_TIME_OUT;
 					display_request_flags = display_request_flags ^ PROGRAM_DISPLAY ;
 				  	display_request_flags &= ~(NORMAL_DISPLAY | STATUS_DISPLAY | SLEEP_DISPLAY|COMMERCIAL_DISPLAY);
                    channel_tens = DISABLE_CHANNEL;
                break;


				case COMMAND_TV_AV:
					update_repeat_timer((MENU_NORMAL_TIME << 8) | MENU_INITIAL_TIME);
					source_flags |= (AV_REQUEST|AV_NIBBLE_REQUEST);
                    
				break;

				case COMMAND_MENU:
						update_repeat_timer((MENU_NORMAL_TIME << 8) | MENU_INITIAL_TIME);
	              		enable_menu_mode();
               	break; 
								
				case COMMAND_MUTE:
               toggle_mute(); 
  
             	break;

                case COMMAND_SERVICE:
					update_repeat_timer((MENU_NORMAL_TIME << 8) | MENU_INITIAL_TIME);
					enable_service_mode();	 
/*					menu_item = 0;*/
                break;

			#ifdef NICAM_FORCED
 				case COMMAND_LOCK: /*NICAM */
					if((!(misc3 & 0x01)) || (source != TUNER))
						return;
					update_repeat_timer((MENU_NORMAL_TIME << 8) | MENU_INITIAL_TIME);
					if (tv_flags & FORCE_NICAM_STD)
					{
						display_request_flags = display_request_flags & ~MUTE_DISPLAY;
					 	stereo_std = roll_inc(stereo_std, MAX_STD);
						user_flags = user_flags | FORCED_NICAM_FLAG;
						write_stereo_standard();
					}
					else
					{
						tv_flags = tv_flags | FORCE_NICAM_STD ;
					}
					user_flags = user_flags & ~DISPLAY_NICAM_STATUS;
					display_request_flags = display_request_flags & ~(NICAM_ON_DISPLAY |LANGUAGE_DISPLAY);
 					display_request_flags = display_request_flags | (NICAM_STANDARD_DISPLAY | REFRESH_DISPLAY);
 					slow_timers[STATUS_TIMER] = STATUS_TIME_OUT;

 				break; 

			#endif					

			#ifdef NICAM

 				case COMMAND_OK: /*LANG SELECTION IN DUAL MODE */
					if((!(misc3 & 0x01)) || (source != TUNER))
						return;
					update_repeat_timer((MENU_NORMAL_TIME << 8) | MENU_INITIAL_TIME);
					if (!(user_flags & MONO_FLAG))
						write_language_data();
 				break; 

 				case COMMAND_INDEX: /*NICAM STD DISPLAY */
					if ((display_request_flags & MUTE_DISPLAY) || (source != TUNER) || (!(misc3 & 0x01)))
						return;
					update_repeat_timer((MENU_NORMAL_TIME << 8) | MENU_INITIAL_TIME);
					display_request_flags = display_request_flags & ~(NICAM_ON_DISPLAY |LANGUAGE_DISPLAY);
 					display_request_flags = display_request_flags | (NICAM_STANDARD_DISPLAY | REFRESH_DISPLAY);
					user_flags = user_flags | DISPLAY_NICAM_STATUS;
 					slow_timers[STATUS_TIMER] = STATUS_TIME_OUT_1;
			#endif					

			}
		}
 }
}

/*****************************************************************************
INPUTS     : Keyboard timer repeat values
             COMMAND_NEW
OUTPUTS    : COMMAND_TIMER
DESCRIPTION: This function updates the repeat timer to allow fast key-down
             repeating.
*****************************************************************************/
void update_repeat_timer(unsigned int repeat_value)
{
    if (command_flags & COMMAND_NEW)
        asm("ld %H0,%L1" : "=r"(repeat_value) : "r"(repeat_value));
    asm("ld %0,%H1" : "=g"(fast_timers[COMMAND_TIMER]) : "r"(repeat_value));
}