fmtuner_key.c

TEA5767HN飞利浦收音芯片的驱动程序

//-----------------------------------------------------------------------------
// (C) Copyright 2003 Philips Semiconductors, All rights reserved
//
// This source code and any compilation or derivative thereof is the sole
// property of Philips Corporation and is provided pursuant to a Software
// License Agreement.  This code is the proprietary information of Philips
// Corporation and is confidential in nature.  Its use and dissemination by
// any party other than Philips Corporation is strictly limited by the
// confidential information provisions of the Agreement referenced above.
//-----------------------------------------------------------------------------
// FILE NAME:    fmTuner_Key.c
//
// VERSION:      <1.00.00.0000>
//
// DESCRIPTION:  This module handles the keyboard event process
//               This virsion has no local variables, using global variables for key
//               process,pointer structure for function of key process  is not modified,
//               return value is replaced with fuzhi yuju.
//
// DOCUMENT REF: SZLAB/PRS0001 SZLAB/PRS0003
// NOTES:        <File notes>
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
// Standard include files:
//-----------------------------------------------------------------------------
//
#include "common.h"
#include "cmd_glb.h"
#include "keyb_glb.h"
#include "global.h"
#include "PSA_API.h"

//-----------------------------------------------------------------------------
// Project include files:
//-----------------------------------------------------------------------------
//
#include "fmTuner.h"
#include "fmDisplay.h"
#include "fmTuner_DrvFunction.h"
#include "fmTuner_PresetStore.h"
//-----------------------------------------------------------------------------
// Types and defines:
//-----------------------------------------------------------------------------
//

//-----------------------------------------------------------------------------
// Global data:
//-----------------------------------------------------------------------------

extern void fmTuner_ToggleBusEnable(void);
//-----------------------------------------------------------------------------
// FUNCTION:    fmTuner_KeyProcess
//
// DESCRIPTION: This function handles porcessing of system event including keyboard,PSA event,command
//
// RETURN:      U32,for description,please refer to global.h
//
// NOTES:       <Function notes - pre/post state, side effects, reentrancy>
//-----------------------------------------------------------------------------

U32 
fmTuner_KeyProcess(
    U32 u32kKeyCode,
    U32 u32kKeyEvent
    )
{
    U32 rc=cSSA_OK;
//    IicMasterError eI2cStatus;
    fmTuner_TuningDirection_e temp;
    U8 PresetNumber;
    temp=fmTuner_TuningDirection_Up;
    if(gfmTuner_u8InTune==TRUE)
    {
        return rc;
    }
    if(gfmTuner_u8SearchBusy==TRUE||gfmTuner_u8AstSearchBusy==TRUE)
    {
        
        if(u32kKeyEvent==cKEYB_EVENT_RELEASE)
        {
            if(u32kKeyCode!=Keyb_Code_EqLongPressed&&
               u32kKeyCode!=Keyb_Code_PrevLongPressed&&
               u32kKeyCode!=Keyb_Code_NextLongPressed
              )
            {
                fmTuner_TerminateImediately();
                return rc;
            }   
       }
       else
       {
            if(u32kKeyCode!=Keyb_Code_Eq&&
               u32kKeyCode!=Keyb_Code_Prev&&
               u32kKeyCode!=Keyb_Code_Next
              )
            {
                fmTuner_TerminateImediately();
                return rc;
            } 
       }
    } 
    if(gfmTuner_u8SaveBusy==TRUE)
    {
        gfmTuner_u8TimeOutFunctionTimer=150;
        if(u32kKeyEvent==cKEYB_EVENT_RELEASE)
        {
            if(u32kKeyCode==Keyb_Code_Play||
               u32kKeyCode==Keyb_Code_Next||
               u32kKeyCode==Keyb_Code_Prev||
               u32kKeyCode==Keyb_Code_Eq
              )
            {
                fmTuner_SaveHandler(u32kKeyCode);
            }    
            
        }    
        
        return rc;    
    }
    switch(u32kKeyCode)
    {
        case     Keyb_Code_Play:
            
            if(u32kKeyEvent==cKEYB_EVENT_RELEASE)
            {
                fmTuner_ToggleStereoMono();
                if(gfmTuner_eMonoStereo==fmTuner_MonoStereo_Mono)
                {
                    fmDisplay_RadioStereo(cFM_DISPLAY_RADIOHUANG_MONO);
                    gfmTuner_eStereoStatus=fmTuner_MonoStereo_Mono;   
                }
            }
            
        break;
        case    Keyb_Code_Eq:
        
            if(u32kKeyEvent==cKEYB_EVENT_RELEASE)
            {
                if(gfmTuner_u8ManualPreset==cFM_TUNER_MANUAL)
                {
                    if(gfmTuner_u8SaveBusy==FALSE)
                    {
                        fmTuner_InitiateSaveHandler();
                    }
                }
            }
        
        break;
        case    Keyb_Code_EqLongPressed:
            if(u32kKeyEvent==cKEYB_EVENT_NORMAL)
            {
                if(gfmTuner_u8ManualPreset==cFM_TUNER_MANUAL)
                {
                    fmTuner_InitiateAstSearch();
                    gfmTuner_u8SearchWrapAround=FALSE;
                    fmDisplay_RadioPutChannelNumber(0,0);  
                    gfmTuner_u8WriteFlash=TRUE;                 
                }
                else
                {
                    
                    if(gfmTuner_u8PresetFirst)
                    {
                        //delete current channel
                        fmTuner_DeleteCurrentChannel();
                        gfmTuner_u8PresetFirst=FALSE; 
                        PresetNumber=fmTuner_GetPresetNumber(fmTuner_TuningDirection_Up);
                        if(PresetNumber)
                        {
                            //found a preset frequency
                            fmTuner_FetchPresetChannel(PresetNumber);
                            gfmTuner_u8WriteFlash=TRUE;
                        

                        }
                        else
                        {
                            fmDisplay_RadioEmptyChannel();

                        }
                        gfmTuner_u8PresetFirst=TRUE;
                    }
                }    
            }

        break;
        case    Keyb_Code_ModeLongPressed:
        
            if(u32kKeyEvent==cKEYB_EVENT_NORMAL)
            {
                rc=cSSA_TASK_SWITCH_TO_VOCREC;
            }
       
        break;
        
        case    Keyb_Code_Mode:
        
            if(u32kKeyEvent==cKEYB_EVENT_RELEASE)
            {
                rc=cSSA_BACK_SWITCH_TO_RECORD;
            }
       
        break;
        case    Keyb_Code_VolUp:
        case    Keyb_Code_VolDown:
           
            if(u32kKeyEvent==cKEYB_EVENT_RELEASE)
            {
                rc=cSSA_BACK_SWITCH_TO_VOLUME;    
                
            }
                   
                         
        
            
        break;
        
        
        case    Keyb_Code_VolUpLongPressed:
            
        
        case    Keyb_Code_VolDownLongPressed:
            
            if(u32kKeyEvent==cKEYB_EVENT_NORMAL)
            {
                rc=cSSA_BACK_SWITCH_TO_VOLUME;
            }
            
        break;
        
        case    Keyb_Code_PrevLongPressed:
                temp=fmTuner_TuningDirection_Down;
        case    Keyb_Code_NextLongPressed:
            if(u32kKeyEvent==cKEYB_EVENT_NORMAL)
            {
                if(gfmTuner_u8ManualPreset==cFM_TUNER_MANUAL)
                {
                    fmTuner_InitiateSearch(temp,gfmTuner_eSearchLevel);
                    fmDisplay_RadioPutChannelNumber(0,0);
                    gfmTuner_u8SearchWrapAround=FALSE;
                    gfmTuner_u8WriteFlash=TRUE;
                }    
            }        
        break;
        
        case    Keyb_Code_Prev:
                temp=fmTuner_TuningDirection_Down;
        case    Keyb_Code_Next:
        
            if(u32kKeyEvent==cKEYB_EVENT_RELEASE)
            {
                if(gfmTuner_u8ManualPreset==cFM_TUNER_MANUAL)
                {
                    //gfmTuner_eHighLowInjection=fmTuner_HighLowInjection_High;
                    fmTuner_ManualTuneUpDown(temp); 
                    fmDisplay_RadioFrequency(gfmTuner_u16TunerFrequency); 
                    fmDisplay_RadioPutChannelNumber(0,0); 
                    fmTuner_PresetDetect();
                    
                    gfmTuner_u8WriteFlash=TRUE;
                   //fmDisplay_RadioPutChannelNumber(0,0); 
                }
                else
                {
                    PresetNumber=fmTuner_GetPresetNumber(temp);
                    
                    if(PresetNumber)
                    {
                        //found a preset frequency
                        fmTuner_FetchPresetChannel(PresetNumber);
                        gfmTuner_u8WriteFlash=TRUE;
                        

                    }
                    else
                    {
                        fmDisplay_RadioEmptyChannel();

                    }
                    gfmTuner_u8PresetFirst=1;
                }
            }
                   
               
                   
                         
        break;
        case    Keyb_Code_Menu:
             
        
            if(u32kKeyEvent==cKEYB_EVENT_RELEASE)
            {
   
                fmTuner_TogglePresetManual();
                fmDisplay_RadioPresetIndicator(gfmTuner_u8ManualPreset); 
                
            }
        
        break;
        case    Keyb_Code_MenuLongPressed:

            if(u32kKeyEvent==cKEYB_EVENT_NORMAL)
            {
                rc=cSSA_BACK_SWITCH_TO_MENU;
            }
               
        
        break;

        default :
        
        break;

    }
    return    rc;

}    
//-----------------------------------------------------------------------------
// FUNCTION:    
//
// DESCRIPTION: <Function description/purpose>
//
//RETURN:      <return data type/description>
//
// NOTES:       <Function notes - pre/post state, side effects, reentrancy>
//-----------------------------------------------------------------------------
//
/*
<Return Type>
<Function Name> (
    <Parameter 1>,	// <[ I:| O:|IO:] Parameter 1 description (include domain
                      //              and/or constraints)>
    <Parameter 2>,	// <[ I:| O:|IO:] Parameter 2 description..>
    <Parameter n>	// <[ I:| O:|IO:] Parameter n description..>
    )
{

    <Code implementation here...>

} // <Function Name> ()

*/
/*============================ History List ================================
============================================================================*/