source: svn/newcon3bcm2_21bu/magnum/portinginterface/ape/7552/bape_adc_input.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: 13.4 KB
Line 
1/***************************************************************************
2 *     Copyright (c) 2006-2011, Broadcom Corporation
3 *     All Rights Reserved
4 *     Confidential Property of Broadcom Corporation
5 *
6 *  THIS SOFTWARE MAY ONLY BE USED SUBJECT TO AN EXECUTED SOFTWARE LICENSE
7 *  AGREEMENT  BETWEEN THE USER AND BROADCOM.  YOU HAVE NO RIGHT TO USE OR
8 *  EXPLOIT THIS MATERIAL EXCEPT SUBJECT TO THE TERMS OF SUCH AN AGREEMENT.
9 *
10 * $brcm_Workfile: bape_adc_input.c $
11 * $brcm_Revision: Hydra_Software_Devel/4 $
12 * $brcm_Date: 8/12/11 4:18p $
13 *
14 * Module Description: Audio adc input Interface
15 *
16 * Revision History:
17 *
18 * $brcm_Log: /magnum/portinginterface/ape/7422/bape_adc_input.c $
19 *
20 * Hydra_Software_Devel/4   8/12/11 4:18p venkatr
21 * SWDTV-6584 : [35233] ADC input code cleanup
22 *
23 ***************************************************************************/
24#include "bape.h"
25#include "bape_priv.h"
26#if defined BCHP_AUDADC_CTRL_REG_START
27#include "bchp_audadc_ctrl.h"
28#endif
29
30BDBG_MODULE(bape_adc_input);
31
32#if BAPE_CHIP_MAX_ADC_INPUTS > 0
33
34/* Actual Implementation */
35BDBG_OBJECT_ID(BAPE_AdcInput);
36typedef struct BAPE_AdcInput
37{
38    BDBG_OBJECT(BAPE_AdcInput)
39    BAPE_Handle deviceHandle;
40    BAPE_InputPortObject connector;
41    unsigned index;
42    BAPE_AdcInputSettings settings;
43    bool enable;
44    char name[11];   /* ADC IN %d */
45    /* TODO: More as required... */
46}BAPE_AdcInput;
47
48static void BAPE_AdcInput_P_Enable(BAPE_InputPort inputPort);
49static void BAPE_AdcInput_P_Disable(BAPE_InputPort inputPort);
50
51void BAPE_AdcInput_GetDefaultSettings(
52                                     BAPE_AdcInputSettings *pSettings        /* [out] */
53                                     )
54{
55    BDBG_ASSERT(NULL != pSettings);
56    BKNI_Memset(pSettings, 0, sizeof(*pSettings));
57    pSettings->sampleRate = 48000; /*Currently only 48k supported */
58    pSettings->inputNumber  = 2; /*TBD: MUX_CTRL value*/
59    return;
60}
61
62BERR_Code BAPE_AdcInput_Open(
63                            BAPE_Handle deviceHandle,
64                            unsigned index,
65                            const BAPE_AdcInputSettings *pSettings,
66                            BAPE_AdcInputHandle *pHandle              /* [out] */
67                            )
68{   
69    BERR_Code errCode;
70    BAPE_AdcInputHandle handle;
71    BAPE_AdcInputSettings defaultSettings;
72    uint32_t      RegVal = 0;
73    BREG_Handle   RegHandle = NULL;
74
75    BDBG_OBJECT_ASSERT(deviceHandle, BAPE_Device);
76    BDBG_ASSERT(NULL != pHandle);
77   
78    *pHandle = NULL;
79    if ( index >= BAPE_CHIP_MAX_ADC_INPUTS )
80    {
81        BDBG_ERR(("Request to open ADC %d but chip only has %u ADC inputs", index, BAPE_CHIP_MAX_ADC_INPUTS ));
82        return BERR_TRACE(BERR_INVALID_PARAMETER);
83    }
84
85    if ( deviceHandle->adcInputs[index] )
86    {
87        BDBG_ERR(("ADC input %d already open", index));
88        return BERR_TRACE(BERR_INVALID_PARAMETER);
89    }
90
91    handle = BKNI_Malloc(sizeof(BAPE_AdcInput));
92    if ( NULL == handle )
93    {
94        return BERR_TRACE(BERR_OUT_OF_SYSTEM_MEMORY);
95    }
96
97    /* Init to specified settings */
98    if ( NULL == pSettings )
99    {/*Move this to before init of connect settings*/
100        BAPE_AdcInput_GetDefaultSettings(&defaultSettings);
101        pSettings = &defaultSettings;
102    }
103
104    BKNI_Memset(handle, 0, sizeof(BAPE_AdcInput));
105    BDBG_OBJECT_SET(handle, BAPE_AdcInput);
106    BAPE_P_InitInputPort(&handle->connector, BAPE_InputPortType_eAdc, index, handle);
107    /*Do we need Rx call back function for adc ? */
108    handle->deviceHandle = deviceHandle;
109    handle->index = index;
110    handle->connector.streamId[BAPE_ChannelPair_eLeftRight] = 10;/*From RDB*/
111    handle->connector.enable = BAPE_AdcInput_P_Enable;
112    handle->connector.disable = BAPE_AdcInput_P_Disable;
113    handle->connector.numChannelPairs = 1;
114    handle->connector.sampleRate = pSettings->sampleRate;
115    handle->connector.compressed = false;
116    BKNI_Snprintf(handle->name, sizeof(handle->name), "ADC IN %u", index);
117    handle->connector.pName = handle->name;
118
119    RegHandle = deviceHandle->regHandle;
120    /* Bring ADC In out of Reset */
121    RegVal = BREG_Read32(RegHandle, BCHP_AUDADC_CTRL_RESET_CTRL);
122    RegVal &= ~ ((BCHP_MASK(AUDADC_CTRL_RESET_CTRL, SYNC_RESET_FIFO)) |
123                     (BCHP_MASK(AUDADC_CTRL_RESET_CTRL, SYNC_RESET)));
124    RegVal |= ((BCHP_FIELD_ENUM(
125                        AUDADC_CTRL_RESET_CTRL, SYNC_RESET_FIFO,
126                        Normal_operation)) |
127                   (BCHP_FIELD_ENUM(
128                        AUDADC_CTRL_RESET_CTRL, SYNC_RESET,
129                        Normal_operation)));
130    BREG_Write32(RegHandle, BCHP_AUDADC_CTRL_RESET_CTRL, RegVal);
131   
132    errCode = BAPE_AdcInput_SetSettings(handle, pSettings);   
133    if ( errCode )
134    {
135        BAPE_AdcInput_Close(handle);
136        return BERR_TRACE(errCode);
137    }
138   
139    /* Start ADC */
140    RegVal = BREG_Read32(RegHandle, BCHP_AUDADC_CTRL_CONFIG);
141
142    RegVal &= ~(BCHP_MASK (AUDADC_CTRL_CONFIG, 
143                    ADC_OUTFIFO_ENA)); 
144   
145    RegVal |= (BCHP_FIELD_ENUM(AUDADC_CTRL_CONFIG, 
146                   ADC_OUTFIFO_ENA, enable));
147   
148    BREG_Write32(RegHandle, BCHP_AUDADC_CTRL_CONFIG, RegVal); 
149
150
151    /* Clear the interrupts before enabling any callbacks */
152   
153    *pHandle = handle;
154    handle->deviceHandle->adcInputs[index] = handle;
155
156    return BERR_SUCCESS;   
157}
158
159void BAPE_AdcInput_Close(
160                        BAPE_AdcInputHandle handle
161                        )
162{
163    uint32_t RegVal;   
164    BREG_Handle   RegHandle = NULL;
165   
166    BDBG_OBJECT_ASSERT(handle, BAPE_AdcInput);
167
168    /* Make sure we're not still connected to anything */
169    if ( handle->connector.pConsumer )
170    {
171        BDBG_ERR(("Cannot close ADC input %p (%d), still connected to %s", handle, handle->index, handle->connector.pConsumer->pName));
172        BDBG_ASSERT(NULL == handle->connector.pConsumer);
173        return;
174    }
175    RegHandle = handle->deviceHandle->regHandle;
176    /* Stop the ADC */
177    RegVal = BREG_Read32(RegHandle,BCHP_AUDADC_CTRL_CONFIG);
178
179    RegVal &= ~(BCHP_MASK (AUDADC_CTRL_CONFIG, 
180                    ADC_OUTFIFO_ENA)); 
181   
182    RegVal |= (BCHP_FIELD_ENUM(AUDADC_CTRL_CONFIG, 
183                   ADC_OUTFIFO_ENA, disable));
184   
185    BREG_Write32(RegHandle,BCHP_AUDADC_CTRL_CONFIG,RegVal); 
186
187    handle->deviceHandle->adcInputs[handle->index] = NULL;
188
189    BDBG_OBJECT_DESTROY(handle, BAPE_AdcInput);
190    BKNI_Free(handle);   
191}
192
193void BAPE_AdcInput_GetSettings(
194                              BAPE_AdcInputHandle handle,
195                              BAPE_AdcInputSettings *pSettings        /* [out] */
196                              )
197{
198    BDBG_OBJECT_ASSERT(handle, BAPE_AdcInput);
199    BDBG_ASSERT(NULL != pSettings);
200    *pSettings = handle->settings;
201}
202
203BERR_Code BAPE_AdcInput_SetSettings(
204                                   BAPE_AdcInputHandle handle,
205                                   const BAPE_AdcInputSettings *pSettings
206                                   )
207{   
208    uint32_t RegVal;
209    BREG_Handle   RegHandle = NULL;
210   
211    BDBG_OBJECT_ASSERT(handle, BAPE_AdcInput);
212    BDBG_ASSERT(NULL != pSettings);
213
214    RegHandle = handle->deviceHandle->regHandle;   
215   
216    /* Choose the Input in Mux */
217    RegVal = BREG_Read32(RegHandle, BCHP_AUDADC_CTRL_ADC_MUX_SEL);
218    RegVal &= ~ ((BCHP_MASK(AUDADC_CTRL_ADC_MUX_SEL, MUX_SEL)));
219    RegVal |= pSettings->inputNumber;
220    BREG_Write32 (RegHandle, BCHP_AUDADC_CTRL_ADC_MUX_SEL, RegVal);
221
222    /* Program the NCO Configuration and Decim Factor */
223    RegVal = BREG_Read32 (RegHandle, BCHP_AUDADC_CTRL_NCO_CFG);
224    RegVal &= ~ ((BCHP_MASK(AUDADC_CTRL_NCO_CFG, IGNORE_RM)) |
225                     (BCHP_MASK(AUDADC_CTRL_NCO_CFG, PHASE_INC)) |   
226                     (BCHP_MASK(AUDADC_CTRL_NCO_CFG, TIMEBASE15_TEST)));
227
228    switch (pSettings->sampleRate)
229    {
230        case 48000:
231            RegVal |= \
232              (BCHP_FIELD_ENUM(AUDADC_CTRL_NCO_CFG, PHASE_INC, FS_48000Hz));
233            break;
234
235        default:
236            BDBG_ERR (("AUDADC :: This sampling rate is not handled"));
237    }           
238    RegVal |= \
239    ( (BCHP_FIELD_ENUM(AUDADC_CTRL_NCO_CFG, IGNORE_RM, Freerun)) |
240      (BCHP_FIELD_ENUM(AUDADC_CTRL_NCO_CFG, TIMEBASE15_TEST, Normal)));
241   
242    BREG_Write32 (RegHandle, BCHP_AUDADC_CTRL_NCO_CFG, RegVal);
243
244
245    /* Program the IIR filters for ADC - the Peak B0,B1 and B2 will have
246        to be programmed based on sampling rate while the other IIRs
247        can be programmed with fixed values
248    */
249    switch (pSettings->sampleRate)
250    {
251        case 48000:
252            /* Program the DECIM factor based on the sampling rate */
253            RegVal = BREG_Read32 (RegHandle, BCHP_AUDADC_CTRL_CONFIG);
254            RegVal &= ~ (BCHP_MASK(AUDADC_CTRL_CONFIG, ADC_CIC_DECIM_FACTOR));
255            /* Except for 32k decim factor for all others should be 32X.
256                        For 32k it should be 48X */
257            RegVal |= (BCHP_FIELD_ENUM(AUDADC_CTRL_CONFIG, 
258                                           ADC_CIC_DECIM_FACTOR, Decim32X));           
259            BREG_Write32 (RegHandle, BCHP_AUDADC_CTRL_CONFIG, RegVal);
260           
261            RegVal = BREG_Read32 (RegHandle, BCHP_AUDADC_CTRL_PEAK_B0);
262            RegVal &= ~(BCHP_MASK(AUDADC_CTRL_PEAK_B0, COEFF));
263            RegVal |= (BCHP_FIELD_ENUM(
264                            AUDADC_CTRL_PEAK_B0, COEFF, B0_Fs48000));
265            BREG_Write32 (RegHandle, BCHP_AUDADC_CTRL_PEAK_B0, RegVal);
266
267            RegVal = BREG_Read32 (RegHandle, BCHP_AUDADC_CTRL_PEAK_B1);
268            RegVal &= ~(BCHP_MASK(AUDADC_CTRL_PEAK_B1, COEFF));
269            RegVal |= (BCHP_FIELD_ENUM(
270                            AUDADC_CTRL_PEAK_B1, COEFF, B1_Fs48000));
271            BREG_Write32 (RegHandle, BCHP_AUDADC_CTRL_PEAK_B1, RegVal);                   
272
273            RegVal = BREG_Read32 (RegHandle, BCHP_AUDADC_CTRL_PEAK_B2);
274            RegVal &= ~(BCHP_MASK(AUDADC_CTRL_PEAK_B2, COEFF));
275            RegVal |= (BCHP_FIELD_ENUM(
276                            AUDADC_CTRL_PEAK_B2, COEFF, B2_Fs48000));
277            BREG_Write32 (RegHandle, BCHP_AUDADC_CTRL_PEAK_B2, RegVal); 
278            break;
279           
280        default:
281            BDBG_ERR (("AUDADC :: This sampling rate is not handled"));
282    }
283
284    BREG_Write32 (RegHandle, BCHP_AUDADC_CTRL_IIR0_B0, 0x200000);
285    BREG_Write32 (RegHandle, BCHP_AUDADC_CTRL_IIR0_B1, 0x000000);
286    BREG_Write32 (RegHandle, BCHP_AUDADC_CTRL_IIR0_A1, 0x000000);           
287
288    BREG_Write32 (RegHandle, BCHP_AUDADC_CTRL_IIR1_B0, 0x200000);
289    BREG_Write32 (RegHandle, BCHP_AUDADC_CTRL_IIR1_B1, 0x000000);
290    BREG_Write32 (RegHandle, BCHP_AUDADC_CTRL_IIR1_A1, 0x000000);           
291
292    BREG_Write32 (RegHandle, BCHP_AUDADC_CTRL_IIR2_B0, 0x200000);
293    BREG_Write32 (RegHandle, BCHP_AUDADC_CTRL_IIR2_B1, 0x000000);
294    BREG_Write32 (RegHandle, BCHP_AUDADC_CTRL_IIR2_A1, 0x000000);           
295   
296    handle->connector.sampleRate = pSettings->sampleRate;   
297    handle->settings = *pSettings;
298
299    return BERR_SUCCESS;
300}
301
302void BAPE_AdcInput_GetInputPort(
303                               BAPE_AdcInputHandle handle,
304                               BAPE_InputPort *pPort
305                               )
306{
307    BDBG_OBJECT_ASSERT(handle, BAPE_AdcInput);
308    BDBG_ASSERT(NULL != pPort);
309    *pPort = &handle->connector;
310}
311static void BAPE_AdcInput_P_Enable(BAPE_InputPort inputPort)
312{
313    BAPE_AdcInputHandle handle;
314
315    handle = inputPort->pHandle;
316    BDBG_OBJECT_ASSERT(handle, BAPE_AdcInput);
317    BDBG_ASSERT(false == handle->enable);
318
319    BDBG_MSG(("Enabling %s", handle->name));
320    BAPE_Iop_P_EnableCapture( handle->deviceHandle, inputPort->streamId[0], inputPort->numChannelPairs );
321
322    handle->enable = true;
323}
324
325static void BAPE_AdcInput_P_Disable(BAPE_InputPort inputPort)
326{
327    BAPE_AdcInputHandle handle;
328   
329    handle = inputPort->pHandle;
330    BDBG_OBJECT_ASSERT(handle, BAPE_AdcInput);
331    BDBG_ASSERT(true == handle->enable);
332
333    BDBG_MSG(("Disabling %s", handle->name));
334    BAPE_Iop_P_DisableCapture( handle->deviceHandle, inputPort->streamId[0], inputPort->numChannelPairs );
335
336    handle->enable = false;
337}
338
339#else
340/* Stubs for chips without ADC */
341void BAPE_AdcInput_GetDefaultSettings(
342                                     BAPE_AdcInputSettings *pSettings        /* [out] */
343                                     )
344{
345    BSTD_UNUSED(pSettings);
346}
347
348BERR_Code BAPE_AdcInput_Open(
349                            BAPE_Handle deviceHandle,
350                            unsigned index,
351                            const BAPE_AdcInputSettings *pSettings,
352                            BAPE_AdcInputHandle *pHandle              /* [out] */
353                            )
354{
355    BSTD_UNUSED(deviceHandle);
356    BSTD_UNUSED(index);
357    BSTD_UNUSED(pSettings);
358    BSTD_UNUSED(pHandle);
359    return BERR_TRACE(BERR_NOT_SUPPORTED);
360}
361
362void BAPE_AdcInput_Close(
363                        BAPE_AdcInputHandle handle
364                        )
365{
366    BSTD_UNUSED(handle);
367}
368
369void BAPE_AdcInput_GetSettings(
370                              BAPE_AdcInputHandle handle,
371                              BAPE_AdcInputSettings *pSettings        /* [out] */
372                              )
373{
374    BSTD_UNUSED(handle);
375    BSTD_UNUSED(pSettings);
376}
377
378BERR_Code BAPE_AdcInput_SetSettings(
379                                   BAPE_AdcInputHandle handle,
380                                   const BAPE_AdcInputSettings *pSettings
381                                   )
382{
383    BSTD_UNUSED(handle);
384    BSTD_UNUSED(pSettings);
385    return BERR_TRACE(BERR_NOT_SUPPORTED);
386}
387
388void BAPE_AdcInput_GetInputPort(
389                               BAPE_AdcInputHandle handle,
390                               BAPE_InputPort *pPort
391                               )
392{
393    BSTD_UNUSED(handle);
394    BSTD_UNUSED(pPort);
395}
396#endif
Note: See TracBrowser for help on using the repository browser.