/******************************************************************************
 *    (c)2008-2009 Broadcom Corporation
 *
 * This program is the proprietary software of Broadcom Corporation and/or its licensors,
 * and may only be used, duplicated, modified or distributed pursuant to the terms and
 * conditions of a separate, written license agreement executed between you and Broadcom
 * (an "Authorized License").  Except as set forth in an Authorized License, Broadcom grants
 * no license (express or implied), right to use, or waiver of any kind with respect to the
 * Software, and Broadcom expressly reserves all rights in and to the Software and all
 * intellectual property rights therein.  IF YOU HAVE NO AUTHORIZED LICENSE, THEN YOU
 * HAVE NO RIGHT TO USE THIS SOFTWARE IN ANY WAY, AND SHOULD IMMEDIATELY
 * NOTIFY BROADCOM AND DISCONTINUE ALL USE OF THE SOFTWARE.
 *
 * Except as expressly set forth in the Authorized License,
 *
 * 1.     This program, including its structure, sequence and organization, constitutes the valuable trade
 * secrets of Broadcom, and you shall use all reasonable efforts to protect the confidentiality thereof,
 * and to use this information only in connection with your use of Broadcom integrated circuit products.
 *
 * 2.     TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE SOFTWARE IS PROVIDED "AS IS"
 * AND WITH ALL FAULTS AND BROADCOM MAKES NO PROMISES, REPRESENTATIONS OR
 * WARRANTIES, EITHER EXPRESS, IMPLIED, STATUTORY, OR OTHERWISE, WITH RESPECT TO
 * THE SOFTWARE.  BROADCOM SPECIFICALLY DISCLAIMS ANY AND ALL IMPLIED WARRANTIES
 * OF TITLE, MERCHANTABILITY, NONINFRINGEMENT, FITNESS FOR A PARTICULAR PURPOSE,
 * LACK OF VIRUSES, ACCURACY OR COMPLETENESS, QUIET ENJOYMENT, QUIET POSSESSION
 * OR CORRESPONDENCE TO DESCRIPTION. YOU ASSUME THE ENTIRE RISK ARISING OUT OF
 * USE OR PERFORMANCE OF THE SOFTWARE.
 *
 * 3.     TO THE MAXIMUM EXTENT PERMITTED BY LAW, IN NO EVENT SHALL BROADCOM OR ITS
 * LICENSORS BE LIABLE FOR (i) CONSEQUENTIAL, INCIDENTAL, SPECIAL, INDIRECT, OR
 * EXEMPLARY DAMAGES WHATSOEVER ARISING OUT OF OR IN ANY WAY RELATING TO YOUR
 * USE OF OR INABILITY TO USE THE SOFTWARE EVEN IF BROADCOM HAS BEEN ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGES; OR (ii) ANY AMOUNT IN EXCESS OF THE AMOUNT
 * ACTUALLY PAID FOR THE SOFTWARE ITSELF OR U.S. $1, WHICHEVER IS GREATER. THESE
 * LIMITATIONS SHALL APPLY NOTWITHSTANDING ANY FAILURE OF ESSENTIAL PURPOSE OF
 * ANY LIMITED REMEDY.
 *
 * $brcm_Workfile:  $
 * $brcm_Revision:  $
 * $brcm_Date:  $
 *
 * Module Description:
 *
 * Manage application settings like volume, channel map, etc.
 *
 * Revision History:
 *
 * Created: 09/28/2009 by Jeff Fisher
 *
 * $brcm_Log:  $
 * 
 *
 *****************************************************************************/
#include "bstd.h"
#include "bkni.h"
#include "bdbg.h"

#include "bapp.h"
#include "bapp_settings.h"
#include "bfdb.h"
#include "bspi_flash.h"

BDBG_MODULE(bast);		/* Register software module with debug interface */


struct settings_state_t {
	bfdb_handle db;
	uint8_t data[BFDB_DATA_MAX];
};

static struct settings_state_t sst;

static bfdb_err bast_add(bfdb_handle handle, uint8_t id, uint8_t *data, size_t size);

/* 
 * 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 divisible by SECTOR_SIZE
 */

#define FLASH_PAGE_SIZE 	0x100
#define FLASH_SECTOR_SIZE	0x10000
#define FLASH_DB_SIZE		0x40000
#define FLASH_DB_OFFSET		(0x400000 - FLASH_DB_SIZE)
#define MEM_DB_OFFSET		0
#define MEM_DB_SIZE			FLASH_DB_SIZE

/*
 * Open and initialize database.
 */
void bast_init(bapp_t *app)
{
	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 = FLASH_PAGE_SIZE;
	dbset.sector_size = spi_settings.sector_size;
	dbset.db_offset = FLASH_DB_OFFSET;
	dbset.db_size = FLASH_DB_SIZE;

	BKNI_Memset(&sst, 0, sizeof(struct settings_state_t));
	dberr = bfdb_open(&dbset, &sst.db);
	if (BFDB_OK != dberr) {
		BDBG_ERR(("Error:%d line:%d", dberr, __LINE__));
		if (BFDB_LOG_ERROR == dberr) {
			dberr = bfdb_erase(sst.db);
			if (BFDB_OK != dberr) {
				BDBG_ERR(("Error:%d line:%d", dberr, __LINE__));
			}
		}
	}
}	

bfdb_err bast_delete_all(uint8_t id)
{
	bfdb_err dberr;

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

/* add with compact if add fails */
bfdb_err bast_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;
}

void bast_channel_save(bapp_t *app)
{
	bfdb_err dberr;
	struct channel_settings_t *channel;

	/* use data memory block */
	channel = (struct channel_settings_t *)sst.data;
	channel->channel = app->cur_ch_num;
	channel->num_channels = app->settings.num_channels;
	channel->volume = app->settings.audio_vol;
	channel->rfm =app->settings.rfm;

	dberr = bast_delete_all(BAST_CHANNEL_ID);
	if (BFDB_OK != dberr)
	{
		BDBG_ERR(("Error:%d line:%d", dberr, __LINE__));
		goto ExitFunc;
	}

	/* create new record */
	dberr = bast_add(sst.db, BAST_CHANNEL_ID, (uint8_t *)channel, sizeof(struct channel_settings_t));
	if (BFDB_OK != dberr) {
		BDBG_ERR(("Error:%d line:%d", dberr, __LINE__));
	}
ExitFunc:
	return;
}

void bast_misc_save(bapp_t *app)
{
	bfdb_err dberr;
	struct misc_settings_t *misc;

	misc = (struct misc_settings_t *)sst.data;
	misc->bits.standby = app->settings.standby;
	misc->bits.av_mute = app->settings.av_mute;
	misc->bits.psi_scan = app->settings.psi_scan;
	misc->bits.state = app->settings.state;
	misc->bits.dummy = 0x3fffff;
	misc->dst_delta = app->settings.dst_delta;
	misc->timeout_policy = app->settings.timeout_policy;
	misc->dummy0 = 0xff;
	misc->hunt_cnt = app->settings.hunt_cnt;
	misc->timeout = app->settings.timeout;
	misc->message_time = app->settings.message_time;
	misc->addressable_time = app->settings.addressable_time;
	misc->timeout_cnt = app->settings.timeout_cnt;
	misc->location = app->settings.location;
	misc->utc_offset = app->settings.utc_offset;
	misc->dst_entry = app->settings.dst_entry;
	misc->dst_exit = app->settings.dst_exit;

#ifdef HAS_HDMI
    misc->aspect_ratio = app->settings.hd_config.aspect_ratio;
    misc->hd_options = app->settings.hd_config.hd_options;
    misc->output_format = app->settings.hd_config.output_format;
    misc->sharpness = app->settings.hd_config.sharpness;
#endif
    misc->sd_options = app->settings.sd_options;

	dberr = bast_delete_all(BAST_MISC_ID);
	if(BFDB_OK != dberr){
	BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
		goto ExitFunc;
	}

	dberr = bast_add(sst.db, BAST_MISC_ID, (uint8_t*)misc, sizeof(struct misc_settings_t));
	if(BFDB_OK != dberr){
		BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
	}

ExitFunc:
	return;
}

void bast_eas_save(bapp_t *app)
{
#if 0
    bfdb_err dberr;
    struct eas_settings_t * eas;

    eas = (struct eas_settings_t *)sst.data;
    eas->eas_filter_control = app->settings.eas_filter_control;
    eas->eas_state_code = app->settings.eas_state_code;
    eas->eas_county_subdivision = app->settings.eas_county_subdivision;
    eas->eas_county_code = app->settings.eas_county_code;

    dberr = bast_delete_all(BAST_EAS_ID);
    if(BFDB_OK != dberr){
        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
        goto ExitFunc;
    }

    dberr = bast_add(sst.db, BAST_EAS_ID, (uint8_t*)eas, sizeof(struct eas_settings_t));
    if(BFDB_OK != dberr){
        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
    }
ExitFunc:
#endif
    return;
}

bfdb_err bast_channel_map_erase(void)
{
	bfdb_err dberr;

	/* erase all components of the channel map, for VSB channel map */
	dberr = bast_delete_all(BAST_CHANNEL_MAP_ID);
	if(BFDB_OK != dberr){
		BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
		goto ExitFunc;
	}
ExitFunc:
	return dberr;
}

void bast_channel_map_save(bapp_t *app)
{
    bfdb_err dberr;
    struct ch_map_settings_t *ch;
	int count, i, j;

    dberr = bast_channel_map_erase();
    if(BFDB_OK != dberr){
        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
        return;
    }

    ch = (struct ch_map_settings_t *)sst.data;
    count = app->settings.num_channels;

	for (i = 0; i < count; i++) {
		ch->major = app->settings.ch[i].major;
		ch->minor = app->settings.ch[i].minor;
		ch->freq_idx = app->settings.ch[i].freq_idx;
		ch->psi = app->settings.ch[i].psi;
		ch->pcr_pid = app->settings.ch[i].pcr_pid;
		ch->video_pid = app->settings.ch[i].video_pid;
		ch->has_lang = app->settings.ch[i].has_lang;
		ch->hidden = app->settings.ch[i].hidden;
		ch->video_type = app->settings.ch[i].video_type;
		ch->program_num = app->settings.ch[i].program_num;
		ch->num_audio = app->settings.ch[i].num_audio;
		for (j = 0; j < MAX_AUDIO_PIDS; j++) {
			ch->audio_pid[j] = app->settings.ch[i].audio_pid[j];
			ch->audio_type[j] = app->settings.ch[i].audio_type[j];
			ch->audio_lang[j][0] = app->settings.ch[i].audio_lang[j][0];
			ch->audio_lang[j][1] = app->settings.ch[i].audio_lang[j][1];
			ch->audio_lang[j][2] = app->settings.ch[i].audio_lang[j][2];
		}
		for (j = 0; j < MAX_CH_SHORT_NAME_CHARS; j++) {
			ch->ch_name[j] = app->settings.ch[i].ch_name[j];
		}
		ch->frequency_khz = app->settings.ch[i].frequency_khz;
		ch->cur_audio = app->settings.ch[i].cur_audio;
		ch->source_id = app->settings.ch[i].source_id;
		ch->skip = app->settings.ch[i].skip;
		ch->favorite = app->settings.ch[i].favorite;
		dberr = bast_add(sst.db, BAST_CHANNEL_MAP_ID, (uint8_t*)ch, sizeof(struct ch_map_settings_t)); if(BFDB_OK != dberr){
			BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
			break;
		}
	}
}

#include "bchp_aon_ctrl.h"

#define bfds_ok 0
#define PHYS_TO_K1(x)   ((x) | 0xa0000000)
#define BCHP_K0_OFFSET 	(0xA0000000 | 0x10000000)
#define ReadReg32(x)	*((volatile unsigned int*)(BCHP_K0_OFFSET + (unsigned int)(x)))

#define normal_close 0x01
#define AC_operate 1

void turn_on_led_t(void)
{
	*(volatile unsigned long *)PHYS_TO_K1(0x10000000+0x00408020) = 0x00000001;
}


void AOV_turn_on_led_t(void)
{
	*(volatile unsigned long *)PHYS_TO_K1(0x10000000+0x00408c04) = 0x200;		/* set LED to green AON_GPIO_09 */
	*(volatile unsigned long *)PHYS_TO_K1(0x10000000+0x00408c08) = 0xFFFFFDEF;
}

int AC_standby()
{
	//add AC_onff
	bfds_handle test;
	unsigned char ACdata;
	unsigned int offset=0x3bfff0,len=1;
	//
	bfds_open(&test);	
	
	ACdata=normal_close;
	bfds_page_program(test, offset, &ACdata, len);
}

void AC_check(void)
{
	int i,sector_count=59; // 64kbyte 64EA block -> 59 for channel db avoid.
	bfds_handle test;
	unsigned int offset=0x3bfff0,erase_offset=0,len=1;
    bfds_properties fprop;
	unsigned char ACdata=0xff;
	uint32_t regi;

	//Read the wheather AC or remocon not
	regi = ReadReg32(BCHP_AON_CTRL_RESET_HISTORY);
	regi &= BCHP_AON_CTRL_RESET_HISTORY_power_on_reset_MASK;	

	//bfds open  & set erase zone
	bfds_open(&test);	

    bfds_get_properties(test, &fprop);

	for(i = 0; i < sector_count; i++){       
        erase_offset += fprop.flash_sector_size;
    }
		
	//1.check the value 
	bfds_read(test,offset,&ACdata,len);

	if(regi==AC_operate){	//AC on off
		if(ACdata==normal_close)
		{
			//2. power off.
			b_s3_standby(USERIO_ID);
			/* don't switch task, experimental till figure out the issue */
			while (1);
		}
	}
	//Remocon or front key on off
	//3.refresh value
	bfds_sector_erase(test,erase_offset);

#ifdef CONFIG_STANDBY
		turn_on_led_t(); /* turn on green LED when waking up */
#endif
		AOV_turn_on_led_t();

}

int bast_channel_read(bapp_t *app)
{
	bfdb_err dberr;
	struct channel_settings_t * channel;

	dberr =  bfdb_rewind(sst.db, BAST_CHANNEL_ID);
	if(BFDB_OK == dberr){
		dberr = bfdb_get(sst.db, sst.data, sizeof(struct channel_settings_t));
		if(BFDB_OK != dberr){
			BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
			goto ExitFunc;
		}
		channel = (struct channel_settings_t *)sst.data;
		app->settings.num_channels = channel->num_channels;
		app->cur_ch_num = channel->channel;
		app->settings.audio_vol = channel->volume;
		app->settings.rfm = channel->rfm;
	}
ExitFunc:
	return dberr;
}

int bast_misc_read(bapp_t *app)
{
	bfdb_err dberr;
	struct misc_settings_t * misc;

	dberr = bfdb_rewind(sst.db, BAST_MISC_ID);
	if(BFDB_OK == dberr){
		dberr = bfdb_get(sst.db, sst.data, sizeof(struct misc_settings_t));
		if(BFDB_OK != dberr){
			BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
			goto ExitFunc;
		}
		misc = (struct misc_settings_t *)sst.data;
		app->settings.standby = misc->bits.standby;
		app->settings.av_mute = misc->bits.av_mute;
		app->settings.psi_scan = misc->bits.psi_scan;
		app->settings.state = misc->bits.state;
		app->settings.dst_delta = misc->dst_delta;
		app->settings.timeout_policy = misc->timeout_policy;
		app->settings.hunt_cnt = misc->hunt_cnt;
		app->settings.timeout = misc->timeout;
		app->settings.max_location_errors = misc->max_location_errors;
		app->settings.location_errors = misc->location_errors;
		app->settings.message_time = misc->message_time;
		app->settings.turn_on_freq_khz = misc->turn_on_freq_khz;
		app->settings.addressable_time = misc->addressable_time;
		app->settings.timeout_cnt = misc->timeout_cnt;
		app->settings.location = misc->location;
		app->settings.utc_offset = misc->utc_offset;
		app->settings.dst_entry = misc->dst_entry;
		app->settings.dst_exit = misc->dst_exit;

#ifdef HAS_HDMI
		app->settings.hd_config.aspect_ratio = misc->aspect_ratio;
		app->settings.hd_config.hd_options = misc->hd_options;
		app->settings.hd_config.output_format = misc->output_format;
		app->settings.hd_config.sharpness = misc->sharpness;
#endif
		app->settings.sd_options = misc->sd_options;
	}
ExitFunc:
	return dberr;
}

int bast_eas_read(bapp_t *app)
{
#if 0
	bfdb_err dberr;
	struct eas_settings_t * eas;

	dberr = bfdb_rewind(sst.db, BAST_EAS_ID);
	if(BFDB_OK == dberr){
		dberr = bfdb_get(sst.db, sst.data, sizeof(struct eas_settings_t));
		if(BFDB_OK != dberr){
			BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
			goto ExitFunc;
		}
		eas = (struct eas_settings_t *)sst.data;
		app->settings.eas_filter_control = eas->eas_filter_control;
		app->settings.eas_state_code = eas->eas_state_code;
		app->settings.eas_county_subdivision = eas->eas_county_subdivision;
		app->settings.eas_county_code = eas->eas_county_code;
	}
ExitFunc:
	return dberr;
#endif
	return 0;
}

int bast_channel_map_read(bapp_t *app)
{
	bfdb_err dberr;
	struct ch_map_settings_t *ch;
	int i, j, count;

	dberr = bfdb_rewind(sst.db, BAST_CHANNEL_MAP_ID);
	if(BFDB_OK == dberr){
		ch = (struct ch_map_settings_t *)sst.data;
		count = app->settings.num_channels;
		for (i = 0; i < count; i++) {
			dberr = bfdb_get(sst.db, sst.data, sizeof(struct ch_map_settings_t));
			if(BFDB_OK != dberr){
				BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
				goto ExitFunc;
			}
			app->settings.ch[i].major = ch->major;
			app->settings.ch[i].minor = ch->minor;
			app->settings.ch[i].freq_idx = ch->freq_idx;
			app->settings.ch[i].psi = ch->psi;
			app->settings.ch[i].pcr_pid = ch->pcr_pid;
			app->settings.ch[i].video_pid = ch->video_pid;
			app->settings.ch[i].has_lang = ch->has_lang;
			app->settings.ch[i].hidden = ch->hidden;
			app->settings.ch[i].video_type = ch->video_type;
			app->settings.ch[i].program_num = ch->program_num;
			app->settings.ch[i].num_audio = ch->num_audio;
			for (j = 0; j < MAX_AUDIO_PIDS; j++) {
				app->settings.ch[i].audio_pid[j] = ch->audio_pid[j];
				app->settings.ch[i].audio_type[j] = ch->audio_type[j];
				app->settings.ch[i].audio_lang[j][0] = ch->audio_lang[j][0];
				app->settings.ch[i].audio_lang[j][1] = ch->audio_lang[j][1];
				app->settings.ch[i].audio_lang[j][2] = ch->audio_lang[j][2];
			}
			for (j = 0; j < MAX_CH_SHORT_NAME_CHARS; j++) {
				app->settings.ch[i].ch_name[j] = ch->ch_name[j];
			}
			app->settings.ch[i].frequency_khz = ch->frequency_khz;
			app->settings.ch[i].cur_audio = ch->cur_audio;
			app->settings.ch[i].source_id = ch->source_id;
			app->settings.ch[i].skip = ch->skip;
			app->settings.ch[i].favorite = ch->favorite;
			/* end of channel map */
			if (i >= (count - 1))
				return 0;
			dberr = bfdb_next(sst.db, BAST_CHANNEL_MAP_ID);
			if(BFDB_OK != dberr){
				BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
				goto ExitFunc;
			}
		}
	}
ExitFunc:
	return dberr;
}

void bast_block_save(uint32_t id, uint8_t size, uint8_t *data)
{
	bfdb_err dberr;

	dberr = bast_delete_all(id);
	if(BFDB_OK != dberr){
		BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
		goto ExitFunc;
	}
	/* create new record */
	dberr = bast_add(sst.db, id, data, size);
	if(BFDB_OK != dberr){
		BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
	}
ExitFunc:
	return;
}

/*
 * Summary:
 *     Save digital closed captioning settings.
 *      */


void bast_dcc_save(dcc_settings_t *settings)
{
	bfdb_err dberr;

	dberr = bast_delete_all(BAST_DCC_ID);
	if(BFDB_OK != dberr){
		BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
		goto ExitFunc;
	}
	/* create new record */
	dberr = bast_add(sst.db, BAST_DCC_ID, (uint8_t*)settings, sizeof(dcc_settings_t));
	if(BFDB_OK != dberr){
		BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
	}
ExitFunc:
	return;
}
/*
 * Summary:
 *     Read digital closed captioning settings.
 */

int bast_dcc_read(dcc_settings_t *settings)
{
	bfdb_err dberr;
	dberr = bfdb_rewind(sst.db, BAST_DCC_ID);
	if(BFDB_OK == dberr){
		dberr = bfdb_get(sst.db, (uint8_t*)settings, sizeof(dcc_settings_t));
		if(BFDB_OK != dberr){
			BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
		}
	}
	return dberr;
}

/*
 * Summary:
 *     Save ratings settings.
 *      */
void bast_ratings_save(ratings_settings_t *settings)
{
	bfdb_err dberr;

	dberr = bast_delete_all(BAST_RATINGS_ID);
	if(BFDB_OK != dberr){
		BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
		goto ExitFunc;
	}
	/* create new record */
	dberr = bast_add(sst.db, BAST_RATINGS_ID, (uint8_t*)settings, sizeof(ratings_settings_t));
	if(BFDB_OK != dberr){
		BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
	}
ExitFunc:
	return;
}
/*
 * Summary:
 *     Read ratings settings.
 *      */

int bast_ratings_read(ratings_settings_t *settings)
{
	bfdb_err dberr;
	dberr = bfdb_rewind(sst.db, BAST_RATINGS_ID);
	if(BFDB_OK == dberr){
		dberr = bfdb_get(sst.db, (uint8_t*)settings, sizeof(ratings_settings_t));
		if(BFDB_OK != dberr){
			BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
		}
	}
	return dberr;
}

/*
 * Summary:
 *     Save RRT settings.
 *      */
void bast_rrt_save(rrt_settings_t *settings)
{
	bfdb_err dberr;
	uint32_t size;

	dberr = bast_delete_all(BAST_RRT_SETTINGS_ID);
	dberr |= bast_delete_all(BAST_RRT_DIM_0);
	dberr |= bast_delete_all(BAST_RRT_DIM_1);
	dberr |= bast_delete_all(BAST_RRT_DIM_2);
	dberr |= bast_delete_all(BAST_RRT_TBL_0);
	dberr |= bast_delete_all(BAST_RRT_TBL_1);
	dberr |= bast_delete_all(BAST_RRT_TBL_2);
	dberr |= bast_delete_all(BAST_RRT_TBL_3);
	dberr |= bast_delete_all(BAST_RRT_TBL_4);
	if(BFDB_OK != dberr){
		BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
		goto ExitFunc;
	}

	size = (uint32_t)(&(settings->ratings_rrt[0])) - (uint32_t)settings;
	/* create new record */
	dberr = bast_add(sst.db, BAST_RRT_SETTINGS_ID, (uint8_t*)settings, size);
	if(BFDB_OK != dberr){
		BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
	}
	dberr = bast_add(sst.db, BAST_RRT_DIM_0, (uint8_t*)settings->ratings_rrt, 0xFF);
	if(BFDB_OK != dberr){
		BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
	}
	dberr = bast_add(sst.db, BAST_RRT_DIM_1, (uint8_t*)&(settings->ratings_rrt[0xFF]),
			sizeof(unsigned short) * MAX_RRT_DIM/2);
	if(BFDB_OK != dberr){
		BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
	}
	dberr = bast_add(sst.db, BAST_RRT_DIM_2, (uint8_t*)&(settings->ratings_rrt[0xFF * 2]),2);
	if(BFDB_OK != dberr){
		BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
	}
	dberr = bast_add(sst.db, BAST_RRT_TBL_0, (uint8_t*)settings->rrt, 0xFF);
	if(BFDB_OK != dberr){
		BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
	}
	dberr = bast_add(sst.db, BAST_RRT_TBL_1, (uint8_t*)&(settings->rrt[0xFF]), 0xFF);
	if(BFDB_OK != dberr){
		BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
	}
	dberr = bast_add(sst.db, BAST_RRT_TBL_2, (uint8_t*)&(settings->rrt[2*0xFF]),0xFF);
	if(BFDB_OK != dberr){
		BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
	}
	dberr = bast_add(sst.db, BAST_RRT_TBL_3, (uint8_t*)&(settings->rrt[3*0xFF]),0xFF);
	if(BFDB_OK != dberr){
		BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
	}
	dberr = bast_add(sst.db, BAST_RRT_TBL_4, (uint8_t*)&(settings->rrt[4*0xFF]),4);
	if(BFDB_OK != dberr){
		BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
	}
ExitFunc:
	return;
}
/*
 * Summary:
 *     Read RRT settings.
 *      */

int bast_rrt_read(rrt_settings_t *settings)
{
	bfdb_err dberr;
	uint32_t size;

	dberr = bfdb_rewind(sst.db, BAST_RRT_SETTINGS_ID);
	if(BFDB_OK == dberr){
		size = (uint32_t)(&(settings->ratings_rrt[0])) - (uint32_t)settings;
		dberr = bfdb_get(sst.db, (uint8_t*)settings, size);
		if(BFDB_OK != dberr){
			BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
		}
	}

	dberr = bfdb_rewind(sst.db, BAST_RRT_DIM_0);
	if(BFDB_OK == dberr){
		dberr = bfdb_get(sst.db, (uint8_t*)settings->ratings_rrt, 0xFF);
		if(BFDB_OK != dberr){
			BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
		}
	}

	dberr = bfdb_rewind(sst.db, BAST_RRT_DIM_1);
	if(BFDB_OK == dberr){
		dberr = bfdb_get(sst.db, (uint8_t*)&(settings->ratings_rrt[0xFF]),0xFF);
		if(BFDB_OK != dberr){
			BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
		}
	}

	dberr = bfdb_rewind(sst.db, BAST_RRT_DIM_2);
	if(BFDB_OK == dberr){
		dberr = bfdb_get(sst.db, (uint8_t*)&(settings->ratings_rrt[2*0xFF]),2);
		if(BFDB_OK != dberr){
			BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
		}
	}

	dberr = bfdb_rewind(sst.db, BAST_RRT_TBL_0);
	if(BFDB_OK == dberr){
		dberr = bfdb_get(sst.db, (uint8_t*)settings->rrt, 0xFF);
		if(BFDB_OK != dberr){
			BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
		}
	}

	dberr = bfdb_rewind(sst.db, BAST_RRT_TBL_1);
	if(BFDB_OK == dberr){
		dberr = bfdb_get(sst.db, (uint8_t*)&(settings->rrt[0xFF]),0xFF);
		if(BFDB_OK != dberr){
			BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
		}
	}

	dberr = bfdb_rewind(sst.db, BAST_RRT_TBL_2);
	if(BFDB_OK == dberr){
		dberr = bfdb_get(sst.db, (uint8_t*)&(settings->rrt[2*0xFF]),0xFF);
		if(BFDB_OK != dberr){
			BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
		}
	}

	dberr = bfdb_rewind(sst.db, BAST_RRT_TBL_3);
	if(BFDB_OK == dberr){
		dberr = bfdb_get(sst.db, (uint8_t*)&(settings->rrt[3*0xFF]),0xFF);
		if(BFDB_OK != dberr){
			BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
		}
	}

	dberr = bfdb_rewind(sst.db, BAST_RRT_TBL_4);
	if(BFDB_OK == dberr){
		dberr = bfdb_get(sst.db, (uint8_t*)&(settings->rrt[4*0xFF]),4);
		if(BFDB_OK != dberr){
			BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
		}
	}

	return dberr;
}

/*
 * Summary:
 * Save menu settings
 */
void bast_screen_save(bapp_t *app)
{
	bfdb_err dberr;
	struct screen_settings_t *screen;

	screen = (struct screen_settings_t *)sst.data;
	screen->sound = app->settings.sound; 
	screen->picture = app->settings.picture; 
	screen->language = app->settings.language; 
	screen->wiz_completed = app->settings.wiz_completed; 
	screen->ratings_lock = app->settings.ratings.ratings_lock; 
	screen->ratings_tv = app->settings.ratings.ratings_tv; 
	screen->ratings_movies = app->settings.ratings.ratings_movies;
	screen->content_d = app->settings.ratings.content_d; 
	screen->content_l =  app->settings.ratings.content_l; 
	screen->content_s = app->settings.ratings.content_s; 
	screen->content_v = app->settings.ratings.content_v; 
	screen->captions_basic = app->settings.dcc.captions_basic;
	screen->captions_font = app->settings.dcc.captions_font; 
	screen->captions_font_size = app->settings.dcc.captions_font_size; 
	screen->captions_font_style = app->settings.dcc.captions_font_style; 
	screen->captions_font_color = app->settings.dcc.captions_font_color; 
	screen->captions_font_opacity = app->settings.dcc.captions_font_opacity; 
	screen->captions_back_color = app->settings.dcc.captions_back_color; 
	screen->captions_back_opacity = app->settings.dcc.captions_back_opacity; 
	screen->captions_edge_color = app->settings.dcc.captions_edge_color; 
	screen->captions_edge_type = app->settings.dcc.captions_edge_type; 
	screen->rrt_status = app->settings.rrt_settings.rrt_status; 
	screen->time_zone = app->settings.time_zone; 
	screen->dst =  app->settings.dst; 
	screen->last_rrt_id = app->settings.rrt_settings.last_rrt_id; 
	screen->pin = app->settings.rrt_settings.pin;
	screen->auto_power = app->settings.auto_power;	
	screen->auto_power_off = app->settings.auto_power_off;
	screen->analog_captioning = app->settings.dcc.captions_analog;

	dberr = bast_delete_all(BAST_SCREEN_ID);
	if(BFDB_OK != dberr){
		BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
		goto ExitFunc;
	}

	dberr = bast_add(sst.db, BAST_SCREEN_ID, (uint8_t*)screen, sizeof(struct screen_settings_t));
	if(BFDB_OK != dberr){
		BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
	}
ExitFunc:
	return;
}

/*
 * Summary:
 * Read menu settings
 */
int bast_screen_read(bapp_t *app)
{
	bfdb_err dberr;
	struct screen_settings_t *screen;

	dberr = bfdb_rewind(sst.db, BAST_SCREEN_ID);
	if (BFDB_OK == dberr) {
		dberr = bfdb_get(sst.db, sst.data, sizeof(struct screen_settings_t));
		if (dberr != BFDB_OK) {
			BDBG_ERR(("Error:%d line:%d", dberr, __LINE__));
			goto ExitFunc;
		}
		screen = (struct screen_settings_t *)sst.data;
		app->settings.sound = screen->sound;
		app->settings.picture = screen->picture;
		app->settings.language = screen->language;
		app->settings.wiz_completed = screen->wiz_completed;
		app->settings.ratings.ratings_lock = screen->ratings_lock;
		app->settings.ratings.ratings_tv = screen->ratings_tv;
		app->settings.ratings.content_d = screen->content_d;
		app->settings.ratings.content_l = screen->content_l;
		app->settings.ratings.content_s = screen->content_s;
		app->settings.ratings.content_v = screen->content_v;
		app->settings.ratings.ratings_movies = screen->ratings_movies;
		app->settings.dcc.captions_basic = screen->captions_basic;
		app->settings.dcc.captions_font = screen->captions_font;
		app->settings.dcc.captions_font_size = screen->captions_font_size;
		app->settings.dcc.captions_font_style = screen->captions_font_style;
		app->settings.dcc.captions_font_color = screen->captions_font_color;
		app->settings.dcc.captions_font_opacity = screen->captions_font_opacity;
		app->settings.dcc.captions_back_color = screen->captions_back_color;
		app->settings.dcc.captions_back_opacity = screen->captions_back_opacity;
		app->settings.dcc.captions_edge_color = screen->captions_edge_color;
		app->settings.dcc.captions_edge_type = screen->captions_edge_type;
		app->settings.rrt_settings.rrt_status = screen->rrt_status;
		app->settings.time_zone = screen->time_zone;
		app->settings.dst = screen->dst;
		app->settings.rrt_settings.last_rrt_id = screen->last_rrt_id;
		app->settings.rrt_settings.pin = screen->pin;
		app->settings.auto_power = screen->auto_power;
		app->settings.auto_power_off = screen->auto_power_off;
		app->settings.dcc.captions_analog = screen->analog_captioning;
	}
ExitFunc:	
	return dberr;
}