flash_strata.c

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

 *
 *
 *  Return values :
 *  ---------------
 *
 *  'OK'(=0)
 *
 *
 *
 ************************************************************************/
static
INT32 FLASH_STRATA_init(
          UINT32 major,          /* IN: major device number             */
          UINT32 minor,          /* IN: minor device number             */
          void   *p_param )      /* INOUT: device parameter block       */
{
    int rcode ;


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

    /* 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 ;


    /* 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 ;

    /* 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 ;

    if (p_param != NULL) 
    {
        /*  Hack that may be used e.g. for test of monitor flash.
	 *  Not used by YAMON.
	 */
        fileflash_phys_start = monitorflash_phys_start;
        monitorflash_phys_start = 0xffffffff;
    }

    /* get system flash sector size */
    rcode = SYSCON_read( SYSCON_BOARD_SYSTEMFLASH_SECTORSIZE_ID,
                         &systemflash_block_size,
                         sizeof(systemflash_block_size) ) ;
    systemflash_block_size = 2 * 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) ) ;
    monitorflash_block_size = 2 * 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) ) ;
    fileflash_block_size = 2 * 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 ;
    }
    return( OK ) ;
}


/************************************************************************
 *
 *                          FLASH_STRATA_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_STRATA_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_STRATA_devicetype(PHYS(p_param->adr)))
    {
        case FLASH_SYSTEMFLASH_DEVICE:
            /* program system FLASH */
            if ( FLASH_STRATA_is_system_flash_write_protected() )
            {
                rcode = ERROR_FLASH_WRITE_PROTECTED ;
            }
            else
            {
                WRITE_ENABLE ;
                rcode = FLASH_STRATA_program_flash( p_param ) ;

                /* set system flash banks in read array mode */
                FLASH_STRATA_set_systemflash_read();   
                WRITE_DISABLE ;
            }
          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_STRATA_program_flash( p_param ) ;

            /* set monitor flash in read array mode */
            FLASH_STRATA_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_STRATA_program_systemram( p_param ) ;
          break ;
    }
    flash_last_error = rcode ;
    return( rcode ) ;
}


/************************************************************************
 *
 *                          FLASH_STRATA_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_STRATA_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 ;

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

    switch(p_param->command)
    {
        case FLASH_CTRL_ERASE_SYSTEMFLASH: 
            {
                rcode = SYSCON_read( SYSCON_BOARD_SYSTEMFLASH_BASE_ID,
                                     (void *)&(p_param->user_physadr),
                                     sizeof(UINT32) ) ;
                if (rcode == OK)
                {
                    rcode = SYSCON_read( SYSCON_BOARD_SYSTEMFLASH_SIZE_ID,
                                         (void *)&(p_param->user_length),
                                         sizeof(UINT32) ) ;
                }
                if (rcode == OK)
                {
                    rcode = FLASH_STRATA_erase_flasharea(p_param) ;
                }
            }
          break ;
 
        case FLASH_CTRL_ERASE_FILEFLASH:
            rcode = FLASH_STRATA_erase_fileflash() ;
          break ;

        case FLASH_CTRL_ERASE_FLASH_AREA:
            rcode = FLASH_STRATA_erase_flasharea(p_param) ;
          break ;

        case FLASH_CTRL_INQUIRE_FLASH_AREA:
            rcode = FLASH_STRATA_inquire_flasharea(p_param) ;
          break ;

        case FLASH_CTRL_TEST_SYSTEMFLASH:
            rcode = FLASH_STRATA_test_systemflash() ;
            if (rcode == OK)
            {
                rcode = FLASH_STRATA_test_fileflash() ;
            }
          break ;

        case FLASH_CTRL_WRITE_FILEFLASH:
            /* program file FLASH */
            rcode = FLASH_STRATA_program_flash( p_param->wr_param ) ;
            if (rcode ==  ERROR_FLASH_LOCKED)
            {
                if ( FLASH_STRATA_is_file_flash_write_protected() )
                {
                    rcode = ERROR_FLASH_FILE_FLASH_LOCK ;
                }
            }


            /* set file flash in read array mode */
            FLASH_STRATA_set_fileflash_read();
          break ;

        case FLASH_CTRL_TEST_MONITORFLASH:
            rcode = FLASH_STRATA_test_monitorflash() ;
          break ;

        default:
            rcode = ERROR_FLASH_INVALID_COMMAND ;
          break ;
    }
    flash_last_error = rcode ;
    return( rcode ) ;
}


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

/************************************************************************
 *
 *                          FLASH_STRATA_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_STRATA_devicetype( UINT32 physadr )
{
    /* check for system FLASH */
    if ((systemflash_phys_start <= physadr) && (physadr < systemflash_phys_end))
    {
        return(FLASH_SYSTEMFLASH_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) ;
    }

    /* check for BOOT */
    if (( boot_phys_start <= physadr) && (physadr < boot_phys_end ))
    {
        return(FLASH_BOOT_DEVICE) ;
    }

    /* device not known */
    return(FLASH_UNKNOWN_DEVICE) ;
}


/************************************************************************
 *
 *                          FLASH_STRATA_program_systemram
 *  Description :
 *  -------------
 *  Programs (store data) in the system RAM device.
 *  
 *
 *  Parameters :
 *  ------------
 *
 *  'p_param',   IN,    variable of type, t_FLASH_write_descriptor.
 *
 *
 *  Return values :
 *  ---------------
 *
 * 'OK' = 0x00:             Data stored in system RAM
 *
 *
 ************************************************************************/
static
INT32 FLASH_STRATA_program_systemram( t_FLASH_write_descriptor *p_param )
{