stppass.c

mtk1389L latest sourcecode enjoy

/**********************************************************************/
/***************    MTK CONFIDENTIAL & COPYRIGHTED     ****************/
/***************                                       ****************/
/***************  $Modtime:: 07/04/09 11:49a   $       ****************/
/***************  $Revision:: 2                $       ****************/
/***************                                       ****************/
/***************   Description : Setup Password        ****************/
/***************                 relative routine      ****************/
/***************                                       ****************/
/***************       Company : MediaTek Inc.         ****************/
/***************    Programmer : Peter Huang           ****************/
/**********************************************************************/

#define _PASSR_C_

#include "general.h"
#include SETUP_MENU_FILE
//#include "stpmenu.h"
/*
#ifdef SIMPLE_MENU
#include "menu1.h"
#else
#include "menu.h"
#endif
*/
#include "stposdfn.h"

#pragma NOAREGS

extern BYTE bGetOptFromEeprom(sEntry *prEntry) large;

// *********************************************************************
// Function : BOOL fgPassValid(void) large
// Description : check if password valid or not,
// Parameter : None
// Return    : TRUE  - if valid (all 0~9)
//             FALSE - if invalid
// *********************************************************************
BOOL fgPassValid(void) large
{
  BYTE bTmp;
  BYTE i;

  for(i=0; i < PASSWORD_LEN; i++)
  {
    // for test
    // bTmp = bEepromReadByte(PASSWD_POSITION+i);
    bTmp = _pbSuperPass[i];

    if(bTmp > 9)
    {
      return (FALSE);
    }
  }
  return TRUE;
}

// *********************************************************************
// Function : BYTE bChangePass(WORD wEEPos, BYTE bValue) large
// Description : When user want to modify password, check if password
//               has been set before, if true ask old password
//                                       not, ask new password
// Parameter : None
// Return    : None
// *********************************************************************
BYTE bChangePass(WORD wEEPos, BYTE bValue) large
{
  _bPrevMenu = 0xFF;
  _bPrevItem = 0xFF;
  _bDataSel = 0;

  _bMenu = PASS_CHG_PAGE;

  //_bOsdState = STPSTT_PASSWORD;
  _bOsdState = STPSTT_DIALOG;
  _bDlgId = DLG_CHANGE_PWD;

  _bEntry = 1;

  return (ENTRY_FUN_REDRAW_PASS);

/* #ifndef SIMPLE_MENU */
#if 0
#if 1
  if(!fgPassValid())
  {
    /* invalid password, let user input new password */
    _bEntry = 2;
    vSetupEntryShowXY(MSG_X, MSG_Y, OSD_MSG_INPUT_NEW_PASS, WB_SETUP_MSG);
  }
  else
#endif
  {
    /* valid password, let user input old password */
    _bEntry = 1;
    vSetupEntryShowXY(MSG_X, MSG_Y, OSD_MSG_INPUT_OLD_PASS, WB_SETUP_MSG);
  }
#endif
}

// *********************************************************************
// Function : BOOL fgPassCorr(void) large
// Description : check if password is correct
//                1. same as EEprom password value
//                2. match super password
// Parameter : None
// Return    : TRUE / FALSE
// *********************************************************************
#if 0
BOOL fgPassCorr(void) large
{
  char cVal;
#if 0
  for(cVal = 0; cVal < PASSWORD_LEN; cVal++)
  {
    if (bSharedInfo(SH_PASS_0 + cVal) != bEepromReadByte(PASSWD_POSITION + cVal))
    {
      break;
    }
    if(cVal == (PASSWORD_LEN-1))
    {
      return(TRUE);
    }
  }
  for(cVal = 0; cVal < PASSWORD_LEN; cVal++)
  {
    if (bSharedInfo(SH_PASS_0 + cVal) != _pbSuperPass[cVal])
    {
      return(FALSE);
    }
  }
#endif
  return(TRUE);
}
#endif

BYTE bCheckOldPwd(WORD wEEPos, BYTE bValue) large
{
  BYTE  i;

  for(i = 0; i < PASSWORD_LEN; i++)
  {
    if (bSharedInfo(SH_DLG_VAL_0 + i) != bEepromReadByte(PASSWD_POSITION + i))
    {
      break;
    }
    if(i == (PASSWORD_LEN-1))
    {
      return RESULT_SUCCESS;
    }
  }
  for(i = 0; i < PASSWORD_LEN; i++)
  {
    if (bSharedInfo(SH_DLG_VAL_0 + i) != _pbSuperPass[i])
    {
      return RESULT_FAILURE;
    }
  }

  return RESULT_SUCCESS;
}

#if 0
BYTE bConfirmPwd(WORD wEEPos, BYTE bValue) large
{
  switch(_bDlgId)
  {
    case DLG_CONFIRM_PNTL:
      break;
    case DLG_CONFIRM_PWD:
      return bCheckOldPwd(wEEPos, bValue);
  }
}
#endif
//void vCheckOldPwd(void) large
BYTE bCheckNewPwd(WORD wEEPos, BYTE bValue) large
{
  BYTE  i;
  
  for(i = 0; i < PASSWORD_LEN; i++)
  {
    vSetSharedInfo(SH_PASS_0 + i, bSharedInfo(SH_DLG_VAL_0 + i));
  }
  
  return RESULT_SUCCESS;
  
  #if 0 //[runma]  remove block
  char cVal;

  vSetSharedInfo(SH_PASS_0 + _bDataCur, _bIRKey);

  if (_bDataCur + 1 == _bDataSel)
  {
    _bDataCur = _bDataSel + 1;
    //for(cVal = 0; cVal < PASSWORD_LEN; cVal++)
    for(cVal = 0; cVal < _bDataSel; cVal++)
    {
      if (bSharedInfo(SH_PASS_0 + cVal) != bEepromReadByte(PASSWD_POSITION + cVal))
      {
        break;
      }
    }
    if(cVal == _bDataSel)
    {
      //_fgNextItem = TRUE;
      return RESULT_SUCCESS;
    }
    for(cVal = 0; cVal < _bDataSel; cVal++)
    {
      if (bSharedInfo(SH_PASS_0 + cVal) != _pbSuperPass[cVal])
      {
        break;
      }
    }
    if(cVal == _bDataSel)
    {
      //_fgNextItem = TRUE;
      return RESULT_SUCCESS;
    }
  }
  
  return RESULT_SUCCESS;
  #endif
}

#if 0
void vCheckNewPwd(void) large
{
#if 0 //[runma] remove a block, it wont be called.
  vSetSharedInfo(SH_PASS_0 + _bDataCur, _bIRKey);
  if (_bDataCur + 1 == _bDataSel)
  {
    _fgNextItem = TRUE;
  }
#endif 
}
#endif
BYTE bConfirmNewPwd(void) large
{
  BYTE  i, bTmp;

  for(i = 0; i < PASSWORD_LEN; i++)
  {
    if (bSharedInfo(SH_DLG_VAL_0 + i) != bSharedInfo(SH_PASS_0 + i))
      return RESULT_FAILURE;
  }

  for(i = 0; i < PASSWORD_LEN; i++)
  {
    fgEepromWriteByte(PASSWD_POSITION + i, bSharedInfo(SH_PASS_0 + i));
  }
  
  return RESULT_SUCCESS;

  #if 0 //[runma] remove a block

  if ((_bIRKey) != bSharedInfo(SH_PASS_0 + _bDataCur))
  {
    _bDataCur = _bDataSel + 1;
//    _bDataCur = 0;
//    _bEntry--;
//    _fgNextItem = FALSE;
  }
  else if (_bDataCur + 1 == _bDataSel)
  {
    for(cVal = 0; cVal < PASSWORD_LEN; cVal++)
    {
      fgEepromWriteByte(PASSWD_POSITION + cVal, bSharedInfo(SH_PASS_0 + cVal));
    }
    _fgNextItem = TRUE;
  }
  #endif
  //[runma] add block
  #if 0
  if(!_fgNewPassDiff)
  {
    for(cVal = 0; cVal < PASSWORD_LEN; cVal++)
    {
      fgEepromWriteByte(PASSWD_POSITION + cVal, bSharedInfo(SH_PASS_0 + cVal));
    }
    return RESULT_SUCCESS;
  }
  return RESULT_FAILURE;
  //[runma] end of block
  #endif
}


#if (defined(SET_PTL_NEED_PWD) || defined(PTL_PWD_MODE_SW))
// *********************************************************************
// Function : BYTE bPassSwitch(WORD wEEPos, BYTE bValue) large
// Description : before user can change password switch, confirm password
//               again
// Parameter : None
// Return    : None
// *********************************************************************
BYTE bPassSwitch(WORD wEEPos, BYTE bValue) large
{
  if (!_fgNotify)
  {
    return (ENTRY_FUN_OK);
  }

  switch(wEEPos)
  {
#ifdef SET_PTL_NEED_PWD
    case PTL_LEVEL_POSITION:
      if (bEepromReadByte(PASS_SW_POSITION) == EV_OFF)
      {
        bSetPrLvl(PTL_LEVEL_POSITION, bValue);
        return (ENTRY_FUN_REDRAW);
      }
      _bDlgId = DLG_CONFIRM_PNTL;
      break;
#endif
    case PASS_SW_POSITION:
    default:
      _bDlgId = DLG_CONFIRM_PWD;
      break;
  }
  _bOsdState = STPSTT_DIALOG;
  _bPrevItem = 0xFF;
  _bMenu = PASS_CON_PAGE;
  _bEntry = 1;
  _bDataSel = 0;

  return (ENTRY_FUN_REDRAW);
}
#endif
// *********************************************************************
// Function : void vBackToPass(void) large
// Description :
// Parameter :
// Return    :
// *********************************************************************
#if 0
void vBackToPass(void) large
{
  /* back to password page */
#ifdef SIMPLE_MENU
//  _bPrevMenu = INVLAID_PAGE;
  _bPrevItem = 0xFF;
  _bMenu = PRE_PAGE;
  _bDataPrev = 0xFF;
  if (_bOsdState == STPSTT_PASSWORD)
  {
    _bEntry = 6;
  }
  else
  {
    _bEntry = 5;
    _bDataCur = _bDataSel = bGetOptFromEeprom(_rMenuRoot.prMenu[_bMenu]->prEntry[_bEntry-1]);
  }
  _bOsdState = STPSTT_OPTION;
  vRedrawPage();
#else
  _bPrevMenu = 0xFF;
  _bPrevItem = 0xFF;
  
#ifdef SET_PTL_NEED_PWD
  if (_bOsdState == STPSTT_CON_PSWD_PWD)
  {
    _bMenu = PASS_PAGE;
    _bEntry = 1;
  }
  else if (_bOsdState == STPSTT_CON_PSWD_PRE)
  {
    _bMenu = PRE_PAGE;
    _bEntry = PREFERENCE_PARENTAL;
  }
  else
#endif
  {
    _bMenu = PASS_PAGE;
    _bEntry = 1;
  }

  _bOsdState = STPSTT_ENTRY;
//  vChgColDis();
  //vRedrawPage();
  vRedrawPage(ENTRY_FUN_REDRAW);
//  vSetHLCol(HL_1, HL1_NORMAL_COL);
#endif

#ifdef SHOW_MARK
  //if (fgIsOsdType2())
  {
    vShowMark();
  }
#endif
}
#endif
// *********************************************************************
// Function : BOOL fgDealPass(void) large
// Description :
// Parameter :
// Return    :
// Note      : In this function,
//             1. the _bDataSel is used for current input password index
//             2. the user input password is store in SH_PASS_0 ->
// *********************************************************************
#if 0
BOOL fgDealPass(void) large
{
  BYTE pbStr[2] = {1, 'X'};
  char cVal;

  vSetBtnCol(WB_SETUP_ITEM, 0, 0, ENTRY_COL_BLACK, ENTRY_COL_WHITE);

  if ((_bIRKey == IR_ENTER) || (_bIRKey == IR_PLAY_ENTER) ||
      (_bIRKey == IR_PLAY) || (_bIRKey == IR_PLAY_PAUSE))
  {
    if (_bEntry == 4)
    {
      /* back to previous page */
      vBackToPass();
    }
    return(TRUE);
  }

  switch(_bEntry)
  {
    case 1:
      vSetMsgCol4(WB_SETUP_ITEM, ENTRY_COL_BTN_BG, ENTRY_COL_BTN_BG, ENTRY_COL_BTN_BG, ENTRY_COL_BLACK);
      vSetSharedInfo(SH_PASS_0 + _bDataSel, _bIRKey);
      vOsdShowStrXY(STP_DATA_START_X + 20 * _bDataSel,
                    STP_MENU_START_Y + STP_MENU_ENTRY_H * (_bEntry - 1),
                    WB_SETUP_ITEM, pbStr);
      vSelButton(WB_SETUP_ITEM, DATA_BTN_BASE + 0);
      _bDataSel++;
      if(_bDataSel == PASSWORD_LEN)
      {
        if(!fgPassCorr())
        {
          vShowSetupMsg(OSD_MSG_OLD_PASSWORD_ERR);
          _bDataSel = 0;
          vSetBtnCol(WB_SETUP_ITEM, ENTRY_COL_BTN_BG, ENTRY_COL_BG, ENTRY_COL_BLACK, ENTRY_COL_WHITE);
          vSelButton(WB_SETUP_ITEM, DATA_BTN_BASE + 0);
          return(TRUE);
        }

        if ((_bOsdState == STPSTT_CON_PSWD) || (_bOsdState == STPSTT_CON_PSWD_PWD) || (_bOsdState == STPSTT_CON_PSWD_PRE))
        {
          /* confirm password correct*/
#ifdef SET_PTL_NEED_PWD
          if (_bOsdState == STPSTT_CON_PSWD_PRE)
          {
            vShowSetupMsg(OSD_MSG_ENTER_CONTINUE);
            _bDataSel = _bDataPrev;
            vSetSharedInfo(SI_PTL_LV, _rMenuRoot.prMenu[PAGE_PRNTL]->prEntry[ITEM_PRNTL]->prData[_bDataSel]->bVal);
            fgEepromWriteByte(PTL_LEVEL_POSITION, _rMenuRoot.prMenu[PAGE_PRNTL]->prEntry[ITEM_PRNTL]->prData[_bDataSel]->bVal);
            _bEntry = 4;
          }
          else
#endif
          if ((_bOsdState == STPSTT_CON_PSWD) || (_bOsdState == STPSTT_CON_PSWD_PWD))
          {
            _bDataSel = _bDataPrev;
            fgEepromWriteByte(_rMenuRoot.prMenu[PASS_PAGE]->prEntry[0]->wEEPos, _bDataPrev);
            vBackToPass();
          }
#if 0
#ifdef SIMPLE_MENU
          vShowSetupMsg(OSD_MSG_ENTER_CONTINUE);
          _bDataSel = _bDataPrev;
          vSetSharedInfo(SI_PTL_LV, _rMenuRoot.prMenu[PRE_PAGE]->prEntry[4]->prData[_bDataSel]->bVal);
          fgEepromWriteByte(PTL_LEVEL_POSITION, _rMenuRoot.prMenu[PRE_PAGE]->prEntry[4]->prData[_bDataSel]->bVal);
          _bEntry = 4;
#else
          _bDataSel = _bDataPrev;
          fgEepromWriteByte(_rMenuRoot.prMenu[PASS_PAGE]->prEntry[0]->wEEPos, _bDataPrev);
          vBackToPass();
#endif
#endif
          return(TRUE);
        }
        else
        {
          _bEntry++;
          _bDataSel = 0;
          vShowSetupMsg(OSD_MSG_INPUT_NEW_PASS);
        }
        vSetBtnCol(WB_SETUP_ITEM, ENTRY_COL_BTN_BG, ENTRY_COL_BG, ENTRY_COL_BLACK, ENTRY_COL_WHITE);
        vSelButton(WB_SETUP_ITEM, DATA_BTN_BASE + 1);
      }
      break;
    case 2:
      vSetSharedInfo(SH_PASS_0 + _bDataSel, _bIRKey);
      vSetMsgCol4(WB_SETUP_ITEM, ENTRY_COL_BTN_BG, ENTRY_COL_BTN_BG, ENTRY_COL_BTN_BG, ENTRY_COL_BLACK);
      vOsdShowStrXY(STP_DATA_START_X + 20 * _bDataSel,
                    STP_MENU_START_Y + STP_MENU_ENTRY_H * (_bEntry - 1),
                    WB_SETUP_ITEM,
                    pbStr);
      vSelButton(WB_SETUP_ITEM, DATA_BTN_BASE + 1);
      _bDataSel++;
      if(_bDataSel == PASSWORD_LEN)
      {
        _bEntry++;
        _bDataSel = 0;
        vShowSetupMsg(OSD_MSG_REENTER_PASSWORD); //OSD_MSG_CONFIRM_PASS);
        vSetBtnCol(WB_SETUP_ITEM, ENTRY_COL_BTN_BG, ENTRY_COL_BG, ENTRY_COL_BLACK, ENTRY_COL_WHITE);
        vSelButton(WB_SETUP_ITEM, DATA_BTN_BASE + 2);
      }
      break;
    case 3:
      if ((_bIRKey) == bSharedInfo(SH_PASS_0 + _bDataSel))
      {
        vSetMsgCol4(WB_SETUP_ITEM, ENTRY_COL_BTN_BG, ENTRY_COL_BTN_BG, ENTRY_COL_BTN_BG, ENTRY_COL_BLACK);
        vOsdShowStrXY(STP_DATA_START_X + 20 * _bDataSel,
                      STP_MENU_START_Y + STP_MENU_ENTRY_H * (_bEntry - 1),
                      WB_SETUP_ITEM,
                      pbStr);
        vSelButton(WB_SETUP_ITEM, DATA_BTN_BASE + 2);
        _bDataSel++;
      }
      else
      {
        /* error confirm */
        vShowSetupMsg(OSD_MSG_CONFIRM_PASS_ERR);
        _bEntry--;
        _bDataSel = 0;
        vSetBtnCol(WB_SETUP_ITEM, ENTRY_COL_BG, ENTRY_COL_BTN_BG, ENTRY_COL_BLACK, ENTRY_COL_WHITE);
        vSelButton(WB_SETUP_ITEM, DATA_BTN_BASE + 2);
        vSetBtnCol(WB_SETUP_ITEM, ENTRY_COL_BTN_BG, ENTRY_COL_BG, ENTRY_COL_BLACK, ENTRY_COL_WHITE);
        vSelButton(WB_SETUP_ITEM, DATA_BTN_BASE + 1);
        return(TRUE);
      }
      if(_bDataSel == PASSWORD_LEN)
      {
        vShowSetupMsg(OSD_MSG_ENTER_CONTINUE);
#ifdef IR_SUPPORT_SHIFT_KEY
        /* force use shift key table to use enter key */
        vSetShiftKeyMode(TRUE);
#endif
        /* correct, save to EEPROM */
        for(cVal = 0; cVal < PASSWORD_LEN; cVal++)
        {
          fgEepromWriteByte(PASSWD_POSITION + cVal, bSharedInfo(SH_PASS_0 + cVal));
        }
        _bEntry++;
      }
      break;
  }
  return(TRUE);
}
#endif