source: svn/newcon3bcm2_21bu/magnum/portinginterface/ape/7552/bape_fmm_isr.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: 17.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_fmm_isr.c $
11 * $brcm_Revision: Hydra_Software_Devel/4 $
12 * $brcm_Date: 11/14/11 3:40p $
13 *
14 * Module Description: Audio Decoder Interface
15 *
16 * Revision History:
17 *
18 * $brcm_Log: /magnum/portinginterface/ape/7422/bape_fmm_isr.c $
19 *
20 * Hydra_Software_Devel/4   11/14/11 3:40p gskerl
21 * SW7429-18: Merging 7429 changes back to main branch.
22 *
23 * Hydra_Software_Devel/SW7429-18/2   10/25/11 9:40a jgarrett
24 * SW7429-18: Adding interrupt ID's for 7429
25 *
26 * Hydra_Software_Devel/SW7429-18/1   10/21/11 6:29p jgarrett
27 * SW7429-18: Initial compileable version for 7429
28 *
29 * Hydra_Software_Devel/3   4/6/11 1:23a jgarrett
30 * SW35330-35: Merge to main branch
31 *
32 * Hydra_Software_Devel/SW35330-35/1   4/5/11 12:49p jgarrett
33 * SW35330-35: FMM Abstraction refactoring to support DTV
34 *
35 * Hydra_Software_Devel/2   3/10/11 7:03p jgarrett
36 * SW7422-146: Refactored DFIFO code, added support for input capture from
37 * compressed/multichannel
38 *
39 * Hydra_Software_Devel/1   12/16/10 4:04p jgarrett
40 * SW7422-146: Initial compilable APE for 7422
41 *
42 ***************************************************************************/
43
44#include "bstd.h"
45#include "bkni.h"
46#include "bape.h"
47#include "bape_priv.h"
48
49#ifdef BCHP_AIO_INTH_REG_START
50#include "bchp_int_id_aio_inth.h"
51#include "bchp_aud_fmm_bf_esr1_h.h"
52#include "bchp_aud_fmm_bf_esr2_h.h"
53
54static void BAPE_P_BfEsr1_isr(void *pParam1, int param2);
55static void BAPE_P_BfEsr2_isr(void *pParam1, int param2);
56#endif
57
58#ifdef BCHP_AUD_INTH_REG_START
59#include "bchp_int_id_aud_inth.h"
60#include "bchp_aud_fmm_bf_esr.h"
61
62static void BAPE_P_BfEsr2_isr(void *pParam1, int param2);
63static void BAPE_P_BfEsr3_isr(void *pParam1, int param2);
64static void BAPE_P_BfEsr4_isr(void *pParam1, int param2);
65#endif
66
67BDBG_MODULE(bape_fmm_isr);
68
69BERR_Code BAPE_P_InitInterrupts(
70    BAPE_Handle handle
71    )
72{
73    BERR_Code errCode;
74    uint32_t intId;
75
76    /* Clear the L3 interrupts before enabling any callbacks */
77#ifdef BCHP_AUD_FMM_BF_ESR2_H_MASK_SET
78    BREG_Write32(handle->regHandle, BCHP_AUD_FMM_BF_ESR2_H_MASK_SET, 0xffffffff&~BCHP_MASK(AUD_FMM_BF_ESR2_H_MASK_SET, reserved0));
79    intId = BCHP_INT_ID_FMM_BF2;
80#else
81    BREG_Write32(handle->regHandle, BCHP_AUD_FMM_BF_ESR_ESR2_MASK_SET, 0xffffffff&~BCHP_MASK(AUD_FMM_BF_ESR_ESR2_MASK_SET, reserved0));
82    intId = BCHP_INT_ID_AUD_BF2;
83#endif
84   
85    /* Install the L2 handler */
86    errCode = BINT_CreateCallback(&handle->isrBfEsr2,
87                                  handle->intHandle,
88                                  intId,
89                                  BAPE_P_BfEsr2_isr,
90                                  handle,
91                                  0);
92    if ( errCode )
93    {
94        BAPE_P_UninitInterrupts(handle);
95        return BERR_TRACE(errCode);
96    }
97
98    BINT_EnableCallback(handle->isrBfEsr2);
99
100#ifdef BCHP_AIO_INTH_REG_START
101    /* Clear the L3 interrupts before enabling any callbacks */
102    BREG_Write32(handle->regHandle, BCHP_AUD_FMM_BF_ESR1_H_MASK_SET, 0xffffffff&~BCHP_MASK(AUD_FMM_BF_ESR1_H_MASK_SET, reserved0));
103
104    /* Install the L2 handler */
105    errCode = BINT_CreateCallback(&handle->isrBfEsr1,
106                                  handle->intHandle,
107                                  BCHP_INT_ID_FMM_BF1,
108                                  BAPE_P_BfEsr1_isr,
109                                  handle,
110                                  0);
111    if ( errCode )
112    {
113        BAPE_P_UninitInterrupts(handle);
114        return BERR_TRACE(errCode);
115    }
116
117    BINT_EnableCallback(handle->isrBfEsr1);
118#else
119    /* Clear the L3 interrupts before enabling any callbacks */
120    BREG_Write32(handle->regHandle, BCHP_AUD_FMM_BF_ESR_ESR3_MASK_SET, 0xffffffff&~BCHP_MASK(AUD_FMM_BF_ESR_ESR3_MASK_SET, reserved0));
121
122    /* Install the L2 handler */
123    errCode = BINT_CreateCallback(&handle->isrBfEsr3,
124                                  handle->intHandle,
125                                  BCHP_INT_ID_AUD_BF3,
126                                  BAPE_P_BfEsr3_isr,
127                                  handle,
128                                  0);
129    if ( errCode )
130    {
131        BAPE_P_UninitInterrupts(handle);
132        return BERR_TRACE(errCode);
133    }
134
135    BINT_EnableCallback(handle->isrBfEsr3);
136
137    /* Clear the L3 interrupts before enabling any callbacks */
138    BREG_Write32(handle->regHandle, BCHP_AUD_FMM_BF_ESR_ESR4_MASK_SET, 0xffffffff&~BCHP_MASK(AUD_FMM_BF_ESR_ESR4_MASK_SET, reserved0));
139
140    /* Install the L2 handler */
141    errCode = BINT_CreateCallback(&handle->isrBfEsr4,
142                                  handle->intHandle,
143                                  BCHP_INT_ID_AUD_BF4,
144                                  BAPE_P_BfEsr4_isr,
145                                  handle,
146                                  0);
147    if ( errCode )
148    {
149        BAPE_P_UninitInterrupts(handle);
150        return BERR_TRACE(errCode);
151    }
152
153    BINT_EnableCallback(handle->isrBfEsr4);
154#endif   
155
156    return errCode;
157}
158
159void BAPE_P_UninitInterrupts(
160    BAPE_Handle handle
161    )
162{
163    if ( handle->isrBfEsr4 )
164    {
165        BKNI_EnterCriticalSection();
166        BINT_DisableCallback_isr(handle->isrBfEsr4);
167        BKNI_LeaveCriticalSection();
168        BINT_DestroyCallback(handle->isrBfEsr4);
169        handle->isrBfEsr4 = NULL;
170    }
171
172    if ( handle->isrBfEsr3 )
173    {
174        BKNI_EnterCriticalSection();
175        BINT_DisableCallback_isr(handle->isrBfEsr3);
176        BKNI_LeaveCriticalSection();
177        BINT_DestroyCallback(handle->isrBfEsr3);
178        handle->isrBfEsr3 = NULL;
179    }
180
181    if ( handle->isrBfEsr2 )
182    {
183        BKNI_EnterCriticalSection();
184        BINT_DisableCallback_isr(handle->isrBfEsr2);
185        BKNI_LeaveCriticalSection();
186        BINT_DestroyCallback(handle->isrBfEsr2);
187        handle->isrBfEsr2 = NULL;
188    }
189
190    if ( handle->isrBfEsr1 )
191    {
192        BKNI_EnterCriticalSection();
193        BINT_DisableCallback_isr(handle->isrBfEsr1);
194        BKNI_LeaveCriticalSection();
195        BINT_DestroyCallback(handle->isrBfEsr1);
196        handle->isrBfEsr1 = NULL;
197    }
198}
199
200BERR_Code BAPE_P_SetSourceChannelFreemarkInterrupt(
201    BAPE_Handle handle,
202    unsigned sourceChannelId,
203    BINT_CallbackFunc callback_isr,
204    void *pParam1,
205    int param2)
206{
207    uint32_t bitmask;
208
209    BDBG_OBJECT_ASSERT(handle, BAPE_Device);
210
211    BDBG_ASSERT(sourceChannelId < BAPE_CHIP_MAX_SFIFOS);
212
213    BKNI_EnterCriticalSection();
214    handle->sourceRbufFreemark[sourceChannelId].callback_isr = callback_isr;
215    handle->sourceRbufFreemark[sourceChannelId].pParam1 = pParam1;
216    handle->sourceRbufFreemark[sourceChannelId].param2 = param2;
217    BKNI_LeaveCriticalSection();
218
219#ifdef BCHP_AUD_FMM_BF_ESR2_H_MASK
220    bitmask = BCHP_MASK(AUD_FMM_BF_ESR2_H_MASK, SOURCE_RINGBUF_0_EXCEED_FREEMARK) << sourceChannelId;
221
222    if ( callback_isr )
223    {
224        /* Enable the interrupt */
225        BREG_Write32(handle->regHandle, BCHP_AUD_FMM_BF_ESR2_H_MASK_CLEAR, bitmask);
226    }
227    else
228    {
229        /* Disable the interrupt */
230        BREG_Write32(handle->regHandle, BCHP_AUD_FMM_BF_ESR2_H_MASK_SET, bitmask);
231    }
232#else
233    bitmask = BCHP_MASK(AUD_FMM_BF_ESR_ESR3_MASK, SOURCE_RINGBUF_0_EXCEED_FREEMARK) << sourceChannelId;
234
235    if ( callback_isr )
236    {
237        /* Enable the interrupt */
238        BREG_Write32(handle->regHandle, BCHP_AUD_FMM_BF_ESR_ESR3_MASK_CLEAR, bitmask);
239    }
240    else
241    {
242        /* Disable the interrupt */
243        BREG_Write32(handle->regHandle, BCHP_AUD_FMM_BF_ESR_ESR3_MASK_SET, bitmask);
244    }
245#endif
246
247    return BERR_SUCCESS;
248}
249
250BERR_Code BAPE_P_SetDfifoFullmarkInterrupt(
251    BAPE_Handle handle,
252    unsigned destChannelId,
253    BINT_CallbackFunc callback_isr,
254    void *pParam1,
255    int param2
256    )
257{
258    uint32_t bitmask;
259
260    BDBG_OBJECT_ASSERT(handle, BAPE_Device);
261
262    BDBG_ASSERT(destChannelId < BAPE_CHIP_MAX_DFIFOS);
263
264    BKNI_EnterCriticalSection();
265    handle->destRbufFullmark[destChannelId].callback_isr = callback_isr;
266    handle->destRbufFullmark[destChannelId].pParam1 = pParam1;
267    handle->destRbufFullmark[destChannelId].param2 = param2;
268    BKNI_LeaveCriticalSection();
269
270#ifdef BCHP_AUD_FMM_BF_ESR2_H_MASK
271    bitmask = BCHP_MASK(AUD_FMM_BF_ESR2_H_MASK, DEST_RINGBUF_0_EXCEED_FULLMARK) << destChannelId;
272
273    if ( callback_isr )
274    {
275        /* Enable the interrupt */
276        BREG_Write32(handle->regHandle, BCHP_AUD_FMM_BF_ESR2_H_MASK_CLEAR, bitmask);
277    }
278    else
279    {
280        /* Disable the interrupt */
281        BREG_Write32(handle->regHandle, BCHP_AUD_FMM_BF_ESR2_H_MASK_SET, bitmask);
282    }
283#else
284    bitmask = BCHP_MASK(AUD_FMM_BF_ESR_ESR4_MASK, DEST_RINGBUF_0_EXCEED_FULLMARK) << destChannelId;
285
286    if ( callback_isr )
287    {
288        /* Enable the interrupt */
289        BREG_Write32(handle->regHandle, BCHP_AUD_FMM_BF_ESR_ESR4_MASK_CLEAR, bitmask);
290    }
291    else
292    {
293        /* Disable the interrupt */
294        BREG_Write32(handle->regHandle, BCHP_AUD_FMM_BF_ESR_ESR4_MASK_SET, bitmask);
295    }
296#endif
297
298    return BERR_SUCCESS;
299}
300
301BERR_Code BAPE_P_SetDfifoOverflowInterrupt(
302    BAPE_Handle handle,
303    unsigned destChannelId,
304    BINT_CallbackFunc callback_isr,
305    void *pParam1,
306    int param2
307    )
308{
309    uint32_t bitmask;
310
311    BDBG_OBJECT_ASSERT(handle, BAPE_Device);
312
313    BDBG_ASSERT(destChannelId < BAPE_CHIP_MAX_DFIFOS);
314
315    BKNI_EnterCriticalSection();
316    handle->destRbufOverflow[destChannelId].callback_isr = callback_isr;
317    handle->destRbufOverflow[destChannelId].pParam1 = pParam1;
318    handle->destRbufOverflow[destChannelId].param2 = param2;
319    BKNI_LeaveCriticalSection();
320
321#ifdef BCHP_AUD_FMM_BF_ESR1_H_MASK
322    bitmask = BCHP_MASK(AUD_FMM_BF_ESR1_H_MASK, DEST_RINGBUF_0_OVERFLOW) << destChannelId;
323
324    if ( callback_isr )
325    {
326        /* Enable the interrupt */
327        BREG_Write32(handle->regHandle, BCHP_AUD_FMM_BF_ESR1_H_MASK_CLEAR, bitmask);
328    }
329    else
330    {
331        /* Disable the interrupt */
332        BREG_Write32(handle->regHandle, BCHP_AUD_FMM_BF_ESR1_H_MASK_SET, bitmask);
333    }
334#else
335    bitmask = BCHP_MASK(AUD_FMM_BF_ESR_ESR2_MASK, DEST_RINGBUF_0_OVERFLOW) << destChannelId;
336
337    if ( callback_isr )
338    {
339        /* Enable the interrupt */
340        BREG_Write32(handle->regHandle, BCHP_AUD_FMM_BF_ESR_ESR2_MASK_CLEAR, bitmask);
341    }
342    else
343    {
344        /* Disable the interrupt */
345        BREG_Write32(handle->regHandle, BCHP_AUD_FMM_BF_ESR_ESR2_MASK_SET, bitmask);
346    }
347#endif
348
349    return BERR_SUCCESS;
350}
351
352#ifdef BCHP_AIO_INTH_REG_START
353static void BAPE_P_BfEsr1_isr(void *pParam1, int param2)
354{
355    uint32_t bitmask, mask, status;
356    BAPE_Handle deviceHandle = pParam1;
357    unsigned i;
358
359    BDBG_OBJECT_ASSERT(deviceHandle, BAPE_Device);
360    BSTD_UNUSED(param2);
361
362    /* TODO: Source channel underflow if needed */
363
364    status = BREG_Read32_isr(deviceHandle->regHandle, BCHP_AUD_FMM_BF_ESR1_H_STATUS);
365    mask = BREG_Read32_isr(deviceHandle->regHandle, BCHP_AUD_FMM_BF_ESR1_H_MASK);
366    bitmask = BCHP_MASK(AUD_FMM_BF_ESR1_H_MASK, DEST_RINGBUF_0_OVERFLOW);
367
368    BDBG_MSG(("BF ESR1 ISR S:0x%08x M:0x%08x", status, mask));
369
370    for ( i = 0; i < BAPE_CHIP_MAX_DFIFOS; i++, bitmask<<=1 )
371    {
372        if ( status & ~mask & bitmask )
373        {
374            /* Sanity check */
375            BDBG_ASSERT(NULL != deviceHandle->destRbufOverflow[i].callback_isr);
376
377            BDBG_MSG(("Destination Channel %d overflow interrupt", i));
378            /* Fire the callback */
379            deviceHandle->destRbufOverflow[i].callback_isr(deviceHandle->destRbufOverflow[i].pParam1, deviceHandle->destRbufOverflow[i].param2);
380            /* Clear the status bit */
381            BREG_Write32_isr(deviceHandle->regHandle, BCHP_AUD_FMM_BF_ESR1_H_STATUS_CLEAR, bitmask);
382        }
383    }
384
385    BINT_EnableCallback_isr(deviceHandle->isrBfEsr1);
386}
387
388static void BAPE_P_BfEsr2_isr(void *pParam1, int param2)
389{
390    uint32_t bitmask, mask, status;
391    BAPE_Handle deviceHandle = pParam1;
392    unsigned i;
393
394    BDBG_OBJECT_ASSERT(deviceHandle, BAPE_Device);
395    BSTD_UNUSED(param2);
396
397    status = BREG_Read32_isr(deviceHandle->regHandle, BCHP_AUD_FMM_BF_ESR2_H_STATUS);
398    mask = BREG_Read32_isr(deviceHandle->regHandle, BCHP_AUD_FMM_BF_ESR2_H_MASK);
399    bitmask = BCHP_MASK(AUD_FMM_BF_ESR2_H_MASK, SOURCE_RINGBUF_0_EXCEED_FREEMARK);
400
401    BDBG_MSG(("BF ESR2 ISR S:0x%08x M:0x%08x", status, mask));
402
403    for ( i = 0; i < BAPE_CHIP_MAX_SFIFOS; i++, bitmask<<=1 )
404    {
405        if ( status & ~mask & bitmask )
406        {
407            /* Sanity check */
408            BDBG_ASSERT(NULL != deviceHandle->sourceRbufFreemark[i].callback_isr);
409
410            BDBG_MSG(("Source Channel %d freemark interrupt", i));
411            /* Fire the callback */
412            deviceHandle->sourceRbufFreemark[i].callback_isr(deviceHandle->sourceRbufFreemark[i].pParam1, deviceHandle->sourceRbufFreemark[i].param2);
413            /* Clear the status bit */
414            BREG_Write32_isr(deviceHandle->regHandle, BCHP_AUD_FMM_BF_ESR2_H_STATUS_CLEAR, bitmask);
415        }
416    }
417
418    bitmask = BCHP_MASK(AUD_FMM_BF_ESR2_H_MASK, DEST_RINGBUF_0_EXCEED_FULLMARK);
419    for ( i = 0; i < BAPE_CHIP_MAX_DFIFOS; i++, bitmask<<=1 )
420    {
421        if ( status & ~mask & bitmask )
422        {
423            /* Sanity check */
424            BDBG_ASSERT(NULL != deviceHandle->destRbufFullmark[i].callback_isr);
425
426            BDBG_MSG(("Destination Channel %d fullmark interrupt", i));
427            /* Fire the callback */
428            deviceHandle->destRbufFullmark[i].callback_isr(deviceHandle->destRbufFullmark[i].pParam1, deviceHandle->destRbufFullmark[i].param2);
429            /* Clear the status bit */
430            BREG_Write32_isr(deviceHandle->regHandle, BCHP_AUD_FMM_BF_ESR2_H_STATUS_CLEAR, bitmask);
431        }
432    }
433
434    BINT_EnableCallback_isr(deviceHandle->isrBfEsr2);
435}
436#else
437/* 7429-style interrupts */
438static void BAPE_P_BfEsr2_isr(void *pParam1, int param2)
439{
440    uint32_t bitmask, mask, status;
441    BAPE_Handle deviceHandle = pParam1;
442    unsigned i;
443
444    BDBG_OBJECT_ASSERT(deviceHandle, BAPE_Device);
445    BSTD_UNUSED(param2);
446
447    status = BREG_Read32_isr(deviceHandle->regHandle, BCHP_AUD_FMM_BF_ESR_ESR2_STATUS);
448    mask = BREG_Read32_isr(deviceHandle->regHandle, BCHP_AUD_FMM_BF_ESR_ESR2_MASK);
449    bitmask = BCHP_MASK(AUD_FMM_BF_ESR_ESR2_MASK, DEST_RINGBUF_0_OVERFLOW);
450
451    BDBG_MSG(("BF ESR2 ISR S:0x%08x M:0x%08x", status, mask));
452
453    for ( i = 0; i < BAPE_CHIP_MAX_DFIFOS; i++, bitmask<<=1 )
454    {
455        if ( status & ~mask & bitmask )
456        {
457            /* Sanity check */
458            BDBG_ASSERT(NULL != deviceHandle->destRbufOverflow[i].callback_isr);
459
460            BDBG_MSG(("Dest Channel %d overflow interrupt", i));
461            /* Fire the callback */
462            deviceHandle->destRbufOverflow[i].callback_isr(deviceHandle->destRbufOverflow[i].pParam1, deviceHandle->destRbufOverflow[i].param2);
463            /* Clear the status bit */
464            BREG_Write32_isr(deviceHandle->regHandle, BCHP_AUD_FMM_BF_ESR_ESR2_STATUS_CLEAR, bitmask);
465        }
466    }
467
468    BINT_EnableCallback_isr(deviceHandle->isrBfEsr2);
469}
470
471static void BAPE_P_BfEsr3_isr(void *pParam1, int param2)
472{
473    uint32_t bitmask, mask, status;
474    BAPE_Handle deviceHandle = pParam1;
475    unsigned i;
476
477    BDBG_OBJECT_ASSERT(deviceHandle, BAPE_Device);
478    BSTD_UNUSED(param2);
479
480    status = BREG_Read32_isr(deviceHandle->regHandle, BCHP_AUD_FMM_BF_ESR_ESR3_STATUS);
481    mask = BREG_Read32_isr(deviceHandle->regHandle, BCHP_AUD_FMM_BF_ESR_ESR3_MASK);
482    bitmask = BCHP_MASK(AUD_FMM_BF_ESR_ESR3_MASK, SOURCE_RINGBUF_0_EXCEED_FREEMARK);
483
484    BDBG_MSG(("BF ESR3 ISR S:0x%08x M:0x%08x", status, mask));
485
486    for ( i = 0; i < BAPE_CHIP_MAX_SFIFOS; i++, bitmask<<=1 )
487    {
488        if ( status & ~mask & bitmask )
489        {
490            /* Sanity check */
491            BDBG_ASSERT(NULL != deviceHandle->sourceRbufFreemark[i].callback_isr);
492
493            BDBG_MSG(("Source Channel %d freemark interrupt", i));
494            /* Fire the callback */
495            deviceHandle->sourceRbufFreemark[i].callback_isr(deviceHandle->sourceRbufFreemark[i].pParam1, deviceHandle->sourceRbufFreemark[i].param2);
496            /* Clear the status bit */
497            BREG_Write32_isr(deviceHandle->regHandle, BCHP_AUD_FMM_BF_ESR_ESR3_STATUS_CLEAR, bitmask);
498        }
499    }
500
501    BINT_EnableCallback_isr(deviceHandle->isrBfEsr3);
502}
503
504static void BAPE_P_BfEsr4_isr(void *pParam1, int param2)
505{
506    uint32_t bitmask, mask, status;
507    BAPE_Handle deviceHandle = pParam1;
508    unsigned i;
509
510    BDBG_OBJECT_ASSERT(deviceHandle, BAPE_Device);
511    BSTD_UNUSED(param2);
512
513    status = BREG_Read32_isr(deviceHandle->regHandle, BCHP_AUD_FMM_BF_ESR_ESR4_STATUS);
514    mask = BREG_Read32_isr(deviceHandle->regHandle, BCHP_AUD_FMM_BF_ESR_ESR4_MASK);
515    bitmask = BCHP_MASK(AUD_FMM_BF_ESR_ESR4_MASK, DEST_RINGBUF_0_EXCEED_FULLMARK);
516
517    BDBG_MSG(("BF ESR4 ISR S:0x%08x M:0x%08x", status, mask));
518
519    for ( i = 0; i < BAPE_CHIP_MAX_DFIFOS; i++, bitmask<<=1 )
520    {
521        if ( status & ~mask & bitmask )
522        {
523            /* Sanity check */
524            BDBG_ASSERT(NULL != deviceHandle->destRbufFullmark[i].callback_isr);
525
526            BDBG_MSG(("Dest Channel %d fullmark interrupt", i));
527            /* Fire the callback */
528            deviceHandle->destRbufFullmark[i].callback_isr(deviceHandle->destRbufFullmark[i].pParam1, deviceHandle->destRbufFullmark[i].param2);
529            /* Clear the status bit */
530            BREG_Write32_isr(deviceHandle->regHandle, BCHP_AUD_FMM_BF_ESR_ESR4_STATUS_CLEAR, bitmask);
531        }
532    }
533
534    BINT_EnableCallback_isr(deviceHandle->isrBfEsr4);
535}
536
537#endif
Note: See TracBrowser for help on using the repository browser.