Context Navigation

bads_utils.c

Last change on this file was 2, checked in by jglee, 11 years ago
first commit
Property svn:executable set to ``*
File size: 50.3 KB

Line
1	/***************************************************************************
2	* (c)2005-2011 Broadcom Corporation
3	*
4	* This program is the proprietary software of Broadcom Corporation and/or its licensors,
5	* and may only be used, duplicated, modified or distributed pursuant to the terms and
6	* conditions of a separate, written license agreement executed between you and Broadcom
7	* (an "Authorized License"). Except as set forth in an Authorized License, Broadcom grants
8	* no license (express or implied), right to use, or waiver of any kind with respect to the
9	* Software, and Broadcom expressly reserves all rights in and to the Software and all
10	* intellectual property rights therein. IF YOU HAVE NO AUTHORIZED LICENSE, THEN YOU
11	* HAVE NO RIGHT TO USE THIS SOFTWARE IN ANY WAY, AND SHOULD IMMEDIATELY
12	* NOTIFY BROADCOM AND DISCONTINUE ALL USE OF THE SOFTWARE.
13	*
14	* Except as expressly set forth in the Authorized License,
15	*
16	* 1. This program, including its structure, sequence and organization, constitutes the valuable trade
17	* secrets of Broadcom, and you shall use all reasonable efforts to protect the confidentiality thereof,
18	* and to use this information only in connection with your use of Broadcom integrated circuit products.
19	*
20	* 2. TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE SOFTWARE IS PROVIDED "AS IS"
21	* AND WITH ALL FAULTS AND BROADCOM MAKES NO PROMISES, REPRESENTATIONS OR
22	* WARRANTIES, EITHER EXPRESS, IMPLIED, STATUTORY, OR OTHERWISE, WITH RESPECT TO
23	* THE SOFTWARE. BROADCOM SPECIFICALLY DISCLAIMS ANY AND ALL IMPLIED WARRANTIES
24	* OF TITLE, MERCHANTABILITY, NONINFRINGEMENT, FITNESS FOR A PARTICULAR PURPOSE,
25	* LACK OF VIRUSES, ACCURACY OR COMPLETENESS, QUIET ENJOYMENT, QUIET POSSESSION
26	* OR CORRESPONDENCE TO DESCRIPTION. YOU ASSUME THE ENTIRE RISK ARISING OUT OF
27	* USE OR PERFORMANCE OF THE SOFTWARE.
28	*
29	* 3. TO THE MAXIMUM EXTENT PERMITTED BY LAW, IN NO EVENT SHALL BROADCOM OR ITS
30	* LICENSORS BE LIABLE FOR (i) CONSEQUENTIAL, INCIDENTAL, SPECIAL, INDIRECT, OR
31	* EXEMPLARY DAMAGES WHATSOEVER ARISING OUT OF OR IN ANY WAY RELATING TO YOUR
32	* USE OF OR INABILITY TO USE THE SOFTWARE EVEN IF BROADCOM HAS BEEN ADVISED OF
33	* THE POSSIBILITY OF SUCH DAMAGES; OR (ii) ANY AMOUNT IN EXCESS OF THE AMOUNT
34	* ACTUALLY PAID FOR THE SOFTWARE ITSELF OR U.S. $1, WHICHEVER IS GREATER. THESE
35	* LIMITATIONS SHALL APPLY NOTWITHSTANDING ANY FAILURE OF ESSENTIAL PURPOSE OF
36	* ANY LIMITED REMEDY.
37	*
38	* $brcm_Workfile: bads_utils.c $
39	* $brcm_Revision: 46 $
40	* $brcm_Date: 11/22/11 4:32p $
41	*
42	* [File Description:]
43	*
44	* Revision History:
45	*
46	* $brcm_Log: /AP/ctfe/core/ads/bads_utils.c $
47	*
48	* 46 11/22/11 4:32p farshidf
49	* SW3461-99: merge to main
50	*
51	* Fw_Integration_Devel/1 11/22/11 3:22p farshidf
52	* SW3461-99: merge to integ
53	*
54	* Fw_Integration_Devel/AP_V3_0_ADS_DEV/1 11/21/11 6:56p mpovich
55	* SW3128-71: Support for a single, common 3128 chip family F/W binary.
56	*
57	* Fw_Integration_Devel/AP_V3_0_ADS_DEV/SW3128-71/1 11/17/11 6:57p mpovich
58	* SW3128-71: Support for common 3128 family chip F/W.
59	*
60	* 45 6/7/11 6:03p farshidf
61	* SW3128-1: add 3123 support
62	*
63	* 44 5/20/11 6:39a mpovich
64	* SW3461-1: rename UFE (BUFE) module to TNR (BTNR).
65	*
66	* TNR_3461_1/1 5/19/11 6:27p mpovich
67	* SW3461-1: Change BUFE module name to BTNR
68	*
69	* 43 5/10/11 3:17p farshidf
70	* SW3128-1: merge main
71	*
72	* ADS_3128_3/1 5/6/11 2:51p cbrooks
73	* sw3128-1:new code
74	*
75	* 41 4/26/11 6:51p farshidf
76	* SW3128-1: merge main
77	*
78	* ADS_3128_2/4 4/26/11 4:57p farshidf
79	* SW3128-1: merge main
80	*
81	* 40 4/25/11 10:23a farshidf
82	* SW3461-1: sync up with 35330
83	*
84	* 39 4/21/11 6:00p farshidf
85	* SW3461-1: make the files host compatible
86	*
87	* 38 4/18/11 5:32p farshidf
88	* SW3128-1: update to make it work with host chip
89	*
90	* 37 4/15/11 4:40p farshidf
91	* SW3128-1: merge main
92	*
93	* ADS_3128_2/2 4/14/11 4:36p cbrooks
94	* sw3128-1:comment change
95	*
96	* 36 3/24/11 4:16p farshidf
97	* SW3128-1: add support for 3124
98	*
99	* 35 3/18/11 4:30p farshidf
100	* SW3461-1: merge main
101	*
102	* ADS_3128_1/2 3/17/11 7:38p cbrooks
103	* sw3128-1:new code
104	*
105	* ADS_3128_1/1 3/15/11 5:14p cbrooks
106	* bcm3128-1:Added new HAB for CWC and changed FFEDFE command
107	*
108	* 32 2/23/11 6:57p cbrooks
109	* sw3128-1:new code
110	*
111	* 31 2/14/11 4:23p mpovich
112	* SW3128-1: Add revised, multi-packet "Get DFE" "Get FFE" coefficients
113	* HAB commands.
114	*
115	* Rom_Devel_3128/1 2/14/11 3:27p mpovich
116	* SW3128-1: Support for FFE DFE coeffs HAB command.
117	*
118	* 30 2/10/11 3:11p mpovich
119	* SW3128-1: Fix "Read Integrators" HAB command function.
120	*
121	* 29 2/10/11 2:17p farshidf
122	* SW3128-1: fix code
123	*
124	* 28 2/10/11 2:10p farshidf
125	* SW3128-1: fix compile
126	*
127	* 27 2/10/11 12:23p farshidf
128	* SW3128-1: make it compile in 3461
129	*
130	* 26 2/9/11 3:39p mpovich
131	* SW3128-1: Fix "Read Constellation" function (read the IQ register each
132	* iteration)
133	*
134	* 25 2/8/11 11:48a farshidf
135	* SW3128-1: update the constellation function
136	*
137	* 24 2/4/11 12:22p farshidf
138	* SW3128-1: fix the power up issue
139	*
140	* 23 2/3/11 6:35p farshidf
141	* SW3128-1: add Gui functions
142	*
143	* 22 1/28/11 3:47p farshidf
144	* SW3128-1: adapt the files to 3461
145	*
146	* 21 1/26/11 4:12p farshidf
147	* SW3128-1: clean up
148	*
149	* 20 1/26/11 3:32p farshidf
150	* SW3128-1: compile fix
151	*
152	* 19 1/26/11 3:28p farshidf
153	* SW3128-1: add the power settings
154	*
155	* 18 1/25/11 9:30p cbrooks
156	* sw3128-1: Cleanup Code
157	*
158	* 17 1/17/11 1:24p cbrooks
159	* sw3128-1:New Code
160	*
161	* 16 12/22/10 2:22p farshidf
162	* SW3128-1: update
163	*
164	* 15 12/18/10 10:40a farshidf
165	* SW3128-1: update
166	*
167	* 14 12/17/10 4:17p farshidf
168	* SW3128-1: update
169	*
170	* 13 12/16/10 6:17p farshidf
171	* SW3128-1: clean up
172	*
173	* 12 12/15/10 5:39p cbrooks
174	* SW3128-1:new code
175	*
176	* 11 12/14/10 2:34p farshidf
177	* SW3128-1: update
178	*
179	* 10 12/14/10 2:12p cbrooks
180	* SW3128-1:New Code
181	*
182	* 9 12/7/10 10:49p cbrooks
183	* SW3128-1:New Code
184	*
185	* 8 12/7/10 4:16p cbrooks
186	* SW3128-1:New Code
187	*
188	* 7 12/3/10 3:53p farshidf
189	* SW3128-1: clean up
190	*
191	* 6 12/2/10 6:29p cbrooks
192	* SW3128-1:fixed case
193	*
194	* 5 12/1/10 3:23p cbrooks
195	* SW3128-1: ADS update
196	*
197	* 4 11/30/10 11:19a farshidf
198	* SW3461-1: add BMTH_2560log10 to math lib
199	*
200	* 3 11/24/10 9:38p cbrooks
201	* sw3128-1: Third try
202	*
203	* 2 11/22/10 6:09p farshidf
204	* SW3128-1: remove old code
205	*
206	* 1 11/12/10 5:45p farshidf
207	* SW3128-1: add ADS code
208	*
209	***************************************************************************/
210	#include "bstd.h"
211	#include "bmth.h"
212	#include "bkni.h"
213	#include "btmr.h"
214	#ifndef LEAP_BASED_CODE
215	#include "bads.h"
216	#include "bads_priv.h"
217	#include "bads_mth.h"
218	#include "bchp_ds_topm.h"
219	#include "bchp_ds_tops.h"
220	#include "bads_global_clk.h"
221	#endif
222	#include "bads_api.h"
223	#include "bads_acquire.h"
224	#include "bads_def.h"
225
226
227	#if (BCHP_FAMILY == 3128) /* 4 Demods or fewer */
228	#include "bchp_ds_topm.h"
229	#include "bchp_ds_tops.h"
230	#include "bwfe_global_clk.h"
231	#if (BCHP_CHIP == 3128) /* 8 Demods */
232	#include "bchp_ds_b_tops.h"
233	#include "bchp_ds_b_topm.h"
234	#include "bchp_tm.h"
235	#endif
236	#endif
237	#if (BCHP_FAMILY==3461)
238	#include "btnr_global_clk.h"
239	#endif
240	/registers needed for the functions in this file/
241	#include "bchp_ds.h"
242	#include "bads_priv.h"
243
244	#ifndef LEAP_BASED_CODE
245	BDBG_MODULE(bads_utils);
246	#endif
247
248	/***********************************************************************************************
249	* BADS_Range_Check() This routine checks that parameters from the PI/BBS are in range
250	************************************************************************************************/
251	BERR_Code BADS_P_Range_Check(BADS_3x7x_ChannelHandle hChn)
252	{
253	BERR_Code retCode = BERR_SUCCESS;
254
255	/************************************************************************************************
256	* Check the BADS_Acquire_Params structure
257	************************************************************************************************/
258
259	switch(hChn->pChnAcqParam->BADS_Acquire_Params.AcqType)
260	{
261	case BADS_Acquire_Params_AcqType_eAuto:
262	case BADS_Acquire_Params_AcqType_eFast:
263	case BADS_Acquire_Params_AcqType_eSlow:
264	case BADS_Acquire_Params_AcqType_eScan:
265	BDBG_MSG(("hChn->pChnAcqParam->BADS_Acquire_Params.AcqType = %d", hChn->pChnAcqParam->BADS_Acquire_Params.AcqType));
266	break;
267	default :
268	BDBG_ERR(("hChn->pChnAcqParam->BADS_Acquire_Params.AcqType OUT OF RANGE"));
269	BDBG_ERR(("Value Received is %d",hChn->pChnAcqParam->BADS_Acquire_Params.AcqType));
270	retCode = BERR_INVALID_PARAMETER;
271	}
272
273	switch(hChn->pChnAcqParam->BADS_Acquire_Params.Auto)
274	{
275	case BADS_Acquire_Params_eDisable:
276	case BADS_Acquire_Params_eEnable:
277	BDBG_MSG(("hChn->pChnAcqParam->BADS_Acquire_Params.Auto = %d", hChn->pChnAcqParam->BADS_Acquire_Params.Auto));
278	break;
279	default :
280	BDBG_ERR(("hChn->pChnAcqParam->BADS_Acquire_Params.Auto OUT OF RANGE"));
281	BDBG_ERR(("Value Received is %d",hChn->pChnAcqParam->BADS_Acquire_Params.Auto));
282	retCode = BERR_INVALID_PARAMETER;
283	}
284
285	switch(hChn->pChnAcqParam->BADS_Acquire_Params.IS)
286	{
287	case BADS_Acquire_Params_eDisable:
288	case BADS_Acquire_Params_eEnable:
289	BDBG_MSG(("hChn->pChnAcqParam->BADS_Acquire_Params.IS = %d", hChn->pChnAcqParam->BADS_Acquire_Params.IS));
290	break;
291	default :
292	BDBG_ERR(("hChn->pChnAcqParam->BADS_Acquire_Params.IS OUT OF RANGE"));
293	BDBG_ERR(("Value Received is %d",hChn->pChnAcqParam->BADS_Acquire_Params.IS));
294	retCode = BERR_INVALID_PARAMETER;
295	}
296
297	/In addition to range checking, assign the local param structure since it is used in LUT's locally/
298	switch(hChn->pChnAcqParam->BADS_Acquire_Params.Annex)
299	{
300	case BADS_Acquire_Params_Annex_eAnnexA :
301	hChn->pChnAcqParam->BADS_Local_Params.Annex = BADS_Local_Params_Annex_eAnnexA;
302	BDBG_MSG(("FEC is AnnexA"));
303	break;
304	case BADS_Acquire_Params_Annex_eAnnexB :
305	hChn->pChnAcqParam->BADS_Local_Params.Annex = BADS_Local_Params_Annex_eAnnexB;
306	BDBG_MSG(("FEC is AnnexB"));
307	break;
308	default :
309	BDBG_ERR(("hChn->pChnAcqParam->BADS_Acquire_Params.Annex OUT OF RANGE"));
310	BDBG_ERR(("Value Received is %d",hChn->pChnAcqParam->BADS_Acquire_Params.Annex));
311	retCode = BERR_INVALID_PARAMETER;
312	}
313
314	/In addition to range checking, assign the local param structure since it is used in LUT's locally/
315	switch(hChn->pChnAcqParam->BADS_Acquire_Params.Qam_Mode)
316	{
317	case BADS_Acquire_Params_BPS_eQam16 :
318	hChn->pChnAcqParam->BADS_Local_Params.QAM = BADS_Local_Params_QAM_eQam16;
319	BDBG_MSG(("Qam_Mode is Qam16"));
320	break;
321	case BADS_Acquire_Params_BPS_eQam32 :
322	hChn->pChnAcqParam->BADS_Local_Params.QAM = BADS_Local_Params_QAM_eQam32;
323	BDBG_MSG(("Qam_Mode is Qam32"));
324	break;
325	case BADS_Acquire_Params_BPS_eQam64 :
326	hChn->pChnAcqParam->BADS_Local_Params.QAM = BADS_Local_Params_QAM_eQam64;
327	BDBG_MSG(("Qam_Mode is Qam64"));
328	break;
329	case BADS_Acquire_Params_BPS_eQam128 :
330	hChn->pChnAcqParam->BADS_Local_Params.QAM = BADS_Local_Params_QAM_eQam128;
331	BDBG_MSG(("Qam_Mode is Qam128"));
332	break;
333	case BADS_Acquire_Params_BPS_eQam256 :
334	hChn->pChnAcqParam->BADS_Local_Params.QAM = BADS_Local_Params_QAM_eQam256;
335	BDBG_MSG(("Qam_Mode is Qam256"));
336	break;
337	case BADS_Acquire_Params_BPS_eQam512 :
338	hChn->pChnAcqParam->BADS_Local_Params.QAM = BADS_Local_Params_QAM_eQam512;
339	BDBG_MSG(("Qam_Mode is Qam512"));
340	break;
341	case BADS_Acquire_Params_BPS_eQam1024:
342	hChn->pChnAcqParam->BADS_Local_Params.QAM = BADS_Local_Params_QAM_eQam1024;
343	BDBG_MSG(("Qam_Mode is Qam1024"));
344	break;
345	default :
346	BDBG_ERR(("hChn->pChnAcqParam->BADS_Acquire_Params.Qam_Mode OUT OF RANGE"));
347	BDBG_ERR(("Value Received is %d",hChn->pChnAcqParam->BADS_Acquire_Params.Qam_Mode));
348	retCode = BERR_INVALID_PARAMETER;
349	}
350
351	/check only right combinations are sent 64/256/1024 for AnnexB, 16/32/64/128/256/512/1024 for AnnexA/
352	switch(hChn->pChnAcqParam->BADS_Acquire_Params.Annex)
353	{
354	case BADS_Acquire_Params_Annex_eAnnexA :
355	switch(hChn->pChnAcqParam->BADS_Acquire_Params.Qam_Mode)
356	{
357	case BADS_Acquire_Params_BPS_eQam16 :
358	case BADS_Acquire_Params_BPS_eQam32 :
359	case BADS_Acquire_Params_BPS_eQam64 :
360	case BADS_Acquire_Params_BPS_eQam128 :
361	case BADS_Acquire_Params_BPS_eQam256 :
362	case BADS_Acquire_Params_BPS_eQam512 :
363	case BADS_Acquire_Params_BPS_eQam1024 :
364	break;
365	default: BDBG_ERR(("Unsupported QAM and FEC combination"));
366	retCode = BERR_INVALID_PARAMETER;
367	}
368	break;
369	case BADS_Acquire_Params_Annex_eAnnexB :
370	switch(hChn->pChnAcqParam->BADS_Acquire_Params.Qam_Mode)
371	{
372	case BADS_Acquire_Params_BPS_eQam64 :
373	case BADS_Acquire_Params_BPS_eQam256 :
374	case BADS_Acquire_Params_BPS_eQam1024 :
375	break;
376	default: BDBG_ERR(("Unsupported QAM and FEC combination"));
377	retCode = BERR_INVALID_PARAMETER;
378	}
379	break;
380	default :
381	BDBG_ERR(("hChn->pChnAcqParam->BADS_Acquire_Params.Annex OUT OF RANGE"));
382	BDBG_ERR(("Value Received is %d",hChn->pChnAcqParam->BADS_Acquire_Params.Annex));
383	retCode = BERR_INVALID_PARAMETER;
384	}
385
386	/Check the ranges for the hChn->pChnAcqParam->BADS_Acquire_Params structure /
387	if (hChn->pChnAcqParam->BADS_Acquire_Params.Carrier_Range <= MAX_CARRIER_RANGE/256)
388	{
389	BDBG_MSG(("hChn->pChnAcqParam->BADS_Acquire_Params.Carrier_Range = %d", hChn->pChnAcqParam->BADS_Acquire_Params.Carrier_Range*256));
390
391	}
392	else
393	{
394	BDBG_ERR(("hChn->pChnAcqParam->BADS_Acquire_Params.Carrier_Range OUT OF RANGE"));
395	BDBG_ERR(("Value Received is %d",hChn->pChnAcqParam->BADS_Acquire_Params.Carrier_Range));
396	retCode = BERR_INVALID_PARAMETER;
397	}
398
399	/Only check AnnexA_Sym_Rate if AnnexA is selected/
400	if (hChn->pChnAcqParam->BADS_Acquire_Params.Annex == BADS_Acquire_Params_Annex_eAnnexA)
401	{
402	if ((hChn->pChnAcqParam->BADS_Acquire_Params.AnnexA_Sym_Rate >= MIN_BAUD_RATE) &&
403	(hChn->pChnAcqParam->BADS_Acquire_Params.AnnexA_Sym_Rate <= MAX_BAUD_RATE))
404	{
405	BDBG_MSG(("hChn->pChnAcqParam->BADS_Acquire_Params.AnnexA_Sym_Rate = %d", hChn->pChnAcqParam->BADS_Acquire_Params.AnnexA_Sym_Rate));
406	}
407	else
408	{
409	BDBG_ERR(("hChn->pChnAcqParam->BADS_Acquire_Params.AnnexA_Sym_Rate OUT OF RANGE"));
410	BDBG_ERR(("Value Received is %d",hChn->pChnAcqParam->BADS_Acquire_Params.AnnexA_Sym_Rate));
411	retCode = BERR_INVALID_PARAMETER;
412	}
413	}
414
415	/************************************************************************************************
416	* Check the BADS_Scan_Params structure
417	************************************************************************************************/
418	if ((hChn->pChnAcqParam->BADS_Acquire_Params.AcqType == BADS_Acquire_Params_AcqType_eAuto) \|\| (hChn->pChnAcqParam->BADS_Acquire_Params.AcqType == BADS_Acquire_Params_AcqType_eScan))
419	{
420	switch(hChn->pChnAcqParam->BADS_Scan_Params.AI)
421	{
422	case BADS_Scan_Params_eDisable:
423	case BADS_Scan_Params_eEnable:
424	BDBG_MSG(("hChn->pChnAcqParam->BADS_Scan_Params.AI = %d", hChn->pChnAcqParam->BADS_Scan_Params.AI));
425	break;
426	default :
427	BDBG_ERR(("hChn->pChnAcqParam->BADS_Scan_Params.AI OUT OF RANGE"));
428	BDBG_ERR(("Value Received is %d",hChn->pChnAcqParam->BADS_Scan_Params.AI));
429	retCode = BERR_INVALID_PARAMETER;
430	}
431
432	switch(hChn->pChnAcqParam->BADS_Scan_Params.QM)
433	{
434	case BADS_Scan_Params_eDisable:
435	case BADS_Scan_Params_eEnable:
436	BDBG_MSG(("hChn->pChnAcqParam->BADS_Scan_Params.QM = %d", hChn->pChnAcqParam->BADS_Scan_Params.QM));
437	break;
438	default :
439	BDBG_ERR(("hChn->pChnAcqParam->BADS_Scan_Params.QM OUT OF RANGE"));
440	BDBG_ERR(("Value Received is %d",hChn->pChnAcqParam->BADS_Scan_Params.QM));
441	retCode = BERR_INVALID_PARAMETER;
442	}
443
444	switch(hChn->pChnAcqParam->BADS_Scan_Params.CO)
445	{
446	case BADS_Scan_Params_eDisable:
447	case BADS_Scan_Params_eEnable:
448	BDBG_MSG(("hChn->pChnAcqParam->BADS_Scan_Params.CO = %d", hChn->pChnAcqParam->BADS_Scan_Params.CO));
449	break;
450	default :
451	BDBG_ERR(("hChn->pChnAcqParam->BADS_Scan_Params.CO OUT OF RANGE"));
452	BDBG_ERR(("Value Received is %d",hChn->pChnAcqParam->BADS_Scan_Params.CO));
453	retCode = BERR_INVALID_PARAMETER;
454	}
455
456	switch(hChn->pChnAcqParam->BADS_Scan_Params.TO)
457	{
458	case BADS_Scan_Params_eDisable:
459	case BADS_Scan_Params_eEnable:
460	BDBG_MSG(("hChn->pChnAcqParam->BADS_Scan_Params.TO = %d", hChn->pChnAcqParam->BADS_Scan_Params.TO));
461	break;
462	default :
463	BDBG_ERR(("hChn->pChnAcqParam->BADS_Scan_Params.TO OUT OF RANGE"));
464	BDBG_ERR(("Value Received is %d",hChn->pChnAcqParam->BADS_Scan_Params.TO));
465	retCode = BERR_INVALID_PARAMETER;
466	}
467
468	/Check only if QM is enabled/
469	if (hChn->pChnAcqParam->BADS_Scan_Params.QM == BADS_Scan_Params_eEnable)
470	{
471	switch(hChn->pChnAcqParam->BADS_Scan_Params.B1024)
472	{
473	case BADS_Scan_Params_eDisable:
474	case BADS_Scan_Params_eEnable:
475	BDBG_MSG(("hChn->pChnAcqParam->BADS_Scan_Params.B1024 = %d", hChn->pChnAcqParam->BADS_Scan_Params.B1024));
476	break;
477	default :
478	BDBG_ERR(("hChn->pChnAcqParam->BADS_Scan_Params.B1024 OUT OF RANGE"));
479	BDBG_ERR(("Value Received is %d",hChn->pChnAcqParam->BADS_Scan_Params.B1024));
480	retCode = BERR_INVALID_PARAMETER;
481	}
482
483	switch(hChn->pChnAcqParam->BADS_Scan_Params.B256)
484	{
485	case BADS_Scan_Params_eDisable:
486	case BADS_Scan_Params_eEnable:
487	BDBG_MSG(("hChn->pChnAcqParam->BADS_Scan_Params.B256 = %d", hChn->pChnAcqParam->BADS_Scan_Params.B256));
488	break;
489	default :
490	BDBG_ERR(("hChn->pChnAcqParam->BADS_Scan_Params.B256 OUT OF RANGE"));
491	BDBG_ERR(("Value Received is %d",hChn->pChnAcqParam->BADS_Scan_Params.B256));
492	retCode = BERR_INVALID_PARAMETER;
493	}
494
495	switch(hChn->pChnAcqParam->BADS_Scan_Params.B64)
496	{
497	case BADS_Scan_Params_eDisable:
498	case BADS_Scan_Params_eEnable:
499	BDBG_MSG(("hChn->pChnAcqParam->BADS_Scan_Params.B64 = %d", hChn->pChnAcqParam->BADS_Scan_Params.B64));
500	break;
501	default :
502	BDBG_ERR(("hChn->pChnAcqParam->BADS_Scan_Params.B64 OUT OF RANGE"));
503	BDBG_ERR(("Value Received is %d",hChn->pChnAcqParam->BADS_Scan_Params.B64));
504	retCode = BERR_INVALID_PARAMETER;
505	}
506
507	switch(hChn->pChnAcqParam->BADS_Scan_Params.A1024)
508	{
509	case BADS_Scan_Params_eDisable:
510	case BADS_Scan_Params_eEnable:
511	BDBG_MSG(("hChn->pChnAcqParam->BADS_Scan_Params.A1024 = %d", hChn->pChnAcqParam->BADS_Scan_Params.A1024));
512	break;
513	default :
514	BDBG_ERR(("hChn->pChnAcqParam->BADS_Scan_Params.A1024 OUT OF RANGE"));
515	BDBG_ERR(("Value Received is %d",hChn->pChnAcqParam->BADS_Scan_Params.A1024));
516	retCode = BERR_INVALID_PARAMETER;
517	}
518
519	switch(hChn->pChnAcqParam->BADS_Scan_Params.A512)
520	{
521	case BADS_Scan_Params_eDisable:
522	case BADS_Scan_Params_eEnable:
523	BDBG_MSG(("hChn->pChnAcqParam->BADS_Scan_Params.A512 = %d", hChn->pChnAcqParam->BADS_Scan_Params.A512));
524	break;
525	default :
526	BDBG_ERR(("hChn->pChnAcqParam->BADS_Scan_Params.A512 OUT OF RANGE"));
527	BDBG_ERR(("Value Received is %d",hChn->pChnAcqParam->BADS_Scan_Params.A512));
528	retCode = BERR_INVALID_PARAMETER;
529	}
530
531	switch(hChn->pChnAcqParam->BADS_Scan_Params.A256)
532	{
533	case BADS_Scan_Params_eDisable:
534	case BADS_Scan_Params_eEnable:
535	BDBG_MSG(("hChn->pChnAcqParam->BADS_Scan_Params.A256 = %d", hChn->pChnAcqParam->BADS_Scan_Params.A256));
536	break;
537	default :
538	BDBG_ERR(("hChn->pChnAcqParam->BADS_Scan_Params.A256 OUT OF RANGE"));
539	BDBG_ERR(("Value Received is %d",hChn->pChnAcqParam->BADS_Scan_Params.A256));
540	retCode = BERR_INVALID_PARAMETER;
541	}
542
543	switch(hChn->pChnAcqParam->BADS_Scan_Params.A128)
544	{
545	case BADS_Scan_Params_eDisable:
546	case BADS_Scan_Params_eEnable:
547	BDBG_MSG(("hChn->pChnAcqParam->BADS_Scan_Params.A128 = %d", hChn->pChnAcqParam->BADS_Scan_Params.A128));
548	break;
549	default :
550	BDBG_ERR(("hChn->pChnAcqParam->BADS_Scan_Params.A128 OUT OF RANGE"));
551	BDBG_ERR(("Value Received is %d",hChn->pChnAcqParam->BADS_Scan_Params.A128));
552	retCode = BERR_INVALID_PARAMETER;
553	}
554
555	switch(hChn->pChnAcqParam->BADS_Scan_Params.A64)
556	{
557	case BADS_Scan_Params_eDisable:
558	case BADS_Scan_Params_eEnable:
559	BDBG_MSG(("hChn->pChnAcqParam->BADS_Scan_Params.A64 = %d", hChn->pChnAcqParam->BADS_Scan_Params.A64));
560	break;
561	default :
562	BDBG_ERR(("hChn->pChnAcqParam->BADS_Scan_Params.A64 OUT OF RANGE"));
563	BDBG_ERR(("Value Received is %d",hChn->pChnAcqParam->BADS_Scan_Params.A64));
564	retCode = BERR_INVALID_PARAMETER;
565	}
566
567	switch(hChn->pChnAcqParam->BADS_Scan_Params.A32)
568	{
569	case BADS_Scan_Params_eDisable:
570	case BADS_Scan_Params_eEnable:
571	BDBG_MSG(("hChn->pChnAcqParam->BADS_Scan_Params.A32 = %d", hChn->pChnAcqParam->BADS_Scan_Params.A32));
572	break;
573	default :
574	BDBG_ERR(("hChn->pChnAcqParam->BADS_Scan_Params.A32 OUT OF RANGE"));
575	BDBG_ERR(("Value Received is %d",hChn->pChnAcqParam->BADS_Scan_Params.A32));
576	retCode = BERR_INVALID_PARAMETER;
577	}
578
579	switch(hChn->pChnAcqParam->BADS_Scan_Params.A16)
580	{
581	case BADS_Scan_Params_eDisable:
582	case BADS_Scan_Params_eEnable:
583	BDBG_MSG(("hChn->pChnAcqParam->BADS_Scan_Params.A16 = %d", hChn->pChnAcqParam->BADS_Scan_Params.A16));
584	break;
585	default :
586	BDBG_ERR(("hChn->pChnAcqParam->BADS_Scan_Params.A16 OUT OF RANGE"));
587	BDBG_ERR(("Value Received is %d",hChn->pChnAcqParam->BADS_Scan_Params.A16));
588	retCode = BERR_INVALID_PARAMETER;
589	}
590	}
591
592	/Check only if CO is enabled/
593	if (hChn->pChnAcqParam->BADS_Scan_Params.CO == BADS_Scan_Params_eEnable)
594	{
595	if (hChn->pChnAcqParam->BADS_Scan_Params.Carrier_Search <= MAX_CARRIER_SCAN/256)
596	{
597	BDBG_MSG(("hChn->pChnAcqParam->BADS_Scan_Params.Carrier_Search = %d", hChn->pChnAcqParam->BADS_Scan_Params.Carrier_Search*256));
598	}
599	else
600	{
601	BDBG_ERR(("hChn->pChnAcqParam->BADS_Scan_Params.Carrier_Search OUT OF RANGE"));
602	BDBG_ERR(("Value Received is %d",hChn->pChnAcqParam->BADS_Scan_Params.Carrier_Search));
603	retCode = BERR_INVALID_PARAMETER;
604	}
605	}
606
607	/Check only if TO is enabled/
608	if (hChn->pChnAcqParam->BADS_Scan_Params.TO == BADS_Scan_Params_eEnable)
609	{
610	if ((hChn->pChnAcqParam->BADS_Scan_Params.Upper_Baud_Search <= MAX_BAUD_SCAN) &&
611	(hChn->pChnAcqParam->BADS_Scan_Params.Lower_Baud_Search >= MIN_BAUD_SCAN))
612	{
613	BDBG_MSG(("hChn->pChnAcqParam->BADS_Scan_Params.Upper_Baud_Search = %d", hChn->pChnAcqParam->BADS_Scan_Params.Upper_Baud_Search));
614	BDBG_MSG(("hChn->pChnAcqParam->BADS_Scan_Params.Lower_Baud_Search = %d", hChn->pChnAcqParam->BADS_Scan_Params.Lower_Baud_Search));
615	}
616	else
617	{
618	BDBG_ERR(("hChn->pChnAcqParam->BADS_Scan_Params.xxxxxx_Baud_Search OUT OF RANGE"));
619	BDBG_ERR(("Value Received is %d",hChn->pChnAcqParam->BADS_Scan_Params.Upper_Baud_Search));
620	BDBG_ERR(("Value Received is %d",hChn->pChnAcqParam->BADS_Scan_Params.Lower_Baud_Search));
621	retCode = BERR_INVALID_PARAMETER;
622	}
623	}
624	}
625	return retCode;
626	}
627
628	/********************************************************************************************
629	*BADS_P_Set_CFL_Frequency() determines the value to program in the front mixer
630	*Calculate the Carrier Loop Frequency Control Word a 16 bit 2's complement number
631	*The NCO value depends on the Fhs, IF Frequency a 2's complement number passed as uint32_t
632	CFLFOS = 2^16IF/Fhs
633	********************************************************************************************/
634	void BADS_P_Set_CFL_Frequency(BADS_3x7x_ChannelHandle hChn, int32_t CFL_Frequency)
635	{
636	/Local Variables/
637	bool IsNegative = false;
638	uint32_t ReadReg;
639	uint32_t ulMultA, ulMultB, ulNrmHi, ulNrmLo, ulDivisor;
640
641	/Detect if CFL_Frequency is negative/
642	if (CFL_Frequency < 0)
643	{
644	IsNegative = true;
645	CFL_Frequency = (CFL_Frequency == (int32_t)0x80000000) ? -1 * (CFL_Frequency + 1) : -1 * CFL_Frequency;
646	}
647
648	ReadReg = (uint32_t)CFL_Frequency;
649
650	ulMultA = POWER2_14;
651	ulMultB = ReadReg;
652	ulDivisor = F_HS;
653	BMTH_HILO_32TO64_Mul(ulMultA, ulMultB, &ulNrmHi, &ulNrmLo);
654	BMTH_HILO_64TO64_Div32(ulNrmHi, ulNrmLo, ulDivisor, &ulNrmHi, &ulNrmLo);
655
656	/If result should be negative, take twos complement of output/
657	ulNrmLo = (IsNegative == true) ? Twos_Complement32(ulNrmLo) : ulNrmLo;
658
659	/Mask to 16 bits/
660	ulNrmLo = ulNrmLo & 0x0000FFFF;
661
662	/Program the Carrier Loop Frequency Control Word/
663	BREG_WriteField(hChn->hRegister, DS_CFLFOS, CFLOFFSET, ulNrmLo);
664
665	return;
666	}
667
668	/****************************************************************************************************
669	*BADS_P_Set_CFL_Integrator(), this is used to jam the phase loop into the front loop interator
670	CFLI = 2^36(IF Frequency)/Fhs
671	****************************************************************************************************/
672	void BADS_P_Set_CFL_Integrator(BADS_3x7x_ChannelHandle hChn, int32_t CFL_Error)
673	{
674	/Local Variables/
675	bool IsNegative = false;
676	uint32_t ReadReg;
677	uint32_t ulMultA, ulMultB, ulNrmHi, ulNrmLo, ulDivisor;
678
679	/Detect if CPL_Error is negative, clamp/
680	IsNegative = 0;
681	if (CFL_Error < 0)
682	{
683	IsNegative = true;
684	CFL_Error = (CFL_Error == (int32_t)0x80000000) ? -1 * (CFL_Error + 1) : -1 * CFL_Error;
685	}
686
687	/Clamp CFL_Error to prevent overflow/
688	if (CFL_Error >= (int32_t) F_HS/8)
689	{
690	CFL_Error = F_HS/8 - 1;
691	BDBG_MSG(("Clamping CarrierPhaseError in BADS_P_Set_CFL_Integrator()"));
692	}
693
694	ReadReg = (uint32_t)CFL_Error;
695
696	ulMultA = 8*ReadReg;
697	ulMultB = POWER2_31;
698	ulDivisor = F_HS;
699	BMTH_HILO_32TO64_Mul(ulMultA, ulMultB, &ulNrmHi, &ulNrmLo);
700	BMTH_HILO_64TO64_Div32(ulNrmHi, ulNrmLo, ulDivisor, &ulNrmHi, &ulNrmLo);
701
702	/If result should be negative, take twos complement of output/
703	ulNrmLo = (IsNegative == true) ? Twos_Complement32(ulNrmLo) : ulNrmLo;
704
705	BREG_Write32(hChn->hRegister, BCHP_DS_CFLI, ulNrmLo);
706
707	return;
708	}
709
710	/****************************************************************************************************
711	*BADS_P_Set_TL_Frequency() determines the value to program in the VID
712	*Calculate the Timing Loop Frequency Control Word a 24 bit 2's complement number
713	TLFOS = (4BaudRate/F1s)2^23 or TLFOS = (2^25BaudRate/F1s)
714	****************************************************************************************************/
715	void BADS_P_Set_TL_Frequency(BADS_3x7x_ChannelHandle hChn, uint32_t Symbol_Rate)
716	{
717
718	uint32_t ulMultA, ulMultB, ulNrmHi, ulNrmLo, ulDivisor;
719
720	/Check to make sure symbol rate is in range/
721	if ((Symbol_Rate < 500000) \|\| (Symbol_Rate >= F_1S/4))
722	{
723	BDBG_ERR(("SymbolRate out of range in BADS_P_Set_TL_Frequency()"));
724	}
725
726	ulMultA = POWER2_25;
727	ulMultB = Symbol_Rate;
728	ulDivisor = F_1S;
729	BMTH_HILO_32TO64_Mul(ulMultA, ulMultB, &ulNrmHi, &ulNrmLo);
730	BMTH_HILO_64TO64_Div32(ulNrmHi, ulNrmLo, ulDivisor, &ulNrmHi, &ulNrmLo);
731
732	/Program the Timing Loop Frequency Control Word/
733	BREG_Write32(hChn->hRegister, BCHP_DS_TLFOS, ulNrmLo);
734
735	return;
736	}
737
738	/****************************************************************************************
739	*BADS_P_Set_TL_Sweep() sets the timing loop sweep
740	*For QAM (with loop filter output gain set to 1.0)
741	TLSWP = (Sweep Rate in Hz/sec) 2^42 / (BaudRate * F1S)
742	*For QAM (with loop filter output gain set to 2^-6) the offset in Hertz is:
743	TLSWP = (Sweep Rate in Hz/sec) 2^48 / (BaudRate * F1S)
744	****************************************************************************************/
745	void BADS_P_Set_TL_Sweep(BADS_3x7x_ChannelHandle hChn, uint32_t Symbol_Rate, int32_t TL_Sweep_Rate)
746	{
747	/Local Variables/
748	bool IsNegative = false;
749	uint8_t TL_Gain;
750	uint32_t ReadReg;
751	uint32_t Symbol_Rate_Div1024, F_1S_Div1024;
752	uint32_t ulMultA, ulMultB, ulNrmHi, ulNrmLo, ulDivisor;
753
754	/Check to make sure symbol rate is in range/
755	if ((Symbol_Rate < 500000) \|\| (Symbol_Rate >= F_1S/4))
756	{
757	BDBG_ERR(("SymbolRate out of range in BADS_P_Set_TL_Frequency()"));
758	}
759
760	if (TL_Sweep_Rate == 0)
761	{
762	/Turn Off Sweep/
763	BREG_Write32(hChn->hRegister, BCHP_DS_TLSWP, 0);
764	}
765	else
766	{
767	/Detect if TL_Sweep_Rate is negative/
768	if (TL_Sweep_Rate < 0)
769	{
770	IsNegative = true;
771	TL_Sweep_Rate = (TL_Sweep_Rate == (int32_t)0x80000000) ? -1 * (TL_Sweep_Rate + 1) : -1 * TL_Sweep_Rate;
772	}
773
774	ReadReg = (uint32_t)TL_Sweep_Rate;
775
776	/Divide by 1024 to keep in range/
777	Symbol_Rate_Div1024 = Symbol_Rate/1024;
778	F_1S_Div1024 = F_1S/1024;
779
780	/Get the timing loop gain/
781	TL_Gain = BREG_ReadField(hChn->hRegister, DS_TLC, TLLFOUTGAIN);
782
783	ulMultA = ReadReg;
784	ulMultB = (TL_Gain == 0) ? POWER2_22 : POWER2_28; /loop filter output gain set to 1 or 2^-6/
785	ulDivisor = Symbol_Rate_Div1024*F_1S_Div1024;
786
787	if (ulDivisor == 0)
788	{
789	BDBG_ERR(("divide by 0 in BADS_P_Set_VIDTimingSweep() while calculating VIDTimingSweep"));
790	}
791	BMTH_HILO_32TO64_Mul(ulMultA, ulMultB, &ulNrmHi, &ulNrmLo);
792	BMTH_HILO_64TO64_Div32(ulNrmHi, ulNrmLo, ulDivisor, &ulNrmHi, &ulNrmLo);
793	if ((ulNrmHi != 0) \|\| (ulNrmLo > 0x7FFFFFFF))
794	{
795	BDBG_WRN(("64to32 division is not in a 31 bit unsigned int range5"));
796	}
797
798	/If result should be negative, take twos complement of output/
799	ulNrmLo = (IsNegative == true) ? Twos_Complement32(ulNrmLo) : ulNrmLo;
800
801	/Write Sweep Value which Turns On Sweep/
802	BREG_Write32(hChn->hRegister, BCHP_DS_TLSWP, ulNrmLo);
803	}
804
805	return;
806	}
807
808	/****************************************************************************************************
809	*BADS_P_Set_CPL_Integrator(), this is used set the phase loop before sweeping
810	CPLI = CPL_Error2^30/SymbolRate
811	****************************************************************************************************/
812	void BADS_P_Set_CPL_Integrator(BADS_3x7x_ChannelHandle hChn, uint32_t Symbol_Rate, int32_t CPL_Error)
813	{
814	/Local Variables/
815	bool IsNegative = false;
816	uint32_t ReadReg;
817	uint32_t ulMultA, ulMultB, ulNrmHi, ulNrmLo, ulDivisor;
818
819	/Check to make sure symbol rate is in range/
820	if ((Symbol_Rate < 500000) \|\| (Symbol_Rate >= F_1S/4))
821	{
822	BDBG_ERR(("SymbolRate out of range in BADS_P_Set_CPL_Sweep()"));
823	}
824
825	/Detect if CPL_Error is negative, clamp/
826	IsNegative = 0;
827	if (CPL_Error < 0)
828	{
829	IsNegative = true;
830	CPL_Error = (CPL_Error == (int32_t)0x80000000) ? -1 * (CPL_Error + 1) : -1 * CPL_Error;
831	}
832
833	/Clamp CPL_Error to prevent overflow/
834	if (CPL_Error >= (int32_t) F_HS/8)
835	{
836	CPL_Error = F_HS/8 - 1;
837	BDBG_MSG(("Clamping CarrierPhaseError in BADS_P_Set_CPL_Integrator()"));
838	}
839
840	ReadReg = (uint32_t)CPL_Error;
841
842	ulMultA = ReadReg;
843	ulMultB = POWER2_30;
844	ulDivisor = Symbol_Rate;
845	BMTH_HILO_32TO64_Mul(ulMultA, ulMultB, &ulNrmHi, &ulNrmLo);
846	BMTH_HILO_64TO64_Div32(ulNrmHi, ulNrmLo, ulDivisor, &ulNrmHi, &ulNrmLo);
847	if ((ulNrmHi != 0) \|\| (ulNrmLo > 0x1FFFFFFF))
848	{
849	ulNrmLo = 0x1FFFFFFF;
850	BDBG_WRN(("CPL_Error out of range in BADS_P_Set_CPL_Integrator(), clamping value"));
851	}
852
853	/If result should be negative, take twos complement of output/
854	ulNrmLo = (IsNegative == true) ? Twos_Complement32(ulNrmLo) : ulNrmLo;
855
856	/Mask to 30 bits/
857	ulNrmLo = ulNrmLo & 0x1FFFFFFF;
858
859	BREG_Write32(hChn->hRegister, BCHP_DS_EQ_CPLI, ulNrmLo);
860
861	return;
862	}
863	/****************************************************************************************
864	*BADS_P_Set_CPL_Sweep() sets the phase loop sweep
865	DS_EQ_CPLSWP = (Sweep Rate in Hz/sec) 2^26 / (BaudRate * BaudRate)
866	****************************************************************************************/
867	void BADS_P_Set_CPL_Sweep(BADS_3x7x_ChannelHandle hChn, uint32_t Symbol_Rate, int32_t CPL_Sweep_Rate)
868	{
869	/Local Variables/
870	bool IsNegative = false;
871	uint32_t ReadReg;
872	uint32_t Symbol_Rate_Div1024;
873	uint32_t ulMultA, ulMultB, ulNrmHi, ulNrmLo, ulDivisor;
874
875	/Check to make sure symbol rate is in range/
876	if ((Symbol_Rate < 500000) \|\| (Symbol_Rate >= F_1S/4))
877	{
878	BDBG_ERR(("SymbolRate out of range in BADS_P_Set_CPL_Sweep()"));
879	}
880
881	if (CPL_Sweep_Rate == 0)
882	{
883	/Turn Off Sweep/
884	BREG_Write32(hChn->hRegister, BCHP_DS_EQ_CPLSWP, 0);
885	}
886	else
887	{
888	/Detect if TL_Sweep_Rate is negative/
889	if (CPL_Sweep_Rate < 0)
890	{
891	IsNegative = true;
892	CPL_Sweep_Rate = (CPL_Sweep_Rate == (int32_t)0x80000000) ? -1 * (CPL_Sweep_Rate + 1) : -1 * CPL_Sweep_Rate;
893	}
894
895	ReadReg = (uint32_t)CPL_Sweep_Rate;
896
897	/Divide by 1024 to keep in range/
898	Symbol_Rate_Div1024 = Symbol_Rate/1024;
899
900	ulMultA = ReadReg;
901	ulMultB = POWER2_26;
902	ulDivisor = Symbol_Rate_Div1024*Symbol_Rate_Div1024;
903	if (ulDivisor == 0)
904	{
905	BDBG_ERR(("divide by 0 in BADS_P_Set_CPL_Sweep() while BADS_P_Set_CPL_Sweep VIDTimingSweep"));
906	}
907	BMTH_HILO_32TO64_Mul(ulMultA, ulMultB, &ulNrmHi, &ulNrmLo);
908	BMTH_HILO_64TO64_Div32(ulNrmHi, ulNrmLo, ulDivisor, &ulNrmHi, &ulNrmLo);
909	if ((ulNrmHi != 0) \|\| (ulNrmLo > 0x7FFFFFFF))
910	{
911	BDBG_WRN(("64to32 division is not in a 31 bit unsigned int range"));
912	}
913
914	/Check to make sure sweep will fit in a 12 bit range/
915	if (ulNrmLo > 0x00000FFF)
916	{
917	ulNrmLo = 0x00000FFF;
918	BDBG_WRN(("Sweep out of range in BADS_P_Set_CPL_Sweep(), clamping value"));
919	}
920
921	/If result should be negative, take twos complement of output/
922	ulNrmLo = (IsNegative == true) ? Twos_Complement32(ulNrmLo) : ulNrmLo;
923
924	/Mask to 12 bits/
925	ulNrmLo = ulNrmLo & 0x00000FFF;
926
927	/Write Sweep Value which Turns On Sweep/
928	BREG_Write32(hChn->hRegister, BCHP_DS_EQ_CPLSWP, ulNrmLo);
929	}
930
931	return;
932	}
933
934	/****************************************************************************************
935	*BADS_P_Get_CFL_Frequency() determines the Frequency in the front mixer
936	IF = FhsCFLFOS/2^16
937	****************************************************************************************/
938	int32_t BADS_P_Get_CFL_Frequency(BADS_3x7x_ChannelHandle hChn)
939	{
940	/Local Variables/
941	bool RegIsNegative = false;
942	uint32_t ReadReg;
943	uint32_t CFL_Frequency;
944	uint32_t ulMultA, ulMultB, ulNrmHi, ulNrmLo, ulDivisor;
945
946	ReadReg = BREG_ReadField(hChn->hRegister, DS_CFLFOS, CFLOFFSET);
947
948	/This is a 16 bit 2's complement register, if negative, clamp, sign extend and twos complement/
949	if ((ReadReg & 0x00008000) != 0)
950	{
951	RegIsNegative = true;
952	ReadReg = ReadReg \| 0xFFFF8000; /sign extend/
953	ReadReg = (ReadReg == 0xFFFF8000) ? Twos_Complement32(0xFFFF8001) : Twos_Complement32(ReadReg);
954	}
955
956	ulMultA = F_HS;
957	ulMultB = ReadReg;
958	ulDivisor = POWER2_14;
959	BMTH_HILO_32TO64_Mul(ulMultA, ulMultB, &ulNrmHi, &ulNrmLo);
960	BMTH_HILO_64TO64_Div32(ulNrmHi, ulNrmLo, ulDivisor, &ulNrmHi, &ulNrmLo);
961
962	/If result should be negative, take twos complement of output/
963	ulNrmLo = (RegIsNegative == true) ? Twos_Complement32(ulNrmLo) : ulNrmLo;
964
965	CFL_Frequency = (int32_t)ulNrmLo;
966	return CFL_Frequency;
967	}
968
969	/****************************************************************************************
970	*BADS_P_Get_TL_Frequency() determines the symbol rate in the VID
971	BaudRate = TLFOSF1s/2^25
972	****************************************************************************************/
973	uint32_t BADS_P_Get_TL_Frequency(BADS_3x7x_ChannelHandle hChn)
974	{
975
976	/Local Variables/
977	uint32_t ReadReg;
978	uint32_t TL_Frequency;
979	uint32_t ulMultA, ulMultB, ulNrmHi, ulNrmLo, ulDivisor;
980
981	/Get the timing loop NCO value, it is a 24 bit signed value that should be positive/
982	ReadReg = BREG_ReadField(hChn->hRegister, DS_TLFOS, TLOFFSET);
983	if ((ReadReg & 0x00800000) != 0)
984	{
985	BDBG_ERR(("Timing loop FCW is < 0 in BADS_P_Get_TL_Frequency()"));
986	}
987
988	ulMultA = ReadReg;
989	ulMultB = F_1S;
990	ulDivisor = POWER2_25;
991	BMTH_HILO_32TO64_Mul(ulMultA, ulMultB, &ulNrmHi, &ulNrmLo);
992	BMTH_HILO_64TO64_Div32(ulNrmHi, ulNrmLo, ulDivisor, &ulNrmHi, &ulNrmLo);
993
994	TL_Frequency = ulNrmLo;
995
996	return TL_Frequency;
997	}
998
999	/***************************************************************************************
1000	*BADS_P_Get_CFL_Error() determines the Front Loop Frequency Error
1001	IF = FhsCFLI/2^36
1002	***************************************************************************************/
1003	int32_t BADS_P_Get_CFL_Error(BADS_3x7x_ChannelHandle hChn)
1004	{
1005	/Local Variables/
1006	bool RegIsNegative = false;
1007	uint32_t ReadReg;
1008	uint32_t CFL_Error;
1009	uint32_t ulMultA, ulMultB, ulNrmHi, ulNrmLo, ulDivisor;
1010
1011	ReadReg = BREG_ReadField(hChn->hRegister, DS_CFLI, CFLVAL);
1012
1013	/This is a 32 bit 2's complement register, if negative, clamp and twos complement/
1014	if ((ReadReg & 0x80000000) != 0)
1015	{
1016	RegIsNegative = true;
1017	ReadReg = (ReadReg == 0x80000000) ? Twos_Complement32(0x80000001) : Twos_Complement32(ReadReg);
1018	}
1019
1020	ulMultA = ReadReg;
1021	ulMultB = F_HS/8;
1022	ulDivisor = POWER2_31;
1023	BMTH_HILO_32TO64_Mul(ulMultA, ulMultB, &ulNrmHi, &ulNrmLo);
1024	BMTH_HILO_64TO64_Div32(ulNrmHi, ulNrmLo, ulDivisor, &ulNrmHi, &ulNrmLo);
1025
1026	/If result should be negative, take twos complement of output/
1027	ulNrmLo = (RegIsNegative == true) ? Twos_Complement32(ulNrmLo) : ulNrmLo;
1028
1029	CFL_Error = (int32_t)ulNrmLo;
1030	return CFL_Error;
1031	}
1032
1033	/****************************************************************************************
1034	*BADS_P_Get_VID_Error() determines the VID Timing Error
1035	*For QAM (with loop filter output gain set to 1.0) the offset in Hertz is:
1036	* (1/8)(TLI/2^31)F1s in Hertz
1037	*For QAM (with loop filter output gain set to 2^-6) the offset in Hertz is:
1038	* (1/512)(TLI/2^31)F1s in Hertz
1039	****************************************************************************************/
1040	int32_t BADS_P_Get_VID_Error(BADS_3x7x_ChannelHandle hChn)
1041	{
1042	/Local Variables/
1043	bool RegIsNegative = false;
1044	uint32_t ReadReg, TL_Gain;
1045	uint32_t VID_Error;
1046	uint32_t ulMultA, ulMultB, ulNrmHi, ulNrmLo, ulDivisor;
1047
1048	TL_Gain = BREG_ReadField(hChn->hRegister, DS_TLC, TLLFOUTGAIN);
1049	ReadReg = BREG_ReadField(hChn->hRegister, DS_TLI, TLVAL);
1050
1051
1052	/This is a 32 bit 2's complement register, if negative, clamp and twos complement/
1053	if ((ReadReg & 0x80000000) != 0)
1054	{
1055	RegIsNegative = true;
1056	ReadReg = (ReadReg == 0x80000000) ? Twos_Complement32(0x80000001) : Twos_Complement32(ReadReg);
1057	}
1058
1059	ulMultA = ReadReg;
1060	ulMultB = F_1S;
1061	ulDivisor = POWER2_31;
1062	BMTH_HILO_32TO64_Mul(ulMultA, ulMultB, &ulNrmHi, &ulNrmLo);
1063	BMTH_HILO_64TO64_Div32(ulNrmHi, ulNrmLo, ulDivisor, &ulNrmHi, &ulNrmLo);
1064
1065	/loop filter output gain set to 1 or 2^-6/
1066	ulNrmLo = (TL_Gain == 0) ? ulNrmLo/8 : ulNrmLo/512;
1067
1068	/If result should be negative, take twos complement of output/
1069	ulNrmLo = (RegIsNegative == true) ? Twos_Complement32(ulNrmLo) : ulNrmLo;
1070
1071	VID_Error = (int32_t)ulNrmLo;
1072
1073	return VID_Error;
1074	}
1075
1076	/****************************************************************************************
1077	*BADS_P_Get_CPL_Error() determines the Phase Loop Frequency Error
1078	phase error is SymbolRateCPLI/2^30
1079	****************************************************************************************/
1080	int32_t BADS_P_Get_CPL_Error(BADS_3x7x_ChannelHandle hChn, uint32_t Symbol_Rate)
1081	{
1082	/Local Variables/
1083	bool RegIsNegative = false;
1084	uint32_t ReadReg;
1085	uint32_t CPL_Error;
1086	uint32_t ulMultA, ulMultB, ulNrmHi, ulNrmLo, ulDivisor;
1087
1088	/Check to make sure symbol rate is in range/
1089	if ((Symbol_Rate < 500000) \|\| (Symbol_Rate >= F_1S/4))
1090	{
1091	BDBG_ERR(("SymbolRate out of range in BADS_P_Get_CPL_Error()"));
1092	}
1093
1094	ReadReg = BREG_ReadField(hChn->hRegister, DS_EQ_CPLI, CPLI);
1095
1096	/This is a 30 bit 2's complement register, if negative, clamp, sign extend and twos complement/
1097	if ((ReadReg & 0x20000000) != 0)
1098	{
1099	RegIsNegative = true;
1100	ReadReg = ReadReg \| 0xC0000000; /sign extend/
1101	ReadReg = (ReadReg == 0xE0000000) ? Twos_Complement32(0xE0000001) : Twos_Complement32(ReadReg);
1102	}
1103
1104	ulMultA = ReadReg;
1105	ulMultB = Symbol_Rate;
1106	ulDivisor = POWER2_30;
1107	BMTH_HILO_32TO64_Mul(ulMultA, ulMultB, &ulNrmHi, &ulNrmLo);
1108	BMTH_HILO_64TO64_Div32(ulNrmHi, ulNrmLo, ulDivisor, &ulNrmHi, &ulNrmLo);
1109
1110	/If result should be negative, take twos complement of output/
1111	ulNrmLo = (RegIsNegative == true) ? Twos_Complement32(ulNrmLo) : ulNrmLo;
1112
1113	CPL_Error = (int32_t)ulNrmLo;
1114	return CPL_Error;
1115	}
1116
1117	/********************************************************************************************
1118	* Read Constellation
1119	********************************************************************************************/
1120	BERR_Code BADS_P_Read_Constellation(
1121	BADS_3x7x_ChannelHandle hChn, /* [in] Device channel handle */
1122	int16_t nbrToGet, /* [in] Number values to get */
1123	int16_t iVal, / [out] Ptr to array to store output I soft decision */
1124	int16_t qVal, / [out] Ptr to array to store output Q soft decision */
1125	int16_t nbrGotten / [out] Number of values gotten/read */
1126	)
1127	{
1128	BERR_Code retCode = BERR_SUCCESS;
1129	uint8_t i;
1130	int32_t ReadReg;
1131
1132	for (i = 0; i < nbrToGet ; i++)
1133	{
1134	ReadReg = BREG_Read32(hChn->hRegister, BCHP_DS_EQ_SOFT);
1135	iVal[i] = ((ReadReg & 0xffff0000) >> 16) ;
1136	qVal[i] = (ReadReg & 0x0000ffff);
1137	}
1138	*nbrGotten = nbrToGet;
1139	return retCode;
1140	}
1141	/********************************************************************************************
1142	*HAB called function to Read DS Integrators
1143	********************************************************************************************/
1144	BERR_Code BADS_P_HAB_Read_Integrators(BADS_3x7x_ChannelHandle hChn, uint8_t *HAB_Buffer, uint8_t Size_HAB)
1145	{
1146	BERR_Code retCode = BERR_SUCCESS;
1147	uint8_t i;
1148	uint32_t ReadReg[12];
1149
1150	if (Size_HAB != 48)
1151	{
1152	BDBG_ERR(("ERROR!!! Incorrect HAB Size in BWFE_P_HAB_Read_Integrators()"));
1153	retCode = BERR_INVALID_PARAMETER;
1154	/goto bottom of function to return error code/
1155	goto something_bad_happened;
1156	}
1157
1158	/Get Integrator Values and store as 32 bit sign extended/
1159	/all registers are 32 bit signed unless noted/
1160	ReadReg[0] = BREG_Read32(hChn->hRegister, BCHP_DS_AGCBI);
1161	ReadReg[1] = BREG_Read32(hChn->hRegister,BCHP_DS_AGCBLI);
1162	ReadReg[1] = ((ReadReg[1] & 0x00008000) !=0) ? (ReadReg[1] \| 0xFFFF0000) : ReadReg[1]; /this is a 16 bit signed/
1163	ReadReg[2] = BREG_Read32(hChn->hRegister,BCHP_DS_CFLI);
1164	ReadReg[3] = BREG_Read32(hChn->hRegister,BCHP_DS_TLI);
1165	ReadReg[4] = BREG_Read32(hChn->hRegister,BCHP_DS_TLAGCI);
1166	ReadReg[4] = ((ReadReg[4] & 0x04000000) !=0) ? (ReadReg[4] \| 0xF8000000) : ReadReg[4]; /this is a 27 bit signed/
1167	ReadReg[5] = BREG_Read32(hChn->hRegister,BCHP_DS_TLAGCL);
1168	ReadReg[5] = ((ReadReg[5] & 0x00080000) !=0) ? (ReadReg[5] \| 0xFFF00000) : ReadReg[5]; /this is a 20 bit signed/
1169	ReadReg[6] = BREG_Read32(hChn->hRegister,BCHP_DS_EQ_CPLI);
1170	ReadReg[6] = ((ReadReg[6] & 0x20000000) !=0) ? (ReadReg[6] \| 0xC0000000) : ReadReg[6]; /this is a 30 bit signed/
1171	ReadReg[7] = BREG_Read32(hChn->hRegister,BCHP_DS_EQ_AGCI);
1172	ReadReg[8] = BREG_Read32(hChn->hRegister,BCHP_DS_EQ_CWC_INT1);
1173	ReadReg[9] = BREG_Read32(hChn->hRegister,BCHP_DS_EQ_CWC_INT2);
1174	ReadReg[10] = BREG_Read32(hChn->hRegister,BCHP_DS_EQ_CWC_INT3);
1175	ReadReg[11] = BREG_Read32(hChn->hRegister,BCHP_DS_EQ_CWC_INT4);
1176
1177	/Copy chip data into HAB_Temp_Buffer/
1178	for (i=0;i<12;i++)
1179	{
1180	*HAB_Buffer = (uint8_t)((ReadReg[i] & 0xFF000000) >> 24);
1181	HAB_Buffer++;
1182	*HAB_Buffer = (uint8_t)((ReadReg[i] & 0x00FF0000)>>16);
1183	HAB_Buffer++;
1184	*HAB_Buffer = (uint8_t)((ReadReg[i] & 0x0000FF00) >> 8);
1185	HAB_Buffer++;
1186	*HAB_Buffer = (uint8_t)(ReadReg[i] & 0x000000FF);
1187	HAB_Buffer++;
1188	}
1189
1190	/goto label to return error code if something bad happened above/
1191	something_bad_happened:
1192	return retCode;
1193	}
1194
1195	/********************************************************************************************/
1196	/HAB called function to Read DS FFE or DFE /
1197	/********************************************************************************************/
1198	BERR_Code BADS_P_HAB_Read_FFEDFE(BADS_3x7x_ChannelHandle hChn, uint8_t *HAB_Buffer, uint8_t Size_HAB, uint8_t FFE)
1199	{
1200	BERR_Code retCode = BERR_SUCCESS;
1201	uint8_t i, CWC_Length;
1202	uint32_t Temp;
1203	uint32_t ReadReg;
1204
1205	if ((Size_HAB != 36*4 + 1) \|\| (FFE>1))
1206	{
1207	BDBG_ERR(("ERROR!!! Incorrect HAB Size or FFE/DFE flag in BWFE_P_HAB_Read_FFE()"));
1208	retCode = BERR_INVALID_PARAMETER;
1209	/goto bottom of function to return error code/
1210	goto something_bad_happened;
1211	}
1212	/Assign Base Address to FFE or DFE/
1213	Temp = (FFE == 1) ? BCHP_DS_EQ_FFEU0 : BCHP_DS_EQ_DFEU0;
1214
1215	/Copy chip data into HAB_Temp_Buffer, read FFE/
1216	for (i=0;i<36;i++)
1217	{
1218	ReadReg = BREG_Read32(hChn->hRegister, Temp+(i*8));
1219	/Zero out FFE taps if CWC is used, they share taps/
1220	CWC_Length = BREG_ReadField(hChn->hRegister, DS_EQ_CWC, LENGTH);
1221	if (((CWC_Length == 4) && (i>31)) \|\| ((CWC_Length == 3) && (i>32)) \|\| ((CWC_Length == 2) && (i>33)) \|\| ((CWC_Length == 1) && (i>34)))
1222	{
1223	ReadReg = 0;
1224	}
1225	*HAB_Buffer = (uint8_t)((ReadReg & 0xFF000000) >> 24);
1226	HAB_Buffer++;
1227	*HAB_Buffer = (uint8_t)((ReadReg & 0x00FF0000)>>16);
1228	HAB_Buffer++;
1229	*HAB_Buffer = (uint8_t)((ReadReg & 0x0000FF00) >> 8);
1230	HAB_Buffer++;
1231	*HAB_Buffer = (uint8_t)(ReadReg & 0x000000FF);
1232	HAB_Buffer++;
1233	}
1234
1235	/Copy main Tap Location to end/
1236	ReadReg = BREG_ReadField(hChn->hRegister, DS_EQ_FFE, MAIN);
1237	*HAB_Buffer = (uint8_t)ReadReg;
1238
1239
1240	/goto label to return error code if something bad happened above/
1241	something_bad_happened:
1242	return retCode;
1243	}
1244
1245	/********************************************************************************************/
1246	/HAB called function to Read DS CWC /
1247	/********************************************************************************************/
1248	BERR_Code BADS_P_HAB_Read_CWC(BADS_3x7x_ChannelHandle hChn, uint8_t *HAB_Buffer, uint8_t Size_HAB)
1249	{
1250	BERR_Code retCode = BERR_SUCCESS;
1251	uint8_t i;
1252	uint32_t Temp, CWC_Length;
1253	uint32_t ReadReg;
1254
1255	if (Size_HAB != 16*4 + 1)
1256	{
1257	BDBG_ERR(("ERROR!!! Incorrect HAB Size in BADS_P_HAB_Read_CWC()"));
1258	retCode = BERR_INVALID_PARAMETER;
1259	/goto bottom of function to return error code/
1260	goto something_bad_happened;
1261	}
1262
1263	/Read DS_EQ_CWC LENGTH/
1264	ReadReg = BREG_ReadField(hChn->hRegister, DS_EQ_CWC, LENGTH);
1265	*HAB_Buffer = (uint8_t)ReadReg;
1266	HAB_Buffer++;
1267	/Read DS_EQ_FFE_FIN1, DS_EQ_CWC_FIN2, DS_EQ_CWC_FIN3, DS_EQ_CWC_FIN4/
1268	Temp = BCHP_DS_EQ_FFEU32;
1269	for (i=0;i<4;i++)
1270	{
1271	ReadReg = BREG_Read32(hChn->hRegister, Temp+(i*8));
1272	/Zero out unused FFE taps/
1273	CWC_Length = BREG_ReadField(hChn->hRegister, DS_EQ_CWC, LENGTH);
1274	if (((CWC_Length == 3) && (i>2)) \|\| ((CWC_Length == 2) && (i>1)) \|\| ((CWC_Length == 1) && (i>0)))
1275	{
1276	ReadReg = 0;
1277	}
1278	*HAB_Buffer = (uint8_t)((ReadReg & 0xFF000000) >> 24);
1279	HAB_Buffer++;
1280	*HAB_Buffer = (uint8_t)((ReadReg & 0x00FF0000)>>16);
1281	HAB_Buffer++;
1282	*HAB_Buffer = (uint8_t)((ReadReg & 0x0000FF00) >> 8);
1283	HAB_Buffer++;
1284	*HAB_Buffer = (uint8_t)(ReadReg & 0x000000FF);
1285	HAB_Buffer++;
1286	}
1287	/Read DS_EQ_CWC_FIN1, DS_EQ_CWC_FIN2, DS_EQ_CWC_FIN3, DS_EQ_CWC_FIN4/
1288	for (i=0;i<4;i++)
1289	{
1290	Temp = BCHP_DS_EQ_CWC_FIN1;
1291	ReadReg = BREG_Read32(hChn->hRegister, Temp+(i*4));
1292	if ((ReadReg & 0x00800000) != 0) /sign extend 24 bit number/
1293	{
1294	ReadReg = (ReadReg \| 0xFF000000);
1295	}
1296	*HAB_Buffer = (uint8_t)((ReadReg & 0xFF000000) >> 24);
1297	HAB_Buffer++;
1298	*HAB_Buffer = (uint8_t)((ReadReg & 0x00FF0000)>>16);
1299	HAB_Buffer++;
1300	*HAB_Buffer = (uint8_t)((ReadReg & 0x0000FF00) >> 8);
1301	HAB_Buffer++;
1302	*HAB_Buffer = (uint8_t)(ReadReg & 0x000000FF);
1303	HAB_Buffer++;
1304	}
1305	/Read DS_EQ_CWC_FOFS1, DS_EQ_CWC_FOFS2, DS_EQ_CWC_FOFS3, DS_EQ_CWC_FOFS4/
1306	for (i=0;i<4;i++)
1307	{
1308	Temp = BCHP_DS_EQ_CWC_FOFS1;
1309	ReadReg = BREG_Read32(hChn->hRegister, Temp+(i*4));
1310	if ((ReadReg & 0x10000000) != 0) /sign extend 29 bit number/
1311	{
1312	ReadReg = (ReadReg \| 0xE0000000);
1313	}
1314	*HAB_Buffer = (uint8_t)((ReadReg & 0xFF000000) >> 24);
1315	HAB_Buffer++;
1316	*HAB_Buffer = (uint8_t)((ReadReg & 0x00FF0000)>>16);
1317	HAB_Buffer++;
1318	*HAB_Buffer = (uint8_t)((ReadReg & 0x0000FF00) >> 8);
1319	HAB_Buffer++;
1320	*HAB_Buffer = (uint8_t)(ReadReg & 0x000000FF);
1321	HAB_Buffer++;
1322	}
1323	/Read DS_EQ_CWC_INT1, DS_EQ_CWC_INT2, DS_EQ_CWC_INT3, DS_EQ_CWC_INT4/
1324	{
1325	Temp = BCHP_DS_EQ_CWC_INT1;
1326	ReadReg = BREG_Read32(hChn->hRegister, Temp+(i*4));
1327	*HAB_Buffer = (uint8_t)((ReadReg & 0xFF000000) >> 24);
1328	HAB_Buffer++;
1329	*HAB_Buffer = (uint8_t)((ReadReg & 0x00FF0000)>>16);
1330	HAB_Buffer++;
1331	*HAB_Buffer = (uint8_t)((ReadReg & 0x0000FF00) >> 8);
1332	HAB_Buffer++;
1333	*HAB_Buffer = (uint8_t)(ReadReg & 0x000000FF);
1334	HAB_Buffer++;
1335	}
1336
1337	/goto label to return error code if something bad happened above/
1338	something_bad_happened:
1339	return retCode;
1340	}
1341	/*******************************************************************************************
1342	* BADS_SetDPM() This routine sets the DPM for the tuner
1343	*This is a function called by the tuner PI
1344	*******************************************************************************************/
1345	BERR_Code BADS_P_SetDPM(BADS_3x7x_ChannelHandle hChn, uint8_t I_OUTDIV_M6)
1346	{
1347	BERR_Code retCode = BERR_SUCCESS;
1348	BSTD_UNUSED(hChn);
1349	BSTD_UNUSED(I_OUTDIV_M6);
1350	/This must be different in 3128/
1351
1352	return retCode;
1353	}
1354
1355	/*******************************************************************************************
1356	* BADS_ResetDPM() This routine resets the DPM integrator for the tuner
1357	*This is a function called by the tuner PI
1358	*******************************************************************************************/
1359	BERR_Code BADS_P_ResetDPM(BADS_3x7x_ChannelHandle hChn)
1360	{
1361	BERR_Code retCode = BERR_SUCCESS;
1362
1363	/This must be different in 3128/
1364	BSTD_UNUSED(hChn);
1365	return retCode;
1366	}
1367
1368	#if (BCHP_FAMILY == 3128)
1369	/*******************************************************************************************
1370	* BADS_Enable_LFSR() This routine enables LFSR receiver in DS
1371	*******************************************************************************************/
1372	BERR_Code BADS_Enable_LFSR(BADS_3x7x_ChannelHandle hChn)
1373	{
1374	BERR_Code retCode;
1375
1376	/* Enable LFSR receivers in DS, pre and post FIFO */
1377	BREG_WriteField(0, DS_TOPS_CNTL, LFSR_ENABLE , 1); // bit 31
1378	BREG_WriteField(0, DS_TOPM_FE_CTL, LFSR_ENABLE_FE , 1); // bit 31
1379
1380	retCode = BERR_SUCCESS;
1381	return retCode;
1382	}
1383
1384	/*******************************************************************************************
1385	* BADS_Check_LFSR() This routine checks LFSR receiver status in DS
1386	*******************************************************************************************/
1387	BERR_Code BADS_Check_LFSR(BADS_3x7x_ChannelHandle hChn)
1388	{
1389	BERR_Code retCode;
1390
1391	/* Read status, expect to see no fail */
1392	BDBG_DBG(("LFSR A %d%d\n", BREG_ReadField(0, DS_TOPM_STATUS, LFSR_COMP_FAIL_FE), BREG_ReadField(0, DS_TOPM_STATUS, LFSR_COMP_FAIL))); // bit [1:0]
1393	// BDBG_DBG(("LFSR B %d%d\n", BREG_ReadField(hChn->hRegister, DS_B_TOPM_STATUS, LFSR_COMP_FAIL_FE), BREG_ReadField(hChn->hRegister, DS_TOPM_STATUS, LFSR_COMP_FAIL))); // bit [1:0]
1394
1395	retCode = BERR_SUCCESS;
1396	return retCode;
1397	}
1398	#endif

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

Context Navigation

source: svn/trunk/newcon3bcm2_21bu/magnum/portinginterface/ads/7552/bads_utils.c

Download in other formats: