source: svn/trunk/newcon3bcm2_21bu/dta/src/app/dta/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.2 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
116static 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
147static 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 = 100;
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        unsigned int i, flags;
430
431        static bool tune = false;
432        static bool color_bars = false;
433        static bool status = false;
434        static int cnt = 0;
435        static int reject_key_timeout = 10;
436
437        switch (p_event->type)
438        {
439        case eS_EVENT_IDLE:
440                {
441                        static int led_cnt = 0;
442                        static bool led_enabled = false;
443
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 ((led_cnt++ == 5) && (p_app->state == eAPP_STATE_FACTORY))
478                        {
479                                flags = bos_enter_critical();
480                                led_cnt = 0;
481                       
482#if (BCHP_CHIP!=7552) && (BCHP_CHIP!=7344)
483                                value = BREG_Read32(GetREG(), BCHP_SUN_TOP_CTRL_GENERAL_CTRL_1);       
484                                /* flash the LED */
485                                if (led_enabled)
486                                {
487                                        BREG_Write32(GetREG(), BCHP_SUN_TOP_CTRL_GENERAL_CTRL_1, value & ~BCHP_SUN_TOP_CTRL_GENERAL_CTRL_1_irw_top_sw_led_cntrl_MASK);
488                                } else
489                                {
490                                        BREG_Write32(GetREG(), BCHP_SUN_TOP_CTRL_GENERAL_CTRL_1, value | BCHP_SUN_TOP_CTRL_GENERAL_CTRL_1_irw_top_sw_led_cntrl_MASK);
491                                }
492#endif
493                                bos_exit_critical(flags);
494                                led_enabled = (led_enabled) ? false : true;
495                        }
496                }
497                break;
498        case eS_EVENT_SETUP_DONE:
499                result = 0;
500                BDBG_WRN(("eS_EVENT_SETUP_DONE...\n"));
501                if (p_app->state == eAPP_STATE_FACTORY)
502                {
503                        result = 1;
504                        tune = true;
505                }
506                break;
507
508        case eS_EVENT_SETUP:
509                BDBG_WRN(("eS_EVENT_SETUP...\n"));
510                if (p_app->state == eAPP_STATE_FACTORY)
511                {
512                        p_app->audio_vol = 100;
513                        bapp_set_audio_volume(p_app, p_app->audio_vol);
514                        /* For factory test mode only */
515#if 0 /* JPF TODO */
516                        flags = bapp_task_enter_critical();
517                        WriteReg32(LED_DATA_REG, ReadReg32( LED_DATA_REG) | LED_GREEN_MASK);
518                        bapp_task_exit_critical(flags);
519#endif
520                }
521                result = 1;
522#if 0 /* JPF TODO */
523                flags = bapp_task_enter_critical();
524#if (BCHP_CHIP!=3543)
525                WriteReg32(LED_DATA_REG, ReadReg32( LED_DATA_REG) & ~LED_RED_MASK);
526#else
527                WriteReg32(BCHP_SUN_TOP_CTRL_GENERAL_CTRL_1,
528                        ReadReg32( BCHP_SUN_TOP_CTRL_GENERAL_CTRL_1) & ~BCHP_SUN_TOP_CTRL_GENERAL_CTRL_1_irw_top_sw_led_cntrl_MASK);
529#endif
530                bapp_task_exit_critical(flags);
531#endif
532                bapp_av_mute(p_app, 0);
533                break;
534
535        case eS_EVENT_SELECTED:
536                result = (p_screen->button_selection == p_event->id) ? 1 : 0;
537                break;
538
539        case eS_EVENT_CHECKED:
540                result = (p_screen->button_checked == p_event->id) ? 1 : 0;
541                break;
542
543        case eS_EVENT_IR:
544                {
545                       
546                        if (reject_key_timeout > 0)
547                        {
548                                BDBG_WRN(("############ STARTING UP THROW AWAY KEY (0x%08x) ############",p_event->id));
549                                break;
550                        }
551
552                        if (p_event->id & 0x40000000)
553                        {
554                                BDBG_WRN(("############ THROW AWAY KEY UP (0x%08x) ############",p_event->id));
555                                break;
556                        }
557#if 0 /* JPF TODO */
558                       
559                        WriteReg32(BCHP_HIFIDAC_CTRL0_TEST,
560                                           ReadReg32(BCHP_HIFIDAC_CTRL0_TEST) & ~BCHP_HIFIDAC_CTRL0_TEST_TESTTONE_ENABLE_MASK);
561#endif
562                        if (p_app->state != eAPP_STATE_FACTORY)
563                        {
564                                bgfx_fill_rect(&p_app->surf,0,0,eWIDTH,eHEIGHT,eCOLOR_CLEAR);
565                                result = 1;
566                                bapp_goto_last_screen(v_app);
567                                return result;
568                        }
569                        color_bars = false;
570                        status = false;
571                        switch (p_event->id)
572                        {
573                        case eIR_1:
574                                break;
575
576                        case eIR_2:
577                                break;
578
579                        case eIR_3:
580                                break;
581
582                        case eIR_4:
583                                BDBG_WRN(("Test left audio channel...\n"));
584                                color_bars = true;
585                                cnt = 0;
586/* JPF TODO */
587                                /* left, freq 1000, count 48, repeat 1 */
588                                //WriteReg32(BCHP_HIFIDAC_CTRL0_TEST, (BCHP_HIFIDAC_CTRL0_TEST_TESTTONE_ENABLE_MASK |
589                                //                                                                       BCHP_HIFIDAC_CTRL0_TEST_TESTTONE_SHARE_MASK |
590                                //                                                                       BCHP_HIFIDAC_CTRL0_TEST_TESTTONE_RIGHT_MASK |
591                                //                                                                       (47 << BCHP_HIFIDAC_CTRL0_TEST_TESTTONE_REPEAT_LEFT_SHIFT)));
592                                for (i = 0; i < s_1khz_samples_num; ++i)
593                                {
594                                        //WriteReg32(BCHP_HIFIDAC_CTRL0_TESTTONE_SAMPLE_i_ARRAY_BASE + (i * 4),s_1khz_samples[i]);
595                                }
596                                break;
597
598                        case eIR_6:
599                                BDBG_WRN(("Test right audio channel...\n"));
600                                color_bars = true;
601                                cnt = 0;
602/* 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                                break;
614
615                        case eIR_8:
616                        case eIR_7:
617                                BDBG_WRN(("Status...\n"));
618                                bapp_sync(p_app);
619                                bgfx_fill_rect(&p_app->surf,0,0,eWIDTH,eHEIGHT,eCOLOR_CLEAR);
620                                bapp_flush_screen(p_app);
621                                status = true;
622                                cnt = 0;
623                                break;
624
625                        case eIR_9:
626                                BDBG_WRN(("Reset user settings...\n"));
627                                /* setup flash */
628                                bapp_reset_settings(p_app);
629
630                                /* update flash with new settings */
631                                bapp_save_settings(p_app);
632                                BDBG_WRN(("Factory reset complete, powering off...\n"));
633                                bos_sleep(200);
634                                bapp_do_poweroff(p_app);
635                                result = 1;
636                                break;
637
638                        case eIR_UP:
639                        case eIR_CH_UP:
640                                tune = ch_map_set_next(bapp_cur_ch_map(p_app));
641                                break;
642
643                        case eIR_CH_DOWN:
644                        case eIR_DOWN:
645                                tune = ch_map_set_prev(bapp_cur_ch_map(p_app));
646                                break;
647
648                        case eIR_0:
649                        case eIR_5:
650                        default:
651                                break;
652                        }
653                        break;
654                }
655                break;
656        default:
657                break;
658        }
659
660        if (tune)
661        {
662                bapp_sync(p_app);
663                bgfx_fill_rect(&p_app->surf,0,0,eWIDTH,eHEIGHT,eCOLOR_CLEAR);
664                bapp_flush_screen(p_app);
665                bapp_tune(p_app);
666                tune = false;
667        }
668        return result; /* always handle event */
669}
670#endif /* CONFIG_BCM_FACTORY_TEST */
671
672
Note: See TracBrowser for help on using the repository browser.