/**********************************************************************/
/***************    MTK CONFIDENTIAL & COPYRIGHTED     ****************/
/***************                                       ****************/
/***************  $Modtime:: 07/04/09 11:49a   $       ****************/
/***************  $Revision:: 4                $       ****************/
/***************                                       ****************/
/***************   Description : Setup State           ****************/
/***************                 Machine               ****************/
/***************   This module must be placed in       ****************/
/***************   bank 0.                             ****************/
/***************       Company : MediaTek Inc.         ****************/
/***************    Programmer : Peter Huang           ****************/
/**********************************************************************/

#include "general.h"

#include "..\..\version.h"

#pragma NOAREGS

static BYTE code _pbFWVer[4] = VER_FIRMWARE;
static BYTE code _pb8032Ver[4] = VER_UI;

#ifdef DISC_UPDATE_CODE
static BYTE code _pbVolumeID[] = {VOLUME_ID};
static BYTE code _pbFileName[] = {UPDATE_FILE};
#endif

#ifdef LOAD_USR_PWD_FILE
static BYTE code _pbPwdFilename[] = {PWD_FILENAME};
#endif

#ifdef JPEG_MTKMARKER
static BYTE code _pbRtTarget[] = {JPEG_ROTATED_TARGET};

/**
 *  Push the target file name of rotated target into shared info.
 */
static void vSetRtTarget(void) large
{
  BYTE bIdx;

  vSetSharedInfo(SI_JPG_ROTATED_TARGET, _pbRtTarget[0]);
  bIdx = 0;
  while (_pbRtTarget[bIdx]) {
    vWriteNextSharedItem(_pbRtTarget[++ bIdx]);
  }

  return;
}
#endif  /* JPEG_MTKMARKER */

/***************************************************************************
     Function : void vSetFWVersion(void) large
  Dsecription : called from Timer routine
    Parameter : None
       Return : None
***************************************************************************/
static void vSetFWVersion(void) large
{
  // store 8032 version
  vSetSharedInfo(SI_8032_VER_ID0, _pb8032Ver[0]);
  vWriteNextSharedItem(_pb8032Ver[1]);
  vWriteNextSharedItem(_pb8032Ver[2]);
  vWriteNextSharedItem(_pb8032Ver[3]);

  // store SERVO version
  _dwIrDoneParm = dSRVGetVer();
  vSetSharedInfo(SI_SERVO_VER_ID0, bHiByte(wHiWord(_dwIrDoneParm)));
  vWriteNextSharedItem(bLoByte(wHiWord(_dwIrDoneParm)));
  vWriteNextSharedItem(bHiByte(wLoWord(_dwIrDoneParm)));
  vWriteNextSharedItem(bLoByte(wLoWord(_dwIrDoneParm)));

  // store Firmware version
  vSetSharedInfo(SI_FW_VER_ID0, _pbFWVer[0]);
  vWriteNextSharedItem(_pbFWVer[1]);
  vWriteNextSharedItem(_pbFWVer[2]);
  vWriteNextSharedItem(_pbFWVer[3]);

}

/***************************************************************************
     Function : void vSetUpgInfo(void) large
  Dsecription : called from Timer routine
    Parameter : None
       Return : None
***************************************************************************/
static void vSetUpgInfo(void) large
{
  BYTE bIdx;

  // enable checksum check
#ifdef UPDATE_KEEP_CPPM_KEY
  vSetSharedInfo(SI_UPG_CONFIG, SV_UPG_CHKSUM | SV_UPG_CPPM_KEEP);
#else
  vSetSharedInfo(SI_UPG_CONFIG, SV_UPG_CHKSUM | SV_UPG_CPPM_REPLACE);
#endif

#ifdef DISC_UPDATE_CODE
  vSetSharedInfo(SI_UPG_VOLUME_ST, _pbVolumeID[0]);
  bIdx = 0;
  while (_pbVolumeID[bIdx])
  {
    vWriteNextSharedItem(_pbVolumeID[++bIdx]);
  }

  vSetSharedInfo(SI_UPG_FILE_ST, _pbFileName[0]);
  bIdx = 0;
  while (_pbFileName[bIdx])
  {
    vWriteNextSharedItem(_pbFileName[++bIdx]);
  }
#endif /* DISC_UPDATE_CODE */

#ifdef LOAD_USR_PWD_FILE
  vSetSharedInfo(SI_PWD_FILENAME, _pbPwdFilename[0]);
  bIdx = 0;
  while (_pbPwdFilename[bIdx])
  {
    vWriteNextSharedItem(_pbPwdFilename[++bIdx]);
  }
#else
  vSetSharedInfo(SI_PWD_FILENAME, 0);
#endif /* LOAD_USR_PWD_FILE */
}

/***************************************************************************
     Function : void vUserInit(BOOL bInited)
  Dsecription : called from Timer routine
    Parameter : None
       Return : None
***************************************************************************/
void vUserInit(BOOL fgInited) large
{
#if (defined (MT1389_PTCON) && defined (MT1389_REV_L))
  BYTE bPScan, bTvMode;
#endif
  WORD  wAddr;

  for (wAddr = 0; wAddr < SHARED_INFO_GRP_SIZE * DSP_SHARED_INFO_GRP_NS; wAddr++)
    WriteSInfo(DSP_SHAREINFO_OFST + wAddr, 0x00);

  for (wAddr = 0; wAddr < 32; wAddr++)
    vSetSharedInfo(wSIItemPos(SI_ERROR_CODE, 1) + wAddr, 0x00);

#ifdef AUDIO_IN_EN
  _bPlayerFuncMode = PLAYER_FUNC_DVD;
#endif

  vSetFWVersion();
  vSetUpgInfo();

#ifdef JPEG_MTKMARKER
  vSetRtTarget();
#endif

  // initial share memory first
  vInitSystemShareInfo();
  vInitAdspShareInfo();
  vInitVideoShareInfo();

#if defined(HD_VIDEO) && defined(PSCAN_EN)
  if (fgInited)
  {
    vSetSharedInfo(SI_HD_MODE, bEepromReadByte(TV_HD_MODE_POS));
    vSetSharedInfo(SI_TV_SYSTEM, bEepromReadByte(TV_SYSTEM_POSITION));
    vSetSharedInfo(SI_PSCAN_EN, bEepromReadByte(TV_PSCAN_EN_POS));
  }
  else
  {
    vSetSharedInfo(SI_HD_MODE, SV_HD_MODE_OFF);
    vSetSharedInfo(SI_TV_SYSTEM, SV_NTSC);
    vSetSharedInfo(SI_PSCAN_EN, SV_OFF);
  }
#endif

  // - audio control init.
  vAdspInit(0); // note mute fitst, turned on in vUIStart()

  /* check if SEE was inited */
  if (fgInited)
  {
#ifdef DISC_UPG_RESET_DEFAULT
    if (bEepromReadByte(RESET_POSITION) == SV_ON)
    {
  #ifdef DISC_UPG_RESET_KEEP_REGION
      BYTE bTmp = bEepromReadByte(REGION_CODE_POSITION);
  #endif

      fgInited = TRUE;

      // load default value
      fgEepromSetWriteShadow();

      vEepromClearShadow(TRUE);

#ifdef MTK_MENU
      vInitMenuEntry(MENU_ITEM_INIT);
#else
      vInitMenuEntry(MENU_ITEM_INIT);
#endif

#if defined(MT1389_REV_E) && defined(PLAYER_KARAOKE) && defined(MTK_AUD_ADC)
  {
    extern void vAdspSetMicFading() large;
    vAdspSetMicFading();
   }
#endif

      // reset flag
      fgEepromWriteByte(RESET_POSITION, SV_OFF);
      // restore region code
  #ifdef DISC_UPG_RESET_KEEP_REGION
      fgEepromWriteByte(REGION_CODE_POSITION, bTmp);
      vSetSharedInfo(SI_REGION, bTmp << 4);
  #endif
      // we want to write back EEPROM shadow
      _rUI.fgEepromInited = FALSE;
    }
    else
#endif // DISC_UPG_RESET_DEFAULT
    {
#ifdef MTK_MENU
      vInitMenuEntry(MENU_ITEM_EEPROM);
#else
      vInitMenuEntry(MENU_ITEM_EEPROM);
#endif
    }
  }
  else /* serial EEPROM not inited */
  {
    fgEepromSetWriteShadow();

    vEepromClearShadow(TRUE);

#ifdef MTK_MENU
    vInitMenuEntry(MENU_ITEM_INIT);
#else
    vInitMenuEntry(MENU_ITEM_INIT);
#endif
    /* note the last memory shadow is written back when power down */

#ifdef DISC_UPG_RESET_DEFAULT
    // reset flag
    fgEepromWriteByte(RESET_POSITION, SV_OFF);
#endif
  }

#if (defined(SETUP_NO_PSCAN_CTRL) && defined(PSCAN_EN))
  vVideoUserRecallPScan(fgInited);
#endif

// MT1379_MANUFACTURE_TEST for SLT need to test i/p switch, so need to be interlace at startup.
#if (defined (MT1389_PTCON) && defined (MT1389_REV_L) && !defined(MT1379_MANUFACTURE_TEST))
  bTvMode = bEepromReadByte(TV_COMP_POS);
  if (bTvMode != SV_TVE_RGB)
  {
    fgEepromWriteByte(TV_COMP_POS, SV_TVE_RGB);
    bTvMode =SV_TVE_RGB;
  }
  bPScan = bEepromReadByte(TV_PSCAN_EN_POS);

  if (bPScan != SV_ON)
  {
    fgEepromWriteByte(TV_PSCAN_EN_POS, SV_ON);
    bPScan =SV_ON;
  }
   vVideoPScanMode(bPScan, bTvMode);
#endif

#ifdef AUDIO_IN_EN
#ifndef AUDIO_IN_ONLY
  if (fgIsFuncAin())
  {
    if (fgIsTrayInside() &&
        (bSharedInfo(SI_SRV_BOOT_STATE) == SV_SRV_BOOT_LOAD))
    {
      vSetSharedInfo(SI_SRV_BOOT_STATE, SV_SRV_BOOT_SKIP_LOAD);
    }
    else // other state not allow to boot in audio in state
    {
      vPlayerFuncSwitch(PLAYER_FUNC_DVD);
    }
  }
#else
  vSetSharedInfo(SI_SRV_BOOT_STATE, SV_SRV_BOOT_SKIP_LOAD);
#endif /* AUDIO_IN_ONLY*/
#endif /* AUDIO_IN_EN */
}