source: svn/newcon3bcm2_21bu/dta/tests/unit_test/umstore.c @ 43

/***************************************************************************
 *     Copyright (c) 2011, 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: UDTA message storage implementation
 *
 * Revision History:
 *
 * $brcm_Log: $
 * 
 *
 ***************************************************************************/

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

#include "umstore.h"
#include "bfdb.h"
#include "bspi_flash.h"
#include "ramheader.h"

BDBG_MODULE(bums);

/* private structure that used by message storage interface */
struct bums_data_t {
    bfdb_handle db;
};

static struct bums_data_t umsd;

/* 
   Flash configuration. For most flashes sector size and page size should be
   left at default. Offset is a starting offset of database from the beginning
   of the flash. DB_SIZE and DB_OFFSET must be dvisible by SECTOR_SIZE
   This must match settings in bapp_settings.c. Later we will consolidate.
 */
#define FLASH_PAGE_SIZE 0x100
#define FLASH_SECTOR_SIZE 0x10000

#define FLASH_DB_SIZE FLASH_DATA_SIZE
#define FLASH_DB_OFFSET (FLASH_BOOTLOADER_SIZE + FLASH_APP0_SIZE + FLASH_APP1_SIZE)
#define MEM_DB_OFFSET 0
#define MEM_DB_SIZE FLASH_DB_SIZE

static bfdb_err bums_add(bfdb_handle handle, uint8_t id, uint8_t * data, size_t size);
static bfdb_err bums_delete_all(bfdb_handle handle, uint8_t id);
void bums_print_request(unsigned char data_id, int read);

void bums_open(void)
{
        bfdb_err dberr;
        struct bfdb_settings dbset;
        bspi_settings_t spi_settings;
        bresult rc;

        rc = bspi_identify(&spi_settings);
        BDBG_ASSERT(rc == b_ok);

        dbset.page_size = spi_settings.page_size;
        dbset.sector_size = spi_settings.sector_size;
        dbset.db_offset = FLASH_DB_OFFSET;
        dbset.db_size = FLASH_DB_SIZE;

        BKNI_Memset(&umsd, 0, sizeof(struct bums_data_t));

        dberr = bfdb_open(&dbset, &umsd.db);
        if(BFDB_OK != dberr){
                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
                if(BFDB_LOG_ERROR == dberr){
                        dberr = bfdb_erase(umsd.db);
                        if(BFDB_OK != dberr){
                                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
                        }
                }
        }
}

void bums_close(void)
{
    int res;
    /* close store handle. database does not need closing */
    res = bfds_close(umsd.db->store);
    if(BFDS_OK == res){
        umsd.db = NULL;
    }
}


int bums_read_data(unsigned char data_id, char * data, size_t size)
{
    int err;
    bfdb_err dberr;

    err = BUMS_ERROR;

    bums_print_request(data_id, 1);

    dberr = bfdb_rewind(umsd.db, data_id);
    if(BFDB_OK == dberr){
        dberr = bfdb_get(umsd.db, data, size);
        if(BFDB_OK != dberr){
                        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
                        goto ExitFunc;            
        }
        err = BUMS_OK;
    }
ExitFunc:
    return err;
}


int bums_write_data(unsigned char data_id, char * data, size_t size)
{
    int err;
    bfdb_err dberr;
    err = BUMS_ERROR;

    bums_print_request(data_id, 0);

    dberr = bums_delete_all(umsd.db, data_id);
        if(BFDB_OK != dberr){
                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
                goto ExitFunc;
        }
    dberr = bums_add(umsd.db, data_id, data, size);
    if(BFDB_OK != dberr){
                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
        }
    err = BUMS_OK;
ExitFunc:    
    return err;
}

int bums_delete_data(unsigned char data_id)
{
    int err;
    bfdb_err dberr;
    err = BUMS_ERROR;

    bums_print_request(data_id, 2);

    dberr = bums_delete_all(umsd.db, data_id);
        if(BFDB_OK != dberr){
                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
                goto ExitFunc;
        }
        err = BUMS_OK;
ExitFunc:
        return err;
}

/* add with compact if add fails */
bfdb_err bums_add(bfdb_handle handle, uint8_t id, uint8_t * data, size_t size)
{
        bfdb_err dberr;
        do {
                dberr = bfdb_add(handle, id, data, size);
                if(BFDB_LOG_FULL == dberr){
                        dberr = bfdb_compact(handle);
                        if(BFDB_OK == dberr){
                                dberr = BFDB_LOG_FULL;
                        }
                }       
        } while(BFDB_LOG_FULL == dberr);
        return dberr;
}

bfdb_err bums_delete_all(bfdb_handle handle, uint8_t id)
{
        bfdb_err dberr;

        dberr = bfdb_rewind(handle, id);
        switch(dberr){
        case BFDB_OK:
                /* we have records in database, delete them */
                do{
                        dberr = bfdb_delete(handle);
                        if(BFDB_OK != dberr){
                                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
                                goto ExitFunc;
                        }
                        dberr = bfdb_next(handle, id);
                }while(BFDB_OK == dberr);
        case BFDB_RECORD_NOT_FOUND:
                dberr = BFDB_OK;
                break;
        default:
                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
        }
ExitFunc:
        return dberr;
}


static char * request_string[] = {
    "CA_SYS_ID",
};

void bums_print_request(unsigned char data_id, int read)
{
    int idx;
        char * action;

    idx = data_id - BUMS_ID_START;
    if(idx > (BUMS_ID_LAST - BUMS_ID_START)){
        BDBG_ERR(("Incorrect ID requested"));
    }
        switch(read){
        case 0:
                action = "write";
                break;
        case 1:
                action = "read";
                break;
        case 2:
                action = "erase";
                break;
        }
    BKNI_Printf("Request to %s %s\n", action, request_string[idx]);
}

bfdb_handle bast_getdb(void)
{
    return umsd.db;
}