drv_loadctrl.c

motorola mpc系列 mpc852cpu bsp

    		return (LoadCtrl_SetDefaultParam());
    	}
		Drv_Print("\r\nBoot data recover successed!");

    }
    else
    {
    	(void)LoadCtrl_BootDataBackup();
    }
    strcpy(ParamInfo.BootDirection,gBootInfo.BootDirc);
    strcpy(ParamInfo.LoadFileName,gBootInfo.LoadFileName);
    sysIpToStr(gBootInfo.HostIp, ParamInfo.HostIpAddr);
#if 0
#if ( DEV_TYPE == DEV_AG )
    sysIpToStr(gBootInfo.InnerIp,ParamInfo.InnerIpAddr);
#endif
    sysMacToStr(gBootInfo.InnerMac,ParamInfo.InnerMacAddr);
#endif
    sysIpToStr(gBootInfo.OuterGateAddr,ParamInfo.OuterGateAddr);
    sysIpToStr(gBootInfo.OuterIp,ParamInfo.OuterIpAddr);
    sysIpToStr(gBootInfo.OuterIpMask,ParamInfo.OuterIpMask);
    sysMacToStr(gBootInfo.OuterMac,ParamInfo.OuterMacAddr);

    BootLine[0] = 0;
    strcat(BootLine,"motfec(0,0)");
    strcat(BootLine,":");
    strcat(BootLine,ParamInfo.BootDirection);
    strcat(BootLine," h=");
    strcat(BootLine,ParamInfo.HostIpAddr);
    strcat(BootLine," e=");
    strcat(BootLine,ParamInfo.OuterIpAddr);
    strcat(BootLine," u=ap pw=ap o=motfec");
    Drv_Print("\r\n sizeof bootline : %d \r\n %s",strlen(BootLine),BootLine);
  
    return SUCCESS;

}

void LoadCtrl_DisplayBootParam(BootInfoString *pParamInfo)
{

    Drv_Print("\r\n\r\nBoot Param:");
    Drv_Print("\r\nOuter IP         :%s",pParamInfo->OuterIpAddr);
    Drv_Print("\r\nOuter MASK       :%s",pParamInfo->OuterIpMask);
    Drv_Print("\r\nOuter GateWay    :%s",pParamInfo->OuterGateAddr);
    Drv_Print("\r\nOuter Mac        :%s",pParamInfo->OuterMacAddr);
#if 0
#if ( DEV_TYPE == DEV_AG )
    Drv_Print("\r\nInner IP         :%s",pParamInfo->InnerIpAddr);
#endif
    Drv_Print("\r\nInner Mac        :%s",pParamInfo->InnerMacAddr);
#endif
    Drv_Print("\r\nHost IP          :%s",pParamInfo->HostIpAddr);
    Drv_Print("\r\nImage File       :%s",pParamInfo->BootDirection);
    Drv_Print("\r\nLoad App FileName:%s",pParamInfo->LoadFileName);
}

_U32 LoadCtrl_SaveParam(void)
{

    if (isModifyParam)
    {
    	Drv_Print("\r\nSaving parameter...");
/*        memset((void *)&gBootInfo,0x0,sizeof(BootInfo));*/
        gBootInfo.BootDircState      = DRV_BOOTINFO_MODEFIED;
        gBootInfo.LoadFileNameState  = DRV_BOOTINFO_MODEFIED;
        gBootInfo.InnerIpState       = DRV_BOOTINFO_MODEFIED;
        gBootInfo.InnerMacState      = DRV_BOOTINFO_MODEFIED;
        gBootInfo.OuterGateAddrState = DRV_BOOTINFO_MODEFIED;
        gBootInfo.OuterIpMaskState   = DRV_BOOTINFO_MODEFIED;
        gBootInfo.OuterIpState       = DRV_BOOTINFO_MODEFIED;
        gBootInfo.OuterMacState      = DRV_BOOTINFO_MODEFIED;
        gBootInfo.HostIpState        = DRV_BOOTINFO_MODEFIED;

        BootLine[0] = 0;
        strcat(BootLine,"motfec(0,0)");
        strcat(BootLine,":");
        strcat(BootLine,ReadParamInfo.BootDirection);
        strcat(BootLine," h=");
        strcat(BootLine,ReadParamInfo.HostIpAddr);
        strcat(BootLine," e=");
        strcat(BootLine,ReadParamInfo.OuterIpAddr);
        strcat(BootLine," u=ap pw=ap o=motfec");

        strcpy(gBootInfo.BootDirc,ReadParamInfo.BootDirection);
        strcpy(gBootInfo.LoadFileName,ReadParamInfo.LoadFileName);


#if 0
#if ( DEV_TYPE == DEV_AG )
        gBootInfo.InnerIp = sysStrToIp(ReadParamInfo.InnerIpAddr);
        if (0 == gBootInfo.InnerIp)
        {
            Drv_Print("\r\nInner Ip Input Error!");
            return FAILURE;
        }

#endif
        if (FAILURE == sysStrToMac(ReadParamInfo.InnerMacAddr,gBootInfo.InnerMac))
        {
            Drv_Print("\r\nInner Mac Input Error!");
            return FAILURE;
        }
#endif
        gBootInfo.OuterIp = sysStrToIp(ReadParamInfo.OuterIpAddr);
        if (0 == gBootInfo.OuterIp)
        {
            Drv_Print("\r\nOuter Ip Input Error!");
            return FAILURE;
        }

        gBootInfo.OuterIpMask = sysStrToIp(ReadParamInfo.OuterIpMask);
        if (0 == gBootInfo.OuterIpMask)
        {
            Drv_Print("\r\nOuter Ip Mask Input Error!");
            return FAILURE;
        }

        gBootInfo.OuterGateAddr = sysStrToIp(ReadParamInfo.OuterGateAddr);
        if (0 == gBootInfo.OuterGateAddr)
        {
            Drv_Print("\r\nOuter Gate Ip Input Error!");
            return FAILURE;
        }

        if (FAILURE == sysStrToMac(ReadParamInfo.OuterMacAddr,gBootInfo.OuterMac))
        {
            Drv_Print("\r\nOuter Mac Input Error!");
            return FAILURE;
        }
        if ((0xff == gBootInfo.OuterMac[0])||(0x01 == (gBootInfo.OuterMac[0]&0x01)))
        {
            Drv_Print("\r\nOuter Mac is BroadCase Mac or MultiCase Mac Error!");
            return FAILURE;
        }

        gBootInfo.HostIp = sysStrToIp(ReadParamInfo.HostIpAddr);
        if (0 == gBootInfo.HostIp)
        {
            Drv_Print("\r\nHost Ip Input Error!");
            return FAILURE;
        }

        gBootInfo.InfoCrc = CalcCrc((_U8 *)&gBootInfo, sizeof(BootInfo) - 4);

        if (SUCCESS != Drv_WriteFlash(BOOT_INFO_IN_FLASH, sizeof(BootInfo), (_U32)&gBootInfo))
        {
            Drv_Print("fail!");
            return FAILURE;
        }
        if (SUCCESS != Drv_WriteFlash(BOOT_INFO_IN_FLASH_BACK, sizeof(BootInfo), (_U32)&gBootInfo))
        {
            Drv_Print("fail!");
            return FAILURE;
        }
        Drv_Print("done!");
    }
    return SUCCESS;
}

void LoadCtrl_ReadFlush(void)
{

    unsigned char data;
    unsigned long rv;
    for(;;)
    {
        InChar(&data,&rv);
        if(rv != SUCCESS)
            return;
    }
}


void LoadCtrl_ReadParam()
{
    /*Begin Set Params*/
    for(;;)
    {
        Drv_Print("\r\nOuter IP[%s]:\r\n",ParamInfo.OuterIpAddr);
        LoadCtrl_ReadFlush();
        LoadCtrl_Receive(ReadParamInfo.OuterIpAddr, IP_ADDR_SIZE);
        if (strcmp(ReadParamInfo.OuterIpAddr,"")==0)
        {
            strcpy(ReadParamInfo.OuterIpAddr,ParamInfo.OuterIpAddr);
        }
        if (SUCCESS == sysVerifyHostIPAddress(ReadParamInfo.OuterIpAddr))
        {
            break;
        }
        else
        {
            Drv_Print("\r\nOuter ip address input error:%s!",ReadParamInfo.OuterIpAddr);
        }
    }

    for(;;)
    {
        Drv_Print("\r\nOuter MASK[%s]:\r\n",ParamInfo.OuterIpMask);
        LoadCtrl_ReadFlush();
        LoadCtrl_Receive(ReadParamInfo.OuterIpMask, IP_ADDR_SIZE);
        if (strcmp(ReadParamInfo.OuterIpMask,"")==0)
        {
            strcpy(ReadParamInfo.OuterIpMask,ParamInfo.OuterIpMask);
        }
        if (SUCCESS == sysVerifyMASKAddress(ReadParamInfo.OuterIpMask))
        {
            break;
        }
        else
        {
            Drv_Print("\r\nOuter mask address input error:%s!",ReadParamInfo.OuterIpMask);
        }
    }

    for(;;)
    {
        Drv_Print("\r\nOuter GATEWAY[%s]:\r\n",ParamInfo.OuterGateAddr);
        LoadCtrl_ReadFlush();
        LoadCtrl_Receive(ReadParamInfo.OuterGateAddr, IP_ADDR_SIZE);
        if (strcmp(ReadParamInfo.OuterGateAddr,"")==0)
        {
            strcpy(ReadParamInfo.OuterGateAddr,ParamInfo.OuterGateAddr);
        }
        if (SUCCESS == sysVerifyHostIPAddress(ReadParamInfo.OuterGateAddr))
        {
            break;
        }
        else
        {
            Drv_Print("\r\nOuter gate address input error:%s!",ReadParamInfo.OuterGateAddr);
        }
    }

    for(;;)
    {
        Drv_Print("\r\nOuter MAC[%s]:\r\n",ParamInfo.OuterMacAddr);
        LoadCtrl_ReadFlush();
        LoadCtrl_Receive(ReadParamInfo.OuterMacAddr, MAC_STR_ADDR_SIZE);
        if (strcmp(ReadParamInfo.OuterMacAddr,"")==0)
        {
            strcpy(ReadParamInfo.OuterMacAddr,ParamInfo.OuterMacAddr);
        }
        if (SUCCESS == sysVerifyMACAddress(ReadParamInfo.OuterMacAddr))
        {
            break;
        }
        else
        {
            Drv_Print("\r\nOuter Mac address input error:%s!",ReadParamInfo.OuterMacAddr);
        }
    }
#if 0
#if ( DEV_TYPE == DEV_AG )
    for(;;)
    {
        Drv_Print("\r\nInner IP[%s]:\r\n",ParamInfo.InnerIpAddr);
        LoadCtrl_ReadFlush();
        LoadCtrl_Receive(ReadParamInfo.InnerIpAddr, IP_ADDR_SIZE);
        if (strcmp(ReadParamInfo.InnerIpAddr,"")==0)
        {
            strcpy(ReadParamInfo.InnerIpAddr,ParamInfo.InnerIpAddr);
        }
        if (SUCCESS == sysVerifyHostIPAddress(ReadParamInfo.InnerIpAddr))
        {
            break;
        }
        else
        {
            Drv_Print("\r\nInner ip address input error:%s!",ReadParamInfo.InnerIpAddr);
        }
    }
#endif
    for(;;)
    {
        Drv_Print("\r\nInner MAC[%s]:\r\n",ParamInfo.InnerMacAddr);
        LoadCtrl_ReadFlush();
        LoadCtrl_Receive(ReadParamInfo.InnerMacAddr, MAC_STR_ADDR_SIZE);
        if (strcmp(ReadParamInfo.InnerMacAddr,"")==0)
        {
            strcpy(ReadParamInfo.InnerMacAddr,ParamInfo.InnerMacAddr);
        }
        if (SUCCESS == sysVerifyMACAddress(ReadParamInfo.InnerMacAddr))
        {
            break;
        }
        else
        {
            Drv_Print("\r\nInner mac address input error:%s!",ReadParamInfo.InnerMacAddr);
        }

    }
#endif
    for(;;)
    {
        Drv_Print("\r\nHost IP[%s]:\r\n",ParamInfo.HostIpAddr);
        LoadCtrl_ReadFlush();
        LoadCtrl_Receive(ReadParamInfo.HostIpAddr, IP_ADDR_SIZE);
        if (strcmp(ReadParamInfo.HostIpAddr,"")==0)
        {
            strcpy(ReadParamInfo.HostIpAddr,ParamInfo.HostIpAddr);
        }
        if (SUCCESS == sysVerifyHostIPAddress(ReadParamInfo.HostIpAddr))
        {
            break;
        }
        else
        {
            Drv_Print("\r\nHost ip address input error:%s!",ReadParamInfo.HostIpAddr);
        }

    }


    Drv_Print("\r\nImage File[%s]:\r\n",ParamInfo.BootDirection);
    LoadCtrl_ReadFlush();
    LoadCtrl_Receive(ReadParamInfo.BootDirection, BOOT_DIRC_SIZE);
    if (strcmp(ReadParamInfo.BootDirection,"")==0)
        strcpy(ReadParamInfo.BootDirection,ParamInfo.BootDirection);

    Drv_Print("\r\nLoad App FileName[%s]:\r\n",ParamInfo.LoadFileName);
    LoadCtrl_ReadFlush();
    LoadCtrl_Receive(ReadParamInfo.LoadFileName, TFTP_LOADNAME_SIZE);
    if (strcmp(ReadParamInfo.LoadFileName,"")==0)
        strcpy(ReadParamInfo.LoadFileName,ParamInfo.LoadFileName);


    LoadCtrl_DisplayBootParam(&ReadParamInfo);

}


void LoadCtrl_SetParam(void)
{
    _U32 rv;
    unsigned char data;
    _U8 InputTime;

    if (LoadCtrl_GetBootParam() != SUCCESS)
    {
        Drv_Print("\r\nNo Boot Param in Flash, Use Default Param!\r\n");
    }

Param_ReInput:

    LoadCtrl_DisplayBootParam(&ParamInfo);

    LoadCtrl_ReadFlush();

    while(1)
    {
        Drv_Print("\r\n\r\nDo You Want to Modify Boot Param(Y/N)?...");
DrvLC_Reselect:
        g_DecTimer = SELECT_DELAY;/*硬件定时器*/
        InputTime = 0;
        for(;;)
        {
            /* wait for press any key */
            /* if user don't press any key in 2 seconds, just boot from flash */

            if(!g_DecTimer)
            {
                if( LoadCtrl_SaveParam() == FAILURE )
                {
                    memcpy(&ParamInfo,&ReadParamInfo,sizeof(BootInfoString));
                    goto Param_ReInput;
                }
                return;
            }

            InChar(&data,&rv);
            if(rv != SUCCESS)
                continue;

            switch(data)
            {
                case 'N':
                case 'n':
                	Drv_SmcPutChar(VPL_SERIAL,0, data);
                    if (FAILURE == LoadCtrl_SaveParam())
                    {
                        memcpy(&ParamInfo,&ReadParamInfo,sizeof(BootInfoString));
                        goto Param_ReInput;
                    }
                    return;

                case 'Y':
                case 'y':
                	Drv_SmcPutChar(VPL_SERIAL,0, data);
                    LoadCtrl_ClearBootInfo(&ReadParamInfo);
                    isModifyParam = 1;
                    LoadCtrl_ReadParam();
                    Drv_Print("\r\n\r\nReModify Boot Param(Y/N)?...");
                    goto DrvLC_Reselect;
                default:
                    InputTime++;
                    if(InputTime > 3)
                    {
                        if (FAILURE == LoadCtrl_SaveParam())
                        {
                            memcpy(&ParamInfo,&ReadParamInfo,sizeof(BootInfoString));
                            goto Param_ReInput;
                        }
                        return;
                    }

                    Drv_Print("\r\n\r\nJust press <Y> or <N> ...");
                    g_DecTimer = SELECT_DELAY;
                    continue;
            }
        }
    }
}