Subversion Repositories openrisc

//==========================================================================
//
//      flashiodev.c
//
//      Old flash device interface to I/O subsystem
//
//==========================================================================
// ####ECOSGPLCOPYRIGHTBEGIN####                                            
// -------------------------------------------                              
// This file is part of eCos, the Embedded Configurable Operating System.   
// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2004, 2009, 2010 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):    jlarmour
// Contributors: woehler, Andrew Lunn
// Date:         2002-01-16
// Purpose:      
// Description:  
//              
//####DESCRIPTIONEND####
//
//==========================================================================
 
#define _FLASH_PRIVATE_
#include <pkgconf/io_flash.h>
 
#include <errno.h>
#include <cyg/infra/cyg_type.h>
#include <cyg/io/devtab.h>
#include <cyg/io/config_keys.h>
#include <cyg/io/flash.h>
#include <string.h> // memcpy
#include <cyg/hal/hal_if.h>
 
#define MIN(x,y) ((x)<(y) ? (x) : (y))
#define MAX(x,y) ((x)>(y) ? (x) : (y))
 
struct flashiodev_priv_t{
  cyg_flashaddr_t start;
  cyg_flashaddr_t end;
  cyg_bool        use_fis;
  cyg_bool        use_absolute;
  cyg_bool        use_offset;
  char *          fis_name;
  cyg_uint32      block_size;
  cyg_bool        init;
};
 
static bool
flashiodev_init( struct cyg_devtab_entry *tab )
{
  int stat = cyg_flash_init(NULL);
 
  return (stat == CYG_FLASH_ERR_OK);
} // flashiodev_init()
 
static Cyg_ErrNo
flashiodev_lookup(struct cyg_devtab_entry **tab,
                  struct cyg_devtab_entry  *sub_tab,
                  const char *name) 
{
  struct flashiodev_priv_t *dev = (struct flashiodev_priv_t *)(*tab)->priv;
  cyg_flash_info_t info;
  cyg_uint32 i;
  int stat;
 
  if (dev->init)
    return ENOERR;
 
  if (dev->use_fis) {
    CYG_ADDRESS	flash_base;
    unsigned long	size;
 
    if(!CYGACC_CALL_IF_FLASH_FIS_OP(CYGNUM_CALL_IF_FLASH_FIS_GET_FLASH_BASE, 
                                    dev->fis_name,
                                    &flash_base))
      return ENOERR; 
 // Strange, yes, but needed since we have to do a lookup in order to
 // set the name using cyg_io_config_set. If we fail here you cannot
 // do a set. Since dev->init will still be false and attempts to
 // actually use the device will fail, so it is safe.
 
    if(!CYGACC_CALL_IF_FLASH_FIS_OP(CYGNUM_CALL_IF_FLASH_FIS_GET_SIZE, 
                                    dev->fis_name,
                                    &size))
      return ENOERR; // Ditto.
    dev->start = flash_base;
    dev->end = flash_base + size;
  }
  if (dev->use_offset) {
    // dev->start contains the offset to the beginning of the block
    // dev->end is the length of the block
    cyg_flash_info_t info;
 
    cyg_flash_get_info(0, &info);
    dev->start = dev->start + info.start;
    dev->end = dev->start + dev->end;
  }
  if (dev->use_absolute) {
    // dev->start is the absolute address of the start
    // dev->end is the length;
    dev->end = dev->start + dev->end;
  }
 
  stat = cyg_flash_get_info_addr(dev->start, &info);
  if (stat != CYG_FLASH_ERR_OK) {
    return ENODEV;
    }
  dev->block_size = 0;
  for (i=0; i < info.num_block_infos; i++){
    dev->block_size = MAX(dev->block_size, info.block_info[i].block_size);
  }
 
  dev->init = 1;
  return ENOERR;
} // flashiodev_lookup()
 
static Cyg_ErrNo
flashiodev_bread( cyg_io_handle_t handle, void *buf, cyg_uint32 *len,
                  cyg_uint32 pos)
{
  struct cyg_devtab_entry *tab = (struct cyg_devtab_entry *)handle;
  struct flashiodev_priv_t *dev = (struct flashiodev_priv_t *)tab->priv;
 
  cyg_flashaddr_t startpos = dev->start + pos;
  Cyg_ErrNo err;
 
  if (!dev->init) {
    return -EINVAL;
  }
 
#ifdef CYGPKG_INFRA_DEBUG // don't bother checking this all the time
  cyg_flashaddr_t endpos = startpos + *len - 1;
  if ( startpos < dev->start )
    return -EINVAL;
  if ( endpos > dev->end )
    return -EINVAL;
#endif
 
  err = cyg_flash_read( startpos,(void *)buf, *len, NULL );
 
  if ( err != CYG_FLASH_ERR_OK )
    err = -EIO; // just something sane
  return err;
} // flashiodev_bread()
 
static Cyg_ErrNo
flashiodev_bwrite( cyg_io_handle_t handle, const void *buf, cyg_uint32 *len,
                   cyg_uint32 pos )
{
  struct cyg_devtab_entry *tab = (struct cyg_devtab_entry *)handle;
  struct flashiodev_priv_t *dev = (struct flashiodev_priv_t *)tab->priv;
 
  Cyg_ErrNo err;
  cyg_flashaddr_t startpos = dev->start + pos;
 
  if (!dev->init) {
    return -EINVAL;
  }
 
#ifdef CYGPKG_INFRA_DEBUG // don't bother checking this all the time
  cyg_flashaddr_t endpos = startpos + *len - 1;
  if ( startpos < dev->start )
    return -EINVAL;
  if ( endpos > dev->end )
    return -EINVAL;
#endif
  err = cyg_flash_program( startpos, (void *)buf, *len, NULL );
 
  if ( err )
    err = -EIO; // just something sane
  return err;
} // flashiodev_bwrite()
 
static Cyg_ErrNo
flashiodev_get_config( cyg_io_handle_t handle,
                       cyg_uint32 key,
                       void* buf,
                       cyg_uint32* len)
{
  struct cyg_devtab_entry *tab = (struct cyg_devtab_entry *)handle;
  struct flashiodev_priv_t *dev = (struct flashiodev_priv_t *)tab->priv;
 
  if (!dev->init) {
    return -EINVAL;
  }
 
  switch (key) {
  case CYG_IO_GET_CONFIG_FLASH_ERASE:
    {
      if (*len != sizeof( cyg_io_flash_getconfig_erase_t ) )
        return -EINVAL;
      {
        cyg_io_flash_getconfig_erase_t *e = (cyg_io_flash_getconfig_erase_t *)buf;
        cyg_flashaddr_t startpos = dev->start + e->offset;
 
#ifdef CYGPKG_INFRA_DEBUG // don't bother checking this all the time
        cyg_flashaddr_t endpos = startpos + e->len - 1;
        if ( startpos < dev->start )
          return -EINVAL;
        if ( endpos > dev->end )
          return -EINVAL;
#endif
        e->flasherr = cyg_flash_erase( startpos, e->len, e->err_address );
      }
      return ENOERR;
    }
  case CYG_IO_GET_CONFIG_FLASH_DEVSIZE:
    {
      if ( *len != sizeof( cyg_io_flash_getconfig_devsize_t ) )
        return -EINVAL;
      {
        cyg_io_flash_getconfig_devsize_t *d =
          (cyg_io_flash_getconfig_devsize_t *)buf;
 
        d->dev_size = dev->end - dev->start;
      }
      return ENOERR;
    }
 
  case CYG_IO_GET_CONFIG_FLASH_BLOCKSIZE:
    {
      cyg_io_flash_getconfig_blocksize_t *b =
        (cyg_io_flash_getconfig_blocksize_t *)buf;
#ifdef CYGPKG_INFRA_DEBUG // don't bother checking this all the time
      cyg_flashaddr_t startpos = dev->start + b->offset;
 
      if ( startpos < dev->start )
        return -EINVAL;
      if ( startpos > dev->end )
        return -EINVAL;
#endif  
      if ( *len != sizeof( cyg_io_flash_getconfig_blocksize_t ) )
        return -EINVAL;
 
      // offset unused for now
      b->block_size = dev->block_size;
      return ENOERR;
    }
 
  default:
    return -EINVAL;
  }
} // flashiodev_get_config()
 
static Cyg_ErrNo
flashiodev_set_config( cyg_io_handle_t handle,
                       cyg_uint32 key,
                       const void* buf,
                       cyg_uint32* len)
{
  struct cyg_devtab_entry *tab = (struct cyg_devtab_entry *)handle;
  struct flashiodev_priv_t *dev = (struct flashiodev_priv_t *)tab->priv;
 
  switch (key) {
  case CYG_IO_SET_CONFIG_FLASH_FIS_NAME:
    {
      cyg_flashaddr_t flash_base;
      unsigned long size;
      cyg_flash_info_t info;
      cyg_uint32 i;
      int stat;
 
      if(!CYGACC_CALL_IF_FLASH_FIS_OP(CYGNUM_CALL_IF_FLASH_FIS_GET_FLASH_BASE, 
                                      (char *)buf, &flash_base))
        return -ENOENT;
 
      if(!CYGACC_CALL_IF_FLASH_FIS_OP(CYGNUM_CALL_IF_FLASH_FIS_GET_SIZE, 
                                      (char *)buf, &size))
        return -ENOENT;
 
      dev->start = flash_base;
      dev->end = flash_base + size;
 
      stat = cyg_flash_get_info_addr(dev->start, &info);
 
      if (stat != CYG_FLASH_ERR_OK) {
        return -ENOENT;
      }
      dev->block_size = 0;
      for (i=0; i < info.num_block_infos; i++){
        dev->block_size = MAX(dev->block_size, info.block_info[i].block_size);
      }
      dev->init = 1;
 
      return ENOERR;
    }
  default:
    return -EINVAL;
  }
} // flashiodev_set_config()
 
// get_config/set_config should be added later to provide the other flash
// operations possible, like erase etc.
 
#define CYG_FLASHIODEV_DEV(start, end, fis, static, offset, name) \
   { start, end, fis, static, offset, name, 0, 0 }
 
#ifdef CYGNUM_IO_FLASH_BLOCK_CFG_FIS_1
static struct flashiodev_priv_t priv1 = CYG_FLASHIODEV_DEV(
  0,       // start
  0,       // end
  1,       // use_fis
  0,       // use_static
  0,       // use_offset
  CYGDAT_IO_FLASH_BLOCK_FIS_NAME_1);
#endif
 
#ifdef CYGNUM_IO_FLASH_BLOCK_CFG_STATIC_ABSOLUTE_1 
static struct flashiodev_priv_t priv1 = CYG_FLASHIODEV_DEV(
  CYGNUM_IO_FLASH_BLOCK_ABSOLUTE_START_1,       // start
  CYGNUM_IO_FLASH_BLOCK_ABSOLUTE_LENGTH_1,      // end
  0,       // use_fis
  1,       // use_static
  0,       // use_offset
  "");     // fis_name
#endif
 
#ifdef CYGNUM_IO_FLASH_BLOCK_CFG_STATIC_1
static struct flashiodev_priv_t priv1 = CYG_FLASHIODEV_DEV(
  CYGNUM_IO_FLASH_BLOCK_OFFSET_1,       // start
  CYGNUM_IO_FLASH_BLOCK_LENGTH_1,       // end 
  0,       // use_fis
  0,       // use_static
  1,       // use_offset
  "");     // fis_name
#endif
 
BLOCK_DEVIO_TABLE( cyg_io_flashdev1_ops,
                   &flashiodev_bwrite,
                   &flashiodev_bread,
                   0, // no select
                   &flashiodev_get_config,
                   &flashiodev_set_config
                   ); 
 
 
BLOCK_DEVTAB_ENTRY( cyg_io_flashdev1,
                    CYGDAT_IO_FLASH_BLOCK_DEVICE_NAME_1,
                    0,
                    &cyg_io_flashdev1_ops,
                    &flashiodev_init,
                    &flashiodev_lookup,
                    &priv1 );
 
#ifdef CYGSEM_IO_FLASH_BLOCK_DEVICE_2 
#ifdef CYGNUM_IO_FLASH_BLOCK_CFG_FIS_2
static struct flashiodev_priv_t priv2 = CYG_FLASHIODEV_DEV(
  0,       // start
  0,       // end
  1,       // use_fis
  0,       // use_static
  0,       // use_offset
  CYGDAT_IO_FLASH_BLOCK_FIS_NAME_2);
#endif
 
#ifdef CYGNUM_IO_FLASH_BLOCK_CFG_STATIC_ABSOLUTE_2 
static struct flashiodev_priv_t priv2 = CYG_FLASHIODEV_DEV(
  CYGNUM_IO_FLASH_BLOCK_ABSOLUTE_START_2,       // start
  CYGNUM_IO_FLASH_BLOCK_ABSOLUTE_LENGTH_2,      // end
  0,       // use_fis
  1,       // use_static
  0,       // use_offset
  "");     // fis_name
#endif
 
#ifdef CYGNUM_IO_FLASH_BLOCK_CFG_STATIC_2
static struct flashiodev_priv_t priv2 = CYG_FLASHIODEV_DEV(
  CYGNUM_IO_FLASH_BLOCK_OFFSET_2,       // start
  CYGNUM_IO_FLASH_BLOCK_LENGTH_2,       // end 
  0,       // use_fis
  0,       // use_static
  1,       // use_offset
  "");     // fis_name
#endif
 
BLOCK_DEVTAB_ENTRY( cyg_io_flashdev2,
                    CYGDAT_IO_FLASH_BLOCK_DEVICE_NAME_2,
                    0,
                    &cyg_io_flashdev1_ops,
                    &flashiodev_init,
                    &flashiodev_lookup,
                    &priv2 );
#endif
 
// EOF flashiodev.c