Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

bapp_settings.c @ 43

Last change on this file since 43 was 43, 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
63	BDBG_MODULE(bast); /* Register software module with debug interface */
64
65
66	struct settings_state_t {
67	bfdb_handle db;
68	uint8_t data[BFDB_DATA_MAX];
69	};
70
71	static struct settings_state_t sst;
72
73	static 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	*/
91	void 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
119	bfdb_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	}
141	ExitFunc:
142	return dberr;
143	}
144
145	/* add with compact if add fails */
146	bfdb_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
162	void 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	}
186	ExitFunc:
187	return;
188	}
189
190	void 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
233	ExitFunc:
234	return;
235	}
236
237	void 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	}
259	ExitFunc:
260	#endif
261	return;
262	}
263
264	bfdb_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	}
274	ExitFunc:
275	return dberr;
276	}
277
278	void 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
337	void turn_on_led_t(void)
338	{
339	(volatile unsigned long )PHYS_TO_K1(0x10000000+0x00408020) = 0x00000001;
340	}
341
342
343	void 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
349	int 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
362	void 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
407	int 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	}
425	ExitFunc:
426	return dberr;
427	}
428
429	int 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	}
469	ExitFunc:
470	return dberr;
471	}
472
473	int 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	}
492	ExitFunc:
493	return dberr;
494	#endif
495	return 0;
496	}
497
498	int 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	}
550	ExitFunc:
551	return dberr;
552	}
553
554	void 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	}
568	ExitFunc:
569	return;
570	}
571
572	/*
573	* Summary:
574	* Save digital closed captioning settings.
575	* */
576
577
578	void 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	}
592	ExitFunc:
593	return;
594	}
595	/*
596	* Summary:
597	* Read digital closed captioning settings.
598	*/
599
600	int 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	* */
617	void 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	}
631	ExitFunc:
632	return;
633	}
634	/*
635	* Summary:
636	* Read ratings settings.
637	* */
638
639	int 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	* */
656	void 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[20xFF]),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[30xFF]),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[40xFF]),4);
711	if(BFDB_OK != dberr){
712	BDBG_ERR(("Error:%d line:%d\n", dberr, __LINE__));
713	}
714	ExitFunc:
715	return;
716	}
717	/*
718	* Summary:
719	* Read RRT settings.
720	* */
721
722	int 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[20xFF]),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[20xFF]),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[30xFF]),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[40xFF]),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	*/
807	void 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	}
853	ExitFunc:
854	return;
855	}
856
857	/*
858	* Summary:
859	* Read menu settings
860	*/
861	int 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	}
904	ExitFunc:
905	return dberr;
906	}

Note: See TracBrowser for help on using the repository browser.

Context Navigation

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

Download in other formats: