Subversion Repositories openrisc_me

//==========================================================================
//
//      flash.c
//
//      Flash programming
//
//==========================================================================
//####ECOSGPLCOPYRIGHTBEGIN####
// -------------------------------------------
// This file is part of eCos, the Embedded Configurable Operating System.
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
//
// eCos is free software; you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free
// Software Foundation; either version 2 or (at your option) any later version.
//
// eCos is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
// for more details.
//
// You should have received a copy of the GNU General Public License along
// with eCos; if not, write to the Free Software Foundation, Inc.,
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
//
// As a special exception, if other files instantiate templates or use macros
// or inline functions from this file, or you compile this file and link it
// with other works to produce a work based on this file, this file does not
// by itself cause the resulting work to be covered by the GNU General Public
// License. However the source code for this file must still be made available
// in accordance with section (3) of the GNU General Public License.
//
// This exception does not invalidate any other reasons why a work based on
// this file might be covered by the GNU General Public License.
//
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
// at http://sources.redhat.com/ecos/ecos-license/
// -------------------------------------------
//####ECOSGPLCOPYRIGHTEND####
//==========================================================================
//#####DESCRIPTIONBEGIN####
//
// Author(s):    gthomas
// Contributors: gthomas
// Date:         2000-07-26
// Purpose:      
// Description:  
//              
//####DESCRIPTIONEND####
//
//==========================================================================
 
#include <pkgconf/system.h>
#include <pkgconf/io_flash.h>
 
#include <cyg/hal/hal_arch.h>
#include <cyg/hal/hal_intr.h>
#include <cyg/hal/hal_cache.h>
#include <string.h>
 
#define  _FLASH_PRIVATE_
#include <cyg/io/flash.h>
 
// When this flag is set, do not actually jump to the relocated code.
// This can be used for running the function in place (RAM startup only),
// allowing calls to diag_printf() and similar.
#undef RAM_FLASH_DEV_DEBUG
#if !defined(CYG_HAL_STARTUP_RAM) && defined(RAM_FLASH_DEV_DEBUG)
# warning "Can only enable the flash debugging when configured for RAM startup"
# undef  CYGHWR_IO_FLASH_DEVICE_NOT_IN_RAM
#endif
 
struct flash_info flash_info;
 
int
flash_init(void *work_space, int work_space_size, _printf *pf)
{
    int err;
 
    if (flash_info.init) return FLASH_ERR_OK;
    flash_info.pf = pf; // Do this before calling into the driver
    flash_info.work_space = work_space;
    flash_info.work_space_size = work_space_size;
    if ((err = flash_hwr_init()) != FLASH_ERR_OK) {
        return err;
    }
    flash_info.block_mask = ~(flash_info.block_size-1);
    flash_info.init = 1;
    return FLASH_ERR_OK;
}
 
#ifndef CYGHWR_IO_FLASH_DEVICE_NOT_IN_RAM
// Use this function to make function pointers anonymous - forcing the
// compiler to use jumps instead of branches when calling driver
// services.
static void* __anonymizer(void* p)
{
  return p;
}
#endif
 
// FIXME: Want to change all drivers to use this function. But it may
// make sense to wait till device structure pointer arguments get
// added as well.
void
flash_dev_query(void* data)
{
    typedef void code_fun(void*);
    code_fun *_flash_query;
    int d_cache, i_cache;
 
#ifdef CYGHWR_IO_FLASH_DEVICE_NOT_IN_RAM
    {
        extern char flash_query[], flash_query_end[];
        CYG_ADDRESS code_len;
 
        // Query the device driver - copy 'query' code to RAM for execution
        code_len = (CYG_ADDRESS)&flash_query_end - (CYG_ADDRESS)&flash_query;
        _flash_query = (code_fun *)flash_info.work_space;
        memcpy(_flash_query, &flash_query, code_len);
    }
#else
    {
        externC code_fun flash_query;
        _flash_query = (code_fun*) __anonymizer(&flash_query);
    }
#endif
 
    HAL_FLASH_CACHES_OFF(d_cache, i_cache);
    (*_flash_query)(data);
    HAL_FLASH_CACHES_ON(d_cache, i_cache);
}
 
int
flash_verify_addr(void *target)
{
    if (!flash_info.init) {
        return FLASH_ERR_NOT_INIT;
    }
    if (((CYG_ADDRESS)target >= (CYG_ADDRESS)flash_info.start) &&
        ((CYG_ADDRESS)target <= ( ((CYG_ADDRESS)flash_info.end) - 1) )) {
        return FLASH_ERR_OK;
    } else {
        return FLASH_ERR_INVALID;
    }
}
 
int
flash_get_limits(void *target, void **start, void **end)
{
    if (!flash_info.init) {
        return FLASH_ERR_NOT_INIT;
    }
    *start = flash_info.start;
    *end = flash_info.end;
    return FLASH_ERR_OK;
}
 
int
flash_get_block_info(int *block_size, int *blocks)
{
    if (!flash_info.init) {
        return FLASH_ERR_NOT_INIT;
    }
    *block_size = flash_info.block_size;
    *blocks = flash_info.blocks;
    return FLASH_ERR_OK;
}
 
int
flash_erase(void *addr, int len, void **err_addr)
{
    unsigned short *block, *end_addr;
    int stat = 0;
    typedef int code_fun(unsigned short *, unsigned int);
    code_fun *_flash_erase_block;
    int d_cache, i_cache;
 
    if (!flash_info.init) {
        return FLASH_ERR_NOT_INIT;
    }
 
#ifdef CYGSEM_IO_FLASH_SOFT_WRITE_PROTECT
    if (plf_flash_query_soft_wp(addr,len))
        return FLASH_ERR_PROTECT;
#endif
 
#ifdef CYGHWR_IO_FLASH_DEVICE_NOT_IN_RAM
    {
        extern char flash_erase_block[], flash_erase_block_end[];
        CYG_ADDRESS code_len;
 
        // Copy 'erase' code to RAM for execution
        code_len = (CYG_ADDRESS)&flash_erase_block_end - (CYG_ADDRESS)&flash_erase_block;
        _flash_erase_block = (code_fun *)flash_info.work_space;
        memcpy(_flash_erase_block, &flash_erase_block, code_len);
    }
#else
    {
        externC code_fun flash_erase_block;
        _flash_erase_block = (code_fun*) __anonymizer(&flash_erase_block);
    }
#endif
 
    block = (unsigned short *)((CYG_ADDRESS)addr & flash_info.block_mask);
    end_addr = (unsigned short *)((CYG_ADDRESS)addr+len);
 
    /* Check to see if end_addr overflowed */
    if( (end_addr < block) && (len > 0) ){
        end_addr = (unsigned short *) ((CYG_ADDRESS) flash_info.end - 1);
    }
 
    (*flash_info.pf)("... Erase from %p-%p: ", (void*)block, (void*)end_addr);
 
    HAL_FLASH_CACHES_OFF(d_cache, i_cache);
    FLASH_Enable(block, end_addr);
    while (block < end_addr) {
        // Supply the blocksize for a gross check for erase success
        int i;
        unsigned char *dp;
        bool erased = true;
        unsigned short *tmp_block;
 
        dp = (unsigned char *)block;
        for (i = 0;  i < flash_info.block_size;  i++) {
            if (*dp++ != (unsigned char)0xFF) {
                erased = false;
                break;
            }
        }
        if (!erased) {
            stat = (*_flash_erase_block)(block, flash_info.block_size);
            stat = flash_hwr_map_error(stat);
        }
        if (stat) {
            *err_addr = (void *)block;
            break;
        }
 
        // Check to see if block will overflow
        tmp_block = block + flash_info.block_size / sizeof(*block);
        if(tmp_block < block){
            // If block address overflows, set block value to end on this loop
            block = end_addr;
        }
        else{
            block = tmp_block;
        }
        (*flash_info.pf)(".");
    }
    FLASH_Disable(block, end_addr);
    HAL_FLASH_CACHES_ON(d_cache, i_cache);
    (*flash_info.pf)("\n");
    return (stat);
}
 
int
flash_program(void *_addr, void *_data, int len, void **err_addr)
{
    int stat = 0;
    int size;
    typedef int code_fun(void *, void *, int, unsigned long, int);
    code_fun *_flash_program_buf;
    unsigned char *addr = (unsigned char *)_addr;
    unsigned char *data = (unsigned char *)_data;
    CYG_ADDRESS tmp;
    int d_cache, i_cache;
 
    if (!flash_info.init) {
        return FLASH_ERR_NOT_INIT;
    }
 
#ifdef CYGSEM_IO_FLASH_SOFT_WRITE_PROTECT
    if (plf_flash_query_soft_wp(addr,len))
        return FLASH_ERR_PROTECT;
#endif
 
#ifdef CYGHWR_IO_FLASH_DEVICE_NOT_IN_RAM
    {
        CYG_ADDRESS code_len;
        extern char flash_program_buf[], flash_program_buf_end[];
        // Copy 'program' code to RAM for execution
        code_len = (CYG_ADDRESS)&flash_program_buf_end - (CYG_ADDRESS)&flash_program_buf;
        _flash_program_buf = (code_fun *)flash_info.work_space;
        memcpy(_flash_program_buf, &flash_program_buf, code_len);
    }
#else
    {
        externC code_fun flash_program_buf;
        _flash_program_buf = (code_fun*) __anonymizer(&flash_program_buf);
    }
#endif
 
    (*flash_info.pf)("... Program from %p-%p at %p: ", (void*)data, 
                     (void*)(((CYG_ADDRESS)data)+len), (void*)addr);
 
    HAL_FLASH_CACHES_OFF(d_cache, i_cache);
    FLASH_Enable((unsigned short*)addr, (unsigned short *)(addr+len));
    while (len > 0) {
        size = len;
        if (size > flash_info.block_size) size = flash_info.block_size;
 
        tmp = (CYG_ADDRESS)addr & ~flash_info.block_mask;
        if (tmp) {
                tmp = flash_info.block_size - tmp;
                if (size>tmp) size = tmp;
 
        }
 
        stat = (*_flash_program_buf)(addr, data, size, 
                                     flash_info.block_mask, flash_info.buffer_size);
        stat = flash_hwr_map_error(stat);
#ifdef CYGSEM_IO_FLASH_VERIFY_PROGRAM
        if (0 == stat) // Claims to be OK
            if (memcmp(addr, data, size) != 0) {                
                stat = 0x0BAD;
                (*flash_info.pf)("V");
            }
#endif
        if (stat) {
            *err_addr = (void *)addr;
            break;
        }
        (*flash_info.pf)(".");
        len -= size;
        addr += size/sizeof(*addr);
        data += size/sizeof(*data);
    }
    FLASH_Disable((unsigned short*)addr, (unsigned short *)(addr+len));
    HAL_FLASH_CACHES_ON(d_cache, i_cache);
    (*flash_info.pf)("\n");
    return (stat);
}
 
#ifdef CYGHWR_IO_FLASH_BLOCK_LOCKING
 
int
flash_lock(void *addr, int len, void **err_addr)
{
    unsigned short *block, *end_addr;
    int stat = 0;
    typedef int code_fun(unsigned short *);
    code_fun *_flash_lock_block;
    int d_cache, i_cache;
 
    if (!flash_info.init) {
        return FLASH_ERR_NOT_INIT;
    }
 
#ifdef CYGSEM_IO_FLASH_SOFT_WRITE_PROTECT
    if (plf_flash_query_soft_wp(addr,len))
        return FLASH_ERR_PROTECT;
#endif
 
#ifdef CYGHWR_IO_FLASH_DEVICE_NOT_IN_RAM
    {
        extern char flash_lock_block[], flash_lock_block_end[];
        CYG_ADDRESS code_len;
        // Copy 'lock' code to RAM for execution
        code_len = (CYG_ADDRESS)&flash_lock_block_end - (CYG_ADDRESS)&flash_lock_block;
        _flash_lock_block = (code_fun *)flash_info.work_space;
        memcpy(_flash_lock_block, &flash_lock_block, code_len);
    }
#else
    {
        externC code_fun flash_lock_block;
        _flash_lock_block = (code_fun*) __anonymizer(&flash_lock_block);
    }
#endif
 
    block = (unsigned short *)((CYG_ADDRESS)addr & flash_info.block_mask);
    end_addr = (unsigned short *)((CYG_ADDRESS)addr+len);
 
    /* Check to see if end_addr overflowed */
    if( (end_addr < block) && (len > 0) ){
        end_addr = (unsigned short *) ((CYG_ADDRESS) flash_info.end - 1);
    }
 
    (*flash_info.pf)("... Lock from %p-%p: ", block, end_addr);
 
    HAL_FLASH_CACHES_OFF(d_cache, i_cache);
    FLASH_Enable(block, end_addr);
    while (block < end_addr) {
        unsigned short *tmp_block;
        stat = (*_flash_lock_block)(block);
        stat = flash_hwr_map_error(stat);
        if (stat) {
            *err_addr = (void *)block;
            break;
        }
 
        // Check to see if block will overflow
        tmp_block = block + flash_info.block_size / sizeof(*block);
        if(tmp_block < block){
            // If block address overflows, set block value to end on this loop
            block = end_addr;
        }
        else{
            block = tmp_block;
        }
        (*flash_info.pf)(".");
    }
    FLASH_Disable(block, end_addr);
    HAL_FLASH_CACHES_ON(d_cache, i_cache);
    (*flash_info.pf)("\n");
    return (stat);
}
 
int
flash_unlock(void *addr, int len, void **err_addr)
{
    unsigned short *block, *end_addr;
    int stat = 0;
    typedef int code_fun(unsigned short *, int, int);
    code_fun *_flash_unlock_block;
    int d_cache, i_cache;
 
    if (!flash_info.init) {
        return FLASH_ERR_NOT_INIT;
    }
 
#ifdef CYGSEM_IO_FLASH_SOFT_WRITE_PROTECT
    if (plf_flash_query_soft_wp(addr,len))
        return FLASH_ERR_PROTECT;
#endif
 
#ifdef CYGHWR_IO_FLASH_DEVICE_NOT_IN_RAM
    {
        extern char flash_unlock_block[], flash_unlock_block_end[];
        CYG_ADDRESS code_len;
        // Copy 'lock' code to RAM for execution
        code_len = (CYG_ADDRESS)&flash_unlock_block_end - (CYG_ADDRESS)&flash_unlock_block;
        _flash_unlock_block = (code_fun *)flash_info.work_space;
        memcpy(_flash_unlock_block, &flash_unlock_block, code_len);
    }
#else
    {
        externC code_fun flash_unlock_block;
        _flash_unlock_block = (code_fun*) __anonymizer(&flash_unlock_block);
    }
#endif
 
    block = (unsigned short *)((CYG_ADDRESS)addr & flash_info.block_mask);
    end_addr = (unsigned short *)((CYG_ADDRESS)addr+len);
 
    /* Check to see if end_addr overflowed */
    if( (end_addr < block) && (len > 0) ){
        end_addr = (unsigned short *) ((CYG_ADDRESS) flash_info.end - 1);
    }
 
    (*flash_info.pf)("... Unlock from %p-%p: ", block, end_addr);
 
    HAL_FLASH_CACHES_OFF(d_cache, i_cache);
    FLASH_Enable(block, end_addr);
    while (block < end_addr) {
        unsigned short *tmp_block;
        stat = (*_flash_unlock_block)(block, flash_info.block_size, flash_info.blocks);
        stat = flash_hwr_map_error(stat);
        if (stat) {
            *err_addr = (void *)block;
            break;
        }
 
        tmp_block = block + flash_info.block_size / sizeof(*block);
        if(tmp_block < block){
            // If block address overflows, set block value to end on this loop
            block = end_addr;
        }
        else{
            block = tmp_block;
        }
        (*flash_info.pf)(".");
    }
    FLASH_Disable(block, end_addr);
    HAL_FLASH_CACHES_ON(d_cache, i_cache);
    (*flash_info.pf)("\n");
    return (stat);
}
#endif
 
char *
flash_errmsg(int err)
{
    switch (err) {
    case FLASH_ERR_OK:
        return "No error - operation complete";
    case FLASH_ERR_ERASE_SUSPEND:
        return "Device is in erase suspend state";
    case FLASH_ERR_PROGRAM_SUSPEND:
        return "Device is in program suspend state";
    case FLASH_ERR_INVALID:
        return "Invalid FLASH address";
    case FLASH_ERR_ERASE:
        return "Error trying to erase";
    case FLASH_ERR_LOCK:
        return "Error trying to lock/unlock";
    case FLASH_ERR_PROGRAM:
        return "Error trying to program";
    case FLASH_ERR_PROTOCOL:
        return "Generic error";
    case FLASH_ERR_PROTECT:
        return "Device/region is write-protected";
    case FLASH_ERR_NOT_INIT:
        return "FLASH sub-system not initialized";
    case FLASH_ERR_DRV_VERIFY:
        return "Data verify failed after operation";
    case FLASH_ERR_DRV_TIMEOUT:
        return "Driver timed out waiting for device";
    case FLASH_ERR_DRV_WRONG_PART:
        return "Driver does not support device";
    case FLASH_ERR_LOW_VOLTAGE:
        return "Device reports low voltage";
    default:
        return "Unknown error";
    }
}
 
// EOF io/flash/..../flash.c