source: svn/newcon3bcm2_21bu/dta/src/app/ntia/bapp_settings.c @ 44

Last change on this file since 44 was 44, checked in by megakiss, 11 years ago

광주방송 OTC 주파수 369Mhz로 변경
  • Property svn:executable set to *
File size: 27.2 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->cur_ch_num;
170        channel->num_channels = app->settings.num_channels;
171        channel->volume = app->settings.audio_vol;
172        channel->rfm =app->settings.rfm;
173
174        dberr = bast_delete_all(BAST_CHANNEL_ID);
175        if (BFDB_OK != dberr)
176        {
177                BDBG_ERR(("Error:%d line:%d", dberr, __LINE__));
178                goto ExitFunc;
179        }
180
181        /* create new record */
182        dberr = bast_add(sst.db, BAST_CHANNEL_ID, (uint8_t *)channel, sizeof(struct channel_settings_t));
183        if (BFDB_OK != dberr) {
184                BDBG_ERR(("Error:%d line:%d", dberr, __LINE__));
185        }
186ExitFunc:
187        return;
188}
189
190void bast_misc_save(bapp_t *app)
191{
192        bfdb_err dberr;
193        struct misc_settings_t *misc;
194
195        misc = (struct misc_settings_t *)sst.data;
196        misc->bits.standby = app->settings.standby;
197        misc->bits.av_mute = app->settings.av_mute;
198        misc->bits.psi_scan = app->settings.psi_scan;
199        misc->bits.state = app->settings.state;
200        misc->bits.dummy = 0x3fffff;
201        misc->dst_delta = app->settings.dst_delta;
202        misc->timeout_policy = app->settings.timeout_policy;
203        misc->dummy0 = 0xff;
204        misc->hunt_cnt = app->settings.hunt_cnt;
205        misc->timeout = app->settings.timeout;
206        misc->message_time = app->settings.message_time;
207        misc->addressable_time = app->settings.addressable_time;
208        misc->timeout_cnt = app->settings.timeout_cnt;
209        misc->location = app->settings.location;
210        misc->utc_offset = app->settings.utc_offset;
211        misc->dst_entry = app->settings.dst_entry;
212        misc->dst_exit = app->settings.dst_exit;
213
214#ifdef HAS_HDMI
215    misc->aspect_ratio = app->settings.hd_config.aspect_ratio;
216    misc->hd_options = app->settings.hd_config.hd_options;
217    misc->output_format = app->settings.hd_config.output_format;
218    misc->sharpness = app->settings.hd_config.sharpness;
219#endif
220    misc->sd_options = app->settings.sd_options;
221
222        dberr = bast_delete_all(BAST_MISC_ID);
223        if(BFDB_OK != dberr){
224        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
225                goto ExitFunc;
226        }
227
228        dberr = bast_add(sst.db, BAST_MISC_ID, (uint8_t*)misc, sizeof(struct misc_settings_t));
229        if(BFDB_OK != dberr){
230                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
231        }
232
233ExitFunc:
234        return;
235}
236
237void bast_eas_save(bapp_t *app)
238{
239#if 0
240    bfdb_err dberr;
241    struct eas_settings_t * eas;
242
243    eas = (struct eas_settings_t *)sst.data;
244    eas->eas_filter_control = app->settings.eas_filter_control;
245    eas->eas_state_code = app->settings.eas_state_code;
246    eas->eas_county_subdivision = app->settings.eas_county_subdivision;
247    eas->eas_county_code = app->settings.eas_county_code;
248
249    dberr = bast_delete_all(BAST_EAS_ID);
250    if(BFDB_OK != dberr){
251        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
252        goto ExitFunc;
253    }
254
255    dberr = bast_add(sst.db, BAST_EAS_ID, (uint8_t*)eas, sizeof(struct eas_settings_t));
256    if(BFDB_OK != dberr){
257        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
258    }
259ExitFunc:
260#endif
261    return;
262}
263
264bfdb_err bast_channel_map_erase(void)
265{
266        bfdb_err dberr;
267
268        /* erase all components of the channel map, for VSB channel map */
269        dberr = bast_delete_all(BAST_CHANNEL_MAP_ID);
270        if(BFDB_OK != dberr){
271                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
272                goto ExitFunc;
273        }
274ExitFunc:
275        return dberr;
276}
277
278void bast_channel_map_save(bapp_t *app)
279{
280    bfdb_err dberr;
281    struct ch_map_settings_t *ch;
282        int count, i, j;
283
284    dberr = bast_channel_map_erase();
285    if(BFDB_OK != dberr){
286        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
287        return;
288    }
289
290    ch = (struct ch_map_settings_t *)sst.data;
291    count = app->settings.num_channels;
292
293        for (i = 0; i < count; i++) {
294                ch->major = app->settings.ch[i].major;
295                ch->minor = app->settings.ch[i].minor;
296                ch->freq_idx = app->settings.ch[i].freq_idx;
297                ch->psi = app->settings.ch[i].psi;
298                ch->pcr_pid = app->settings.ch[i].pcr_pid;
299                ch->video_pid = app->settings.ch[i].video_pid;
300                ch->has_lang = app->settings.ch[i].has_lang;
301                ch->hidden = app->settings.ch[i].hidden;
302                ch->video_type = app->settings.ch[i].video_type;
303                ch->program_num = app->settings.ch[i].program_num;
304                ch->num_audio = app->settings.ch[i].num_audio;
305                for (j = 0; j < MAX_AUDIO_PIDS; j++) {
306                        ch->audio_pid[j] = app->settings.ch[i].audio_pid[j];
307                        ch->audio_type[j] = app->settings.ch[i].audio_type[j];
308                        ch->audio_lang[j][0] = app->settings.ch[i].audio_lang[j][0];
309                        ch->audio_lang[j][1] = app->settings.ch[i].audio_lang[j][1];
310                        ch->audio_lang[j][2] = app->settings.ch[i].audio_lang[j][2];
311                }
312                for (j = 0; j < MAX_CH_SHORT_NAME_CHARS; j++) {
313                        ch->ch_name[j] = app->settings.ch[i].ch_name[j];
314                }
315                ch->frequency_khz = app->settings.ch[i].frequency_khz;
316                ch->cur_audio = app->settings.ch[i].cur_audio;
317                ch->source_id = app->settings.ch[i].source_id;
318                ch->skip = app->settings.ch[i].skip;
319                ch->favorite = app->settings.ch[i].favorite;
320                dberr = bast_add(sst.db, BAST_CHANNEL_MAP_ID, (uint8_t*)ch, sizeof(struct ch_map_settings_t)); if(BFDB_OK != dberr){
321                        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
322                        break;
323                }
324        }
325}
326
327#include "bchp_aon_ctrl.h"
328
329#define bfds_ok 0
330#define PHYS_TO_K1(x)   ((x) | 0xa0000000)
331#define BCHP_K0_OFFSET  (0xA0000000 | 0x10000000)
332#define ReadReg32(x)    *((volatile unsigned int*)(BCHP_K0_OFFSET + (unsigned int)(x)))
333
334#define normal_close 0x01
335#define AC_operate 1
336
337void turn_on_led_t(void)
338{
339        *(volatile unsigned long *)PHYS_TO_K1(0x10000000+0x00408020) = 0x00000001;
340}
341
342
343void AOV_turn_on_led_t(void)
344{
345        *(volatile unsigned long *)PHYS_TO_K1(0x10000000+0x00408c04) = 0x200;           /* set LED to green AON_GPIO_09 */
346        *(volatile unsigned long *)PHYS_TO_K1(0x10000000+0x00408c08) = 0xFFFFFDEF;
347}
348
349int AC_standby()
350{
351        //add AC_onff
352        bfds_handle test;
353        unsigned char ACdata;
354        unsigned int offset=0x3bfff0,len=1;
355        //
356        bfds_open(&test);       
357       
358        ACdata=normal_close;
359        bfds_page_program(test, offset, &ACdata, len);
360}
361
362void AC_check(void)
363{
364        int i,sector_count=59; // 64kbyte 64EA block -> 59 for channel db avoid.
365        bfds_handle test;
366        unsigned int offset=0x3bfff0,erase_offset=0,len=1;
367    bfds_properties fprop;
368        unsigned char ACdata=0xff;
369        uint32_t regi;
370
371        //Read the wheather AC or remocon not
372        regi = ReadReg32(BCHP_AON_CTRL_RESET_HISTORY);
373        regi &= BCHP_AON_CTRL_RESET_HISTORY_power_on_reset_MASK;       
374
375        //bfds open  & set erase zone
376        bfds_open(&test);       
377
378    bfds_get_properties(test, &fprop);
379
380        for(i = 0; i < sector_count; i++){       
381        erase_offset += fprop.flash_sector_size;
382    }
383               
384        //1.check the value
385        bfds_read(test,offset,&ACdata,len);
386
387        if(regi==AC_operate){   //AC on off
388                if(ACdata==normal_close)
389                {
390                        //2. power off.
391                        b_s3_standby(USERIO_ID);
392                        /* don't switch task, experimental till figure out the issue */
393                        while (1);
394                }
395        }
396        //Remocon or front key on off
397        //3.refresh value
398        bfds_sector_erase(test,erase_offset);
399
400#ifdef CONFIG_STANDBY
401                turn_on_led_t(); /* turn on green LED when waking up */
402#endif
403                AOV_turn_on_led_t();
404
405}
406
407int bast_channel_read(bapp_t *app)
408{
409        bfdb_err dberr;
410        struct channel_settings_t * channel;
411
412        dberr =  bfdb_rewind(sst.db, BAST_CHANNEL_ID);
413        if(BFDB_OK == dberr){
414                dberr = bfdb_get(sst.db, sst.data, sizeof(struct channel_settings_t));
415                if(BFDB_OK != dberr){
416                        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
417                        goto ExitFunc;
418                }
419                channel = (struct channel_settings_t *)sst.data;
420                app->settings.num_channels = channel->num_channels;
421                app->cur_ch_num = channel->channel;
422                app->settings.audio_vol = channel->volume;
423                app->settings.rfm = channel->rfm;
424        }
425ExitFunc:
426        return dberr;
427}
428
429int bast_misc_read(bapp_t *app)
430{
431        bfdb_err dberr;
432        struct misc_settings_t * misc;
433
434        dberr = bfdb_rewind(sst.db, BAST_MISC_ID);
435        if(BFDB_OK == dberr){
436                dberr = bfdb_get(sst.db, sst.data, sizeof(struct misc_settings_t));
437                if(BFDB_OK != dberr){
438                        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
439                        goto ExitFunc;
440                }
441                misc = (struct misc_settings_t *)sst.data;
442                app->settings.standby = misc->bits.standby;
443                app->settings.av_mute = misc->bits.av_mute;
444                app->settings.psi_scan = misc->bits.psi_scan;
445                app->settings.state = misc->bits.state;
446                app->settings.dst_delta = misc->dst_delta;
447                app->settings.timeout_policy = misc->timeout_policy;
448                app->settings.hunt_cnt = misc->hunt_cnt;
449                app->settings.timeout = misc->timeout;
450                app->settings.max_location_errors = misc->max_location_errors;
451                app->settings.location_errors = misc->location_errors;
452                app->settings.message_time = misc->message_time;
453                app->settings.turn_on_freq_khz = misc->turn_on_freq_khz;
454                app->settings.addressable_time = misc->addressable_time;
455                app->settings.timeout_cnt = misc->timeout_cnt;
456                app->settings.location = misc->location;
457                app->settings.utc_offset = misc->utc_offset;
458                app->settings.dst_entry = misc->dst_entry;
459                app->settings.dst_exit = misc->dst_exit;
460
461#ifdef HAS_HDMI
462                app->settings.hd_config.aspect_ratio = misc->aspect_ratio;
463                app->settings.hd_config.hd_options = misc->hd_options;
464                app->settings.hd_config.output_format = misc->output_format;
465                app->settings.hd_config.sharpness = misc->sharpness;
466#endif
467                app->settings.sd_options = misc->sd_options;
468        }
469ExitFunc:
470        return dberr;
471}
472
473int bast_eas_read(bapp_t *app)
474{
475#if 0
476        bfdb_err dberr;
477        struct eas_settings_t * eas;
478
479        dberr = bfdb_rewind(sst.db, BAST_EAS_ID);
480        if(BFDB_OK == dberr){
481                dberr = bfdb_get(sst.db, sst.data, sizeof(struct eas_settings_t));
482                if(BFDB_OK != dberr){
483                        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
484                        goto ExitFunc;
485                }
486                eas = (struct eas_settings_t *)sst.data;
487                app->settings.eas_filter_control = eas->eas_filter_control;
488                app->settings.eas_state_code = eas->eas_state_code;
489                app->settings.eas_county_subdivision = eas->eas_county_subdivision;
490                app->settings.eas_county_code = eas->eas_county_code;
491        }
492ExitFunc:
493        return dberr;
494#endif
495        return 0;
496}
497
498int bast_channel_map_read(bapp_t *app)
499{
500        bfdb_err dberr;
501        struct ch_map_settings_t *ch;
502        int i, j, count;
503
504        dberr = bfdb_rewind(sst.db, BAST_CHANNEL_MAP_ID);
505        if(BFDB_OK == dberr){
506                ch = (struct ch_map_settings_t *)sst.data;
507                count = app->settings.num_channels;
508                for (i = 0; i < count; i++) {
509                        dberr = bfdb_get(sst.db, sst.data, sizeof(struct ch_map_settings_t));
510                        if(BFDB_OK != dberr){
511                                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
512                                goto ExitFunc;
513                        }
514                        app->settings.ch[i].major = ch->major;
515                        app->settings.ch[i].minor = ch->minor;
516                        app->settings.ch[i].freq_idx = ch->freq_idx;
517                        app->settings.ch[i].psi = ch->psi;
518                        app->settings.ch[i].pcr_pid = ch->pcr_pid;
519                        app->settings.ch[i].video_pid = ch->video_pid;
520                        app->settings.ch[i].has_lang = ch->has_lang;
521                        app->settings.ch[i].hidden = ch->hidden;
522                        app->settings.ch[i].video_type = ch->video_type;
523                        app->settings.ch[i].program_num = ch->program_num;
524                        app->settings.ch[i].num_audio = ch->num_audio;
525                        for (j = 0; j < MAX_AUDIO_PIDS; j++) {
526                                app->settings.ch[i].audio_pid[j] = ch->audio_pid[j];
527                                app->settings.ch[i].audio_type[j] = ch->audio_type[j];
528                                app->settings.ch[i].audio_lang[j][0] = ch->audio_lang[j][0];
529                                app->settings.ch[i].audio_lang[j][1] = ch->audio_lang[j][1];
530                                app->settings.ch[i].audio_lang[j][2] = ch->audio_lang[j][2];
531                        }
532                        for (j = 0; j < MAX_CH_SHORT_NAME_CHARS; j++) {
533                                app->settings.ch[i].ch_name[j] = ch->ch_name[j];
534                        }
535                        app->settings.ch[i].frequency_khz = ch->frequency_khz;
536                        app->settings.ch[i].cur_audio = ch->cur_audio;
537                        app->settings.ch[i].source_id = ch->source_id;
538                        app->settings.ch[i].skip = ch->skip;
539                        app->settings.ch[i].favorite = ch->favorite;
540                        /* end of channel map */
541                        if (i >= (count - 1))
542                                return 0;
543                        dberr = bfdb_next(sst.db, BAST_CHANNEL_MAP_ID);
544                        if(BFDB_OK != dberr){
545                                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
546                                goto ExitFunc;
547                        }
548                }
549        }
550ExitFunc:
551        return dberr;
552}
553
554void bast_block_save(uint32_t id, uint8_t size, uint8_t *data)
555{
556        bfdb_err dberr;
557
558        dberr = bast_delete_all(id);
559        if(BFDB_OK != dberr){
560                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
561                goto ExitFunc;
562        }
563        /* create new record */
564        dberr = bast_add(sst.db, id, data, size);
565        if(BFDB_OK != dberr){
566                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
567        }
568ExitFunc:
569        return;
570}
571
572/*
573 * Summary:
574 *     Save digital closed captioning settings.
575 *      */
576
577
578void bast_dcc_save(dcc_settings_t *settings)
579{
580        bfdb_err dberr;
581
582        dberr = bast_delete_all(BAST_DCC_ID);
583        if(BFDB_OK != dberr){
584                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
585                goto ExitFunc;
586        }
587        /* create new record */
588        dberr = bast_add(sst.db, BAST_DCC_ID, (uint8_t*)settings, sizeof(dcc_settings_t));
589        if(BFDB_OK != dberr){
590                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
591        }
592ExitFunc:
593        return;
594}
595/*
596 * Summary:
597 *     Read digital closed captioning settings.
598 */
599
600int bast_dcc_read(dcc_settings_t *settings)
601{
602        bfdb_err dberr;
603        dberr = bfdb_rewind(sst.db, BAST_DCC_ID);
604        if(BFDB_OK == dberr){
605                dberr = bfdb_get(sst.db, (uint8_t*)settings, sizeof(dcc_settings_t));
606                if(BFDB_OK != dberr){
607                        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
608                }
609        }
610        return dberr;
611}
612
613/*
614 * Summary:
615 *     Save ratings settings.
616 *      */
617void bast_ratings_save(ratings_settings_t *settings)
618{
619        bfdb_err dberr;
620
621        dberr = bast_delete_all(BAST_RATINGS_ID);
622        if(BFDB_OK != dberr){
623                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
624                goto ExitFunc;
625        }
626        /* create new record */
627        dberr = bast_add(sst.db, BAST_RATINGS_ID, (uint8_t*)settings, sizeof(ratings_settings_t));
628        if(BFDB_OK != dberr){
629                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
630        }
631ExitFunc:
632        return;
633}
634/*
635 * Summary:
636 *     Read ratings settings.
637 *      */
638
639int bast_ratings_read(ratings_settings_t *settings)
640{
641        bfdb_err dberr;
642        dberr = bfdb_rewind(sst.db, BAST_RATINGS_ID);
643        if(BFDB_OK == dberr){
644                dberr = bfdb_get(sst.db, (uint8_t*)settings, sizeof(ratings_settings_t));
645                if(BFDB_OK != dberr){
646                        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
647                }
648        }
649        return dberr;
650}
651
652/*
653 * Summary:
654 *     Save RRT settings.
655 *      */
656void bast_rrt_save(rrt_settings_t *settings)
657{
658        bfdb_err dberr;
659        uint32_t size;
660
661        dberr = bast_delete_all(BAST_RRT_SETTINGS_ID);
662        dberr |= bast_delete_all(BAST_RRT_DIM_0);
663        dberr |= bast_delete_all(BAST_RRT_DIM_1);
664        dberr |= bast_delete_all(BAST_RRT_DIM_2);
665        dberr |= bast_delete_all(BAST_RRT_TBL_0);
666        dberr |= bast_delete_all(BAST_RRT_TBL_1);
667        dberr |= bast_delete_all(BAST_RRT_TBL_2);
668        dberr |= bast_delete_all(BAST_RRT_TBL_3);
669        dberr |= bast_delete_all(BAST_RRT_TBL_4);
670        if(BFDB_OK != dberr){
671                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
672                goto ExitFunc;
673        }
674
675        size = (uint32_t)(&(settings->ratings_rrt[0])) - (uint32_t)settings;
676        /* create new record */
677        dberr = bast_add(sst.db, BAST_RRT_SETTINGS_ID, (uint8_t*)settings, size);
678        if(BFDB_OK != dberr){
679                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
680        }
681        dberr = bast_add(sst.db, BAST_RRT_DIM_0, (uint8_t*)settings->ratings_rrt, 0xFF);
682        if(BFDB_OK != dberr){
683                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
684        }
685        dberr = bast_add(sst.db, BAST_RRT_DIM_1, (uint8_t*)&(settings->ratings_rrt[0xFF]),
686                        sizeof(unsigned short) * MAX_RRT_DIM/2);
687        if(BFDB_OK != dberr){
688                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
689        }
690        dberr = bast_add(sst.db, BAST_RRT_DIM_2, (uint8_t*)&(settings->ratings_rrt[0xFF * 2]),2);
691        if(BFDB_OK != dberr){
692                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
693        }
694        dberr = bast_add(sst.db, BAST_RRT_TBL_0, (uint8_t*)settings->rrt, 0xFF);
695        if(BFDB_OK != dberr){
696                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
697        }
698        dberr = bast_add(sst.db, BAST_RRT_TBL_1, (uint8_t*)&(settings->rrt[0xFF]), 0xFF);
699        if(BFDB_OK != dberr){
700                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
701        }
702        dberr = bast_add(sst.db, BAST_RRT_TBL_2, (uint8_t*)&(settings->rrt[2*0xFF]),0xFF);
703        if(BFDB_OK != dberr){
704                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
705        }
706        dberr = bast_add(sst.db, BAST_RRT_TBL_3, (uint8_t*)&(settings->rrt[3*0xFF]),0xFF);
707        if(BFDB_OK != dberr){
708                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
709        }
710        dberr = bast_add(sst.db, BAST_RRT_TBL_4, (uint8_t*)&(settings->rrt[4*0xFF]),4);
711        if(BFDB_OK != dberr){
712                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
713        }
714ExitFunc:
715        return;
716}
717/*
718 * Summary:
719 *     Read RRT settings.
720 *      */
721
722int bast_rrt_read(rrt_settings_t *settings)
723{
724        bfdb_err dberr;
725        uint32_t size;
726
727        dberr = bfdb_rewind(sst.db, BAST_RRT_SETTINGS_ID);
728        if(BFDB_OK == dberr){
729                size = (uint32_t)(&(settings->ratings_rrt[0])) - (uint32_t)settings;
730                dberr = bfdb_get(sst.db, (uint8_t*)settings, size);
731                if(BFDB_OK != dberr){
732                        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
733                }
734        }
735
736        dberr = bfdb_rewind(sst.db, BAST_RRT_DIM_0);
737        if(BFDB_OK == dberr){
738                dberr = bfdb_get(sst.db, (uint8_t*)settings->ratings_rrt, 0xFF);
739                if(BFDB_OK != dberr){
740                        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
741                }
742        }
743
744        dberr = bfdb_rewind(sst.db, BAST_RRT_DIM_1);
745        if(BFDB_OK == dberr){
746                dberr = bfdb_get(sst.db, (uint8_t*)&(settings->ratings_rrt[0xFF]),0xFF);
747                if(BFDB_OK != dberr){
748                        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
749                }
750        }
751
752        dberr = bfdb_rewind(sst.db, BAST_RRT_DIM_2);
753        if(BFDB_OK == dberr){
754                dberr = bfdb_get(sst.db, (uint8_t*)&(settings->ratings_rrt[2*0xFF]),2);
755                if(BFDB_OK != dberr){
756                        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
757                }
758        }
759
760        dberr = bfdb_rewind(sst.db, BAST_RRT_TBL_0);
761        if(BFDB_OK == dberr){
762                dberr = bfdb_get(sst.db, (uint8_t*)settings->rrt, 0xFF);
763                if(BFDB_OK != dberr){
764                        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
765                }
766        }
767
768        dberr = bfdb_rewind(sst.db, BAST_RRT_TBL_1);
769        if(BFDB_OK == dberr){
770                dberr = bfdb_get(sst.db, (uint8_t*)&(settings->rrt[0xFF]),0xFF);
771                if(BFDB_OK != dberr){
772                        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
773                }
774        }
775
776        dberr = bfdb_rewind(sst.db, BAST_RRT_TBL_2);
777        if(BFDB_OK == dberr){
778                dberr = bfdb_get(sst.db, (uint8_t*)&(settings->rrt[2*0xFF]),0xFF);
779                if(BFDB_OK != dberr){
780                        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
781                }
782        }
783
784        dberr = bfdb_rewind(sst.db, BAST_RRT_TBL_3);
785        if(BFDB_OK == dberr){
786                dberr = bfdb_get(sst.db, (uint8_t*)&(settings->rrt[3*0xFF]),0xFF);
787                if(BFDB_OK != dberr){
788                        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
789                }
790        }
791
792        dberr = bfdb_rewind(sst.db, BAST_RRT_TBL_4);
793        if(BFDB_OK == dberr){
794                dberr = bfdb_get(sst.db, (uint8_t*)&(settings->rrt[4*0xFF]),4);
795                if(BFDB_OK != dberr){
796                        BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
797                }
798        }
799
800        return dberr;
801}
802
803/*
804 * Summary:
805 * Save menu settings
806 */
807void bast_screen_save(bapp_t *app)
808{
809        bfdb_err dberr;
810        struct screen_settings_t *screen;
811
812        screen = (struct screen_settings_t *)sst.data;
813        screen->sound = app->settings.sound; 
814        screen->picture = app->settings.picture; 
815        screen->language = app->settings.language; 
816        screen->wiz_completed = app->settings.wiz_completed; 
817        screen->ratings_lock = app->settings.ratings.ratings_lock; 
818        screen->ratings_tv = app->settings.ratings.ratings_tv; 
819        screen->ratings_movies = app->settings.ratings.ratings_movies;
820        screen->content_d = app->settings.ratings.content_d; 
821        screen->content_l =  app->settings.ratings.content_l; 
822        screen->content_s = app->settings.ratings.content_s; 
823        screen->content_v = app->settings.ratings.content_v; 
824        screen->captions_basic = app->settings.dcc.captions_basic;
825        screen->captions_font = app->settings.dcc.captions_font; 
826        screen->captions_font_size = app->settings.dcc.captions_font_size; 
827        screen->captions_font_style = app->settings.dcc.captions_font_style; 
828        screen->captions_font_color = app->settings.dcc.captions_font_color; 
829        screen->captions_font_opacity = app->settings.dcc.captions_font_opacity; 
830        screen->captions_back_color = app->settings.dcc.captions_back_color; 
831        screen->captions_back_opacity = app->settings.dcc.captions_back_opacity; 
832        screen->captions_edge_color = app->settings.dcc.captions_edge_color; 
833        screen->captions_edge_type = app->settings.dcc.captions_edge_type; 
834        screen->rrt_status = app->settings.rrt_settings.rrt_status; 
835        screen->time_zone = app->settings.time_zone; 
836        screen->dst =  app->settings.dst; 
837        screen->last_rrt_id = app->settings.rrt_settings.last_rrt_id; 
838        screen->pin = app->settings.rrt_settings.pin;
839        screen->auto_power = app->settings.auto_power; 
840        screen->auto_power_off = app->settings.auto_power_off;
841        screen->analog_captioning = app->settings.dcc.captions_analog;
842
843        dberr = bast_delete_all(BAST_SCREEN_ID);
844        if(BFDB_OK != dberr){
845                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
846                goto ExitFunc;
847        }
848
849        dberr = bast_add(sst.db, BAST_SCREEN_ID, (uint8_t*)screen, sizeof(struct screen_settings_t));
850        if(BFDB_OK != dberr){
851                BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
852        }
853ExitFunc:
854        return;
855}
856
857/*
858 * Summary:
859 * Read menu settings
860 */
861int bast_screen_read(bapp_t *app)
862{
863        bfdb_err dberr;
864        struct screen_settings_t *screen;
865
866        dberr = bfdb_rewind(sst.db, BAST_SCREEN_ID);
867        if (BFDB_OK == dberr) {
868                dberr = bfdb_get(sst.db, sst.data, sizeof(struct screen_settings_t));
869                if (dberr != BFDB_OK) {
870                        BDBG_ERR(("Error:%d line:%d", dberr, __LINE__));
871                        goto ExitFunc;
872                }
873                screen = (struct screen_settings_t *)sst.data;
874                app->settings.sound = screen->sound;
875                app->settings.picture = screen->picture;
876                app->settings.language = screen->language;
877                app->settings.wiz_completed = screen->wiz_completed;
878                app->settings.ratings.ratings_lock = screen->ratings_lock;
879                app->settings.ratings.ratings_tv = screen->ratings_tv;
880                app->settings.ratings.content_d = screen->content_d;
881                app->settings.ratings.content_l = screen->content_l;
882                app->settings.ratings.content_s = screen->content_s;
883                app->settings.ratings.content_v = screen->content_v;
884                app->settings.ratings.ratings_movies = screen->ratings_movies;
885                app->settings.dcc.captions_basic = screen->captions_basic;
886                app->settings.dcc.captions_font = screen->captions_font;
887                app->settings.dcc.captions_font_size = screen->captions_font_size;
888                app->settings.dcc.captions_font_style = screen->captions_font_style;
889                app->settings.dcc.captions_font_color = screen->captions_font_color;
890                app->settings.dcc.captions_font_opacity = screen->captions_font_opacity;
891                app->settings.dcc.captions_back_color = screen->captions_back_color;
892                app->settings.dcc.captions_back_opacity = screen->captions_back_opacity;
893                app->settings.dcc.captions_edge_color = screen->captions_edge_color;
894                app->settings.dcc.captions_edge_type = screen->captions_edge_type;
895                app->settings.rrt_settings.rrt_status = screen->rrt_status;
896                app->settings.time_zone = screen->time_zone;
897                app->settings.dst = screen->dst;
898                app->settings.rrt_settings.last_rrt_id = screen->last_rrt_id;
899                app->settings.rrt_settings.pin = screen->pin;
900                app->settings.auto_power = screen->auto_power;
901                app->settings.auto_power_off = screen->auto_power_off;
902                app->settings.dcc.captions_analog = screen->analog_captioning;
903        }
904ExitFunc:       
905        return dberr;
906}
Note: See TracBrowser for help on using the repository browser.