path: root/cfe/cfe/arch/mips/board/bcm63xx_ram/src/bcm63xx_board.c

/*  *********************************************************************
    *  Broadcom Common Firmware Environment (CFE)
    *  
    *  bcm63xx_board.c   utility functions for bcm63xx board
    *  
    *  Created on :  09/25/2002  seanl
    *
    *********************************************************************

<:copyright-broadcom 
 
 Copyright (c) 2002 Broadcom Corporation 
 All Rights Reserved 
 No portions of this material may be reproduced in any form without the 
 written permission of: 
          Broadcom Corporation 
          16215 Alton Parkway 
          Irvine, California 92619 
 All information contained in this document is Broadcom Corporation 
 company private, proprietary, and trade secret. 
 
:>
*/
    
#include "bcm63xx_util.h"
#include "foxconnCfg.h"

#define MAX_BOARD_ID_NAMES          16
#define MAX_VOICE_BOARD_ID_NAMES    20

static char g_boardIdNames[BP_BOARD_ID_LEN * MAX_BOARD_ID_NAMES];
static int g_numBoardIdNames = 0;

static char g_voiceBoardIdNames[BP_BOARD_ID_LEN * MAX_VOICE_BOARD_ID_NAMES];
static int g_numVoiceBoardIdNames = 0;

static int parsehwaddr(char *, uint8_t *);
static int parseBoardIdStr(char *);
static int parseVoiceBoardIdStr(char *);
static int parsePsiSize(char *);
static int parseBackupPsi(char *tpStr);
static int parseSyslogSize(char *tpStr);
static int parseMainTp(char *);
static int parseMacAddrCount(char *);
static int parseMacAddr(char *);
static int charIsHex(char ch);
static int parseGponSN(char *snStr);
static int parseGponPW(char *pwStr);
static int macNumToStr(unsigned char *, char *);
static void getGponBoardParam(void);
static int gponParamsInitialized(NVRAM_DATA *pNvramData);

static int parseWpsDevicePin(char *pinStr);
static void getWpsDevicePinBoardParam(void);
#define PARAM_IDX_BOARD_NAME                0
#define PARAM_IDX_NUM_MAC_ADDR              1
#define PARAM_IDX_BASE_MAC_ADDR             2
#define PARAM_IDX_PSI_SIZE                  3
#define PARAM_IDX_ENABLE_BACKUP_PSI         4
#define PARAM_IDX_SYSLOG_SIZE               5
#define PARAM_IDX_MAIN_THREAD_NUM           6

#define PARAM_IDX_GPON_SN                   0
#define PARAM_IDX_GPON_PW                   1

#define PARAM_IDX_WPS_DEVICE_PIN            0

#define PARAM_IDX_VOICE_BOARD_NAME          0

static PARAMETER_SETTING gBoardParam[] =
{
    // prompt name                      Error Prompt Define Param  Validation function
    {"Board Id (0-#                     :", BOARDID_STR_PROMPT, "", "", 2,
        parseBoardIdStr, TRUE},
    {"Number of MAC Addresses (1-32)    :", MAC_CT_PROMPT, "", "", 2,
        parseMacAddrCount, TRUE},
    {"Base MAC Address                  :", MAC_ADDR_PROMPT, "", "", 17,
        parseMacAddr, TRUE},
    {"PSI Size (1-64) KBytes            :", PSI_SIZE_PROMPT, "", "", 2,
        parsePsiSize, TRUE},
    {"Enable Backup PSI [0|1]           :", BACKUP_PSI_PROMPT, "", "", 1,
        parseBackupPsi, TRUE},
    {"System Log Size (0-256) KBytes    :", SYSLOG_SIZE_PROMPT, "", "", 3,
        parseSyslogSize, TRUE},
    {"Main Thread Number [0|1]          :", CPU_TP_PROMPT, "", "", 1,
        parseMainTp, TRUE},
    {NULL}
};

static int gNumBoardParams = (sizeof(gBoardParam) / sizeof(PARAMETER_SETTING))-1;

static PARAMETER_SETTING gGponBoardParam[] =
{
    // prompt name                      Error Prompt Define Param  Validation function
    {"GPON Serial Number                :", GPON_SN_PROMPT, "", "", 12,
        parseGponSN, TRUE},
    {"GPON Password                     :", GPON_PW_PROMPT, "", "", 10,
        parseGponPW, TRUE},
    {NULL}
};

static int gNumGponBoardParams = (sizeof(gGponBoardParam) / sizeof(PARAMETER_SETTING))-1;
static int gGponParamsInitialized = 0;


static PARAMETER_SETTING gWpsDevicePinBoardParam[] =
{
    // prompt name                      Error Prompt Define Param  Validation function
    {"Device Pin                        :", WPS_DEVICE_PIN_PROMPT, "", "", 8,
        parseWpsDevicePin, TRUE},
    {NULL}
};

static int gNumWpsDevicePinBoardParams = (sizeof(gWpsDevicePinBoardParam) / sizeof(PARAMETER_SETTING))-1;
static int gWpsDevicePinInitialized = 0;

static PARAMETER_SETTING gVoiceBoardParam[] =
{
    // prompt name                      Error Prompt Define Param  Validation function
    {"Voice Board Configuration (0-#    :", BOARDID_STR_PROMPT, "", "", 2,
        parseVoiceBoardIdStr, FALSE},
    {NULL}
};

static int gNumVoiceBoardParams = (sizeof(gVoiceBoardParam) / sizeof(PARAMETER_SETTING))-1;
static int gVoiceParamsInitialized = 0;


static int parsehwaddr(char *str,uint8_t *hwaddr)
{
    int digit1,digit2;
    int idx = 6;
    
    if (strlen(str) == (MAX_MAC_STR_LEN - 7)) {       // no ':' mac input format ie. 021800100801
        while (*str && (idx > 0)) {
	        digit1 = parsexdigit(*str);
	        if (digit1 < 0)
                return -1;
	        str++;
	        if (!*str)
                return -1;
	        digit2 = parsexdigit(*str);
	        if (digit2 < 0)
                return -1;
	        *hwaddr++ = (digit1 << 4) | digit2;
	        idx--;
            str++;
	    }
        return 0;
    }

    if (strlen(str) != MAX_MAC_STR_LEN-2)
        return -1;
    if (*(str+2) != ':' || *(str+5) != ':' || *(str+8) != ':' || *(str+11) != ':' || *(str+14) != ':')
        return -1;
    
    while (*str && (idx > 0)) {
	    digit1 = parsexdigit(*str);
	    if (digit1 < 0)
            return -1;
	    str++;
	    if (!*str)
            return -1;

	    if (*str == ':') {
	        digit2 = digit1;
	        digit1 = 0;
	    }
	    else {
	        digit2 = parsexdigit(*str);
	        if (digit2 < 0)
                return -1;
            str++;
	    }

	    *hwaddr++ = (digit1 << 4) | digit2;
	    idx--;

	    if (*str == ':') 
            str++;
	}
    return 0;
}


static int parseMacAddr(char * macStr)
{
    unsigned char tmpBuf[MAX_PROMPT_LEN];
    
    return (parsehwaddr(macStr, tmpBuf));
}


static int parseBoardIdStr(char *boardIdStr)
{
    int ret = 1;
    int boardId;
    
    if (strlen (boardIdStr) != 0) {
        boardId = atoi(boardIdStr);
        if (boardId >= 0 && boardId < g_numBoardIdNames)
            ret = 0;
    }

    return ret;
}


static int parseVoiceBoardIdStr(char *boardIdStr)
{
    int ret = 1;
    int boardId;
    
    if (strlen (boardIdStr) != 0) {
        boardId = atoi(boardIdStr);
        if (boardId >= 0 && boardId < g_numVoiceBoardIdNames)
            ret = 0;
    }

    return ret;
}


static int parseMacAddrCount(char *ctStr)
{
    int count = atoi(ctStr);

    if (count >= 1 && count <= NVRAM_MAC_COUNT_MAX)
        return 0;
    else
        return 1;
}

static int parsePsiSize(char *tpStr)
{
    int psiSize = atoi(tpStr);

    if (psiSize >= 1 && psiSize <= NVRAM_MAX_PSI_SIZE)
        return 0;
    else
        return 1;
}

static int parseBackupPsi(char *tpStr)
{
    int enable = atoi(tpStr);

    if (enable == 0 || enable == 1)
        return 0;
    else
        return 1;
}

static int parseSyslogSize(char *tpStr)
{
    int syslogSize = atoi(tpStr);

    if (syslogSize >= 0 && syslogSize <= NVRAM_MAX_SYSLOG_SIZE)
        return 0;
    else
        return 1;
}


static int parseMainTp(char *tpStr)
{
    int tpNum = atoi(tpStr);

    if (tpNum == 0 || tpNum == 1)
        return 0;
    else
        return 1;
}

static int charIsHex(char ch)
{
    if (((ch >= '0') && (ch <= '9')) ||
        ((ch >= 'a') && (ch <= 'f')) ||
        ((ch >= 'A') && (ch <= 'F')))
        return 1;
    else
        return 0;
}

static int parseGponSN(char *snStr)
{
    int i;
    int ret = 0;

    if(strlen(snStr) == NVRAM_GPON_SERIAL_NUMBER_LEN-1) {
        for(i=4; i<NVRAM_GPON_SERIAL_NUMBER_LEN-1; ++i) {
            if(!charIsHex(snStr[i])) {
                ret = 1;
                break;
            }
        }
    }
    else {
        ret = 1;
    }

    return ret;
}

static int parseGponPW(char *pwStr)
{
    if(strlen(pwStr) == NVRAM_GPON_PASSWORD_LEN-1)
        return 0;
    else
        return 1;
}

static int parseWpsDevicePin(char *pinStr)
{
   unsigned char accum=0;
   unsigned char factor[NVRAM_WPS_DEVICE_PIN_LEN]={3,1,3,1,3,1,3,1};
   int i =0;
   
    /*Check Length*/
    if(strlen(pinStr) != NVRAM_WPS_DEVICE_PIN_LEN)
		return 1;

   /*valid checksum*/
   for ( i=0; i< NVRAM_WPS_DEVICE_PIN_LEN; i++ ) 
     accum += (pinStr[i]-'0')*factor[i];
   
   if ( (accum%10) ==0 )
   	return 0;

   return 1;
}

int macNumToStr(unsigned char *macAddr, char *str)
{
   if (macAddr == NULL || str == NULL) 
       return 0;

   sprintf(str, "%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x",
           macAddr[0], macAddr[1], macAddr[2], 
           macAddr[3], macAddr[4], macAddr[5]);
   return 1;
}

static int gponParamsInitialized(NVRAM_DATA *pNvramData)
{
    int i;
    int erased = 1;

    for(i=0; i<NVRAM_GPON_SERIAL_NUMBER_LEN-1; ++i) {
        if((pNvramData->gponSerialNumber[i] != (char)0xFF) &&
           (pNvramData->gponSerialNumber[i] != '\0')) {
            erased = 0;
            break;
        }
    }

    if(erased) {
        for(i=0; i<NVRAM_GPON_PASSWORD_LEN-1; ++i) {
            if((pNvramData->gponPassword[i] != (char)0xFF) &&
               (pNvramData->gponPassword[i] != '\0')) {
                erased = 0;
                break;
            }
        }
    }

    return (erased) ? 0 : 1;
}

static void getGponBoardParam(void)
{
    NVRAM_DATA nvramData;
    int erased;
    int i;
    int writeNvram = 0;

    readNvramData(&nvramData);

    erased = 1;
    for(i=0; i<NVRAM_GPON_SERIAL_NUMBER_LEN-1; ++i) {
        if((nvramData.gponSerialNumber[i] != (char)0xFF) &&
           (nvramData.gponSerialNumber[i] != '\0')) {
            erased = 0;
            break;
        }
    }

    if(erased) {
        strcpy(nvramData.gponSerialNumber, DEFAULT_GPON_SN);
        writeNvram = 1;
    }

    erased = 1;
    for(i=0; i<NVRAM_GPON_PASSWORD_LEN-1; ++i) {
        if((nvramData.gponPassword[i] != (char)0xFF) &&
           (nvramData.gponPassword[i] != '\0')) {
            erased = 0;
            break;
        }
    }

    if(erased) {
        strcpy(nvramData.gponPassword, DEFAULT_GPON_PW);
        writeNvram = 1;
    }

    if(writeNvram) {
        writeNvramData(&nvramData);
    }

    strcpy(gGponBoardParam[PARAM_IDX_GPON_SN].parameter, nvramData.gponSerialNumber);
    strcpy(gGponBoardParam[PARAM_IDX_GPON_PW].parameter, nvramData.gponPassword);
}

int setGponBoardParam(void)
{
    NVRAM_DATA nvramData;
    int ret = 0;

    getGponBoardParam();

    readNvramData(&nvramData);

    if (processPrompt(gGponBoardParam, gNumGponBoardParams)) {

        // At least one field was changed
        strcpy(nvramData.gponSerialNumber, gGponBoardParam[PARAM_IDX_GPON_SN].parameter);
        strcpy(nvramData.gponPassword, gGponBoardParam[PARAM_IDX_GPON_PW].parameter);

        // save the buf to nvram
        writeNvramData(&nvramData);
        ret = 1;
    }

    return ret;
}



static int gWpsDevicePinParamsInitialized(NVRAM_DATA *pNvramData)
{
    int i;

    for(i=0; i<NVRAM_WPS_DEVICE_PIN_LEN; ++i) {
        if(( (unsigned char)(pNvramData->wpsDevicePin[i])  > 0x39) ||
           ( (unsigned char)(pNvramData->wpsDevicePin[i])  < 0x30)  ) {
            return 0;
        }
    }

    return 1;
}

static void getWpsDevicePinBoardParam(void)
{
    NVRAM_DATA nvramData;

    readNvramData(&nvramData);

    if ( gWpsDevicePinParamsInitialized( &nvramData) ) {
        memcpy(gWpsDevicePinBoardParam[PARAM_IDX_WPS_DEVICE_PIN].parameter, 
		nvramData.wpsDevicePin, NVRAM_WPS_DEVICE_PIN_LEN);
		(gWpsDevicePinBoardParam[PARAM_IDX_WPS_DEVICE_PIN].parameter)[NVRAM_WPS_DEVICE_PIN_LEN] =
			'\0';
    }
    else {
	/*Set Default Device Pin*/
        memcpy(nvramData.wpsDevicePin, DEFAULT_WPS_DEVICE_PIN, NVRAM_WPS_DEVICE_PIN_LEN);
        writeNvramData(&nvramData);

        memcpy(gWpsDevicePinBoardParam[PARAM_IDX_WPS_DEVICE_PIN].parameter, 
		nvramData.wpsDevicePin,
		NVRAM_WPS_DEVICE_PIN_LEN);
		(gWpsDevicePinBoardParam[PARAM_IDX_WPS_DEVICE_PIN].parameter)[NVRAM_WPS_DEVICE_PIN_LEN] =
			'\0';
    }

}

int setWpsDevicePinBoardParam(void)
{
    NVRAM_DATA nvramData;
    int ret = 0;

    getWpsDevicePinBoardParam();

    readNvramData(&nvramData);

    if (processPrompt(gWpsDevicePinBoardParam, gNumWpsDevicePinBoardParams)) {
        memcpy(nvramData.wpsDevicePin, 
			gWpsDevicePinBoardParam[PARAM_IDX_WPS_DEVICE_PIN].parameter,
			NVRAM_WPS_DEVICE_PIN_LEN);
        // save the buf to nvram
        writeNvramData(&nvramData);
        ret = 1;
    }

    return ret;
}


static int voiceParamsInitialized(NVRAM_DATA *pNvramData)
{
    int rc = 0;
    NVRAM_DATA nvramData;
    readNvramData(&nvramData);

    if ( BpSetBoardId(nvramData.szBoardId) == BP_SUCCESS ) {
        if ( BpGetVoipDspConfig( 0 ) == NULL ) {
           gVoiceBoardParam[PARAM_IDX_VOICE_BOARD_NAME].enabled = FALSE;
        }
        else  {
           gVoiceBoardParam[PARAM_IDX_VOICE_BOARD_NAME].enabled = TRUE;
           rc = 1;
        }
    }

    return rc;
}

static void getVoiceBoardParam(void)
{
    NVRAM_DATA nvramData;
    char *ptr;
    char tmp[10];

    if (g_numVoiceBoardIdNames == 0)
        g_numVoiceBoardIdNames = BpGetVoiceBoardIds(g_voiceBoardIdNames, MAX_VOICE_BOARD_ID_NAMES);

    ptr = strchr(gVoiceBoardParam[PARAM_IDX_VOICE_BOARD_NAME].promptName, '#');
    if (ptr != NULL) {
        sprintf(tmp, "%d)", g_numVoiceBoardIdNames - 1);
        memcpy(ptr, tmp, strlen(tmp));
    }

    readNvramData(&nvramData);

    memcpy(gVoiceBoardParam[PARAM_IDX_VOICE_BOARD_NAME].parameter, nvramData.szVoiceBoardId, NVRAM_BOARD_ID_STRING_LEN);
    gVoiceBoardParam[PARAM_IDX_VOICE_BOARD_NAME].parameter[NVRAM_BOARD_ID_STRING_LEN] = '\0';
}

int setVoiceBoardParam(void)
{
    NVRAM_DATA nvramData;
    char voiceBoardIdPrompt[1000];
    int i;
    char tmp[3];
    char *voiceBoardIdPromptPtr, *savedVoiceBoardIdPromptPtr;
    int ret = 0;

    getVoiceBoardParam();

    readNvramData(&nvramData);

    // Create prompt string with voice board ID name selection
    voiceBoardIdPromptPtr = voiceBoardIdPrompt;
    for (i = 0; i < g_numVoiceBoardIdNames; i++) {
        sprintf (tmp, "%d", i);
        sprintf (voiceBoardIdPromptPtr, "%-17s-- %2s\n", &g_voiceBoardIdNames[i * BP_BOARD_ID_LEN], tmp);
        voiceBoardIdPromptPtr += strlen(voiceBoardIdPromptPtr);
    }
    strcpy (voiceBoardIdPromptPtr, gVoiceBoardParam[PARAM_IDX_VOICE_BOARD_NAME].promptName);

    // Save existing prompt string
    savedVoiceBoardIdPromptPtr = gVoiceBoardParam[PARAM_IDX_VOICE_BOARD_NAME].promptName;
    // Set newly created prompt string
    gVoiceBoardParam[PARAM_IDX_VOICE_BOARD_NAME].promptName = voiceBoardIdPrompt;

    // Convert board ID string to numeric value
    for (i = 0; i < g_numVoiceBoardIdNames; i++) {
        if (!strcmp(gVoiceBoardParam[PARAM_IDX_VOICE_BOARD_NAME].parameter, &g_voiceBoardIdNames[i * BP_BOARD_ID_LEN])) {
            sprintf(gVoiceBoardParam[PARAM_IDX_VOICE_BOARD_NAME].parameter, "%d", i);
        }
    }

    if (processPrompt(gVoiceBoardParam, gNumVoiceBoardParams)) {
        // At least one field was changed
        i = atoi(gVoiceBoardParam[PARAM_IDX_VOICE_BOARD_NAME].parameter);
        strcpy(nvramData.szVoiceBoardId, &g_voiceBoardIdNames[i * BP_BOARD_ID_LEN]);

        // save the buf to nvram
        writeNvramData(&nvramData);
        ret = 1;
    }

    // Convert numeric value of voice board ID to string
    gVoiceBoardParam[PARAM_IDX_VOICE_BOARD_NAME].promptName = savedVoiceBoardIdPromptPtr;
    i = atoi(gVoiceBoardParam[PARAM_IDX_VOICE_BOARD_NAME].parameter);
    strcpy(gVoiceBoardParam[PARAM_IDX_VOICE_BOARD_NAME].parameter, &g_voiceBoardIdNames[i * BP_BOARD_ID_LEN]);

    return ret;
}


//
// getBoardParam:  convert the board param data and put them in the gBoardParam struct
//
int getBoardParam(void)
{
    NVRAM_DATA nvramData;
    char *ptr;
    char tmp[10];
    int ret = 0;

    if (g_numBoardIdNames == 0)
        g_numBoardIdNames = BpGetBoardIds(g_boardIdNames, MAX_BOARD_ID_NAMES);

    ptr = strchr(gBoardParam[PARAM_IDX_BOARD_NAME].promptName, '#');
    if (ptr != NULL) {
        sprintf(tmp, "%d)", g_numBoardIdNames - 1);
        memcpy(ptr, tmp, strlen(tmp));
    }

    readNvramData(&nvramData);

    if(!gGponParamsInitialized) {
        gGponParamsInitialized = gponParamsInitialized(&nvramData);
    }

    /*WPS Device Pin Initialized?*/
    if(!gWpsDevicePinInitialized) {
        gWpsDevicePinInitialized = gWpsDevicePinParamsInitialized(&nvramData);
    }

    if (nvramData.ulVersion == -1) {
        // Set default values
        nvramData.ulVersion = NVRAM_VERSION_NUMBER;
        nvramData.szBoardId[0] = '\0';
        nvramData.ulNumMacAddrs = DEFAULT_MAC_NUM;
        parsehwaddr(DEFAULT_BOARD_MAC, nvramData.ucaBaseMacAddr);
        nvramData.ulMainTpNum = DEFAULT_TP_NUM;
        nvramData.szVoiceBoardId[0] = '\0';
        nvramData.ulPsiSize = DEFAULT_PSI_SIZE;
        nvramData.backupPsi = 0;
        nvramData.ulSyslogSize = 0;
        writeNvramData(&nvramData);
    }
    else if (nvramData.ulVersion != NVRAM_VERSION_NUMBER) {
        // When upgrading from older bootloader initialize new fields
        printf("*** Upgrading NVRAM (version %d to version %d) ***\n\n",
               nvramData.ulVersion, NVRAM_VERSION_NUMBER);
        nvramData.ulVersion = NVRAM_VERSION_NUMBER;
        if (nvramData.ulMainTpNum == -1)
            nvramData.ulMainTpNum = DEFAULT_TP_NUM;
        if ((nvramData.ulPsiSize == -1) || (nvramData.ulPsiSize == 0))
            nvramData.ulPsiSize = DEFAULT_PSI_SIZE;
        nvramData.szVoiceBoardId[0] = '\0';
        if (nvramData.backupPsi == -1)
           nvramData.backupPsi = 0;
        if (nvramData.ulSyslogSize == -1)
           nvramData.ulSyslogSize = 0;
        writeNvramData(&nvramData);
        ret = 1;
    }

    gVoiceParamsInitialized = voiceParamsInitialized(&nvramData);

    // When backupPsi and syslog were introduced, the NVRAM version number
    // was not bumped up.  So convert -1 (unitialized) to 0 so it looks better.
    if (nvramData.backupPsi == -1)
       nvramData.backupPsi = 0;
    if (nvramData.ulSyslogSize == -1)
       nvramData.ulSyslogSize = 0;
    
    strcpy(gBoardParam[PARAM_IDX_BOARD_NAME].parameter, nvramData.szBoardId);
    sprintf(gBoardParam[PARAM_IDX_NUM_MAC_ADDR].parameter, "%d", nvramData.ulNumMacAddrs);
    macNumToStr(nvramData.ucaBaseMacAddr, gBoardParam[PARAM_IDX_BASE_MAC_ADDR].parameter);  
    sprintf(gBoardParam[PARAM_IDX_PSI_SIZE].parameter, "%d", nvramData.ulPsiSize);
    sprintf(gBoardParam[PARAM_IDX_ENABLE_BACKUP_PSI].parameter, "%d", nvramData.backupPsi);
    sprintf(gBoardParam[PARAM_IDX_SYSLOG_SIZE].parameter, "%d", nvramData.ulSyslogSize);
    sprintf(gBoardParam[PARAM_IDX_MAIN_THREAD_NUM].parameter, "%d", nvramData.ulMainTpNum);

    return ret;
}

/* Bob added start to set default board parameters, 11/01/2010 */
int setDefaultBoardParam(void)
{
    NVRAM_DATA nvramData;
    int ret = 0;

    if (getBoardParam()) {
        /* New NVRAM version */
        return ret;
    }

    readNvramData(&nvramData);

    {
        // At least one field was changed
        nvramData.ulVersion = NVRAM_VERSION_NUMBER;
        strcpy(nvramData.szBoardId, "963281TAN");
        strcpy(nvramData.szFirmwareUpgradeBoardId, FOXCONN_BOARD_ID);
        nvramData.ulNumMacAddrs = 10;
        parsehwaddr("00:00:00:00:00:01", nvramData.ucaBaseMacAddr);
        nvramData.ulPsiSize = 24;
        nvramData.backupPsi = 0;
        nvramData.ulSyslogSize = 0;
        nvramData.ulMainTpNum = 0;

        // save the buf to nvram
        writeNvramData(&nvramData);
        ret = 1;
    }

    return ret;
}
/* Bob added end to set default board parameters, 11/01/2010 */

//
// setBoardParam: Set the board Id string, mac addresses, psi size, etc...
//
int setBoardParam(void)
{
    char boardIdPrompt[1000];
    NVRAM_DATA nvramData;
    int i;
    char tmp[3];
    char *boardIdPromptPtr, *savedBoardIdPromptPtr;
    int ret = 0;

    if (getBoardParam()) {
        /* New NVRAM version */
        return ret;
    }

    readNvramData(&nvramData);

    // Create prompt string with board ID name selection
    boardIdPromptPtr = boardIdPrompt;
    for (i = 0; i < g_numBoardIdNames; i++) {
        sprintf (tmp, "%d", i);
        sprintf (boardIdPromptPtr, "%-17s------- %2s\n", &g_boardIdNames[i * BP_BOARD_ID_LEN], tmp);
        boardIdPromptPtr += strlen(boardIdPromptPtr);
    }
    strcpy (boardIdPromptPtr, gBoardParam[PARAM_IDX_BOARD_NAME].promptName);

    // Save existing prompt string
    savedBoardIdPromptPtr = gBoardParam[PARAM_IDX_BOARD_NAME].promptName;
    // Set newly created prompt string
    gBoardParam[PARAM_IDX_BOARD_NAME].promptName = boardIdPrompt;

    // Convert board ID string to numeric value
    for (i = 0; i < g_numBoardIdNames; i++) {
        if (!strcmp(gBoardParam[PARAM_IDX_BOARD_NAME].parameter, &g_boardIdNames[i * BP_BOARD_ID_LEN])) {
            sprintf(gBoardParam[PARAM_IDX_BOARD_NAME].parameter, "%d", i);
        }
    }

    if (processPrompt(gBoardParam, gNumBoardParams)) {
        // At least one field was changed
        nvramData.ulVersion = NVRAM_VERSION_NUMBER;

        // Convert numeric value of board ID to string
        i = atoi(gBoardParam[PARAM_IDX_BOARD_NAME].parameter);
        strcpy(nvramData.szBoardId, &g_boardIdNames[i * BP_BOARD_ID_LEN]);

        nvramData.ulNumMacAddrs = atoi(gBoardParam[PARAM_IDX_NUM_MAC_ADDR].parameter);
        parsehwaddr(gBoardParam[PARAM_IDX_BASE_MAC_ADDR].parameter, nvramData.ucaBaseMacAddr);
        nvramData.ulPsiSize = atoi(gBoardParam[PARAM_IDX_PSI_SIZE].parameter);
        nvramData.backupPsi = atoi(gBoardParam[PARAM_IDX_ENABLE_BACKUP_PSI].parameter);
        nvramData.ulSyslogSize = atoi(gBoardParam[PARAM_IDX_SYSLOG_SIZE].parameter);
        nvramData.ulMainTpNum = atoi(gBoardParam[PARAM_IDX_MAIN_THREAD_NUM].parameter);

        // save the buf to nvram
        writeNvramData(&nvramData);
        ret = 1;
    }

    // restore gBoardParam
    // Convert numeric value of board ID to string
    gBoardParam[PARAM_IDX_BOARD_NAME].promptName = savedBoardIdPromptPtr;
    i = atoi(gBoardParam[PARAM_IDX_BOARD_NAME].parameter);
    strcpy(gBoardParam[PARAM_IDX_BOARD_NAME].parameter, &g_boardIdNames[i * BP_BOARD_ID_LEN]);

    if(gGponParamsInitialized) {
        printf("\n");
        ret += setGponBoardParam();
    }

    if(gWpsDevicePinInitialized) {
        printf("\n");
        ret += setWpsDevicePinBoardParam();
    }

    gVoiceParamsInitialized = voiceParamsInitialized(&nvramData);

    if(gVoiceParamsInitialized) {
        printf("\n");
        ret += setVoiceBoardParam();
    }

    return ret;
}

void displayBoardParam(void)
{
    int i;

    getBoardParam();

    for (i = 0; i < gNumBoardParams; i++) {
        if( gBoardParam[i].enabled )
            printf("%s %s  \n", gBoardParam[i].promptName, gBoardParam[i].parameter);
    }

    if(gGponParamsInitialized) {
        getGponBoardParam();

        for (i = 0; i < gNumGponBoardParams; i++)
            if( gGponBoardParam[i].enabled )
                printf("%s \"%s\"  \n", gGponBoardParam[i].promptName, gGponBoardParam[i].parameter);
    }

    /*Show WPS Device PIN */
    if(gWpsDevicePinInitialized) {
        getWpsDevicePinBoardParam();
    if ( gWpsDevicePinBoardParam[PARAM_IDX_WPS_DEVICE_PIN].enabled) 
         printf("%s \"%s\"  \n", gWpsDevicePinBoardParam[PARAM_IDX_WPS_DEVICE_PIN].promptName,  \
                                            gWpsDevicePinBoardParam[PARAM_IDX_WPS_DEVICE_PIN].parameter);
    }

    if(gVoiceParamsInitialized) {
        getVoiceBoardParam();

        for (i = 0; i < gNumVoiceBoardParams; i++)
            if( gVoiceBoardParam[i].enabled )
                printf("%s %s  \n", gVoiceBoardParam[i].promptName, gVoiceBoardParam[i].parameter);
    }
}