//==========================================================================
//
//      flash_load.c
//
//      RedBoot file/image loader into flash
//
//==========================================================================
// ####ECOSGPLCOPYRIGHTBEGIN####                                            
// -------------------------------------------                              
// This file is part of eCos, the Embedded Configurable Operating System.   
// Copyright (C) 2006 Free Software Foundation, 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.,    
// 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, 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 v2.                                               
//
// This exception does not invalidate any other reasons why a work based    
// on this file might be covered by the GNU General Public License.         
// -------------------------------------------                              
// ####ECOSGPLCOPYRIGHTEND####                                              
//==========================================================================
//#####DESCRIPTIONBEGIN####
//
// Author(s):    Oliver Munz
// Contributors: om, asl
// Date:         2006-02-21
// Purpose:      
// Description:  
//              
// This code is part of RedBoot (tm).
//
//####DESCRIPTIONEND####
//
//==========================================================================

#include <redboot.h>
#include <flash_load.h>

#include <cyg/io/flash.h>
#include <cyg/infra/cyg_ass.h>

static int flash_block_size;

static cyg_uint8 * current_flash_page;

/* Allocation of the flash-sector size RAM-buffer is done */
static bool init_done = false; 

/* We have initialized the current page ready for writing */
static bool flash_page_init = false; 

static cyg_uint8 *flash_buffer;

// If the io flash code outputs when erasing/writing it will upset the
// download over the communications channel. So we install a dummy
// print function.
static int dummy_printf(const char *fmt, ...){ 
  return 0;
}

// Calculate the address of the first byte in a flash block
static cyg_uint8 * flash_block_begin(cyg_uint32 addr) 
{
  return (cyg_uint8 *)
    ((addr / flash_block_size) * flash_block_size);
}

// Initialize the loading process
void flash_load_start(void)
{
  flash_init(dummy_printf);
  
  init_done = true;
  flash_page_init = false;
}

// Write a byte into flash. We maintain a copy in RAM of the FLASH
// page we are currently "writing" into. This copy is loaded with the
// current contents of the FLASH page when the first byte is "written"
// to the page. The "writes" are then made into the RAM copy. We only
// write to FLASH when there is a "write" outside of the current page,
// or the flash_load_finish function is called.
void flash_load_write(cyg_uint8 *flash_addr, cyg_uint8 value)
{
  
  cyg_uint32 retcode = FLASH_ERR_OK;
  void * err_addr;
  cyg_uint32 addr = (cyg_uint32)flash_addr;
  cyg_uint32 offset;
  
  if (!flash_page_init) { 
    /* First Byte for the current flash block. Read the current contents */
    current_flash_page = flash_block_begin(addr);
    flash_read(flash_buffer, current_flash_page, flash_block_size, &err_addr); 
    flash_page_init = true;
  } 
  if (flash_block_begin(addr) != current_flash_page) { 
    /* We have moved into the next flash page. Write the current
       page so we can move on */
    retcode = flash_erase(current_flash_page, flash_block_size, &err_addr);
    if (retcode != FLASH_ERR_OK){ /* Flash ERROR */
      diag_printf("Error erase at %p: %s\n", err_addr, flash_errmsg(retcode));
      return;
    }
    
    retcode = flash_program(current_flash_page, flash_buffer, 
                            flash_block_size, &err_addr); 
    if (retcode != FLASH_ERR_OK){ 
      diag_printf("Error writing at %p: %s\n", 
                  err_addr, flash_errmsg(retcode));
      return;
    }
    current_flash_page = flash_block_begin(addr);
    flash_read(flash_buffer, current_flash_page, flash_block_size, &err_addr);
  }
  
  offset = flash_addr - current_flash_page;
  CYG_ASSERT(offset < flash_block_size, "offset not inside flash block");
  
  flash_buffer[offset] = value;
}

// Program the current page into flash.
void flash_load_finish(void)
{
  cyg_uint32 retcode = FLASH_ERR_OK;
  void * err_addr;
  
  if (init_done && flash_page_init) {
    flash_page_init = false;
    
    retcode = flash_erase(current_flash_page, flash_block_size, &err_addr);
    if (retcode != FLASH_ERR_OK){
      diag_printf("Error erase at %p: %s\n", err_addr, flash_errmsg(retcode));
    } else {
      retcode = flash_program(current_flash_page, flash_buffer, 
                              flash_block_size, &err_addr);
      if (retcode != FLASH_ERR_OK){ 
        diag_printf("Error writing at %p: %s\n", 
                    err_addr, flash_errmsg(retcode));
      }
    }
  }
  flash_init(diag_printf);
}

// This is called during redboot start up. We allocate a buffer the
// size of the flash page.
void
flash_load_init(void)
{
  int flash_blocks;

  flash_get_block_info(&flash_block_size, &flash_blocks);
  workspace_end -= flash_block_size;
  
  flash_buffer = workspace_end;
}

// Register this initialization function in the table
RedBoot_init(flash_load_init, RedBoot_INIT_LAST);


    
