source: svn/newcon3bcm2_21bu/BSEAV/lib/scte_127/bapp_amol.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: 28.1 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_amol.h"
22#include "bchp_amole_0.h"
23#include "bchp_amole_1.h"
24#include "bchp_vbi_enc.h"
25#include "bchp_vf_0.h"
26#include "bstd.h"
27#include "scte_127.h"
28#include "ministd.h"
29#include "gist.h"
30
31BDBG_MODULE(bapp_amol);
32
33#ifndef AMOL_ASSERT
34#define AMOL_ASSERT(expr) {                                         \
35    if (!expr)                                                      \
36        printf("%s failed at %s:%d\n",#expr, __FILE__, __LINE__);   \
37    }
38#endif
39
40#define NUM_AMOL_BUF            4               /* maximux 4 banks, 0 and 2 for top field, 1 and 3 for botton field */
41#define AMOL_BUF_SIZE           24              /* maximum data bytes for each field, 6 for AMOL I, 12 for AMOL II@1M, 24 for AMOL II@2M */
42
43#define AMOL_ENABLE_TIMEOUT                     (g_ticks_per_second * 2)
44
45/*
46 * Main data structure containing references to all interfaces
47 * required throughout the application.
48 */
49typedef struct _amol_field_buf_t
50{
51        unsigned int    size;
52        unsigned char   buf[AMOL_BUF_SIZE];
53} amol_field_buf_t;
54
55typedef struct _amol_buf_t
56{
57        unsigned int    index;
58        amol_field_buf_t field[NUM_AMOL_BUF];
59} amol_buf_t;
60
61typedef struct _amol_info_t
62{
63        AMOL_TYPE       type[2];                /* amol type for given lines for a field */
64        unsigned char   line[2];                /* line numbers for a field */
65} amol_info_t;
66
67struct bapp_amol
68{
69        bool            enabled;
70        b_mutex_t       mutex;
71        amol_buf_t      buf[NUM_AMOL_BUF];
72        amol_info_t     info[2];        /* for both fields */
73        unsigned int    mask[2];        /* line mask bits for both top and bottom field */
74} bapp_amol;
75
76bapp_amol_t s_p_amol = NULL;
77
78/*
79Summary:
80        Initialize and allocate resources
81*/
82
83bapp_amol_t bapp_amol_open(void* p_opaque_app)
84{
85        BDBG_MSG(("%s: enter", __func__));
86
87        s_p_amol = (bapp_amol_t)malloc(sizeof(struct bapp_amol));
88        AMOL_ASSERT(s_p_amol);
89
90        memset(s_p_amol, 0, sizeof(struct bapp_amol));
91
92        AMOL_ASSERT(bos_create_mutex(&s_p_amol->mutex) == b_ok);
93       
94        bapp_amol_init(s_p_amol);
95
96        BDBG_MSG(("%s: leave", __func__));
97
98        return s_p_amol;
99}
100
101/*
102Summary:
103        Release all resources allocated with bapp_amol_open
104*/
105
106void bapp_amol_close(bapp_amol_t p_amol)
107{
108        BDBG_WRN(("%s: enter", __func__));
109
110        AMOL_ASSERT(p_amol);
111
112        bos_delete_mutex(&p_amol->mutex);
113       
114        free(p_amol);
115        s_p_amol = NULL;
116
117        BDBG_WRN(("%s: leave", __func__));
118}
119
120static void bapp_amol_program_null (
121        uint32_t ulWritePointer, 
122        uint32_t value)
123{
124        uint32_t ulRegVal  = BREG_Read32(GetREG(), BCHP_AMOLE_0_NULL);
125
126        switch (ulWritePointer & 0x3)
127        {
128                case 1:
129                        if (!value)
130                                ulRegVal &= 
131                                        ~BCHP_MASK (AMOLE_0_NULL, NULL_ENABLE_BANK1);
132                        else
133                                ulRegVal |= 
134                                         BCHP_FIELD_DATA (AMOLE_0_NULL, NULL_ENABLE_BANK1, value);
135                        break;
136                case 2:
137                        if (!value)
138                                ulRegVal &= 
139                                        ~BCHP_MASK (AMOLE_0_NULL, NULL_ENABLE_BANK2);
140                        else
141                                ulRegVal |= 
142                                         BCHP_FIELD_DATA (AMOLE_0_NULL, NULL_ENABLE_BANK2, value);
143                        break;
144                case 3:
145                        if (!value)
146                                ulRegVal &= 
147                                        ~BCHP_MASK (AMOLE_0_NULL, NULL_ENABLE_BANK3);
148                        else
149                                ulRegVal |= 
150                                         BCHP_FIELD_DATA (AMOLE_0_NULL, NULL_ENABLE_BANK3, value);
151                        break;
152       
153                default:
154                case 0:
155                        if (!value)
156                                ulRegVal &= 
157                                        ~BCHP_MASK (AMOLE_0_NULL, NULL_ENABLE_BANK0);
158                        else
159                                ulRegVal |= 
160                                         BCHP_FIELD_DATA (AMOLE_0_NULL, NULL_ENABLE_BANK0, value);
161                        break;
162        }
163
164        BREG_Write32(GetREG(), BCHP_AMOLE_0_NULL, ulRegVal);
165}
166
167/*
168Summary:
169        Enable/Disable AMOL
170*/
171void bapp_amol_enable(bapp_amol_t p_amol, bool enable)
172{
173        uint32_t ulReg, flags;
174
175        BDBG_MSG(("%s: enter", __func__));
176
177        AMOL_ASSERT(p_amol);
178        BDBG_WRN(("%s: enable %d - current %d\n", __func__, enable, p_amol->enabled));
179        if (bos_acquire_mutex(&(p_amol->mutex), AMOL_ENABLE_TIMEOUT) != b_ok)
180        {
181                BDBG_ERR(("%s bos_acquire_mutex failed(enable = %d)\n",__func__,enable));
182                return;
183        }
184
185#if 0
186        if (p_amol->enabled == enable)
187        {
188                bos_release_mutex(&(p_amol->mutex));
189                BDBG_WRN(("%s: no change", __func__));
190                return;
191        }
192#endif
193
194        p_amol->enabled = enable;
195
196        /* sel 5 for AMOL */
197        ulReg = BREG_Read32(GetREG(), BCHP_VBI_ENC_VBI_0_CORE_5_SEL);
198        ulReg &= ~BCHP_MASK(VBI_ENC_VBI_0_CORE_5_SEL, SEL);
199        if (enable) {
200                ulReg = BCHP_FIELD_ENUM (VBI_ENC_VBI_0_CORE_5_SEL, SEL, AMOLE_0);
201        }
202        BREG_Write32(GetREG(), BCHP_VBI_ENC_VBI_0_CORE_5_SEL, ulReg);
203
204        ulReg = BREG_Read32(GetREG(), BCHP_VF_0_MISC);
205        ulReg &= ~BCHP_MASK(VF_0_MISC, VBI_ENABLE);
206        ulReg &= ~BCHP_MASK(VF_0_MISC, VBI_PREFERRED);
207        if (enable)
208        {
209                ulReg |= BCHP_FIELD_ENUM (VF_0_MISC, VBI_ENABLE, ON);
210                ulReg |= BCHP_FIELD_ENUM (VF_0_MISC, VBI_PREFERRED, ON);
211        }
212        BREG_Write32(GetREG(), BCHP_VF_0_MISC, ulReg);
213
214        bos_release_mutex(&(p_amol->mutex));
215
216        flags = bos_enter_critical();
217    ulReg = BREG_Read32(GetREG(), BCHP_VBI_ENC_VBI_0_INTR_CTRL);
218    ulReg &= !BCHP_MASK(VBI_ENC_VBI_0_INTR_CTRL, INTR0_LINE);
219    if (enable)
220                ulReg = BCHP_FIELD_DATA(VBI_ENC_VBI_0_INTR_CTRL, INTR0_LINE, 20);
221    else
222        ulReg = BCHP_FIELD_DATA(VBI_ENC_VBI_0_INTR_CTRL, INTR0_LINE, 0);
223    BREG_Write32(GetREG(), BCHP_VBI_ENC_VBI_0_INTR_CTRL, ulReg);
224        bos_exit_critical(flags);
225
226        BDBG_MSG(("%s: leave", __func__));
227}
228
229bool bapp_amol_mask_lines(
230        bapp_amol_t p_amol,
231        unsigned char field
232)
233{
234        uint32_t ulReg, mask;
235        uint16_t line1, line2;
236
237        BDBG_MSG(("%s: enter", __func__));
238
239        if (field > 1) {
240                BDBG_ERR(("%s: field (%d) out of range", __func__, field));
241                return 0;
242        }
243
244        line1 = p_amol->info[field].line[0];
245        line2 = p_amol->info[field].line[1];
246
247        if (line1 < AMOL_LOWER_LINE || line1 > AMOL_UPPER_LINE) {
248                BDBG_WRN(("%s: invalid VBI line1 %d, %d", __func__, line1));
249                return 0;
250        }
251        if (line2 < AMOL_LOWER_LINE || line2 > AMOL_UPPER_LINE) {
252                BDBG_WRN(("%s: invalid VBI line2 %d, %d", __func__, line2));
253                return 0;
254        }
255
256        mask = (1L << (line1 - AMOL_LOWER_LINE)) | (1L << (line2 - AMOL_LOWER_LINE));
257        ulReg = 0;
258        if (0 == field) {
259                if (mask != p_amol->mask[0]) {
260                        ulReg |= BCHP_FIELD_DATA (AMOLE_0_ACT_LINE_BASE_TOP, BASE, AMOL_LOWER_LINE);
261                        ulReg |= BCHP_FIELD_DATA (AMOLE_0_ACT_LINE_BASE_TOP, ACTIVE_LINE, mask);
262                        BREG_Write32(GetREG(), BCHP_AMOLE_0_ACT_LINE_BASE_TOP, ulReg);
263                        p_amol->mask[0] = mask;
264                }
265        } else if (1 == field) {
266                if (mask != p_amol->mask[1]) {
267                        ulReg |= BCHP_FIELD_DATA (AMOLE_0_ACT_LINE_BASE_BOT, BASE, 17);
268                        ulReg |= BCHP_FIELD_DATA (AMOLE_0_ACT_LINE_BASE_BOT, ACTIVE_LINE, mask);
269                        BREG_Write32(GetREG(), BCHP_AMOLE_0_ACT_LINE_BASE_BOT, ulReg);
270                        p_amol->mask[1] = mask;
271                }
272        }
273
274        return 1;
275}
276
277bool bapp_amol_set_symbolrate(
278        bapp_amol_t p_amol, 
279        AMOL_TYPE type
280)
281{
282        uint32_t ulReg = 0;
283        uint32_t nbyte_symbol = (AMOL_TYPE_II_2M == type) ? 1 : 0;
284
285        BDBG_MSG(("%s: enter", __func__));
286
287        /* 6 bytes for TYPE I and TYPE II@1M, 12 bytes for TYPE II@2M */
288        ulReg |= (
289                BCHP_FIELD_DATA (
290                        AMOLE_0_BYTES_PER_LINE, LINE22_BANK3, nbyte_symbol) |
291                BCHP_FIELD_DATA (
292                        AMOLE_0_BYTES_PER_LINE, LINE20_BANK3, nbyte_symbol) |
293                BCHP_FIELD_DATA (
294                        AMOLE_0_BYTES_PER_LINE, LINE22_BANK2, nbyte_symbol) |
295                BCHP_FIELD_DATA (
296                        AMOLE_0_BYTES_PER_LINE, LINE20_BANK2, nbyte_symbol) |
297                BCHP_FIELD_DATA (
298                        AMOLE_0_BYTES_PER_LINE, LINE22_BANK1, nbyte_symbol) |
299                BCHP_FIELD_DATA (
300                        AMOLE_0_BYTES_PER_LINE, LINE20_BANK1, nbyte_symbol) |
301                BCHP_FIELD_DATA (
302                        AMOLE_0_BYTES_PER_LINE, LINE22_BANK0, nbyte_symbol) |
303                BCHP_FIELD_DATA (
304                        AMOLE_0_BYTES_PER_LINE, LINE20_BANK0, nbyte_symbol) 
305        );
306        BREG_Write32(GetREG(), BCHP_AMOLE_0_BYTES_PER_LINE, ulReg);
307
308        BDBG_MSG(("%s: leave", __func__));
309        return 0;
310}
311
312bool bapp_amol_init(
313        bapp_amol_t p_amol
314)
315{
316        uint32_t ulReg, i;
317
318        BDBG_MSG(("%s: enter", __func__));
319
320        p_amol->info[0].type[0] = AMOL_TYPE_I;
321        p_amol->info[0].line[0] = 20;
322        p_amol->info[0].type[1] = AMOL_TYPE_I;
323        p_amol->info[0].line[1] = 22;
324        p_amol->info[1].type[0] = AMOL_TYPE_I;
325        p_amol->info[1].line[0] = 20;
326        p_amol->info[1].type[1] = AMOL_TYPE_I;
327        p_amol->info[1].line[1] = 22;
328
329        bapp_amol_mask_lines(p_amol, 0);
330        bapp_amol_mask_lines(p_amol, 1);
331
332        /* IRE */
333        ulReg = 0;
334        ulReg |= (
335                BCHP_FIELD_DATA (AMOLE_0_GAIN_PED_TOP, GAIN_LINE22,      70) |
336                BCHP_FIELD_DATA (AMOLE_0_GAIN_PED_TOP, GAIN_LINE20,      70) |
337                BCHP_FIELD_ENUM (AMOLE_0_GAIN_PED_TOP,  PED_LINE22, DISABLE) |
338                BCHP_FIELD_ENUM (AMOLE_0_GAIN_PED_TOP,  PED_LINE20, DISABLE) 
339        );
340        BREG_Write32(GetREG(), BCHP_AMOLE_0_GAIN_PED_TOP, ulReg);
341
342        ulReg = 0;
343        ulReg |= (
344                BCHP_FIELD_DATA (AMOLE_0_GAIN_PED_BOT, GAIN_LINE22,      70) |
345                BCHP_FIELD_DATA (AMOLE_0_GAIN_PED_BOT, GAIN_LINE20,      70) |
346                BCHP_FIELD_ENUM (AMOLE_0_GAIN_PED_BOT,  PED_LINE22, DISABLE) |
347                BCHP_FIELD_ENUM (AMOLE_0_GAIN_PED_BOT,  PED_LINE20, DISABLE) 
348        );
349        BREG_Write32(GetREG(), BCHP_AMOLE_0_GAIN_PED_BOT, ulReg);
350
351        /* set default symbol rate */
352        bapp_amol_set_symbolrate(p_amol, AMOL_TYPE_I);
353
354        ulReg = 0;
355        ulReg |= (
356                BCHP_FIELD_DATA (AMOLE_0_NULL, NULL_ENABLE_BANK3,    0) |
357                BCHP_FIELD_DATA (AMOLE_0_NULL, NULL_ENABLE_BANK2,    0) |
358                BCHP_FIELD_DATA (AMOLE_0_NULL, NULL_ENABLE_BANK1,    0) |
359                BCHP_FIELD_DATA (AMOLE_0_NULL, NULL_ENABLE_BANK0,    0) |
360                BCHP_FIELD_DATA (AMOLE_0_NULL, CHARACTER,               0) 
361        );
362        BREG_Write32(GetREG(), BCHP_AMOLE_0_NULL, ulReg);
363
364        ulReg = 0;
365        ulReg |= (
366                BCHP_FIELD_DATA (AMOLE_0_CONTROL, DELAY_COUNT, 0x6B) |
367                BCHP_FIELD_DATA (AMOLE_0_CONTROL, FIFO_FREEZE,    0) |
368                BCHP_FIELD_DATA (AMOLE_0_CONTROL, NULL_MODE,      1) ); /* enable NULL insertion */
369        if (p_amol->enabled)
370                ulReg |= BCHP_FIELD_ENUM (AMOLE_0_CONTROL, ENABLE, ON);
371
372        BREG_Write32(GetREG(), BCHP_AMOLE_0_CONTROL, ulReg);
373
374        /* clear data registers first */
375        for (i = 0; i < 6; i++) {
376                BREG_Write32(GetREG(), BCHP_AMOLE_0_DATA_WORD0_BANK0 + i * 4, 0);
377                BREG_Write32(GetREG(), BCHP_AMOLE_0_DATA_WORD0_BANK1 + i * 4, 0);
378                BREG_Write32(GetREG(), BCHP_AMOLE_0_DATA_WORD0_BANK2 + i * 4, 0);
379                BREG_Write32(GetREG(), BCHP_AMOLE_0_DATA_WORD0_BANK3 + i * 4, 0);
380        }
381
382        BDBG_MSG(("%s: leave", __func__));
383        return 0;
384}
385
386void bapp_amol_status( 
387        bapp_amol_t p_amol
388)
389{
390        uint32_t ulVal;
391
392        BDBG_MSG(("%s: enter", __func__));
393
394        AMOL_ASSERT(p_amol);
395        if (!p_amol) {
396                BDBG_ERR(("%s: null point", __func__));
397                return;
398        }
399
400        if (!p_amol->enabled) {
401                BDBG_ERR(("%s: not enabled yet", __func__));
402                return;
403        }
404
405        ulVal = BREG_Read32(GetREG(), BCHP_AMOLE_0_STATUS);
406        if (ulVal & BCHP_AMOLE_0_STATUS_FIFO_OVERFLOW_MASK) {
407                BDBG_ERR(("AMOL: FIFO overflow"));
408        }
409        if (ulVal & BCHP_AMOLE_0_STATUS_FIFO_UNDERFLOW_MASK) {
410                BDBG_ERR(("AMOL: FIFO underflow"));
411        }
412        if (ulVal & BCHP_AMOLE_0_STATUS_BANK3_VIDEO_SAMPLE_DATA_MASK) {
413                BDBG_ERR(("AMOL: Bank3 XMIT"));
414        }
415        if (ulVal & BCHP_AMOLE_0_STATUS_BANK2_VIDEO_SAMPLE_DATA_MASK) {
416                BDBG_ERR(("AMOL: Bank2 XMIT"));
417        }
418        if (ulVal & BCHP_AMOLE_0_STATUS_BANK1_VIDEO_SAMPLE_DATA_MASK) {
419                BDBG_ERR(("AMOL: Bank1 XMIT"));
420        }
421        if (ulVal & BCHP_AMOLE_0_STATUS_BANK0_VIDEO_SAMPLE_DATA_MASK) {
422                BDBG_ERR(("AMOL: Bank0 XMIT"));
423        }
424        if (ulVal & BCHP_AMOLE_0_STATUS_BANK3_656_ANCIL_DATA_MASK) {
425                BDBG_ERR(("AMOL: 656 Ancillary Bank3 XMIT"));
426        }
427        if (ulVal & BCHP_AMOLE_0_STATUS_BANK2_656_ANCIL_DATA_MASK) {
428                BDBG_ERR(("AMOL: 656 Ancillary Bank2 XMIT"));
429        }
430        if (ulVal & BCHP_AMOLE_0_STATUS_BANK1_656_ANCIL_DATA_MASK) {
431                BDBG_ERR(("AMOL: 656 Ancillary Bank1 XMIT"));
432        }
433        if (ulVal & BCHP_AMOLE_0_STATUS_BANK0_656_ANCIL_DATA_MASK) {
434                BDBG_ERR(("AMOL: 656 Ancillary Bank0 XMIT"));
435        }
436        /* clear bits */
437        if (ulVal & (BCHP_AMOLE_0_STATUS_FIFO_OVERFLOW_MASK | BCHP_AMOLE_0_STATUS_FIFO_UNDERFLOW_MASK)) {
438                BDBG_WRN(("%s: clear over/under flow errors", __func__));
439                ulVal &= ~BCHP_AMOLE_0_STATUS_reserved0_MASK;
440                BREG_Write32(GetREG(), BCHP_AMOLE_0_STATUS, ulVal);
441        }
442
443        BDBG_MSG(("%s: leave", __func__));
444}
445
446uint32_t bapp_amol_set_scte_127( 
447        bapp_amol_t p_amol, 
448        scte_127_data *line_data)
449       
450{
451        uint32_t ulRegVal, status;
452        uint32_t ulRegAddr = 0;
453        uint32_t ulReadPointer;
454        uint32_t ulWritePointer;
455        uint32_t bankIndex;
456        int      totalBytes, i;
457        uint8_t field = 0, *pAMOLData;
458
459        BDBG_MSG(("%s: enter", __func__));
460
461        /* validation */
462        if (!p_amol || !line_data)
463        {
464                BDBG_WRN(("%s: null data pointer", __func__));
465                return -1;
466        }
467
468        /* currently just assume line is for 20 and 22 only */
469        if (20 != line_data->line_offset && 22 != line_data->line_offset) {
470                BDBG_WRN(("invalid line, drop (l1=%d)", line_data->line_offset));
471                return -1;
472        }
473
474        status = BREG_Read32(GetREG(), BCHP_AMOLE_0_STATUS) & ~BCHP_AMOLE_0_STATUS_reserved0_MASK;
475        BREG_Write32(GetREG(), BCHP_AMOLE_0_STATUS, status);
476
477        /* Get FIFO pointers */
478        ulRegVal = BREG_Read32(GetREG(), BCHP_AMOLE_0_WRPTR);
479        ulWritePointer = BCHP_GET_FIELD_DATA (ulRegVal, AMOLE_0_WRPTR, VALUE);
480        bankIndex = ulWritePointer & 0x3;
481        ulRegVal = BREG_Read32(GetREG(), BCHP_AMOLE_0_RDPTR);
482        ulReadPointer = BCHP_GET_FIELD_DATA (ulRegVal, AMOLE_0_RDPTR, VALUE);
483
484        /* Check for FIFO full */
485        if (((ulReadPointer & 0x3) == bankIndex) &&
486            (ulReadPointer         != ulWritePointer))
487        {
488                if (status & (BCHP_AMOLE_0_STATUS_FIFO_OVERFLOW_MASK | BCHP_AMOLE_0_STATUS_FIFO_UNDERFLOW_MASK)) {
489                        BDBG_WRN(("OF/UF (idx=%d,W=%d,R=%d,status=0x%08x)", bankIndex, ulReadPointer, ulWritePointer, status));
490                        return -1;
491                }
492        }
493
494        /* Decide how many bytes to copy */
495        switch (line_data->amol_type)
496        {
497                case AMOL_TYPE_I:
498                        totalBytes = 6;
499                        pAMOLData = line_data->u.amol48;
500                        break;
501                /* 12 bytes AMOL 96, but not AMOL 48 */
502                case AMOL_TYPE_II_1M:
503                        pAMOLData = line_data->u.amol96;
504                        totalBytes = 12;
505                        break;
506
507                default:
508                        BDBG_WRN(("%s: unsupported AMOL type %d", __func__, line_data->amol_type));
509                        return -1;
510        }
511
512        field = line_data->field_parity? 0 : 1;
513
514        /* Handle field misalignment */
515        if (((bankIndex == 0) || (bankIndex == 2)) &&           /* top field */
516                (AMOL_FIELD_TOP != field))
517        {
518                BDBG_MSG(("top field misalignment, bankIndex=%d", bankIndex));
519                bapp_amol_program_null(bankIndex, 1);
520                ++ulWritePointer;
521                bankIndex++;
522                bankIndex %= 4;
523        }
524        else if (((bankIndex == 1) || (bankIndex == 3)) &&      /* bottom filed */
525                (AMOL_FIELD_BOT != field))
526        {
527                BDBG_MSG(("bot field misalignment, bankIndex=%d", bankIndex));
528                bapp_amol_program_null(bankIndex, 1);
529                ++ulWritePointer;
530                bankIndex++;
531                bankIndex %= 4;
532        }
533        bapp_amol_program_null(bankIndex, 0);
534
535#if 0
536        /* if line number changed */
537        if (line_data->line_offset != p_amol->info[field].line[0] &&
538                line_data->line_offset != p_amol->info[field].line[1]) {
539                /* which line? */
540                if (line_data->line_offset < p_amol->info[field].line[1])
541                        p_amol->info[field].line[0] = line_data->line_offset;
542                else
543                        p_amol->info[field].line[1] = line_data->line_offset;
544                /* update line mask accordingly */
545                bapp_amol_mask_lines(p_amol, field);
546        }
547#endif
548
549        /* if type changed */
550        if (20 == line_data->line_offset)
551                i = 0;
552        else
553                i = 1;
554
555        /* update symbol rate accordingly */
556        ulRegVal = BREG_Read32(GetREG(), BCHP_AMOLE_0_BYTES_PER_LINE);
557        switch (bankIndex)
558        {
559                case 0:
560                        if (i) {
561                                ulRegAddr = BCHP_AMOLE_0_DATA_WORD0_BANK0 + 12;
562                                ulRegVal &= ~BCHP_MASK(AMOLE_0_BYTES_PER_LINE, LINE22_BANK0);
563                                if (AMOL_TYPE_I != line_data->amol_type)
564                                        ulRegVal |= BCHP_FIELD_DATA (
565                                                AMOLE_0_BYTES_PER_LINE, LINE22_BANK0, 1);
566                                /* NOTE if configure lines based on line number, then there is not need for this */
567                                BREG_Write32(GetREG(), BCHP_AMOLE_0_DATA_WORD0_BANK0, 0);
568                                BREG_Write32(GetREG(), BCHP_AMOLE_0_DATA_WORD0_BANK0 + 4, 0);
569                                BREG_Write32(GetREG(), BCHP_AMOLE_0_DATA_WORD0_BANK0 + 8, 0);
570                        }
571                        else {
572                                ulRegAddr = BCHP_AMOLE_0_DATA_WORD0_BANK0;
573                                ulRegVal &= ~BCHP_MASK(AMOLE_0_BYTES_PER_LINE, LINE20_BANK0);
574                                if (AMOL_TYPE_I != line_data->amol_type)
575                                        ulRegVal |= BCHP_FIELD_DATA (
576                                                AMOLE_0_BYTES_PER_LINE, LINE20_BANK0, 1);
577                                BREG_Write32(GetREG(), BCHP_AMOLE_0_DATA_WORD0_BANK0 + 12, 0);
578                                BREG_Write32(GetREG(), BCHP_AMOLE_0_DATA_WORD0_BANK0 + 16, 0);
579                                BREG_Write32(GetREG(), BCHP_AMOLE_0_DATA_WORD0_BANK0 + 20, 0);
580                        }
581                        break;
582
583                case 1:
584                        if (i) {
585                                ulRegAddr = BCHP_AMOLE_0_DATA_WORD0_BANK1 + 12;
586                                ulRegVal &= ~BCHP_MASK(AMOLE_0_BYTES_PER_LINE, LINE22_BANK1);
587                                if (AMOL_TYPE_I != line_data->amol_type)
588                                        ulRegVal |= BCHP_FIELD_DATA (
589                                                AMOLE_0_BYTES_PER_LINE, LINE22_BANK1, 1);
590                                BREG_Write32(GetREG(), BCHP_AMOLE_0_DATA_WORD0_BANK1, 0);
591                                BREG_Write32(GetREG(), BCHP_AMOLE_0_DATA_WORD0_BANK1 + 4, 0);
592                                BREG_Write32(GetREG(), BCHP_AMOLE_0_DATA_WORD0_BANK1 + 8, 0);
593                        }
594                        else {
595                                ulRegAddr = BCHP_AMOLE_0_DATA_WORD0_BANK1;
596                                ulRegVal &= ~BCHP_MASK(AMOLE_0_BYTES_PER_LINE, LINE20_BANK1);
597                                if (AMOL_TYPE_I != line_data->amol_type)
598                                        ulRegVal |= BCHP_FIELD_DATA (
599                                                AMOLE_0_BYTES_PER_LINE, LINE20_BANK1, 1);
600                                BREG_Write32(GetREG(), BCHP_AMOLE_0_DATA_WORD0_BANK1 + 12, 0);
601                                BREG_Write32(GetREG(), BCHP_AMOLE_0_DATA_WORD0_BANK1 + 16, 0);
602                                BREG_Write32(GetREG(), BCHP_AMOLE_0_DATA_WORD0_BANK1 + 20, 0);
603                        }
604                        break;
605
606                case 2:
607                        if (i) {
608                                ulRegAddr = BCHP_AMOLE_0_DATA_WORD0_BANK2 + 12;
609                                ulRegVal &= ~BCHP_MASK(AMOLE_0_BYTES_PER_LINE, LINE22_BANK2);
610                                if (AMOL_TYPE_I != line_data->amol_type)
611                                        ulRegVal |= BCHP_FIELD_DATA (
612                                                AMOLE_0_BYTES_PER_LINE, LINE22_BANK2, 1);
613                                BREG_Write32(GetREG(), BCHP_AMOLE_0_DATA_WORD0_BANK2, 0);
614                                BREG_Write32(GetREG(), BCHP_AMOLE_0_DATA_WORD0_BANK2 + 4, 0);
615                                BREG_Write32(GetREG(), BCHP_AMOLE_0_DATA_WORD0_BANK2 + 8, 0);
616                        }
617                        else {
618                                ulRegAddr = BCHP_AMOLE_0_DATA_WORD0_BANK2;
619                                ulRegVal &= ~BCHP_MASK(AMOLE_0_BYTES_PER_LINE, LINE20_BANK2);
620                                if (AMOL_TYPE_I != line_data->amol_type)
621                                        ulRegVal |= BCHP_FIELD_DATA (
622                                                AMOLE_0_BYTES_PER_LINE, LINE20_BANK2, 1);
623                                BREG_Write32(GetREG(), BCHP_AMOLE_0_DATA_WORD0_BANK2 + 12, 0);
624                                BREG_Write32(GetREG(), BCHP_AMOLE_0_DATA_WORD0_BANK2 + 16, 0);
625                                BREG_Write32(GetREG(), BCHP_AMOLE_0_DATA_WORD0_BANK2 + 20, 0);
626                        }
627                        break;
628
629                case 3:
630                        if (i) {
631                                ulRegAddr = BCHP_AMOLE_0_DATA_WORD0_BANK3 + 12;
632                                ulRegVal &= ~BCHP_MASK(AMOLE_0_BYTES_PER_LINE, LINE22_BANK3);
633                                if (AMOL_TYPE_I != line_data->amol_type)
634                                        ulRegVal |= BCHP_FIELD_DATA (
635                                                AMOLE_0_BYTES_PER_LINE, LINE22_BANK3, 1);
636                                BREG_Write32(GetREG(), BCHP_AMOLE_0_DATA_WORD0_BANK3, 0);
637                                BREG_Write32(GetREG(), BCHP_AMOLE_0_DATA_WORD0_BANK3 + 4, 0);
638                                BREG_Write32(GetREG(), BCHP_AMOLE_0_DATA_WORD0_BANK3 + 8, 0);
639                        }
640                        else {
641                                ulRegAddr = BCHP_AMOLE_0_DATA_WORD0_BANK3;
642                                ulRegVal &= ~BCHP_MASK(AMOLE_0_BYTES_PER_LINE, LINE20_BANK3);
643                                if (AMOL_TYPE_I != line_data->amol_type)
644                                        ulRegVal |= BCHP_FIELD_DATA (
645                                                AMOLE_0_BYTES_PER_LINE, LINE20_BANK3, 1);
646                                BREG_Write32(GetREG(), BCHP_AMOLE_0_DATA_WORD0_BANK3 + 12, 0);
647                                BREG_Write32(GetREG(), BCHP_AMOLE_0_DATA_WORD0_BANK3 + 16, 0);
648                                BREG_Write32(GetREG(), BCHP_AMOLE_0_DATA_WORD0_BANK3 + 20, 0);
649                        }
650                        break;
651        }
652        BREG_Write32(GetREG(), BCHP_AMOLE_0_BYTES_PER_LINE, ulRegVal);
653
654        /* Now write the user's data */
655        ulRegVal = 0;
656        ulRegVal |= (uint32_t)(*pAMOLData++);
657        ulRegVal |= (uint32_t)(*pAMOLData++) << 8;
658        ulRegVal |= (uint32_t)(*pAMOLData++) << 16;
659        ulRegVal |= (uint32_t)(*pAMOLData++) << 24;
660        BREG_Write32(GetREG(), ulRegAddr, ulRegVal);
661
662        ulRegAddr += 4;
663        ulRegVal = 0;
664        ulRegVal |= (uint32_t)(*pAMOLData++);
665        ulRegVal |= (uint32_t)(*pAMOLData++) <<  8;
666        if (totalBytes > 6)
667        {
668                ulRegVal |= (uint32_t)(*pAMOLData++) << 16;
669                ulRegVal |= (uint32_t)(*pAMOLData++) << 24;
670                BREG_Write32(GetREG(), ulRegAddr, ulRegVal);
671
672                ulRegAddr += 4;
673                ulRegVal = 0;
674
675                ulRegVal |= (uint32_t)(*pAMOLData++);
676                ulRegVal |= (uint32_t)(*pAMOLData++) << 8;
677                ulRegVal |= (uint32_t)(*pAMOLData++) << 16;
678                ulRegVal |= (uint32_t)(*pAMOLData++) << 24;
679        }
680        BREG_Write32(GetREG(), ulRegAddr, ulRegVal);
681
682        /* Program the write pointer into hardware */
683        ++ulWritePointer;
684        ulRegVal = BCHP_FIELD_DATA (AMOLE_0_WRPTR, VALUE, ulWritePointer);
685        BREG_Write32(GetREG(), BCHP_AMOLE_0_WRPTR, ulRegVal);
686
687        BDBG_MSG(("%s: leave", __func__));
688        return 0x0;
689}
690
691uint32_t bapp_amol_set_scte_127_ex( 
692        bapp_amol_t p_amol, 
693        scte_127_data *line_data1,
694        scte_127_data *line_data2)
695       
696{
697        uint32_t ulRegVal, status;
698        uint32_t ulRegAddr = 0;
699        uint32_t ulReadPointer;
700        uint32_t ulWritePointer;
701        uint32_t bankIndex;
702        int      totalBytes;
703        uint8_t field = 0;
704        uint8_t *pAMOLData;
705
706        BDBG_MSG(("%s: enter", __func__));
707
708        /* validation */
709        if (!p_amol || !line_data1 || !line_data2)
710        {
711                BDBG_WRN(("%s: null data pointer", __func__));
712                return -1;
713        }
714
715        /* the pair must be for same field and different lines */
716        if (line_data1->field_parity != line_data2->field_parity || 
717                line_data1->line_offset == line_data2->line_offset) {
718                BDBG_WRN(("invalid data, drop (%d,%d)(%d,%d)", line_data1->field_parity,
719                        line_data1->line_offset, line_data2->field_parity, line_data2->line_offset));
720                return -1;
721        }
722
723        /* currently just assume lines are for 20 and 22 only */
724        if ((20 != line_data1->line_offset && 22 != line_data1->line_offset) || 
725                (20 != line_data2->line_offset && 22 != line_data2->line_offset)) {
726                BDBG_WRN(("invalid lines, drop (l1=%d,l2=%d)", line_data1->line_offset,
727                        line_data2->line_offset));
728                return -1;
729        }
730
731        status = BREG_Read32(GetREG(), BCHP_AMOLE_0_STATUS) & ~BCHP_AMOLE_0_STATUS_reserved0_MASK;
732        BREG_Write32(GetREG(), BCHP_AMOLE_0_STATUS, status);
733
734        /* Get FIFO pointers */
735        ulRegVal = BREG_Read32(GetREG(), BCHP_AMOLE_0_WRPTR);
736        ulWritePointer = BCHP_GET_FIELD_DATA (ulRegVal, AMOLE_0_WRPTR, VALUE);
737        bankIndex = ulWritePointer & 0x3;
738        ulRegVal = BREG_Read32(GetREG(), BCHP_AMOLE_0_RDPTR);
739        ulReadPointer = BCHP_GET_FIELD_DATA (ulRegVal, AMOLE_0_RDPTR, VALUE);
740
741        /* Check for FIFO full */
742        if (((ulReadPointer & 0x3) == bankIndex) &&
743            (ulReadPointer         != ulWritePointer))
744        {
745                if (status & (BCHP_AMOLE_0_STATUS_FIFO_OVERFLOW_MASK | BCHP_AMOLE_0_STATUS_FIFO_UNDERFLOW_MASK)) {
746                        BDBG_WRN(("2: OF/UF (idx=%d,W=%d,R=%d,status=0x%08x)", bankIndex, ulReadPointer, ulWritePointer, status));
747                        return -1;
748                }
749        }
750
751        field = line_data1->field_parity? 0 : 1;
752
753        /* Handle field misalignment */
754        if (((bankIndex == 0) || (bankIndex == 2)) &&           /* top field */
755                (AMOL_FIELD_TOP != field))
756        {
757                BDBG_MSG(("top field misalignment, bankIndex=%d", bankIndex));
758                bapp_amol_program_null(bankIndex, 1);
759                ++ulWritePointer;
760                ulWritePointer %= 8;
761                bankIndex++;
762                bankIndex %= 4;
763        }
764        else if (((bankIndex == 1) || (bankIndex == 3)) &&      /* bottom filed */
765                (AMOL_FIELD_BOT != field))
766        {
767                BDBG_MSG(("bot field misalignment, bankIndex=%d", bankIndex));
768                bapp_amol_program_null(bankIndex, 1);
769                ++ulWritePointer;
770                ulWritePointer %= 8;
771                bankIndex++;
772                bankIndex %= 4;
773        }
774       
775        bapp_amol_program_null(bankIndex, 0);
776
777        /* the caller should verify that line offset is valid (10 - 22) */
778        /* if line number changed */
779        if (line_data1->line_offset != p_amol->info[field].line[0] &&
780                line_data2->line_offset != p_amol->info[field].line[1]) {
781                /* update line mask accordingly */
782                p_amol->info[field].line[0] = line_data1->line_offset;
783                p_amol->info[field].line[1] = line_data2->line_offset;
784                bapp_amol_mask_lines(p_amol, field);
785        }
786
787        /* update symbol rate accordingly */
788        ulRegVal = BREG_Read32(GetREG(), BCHP_AMOLE_0_BYTES_PER_LINE);
789        switch (bankIndex)
790        {
791                case 0:
792                        ulRegVal &= ~BCHP_MASK(AMOLE_0_BYTES_PER_LINE, LINE20_BANK0);
793                        ulRegVal &= ~BCHP_MASK(AMOLE_0_BYTES_PER_LINE, LINE22_BANK0);
794                        if (line_data1->amol_type >= AMOL_TYPE_II_1M)
795                                ulRegVal |= BCHP_FIELD_DATA(AMOLE_0_BYTES_PER_LINE, LINE20_BANK0, 1);
796                        if (line_data2->amol_type >= AMOL_TYPE_II_1M)
797                                ulRegVal |= BCHP_FIELD_DATA(AMOLE_0_BYTES_PER_LINE, LINE22_BANK0, 1);
798                        ulRegAddr = BCHP_AMOLE_0_DATA_WORD0_BANK0;
799                        break;
800
801                case 1:
802                        ulRegVal &= ~BCHP_MASK(AMOLE_0_BYTES_PER_LINE, LINE20_BANK1);
803                        ulRegVal &= ~BCHP_MASK(AMOLE_0_BYTES_PER_LINE, LINE22_BANK1);
804                        if (line_data1->amol_type >= AMOL_TYPE_II_1M)
805                                ulRegVal |= BCHP_FIELD_DATA(AMOLE_0_BYTES_PER_LINE, LINE20_BANK1, 1);
806                        if (line_data2->amol_type >= AMOL_TYPE_II_1M)
807                                ulRegVal |= BCHP_FIELD_DATA(AMOLE_0_BYTES_PER_LINE, LINE22_BANK1, 1);
808                        ulRegAddr = BCHP_AMOLE_0_DATA_WORD0_BANK1;
809                        break;
810
811                case 2:
812                        ulRegVal &= ~BCHP_MASK(AMOLE_0_BYTES_PER_LINE, LINE20_BANK2);
813                        ulRegVal &= ~BCHP_MASK(AMOLE_0_BYTES_PER_LINE, LINE22_BANK2);
814                        if (line_data1->amol_type >= AMOL_TYPE_II_1M)
815                                ulRegVal |= BCHP_FIELD_DATA(AMOLE_0_BYTES_PER_LINE, LINE20_BANK2, 1);
816                        if (line_data2->amol_type >= AMOL_TYPE_II_1M)
817                                ulRegVal |= BCHP_FIELD_DATA(AMOLE_0_BYTES_PER_LINE, LINE22_BANK2, 1);
818                        ulRegAddr = BCHP_AMOLE_0_DATA_WORD0_BANK2;
819                        break;
820
821                case 3:
822                        ulRegVal &= ~BCHP_MASK(AMOLE_0_BYTES_PER_LINE, LINE20_BANK3);
823                        ulRegVal &= ~BCHP_MASK(AMOLE_0_BYTES_PER_LINE, LINE22_BANK3);
824                        if (line_data1->amol_type >= AMOL_TYPE_II_1M)
825                                ulRegVal |= BCHP_FIELD_DATA(AMOLE_0_BYTES_PER_LINE, LINE20_BANK3, 1);
826                        if (line_data2->amol_type >= AMOL_TYPE_II_1M)
827                                ulRegVal |= BCHP_FIELD_DATA(AMOLE_0_BYTES_PER_LINE, LINE22_BANK3, 1);
828                        ulRegAddr = BCHP_AMOLE_0_DATA_WORD0_BANK3;
829                        break;
830        }
831        BREG_Write32(GetREG(), BCHP_AMOLE_0_BYTES_PER_LINE, ulRegVal);
832
833        /* Now write the user's data of first line */
834        if (AMOL_TYPE_I == line_data1->amol_type) {
835                totalBytes = 6;
836                pAMOLData = line_data1->u.amol48;
837        } else {
838                totalBytes = 12;
839                pAMOLData = line_data1->u.amol96;
840        }
841
842        ulRegVal = 0;
843        ulRegVal |= (uint32_t)(*pAMOLData++);
844        ulRegVal |= (uint32_t)(*pAMOLData++) << 8;
845        ulRegVal |= (uint32_t)(*pAMOLData++) << 16;
846        ulRegVal |= (uint32_t)(*pAMOLData++) << 24;
847        BREG_Write32(GetREG(), ulRegAddr, ulRegVal);
848
849        ulRegAddr += 4;
850        ulRegVal = 0;
851        ulRegVal |= (uint32_t)(*pAMOLData++);
852        ulRegVal |= (uint32_t)(*pAMOLData++) <<  8;
853        if (totalBytes > 6)
854        {
855                ulRegVal |= (uint32_t)(*pAMOLData++) << 16;
856                ulRegVal |= (uint32_t)(*pAMOLData++) << 24;
857                BREG_Write32(GetREG(), ulRegAddr, ulRegVal);
858
859                ulRegAddr += 4;
860                ulRegVal = 0;
861
862                ulRegVal |= (uint32_t)(*pAMOLData++);
863                ulRegVal |= (uint32_t)(*pAMOLData++) << 8;
864                ulRegVal |= (uint32_t)(*pAMOLData++) << 16;
865                ulRegVal |= (uint32_t)(*pAMOLData++) << 24;
866        }
867        BREG_Write32(GetREG(), ulRegAddr, ulRegVal);
868
869        /* write line 22 data */
870        if (totalBytes > 6)
871                ulRegAddr += 4;
872        else
873                ulRegAddr += 8;
874
875        /* write line 2 */
876        if (AMOL_TYPE_I == line_data2->amol_type) {
877                totalBytes = 6;
878                pAMOLData = line_data2->u.amol48;
879        } else {
880                totalBytes = 12;
881                pAMOLData = line_data2->u.amol96;
882        }
883
884        ulRegVal = 0;
885        ulRegVal |= (uint32_t)(*pAMOLData++);
886        ulRegVal |= (uint32_t)(*pAMOLData++) << 8;
887        ulRegVal |= (uint32_t)(*pAMOLData++) << 16;
888        ulRegVal |= (uint32_t)(*pAMOLData++) << 24;
889        BREG_Write32(GetREG(), ulRegAddr, ulRegVal);
890
891        ulRegAddr += 4;
892        ulRegVal = 0;
893        ulRegVal |= (uint32_t)(*pAMOLData++);
894        ulRegVal |= (uint32_t)(*pAMOLData++) <<  8;
895        if (totalBytes > 6)
896        {
897                ulRegVal |= (uint32_t)(*pAMOLData++) << 16;
898                ulRegVal |= (uint32_t)(*pAMOLData++) << 24;
899                BREG_Write32(GetREG(), ulRegAddr, ulRegVal);
900
901                ulRegAddr += 4;
902                ulRegVal = 0;
903
904                ulRegVal |= (uint32_t)(*pAMOLData++);
905                ulRegVal |= (uint32_t)(*pAMOLData++) << 8;
906                ulRegVal |= (uint32_t)(*pAMOLData++) << 16;
907                ulRegVal |= (uint32_t)(*pAMOLData++) << 24;
908        }
909        BREG_Write32(GetREG(), ulRegAddr, ulRegVal);
910        /* Program the write pointer into hardware */
911        ++ulWritePointer;
912        ulWritePointer %= 8;
913        ulRegVal = BCHP_FIELD_DATA (AMOLE_0_WRPTR, VALUE, ulWritePointer);
914        BREG_Write32(GetREG(), BCHP_AMOLE_0_WRPTR, ulRegVal);
915
916        BDBG_MSG(("%s: leave", __func__));
917        return 0x0;
918}
Note: See TracBrowser for help on using the repository browser.