Context Navigation

bvbi_amole.c

Last change on this file was 2, checked in by phkim, 11 years ago

1.phkim

revision copy newcon3sk r27

Property svn:executable set to *

File size: 18.1 KB

Line
1	/***************************************************************************
2	* Copyright (c) 2003-2012, 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: bvbi_amole.c $
11	* $brcm_Revision: Hydra_Software_Devel/6 $
12	* $brcm_Date: 2/20/12 2:53p $
13	*
14	* Module Description:
15	*
16	* Revision History:
17	*
18	* $brcm_Log: /magnum/portinginterface/vbi/7420/bvbi_amole.c $
19	*
20	* Hydra_Software_Devel/6 2/20/12 2:53p darnstein
21	* SW7425-2434: more detail in error messages.
22	*
23	* Hydra_Software_Devel/5 2/20/12 12:55p darnstein
24	* SW7425-2434: when an unsupported video format is entered, the BDBG
25	* error message should be informative.
26	*
27	* Hydra_Software_Devel/4 9/9/11 5:13p darnstein
28	* SW7425-1217: Correct ordering of AMOL data.
29	*
30	* Hydra_Software_Devel/3 12/8/08 9:01p darnstein
31	* PR9987,PR45819: fix up logic for ITU-R 656 output of AMOL.
32	*
33	* Hydra_Software_Devel/2 12/4/08 6:06p darnstein
34	* PR45819: 7420 software will now compile, but not link.
35	*
36	* Hydra_Software_Devel/1 12/3/08 8:00p darnstein
37	* PR45819:
38	*
39	***************************************************************************/
40
41
42	#include "bstd.h" /* standard types */
43	#include "bdbg.h" /* Dbglib */
44	#include "bkni.h" /* For critical sections */
45	#include "bvbi.h" /* VBI processing, this module. */
46	#include "bvbi_priv.h" /* VBI internal data structures */
47	#if (BVBI_P_NUM_AMOLE >= 1)
48	#include "bchp_amole_0.h" /* RDB info for primary AMOL encoder core */
49	#endif
50	#if (BVBI_P_NUM_AMOLE >= 2)
51	#include "bchp_amole_1.h" /* RDB info for secondary AMOL encoder core */
52	#endif
53	#if (BVBI_P_NUM_AMOLE >= 3)
54	#include "bchp_amole_2.h" /* RDB info for tertiary AMOL encoder core */
55	#endif
56	#if (BVBI_P_NUM_AMOLE_656 >= 1)
57	#include "bchp_amole_ancil_0.h"
58	#endif
59
60	BDBG_MODULE(BVBI);
61
62	/***************************************************************************
63	* Private data
64	***************************************************************************/
65
66	/***************************************************************************
67	* Forward declarations of static (private) functions
68	***************************************************************************/
69
70	#if (BVBI_P_NUM_AMOLE >= 1)
71	static void BVBI_P_ProgramNull (
72	BREG_Handle hReg, uint32_t coreOffset,
73	uint32_t ulWritePointer, uint32_t value);
74	static uint32_t P_GetCoreOffset (bool is656, uint8_t hwCoreIndex);
75	#endif / } BVBI_P_NUM_AMOLE /
76
77
78	/***************************************************************************
79	* Implementation of "BVBI_" API functions
80	***************************************************************************/
81
82
83	/***************************************************************************
84	* Implementation of supporting AMOL functions that are not in API
85	***************************************************************************/
86
87	/***************************************************************************
88	*
89	*/
90	void BVBI_P_AMOL_Enc_Init (BREG_Handle hReg, bool is656, uint8_t hwCoreIndex)
91	{
92	#if (BVBI_P_NUM_AMOLE > 0) \|\| (BVBI_P_NUM_AMOLE_656 > 0) / { /
93
94	BDBG_ENTER(BVBI_P_AMOL_Enc_Init);
95
96	BVBI_P_VIE_SoftReset (hReg, is656, hwCoreIndex, BVBI_P_SELECT_AMOL);
97
98	BDBG_LEAVE(BVBI_P_AMOL_Enc_Init);
99
100	#else / } BVBI_P_NUM_AMOLE { /
101
102	BSTD_UNUSED (hReg);
103	BSTD_UNUSED (is656);
104	BSTD_UNUSED (hwCoreIndex);
105
106	#endif / } BVBI_P_NUM_AMOLE /
107	}
108
109	/***************************************************************************
110	*
111	*/
112	BERR_Code BVBI_P_AMOL_Enc_Program (
113	BREG_Handle hReg,
114	bool is656,
115	uint8_t hwCoreIndex,
116	bool bActive,
117	BFMT_VideoFmt eVideoFormat,
118	BVBI_AMOL_Type amolType)
119	{
120	/*
121	Programming note: the implementation here assumes that the bitfield layout
122	within registers is the same for all AMOL encoder cores in the chip.
123
124	If a chip is built that has multiple AMOL encoder cores that are not
125	identical, then this routine will have to be redesigned.
126	*/
127	#if (BVBI_P_NUM_AMOLE > 0) \|\| (BVBI_P_NUM_AMOLE_656 > 0) / { /
128
129	uint16_t lineMask;
130	uint32_t ulCoreOffset;
131	uint32_t ulAmole_controlReg;
132	uint32_t nbyte_symbol = (amolType == BVBI_AMOL_Type_II_Highrate) ? 1 : 0;
133
134	BDBG_ENTER(BVBI_P_AMOL_Enc_Program);
135
136	/* Figure out which encoder core to use */
137	ulCoreOffset = P_GetCoreOffset (is656, hwCoreIndex);
138	if (ulCoreOffset == 0xFFFFFFFF)
139	{
140	/* This is difficult to do right. Just say bye. */
141	return BERR_SUCCESS;
142	}
143
144	/* Complain if video format is not supported */
145	switch (eVideoFormat)
146	{
147	case BFMT_VideoFmt_eNTSC:
148	case BFMT_VideoFmt_eNTSC_J:
149	break;
150
151	default:
152	if (bActive)
153	{
154	BDBG_ERR(("BVBI_AMOLE: video format %d not supported",
155	eVideoFormat));
156	return BERR_TRACE (BVBI_ERR_VFMT_CONFLICT);
157	}
158	}
159
160	/* All three AMOL types use lines 20-top and 22-bottom */
161	ulAmole_controlReg = 0;
162	lineMask = (unsigned int)1 << (20 - 15);
163	ulAmole_controlReg \|= (
164	BCHP_FIELD_DATA (AMOLE_0_ACT_LINE_BASE_TOP, BASE, 15) \|
165	BCHP_FIELD_DATA (AMOLE_0_ACT_LINE_BASE_TOP, ACTIVE_LINE, lineMask) );
166	if (amolType != BVBI_AMOL_Type_I)
167	{
168	lineMask = (unsigned int)1 << (22 - 15);
169	ulAmole_controlReg \|= (
170	BCHP_FIELD_DATA (AMOLE_0_ACT_LINE_BASE_TOP, ACTIVE_LINE, lineMask) );
171	}
172	BREG_Write32 (
173	hReg, BCHP_AMOLE_0_ACT_LINE_BASE_TOP + ulCoreOffset,
174	ulAmole_controlReg);
175
176	ulAmole_controlReg = 0;
177	lineMask = (unsigned int)1 << (22 - 15);
178	ulAmole_controlReg \|= (
179	BCHP_FIELD_DATA (AMOLE_0_ACT_LINE_BASE_BOT, BASE, 22) \|
180	BCHP_FIELD_DATA (AMOLE_0_ACT_LINE_BASE_BOT, ACTIVE_LINE, lineMask) );
181	if (amolType != BVBI_AMOL_Type_I)
182	{
183	lineMask = (unsigned int)1 << (20 - 15);
184	ulAmole_controlReg \|= (
185	BCHP_FIELD_DATA (AMOLE_0_ACT_LINE_BASE_BOT, ACTIVE_LINE, lineMask) );
186	}
187	BREG_Write32 (
188	hReg, BCHP_AMOLE_0_ACT_LINE_BASE_BOT + ulCoreOffset,
189	ulAmole_controlReg);
190
191	ulAmole_controlReg = 0;
192	ulAmole_controlReg \|= (
193	BCHP_FIELD_DATA (AMOLE_0_GAIN_PED_TOP, GAIN_LINE22, 0x4d) \|
194	BCHP_FIELD_DATA (AMOLE_0_GAIN_PED_TOP, GAIN_LINE20, 0x4d) \|
195	BCHP_FIELD_ENUM (AMOLE_0_GAIN_PED_TOP, PED_LINE22, DISABLE) \|
196	BCHP_FIELD_ENUM (AMOLE_0_GAIN_PED_TOP, PED_LINE20, DISABLE)
197	);
198	BREG_Write32 (
199	hReg, BCHP_AMOLE_0_GAIN_PED_TOP + ulCoreOffset, ulAmole_controlReg);
200
201	ulAmole_controlReg = 0;
202	ulAmole_controlReg \|= (
203	BCHP_FIELD_DATA (AMOLE_0_GAIN_PED_BOT, GAIN_LINE22, 0x4d) \|
204	BCHP_FIELD_DATA (AMOLE_0_GAIN_PED_BOT, GAIN_LINE20, 0x4d) \|
205	BCHP_FIELD_ENUM (AMOLE_0_GAIN_PED_BOT, PED_LINE22, DISABLE) \|
206	BCHP_FIELD_ENUM (AMOLE_0_GAIN_PED_BOT, PED_LINE20, DISABLE)
207	);
208	BREG_Write32 (
209	hReg, BCHP_AMOLE_0_GAIN_PED_BOT + ulCoreOffset, ulAmole_controlReg);
210
211	ulAmole_controlReg = 0;
212	ulAmole_controlReg \|= (
213	BCHP_FIELD_DATA (
214	AMOLE_0_BYTES_PER_LINE, LINE22_BANK3, nbyte_symbol) \|
215	BCHP_FIELD_DATA (
216	AMOLE_0_BYTES_PER_LINE, LINE20_BANK3, nbyte_symbol) \|
217	BCHP_FIELD_DATA (
218	AMOLE_0_BYTES_PER_LINE, LINE22_BANK2, nbyte_symbol) \|
219	BCHP_FIELD_DATA (
220	AMOLE_0_BYTES_PER_LINE, LINE20_BANK2, nbyte_symbol) \|
221	BCHP_FIELD_DATA (
222	AMOLE_0_BYTES_PER_LINE, LINE22_BANK1, nbyte_symbol) \|
223	BCHP_FIELD_DATA (
224	AMOLE_0_BYTES_PER_LINE, LINE20_BANK1, nbyte_symbol) \|
225	BCHP_FIELD_DATA (
226	AMOLE_0_BYTES_PER_LINE, LINE22_BANK0, nbyte_symbol) \|
227	BCHP_FIELD_DATA (
228	AMOLE_0_BYTES_PER_LINE, LINE20_BANK0, nbyte_symbol)
229	);
230	BREG_Write32 (
231	hReg, BCHP_AMOLE_0_BYTES_PER_LINE + ulCoreOffset,
232	ulAmole_controlReg);
233
234	ulAmole_controlReg = 0;
235	ulAmole_controlReg \|= (
236	BCHP_FIELD_DATA (AMOLE_0_NULL, NULL_ENABLE_BANK3, 0) \|
237	BCHP_FIELD_DATA (AMOLE_0_NULL, NULL_ENABLE_BANK2, 0) \|
238	BCHP_FIELD_DATA (AMOLE_0_NULL, NULL_ENABLE_BANK1, 0) \|
239	BCHP_FIELD_DATA (AMOLE_0_NULL, NULL_ENABLE_BANK0, 0) \|
240	BCHP_FIELD_DATA (AMOLE_0_NULL, CHARACTER, 0x20)
241	);
242	BREG_Write32 (
243	hReg, BCHP_AMOLE_0_NULL + ulCoreOffset, ulAmole_controlReg);
244
245	ulAmole_controlReg = 0;
246	ulAmole_controlReg \|= (
247	BCHP_FIELD_DATA (AMOLE_0_CONTROL, DELAY_COUNT, 0x6B) \|
248	BCHP_FIELD_DATA (AMOLE_0_CONTROL, FIFO_FREEZE, 0) \|
249	BCHP_FIELD_DATA (AMOLE_0_CONTROL, NULL_MODE, 1) );
250	if (bActive)
251	{
252	ulAmole_controlReg \|=
253	BCHP_FIELD_ENUM (AMOLE_0_CONTROL, ENABLE, ON);
254	}
255	else
256	{
257	ulAmole_controlReg \|=
258	BCHP_FIELD_ENUM (AMOLE_0_CONTROL, ENABLE, OFF);
259	}
260	BREG_Write32 (
261	hReg, BCHP_AMOLE_0_CONTROL + ulCoreOffset, ulAmole_controlReg);
262
263	BDBG_LEAVE(BVBI_P_AMOL_Enc_Program);
264	return BERR_SUCCESS;
265
266	#else / } BVBI_P_NUM_AMOLE { /
267
268	BSTD_UNUSED (hReg);
269	BSTD_UNUSED (is656);
270	BSTD_UNUSED (hwCoreIndex);
271	BSTD_UNUSED (bActive);
272	BSTD_UNUSED (eVideoFormat);
273	BSTD_UNUSED (amolType);
274
275	return BERR_TRACE (BVBI_ERR_HW_UNSUPPORTED);
276
277	#endif / } BVBI_P_NUM_AMOLE /
278	}
279
280	uint32_t BVBI_P_AMOL_Encode_Data_isr (
281	BREG_Handle hReg,
282	bool is656,
283	uint8_t hwCoreIndex,
284	BFMT_VideoFmt eVideoFormat,
285	BAVC_Polarity polarity,
286	BVBI_AMOL_Type amolType,
287	uint8_t* pAMOLData )
288	{
289	#if (BVBI_P_NUM_AMOLE > 0) \|\| (BVBI_P_NUM_AMOLE_656 > 0) / { /
290
291	uint32_t ulCoreOffset;
292	uint32_t ulRegVal;
293	uint32_t ulRegAddr;
294	uint32_t ulReadPointer;
295	uint32_t ulWritePointer;
296	uint32_t bankIndex;
297	int totalBytes;
298	int iReg;
299
300	/* Debug code
301	uint32_t dread_pointer[2];
302	uint32_t dwrite_pointer[2];
303	uint32_t status;
304	*/
305
306	BDBG_ENTER(BVBI_P_AMOL_Encode_Data_isr);
307
308	/* Size check for field data */
309	if (!pAMOLData)
310	{
311	return (BVBI_LINE_ERROR_FLDH_CONFLICT);
312	}
313
314	/* Figure out which encoder core to use */
315	ulCoreOffset = P_GetCoreOffset (is656, hwCoreIndex);
316	if (ulCoreOffset == 0xFFFFFFFF)
317	{
318	/* This should never happen! This parameter was checked by
319	BVBI_Encode_Create() */
320	ulCoreOffset = 0;
321	BDBG_ASSERT (ulCoreOffset);
322	}
323
324	/* Complain if video format is not supported */
325	switch (eVideoFormat)
326	{
327	case BFMT_VideoFmt_eNTSC:
328	case BFMT_VideoFmt_eNTSC_J:
329	break;
330
331	default:
332	/* Should not happen */
333	BDBG_ERR(("BVBI_AMOLE: video format %d not supported", eVideoFormat));
334	BDBG_ASSERT (0);
335	break;
336	}
337
338	/* Decide how many bytes to copy */
339	switch (amolType)
340	{
341	case BVBI_AMOL_Type_I:
342	totalBytes = 6;
343	break;
344	case BVBI_AMOL_Type_II_Lowrate:
345	totalBytes = 12;
346	break;
347	case BVBI_AMOL_Type_II_Highrate:
348	totalBytes = 24;
349	break;
350	default:
351	totalBytes = 0;
352	BDBG_ASSERT (totalBytes);
353	break;
354	}
355
356	/* Clear status bits */
357	ulRegVal = BREG_Read32 (hReg, BCHP_AMOLE_0_STATUS + ulCoreOffset);
358	/* Debug code
359	status = ulRegVal;
360	*/
361	ulRegVal &= 0x000003FF;
362	BREG_Write32 (hReg, BCHP_AMOLE_0_STATUS + ulCoreOffset, ulRegVal);
363	/* TODO: Check AMOLE_0_STATUS register? */
364
365	/* Get FIFO pointers */
366	ulRegVal = BREG_Read32 (hReg, BCHP_AMOLE_0_WRPTR + ulCoreOffset);
367	ulWritePointer = BCHP_GET_FIELD_DATA (ulRegVal, AMOLE_0_WRPTR, VALUE);
368	bankIndex = ulWritePointer & 0x00000003;
369	ulRegVal = BREG_Read32 (hReg, BCHP_AMOLE_0_RDPTR + ulCoreOffset);
370	ulReadPointer = BCHP_GET_FIELD_DATA (ulRegVal, AMOLE_0_RDPTR, VALUE);
371
372	/* Debug code
373	dread_pointer[0] = ulReadPointer;
374	dwrite_pointer[0] = ulWritePointer;
375	*/
376
377	/* Check for FIFO full */
378	if (((ulReadPointer & 0x3) == bankIndex ) &&
379	(ulReadPointer != ulWritePointer) )
380	{
381	/* Debug code
382	printf ("\n * AMOL FIFO full!!! *\n\n");
383	*/
384	return BVBI_LINE_ERROR_AMOL_OVERRUN;
385	}
386
387	/* Handle field misalignment */
388	if (
389	((bankIndex == 0) \|\| (bankIndex == 2)) &&
390	(polarity != BAVC_Polarity_eTopField)
391	)
392	{
393	BVBI_P_ProgramNull (hReg, ulCoreOffset, bankIndex, 1);
394	++ulWritePointer;
395	}
396	else if (
397	((bankIndex == 1) \|\| (bankIndex == 3)) &&
398	(polarity != BAVC_Polarity_eBotField)
399	)
400	{
401	BVBI_P_ProgramNull (hReg, ulCoreOffset, bankIndex, 1);
402	++ulWritePointer;
403	}
404	else
405	{
406	BVBI_P_ProgramNull (hReg, ulCoreOffset, bankIndex, 0);
407	}
408
409	/* Decide where to put user's data */
410	switch (bankIndex)
411	{
412	case 0:
413	ulRegAddr = BCHP_AMOLE_0_DATA_WORD0_BANK0 + ulCoreOffset;
414	break;
415	case 1:
416	ulRegAddr = BCHP_AMOLE_0_DATA_WORD0_BANK1 + ulCoreOffset;
417	break;
418	case 2:
419	ulRegAddr = BCHP_AMOLE_0_DATA_WORD0_BANK2 + ulCoreOffset;
420	break;
421	case 3:
422	ulRegAddr = BCHP_AMOLE_0_DATA_WORD0_BANK3 + ulCoreOffset;
423	break;
424	default:
425	ulRegAddr = 0x0;
426	BDBG_ASSERT (ulRegAddr);
427	}
428
429	/* Now write the user's data */
430	/* Programming note: the bit ordering is somewhat complicated. See bvbi.h
431	* ---------------- for details. */
432	switch (totalBytes)
433	{
434	case 6:
435	ulRegVal = 0;
436	ulRegVal \|= (uint32_t)(*pAMOLData++) ;
437	ulRegVal \|= (uint32_t)(*pAMOLData++) << 8;
438	ulRegVal \|= (uint32_t)(*pAMOLData++) << 16;
439	ulRegVal \|= (uint32_t)(*pAMOLData++) << 24;
440	BREG_Write32 (hReg, ulRegAddr, ulRegVal);
441	ulRegAddr += 4;
442	ulRegVal = 0;
443	ulRegVal \|= (uint32_t)(*pAMOLData++) ;
444	ulRegVal \|= (uint32_t)(*pAMOLData++) << 8;
445	BREG_Write32 (hReg, ulRegAddr, ulRegVal);
446	break;
447	case 12:
448	for (iReg = 0 ; iReg < 3 ; ++iReg)
449	{
450	ulRegVal = 0;
451	ulRegVal \|= (uint32_t)(*pAMOLData++) ;
452	ulRegVal \|= (uint32_t)(*pAMOLData++) << 8;
453	ulRegVal \|= (uint32_t)(*pAMOLData++) << 16;
454	ulRegVal \|= (uint32_t)(*pAMOLData++) << 24;
455	BREG_Write32 (hReg, ulRegAddr, ulRegVal);
456	ulRegAddr += 4;
457	}
458	break;
459	case 24:
460	for (iReg = 0 ; iReg < 6 ; ++iReg)
461	{
462	ulRegVal = 0;
463	ulRegVal \|= (uint32_t)(*pAMOLData++) ;
464	ulRegVal \|= (uint32_t)(*pAMOLData++) << 8;
465	ulRegVal \|= (uint32_t)(*pAMOLData++) << 16;
466	ulRegVal \|= (uint32_t)(*pAMOLData++) << 24;
467	BREG_Write32 (hReg, ulRegAddr, ulRegVal);
468	ulRegAddr += 4;
469	}
470	break;
471	default:
472	/* Should not happen */
473	totalBytes = 0;
474	BDBG_ASSERT (totalBytes);
475	break;
476	}
477
478	/* Program the write pointer into hardware */
479	++ulWritePointer;
480	ulRegVal = BCHP_FIELD_DATA (AMOLE_0_WRPTR, VALUE, ulWritePointer);
481	BREG_Write32 (hReg, BCHP_AMOLE_0_WRPTR + ulCoreOffset, ulRegVal);
482
483	/* Debug code
484	ulRegVal = BREG_Read32 (hReg, BCHP_AMOLE_0_WRPTR + ulCoreOffset);
485	ulWritePointer = BCHP_GET_FIELD_DATA (ulRegVal, AMOLE_0_WRPTR, VALUE);
486	dwrite_pointer[1] = ulWritePointer;
487	ulRegVal = BREG_Read32 (hReg, BCHP_AMOLE_0_RDPTR + ulCoreOffset);
488	dread_pointer[1] = BCHP_GET_FIELD_DATA (ulRegVal, AMOLE_0_RDPTR, VALUE);
489	printf (
490	"Field %c: status: %03x R/W (%d/%d) --> (%d/%d) data (%08x %08x %08x)\n",
491	((polarity == BAVC_Polarity_eTopField) ? 'T' : 'B'),
492	status,
493	dread_pointer[0], dwrite_pointer[0],
494	dread_pointer[1], dwrite_pointer[1],
495	pAMOLata->ulData[0], pAMOLata->ulData[1], pAMOLata->ulData[2]);
496	*/
497
498	BDBG_LEAVE(BVBI_P_AMOL_Encode_Data_isr);
499	return 0x0;
500
501	#else / } BVBI_P_NUM_AMOLE { /
502
503	BSTD_UNUSED (hReg);
504	BSTD_UNUSED (is656);
505	BSTD_UNUSED (hwCoreIndex);
506	BSTD_UNUSED (eVideoFormat);
507	BSTD_UNUSED (polarity);
508	BSTD_UNUSED (amolType);
509	BSTD_UNUSED (pAMOLData);
510
511	return (-1);
512
513	#endif / } BVBI_P_NUM_AMOLE /
514	}
515
516	/***************************************************************************
517	*
518	*/
519	BERR_Code BVBI_P_AMOL_Encode_Enable_isr (
520	BREG_Handle hReg,
521	bool is656,
522	uint8_t hwCoreIndex,
523	BFMT_VideoFmt eVideoFormat,
524	bool bEnable)
525	{
526	#if (BVBI_P_NUM_AMOLE > 0) \|\| (BVBI_P_NUM_AMOLE_656 > 0) / { /
527
528	uint32_t ulCoreOffset;
529	uint32_t ulAmole_controlReg;
530
531	BSTD_UNUSED (eVideoFormat);
532
533	BDBG_ENTER(BVBI_P_AMOL_Encode_Enable_isr);
534
535	/* Figure out which encoder core to use */
536	ulCoreOffset = P_GetCoreOffset (is656, hwCoreIndex);
537	if (ulCoreOffset == 0xFFFFFFFF)
538	{
539	/* This should never happen! This parameter was checked by
540	BVBI_Encode_Create() */
541	BDBG_LEAVE(BVBI_P_AMOL_Encode_Enable_isr);
542	return BERR_TRACE(BERR_INVALID_PARAMETER);
543	}
544
545	ulAmole_controlReg =
546	BREG_Read32 (hReg, BCHP_AMOLE_0_CONTROL + ulCoreOffset);
547	ulAmole_controlReg &= ~(
548	BCHP_MASK (AMOLE_0_CONTROL, ENABLE ) );
549	if (bEnable)
550	{
551	ulAmole_controlReg \|= (
552	BCHP_FIELD_DATA (AMOLE_0_CONTROL, ENABLE, 1) );
553	}
554	else
555	{
556	ulAmole_controlReg \|= (
557	BCHP_FIELD_DATA (AMOLE_0_CONTROL, ENABLE, 0) );
558	}
559	BREG_Write32 (
560	hReg, BCHP_AMOLE_0_CONTROL + ulCoreOffset, ulAmole_controlReg);
561
562	BDBG_LEAVE(BVBI_P_AMOL_Encode_Enable_isr);
563	return BERR_SUCCESS;
564
565	#else / } BVBI_P_NUM_AMOLE { /
566
567	BSTD_UNUSED (hReg);
568	BSTD_UNUSED (is656);
569	BSTD_UNUSED (hwCoreIndex);
570	BSTD_UNUSED (eVideoFormat);
571	BSTD_UNUSED (bEnable);
572
573	return BERR_TRACE (BVBI_ERR_HW_UNSUPPORTED);
574
575	#endif / } BVBI_P_NUM_AMOLE /
576	}
577
578
579	/***************************************************************************
580	* Static (private) functions
581	***************************************************************************/
582
583
584	#if (BVBI_P_NUM_AMOLE > 0) \|\| (BVBI_P_NUM_AMOLE_656 > 0) / { /
585
586	/***************************************************************************
587	*
588	*/
589	static void BVBI_P_ProgramNull (
590	BREG_Handle hReg, uint32_t coreOffset,
591	uint32_t ulWritePointer, uint32_t value)
592	{
593	uint32_t ulRegAddr = BCHP_AMOLE_0_NULL + coreOffset;
594	uint32_t ulRegVal = BREG_Read32 (hReg, ulRegAddr);
595
596	switch (ulWritePointer & 0x3)
597	{
598	case 0:
599	ulRegVal &=
600	~BCHP_MASK (AMOLE_0_NULL, NULL_ENABLE_BANK0 );
601	ulRegVal \|=
602	BCHP_FIELD_DATA (AMOLE_0_NULL, NULL_ENABLE_BANK0, value);
603	break;
604	case 1:
605	ulRegVal &=
606	~BCHP_MASK (AMOLE_0_NULL, NULL_ENABLE_BANK1 );
607	ulRegVal \|=
608	BCHP_FIELD_DATA (AMOLE_0_NULL, NULL_ENABLE_BANK1, value);
609	break;
610	case 2:
611	ulRegVal &=
612	~BCHP_MASK (AMOLE_0_NULL, NULL_ENABLE_BANK2 );
613	ulRegVal \|=
614	BCHP_FIELD_DATA (AMOLE_0_NULL, NULL_ENABLE_BANK2, value);
615	break;
616	case 3:
617	ulRegVal &=
618	~BCHP_MASK (AMOLE_0_NULL, NULL_ENABLE_BANK3 );
619	ulRegVal \|=
620	BCHP_FIELD_DATA (AMOLE_0_NULL, NULL_ENABLE_BANK3, value);
621	break;
622	default:
623	/* Should never happen! Programming error! */
624	BDBG_ASSERT (false);
625	break;
626	}
627
628	BREG_Write32 (hReg, ulRegAddr, ulRegVal);
629	}
630
631	static uint32_t P_GetCoreOffset (bool is656, uint8_t hwCoreIndex)
632	{
633	uint32_t ulCoreOffset = 0xFFFFFFFF;
634
635	if (is656)
636	{
637	switch (hwCoreIndex)
638	{
639	#if (BVBI_P_NUM_AMOLE_656 >= 1)
640	case 0:
641	ulCoreOffset = (BCHP_AMOLE_ANCIL_0_REVID - BCHP_AMOLE_0_REVID);
642	break;
643	#endif
644	default:
645	break;
646	}
647	}
648	else
649	{
650	switch (hwCoreIndex)
651	{
652	#if (BVBI_P_NUM_AMOLE >= 1)
653	case 0:
654	ulCoreOffset = 0;
655	break;
656	#endif
657	#if (BVBI_P_NUM_AMOLE >= 2)
658	case 1:
659	ulCoreOffset = (BCHP_AMOLE_1_REVID - BCHP_AMOLE_0_REVID);
660	break;
661	#endif
662	#if (BVBI_P_NUM_AMOLE >= 3)
663	case 2:
664	ulCoreOffset = (BCHP_AMOLE_2_REVID - BCHP_AMOLE_0_REVID);
665	break;
666	#endif
667	default:
668	break;
669	}
670	}
671
672	return ulCoreOffset;
673	}
674
675	#endif / } BVBI_P_NUM_AMOLE /

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

Context Navigation

source: svn/trunk/newcon3bcm2_21bu/magnum/portinginterface/vbi/7552/bvbi_amole.c

Download in other formats: