source: svn/trunk/newcon3bcm2_21bu/magnum/portinginterface/dma/7552/bdma_mem.c

Last change on this file was 2, checked in by jglee, 11 years ago

first commit
  • Property svn:executable set to *
File size: 21.7 KB
Line 
1/***************************************************************************
2 *     Copyright (c) 2003-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: bdma_mem.c $
11 * $brcm_Revision: Hydra_Software_Devel/9 $
12 * $brcm_Date: 3/21/11 6:37p $
13 *
14 * Module Description:
15 *
16 *
17 * Revision History:
18 * $brcm_Log: /magnum/portinginterface/dma/7400/bdma_mem.c $
19 *
20 * Hydra_Software_Devel/9   3/21/11 6:37p vanessah
21 * SW7420-1431: support oflarge DMA descriptor list subset
22 *
23 * Hydra_Software_Devel/8   2/22/11 7:48a vanessah
24 * SW7550-670: add Sharf DMA support
25 *
26 * Hydra_Software_Devel/7   2/2/11 10:26a vanessah
27 * SW7550-670: add Sharf DMA support
28 *
29 * Hydra_Software_Devel/6   1/18/11 4:53p cdisc
30 * SW35125-56: adding 35125 BCHP precompile lines and removing 35125 stub
31 * functions
32 *
33 * Hydra_Software_Devel/5   11/9/10 5:11p vanessah
34 * SW35125-11:  DMA PI support for 35125
35 *
36 * Hydra_Software_Devel/4   8/20/08 4:07p syang
37 * PR 45892 : took off unnecessary criticalsection protection
38 *
39 * Hydra_Software_Devel/3   7/30/08 11:53a syang
40 * PR 45128: fix ptr over-run caused by using BDMA_MemDmaEngine_eUnknown
41 * for engine handle array boundary
42 *
43 * Hydra_Software_Devel/2   7/11/08 3:45p syang
44 * PR 43729:  rm code for old crypto hw arch
45 *
46 * Hydra_Software_Devel/24   12/7/07 6:38p syang
47 * PR 34606: move SetCrypto to Tran level from Engine level for better
48 * sharing by threads of the same progress
49 *
50 * Hydra_Software_Devel/23   12/7/07 4:10p syang
51 * PR 34606: rewrite more than half of code to support hw sharing for
52 * kernel and user-mode sides
53 *
54 * Hydra_Software_Devel/22   10/15/07 3:37p syang
55 * PR 35947: add "_isr" to call back func name
56 *
57 * Hydra_Software_Devel/21   3/16/07 3:23p syang
58 * PR 28173: add scatter-gather support
59 *
60 * Hydra_Software_Devel/20   3/16/07 12:51p syang
61 * PR 28173: add dynamic link support (not turn on yet)
62 *
63 * Hydra_Software_Devel/18   10/3/06 4:00p syang
64 * PR 24634: replace critical section with private mutex for
65 * mem/pci_dma_handle create/destroy.
66 *
67 * Hydra_Software_Devel/17   3/23/06 12:41p syang
68 * PR 19670: added support for 7438
69 *
70 * Hydra_Software_Devel/16   7/14/05 5:12p syang
71 * PR 16059: updated 7401 crypto configure
72 *
73 * Hydra_Software_Devel/15   7/8/05 4:00p nissen
74 * PR 15575: Added BDMA_Mem_Transfer() entry point function to do memory
75 * transfers with less function call overhead.
76 *
77 * Hydra_Software_Devel/14   5/19/05 4:46p syang
78 * PR 14516: added obsolete comments to older API Func, and added _isr
79 * version of SetDmaBlockInfo
80 *
81 * Hydra_Software_Devel/13   5/18/05 9:44p nissen
82 * PR 14516: Added support for setting ENC_DEC_INIT and removed word
83 * alignment check of TRANSFER_SIZE.
84 *
85 * Hydra_Software_Devel/12   5/18/05 9:00p nissen
86 * PR 15312: Added support for big endian memory transfers.
87 *
88 * Hydra_Software_Devel/11   5/13/05 4:23p syang
89 * PR 15269: added implementation of BDMA_Mem_Tran_GetMaxNumBlocks and
90 * BDMA_Pci_Tran_GetMaxNumBlocks
91 *
92 * Hydra_Software_Devel/10   5/24/04 5:58p jasonh
93 * PR 11189: Merge down from B0 to main-line
94 *
95 * Hydra_Software_Devel/Refsw_Devel_7038_B0/1   5/6/04 2:23p syang
96 * PR 10685:  In order to support new crypt features of B0, changed DesSel
97 * to CryptAlg,  expanded Key sel, added MODE_SEL and ENC_DEC_INIT
98 * setting (changed to use mode 1, mode 0 is not used again),
99 *
100 * Hydra_Software_Devel/9   2/4/04 3:00p syang
101 * PR 9608: 1). added init for hMemDma / hPciDma of Channel, hDma of
102 * MemDma / PciDma and hChannel of Queue; 2). split CallBackFunc type def
103 * to mem and pci versions; 3). fixed typo in TranHandle def; 4).leave
104 * critical section before calling BINT func; 5). fixed a bug with
105 * nextDesc in Desc info setting; 6). use wake to start dma as in sleep
106 * mode; 7). corrected typo in the asserts of Queue_CreateTran.
107 *
108 * Hydra_Software_Devel/8   10/23/03 6:17p syang
109 * to make linux comipler silent
110 *
111 * Hydra_Software_Devel/7   10/23/03 4:20p syang
112 * adjusted sub-module implementaion overview
113 *
114 * Hydra_Software_Devel/6   10/23/03 11:07a syang
115 * first time checking after resolving comipling errors
116 *
117 * Hydra_Software_Devel/5   10/21/03 4:34p syang
118 * added implementation of StartAndCallBack
119 *
120 * Hydra_Software_Devel/4   10/20/03 12:15p syang
121 * updated to use TranHandle (rather than TranId)
122 *
123 * Hydra_Software_Devel/3   10/10/03 4:15p syang
124 * added peStatus to CallAndWait
125 *
126 * Hydra_Software_Devel/2   10/3/03 6:14p syang
127 * added real code
128 *
129 * Hydra_Software_Devel/1   9/25/03 7:02p syang
130 * init version, from scratch
131 *
132 ***************************************************************************/
133
134
135#include "bdma_mem_priv.h"    /*  */
136#include "bkni.h"
137
138BDBG_MODULE(BDMA_MEM);
139
140/***************************************************************************
141 * Implementation Overview:
142 *
143 * The corresponding API functions of both interrupt handler (or critical
144 * session) and non-interrupt handler context version call the same
145 * corresponding private function to do the real job. However, a non-
146 * interrupt handler context version API function enters critical session
147 * before calling its private function, and leave critical session afterwards.
148 * But interrupt handler is already not interruptable, a interrupt handler
149 * context version of API functions call their private functions without
150 * entering critical session
151 ****************************************************************************/
152
153/* Default settings. */
154static const BDMA_Mem_Settings s_stDefaultMemDmaSettings =
155{
156        BDMA_P_NUM_QUEUE_ENTRIES,
157        BDMA_P_MAX_NUM_BLOCKS,
158
159        /* deafult for the case that only one BDMA instance exists in the system */
160        NULL, NULL, NULL, 0, true
161};
162
163/***************************************************************************
164 *
165 */
166BERR_Code BDMA_Mem_GetDefaultSettings
167        ( BDMA_Mem_Settings     *pDefSettings )
168{
169        if (NULL != pDefSettings)
170        {
171                *pDefSettings = s_stDefaultMemDmaSettings;
172                return BERR_SUCCESS;
173        }
174        else
175        {
176                return BERR_TRACE(BERR_INVALID_PARAMETER);             
177        }
178}
179
180
181/***************************************************************************
182 *
183 */
184BERR_Code BDMA_Mem_SetByteSwapMode(
185        BDMA_Mem_Handle          hMemDma,
186        BDMA_Endian              eReadEndian,
187        BDMA_SwapMode            eSwapMode )
188{
189        BERR_Code  eResult = BERR_SUCCESS;
190
191        /*BKNI_EnterCriticalSection();*/
192        eResult = BDMA_P_Mem_SetByteSwapMode_isr( hMemDma, eReadEndian, eSwapMode );
193        /*BKNI_LeaveCriticalSection();*/
194               
195        return BERR_TRACE(eResult);
196}
197
198/***************************************************************************
199 *
200 */
201BERR_Code BDMA_Mem_Tran_Create2(
202        BDMA_Mem_Handle          hMemDma,
203        uint32_t                 ulNumBlocks,
204        bool                     bCachedDesc,
205        BDMA_Mem_Tran_Handle  *  phTran )
206{
207        BERR_Code  eResult = BERR_SUCCESS;
208
209        BKNI_EnterCriticalSection();   
210        eResult = BDMA_P_Mem_Tran_Create_isr( hMemDma, ulNumBlocks, bCachedDesc, phTran );
211        BKNI_LeaveCriticalSection();
212               
213        return BERR_TRACE(eResult);
214}
215
216/***************************************************************************
217 *
218 */
219BERR_Code BDMA_Mem_Tran_Create2_isr(
220        BDMA_Mem_Handle          hMemDma,
221        uint32_t                 ulNumBlocks,
222        bool                     bCachedDesc,
223        BDMA_Mem_Tran_Handle  *  phTran )
224{
225        BERR_Code  eResult = BERR_SUCCESS;
226
227        eResult = BDMA_P_Mem_Tran_Create_isr( hMemDma, ulNumBlocks, bCachedDesc, phTran );
228               
229        return BERR_TRACE(eResult);
230}
231
232
233/***************************************************************************
234 *
235 */
236BERR_Code BDMA_Mem_Tran_Create(
237        BDMA_Mem_Handle          hMemDma,
238        uint32_t                 ulNumBlocks,
239        BDMA_Mem_Tran_Handle  *  phTran )
240{
241        BERR_Code  eResult = BERR_SUCCESS;
242
243        BKNI_EnterCriticalSection();   
244        eResult = BDMA_P_Mem_Tran_Create_isr( hMemDma, ulNumBlocks, false, phTran );
245        BKNI_LeaveCriticalSection();
246               
247        return BERR_TRACE(eResult);
248}
249
250/***************************************************************************
251 *
252 */
253BERR_Code BDMA_Mem_Tran_Create_isr(
254        BDMA_Mem_Handle          hMemDma,
255        uint32_t                 ulNumBlocks,
256        BDMA_Mem_Tran_Handle  *  phTran )
257{
258        BERR_Code  eResult = BERR_SUCCESS;
259
260        eResult = BDMA_P_Mem_Tran_Create_isr( hMemDma, ulNumBlocks, false, phTran );
261               
262        return BERR_TRACE(eResult);
263}
264
265
266/***************************************************************************
267 *
268 */
269BERR_Code BDMA_Mem_Tran_GetMaxNumBlocks(
270        BDMA_Mem_Handle          hMemDma,
271        uint32_t *               pulMaxNumBlocks )
272{
273        BERR_Code  eResult = BERR_SUCCESS;
274
275        if ( (NULL == hMemDma) || (NULL == pulMaxNumBlocks) )
276        {
277                eResult = BERR_TRACE(BERR_INVALID_PARAMETER);
278                goto BDMA_Done_Mem_Tran_GetMaxNumBlocks;
279        }
280        *pulMaxNumBlocks = BDMA_P_MAX_NUM_BLOCKS;
281
282  BDMA_Done_Mem_Tran_GetMaxNumBlocks:
283       
284        return BERR_TRACE(eResult);
285}
286
287
288
289/***************************************************************************
290 *
291 */
292BERR_Code BDMA_Mem_Tran_GetStatus(
293        BDMA_Mem_Tran_Handle     hTran,
294        BDMA_TranStatus *        peTranStatus )
295{
296        BERR_Code  eResult = BERR_SUCCESS;
297
298        BKNI_EnterCriticalSection();
299        eResult = BDMA_P_Mem_Tran_GetStatus_isr( hTran, peTranStatus );
300        BKNI_LeaveCriticalSection();
301               
302        return BERR_TRACE(eResult);
303 
304}
305
306/***************************************************************************
307 *
308 */
309BERR_Code BDMA_Mem_Tran_Destroy(
310        BDMA_Mem_Tran_Handle     hTran )
311{
312        BERR_Code  eResult = BERR_SUCCESS;
313
314        BKNI_EnterCriticalSection();
315        eResult = BDMA_P_Mem_Tran_Destroy_isr( hTran );
316        BKNI_LeaveCriticalSection();
317               
318        return BERR_TRACE(eResult);
319}
320
321/***************************************************************************
322 *
323 */
324BERR_Code BDMA_Mem_Tran_Reset(
325        BDMA_Mem_Tran_Handle     hTran )
326{
327        BERR_Code  eResult = BERR_SUCCESS;
328
329        /*BKNI_EnterCriticalSection();*/
330        eResult = BDMA_P_Mem_Tran_Reset_isr( hTran );
331        /*BKNI_LeaveCriticalSection();*/
332               
333        return BERR_TRACE(eResult);
334}
335
336/***************************************************************************
337 *
338 */
339BERR_Code BDMA_Mem_Tran_GetStatus_isr(
340        BDMA_Mem_Tran_Handle     hTran,
341        BDMA_TranStatus *        peTranStatus )
342{
343        BERR_Code  eResult = BERR_SUCCESS;
344
345        eResult = BDMA_P_Mem_Tran_GetStatus_isr( hTran, peTranStatus );
346               
347        return BERR_TRACE(eResult);
348 
349}
350
351/***************************************************************************
352 *
353 */
354BERR_Code BDMA_Mem_Tran_Destroy_isr(
355        BDMA_Mem_Tran_Handle     hTran )
356{
357        BERR_Code  eResult = BERR_SUCCESS;
358
359        eResult = BDMA_P_Mem_Tran_Destroy_isr( hTran );
360               
361        return BERR_TRACE(eResult);
362}
363
364/***************************************************************************
365 *
366 */
367BERR_Code BDMA_Mem_Tran_Reset_isr(
368        BDMA_Mem_Tran_Handle     hTran )
369{
370        BERR_Code  eResult = BERR_SUCCESS;
371
372        eResult = BDMA_P_Mem_Tran_Reset_isr( hTran );
373               
374        return BERR_TRACE(eResult);
375}
376
377
378#if BDMA_P_SUPPORT_MEM_DMA_ENGINE
379
380/***************************************************************************
381 *
382 */
383BERR_Code BDMA_Mem_Create2(
384        BDMA_Handle           hDma,
385        BDMA_MemDmaEngine     eEngine,
386        BDMA_Mem_Settings *   pSettings,       
387        BDMA_Mem_Handle *     phMemDma )
388{
389        BERR_Code  eResult = BERR_SUCCESS;
390        BDMA_P_Context  *pDma;
391
392        BDMA_P_MAIN_GET_CONTEXT( hDma, pDma );
393        if (NULL == pDma)
394        {
395                eResult = BERR_TRACE(BERR_INVALID_PARAMETER);
396                goto BDMA_Err_Mem_Create;
397        }
398       
399        /* hDma passed the magic check, we trust every thing pointed by it now */
400        eResult = BKNI_AcquireMutex(pDma->hMutex);
401        if (BERR_SUCCESS == eResult)
402        {
403                if (NULL != pSettings)
404                        eResult = BDMA_P_Mem_Create( hDma, eEngine, pSettings, phMemDma );
405                else
406                        eResult = BDMA_P_Mem_Create( hDma, eEngine, &s_stDefaultMemDmaSettings, phMemDma );
407                BKNI_ReleaseMutex(pDma->hMutex);
408        }
409
410  BDMA_Err_Mem_Create:
411        return BERR_TRACE(eResult);
412}
413
414
415/***************************************************************************
416 * Obsolete Memory Dma API:
417 **************************************************************************/
418
419/***************************************************************************
420 *
421 */
422BERR_Code BDMA_Mem_Create(
423        BDMA_Handle           hDma,
424        BDMA_Mem_Handle *     phMemDma )
425{
426        BERR_Code  eResult = BERR_SUCCESS;
427        BDMA_P_Context  *pDma;
428        BDMA_P_Mem_Context  *pMemDma = NULL;
429        BDMA_MemDmaEngine  eEngine;
430       
431        BDMA_P_MAIN_GET_CONTEXT( hDma, pDma );
432        if (NULL == pDma)
433        {
434                eResult = BERR_TRACE(BERR_INVALID_PARAMETER);
435                goto BDMA_Err_Mem_Create;
436        }
437       
438        /* hDma passed the magic check, we trust every thing pointed by it now */
439        *phMemDma = NULL;
440        eResult = BKNI_AcquireMutex(pDma->hMutex);
441        if (BERR_SUCCESS == eResult)
442        {
443                for (eEngine = BDMA_MemDmaEngine_e0; eEngine < BDMA_P_SUPPORT_MEM_DMA_ENGINE; eEngine ++)
444                {
445                        pMemDma = BDMA_P_GetMemDmaHandle( hDma, eEngine );
446                        if (NULL == pMemDma)
447                                break;
448                }
449               
450                if ( NULL == pMemDma )
451                {
452                        /* eEngine is not used yet */
453                        eResult = BDMA_P_Mem_Create( hDma, eEngine, &s_stDefaultMemDmaSettings, phMemDma );
454                }
455                else
456                {
457                        /* all mem dma engine are used */
458                        eResult = BDMA_ERR_ENGINE_OCCUPIED;
459                }
460                BKNI_ReleaseMutex(pDma->hMutex);
461        }
462
463  BDMA_Err_Mem_Create:
464        return BERR_TRACE(eResult);
465}
466
467
468
469/***************************************************************************
470 *
471 */
472BERR_Code BDMA_Mem_Destroy(
473        BDMA_Mem_Handle       hMemDma )
474{
475        BKNI_MutexHandle  hMutex;
476        BERR_Code  eResult = BERR_SUCCESS;
477
478        eResult = BDMA_P_Mem_AcquireMutex( hMemDma, &hMutex );
479        if (BERR_SUCCESS == eResult)
480        {
481                eResult = BDMA_P_Mem_Destroy( hMemDma );
482                BKNI_ReleaseMutex(hMutex);
483        }
484               
485        return BERR_TRACE(eResult);
486}
487
488
489
490/***************************************************************************
491 *
492 */
493BERR_Code BDMA_Mem_Tran_SetCrypto(
494        BDMA_Mem_Tran_Handle     hTran,
495        BDMA_CryptMode           eCryptMode,
496        uint32_t                 ulKeySlot,
497        bool                     bSgEnable )
498{
499        BERR_Code  eResult = BERR_SUCCESS;
500
501        /*BKNI_EnterCriticalSection();*/
502        eResult = BDMA_P_Mem_Tran_SetCrypto_isr( hTran, eCryptMode, ulKeySlot, bSgEnable );
503        /*BKNI_LeaveCriticalSection();*/
504               
505        return BERR_TRACE(eResult);
506}
507
508/***************************************************************************
509 *
510 */
511BERR_Code BDMA_Mem_Tran_SetCrypto_isr(
512        BDMA_Mem_Tran_Handle     hTran,
513        BDMA_CryptMode           eCryptMode,
514        uint32_t                 ulKeySlot,
515        bool                     bSgEnable )
516{
517        BERR_Code  eResult = BERR_SUCCESS;
518
519        eResult = BDMA_P_Mem_Tran_SetCrypto_isr( hTran, eCryptMode, ulKeySlot, bSgEnable );
520               
521        return BERR_TRACE(eResult);
522}
523
524/***************************************************************************
525 *
526 */
527BERR_Code BDMA_Mem_SetCrypt(
528        BDMA_Mem_Handle          hMemDma,
529        BDMA_CryptMode           eCryptMode,
530        uint32_t                 ulKeySlot )
531{
532        BERR_Code  eResult = BERR_SUCCESS;
533
534        BKNI_EnterCriticalSection();
535        eResult = BDMA_P_Mem_SetCrypto_isr( hMemDma, eCryptMode, ulKeySlot, false );
536        BKNI_LeaveCriticalSection();
537               
538        return BERR_TRACE(eResult);
539}
540
541/***************************************************************************
542 *
543 */
544BERR_Code BDMA_Mem_SetCrypto(
545        BDMA_Mem_Handle          hMemDma,
546        BDMA_CryptMode           eCryptMode,
547        uint32_t                 ulKeySlot,
548        bool                     bSgEnable )
549{
550        BERR_Code  eResult = BERR_SUCCESS;
551
552        BKNI_EnterCriticalSection();
553        eResult = BDMA_P_Mem_SetCrypto_isr( hMemDma, eCryptMode, ulKeySlot, bSgEnable );
554        BKNI_LeaveCriticalSection();
555               
556        return BERR_TRACE(eResult);
557}
558
559
560/***************************************************************************
561 *
562 */
563BERR_Code BDMA_Mem_Tran_SetDmaBlockInfo(
564        BDMA_Mem_Tran_Handle     hTran,
565        uint32_t                 ulBlockId,
566        uint32_t                 ulDstBusAddr,
567        uint32_t                 ulSrcBusAddr,
568        uint32_t                 ulBlockSize,
569        bool                     bCryptInit )
570{
571        BERR_Code  eResult = BERR_SUCCESS;
572
573        /*BKNI_EnterCriticalSection();*/
574        eResult = BDMA_P_Mem_Tran_SetDmaBlockInfo_isr( hTran, ulBlockId,
575                                                                                        ulDstBusAddr, ulSrcBusAddr,
576                                                                                        ulBlockSize, bCryptInit );
577        /*BKNI_LeaveCriticalSection();*/
578               
579        return BERR_TRACE(eResult);
580}
581
582/***************************************************************************
583 *
584 */
585BERR_Code BDMA_Mem_Tran_SetDmaBlockInfo_isr(
586        BDMA_Mem_Tran_Handle     hTran,
587        uint32_t                 ulBlockId,
588        uint32_t                 ulDstBusAddr,
589        uint32_t                 ulSrcBusAddr,
590        uint32_t                 ulBlockSize,
591        bool                     bCryptInit )
592{
593        BERR_Code  eResult = BERR_SUCCESS;
594
595        eResult = BDMA_P_Mem_Tran_SetDmaBlockInfo_isr( hTran, ulBlockId,
596                                                                                        ulDstBusAddr, ulSrcBusAddr,
597                                                                                        ulBlockSize, bCryptInit );
598               
599        return BERR_TRACE(eResult);
600}
601
602
603/***************************************************************************
604 *
605 */
606BERR_Code BDMA_Mem_Tran_SetSgStartEnd(
607        BDMA_Mem_Tran_Handle     hTran,
608        uint32_t                 ulBlockId,
609        bool                     bSgStart,
610        bool                     bSgEnd )
611{
612        BERR_Code  eResult = BERR_SUCCESS;
613
614        /*BKNI_EnterCriticalSection();*/
615        eResult = BDMA_P_Mem_Tran_SetSgStartEnd_isr( hTran, ulBlockId,
616                                                                                                 bSgStart, bSgEnd );
617        /*BKNI_LeaveCriticalSection();*/
618               
619        return BERR_TRACE(eResult);
620}
621
622
623/***************************************************************************
624 *
625 */
626BERR_Code BDMA_Mem_Tran_SetSgStartEnd_isr(
627        BDMA_Mem_Tran_Handle     hTran,
628        uint32_t                 ulBlockId,
629        bool                     bSgStart,
630        bool                     bSgEnd )
631{
632        BERR_Code  eResult = BERR_SUCCESS;
633
634        eResult = BDMA_P_Mem_Tran_SetSgStartEnd_isr( hTran, ulBlockId,
635                                                                                                 bSgStart, bSgEnd );
636               
637        return BERR_TRACE(eResult);
638}
639
640/***************************************************************************
641 *
642 */
643BERR_Code BDMA_Mem_Transfer(
644        BDMA_Mem_Tran_Handle     hTran,
645        uint32_t                 ulBlockId,
646        uint32_t                 ulDstBusAddr,
647        uint32_t                 ulSrcBusAddr,
648        uint32_t                 ulBlockSize,
649        bool                     bCryptInit,
650        BDMA_Mem_CallbackFunc    pCallBackFunc_isr,
651        void *                   pUserCallBackParam )
652{
653        BERR_Code  eResult = BERR_SUCCESS;
654
655        BKNI_EnterCriticalSection();
656        eResult = BDMA_P_Mem_Transfer_isr( hTran, 
657                ulBlockId, ulDstBusAddr, ulSrcBusAddr, ulBlockSize, bCryptInit, 
658                pCallBackFunc_isr, pUserCallBackParam );
659        BKNI_LeaveCriticalSection();
660               
661        return BERR_TRACE(eResult);
662
663}
664
665
666
667/***************************************************************************
668 *
669 */
670BERR_Code BDMA_Mem_Tran_StartAndCallBack_isr(
671        BDMA_Mem_Tran_Handle     hTran,
672        BDMA_Mem_CallbackFunc    pCallBackFunc_isr,
673        void *                   pUserCallBackParam )
674{
675        BERR_Code  eResult = BERR_SUCCESS;
676
677        eResult = BDMA_P_Mem_Tran_Start_isr( hTran, hTran->QueueEntry.ulNumTranBlocks,
678                                                                                 pCallBackFunc_isr, pUserCallBackParam );
679               
680        return BERR_TRACE(eResult);
681}
682
683/***************************************************************************
684 *
685 */
686BERR_Code BDMA_Mem_Tran_Start(
687        BDMA_Mem_Tran_Handle     hTran )
688{
689        BERR_Code  eResult = BERR_SUCCESS;
690
691        BKNI_EnterCriticalSection();
692        eResult = BDMA_P_Mem_Tran_Start_isr(
693                hTran, hTran->QueueEntry.ulNumTranBlocks, NULL, NULL );
694        BKNI_LeaveCriticalSection();
695               
696        return BERR_TRACE(eResult);
697}
698
699/***************************************************************************
700 *
701 */
702BERR_Code BDMA_Mem_Tran_StartAndCallBack(
703        BDMA_Mem_Tran_Handle     hTran,
704        BDMA_Mem_CallbackFunc    pCallBackFunc_isr,
705        void *                   pUserCallBackParam )
706{
707        BERR_Code  eResult = BERR_SUCCESS;
708
709        BKNI_EnterCriticalSection();
710        eResult = BDMA_P_Mem_Tran_Start_isr( hTran, hTran->QueueEntry.ulNumTranBlocks,
711                                                                                 pCallBackFunc_isr, pUserCallBackParam );
712        BKNI_LeaveCriticalSection();
713               
714        return BERR_TRACE(eResult);
715}
716
717/***************************************************************************
718 *
719 */
720BERR_Code BDMA_Mem_Tran_StartDma(
721        BDMA_Mem_Tran_Handle     hTran,
722        uint32_t                 ulNumActBlocks )
723{
724        BERR_Code  eResult = BERR_SUCCESS;
725
726        BKNI_EnterCriticalSection();
727        eResult = BDMA_P_Mem_Tran_Start_isr( hTran, ulNumActBlocks, NULL, NULL );
728        BKNI_LeaveCriticalSection();
729               
730        return BERR_TRACE(eResult);
731}
732
733/***************************************************************************
734 *
735 */
736
737BERR_Code BDMA_Mem_Tran_StartDmaSubset(
738        BDMA_Mem_Tran_Handle     hTran,
739        uint32_t                 ulFirstBlock,
740        uint32_t                 ulNumActBlocks )
741{
742        BERR_Code  eResult = BERR_SUCCESS;
743
744        BKNI_EnterCriticalSection();
745        eResult = BDMA_P_Mem_Tran_StartSubset_isr( hTran, ulFirstBlock, ulNumActBlocks, NULL, NULL );
746        BKNI_LeaveCriticalSection();
747
748        return BERR_TRACE(eResult);
749}
750/***************************************************************************
751 *
752 */
753BERR_Code BDMA_Mem_Tran_StartDmaAndCallBack(
754        BDMA_Mem_Tran_Handle     hTran,
755        uint32_t                 ulNumActBlocks,
756        BDMA_Mem_CallbackFunc    pCallBackFunc_isr,
757        void *                   pUserCallBackParam )
758{
759        BERR_Code  eResult = BERR_SUCCESS;
760
761        BKNI_EnterCriticalSection();
762        eResult = BDMA_P_Mem_Tran_Start_isr( hTran, ulNumActBlocks, pCallBackFunc_isr, pUserCallBackParam );
763        BKNI_LeaveCriticalSection();
764               
765        return BERR_TRACE(eResult);
766}
767
768/***************************************************************************
769 *
770 */
771BERR_Code BDMA_Mem_Tran_StartDmaSubsetAndCallBack(
772        BDMA_Mem_Tran_Handle     hTran,
773        uint32_t                 ulFirstBlock,
774        uint32_t                 ulNumActBlocks,
775        BDMA_Mem_CallbackFunc    pCallBackFunc_isr,
776        void *                   pUserCallBackParam )
777{
778        BERR_Code  eResult = BERR_SUCCESS;
779
780        BKNI_EnterCriticalSection();
781        eResult = BDMA_P_Mem_Tran_StartSubset_isr( hTran, ulFirstBlock, ulNumActBlocks, pCallBackFunc_isr, pUserCallBackParam );
782        BKNI_LeaveCriticalSection();
783               
784        return BERR_TRACE(eResult);
785}
786
787
788/***************************************************************************
789 *
790 */
791BERR_Code BDMA_Mem_Tran_StartDmaAndCallBack_isr(
792        BDMA_Mem_Tran_Handle     hTran,
793        uint32_t                 ulNumActBlocks,
794        BDMA_Mem_CallbackFunc    pCallBackFunc_isr,
795        void *                   pUserCallBackParam )
796{
797        BERR_Code  eResult = BERR_SUCCESS;
798
799        eResult = BDMA_P_Mem_Tran_Start_isr( hTran, ulNumActBlocks, pCallBackFunc_isr, pUserCallBackParam );
800               
801        return BERR_TRACE(eResult);
802}
803
804#endif
805
806
807
808
809
810
Note: See TracBrowser for help on using the repository browser.