source: svn/trunk/newcon3bcm2_21bu/dta/src/app/nanotv/bapp_settings.c

Last change on this file was 2, checked in by phkim, 11 years ago

1.phkim

  1. revision copy newcon3sk r27
  • Property svn:executable set to *
File size: 41.9 KB
Line 
1/******************************************************************************
2 *    (c)2008-2009 Broadcom Corporation
3 *
4 * This program is the proprietary software of Broadcom Corporation and/or its licensors,
5 * and may only be used, duplicated, modified or distributed pursuant to the terms and
6 * conditions of a separate, written license agreement executed between you and Broadcom
7 * (an "Authorized License").  Except as set forth in an Authorized License, Broadcom grants
8 * no license (express or implied), right to use, or waiver of any kind with respect to the
9 * Software, and Broadcom expressly reserves all rights in and to the Software and all
10 * intellectual property rights therein.  IF YOU HAVE NO AUTHORIZED LICENSE, THEN YOU
11 * HAVE NO RIGHT TO USE THIS SOFTWARE IN ANY WAY, AND SHOULD IMMEDIATELY
12 * NOTIFY BROADCOM AND DISCONTINUE ALL USE OF THE SOFTWARE.
13 *
14 * Except as expressly set forth in the Authorized License,
15 *
16 * 1.     This program, including its structure, sequence and organization, constitutes the valuable trade
17 * secrets of Broadcom, and you shall use all reasonable efforts to protect the confidentiality thereof,
18 * and to use this information only in connection with your use of Broadcom integrated circuit products.
19 *
20 * 2.     TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE SOFTWARE IS PROVIDED "AS IS"
21 * AND WITH ALL FAULTS AND BROADCOM MAKES NO PROMISES, REPRESENTATIONS OR
22 * WARRANTIES, EITHER EXPRESS, IMPLIED, STATUTORY, OR OTHERWISE, WITH RESPECT TO
23 * THE SOFTWARE.  BROADCOM SPECIFICALLY DISCLAIMS ANY AND ALL IMPLIED WARRANTIES
24 * OF TITLE, MERCHANTABILITY, NONINFRINGEMENT, FITNESS FOR A PARTICULAR PURPOSE,
25 * LACK OF VIRUSES, ACCURACY OR COMPLETENESS, QUIET ENJOYMENT, QUIET POSSESSION
26 * OR CORRESPONDENCE TO DESCRIPTION. YOU ASSUME THE ENTIRE RISK ARISING OUT OF
27 * USE OR PERFORMANCE OF THE SOFTWARE.
28 *
29 * 3.     TO THE MAXIMUM EXTENT PERMITTED BY LAW, IN NO EVENT SHALL BROADCOM OR ITS
30 * LICENSORS BE LIABLE FOR (i) CONSEQUENTIAL, INCIDENTAL, SPECIAL, INDIRECT, OR
31 * EXEMPLARY DAMAGES WHATSOEVER ARISING OUT OF OR IN ANY WAY RELATING TO YOUR
32 * USE OF OR INABILITY TO USE THE SOFTWARE EVEN IF BROADCOM HAS BEEN ADVISED OF
33 * THE POSSIBILITY OF SUCH DAMAGES; OR (ii) ANY AMOUNT IN EXCESS OF THE AMOUNT
34 * ACTUALLY PAID FOR THE SOFTWARE ITSELF OR U.S. $1, WHICHEVER IS GREATER. THESE
35 * LIMITATIONS SHALL APPLY NOTWITHSTANDING ANY FAILURE OF ESSENTIAL PURPOSE OF
36 * ANY LIMITED REMEDY.
37 *
38 * $brcm_Workfile:  $
39 * $brcm_Revision:  $
40 * $brcm_Date:  $
41 *
42 * Module Description:
43 *
44 * Manage application settings like volume, channel map, etc.
45 *
46 * Revision History:
47 *
48 * Created: 09/28/2009 by Jeff Fisher
49 *
50 * $brcm_Log:  $
51 *
52 *
53 *****************************************************************************/
54#include "bstd.h"
55#include "bkni.h"
56#include "bdbg.h"
57
58#include "bapp.h"
59#include "bapp_settings.h"
60#include "bfdb.h"
61#include "bspi_flash.h"
62
63BDBG_MODULE(bast);              /* Register software module with debug interface */
64
65
66struct settings_state_t {
67        bfdb_handle db;
68        uint8_t data[BFDB_DATA_MAX];
69};
70
71static struct settings_state_t sst;
72
73static bfdb_err bast_add(bfdb_handle handle, uint8_t id, uint8_t *data, size_t size);
74
75/*
76 * Flash configuration. for most flashes sector size and page size should be
77 * left at default. Offset is a starting offset of database from the beginning
78 * of the flash. DB_SIZE and DB_OFFSET must be divisible by SECTOR_SIZE
79 */
80
81#define FLASH_PAGE_SIZE         0x100
82#define FLASH_SECTOR_SIZE       0x10000
83#define FLASH_DB_SIZE           0x40000
84#define FLASH_DB_OFFSET         (0x400000 - FLASH_DB_SIZE)
85#define MEM_DB_OFFSET           0
86#define MEM_DB_SIZE                     FLASH_DB_SIZE
87
88/*
89 * Open and initialize database.
90 */
91void bast_init(bapp_t *app)
92{
93        bfdb_err dberr;
94        struct bfdb_settings dbset;
95        bspi_settings_t spi_settings;
96        bresult rc;
97
98        rc = bspi_identify(&spi_settings);
99        BDBG_ASSERT(rc == b_ok);
100
101        dbset.page_size = FLASH_PAGE_SIZE;
102        dbset.sector_size = spi_settings.sector_size;
103        dbset.db_offset = FLASH_DB_OFFSET;
104        dbset.db_size = FLASH_DB_SIZE;
105
106        BKNI_Memset(&sst, 0, sizeof(struct settings_state_t));
107        dberr = bfdb_open(&dbset, &sst.db);
108        if (BFDB_OK != dberr) {
109                BDBG_ERR(("Error:%d line:%d", dberr, __LINE__));
110                if (BFDB_LOG_ERROR == dberr) {
111                        dberr = bfdb_erase(sst.db);
112                        if (BFDB_OK != dberr) {
113                                BDBG_ERR(("Error:%d line:%d", dberr, __LINE__));
114                        }
115                }
116        }
117}       
118
119bfdb_err bast_delete_all(uint8_t id)
120{
121        bfdb_err dberr;
122
123        dberr = bfdb_rewind(sst.db, id);
124        switch(dberr) {
125        case BFDB_OK:
126                /* we have records in database, delete them */
127                do {
128                        dberr = bfdb_delete(sst.db);
129                        if (BFDB_OK != dberr) {
130                                BDBG_ERR(("Error:%d line:%d", dberr, __LINE__));
131                                goto ExitFunc;
132                        }
133                        dberr = bfdb_next(sst.db, id);
134                } while (BFDB_OK == dberr);
135        case BFDB_RECORD_NOT_FOUND:
136                dberr = BFDB_OK;
137                break;
138        default:
139                BDBG_ERR(("Error:%d line:%d", dberr, __LINE__));
140        }
141ExitFunc:
142        return dberr;
143}
144
145/* add with compact if add fails */
146bfdb_err bast_add(bfdb_handle handle, uint8_t id, uint8_t *data, size_t size)
147{
148        bfdb_err dberr;
149       
150        do {
151                dberr = bfdb_add(handle, id, data, size);
152                if (BFDB_LOG_FULL == dberr) {
153                        dberr = bfdb_compact(handle);
154                        if (BFDB_OK == dberr) {
155                                dberr = BFDB_LOG_FULL;
156                        }
157                }
158        } while (BFDB_LOG_FULL == dberr);
159        return dberr;
160}
161
162void bast_channel_save(bapp_t *app)
163{
164        bfdb_err dberr;
165        struct channel_settings_t *channel;
166
167        /* use data memory block */
168        channel = (struct channel_settings_t *)sst.data;
169        channel->channel = app->settings.ch_map.cur_ch;
170        channel->volume = app->settings.audio_vol;
171
172        dberr = bast_delete_all(BAST_CHANNEL_ID);
173        if (BFDB_OK != dberr)
174        {
175                BDBG_ERR(("Error:%d line:%d", dberr, __LINE__));
176                goto ExitFunc;
177        }
178
179        /* create new record */
180        dberr = bast_add(sst.db, BAST_CHANNEL_ID, (uint8_t *)channel, sizeof(struct channel_settings_t));
181        if (BFDB_OK != dberr) {
182                BDBG_ERR(("Error:%d line:%d", dberr, __LINE__));
183        }
184ExitFunc:
185        return;
186}
187
188void bast_misc_save(bapp_t *app)
189{
190        bfdb_err dberr;
191        struct misc_settings_t *misc;
192
193        misc = (struct misc_settings_t *)sst.data;
194        misc->bits.activated = app->settings.activated;
195        misc->bits.deactivated = app->settings.deactivated;
196        misc->bits.standby = app->settings.standby;
197        misc->bits.has_CAT = app->settings.has_CAT;
198        misc->bits.av_mute = app->settings.av_mute;
199        misc->bits.psi_scan = app->settings.psi_scan;
200        misc->bits.state = app->settings.state;
201        misc->bits.dummy = 0x3fffff;
202        misc->dst_delta = app->settings.dst_delta;
203        misc->timeout_policy = app->settings.timeout_policy;
204        misc->SCP_operating_mode = app->settings.SCP_operating_mode;
205        misc->dummy0 = 0xff;
206        misc->CA_System_ID = app->settings.CA_System_ID;
207        misc->EMM_Provider_ID = app->settings.EMM_Provider_ID;
208        misc->EMM_PID = app->settings.EMM_PID;
209        misc->VCT_ID = app->settings.VCT_ID;
210        misc->network_PID = app->settings.network_PID;
211        misc->hunt_cnt = app->settings.hunt_cnt;
212        misc->download_failed_cnt = app->settings.download_failed_cnt;
213        misc->download_invalid_cnt = app->settings.download_invalid_cnt;
214        misc->timeout = app->settings.timeout;
215        misc->max_location_errors = app->settings.max_location_errors;
216        misc->location_errors = app->settings.location_errors;
217        misc->message_time = app->settings.message_time;
218        misc->turn_on_freq_khz = app->settings.turn_on_freq_khz;
219        misc->addressable_time = app->settings.addressable_time;
220        misc->timeout_cnt = app->settings.timeout_cnt;
221        misc->location = app->settings.location;
222        misc->utc_offset = app->settings.utc_offset;
223        misc->dst_entry = app->settings.dst_entry;
224        misc->dst_exit = app->settings.dst_exit;
225
226    misc->aspect_ratio = app->settings.hd_config.aspect_ratio;
227    misc->hd_options = app->settings.hd_config.hd_options;
228    misc->output_format = app->settings.hd_config.output_format;
229    misc->sharpness = app->settings.hd_config.sharpness;
230    misc->sd_options = app->settings.sd_options;
231
232        dberr = bast_delete_all(BAST_MISC_ID);
233        if(BFDB_OK != dberr){
234        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
235                goto ExitFunc;
236        }
237
238        dberr = bast_add(sst.db, BAST_MISC_ID, (uint8_t*)misc, sizeof(struct misc_settings_t));
239        if(BFDB_OK != dberr){
240                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
241        }
242
243ExitFunc:
244        return;
245}
246
247void bast_eas_save(bapp_t *app)
248{
249#if 0
250    bfdb_err dberr;
251    struct eas_settings_t * eas;
252
253    eas = (struct eas_settings_t *)sst.data;
254    eas->eas_filter_control = app->settings.eas_filter_control;
255    eas->eas_state_code = app->settings.eas_state_code;
256    eas->eas_county_subdivision = app->settings.eas_county_subdivision;
257    eas->eas_county_code = app->settings.eas_county_code;
258
259    dberr = bast_delete_all(BAST_EAS_ID);
260    if(BFDB_OK != dberr){
261        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
262        goto ExitFunc;
263    }
264
265    dberr = bast_add(sst.db, BAST_EAS_ID, (uint8_t*)eas, sizeof(struct eas_settings_t));
266    if(BFDB_OK != dberr){
267        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
268    }
269ExitFunc:
270#endif
271    return;
272}
273
274void bast_phone_number_save(bapp_t *app)
275{
276        bfdb_err dberr;
277        size_t len;
278        struct phone_number_settings_t *phone;
279
280        phone = (struct phone_number_settings_t *)sst.data;
281        len = strlen(app->settings.phonenumber);
282        if (len > (MAX_PHONE_LEN-2)) {
283                BDBG_ERR(("Truncating phone number"));
284                len = (MAX_PHONE_LEN-2);
285        }
286
287        phone->size = len;
288        strcpy(phone->data, app->settings.phonenumber);
289
290        dberr = bast_delete_all(BAST_PHONE_NUMBER_ID);
291        if(BFDB_OK != dberr){
292                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
293                goto ExitFunc;
294        }
295        dberr = bast_add(sst.db, BAST_PHONE_NUMBER_ID, (uint8_t*)phone, len+1);
296        if(BFDB_OK != dberr){
297                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
298        }
299ExitFunc:
300        return;
301}
302
303bfdb_err bast_channel_map_erase(void)
304{
305
306        bfdb_err dberr;
307        /* erase all components of the channel map */
308        dberr = bast_delete_all(BAST_CHANNEL_MAP_HEADER_ID);
309        if(BFDB_OK != dberr){
310                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
311                goto ExitFunc;
312        }
313        dberr = bast_delete_all(BAST_MMS_ENTRY_ID);
314        if(BFDB_OK != dberr){
315                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
316                goto ExitFunc;
317        }
318        dberr = bast_delete_all(BAST_FREQ_ENTRY_ID);
319        if(BFDB_OK != dberr){
320                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
321                goto ExitFunc;
322        }
323        dberr = bast_delete_all(BAST_ST_ENTRY_ID);
324        if(BFDB_OK != dberr){
325                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
326                goto ExitFunc;
327        }
328        dberr = bast_delete_all(BAST_VCH_ENTRY_ID);
329        if(BFDB_OK != dberr){
330                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
331        }
332ExitFunc:
333        return dberr;
334}
335
336#define BAST_MAX_ITEM 8
337
338bfdb_err bast_mms_save(bapp_t *app)
339{
340        bfdb_err dberr;
341        unsigned int mms_count;
342        unsigned int i, j;
343        struct mms_entry_settings_t * mms;
344
345        dberr = BFDB_OK;
346        mms = (struct mms_entry_settings_t *)sst.data;
347        mms_count = app->settings.ch_map.mms_map.num_mms;
348
349        for(i = 0; i < mms_count; ){
350                j = 0;
351                while((j < BAST_MAX_ITEM) && (i < mms_count)){
352                        mms->mms[j].idx = app->settings.ch_map.mms_map.mms[i].idx;
353                        mms->mms[j].code_rate = app->settings.ch_map.mms_map.mms[i].code_rate;
354                        mms->mms[j].modulation = app->settings.ch_map.mms_map.mms[i].modulation;
355                        mms->mms[j].symbol_rate = app->settings.ch_map.mms_map.mms[i].symbol_rate;
356                        j++; i++;
357                }
358
359                /* fill unused values */
360                while(j < BAST_MAX_ITEM){
361                        mms->mms[j].idx = 0xff;
362                        mms->mms[j].code_rate = 0xff;
363                        mms->mms[j].modulation = 0xff;
364                        mms->mms[j].symbol_rate = 0xffffffff;
365                        j++;
366                }
367
368                dberr = bast_add(sst.db, BAST_MMS_ENTRY_ID, (uint8_t*)mms, sizeof(struct mms_entry_settings_t));
369                if(BFDB_OK != dberr){
370                        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
371                        goto ExitFunc;
372                }
373        }
374
375ExitFunc:
376        return dberr;
377}
378
379bfdb_err bast_freq_save(bapp_t *app)
380{
381        bfdb_err dberr;
382        unsigned int i, j;
383        struct freq_entry_settings_t * fr;
384        unsigned int freq_count;
385
386        dberr = BFDB_OK;
387        fr = (struct freq_entry_settings_t*)sst.data;
388        freq_count = app->settings.ch_map.freq_map.num_freq;
389
390        for(i = 0; i < freq_count; ){
391                j = 0;
392                while((j < BAST_MAX_ITEM) && (i < freq_count)){
393                        fr->freq[j].idx = app->settings.ch_map.freq_map.freq[i].idx;
394                        fr->freq[j].freq_khz = app->settings.ch_map.freq_map.freq[i].freq_khz;
395                        i++; j++;
396                }
397
398                /* fill unused values */
399                while(j < BAST_MAX_ITEM){
400                        fr->freq[j].idx = 0xff;
401                        fr->freq[j].freq_khz = 0xffffffff;
402                        j++;
403                }
404
405                dberr = bast_add(sst.db, BAST_FREQ_ENTRY_ID, (uint8_t*)fr, sizeof(struct freq_entry_settings_t));
406                if(BFDB_OK != dberr){
407                        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
408                        goto ExitFunc;
409                }
410        }
411ExitFunc:
412        return dberr;
413}
414
415bfdb_err bast_st_save(bapp_t *app)
416{
417        bfdb_err dberr;
418        unsigned int i;
419        unsigned int st_count;
420        struct st_entry_settings_t * st;
421
422        dberr = BFDB_OK;
423        st = (struct st_entry_settings_t*)sst.data;
424        st_count = app->settings.ch_map.st_map.num_st;
425        for(i = 0 ; i < st_count; i++){
426                BKNI_Memset(st, 0xff, sizeof(struct st_entry_settings_t));
427                st->source_id = app->settings.ch_map.st_map.st[i].source_id;
428                strcpy(st->name, app->settings.ch_map.st_map.st[i].name);
429
430                dberr = bast_add(sst.db, BAST_ST_ENTRY_ID, (uint8_t*)st, sizeof(struct st_entry_settings_t));
431                if(BFDB_OK != dberr){
432                        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
433                        goto ExitFunc;
434                }
435        }
436
437ExitFunc:
438        return dberr;
439}
440
441bfdb_err bast_vch_save(bapp_t *app)
442{
443    bfdb_err dberr;
444    unsigned i,j;
445    unsigned vch_count;
446    struct vch_entry_settings_t * vch;
447
448    dberr = BFDB_OK;
449    vch = (struct vch_entry_settings_t *)sst.data;
450    vch_count = app->settings.ch_map.vch_map.num_vch;
451
452    for(i = 0; i < vch_count; i++){
453        vch->ch_num = app->settings.ch_map.vch_map.vch[i].ch_num;
454        vch->source_id = app->settings.ch_map.vch_map.vch[i].source_id;
455        vch->program_num = app->settings.ch_map.vch_map.vch[i].program_num;
456        vch->pcr_pid = app->settings.ch_map.vch_map.vch[i].pcr_pid;
457        vch->scte127_pid = app->settings.ch_map.vch_map.vch[i].scte127_pid;
458        vch->video_pid = app->settings.ch_map.vch_map.vch[i].video_pid;
459        vch->video_type = app->settings.ch_map.vch_map.vch[i].video_type;
460        vch->ca_pid = app->settings.ch_map.vch_map.vch[i].ca_pid;
461        vch->freq_idx = app->settings.ch_map.vch_map.vch[i].freq_idx;
462        vch->mms_idx = app->settings.ch_map.vch_map.vch[i].mms_idx;
463        vch->vchflags = app->settings.ch_map.vch_map.vch[i].vchflags;
464        vch->audio_count = app->settings.ch_map.vch_map.vch[i].num_audio;
465        vch->audio_current = app->settings.ch_map.vch_map.vch[i].cur_audio;
466        for(j = 0; j < VCH_MAX_AUDIO; j++){
467            vch->audio_pid[j] = app->settings.ch_map.vch_map.vch[i].audio_pid[j];
468            vch->audio_type[j] = app->settings.ch_map.vch_map.vch[i].audio_type[j];
469            vch->audio_lang[j][0] = app->settings.ch_map.vch_map.vch[i].audio_lang[j][0];
470            vch->audio_lang[j][1] = app->settings.ch_map.vch_map.vch[i].audio_lang[j][1];
471            vch->audio_lang[j][2] = app->settings.ch_map.vch_map.vch[i].audio_lang[j][2];
472        }
473#ifdef CONFIG_DVB_SUBTITLE
474                vch->dsub_count = app->settings.ch_map.vch_map.vch[i].num_dsub;
475                vch->dsub_current = app->settings.ch_map.vch_map.vch[i].cur_dsub;
476                for (j=0; j<VCH_MAX_DSUB; j++) {
477                        vch->dsub_pid[j] = app->settings.ch_map.vch_map.vch[i].dsub_pid[j];
478                        vch->dsub_lang[j][0] = app->settings.ch_map.vch_map.vch[i].dsub_lang[j][0];
479                        vch->dsub_lang[j][1] = app->settings.ch_map.vch_map.vch[i].dsub_lang[j][1];
480                        vch->dsub_lang[j][2] = app->settings.ch_map.vch_map.vch[i].dsub_lang[j][2];
481                        vch->dsub_page[j] = app->settings.ch_map.vch_map.vch[i].dsub_page[j];
482                }
483#endif
484        dberr = bast_add(sst.db, BAST_VCH_ENTRY_ID, (uint8_t*)vch, sizeof(struct vch_entry_settings_t));
485        if(BFDB_OK != dberr){
486            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
487            goto ExitFunc;
488        }
489    }
490ExitFunc:
491    return dberr;
492}
493
494void bast_channel_map_save(bapp_t *app)
495{
496    bfdb_err dberr;
497    struct channel_map_header_settings_t * header;
498
499    dberr = bast_channel_map_erase();
500    if(BFDB_OK != dberr){
501        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
502        goto ExitFunc;
503    }
504
505    header = (struct channel_map_header_settings_t *)sst.data;
506    header->mms_count = app->settings.ch_map.mms_map.num_mms;
507    header->freq_count = app->settings.ch_map.freq_map.num_freq;
508    header->st_count = app->settings.ch_map.st_map.num_st;
509    header->vch_count = app->settings.ch_map.vch_map.num_vch;
510
511    if(0 != (header->mms_count + header->freq_count + header->st_count + header->vch_count)){
512
513        dberr = bast_add(sst.db, BAST_CHANNEL_MAP_HEADER_ID, (uint8_t*)header, sizeof(struct channel_map_header_settings_t));
514        if(BFDB_OK != dberr){
515            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
516            goto ExitFunc;
517        }
518
519        dberr = bast_mms_save(app);
520        if(BFDB_OK != dberr){
521            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
522            goto ExitFunc;
523        }
524        dberr = bast_freq_save(app);
525        if(BFDB_OK != dberr){
526            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
527            goto ExitFunc;
528        }
529        dberr = bast_st_save(app);
530        if(BFDB_OK != dberr){
531            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
532            goto ExitFunc;
533        }
534        dberr = bast_vch_save(app);
535        if(BFDB_OK != dberr){
536            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
537            goto ExitFunc;
538        }
539
540        if(BFDB_OK != dberr)
541            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
542    }
543ExitFunc:
544    return;
545}
546
547int bast_channel_read(bapp_t *app)
548{
549    bfdb_err dberr;
550    struct channel_settings_t * channel;
551
552    dberr =  bfdb_rewind(sst.db, BAST_CHANNEL_ID);
553    if(BFDB_OK == dberr){
554        dberr = bfdb_get(sst.db, sst.data, sizeof(struct channel_settings_t));
555        if(BFDB_OK != dberr){
556            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
557            goto ExitFunc;
558        }
559        channel = (struct channel_settings_t *)sst.data;
560        app->settings.ch_map.cur_ch = channel->channel;
561        app->settings.audio_vol = channel->volume;
562    }
563ExitFunc:
564    return dberr;
565}
566
567int bast_misc_read(bapp_t *app)
568{
569    bfdb_err dberr;
570    struct misc_settings_t * misc;
571
572    dberr = bfdb_rewind(sst.db, BAST_MISC_ID);
573    if(BFDB_OK == dberr){
574        dberr = bfdb_get(sst.db, sst.data, sizeof(struct misc_settings_t));
575        if(BFDB_OK != dberr){
576            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
577            goto ExitFunc;
578        }
579        misc = (struct misc_settings_t *)sst.data;
580        app->settings.activated = misc->bits.activated;
581        app->settings.deactivated = misc->bits.deactivated;
582        app->settings.standby = misc->bits.standby;
583        app->settings.has_CAT = misc->bits.has_CAT;
584        app->settings.av_mute = misc->bits.av_mute;
585        app->settings.psi_scan = misc->bits.psi_scan;
586        app->settings.state = misc->bits.state;
587        app->settings.dst_delta = misc->dst_delta;
588        app->settings.timeout_policy = misc->timeout_policy;
589        app->settings.SCP_operating_mode = misc->SCP_operating_mode;
590        app->settings.CA_System_ID = misc->CA_System_ID;
591        app->settings.EMM_Provider_ID = misc->EMM_Provider_ID;
592        app->settings.EMM_PID = misc->EMM_PID;
593        app->settings.VCT_ID = misc->VCT_ID;
594        app->settings.network_PID = misc->network_PID;
595        app->settings.hunt_cnt = misc->hunt_cnt;
596        app->settings.download_failed_cnt = misc->download_failed_cnt;
597        app->settings.download_invalid_cnt = misc->download_invalid_cnt;
598        app->settings.timeout = misc->timeout;
599        app->settings.max_location_errors = misc->max_location_errors;
600        app->settings.location_errors = misc->location_errors;
601        app->settings.message_time = misc->message_time;
602        app->settings.turn_on_freq_khz = misc->turn_on_freq_khz;
603        app->settings.addressable_time = misc->addressable_time;
604        app->settings.timeout_cnt = misc->timeout_cnt;
605        app->settings.location = misc->location;
606        app->settings.utc_offset = misc->utc_offset;
607        app->settings.dst_entry = misc->dst_entry;
608        app->settings.dst_exit = misc->dst_exit;
609
610        app->settings.hd_config.aspect_ratio = misc->aspect_ratio;
611        app->settings.hd_config.hd_options = misc->hd_options;
612        app->settings.hd_config.output_format = misc->output_format;
613        app->settings.hd_config.sharpness = misc->sharpness;
614        app->settings.sd_options = misc->sd_options;
615    }
616ExitFunc:
617    return dberr;
618}
619
620
621int bast_eas_read(bapp_t *app)
622{
623#if 0
624    bfdb_err dberr;
625    struct eas_settings_t * eas;
626
627    dberr = bfdb_rewind(sst.db, BAST_EAS_ID);
628    if(BFDB_OK == dberr){
629        dberr = bfdb_get(sst.db, sst.data, sizeof(struct eas_settings_t));
630        if(BFDB_OK != dberr){
631            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
632            goto ExitFunc;
633        }
634        eas = (struct eas_settings_t *)sst.data;
635        app->settings.eas_filter_control = eas->eas_filter_control;
636        app->settings.eas_state_code = eas->eas_state_code;
637        app->settings.eas_county_subdivision = eas->eas_county_subdivision;
638        app->settings.eas_county_code = eas->eas_county_code;
639    }
640ExitFunc:
641    return dberr;
642#endif
643return 0;
644}
645
646int bast_phone_number_read(bapp_t *app)
647{
648    bfdb_err dberr;
649    struct phone_number_settings_t * phone;
650
651    dberr = bfdb_rewind(sst.db, BAST_PHONE_NUMBER_ID);
652    if(BFDB_OK == dberr){
653        dberr = bfdb_get(sst.db, sst.data, sizeof(struct phone_number_settings_t));
654        if(BFDB_OK != dberr){
655            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
656            goto ExitFunc;
657        }
658        phone = (struct phone_number_settings_t*)sst.data;
659        phone->data[phone->size] = 0;
660        strcpy(app->settings.phonenumber, phone->data);
661    }
662ExitFunc:
663    return dberr;
664}
665
666bfdb_err bast_mms_read(bapp_t *app)
667{
668    bfdb_err dberr;
669    unsigned int i, j;
670    unsigned int count;
671    struct mms_entry_settings_t * mms;
672
673    dberr = bfdb_rewind(sst.db, BAST_MMS_ENTRY_ID);
674    if(BFDB_OK == dberr){
675        count = app->settings.ch_map.mms_map.num_mms;
676        mms = (struct mms_entry_settings_t *)sst.data;
677        for(i = 0; i < count; ){
678            dberr = bfdb_get(sst.db, sst.data, sizeof(struct mms_entry_settings_t));
679            if(BFDB_OK != dberr){
680                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
681                goto ExitFunc;
682            }
683            j = 0;
684            while((j < BAST_MAX_ITEM) && (i < count)){
685                app->settings.ch_map.mms_map.mms[i].idx = mms->mms[j].idx;
686                app->settings.ch_map.mms_map.mms[i].code_rate = mms->mms[j].code_rate;
687                app->settings.ch_map.mms_map.mms[i].modulation = mms->mms[j].modulation;
688                app->settings.ch_map.mms_map.mms[i].symbol_rate = mms->mms[j].symbol_rate;
689                j++; i++;
690            }
691            if(i >= count)
692                continue;
693            dberr = bfdb_next(sst.db, BAST_MMS_ENTRY_ID);
694            if(BFDB_OK != dberr){
695                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
696                goto ExitFunc;
697            }
698        }
699    }
700ExitFunc:
701    return dberr;
702}
703
704bfdb_err bast_freq_read(bapp_t *app)
705{
706    bfdb_err dberr;
707    unsigned int i, j;
708    struct freq_entry_settings_t * fr;
709    unsigned int count;
710
711    dberr = bfdb_rewind(sst.db, BAST_FREQ_ENTRY_ID);
712    if(BFDB_OK != dberr){
713        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
714        goto ExitFunc;
715    }
716    count = app->settings.ch_map.freq_map.num_freq;
717    fr = (struct freq_entry_settings_t*)sst.data;
718    for(i = 0; i < count; ){
719        dberr = bfdb_get(sst.db, sst.data, sizeof(struct freq_entry_settings_t));
720        if(BFDB_OK != dberr){
721            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
722            goto ExitFunc;
723        }
724        j = 0;
725        while((j < BAST_MAX_ITEM) && (i < count)){
726            app->settings.ch_map.freq_map.freq[i].idx = fr->freq[j].idx;
727            app->settings.ch_map.freq_map.freq[i].freq_khz = fr->freq[j].freq_khz;
728            i++; j++;
729        }
730        if(i >= count)
731            continue;
732        dberr = bfdb_next(sst.db, BAST_FREQ_ENTRY_ID);
733        if(BFDB_OK != dberr){
734            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
735            goto ExitFunc;
736        }
737    }
738ExitFunc:
739    return dberr;
740}
741bfdb_err bast_st_read(bapp_t *app)
742{
743    bfdb_err dberr;
744    unsigned int i;
745    unsigned int count;
746    struct st_entry_settings_t * st;
747
748    dberr = bfdb_rewind(sst.db, BAST_ST_ENTRY_ID);
749    if(BFDB_OK != dberr){
750        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
751        goto ExitFunc;
752    }
753    count = app->settings.ch_map.st_map.num_st;
754    st = (struct st_entry_settings_t *)sst.data;
755    for(i = 0; i < count;){
756        dberr = bfdb_get(sst.db, sst.data, sizeof(struct st_entry_settings_t));
757        if(BFDB_OK != dberr){
758            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
759            goto ExitFunc;
760        }
761        app->settings.ch_map.st_map.st[i].source_id = st->source_id;
762        strcpy(app->settings.ch_map.st_map.st[i].name, st->name);
763        i++;
764        if(i >= count)
765            continue;
766        dberr = bfdb_next(sst.db, BAST_ST_ENTRY_ID);
767        if(BFDB_OK != dberr){
768            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
769            goto ExitFunc;
770        }
771    }
772ExitFunc:
773    return dberr;
774}
775
776bfdb_err bast_vch_read(bapp_t *app)
777{
778    bfdb_err dberr;
779    unsigned i,j;
780    unsigned count;
781    struct vch_entry_settings_t * vch;
782
783    dberr = bfdb_rewind(sst.db, BAST_VCH_ENTRY_ID);
784    if(BFDB_OK != dberr){
785        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
786        goto ExitFunc;
787    }
788    count = app->settings.ch_map.vch_map.num_vch;
789    vch = (struct vch_entry_settings_t *)sst.data;
790    for(i = 0; i < count; ){
791        dberr = bfdb_get(sst.db, sst.data, sizeof(struct vch_entry_settings_t));
792        if(BFDB_OK != dberr){
793            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
794            goto ExitFunc;
795        }
796        app->settings.ch_map.vch_map.vch[i].ch_num = vch->ch_num;
797        app->settings.ch_map.vch_map.vch[i].source_id = vch->source_id;
798        app->settings.ch_map.vch_map.vch[i].program_num = vch->program_num;
799        app->settings.ch_map.vch_map.vch[i].pcr_pid = vch->pcr_pid;
800        app->settings.ch_map.vch_map.vch[i].scte127_pid = vch->scte127_pid;
801        app->settings.ch_map.vch_map.vch[i].video_pid = vch->video_pid;
802        app->settings.ch_map.vch_map.vch[i].video_type = vch->video_type;
803        app->settings.ch_map.vch_map.vch[i].ca_pid = vch->ca_pid;
804        app->settings.ch_map.vch_map.vch[i].freq_idx = vch->freq_idx;
805        app->settings.ch_map.vch_map.vch[i].mms_idx = vch->mms_idx;
806        app->settings.ch_map.vch_map.vch[i].vchflags = vch->vchflags;
807        app->settings.ch_map.vch_map.vch[i].num_audio = vch->audio_count;
808        app->settings.ch_map.vch_map.vch[i].cur_audio = vch->audio_current;
809        for(j = 0; j < VCH_MAX_AUDIO; j++){
810            app->settings.ch_map.vch_map.vch[i].audio_pid[j] = vch->audio_pid[j];
811            app->settings.ch_map.vch_map.vch[i].audio_type[j] = vch->audio_type[j];
812            app->settings.ch_map.vch_map.vch[i].audio_lang[j][0] = vch->audio_lang[j][0];
813            app->settings.ch_map.vch_map.vch[i].audio_lang[j][1] = vch->audio_lang[j][1];
814            app->settings.ch_map.vch_map.vch[i].audio_lang[j][2] = vch->audio_lang[j][2];
815        }
816#ifdef CONFIG_DVB_SUBTITLE
817                app->settings.ch_map.vch_map.vch[i].num_dsub = vch->dsub_count;
818                app->settings.ch_map.vch_map.vch[i].cur_dsub = vch->dsub_current;
819                for (j=0; j<VCH_MAX_DSUB; j++) {
820                        app->settings.ch_map.vch_map.vch[i].dsub_pid[j] = vch->dsub_pid[j];
821                        app->settings.ch_map.vch_map.vch[i].dsub_lang[j][0] = vch->dsub_lang[j][0];
822                        app->settings.ch_map.vch_map.vch[i].dsub_lang[j][1] = vch->dsub_lang[j][1];
823                        app->settings.ch_map.vch_map.vch[i].dsub_lang[j][2] = vch->dsub_lang[j][2];
824                        app->settings.ch_map.vch_map.vch[i].dsub_page[j] = vch->dsub_page[j];
825                }
826#endif
827        i++;
828        if(i >= count)
829            continue;
830        dberr = bfdb_next(sst.db, BAST_VCH_ENTRY_ID);
831        if(BFDB_OK != dberr){
832            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
833            goto ExitFunc;
834        }
835    }
836ExitFunc:
837    return dberr;
838}
839int bast_channel_map_read(bapp_t *app)
840{
841    bfdb_err dberr;
842    struct channel_map_header_settings_t * header;
843
844    dberr = bfdb_rewind(sst.db, BAST_CHANNEL_MAP_HEADER_ID);
845    if(BFDB_OK == dberr){
846        dberr = bfdb_get(sst.db, sst.data, sizeof(struct channel_map_header_settings_t));
847        if(BFDB_OK != dberr){
848            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
849            goto ExitFunc;
850        }
851        header = (struct channel_map_header_settings_t *)sst.data;
852        app->settings.ch_map.mms_map.num_mms = header->mms_count;
853        app->settings.ch_map.freq_map.num_freq = header->freq_count;
854        app->settings.ch_map.st_map.num_st = header->st_count;
855        app->settings.ch_map.vch_map.num_vch = header->vch_count;
856
857        dberr = bast_mms_read(app);
858        if(BFDB_OK != dberr){
859            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
860            goto ExitFunc;
861        }
862        dberr = bast_freq_read(app);
863        if(BFDB_OK != dberr){
864            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
865            goto ExitFunc;
866        }
867        dberr = bast_st_read(app);
868        if(BFDB_OK != dberr){
869            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
870            goto ExitFunc;
871        }
872        dberr = bast_vch_read(app);
873        if(BFDB_OK != dberr){
874            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
875            goto ExitFunc;
876        }
877    }
878ExitFunc:
879    return dberr;
880}
881
882void bast_shared_key_save(struct shared_key_settings_t * key)
883{
884    bfdb_err dberr;
885
886    dberr = bast_delete_all(BAST_SHARED_KEY_ID);
887    if(BFDB_OK != dberr){
888        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
889        goto ExitFunc;
890    }
891    /* create new record */
892    dberr = bast_add(sst.db, BAST_SHARED_KEY_ID, (uint8_t*)key, sizeof(struct shared_key_settings_t));
893    if(BFDB_OK != dberr){
894        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
895    }
896ExitFunc:
897    return;
898}
899
900void bast_upk_generator_save(struct upk_generator_settings_t * gen)
901{
902    bfdb_err dberr;
903
904    dberr = bast_delete_all(BAST_UPK_GENERATOR_ID);
905    if(BFDB_OK != dberr){
906        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
907        goto ExitFunc;
908    }
909    /* create new record */
910    dberr = bast_add(sst.db, BAST_UPK_GENERATOR_ID, (uint8_t*)gen, sizeof(struct upk_generator_settings_t));
911    if(BFDB_OK != dberr){
912        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
913    }
914ExitFunc:
915    return;
916}
917
918int bast_shared_key_read(struct shared_key_settings_t * key)
919{
920    bfdb_err dberr;
921    dberr = bfdb_rewind(sst.db, BAST_SHARED_KEY_ID);
922    if(BFDB_OK == dberr){
923        dberr = bfdb_get(sst.db, (uint8_t*)key, sizeof(struct shared_key_settings_t));
924        if(BFDB_OK != dberr){
925            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
926        }
927    }
928    return dberr;
929}
930
931int bast_upk_generator_read(struct upk_generator_settings_t * gen)
932{
933    bfdb_err dberr;
934    dberr = bfdb_rewind(sst.db, BAST_UPK_GENERATOR_ID);
935    if(BFDB_OK == dberr){
936        dberr = bfdb_get(sst.db, (uint8_t*)gen, sizeof(struct upk_generator_settings_t));
937        if(BFDB_OK != dberr){
938            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
939        }
940    }
941    return dberr;
942}
943
944void bast_block_save(uint32_t id, uint8_t size, uint8_t *data)
945{
946    bfdb_err dberr;
947
948    dberr = bast_delete_all(id);
949    if(BFDB_OK != dberr){
950        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
951        goto ExitFunc;
952    }
953    /* create new record */
954    dberr = bast_add(sst.db, id, data, size);
955    if(BFDB_OK != dberr){
956        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
957    }
958ExitFunc:
959    return;
960}
961
962/*
963 * Summary:
964 *     Save digital closed captioning settings.
965 *      */
966
967
968void bast_dcc_save(dcc_settings_t *settings)
969{
970    bfdb_err dberr;
971
972    dberr = bast_delete_all(BAST_DCC_ID);
973    if(BFDB_OK != dberr){
974        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
975        goto ExitFunc;
976    }
977    /* create new record */
978    dberr = bast_add(sst.db, BAST_DCC_ID, (uint8_t*)settings, sizeof(dcc_settings_t));
979    if(BFDB_OK != dberr){
980        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
981    }
982ExitFunc:
983    return;
984}
985/*
986 * Summary:
987 *     Read digital closed captioning settings.
988 *      */
989
990int bast_dcc_read(dcc_settings_t *settings)
991{
992    bfdb_err dberr;
993    dberr = bfdb_rewind(sst.db, BAST_DCC_ID);
994    if(BFDB_OK == dberr){
995        dberr = bfdb_get(sst.db, (uint8_t*)settings, sizeof(dcc_settings_t));
996        if(BFDB_OK != dberr){
997            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
998        }
999    }
1000    return dberr;
1001}
1002
1003/*
1004 * Summary:
1005 *     Save ratings settings.
1006 *      */
1007void bast_ratings_save(ratings_settings_t *settings)
1008{
1009    bfdb_err dberr;
1010
1011    dberr = bast_delete_all(BAST_RATINGS_ID);
1012    if(BFDB_OK != dberr){
1013        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
1014        goto ExitFunc;
1015    }
1016    /* create new record */
1017    dberr = bast_add(sst.db, BAST_RATINGS_ID, (uint8_t*)settings, sizeof(ratings_settings_t));
1018    if(BFDB_OK != dberr){
1019        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
1020    }
1021ExitFunc:
1022    return;
1023}
1024/*
1025 * Summary:
1026 *     Read ratings settings.
1027 *      */
1028
1029int bast_ratings_read(ratings_settings_t *settings)
1030{
1031    bfdb_err dberr;
1032    dberr = bfdb_rewind(sst.db, BAST_RATINGS_ID);
1033    if(BFDB_OK == dberr){
1034        dberr = bfdb_get(sst.db, (uint8_t*)settings, sizeof(ratings_settings_t));
1035        if(BFDB_OK != dberr){
1036            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
1037        }
1038    }
1039    return dberr;
1040}
1041
1042/*
1043 * Summary:
1044 *     Save RRT settings.
1045 *      */
1046void bast_rrt_save(rrt_settings_t *settings)
1047{
1048    bfdb_err dberr;
1049    uint32_t size;
1050
1051    dberr = bast_delete_all(BAST_RRT_SETTINGS_ID);
1052    dberr |= bast_delete_all(BAST_RRT_DIM_0);
1053    dberr |= bast_delete_all(BAST_RRT_DIM_1);
1054    dberr |= bast_delete_all(BAST_RRT_DIM_2);
1055    dberr |= bast_delete_all(BAST_RRT_TBL_0);
1056    dberr |= bast_delete_all(BAST_RRT_TBL_1);
1057    dberr |= bast_delete_all(BAST_RRT_TBL_2);
1058    dberr |= bast_delete_all(BAST_RRT_TBL_3);
1059    dberr |= bast_delete_all(BAST_RRT_TBL_4);
1060    if(BFDB_OK != dberr){
1061        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
1062        goto ExitFunc;
1063    }
1064
1065    size = (uint32_t)(&(settings->ratings_rrt[0])) - (uint32_t)settings;
1066    /* create new record */
1067    dberr = bast_add(sst.db, BAST_RRT_SETTINGS_ID, (uint8_t*)settings, size);
1068    if(BFDB_OK != dberr){
1069        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
1070    }
1071    dberr = bast_add(sst.db, BAST_RRT_DIM_0, (uint8_t*)settings->ratings_rrt, 0xFF);
1072    if(BFDB_OK != dberr){
1073        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
1074    }
1075    dberr = bast_add(sst.db, BAST_RRT_DIM_1, (uint8_t*)&(settings->ratings_rrt[0xFF]),
1076                     sizeof(unsigned short) * MAX_RRT_DIM/2);
1077    if(BFDB_OK != dberr){
1078        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
1079    }
1080    dberr = bast_add(sst.db, BAST_RRT_DIM_2, (uint8_t*)&(settings->ratings_rrt[0xFF * 2]),2);
1081    if(BFDB_OK != dberr){
1082        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
1083    }
1084    dberr = bast_add(sst.db, BAST_RRT_TBL_0, (uint8_t*)settings->rrt, 0xFF);
1085    if(BFDB_OK != dberr){
1086        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
1087    }
1088    dberr = bast_add(sst.db, BAST_RRT_TBL_1, (uint8_t*)&(settings->rrt[0xFF]), 0xFF);
1089    if(BFDB_OK != dberr){
1090        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
1091    }
1092    dberr = bast_add(sst.db, BAST_RRT_TBL_2, (uint8_t*)&(settings->rrt[2*0xFF]),0xFF);
1093    if(BFDB_OK != dberr){
1094        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
1095    }
1096    dberr = bast_add(sst.db, BAST_RRT_TBL_3, (uint8_t*)&(settings->rrt[3*0xFF]),0xFF);
1097    if(BFDB_OK != dberr){
1098        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
1099    }
1100    dberr = bast_add(sst.db, BAST_RRT_TBL_4, (uint8_t*)&(settings->rrt[4*0xFF]),4);
1101    if(BFDB_OK != dberr){
1102        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
1103    }
1104ExitFunc:
1105    return;
1106}
1107/*
1108 * Summary:
1109 *     Read RRT settings.
1110 *      */
1111
1112int bast_rrt_read(rrt_settings_t *settings)
1113{
1114    bfdb_err dberr;
1115    uint32_t size;
1116
1117    dberr = bfdb_rewind(sst.db, BAST_RRT_SETTINGS_ID);
1118    if(BFDB_OK == dberr){
1119        size = (uint32_t)(&(settings->ratings_rrt[0])) - (uint32_t)settings;
1120        dberr = bfdb_get(sst.db, (uint8_t*)settings, size);
1121        if(BFDB_OK != dberr){
1122            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
1123        }
1124    }
1125
1126    dberr = bfdb_rewind(sst.db, BAST_RRT_DIM_0);
1127    if(BFDB_OK == dberr){
1128        dberr = bfdb_get(sst.db, (uint8_t*)settings->ratings_rrt, 0xFF);
1129        if(BFDB_OK != dberr){
1130            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
1131        }
1132    }
1133
1134    dberr = bfdb_rewind(sst.db, BAST_RRT_DIM_1);
1135    if(BFDB_OK == dberr){
1136        dberr = bfdb_get(sst.db, (uint8_t*)&(settings->ratings_rrt[0xFF]),0xFF);
1137        if(BFDB_OK != dberr){
1138            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
1139        }
1140    }
1141
1142    dberr = bfdb_rewind(sst.db, BAST_RRT_DIM_2);
1143    if(BFDB_OK == dberr){
1144        dberr = bfdb_get(sst.db, (uint8_t*)&(settings->ratings_rrt[2*0xFF]),2);
1145        if(BFDB_OK != dberr){
1146            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
1147        }
1148    }
1149
1150    dberr = bfdb_rewind(sst.db, BAST_RRT_TBL_0);
1151    if(BFDB_OK == dberr){
1152        dberr = bfdb_get(sst.db, (uint8_t*)settings->rrt, 0xFF);
1153        if(BFDB_OK != dberr){
1154            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
1155        }
1156    }
1157
1158    dberr = bfdb_rewind(sst.db, BAST_RRT_TBL_1);
1159    if(BFDB_OK == dberr){
1160        dberr = bfdb_get(sst.db, (uint8_t*)&(settings->rrt[0xFF]),0xFF);
1161        if(BFDB_OK != dberr){
1162            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
1163        }
1164    }
1165
1166    dberr = bfdb_rewind(sst.db, BAST_RRT_TBL_2);
1167    if(BFDB_OK == dberr){
1168        dberr = bfdb_get(sst.db, (uint8_t*)&(settings->rrt[2*0xFF]),0xFF);
1169        if(BFDB_OK != dberr){
1170            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
1171        }
1172    }
1173
1174    dberr = bfdb_rewind(sst.db, BAST_RRT_TBL_3);
1175    if(BFDB_OK == dberr){
1176        dberr = bfdb_get(sst.db, (uint8_t*)&(settings->rrt[3*0xFF]),0xFF);
1177        if(BFDB_OK != dberr){
1178            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
1179        }
1180    }
1181
1182    dberr = bfdb_rewind(sst.db, BAST_RRT_TBL_4);
1183    if(BFDB_OK == dberr){
1184        dberr = bfdb_get(sst.db, (uint8_t*)&(settings->rrt[4*0xFF]),4);
1185        if(BFDB_OK != dberr){
1186            BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
1187        }
1188    }
1189
1190    return dberr;
1191}
1192
1193/*
1194 * Summary:
1195 * Save menu settings
1196 */
1197void bast_screen_save(bapp_t *app)
1198{
1199    bfdb_err dberr;
1200    struct screen_settings_t *screen;
1201
1202        screen = (struct screen_settings_t *)sst.data;
1203        screen->sound = app->settings.sound; 
1204        screen->picture = app->settings.picture; 
1205        screen->language = app->settings.language ; 
1206        screen->wiz_completed = app->settings.wiz_completed ; 
1207        screen->ratings_lock = app->settings.ratings_lock ; 
1208        screen->ratings_tv = app->settings.ratings_tv ; 
1209        screen->ratings_movies = app->settings.ratings_movies;
1210        screen->content_d = app->settings.content_d ; 
1211        screen->content_l =  app->settings.content_l ; 
1212        screen->content_s = app->settings.content_s ; 
1213        screen->content_v = app->settings.content_v ; 
1214        screen->captions_basic = app->settings.dcc.captions_basic ;
1215        screen->captions_font = app->settings.dcc.captions_font ; 
1216        screen->captions_font_size = app->settings.dcc.captions_font_size ; 
1217        screen->captions_font_style = app->settings.dcc.captions_font_style ; 
1218        screen->captions_font_color = app->settings.dcc.captions_font_color ; 
1219        screen->captions_font_opacity = app->settings.dcc.captions_font_opacity ; 
1220        screen->captions_back_color = app->settings.dcc.captions_back_color ; 
1221        screen->captions_back_opacity = app->settings.dcc.captions_back_opacity ; 
1222        screen->captions_edge_color = app->settings.dcc.captions_edge_color ; 
1223        screen->captions_edge_type = app->settings.dcc.captions_edge_type ; 
1224        screen->rrt_status = app->settings.rrt_status ; 
1225        screen->time_zone = app->settings.time_zone ; 
1226        screen->dst =  app->settings.dst ; 
1227        screen->last_rrt_id = app->settings.last_rrt_id ; 
1228        screen->pin = app->settings.pin;
1229        screen->auto_power = app->settings.auto_power; 
1230        screen->auto_power_off = app->settings.auto_power_off;
1231
1232    dberr = bast_delete_all(BAST_SCREEN_ID);
1233    if(BFDB_OK != dberr){
1234        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
1235        goto ExitFunc;
1236    }
1237
1238    dberr = bast_add(sst.db, BAST_SCREEN_ID, (uint8_t*)screen, sizeof(struct screen_settings_t));
1239    if(BFDB_OK != dberr){
1240        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
1241    }
1242ExitFunc:
1243        return ;
1244}
1245
1246/*
1247 * Summary:
1248 * Read menu settings
1249 */
1250int bast_screen_read(bapp_t *app)
1251{
1252        bfdb_err dberr;
1253        struct screen_settings_t *screen;
1254       
1255        dberr = bfdb_rewind(sst.db, BAST_SCREEN_ID);
1256        if (BFDB_OK == dberr) {
1257                dberr = bfdb_get(sst.db, sst.data, sizeof(struct screen_settings_t));
1258                if (dberr != BFDB_OK) {
1259                        BDBG_ERR(("Error:%d line:%d", dberr, __LINE__));
1260                        goto ExitFunc;
1261                }
1262                screen = (struct screen_settings_t *)sst.data;
1263                app->settings.sound = screen->sound;
1264                app->settings.picture = screen->picture;
1265                app->settings.language = screen->language;
1266                app->settings.wiz_completed = screen->wiz_completed;
1267                app->settings.ratings_lock = screen->ratings_lock;
1268                app->settings.ratings_tv = screen->ratings_tv;
1269                app->settings.content_d = screen->content_d;
1270                app->settings.content_l = screen->content_l;
1271                app->settings.content_s = screen->content_s;
1272                app->settings.content_v = screen->content_v;
1273                app->settings.ratings_movies = screen->ratings_movies;
1274                app->settings.dcc.captions_basic = screen->captions_basic;
1275                app->settings.dcc.captions_font = screen->captions_font;
1276                app->settings.dcc.captions_font_size = screen->captions_font_size;
1277                app->settings.dcc.captions_font_style = screen->captions_font_style;
1278                app->settings.dcc.captions_font_color = screen->captions_font_color;
1279                app->settings.dcc.captions_font_opacity = screen->captions_font_opacity;
1280                app->settings.dcc.captions_back_color = screen->captions_back_color;
1281                app->settings.dcc.captions_back_opacity = screen->captions_back_opacity;
1282                app->settings.dcc.captions_edge_color = screen->captions_edge_color;
1283                app->settings.dcc.captions_edge_type = screen->captions_edge_type;
1284                app->settings.rrt_status = screen->rrt_status;
1285                app->settings.time_zone = screen->time_zone;
1286                app->settings.dst = screen->dst;
1287                app->settings.last_rrt_id = screen->last_rrt_id;
1288                app->settings.pin = screen->pin;
1289                app->settings.auto_power = screen->auto_power;
1290                app->settings.auto_power_off = screen->auto_power_off;
1291        }
1292ExitFunc:       
1293        return dberr;
1294}
Note: See TracBrowser for help on using the repository browser.