Subversion Repositories openrisc

//==========================================================================

//

//      synth.c

//

//      Flash programming

//

//==========================================================================

// ####ECOSGPLCOPYRIGHTBEGIN####                                            

// -------------------------------------------                              

// This file is part of eCos, the Embedded Configurable Operating System.   

// Copyright (C) 1998, 1999, 2000, 2001, 2002 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):    andrew.lunn@ascom.ch

// Contributors: jlarmour

// Date:         2001-10-30

// Purpose:      

// Description:  

//              

//####DESCRIPTIONEND####

//

//==========================================================================

#include <pkgconf/devs_flash_synth_v2.h>

#include <cyg/hal/hal_io.h>

#include <cyg/infra/cyg_ass.h>

#include <string.h>

#include <cyg/io/flash.h>

#include <cyg/io/flash_dev.h>

#include <cyg/flash/synth.h>

#ifndef MIN

#define MIN(x,y) ((x)<(y) ? (x) : (y))

#endif

static int

synth_flash_init(struct cyg_flash_dev *dev)

{

    struct cyg_flash_synth_priv *priv =

        (struct cyg_flash_synth_priv *) dev->priv;

    cyg_flashaddr_t base;

    int flags = CYG_HAL_SYS_MAP_SHARED;

    priv->flashfd = cyg_hal_sys_open(

        priv->filename,

        CYG_HAL_SYS_O_RDWR,

        CYG_HAL_SYS_S_IRWXU|CYG_HAL_SYS_S_IRWXG|CYG_HAL_SYS_S_IRWXO);

    if (priv->flashfd == -ENOENT) {

        long w, bytesleft;

        char buf[128];

        priv->flashfd = cyg_hal_sys_open(

            priv->filename,

            CYG_HAL_SYS_O_RDWR|CYG_HAL_SYS_O_CREAT,

            CYG_HAL_SYS_S_IRWXU|CYG_HAL_SYS_S_IRWXG|CYG_HAL_SYS_S_IRWXO);

        CYG_ASSERT(priv->flashfd >= 0,

                   "Opening of the file for the synth flash failed!");

        // Fill with 0xff

        memset(buf, 0xff, sizeof(buf));

        bytesleft = priv->block_size * priv->blocks +

            priv->boot_block_size * priv->boot_blocks;

        while (bytesleft > 0) {

            int bytesneeded;

            bytesneeded = bytesleft < sizeof(buf) ? bytesleft : sizeof(buf);

            w = cyg_hal_sys_write(priv->flashfd, buf, bytesneeded);

            CYG_ASSERT(w == bytesneeded, "initialization of flash file failed");

            bytesleft -= bytesneeded;

        }

    }

    CYG_ASSERT(priv->flashfd >= 0,

               "Opening of the file for the synth flash failed!");

    if (priv->flashfd <= 0)

        return CYG_FLASH_ERR_HWR;

    if (dev->start != 0)

        flags |= CYG_HAL_SYS_MAP_FIXED;

    base = (cyg_flashaddr_t) cyg_hal_sys_mmap(

        (void *) dev->start,

        priv->blocks * priv->block_size +

        priv->boot_block_size * priv->boot_blocks,

        CYG_HAL_SYS_PROT_READ,

        flags,

        priv->flashfd,

        0l);

    CYG_ASSERT(base != -1, "mmap of flash file failed!");

    if (base == -1)

        return CYG_FLASH_ERR_HWR;

    dev->start = base;

    dev->end = base + (priv->blocks * priv->block_size) +

        (priv->boot_blocks * priv->boot_block_size) - 1;

    if (priv->boot_blocks) {

        if (priv->boot_block_bottom) {

            priv->block_info[0].block_size = priv->boot_block_size;

            priv->block_info[0].blocks = priv->boot_blocks;

            priv->block_info[1].block_size = priv->block_size;

            priv->block_info[1].blocks = priv->blocks;

        } else {

            priv->block_info[0].block_size = priv->block_size;

            priv->block_info[0].blocks = priv->blocks;

            priv->block_info[1].block_size = priv->boot_block_size;

            priv->block_info[1].blocks = priv->boot_blocks;

        }

        dev->num_block_infos = 2;

    } else {

        priv->block_info[0].block_size = priv->block_size;

        priv->block_info[0].blocks = priv->blocks;

        dev->num_block_infos = 1;

    }

    dev->block_info = &priv->block_info[0];

    return CYG_FLASH_ERR_OK;

}

// Return the size of the block which is at the given address.

// __inline__ so that we know it will be in RAM, not ROM.

static __inline__ size_t

flash_block_size(struct cyg_flash_dev *dev, const cyg_flashaddr_t addr)

{

    int i;

    cyg_flashaddr_t offset;

    CYG_ASSERT((addr >= dev->start) && (addr <= dev->end), "Not inside device");

    offset = addr - dev->start;

    for (i=0; i < dev->num_block_infos; i++) {

        if (offset < (dev->block_info[i].blocks *

                      dev->block_info[i].block_size))

             return dev->block_info[i].block_size;

        offset = offset -

            (dev->block_info[i].blocks * dev->block_info[i].block_size);

    }

    CYG_FAIL("Programming error");

    return 0;

}

static int

synth_flash_erase_block(struct cyg_flash_dev *dev,

                        cyg_flashaddr_t block_base)

{

    const struct cyg_flash_synth_priv *priv = dev->priv;

    cyg_flashaddr_t offset = block_base;

    size_t remaining;

    int write_size;

    // This helps speed up the erasing

    static cyg_uint8 empty[4096];

    static cyg_bool empty_inited;

    offset -= dev->start;

    cyg_hal_sys_lseek(priv->flashfd, offset, CYG_HAL_SYS_SEEK_SET);

    if (!empty_inited) {

        memset(empty, 0xff, sizeof(empty));

        empty_inited = true;

    }

    remaining = flash_block_size(dev, block_base);

    while (remaining) {

      write_size = MIN(remaining, sizeof(empty));

      cyg_hal_sys_write(priv->flashfd, empty, write_size);

      remaining -= write_size;

    }

    return CYG_FLASH_ERR_OK;

}

static int

synth_flash_program (struct cyg_flash_dev *dev,

                     cyg_flashaddr_t base,

                     const void* data, size_t len)

{

    const struct cyg_flash_synth_priv *priv = dev->priv;

    cyg_flashaddr_t offset = base;

    cyg_uint8 *buf = (cyg_uint8 *) data;

    // This helps speed up the programming

    static cyg_uint8 tmp[4096];

    offset -= dev->start;

    while (len > 0) {

        int i;

        int write_size = MIN(len, sizeof(tmp));

        // Writing to NOR flash only sets bits from 1 to 0, not vice-versa

        cyg_hal_sys_lseek(priv->flashfd, offset, CYG_HAL_SYS_SEEK_SET);

        cyg_hal_sys_read(priv->flashfd, tmp, write_size);

        for (i = 0; i < write_size; i++)

            tmp[i] = tmp[i] & buf[i];

        cyg_hal_sys_lseek(priv->flashfd, offset, CYG_HAL_SYS_SEEK_SET);

        cyg_hal_sys_write(priv->flashfd, tmp, write_size);

        // Process next chunk

        buf += write_size;

        offset += write_size;

        len -= write_size;

    }

    return CYG_FLASH_ERR_OK;

}

#define QUERY "Linux Synthetic Flash" 

static size_t

synth_flash_query(struct cyg_flash_dev *dev, void * data, size_t len)

{

    memcpy(data, QUERY, sizeof(QUERY));

    return sizeof(QUERY);

}

const CYG_FLASH_FUNS(cyg_flash_synth_funs,

                     synth_flash_init,

                     synth_flash_query,

                     synth_flash_erase_block,

                     synth_flash_program,

                     NULL,                 // read

                     cyg_flash_devfn_lock_nop,

                     cyg_flash_devfn_unlock_nop);

static struct cyg_flash_synth_priv synth_flash_priv = {

    .block_size         = CYGNUM_FLASH_SYNTH_V2_BLOCKSIZE,

    .blocks             = CYGNUM_FLASH_SYNTH_V2_NUMBLOCKS,

    .boot_block_size    = CYGNUM_FLASH_SYNTH_V2_BOOT_BLOCKSIZE,

    .boot_blocks        = CYGNUM_FLASH_SYNTH_V2_NUMBOOT_BLOCKS,

    .boot_block_bottom  = CYGNUM_FLASH_SYNTH_V2_BOOT_BLOCK_BOTTOM,

    .filename           = CYGDAT_FLASH_SYNTH_V2_FILENAME,

    .flashfd            = -1

};

CYG_FLASH_DRIVER(cyg_flash_synth_flashdev,

                 &cyg_flash_synth_funs,

                 0,                             // flags

                 CYGMEM_FLASH_SYNTH_V2_BASE,    // Start, if 0 will be updated by init

                 0,                             // end, filled in by init

                 0,                             // number of block_info's, filled in by init

                 synth_flash_priv.block_info,

                 &synth_flash_priv);

// EOF synth.c