source: svn/trunk/newcon3bcm2_21bu/dta/src/bfdb/bfds_mem.c @ 2

/***************************************************************************
 *     Copyright (c) 2003-2010, Broadcom Corporation
 *     All Rights Reserved
 *     Confidential Property of Broadcom Corporation
 *
 *  THIS SOFTWARE MAY ONLY BE USED SUBJECT TO AN EXECUTED SOFTWARE LICENSE
 *  AGREEMENT  BETWEEN THE USER AND BROADCOM.  YOU HAVE NO RIGHT TO USE OR
 *  EXPLOIT THIS MATERIAL EXCEPT SUBJECT TO THE TERMS OF SUCH AN AGREEMENT.
 *
 * $brcm_Workfile: $
 * $brcm_Revision: $
 * $brcm_Date: $
 *
 * Module Description: flash simulation module in memory
 *
 * Revision History:
 *
 * $brcm_Log: $
 * 
 *
 ***************************************************************************/

#include "bstd.h"
#include "bdbg.h"
#include "bkni.h"

#include "bfds.h"

#define BFDS_SECTOR_SIZE 0x1000
#define BFDS_PAGE_SIZE 0x100
#define BFDS_SECTOR_MASK (~(BFDS_SECTOR_SIZE - 1))

struct bfds_state {
        void * storage;
        unsigned size;
};

static struct bfds_state mems;

int bfds_open(bfds_handle * handle)
{
        int res;

        BKNI_Memset(&mems, 0, sizeof(struct bfds_state));
        //mems.size = BFDS_SECTOR_SIZE * 4 * 16; /* 16 sectors of flash */
        mems.size = 0x400000 * 2; /* 16 sectors of flash */
        mems.storage = BKNI_Malloc(mems.size);
        if(NULL == mems.storage){
                res = BFDS_ERROR;
                goto ExitFunc;
        }
        /* fill memory with 0xff to simulate flash */
        BKNI_Memset(mems.storage, 0xff, mems.size);
        *handle = &mems;
        res = BFDS_OK;
ExitFunc:
        return res;
}
int bfds_close(
                                bfds_handle handle  /* [in] device handle */
                           )
{
        if (mems.storage)
        {
                BKNI_Free(mems.storage);
                mems.storage = NULL;
        }
        return BFDS_OK;
}
int bfds_read(bfds_handle handle, unsigned offset, void * data, unsigned size)
{
        void * pdata;
        BDBG_ASSERT(NULL != handle);
        pdata = (void*)((unsigned)(handle->storage) + offset);
        BKNI_Memcpy(data, pdata, size);
        return BFDS_OK;
}

int bfds_sector_erase(bfds_handle handle, unsigned offset)
{
        void * erase_addr;
        BDBG_ASSERT(NULL != handle);
        erase_addr = (void *)((unsigned)(handle->storage) + (offset & BFDS_SECTOR_MASK));
        BKNI_Memset(erase_addr, 0xff, BFDS_SECTOR_SIZE);
        return BFDS_OK;
}

int bfds_page_program(bfds_handle handle, unsigned offset, void * data, unsigned size)
{
        void * page_addr;
        unsigned remainder;

        BDBG_ASSERT(NULL != handle);

        page_addr = (void *)((unsigned)(handle->storage) + offset);
        remainder = BFDS_PAGE_SIZE - (offset & (BFDS_PAGE_SIZE - 1));
        if(size > remainder){
                /* If write is not page aligned we need to chop size,
                   in real flash data will wrap to the beggining of the page*/
                BKNI_Fail();
        }
        BKNI_Memcpy(page_addr, data, size);
        return BFDS_OK;
}

int bfds_get_properties (
        bfds_handle handle,                      /* [in] device handle */
        bfds_properties * properties /* [out] details of flash device */
        )
{
        int res;
        if(NULL == properties){
                res = BFDS_ERROR;
                goto ExitFunc;
        }
        properties->flash_sector_size = BFDS_SECTOR_SIZE;
        properties->flash_page_size = BFDS_PAGE_SIZE;
        res = BFDS_OK;
ExitFunc:
        return res;        
}