sysenv.c

MIPS下的boottloader yamon 的源代码

            pb       = SYSENV_write_buffer ;
            pdata    = var->data_inout ;
            checksum = 0 ;
            for (i=0; i<var->size; i++)
            {
                checksum += pdata[i] ;
            }
            REGP(pb,SYSENV_HEADER) = REGPWRI(pb,SYSENV_HEADER,CONTROL,SYSENV_RECORD_IN_USE) ;
            REGP(pb,SYSENV_HEADER) = REGPWRI(pb,SYSENV_HEADER,ID,var->index) ;
            REGP(pb,SYSENV_HEADER) = REGPWRI(pb,SYSENV_HEADER,CHKSUM,checksum) ;
            REGP(pb,SYSENV_HEADER) = REGPWRI(pb,SYSENV_HEADER,SIZE,var->size) ;
            memcpy( &SYSENV_write_buffer[ SYSENV_HEADER_SIZE ], var->data_inout , var->size ) ;

            /* get pointer to file flash record */
            pb = SYSENV_file_flash_start + (SYSENV_next_free * sizeof(t_SYSENV_elem)) ;
            
            /* store record in file flash */
            flash_write.adr     = PHYS((UINT32)pb) ;
            flash_write.length  = var->size + SYSENV_HEADER_SIZE ;
            flash_write.buffer  = SYSENV_write_buffer ;
            flash_ctrl.command  = FLASH_CTRL_WRITE_FILEFLASH ;
            flash_ctrl.wr_param = &flash_write ;

            rcode = IO_ctrl( SYS_MAJOR_FLASH_STRATA, 0, &flash_ctrl ) ;
            if (rcode != OK)
            {
				printf("Flash write error");
				SYSENV_state = SYSENV_STATE_ERROR ;
                return(rcode) ;
            }

            /* update lookup table */
            SYSENV_lookup[ var->index ].flash_record = pb ; 

            /* update user reference */
            var->data_inout = (void*)&(REGP(pb,SYSENV_HEADER_SIZE)) ;

            /* Paranoid checking.. */
            rcode = SYSENV_check_inuse_record( pb, REGPRD(pb,SYSENV_HEADER,ID) ) ;
            if (rcode != OK)
			{
				printf("error in check inuse");
                return(rcode) ;
            }

            /* advance to next free record in file flash */
            SYSENV_next_free++ ;

            rcode = completion ;
        }
        else
        {
            /* Size is too big */
            rcode = ERROR_SYSENV_ENV_VAR_TOO_BIG ;
        }
    }
    else
    {
        /* Index is out of valid range */
        rcode = ERROR_SYSENV_INVALID_INDEX ;
    }
    return( rcode ) ;
}


/************************************************************************
 *      Implementation : Static functions
 ************************************************************************/


/************************************************************************
 *
 *                          SYSENV_collect_garbage
 *  Description :
 *  -------------
 *
 *  Execute garbage collection.
 *
 *
 *
 *
 *  Parameters :
 *  ------------
 *
 *  -
 *
 *
 *  Return values :
 *  ---------------
 *
 *  'ERROR_SYSENV_UPDATE_READ_REFS', all references for env variables 
                                     must be re-read.
 *
 ************************************************************************/
static INT32 SYSENV_collect_garbage( void )
{
    int            i ;
    INT32          rcode ;
    t_SYSENV_elem *pf ;
    t_SYSENV_elem *pr ;
    t_FLASH_ctrl_descriptor  flash_ctrl ;
    t_FLASH_write_descriptor flash_write ;


    /* cache any variable in RAM */
    for ( i = 0; i <= SYS_USER_ENVIRONMENT_MAX_INDEX ;  i++ )
    {
        if ( SYSENV_lookup[ i ].flash_record != NULL )
        {
            /* copy flash data to RAM */
            pf = SYSENV_lookup[ i ].flash_record ;
            memcpy( SYSENV_lookup[ i ].ram_record,
                    SYSENV_lookup[ i ].flash_record, 
                    REGPRD(pf,SYSENV_HEADER,SIZE) + SYSENV_HEADER_SIZE ) ;

            /* delete reference */
            SYSENV_lookup[i].flash_record = NULL ;
        }
        else
        {
            /* set size to '0' to delete record */
            pr = SYSENV_lookup[ i ].ram_record ;
            REGP(pr,SYSENV_HEADER) = REGPWRI(pr,SYSENV_HEADER,SIZE,0) ;
        }
    }

    /* delete file flash */
    flash_ctrl.command = FLASH_CTRL_ERASE_FILEFLASH ;
    rcode = IO_ctrl( SYS_MAJOR_FLASH_STRATA, 0, &flash_ctrl ) ;
    if (rcode != OK)
    {
        return(rcode) ;
    }

    /* reset context */
    SYSENV_next_free = 0 ;

    /* copy cached data back into flash */
    for ( i = 0; i <= SYS_USER_ENVIRONMENT_MAX_INDEX ;  i++ )
    {
        pr = SYSENV_lookup[ i ].ram_record ;
        if (REGPRD(pr,SYSENV_HEADER,SIZE) != 0)
        {
            /* store cached data in flash */
            pf = SYSENV_file_flash_start + (SYSENV_next_free * sizeof(t_SYSENV_elem)) ;
            pr = SYSENV_lookup[ i ].ram_record ;
            flash_write.adr     = PHYS((UINT32)pf) ;
            flash_write.length  = REGPRD(pr,SYSENV_HEADER,SIZE) + SYSENV_HEADER_SIZE ;
            flash_write.buffer  = (UINT8*)&REGP(pr,SYSENV_HEADER) ;
            flash_ctrl.command  = FLASH_CTRL_WRITE_FILEFLASH ;
            flash_ctrl.wr_param = &flash_write ;
            rcode = IO_ctrl( SYS_MAJOR_FLASH_STRATA, 0, &flash_ctrl ) ;
            if (rcode != OK)
            {
                return(rcode) ;
            }

            /* update reference */
            SYSENV_lookup[i].flash_record = pf ;

            /* advance to next free record in file flash */
            SYSENV_next_free++ ;
        }
        else
        {
            /* update reference */
            SYSENV_lookup[i].flash_record = NULL ;
        }
    }
    return(ERROR_SYSENV_UPDATE_READ_REFS) ;
}


/************************************************************************
 *
 *                          SYSENV_error_lookup
 *  Description :
 *  -------------
 *  Lookup error code to error string(s)
 * 
 *
 *  Parameters :
 *  ------------
 *
 *  'p_param',   INOUT,    variable of type, t_sys_error_string.
 *
 *
 *  Return values :
 *  ---------------
 *
 * 'OK' = 0x00: 
 *
 *
 ************************************************************************/
static
INT32 SYSENV_error_lookup( t_sys_error_string *p_param )
{
    UINT32 t, i ;

    i = 0 ;
    p_param->count = 0 ;
    t = SYSERROR_ID( p_param->syserror ) ;

    /* check for recognized error code */
    if (t < sizeof(sysenv_error_string)/sizeof(char*) )
    {
        /* fill in mandatory error message string */
        p_param->strings[SYSCON_ERRORMSG_IDX] = sysenv_error_string[t] ;
        i++ ;

        /* check for hint message */
        if ( sysenv_error_hint_string[t] != NULL)
        {
            /* fill in optional hint message string */
            p_param->strings[SYSCON_HINTMSG_IDX] = sysenv_error_hint_string[t] ;
            i++ ;
        }
    }
    p_param->count      = i ;
    return(OK) ;
}


/************************************************************************
 *
 *                          SYSENV_check_inuse_record
 *  Description :
 *  -------------
 *  Check referenced record
 * 
 *
 *  Parameters :
 *  ------------
 *
 *  'pb',      INOUT,    environment flash record.
 *  'index',   INOUT,    environment flash record index.
 *
 *
 *  Return values :
 *  ---------------
 *
 * 'ERROR_SYSENV_FLASH_INVALID':  Environment is corrupted.
 * 'OK' = 0x00: 
 *
 *
 ************************************************************************/
static
INT32 SYSENV_check_inuse_record( UINT8 *ph, UINT8 index )
{
    int    i ;
    UINT32 size     ; 
    UINT8  checksum ;
    UINT8  *pb ;

    /* check control */
    if ( REGPRD(ph,SYSENV_HEADER,CONTROL) == SYSENV_RECORD_IN_USE )
    { 
        /* check index */
        if ( REGPRD(ph,SYSENV_HEADER,ID) == index )
        {
            /* check size: */
            size = REGPRD(ph,SYSENV_HEADER,SIZE) ;
            pb   = ph + SYSENV_HEADER_SIZE  ;
            if ( size <= SYS_USER_ENVIRONMENT_DATA_SIZE )
            {
                /* calculate checksum */
                checksum = 0 ;
                // printf("%s\n", pb ) ;
                for (i=0; i<size; i++)
                {
                    switch (i%4)
                    {
                        case 0: checksum += REGPRD(pb,SYSENV_DATA,BYTE0) ;
                                // printf("%c ", REGPRD(pb,SYSENV_DATA,BYTE0) ) ;
                        break;
                        case 1: checksum += REGPRD(pb,SYSENV_DATA,BYTE1) ;
                                // printf("%c ", REGPRD(pb,SYSENV_DATA,BYTE1) ) ;
                        break;
                        case 2: checksum += REGPRD(pb,SYSENV_DATA,BYTE2) ;
                                // printf("%c ", REGPRD(pb,SYSENV_DATA,BYTE2) ) ;
                        break;
                        case 3: checksum += REGPRD(pb,SYSENV_DATA,BYTE3) ;
                                // printf("%c ", REGPRD(pb,SYSENV_DATA,BYTE3) ) ;
                                pb        = pb + 4 ;
                        break;
                        default:
                        break;
                    }
                }

                 //printf("\n") ;
                /* check checksum */
                if ( checksum == REGPRD(ph,SYSENV_HEADER,CHKSUM) )
                {
                    /* OK, header is valid */
                    return( OK ) ;
                }
                // printf("SYSENV_check_inuse_record: calculated checksum = %d\n", checksum ) ;
                // printf("SYSENV_check_inuse_record: read checksum = %d\n", REGPRD(ph,SYSENV_HEADER,CHKSUM) ) ;
            }
        }
    }

    /* This is an error, file FLASH is corrupted ! */

    /* Set SYSENV state = 'ERROR' */

    SYSENV_state = SYSENV_STATE_ERROR ;

    // printf("WARNING: environment variable FLASH area is invalid !!\n") ;
    return( ERROR_SYSENV_FLASH_INVALID ) ;
}