flash_strata.c

MIPS YAMON, a famous monitor inc. source, make file and PDF manuals.

    /* issue 'READ ARRAY' command */
    REG32(pw)  = FLASH_READ_COMMAND;

    return( rcode ) ;
}

/************************************************************************
 *
 *                          FLASH_STRATA_erase_flasharea
 *  Description :
 *  -------------
 *  Erase flash area; i.e. the driver erases the flash blocks inside 
 *  the specified memory area.
 *  
 *
 *  Parameters :
 *  ------------
 * 
 *  'p_param',   IN,    variable of type, t_FLASH_ctrl_descriptor.
 *
 *
 *  Return values :
 *  ---------------
 *
 * 'OK' = 0x00:                         FLASH erased succesfully
 *  ERROR_FLASH_PROGRAM_ERROR           Flash device failure
 *  ERROR_FLASH_INVALID_ADDRESS         Address area not inside FLASH
 *                                      devices
 *
 *
 ************************************************************************/
static
INT32 FLASH_STRATA_erase_flasharea( t_FLASH_ctrl_descriptor *p_param )
{
    int rcode = OK ;
    UINT32 blocksize, start, end, blockcount ;
    UINT32 block ;
    bool   monitor_flash = FALSE ;
    UINT32 pw ;

    switch (FLASH_STRATA_devicetype(p_param->user_physadr))
    {
        case FLASH_SYSTEMFLASH_DEVICE:
            /* system FLASH */
            if ( FLASH_STRATA_is_system_flash_write_protected() )
            {
                return( ERROR_FLASH_WRITE_PROTECTED ) ;
            }
            else
            {
                /* validate upper boundary */
                if ( FLASH_STRATA_devicetype( p_param->user_physadr +
                                              p_param->user_length - 1 ) 
                     != FLASH_SYSTEMFLASH_DEVICE )
                {
                    return( ERROR_FLASH_INVALID_ADDRESS ) ;
                }
                WRITE_ENABLE ;
                blocksize = systemflash_block_size ;
            }
          break ;

        case FLASH_FILEFLASH_DEVICE:
            /* Reject erase of 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->user_physadr) ) ; 
            return( ERROR_FLASH_FILE_FLASH_PROT ) ;

        case FLASH_MONITORFLASH_DEVICE:
            /* Monitor FLASH */
            monitor_flash = TRUE ;

            /* validate upper boundary */
            if ( FLASH_STRATA_devicetype( p_param->user_physadr +
                                          p_param->user_length - 1 ) 
                 != FLASH_MONITORFLASH_DEVICE )
            {
                return( ERROR_FLASH_INVALID_ADDRESS ) ;
            }

            blocksize = monitorflash_block_size ;
          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->user_physadr) ) ; 
            return( ERROR_FLASH_BOOT_WRITE_PROTECTED ) ;

        default:
            return( ERROR_FLASH_INVALID_ADDRESS ) ;
    }

    /* calculate committed FLASH area */
    start      = (KSEG1(p_param->user_physadr)/blocksize) * blocksize ;
    end        = ((((KSEG1(p_param->user_physadr) + 
                          p_param->user_length)/blocksize)) * blocksize) - 1  ;
    if ( ((KSEG1(p_param->user_physadr)+p_param->user_length) % blocksize) != 0)
    {
        end = end + blocksize ;
    }
    blockcount = (end + 1 - start)/ blocksize ;

    /* return committed area to user */
    p_param->driver_physadr = PHYS(start) ;
    p_param->driver_length  = (end - start) + 1 ;

    /* erase FLASH area */
    pw = start ;

    /* issue 'CLEAR STATUS: SR-5,4,3,1' command */
    REG32(pw)  = FLASH_CLEAR_STATUS_COMMAND ;

    for (block = 0; block < blockcount; block++)
    {
        /* issue 'READ_ID_CODES' command */
        REG32(pw)  = FLASH_READ_ID_CODES_COMMAND ;

        /* read status and check for LOCKED block */
        if ( REG32(pw+FLASH_BLOCKSTATUS_OFS) & FLASH_BLOCKSTATUS_LOCK_MSK )     
        {
            /* issue 'clear lock-bit' command */
            REG32(pw)  = FLASH_CLEAR_LOCK_COMMAND ;

            /* issue 'confirm' command */
            REG32(pw)  = FLASH_CONFIRM_COMMAND;    

            /* await completion */
            rcode = FLASH_STRATA_wait_ready( pw, FLASH_RETRY_10);   
        }
        if (rcode == OK)
        {
            /* issue 'erase' command */
            REG32(pw)  = FLASH_ERASE_COMMAND;
    
            /* issue 'confirm' command */
            REG32(pw)  = FLASH_CONFIRM_COMMAND;    

            /* await completion */
            rcode = FLASH_STRATA_wait_ready( pw, FLASH_RETRY_10);   
        }

        /* check for hw write protect */
        if ( (rcode == ERROR_FLASH_LOCKED) && (monitor_flash) )
        {
            if ( FLASH_STRATA_is_monitor_flash_write_protected() )
            {
                rcode = ERROR_FLASH_MONITOR_FLASH_LOCK ;
            }
        }


        /* issue 'CLEAR STATUS: SR-5,4,3,1' command */
        REG32(pw)  = FLASH_CLEAR_STATUS_COMMAND;

        /* issue 'READ ARRAY' command */
        REG32(pw)  = FLASH_READ_COMMAND;

        /* check status now, after having set back the flash in read array mode */
        if (rcode != OK)
        {
            break ;
        }

        /* next block */
        pw = pw + blocksize ;
    }
    /* enable write protection again in system flash */
    WRITE_DISABLE ;
    return( rcode ) ;
}


/************************************************************************
 *
 *                          FLASH_STRATA_inquire_flasharea
 *  Description :
 *  -------------
 *  Inquire flash area; i.e. the driver calculates the effective flash
 *  block area covering the specified memory area.
 *  
 *
 *  Parameters :
 *  ------------
 * 
 *  'p_param',   IN,    variable of type, t_FLASH_ctrl_descriptor.
 *
 *
 *  Return values :
 *  ---------------
 *
 * 'OK' = 0x00:                         Area specified inside valid
 *                                      FLASH device area
 *  ERROR_FLASH_INVALID_ADDRESS         Address area not inside FLASH
 *                                      devices
 *
 *
 ************************************************************************/
static
INT32 FLASH_STRATA_inquire_flasharea( t_FLASH_ctrl_descriptor *p_param )
{
    UINT32 blocksize, start, end ;

    //printf(" FLASH_STRATA_inquire_flasharea: %x, %x\n", p_param->user_physadr, p_param->user_length ) ;

    switch (FLASH_STRATA_devicetype(p_param->user_physadr))
    {
        case FLASH_SYSTEMFLASH_DEVICE:
            /* system FLASH */

            /* validate upper boundary */
            if ( FLASH_STRATA_devicetype( p_param->user_physadr +
                                          p_param->user_length - 1 ) 
                 != FLASH_SYSTEMFLASH_DEVICE )
            {
                return( ERROR_FLASH_INVALID_ADDRESS ) ;
            }

            blocksize = systemflash_block_size ;
          break ;

        case FLASH_FILEFLASH_DEVICE:
            /* Reject programming of 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->user_physadr) ) ; 
            return( ERROR_FLASH_FILE_FLASH_PROT ) ;

        case FLASH_MONITORFLASH_DEVICE:
            /* Monitor FLASH */

            /* validate upper boundary */
            if ( FLASH_STRATA_devicetype( p_param->user_physadr +
                                          p_param->user_length - 1 ) 
                 != FLASH_MONITORFLASH_DEVICE )
            {
                return( ERROR_FLASH_INVALID_ADDRESS ) ;
            }

            blocksize = monitorflash_block_size ;
          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->user_physadr) ) ;
            return( ERROR_FLASH_BOOT_WRITE_PROTECTED ) ;

        default:
            return( ERROR_FLASH_INVALID_ADDRESS ) ;
    }

    /* calculate committed FLASH area */
    start      = (KSEG1(p_param->user_physadr)/blocksize) * blocksize ;
    end        = ((((KSEG1(p_param->user_physadr) + 
                          p_param->user_length)/blocksize)) * blocksize) - 1  ;
    if ( ((KSEG1(p_param->user_physadr)+p_param->user_length) % blocksize) != 0)
    {
        end = end + blocksize ;
    }

    /* return committed area to user */
    p_param->driver_physadr = PHYS(start) ;
    p_param->driver_length  = (end - start) + 1 ;

    return( OK ) ;
}


/************************************************************************
 *
 *                          FLASH_STRATA_test_systemflash
 *  Description :
 *  -------------
 *  Test complete file flash (just one block)
 *  
 *
 *  Parameters :
 *  ------------
 *
 *  -
 *
 *  Return values :
 *  ---------------
 *
 * 'OK' = 0x00:                         System FLASH OK
 *  ERROR_FLASH_LOCKED                  Some sector(s) locked
 *  ERROR_FLASH_ERASE_ERROR             Some sector(s) have erase error
 *
 *
 ************************************************************************/
static
INT32 FLASH_STRATA_test_systemflash( void )
{
    int             rcode = OK ;
    UINT32          block, bank ;
    UINT32          pw ;
	 
    pw = KSEG1(systemflash_phys_start) ;
    for (bank = 0; bank < systemflash_bank_count; bank++)
    {
        for (block = 0; block < systemflash_block_count; block++)
        {
            /* issue 'QUERY' command */
            REG32(pw)  = FLASH_QUERY_COMMAND ;

#ifdef  FLASH_DEBUG
            sprintf( msg, "\n\r FLASH_STRATA_test_systemflash: Adr= 0x%08x, Sta= 0x%08x\n\r", 
                   pw, REG32(pw+FLASH_BLOCKSTATUS_OFS) ) ;
            PUTS( DEFAULT_PORT, msg ) ;
#endif

            /* Verify 'Q' char of the Query-unique ASCII string, part of CFI spec. */
            if ( REG32(pw+FLASH_QUERYQCHAR_OFS) != FLASH_QUERYQCHAR )     
            {
                memset( flash_diag_msg, 0, sizeof(flash_diag_msg) ) ;
                sprintf( flash_diag_msg, "Adr= %08x, (Adr)= %08x",pw+FLASH_QUERYQCHAR_OFS,
                                                                  REG32(pw+FLASH_QUERYQCHAR_OFS) ) ;
                rcode = ERROR_FLASH_QRY_NOT_FOUND ;
                break ;
            }

            /* Verify 'R' char of the Query-unique ASCII string, part of CFI spec. */
            if ( REG32(pw+FLASH_QUERYRCHAR_OFS) != FLASH_QUERYRCHAR )     
            {
                memset( flash_diag_msg, 0, sizeof(flash_diag_msg) ) ;
                sprintf( flash_diag_msg, "Adr= %08x, (Adr)= %08x",pw+FLASH_QUERYRCHAR_OFS,
                                                                  REG32(pw+FLASH_QUERYRCHAR_OFS) ) ;
                rcode = ERROR_FLASH_QRY_NOT_FOUND ;
                break ;
            }

            /* Verify 'Y' char of the Query-unique ASCII string, part of CFI spec. */
            if ( REG32(pw+FLASH_QUERYYCHAR_OFS) != FLASH_QUERYYCHAR )     
            {
                memset( flash_diag_msg, 0, sizeof(flash_diag_msg) ) ;
                sprintf( flash_diag_msg, "Adr= %08x, (Adr)= %08x",pw+FLASH_QUERYYCHAR_OFS,
                                                                  REG32(pw+FLASH_QUERYYCHAR_OFS) ) ;
                rcode = ERROR_FLASH_QRY_NOT_FOUND ;
                break ;
            }


            /* next block */
            pw = pw + systemflash_block_size ;
        }

        if (rcode != OK)
        {
            break ;
        }
    }


    /* reset working pointer to start of system flash */
    pw = KSEG1(systemflash_phys_start) ;
    for (bank = 0; bank < systemflash_bank_count; bank++)
    {
        /* issue 'CLEAR STATUS: SR-5,4,3,1' command */
        REG32(pw)  = FLASH_CLEAR_STATUS_COMMAND;

        /* issue 'READ ARRAY' command */
        REG32(pw)  = FLASH_READ_COMMAND;

        /* next bank: */
        pw = pw + (systemflash_block_count * systemflash_block_size) ;
    }
    return( rcode ) ;
}


/************************************************************************
 *
 *                          FLASH_STRATA_test_fileflash
 *  Description :
 *  -------------
 *  Test complete file flash.
 *  
 *
 *  Parameters :
 *  ------------
 *
 *  -
 *
 *  Return values :
 *  ---------------
 *
 * 'OK' = 0x00:                         System FLASH OK
 *  ERROR_FLASH_LOCKED                  Some sector(s) locked
 *  ERROR_FLASH_ERASE_ERROR             Some sector(s) have erase error
 *
 *
 ************************************************************************/
static
INT32 FLASH_STRATA_test_fileflash( void )
{
    int             rcode = OK ;
    UINT32          pw ;
	 
    pw = KSEG1(fileflash_phys_start) ;

    /* issue 'QUERY' command */
    REG32(pw)  = FLASH_QUERY_COMMAND ;

    /* Verify 'Q' char of the Query-unique ASCII string, part of CFI spec. */
    if ( REG32(pw+FLASH_QUERYQCHAR_OFS) != FLASH_QUERYQCHAR )
    {
        memset( flash_diag_msg, 0, sizeof(flash_diag_msg) ) ;
        sprintf( flash_diag_msg, "Adr= %08x, (Adr)= %08x",pw+FLASH_QUERYQCHAR_OFS,
                                                                  REG32(pw+FLASH_QUERYQCHAR_OFS) ) ;
        rcode = ERROR_FLASH_QRY_NOT_FOUND ;
    }

    /* Verify 'R' char of the Query-unique ASCII string, part of CFI spec. */
    if ( REG32(pw+FLASH_QUERYRCHAR_OFS) != FLASH_QUERYRCHAR )
    {
        memset( flash_diag_msg, 0, sizeof(flash_diag_msg) ) ;
        sprintf( flash_diag_msg, "Adr= %08x, (Adr)= %08x",pw+FLASH_QUERYRCHAR_OFS,
                                                                  REG32(pw+FLASH_QUERYRCHAR_OFS) ) ;
        rcode = ERROR_FLASH_QRY_NOT_FOUND ;
    }

    /* Verify