source: svn/newcon3bcm2_21bu/magnum/portinginterface/ape/7552/bape_src_priv.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: 42.7 KB
Line 
1/***************************************************************************
2 *     Copyright (c) 2006-2012, Broadcom Corporation
3 *     All Rights Reserved
4 *     Confidential Property of Broadcom Corporation
5 *
6 *  THIS SOFTWARE MAY ONLY BE USED SUBJECT TO AN EXECUTED SOFTWARE LICENSE
7 *  AGREEMENT  BETWEEN THE USER AND BROADCOM.  YOU HAVE NO RIGHT TO USE OR
8 *  EXPLOIT THIS MATERIAL EXCEPT SUBJECT TO THE TERMS OF SUCH AN AGREEMENT.
9 *
10 * $brcm_Workfile: bape_src_priv.c $
11 * $brcm_Revision: Hydra_Software_Devel/16 $
12 * $brcm_Date: 3/2/12 3:04p $
13 *
14 * Module Description: Sample Rate Converter (SRC) Interface
15 *
16 * Revision History:
17 *
18 * $brcm_Log: /magnum/portinginterface/ape/7422/bape_src_priv.c $
19 *
20 * Hydra_Software_Devel/16   3/2/12 3:04p jgarrett
21 * SW7429-18: Correctly programming coefficient base address for
22 * multichannel SRCs
23 *
24 * Hydra_Software_Devel/15   2/8/12 11:53a jgarrett
25 * SW7346-672: Adding support for non-standard sample rates and using
26 * L_INT instead of Bypass to avoid SRC lockup
27 *
28 * Hydra_Software_Devel/14   12/5/11 6:56p gskerl
29 * SW7429-18: Merged bape_src_dtv_priv.c into bape_src_priv.c
30 *
31 * Hydra_Software_Devel/14   12/5/11 6:55p gskerl
32 * SW7429-18: Merged bape_src_dtv_priv.c into bape_src_priv.c
33 *
34 * Hydra_Software_Devel/13   11/2/11 1:40p gskerl
35 * SW7231-129: Added power standby/resume support for
36 * SampleRateConverterRampStep.
37 *
38 * Hydra_Software_Devel/12   9/16/11 6:49p gskerl
39 * SW7231-129: Refactored to put hardware and software initialization into
40 * separate functions.
41 *
42 * Hydra_Software_Devel/11   8/29/11 4:19p jgarrett
43 * SWDTV-6627: Fixing build errors for STB chips
44 *
45 * Hydra_Software_Devel/10   8/19/11 1:40p jgarrett
46 * SW7344-170: Handling SRC ZERO_DETECT bit name change
47 *
48 * Hydra_Software_Devel/9   5/18/11 2:32p jgarrett
49 * SW7425-574: Disabling RAMP_ZERO_DET_ENA feature as it causes problems
50 * with streams that have zero data on one channel but not the other
51 *
52 * Hydra_Software_Devel/8   4/16/11 12:16p jgarrett
53 * SW7425-371: Removing tab characters
54 *
55 * Hydra_Software_Devel/7   4/6/11 1:23a jgarrett
56 * SW35330-35: Merge to main branch
57 *
58 * Hydra_Software_Devel/SW35330-35/1   4/5/11 12:50p jgarrett
59 * SW35330-35: FMM Abstraction refactoring to support DTV
60 *
61 * Hydra_Software_Devel/6   3/11/11 11:17a jgarrett
62 * SW7422-146: Coverity CID 289
63 *
64 * Hydra_Software_Devel/5   3/9/11 3:53p jgarrett
65 * SW7422-146: Adding DFIFO interface
66 *
67 * Hydra_Software_Devel/4   3/9/11 3:41p jgarrett
68 * SW7422-146: Optimizing SRC coefficients for several conversions
69 *
70 * Hydra_Software_Devel/3   3/9/11 2:54p jgarrett
71 * SW7422-146: Fixing SRC lockup with decode stop/start
72 *
73 * Hydra_Software_Devel/2   12/17/10 3:58p jgarrett
74 * SW7422-146: Nexus APE integration on 7422
75 *
76 * Hydra_Software_Devel/1   12/16/10 4:05p jgarrett
77 * SW7422-146: Initial compilable APE for 7422
78 *
79 ***************************************************************************/
80
81#include "bstd.h"
82#include "bkni.h"
83#include "bape.h"
84#include "bape_priv.h"
85#include "bchp_aud_fmm_src_ctrl0.h"
86
87BDBG_MODULE(bape_src_priv);
88
89typedef struct BAPE_SrcGroup
90{
91    bool allocated;
92    bool started;
93    uint8_t blockId;
94    unsigned numChannelPairs;
95    unsigned inputRate, outputRate;
96    BAPE_SrcMode mode;
97    BAPE_SrcGroupCoefficients *pCoefMemory[2];   /* IIR Coefficient Memory.  Two are required if doubleBuffered is true, otherwise one. */   
98    BAPE_Handle deviceHandle;
99    uint32_t srcIds[BAPE_ChannelPair_eMax];
100    BAPE_SrcGroupSettings settings;
101} BAPE_SrcGroup;
102
103static void BAPE_Src_P_SetGroup(BAPE_Handle deviceHandle, uint32_t src, uint32_t group);
104
105BERR_Code BAPE_P_InitSrcSw(
106                        BAPE_Handle handle
107                        )
108{
109    unsigned i;
110    uint32_t regVal;
111
112    BDBG_OBJECT_ASSERT(handle, BAPE_Device);
113
114    /* TODO: Register for ESR's to catch HW Failures?? */
115
116    /* Setup Group Handles */
117    BDBG_MSG(("Allocating %u SRC Groups", BAPE_CHIP_MAX_SRC_GROUPS));
118    handle->srcGroups[0] = BKNI_Malloc(BAPE_CHIP_MAX_SRC_GROUPS*sizeof(BAPE_SrcGroup));
119    if ( NULL == handle->srcGroups[0] )
120    {
121        return BERR_TRACE(BERR_OUT_OF_SYSTEM_MEMORY);
122    }
123    BKNI_Memset(handle->srcGroups[0], 0, BAPE_CHIP_MAX_SRC_GROUPS*sizeof(BAPE_SrcGroup));
124    for ( i = 1; i < BAPE_CHIP_MAX_SRC_GROUPS; i++ )
125    {
126        handle->srcGroups[i] = handle->srcGroups[0] + i;
127    }
128
129    /* Initialize the sampleRateConverterRampStep by reading the default value from the hardware. */
130    regVal = BREG_Read32(handle->regHandle, BCHP_AUD_FMM_SRC_CTRL0_RAMP_STEP);
131    handle->sampleRateConverterRampStep = BCHP_GET_FIELD_DATA(regVal, AUD_FMM_SRC_CTRL0_RAMP_STEP, STEP_SIZE);
132
133    return BERR_SUCCESS;
134}
135
136BERR_Code BAPE_P_InitSrcHw(
137                        BAPE_Handle handle
138                        )
139{
140    unsigned i;
141
142    #if BAPE_CHIP_SRC_TYPE_IS_LEGACY
143        uint32_t regAddr, regVal, stride, mem=0;
144
145        BDBG_OBJECT_ASSERT(handle, BAPE_Device);
146
147        /* We only use LINT mode on STB, so we just need to give each SRC 4 bytes of memory to work with. */
148        regAddr = BCHP_AUD_FMM_SRC_CTRL0_SRC_CFG0;
149        stride = BCHP_AUD_FMM_SRC_CTRL0_SRC_CFG1 - BCHP_AUD_FMM_SRC_CTRL0_SRC_CFG0;
150        for ( i = 0; i < BAPE_CHIP_MAX_SRCS; i++ )
151        {
152            regVal = BREG_Read32(handle->regHandle, regAddr);
153            regVal &= ~(BCHP_MASK(AUD_FMM_SRC_CTRL0_SRC_CFG0, BASE_ADDR)|
154                        BCHP_MASK(AUD_FMM_SRC_CTRL0_SRC_CFG0, TYPE));
155            regVal |= BCHP_FIELD_DATA(AUD_FMM_SRC_CTRL0_SRC_CFG0, BASE_ADDR, mem);
156            regVal |= BCHP_FIELD_ENUM(AUD_FMM_SRC_CTRL0_SRC_CFG0, TYPE, Bypass);
157            BREG_Write32(handle->regHandle, regAddr, regVal);
158            mem += 4;
159            regAddr += stride;
160        }
161    /* End of BAPE_CHIP_SRC_TYPE_IS_LEGACY */
162
163    #elif BAPE_CHIP_SRC_TYPE_IS_IIR       
164        uint32_t regAddr, regVal=0x0, stride, mem=0x30;
165        uint32_t coefSelRegAddr,coefRegAddr;
166
167        BDBG_OBJECT_ASSERT(handle, BAPE_Device);
168
169        /* Total SRAM Memory: 1280-48(HW Internal use) */
170        /* Each SRC is allocated 102 bytes of Scratch memory which is required for IIR. */
171        /* TODO: Add dynamic allocation support when Upx or Downx SRC types are required */
172        regAddr = BCHP_AUD_FMM_SRC_CTRL0_SRC_CFGi_ARRAY_BASE;
173        coefSelRegAddr = BCHP_AUD_FMM_SRC_CTRL0_CF_SELi_ARRAY_BASE;
174        coefRegAddr = BCHP_AUD_FMM_SRC_CTRL0_COEFFi_ARRAY_BASE;   
175        stride = 4;
176        for ( i = 0; i < BAPE_CHIP_MAX_SRCS; i++ )
177        {
178            /* Setup for IIR w/102 bytes scratch ram */
179            regVal = 0x0;
180            regVal &= ~(BCHP_MASK(AUD_FMM_SRC_CTRL0_SRC_CFGi, TM_BASE_ADDR)|
181                        BCHP_MASK(AUD_FMM_SRC_CTRL0_SRC_CFGi, SRC_TYPE)|
182                        BCHP_MASK(AUD_FMM_SRC_CTRL0_SRC_CFGi, WR_BANK_SEL));
183            regVal |= BCHP_FIELD_DATA(AUD_FMM_SRC_CTRL0_SRC_CFGi, TM_BASE_ADDR, mem);
184            regVal |= BCHP_FIELD_ENUM(AUD_FMM_SRC_CTRL0_SRC_CFGi, SRC_TYPE, Bypass);
185            regVal |= BCHP_FIELD_DATA(AUD_FMM_SRC_CTRL0_SRC_CFGi, WR_BANK_SEL, 0);
186            BREG_Write32(handle->regHandle, regAddr, regVal);
187            regVal = 0x0;
188            BREG_Write32(handle->regHandle, coefSelRegAddr, regVal);       
189            regVal = 0x0;
190            BREG_Write32(handle->regHandle, coefSelRegAddr, regVal);
191            mem += 102;     
192            regAddr += stride;
193            coefSelRegAddr += stride;
194            coefRegAddr += stride;
195        }
196
197        /* Zero the coef memory */
198        regAddr = BCHP_AUD_FMM_SRC_CTRL0_COEFFi_ARRAY_BASE;
199        for ( i = 0; i <= BCHP_AUD_FMM_SRC_CTRL0_COEFFi_ARRAY_END; i++ )
200        {
201            BREG_Write32(handle->regHandle, regAddr + (4*i), 0);
202        }
203
204    /* End of BAPE_CHIP_SRC_TYPE_IS_LEGACY */ 
205    #else
206        #error "Unknown BAPE_CHIP_SRC_TYPE"
207    #endif /* BAPE_CHIP_SRC_TYPE_... */ 
208
209    /* Reset group IDs to default */   
210    for ( i = 0; i < BAPE_CHIP_MAX_SRCS; i++ )
211    {
212        BAPE_Src_P_SetGroup(handle, i, i);
213    }
214
215    /* Refresh the HW SRC ramp step from the value saved in the device structure. */
216    (void)BAPE_SetSampleRateConverterRampStep(handle, handle->sampleRateConverterRampStep);
217
218    /* TODO: Register for ESR's to catch HW Failures?? */
219
220    return BERR_SUCCESS;
221}
222
223
224void BAPE_P_UninitSrcSw(
225                     BAPE_Handle handle
226                     )
227{
228    BDBG_OBJECT_ASSERT(handle, BAPE_Device);
229
230    if ( handle->srcGroups[0] )
231    {
232        BKNI_Free(handle->srcGroups[0]);
233        BKNI_Memset(handle->srcGroups, 0, sizeof(handle->srcGroups));
234    }
235}
236
237#include "bape_src_lint_coefs.h"
238
239static void BAPE_Src_P_SetSampleRate_isr(BAPE_Handle handle, uint32_t srcId, unsigned inputRate, unsigned outputRate)
240{
241    uint32_t regVal, regAddr;
242    BAVC_AudioSamplingRate inputRateEnum, outputRateEnum;
243    uint32_t type, num, den, denScale;
244
245    /* If the input rate is unknown, use the output rate so we go into bypass mode */
246    if ( inputRate == 0 )
247    {
248        inputRate = outputRate;
249    }
250    BDBG_ASSERT(outputRate != 0);
251
252    /* Convert from unsigned to array indexes */
253    inputRateEnum = BAPE_P_GetSampleRateEnum(inputRate);
254    outputRateEnum = BAPE_P_GetSampleRateEnum(outputRate);
255
256    if ( inputRateEnum == BAVC_AudioSamplingRate_eUnknown || outputRateEnum == BAVC_AudioSamplingRate_eUnknown )
257    {
258        /* Handle non-standard rates that aren't in a pre-computed table */
259        type = TYPE_LINT;
260        if ( inputRate == outputRate )
261        {
262            num = den = 1;
263        }
264        else
265        {
266            num = inputRate;
267            den = outputRate;
268            /* Reduce coefficients by removing common prime factors to increase quality of scaling */
269            /* Divide by two until we can't anymore */
270            while ( num % 2 == 0 && den % 2 == 0 )
271            {
272                num /= 2;
273                den /= 2;
274            }
275            /* Divide by three until we can't anymore */
276            while ( num % 3 == 0 && den % 3 == 0 )
277            {
278                num /= 3;
279                den /= 3;
280            }
281            /* Divide by five until we can't anymore */
282            while ( num % 5 == 0 && den % 5 == 0 )
283            {
284                num /= 5;
285                den /= 5;
286            }
287        }
288        denScale = DEN_SCALE(den);
289    }
290    else
291    {
292        /* Use the tables to select the correct mode */
293        type = g_pSrcTable[inputRateEnum][outputRateEnum].type;
294        num = g_pSrcTable[inputRateEnum][outputRateEnum].num;
295        den = g_pSrcTable[inputRateEnum][outputRateEnum].den;
296        denScale = g_pSrcTable[inputRateEnum][outputRateEnum].denScale;
297    }
298
299    BDBG_OBJECT_ASSERT(handle, BAPE_Device);
300    BDBG_ASSERT(srcId < BAPE_CHIP_MAX_SRCS);
301
302    BDBG_MSG(("SRC Programming - Input Rate %u Output Rate %u", inputRate, outputRate));
303    BDBG_MSG(("Programming SRC %u to mode %u num %u den %u scale %u", srcId, type, num, den, denScale));
304
305    #if BAPE_CHIP_SRC_TYPE_IS_LEGACY   
306        regAddr = BCHP_AUD_FMM_SRC_CTRL0_SRC_CFG0 + (((uint32_t) srcId)*(BCHP_AUD_FMM_SRC_CTRL0_SRC_CFG1-BCHP_AUD_FMM_SRC_CTRL0_SRC_CFG0));
307        regVal = BREG_Read32_isr(handle->regHandle, regAddr);
308        regVal &= ~BCHP_MASK(AUD_FMM_SRC_CTRL0_SRC_CFG0, TYPE);
309        regVal |= BCHP_FIELD_DATA(AUD_FMM_SRC_CTRL0_SRC_CFG0, TYPE, type);
310        BREG_Write32_isr(handle->regHandle, regAddr, regVal);
311        regAddr += BCHP_AUD_FMM_SRC_CTRL0_LI_NUM0-BCHP_AUD_FMM_SRC_CTRL0_SRC_CFG0;
312        regVal = BREG_Read32_isr(handle->regHandle, regAddr);
313        regVal &= ~BCHP_MASK(AUD_FMM_SRC_CTRL0_LI_NUM0, NUMERATOR);
314        regVal |= BCHP_FIELD_DATA(AUD_FMM_SRC_CTRL0_LI_NUM0, NUMERATOR, num);
315        BREG_Write32_isr(handle->regHandle, regAddr, regVal);
316
317        regAddr += BCHP_AUD_FMM_SRC_CTRL0_LI_DEN0-BCHP_AUD_FMM_SRC_CTRL0_LI_NUM0;
318        regVal = BREG_Read32_isr(handle->regHandle, regAddr);
319        regVal &= ~BCHP_MASK(AUD_FMM_SRC_CTRL0_LI_DEN0, DENOMINATOR);
320        regVal |= BCHP_FIELD_DATA(AUD_FMM_SRC_CTRL0_LI_DEN0, DENOMINATOR, den);
321        BREG_Write32_isr(handle->regHandle, regAddr, regVal);
322
323        regAddr += BCHP_AUD_FMM_SRC_CTRL0_LI_DEN_SCALE0-BCHP_AUD_FMM_SRC_CTRL0_LI_DEN0;
324        regVal = BREG_Read32_isr(handle->regHandle, regAddr);
325        regVal &= ~BCHP_MASK(AUD_FMM_SRC_CTRL0_LI_DEN_SCALE0, DEN_SCALE);
326        regVal |= BCHP_FIELD_DATA(AUD_FMM_SRC_CTRL0_LI_DEN_SCALE0, DEN_SCALE, denScale);
327        BREG_Write32_isr(handle->regHandle, regAddr, regVal);
328    #endif /* BAPE_CHIP_SRC_TYPE_IS_LEGACY */ 
329
330    #if BAPE_CHIP_SRC_TYPE_IS_IIR       
331        {
332            uint32_t coefAddr;
333
334            /* Reverse engineer location of coefs for this SRC */
335            regVal = BREG_Read32(handle->regHandle, BCHP_AUD_FMM_SRC_CTRL0_CF_SELi_ARRAY_BASE + (4*srcId));
336            coefAddr = (BCHP_GET_FIELD_DATA(regVal, AUD_FMM_SRC_CTRL0_CF_SELi, CF_BASE_ADDR0)-0x18);
337            BDBG_ASSERT(coefAddr < (BCHP_AUD_FMM_SRC_CTRL0_COEFFi_ARRAY_END-2));
338            coefAddr *= 4;
339            coefAddr += BCHP_AUD_FMM_SRC_CTRL0_COEFFi_ARRAY_BASE;
340
341            /* Now, write coefficients in order */
342            BREG_Write32_isr(handle->regHandle, coefAddr+0, num);
343            BREG_Write32_isr(handle->regHandle, coefAddr+4, den);
344            BREG_Write32_isr(handle->regHandle, coefAddr+8, denScale);
345
346            /* Set SRC mode */
347            regAddr = BCHP_AUD_FMM_SRC_CTRL0_SRC_CFGi_ARRAY_BASE + ((BCHP_AUD_FMM_SRC_CTRL0_SRC_CFGi_ARRAY_ELEMENT_SIZE * srcId) / 8);
348            regVal = BREG_Read32_isr(handle->regHandle, regAddr);
349            regVal &= ~BCHP_MASK(AUD_FMM_SRC_CTRL0_SRC_CFGi, SRC_TYPE);
350            regVal |= BCHP_FIELD_DATA(AUD_FMM_SRC_CTRL0_SRC_CFGi, SRC_TYPE, type);
351            BREG_Write32_isr(handle->regHandle, regAddr, regVal);
352        }
353    #endif /* BAPE_CHIP_SRC_TYPE_IS_IIR */ 
354}
355
356void BAPE_SrcGroup_P_GetDefaultCreateSettings(
357                                             BAPE_SrcGroupCreateSettings *pSettings   /* [out] */
358                                             )
359{
360    BDBG_ASSERT(NULL != pSettings);
361    pSettings->blockId = 0;
362    pSettings->numChannelPairs = 1;
363    pSettings->mode = BAPE_SrcMode_eLinear;
364
365    #if BAPE_CHIP_SRC_TYPE_IS_IIR       
366        pSettings->pCoefMemory[0]=NULL;
367        pSettings->pCoefMemory[1]=NULL;   
368        pSettings->equalizerSettings.numIirBands = 8;
369        pSettings->equalizerSettings.rampEnable = false;
370    #endif /* BAPE_CHIP_SRC_TYPE_IS_IIR */ 
371}
372
373BERR_Code BAPE_SrcGroup_P_Create(
374                                BAPE_Handle deviceHandle,
375                                const BAPE_SrcGroupCreateSettings *pSettings,
376                                BAPE_SrcGroupHandle *pHandle        /* [out] */
377                                )
378{
379    unsigned i, src;
380    BERR_Code errCode;
381    BAPE_SrcGroupHandle handle=NULL;
382    BAPE_SrcGroupCoefficients   *pCoefMemory[2]={NULL, NULL};
383
384    #if BAPE_CHIP_SRC_TYPE_IS_IIR       
385        uint32_t    regAddr, regVal;
386        BAPE_SrcCoefficientsSettings coeffSettings;
387    #endif /* BAPE_CHIP_SRC_TYPE_IS_IIR */ 
388
389    BDBG_OBJECT_ASSERT(deviceHandle, BAPE_Device);
390    BDBG_ASSERT(NULL != pSettings);
391    BDBG_ASSERT(NULL != pHandle);
392    BDBG_ASSERT(pSettings->numChannelPairs <= BAPE_ChannelPair_eMax);
393    BDBG_ASSERT(pSettings->blockId == 0);   /* TODO: Handle more than one */
394
395    switch ( pSettings->mode )
396    {
397    case BAPE_SrcMode_eBypass:
398    case BAPE_SrcMode_eLinear:
399        break;
400
401    case BAPE_SrcMode_eIir:
402        #if BAPE_CHIP_SRC_TYPE_IS_LEGACY   
403            BDBG_ERR(("SRC Equalization is not supported on this chipset."));
404            return BERR_TRACE(BERR_NOT_SUPPORTED);
405        #endif /* BAPE_CHIP_SRC_TYPE_IS_LEGACY */ 
406        break;
407
408    default:
409        /* TODO: Could add HQ modes if a usage case arises */
410        BDBG_ERR(("SRC Mode %u is not supported.", pSettings->mode));
411        return BERR_TRACE(BERR_NOT_SUPPORTED);
412    }
413
414    /* Find an available group handle */
415    for ( i = 0; i < BAPE_CHIP_MAX_SRC_GROUPS; i++ )
416    {
417        BDBG_ASSERT(NULL != deviceHandle->srcGroups[i]);
418        if ( !deviceHandle->srcGroups[i]->allocated )
419        {
420            handle = deviceHandle->srcGroups[i];
421            break;
422        }
423    }
424
425    /* If none found, return error */
426    if ( NULL == handle )
427    {
428        return BERR_TRACE(BERR_NOT_SUPPORTED);
429    }
430
431    /* Now search for the correct number of resources */
432    errCode = BAPE_P_AllocateFmmResource(deviceHandle, BAPE_FmmResourceType_eSrc, pSettings->numChannelPairs, &src);
433    if ( errCode )
434    {
435        errCode = BERR_TRACE(errCode);
436        goto err_alloc_src;
437    }
438
439    #if BAPE_CHIP_SRC_TYPE_IS_IIR       
440        /* Allocate SRC coefficient memory */
441        if(BAPE_SrcMode_eBypass != pSettings->mode)
442        { 
443            unsigned j;
444           
445            if(NULL != pSettings->pCoefMemory[0])
446            {               
447                pCoefMemory[0] = pSettings->pCoefMemory[0];
448                if(pSettings->equalizerSettings.rampEnable)
449                {
450                    if(NULL != pSettings->pCoefMemory[1])
451                    {
452                        pCoefMemory[1] = pSettings->pCoefMemory[1];
453                    }
454                    else
455                    {
456                        BDBG_ERR((" In case of Equalizer ramp enable the sharing of Coefficients can happen either for both banks or not at all"));
457                        goto err_alloc_src;
458                    }
459                }
460            }
461            else
462            {
463                pCoefMemory[0] = BKNI_Malloc(sizeof(BAPE_SrcGroupCoefficients));
464                if ( NULL == pCoefMemory[0] )
465                {
466                    errCode = BERR_OUT_OF_SYSTEM_MEMORY;
467                    return BERR_TRACE(errCode);
468                }
469                BKNI_Memset(pCoefMemory[0], 0, sizeof(BAPE_SrcGroupCoefficients));
470                if(pSettings->equalizerSettings.rampEnable)
471                {
472                    pCoefMemory[1] = BKNI_Malloc(sizeof(BAPE_SrcGroupCoefficients));
473                    if ( NULL == pCoefMemory[1] )
474                    {
475                        errCode = BERR_OUT_OF_SYSTEM_MEMORY;
476                        return BERR_TRACE(errCode);
477                    }
478                    BKNI_Memset(pCoefMemory[1], 0, sizeof(BAPE_SrcGroupCoefficients));       
479                }
480            }   
481
482            for ( i = 0; i < 2; i++ )
483            {     
484                if(NULL != pCoefMemory[i])
485                {       
486                    for ( j = 0; j < pSettings->numChannelPairs; j++ )
487                    {   
488                        coeffSettings.mode = pSettings->mode;
489                        errCode = BAPE_SrcCoefficients_P_Allocate(deviceHandle, &coeffSettings, &pCoefMemory[i]->srcCoefficients[j]);           
490                        if ( errCode )
491                        {
492                            errCode = BERR_TRACE(errCode);
493                            goto err_alloc_src;
494                        }           
495                        regAddr = BCHP_AUD_FMM_SRC_CTRL0_CF_SELi_ARRAY_BASE + (4*(src+j));
496                        regVal = BREG_Read32(deviceHandle->regHandle, regAddr);
497                        if ( i == 0 )
498                        {
499                            regVal &= ~(BCHP_MASK(AUD_FMM_SRC_CTRL0_CF_SELi, CF_BASE_ADDR0));
500                            regVal |= BCHP_FIELD_DATA(AUD_FMM_SRC_CTRL0_CF_SELi, CF_BASE_ADDR0, (pCoefMemory[i]->srcCoefficients[j].baseAddress + 0x18));
501                        }
502                        else
503                        {
504                            regVal &= ~(BCHP_MASK(AUD_FMM_SRC_CTRL0_CF_SELi, CF_BASE_ADDR1));
505                            regVal |= BCHP_FIELD_DATA(AUD_FMM_SRC_CTRL0_CF_SELi, CF_BASE_ADDR1, (pCoefMemory[i]->srcCoefficients[j].baseAddress + 0x18));
506                        }
507                        BREG_Write32(deviceHandle->regHandle, regAddr, regVal); 
508                    }
509                }
510            }
511
512            for ( i = 0; i < pSettings->numChannelPairs; i++ )
513            {       
514                BDBG_MSG(("Programming SRC %u to SRC Type %u", (src+i), pSettings->mode));
515               
516                regAddr = BCHP_AUD_FMM_SRC_CTRL0_SRC_CFGi_ARRAY_BASE + ((BCHP_AUD_FMM_SRC_CTRL0_SRC_CFGi_ARRAY_ELEMENT_SIZE * (src+i)) / 8);
517                regVal = BREG_Read32_isr(deviceHandle->regHandle, regAddr);
518                regVal &= ~BCHP_MASK(AUD_FMM_SRC_CTRL0_SRC_CFGi, SRC_TYPE);
519                if ( pSettings->mode == BAPE_SrcMode_eIir )
520                {
521                    regVal |= BCHP_FIELD_ENUM(AUD_FMM_SRC_CTRL0_SRC_CFGi, SRC_TYPE, IIR);
522                }
523                else 
524                {
525                    regVal |= BCHP_FIELD_ENUM(AUD_FMM_SRC_CTRL0_SRC_CFGi, SRC_TYPE, L_Int);
526                }
527                BREG_Write32_isr(deviceHandle->regHandle, regAddr, regVal);               
528            }
529        }
530
531    #endif /* BAPE_CHIP_SRC_TYPE_IS_IIR */ 
532
533    /* Successfully allocated resources.  Initialize Group */
534    handle->allocated = true;
535    handle->started = false;
536    handle->blockId = pSettings->blockId;
537    handle->numChannelPairs = pSettings->numChannelPairs;
538    handle->deviceHandle = deviceHandle;
539    handle->pCoefMemory[0] = pCoefMemory[0];
540    handle->pCoefMemory[1] = pCoefMemory[1];
541    handle->mode = pSettings->mode;
542    BKNI_Memset(&handle->settings, 0, sizeof(handle->settings));
543    BAPE_FciIdGroup_Init(&handle->settings.input);
544    handle->settings.rampEnabled = deviceHandle->settings.rampPcmSamples;
545    handle->settings.startupRampEnabled = deviceHandle->settings.rampPcmSamples;
546    BKNI_Memset(handle->srcIds, 0xff, sizeof(handle->srcIds));
547    for ( i = 0; i < pSettings->numChannelPairs; i++ )
548    {
549        handle->srcIds[i] = src + i;
550        /* Setup Grouping */
551        BAPE_Src_P_SetGroup(deviceHandle, src + i, src);
552    }
553    /* Unmute */
554    BKNI_EnterCriticalSection();
555    BAPE_SrcGroup_P_SetMute_isr(handle, false);
556    BAPE_SrcGroup_P_SetSampleRate_isr(handle, 48000, 48000);
557    BKNI_LeaveCriticalSection();
558    *pHandle = handle;
559    return BERR_SUCCESS;
560
561    err_alloc_src:
562    return errCode;
563}
564
565void BAPE_SrcGroup_P_Destroy(
566                            BAPE_SrcGroupHandle handle
567                            )
568{
569    unsigned i;
570
571    BDBG_ASSERT(NULL != handle);
572    BDBG_ASSERT(handle->allocated);
573    BDBG_ASSERT(!handle->started);
574    BDBG_OBJECT_ASSERT(handle->deviceHandle, BAPE_Device);
575
576    /* Clear SRC Grouping */
577    for ( i = 0; i < handle->numChannelPairs; i++ )
578    {
579        BAPE_Src_P_SetGroup(handle->deviceHandle, handle->srcIds[i], handle->srcIds[i]);
580    }
581    /* Unmute and revert to bypass */
582    BKNI_EnterCriticalSection();
583    BAPE_SrcGroup_P_SetMute_isr(handle, false);
584    BAPE_SrcGroup_P_SetSampleRate_isr(handle, 48000, 48000);
585    BKNI_LeaveCriticalSection();
586
587    /* Free SRC coefficient memory */
588    #if BAPE_CHIP_SRC_TYPE_IS_IIR       
589        for(i=0; i<2; i++)
590        {
591            if(NULL != handle->pCoefMemory[i])
592            {
593                unsigned j;
594                for(j=0; j<handle->numChannelPairs; j++)
595                {
596                    BAPE_SrcCoefficients_P_Free(
597                        handle->deviceHandle,
598                        &handle->pCoefMemory[i]->srcCoefficients[j]
599                        );
600                }
601                BKNI_Free(handle->pCoefMemory[i]);
602            }   
603        }
604    #endif /* BAPE_CHIP_SRC_TYPE_IS_IIR */ 
605
606    /* Release Resources */
607    BAPE_P_FreeFmmResource(handle->deviceHandle, BAPE_FmmResourceType_eSrc, handle->numChannelPairs, handle->srcIds[0]);
608    BKNI_Memset(handle->srcIds, 0xff, sizeof(handle->srcIds));
609    handle->allocated = false;
610}
611
612void BAPE_SrcGroup_P_GetSettings(
613                                BAPE_SrcGroupHandle handle,
614                                BAPE_SrcGroupSettings *pSettings  /* [out] */
615                                )
616{
617    BDBG_ASSERT(NULL != handle);
618    BDBG_ASSERT(handle->allocated);
619    *pSettings = handle->settings;
620}
621
622BERR_Code BAPE_SrcGroup_P_SetSettings(
623                                     BAPE_SrcGroupHandle handle,
624                                     const BAPE_SrcGroupSettings *pSettings
625                                     )
626{
627    BDBG_ASSERT(NULL != handle);
628    BDBG_ASSERT(handle->allocated);
629
630    if ( handle->started )
631    {
632        /* TODO: Implement bypass on the fly?  Maybe not required since only use L_INT and in==out will do it anyway. */
633        return BERR_TRACE(BERR_NOT_SUPPORTED);
634    }
635    handle->settings = *pSettings;
636    if ( !handle->deviceHandle->settings.rampPcmSamples )
637    {
638        handle->settings.rampEnabled = false;
639        handle->settings.startupRampEnabled = false;
640    }
641
642    return BERR_SUCCESS;
643}
644
645/***************************************************************************
646Summary:
647Set SRC Sample Rate (used for Linear mode only)
648***************************************************************************/
649void BAPE_SrcGroup_P_SetSampleRate_isr(
650                                      BAPE_SrcGroupHandle handle,
651                                      unsigned inputRate,
652                                      unsigned outputRate
653                                      )
654{
655    unsigned i;
656
657    BDBG_ASSERT(NULL != handle);
658    BDBG_ASSERT(handle->allocated);
659    BKNI_ASSERT_ISR_CONTEXT();
660
661    if ( handle->mode != BAPE_SrcMode_eLinear )
662    {
663        return;
664    }
665
666    handle->inputRate = inputRate;
667    handle->outputRate = outputRate;
668
669    if ( handle->mode == BAPE_SrcMode_eBypass || handle->settings.bypass )
670    {
671        inputRate = outputRate; /* Force bypass mode */
672    }
673
674    for ( i = 0; i < handle->numChannelPairs; i++ )
675    {
676        BAPE_Src_P_SetSampleRate_isr(handle->deviceHandle, handle->srcIds[i],inputRate, outputRate);
677    }
678}
679
680/***************************************************************************
681Summary:
682Set SRC Mute
683***************************************************************************/
684void BAPE_SrcGroup_P_SetMute_isr(
685                                BAPE_SrcGroupHandle handle,
686                                bool muted
687                                )
688{
689    unsigned i;
690    uint32_t regAddr, regVal;
691
692    BDBG_ASSERT(NULL != handle);
693    BDBG_ASSERT(handle->allocated);
694    BKNI_ASSERT_ISR_CONTEXT();
695
696    for ( i = 0; i < handle->numChannelPairs; i++ )
697    {
698        regAddr = BCHP_AUD_FMM_SRC_CTRL0_STRM_CFGi_ARRAY_BASE + 
699                  (handle->srcIds[i] * (BCHP_AUD_FMM_SRC_CTRL0_STRM_CFGi_ARRAY_ELEMENT_SIZE/8));
700        regVal = BREG_Read32_isr(handle->deviceHandle->regHandle, regAddr);
701        regVal &= ~BCHP_MASK(AUD_FMM_SRC_CTRL0_STRM_CFGi, MUTE_ENA);
702        regVal |= BCHP_FIELD_DATA(AUD_FMM_SRC_CTRL0_STRM_CFGi, MUTE_ENA, muted?1:0);
703        BREG_Write32_isr(handle->deviceHandle->regHandle, regAddr, regVal);
704    }
705}
706
707/***************************************************************************
708Summary:
709Start SRC
710***************************************************************************/
711BERR_Code BAPE_SrcGroup_P_Start(
712                               BAPE_SrcGroupHandle handle
713                               )
714{
715    uint32_t regVal, regAddr;
716#if BAPE_CHIP_SRC_TYPE_IS_LEGACY   
717    uint32_t mask, value;
718#endif /* BAPE_CHIP_SRC_TYPE_IS_LEGACY */ 
719    unsigned i;
720
721    BDBG_ASSERT(NULL != handle);
722    BDBG_ASSERT(handle->allocated);
723
724    /* Apply Settings */
725    for ( i = 0; i < handle->numChannelPairs; i++ )
726    {
727        #if BAPE_CHIP_SRC_TYPE_IS_IIR       
728            /* Ramping Options, Priority, input FCI */
729            regAddr = BCHP_AUD_FMM_SRC_CTRL0_STRM_CFGi_ARRAY_BASE + 
730                      (handle->srcIds[i] * (BCHP_AUD_FMM_SRC_CTRL0_STRM_CFGi_ARRAY_ELEMENT_SIZE/8));
731            regVal = BREG_Read32(handle->deviceHandle->regHandle, regAddr);
732            regVal &= ~(BCHP_MASK(AUD_FMM_SRC_CTRL0_STRM_CFGi, RAMP_ENA)|
733                        BCHP_MASK(AUD_FMM_SRC_CTRL0_STRM_CFGi, STARTUP_RAMP_ENA)|
734                        BCHP_MASK(AUD_FMM_SRC_CTRL0_STRM_CFGi, FCI_ID)|
735                        BCHP_MASK(AUD_FMM_SRC_CTRL0_STRM_CFGi, PRIORITY));
736            regVal |= BCHP_FIELD_DATA(AUD_FMM_SRC_CTRL0_STRM_CFGi, RAMP_ENA, handle->settings.rampEnabled?1:0);
737            regVal |= BCHP_FIELD_DATA(AUD_FMM_SRC_CTRL0_STRM_CFGi, STARTUP_RAMP_ENA, handle->settings.startupRampEnabled?1:0);
738            regVal |= BCHP_FIELD_DATA(AUD_FMM_SRC_CTRL0_STRM_CFGi, FCI_ID, handle->settings.input.ids[i]);
739            regVal |= BCHP_FIELD_DATA(AUD_FMM_SRC_CTRL0_STRM_CFGi, PRIORITY, handle->settings.highPriority?1:0);
740            BREG_Write32(handle->deviceHandle->regHandle, regAddr, regVal);
741        #endif /* BAPE_CHIP_SRC_TYPE_IS_IIR */ 
742
743
744        #if BAPE_CHIP_SRC_TYPE_IS_LEGACY   
745            /* Ramping Options, Priority, input FCI */
746            regAddr = BCHP_AUD_FMM_SRC_CTRL0_STRM_CFGi_ARRAY_BASE + 
747                      (handle->srcIds[i] * (BCHP_AUD_FMM_SRC_CTRL0_STRM_CFGi_ARRAY_ELEMENT_SIZE/8));
748            regVal = BREG_Read32(handle->deviceHandle->regHandle, regAddr);
749            regVal &= ~(BCHP_MASK(AUD_FMM_SRC_CTRL0_STRM_CFGi, RAMP_ENA)|
750            #ifdef BCHP_AUD_FMM_SRC_CTRL0_STRM_CFGi_RAMP_ZERO_DET_ENA_MASK
751                        BCHP_MASK(AUD_FMM_SRC_CTRL0_STRM_CFGi, RAMP_ZERO_DET_ENA)|  /* SW7425-574: This feature does not work unless both L+R have non-zero data.  The field is renamed to ZERO_DETECT when it works correctly. */
752            #endif                   
753                        BCHP_MASK(AUD_FMM_SRC_CTRL0_STRM_CFGi, STARTUP_RAMP_ENA));
754            regVal |= BCHP_FIELD_DATA(AUD_FMM_SRC_CTRL0_STRM_CFGi, RAMP_ENA, handle->settings.rampEnabled?1:0);
755            regVal |= BCHP_FIELD_DATA(AUD_FMM_SRC_CTRL0_STRM_CFGi, STARTUP_RAMP_ENA, handle->settings.startupRampEnabled?1:0);
756            BREG_Write32(handle->deviceHandle->regHandle, regAddr, regVal);
757
758            /* Input FCI */
759            regAddr = BCHP_AUD_FMM_SRC_CTRL0_IDMAP10 + ((handle->srcIds[i]/2)*(BCHP_AUD_FMM_SRC_CTRL0_IDMAP32-BCHP_AUD_FMM_SRC_CTRL0_IDMAP10));
760            regVal = BREG_Read32(handle->deviceHandle->regHandle, regAddr);
761            if ( handle->srcIds[i] & 1 )
762            {
763                /* Odd */
764                regVal &= ~BCHP_MASK(AUD_FMM_SRC_CTRL0_IDMAP10, STREAM1);
765                regVal |= BCHP_FIELD_DATA(AUD_FMM_SRC_CTRL0_IDMAP10, STREAM1, handle->settings.input.ids[i]);
766            }
767            else
768            {
769                /* Even */
770                regVal &= ~BCHP_MASK(AUD_FMM_SRC_CTRL0_IDMAP10, STREAM0);
771                regVal |= BCHP_FIELD_DATA(AUD_FMM_SRC_CTRL0_IDMAP10, STREAM0, handle->settings.input.ids[i]);
772            }
773            BREG_Write32(handle->deviceHandle->regHandle, regAddr, regVal);
774        #endif /* BAPE_CHIP_SRC_TYPE_IS_LEGACY */ 
775    }
776
777    /* Re-apply Sample Rate */
778    BKNI_EnterCriticalSection();
779    BAPE_SrcGroup_P_SetSampleRate_isr(handle, handle->inputRate, handle->outputRate);
780    BKNI_LeaveCriticalSection();
781
782    #if BAPE_CHIP_SRC_TYPE_IS_IIR       
783        /* Set Enables Last */
784        for ( i = 0; i < handle->numChannelPairs; i++ )
785        {
786            regAddr = BCHP_AUD_FMM_SRC_CTRL0_STRM_CFGi_ARRAY_BASE + 
787                      (handle->srcIds[i] * (BCHP_AUD_FMM_SRC_CTRL0_STRM_CFGi_ARRAY_ELEMENT_SIZE/8));
788            regVal = BREG_Read32(handle->deviceHandle->regHandle, regAddr);
789            regVal |= BCHP_MASK(AUD_FMM_SRC_CTRL0_STRM_CFGi, ENABLE);
790            BREG_Write32(handle->deviceHandle->regHandle, regAddr, regVal);
791        }
792    #endif /* BAPE_CHIP_SRC_TYPE_IS_IIR */ 
793
794    #if BAPE_CHIP_SRC_TYPE_IS_LEGACY   
795        /* Set Priority */
796        mask=value=0;
797        for ( i = 0; i < handle->numChannelPairs; i++ )
798        {
799            mask |= (BCHP_MASK(AUD_FMM_SRC_CTRL0_STRM_ENA, PRIORITY0) << handle->srcIds[i]);
800        }
801        value = (handle->settings.highPriority) ? mask : 0;
802        regVal = BREG_Read32(handle->deviceHandle->regHandle, BCHP_AUD_FMM_SRC_CTRL0_STRM_ENA);
803        BREG_Write32(handle->deviceHandle->regHandle, BCHP_AUD_FMM_SRC_CTRL0_STRM_ENA, (regVal & ~mask) | value);
804
805        /* Set Enable */
806        mask=0;
807        for ( i = 0; i < handle->numChannelPairs; i++ )
808        {
809            mask |= (BCHP_MASK(AUD_FMM_SRC_CTRL0_STRM_ENA, ENA0) << handle->srcIds[i]);
810        }
811        regVal = BREG_Read32(handle->deviceHandle->regHandle, BCHP_AUD_FMM_SRC_CTRL0_STRM_ENA);
812        BREG_Write32(handle->deviceHandle->regHandle, BCHP_AUD_FMM_SRC_CTRL0_STRM_ENA, regVal | mask);
813    #endif /* BAPE_CHIP_SRC_TYPE_IS_LEGACY */ 
814
815    handle->started = true;
816    return BERR_SUCCESS;
817}
818
819/***************************************************************************
820Summary:
821Stop SRC
822***************************************************************************/
823void BAPE_SrcGroup_P_Stop(
824                         BAPE_SrcGroupHandle handle
825                         )
826{
827    unsigned i;
828
829    BDBG_ASSERT(NULL != handle);
830    BDBG_ASSERT(handle->allocated);
831
832    if ( !handle->started )
833    {
834        return;
835    }
836
837    /* Stop */
838    #if BAPE_CHIP_SRC_TYPE_IS_LEGACY   
839        {
840            uint32_t regVal, mask;
841
842            mask=0;
843            for ( i = 0; i < handle->numChannelPairs; i++ )
844            {
845                mask |= (BCHP_MASK(AUD_FMM_SRC_CTRL0_STRM_ENA, ENA0) << handle->srcIds[i]);
846            }
847            regVal = BREG_Read32(handle->deviceHandle->regHandle, BCHP_AUD_FMM_SRC_CTRL0_STRM_ENA);
848            BREG_Write32(handle->deviceHandle->regHandle, BCHP_AUD_FMM_SRC_CTRL0_STRM_ENA, regVal & (~mask));
849        }
850    #endif /* BAPE_CHIP_SRC_TYPE_IS_LEGACY */ 
851
852    #if BAPE_CHIP_SRC_TYPE_IS_IIR       
853        {
854            uint32_t regVal, regAddr;
855
856            for ( i = 0; i < handle->numChannelPairs; i++ )
857            {
858                regAddr = BCHP_AUD_FMM_SRC_CTRL0_STRM_CFGi_ARRAY_BASE + 
859                          (handle->srcIds[i] * (BCHP_AUD_FMM_SRC_CTRL0_STRM_CFGi_ARRAY_ELEMENT_SIZE/8));
860                regVal = BREG_Read32(handle->deviceHandle->regHandle, regAddr);
861                regVal &= ~BCHP_MASK(AUD_FMM_SRC_CTRL0_STRM_CFGi, ENABLE);
862                BREG_Write32(handle->deviceHandle->regHandle, regAddr, regVal);
863            }
864        }
865    #endif /* BAPE_CHIP_SRC_TYPE_IS_IIR */ 
866
867    handle->started = false;
868}
869
870/***************************************************************************
871Summary:
872Set Coefficient Index (used for Equalizer mode only)
873***************************************************************************/
874void BAPE_SrcGroup_P_SetCoefficientIndex_isr(
875                                            BAPE_SrcGroupHandle handle,
876                                            unsigned index
877                                            )
878{
879    BSTD_UNUSED(handle);
880    BSTD_UNUSED(index);
881    /* These chips don't support IIR filtering */
882    (void)BERR_TRACE(BERR_NOT_SUPPORTED);
883}
884
885void BAPE_SrcGroup_P_GetOutputFciIds(
886                                    BAPE_SrcGroupHandle handle,
887                                    BAPE_FciIdGroup *pFciGroup      /* [out] */
888                                    )
889{
890    unsigned i;
891
892    BDBG_ASSERT(NULL != handle);
893    BDBG_ASSERT(handle->blockId == 0);
894
895    BAPE_FciIdGroup_Init(pFciGroup);
896    for ( i = 0; i < handle->numChannelPairs; i++ )
897    {
898        pFciGroup->ids[i] = (0x2<<6) | handle->srcIds[i];
899    }
900}
901
902static void BAPE_Src_P_SetGroup(BAPE_Handle deviceHandle, uint32_t src, uint32_t group)
903{
904    BREG_Handle regHandle;
905    uint32_t regAddr, regVal;
906
907    BDBG_OBJECT_ASSERT(deviceHandle, BAPE_Device);
908    regHandle = deviceHandle->regHandle;
909
910    regAddr = BCHP_AUD_FMM_SRC_CTRL0_STRM_CFGi_ARRAY_BASE + (src * (BCHP_AUD_FMM_SRC_CTRL0_STRM_CFGi_ARRAY_ELEMENT_SIZE/8));
911    regVal = BREG_Read32(regHandle, regAddr);
912    regVal &= ~BCHP_MASK(AUD_FMM_SRC_CTRL0_STRM_CFGi, GROUP);
913    regVal |= BCHP_FIELD_DATA(AUD_FMM_SRC_CTRL0_STRM_CFGi, GROUP, group);
914    BREG_Write32(regHandle, regAddr, regVal);
915}
916
917void BAPE_GetSampleRateConverterRampStep(
918                                        BAPE_Handle deviceHandle,
919                                        uint32_t *pRampStep                 /* All sample rate converters volume is changed by this amount
920                                                                               every Fs while ramping.  Specified in 4.23 format.
921                                                                               Ignored for compressed data. */
922                                        )
923{
924    BDBG_OBJECT_ASSERT(deviceHandle, BAPE_Device);
925    BDBG_ASSERT(NULL != pRampStep);
926
927    *pRampStep = deviceHandle->sampleRateConverterRampStep;
928}
929
930BERR_Code BAPE_SetSampleRateConverterRampStep(
931                                             BAPE_Handle deviceHandle,
932                                             uint32_t rampStep             /* All sample rate converters volume is changed by this amount
933                                                                                    every Fs while ramping.  Specified in 4.23 format.
934                                                                                    Ignored for compressed data. */
935                                             )
936{
937    uint32_t regVal;
938
939    BDBG_OBJECT_ASSERT(deviceHandle, BAPE_Device);
940
941    if ( rampStep > 0x8000 )
942    {
943        BDBG_ERR(("Maximum SRC ramp step is 0x8000"));
944        return BERR_TRACE(BERR_INVALID_PARAMETER);
945    }
946
947    regVal = BREG_Read32(deviceHandle->regHandle, BCHP_AUD_FMM_SRC_CTRL0_RAMP_STEP);
948    regVal &= ~BCHP_MASK(AUD_FMM_SRC_CTRL0_RAMP_STEP, STEP_SIZE);
949    regVal |= BCHP_FIELD_DATA(AUD_FMM_SRC_CTRL0_RAMP_STEP, STEP_SIZE, rampStep);
950    BREG_Write32(deviceHandle->regHandle, BCHP_AUD_FMM_SRC_CTRL0_RAMP_STEP, regVal);
951
952    /* Save the setting in the BAPE_Device struct.  Use the value from the register field in case the user's value was truncated. */
953    deviceHandle->sampleRateConverterRampStep = BCHP_GET_FIELD_DATA(regVal, AUD_FMM_SRC_CTRL0_RAMP_STEP, STEP_SIZE);
954
955    return BERR_SUCCESS;
956}
957
958
959#if BAPE_CHIP_SRC_TYPE_IS_IIR       
960BERR_Code BAPE_SrcCoefficients_P_Allocate(
961                                        BAPE_Handle deviceHandle,
962                                        const BAPE_SrcCoefficientsSettings *pSettings,
963                                        BAPE_SrcCoefficients *pCoefficients           /* [out] Coefficient status */
964                                        )
965{
966    unsigned    chunk;
967    BERR_Code errCode=BERR_SUCCESS;
968
969    BDBG_OBJECT_ASSERT(deviceHandle, BAPE_Device);
970
971    /*
972        SRC Coefficient Memory Partition:
973        0
974        . --> IIR
975        .
976        11
977
978        12
979        . --> Linear
980        .
981        27
982    */
983    switch(pSettings->mode)
984    {
985        case BAPE_SrcMode_eIir:
986            for(chunk=BAPE_CHIP_P_SRC_IIR_CHUNK_BASE; chunk<=BAPE_CHIP_P_SRC_IIR_CHUNK_END; chunk++)
987            {
988                if(false == deviceHandle->srcCoeffAllocated[chunk])
989                {
990                    pCoefficients->baseAddress = chunk*BAPE_CHIP_P_MAX_SRC_IIR_COEFF_PER_CHUNK;
991                    pCoefficients->numCoefs = BAPE_CHIP_P_MAX_SRC_IIR_COEFF_PER_CHUNK;
992                    break;
993                }
994            }
995            if(chunk > BAPE_CHIP_P_SRC_IIR_CHUNK_END)
996            {
997                BDBG_ERR(("No free IIR coefficients memory available"));
998                errCode = BERR_NOT_SUPPORTED;
999            }
1000            else
1001            {
1002                deviceHandle->srcCoeffAllocated[chunk] = true;
1003            }
1004            break;
1005           
1006        case BAPE_SrcMode_eLinear:
1007            for(chunk=BAPE_CHIP_P_SRC_LIN_CHUNK_BASE; chunk<=BAPE_CHIP_P_SRC_LIN_CHUNK_END; chunk++)
1008            {
1009                if(false == deviceHandle->srcCoeffAllocated[chunk])
1010                {
1011                    pCoefficients->baseAddress = BAPE_CHIP_P_TOTAL_SRC_IIR_COEFF + 
1012                        (chunk - BAPE_CHIP_P_SRC_LIN_CHUNK_BASE)*BAPE_CHIP_P_NUM_LIN_COEFF_PER_CHUNK;
1013                    pCoefficients->numCoefs = BAPE_CHIP_P_NUM_LIN_COEFF_PER_CHUNK;
1014                    break;
1015                }
1016            }
1017            if(chunk > BAPE_CHIP_P_SRC_LIN_CHUNK_END)
1018            {
1019                BDBG_ERR(("No free Linear coefficients memory available"));
1020                errCode = BERR_NOT_SUPPORTED;
1021            }
1022            else
1023            {
1024                deviceHandle->srcCoeffAllocated[chunk] = true;
1025            }
1026            break;
1027           
1028        default:
1029            BDBG_ERR(("Unsupported SRC Type %d", pSettings->mode));
1030            return BERR_NOT_SUPPORTED;
1031    }
1032
1033    BDBG_MSG(("SRC Coeff Memory Allocated: Mode=%d, Coeff Offset=%u", pSettings->mode, pCoefficients->baseAddress));
1034    return errCode;
1035}
1036
1037void BAPE_SrcCoefficients_P_Free(
1038    BAPE_Handle deviceHandle,
1039    BAPE_SrcCoefficients *pCoefficients             /* [modified] Coefficients will be released */
1040    )
1041{
1042    unsigned chunk;
1043    BDBG_ASSERT(NULL != pCoefficients);
1044
1045    if(pCoefficients->baseAddress <= (BAPE_CHIP_P_MAX_SRC_IIR_CHUNKS*BAPE_CHIP_P_MAX_SRC_IIR_COEFF_PER_CHUNK))
1046    {
1047        chunk = pCoefficients->baseAddress/BAPE_CHIP_P_MAX_SRC_IIR_COEFF_PER_CHUNK;
1048    }
1049    else
1050    {
1051        chunk = (pCoefficients->baseAddress - BAPE_CHIP_P_TOTAL_SRC_IIR_COEFF)/BAPE_CHIP_P_NUM_LIN_COEFF_PER_CHUNK + \
1052                    BAPE_CHIP_P_SRC_LIN_CHUNK_BASE;
1053    }       
1054       
1055    deviceHandle->srcCoeffAllocated[chunk] = false;   
1056}
1057
1058void BAPE_SrcGroup_P_UpdateCoefficients_isr(
1059        BAPE_SrcGroupHandle src, 
1060        BAPE_SRC_P_IIRCoeff *pCoeff,
1061        unsigned *pStepSize
1062        )
1063{
1064    unsigned i, j, regAddr, coefRegAddr, regVal, newBank=0;
1065    BDBG_ASSERT(NULL!=src);
1066
1067    for(i=0; i<src->numChannelPairs; i++)
1068    {
1069        if(pStepSize)
1070        {
1071            regAddr = BCHP_AUD_FMM_SRC_CTRL0_SRC_CFGi_ARRAY_BASE + ((BCHP_AUD_FMM_SRC_CTRL0_SRC_CFGi_ARRAY_ELEMENT_SIZE * (src->srcIds[i])) / 8);
1072            regVal = BREG_Read32(src->deviceHandle->regHandle, regAddr);
1073            newBank = (0 == (BCHP_GET_FIELD_DATA(regVal, AUD_FMM_SRC_CTRL0_SRC_CFGi, WR_BANK_SEL)))?1:0;
1074        }
1075
1076        coefRegAddr = BCHP_AUD_FMM_SRC_CTRL0_COEFFi_ARRAY_BASE +
1077        (src->pCoefMemory[newBank]->srcCoefficients[i].baseAddress*(BCHP_AUD_FMM_SRC_CTRL0_COEFFi_ARRAY_ELEMENT_SIZE/8));
1078       
1079        for(j=0; j<BAPE_CHIP_P_MAX_IIR_FILTERS_PER_SRC; j++)
1080        {
1081            BREG_Write32_isr(src->deviceHandle->regHandle, 
1082                coefRegAddr+(4*5*j), 
1083                pCoeff->b0[j]);
1084            BREG_Write32_isr(src->deviceHandle->regHandle, 
1085                coefRegAddr+(4*5*j)+4, 
1086                pCoeff->b1[j]);
1087            BREG_Write32_isr(src->deviceHandle->regHandle, 
1088                coefRegAddr+(4*5*j)+8,
1089                pCoeff->b2[j]);
1090            BREG_Write32_isr(src->deviceHandle->regHandle, 
1091                coefRegAddr+(4*5*j)+12,
1092                pCoeff->a1[j]);   
1093            BREG_Write32_isr(src->deviceHandle->regHandle, 
1094                coefRegAddr+(4*5*j)+16,
1095                pCoeff->a2[j]);   
1096        }
1097
1098        if(pStepSize)
1099        {
1100            regAddr = BCHP_AUD_FMM_SRC_CTRL0_SRC_CFGi_ARRAY_BASE + ((BCHP_AUD_FMM_SRC_CTRL0_SRC_CFGi_ARRAY_ELEMENT_SIZE * (src->srcIds[i])) / 8);
1101            regVal = BREG_Read32(src->deviceHandle->regHandle, regAddr);
1102            regVal = ~(BCHP_MASK(AUD_FMM_SRC_CTRL0_SRC_CFGi, IIR_STEP_SIZE));
1103            regVal = ~(BCHP_MASK(AUD_FMM_SRC_CTRL0_SRC_CFGi, WR_BANK_SEL));
1104            regVal |= BCHP_FIELD_DATA(AUD_FMM_SRC_CTRL0_SRC_CFGi, IIR_STEP_SIZE, *pStepSize);
1105            regVal |= BCHP_FIELD_DATA(AUD_FMM_SRC_CTRL0_SRC_CFGi, WR_BANK_SEL, (newBank));
1106            BREG_Write32(src->deviceHandle->regHandle, regAddr, regVal);
1107        }       
1108    }
1109}
1110#endif /* BAPE_CHIP_SRC_TYPE_IS_IIR */ 
1111
Note: See TracBrowser for help on using the repository browser.