source: svn/newcon3bcm2_21bu/BSEAV/lib/scte_127/bapp_gs.c @ 46

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

459Mhz로 OTC 주파수 변경
  • Property svn:executable set to *
File size: 14.7 KB
Line 
1/***************************************************************************
2 *     Copyright (c) 2008, 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#include "bapp_gs.h"
22//#include "bstd.h"
23#include "bchp_gse_0.h"
24#include "bchp_gse_1.h"
25#include "bchp_vbi_enc.h"
26#include "bchp_vf_0.h"
27#include "bstd.h"
28#include "scte_127.h"
29#include "ministd.h"
30#include "gist.h"
31
32BDBG_MODULE(bapp_gs);
33
34#ifndef BAPP_ASSERT
35#define BAPP_ASSERT(expr) {                                         \
36    if (!expr)                                                      \
37        printf("%s failed at %s:%d\n",#expr, __FILE__, __LINE__);   \
38    }
39#endif
40
41#define GS_ENABLE_TIMEOUT       (g_ticks_per_second * 2)
42
43#define BASE_LINE               10
44
45/*
46 * Main data structure containing references to all interfaces
47 * required throughout the application.
48 */
49struct bapp_gs
50{
51        bool                    done;
52        bool                    enabled;
53        b_mutex_t               mutex;
54        int                     baseline_top;           /* baseline for top field */
55        unsigned short          linemask_top;           /* bit mask for top field */
56        int                     baseline_bot;           /* baseline for bottom field */
57        unsigned short          linemask_bot;           /* bit mask for bottom field */
58};
59
60bapp_gs_t s_p_gs = NULL;
61
62#define IRE_70                  0x5c    /* 92 */
63#define IRE_80                  0x69    /* 105 */
64
65/*
66Summary:
67        Initialize and allocate resources
68*/
69bapp_gs_t bapp_gs_open(void* p_opaque_app)
70{
71        BDBG_MSG(("%s: enter", __func__));
72
73        s_p_gs = (bapp_gs_t)malloc(sizeof(struct bapp_gs));
74        BAPP_ASSERT(s_p_gs);
75
76        memset(s_p_gs, 0, sizeof(struct bapp_gs));
77
78        BAPP_ASSERT(bos_create_mutex(&s_p_gs->mutex) == b_ok);
79       
80        s_p_gs->linemask_top = 0;               /* 0 lines initially starting from baseline_top */
81        s_p_gs->baseline_top = BASE_LINE;               /* baseline for top field */
82        s_p_gs->linemask_bot = 0;               /* 0 lines initially starting from baseline_bot */
83        s_p_gs->baseline_bot = 17;              /* baseline for bottom field */
84        bapp_gs_init(s_p_gs);
85
86        BDBG_MSG(("%s: leave", __func__));
87
88        return s_p_gs;
89}
90
91/*
92Summary:
93        Release all resources allocated with bapp_gs_open
94*/
95
96void bapp_gs_close(bapp_gs_t p_gs)
97{
98        BDBG_WRN(("%s: enter", __func__));
99
100        BAPP_ASSERT(p_gs);
101
102        bos_delete_mutex(&p_gs->mutex);
103       
104        free(p_gs);
105        s_p_gs = NULL;
106
107        BDBG_WRN(("%s: leave", __func__));
108}
109
110static void bapp_gs_program_null (
111        uint32_t ulWritePointer, 
112        uint32_t value)
113{
114        uint32_t ulRegVal  = BREG_Read32(GetREG(), BCHP_GSE_0_NULL);
115
116        switch (ulWritePointer & 0x3)
117        {
118                case 1:
119                        if (!value)
120                                ulRegVal &= 
121                                        ~BCHP_MASK (GSE_0_NULL, NULL_ENABLE_BANK1);
122                        else
123                                ulRegVal |= 
124                     BCHP_FIELD_DATA (GSE_0_NULL, NULL_ENABLE_BANK1, 1);
125                        break;
126                case 2:
127                        if (!value)
128                                ulRegVal &= 
129                                        ~BCHP_MASK (GSE_0_NULL, NULL_ENABLE_BANK2);
130                        else
131                                ulRegVal |= 
132                     BCHP_FIELD_DATA (GSE_0_NULL, NULL_ENABLE_BANK2, 1);
133                        break;
134                case 3:
135                        if (!value)
136                                ulRegVal &= 
137                                        ~BCHP_MASK (GSE_0_NULL, NULL_ENABLE_BANK3);
138                        else
139                                ulRegVal |= 
140                     BCHP_FIELD_DATA (GSE_0_NULL, NULL_ENABLE_BANK3, 1);
141                        break;
142       
143                default:
144                case 0:
145                        if (!value)
146                                ulRegVal &= 
147                                        ~BCHP_MASK (GSE_0_NULL, NULL_ENABLE_BANK0);
148                        else
149                                ulRegVal |= 
150                     BCHP_FIELD_DATA (GSE_0_NULL, NULL_ENABLE_BANK0, 1);
151                        break;
152        }
153
154        BREG_Write32(GetREG(), BCHP_GSE_0_NULL, ulRegVal);
155}
156
157/*
158Summary:
159        Enable/Disable GSE
160*/
161void bapp_gs_enable(bapp_gs_t p_gs, bool enable)
162{
163        uint32_t ulReg;
164
165        BDBG_MSG(("%s: enter: enable=%d", __func__, enable));
166
167        BAPP_ASSERT(p_gs);
168        if (bos_acquire_mutex(&(p_gs->mutex), GS_ENABLE_TIMEOUT) != b_ok)
169        {
170                BDBG_ERR(("%s bos_acquire_mutex failed(enable = %d)\n",__func__,enable));
171                return;
172        }
173
174        if (p_gs->enabled == enable)
175        {
176                bos_release_mutex(&(p_gs->mutex));
177                BDBG_WRN(("%s: no change", __func__));
178                return;
179        }
180       
181        p_gs->enabled = enable;
182        ulReg = BREG_Read32(GetREG(), BCHP_GSE_0_CONTROL);
183        ulReg &= ~BCHP_MASK(GSE_0_CONTROL, ENABLE);
184        if (enable)
185        {
186                ulReg |= BCHP_FIELD_ENUM (GSE_0_CONTROL, ENABLE, ENABLED);
187        }
188        BREG_Write32(GetREG(), BCHP_GSE_0_CONTROL, ulReg);
189
190        ulReg = BREG_Read32(GetREG(), BCHP_VF_0_MISC);
191        ulReg &= ~BCHP_MASK(VF_0_MISC, VBI_ENABLE);
192        ulReg &= ~BCHP_MASK(VF_0_MISC, VBI_PREFERRED);
193        if (enable)
194        {
195                ulReg |= BCHP_FIELD_ENUM (VF_0_MISC, VBI_ENABLE, ON);
196                ulReg |= BCHP_FIELD_ENUM (VF_0_MISC, VBI_PREFERRED, ON);
197        }
198        BREG_Write32(GetREG(), BCHP_VF_0_MISC, ulReg);
199
200        bos_release_mutex(&(p_gs->mutex));
201
202        if (!enable)
203                bapp_gs_reset(p_gs);
204
205        BDBG_MSG(("%s: leave", __func__));
206}
207
208bool bapp_gs_init(
209        bapp_gs_t p_gs
210)
211{
212        uint32_t ulReg, i;
213
214        BDBG_MSG(("%s: enter", __func__));
215
216        ulReg = 0;
217        ulReg |= (
218                BCHP_FIELD_DATA (GSE_0_CONTROL, FIFO_FREEZE, 0) |
219                BCHP_FIELD_DATA (GSE_0_CONTROL, NULL_MODE, 1) |
220#if     (DISPLAY_PAL == 1) || (DISPLAY_PAL_NC == 1)
221                BCHP_FIELD_ENUM (GSE_0_CONTROL, BIT_WIDTH, PAL) |               /* 429 for NTSC, 432 for PAL */
222#else
223                BCHP_FIELD_ENUM (GSE_0_CONTROL, BIT_WIDTH, NTSC) |              /* 429 for NTSC, 432 for PAL */
224#endif
225                BCHP_FIELD_DATA (GSE_0_CONTROL, DELAY_COUNT, 66) |              /* number of 27 MHz cycles to wait */
226                BCHP_FIELD_ENUM (GSE_0_CONTROL, PARITY_TYPE, EVEN) |
227                BCHP_FIELD_ENUM (GSE_0_CONTROL, TOP_FLD_PARITY, AUTOMATIC) |
228                BCHP_FIELD_ENUM (GSE_0_CONTROL, BOT_FLD_PARITY, AUTOMATIC) |
229                BCHP_FIELD_ENUM (GSE_0_CONTROL, BYTE_SWAP_656_ANCIL, LITTLE_ENDIAN) |
230                BCHP_FIELD_ENUM (GSE_0_CONTROL, BYTE_SWAP_VIDEO_SAMPLE, LITTLE_ENDIAN) |
231                BCHP_FIELD_ENUM (GSE_0_CONTROL, SHIFT_DIRECTION, LSB2MSB) 
232        );
233        BREG_Write32(GetREG(), BCHP_GSE_0_CONTROL, ulReg);
234
235        /* top field */
236        ulReg = 0;
237        ulReg |= (
238                  BCHP_FIELD_DATA (GSE_0_ACTIVE_LINE_TOP, ACTIVE_LINE, p_gs->linemask_top) |
239                  BCHP_FIELD_ENUM (GSE_0_ACTIVE_LINE_TOP, PED_LINE5, DISABLE) |
240                  BCHP_FIELD_ENUM (GSE_0_ACTIVE_LINE_TOP, PED_LINE4, DISABLE) |
241                  BCHP_FIELD_ENUM (GSE_0_ACTIVE_LINE_TOP, PED_LINE3, DISABLE) |
242                  BCHP_FIELD_ENUM (GSE_0_ACTIVE_LINE_TOP, PED_LINE2, DISABLE) |
243                  BCHP_FIELD_ENUM (GSE_0_ACTIVE_LINE_TOP, PED_LINE1, DISABLE) |
244                  BCHP_FIELD_DATA (GSE_0_ACTIVE_LINE_TOP, BASE, p_gs->baseline_top)
245                  );
246        BREG_Write32(GetREG(), BCHP_GSE_0_ACTIVE_LINE_TOP, ulReg);
247
248        /* bottom field */
249        ulReg = 0;
250        ulReg |= (
251                  BCHP_FIELD_DATA (GSE_0_ACTIVE_LINE_BOT, ACTIVE_LINE, p_gs->linemask_bot) |
252                  BCHP_FIELD_ENUM (GSE_0_ACTIVE_LINE_BOT, PED_LINE5, DISABLE) |
253                  BCHP_FIELD_ENUM (GSE_0_ACTIVE_LINE_BOT, PED_LINE4, DISABLE) |
254                  BCHP_FIELD_ENUM (GSE_0_ACTIVE_LINE_BOT, PED_LINE3, DISABLE) |
255                  BCHP_FIELD_ENUM (GSE_0_ACTIVE_LINE_BOT, PED_LINE2, DISABLE) |
256                  BCHP_FIELD_ENUM (GSE_0_ACTIVE_LINE_BOT, PED_LINE1, DISABLE) |
257                  BCHP_FIELD_DATA (GSE_0_ACTIVE_LINE_BOT, BASE, p_gs->baseline_bot)
258                  );
259        BREG_Write32(GetREG(), BCHP_GSE_0_ACTIVE_LINE_BOT, ulReg);
260
261        /* IRE */
262        ulReg = 0;
263        ulReg |= (
264                BCHP_FIELD_DATA (GSE_0_GAIN_TOP, LINE4, IRE_80) |
265                BCHP_FIELD_DATA (GSE_0_GAIN_TOP, LINE3, IRE_80) |
266                BCHP_FIELD_DATA (GSE_0_GAIN_TOP, LINE2, IRE_80) |
267                BCHP_FIELD_DATA (GSE_0_GAIN_TOP, LINE1, IRE_80) 
268        );
269        BREG_Write32(GetREG(), BCHP_GSE_0_GAIN_TOP, ulReg);
270
271        ulReg = IRE_80;
272        BREG_Write32(GetREG(), BCHP_GSE_0_GAIN_EXT_TOP, ulReg);
273
274        ulReg = 0;
275        ulReg |= (
276                BCHP_FIELD_DATA (GSE_0_GAIN_BOT, LINE4, IRE_80) |
277                BCHP_FIELD_DATA (GSE_0_GAIN_BOT, LINE3, IRE_80) |
278                BCHP_FIELD_DATA (GSE_0_GAIN_BOT, LINE2, IRE_80) |
279                BCHP_FIELD_DATA (GSE_0_GAIN_BOT, LINE1, IRE_80) 
280        );
281        BREG_Write32(GetREG(), BCHP_GSE_0_GAIN_BOT, ulReg);
282
283        ulReg = IRE_80;
284        BREG_Write32(GetREG(), BCHP_GSE_0_GAIN_EXT_BOT, ulReg);
285
286        ulReg = 0;
287        ulReg |= (
288                BCHP_FIELD_DATA (GSE_0_NULL, NULL_ENABLE_BANK3, 0) |
289                BCHP_FIELD_DATA (GSE_0_NULL, NULL_ENABLE_BANK2, 0) |
290                BCHP_FIELD_DATA (GSE_0_NULL, NULL_ENABLE_BANK1, 0) |
291                BCHP_FIELD_DATA (GSE_0_NULL, NULL_ENABLE_BANK0, 0) |
292                BCHP_FIELD_DATA (GSE_0_NULL, CHARACTER, 0x20) 
293        );
294        BREG_Write32(GetREG(), BCHP_GSE_0_NULL, ulReg);
295
296        /* clear data registers */
297        for (i = 0; i < 5; i++) {
298                BREG_Write32(GetREG(), BCHP_GSE_0_DATA_LINE1_BANK0 + (4 * i), 0);
299                BREG_Write32(GetREG(), BCHP_GSE_0_DATA_LINE1_BANK1 + (4 * i), 0);
300                BREG_Write32(GetREG(), BCHP_GSE_0_DATA_LINE1_BANK2 + (4 * i), 0);
301                BREG_Write32(GetREG(), BCHP_GSE_0_DATA_LINE1_BANK3 + (4 * i), 0);
302        }
303
304        BDBG_MSG(("%s: leave", __func__));
305        return 0;
306}
307
308void bapp_gs_status( 
309        bapp_gs_t p_gs
310)
311{
312        uint32_t ulVal;
313
314        BDBG_MSG(("%s: enter", __func__));
315
316        BAPP_ASSERT(p_gs);
317        if (!p_gs) {
318                BDBG_ERR(("%s: null point", __func__));
319                return;
320        }
321
322        if (!p_gs->enabled) {
323                BDBG_ERR(("%s: not enabled yet", __func__));
324                return;
325        }
326
327        ulVal = BREG_Read32(GetREG(), BCHP_GSE_0_STATUS);
328        if (ulVal & BCHP_GSE_0_STATUS_FIFO_OVERFLOW_MASK) {
329                BDBG_ERR(("GSE: FIFO overflow"));
330        }
331        if (ulVal & BCHP_GSE_0_STATUS_FIFO_UNDERFLOW_MASK) {
332                BDBG_ERR(("GSE: FIFO underflow"));
333        }
334        if (ulVal & BCHP_GSE_0_STATUS_BANK3_VIDEO_SAMPLE_DATA_MASK) {
335                BDBG_ERR(("GSE: Bank3 XMIT"));
336        }
337        if (ulVal & BCHP_GSE_0_STATUS_BANK2_VIDEO_SAMPLE_DATA_MASK) {
338                BDBG_ERR(("GSE: Bank2 XMIT"));
339        }
340        if (ulVal & BCHP_GSE_0_STATUS_BANK1_VIDEO_SAMPLE_DATA_MASK) {
341                BDBG_ERR(("GSE: Bank1 XMIT"));
342        }
343        if (ulVal & BCHP_GSE_0_STATUS_BANK0_VIDEO_SAMPLE_DATA_MASK) {
344                BDBG_ERR(("GSE: Bank0 XMIT"));
345        }
346        if (ulVal & BCHP_GSE_0_STATUS_BANK3_656_ANCIL_DATA_MASK) {
347                BDBG_ERR(("GSE: 656 Ancillary Bank3 XMIT"));
348        }
349        if (ulVal & BCHP_GSE_0_STATUS_BANK2_656_ANCIL_DATA_MASK) {
350                BDBG_ERR(("GSE: 656 Ancillary Bank2 XMIT"));
351        }
352        if (ulVal & BCHP_GSE_0_STATUS_BANK1_656_ANCIL_DATA_MASK) {
353                BDBG_ERR(("GSE: 656 Ancillary Bank1 XMIT"));
354        }
355        if (ulVal & BCHP_GSE_0_STATUS_BANK0_656_ANCIL_DATA_MASK) {
356                BDBG_ERR(("GSE: 656 Ancillary Bank0 XMIT"));
357        }
358
359        BDBG_MSG(("%s: leave", __func__));
360}
361
362uint32_t bapp_gs_set_scte_127_list(bapp_gs_t p_gs, int count, pscte_127_data line_list[])
363{
364        uint32_t ulRegVal, ulReg, status;
365        uint32_t ulReadPointer;
366        uint32_t ulWritePointer;
367        uint32_t bankIndex;
368        int i, j;
369
370        BDBG_MSG(("%s: enter", __func__));
371
372        /* Size check for field data */
373        if (!p_gs || (0 == count || count > SCTE_127_MAX_GS_DATA))
374        {
375                BDBG_ERR(("%s: null data pointer", __func__));
376                return -1;
377        }
378
379        /* Clear status bits. This one should be called only if FIFO overflow error happens */
380        status = BREG_Read32(GetREG(), BCHP_GSE_0_STATUS) & ~BCHP_GSE_0_STATUS_reserved0_MASK;
381        BREG_Write32(GetREG(), BCHP_GSE_0_STATUS, status);
382
383        /* Get FIFO pointers */
384        ulRegVal = BREG_Read32(GetREG(), BCHP_GSE_0_WRPTR);
385        ulWritePointer = BCHP_GET_FIELD_DATA (ulRegVal, GSE_0_WRPTR, VALUE);
386        bankIndex = ulWritePointer & 0x3;
387        ulRegVal = BREG_Read32(GetREG(), BCHP_GSE_0_RDPTR);
388        ulReadPointer = BCHP_GET_FIELD_DATA (ulRegVal, GSE_0_WRPTR, VALUE);
389       
390        /* Check for FIFO full */
391        if (((ulReadPointer & 0x3) == bankIndex     ) &&
392            (ulReadPointer         != ulWritePointer)    )
393        {
394                if (status & BCHP_GSE_0_STATUS_FIFO_OVERFLOW_MASK) {
395                        BDBG_WRN(("OF (idx=%d,W=%d,R=%d,status=0x%08x)", bankIndex, ulReadPointer, ulWritePointer, status));
396                        return -1;
397                }
398        }
399
400        /* Handle field misalignment */
401        if (((bankIndex == 0) || (bankIndex == 2)) &&           /* top field */
402                (GS_FIELD_TOP != (!line_list[0]->field_parity)))
403        {
404                BDBG_MSG(("%s: field top misalignment, band=%d", __func__, bankIndex));
405                bapp_gs_program_null(bankIndex, 1);
406                ++ulWritePointer;
407                ulWritePointer %= 8;
408                bankIndex++;
409        bankIndex %= 4;
410    }
411        else if (((bankIndex == 1) || (bankIndex == 3)) &&      /* bottom filed */
412                (GS_FIELD_BOT != (!line_list[0]->field_parity)))
413        {
414                BDBG_MSG(("%s: field bottom misalignment, band=%d", __func__, bankIndex));
415                bapp_gs_program_null(bankIndex, 1);
416                ++ulWritePointer;
417                ulWritePointer %= 8;
418                bankIndex++;
419        bankIndex %= 4;
420    }
421        bapp_gs_program_null(bankIndex, 0);
422
423        /* the caller should verify that line offset is valid (10 - 22) */
424        if (!line_list[0]->field_parity) {
425                p_gs->linemask_top = 0;
426                for (i = 0; i < count; i++) {
427                        p_gs->linemask_top |= (1L << (line_list[i]->line_offset - BASE_LINE));
428                }
429                ulRegVal = p_gs->baseline_top;
430                ulRegVal |= BCHP_FIELD_DATA(GSE_0_ACTIVE_LINE_TOP, ACTIVE_LINE, p_gs->linemask_top);
431                BREG_Write32(GetREG(), BCHP_GSE_0_ACTIVE_LINE_TOP, ulRegVal);
432                /* per CEA 2020 spec */
433                if (line_list[0]->line_offset >= 13 && line_list[0]->line_offset <20)
434                        j = IRE_80;             
435                else
436                        j = IRE_70;
437
438                ulRegVal = (
439                        BCHP_FIELD_DATA (GSE_0_GAIN_TOP, LINE4, j) |
440                        BCHP_FIELD_DATA (GSE_0_GAIN_TOP, LINE3, j) |
441                        BCHP_FIELD_DATA (GSE_0_GAIN_TOP, LINE2, j) |
442                        BCHP_FIELD_DATA (GSE_0_GAIN_TOP, LINE1, j)
443                        );
444                BREG_Write32(GetREG(), BCHP_GSE_0_GAIN_TOP, ulRegVal);
445                ulRegVal = j;
446                BREG_Write32(GetREG(), BCHP_GSE_0_GAIN_EXT_TOP, ulRegVal);
447        }
448        else {
449                p_gs->linemask_bot = 0;
450                for (i = 0; i < count; i++) {
451                        p_gs->linemask_bot |= (1L << (line_list[i]->line_offset - BASE_LINE));
452                }
453                ulRegVal = p_gs->baseline_bot;
454                ulRegVal |= BCHP_FIELD_DATA(GSE_0_ACTIVE_LINE_BOT, ACTIVE_LINE, p_gs->linemask_bot);
455                BREG_Write32(GetREG(), BCHP_GSE_0_ACTIVE_LINE_BOT, ulRegVal);
456        /* per CEA 2020 spec */
457        if (line_list[0]->line_offset >= 13 && line_list[0]->line_offset <20)
458            j = IRE_80;
459        else
460            j = IRE_70;
461
462        ulRegVal = (
463            BCHP_FIELD_DATA (GSE_0_GAIN_BOT, LINE4, j) |
464            BCHP_FIELD_DATA (GSE_0_GAIN_BOT, LINE3, j) |
465            BCHP_FIELD_DATA (GSE_0_GAIN_BOT, LINE2, j) |
466            BCHP_FIELD_DATA (GSE_0_GAIN_BOT, LINE1, j)
467            );
468        BREG_Write32(GetREG(), BCHP_GSE_0_GAIN_BOT, ulRegVal);
469        ulRegVal = j;
470        BREG_Write32(GetREG(), BCHP_GSE_0_GAIN_EXT_BOT, ulRegVal);
471        }
472
473        /* Decide where to put user's data */
474        switch (bankIndex)
475        {
476                        case 1:
477                                        ulReg = BCHP_GSE_0_DATA_LINE1_BANK1;
478                                        break;
479
480                        case 2:
481                                        ulReg = BCHP_GSE_0_DATA_LINE1_BANK2;
482                                        break;
483
484                        case 3:
485                                        ulReg = BCHP_GSE_0_DATA_LINE1_BANK3;
486                                        break;
487
488                        default:
489                        case 0:
490                                        ulReg = BCHP_GSE_0_DATA_LINE1_BANK0;
491                                        break;
492        }
493        for (i = 0; i < count; i++) {
494                        BREG_Write32(GetREG(), ulReg + (i * 4), line_list[i]->u.tvg2x);
495        }
496        /* Program the write pointer into hardware */
497        ++ulWritePointer;
498        ulWritePointer %= 8;
499        ulRegVal = BCHP_FIELD_DATA (GSE_0_WRPTR, VALUE, ulWritePointer);
500        BREG_Write32(GetREG(), BCHP_GSE_0_WRPTR, ulRegVal);
501
502        BDBG_MSG(("%s: leave", __func__));
503        return 0x0;
504}
505
506bool bapp_gs_reset(bapp_gs_t p_gs)
507{
508                uint32_t i;
509
510                BDBG_MSG(("%s: enter", __func__));
511                /* don't use it */
512                if (!p_gs)
513                                return 0;
514
515                /* top field */
516                //BREG_Write32(GetREG(), BCHP_GSE_0_ACTIVE_LINE_TOP, 0);
517                /* bottom field */
518                //BREG_Write32(GetREG(), BCHP_GSE_0_ACTIVE_LINE_BOT, 0);
519
520                /* clear data registers */
521                for (i = 0; i < 5; i++) {
522                                BREG_Write32(GetREG(), BCHP_GSE_0_DATA_LINE1_BANK0 + (4 * i), 0);
523                                BREG_Write32(GetREG(), BCHP_GSE_0_DATA_LINE1_BANK1 + (4 * i), 0);
524                                BREG_Write32(GetREG(), BCHP_GSE_0_DATA_LINE1_BANK2 + (4 * i), 0);
525                                BREG_Write32(GetREG(), BCHP_GSE_0_DATA_LINE1_BANK3 + (4 * i), 0);
526                }
527
528                BDBG_MSG(("%s: leave", __func__));
529                return 1;
530}
Note: See TracBrowser for help on using the repository browser.