source: svn/trunk/newcon3bcm2_21bu/dta/src/app/nanotv/bscreen_debug.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: 17.0 KB
Line 
1/***************************************************************************
2 *     Copyright (c) 2003-2006, Broadcom Corporation
3 *     All Rights Reserved
4 *     Confidential Property of Broadcom Corporation
5 *
6 *  THIS SOFTWARE MAY ONLY BE USED SUBJECT TO AN EXECUTED SOFTWARE LICENSE
7 *  AGREEMENT  BETWEEN THE USER AND BROADCOM.  YOU HAVE NO RIGHT TO USE OR
8 *  EXPLOIT THIS MATERIAL EXCEPT SUBJECT TO THE TERMS OF SUCH AN AGREEMENT.
9 *
10 * $brcm_Workfile:  $
11 * $brcm_Revision:  $
12 * $brcm_Date: $
13 *
14 * Module Description:
15 *
16 * Revision History:
17 *
18 * $brcm_Log:  $
19 *
20 ***************************************************************************/
21
22#include "bapp.h"
23#include "bstd.h"
24#include "bapp_util.h"
25#include "bapp_palette.h"
26#include "bgfx.h"
27#include "chan_mgr.h"
28#include "ch_map.h"
29
30BDBG_MODULE(bscreen_debug);              /* Register software module with debug interface */
31
32typedef enum dbg_layout_t
33{
34        eDBG_STATUS_X   = 260,
35        eDBG_STATUS_Y   = 40,
36        eDBG_COL_WIDTH  = 170,
37        eDBG_ROW_HEIGHT = 26,
38}dbg_layout_t;
39
40static const char *s_status_str_table[] =
41{
42        "V/A/PCR PID:",
43        "VSTC/PTS:",
44        "ASTC/PTS:",
45        "AV,V,A Delta:",
46        "A/V FIFO:",
47        "SRC W:H:",
48        "FREQ:",
49        "SNR:",
50        "State:",
51        "Version:",
52#ifdef CONFIG_SCL_INFO 
53        "SCL IN:",
54        "SCL OUT:",
55        "SRC OUT:",
56        "WIN:",
57        "PanScan:",
58#endif
59        "\0"
60};
61
62/* left, freq 1000, count 48, repeat 1 */
63static const uint32_t s_1khz_samples[] =
64{
65        (uint32_t) 0,
66        (uint32_t) 68433,
67        (uint32_t) 135695,
68        (uint32_t) 200636,
69        (uint32_t) 262143,
70        (uint32_t) 319166,
71        (uint32_t) 370727,
72        (uint32_t) 415945,
73        (uint32_t) 454046,
74        (uint32_t) 484378,
75        (uint32_t) 506422,
76        (uint32_t) 519802,
77        (uint32_t) 524287,
78        (uint32_t) 519802,
79        (uint32_t) 506422,
80        (uint32_t) 484378,
81        (uint32_t) 454046,
82        (uint32_t) 415945,
83        (uint32_t) 370727,
84        (uint32_t) 319166,
85        (uint32_t) 262143,
86        (uint32_t) 200636,
87        (uint32_t) 135695,
88        (uint32_t) 68433,
89        (uint32_t) 0,
90        (uint32_t) -68433,
91        (uint32_t) -135695,
92        (uint32_t) -200636,
93        (uint32_t) -262143,
94        (uint32_t) -319166,
95        (uint32_t) -370727,
96        (uint32_t) -415945,
97        (uint32_t) -454046,
98        (uint32_t) -484378,
99        (uint32_t) -506422,
100        (uint32_t) -519802,
101        (uint32_t) -524287,
102        (uint32_t) -519802,
103        (uint32_t) -506422,
104        (uint32_t) -484378,
105        (uint32_t) -454046,
106        (uint32_t) -415945,
107        (uint32_t) -370727,
108        (uint32_t) -319166,
109        (uint32_t) -262144,
110        (uint32_t) -200636,
111        (uint32_t) -135695,
112        (uint32_t) -68433
113};
114
115
116//static int s_1khz_samples_num = sizeof(s_1khz_samples)/sizeof(s_1khz_samples[0]);
117
118/* Actual frequency: 10000, Repeat count: 24, Number of sine waves per repeat: 5 */
119static const uint32_t s_10khz_samples[] =
120{
121        (uint32_t) 0,
122        (uint32_t) 506422,
123        (uint32_t) 262143,
124        (uint32_t) -370727,
125        (uint32_t) -454046,
126        (uint32_t) 135695,
127        (uint32_t) 524287,
128        (uint32_t) 135695,
129        (uint32_t) -454046,
130        (uint32_t) -370727,
131        (uint32_t) 262144,
132        (uint32_t) 506422,
133        (uint32_t) 0,
134        (uint32_t) -506422,
135        (uint32_t) -262144,
136        (uint32_t) 370727,
137        (uint32_t) 454046,
138        (uint32_t) -135695,
139        (uint32_t) -524287,
140        (uint32_t) -135695,
141        (uint32_t) 454046,
142        (uint32_t) 370727,
143        (uint32_t) -262143,
144        (uint32_t) -506422
145};
146
147//static int s_10khz_samples_num = sizeof(s_10khz_samples)/sizeof(s_10khz_samples[0]);
148
149/*
150Summary:
151        Use the this function to get a UNI string.
152*/
153
154static void get_status_str(bapp_t *p_app,
155                                                  int text_id,           /* Text id */
156                                                  unsigned int *p_uni_str,        /* Buffer to put UNI string into */
157                                                  unsigned int *str_len    /* On input the max length in words on output the actual size in characters. */
158                                                  )
159{
160        static char ts_str[64];
161        *str_len = 0;
162#if 0
163        switch (text_id)
164        {
165        case 0: *str_len = snprintf(ts_str,64,"0x%04x, 0x%04x, 0x%04x",p_status->vPID,p_status->aPID,p_status->pcrPID); break;
166        case 1: *str_len = snprintf(ts_str,64,"0x%08x/0x%08x",p_status->video_stc,p_status->video_pts); break;
167        case 2: *str_len = snprintf(ts_str,64,"0x%08x/0x%08x",p_status->audio_stc,p_status->audio_pts); break;
168        case 3: *str_len = snprintf(ts_str,64,"%d,%d,%d",(int)p_status->audio_pts - (int)p_status->video_pts,
169                                                                (int)p_status->audio_stc-(int)p_status->audio_pts,
170                                                                (int)p_status->video_stc-(int)p_status->video_pts);
171                                                                break;
172        case 4: *str_len = snprintf(ts_str,64,"%d/%d,%d/%d",p_status->audio_fifo_depth,p_status->audio_fifo_size,p_status->video_fifo_depth,p_status->video_fifo_size); break;
173        case 5: *str_len = snprintf(ts_str,64,"%d:%d(%s,%d)",p_status->source_width,p_status->source_height,(p_status->bStreamProgressive ? "P" : "I"),p_status->video_aspect_ratio); break;
174        case 6:
175                *str_len = snprintf(ts_str,64,"%d",p_vsb_status->freq);
176                break;
177        case 7:
178                *str_len = snprintf(ts_str,64,"%d",p_vsb_status->snr);
179                break;
180        case 8:
181                *str_len = snprintf(ts_str,64,"%s(late:  %d/%d) %s",(p_status->bVideoDecoderState == 0) ? "stop" : "start",p_status->late_int,
182                                                        p_status->picture_int_cnt,(ReadReg32(BCHP_HIFIDAC_CTRL0_MUTECTRL) & BCHP_HIFIDAC_CTRL0_MUTECTRL_MUTEALL_MASK) ? "mute" : "unmute");
183                break;
184        case 9:
185                *str_len = snprintf(ts_str, 64, "%d.%d.%d, %s", MAJOR_VERSION,MINOR_VERSION,SUB_VERSION,__DATE__);
186                break;
187#ifdef CONFIG_SCL_INFO 
188        case 10: *str_len = snprintf(ts_str,64,"%d,%d,%d,%d",p_status->scl_cut_left,p_status->scl_cut_top,p_status->scl_cut_width,p_status->scl_cut_height); break;
189        case 11: *str_len = snprintf(ts_str,64,"%d,%d,%d,%d",p_status->scl_out_left,p_status->scl_out_top,p_status->scl_out_width,p_status->scl_out_height); break;
190        case 12: *str_len = snprintf(ts_str,64,"%d,%d,%d,%d",p_status->src_out_left,p_status->src_out_top,p_status->src_out_width,p_status->src_out_height); break;
191        case 13: *str_len = snprintf(ts_str,64,"%d,%d,%d,%d",p_status->win_left,p_status->win_top,p_status->win_width,p_status->win_height); break;
192        case 14: *str_len = snprintf(ts_str,64,"%d,%d(0x%04x)",p_status->hPanScan,p_status->vPanScan,p_status->video_format); break;
193#endif
194        }
195#endif /* JPF TODO */
196        if (*str_len)
197        {
198                *str_len = c_to_uni_str(ts_str,p_uni_str,*str_len);
199        }
200}
201
202
203/*
204Summary:
205        Use the this function to get a UNI string.
206*/
207
208static void get_status_label(
209                                                        int text_id,       /* Text id */
210                                                        unsigned int *p_uni_str,        /* Buffer to put UNI string into */
211                                                        unsigned int *str_len           /* On input the max length in words on output the actual size in characters. */
212                                                        )
213{
214        char *p_str;
215
216        p_str = (char*)s_status_str_table[text_id];
217        if (!p_str)
218        {
219                *str_len = 0;
220                return;
221        }
222
223        *str_len = c_to_uni_str(p_str,p_uni_str,*str_len);
224}
225/*
226Summary:
227        Status screen drawing function.
228*/
229void bscreen_status_draw(void *v_app, void *v_screen)
230{
231        bapp_t *p_app = (bapp_t*)v_app;
232        /* not used bscreen_t *p_screen = (bscreen_t*)v_screen; */
233        uint16_t x,y,y_off;
234        unsigned int num_chars = 0;
235        int i;
236#if 0
237        bdecode_status status;
238        btuner_ds_status vsb_status;
239#endif /* JPF TODO */
240        x = eDBG_STATUS_X;
241        y = eDBG_STATUS_Y;
242
243        i = 0;
244#if 0
245
246        status.audio_decode = p_app->audio;
247        bdecode_get_status(p_app->decode,&status);
248
249        btuner_get_ds_status(p_app->chm.tuner, &vsb_status);
250#endif
251        while (*(s_status_str_table[i]) != '\0')
252        {
253                y_off = y + (i * eDBG_ROW_HEIGHT);
254                bgfx_fill_rect(&p_app->surf,x,y_off,eWIDTH - x,eDBG_ROW_HEIGHT,eCOLOR_BLACK_65);
255                num_chars = SCREEN_MAX_STR_WIDTH;
256                get_status_label(i, p_app->tmp_str, &num_chars);
257                text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
258                                 x, y_off, eDBG_COL_WIDTH - 20, eDBG_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
259
260                num_chars = SCREEN_MAX_STR_WIDTH;
261                get_status_str(p_app,i,p_app->tmp_str, &num_chars);
262                text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
263                                 x + eDBG_COL_WIDTH + 20, y_off, eWIDTH - x - eDBG_COL_WIDTH, eDBG_ROW_HEIGHT, 
264                                 p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
265                i++;
266        }
267}
268
269/*
270Summary:
271        Status screen event handler for debugging and monitoring.
272        .
273*/
274#ifdef CONFIG_BCM_FACTORY_TEST
275int bscreen_status_event(void *v_app, void *v_screen, 
276                                                 bscreen_event_t *p_event)
277{
278        bapp_t *p_app = (bapp_t*)v_app;
279        bscreen_t *p_screen = (bscreen_t*)v_screen;
280        int result = 0;
281        int i;
282        unsigned int flags;
283
284        static bool tune = false;
285        static int cnt = 0;
286        static int reject_key_timeout = 10;
287
288        switch (p_event->type)
289        {
290        case eS_EVENT_IDLE:
291                {
292                        if (reject_key_timeout > 0)
293                        {
294                                reject_key_timeout--;
295                                if (reject_key_timeout == 0)
296                                {
297                                        bapp_sync(p_app);
298                                        bgfx_fill_rect(&p_app->surf,0,0,eWIDTH,eHEIGHT,eCOLOR_CLEAR);
299                                        bapp_flush_screen(p_app);
300                                }
301                        }
302
303                        if (cnt++ == 10)
304                        {
305                                cnt = 0;
306                                bapp_sync(p_app);
307                                bscreen_status_draw(v_app,v_screen);
308                                bapp_flush_screen(p_app);
309                        }
310                }
311                break;
312        case eS_EVENT_SETUP_DONE:
313                result = 0;
314                BDBG_WRN(("eS_EVENT_SETUP_DONE...\n"));
315                if (p_app->state == eAPP_STATE_FACTORY)
316                {
317                        result = 1;
318                        p_app->cur_ch_num = 0;
319                        tune = true;
320                }
321                break;
322
323        case eS_EVENT_SETUP:
324                BDBG_WRN(("eS_EVENT_SETUP...\n"));
325                if (p_app->state == eAPP_STATE_FACTORY)
326                {
327                        p_app->audio_vol = 0;   /* max volume */
328                        bapp_set_audio_volume(p_app, p_app->audio_vol);
329                        /* For factory test mode only */
330                        flags = bapp_task_enter_critical();
331                        WriteReg32(LED_DATA_REG, ReadReg32( LED_DATA_REG) | LED_GREEN_MASK);
332                        bapp_task_exit_critical(flags);
333                }
334                result = 1;
335                flags = bapp_task_enter_critical();
336#if (BCHP_CHIP!=3543)
337                WriteReg32(LED_DATA_REG, ReadReg32( LED_DATA_REG) & ~LED_RED_MASK);
338#else
339                WriteReg32(BCHP_SUN_TOP_CTRL_GENERAL_CTRL_1, 
340                        ReadReg32( BCHP_SUN_TOP_CTRL_GENERAL_CTRL_1) & ~BCHP_SUN_TOP_CTRL_GENERAL_CTRL_1_irw_top_sw_led_cntrl_MASK);
341#endif
342                bapp_task_exit_critical(flags);
343                bapp_av_mute(p_app, 0);
344                break;
345
346        case eS_EVENT_SELECTED:
347                result = (p_screen->button_selection == p_event->id) ? 1 : 0;
348                break;
349
350        case eS_EVENT_CHECKED:
351                result = (p_screen->button_checked == p_event->id) ? 1 : 0;
352                break;
353
354        case eS_EVENT_IR:
355                {
356                       
357                        if (reject_key_timeout > 0)
358                        {
359                                BDBG_WRN(("############ STARTING UP THROW AWAY KEY (0x%08x) ############",p_event->id));
360                                break;
361                        }
362
363                        if (p_event->id & 0x40000000)
364                        {
365                                BDBG_WRN(("############ THROW AWAY KEY UP (0x%08x) ############",p_event->id));
366                                break;
367                        }
368                       
369                        switch (p_event->id)
370                        {
371                        case eIR_CH_UP:
372                        case eIR_UP:
373                                result = bapp_change_channel(p_app, 1, 1);
374                                break;
375
376                        case eIR_CH_DOWN:
377                        case eIR_DOWN:
378                                result = bapp_change_channel(p_app, 0, 1);
379                                break;
380                        case eIR_RIGHT:
381                                {
382                                        static char idx = 0;
383                                        if (idx < 4)
384                                        {
385                                                p_app->settings.ch[p_app->cur_ch_num].cmd = idx << 5;
386                                        } else
387                                        {
388                                                p_app->settings.ch[p_app->cur_ch_num].cmd = 0;
389                                        }
390                                        bant_send(p_app->settings.ch[p_app->cur_ch_num].cmd,
391                                                          p_app->settings.ch[p_app->cur_ch_num].freq_idx + 2);
392                                        idx++;
393                                        if (idx > 4)
394                                                idx = 0;
395                                }
396                                break;
397                        case eIR_LEFT:
398                                {
399                                        static char idx = 0;
400                                        p_app->settings.ch[p_app->cur_ch_num].cmd = idx;
401                                        bant_send(p_app->settings.ch[p_app->cur_ch_num].cmd,
402                                                          p_app->settings.ch[p_app->cur_ch_num].freq_idx + 2);
403                                        if (idx == 0x7F)
404                                                idx = 0;
405                                        else
406                                                idx++;
407                                }
408                                break;
409
410                        default:
411                                break;
412                        }
413                        break;
414                }
415                break;
416        default:
417                break;
418        }
419        return result; /* always handle event */
420}
421
422#else /* CONFIG_BCM_FACTORY_TEST */
423int bscreen_status_event(void *v_app, void *v_screen, 
424                                                 bscreen_event_t *p_event)
425{
426        bapp_t *p_app = (bapp_t*)v_app;
427        bscreen_t *p_screen = (bscreen_t*)v_screen;
428        int result = 0;
429//      int i;
430//      unsigned int flags;
431
432        static bool tune = false;
433        static bool color_bars = false;
434        static bool status = false;
435        static int cnt = 0;
436        static int reject_key_timeout = 10;
437
438        switch (p_event->type)
439        {
440        case eS_EVENT_IDLE:
441                {
442//                      static int led_cnt = 0;
443//                      static bool led_enabled = false;
444                        if (reject_key_timeout > 0)
445                        {
446                                reject_key_timeout--;
447                                if (reject_key_timeout == 0)
448                                {
449                                        bapp_sync(p_app);
450                                        bgfx_fill_rect(&p_app->surf,0,0,eWIDTH,eHEIGHT,eCOLOR_CLEAR);
451                                        bapp_flush_screen(p_app);
452                                }
453                        }
454
455                        if (cnt++ == 10)
456                        {
457                                cnt = 0;
458                                if (color_bars)
459                                {
460                                        cnt = 11;
461                                        bapp_sync(p_app);
462                                        bgfx_fill_rect(&p_app->surf,0,0,eWIDTH ,eHEIGHT,eCOLOR_BLACK);
463                                        bgfx_fill_rect(&p_app->surf,40,40,eWIDTH - 80,eHEIGHT - 80,eCOLOR_WHITE);
464                                        bgfx_fill_rect(&p_app->surf,80,80,(eWIDTH - 160)/3,eHEIGHT - 160,eCOLOR_DK_YELLOW);
465                                        bgfx_fill_rect(&p_app->surf,80 + ((eWIDTH - 160)/3),80,(eWIDTH - 160)/3,eHEIGHT - 160,eCOLOR_NEON_GREEN);
466                                        bgfx_fill_rect(&p_app->surf,80 + (((eWIDTH - 160) * 2)/3),80,(eWIDTH - 160)/3,eHEIGHT - 160,eCOLOR_LT_BLUE);
467                                        bapp_flush_screen(p_app);
468
469                                }
470                                else if ((p_app->state != eAPP_STATE_FACTORY) || status)
471                                {
472                                        bapp_sync(p_app);
473                                        bscreen_status_draw(v_app,v_screen);
474                                        bapp_flush_screen(p_app);
475                                }
476                        }
477#if 0 /* JPF TODO */
478                        if ((led_cnt++ == 5) && (p_app->state == eAPP_STATE_FACTORY))
479                        {
480                                flags = bapp_task_enter_critical();
481                                led_cnt = 0;
482
483                                /* flash the LED */
484                                if (led_enabled)
485                                {
486                                        WriteReg32(LED_DATA_REG, ReadReg32( LED_DATA_REG) | LED_GREEN_MASK);
487                                } else
488                                {
489                                        WriteReg32(LED_DATA_REG, ReadReg32( LED_DATA_REG) & ~LED_GREEN_MASK);
490                                }
491                                bapp_task_exit_critical(flags);
492                                led_enabled = (led_enabled) ? false : true;
493                        }
494#endif
495                }
496                break;
497        case eS_EVENT_SETUP_DONE:
498                result = 0;
499                BDBG_WRN(("eS_EVENT_SETUP_DONE...\n"));
500                if (p_app->state == eAPP_STATE_FACTORY)
501                {
502                        result = 1;
503                        tune = true;
504                }
505                break;
506
507        case eS_EVENT_SETUP:
508                BDBG_WRN(("eS_EVENT_SETUP...\n"));
509                if (p_app->state == eAPP_STATE_FACTORY)
510                {
511                        p_app->audio_vol = 0;   /* max volume */
512                        bapp_set_audio_volume(p_app, p_app->audio_vol);
513                        /* For factory test mode only */
514#if 0 /* JPF TODO */
515                        flags = bapp_task_enter_critical();
516                        WriteReg32(LED_DATA_REG, ReadReg32( LED_DATA_REG) | LED_GREEN_MASK);
517                        bapp_task_exit_critical(flags);
518#endif
519                }
520                result = 1;
521#if 0 /* JPF TODO */
522                flags = bapp_task_enter_critical();
523#if (BCHP_CHIP!=3543)
524                WriteReg32(LED_DATA_REG, ReadReg32( LED_DATA_REG) & ~LED_RED_MASK);
525#else
526                WriteReg32(BCHP_SUN_TOP_CTRL_GENERAL_CTRL_1,
527                        ReadReg32( BCHP_SUN_TOP_CTRL_GENERAL_CTRL_1) & ~BCHP_SUN_TOP_CTRL_GENERAL_CTRL_1_irw_top_sw_led_cntrl_MASK);
528#endif
529                bapp_task_exit_critical(flags);
530#endif
531                bapp_av_mute(p_app, 0);
532                break;
533
534        case eS_EVENT_SELECTED:
535                result = (p_screen->button_selection == p_event->id) ? 1 : 0;
536                break;
537
538        case eS_EVENT_CHECKED:
539                result = (p_screen->button_checked == p_event->id) ? 1 : 0;
540                break;
541
542        case eS_EVENT_IR:
543                {
544                       
545                        if (reject_key_timeout > 0)
546                        {
547                                BDBG_WRN(("############ STARTING UP THROW AWAY KEY (0x%08x) ############",p_event->id));
548                                break;
549                        }
550
551                        if (p_event->id & 0x40000000)
552                        {
553                                BDBG_WRN(("############ THROW AWAY KEY UP (0x%08x) ############",p_event->id));
554                                break;
555                        }
556#if 0 /* JPF TODO */
557                       
558                        WriteReg32(BCHP_HIFIDAC_CTRL0_TEST,
559                                           ReadReg32(BCHP_HIFIDAC_CTRL0_TEST) & ~BCHP_HIFIDAC_CTRL0_TEST_TESTTONE_ENABLE_MASK);
560#endif
561                        if (p_app->state != eAPP_STATE_FACTORY)
562                        {
563                                bgfx_fill_rect(&p_app->surf,0,0,eWIDTH,eHEIGHT,eCOLOR_CLEAR);
564                                result = 1;
565                                bapp_goto_last_screen(v_app);
566                                return result;
567                        }
568                        color_bars = false;
569                        status = false;
570                        switch (p_event->id)
571                        {
572                        case eIR_1:
573                                break;
574
575                        case eIR_2:
576                                break;
577
578                        case eIR_3:
579                                break;
580
581                        case eIR_4:
582                                BDBG_WRN(("Test left audio channel...\n"));
583                                color_bars = true;
584                                cnt = 0;
585#if 0 /* JPF TODO */
586                                /* left, freq 1000, count 48, repeat 1 */
587                                WriteReg32(BCHP_HIFIDAC_CTRL0_TEST, (BCHP_HIFIDAC_CTRL0_TEST_TESTTONE_ENABLE_MASK |
588                                                                                                         BCHP_HIFIDAC_CTRL0_TEST_TESTTONE_SHARE_MASK |
589                                                                                                         BCHP_HIFIDAC_CTRL0_TEST_TESTTONE_RIGHT_MASK |
590                                                                                                         (47 << BCHP_HIFIDAC_CTRL0_TEST_TESTTONE_REPEAT_LEFT_SHIFT)));
591                                for (i = 0; i < s_1khz_samples_num; ++i)
592                                {
593                                        WriteReg32(BCHP_HIFIDAC_CTRL0_TESTTONE_SAMPLE_i_ARRAY_BASE + (i * 4),s_1khz_samples[i]);
594                                }
595#endif
596                                break;
597
598                        case eIR_6:
599                                BDBG_WRN(("Test right audio channel...\n"));
600                                color_bars = true;
601                                cnt = 0;
602#if 0 /* JPF TODO */
603                                /* Actual frequency: 10000, Repeat count: 24, Number of sine waves per repeat: 5 */
604                                WriteReg32(BCHP_HIFIDAC_CTRL0_TEST, (BCHP_HIFIDAC_CTRL0_TEST_TESTTONE_ENABLE_MASK |
605                                                                                                         BCHP_HIFIDAC_CTRL0_TEST_TESTTONE_SHARE_MASK |
606                                                                                                         BCHP_HIFIDAC_CTRL0_TEST_TESTTONE_LEFT_MASK |
607                                                                                                         (23 << BCHP_HIFIDAC_CTRL0_TEST_TESTTONE_REPEAT_LEFT_SHIFT)));
608                                /* Write every other sample */
609                                for (i = 0; i < s_10khz_samples_num; ++i)
610                                {
611                                        WriteReg32(BCHP_HIFIDAC_CTRL0_TESTTONE_SAMPLE_i_ARRAY_BASE + (i * 4),s_10khz_samples[i]);
612                                }
613#endif
614                                break;
615
616                        case eIR_8:
617                        case eIR_7:
618                                BDBG_WRN(("Status...\n"));
619                                bapp_sync(p_app);
620                                bgfx_fill_rect(&p_app->surf,0,0,eWIDTH,eHEIGHT,eCOLOR_CLEAR);
621                                bapp_flush_screen(p_app);
622                                status = true;
623                                cnt = 0;
624                                break;
625
626                        case eIR_9:
627                                BDBG_WRN(("Reset user settings...\n"));
628                                /* setup flash */
629                                bapp_reset_settings(p_app);
630
631                                /* update flash with new settings */
632                                bapp_save_settings(p_app);
633                                BDBG_WRN(("Factory reset complete, powering off...\n"));
634                                bos_sleep(200);
635                                bapp_do_poweroff(p_app);
636                                result = 1;
637                                break;
638
639                        case eIR_UP:
640                        case eIR_CH_UP:
641                                tune = ch_map_set_next(bapp_cur_ch_map(p_app));
642                                break;
643
644                        case eIR_CH_DOWN:
645                        case eIR_DOWN:
646                                tune = ch_map_set_prev(bapp_cur_ch_map(p_app));
647                                break;
648
649                        case eIR_0:
650                        case eIR_5:
651                        default:
652                                break;
653                        }
654                        break;
655                }
656                break;
657        default:
658                break;
659        }
660
661        if (tune)
662        {
663                bapp_sync(p_app);
664                bgfx_fill_rect(&p_app->surf,0,0,eWIDTH,eHEIGHT,eCOLOR_CLEAR);
665                bapp_flush_screen(p_app);
666                bapp_tune(p_app);
667                tune = false;
668        }
669        return result; /* always handle event */
670}
671#endif /* CONFIG_BCM_FACTORY_TEST */
672
673
Note: See TracBrowser for help on using the repository browser.