stpcheck.c

mtk1389L latest sourcecode enjoy

/**********************************************************************/
/***************    MTK CONFIDENTIAL & COPYRIGHTED     ****************/
/***************                                       ****************/
/***************  $Modtime:: 07/06/04 8:06p    $       ****************/
/***************  $Revision:: 4                $       ****************/
/***************   Description : Setup check valid     ****************/
/***************                 relative routine      ****************/
/***************                                       ****************/
/***************       Company : MediaTek Inc.         ****************/
/***************    Programmer : Peter Huang           ****************/
/**********************************************************************/

#include "general.h"
#include "stpmain.h"

#ifdef SIMPLE_MENU
#include "stpmenu1.h"
#else
#include "stpmenu.h"
#endif

#pragma NOAREGS

//extern BOOL _fgPsLbValid;
static void vCheckSp(void) large;
static void vChkPerf(void) large;
static void vVerIn(void) large;
static void vChkVdo(void) large;
static void vChkAdo(void) large;
static void vChkSpdif(void) large;
static void vCheckMain(void) large;
static void vChkGen(void) large;
#ifdef SETUP_INVALID_ITEM
static void vCheckGenItem(BYTE bEntry) large;
#endif

#ifndef PLAYER_2_CHANNEL
static void vChkEq(void) large;
#endif

#if (defined(PLAYER_SURROUND) || defined(DOLBY_PROLOGIC) || defined(DOLBY_PROLOGIC2))
static void vChk3D(void) large;
#endif

#ifdef PLAYER_KARAOKE
static void vChkKok(void) large;
#endif

#ifdef PLAYER_SEQ
static void vChkSeq(void) large;
#endif

#ifdef DOLBY_PROLOGIC2
static void vChkPL2(void) large;
#endif

#ifdef SUPPORT_DDEX
static void vChkDDEX(void) large;
#endif

#ifdef SUPPORT_HDMI
static void vChkHDMI(void) large;
#endif //#ifdef SUPPORT_HDMI

// *********************************************************************
// Function : void vChkValid(BYTE bType) large
// Description :
// Parameter : None
// Return    : None
// *********************************************************************
void vChkValid(BYTE bType) large
{
  switch(bType)
  {
    case CHK_MAIN:
      vCheckMain();
      break;
    case CHK_VDO:
      vChkVdo();
      break;
    case CHK_ADO:
      vChkAdo();
      break;
    case CHK_PREF:
      vChkPerf();
      break;
    case CHK_VER:
      vVerIn();
      break;

    case CHK_GENERAL:
      vChkGen();
      break;

#ifdef PLAYER_SEQ
    case CHK_SEQ:
      vChkSeq();
      break;
#endif /* PLAYER_SEQ */

#ifndef PLAYER_2_CHANNEL
    case CHK_EQ:
      vChkEq();
      break;
#endif /* PLAYER_2_CHANNEL */

#ifndef PLAYER_2_CHANNEL
    case CHK_SPDIF:
      vChkSpdif();
      break;
  #if (defined(PLAYER_SURROUND) || defined(DOLBY_PROLOGIC) || defined(DOLBY_PROLOGIC2))
    case CHK_3D:
      vChk3D();
      break;
  #endif
    case CHK_SP:
      vCheckSp();
      break;
  #ifdef PLAYER_KARAOKE
    case CHK_KOK:
      vChkKok();
      break;
  #endif
  #ifdef DOLBY_PROLOGIC2
    case CHK_PL2:
      vChkPL2();
      break;
  #endif
  #ifdef SUPPORT_DDEX
    case CHK_DDEX:
      vChkDDEX();
      break;
  #endif
    case CHK_EXIT:
      _wInvalid = 0;
      break;
#endif

#ifdef SUPPORT_HDMI
    case CHK_HDMI:
      vChkHDMI();
      break;
#endif //#ifdef SUPPORT_HDMI

    default:
      break;
  }
}

// *********************************************************************
// Function : void vChkGen(void) large
// Description :
// Parameter : None
// Return    : None
// *********************************************************************
void vChkGen(void) large
{
//  #define TV_ASPECT_ITEM 0x01

  BYTE bDefMode;
  BYTE bInitState = bSharedInfo(SI_INIT_STATE);
  BYTE bPbcState = bSharedInfo(SI_PBC_STATE);

//  _fgPsLbValid = TRUE;

  bDefMode = bSharedInfo(SI_ASPECT_CHG_VALID);

  if (bInitState == SV_DISC_IDENTIFIED)
  {
    switch(bPbcState)
    {
      case SV_STOP:
      case SV_STOP_RESUME:
        break;

      default:
#if ((!defined(SETUP_PAUSE_PLAY)) &&  (!defined(SPDIF_MODE_CHANGE_MUTE)))
        _wInvalid &= ~AUDIO_OUT_ITEM;
#endif
        break;
    }
  }


#ifdef CHECK_TV_ASPECT_SET
  if (fgIsDvdPlay())
  {
    if (bDefMode & SV_BLOCK_ON)
    {
      _wInvalid &= ~TV_ASPECT_ITEM;
    }
  }
#endif

#if 0 // #ifdef TREAT_PS_LB_AS_THE_SAME
  if ( !(bDefMode & (SV_PSCAN_ON | SV_LB_ON)))
    _fgPsLbValid = FALSE;
  else
    _fgPsLbValid = TRUE;
#endif

#ifdef AUDIO_IN_EN
  // Disable line-in if test tone is active. Seiya
  if (_fgTestTone)
  {
    _wInvalid &= 0xBF;
  }
#endif
}

// *********************************************************************
// Function : void vCheckMain(void) large
// Description : preference page only enable in FULL stop mode
// Parameter : None
// Return    : None
// *********************************************************************
void vCheckMain(void) large
{
/*
#ifdef SIMPLE_MENU
  #define PREF_ITEM     0x10  // preference page
#else
  #define PREF_ITEM     0x08
#endif
  #define VERSION_ITEM  0x20
*/
  BYTE bPbcState = bSharedInfo(SI_PBC_STATE);
  BYTE bInitState = bSharedInfo(SI_INIT_STATE);

  switch (bInitState)
  {
    case SV_TRAY_OPENING:
    case SV_TRAY_ERROR:
    case SV_NO_DISC:
    case SV_UNKNOWN_DISC:
      // allowed
      break;

    case SV_DISC_IDENTIFIED:
      // need to check
      if ((bPbcState != SV_STOP) && (bPbcState != SV_PTL_ERR))
      {
        _wInvalid &= ~PREF_ITEM;
      }
      break;

    case SV_LOADING_DISC:
    case SV_TRAY_CLOSING:
    default:
      _wInvalid &= ~PREF_ITEM;
      // not allowed
      break;
  }

  //if (_bShowVerIdx != 0x0F)  //[runma] mark off, because main menu have no version_item in this version.
  //  _wInvalid &= ~VERSION_ITEM;
}

// *********************************************************************
// Function : void vChkPerf(void) large
// Description :
// Parameter : None
// Return    : None
// *********************************************************************
void vChkPerf(void) large
{
#if (defined(PLAYER_2_CHANNEL) || !defined(PWD_ON_NO_SET_PTL))
  return;
#else

  BYTE bPwdMode = bEepromReadByte(PASS_SW_POSITION);

//  #define TV_ITEM     0x01 /* TV */
//  #define PBC_ITEM    0x02 /* audio */
//  #define AUDIO_ITEM  0x04 /* audio */
//  #define SP_ITEM     0x08 /* sub-title */
//  #define DM_ITEM     0x10 /* disc menu */
//  #define PR_ITEM     0x20 /* parental */
//  #define CR_ITEM     0x40 /* locale */
//  #define RESET_ITEM  0x80

  // we have the disc, check it
  if (bPwdMode == EV_ON)
  {
    _wInvalid &= ~PR_ITEM;
  }
#endif
}

// *********************************************************************
// Function : void vChkAdo(void) large
// Description :
// Parameter : None
// Return    : None
// *********************************************************************
void vChkAdo(void) large
{
#ifdef PLAYER_2_CHANNEL
  return;
#else
  BYTE bPbcState = bSharedInfo(SI_PBC_STATE);
  BYTE bInitState = bSharedInfo(SI_INIT_STATE);
  #ifdef AUDIO_IN_EN
  BYTE bAINMode = bEepromReadByte(AUDIO_IN_POS);
  #endif
/*
  #define FNT_SPK_SZ  1
  #define CNT_SPK_SZ  2
  #define REAR_SPK_SZ 3
  #define TEST_MODE   5
  #define DIALOG_GIAN 6
*/

  if ((bEepromReadByte(SPEAKER_POSITION) == EV_DOWN_OFF)
#ifdef SPDIF_PCM_FORCE_DOWNMIX
      && (bEepromReadByte(IEC958_POSITION) != EV_PCM)
#endif
     )
  {
    _wInvalid &= ~(1<<DIALOG_GIAN);
  }
  else // downmix on
  {
    _wInvalid &= ~((1<<CNT_SPK_SZ) | (1<<REAR_SPK_SZ) | (1<<TEST_MODE));

#ifdef SET_VSURR_IN_SPKCFG
    if (bEepromReadByte(SPEAKER_POSITION) == EV_DOWN_VSURR)
    {
      _wInvalid &= ~(1<<DIALOG_GIAN);
    }
#endif // SET_VSURR_IN_SPKCFG
  }

  // if SPDIF output is enabled, no test tone is allowed
#ifdef SPDIF_ON_NO_TEST_TONE
  if (bEepromReadByte(IEC958_POSITION) != EV_AO_OFF)
  {
    _wInvalid &= ~(1<<TEST_MODE);
  }
#endif

  #ifdef AUDIO_IN_EN // Disable test tone if line-in is active. Seiya
  if (fgIsFuncAin() && (bAINMode > EV_AI_OFF) && (bAINMode < EV_AIN_MAX))
  {
    _wInvalid &= ~(1<<TEST_MODE);
  }
  #endif

  // not implement TEST tone
#ifdef SETUP_ENABLE_TEST_TONE
  // note we can not enable test tone here
  switch (bInitState)
  {
    case SV_TRAY_OPENING:
    case SV_TRAY_ERROR:
    case SV_NO_DISC:
    case SV_UNKNOWN_DISC:
      // allowed
      break;

    case SV_DISC_IDENTIFIED:
      // need to check
      // if ((bPbcState != SV_STOP) && (bPbcState != SV_STOP_RESUME))
      {
        _wInvalid &= ~(1<<TEST_MODE);
      }
      break;

    case SV_LOADING_DISC:
    case SV_TRAY_CLOSING:
    default:
      _wInvalid &= ~(1<<TEST_MODE);
      // not allowed
      break;
  }
#else
  _wInvalid &= ~(1<<TEST_MODE);
#endif

#endif
}

extern BOOL _fgIs1389Lite;

// *********************************************************************
// Function : void vChkVdo(void) large
// Description :
// Parameter : None
// Return    : None
// *********************************************************************
void vChkVdo(void) large
{
#ifdef PSCAN_EN
  BYTE bTvOut = bEepromReadByte(TV_COMP_POS);
  BYTE bPScan = bEepromReadByte(TV_PSCAN_EN_POS);
  BYTE bMode = bEepromReadByte(TV_PSCAN_MODE_POS);
#endif