flash_amd.c

MIPS下的boottloader yamon 的源代码

static
INT32 FLASH_AMD_init(
                     UINT32 major,          /* IN: major device number             */
                     UINT32 minor,          /* IN: minor device number             */
                     void   *p_param )      /* INOUT: device parameter block       */
{
    int rcode ;
    UINT32 *pt;

//    printf("AMD Flash INIT.\n");

    /* initialize system profile: FLASH, address boundaries */

    /* Update with latest boot phys end */

    /* MIPS BOOT: */
    boot_phys_start = MIPS_RESET_VECTOR ;
    boot_phys_end   = 0x20000000 ; /* TBD: This size may change for future
        board support packages       */

    /* SYSTEM FLASH: */
    /* get base for system flash  */
    rcode = SYSCON_read( SYSCON_BOARD_SYSTEMFLASH_BASE_ID,
                         &systemflash_phys_start,
                         sizeof(systemflash_phys_start) ) ;
    if (rcode != OK)
    {
        systemflash_phys_start = 0 ;
    }
    systemflash_phys_start = PHYS(systemflash_phys_start) ;

    /* get size for system flash  */
    rcode = SYSCON_read( SYSCON_BOARD_SYSTEMFLASH_SIZE_ID,
                         &systemflash_phys_end,
                         sizeof(systemflash_phys_end) ) ;
    if (rcode != OK)
    {
        systemflash_phys_end = 0 ;
    }
    systemflash_phys_end = systemflash_phys_start + systemflash_phys_end - 1;


    /* MONITOR FLASH: */
    /* get base for monitor flash  */
    rcode = SYSCON_read( SYSCON_BOARD_MONITORFLASH_BASE_ID,
                         &monitorflash_phys_start,
                         sizeof(monitorflash_phys_start) ) ;
    if (rcode != OK)
    {
        monitorflash_phys_start = 0 ;
    }
    monitorflash_phys_start = PHYS(monitorflash_phys_start) ;

    /* get size for monitor flash  */
    rcode = SYSCON_read( SYSCON_BOARD_MONITORFLASH_SIZE_ID,
                         &monitorflash_phys_end,
                         sizeof(monitorflash_phys_end) ) ;
    if (rcode != OK)
    {
        monitorflash_phys_end = 0 ;
    }
    monitorflash_phys_end = monitorflash_phys_start + monitorflash_phys_end - 1;

    /* FILE FLASH: */
    /* get base for file flash  */
    rcode = SYSCON_read( SYSCON_BOARD_FILEFLASH_BASE_ID,
                         &fileflash_phys_start,
                         sizeof(fileflash_phys_start) ) ;
    if (rcode != OK)
    {
        fileflash_phys_start = 0 ;
    }
    fileflash_phys_start = PHYS(fileflash_phys_start) ;

    /* get size for file flash  */
    rcode = SYSCON_read( SYSCON_BOARD_FILEFLASH_SIZE_ID,
                         &fileflash_phys_end,
                         sizeof(fileflash_phys_end) ) ;
    if (rcode != OK)
    {
        fileflash_phys_end = 0 ;
    }
    fileflash_phys_end = fileflash_phys_start + fileflash_phys_end - 1;


    /* get system flash sector size */
    rcode = SYSCON_read( SYSCON_BOARD_SYSTEMFLASH_SECTORSIZE_ID,
                         &systemflash_block_size,
                         sizeof(systemflash_block_size) ) ;

    if (rcode != OK)
    {
        systemflash_block_size = 0 ;
    }

    /* get monitor flash sector size */
    rcode = SYSCON_read( SYSCON_BOARD_MONITORFLASH_SECTORSIZE_ID,
                         &monitorflash_block_size,
                         sizeof(monitorflash_block_size) ) ;

    if (rcode != OK)
    {
        monitorflash_block_size = 0 ;
    }

    /* get file flash sector size */
    rcode = SYSCON_read( SYSCON_BOARD_FILEFLASH_SECTORSIZE_ID,
                         &fileflash_block_size,
                         sizeof(fileflash_block_size) ) ;

    if (rcode != OK)
    {
        fileflash_block_size = 0 ;
    }

    /* get system flash bank count */
    rcode = SYSCON_read( SYSCON_BOARD_SYSTEMFLASH_BANKCOUNT_ID,
                         &systemflash_bank_count,
                         sizeof(systemflash_bank_count) ) ;
    if (rcode != OK)
    {
        systemflash_bank_count = 0 ;
    }

    /* get system flash block count */
    rcode = SYSCON_read( SYSCON_BOARD_SYSTEMFLASH_BLOCKCOUNT_ID,
                         &systemflash_block_count,
                         sizeof(systemflash_block_count) ) ;
    if (rcode != OK)
    {
        systemflash_block_count = 0 ;
    }

    pt = (UINT32*) KSEG1(fileflash_phys_start);



    return( OK ) ;
}


/************************************************************************
*
*                          FLASH_AMD_write
*  Description :
*  -------------
*  This service writes data into a specified address location, which
*  can be in either SYSTEM-FLASH or FILE-FLASH space. Default is RAM.
*  
*
*  Parameters :
*  ------------
*
*  'major',     IN,    major device number
*  'minor',     IN,    minor device number for multi device drivers
*  'p_param',   IN,    variable of type, t_FLASH_write_descriptor.
*
*
*  Return values :
*  ---------------
*
* 'OK' = 0x00:                         data has been stored
*  ERROR_FLASH_PROGRAM_ERROR           Flash device failure
*  ERROR_FLASH_INVALID_ADDRESS,        Physical address not impl.    
*
*
************************************************************************/
static
INT32 FLASH_AMD_write(
                      UINT32 major,          /* IN: major device number             */
                      UINT32 minor,          /* IN: minor device number             */
                      t_FLASH_write_descriptor *p_param )   /* IN: write data       */
{
    int rcode = OK ;


    /* set to default */
    flash_diag_msg[0] = 0 ;

    switch (FLASH_AMD_devicetype(PHYS(p_param->adr)))
    {
        case FLASH_SYSTEMFLASH_DEVICE:
            /* program system FLASH */
            if ( FLASH_AMD_is_system_flash_write_protected() )
            {
                rcode = ERROR_FLASH_WRITE_PROTECTED ;
            }
            else
            {
                rcode = FLASH_AMD_program_flash( p_param ) ;

                /* set system flash banks in read array mode */
                FLASH_AMD_set_systemflash_read();
            }
            break ;

        case FLASH_FILEFLASH_DEVICE:


            /* Reject user to program FILE FLASH */
            memset( flash_diag_msg, 0, sizeof(flash_diag_msg) ) ;
            sprintf( flash_diag_msg, "Environment FLASH: map = (0x%08x,0x%08x), user = 0x%08x",
                     (UINT32) fileflash_phys_start,
                     (UINT32) fileflash_phys_end,
                     (UINT32) PHYS(p_param->adr) ) ;
            rcode = ERROR_FLASH_FILE_FLASH_PROT ;

            break ;


        case FLASH_MONITORFLASH_DEVICE:
            /* program monitor FLASH */
            rcode = FLASH_AMD_program_flash( p_param ) ;

            /* set monitor flash in read array mode */
            FLASH_AMD_set_monitorflash_read();
            break ;

        case FLASH_BOOT_DEVICE:
            /* Boot device */
            memset( flash_diag_msg, 0, sizeof(flash_diag_msg) ) ;
            sprintf( flash_diag_msg, "MIPS boot media: map = (0x%08x,0x%08x), user = 0x%08x",
                     (UINT32) boot_phys_start,
                     (UINT32) boot_phys_end,
                     (UINT32) PHYS(p_param->adr) ) ;
            rcode = ERROR_FLASH_BOOT_WRITE_PROTECTED ;
            break ;

        default:
            /* program any RAM */
            rcode = FLASH_AMD_program_systemram( p_param ) ;
            break ;
    }
    flash_last_error = rcode ;
    return( rcode ) ;
}


/************************************************************************
*
*                          FLASH_AMD_ctrl
*  Description :
*  -------------
*  This service comprise following specific FLASH services:
*    1) 'ERASE_SYSTEMFLASH'
*    2) 'ERASE_FILEFLASH'
*    3) 'FLASH_CTRL_ERASE_FLASH_AREA'
*    4) 'FLASH_CTRL_INQUIRE_FLASH_AREA'
*    5) 'FLASH_CTRL_TEST_SYSTEMFLASH'
*  
*
*  Parameters :
*  ------------
*
*  'major',     IN,    major device number
*  'minor',     IN,    minor device number for multi device drivers
*  'p_param',   IN,    variable of type, t_FLASH_ctrl_descriptor.
*
*
*  Return values :
*  ---------------
*
* 'OK' = 0x00:                         FLASH service completed successfully
*  ERROR_FLASH_PROGRAM_ERROR           Flash device failure
*
*
************************************************************************/
static
INT32 FLASH_AMD_ctrl(
                     UINT32 major,          /* IN: major device number             */
                     UINT32 minor,          /* IN: minor device number             */
                     t_FLASH_ctrl_descriptor *p_param )    /* IN: write data       */
{
    int                      rcode = OK ;
    UINT32 *pt;

    /* set to default */
    flash_diag_msg[0] = 0 ;

//    printf("flash control...\n");

    switch(p_param->command)
    {
        case FLASH_CTRL_ERASE_SYSTEMFLASH:
//            printf(" erase system flash\n");
            if ( FLASH_AMD_is_system_flash_write_protected() )
            {
                rcode = ERROR_FLASH_WRITE_PROTECTED ;
            }
            else
            {
                rcode = FLASH_AMD_erase_systemflash() ;
            }
            break ;

        case FLASH_CTRL_ERASE_FILEFLASH:
//            printf("ERASE FILEFLASH\n");

#ifdef PROMICE

            /* added to emulate flash */

            pt = (UINT32*) KSEG1(fileflash_phys_start);

            /*PBUpdate  added so SRAM could fake flash */

            while(KSEG1((UINT32)pt) < KSEG1(fileflash_phys_end))
            {
                REG32(pt) = 0xffffffff;
                pt++;
            }
#else

                rcode = FLASH_AMD_erase_fileflash() ;

#endif /*PROMICE*/

            break ;

        case FLASH_CTRL_ERASE_FLASH_AREA:
//            printf("erase flash area\n");
            rcode = FLASH_AMD_erase_flasharea(p_param) ;
            break ;

        case FLASH_CTRL_INQUIRE_FLASH_AREA:
//            printf("inquire flash area.\n");
            rcode = FLASH_AMD_inquire_flasharea(p_param) ;
            break ;

        case FLASH_CTRL_TEST_SYSTEMFLASH:
//            printf("test flash\n");
            rcode = FLASH_AMD_test_systemflash() ;
            if (rcode == OK)
            {
                rcode = FLASH_AMD_test_fileflash() ;
            }
                break ;

        case FLASH_CTRL_WRITE_FILEFLASH:
//            printf("write flash\n");
            /* program file FLASH */

#ifdef PROMICE

            rcode = FLASH_AMD_program_systemram( p_param->wr_param );
#else

            rcode = FLASH_AMD_program_flash( p_param->wr_param );
            if (rcode ==  ERROR_FLASH_LOCKED)
            {
                if ( FLASH_AMD_is_file_flash_write_protected() )
                {
                    rcode = ERROR_FLASH_FILE_FLASH_LOCK ;
                }
            }

            /* set file flash in read array mode */
            FLASH_AMD_set_fileflash_read();
            
#endif /*PROMICE*/

            break ;

        case FLASH_CTRL_TEST_MONITORFLASH:
            rcode = FLASH_AMD_test_monitorflash() ;
            break ;

        default:
            printf("invalid flash command...\n");
            rcode = ERROR_FLASH_INVALID_COMMAND ;
            break ;
    }
    flash_last_error = rcode ;
    return( rcode ) ;
}


/************************************************************************
*      Local helper functions
************************************************************************/

/************************************************************************
*
*                          FLASH_AMD_devicetype
*  Description :
*  -------------
*  Derive the memory device type from 'physical address'
*  
*
*  Parameters :
*  ------------
*
*  'physadr': physical address inside a 512 MByte space
*
*
*  Return values :
*  ---------------
*
*  t_flash_device_id:    memory device type detected.
*
*
************************************************************************/
static
t_flash_device_id FLASH_AMD_devicetype( UINT32 physadr )
{
    /* check for system FLASH */
    if ((systemflash_phys_start <= physadr) && (physadr <= systemflash_phys_end))
    {
        return(FLASH_SYSTEMFLASH_DEVICE) ;
    }

    /* check for BOOT */
    /*    if (( boot_phys_start <= physadr) && (physadr <= boot_phys_end ))
{
        return(FLASH_BOOT_DEVICE) ;
}
*/
    /* check for monitor FLASH */
    if ((monitorflash_phys_start <= physadr) && (physadr <= monitorflash_phys_end))
    {
        return(FLASH_MONITORFLASH_DEVICE) ;
    }

    /* check for file FLASH */
    if ((fileflash_phys_start <= physadr) && (physadr <= fileflash_phys_end))
    {
        return(FLASH_FILEFLASH_DEVICE) ;