source: svn/newcon3bcm2_21bu/nexus/modules/frontend/7552/src/nexus_frontend_7552.c

Last change on this file was 76, checked in by megakiss, 10 years ago

1W 대기전력을 만족시키기 위하여 POWEROFF시 튜너를 Standby 상태로 함
  • Property svn:executable set to *
File size: 65.7 KB
Line 
1/***************************************************************************
2*     (c) 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: nexus_frontend_7552.c $
39* $brcm_Revision: 7 $
40* $brcm_Date: 1/16/12 5:09p $
41*
42* Module Description:
43*       The frontend_7552 module defines the common functions in signal
44*   demodulation process, including opening or closing a frontend_7552 device,
45*   acquire a DVB-T or ISDB-T signal, getting the status of the acquired
46*   channel, setting the inband transport output interface settings, detecting
47*   certain type of signal, install signal lock callback, install signal
48*   unlock callback, and etc.
49*
50* Revision History:
51*
52* $brcm_Log: /nexus/modules/frontend/7552/src/nexus_frontend_7552.c $
53*
54* 7   1/16/12 5:09p vishk
55* SW7552-191: initial frontend at run time for different bond out of
56*  7552. Bug fix.
57*
58* 6   1/16/12 4:51p vishk
59* SW7552-191: initial frontend at run time for different bond out of 7552
60*
61* SW7552-191/1   1/16/12 1:35p xhuang
62* SW7552-191: initial frontend at run time for different bond out of 7552
63*
64* 5   1/13/12 10:33a vishk
65* SW7552-147: 7552B0: Add Nexus OOB support Fix Typo.
66*
67* 4   1/12/12 3:09p vishk
68* SW7552-147: 7552B0: Add Nexus OOB support Disable OOB for A0
69*
70* 3   1/11/12 5:56p vishk
71* SW7552-147: 7552B0: Add Nexus OOB support
72*
73* NEXUS_AOB_7552/2   1/11/12 5:05p vishk
74* SW7552-147: 7552B0: Add Nexus OOB support
75*
76* NEXUS_AOB_7552/1   1/2/12 6:30p vishk
77* SW7552-147: 7552B0: Add Nexus OOB support
78*
79* 2   8/29/11 6:51p vishk
80* SW7552-112:CLONE -RF loopthrough control not exposed via API
81*  (Magnum+Nexus)
82*
83* 1   7/19/11 4:42p vishk
84* SW7552-81: Support capability to tune either QAM or OFDM signals using
85*  the same binary.
86**************************************************************************/
87#include "nexus_frontend_module.h"
88#include "btnr_3x7x.h"
89#include "bthd.h"
90#include "bthd_3x7x.h"
91#include "bads.h"
92#include "bads_priv.h"
93#include "bads_api.h"
94#include "bads_3x7x.h"
95#ifndef NEXUS_FRONTEND_7552_A0
96#include "baob.h"
97#include "btnr_ob_3x7x.h"
98#endif
99
100BDBG_MODULE(nexus_frontend_7552);
101BDBG_OBJECT_ID(NEXUS_7552);
102/*BDBG_OBJECT_ID_DECLARE(NEXUS_7552);*/
103
104typedef struct NEXUS_7552
105{
106    BDBG_OBJECT(NEXUS_7552)
107    union
108    {
109        NEXUS_FrontendQamSettings qam;
110        NEXUS_FrontendOfdmSettings ofdm;
111    } lastSettings;
112    enum
113    {
114        UNKNOWN_7552,
115        QAM_7552,
116        OFDM_7552
117    } currentMode;
118    BTNR_Handle tnrHandle;
119    BTHD_Handle thdHandle;
120    BADS_Handle adsHandle;
121    BADS_ChannelHandle channelHandle; /* 7552 has only one channel */
122    BKNI_EventHandle tnrIsrEvent;
123    BKNI_EventHandle thdIsrEvent;
124    BKNI_EventHandle adsIsrEvent;
125    BKNI_EventHandle thdLockEvent;
126    BKNI_EventHandle adsLockEvent;
127    BKNI_EventHandle ewsEvent;
128    BKNI_EventHandle bbsEvent;
129    BKNI_EventHandle channelScanEvent;
130    NEXUS_EventCallbackHandle tnrIsrEventCallback;
131    NEXUS_EventCallbackHandle thdIsrEventCallback;
132    NEXUS_EventCallbackHandle adsIsrEventCallback;
133    NEXUS_EventCallbackHandle thdLockEventCallback;
134    NEXUS_EventCallbackHandle adsLockEventCallback;
135    NEXUS_EventCallbackHandle ewsEventCallback;
136    NEXUS_EventCallbackHandle bbsEventCallback;
137    NEXUS_TaskCallbackHandle thdLockAppCallback;
138    NEXUS_IsrCallbackHandle  adsLockAppCallback;
139    NEXUS_TaskCallbackHandle ewsAppCallback;
140    NEXUS_IsrCallbackHandle tunerIsrCallback;
141    bool untuned;
142    unsigned channelScanTimeout; /* in milliseconds */
143    unsigned upperBaudSearch; /* in symbols per sec */
144    unsigned lowerBaudSearch; /* in symbols per sec */
145    unsigned frontendcount;
146    NEXUS_7552TunerRfInput rfInput;
147    bool enableRfLoopThrough;
148#ifndef NEXUS_FRONTEND_7552_A0
149    BAOB_Handle oobHandle;
150    BTNR_Handle oobTnrHandle;
151    BKNI_EventHandle oobIsrEvent;
152    BKNI_EventHandle oobLockEvent;
153    NEXUS_EventCallbackHandle oobTnrIsrEventCallback;
154    NEXUS_EventCallbackHandle oobIsrEventCallback;
155    NEXUS_IsrCallbackHandle  oobLockAppCallback;
156    NEXUS_IsrCallbackHandle oobTunerIsrCallback;
157    bool oobUntuned;
158#endif
159} NEXUS_7552;
160
161static NEXUS_7552 *p_7552device = NULL;
162
163/***************************************************************************
164 * Module callback functions for tuning
165 ***************************************************************************/
166 
167static NEXUS_Error NEXUS_Frontend_P_Init7552( const NEXUS_7552FrontendSettings *pSettings);
168static void NEXUS_Frontend_P_7552_Close(NEXUS_FrontendHandle handle);
169static void NEXUS_Frontend_P_7552_Untune(void *handle);
170static NEXUS_Error NEXUS_Frontend_P_7552_TuneQam(void *handle, const NEXUS_FrontendQamSettings *pSettings);
171static NEXUS_Error NEXUS_Frontend_P_7552_GetQamStatus(void *handle, NEXUS_FrontendQamStatus *pStatus);
172static NEXUS_Error NEXUS_Frontend_P_7552_GetSoftDecisions(void *handle, NEXUS_FrontendSoftDecision *pDecisions, size_t length);
173static void NEXUS_Frontend_P_7552_ResetStatus(void *handle);
174static NEXUS_Error NEXUS_Frontend_P_7552_GetFastStatus(void *handle, NEXUS_FrontendFastStatus *pStatus);
175#if 0
176static NEXUS_Error NEXUS_Frontend_P_7552_GetQamScanStatus(void *handle, NEXUS_FrontendQamScanStatus *pScanStatus);
177#endif
178static NEXUS_Error NEXUS_Frontend_P_7552_TuneOfdm(void *handle, const NEXUS_FrontendOfdmSettings *pSettings);
179static NEXUS_Error NEXUS_Frontend_P_7552_GetOfdmStatus(void *handle, NEXUS_FrontendOfdmStatus *pStatus);
180
181static BTHD_IsdbtTimeInterleaving NEXUS_Frontend_P_TimeInterleavingToTHD(NEXUS_FrontendOfdmTimeInterleaving nexus);
182static NEXUS_FrontendOfdmTimeInterleaving NEXUS_Frontend_P_THDToTimeInterleaving(BTHD_IsdbtTimeInterleaving magnum);
183static BTHD_CodeRate NEXUS_Frontend_P_CodeRateToTHD(NEXUS_FrontendOfdmCodeRate nexusCodeRate);
184static NEXUS_FrontendOfdmCodeRate NEXUS_Frontend_P_THDToCodeRate(BTHD_CodeRate magnum);
185static BTHD_Modulation NEXUS_Frontend_P_ModulationToTHD(NEXUS_FrontendOfdmModulation nexus);
186static NEXUS_FrontendOfdmModulation NEXUS_Frontend_P_THDToModulation(BTHD_Modulation magnum);
187#ifndef NEXUS_FRONTEND_7552_A0
188static NEXUS_Error NEXUS_Frontend_P_7552_TuneOob(void *handle, const NEXUS_FrontendOutOfBandSettings *pSettings);
189#endif
190/***************************************************************************
191Summary:
192    Lock callback handler for a 7552 Inband device
193 ***************************************************************************/
194static void NEXUS_Frontend_P_TnrIsrBBSEvent(void *pParam)
195{
196    NEXUS_7552 *pDevice = pParam;
197    BDBG_OBJECT_ASSERT(pDevice, NEXUS_7552);
198    BDBG_MSG(("Calling BTNR_3x7x_ProcessInterruptEvent"));
199    BTNR_3x7x_ProcessInterruptEvent(pDevice->tnrHandle);
200}
201static void NEXUS_Frontend_P_7552_ThdIsrEvent(void *pParam)
202{
203    NEXUS_7552 *pDevice = pParam;
204    BDBG_OBJECT_ASSERT(pDevice, NEXUS_7552);
205
206    BDBG_MSG(("Calling BTHD_ProcessInterruptEvent"));
207    BTHD_ProcessInterruptEvent(pDevice->thdHandle);
208}
209static void NEXUS_Frontend_P_7552_ThdLockEvent(void *pParam)
210{
211    NEXUS_7552 *pDevice = pParam;
212
213    BDBG_OBJECT_ASSERT(pDevice, NEXUS_7552);
214    BDBG_MSG(("OFDM lock event set"));
215    NEXUS_TaskCallback_Fire(pDevice->thdLockAppCallback);
216}
217
218static void NEXUS_Frontend_P_7552_ThdEwsEvent(void *pParam)
219{
220    NEXUS_7552 *pDevice = pParam;
221
222    BDBG_OBJECT_ASSERT(pDevice, NEXUS_7552);
223    BDBG_MSG(("OFDM EWS event set"));
224    NEXUS_TaskCallback_Fire(pDevice->ewsAppCallback);
225}
226static void NEXUS_Frontend_P_7552_ThdBbsEvent(void *pParam)
227{
228    NEXUS_7552 *pDevice = pParam;
229    BDBG_OBJECT_ASSERT(pDevice, NEXUS_7552);
230
231    BDBG_MSG(("Calling BTHD_ProcessBBSInterruptEvent"));
232    BTHD_ProcessBBSInterruptEvent(pDevice->thdHandle);
233}
234static void NEXUS_Frontend_P_7552_ThdTuner_isr(void *pParam)
235{
236    NEXUS_Error rc = NEXUS_SUCCESS;
237    /* NOTE: Even though the pDevice is passed in as the pParam, NEXUS_Frontend_P_7552_Tuner_isr gets called with BTHD_P_ThdCallbackData_t  as its pParam. */
238    BTHD_P_ThdCallbackData_t *pCallback;
239    BTNR_3x7x_RfStatus_t RfCallbackStatus;
240    NEXUS_7552 *pDevice;
241    BDBG_ASSERT(NULL != pParam);
242    pCallback = (BTHD_P_ThdCallbackData_t *)pParam;
243    pDevice = (NEXUS_7552 *) pCallback->hTunerChn;
244
245    if (BTHD_CallbackMode_eSetMode == pCallback->Mode) {
246        /* TODO: call the tuner with pCallback->Freq_Offset */
247        rc = BTNR_3x7x_Set_RF_Offset( pDevice->tnrHandle, pCallback->Freq_Offset, pCallback->Symbol_Rate);
248        if(rc){BERR_TRACE(rc); goto done;}
249             
250    } else {
251        /* magic numbers from hardware team */
252
253        rc = BTNR_3x7x_Get_RF_Status(pDevice->tnrHandle, &RfCallbackStatus);
254        if(rc){BERR_TRACE(rc); goto done;}
255        pCallback->RF_Freq = RfCallbackStatus.RF_Freq;
256        pCallback->Total_Mix_After_ADC = RfCallbackStatus.Total_Mix_After_ADC;
257        pCallback->PreADC_Gain_x256db  = RfCallbackStatus.PreADC_Gain_x256db;
258        pCallback->PostADC_Gain_x256db = RfCallbackStatus.PostADC_Gain_x256db;
259        pCallback->External_Gain_x256db = RfCallbackStatus.External_Gain_x256db;   
260                       
261    }
262done:
263    return;
264}
265
266static void NEXUS_Frontend_P_7552_LockChange_isr(void *pParam)
267{
268    NEXUS_IsrCallbackHandle callback = (NEXUS_IsrCallbackHandle)pParam;
269
270    if (NULL != callback) NEXUS_IsrCallback_Fire_isr(callback);
271}
272
273static void NEXUS_Frontend_P_7552_AdsTuner_isr(void *pParam)
274{
275    NEXUS_Error rc = NEXUS_SUCCESS;
276    /* NOTE: Even though the pDevice is passed in as the pParam, NEXUS_Frontend_P_7552_Ads_Tuner_isr gets called with BADS_P_AdsCallbackData_s as its pParam. */
277    BADS_P_AdsCallbackData_t *pCallback;
278    BTNR_3x7x_RfStatus_t RfCallbackStatus;
279    NEXUS_7552 *pDevice;
280    BDBG_ASSERT(NULL != pParam);
281    pCallback = (BADS_P_AdsCallbackData_t *)pParam;
282    pDevice = (NEXUS_7552 *) pCallback->hTunerChn;
283
284    if (BADS_CallbackMode_eSetMode == pCallback->Mode) {
285        /* TODO: call the tuner with pCallback->Freq_Offset */
286        rc = BTNR_3x7x_Set_RF_Offset( pDevice->tnrHandle, pCallback->Freq_Offset, pCallback->Symbol_Rate);
287        if(rc){BERR_TRACE(rc); goto done;}     
288    } else {
289        /* magic numbers from hardware team */
290
291        rc = BTNR_3x7x_Get_RF_Status(pDevice->tnrHandle, &RfCallbackStatus);
292        if(rc){BERR_TRACE(rc); goto done;}
293        pCallback->RF_Freq = RfCallbackStatus.RF_Freq;
294        pCallback->Total_Mix_After_ADC = RfCallbackStatus.Total_Mix_After_ADC;
295        pCallback->PreADC_Gain_x256db  = RfCallbackStatus.PreADC_Gain_x256db;
296        pCallback->PostADC_Gain_x256db = RfCallbackStatus.PostADC_Gain_x256db;
297        pCallback->External_Gain_x256db = RfCallbackStatus.External_Gain_x256db; 
298        pCallback->Freq_Offset = RfCallbackStatus.RF_Offset;
299        pCallback->Symbol_Rate = RfCallbackStatus.Symbol_Rate;
300    }
301done:
302    return;
303}
304
305/***************************************************************************
306Summary:
307    ISR Event Handler for a 7552 device
308 ***************************************************************************/
309static void NEXUS_Frontend_P_7552_AdsIsrEvent(void *pParam)
310{
311    NEXUS_7552 *pDevice = pParam;
312    BDBG_OBJECT_ASSERT(pDevice, NEXUS_7552);
313
314    BDBG_MSG(("Calling BADS_ProcessInterruptEvent"));
315    BADS_ProcessInterruptEvent(pDevice->adsHandle);
316}
317
318#ifndef NEXUS_FRONTEND_7552_A0
319static void NEXUS_Frontend_P_oobIsrBBSEvent(void *pParam)
320{
321    NEXUS_7552 *pDevice = pParam;
322    BDBG_OBJECT_ASSERT(pDevice, NEXUS_7552);
323    BDBG_MSG(("Calling BTNR_Ob_3x7x_ProcessInterruptEvent"));
324    BTNR_Ob_3x7x_ProcessInterruptEvent(pDevice->oobTnrHandle);
325}
326#endif
327
328/***************************************************************************
329Summary:
330    Get the default settings for a BCM7552 Frontend
331See Also:
332    NEXUS_Frontend_Open7552
333 ***************************************************************************/
334void NEXUS_Frontend_GetDefault7552Settings(NEXUS_7552FrontendSettings *pSettings )
335{
336    BDBG_ASSERT(NULL != pSettings);
337    BKNI_Memset(pSettings, 0, sizeof*(pSettings));
338    pSettings->supportIsdbt = true;
339}
340
341static NEXUS_Error NEXUS_Frontend_P_Init7552(const NEXUS_7552FrontendSettings *pSettings )
342{
343    NEXUS_Error rc = NEXUS_SUCCESS;
344    NEXUS_7552 *pDevice = p_7552device;
345    BTNR_3x7x_Settings tnrSettings;
346    BADS_Settings adsSettings;
347    BTHD_Settings thdSettings;
348    BTNR_Handle tnrHandle;
349    unsigned numChannels;
350    BADS_ChannelSettings channelSettings;
351#ifndef NEXUS_FRONTEND_7552_A0
352    BTNR_Ob_3x7x_Settings oobTnrSettings;
353    BAOB_Settings oobSettings;
354#endif
355   
356    BDBG_ASSERT(NULL != pSettings);
357
358    if ( NULL == pDevice)
359    {
360        pDevice = (NEXUS_7552 *) BKNI_Malloc(sizeof(NEXUS_7552));
361        if (NULL == pDevice) {rc = BERR_TRACE(NEXUS_OUT_OF_DEVICE_MEMORY); goto err_create;}
362
363        BKNI_Memset(pDevice, 0, sizeof(*pDevice));
364        BDBG_OBJECT_SET(pDevice, NEXUS_7552);
365
366        tnrSettings.i2cAddr = 0;
367        tnrSettings.hTmr = g_pCoreHandles->tmr;
368        tnrSettings.hHeap = g_pCoreHandles->heap[0];
369       
370        rc = BTNR_3x7x_Open(&tnrHandle, &tnrSettings, g_pCoreHandles->reg);
371        if(rc){rc = BERR_TRACE(rc); goto err_malloc;}
372       
373        rc = BTNR_3x7x_GetInterruptEventHandle(tnrHandle, &pDevice->tnrIsrEvent);
374        if(rc){rc = BERR_TRACE(rc); goto err_malloc;}
375       
376        pDevice->tnrIsrEventCallback = NEXUS_RegisterEvent(pDevice->tnrIsrEvent, NEXUS_Frontend_P_TnrIsrBBSEvent, pDevice);
377        if(rc){rc = BERR_TRACE(rc); goto err_malloc;}
378       
379        pDevice->tnrHandle = tnrHandle;
380        pDevice->frontendcount = 0;
381        pDevice->rfInput = NEXUS_7552TunerRfInput_eInternalLna;
382        p_7552device = pDevice; 
383    }
384
385    if ((NULL == pDevice->adsHandle) && (pSettings->type == NEXUS_7552ChannelType_eQam)) {
386        /* get default settings and update */
387        rc = BADS_3x7x_GetDefaultSettings(&adsSettings, NULL);
388        if(rc){rc = BERR_TRACE(rc); goto err_malloc;}
389       
390        adsSettings.hTmr = g_pCoreHandles->tmr;
391        adsSettings.hHeap = g_pCoreHandles->heap[0];
392
393        /* Open ADS device */
394        rc = BADS_Open(&pDevice->adsHandle, g_pCoreHandles->chp, g_pCoreHandles->reg, g_pCoreHandles->bint, &adsSettings);
395        if(rc){rc = BERR_TRACE(rc); goto err_malloc;}
396
397        /* Initialize Acquisition Processor */
398        BDBG_MSG(("Initializating QAM core..."));
399        rc = BADS_Init(pDevice->adsHandle);
400        if(rc){rc = BERR_TRACE(rc); goto err_open_ads;}
401        BDBG_MSG(("Initializating QAM core... Done"));
402
403        /* Open the ADS channel handles */
404        rc = BADS_GetTotalChannels(pDevice->adsHandle, &numChannels);
405        if(rc){rc = BERR_TRACE(rc); goto err_open_ads;}
406
407        /* only one channel in 7552 is asserted */
408        BDBG_ASSERT(1 == numChannels);
409
410        rc = BADS_GetChannelDefaultSettings(pDevice->adsHandle, 0, &channelSettings);
411        if(rc){rc = BERR_TRACE(rc); goto err_open_ads;}
412
413        rc = BADS_OpenChannel(pDevice->adsHandle, &pDevice->channelHandle, 0, &channelSettings);
414        if(rc){rc = BERR_TRACE(rc); goto err_open_ads;}
415    }
416   
417    if ((NULL == pDevice->thdHandle) && (pSettings->type == NEXUS_7552ChannelType_eOfdm)) {
418        BTHD_3x7x_GetDefaultSettings(&thdSettings);
419        thdSettings.hTmr = g_pCoreHandles->tmr;
420        thdSettings.hHeap = g_pCoreHandles->heap[0];
421        thdSettings.supportIsdbt = pSettings->supportIsdbt;
422
423        /* Open THD device */
424        rc = BTHD_Open(&pDevice->thdHandle, g_pCoreHandles->chp, (void*)g_pCoreHandles->reg, g_pCoreHandles->bint, &thdSettings);
425        if(rc){rc = BERR_TRACE(rc); goto err_open_channel;}
426
427        /* Initialize Acquisition Processor */
428        BDBG_MSG(("Initializating OFDM core..."));
429        rc = BTHD_Init(pDevice->thdHandle, NULL, 0);
430        if(rc){rc = BERR_TRACE(rc); goto err_open_thd;}
431        BDBG_MSG(("Initializating OFDM core... Done"));
432
433        /* Get events and register callbacks */
434        rc = BTHD_GetInterruptEventHandle(pDevice->thdHandle, &pDevice->thdIsrEvent);
435        if(rc){rc = BERR_TRACE(rc); goto err_open_thd;}
436
437        pDevice->thdIsrEventCallback = NEXUS_RegisterEvent(pDevice->thdIsrEvent, NEXUS_Frontend_P_7552_ThdIsrEvent, pDevice);
438        if(rc){rc = BERR_TRACE(rc); goto err_open_thd;}
439
440        rc = BTHD_GetLockStateChangeEventHandle(pDevice->thdHandle, &pDevice->thdLockEvent);
441        if(rc){rc = BERR_TRACE(rc); goto err_isr_callback;}
442
443        pDevice->thdLockEventCallback = NEXUS_RegisterEvent(pDevice->thdLockEvent, NEXUS_Frontend_P_7552_ThdLockEvent, pDevice);
444        if(rc){rc = BERR_TRACE(rc); goto err_isr_callback;}
445
446        rc = BTHD_GetEWSEventHandle(pDevice->thdHandle, &pDevice->ewsEvent);
447        if(rc){rc = BERR_TRACE(rc); goto err_lock_callback;}
448
449        pDevice->ewsEventCallback = NEXUS_RegisterEvent(pDevice->ewsEvent, NEXUS_Frontend_P_7552_ThdEwsEvent, pDevice);
450        if(rc){rc = BERR_TRACE(rc); goto err_lock_callback;}
451
452        rc = BTHD_GetBBSInterruptEventHandle(pDevice->thdHandle, &pDevice->bbsEvent);
453        if(rc){rc = BERR_TRACE(rc); goto err_ews_callback;}
454
455        pDevice->bbsEventCallback = NEXUS_RegisterEvent(pDevice->bbsEvent, NEXUS_Frontend_P_7552_ThdBbsEvent, pDevice);
456        if(rc){rc = BERR_TRACE(rc); goto err_ews_callback;}
457
458        /* NOTE: Even though the pDevice is passed in as the pParam, NEXUS_Frontend_P_7552_Tuner_isr gets called with BTHD_P_ThdCallbackData_t  as its pParam. */
459        rc = BTHD_InstallCallback(pDevice->thdHandle, BTHD_Callback_eTuner, (BTHD_CallbackFunc)NEXUS_Frontend_P_7552_ThdTuner_isr, (void*)pDevice);
460        if(rc){rc = BERR_TRACE(rc); goto err_bbs_callback;}
461    }
462
463#ifndef NEXUS_FRONTEND_7552_A0
464    if ((NULL == pDevice->oobHandle) && (pSettings->type == NEXUS_7552ChannelType_eOutOfBand)) {
465        oobTnrSettings.i2cAddr = 0;
466        oobTnrSettings.hTmr = g_pCoreHandles->tmr;
467        oobTnrSettings.hHeap = g_pCoreHandles->heap[0];
468
469        rc = BTNR_Ob_3x7x_Open(&tnrHandle, &oobTnrSettings, g_pCoreHandles->reg);
470        if(rc){rc = BERR_TRACE(rc); goto err_malloc;}
471       
472        rc = BTNR_Ob_3x7x_GetInterruptEventHandle(tnrHandle, &pDevice->tnrIsrEvent);
473        if(rc){rc = BERR_TRACE(rc); goto err_malloc;}
474       
475        pDevice->oobTnrIsrEventCallback = NEXUS_RegisterEvent(pDevice->tnrIsrEvent, NEXUS_Frontend_P_oobIsrBBSEvent, pDevice);
476        if(rc){rc = BERR_TRACE(rc); goto err_malloc;}
477       
478        pDevice->oobTnrHandle = tnrHandle;
479       
480        /* get default settings and update */
481        rc = BAOB_GetDefaultSettings(&oobSettings, NULL);
482        if(rc){rc = BERR_TRACE(rc); goto err_bbs_callback;}
483       
484        oobSettings.hTmr = g_pCoreHandles->tmr;
485        oobSettings.hHeap = g_pCoreHandles->heap[0];
486
487        /* Open AOB device */
488        rc = BAOB_Open(&pDevice->oobHandle, g_pCoreHandles->chp, g_pCoreHandles->reg, g_pCoreHandles->bint, &oobSettings);
489        if(rc){rc = BERR_TRACE(rc); goto err_bbs_callback;}
490    }
491#endif
492
493    return rc;
494
495err_bbs_callback:
496    NEXUS_UnregisterEvent(pDevice->bbsEventCallback);
497err_ews_callback:
498    NEXUS_UnregisterEvent(pDevice->ewsEventCallback);
499err_lock_callback:
500    NEXUS_UnregisterEvent(pDevice->thdLockEventCallback);
501err_isr_callback:
502    NEXUS_UnregisterEvent(pDevice->thdIsrEventCallback);
503err_open_thd:
504    BTHD_Close(pDevice->thdHandle);
505err_open_channel:
506    BADS_CloseChannel(pDevice->channelHandle);
507err_open_ads:
508    BADS_Close(pDevice->adsHandle);
509err_malloc:
510    BDBG_OBJECT_DESTROY(pDevice, NEXUS_7552);
511    BKNI_Free(pDevice);
512err_create:
513    return rc; 
514}
515
516/***************************************************************************
517Summary:
518    Open a handle to a BCM7552 device.
519 ***************************************************************************/
520NEXUS_FrontendHandle NEXUS_Frontend_Open7552( const NEXUS_7552FrontendSettings *pSettings )
521{
522    BERR_Code rc;
523    NEXUS_FrontendHandle frontendHandle;
524    NEXUS_7552 *pDevice=NULL;
525    NEXUS_IsrCallbackHandle callbackLockChange;
526
527    BDBG_ASSERT(NULL != pSettings);
528
529    rc = NEXUS_Frontend_P_Init7552(pSettings);
530    if(rc){rc = BERR_TRACE(rc); goto done;}
531
532    pDevice = p_7552device;
533
534    /* Create a Nexus frontend handle */
535    frontendHandle = NEXUS_Frontend_P_Create(pDevice);
536    if(rc){rc = BERR_TRACE(rc); goto done;}
537
538    if (pSettings->type == NEXUS_7552ChannelType_eQam){
539
540        /* Establish device capabilities */
541        frontendHandle->capabilities.qam = true;
542        frontendHandle->capabilities.scan = false;
543        /* QAM 16/32/64/128/256 are supported, others are not */
544        frontendHandle->capabilities.qamModes[NEXUS_FrontendQamMode_e16] = true;
545        frontendHandle->capabilities.qamModes[NEXUS_FrontendQamMode_e32] = true;
546        frontendHandle->capabilities.qamModes[NEXUS_FrontendQamMode_e64] = true;
547        frontendHandle->capabilities.qamModes[NEXUS_FrontendQamMode_e128] = true;
548        frontendHandle->capabilities.qamModes[NEXUS_FrontendQamMode_e256] = true;
549
550        /* Bind required callbacks */
551        frontendHandle->tuneQam = NEXUS_Frontend_P_7552_TuneQam;
552        frontendHandle->getQamStatus = NEXUS_Frontend_P_7552_GetQamStatus;
553#if 0   
554        frontendHandle->getQamScanStatus = NEXUS_Frontend_P_7552_GetQamScanStatus;
555#endif
556        callbackLockChange = NEXUS_IsrCallback_Create(frontendHandle, NULL);
557        if(rc){rc = BERR_TRACE(rc); goto err_frontendhandle;}
558
559        rc = BADS_InstallCallback(pDevice->channelHandle, BADS_Callback_eLockChange, (BADS_CallbackFunc)NEXUS_Frontend_P_7552_LockChange_isr, (void*)callbackLockChange);
560        if(rc){rc = BERR_TRACE(rc); goto err_lockchangeisr_callback;}
561
562        /* NOTE: Even though the pDevice is passed in as the pParam, NEXUS_Frontend_P_7552_Ads_Tuner_isr gets called with BADS_P_AdsCallbackData_s as its pParam. */
563        rc = BADS_InstallCallback(pDevice->channelHandle, BADS_Callback_eTuner, (BADS_CallbackFunc)NEXUS_Frontend_P_7552_AdsTuner_isr, (void*)pDevice);
564        if(rc){rc = BERR_TRACE(rc); goto err_lockchangeisr_callback;}
565
566        pDevice->adsLockAppCallback = callbackLockChange;
567        pDevice->frontendcount++;
568
569        /* Get events and register callbacks */
570        rc = BADS_GetInterruptEventHandle(pDevice->adsHandle, &pDevice->adsIsrEvent);
571        if(rc){rc = BERR_TRACE(rc); goto err_lockchangeisr_callback;}
572
573        pDevice->adsIsrEventCallback = NEXUS_RegisterEvent(pDevice->adsIsrEvent, NEXUS_Frontend_P_7552_AdsIsrEvent, pDevice);
574        if(rc){rc = BERR_TRACE(rc); goto err_lockchangeisr_callback;}
575
576    }
577    else if(pSettings->type == NEXUS_7552ChannelType_eOfdm){         
578
579        pDevice->frontendcount++;
580
581        pDevice->thdLockAppCallback = NEXUS_TaskCallback_Create(frontendHandle, NULL);
582        if(rc){rc = BERR_TRACE(rc); goto err_frontendhandle;}
583
584        pDevice->ewsAppCallback = NEXUS_TaskCallback_Create(frontendHandle, NULL);
585        if(rc){rc = BERR_TRACE(rc); goto err_lock_app_callback;}
586       
587        /* Establish device capabilities */
588        frontendHandle->capabilities.ofdm = true;
589
590        /* DVB-T is supported, but ISDB-T is supported only when it is requested */
591        frontendHandle->capabilities.ofdmModes[NEXUS_FrontendOfdmMode_eDvbt] = true;
592        frontendHandle->capabilities.ofdmModes[NEXUS_FrontendOfdmMode_eIsdbt] = pSettings->supportIsdbt;
593
594        /* Bind required callbacks */
595        frontendHandle->tuneOfdm = NEXUS_Frontend_P_7552_TuneOfdm;
596        frontendHandle->getOfdmStatus = NEXUS_Frontend_P_7552_GetOfdmStatus;
597       
598    }
599#ifndef NEXUS_FRONTEND_7552_A0
600    else if(pSettings->type == NEXUS_7552ChannelType_eOutOfBand){
601       
602        pDevice->frontendcount++;
603       
604        frontendHandle->capabilities.outOfBand = true; 
605        frontendHandle->tuneOutOfBand = NEXUS_Frontend_P_7552_TuneOob;
606
607        callbackLockChange = NEXUS_IsrCallback_Create(frontendHandle, NULL);
608        if(rc){rc = BERR_TRACE(rc); goto err_frontendhandle;}
609
610        rc = BAOB_InstallCallback(pDevice->oobHandle, BAOB_Callback_eLockChange, (BAOB_CallbackFunc)NEXUS_Frontend_P_7552_LockChange_isr, (void*)callbackLockChange);
611        if(rc){rc = BERR_TRACE(rc); goto err_lockchangeisr_callback;}
612
613        pDevice->oobLockAppCallback = callbackLockChange;   
614    }
615#endif 
616    frontendHandle->close = NEXUS_Frontend_P_7552_Close;
617    frontendHandle->untune = NEXUS_Frontend_P_7552_Untune;
618    frontendHandle->getFastStatus = NEXUS_Frontend_P_7552_GetFastStatus;
619    frontendHandle->resetStatus = NEXUS_Frontend_P_7552_ResetStatus;
620    frontendHandle->getSoftDecisions = NEXUS_Frontend_P_7552_GetSoftDecisions;
621
622    pDevice->currentMode = UNKNOWN_7552;
623    frontendHandle->chip.familyId = 0x7552;
624    return frontendHandle;
625
626err_lock_app_callback:
627    NEXUS_TaskCallback_Destroy(pDevice->thdLockAppCallback);
628err_lockchangeisr_callback:
629    NEXUS_IsrCallback_Destroy(callbackLockChange);
630err_frontendhandle:
631    NEXUS_Frontend_P_Destroy(frontendHandle);
632done:
633    return NULL;
634}
635
636/***************************************************************************
637Summary:
638    Close a handle to a BCM7552 device.
639See Also:
640    NEXUS_Frontend_Open7552
641 ***************************************************************************/
642static void NEXUS_Frontend_P_7552_Close( NEXUS_FrontendHandle handle )
643{
644    NEXUS_7552 *pDevice;
645    NEXUS_FrontendCapabilities capabilities;
646    BDBG_OBJECT_ASSERT(handle, NEXUS_Frontend);
647    pDevice = (NEXUS_7552 *)handle->pDeviceHandle;
648    BDBG_OBJECT_ASSERT(pDevice, NEXUS_7552);
649
650    NEXUS_Frontend_GetCapabilities(handle, &capabilities);
651   
652    if ( capabilities.qam ){
653        if (pDevice->adsIsrEventCallback) NEXUS_UnregisterEvent(pDevice->adsIsrEventCallback);
654        pDevice->adsIsrEventCallback = NULL;     
655        if(pDevice->adsLockAppCallback) NEXUS_IsrCallback_Destroy(pDevice->adsLockAppCallback);
656        pDevice->adsLockAppCallback = NULL;   
657       
658        if(pDevice->channelScanEvent)BKNI_DestroyEvent(pDevice->channelScanEvent);
659
660        if(pDevice->channelHandle)BADS_CloseChannel(pDevice->channelHandle);
661        pDevice->channelHandle = NULL;
662        if(pDevice->adsHandle)BADS_Close(pDevice->adsHandle);
663        pDevice->adsHandle = NULL;
664
665        if(handle) NEXUS_Frontend_P_Destroy(handle);
666        pDevice->frontendcount--;
667    }
668    else if(capabilities.ofdm){
669       
670        if (pDevice->thdLockAppCallback) NEXUS_TaskCallback_Destroy(pDevice->thdLockAppCallback);
671        pDevice->thdLockAppCallback = NULL;
672        if (pDevice->ewsAppCallback) NEXUS_TaskCallback_Destroy(pDevice->ewsAppCallback);
673        pDevice->ewsAppCallback = NULL;
674       
675        if(pDevice->ewsEventCallback)NEXUS_UnregisterEvent(pDevice->ewsEventCallback);
676        pDevice->ewsEventCallback = NULL;
677        if(pDevice->thdLockEventCallback)NEXUS_UnregisterEvent(pDevice->thdLockEventCallback);
678        pDevice->thdLockEventCallback = NULL;
679        if(pDevice->thdIsrEventCallback)NEXUS_UnregisterEvent(pDevice->thdIsrEventCallback);
680        pDevice->thdIsrEventCallback = NULL;
681        if(pDevice->bbsEventCallback)NEXUS_UnregisterEvent(pDevice->bbsEventCallback);
682        pDevice->bbsEventCallback = NULL;
683
684        if(pDevice->thdHandle)BTHD_Close(pDevice->thdHandle);
685        pDevice->thdHandle = NULL;
686
687        if(handle) NEXUS_Frontend_P_Destroy(handle);
688        pDevice->frontendcount--;       
689    }
690#ifndef NEXUS_FRONTEND_7552_A0
691    else if(capabilities.outOfBand){
692       
693        if (pDevice->oobLockAppCallback) NEXUS_IsrCallback_Destroy(pDevice->oobLockAppCallback);
694        pDevice->oobLockAppCallback = NULL;     
695
696        if(pDevice->oobHandle)BAOB_Close(pDevice->oobHandle);
697        pDevice->oobHandle = NULL;
698
699        if(handle) NEXUS_Frontend_P_Destroy(handle);
700        pDevice->frontendcount--;       
701    }
702#endif 
703    if(!pDevice->frontendcount){
704        if (pDevice->tnrIsrEventCallback) NEXUS_UnregisterEvent(pDevice->tnrIsrEventCallback);
705        pDevice->tnrIsrEventCallback = NULL;
706        if(pDevice->tnrHandle) BTNR_Close(pDevice->tnrHandle);
707        pDevice->tnrHandle = NULL;
708#ifndef NEXUS_FRONTEND_7552_A0
709        if (pDevice->oobTnrIsrEventCallback) NEXUS_UnregisterEvent(pDevice->oobTnrIsrEventCallback);
710        pDevice->oobTnrIsrEventCallback = NULL;
711        if(pDevice->oobTnrHandle) BTNR_Close(pDevice->oobTnrHandle);
712        pDevice->oobTnrHandle = NULL;
713#endif     
714        BDBG_OBJECT_DESTROY(pDevice, NEXUS_7552);
715        if (pDevice) BKNI_Free(pDevice);
716    }
717}
718
719/***************************************************************************
720 * Module callback functions for tuning
721 ***************************************************************************/
722static void NEXUS_Frontend_P_7552_Untune( void *handle )
723{
724    NEXUS_Error rc = NEXUS_SUCCESS;
725    NEXUS_7552 *pDevice;
726    BTNR_PowerSaverSettings pwrSettings;
727    BDBG_ASSERT(handle != NULL);
728    pDevice = (NEXUS_7552 *)handle;
729    BDBG_OBJECT_ASSERT(pDevice, NEXUS_7552);
730
731    if (!pDevice->untuned) { 
732        if(pDevice->thdIsrEventCallback)NEXUS_UnregisterEvent(pDevice->thdIsrEventCallback); 
733        pDevice->thdIsrEventCallback = NULL;
734        if(pDevice->adsIsrEventCallback)NEXUS_UnregisterEvent(pDevice->adsIsrEventCallback);   
735        pDevice->adsIsrEventCallback = NULL;
736       
737        rc = BADS_Untune(pDevice->adsHandle);
738        if(rc){rc = BERR_TRACE(rc); goto done;}
739        pDevice->untuned = true;
740
741        rc = BADS_EnablePowerSaver(pDevice->channelHandle);
742        if(rc){rc = BERR_TRACE(rc); goto done;}
743
744        pwrSettings.enable = true;
745        rc = BTNR_SetPowerSaver(pDevice->tnrHandle, &pwrSettings);
746        if(rc){rc = BERR_TRACE(rc); goto done;}
747    }
748done:
749    pDevice->currentMode = UNKNOWN_7552;
750}
751
752static NEXUS_Error NEXUS_Frontend_P_7552_TuneQam( void *handle, const NEXUS_FrontendQamSettings *pSettings )
753{
754    NEXUS_Error rc = NEXUS_SUCCESS;
755    NEXUS_7552 *pDevice;
756    BADS_InbandParam params;
757    BADS_ModulationType qam_mode;
758    uint32_t symbolRate = 0;
759    BTNR_PowerSaverSettings pwrSettings;
760    BTNR_Settings tnrSettings;
761    BADS_ChannelScanSettings scanParam;
762    BDBG_ASSERT(handle != NULL);
763    pDevice = (NEXUS_7552 *)handle;
764    BDBG_OBJECT_ASSERT(pDevice, NEXUS_7552);
765    BDBG_ASSERT(NULL != pSettings);
766
767    pDevice->currentMode = QAM_7552;
768    pDevice->lastSettings.qam = *pSettings;
769
770    if (pDevice->untuned) {
771        /* Get interrupt event and register callback */
772        rc = BADS_GetInterruptEventHandle(pDevice->adsHandle, &pDevice->adsIsrEvent);
773        if(rc){rc = BERR_TRACE(rc); goto done;}
774
775        pDevice->adsIsrEventCallback = NEXUS_RegisterEvent(pDevice->adsIsrEvent, NEXUS_Frontend_P_7552_AdsIsrEvent, pDevice);
776        if (NULL == pDevice->adsIsrEventCallback){rc = BERR_TRACE(BERR_OUT_OF_SYSTEM_MEMORY); goto done; }
777    }
778
779    if (pDevice->tnrHandle)
780    {
781        /* TODO: we should be able to call BTNR_SetSettings after BTNR_SetPowerSaver. verify */
782        pwrSettings.enable = false;     
783        rc = BTNR_SetPowerSaver(pDevice->tnrHandle, &pwrSettings);
784        if(rc){rc = BERR_TRACE(rc); goto done;}
785
786        rc = BTNR_GetSettings(pDevice->tnrHandle, &tnrSettings);
787        if(rc){rc = BERR_TRACE(rc); goto done;}
788
789        tnrSettings.tnrApplication = pSettings->terrestrial?BTNR_TunerApplication_eTerrestrial:BTNR_TunerApplication_eCable;
790        tnrSettings.bandwidth = pSettings->bandwidth;
791        tnrSettings.rfInputMode = pDevice->rfInput;       
792        rc = BTNR_SetSettings(pDevice->tnrHandle, &tnrSettings);
793        if(rc){rc = BERR_TRACE(rc); goto done;}
794       
795        rc = BADS_DisablePowerSaver(pDevice->channelHandle);
796        if(rc){rc = BERR_TRACE(rc); goto done;}
797       
798        rc = BTNR_SetTunerRfFreq(pDevice->tnrHandle, pSettings->frequency, BTNR_TunerMode_eDigital);
799        if(rc){rc = BERR_TRACE(rc); goto done;}
800    }
801
802
803    switch (pSettings->annex) {
804    case NEXUS_FrontendQamAnnex_eA:
805        switch (pSettings->mode) {
806        case NEXUS_FrontendQamMode_e16:
807            qam_mode = BADS_ModulationType_eAnnexAQam16;
808            break;
809        case NEXUS_FrontendQamMode_e32:
810            qam_mode = BADS_ModulationType_eAnnexAQam32;
811            break;
812        case NEXUS_FrontendQamMode_e64:
813            qam_mode = BADS_ModulationType_eAnnexAQam64;
814            break;
815        case NEXUS_FrontendQamMode_e128:
816            qam_mode = BADS_ModulationType_eAnnexAQam128;
817            break;
818        case NEXUS_FrontendQamMode_e256:
819            qam_mode = BADS_ModulationType_eAnnexAQam256;
820            break;
821        default:
822            BDBG_ERR(("J.83A invalid constellation (%d)", pSettings->mode));
823            rc = BERR_TRACE(BERR_INVALID_PARAMETER); goto done;
824        }
825        break;
826    case NEXUS_FrontendQamAnnex_eB:
827        /* only 6MHz, and 64/256QAM */
828        if (NEXUS_FrontendBandwidth_e6Mhz != pSettings->bandwidth) {
829            BDBG_ERR(("J.83B with non-6MHz bandwidth (%d)", pSettings->bandwidth));
830            rc = BERR_TRACE(BERR_INVALID_PARAMETER); goto done;
831        }
832        switch (pSettings->mode) {
833        case NEXUS_FrontendQamMode_e64:
834            BDBG_MSG(("J.83B with 64QAM and 5056941"));
835            /* TODO: BADS_ModulationType_eAnnexBQam64 is not making ADS happy.  For now, stick to J.83A looking identifier */
836            qam_mode = BADS_ModulationType_eAnnexBQam64;
837            symbolRate = 5056941; /* QAM64 */
838            break;
839        case NEXUS_FrontendQamMode_e256:
840            BDBG_MSG(("J.83B with 256QAM and 5360537"));
841            /* TODO: BADS_ModulationType_eAnnexBQam256 is not making ADS happy. For now, stick to J.83A looking identifier */
842            qam_mode = BADS_ModulationType_eAnnexBQam256;
843            symbolRate = 5360537; /* QAM256 */
844            break;
845        default:
846            BDBG_ERR(("J.83B invalid constellation (%d)", pSettings->mode));
847            rc = BERR_TRACE(BERR_INVALID_PARAMETER); goto done;
848        }
849        break;
850    case NEXUS_FrontendQamAnnex_eC:
851        switch (pSettings->mode) {
852        case NEXUS_FrontendQamMode_e64:
853            qam_mode = BADS_ModulationType_eAnnexCQam64;
854            symbolRate = 5274000; /* QAM64 */
855            break;
856        default:
857            BDBG_ERR(("J.83C invalid constellation (%d)", pSettings->mode));
858            rc = BERR_TRACE(BERR_INVALID_PARAMETER); goto done;
859        }
860        break;
861    default:
862        BDBG_ERR(("Invalid annex (%d)", pSettings->annex));
863        rc = BERR_TRACE(BERR_INVALID_PARAMETER); goto done;
864        break;
865    }
866
867    /* Scan Parameters */ 
868    if(pSettings->acquisitionMode == NEXUS_FrontendQamAcquisitionMode_eScan){
869        BKNI_Memset(&scanParam, 0, sizeof(scanParam));
870        scanParam.QM = true;
871        scanParam.TO = true; 
872        if( pSettings->spectrumMode == NEXUS_FrontendQamSpectrumMode_eAuto) scanParam.AI = true;       
873        if(pSettings->scan.mode[NEXUS_FrontendQamAnnex_eA][NEXUS_FrontendQamMode_e16]) scanParam.A16 = true;
874        if(pSettings->scan.mode[NEXUS_FrontendQamAnnex_eA][NEXUS_FrontendQamMode_e32]) scanParam.A32= true;
875        if(pSettings->scan.mode[NEXUS_FrontendQamAnnex_eA][NEXUS_FrontendQamMode_e64]) scanParam.A64 = true;
876        if(pSettings->scan.mode[NEXUS_FrontendQamAnnex_eA][NEXUS_FrontendQamMode_e128]) scanParam.A128 = true;
877        if(pSettings->scan.mode[NEXUS_FrontendQamAnnex_eA][NEXUS_FrontendQamMode_e256]) scanParam.A256 = true;
878        if(pSettings->scan.mode[NEXUS_FrontendQamAnnex_eA][NEXUS_FrontendQamMode_e512]) scanParam.A512 = true;
879        if(pSettings->scan.mode[NEXUS_FrontendQamAnnex_eA][NEXUS_FrontendQamMode_e1024]) scanParam.A1024 = true;
880        if(pSettings->scan.mode[NEXUS_FrontendQamAnnex_eB][NEXUS_FrontendQamMode_e64]) scanParam.B64 = true;
881        if(pSettings->scan.mode[NEXUS_FrontendQamAnnex_eB][NEXUS_FrontendQamMode_e256]) scanParam.B256 = true;
882        if(pSettings->scan.mode[NEXUS_FrontendQamAnnex_eB][NEXUS_FrontendQamMode_e1024]) scanParam.B1024 = true;
883        if(pSettings->scan.frequencyOffset){
884            scanParam.CO = true; 
885            scanParam.carrierSearch = pSettings->scan.frequencyOffset/256; 
886        }       
887        scanParam.upperBaudSearch = pSettings->scan.upperBaudSearch;
888        scanParam.lowerBaudSearch = pSettings->scan.lowerBaudSearch;
889       
890        rc = BADS_SetScanParam(pDevice->channelHandle, &scanParam );
891        if(rc){rc = BERR_TRACE(rc); goto done;}
892    }
893
894    params.modType = qam_mode;
895    params.enableDpm = pSettings->enablePowerMeasurement;
896    params.acquisitionType = pSettings->acquisitionMode;
897    params.invertSpectrum = pSettings->spectralInversion;
898    params.spectrum = pSettings->spectrumMode;
899    params.autoAcquire = pSettings->autoAcquire;
900    params.frequencyOffset = pSettings->frequencyOffset;   
901    /* if non-zero, try using what we are asked to use */
902    if (0 != pSettings->symbolRate) {
903        params.symbolRate = pSettings->symbolRate;
904    } else {
905        params.symbolRate = symbolRate;
906    }
907
908    BDBG_MSG(("Calling BADS_Acquire() with autoAcquire %d, frequencyOffset %d, enableDpm %d, spectrum %d",
909        params.autoAcquire, params.frequencyOffset, params.enableDpm, params.spectrum));
910
911    BDBG_MSG(("Calling BADS_Acquire() with modType %d, enableDpm %d, invertSpectrum %d, spectrum %d, symbolRate %d",
912        params.modType, params.enableDpm, params.invertSpectrum, params.spectrum, params.symbolRate));
913
914    NEXUS_IsrCallback_Set(pDevice->adsLockAppCallback, &pSettings->lockCallback);
915
916    rc = BADS_Acquire(pDevice->channelHandle, &params);
917        if(rc){rc = BERR_TRACE(rc); goto done;}
918
919    pDevice->untuned = false;
920done:
921    return rc;
922}
923
924static NEXUS_Error NEXUS_Frontend_P_7552_GetFastStatus(void *handle, NEXUS_FrontendFastStatus *pStatus)
925{
926    NEXUS_Error rc = NEXUS_SUCCESS;
927    NEXUS_7552 *pDevice;
928    BADS_LockStatus lockStatus; 
929    BDBG_ASSERT(handle != NULL);
930    pDevice = (NEXUS_7552 *)handle;
931    BDBG_OBJECT_ASSERT(pDevice, NEXUS_7552);
932    BDBG_ASSERT(NULL != pStatus);
933     
934    rc = BADS_GetLockStatus(pDevice->channelHandle,  &lockStatus);
935    if(rc){rc = BERR_TRACE(rc); goto done;}
936    switch ( lockStatus )
937    {
938    case BADS_LockStatus_eUnlocked:
939        pStatus->lockStatus = NEXUS_FrontendLockStatus_eUnlocked;
940        break;
941    case BADS_LockStatus_eLocked:
942        pStatus->lockStatus = NEXUS_FrontendLockStatus_eLocked;
943        break;
944    case BADS_LockStatus_eNoSignal:
945        pStatus->lockStatus = NEXUS_FrontendLockStatus_eNoSignal;
946        break;
947    default:
948        BDBG_WRN(("Unrecognized lock status (%d) ", lockStatus));
949        BERR_TRACE(BERR_NOT_SUPPORTED);
950        return NEXUS_FrontendLockStatus_eUnknown;
951    }
952done:
953    return rc;
954}
955#if 0
956static NEXUS_Error NEXUS_Frontend_P_7552_GetQamScanStatus(void *handle, NEXUS_FrontendQamScanStatus *pScanStatus)
957{
958
959    NEXUS_Error rc = NEXUS_SUCCESS;
960    NEXUS_7552 *pDevice = (NEXUS_7552 *)handle;
961    struct BADS_ScanStatus st;
962   
963    BDBG_OBJECT_ASSERT(pDevice, NEXUS_7552);
964    BDBG_ASSERT(NULL != pScanStatus);
965
966
967    BKNI_Memset(pScanStatus, 0, sizeof(*pScanStatus));
968
969    rc = BADS_GetScanStatus(pDevice->channelHandle,  &st);
970    if(rc){rc = BERR_TRACE(rc); goto done;}
971   
972    pScanStatus->spectrumInverted = st.isSpectrumInverted;
973    pScanStatus->symbolRate = st.symbolRate;
974    pScanStatus->frequencyOffset = st.carrierFreqOffset;
975    pScanStatus->interleaver = st.interleaver;
976    pScanStatus->acquisitionStatus = st.acquisitionStatus;
977    return BERR_SUCCESS;
978done:
979    return rc;
980}
981#endif
982static NEXUS_Error NEXUS_Frontend_P_7552_GetQamStatus( void *handle, NEXUS_FrontendQamStatus *pStatus )
983{
984    NEXUS_Error rc = NEXUS_SUCCESS;
985    NEXUS_7552 *pDevice;
986    BADS_Status adsStatus;
987    BDBG_ASSERT(handle != NULL);
988    pDevice = (NEXUS_7552 *)handle;
989    BDBG_OBJECT_ASSERT(pDevice, NEXUS_7552);
990    BDBG_ASSERT(NULL != pStatus);
991
992    BKNI_Memset(pStatus, 0, sizeof*(pStatus));
993
994    rc = BADS_GetStatus(pDevice->channelHandle, &adsStatus);
995    if(rc){rc = BERR_TRACE(rc); goto done;}
996
997    pStatus->fecLock = adsStatus.isFecLock;
998    pStatus->receiverLock = adsStatus.isQamLock;
999    pStatus->rfAgcLevel = adsStatus.agcExtLevel;
1000    pStatus->ifAgcLevel = adsStatus.agcIntLevel;
1001    pStatus->dsChannelPower = adsStatus.dsChannelPower;
1002    pStatus->snrEstimate = (adsStatus.snrEstimate * 100)/256;
1003    pStatus->fecCorrected = adsStatus.correctedCount;
1004    pStatus->fecUncorrected = adsStatus.uncorrectedCount;
1005    pStatus->carrierPhaseOffset = adsStatus.carrierPhaseOffset;
1006    pStatus->carrierFreqOffset = adsStatus.carrierFreqOffset;
1007    pStatus->symbolRate = adsStatus.rxSymbolRate;
1008    pStatus->symbolRateError = adsStatus.symbolRateError;
1009    pStatus->berEstimate = adsStatus.berRawCount;
1010    pStatus->mainTap = adsStatus.mainTap;
1011    pStatus->equalizerGain = adsStatus.equalizerGain;
1012    pStatus->postRsBer = 0;/* Not supported */
1013    pStatus->postRsBerElapsedTime = 0;/* Not supported */
1014    pStatus->settings = pDevice->lastSettings.qam;
1015    pStatus->spectrumInverted = adsStatus.isSpectrumInverted;
1016    pStatus->fecClean = adsStatus.cleanCount;
1017    pStatus->intAgcLevel = adsStatus.agcAGFLevel;
1018    pStatus->bitErrCorrected = adsStatus.correctedBits;
1019done:
1020    return rc;
1021}
1022
1023static NEXUS_Error NEXUS_Frontend_P_7552_GetSoftDecisions( void *handle, NEXUS_FrontendSoftDecision *pDecisions, size_t length )
1024{
1025#define TOTAL_ADS_SOFTDECISIONS 30
1026    NEXUS_Error rc = NEXUS_SUCCESS;
1027    int j;
1028    size_t i;
1029    int16_t return_length;
1030    NEXUS_7552 *pDevice;
1031    int16_t d_i[TOTAL_ADS_SOFTDECISIONS], d_q[TOTAL_ADS_SOFTDECISIONS];
1032    BDBG_ASSERT(handle != NULL);
1033    pDevice = (NEXUS_7552 *)handle;
1034    BDBG_OBJECT_ASSERT(pDevice, NEXUS_7552);
1035    BDBG_ASSERT(NULL != pDecisions);
1036
1037    BDBG_OBJECT_ASSERT(pDevice, NEXUS_7552);
1038
1039    for( i=0; i<length; i += TOTAL_ADS_SOFTDECISIONS )
1040    {
1041
1042        rc = BADS_GetSoftDecision(pDevice->channelHandle, (int16_t)TOTAL_ADS_SOFTDECISIONS,  d_i, d_q, &return_length);
1043        if(rc){rc = BERR_TRACE(rc); goto done;}
1044
1045        for ( j=0; j<TOTAL_ADS_SOFTDECISIONS && i+j<length; j++ )
1046        {
1047            pDecisions[i+j].i = d_i[j] * 2; /* Multiply by two is just a scaling factor. */
1048            pDecisions[i+j].q = d_q[j] * 2;
1049        }
1050    }
1051done:   
1052    return rc;
1053}
1054
1055static void NEXUS_Frontend_P_7552_ResetStatus( void *handle )
1056{
1057    BSTD_UNUSED(handle);
1058
1059    /*(void) BERR_TRACE(BERR_NOT_SUPPORTED);*/
1060}
1061
1062static BERR_Code NEXUS_Frontend_P_7552_TuneOfdm( void *handle, const NEXUS_FrontendOfdmSettings *pSettings )
1063{
1064    NEXUS_Error rc = NEXUS_SUCCESS;
1065    NEXUS_7552 *pDevice;
1066    BTHD_InbandParams params;
1067    BTNR_PowerSaverSettings pwrSettings;
1068    BTNR_Settings tnrSettings;
1069    BDBG_ASSERT(handle != NULL);
1070    pDevice = (NEXUS_7552 *)handle;
1071    BDBG_OBJECT_ASSERT(pDevice, NEXUS_7552);
1072    BDBG_ASSERT(NULL != pSettings);
1073
1074    if (pDevice->untuned) {
1075        /* Get interrupt event and register callback */
1076        rc = BTHD_GetInterruptEventHandle(pDevice->thdHandle, &pDevice->thdIsrEvent);
1077    if(rc){rc = BERR_TRACE(rc); goto done;}
1078
1079        pDevice->thdIsrEventCallback = NEXUS_RegisterEvent(pDevice->thdIsrEvent, NEXUS_Frontend_P_7552_ThdIsrEvent, pDevice);
1080        if (NULL == pDevice->thdIsrEventCallback) {rc = BERR_TRACE(BERR_OUT_OF_SYSTEM_MEMORY); goto done; }
1081        pDevice->untuned = false;
1082    }
1083
1084    pDevice->currentMode = OFDM_7552;
1085
1086    if (pDevice->tnrHandle)
1087    {     
1088        rc = BTNR_GetSettings(pDevice->tnrHandle, &tnrSettings);
1089    if(rc){rc = BERR_TRACE(rc); goto done;}
1090
1091        pwrSettings.enable = false;     
1092        rc = BTNR_SetPowerSaver(pDevice->tnrHandle, &pwrSettings);
1093        if(rc){rc = BERR_TRACE(rc); goto done;}
1094
1095        tnrSettings.tnrApplication = pSettings->terrestrial?BTNR_TunerApplication_eTerrestrial:BTNR_TunerApplication_eCable;
1096        tnrSettings.bandwidth = pSettings->bandwidth;
1097        tnrSettings.rfInputMode = pDevice->rfInput;
1098        rc = BTNR_SetSettings(pDevice->tnrHandle, &tnrSettings);
1099        if(rc){rc = BERR_TRACE(rc); goto done;}
1100
1101        rc = BTNR_SetTunerRfFreq(pDevice->tnrHandle, pSettings->frequency, BTNR_TunerMode_eDigital);
1102        if(rc){rc = BERR_TRACE(rc); goto done;}
1103    }
1104
1105    rc = BTHD_GetDefaultInbandParams(pDevice->thdHandle, &params);
1106    if(rc){rc = BERR_TRACE(rc); goto done;}
1107
1108    switch (pSettings->mode) {
1109    case NEXUS_FrontendOfdmMode_eDvbt:
1110        params.mode = BTHD_InbandMode_eDvbt;
1111        break;
1112    case NEXUS_FrontendOfdmMode_eIsdbt:
1113        params.mode = BTHD_InbandMode_eIsdbt;
1114        break;
1115    default:
1116        BDBG_ERR(("Invalid OFDM Mode"));
1117        rc = BERR_TRACE(BERR_INVALID_PARAMETER); goto done;
1118    }
1119    params.decodeMode = (NEXUS_FrontendOfdmPriority_eHigh == pSettings->priority) ? BTHD_Decode_Hp : BTHD_Decode_Lp;
1120    params.cciMode = (NEXUS_FrontendOfdmCciMode_eNone == pSettings->cciMode) ? BTHD_CCI_None : BTHD_CCI_Auto;
1121    params.ifFreq = pSettings->ifFrequency;
1122
1123    switch (pSettings->bandwidth) {
1124    case NEXUS_FrontendOfdmBandwidth_e5Mhz:
1125        params.bandwidth = BTHD_Bandwidth_5Mhz;
1126        break;
1127    case NEXUS_FrontendOfdmBandwidth_e6Mhz:
1128        params.bandwidth = BTHD_Bandwidth_6Mhz;
1129        break;
1130    case NEXUS_FrontendOfdmBandwidth_e7Mhz:
1131        params.bandwidth = BTHD_Bandwidth_7Mhz;
1132        break;
1133    default:
1134        BDBG_WRN(("Unrecognized bandwidth setting, defaulting to 8MHz"));
1135        /* fall through */
1136    case NEXUS_FrontendOfdmBandwidth_e8Mhz:
1137        params.bandwidth = BTHD_Bandwidth_8Mhz;
1138        break;
1139    }
1140    params.bTpsAcquire = !pSettings->manualTpsSettings;
1141    if (pSettings->manualTpsSettings) {
1142        params.eCodeRateHP = NEXUS_Frontend_P_CodeRateToTHD(pSettings->tpsSettings.highPriorityCodeRate);
1143        params.eCodeRateLP = NEXUS_Frontend_P_CodeRateToTHD(pSettings->tpsSettings.lowPriorityCodeRate);
1144        switch (pSettings->tpsSettings.hierarchy) {
1145        default:
1146            BDBG_WRN(("Unrecognized hierarchy setting, defaulting to 0"));
1147            /* fall through */
1148        case NEXUS_FrontendOfdmHierarchy_e0:
1149            params.eHierarchy = BTHD_Hierarchy_0;
1150            break;
1151        case NEXUS_FrontendOfdmHierarchy_e1:
1152            params.eHierarchy = BTHD_Hierarchy_1;
1153            break;
1154        case NEXUS_FrontendOfdmHierarchy_e2:
1155            params.eHierarchy = BTHD_Hierarchy_2;
1156            break;
1157        case NEXUS_FrontendOfdmHierarchy_e4:
1158            params.eHierarchy = BTHD_Hierarchy_4;
1159            break;
1160        }
1161        params.eModulation = NEXUS_Frontend_P_ModulationToTHD(pSettings->tpsSettings.modulation);
1162    }
1163    params.eModeGuardAcquire = !pSettings->manualModeSettings;
1164    if (pSettings->manualModeSettings) {
1165        switch (pSettings->modeSettings.mode) {
1166        default:
1167            BDBG_WRN(("Unrecognized transmission mode, defaulting to 2k"));
1168            /* fall through */
1169        case NEXUS_FrontendOfdmTransmissionMode_e2k:
1170            params.eTransmissionMode = BTHD_TransmissionMode_e2K;
1171            break;
1172        case NEXUS_FrontendOfdmTransmissionMode_e4k:
1173            params.eTransmissionMode = BTHD_TransmissionMode_e4K;
1174            break;
1175        case NEXUS_FrontendOfdmTransmissionMode_e8k:
1176            params.eTransmissionMode = BTHD_TransmissionMode_e8K;
1177            break;
1178        }
1179        switch (pSettings->modeSettings.guardInterval) {
1180        default:
1181            BDBG_WRN(("Unrecognized guardInterval, defaulting to 1_32"));
1182            /* fall through */
1183        case NEXUS_FrontendOfdmGuardInterval_e1_32:
1184            params.eGuardInterval = BTHD_GuardInterval_e1_32;
1185            break;
1186        case NEXUS_FrontendOfdmGuardInterval_e1_16:
1187            params.eGuardInterval = BTHD_GuardInterval_e1_16;
1188            break;
1189        case NEXUS_FrontendOfdmGuardInterval_e1_8:
1190            params.eGuardInterval = BTHD_GuardInterval_e1_8;
1191            break;
1192        case NEXUS_FrontendOfdmGuardInterval_e1_4:
1193            params.eGuardInterval = BTHD_GuardInterval_e1_4;
1194            break;
1195        }
1196
1197    }
1198    switch (pSettings->acquisitionMode) {
1199    default:
1200        BDBG_WRN(("Unrecognized acquisitionMode, defaulting to Auto"));
1201        /* fall through */
1202    case NEXUS_FrontendOfdmAcquisitionMode_eAuto:
1203        params.eAcquisitionMode = BTHD_ThdAcquisitionMode_eAuto;
1204        break;
1205    case NEXUS_FrontendOfdmAcquisitionMode_eManual:
1206        params.eAcquisitionMode = BTHD_ThdAcquisitionMode_eManual;
1207        break;
1208    case NEXUS_FrontendOfdmAcquisitionMode_eScan:
1209        params.eAcquisitionMode = BTHD_ThdAcquisitionMode_eScan;
1210        break;
1211    }
1212    params.bTmccAcquire = !pSettings->manualTmccSettings;
1213    if (pSettings->manualTmccSettings) {
1214        params.bIsdbtPartialReception =
1215            pSettings->tmccSettings.partialReception;
1216        params.eIsdbtAModulation = NEXUS_Frontend_P_ModulationToTHD(
1217            pSettings->tmccSettings.modulationA);
1218        params.eIsdbtACodeRate = NEXUS_Frontend_P_CodeRateToTHD(
1219            pSettings->tmccSettings.codeRateA);
1220        params.eIsdbtATimeInterleaving = NEXUS_Frontend_P_TimeInterleavingToTHD(
1221            pSettings->tmccSettings.timeInterleavingA);
1222        params.eIsdbtASegments = pSettings->tmccSettings.numSegmentsA;
1223        params.eIsdbtBModulation = NEXUS_Frontend_P_ModulationToTHD(
1224            pSettings->tmccSettings.modulationB);
1225        params.eIsdbtBCodeRate = NEXUS_Frontend_P_CodeRateToTHD(
1226            pSettings->tmccSettings.codeRateB);
1227        params.eIsdbtBTimeInterleaving = NEXUS_Frontend_P_TimeInterleavingToTHD(
1228            pSettings->tmccSettings.timeInterleavingB);
1229        params.eIsdbtBSegments = pSettings->tmccSettings.numSegmentsB;
1230        params.eIsdbtCModulation = NEXUS_Frontend_P_ModulationToTHD(
1231            pSettings->tmccSettings.modulationC);
1232        params.eIsdbtCCodeRate = NEXUS_Frontend_P_CodeRateToTHD(
1233            pSettings->tmccSettings.codeRateC);
1234        params.eIsdbtCTimeInterleaving = NEXUS_Frontend_P_TimeInterleavingToTHD(
1235            pSettings->tmccSettings.timeInterleavingC);
1236        params.eIsdbtCSegments = pSettings->tmccSettings.numSegmentsC;
1237    }
1238    params.tunerFreq = pSettings->frequency;
1239    params.ePullinRange =
1240        (NEXUS_FrontendOfdmPullInRange_eNarrow == pSettings->pullInRange) ?
1241            BTHD_PullInRange_eNarrow : BTHD_PullInRange_eWide;
1242
1243    NEXUS_TaskCallback_Set(pDevice->thdLockAppCallback, &pSettings->lockCallback);
1244    NEXUS_TaskCallback_Set(pDevice->ewsAppCallback, &pSettings->ewsCallback);
1245    pDevice->lastSettings.ofdm = *pSettings;
1246
1247    rc = BTHD_TuneAcquire(pDevice->thdHandle, &params);
1248    if(rc){rc = BERR_TRACE(rc);}
1249done:
1250    return rc;
1251}
1252
1253static NEXUS_Error NEXUS_Frontend_P_7552_GetOfdmStatus( void *handle, NEXUS_FrontendOfdmStatus *pStatus )
1254{
1255    NEXUS_Error rc = NEXUS_SUCCESS;
1256    NEXUS_7552 *pDevice;
1257    BTHD_THDStatus status;
1258    BDBG_ASSERT(handle != NULL);
1259    pDevice = (NEXUS_7552 *)handle;
1260    BDBG_OBJECT_ASSERT(pDevice, NEXUS_7552);
1261    BDBG_ASSERT(NULL != pStatus);
1262
1263    BKNI_Memset(pStatus, 0, sizeof(NEXUS_FrontendOfdmStatus));
1264
1265    rc = BTHD_GetThdStatus(pDevice->thdHandle, &status);
1266    if(rc){rc = BERR_TRACE(rc); goto done;}
1267
1268    pStatus->settings = pDevice->lastSettings.ofdm;
1269    pStatus->fecLock = status.bFecLock;
1270    pStatus->receiverLock = status.bReceiverLock;
1271    pStatus->noSignalDetected = status.bNoSignalDetected;
1272    pStatus->spectrumInverted = status.bSpectrumInverted;
1273    pStatus->ews = status.bIsdbtEWS;
1274    if(pStatus->settings.mode == NEXUS_FrontendOfdmMode_eDvbt) {
1275        switch (status.eModulation) {
1276        case BTHD_Modulation_eQpsk:
1277            pStatus->modulation = NEXUS_FrontendOfdmModulation_eQpsk;
1278            break;
1279        case BTHD_Modulation_e16Qam:
1280            pStatus->modulation = NEXUS_FrontendOfdmModulation_eQam16;
1281            break;
1282        case BTHD_Modulation_e64Qam:
1283            pStatus->modulation = NEXUS_FrontendOfdmModulation_eQam64;
1284            break;
1285        default:
1286            BDBG_WRN(("Unrecognized modulation mode (%d) reported by BTHD", status.eModulation));
1287            pStatus->modulation = NEXUS_FrontendOfdmModulation_eMax;
1288            break;
1289        }
1290
1291            pStatus->codeRate = NEXUS_Frontend_P_THDToCodeRate(status.eCodeRate);
1292        switch (status.eHierarchy) {
1293        case BTHD_Hierarchy_0:
1294            pStatus->hierarchy = NEXUS_FrontendOfdmHierarchy_e0;
1295            break;
1296        case BTHD_Hierarchy_1:
1297            pStatus->hierarchy = NEXUS_FrontendOfdmHierarchy_e1;
1298            break;
1299        case BTHD_Hierarchy_2:
1300            pStatus->hierarchy = NEXUS_FrontendOfdmHierarchy_e2;
1301            break;
1302        case BTHD_Hierarchy_4:
1303            pStatus->hierarchy = NEXUS_FrontendOfdmHierarchy_e4;
1304            break;
1305        default:
1306            BDBG_WRN(("Unrecognized hierarchy (%d) reported by BTHD", status.eHierarchy));
1307            pStatus->hierarchy = NEXUS_FrontendOfdmHierarchy_eMax;
1308            break;
1309        }
1310    }
1311    switch (status.eTransmissionMode) {
1312    case BTHD_TransmissionMode_e2K:
1313        pStatus->transmissionMode = NEXUS_FrontendOfdmTransmissionMode_e2k;
1314        break;
1315    case BTHD_TransmissionMode_e4K:
1316        pStatus->transmissionMode = NEXUS_FrontendOfdmTransmissionMode_e4k;
1317        break;
1318    case BTHD_TransmissionMode_e8K:
1319        pStatus->transmissionMode = NEXUS_FrontendOfdmTransmissionMode_e8k;
1320        break;
1321    default:
1322        BDBG_WRN(("Unrecognized transmission mode (%d) reported by BTHD", status.eTransmissionMode));
1323        pStatus->transmissionMode = NEXUS_FrontendOfdmTransmissionMode_eMax;
1324        break;
1325    }
1326    switch (status.eGuardInterval) {
1327    case BTHD_GuardInterval_e1_32:
1328        pStatus->guardInterval = NEXUS_FrontendOfdmGuardInterval_e1_32;
1329        break;
1330    case BTHD_GuardInterval_e1_16:
1331        pStatus->guardInterval = NEXUS_FrontendOfdmGuardInterval_e1_16;
1332        break;
1333    case BTHD_GuardInterval_e1_8:
1334        pStatus->guardInterval = NEXUS_FrontendOfdmGuardInterval_e1_8;
1335        break;
1336    case BTHD_GuardInterval_e1_4:
1337        pStatus->guardInterval = NEXUS_FrontendOfdmGuardInterval_e1_4;
1338        break;
1339    default:
1340        BDBG_WRN(("Unrecognized guard interval (%d) reported by BTHD", status.eGuardInterval));
1341        pStatus->guardInterval = NEXUS_FrontendOfdmGuardInterval_eMax;
1342        break;
1343    }
1344
1345    pStatus->cellId = status.nCellId;
1346    pStatus->carrierOffset = status.lCarrierOffset;
1347    pStatus->timingOffset = status.lTimingOffset;
1348    pStatus->snr = (status.nSnr*100)/256;   
1349    pStatus->fecCorrectedBlocks = status.ulRsCorrectedBlocks;
1350    pStatus->fecUncorrectedBlocks = status.ulRsUncorrectedBlocks;
1351    pStatus->fecCleanBlocks = status.ulRsCleanBlocks;
1352    pStatus->reacquireCount = status.ulReacqCount;
1353    pStatus->viterbiUncorrectedBits = status.ulViterbiUncorrectedBits;
1354    pStatus->viterbiTotalBits = status.ulViterbiTotalbits;
1355    pStatus->viterbiErrorRate = status.ulViterbiBer;
1356    pStatus->preViterbiErrorRate = status.ulPreViterbiBer;
1357    pStatus->ifAgcLevel = status.ulIFAgc;
1358    pStatus->rfAgcLevel = status.ulRFAgc;
1359   
1360#if TODO_THD_TUNER_CONNECTION
1361    if (pDevice->tuner) {
1362        NEXUS_7552TunerStatus tunerStatus;
1363        NEXUS_Tuner_Get7552Status(pDevice->tuner, &tunerStatus);
1364        pStatus->rfAgcLevel = tunerStatus.rfAgcLevel;
1365        pStatus->signalStrength = tunerStatus.signalStrength;
1366    }
1367#endif
1368    pStatus->rfAgcLevel = status.ulRFAgc;
1369    pStatus->signalStrength = status.nSignalStrength;
1370
1371    if(pStatus->settings.mode == NEXUS_FrontendOfdmMode_eIsdbt) {
1372        pStatus->fecCorrectedBlocksA = status.ulIsdbtARsCorrectedBlocks;
1373        pStatus->fecUncorrectedBlocksA = status.ulIsdbtARsUncorrectedBlocks;
1374        pStatus->fecCleanBlocksA = status.ulIsdbtARsCleanBlocks;
1375        pStatus->fecCorrectedBlocksB = status.ulIsdbtBRsCorrectedBlocks;
1376        pStatus->fecUncorrectedBlocksB = status.ulIsdbtBRsUncorrectedBlocks;
1377        pStatus->fecCleanBlocksB = status.ulIsdbtBRsCleanBlocks;
1378        pStatus->fecCorrectedBlocksC = status.ulIsdbtCRsCorrectedBlocks;
1379        pStatus->fecUncorrectedBlocksC = status.ulIsdbtCRsUncorrectedBlocks;
1380        pStatus->fecCleanBlocksC = status.ulIsdbtCRsCleanBlocks;
1381        pStatus->isdbtAPreRS = status.ulIsdbtAViterbiUncorrectedBits;
1382        pStatus->isdbtBPreRS = status.ulIsdbtBViterbiUncorrectedBits;
1383        pStatus->isdbtCPreRS = status.ulIsdbtCViterbiUncorrectedBits;
1384        pStatus->modulationA =NEXUS_Frontend_P_THDToModulation(status.eIsdbtAModulation);
1385        pStatus->codeRateA = NEXUS_Frontend_P_THDToCodeRate(status.eIsdbtACodeRate);
1386        pStatus->timeInterleavingA = NEXUS_Frontend_P_THDToTimeInterleaving(status.eIsdbtATimeInterleaving);
1387        pStatus->numSegmentsA = status.eIsdbtASegments;
1388        pStatus->fecCorrectedBlocksA = status.ulIsdbtARsCorrectedBlocks;
1389        pStatus->fecUncorrectedBlocksA = status.ulIsdbtARsUncorrectedBlocks;
1390        pStatus->fecCleanBlocksA = status.ulIsdbtARsCleanBlocks;
1391        pStatus->modulationB = NEXUS_Frontend_P_THDToModulation(status.eIsdbtBModulation);
1392        pStatus->codeRateB = NEXUS_Frontend_P_THDToCodeRate(status.eIsdbtBCodeRate);
1393        pStatus->timeInterleavingB = NEXUS_Frontend_P_THDToTimeInterleaving(status.eIsdbtBTimeInterleaving);
1394        pStatus->numSegmentsB = status.eIsdbtBSegments;
1395        pStatus->fecCorrectedBlocksB = status.ulIsdbtBRsCorrectedBlocks;
1396        pStatus->fecUncorrectedBlocksB = status.ulIsdbtBRsUncorrectedBlocks;
1397        pStatus->fecCleanBlocksB = status.ulIsdbtBRsCleanBlocks;
1398        pStatus->modulationC = NEXUS_Frontend_P_THDToModulation(status.eIsdbtCModulation);
1399        pStatus->codeRateC = NEXUS_Frontend_P_THDToCodeRate(status.eIsdbtCCodeRate);
1400        pStatus->timeInterleavingC = NEXUS_Frontend_P_THDToTimeInterleaving(status.eIsdbtCTimeInterleaving);
1401        pStatus->numSegmentsC = status.eIsdbtCSegments;
1402        pStatus->fecCorrectedBlocksC = status.ulIsdbtCRsCorrectedBlocks;
1403        pStatus->fecUncorrectedBlocksC = status.ulIsdbtCRsUncorrectedBlocks;
1404        pStatus->fecCleanBlocksC = status.ulIsdbtCRsCleanBlocks;
1405    }
1406done:
1407    return rc;
1408}
1409
1410static BTHD_IsdbtTimeInterleaving NEXUS_Frontend_P_TimeInterleavingToTHD( NEXUS_FrontendOfdmTimeInterleaving nexus )
1411{
1412    switch (nexus) {
1413    default:
1414        BDBG_WRN(("Unknown NEXUS time interleaving %d, defaulting to 0x",
1415            nexus));
1416        /* fall-through */
1417    case NEXUS_FrontendOfdmTimeInterleaving_e0x:
1418        return BTHD_IsdbtTimeInterleaving_0X;
1419        break;
1420    case NEXUS_FrontendOfdmTimeInterleaving_e1x:
1421        return BTHD_IsdbtTimeInterleaving_1X;
1422        break;
1423    case NEXUS_FrontendOfdmTimeInterleaving_e2x:
1424        return BTHD_IsdbtTimeInterleaving_2X;
1425        break;
1426    case NEXUS_FrontendOfdmTimeInterleaving_e3x:
1427        return BTHD_IsdbtTimeInterleaving_3X;
1428        break;
1429    }
1430}
1431
1432static NEXUS_FrontendOfdmTimeInterleaving  NEXUS_Frontend_P_THDToTimeInterleaving(  BTHD_IsdbtTimeInterleaving magnum )
1433{
1434    switch (magnum) {
1435    default:
1436        BDBG_WRN(("Unknown Magnum time interleaving %d, defaulting to 0x", magnum));
1437        /* fall-through */
1438    case BTHD_IsdbtTimeInterleaving_0X:
1439        return NEXUS_FrontendOfdmTimeInterleaving_e0x;
1440    case BTHD_IsdbtTimeInterleaving_1X:
1441        return NEXUS_FrontendOfdmTimeInterleaving_e1x;
1442    case BTHD_IsdbtTimeInterleaving_2X:
1443        return NEXUS_FrontendOfdmTimeInterleaving_e2x;
1444    case BTHD_IsdbtTimeInterleaving_3X:
1445        return NEXUS_FrontendOfdmTimeInterleaving_e3x;
1446    }
1447}
1448
1449static BTHD_CodeRate NEXUS_Frontend_P_CodeRateToTHD(  NEXUS_FrontendOfdmCodeRate nexusCodeRate )
1450{
1451    switch (nexusCodeRate) {
1452    default:
1453        BDBG_WRN(("Unsupported code rate value %d, defaulting to 1_2"));
1454        /* Fall through */
1455    case NEXUS_FrontendOfdmCodeRate_e1_2:
1456        return BTHD_CodeRate_e1_2;
1457    case NEXUS_FrontendOfdmCodeRate_e2_3:
1458        return BTHD_CodeRate_e2_3;
1459    case NEXUS_FrontendOfdmCodeRate_e3_4:
1460        return BTHD_CodeRate_e3_4;
1461    case NEXUS_FrontendOfdmCodeRate_e5_6:
1462        return BTHD_CodeRate_e5_6;
1463    case NEXUS_FrontendOfdmCodeRate_e7_8:
1464        return BTHD_CodeRate_e7_8;
1465    }
1466}
1467
1468static NEXUS_FrontendOfdmCodeRate NEXUS_Frontend_P_THDToCodeRate( BTHD_CodeRate magnum )
1469{
1470    switch (magnum) {
1471    case BTHD_CodeRate_e1_2:
1472        return NEXUS_FrontendOfdmCodeRate_e1_2;
1473    case BTHD_CodeRate_e2_3:
1474        return NEXUS_FrontendOfdmCodeRate_e2_3;
1475    case BTHD_CodeRate_e3_4:
1476        return NEXUS_FrontendOfdmCodeRate_e3_4;
1477    case BTHD_CodeRate_e5_6:
1478        return NEXUS_FrontendOfdmCodeRate_e5_6;
1479    case BTHD_CodeRate_e7_8:
1480        return NEXUS_FrontendOfdmCodeRate_e7_8;
1481    default:
1482        return NEXUS_FrontendOfdmCodeRate_eMax;
1483    }
1484}
1485
1486static BTHD_Modulation NEXUS_Frontend_P_ModulationToTHD( NEXUS_FrontendOfdmModulation nexus )
1487{
1488    switch (nexus) {
1489    default:
1490        BDBG_WRN(("Urecognized NEXUS modulation %d, defaulting to QAM64", nexus));
1491        /* fall through */
1492    case NEXUS_FrontendOfdmModulation_eQam64:
1493        return BTHD_Modulation_e64Qam;
1494    case NEXUS_FrontendOfdmModulation_eQam16:
1495        return BTHD_Modulation_e16Qam;
1496    case NEXUS_FrontendOfdmModulation_eQpsk:
1497        return BTHD_Modulation_eQpsk;
1498    }
1499}
1500
1501static NEXUS_FrontendOfdmModulation NEXUS_Frontend_P_THDToModulation( BTHD_Modulation magnum )
1502{
1503    switch (magnum) {
1504    case BTHD_Modulation_e64Qam:
1505        return NEXUS_FrontendOfdmModulation_eQam64;
1506    case BTHD_Modulation_e16Qam:
1507        return NEXUS_FrontendOfdmModulation_eQam16;
1508    default:
1509        BDBG_WRN(("Unrecognized ofdm modulation %d, defaulting to QPSK", magnum));
1510        /* fall-through */
1511    case BTHD_Modulation_eQpsk:
1512        return NEXUS_FrontendOfdmModulation_eQpsk;
1513    }
1514}
1515#ifndef NEXUS_FRONTEND_7552_A0
1516static NEXUS_Error NEXUS_Frontend_P_7552_TuneOob( void *handle, const NEXUS_FrontendOutOfBandSettings *pSettings )
1517{
1518    NEXUS_Error rc = NEXUS_SUCCESS;
1519    NEXUS_7552 *pDevice;
1520    BTNR_PowerSaverSettings pwrSettings;
1521    BTNR_Settings tnrSettings;
1522    BAOB_AcquireParam obParams;
1523    BDBG_ASSERT(handle != NULL);
1524    pDevice = (NEXUS_7552 *)handle;
1525    BDBG_OBJECT_ASSERT(pDevice, NEXUS_7552);
1526    BDBG_ASSERT(NULL != pSettings);
1527
1528    if (pDevice->oobTnrHandle)
1529    {
1530        /* TODO: we should be able to call BTNR_SetSettings after BTNR_SetPowerSaver. verify */
1531        pwrSettings.enable = false;     
1532        rc = BTNR_SetPowerSaver(pDevice->oobTnrHandle, &pwrSettings);
1533        if(rc){rc = BERR_TRACE(rc); goto done;}
1534
1535        rc = BTNR_GetSettings(pDevice->oobTnrHandle, &tnrSettings);
1536        if(rc){rc = BERR_TRACE(rc); goto done;} 
1537
1538        tnrSettings.rfInputMode = pDevice->rfInput;       
1539        rc = BTNR_SetSettings(pDevice->oobTnrHandle, &tnrSettings);
1540        if(rc){rc = BERR_TRACE(rc); goto done;}
1541       
1542        rc = BAOB_DisablePowerSaver(pDevice->oobHandle);
1543        if(rc){rc = BERR_TRACE(rc); goto done;}
1544       
1545        rc = BTNR_SetTunerRfFreq(pDevice->oobTnrHandle, pSettings->frequency, BTNR_TunerMode_eDigital);
1546        if(rc){rc = BERR_TRACE(rc); goto done;}
1547    }
1548
1549    obParams.autoAcquire = pSettings->autoAcquire;
1550    obParams.modType = (BAOB_ModulationType)pSettings->mode ;
1551    obParams.symbolRate = pSettings->symbolRate;
1552    obParams.berSrc = pSettings->bertSource;
1553    obParams.spectrum = pSettings->spectrum;
1554
1555    rc = BAOB_Acquire(pDevice->oobHandle, &obParams);
1556    if(rc){rc = BERR_TRACE(rc);}
1557
1558done:
1559    return rc;
1560}
1561#endif
1562static NEXUS_7552 *NEXUS_Get7552Device(NEXUS_FrontendHandle handle)
1563{
1564    NEXUS_7552 *pDevice;
1565    BDBG_OBJECT_ASSERT(handle, NEXUS_Frontend);
1566     
1567    if (handle->chip.familyId == 0x7552) {     
1568        pDevice = (NEXUS_7552 *)handle->pDeviceHandle;
1569        return pDevice;
1570    }
1571    return NULL;
1572}
1573
1574void NEXUS_Frontend_GetDefault7552ConfigSettings(
1575    NEXUS_7552ConfigSettings *pConfigSettings   /* [out] */
1576    )
1577{
1578    BDBG_ASSERT(NULL != pConfigSettings);
1579    BKNI_Memset(pConfigSettings, 0, sizeof(*pConfigSettings));
1580}
1581
1582NEXUS_Error NEXUS_Frontend_7552_GetConfigSettings(
1583    NEXUS_FrontendHandle handle,                 /* [In]  */
1584    NEXUS_7552ConfigSettings *pConfigSettings    /* [out]  */
1585    )                 
1586{
1587    NEXUS_Error rc = NEXUS_SUCCESS;
1588    NEXUS_7552 *pDevice = NULL;
1589    BDBG_ASSERT(handle != NULL);   
1590
1591    pDevice = NEXUS_Get7552Device(handle);   
1592    if (!pDevice) { rc = BERR_TRACE(NEXUS_INVALID_PARAMETER); goto done; }   
1593    BDBG_OBJECT_ASSERT(pDevice, NEXUS_7552);
1594
1595    pConfigSettings->rfInput = pDevice->rfInput;
1596    pConfigSettings->enableRfLoopThrough = pDevice->enableRfLoopThrough;
1597done:
1598    return rc;
1599}
1600
1601NEXUS_Error NEXUS_Frontend_7552_SetConfigSettings(
1602    NEXUS_FrontendHandle handle,                 /* [In] */
1603    const NEXUS_7552ConfigSettings *pConfigSettings    /* [In] */
1604    )                 
1605{
1606    NEXUS_Error rc = NEXUS_SUCCESS;
1607    NEXUS_7552 *pDevice = NULL;
1608    BDBG_ASSERT(handle != NULL);   
1609
1610    pDevice = NEXUS_Get7552Device(handle);   
1611    if (!pDevice) { rc = BERR_TRACE(NEXUS_INVALID_PARAMETER); goto done; }   
1612    BDBG_OBJECT_ASSERT(pDevice, NEXUS_7552);
1613
1614    if((pConfigSettings->enableRfLoopThrough != pDevice->enableRfLoopThrough)) {
1615       
1616        rc = BTNR_3x7x_Set_RF_LoopThrough(pDevice->tnrHandle, pConfigSettings->enableRfLoopThrough);
1617        if(rc){rc = BERR_TRACE(rc); goto done;}
1618         
1619        pDevice->enableRfLoopThrough = pConfigSettings->enableRfLoopThrough;       
1620    }
1621
1622    pDevice->rfInput = pConfigSettings->rfInput;
1623done:
1624    return rc;
1625}
1626
1627
Note: See TracBrowser for help on using the repository browser.