Context Navigation

bads_api.c

Last change on this file was 2, checked in by jglee, 11 years ago
first commit
Property svn:executable set to ``*
File size: 60.4 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_api.c $
39	* $brcm_Revision: Hydra_Software_Devel/22 $
40	* $brcm_Date: 3/29/12 8:45p $
41	*
42	* Module Description:
43	*
44	* Revision History:
45	*
46	* $brcm_Log: /magnum/portinginterface/ads/7552/bads_api.c $
47	*
48	* Hydra_Software_Devel/22 3/29/12 8:45p farshidf
49	* SW7552-239: fix the ADS power setting
50	*
51	* Hydra_Software_Devel/21 3/9/12 11:40a farshidf
52	* SW7552-209: fix the scan mode
53	*
54	* Hydra_Software_Devel/20 3/8/12 2:51p farshidf
55	* SW7552-209: fix No signal
56	*
57	* Hydra_Software_Devel/19 3/8/12 12:22p farshidf
58	* SW7552-209: add no signal
59	*
60	* Hydra_Software_Devel/18 3/7/12 11:37a farshidf
61	* SW7552-183: the problem of how to get the signal quality from nexus
62	*
63	* Hydra_Software_Devel/17 3/5/12 5:31p atanugul
64	* SW3128-130: change the resolution for equalizerGain units to 1/100th of
65	* dB
66	*
67	* Hydra_Software_Devel/16 3/2/12 2:42p farshidf
68	* SW7552-183: fix the status
69	*
70	* Hydra_Software_Devel/15 2/15/12 6:21p farshidf
71	* SW7552-209: compile fix
72	*
73	* Hydra_Software_Devel/14 2/15/12 5:59p farshidf
74	* SW7552-205: add the extra reset before acquire
75	*
76	* Hydra_Software_Devel/13 12/22/11 4:50p farshidf
77	* SW7552-170: add scanstatus calls
78	*
79	* Hydra_Software_Devel/12 12/21/11 3:00p farshidf
80	* SW7574-56: remove the hardcoded value
81	*
82	* Hydra_Software_Devel/10 11/16/11 6:05p atanugul
83	* SW3461-79: Add No Signal to GetLockStatus()
84	*
85	* Hydra_Software_Devel/9 11/8/11 5:32p farshidf
86	* SW7552-133: add dsChannelPower
87	*
88	* Hydra_Software_Devel/8 11/4/11 5:06p farshidf
89	* SW7552-61: init more var
90	*
91	* Hydra_Software_Devel/7 11/1/11 5:09p farshidf
92	* SW7552-61: add the extra lock change for scan at the before each
93	* acquire
94	*
95	* Hydra_Software_Devel/6 10/31/11 2:22p farshidf
96	* SW7552-134: compile fix
97	*
98	* Hydra_Software_Devel/6 10/31/11 2:11p farshidf
99	* SW7552-134: compile fix
100	*
101	* Hydra_Software_Devel/5 10/31/11 11:49a farshidf
102	* CDFEDEMOD-25: Reset the DS core and Fifo top level reset at Ds power
103	* up.
104	*
105	* Hydra_Software_Devel/4 10/24/11 2:48p farshidf
106	* SW7552-134: update the FIFO FE reset doen at power up only
107	*
108	* Hydra_Software_Devel/3 10/10/11 4:05p farshidf
109	* SW7552-134: compile fix
110	*
111	* Hydra_Software_Devel/2 10/10/11 3:43p farshidf
112	* SW7552-134: compile fix
113	*
114	* Hydra_Software_Devel/1 10/10/11 2:06p farshidf
115	* SW7552-134: sync up to V2_0 of 3461
116	*
117	* Hydra_Software_Devel/44 10/10/11 1:51p farshidf
118	* SW7552-134: update to match V2_0 of 3461
119	*
120	* Hydra_Software_Devel/43 8/22/11 11:08a farshidf
121	* SWDTV-7671: update power call according to Adam
122	*
123	* Hydra_Software_Devel/42 8/16/11 4:31p farshidf
124	* SW7552-105: update the frontend with 3461_V1_0_RC0 label
125	*
126	* Hydra_Software_Devel/41 8/16/11 4:23p farshidf
127	* SW7552-105: rebase ro 3461_V1_0_RC0 label
128	*
129	* Hydra_Software_Devel/40 7/28/11 4:11p farshidf
130	* SWDTV-8113: update the close
131	*
132	* Hydra_Software_Devel/39 7/27/11 5:45p farshidf
133	* SWDTV-8113: clean up
134	*
135	* Hydra_Software_Devel/38 7/20/11 2:14p farshidf
136	* SW7552-60: stop timer before acquire
137	*
138	* Hydra_Software_Devel/37 7/18/11 4:22p farshidf
139	* SWDTV-7869: compile fix
140	*
141	* Hydra_Software_Devel/36 7/18/11 3:53p farshidf
142	* SWDTV-7869: compile fix
143	*
144	* Hydra_Software_Devel/35 7/15/11 5:47p farshidf
145	* SWDTV-7869: add the 35126Bo changes
146	*
147	* Hydra_Software_Devel/34 7/15/11 10:27a farshidf
148	* SWDTV-7671: correction
149	*
150	* Hydra_Software_Devel/33 7/15/11 9:47a farshidf
151	* SWDTV-7671: add new header file and move back the resource free
152	*
153	* Hydra_Software_Devel/32 7/14/11 4:42p farshidf
154	* SW3128-28: update to fix the FFt IRQ
155	*
156	* Hydra_Software_Devel/31 7/13/11 5:30p farshidf
157	* SWDTV-7671: fix the Power Management 2.0 code
158	*
159	* Hydra_Software_Devel/30 7/12/11 4:39p farshidf
160	* SWDTV-7671: merge
161	*
162	* Hydra_Software_Devel/SWDTV-7327/2 7/11/11 10:52a farshidf
163	* SWDTV-7671: add the power managment 2.0 for DS
164	*
165	* Hydra_Software_Devel/SWDTV-7327/1 6/2/11 5:43p shyi
166	* SWDTV-7237: Added unit conversion from Hz to 256Hz for carrier range
167	*
168	* Hydra_Software_Devel/28 6/3/11 5:39p farshidf
169	* SW7552-36: update header file
170	*
171	* Hydra_Software_Devel/27 6/1/11 11:43a farshidf
172	* SW7552-36: clean up the code
173	*
174	* Hydra_Software_Devel/26 5/31/11 3:54p farshidf
175	* SW7552-36: add disable power saver
176	*
177	* Hydra_Software_Devel/25 5/31/11 2:06p farshidf
178	* SW7552-36: fix the timer
179	*
180	* Hydra_Software_Devel/24 5/27/11 1:57p vishk
181	* SW7231-180: Remove duplicate member variables in bads.h and convert
182	* BADS_AutomaticFrequencyOffset and NEXUS_FrontendQamFrequencyOffset
183	* enum types to unsigned integer.
184	*
185	* Hydra_Software_Devel/23 5/27/11 10:50a farshidf
186	* SW7552-36: compiel fix
187	*
188	* Hydra_Software_Devel/22 5/26/11 5:19p vishk
189	* SWDTV-7035: adapt to latest bads.h file
190	*
191	* Hydra_Software_Devel/21 5/16/11 4:26p farshidf
192	* SWDTV-7035: adapt to latest bads.h file
193	*
194	* Hydra_Software_Devel/20 5/16/11 12:51p farshidf
195	* SWDTV-7035:merg main
196	*
197	* Hydra_Software_Devel/SWDTV-7035/5 5/16/11 12:50p farshidf
198	* SWDTV-7035: update naming convention
199	*
200	* Hydra_Software_Devel/19 5/10/11 11:07p farshidf
201	* SWDTV-7035: merge main
202	*
203	* Hydra_Software_Devel/SWDTV-7035/3 5/10/11 6:30p cbrooks
204	* SWDTV-7035:Fixed MIPS timer
205	*
206	* Hydra_Software_Devel/SWDTV-7035/2 5/10/11 5:51p farshidf
207	* SWDTV-7035: put back Nexus status
208	*
209	* Hydra_Software_Devel/SWDTV-7035/1 5/10/11 11:54a farshidf
210	* SWDTV-7035: update the naming
211	*
212	* Hydra_Software_Devel/18 5/9/11 6:42p farshidf
213	* SWDTV-6857: fix teh BBS lock info
214	*
215	* Hydra_Software_Devel/17 5/9/11 5:16p farshidf
216	* SWDTV-6857: fix compil issue
217	*
218	* Hydra_Software_Devel/16 5/9/11 5:09p farshidf
219	* SWDTV-6857: remove teh Nexus line check
220	*
221	* Hydra_Software_Devel/15 5/6/11 5:09p farshidf
222	* SWDTV-6857: update Nexus Status
223	*
224	* Hydra_Software_Devel/14 5/6/11 4:26p farshidf
225	* SWDTV-6857: waring fix
226	*
227	* Hydra_Software_Devel/13 5/6/11 3:50p farshidf
228	* SWDTV-6857: fix some of the status to Nexus
229	*
230	* Hydra_Software_Devel/12 5/6/11 2:04p farshidf
231	* SWDTV-6587: add scan structure and calls
232	*
233	* Hydra_Software_Devel/11 5/6/11 9:07a farshidf
234	* SWDTV-6857: merge main
235	*
236	* Hydra_Software_Devel/SWDTV-6857/1 5/5/11 9:18p cbrooks
237	* SWDTV-6857:Cleaned up Code
238	*
239	* Hydra_Software_Devel/10 4/28/11 9:08p farshidf
240	* SWDTV-6190: reset the reac count
241	*
242	* Hydra_Software_Devel/9 4/28/11 8:20p farshidf
243	* SWDTV-6190: fix the lockstatus call
244	*
245	* Hydra_Software_Devel/8 4/28/11 11:42a farshidf
246	* SWDTV-6190: fix the channel handle
247	*
248	* Hydra_Software_Devel/7 4/27/11 11:47p farshidf
249	* SWDTV-6190: move the L3 interrupt processing inside the PI
250	*
251	* Hydra_Software_Devel/6 4/27/11 3:42p farshidf
252	* SWDTV-6190: bug fix
253	*
254	* Hydra_Software_Devel/5 4/27/11 12:01a farshidf
255	* SWDTV-6190: fix compile
256	*
257	* Hydra_Software_Devel/4 4/26/11 4:09p farshidf
258	* SWDTV-6191: update the param
259	*
260	* Hydra_Software_Devel/3 4/26/11 2:26p farshidf
261	* SWDTV-6191: fix the DS compile
262	*
263	* Hydra_Software_Devel/2 4/25/11 6:22p farshidf
264	* SWDTV-6191: update the ADS callback
265	*
266	* Hydra_Software_Devel/1 4/20/11 12:40p farshidf
267	* SWDTV-6190: add intial DS files
268	*
269	***************************************************************************/
270	#include "bstd.h"
271	#include "bads.h"
272	#include "bads_priv.h"
273	#include "btmr.h"
274	#include "bmth.h"
275	#include "bkni.h"
276	#include "bads_def.h"
277	#include "bads_api.h"
278	#include "bads_acquire.h"
279	#include "bads_status.h"
280	#include "bads_utils.h"
281	#include "bchp_ds_topm.h"
282	#include "bchp_ds_tops.h"
283	#include "bchp_sun_top_ctrl.h"
284	#include "bchp_int_id_ds.h"
285	#include "bads_global_clk.h"
286	#include "bads_mth.h"
287	#if ((BCHP_CHIP==7552) \|\| (BCHP_CHIP==35230) \|\| (BCHP_CHIP==35233))
288	#include "bchp_int_id_ds_topm.h"
289	#endif
290	#ifdef BCHP_PWR_SUPPORT
291	#include "bchp_pwr_resources.h"
292	#include "bchp_pwr.h"
293	#endif
294
295	BERR_Code BADS_P_ResetDSCore(BADS_3x7x_ChannelHandle hImplChnDev);
296
297	BDBG_MODULE(bads_api);
298
299	/*******************************************************************************
300	* BADS_P_3x7x_Isr
301	*******************************************************************************/
302
303	void BADS_P_3x7x_Isr(void *p, int param)
304	{
305	BADS_3x7x_ChannelHandle pHandle = (BADS_3x7x_ChannelHandle)p;
306	uint32_t RegStatus, RegMaskStatus;
307	BSTD_UNUSED(param);
308
309	RegStatus = BREG_Read32(pHandle->hRegister, BCHP_DS_IRQSTS2);
310	RegMaskStatus = BREG_Read32(pHandle->hRegister, BCHP_DS_IRQMSK2);
311
312
313	if ((RegStatus)& ~(RegMaskStatus))
314	{
315	RegStatus &= ~RegMaskStatus;
316	#if BCHP_DS_CORE_V_9_1
317	if (RegStatus & BCHP_DS_IRQSTS2_FCA_IRQ_MASK)
318	{
319	BREG_Write32(pHandle->hRegister, BCHP_DS_IRQCLR2, BCHP_DS_IRQCLR2_FCA_ICLR_MASK);
320	BKNI_SetEvent(pHandle->hFcaEvent);
321	}
322	else if (RegStatus & BCHP_DS_IRQSTS2_CHSCN_IRQ_MASK)
323	{
324	BREG_Write32(pHandle->hRegister, BCHP_DS_IRQCLR2, BCHP_DS_IRQCLR2_CHSCN_ICLR_MASK);
325	BKNI_SetEvent(pHandle->hChscnEvent);
326	}
327	#elif ((BCHP_DS_CORE_V_9_2) \|\| (BCHP_DS_CORE_V_9_4))
328	if (RegStatus & BCHP_DS_IRQCLR2_FFT_ICLR_MASK)
329	{
330	BKNI_SetEvent(pHandle->hFftEvent);
331	BREG_Write32(pHandle->hRegister, BCHP_DS_IRQCLR2, BCHP_DS_IRQCLR2_FFT_ICLR_MASK);
332	}
333	#endif
334	}
335	}
336
337
338	/*******************************************************************************
339	* BADS_P_TimerFunc
340	*******************************************************************************/
341	BERR_Code BADS_P_TimerFunc(void *myParam1, int myParam2)
342	{
343
344	BERR_Code retCode = BERR_SUCCESS;
345	BADS_3x7x_Handle hImplDev;
346	BADS_3x7x_ChannelHandle h;
347	BSTD_UNUSED(myParam2);
348
349	BDBG_ENTER(BADS_P_TimerFunc);
350	hImplDev = (BADS_3x7x_Handle) myParam1;
351	BDBG_ASSERT( hImplDev );
352	h = (BADS_3x7x_ChannelHandle)(hImplDev->hAdsChn[0]);
353	BDBG_ASSERT( h );
354
355	BKNI_ResetEvent(hImplDev->hIntEvent);
356	BADS_P_ChnLockStatus(h);
357	if ( h->pCallback[BADS_Callback_eLockChange] != NULL )
358	{
359	if (h->pChnLockStatus->FLK == 1)
360	{
361	if (h->pChnAcqParam->BADS_Local_Params.LockUpdate)
362	{
363	h->pChnAcqParam->BADS_Local_Params.LockUpdate = false;
364	(h->pCallback[BADS_Callback_eLockChange])(h->pCallbackParam[BADS_Callback_eLockChange] );
365	}
366	}
367	else
368	{
369	if (h->pChnAcqParam->BADS_Local_Params.lock_status != h->pChnLockStatus->FLK )
370	{
371	h->pChnAcqParam->BADS_Local_Params.LockUpdate = true;
372	(h->pCallback[BADS_Callback_eLockChange])(h->pCallbackParam[BADS_Callback_eLockChange] );
373	h->pChnLockStatus->ReAck_Count = 0;
374	}
375	}
376	}
377	h->pChnAcqParam->BADS_Local_Params.lock_status = h->pChnLockStatus->FLK;
378
379	if (h->pChnAcqParam->BADS_Acquire_Params.NexusStatusMode & BADS_NexusStatusMode_EnableStatusForNexus)
380	{
381	BADS_P_ChnStatus(h);
382	h->pChnAcqParam->BADS_Acquire_Params.NexusStatusMode &= (~BADS_NexusStatusMode_EnableStatusForNexus);
383	}
384
385	if (h->pChnAcqParam->BADS_Acquire_Params.AcquireStartMode & BADS_AcquireStartMode_ResetStatus)
386	{
387	BDBG_WRN(("call reset"));
388	BADS_P_ChnStatusReset(h);
389	h->pChnAcqParam->BADS_Acquire_Params.AcquireStartMode &= (~BADS_AcquireStartMode_ResetStatus);
390	}
391
392	if (h->pChnAcqParam->BADS_Acquire_Params.AcquireStartMode & BADS_AcquireStartMode_Acquire)
393	{
394	h->pChnAcqParam->BADS_Acquire_Params.AcquireStartMode &= ~BADS_AcquireStartMode_Acquire;
395	h->pChnLockStatus->ReAck_Count = 0;
396	BDBG_WRN(("call1 BADS_3x7x_ProcessInterruptEvent"));
397	BKNI_SetEvent(hImplDev->hIntEvent);
398	return BERR_SUCCESS;
399	}
400	else
401	{
402	if (h->pChnAcqParam->BADS_Acquire_Params.AcqType == BADS_Acquire_Params_AcqType_eAuto)
403	{
404	if (h->pChnAcqParam->BADS_Local_Params.lock_status == 0)
405	{
406	BDBG_MSG(("call BADS_3x7x_ProcessInterruptEvent in AUTO mode"));
407	BKNI_SetEvent(hImplDev->hIntEvent);
408	}
409	}
410	}
411
412	BDBG_LEAVE(BADS_P_TimerFunc);
413	return retCode;
414	}
415
416
417	/*******************************************************************************
418	* BADS_3x7x_Open
419	*******************************************************************************/
420	BERR_Code BADS_3x7x_Open(
421	BADS_Handle pAds, / [out] Returns handle */
422	BCHP_Handle hChip, /* [in] Chip handle */
423	BREG_Handle hRegister, /* [in] Register handle */
424	BINT_Handle hInterrupt, /* [in] Interrupt handle */
425	const struct BADS_Settings pDefSettings / [in] Default settings */
426	)
427	{
428
429	BERR_Code retCode = BERR_SUCCESS;
430	BADS_Handle hDev;
431	uint8_t chnIdx;
432	BTMR_Settings sTimerSettings;
433	BADS_3x7x_Handle hImplDev = NULL;;
434	BDBG_ENTER(BADS_3x7x_Open);
435
436	/* Alloc memory from the system heap */
437	hDev = (BADS_Handle) BKNI_Malloc( sizeof( BADS_P_Handle ) );
438
439	if( hDev == NULL )
440	{
441	retCode = BERR_TRACE(BERR_OUT_OF_SYSTEM_MEMORY);
442	BDBG_ERR(("BADS_Open: BKNI_malloc() failed"));
443	goto done;
444	}
445
446	BKNI_Memset( hDev, 0x00, sizeof( BADS_P_Handle ) );
447	hDev->magicId = DEV_MAGIC_ID;
448	BKNI_Memcpy(&hDev->settings, pDefSettings, sizeof(*pDefSettings));
449
450	/* Alloc memory from the system heap */
451	hImplDev = (BADS_3x7x_Handle) BKNI_Malloc( sizeof( BADS_P_3x7x_Handle ) );
452	if( hImplDev == NULL )
453	{
454	retCode = BERR_TRACE(BERR_OUT_OF_SYSTEM_MEMORY);
455	BDBG_ERR(("BADS_Open: BKNI_malloc() failed"));
456	goto done;
457	}
458
459	BKNI_Memset( hImplDev, 0x00, sizeof( BADS_P_3x7x_Handle ) );
460	hImplDev->magicId = DEV_MAGIC_ID;
461	hImplDev->hChip = hChip;
462	hImplDev->mxChnNo = MX_ADS_CHANNELS;
463	hImplDev->hRegister = hRegister;
464	hImplDev->hInterrupt = hInterrupt;
465	#ifdef BCHP_PWR_RESOURCE_DS_TOP
466	BCHP_PWR_AcquireResource(hImplDev->hChip, BCHP_PWR_RESOURCE_DS_TOP);
467	#endif
468
469	BKNI_CreateEvent(&(hImplDev->hIntEvent));
470
471	/* Create timer for status lock check */
472
473	sTimerSettings.type = BTMR_Type_ePeriodic;
474	sTimerSettings.cb_isr = (BTMR_CallbackFunc)BADS_P_TimerFunc;
475	sTimerSettings.pParm1 = (void*)hImplDev;
476	sTimerSettings.parm2 = 0;
477	sTimerSettings.exclusive = false;
478	retCode = BTMR_CreateTimer (hDev->settings.hTmr, &hImplDev->hTimer, &sTimerSettings);
479	if ( retCode != BERR_SUCCESS )
480	{
481	BDBG_ERR(("BTHD_Open: Create Timer Failed"));
482	goto done;
483	}
484
485	sTimerSettings.type = BTMR_Type_eStopWatch;
486	sTimerSettings.cb_isr = 0;
487	sTimerSettings.pParm1 = 0;
488	sTimerSettings.parm2 = 0;
489	sTimerSettings.exclusive = false;
490	retCode = BTMR_CreateTimer (hDev->settings.hTmr, &hImplDev->hStatusTimer, &sTimerSettings);
491	if ( retCode != BERR_SUCCESS )
492	{
493	BDBG_ERR(("BTHD_Open: Create Timer Failed"));
494	goto done;
495	}
496	BTMR_StartTimer(hImplDev->hStatusTimer, POWER2_30/MIPS_TIMER); /* the timer is in Micro second */;
497
498
499	for( chnIdx = 0; chnIdx < MX_ADS_CHANNELS; chnIdx++ )
500	{
501	hImplDev->hAdsChn[chnIdx] = NULL;
502	}
503
504	hDev->pImpl = hImplDev;
505
506	*pAds = hDev;
507	done:
508	#ifdef BCHP_PWR_RESOURCE_DS_TOP
509	BCHP_PWR_ReleaseResource(hImplDev->hChip, BCHP_PWR_RESOURCE_DS_TOP);
510	#endif
511	if( retCode != BERR_SUCCESS )
512	{
513	if( hImplDev != NULL )
514	{
515	BKNI_Free( hImplDev );
516	}
517	if( hDev != NULL )
518	{
519	BKNI_Free( hDev );
520	}
521	*pAds = NULL;
522	}
523
524	return( retCode );
525	}
526
527
528	/*******************************************************************************
529	* BADS_3x7x_Close
530	*******************************************************************************/
531	BERR_Code BADS_3x7x_Close(
532	BADS_Handle hDev /* [in] Device handle */
533	)
534	{
535	BERR_Code retCode = BERR_SUCCESS;
536	BADS_3x7x_Handle hImplDev = (BADS_3x7x_Handle) hDev->pImpl;
537	BDBG_ASSERT( hDev );
538	BDBG_ASSERT( hDev->magicId == DEV_MAGIC_ID );
539
540	BDBG_ENTER(BADS_3x7x_Close);
541	BTMR_DestroyTimer(hImplDev->hTimer);
542	BTMR_DestroyTimer(hImplDev->hStatusTimer);
543	BKNI_DestroyEvent(hImplDev->hIntEvent);
544
545	hDev->magicId = 0x00; /* clear it to catch improper use */
546	BKNI_Free( (void *) hDev->pImpl );
547	BKNI_Free( (void *) hDev );
548
549	BDBG_LEAVE(BADS_3x7x_Close);
550	return( retCode );
551	}
552
553	/*******************************************************************************
554	* BADS_3x7x_Init
555	*******************************************************************************/
556	BERR_Code BADS_3x7x_Init(
557	BADS_Handle hDev /* [in] Device handle */
558	)
559	{
560	BERR_Code retCode = BERR_SUCCESS;
561	BDBG_ENTER(BADS_3x7x_Init);
562	BSTD_UNUSED(hDev);
563	BDBG_LEAVE(BADS_3x7x_Init);
564	return( retCode );
565	}
566
567	/*******************************************************************************
568	* BADS_3x7x_Init
569	*******************************************************************************/
570
571	BERR_Code BADS_3x7x_GetVersion(
572	BADS_Handle hDev, /* [in] Device handle */
573	BADS_Version pVersion / [out] Returns version */
574	)
575	{
576	BERR_Code retCode = BERR_SUCCESS;
577	BADS_3x7x_Handle hImplDev;
578	uint32_t chipVer;
579	BADS_Version Version;
580
581	BDBG_ENTER(BADS_3x7x_GetVersion);
582	BDBG_ASSERT( hDev );
583	BDBG_ASSERT( hDev->magicId == DEV_MAGIC_ID );
584
585	hImplDev = (BADS_3x7x_Handle) hDev->pImpl;
586	BDBG_ASSERT( hImplDev );
587
588	chipVer = BREG_Read32(hImplDev->hRegister, BCHP_SUN_TOP_CTRL_PRODUCT_ID);
589	Version.majVer = chipVer >> 8;
590	Version.minVer = chipVer & 0xFF;
591
592	*pVersion = Version;
593
594	BDBG_LEAVE(BADS_3x7x_GetVersion);
595	return( retCode );
596	}
597
598
599	/*******************************************************************************
600	* BADS_3x7x_GetTotalChannels
601	*******************************************************************************/
602	BERR_Code BADS_3x7x_GetTotalChannels(
603	BADS_Handle hDev, /* [in] Device handle */
604	unsigned int totalChannels / [out] Returns total number downstream channels supported */
605	)
606	{
607	BERR_Code retCode = BERR_SUCCESS;
608	BADS_3x7x_Handle hImplDev;
609
610	BDBG_ENTER(BADS_3x7x_GetTotalChannels);
611	BDBG_ASSERT( hDev );
612	BDBG_ASSERT( hDev->magicId == DEV_MAGIC_ID );
613
614	hImplDev = (BADS_3x7x_Handle) hDev->pImpl;
615	BDBG_ASSERT( hImplDev );
616
617	totalChannels = hImplDev->mxChnNo; / use saved data */
618
619	BDBG_LEAVE(BADS_3x7x_GetTotalChannels);
620	return( retCode );
621	}
622
623
624	/*******************************************************************************
625	* Channel Managment level
626	* BADS_3x7x_OpenChannel
627	*******************************************************************************/
628
629	BERR_Code BADS_3x7x_OpenChannel(
630	BADS_Handle hDev, /* [in] Device handle */
631	BADS_ChannelHandle phChn, / [out] Returns channel handle */
632	unsigned int channelNo, /* [in] Channel number to open */
633	const struct BADS_ChannelSettings pChnDefSettings / [in] Channel default setting */
634	)
635	{
636	BERR_Code retCode = BERR_SUCCESS;
637	BADS_3x7x_Handle hImplDev;
638	BADS_3x7x_ChannelHandle hImplChnDev = NULL;
639	BADS_ChannelHandle hChnDev;
640	uint32_t BufSrc;
641
642	BDBG_ENTER(BADS_3x7x_OpenChannel);
643	BDBG_ASSERT( hDev );
644	BDBG_ASSERT( hDev->magicId == DEV_MAGIC_ID );
645
646	hImplDev = (BADS_3x7x_Handle) hDev->pImpl;
647	BDBG_ASSERT( hImplDev );
648	hChnDev = NULL;
649	if( channelNo < hImplDev->mxChnNo )
650	{
651	if( hImplDev->hAdsChn[channelNo] == NULL )
652	{
653	BDBG_MSG(("BADS_3x7x_OpenChannel"));
654
655	/* Alloc memory from the system heap */
656	hChnDev = (BADS_ChannelHandle) BKNI_Malloc( sizeof( BADS_P_ChannelHandle ) );
657	if( hChnDev == NULL )
658	{
659	retCode = BERR_TRACE(BERR_OUT_OF_SYSTEM_MEMORY);
660	BDBG_ERR(("BADS_OpenChannel: BKNI_malloc() failed"));
661	goto done;
662	}
663
664	BKNI_Memset( hChnDev, 0x00, sizeof( BADS_P_ChannelHandle ) );
665	hChnDev->magicId = DEV_MAGIC_ID;
666	hChnDev->hAds = hDev;
667
668	hImplChnDev = (BADS_3x7x_ChannelHandle) BKNI_Malloc( sizeof( BADS_P_3x7x_ChannelHandle ) );
669	if( hImplChnDev == NULL )
670	{
671	retCode = BERR_TRACE(BERR_OUT_OF_SYSTEM_MEMORY);
672	BDBG_ERR(("BADS_OpenChannel: BKNI_malloc() failed, impl"));
673	goto done;
674	}
675
676	hImplChnDev->chnNo = channelNo;
677	hImplChnDev->hAds = hImplDev;
678	hImplChnDev->magicId = DEV_MAGIC_ID;
679	hImplChnDev->hChnAds = hChnDev;
680	#if BCHP_DS_CORE_V_9_1
681	#if (BCHP_CHIP!=3461)
682	BKNI_CreateEvent(&(hImplChnDev->hChscnEvent));
683	BKNI_CreateEvent(&(hImplChnDev->hFcaEvent));
684	#endif
685	#elif ((BCHP_DS_CORE_V_9_2) \|\| (BCHP_DS_CORE_V_9_4))
686	BKNI_CreateEvent(&(hImplChnDev->hFftEvent));
687	#endif
688
689	BINT_CreateCallback( &(hImplChnDev->hDs2Callback), hImplDev->hInterrupt, BCHP_INT_ID_DS0_2_IS, BADS_P_3x7x_Isr, (void*)hImplChnDev, BADS_DS0_2_EVENT );
690	BINT_EnableCallback(hImplChnDev->hDs2Callback);
691	hImplChnDev->hRegister = hImplDev->hRegister;
692
693	hImplChnDev->pChnStatus = (BADS_3x7x_ChnStatus_t *)BMEM_AllocAligned(hDev->settings.hHeap, sizeof(BADS_3x7x_ChnStatus_t), 0, 0 );
694	if( hImplChnDev->pChnStatus == NULL )
695	{
696	retCode = BERR_TRACE(BERR_OUT_OF_SYSTEM_MEMORY);
697	BDBG_ERR(("BADS_Open: BKNI_malloc() failed"));
698	goto done;
699	}
700
701	hImplChnDev->pChnScanStatus = (BADS_3x7x_ChnScanStatus_t *)BMEM_AllocAligned(hDev->settings.hHeap, sizeof(BADS_3x7x_ChnScanStatus_t), 0, 0 );
702	if( hImplChnDev->pChnScanStatus == NULL )
703	{
704	retCode = BERR_TRACE(BERR_OUT_OF_SYSTEM_MEMORY);
705	BDBG_ERR(("BADS_Open: BKNI_malloc() failed"));
706	goto done;
707	}
708	BMEM_ConvertAddressToOffset(hDev->settings.hHeap, hImplChnDev->pChnStatus, &BufSrc );
709	BKNI_Memset(hImplChnDev->pChnStatus, 0x00, sizeof( BADS_3x7x_ChnStatus_t ) );
710	BREG_Write32(hImplDev->hRegister, BCHP_DS_TOPM_SW_SPARE1, BufSrc);
711
712	hImplChnDev->pChnAcqParam = (BADS_3x7x_AcqParams_t *)BMEM_AllocAligned(hDev->settings.hHeap, sizeof(BADS_3x7x_AcqParams_t), 0, 0 );
713	if( hImplChnDev->pChnAcqParam == NULL )
714	{
715	retCode = BERR_TRACE(BERR_OUT_OF_SYSTEM_MEMORY);
716	BDBG_ERR(("BADS_OpenChannel: BMEM_AllocAligned() failed"));
717	goto done;
718	}
719	BMEM_ConvertAddressToOffset(hDev->settings.hHeap, hImplChnDev->pChnAcqParam, &BufSrc );
720	BKNI_Memset(hImplChnDev->pChnAcqParam, 0x00, sizeof( BADS_3x7x_AcqParams_t ) );
721	BREG_Write32(hImplDev->hRegister, BCHP_DS_TOPM_SW_SPARE2, BufSrc);
722	hImplChnDev->pChnLockStatus = (BADS_3x7x_ChnLockStatus_t *)BMEM_AllocAligned(hDev->settings.hHeap, sizeof(BADS_3x7x_ChnLockStatus_t), 0, 0 );
723	if( hImplChnDev->pChnLockStatus == NULL )
724	{
725	retCode = BERR_TRACE(BERR_OUT_OF_SYSTEM_MEMORY);
726	BDBG_ERR(("BADS_OpenChannel: BMEM_AllocAligned() failed"));
727	goto done;
728	}
729	BMEM_ConvertAddressToOffset(hDev->settings.hHeap, hImplChnDev->pChnLockStatus, &BufSrc );
730	BKNI_Memset( hImplChnDev->pChnLockStatus, 0x00, sizeof( BADS_3x7x_ChnLockStatus_t ) );
731	BREG_Write32(hImplDev->hRegister, BCHP_DS_TOPM_SPARE1, BufSrc);
732	hImplChnDev->pChnAcqParam->BADS_Local_Params.lock_status = 2; /* init to a value different than 1 and 0 */
733
734
735	if (pChnDefSettings->autoAcquire == true)
736	{
737	hImplChnDev->pChnAcqParam->BADS_Acquire_Params.Auto = BADS_Acquire_Params_eEnable;
738	}
739	else
740	{
741	hImplChnDev->pChnAcqParam->BADS_Acquire_Params.Auto = BADS_Acquire_Params_eDisable;
742	}
743
744	hImplDev->hAdsChn[channelNo] = hImplChnDev;
745	hChnDev->pImpl = hImplChnDev;
746	hImplChnDev->ePowerStatus = BADS_eChan_Power_Off;
747
748	*phChn = hChnDev;
749
750	}
751	else
752	{
753	retCode = BERR_TRACE(BADS_ERR_NOTAVAIL_CHN_NO);
754	}
755	}
756	else
757	{
758	retCode = BERR_TRACE(BERR_INVALID_PARAMETER);
759	}
760
761	done:
762	if( retCode != BERR_SUCCESS )
763	{
764	if( hImplChnDev->pChnStatus != NULL )
765	BMEM_Free(hDev->settings.hHeap,(void *)(hImplChnDev->pChnStatus) );
766	if( hImplChnDev->pChnAcqParam != NULL )
767	BMEM_Free(hDev->settings.hHeap ,(void *)(hImplChnDev->pChnAcqParam) );
768	if( hImplChnDev->pChnLockStatus != NULL )
769	BMEM_Free(hDev->settings.hHeap,(void *)(hImplChnDev->pChnLockStatus) );
770	if( hImplChnDev->pChnScanStatus != NULL )
771	BMEM_Free(hDev->settings.hHeap,(void *)(hImplChnDev->pChnScanStatus) );
772	if( hImplChnDev != NULL )
773	BKNI_Free( hImplChnDev );
774	if( hChnDev != NULL )
775	BKNI_Free( hChnDev );
776	*phChn = NULL;
777	}
778	BDBG_LEAVE(BADS_3x7x_OpenChannel);
779	return( retCode );
780	}
781
782	/*******************************************************************************
783	* BADS_3x7x_CloseChannel
784	*******************************************************************************/
785	BERR_Code BADS_3x7x_CloseChannel(
786	BADS_ChannelHandle hChn
787	)
788	{
789	BADS_Handle hDev;
790	BADS_3x7x_Handle hImplDev;
791
792	BADS_3x7x_ChannelHandle hImplChnDev = (BADS_3x7x_ChannelHandle) hChn->pImpl;
793	BDBG_ASSERT( hChn );
794	BDBG_ASSERT( hChn->magicId == DEV_MAGIC_ID );
795	hDev = hChn->hAds;
796	hImplDev = (BADS_3x7x_Handle) hDev->pImpl;
797
798	BINT_DisableCallback(hImplChnDev->hDs2Callback);
799	#if BCHP_DS_CORE_V_9_1
800	BKNI_DestroyEvent(hImplChnDev->hFcaEvent);
801	BKNI_DestroyEvent(hImplChnDev->hChscnEvent);
802	#elif ((BCHP_DS_CORE_V_9_2) \|\| (BCHP_DS_CORE_V_9_4))
803	BKNI_DestroyEvent(hImplChnDev->hFftEvent);
804	#endif
805	hImplChnDev->ePowerStatus = BADS_eChan_Power_Off;
806
807	hChn->magicId = 0x00; /* clear it to catch inproper use */
808	BMEM_Free(hDev->settings.hHeap ,(void *)(hImplChnDev->pChnAcqParam) );
809	BMEM_Free(hDev->settings.hHeap,(void *)(hImplChnDev->pChnLockStatus) );
810	BMEM_Free(hDev->settings.hHeap,(void *)(hImplChnDev->pChnStatus) );
811	BMEM_Free(hDev->settings.hHeap,(void *)(hImplChnDev->pChnScanStatus) );
812	hImplDev->hAdsChn[hImplChnDev->chnNo] = NULL;
813	BKNI_Free( hChn->pImpl );
814	BKNI_Free( hChn );
815
816	return BERR_SUCCESS;
817	}
818
819
820	/*******************************************************************************
821	* BADS_3x7x_GetDevice
822	*******************************************************************************/
823	BERR_Code BADS_3x7x_GetDevice(
824	BADS_ChannelHandle hChn, /* [in] Device channel handle */
825	BADS_Handle phDev / [out] Returns Device handle */
826	)
827	{
828	BERR_Code retCode = BERR_SUCCESS;
829
830	BDBG_ENTER(BADS_3x7x_GetDevice);
831	BDBG_ASSERT( hChn );
832	BDBG_ASSERT( hChn->magicId == DEV_MAGIC_ID );
833
834	*phDev = hChn->hAds;
835
836	BDBG_LEAVE(BADS_3x7x_GetDevice);
837	return( retCode );
838	}
839
840
841	/*******************************************************************************
842	* BADS_3x7x_SetScanParam
843	*******************************************************************************/
844	BERR_Code BADS_3x7x_SetScanParam(
845	BADS_ChannelHandle hChn, /* [in] Device channel handle */
846	BADS_ChannelScanSettings *pChnScanSettings
847	)
848	{
849	BERR_Code retCode = BERR_SUCCESS;
850	BADS_3x7x_ChannelHandle hImplChnDev;
851
852	BDBG_ENTER(BADS_3x7x_SetScanParam);
853	BDBG_ASSERT( hChn );
854	BDBG_ASSERT( hChn->magicId == DEV_MAGIC_ID );
855	hImplChnDev = (BADS_3x7x_ChannelHandle) hChn->pImpl;
856
857	hImplChnDev->pChnAcqParam->BADS_Scan_Params.AI = pChnScanSettings->AI;
858	hImplChnDev->pChnAcqParam->BADS_Scan_Params.QM = pChnScanSettings->QM;
859	hImplChnDev->pChnAcqParam->BADS_Scan_Params.CO = pChnScanSettings->CO;
860	hImplChnDev->pChnAcqParam->BADS_Scan_Params.TO = pChnScanSettings->TO;
861	hImplChnDev->pChnAcqParam->BADS_Scan_Params.B1024 = pChnScanSettings->B1024;
862	hImplChnDev->pChnAcqParam->BADS_Scan_Params.B256 = pChnScanSettings->B256;
863	hImplChnDev->pChnAcqParam->BADS_Scan_Params.B64 = pChnScanSettings->B64;
864	hImplChnDev->pChnAcqParam->BADS_Scan_Params.A1024 = pChnScanSettings->A1024;
865	hImplChnDev->pChnAcqParam->BADS_Scan_Params.A512 = pChnScanSettings->A512;
866	hImplChnDev->pChnAcqParam->BADS_Scan_Params.A256 = pChnScanSettings->A256;
867	hImplChnDev->pChnAcqParam->BADS_Scan_Params.A128 = pChnScanSettings->A128;
868	hImplChnDev->pChnAcqParam->BADS_Scan_Params.A64 = pChnScanSettings->A64;
869	hImplChnDev->pChnAcqParam->BADS_Scan_Params.A32 = pChnScanSettings->A32;
870	hImplChnDev->pChnAcqParam->BADS_Scan_Params.A16 = pChnScanSettings->A16;
871	hImplChnDev->pChnAcqParam->BADS_Scan_Params.Carrier_Search = pChnScanSettings->carrierSearch;
872	hImplChnDev->pChnAcqParam->BADS_Scan_Params.Upper_Baud_Search = pChnScanSettings->upperBaudSearch;
873	hImplChnDev->pChnAcqParam->BADS_Scan_Params.Lower_Baud_Search = pChnScanSettings->lowerBaudSearch;
874
875	BDBG_LEAVE(BADS_3x7x_SetScanParam);
876	return( retCode );
877	}
878
879
880
881	/*******************************************************************************
882	* BADS_3x7x_GetScanParam
883	*******************************************************************************/
884	BERR_Code BADS_3x7x_GetScanParam(
885	BADS_ChannelHandle hChn, /* [in] Device channel handle */
886	BADS_ChannelScanSettings *pChnScanSettings
887	)
888	{
889	BERR_Code retCode = BERR_SUCCESS;
890	BADS_3x7x_ChannelHandle hImplChnDev;
891
892	BDBG_ENTER(BADS_3x7x_GetScanParam);
893	BDBG_ASSERT( hChn );
894	BDBG_ASSERT( hChn->magicId == DEV_MAGIC_ID );
895	hImplChnDev = (BADS_3x7x_ChannelHandle) hChn->pImpl;
896
897	pChnScanSettings->AI = hImplChnDev->pChnAcqParam->BADS_Scan_Params.AI ;
898	pChnScanSettings->QM = hImplChnDev->pChnAcqParam->BADS_Scan_Params.QM ;
899	pChnScanSettings->CO = hImplChnDev->pChnAcqParam->BADS_Scan_Params.CO ;
900	pChnScanSettings->TO = hImplChnDev->pChnAcqParam->BADS_Scan_Params.TO ;
901	pChnScanSettings->B1024 = hImplChnDev->pChnAcqParam->BADS_Scan_Params.B1024 ;
902	pChnScanSettings->B256 = hImplChnDev->pChnAcqParam->BADS_Scan_Params.B256 ;
903	pChnScanSettings->B64 = hImplChnDev->pChnAcqParam->BADS_Scan_Params.B64 ;
904	pChnScanSettings->A1024 = hImplChnDev->pChnAcqParam->BADS_Scan_Params.A1024 ;
905	pChnScanSettings->A512 = hImplChnDev->pChnAcqParam->BADS_Scan_Params.A512 ;
906	pChnScanSettings->A256 = hImplChnDev->pChnAcqParam->BADS_Scan_Params.A256 ;
907	pChnScanSettings->A128 = hImplChnDev->pChnAcqParam->BADS_Scan_Params.A128 ;
908	pChnScanSettings->A64 = hImplChnDev->pChnAcqParam->BADS_Scan_Params.A64 ;
909	pChnScanSettings->A32 = hImplChnDev->pChnAcqParam->BADS_Scan_Params.A32 ;
910	pChnScanSettings->A16 = hImplChnDev->pChnAcqParam->BADS_Scan_Params.A16 ;
911	pChnScanSettings->carrierSearch = hImplChnDev->pChnAcqParam->BADS_Scan_Params.Carrier_Search ;
912	pChnScanSettings->upperBaudSearch = hImplChnDev->pChnAcqParam->BADS_Scan_Params.Upper_Baud_Search ;
913	pChnScanSettings->lowerBaudSearch = hImplChnDev->pChnAcqParam->BADS_Scan_Params.Lower_Baud_Search ;
914
915	BDBG_LEAVE(BADS_3x7x_GetScanParam);
916	return( retCode );
917	}
918
919
920
921	/*******************************************************************************
922	* BADS_3x7x_Acquire
923	*******************************************************************************/
924	BERR_Code BADS_3x7x_Acquire(
925	BADS_ChannelHandle hChn, /* [in] Device channel handle */
926	BADS_InbandParam ibParam / [in] Inband Parameters to use */
927	)
928	{
929	BERR_Code retCode = BERR_SUCCESS;
930	BADS_3x7x_ChannelHandle hImplChnDev;
931	BADS_Handle hDev;
932	BADS_3x7x_Handle hImplDev;
933
934	BDBG_ENTER(BADS_3x7x_Acquire);
935	BDBG_ASSERT( hChn );
936	BDBG_ASSERT( hChn->magicId == DEV_MAGIC_ID );
937
938	hImplChnDev = (BADS_3x7x_ChannelHandle) hChn->pImpl;
939	BDBG_ASSERT( hImplChnDev );
940	hDev = (BADS_Handle)(hChn->hAds);
941	BDBG_ASSERT( hDev );
942	hImplDev = (BADS_3x7x_Handle) hDev->pImpl;
943	BDBG_ASSERT( hImplDev );
944	BDBG_MSG(("BADS_3x7x_Acquire"));
945
946	if (hImplChnDev->ePowerStatus != BADS_eChan_Power_On)
947	{
948	BDBG_WRN(("!!!BADS_3x7x_Acquire: chan power not on yet"));
949	return BERR_NOT_INITIALIZED;
950	}
951
952
953	switch(ibParam->modType)
954	{
955	case BADS_ModulationType_eAnnexAQam16:
956	hImplChnDev->pChnAcqParam->BADS_Acquire_Params.Annex = BADS_Acquire_Params_Annex_eAnnexA;
957	hImplChnDev->pChnAcqParam->BADS_Acquire_Params.Qam_Mode = BADS_Acquire_Params_BPS_eQam16;
958	break;
959	case BADS_ModulationType_eAnnexAQam32:
960	hImplChnDev->pChnAcqParam->BADS_Acquire_Params.Annex = BADS_Acquire_Params_Annex_eAnnexA;
961	hImplChnDev->pChnAcqParam->BADS_Acquire_Params.Qam_Mode = BADS_Acquire_Params_BPS_eQam32;
962	break;
963	case BADS_ModulationType_eAnnexAQam64:
964	hImplChnDev->pChnAcqParam->BADS_Acquire_Params.Annex = BADS_Acquire_Params_Annex_eAnnexA;
965	hImplChnDev->pChnAcqParam->BADS_Acquire_Params.Qam_Mode = BADS_Acquire_Params_BPS_eQam64;
966	break;
967	case BADS_ModulationType_eAnnexAQam128:
968	hImplChnDev->pChnAcqParam->BADS_Acquire_Params.Annex = BADS_Acquire_Params_Annex_eAnnexA;
969	hImplChnDev->pChnAcqParam->BADS_Acquire_Params.Qam_Mode = BADS_Acquire_Params_BPS_eQam128;
970	break;
971	case BADS_ModulationType_eAnnexAQam256:
972	hImplChnDev->pChnAcqParam->BADS_Acquire_Params.Annex = BADS_Acquire_Params_Annex_eAnnexA;
973	hImplChnDev->pChnAcqParam->BADS_Acquire_Params.Qam_Mode = BADS_Acquire_Params_BPS_eQam256;
974	break;
975	case BADS_ModulationType_eAnnexAQam1024:
976	hImplChnDev->pChnAcqParam->BADS_Acquire_Params.Annex = BADS_Acquire_Params_Annex_eAnnexA;
977	hImplChnDev->pChnAcqParam->BADS_Acquire_Params.Qam_Mode = BADS_Acquire_Params_BPS_eQam1024;
978	break;
979	case BADS_ModulationType_eAnnexBQam16:
980	hImplChnDev->pChnAcqParam->BADS_Acquire_Params.Annex = BADS_Acquire_Params_Annex_eAnnexA;
981	hImplChnDev->pChnAcqParam->BADS_Acquire_Params.Qam_Mode = BADS_Acquire_Params_BPS_eQam16;
982	break;
983	case BADS_ModulationType_eAnnexBQam32:
984	hImplChnDev->pChnAcqParam->BADS_Acquire_Params.Annex = BADS_Acquire_Params_Annex_eAnnexB;
985	hImplChnDev->pChnAcqParam->BADS_Acquire_Params.Qam_Mode = BADS_Acquire_Params_BPS_eQam32;
986	break;
987	case BADS_ModulationType_eAnnexBQam64:
988	hImplChnDev->pChnAcqParam->BADS_Acquire_Params.Annex = BADS_Acquire_Params_Annex_eAnnexB;
989	hImplChnDev->pChnAcqParam->BADS_Acquire_Params.Qam_Mode = BADS_Acquire_Params_BPS_eQam64;
990	break;
991	case BADS_ModulationType_eAnnexBQam128:
992	hImplChnDev->pChnAcqParam->BADS_Acquire_Params.Annex = BADS_Acquire_Params_Annex_eAnnexB;
993	hImplChnDev->pChnAcqParam->BADS_Acquire_Params.Qam_Mode = BADS_Acquire_Params_BPS_eQam128;
994	break;
995	case BADS_ModulationType_eAnnexBQam256:
996	hImplChnDev->pChnAcqParam->BADS_Acquire_Params.Annex = BADS_Acquire_Params_Annex_eAnnexB;
997	hImplChnDev->pChnAcqParam->BADS_Acquire_Params.Qam_Mode = BADS_Acquire_Params_BPS_eQam256;
998	break;
999	case BADS_ModulationType_eAnnexBQam1024:
1000	hImplChnDev->pChnAcqParam->BADS_Acquire_Params.Annex = BADS_Acquire_Params_Annex_eAnnexB;
1001	hImplChnDev->pChnAcqParam->BADS_Acquire_Params.Qam_Mode = BADS_Acquire_Params_BPS_eQam1024;
1002	break;
1003	default:
1004	BDBG_WRN(("BADS_3x7x_Acquire: QAM mode not supported"));
1005	break;
1006
1007	}
1008	hImplChnDev->pChnAcqParam->BADS_Acquire_Params.AnnexA_Sym_Rate = ibParam->symbolRate;
1009	hImplChnDev->pChnAcqParam->BADS_Acquire_Params.IS = ibParam->invertSpectrum;
1010	hImplChnDev->pChnAcqParam->BADS_Acquire_Params.Auto = ibParam->autoAcquire;
1011	hImplChnDev->pChnAcqParam->BADS_Acquire_Params.AcqType = ibParam->acquisitionType;
1012	hImplChnDev->pChnAcqParam->BADS_Acquire_Params.Carrier_Range = ibParam->frequencyOffset / 256; /* from Hz to 256Hz */
1013	BKNI_Memset(hImplChnDev->pChnLockStatus, 0x00, sizeof( BADS_3x7x_ChnLockStatus_t ) ); /* Clear status structure upon new TuneAcquire command from host */
1014	hImplChnDev->pChnAcqParam->BADS_Local_Params.LockUpdate = true;
1015	hImplChnDev->pChnLockStatus->ReAck_Count = 0;
1016
1017	BTMR_StopTimer(hImplDev->hTimer); /* the timer is in Micro second */
1018
1019	hImplChnDev->pChnStatus->FLK = 0;
1020	hImplChnDev->pChnStatus->QLK = 0;
1021	hImplChnDev->pChnAcqParam->BADS_Local_Params.lock_status = 1;
1022	hImplChnDev->pChnAcqParam->BADS_Local_Params.LockUpdate = true;
1023	BKNI_EnterCriticalSection();
1024	if ( hImplChnDev->pCallback[BADS_Callback_eLockChange] != NULL )
1025	(hImplChnDev->pCallback[BADS_Callback_eLockChange])(hImplChnDev->pCallbackParam[BADS_Callback_eLockChange] );
1026	BKNI_LeaveCriticalSection();
1027	BADS_P_ResetDSCore(hImplChnDev);
1028	BADS_P_Acquire(hImplChnDev);
1029	BTMR_StartTimer(hImplDev->hTimer, 25000); /* the timer is in Micro second */
1030
1031	BDBG_LEAVE(BADS_3x7x_Acquire);
1032	return( retCode );
1033	}
1034
1035
1036	/*******************************************************************************
1037	* BADS_3x7x_GetStatus
1038	*******************************************************************************/
1039	BERR_Code BADS_3x7x_GetStatus(
1040	BADS_ChannelHandle hChn, /* [in] Device channel handle */
1041	BADS_Status pStatus / [out] Returns status */
1042	)
1043	{
1044	BERR_Code retCode = BERR_SUCCESS;
1045	BADS_3x7x_ChannelHandle hImplChnDev;
1046	BADS_3x7x_Handle hImplDev;
1047
1048	BDBG_ENTER(BADS_3x7x_GetStatus);
1049	BDBG_ASSERT( hChn );
1050	BDBG_ASSERT( hChn->magicId == DEV_MAGIC_ID );
1051
1052	hImplChnDev = (BADS_3x7x_ChannelHandle) hChn->pImpl;
1053	BDBG_ASSERT( hImplChnDev );
1054	hImplDev = hImplChnDev->hAds;
1055
1056	if (hImplChnDev->ePowerStatus != BADS_eChan_Power_On)
1057	{
1058	BDBG_WRN(("!!!BADS_3x7x_Acquire: chan power not on yet"));
1059	return BERR_NOT_INITIALIZED;
1060	}
1061
1062	BADS_P_ChnStatus(hImplChnDev);
1063
1064
1065	pStatus->isPowerSaverEnabled = 0; /* Enable=1, Disable=0 */
1066
1067	pStatus->isFecLock = (hImplChnDev->pChnStatus->FLK==BADS_3x7x_ChnStatus_eLock)?1:0; /* lock=1, unlock=0 */
1068	pStatus->isQamLock = (hImplChnDev->pChnStatus->QLK==BADS_3x7x_ChnStatus_eLock)?1:0; /* lock=1, unlock=0 */
1069	pStatus->symbolRate = hImplChnDev->pChnStatus->Symbol_Rate; /* in Baud */
1070
1071	if (hImplChnDev->pChnStatus->AB == BADS_3x7x_ChnStatus_Annex_eAnnexA)
1072	{
1073	switch(hImplChnDev->pChnStatus->BPS)
1074	{
1075	case BADS_Acquire_Params_BPS_eQam16:
1076	pStatus->modType = BADS_ModulationType_eAnnexAQam16;
1077	break;
1078	case BADS_Acquire_Params_BPS_eQam32:
1079	pStatus->modType = BADS_ModulationType_eAnnexAQam32;
1080	break;
1081	case BADS_Acquire_Params_BPS_eQam64:
1082	pStatus->modType = BADS_ModulationType_eAnnexAQam64;
1083	break;
1084	case BADS_Acquire_Params_BPS_eQam128:
1085	pStatus->modType = BADS_ModulationType_eAnnexAQam128;
1086	break;
1087	case BADS_Acquire_Params_BPS_eQam256:
1088	pStatus->modType = BADS_ModulationType_eAnnexAQam256;
1089	break;
1090	case BADS_Acquire_Params_BPS_eQam512:
1091	pStatus->modType = BADS_ModulationType_eAnnexAQam512;
1092	break;
1093	case BADS_Acquire_Params_BPS_eQam1024:
1094	pStatus->modType = BADS_ModulationType_eAnnexAQam1024;
1095	break;
1096	}
1097	}
1098	else if (hImplChnDev->pChnStatus->AB == BADS_3x7x_ChnStatus_Annex_eAnnexB)
1099	{
1100	switch(hImplChnDev->pChnStatus->BPS)
1101	{
1102	case BADS_Acquire_Params_BPS_eQam16:
1103	pStatus->modType = BADS_ModulationType_eAnnexBQam16;
1104	break;
1105	case BADS_Acquire_Params_BPS_eQam32:
1106	pStatus->modType = BADS_ModulationType_eAnnexBQam32;
1107	break;
1108	case BADS_Acquire_Params_BPS_eQam64:
1109	pStatus->modType = BADS_ModulationType_eAnnexBQam64;
1110	break;
1111	case BADS_Acquire_Params_BPS_eQam128:
1112	pStatus->modType = BADS_ModulationType_eAnnexBQam128;
1113	break;
1114	case BADS_Acquire_Params_BPS_eQam256:
1115	pStatus->modType = BADS_ModulationType_eAnnexBQam256;
1116	break;
1117	case BADS_Acquire_Params_BPS_eQam512:
1118	pStatus->modType = BADS_ModulationType_eAnnexBQam512;
1119	break;
1120	case BADS_Acquire_Params_BPS_eQam1024:
1121	pStatus->modType = BADS_ModulationType_eAnnexBQam1024;
1122	break;
1123	}
1124	}
1125	pStatus->carrierFreqOffset = hImplChnDev->pChnStatus->Carrier_Error/1000; /* in 1/1000 Hz */
1126	pStatus->carrierPhaseOffset = hImplChnDev->pChnStatus->Phase_Error/1000; /* in 1/1000 Hz */
1127	pStatus->symbolRateError = hImplChnDev->pChnStatus->Symbol_Error;
1128	pStatus->rxSymbolRate = hImplChnDev->pChnStatus->Symbol_Error + hImplChnDev->pChnStatus->Symbol_Rate;
1129	pStatus->snrEstimate = hImplChnDev->pChnStatus->SNRAVG_db;
1130	pStatus->correctedBits = hImplChnDev->pChnStatus->FEC_Corr_RS_Bits;
1131	pStatus->berRawCount = hImplChnDev->pChnStatus->BERT;
1132	pStatus->isSpectrumInverted = hImplChnDev->pChnStatus->SI;
1133	pStatus->dsChannelPower = hImplChnDev->pChnStatus->EstChannelPower_dbm; /* it is in units of 1/256 db. */
1134	pStatus->symbolRate = hImplChnDev->pChnStatus->Symbol_Rate; /* in Baud */
1135	pStatus->mainTap = hImplChnDev->pChnStatus->EQ_Main_Tap; /* Channel main tap coefficient */
1136	pStatus->equalizerGain = hImplChnDev->pChnStatus->EQ_Gain_db100; / Channel equalizer gain value in 1/100th of dB */
1137	pStatus->correctedBits = hImplChnDev->pChnStatus->FEC_Corr_RS_Bits;
1138	pStatus->accCorrectedCount = hImplChnDev->pChnStatus->FEC_Corr_RS_Blocks;
1139	pStatus->accUncorrectedCount = hImplChnDev->pChnStatus->FEC_UCorr_RS_Blocks;
1140	pStatus->accCleanCount = hImplChnDev->pChnStatus->FEC_Clean_RS_Blocks;
1141
1142	pStatus->goodRsBlockCount = 0; /* Not supported */
1143	pStatus->uncorrectedCount = 0; /* Not supported */
1144	pStatus->correctedCount = 0; /* Not supported */
1145	pStatus->ifFreq = 0; /* Not supported */
1146	pStatus->agcIntLevel = 0; /* Not supported / / returns 0, moved to tuner*/
1147	pStatus->agcExtLevel = 0; /* Not supported / / returns 0, moved to tuner*/
1148	pStatus->interleaveDepth = 0; /* Not supported */
1149	pStatus->goodRsBlockCount = 0; /* Not supported */
1150	pStatus->postRsBER = 0; /* Not supported */
1151	pStatus->elapsedTimeSec = 0; /* Not supported */
1152	pStatus->cleanCount = 0; /* Not supported */
1153
1154	BDBG_LEAVE(BADS_3x7x_GetStatus);
1155	return( retCode );
1156	}
1157
1158
1159	/*******************************************************************************
1160	* BADS_3x7x_GetLockStatus
1161	*******************************************************************************/
1162	BERR_Code BADS_3x7x_GetLockStatus(
1163	BADS_ChannelHandle hChn, /* [in] Device channel handle */
1164	BADS_LockStatus pLockStatus / [out] Returns lock status */
1165	)
1166	{
1167	BERR_Code retCode = BERR_SUCCESS;
1168	BADS_3x7x_ChannelHandle hImplChnDev;
1169
1170	BDBG_ENTER(BADS_3x7x_GetLockStatus);
1171	BDBG_ASSERT( hChn );
1172	BDBG_ASSERT( hChn->magicId == DEV_MAGIC_ID );
1173
1174	hImplChnDev = (BADS_3x7x_ChannelHandle) hChn->pImpl;
1175	BDBG_ASSERT( hImplChnDev );
1176
1177	if (hImplChnDev->ePowerStatus != BADS_eChan_Power_On)
1178	{
1179	BDBG_WRN(("!!!BADS_3x7x_Acquire: chan power not on yet"));
1180	return BERR_NOT_INITIALIZED;
1181	}
1182
1183	BADS_P_ChnStatus(hImplChnDev);
1184	if (hImplChnDev->pChnStatus->FLK == BADS_3x7x_ChnStatus_eUnlock)
1185	{
1186	*pLockStatus = BADS_LockStatus_eUnlocked;
1187	if ( (hImplChnDev->pChnStatus->AcqStatus == BADS_3x7x_ChnStatus_AcqStatus_eNoPower ) \|\|
1188	(hImplChnDev->pChnStatus->AcqStatus == BADS_3x7x_ChnStatus_AcqStatus_eNoTiming) )
1189	*pLockStatus = BADS_LockStatus_eNoSignal;
1190	}
1191	else
1192	{
1193	*pLockStatus = BADS_LockStatus_eLocked;
1194	}
1195
1196	BDBG_LEAVE(BADS_3x7x_GetLockStatus);
1197	return( retCode );
1198
1199	BDBG_LEAVE(BADS_3x7x_GetLockStatus);
1200	return( retCode );
1201
1202	}
1203
1204	/*******************************************************************************
1205	* BADS_3x7x_GetSoftDecision
1206	*******************************************************************************/
1207	BERR_Code BADS_3x7x_GetSoftDecision(
1208	BADS_ChannelHandle hChn, /* [in] Device channel handle */
1209	int16_t nbrToGet, /* [in] Number values to get */
1210	int16_t iVal, / [out] Ptr to array to store output I soft decision */
1211	int16_t qVal, / [out] Ptr to array to store output Q soft decision */
1212	int16_t nbrGotten / [out] Number of values gotten/read */
1213	)
1214	{
1215	BADS_3x7x_ChannelHandle hImplChnDev;
1216	BERR_Code retCode = BERR_SUCCESS;
1217	BSTD_UNUSED(nbrToGet);
1218	BDBG_ENTER(BADS_3x7x_GetSoftDecision);
1219	BDBG_ASSERT( hChn );
1220	BDBG_ASSERT( hChn->magicId == DEV_MAGIC_ID );
1221
1222	hImplChnDev = (BADS_3x7x_ChannelHandle) hChn->pImpl;
1223	BDBG_ASSERT( hImplChnDev );
1224
1225	if (hImplChnDev->ePowerStatus != BADS_eChan_Power_On)
1226	{
1227	BDBG_WRN(("!!!BADS_3x7x_Acquire: chan power not on yet"));
1228	return BERR_NOT_INITIALIZED;
1229	}
1230
1231	BADS_P_Read_Constellation(hImplChnDev, nbrToGet, iVal, qVal, nbrGotten);
1232
1233	BDBG_LEAVE(BADS_3x7x_GetSoftDecision);
1234	return( retCode );
1235	}
1236
1237
1238	/*******************************************************************************
1239	* BADS_3x7x_EnablePowerSaver
1240	*******************************************************************************/
1241	BERR_Code BADS_3x7x_EnablePowerSaver(
1242	BADS_ChannelHandle hChn /* [in] Device channel handle */
1243	)
1244	{
1245	BERR_Code retCode = BERR_SUCCESS;
1246	BADS_3x7x_ChannelHandle hImplChnDev;
1247
1248
1249	BDBG_ENTER(BADS_3x7x_EnablePowerSaver);
1250	BDBG_ASSERT( hChn );
1251	BDBG_ASSERT( hChn->magicId == DEV_MAGIC_ID );
1252
1253	hImplChnDev = (BADS_3x7x_ChannelHandle) hChn->pImpl;
1254	BDBG_ASSERT( hImplChnDev );
1255
1256	#if BCHP_DS_CORE_V_9_1
1257	BREG_Write32(hImplChnDev->hRegister, BCHP_DS_PD, 0x1F300023); /* power down the DS core */
1258	#elif ((BCHP_DS_CORE_V_9_2) \|\| (BCHP_DS_CORE_V_9_3))
1259	BREG_WriteField(hImplChnDev->hRegister, DS_TOPM_PD, DS0_540_DISABLE, 1); /* power down the DS core */
1260	#endif
1261
1262	hImplChnDev->ePowerStatus = BADS_eChan_Power_Off;
1263	BDBG_LEAVE(BADS_3x7x_EnablePowerSaver);
1264	return( retCode );
1265	}
1266
1267	/*******************************************************************************
1268	* BADS_3x7x_DisablePowerSaver
1269	*******************************************************************************/
1270	BERR_Code BADS_3x7x_DisablePowerSaver(
1271	BADS_ChannelHandle hChn /* [in] Device channel handle */
1272	)
1273	{
1274	BERR_Code retCode = BERR_SUCCESS;
1275	BADS_3x7x_ChannelHandle hImplChnDev;
1276
1277
1278	BDBG_ENTER(BADS_3x7x_DisablePowerSaver);
1279	BDBG_ASSERT( hChn );
1280	BDBG_ASSERT( hChn->magicId == DEV_MAGIC_ID );
1281
1282	BDBG_MSG(("BADS_3x7x_DisablePowerSaver"));
1283
1284	hImplChnDev = (BADS_3x7x_ChannelHandle) hChn->pImpl;
1285	BDBG_ASSERT( hImplChnDev );
1286	BREG_WriteField(hImplChnDev->hRegister, DS_TOPS_CNTL, FIFO_RESET, 1);
1287	BREG_WriteField(hImplChnDev->hRegister, DS_TOPS_CNTL, FIFO_RESET, 0);
1288	#if BCHP_DS_CORE_V_9_1
1289	BREG_Write32(hImplChnDev->hRegister, BCHP_DS_PD, 0x0); /* power up the DS core */
1290	#elif ((BCHP_DS_CORE_V_9_2) \|\| (BCHP_DS_CORE_V_9_3))
1291	BREG_WriteField(hImplChnDev->hRegister, DS_TOPM_PD, DS0_540_DISABLE, 0); /* power up the DS core */
1292	#endif
1293	BADS_P_ResetDSCore(hImplChnDev);
1294	/* reset the FE Fifo */
1295	BREG_WriteField(hImplChnDev->hRegister, DS_TOPS_CNTL, FIFO_RESET, 1);
1296	BREG_WriteField(hImplChnDev->hRegister, DS_TOPS_CNTL, FIFO_RESET, 0);
1297
1298	hImplChnDev->ePowerStatus = BADS_eChan_Power_On;
1299
1300	BDBG_LEAVE(BADS_3x7x_DisablePowerSaver);
1301	return( retCode );
1302	}
1303
1304	/*******************************************************************************
1305	* BADS_3x7x_EnablePowerSaver
1306	*******************************************************************************/
1307	BERR_Code BADS_3x7x_ProcessNotification(
1308	BADS_ChannelHandle hChn, /* [in] Device channel handle */
1309	unsigned int event /* [in] Event code and event data*/
1310	)
1311	{
1312	BERR_Code retCode = BERR_SUCCESS;
1313	BSTD_UNUSED(hChn);
1314	BSTD_UNUSED(event);
1315
1316	BDBG_WRN(("Not supported for this frontend chip."));
1317	return( retCode );
1318	}
1319
1320
1321
1322	/*******************************************************************************
1323	* BADS_3x7x_InstallCallback
1324	*******************************************************************************/
1325	BERR_Code BADS_3x7x_InstallCallback(
1326	BADS_ChannelHandle hChn, /* [in] Device channel handle */
1327	BADS_Callback callbackType, /* [in] Type of callback */
1328	BADS_CallbackFunc pCallback, /* [in] Function Ptr to callback */
1329	void pParam / [in] Generic parameter send on callback */
1330	)
1331	{
1332	BERR_Code retCode = BERR_SUCCESS;
1333
1334	BADS_3x7x_ChannelHandle hImplChnDev = (BADS_3x7x_ChannelHandle) hChn->pImpl;
1335	BDBG_ASSERT( hChn );
1336	BDBG_ASSERT( hChn->magicId == DEV_MAGIC_ID );
1337	BDBG_ENTER(BADS_3x7x_InstallCallback);
1338
1339	switch( callbackType )
1340	{
1341	case BADS_Callback_eLockChange:
1342	hImplChnDev->pCallback[callbackType] = pCallback;
1343	hImplChnDev->pCallbackParam[callbackType] = pParam;
1344	break;
1345	case BADS_Callback_eTuner:
1346	hImplChnDev->pCallback[callbackType] = pCallback;
1347	hImplChnDev->pCallbackParam[callbackType] = pParam;
1348	break;
1349
1350	default:
1351	retCode = BERR_TRACE(BERR_INVALID_PARAMETER);
1352	break;
1353	}
1354
1355	BDBG_LEAVE(BADS_3x7x_InstallCallback);
1356	return( retCode );
1357	}
1358
1359	/*******************************************************************************
1360	* BADS_3x7x_SetDaisyChain
1361	*******************************************************************************/
1362	BERR_Code BADS_3x7x_SetDaisyChain(
1363	BADS_Handle hDev, /* [in] Returns handle */
1364	bool enableDaisyChain /* [in] Eanble/disable daisy chain. */
1365	)
1366	{
1367	BERR_Code retCode = BERR_SUCCESS;
1368	BADS_3x7x_Handle hImplDev;
1369
1370
1371	BDBG_ENTER(BADS_3x7x_SetDaisyChain);
1372	BDBG_ASSERT( hDev );
1373	BDBG_ASSERT( hDev->magicId == DEV_MAGIC_ID );
1374
1375	hImplDev = (BADS_3x7x_Handle) hDev->pImpl;
1376	BDBG_ASSERT( hImplDev );
1377
1378	hImplDev->isDaisyChain = enableDaisyChain;
1379
1380	BDBG_LEAVE(BADS_3x7x_SetDaisyChain);
1381	return( retCode );
1382	}
1383	/*******************************************************************************
1384	* BADS_3x7x_GetDaisyChain
1385	*******************************************************************************/
1386	BERR_Code BADS_3x7x_GetDaisyChain(
1387	BADS_Handle hDev, /* [in] Returns handle */
1388	bool isEnableDaisyChain / [in] Eanble/disable daisy chain. */
1389	)
1390	{
1391	BERR_Code retCode = BERR_SUCCESS;
1392	BADS_3x7x_Handle hImplDev;
1393
1394	BDBG_ENTER(BADS_3x7x_GetDaisyChain);
1395	BDBG_ASSERT( hDev );
1396	BDBG_ASSERT( hDev->magicId == DEV_MAGIC_ID );
1397
1398	hImplDev = (BADS_3x7x_Handle) hDev->pImpl;
1399	BDBG_ASSERT( hImplDev );
1400
1401	*isEnableDaisyChain = hImplDev->isDaisyChain;
1402
1403	BDBG_LEAVE(BADS_3x7x_GetDaisyChain);
1404	return( retCode );
1405	}
1406
1407	/*******************************************************************************
1408	* BADS_3x7x_ResetStatus
1409	*******************************************************************************/
1410	BERR_Code BADS_3x7x_ResetStatus(
1411	BADS_ChannelHandle hChannel /* [in] Returns handle */
1412	)
1413	{
1414	BERR_Code retCode = BERR_SUCCESS;
1415	BADS_3x7x_ChannelHandle hImplChnDev = (BADS_3x7x_ChannelHandle) hChannel->pImpl;
1416	BDBG_ASSERT( hChannel );
1417	BDBG_ASSERT( hChannel->magicId == DEV_MAGIC_ID );
1418	BDBG_ENTER(BADS_3x7x_ResetStatus);
1419
1420	if (hImplChnDev->ePowerStatus != BADS_eChan_Power_On)
1421	{
1422	BDBG_WRN(("!!!BADS_3x7x_Acquire: chan power not on yet"));
1423	return BERR_NOT_INITIALIZED;
1424	}
1425	BADS_P_ChnStatusReset(hImplChnDev);
1426
1427	BDBG_LEAVE(BADS_3x7x_ResetStatus);
1428	return( retCode );
1429	}
1430
1431
1432	/*******************************************************************************
1433	* BADS_3x7x_GetInterruptEventHandle
1434	*******************************************************************************/
1435	BERR_Code BADS_3x7x_GetInterruptEventHandle(
1436	BADS_Handle hDev, /* [in] BADS handle */
1437	BKNI_EventHandle phEvent / [out] event handle */
1438	)
1439	{
1440
1441	BERR_Code retCode = BERR_SUCCESS;
1442	BADS_3x7x_Handle hImplDev;
1443
1444	BDBG_ENTER(BADS_3x7x_GetInterruptEventHandle);
1445	BDBG_ASSERT( hDev );
1446	BDBG_ASSERT( hDev->magicId == DEV_MAGIC_ID );
1447
1448	hImplDev = (BADS_3x7x_Handle) hDev->pImpl;
1449	BDBG_ASSERT( hImplDev );
1450	*phEvent = hImplDev->hIntEvent;
1451
1452
1453	BDBG_LEAVE(BADS_3x7x_GetInterruptEventHandle);
1454	return( retCode );
1455	}
1456
1457	/*******************************************************************************
1458	* BADS_3x7x_ProcessInterruptEvent
1459	*******************************************************************************/
1460	BERR_Code BADS_3x7x_ProcessInterruptEvent(
1461	BADS_Handle hDev /* [in] Returns handle */
1462	)
1463	{
1464	BERR_Code retCode = BERR_SUCCESS;
1465	BADS_3x7x_Handle hImplDev;
1466	BADS_3x7x_ChannelHandle hImplChnDev;
1467
1468
1469	BDBG_ENTER(BADS_3x7x_ProcessInterruptEvent);
1470	BDBG_ASSERT( hDev );
1471	BDBG_ASSERT( hDev->magicId == DEV_MAGIC_ID );
1472
1473	hImplDev = (BADS_3x7x_Handle) hDev->pImpl;
1474	BDBG_ASSERT( hImplDev );
1475	hImplChnDev = (BADS_3x7x_ChannelHandle)(hImplDev->hAdsChn[0]);
1476	BDBG_MSG(("BADS_3x7x_ProcessInterruptEvent"));
1477
1478	if (hImplChnDev->ePowerStatus != BADS_eChan_Power_On)
1479	{
1480	BDBG_WRN(("!!!BADS_3x7x_Acquire: chan power not on yet"));
1481	return BERR_NOT_INITIALIZED;
1482	}
1483
1484	BTMR_StopTimer(hImplDev->hTimer); /* the timer is in Micro second */
1485	BKNI_ResetEvent(hImplDev->hIntEvent);
1486	BADS_P_ResetDSCore(hImplChnDev);
1487	BADS_P_Acquire(hImplChnDev);
1488	BTMR_StartTimer(hImplDev->hTimer, 25000); /* the timer is in Micro second */
1489
1490
1491	BDBG_LEAVE(BADS_3x7x_ProcessInterruptEvent);
1492	return( retCode );
1493	}
1494
1495	/*******************************************************************************
1496	* BADS_3x7x_GetChannelDefaultSettings
1497	*******************************************************************************/
1498	BERR_Code BADS_3x7x_GetChannelDefaultSettings(
1499	BADS_Handle hDev, /* [in] Device handle */
1500	unsigned int channelNo, /* [in] Channel number to default setting for */
1501	BADS_ChannelSettings pChnDefSettings / [out] Returns channel default setting */
1502	)
1503	{
1504	BERR_Code retCode = BERR_SUCCESS;
1505	BADS_3x7x_Handle hImplDev;
1506
1507	BDBG_ENTER(BADS_3x7x_GetChannelDefaultSettings);
1508	BDBG_ASSERT( hDev );
1509	BDBG_ASSERT( hDev->magicId == DEV_MAGIC_ID );
1510
1511	hImplDev = (BADS_3x7x_Handle) hDev->pImpl;
1512	BDBG_ASSERT( hImplDev );
1513
1514	switch( channelNo )
1515	{
1516	case 0:
1517	if( channelNo < hImplDev->mxChnNo )
1518	{
1519	pChnDefSettings->ifFreq = 0; /The if freq for 3x7x is set to 0 as the internal tuner does not spit out seperate if frequency. /
1520	pChnDefSettings->autoAcquire = true;
1521	pChnDefSettings->fastAcquire = false;
1522	break;
1523	}
1524	default:
1525	retCode = BERR_TRACE(BERR_INVALID_PARAMETER);
1526	break;
1527	}
1528
1529	BDBG_LEAVE(BADS_3x7x_GetChannelDefaultSettings);
1530	return( retCode );
1531	}
1532
1533	/*******************************************************************************
1534	* BADS_3x7x_Untune
1535	*******************************************************************************/
1536	BERR_Code BADS_3x7x_Untune(
1537	BADS_Handle hDev /* [in] Returns handle */
1538	)
1539	{
1540	BERR_Code retCode = BERR_SUCCESS;
1541	BADS_3x7x_Handle hImplDev;
1542
1543	BDBG_ENTER(BADS_3x7x_Untune);
1544	BDBG_ASSERT( hDev );
1545	BDBG_ASSERT( hDev->magicId == DEV_MAGIC_ID );
1546
1547	hImplDev = (BADS_3x7x_Handle) hDev->pImpl;
1548	BDBG_ASSERT( hImplDev );
1549
1550	BTMR_StopTimer(hImplDev->hTimer); /* the timer is in Micro second */
1551	hImplDev->timerStopped = true;
1552
1553	BDBG_LEAVE(BADS_3x7x_Untune);
1554	return( retCode );
1555	}
1556
1557
1558
1559	/*******************************************************************************
1560	* BADS_GetScanStatus
1561	*******************************************************************************/
1562	BERR_Code BADS_3x7x_GetScanStatus(
1563	BADS_ChannelHandle hChn, /* [in] Device channel handle */
1564	BADS_ScanStatus pChnScanStatus / [out] Device Scan Status */
1565	)
1566	{
1567	BERR_Code eResult = BERR_SUCCESS;
1568	BADS_3x7x_ChannelHandle hImplChnDev = (BADS_3x7x_ChannelHandle) hChn->pImpl;
1569	BDBG_ASSERT( hChn );
1570	BDBG_ASSERT( hChn->magicId == DEV_MAGIC_ID );
1571
1572	switch (hImplChnDev->pChnScanStatus->AcqStatus)
1573	{
1574	case BADS_3x7x_ChnScanStatus_AcqStatus_eLockedSlow:
1575	pChnScanStatus->acquisitionStatus = BADS_AcquisitionStatus_eLockedSlow;
1576	break;
1577	case BADS_3x7x_ChnScanStatus_AcqStatus_eLockedFast:
1578	pChnScanStatus->acquisitionStatus = BADS_AcquisitionStatus_eLockedFast;
1579	break;
1580	case BADS_3x7x_ChnScanStatus_AcqStatus_eNoFECLock:
1581	pChnScanStatus->acquisitionStatus = BADS_AcquisitionStatus_eUnlocked;
1582	break;
1583	case BADS_3x7x_ChnScanStatus_AcqStatus_eNoCarrier:
1584	pChnScanStatus->acquisitionStatus = BADS_AcquisitionStatus_eNoSignal;
1585	break;
1586	default:
1587	pChnScanStatus->acquisitionStatus = BADS_AcquisitionStatus_eNoSignal;
1588	break;
1589	}
1590
1591	if (hImplChnDev->pChnScanStatus->Spectrum == BADS_3x7x_ChnScanStatus_Spectrum_eNormal)
1592	pChnScanStatus->isSpectrumInverted = false;
1593	else
1594	pChnScanStatus->isSpectrumInverted = true;
1595
1596	if (hImplChnDev->pChnScanStatus->AB == BADS_3x7x_ChnScanStatus_Annex_eAnnexA)
1597	{
1598	switch (hImplChnDev->pChnScanStatus->BPS)
1599	{
1600	case BADS_3x7x_ChnScanStatus_BPS_eQam16:
1601	pChnScanStatus->modType = BADS_ModulationType_eAnnexAQam16;
1602	break;
1603	case BADS_3x7x_ChnScanStatus_BPS_eQam32:
1604	pChnScanStatus->modType = BADS_ModulationType_eAnnexAQam32;
1605	break;
1606	case BADS_3x7x_ChnScanStatus_BPS_eQam64:
1607	pChnScanStatus->modType = BADS_ModulationType_eAnnexAQam64;
1608	break;
1609	case BADS_3x7x_ChnScanStatus_BPS_eQam128:
1610	pChnScanStatus->modType = BADS_ModulationType_eAnnexAQam128;
1611	break;
1612	case BADS_3x7x_ChnScanStatus_BPS_eQam256:
1613	pChnScanStatus->modType = BADS_ModulationType_eAnnexAQam256;
1614	break;
1615	case BADS_3x7x_ChnScanStatus_BPS_eQam512:
1616	pChnScanStatus->modType = BADS_ModulationType_eAnnexAQam512;
1617	break;
1618	case BADS_3x7x_ChnScanStatus_BPS_eQam1024:
1619	pChnScanStatus->modType = BADS_ModulationType_eAnnexAQam1024;
1620	break;
1621	default:
1622	pChnScanStatus->modType = BADS_ModulationType_eAnnexAQam64;
1623	break;
1624	}
1625	}
1626	if (hImplChnDev->pChnScanStatus->AB == BADS_3x7x_ChnScanStatus_Annex_eAnnexB)
1627	{
1628	switch (hImplChnDev->pChnScanStatus->BPS)
1629	{
1630	case BADS_3x7x_ChnScanStatus_BPS_eQam16:
1631	pChnScanStatus->modType = BADS_ModulationType_eAnnexBQam16;
1632	break;
1633	case BADS_3x7x_ChnScanStatus_BPS_eQam32:
1634	pChnScanStatus->modType = BADS_ModulationType_eAnnexBQam32;
1635	break;
1636	case BADS_3x7x_ChnScanStatus_BPS_eQam64:
1637	pChnScanStatus->modType = BADS_ModulationType_eAnnexBQam64;
1638	break;
1639	case BADS_3x7x_ChnScanStatus_BPS_eQam128:
1640	pChnScanStatus->modType = BADS_ModulationType_eAnnexBQam128;
1641	break;
1642	case BADS_3x7x_ChnScanStatus_BPS_eQam256:
1643	pChnScanStatus->modType = BADS_ModulationType_eAnnexBQam256;
1644	break;
1645	case BADS_3x7x_ChnScanStatus_BPS_eQam512:
1646	pChnScanStatus->modType = BADS_ModulationType_eAnnexBQam512;
1647	break;
1648	case BADS_3x7x_ChnScanStatus_BPS_eQam1024:
1649	pChnScanStatus->modType = BADS_ModulationType_eAnnexBQam1024;
1650	break;
1651	default:
1652	pChnScanStatus->modType = BADS_ModulationType_eAnnexBQam64;
1653	break;
1654	}
1655	}
1656
1657	if (hImplChnDev->pChnScanStatus->AcqType == BADS_3x7x_ChnScanStatus_AcqType_eAuto)
1658	pChnScanStatus->autoAcquire = true;
1659	else
1660	pChnScanStatus->autoAcquire = false;
1661
1662	pChnScanStatus->symbolRate = hImplChnDev->pChnScanStatus->Symbol_Rate;
1663	pChnScanStatus->carrierFreqOffset = hImplChnDev->pChnScanStatus->RF_Offset;
1664	pChnScanStatus->interleaver = hImplChnDev->pChnScanStatus->Interleaver;
1665	return ( eResult );
1666	}
1667
1668
1669	/*******************************************************************************
1670	* BADS_GetScanStatus
1671	*******************************************************************************/
1672
1673	BERR_Code BADS_P_ResetDSCore(
1674	BADS_3x7x_ChannelHandle hImplChnDev /* [in] Device channel handle */
1675	)
1676	{
1677	BERR_Code eResult = BERR_SUCCESS;
1678	BREG_Write32(hImplChnDev->hRegister, BCHP_DS_TOPM_RST_MASK, 0xFFFFFFFF); /Enable the DS core reset /
1679	BREG_Write32(hImplChnDev->hRegister, BCHP_DS_TOPM_GBL , 0x1); /* Enable the DS core reset */
1680	BREG_Write32(hImplChnDev->hRegister, BCHP_DS_TOPM_GBL , 0x0); /* Disable the DS core reset */
1681	BKNI_Delay(20); /* it takes around 10us to be dave I used 20 Us */
1682	if (BREG_ReadField(hImplChnDev->hRegister, DS_STAT, RST_DATA_N) == 0)
1683	BDBG_ERR(("*********DS core is not coming out of reset "));
1684	return ( eResult );
1685	}
1686
1687
1688
1689
1690

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

Context Navigation

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

Download in other formats: