1 //<MStar Software>
2 //******************************************************************************
3 // MStar Software
4 // Copyright (c) 2010 - 2012 MStar Semiconductor, Inc. All rights reserved.
5 // All software, firmware and related documentation herein ("MStar Software") are
6 // intellectual property of MStar Semiconductor, Inc. ("MStar") and protected by
7 // law, including, but not limited to, copyright law and international treaties.
8 // Any use, modification, reproduction, retransmission, or republication of all
9 // or part of MStar Software is expressly prohibited, unless prior written
10 // permission has been granted by MStar.
11 //
12 // By accessing, browsing and/or using MStar Software, you acknowledge that you
13 // have read, understood, and agree, to be bound by below terms ("Terms") and to
14 // comply with all applicable laws and regulations:
15 //
16 // 1. MStar shall retain any and all right, ownership and interest to MStar
17 // Software and any modification/derivatives thereof.
18 // No right, ownership, or interest to MStar Software and any
19 // modification/derivatives thereof is transferred to you under Terms.
20 //
21 // 2. You understand that MStar Software might include, incorporate or be
22 // supplied together with third party`s software and the use of MStar
23 // Software may require additional licenses from third parties.
24 // Therefore, you hereby agree it is your sole responsibility to separately
25 // obtain any and all third party right and license necessary for your use of
26 // such third party`s software.
27 //
28 // 3. MStar Software and any modification/derivatives thereof shall be deemed as
29 // MStar`s confidential information and you agree to keep MStar`s
30 // confidential information in strictest confidence and not disclose to any
31 // third party.
32 //
33 // 4. MStar Software is provided on an "AS IS" basis without warranties of any
34 // kind. Any warranties are hereby expressly disclaimed by MStar, including
35 // without limitation, any warranties of merchantability, non-infringement of
36 // intellectual property rights, fitness for a particular purpose, error free
37 // and in conformity with any international standard. You agree to waive any
38 // claim against MStar for any loss, damage, cost or expense that you may
39 // incur related to your use of MStar Software.
40 // In no event shall MStar be liable for any direct, indirect, incidental or
41 // consequential damages, including without limitation, lost of profit or
42 // revenues, lost or damage of data, and unauthorized system use.
43 // You agree that this Section 4 shall still apply without being affected
44 // even if MStar Software has been modified by MStar in accordance with your
45 // request or instruction for your use, except otherwise agreed by both
46 // parties in writing.
47 //
48 // 5. If requested, MStar may from time to time provide technical supports or
49 // services in relation with MStar Software to you for your use of
50 // MStar Software in conjunction with your or your customer`s product
51 // ("Services").
52 // You understand and agree that, except otherwise agreed by both parties in
53 // writing, Services are provided on an "AS IS" basis and the warranty
54 // disclaimer set forth in Section 4 above shall apply.
55 //
56 // 6. Nothing contained herein shall be construed as by implication, estoppels
57 // or otherwise:
58 // (a) conferring any license or right to use MStar name, trademark, service
59 // mark, symbol or any other identification;
60 // (b) obligating MStar or any of its affiliates to furnish any person,
61 // including without limitation, you and your customers, any assistance
62 // of any kind whatsoever, or any information; or
63 // (c) conferring any license or right under any intellectual property right.
64 //
65 // 7. These terms shall be governed by and construed in accordance with the laws
66 // of Taiwan, R.O.C., excluding its conflict of law rules.
67 // Any and all dispute arising out hereof or related hereto shall be finally
68 // settled by arbitration referred to the Chinese Arbitration Association,
69 // Taipei in accordance with the ROC Arbitration Law and the Arbitration
70 // Rules of the Association by three (3) arbitrators appointed in accordance
71 // with the said Rules.
72 // The place of arbitration shall be in Taipei, Taiwan and the language shall
73 // be English.
74 // The arbitration award shall be final and binding to both parties.
75 //
76 //******************************************************************************
77 //<MStar Software>
78 ////////////////////////////////////////////////////////////////////////////////
79 //
80 // Copyright (c) 2008-2009 MStar Semiconductor, Inc.
81 // All rights reserved.
82 //
83 // Unless otherwise stipulated in writing, any and all information contained
84 // herein regardless in any format shall remain the sole proprietary of
85 // MStar Semiconductor Inc. and be kept in strict confidence
86 // ("MStar Confidential Information") by the recipient.
87 // Any unauthorized act including without limitation unauthorized disclosure,
88 // copying, use, reproduction, sale, distribution, modification, disassembling,
89 // reverse engineering and compiling of the contents of MStar Confidential
90 // Information is unlawful and strictly prohibited. MStar hereby reserves the
91 // rights to any and all damages, losses, costs and expenses resulting therefrom.
92 ///////////////////////////////////////////////////////////////////////////////
93 #define _DRVBYTEDMA_C
94
95 ////////////////////////////////////////////////////////////////////////////////
96 /// file drvBDMA.c
97 /// @author MStar Semiconductor Inc.
98 /// @brief DRAM byte DMA control driver
99 ////////////////////////////////////////////////////////////////////////////////
100 //------------------------------------------------------------------------------
101 // Header Files
102 //------------------------------------------------------------------------------
103 #if defined(MSOS_TYPE_LINUX_KERNEL)
104 #include <linux/string.h>
105 #include <linux/slab.h>
106 #endif
107
108 #include "MsCommon.h"
109 #include "MsVersion.h"
110 #include "drvBDMA.h"
111 #include "halBDMA.h"
112 #include "drvMMIO.h"
113 #include "MsOS.h"
114 #include "asmCPU.h"
115 #include "halCHIP.h"
116 #include "utopia.h"
117 #include "drvSEM.h"
118
119 #include "ULog.h"
120
121 ////////////////////////////////////////////////////////////////////////////////
122 // Local defines & local structures
123 ////////////////////////////////////////////////////////////////////////////////
124 #define TAG_BDMA "BDMA"
125 #define BDMA_WAIT_TIME (HAL_BDMA_MS(100)*0x400)
126 #define BDMA_DELAYMS(ms) MsOS_DelayTask(ms)
127 #define BDMA_IS_TIMEOUT(x) ((x) ? FALSE : TRUE)
128 #define BDMA_DBG_FUNC() if (_gsInfo.eDbgLv >= E_BDMA_DBGLV_ALL) \
129 {MS_DEBUG_MSG(ULOGD(TAG_BDMA, "\t==== %s ====\n", __FUNCTION__));}
130 #define BDMA_DBG_INFO(x, args...) if (_gsInfo.eDbgLv >= E_BDMA_DBGLV_INFO ) \
131 {MS_DEBUG_MSG(ULOGI(TAG_BDMA, x, ##args));}
132 #define BDMA_DBG_ERR(x, args...) if (_gsInfo.eDbgLv >= E_BDMA_DBGLV_ERR_ONLY) \
133 {MS_DEBUG_MSG(ULOGE(TAG_BDMA, x, ##args));}
134
135 #define BDMA_DFLUSH(base, size) MsOS_Dcache_Flush(MS_PA2KSEG0(base), size)
136 //bdma mutex wait time
137 #define BDMA_MUTEX_WAIT_TIME (5000)
138 #define _NOP_ MAsm_CPU_Nop();
139 #define BDMA_USE_HW_SEM (0)
140 #define BDMA_USE_ISR (0)
141 #define BDMA_USE_DMA_FLASH_COPY (0)
142
143
144 #if defined(__AEONR2__)
145 #define AEON_R2
146 #define RES_ID (0x02)
147 #define START_CH (0)
148 #elif (defined (MCU_AEON))
149 #define AEON_MCU
150 #define RES_ID (0x01)
151 #define START_CH (1)
152 #elif defined (MCU_MIPS_4KE) || defined(MCU_MIPS_34K) || defined(MCU_MIPS_74K) || defined(MCU_MIPS_1004K)
153 #define MIPS_MCU
154 #define RES_ID (0x02)
155 #define START_CH (0)
156 #elif defined (__arm__)
157 #define ARM_MCU
158 #define RES_ID (0x02)
159 #define START_CH (0)
160 #elif defined (__aarch64__)
161 #define ARM_MCU
162 #define RES_ID (0x02)
163 #define START_CH (0)
164 #else
165 #Error_MCU_for_BDMA
166 #endif
167
168 typedef struct _BDMA_OP_CB //control block
169 {
170 MS_U8 u8OpCfg;
171 MS_U8 u8SrcDevCfg;
172 MS_U8 u8DstDevCfg;
173 MS_U8 u8DmyWrCnt;
174 MS_PHY phy64SrcAddr;
175 MS_PHY phy64DstAddr;
176 MS_U32 u32DataSize;
177 MS_U32 u32Cmd0;
178 MS_U32 u32Cmd1;
179 MS_U32 u32Cmd2;
180 BDMA_Act eAct;
181 BDMA_ISR_CBF pCbf;
182 }BDMA_OP_CB;
183
184 #if defined(T3_REMOVE_LATER)
185 MS_U8 _gu8ChipVer = 0;
186 #endif
187
188 #define BDMASEMID (0x03)
189 ////////////////////////////////////////////////////////////////////////////////
190 // External funciton
191 ////////////////////////////////////////////////////////////////////////////////
192 //extern MS_BOOL MDrv_FLASH_CheckWriteDone(void);
193
194 ////////////////////////////////////////////////////////////////////////////////
195 // Local & Global Variables
196 ////////////////////////////////////////////////////////////////////////////////
197 static BDMA_Info _gsInfo = {
198 .u8ChNum = 0,
199 };
200 static BDMA_HwInfo _gsHwInfo = {
201 .bEnMIU1 = 0,
202 };
203 static MSIF_Version _drv_bdma_version = {
204 .DDI = { BDMA_DRV_VERSION },
205 };
206
207 #if (BDMA_USE_ISR)
208 //ISR callback function for channel 0 & channel 1
209 static BDMA_ISR_CBF pIsrCbf[E_BDMA_CH_END];
210 #endif
211
212 #if (BDMA_UTOPIA20)
213 void* pInstantBdma = NULL;
214 void* pAttributeBdma = NULL;
215
216 #endif
217 ////////////////////////////////////////////////////////////////////////////////
218 // Local Function
219 ////////////////////////////////////////////////////////////////////////////////
220 static void _BDMA_MemFlush(BDMA_Dev eDev, MS_U32 u32Base, MS_U32 u32Size);
221 static MS_U8 _BDMA_GetDevCfg(BDMA_Dev eDev);
222 static MS_BOOL _BDMA_Is_Init(void);
223 static MS_BOOL _BDMA_Is_Done_INT(MS_U8 u8Ch);
224 static MS_BOOL _BDMA_Get_FreeCh(MS_U8 *pu8Ch);
225 static MS_BOOL _BDMA_GetHwInfo(BDMA_HwInfo *psHwInfo);
226 #if (BDMA_USE_DMA_FLASH_COPY)
227 static BDMA_Result _DMA_FlashCopy(BDMA_OP_CB sOpCB);
228 #endif
229 static BDMA_Result _BDMA_WaitDone(BDMA_Act eAct, MS_U8 u8Ch);
230 static BDMA_Result _BDMA_CmnHnd(BDMA_OP_CB sOpCB, MS_U8 *pu8Ch);
231 static BDMA_Result _BDMA_Start(MS_U8 u8SrcDev, MS_U8 u8DstDev, MS_U8 u8Ch);
232 static BDMA_Result _BDMA_Check_Device(BDMA_SrcDev eSrc, BDMA_DstDev eDst);
233
234 ////////////////////////////////////////////////////////////////////////////////
235 /// @brief \b Function \b Name: _BDMA_Is_Init
236 /// @brief \b Function \b Description: check if BDMA is initial
237 /// @param <IN> \b None:
238 /// @param <OUT> \b None:
239 /// @param <RET> \b TRUE: Initial FALSE: Not initial
240 /// @param <GLOBAL> \b None :
241 ////////////////////////////////////////////////////////////////////////////////
_BDMA_Is_Init(void)242 static MS_BOOL _BDMA_Is_Init(void)
243 {
244 BDMA_DBG_FUNC();
245 if (!_gsInfo.bInit)
246 BDMA_DBG_ERR("Call MDrv_BDMA_Init first!\n");
247 return _gsInfo.bInit;
248 }
249
250 ////////////////////////////////////////////////////////////////////////////////
251 /// @brief \b Function \b Name: MDrv_BDMA_Is_Int
252 /// @brief \b Function \b Description: Check if interrupted for BDMA done
253 /// @param <IN> \b u8Ch: Channel 0/1
254 /// @param <OUT> \b None :
255 /// @param <RET> \b TRUE: Interrupted FALSE: No interrupt
256 /// @param <GLOBAL> \b None :
257 ////////////////////////////////////////////////////////////////////////////////
_BDMA_Is_Done_INT(MS_U8 u8Ch)258 static MS_BOOL _BDMA_Is_Done_INT(MS_U8 u8Ch)
259 {
260 BDMA_DBG_FUNC();
261 return HAL_BDMA_Is_Int(u8Ch);
262 }
263
264 ////////////////////////////////////////////////////////////////////////////////
265 /// @brief \b Function \b Name: _BDMA_Get_FreeCh
266 /// @brief \b Function \b Description: get free channel for BDMA action
267 /// @param <IN> \b u8Ch: Channel 0/1
268 /// @param <OUT> \b None :
269 /// @param <RET> \b TRUE: Success FALSE: Fail
270 /// @param <GLOBAL> \b None :
271 ////////////////////////////////////////////////////////////////////////////////
_BDMA_Get_FreeCh(MS_U8 * pu8Ch)272 static MS_BOOL _BDMA_Get_FreeCh(MS_U8 *pu8Ch)
273 {
274 MS_U32 u32Delay = 0;
275
276 BDMA_DBG_FUNC();
277 if (!pu8Ch)
278 return FALSE;
279
280 #if (BDMA_USE_HW_SEM)
281 static MS_U8 preCh = 0;
282 *pu8Ch = ((preCh+1) % E_BDMA_CH_END);
283 #else
284 *pu8Ch = START_CH;
285 #endif
286 u32Delay = BDMA_WAIT_TIME;
287 do
288 {
289 if ((!HAL_BDMA_Is_Queued(*pu8Ch)) && (!HAL_BDMA_Is_Busy(*pu8Ch)))
290 break;
291 if(BDMA_IS_TIMEOUT(u32Delay))
292 {
293 BDMA_DBG_ERR("BDAM no free channel!\n");
294 *pu8Ch = 0xFF;
295 return FALSE;
296 }
297 #if (BDMA_USE_HW_SEM)
298 if (++*pu8Ch == E_BDMA_CH_END)
299 *pu8Ch = E_BDMA_CH_START;
300 #endif
301 u32Delay--;
302 }while(1);
303
304 BDMA_DBG_INFO("BDMA Ch%u is free!\n", *pu8Ch);
305 return TRUE;
306 }
307
308 ////////////////////////////////////////////////////////////////////////////////
309 /// @brief \b Function \b Name: _BDMA_Start
310 /// @brief \b Function \b Description: Start BDMA action for channel 0/1
311 /// @param <IN> \b u8Ch: Channel 0/1
312 /// @param <IN> \b u8Ch: Channel 0/1
313 /// @param <IN> \b u8Ch: Channel 0/1
314 /// @param <OUT> \b None :
315 /// @param <RET> \b TRUE: Success FALSE: Fail
316 /// @param <GLOBAL> \b None :
317 ////////////////////////////////////////////////////////////////////////////////
_BDMA_Start(MS_U8 u8SrcDev,MS_U8 u8DstDev,MS_U8 u8Ch)318 static BDMA_Result _BDMA_Start(MS_U8 u8SrcDev, MS_U8 u8DstDev, MS_U8 u8Ch)
319 {
320 BDMA_DBG_FUNC();
321
322 if (HAL_BDMA_Is_Queued(u8Ch) || HAL_BDMA_Is_Busy(u8Ch))
323 {
324 BDMA_DBG_ERR("BDMA Ch%u can't start!\n", u8Ch);
325 return E_BDMA_FAIL;
326 }
327 HAL_BDMA_TrigOn(u8SrcDev, u8DstDev, u8Ch);
328 return E_BDMA_OK;
329 }
330
331 ////////////////////////////////////////////////////////////////////////////////
332 /// @brief \b Function \b Name: _BDMA_MemFlush
333 /// @brief \b Function \b Description: flush dcache
334 /// @param <IN> \b eDev: selected device
335 /// @param <IN> \b u32Base: physical address
336 /// @param <IN> \b u32Size: len
337 /// @param <OUT> \b None :
338 /// @param <RET> \b None :
339 /// @param <GLOBAL> \b None :
340 ////////////////////////////////////////////////////////////////////////////////
_BDMA_MemFlush(BDMA_Dev eDev,MS_U32 u32Base,MS_U32 u32Size)341 static void _BDMA_MemFlush(BDMA_Dev eDev, MS_U32 u32Base, MS_U32 u32Size)
342 {
343 BDMA_DBG_FUNC();
344
345 switch (eDev)
346 {
347 case E_BDMA_DEV_MIU0:
348 case E_BDMA_DEV_MIU1:
349 case E_BDMA_DEV_MIU2:
350 case E_BDMA_DEV_MIU3:
351 if(MS_PA2KSEG0(u32Base))
352 {
353 BDMA_DFLUSH(u32Base, u32Size);
354 }
355 MsOS_FlushMemory();
356 break;
357
358 default:
359 break;
360 }
361 }
362
363 ////////////////////////////////////////////////////////////////////////////////
364 /// @brief \b Function \b Name: _BDMA_WaitDone
365 /// @brief \b Function \b Description: wait done for bdma action
366 /// @param <IN> \b eAct: action
367 /// @param <IN> \b u8Ch: channel
368 /// @param <OUT> \b None :
369 /// @param <RET> \b TRUE: Success FALSE: Fail
370 /// @param <GLOBAL> \b None :
371 ////////////////////////////////////////////////////////////////////////////////
_BDMA_WaitDone(BDMA_Act eAct,MS_U8 u8Ch)372 static BDMA_Result _BDMA_WaitDone(BDMA_Act eAct, MS_U8 u8Ch)
373 {
374 MS_U32 u32Delay = 0;
375
376 BDMA_DBG_FUNC();
377 if (E_BDMA_ACT_MAX <= eAct)
378 {
379 BDMA_DBG_ERR("Error action: %u!\n", eAct);
380 return E_BDMA_FAIL;
381 }
382
383 u32Delay = BDMA_WAIT_TIME;
384 do
385 {
386 if (HAL_BDMA_Is_Done(eAct, u8Ch))
387 {
388 if (_BDMA_Is_Done_INT(u8Ch))
389 {
390 BDMA_DBG_INFO("BDMA ch%u act:%u interruptted!\n ",u8Ch, eAct);
391 }
392 BDMA_DBG_INFO("BDMA ch%u act:%u done!\n",u8Ch, eAct);
393 if (E_BDMA_DBGLV_REG_DUMP == _gsInfo.eDbgLv)
394 {
395 HAL_BDMA_Dump_AllReg();
396 }
397 return E_BDMA_OK;
398 }
399 u32Delay--;
400 }while(!BDMA_IS_TIMEOUT(u32Delay));
401 BDMA_DBG_ERR("BDMA ch%u wait act:%u done timeout!\n ",u8Ch, eAct);
402
403 return E_BDMA_TIMEOUT;
404 }
405
406 ////////////////////////////////////////////////////////////////////////////////
407 /// @brief \b Function \b Name: _BDMA_CmnHnd
408 /// @brief \b Function \b Description: Handle for common actions
409 /// @param <IN> \b sOpCB : control block
410 /// @param <OUT> \b u8Ch : action channel
411 /// @param <RET> \b TRUE : Success FALSE: Fail
412 /// @param <GLOBAL> \b sOpCB : global control block
413 ////////////////////////////////////////////////////////////////////////////////
_BDMA_CmnHnd(BDMA_OP_CB sOpCB,MS_U8 * pu8Ch)414 static BDMA_Result _BDMA_CmnHnd(BDMA_OP_CB sOpCB, MS_U8 *pu8Ch)
415 {
416 BDMA_Result eRet;
417
418 BDMA_DBG_FUNC();
419 MDrv_BDMA_DumpCB(&sOpCB);
420
421 //make atomic operation
422 if (FALSE == MsOS_ObtainMutex(_gsInfo.s32Mutex, BDMA_MUTEX_WAIT_TIME))
423 {
424 BDMA_DBG_ERR("%s ENTRY fails!\n", __FUNCTION__);
425 return E_BDMA_FAIL;
426 }
427
428
429 #if (BDMA_USE_HW_SEM)
430 MS_U32 u32Cnt = 0;
431
432 while(FALSE == MDrv_SEM_Get_Resource(BDMASEMID, RES_ID))
433 {
434 if (BDMA_WAIT_TIME == ++u32Cnt)
435 {
436 BDMA_DBG_ERR("%s can't get HW SEM!\n", __FUNCTION__);
437 eRet = E_BDMA_TIMEOUT;
438 MsOS_ReleaseMutex(_gsInfo.s32Mutex);
439 return eRet;
440 }
441 }
442 #endif
443
444 if (!pu8Ch || !_BDMA_Get_FreeCh(pu8Ch))
445 {
446 eRet = E_BDMA_FAIL;
447 goto end;
448 }
449 eRet = E_BDMA_FAIL;
450 //clear status first
451 HAL_BDMA_Clear_Status(sOpCB.eAct, *pu8Ch);
452
453 //Set start address
454 HAL_BDMA_SetSrcAddr(sOpCB.eAct, sOpCB.phy64SrcAddr, *pu8Ch);
455 HAL_BDMA_SetDstAddr(sOpCB.eAct, sOpCB.phy64DstAddr, *pu8Ch);
456 //Set size
457 HAL_BDMA_SetLen(sOpCB.eAct, sOpCB.u32DataSize, *pu8Ch);
458
459 HAL_BDMA_SetSrcDev(sOpCB.u8SrcDevCfg, *pu8Ch);
460 HAL_BDMA_SetDstDev(sOpCB.u8DstDevCfg, *pu8Ch);
461 HAL_BDMA_SetCmd0(sOpCB.u32Cmd0 ,*pu8Ch);
462 HAL_BDMA_SetCmd1(sOpCB.u32Cmd1 ,*pu8Ch);
463 HAL_BDMA_SetCmd2(sOpCB.u32Cmd2 ,*pu8Ch);
464 // Set INT
465 HAL_BDMA_Enable_INT(((sOpCB.pCbf)?TRUE:FALSE), *pu8Ch);
466 // Set address direction
467 HAL_BDMA_Set_Addr_Dec((sOpCB.u8OpCfg & BDMA_OPCFG_INV_COPY), *pu8Ch);
468 // Set crc reflection
469 HAL_BDMA_Set_CRC_Reflect((sOpCB.u8OpCfg & BDMA_OPCFG_CRC_REFLECT), *pu8Ch);
470 #ifdef MOBF_ENABLE
471 // Set mobf ps
472 HAL_BDMA_MOBF((sOpCB.u8OpCfg & BDMA_OPCFG_MOBF_PS), *pu8Ch);
473 #endif
474 HAL_BDMA_SetDmyWrCnt(sOpCB.u8DmyWrCnt, *pu8Ch);
475
476 if (E_BDMA_DBGLV_REG_DUMP == _gsInfo.eDbgLv)
477 {
478 HAL_BDMA_Dump_AllReg();
479 }
480 //while(1);
481 if (_BDMA_Start(sOpCB.u8SrcDevCfg, sOpCB.u8DstDevCfg, *pu8Ch))
482 {
483 #if (BDMA_USE_ISR)
484 if (sOpCB.pCbf)
485 {
486 pIsrCbf[*pu8Ch] = sOpCB.pCbf;
487 BDMA_DBG_INFO("BDMA Ch%u act:%u wait ISR!\n", *pu8Ch, sOpCB.eAct);
488 eRet = E_BDMA_OK;
489 goto end;
490
491 }
492 #endif
493 eRet = _BDMA_WaitDone(sOpCB.eAct, *pu8Ch);
494 }
495 else
496 {
497 BDMA_DBG_ERR("BDMA Act:%u can't start\n", sOpCB.eAct);
498 }
499 end:
500 _NOP_ _NOP_ _NOP_
501
502 #if (BDMA_USE_HW_SEM)
503 MDrv_SEM_Free_Resource(BDMASEMID, RES_ID);
504 #endif
505 MsOS_ReleaseMutex(_gsInfo.s32Mutex);
506 return eRet;
507 }
508
509 ////////////////////////////////////////////////////////////////////////////////
510 /// @brief \b Function \b Name: _DMA_FlashCopy
511 /// @brief \b Function \b Description: Handle for DMA flash copy action
512 /// @param <IN> \b sOpCB : control block
513 /// @param <OUT> \b u8Ch : action channel
514 /// @param <RET> \b TRUE : Success FALSE: Fail
515 /// @param <GLOBAL> \b sOpCB : global control block
516 ////////////////////////////////////////////////////////////////////////////////
517 #if (BDMA_USE_DMA_FLASH_COPY)
_DMA_FlashCopy(BDMA_OP_CB sOpCB)518 static BDMA_Result _DMA_FlashCopy(BDMA_OP_CB sOpCB)
519 {
520 MS_U8 u8Ch = E_BDMA_CH0;
521 MS_U32 u32Delay = BDMA_WAIT_TIME;
522
523 BDMA_DBG_FUNC();
524 MDrv_BDMA_DumpCB(&sOpCB);
525
526 //if bdma support flash, plz use bdma command
527 if (_gsHwInfo.bEnFlsCpy)
528 {
529 BDMA_DBG_ERR("BDMA support flash copy!\n");
530 return E_BDMA_FAIL;
531 }
532
533 while (!HAL_DMA_Is_FlashReady())
534 {
535 if (BDMA_IS_TIMEOUT(u32Delay))
536 {
537 BDMA_DBG_ERR("DMA flash is busy!\n");
538 return E_BDMA_TIMEOUT;
539 }
540 u32Delay--;
541 }
542
543 //Set start address
544 HAL_BDMA_SetSrcAddr(sOpCB.eAct, sOpCB.phy64SrcAddr, u8Ch);
545 HAL_BDMA_SetDstAddr(sOpCB.eAct, sOpCB.phy64DstAddr, u8Ch);
546 //Set size
547 HAL_BDMA_SetLen(sOpCB.eAct, HAL_BDMA_ALIGN(sOpCB.u32DataSize), u8Ch);
548 HAL_BDMA_Clear_Status(sOpCB.eAct, u8Ch);
549
550 if (_BDMA_Start(sOpCB.u8SrcDevCfg, sOpCB.u8DstDevCfg, u8Ch))
551 {
552 BDMA_Result eRet = _BDMA_WaitDone(sOpCB.eAct, u8Ch);
553 if (E_BDMA_OK == eRet)
554 {
555 //flush miu FIFO data to MIU
556 if (!_gsHwInfo.bEnDmyWrCnt && (E_BDMA_DEV_MIU0 == (sOpCB.u8DstDevCfg&0x0F) || E_BDMA_DEV_MIU1 == (sOpCB.u8DstDevCfg&0x0F) || E_BDMA_DEV_MIU2 == (sOpCB.u8DstDevCfg&0x0F) || E_BDMA_DEV_MIU3 == (sOpCB.u8DstDevCfg&0x0F)))
557 MDrv_BDMA_CRC32(sOpCB.phy64DstAddr, HAL_BDMA_DMY_WRCNT, BDMA_CRC32_POLY, BDMA_CRC_SEED_0, (BDMA_SrcDev)(sOpCB.u8DstDevCfg&0x0F), FALSE);
558 }
559 return eRet;
560 }
561 else
562 {
563 BDMA_DBG_ERR("DMA can't start flash copy\n");
564 return E_BDMA_FAIL;
565 }
566 }
567 #endif
568 ////////////////////////////////////////////////////////////////////////////////
569 /// @brief \b Function \b Name: _BDMA_Check_Device
570 /// @brief \b Function \b Description: Check if support selected device
571 /// @param <IN> \b eSrc: source device
572 /// @param <IN> \b eDst: destination device
573 /// @param <OUT> \b None :
574 /// @param <RET> \b BDMA_Result
575 /// @param <GLOBAL> \b None :
576 ////////////////////////////////////////////////////////////////////////////////
_BDMA_Check_Device(BDMA_SrcDev eSrc,BDMA_DstDev eDst)577 static BDMA_Result _BDMA_Check_Device(BDMA_SrcDev eSrc, BDMA_DstDev eDst)
578 {
579 BDMA_DBG_FUNC();
580
581 switch(eSrc)
582 {
583 case E_BDMA_SRCDEV_MIU0:
584 case E_BDMA_SRCDEV_MIU1:
585 case E_BDMA_SRCDEV_MIU2:
586 case E_BDMA_SRCDEV_MIU3:
587 case E_BDMA_SRCDEV_FLASH:
588 case E_BDMA_SRCDEV_MEM_FILL:
589 break;
590
591 default:
592 BDMA_DBG_ERR("Source Device error:%x!\n", eSrc);
593 return E_BDMA_FAIL;
594 }
595 if (E_BDMA_DSTDEV_NOT_SUPPORT <= eDst)
596 {
597 BDMA_DBG_ERR("Destination Device error:%x!\n", eDst);
598 return E_BDMA_FAIL;
599 }
600
601 if (((E_BDMA_DEV_MIU1 == (BDMA_Dev)eSrc) || (E_BDMA_DEV_MIU1 == (BDMA_Dev)eDst)) && (!_gsHwInfo.bEnMIU1))
602 {
603 BDMA_DBG_ERR("Not support MIU1!\n");
604 return E_BDMA_FAIL;
605 }
606
607 if (((!_gsHwInfo.bEnDMDMCU) && (E_BDMA_DSTDEV_DMDMCU == eDst))
608 || ((!_gsHwInfo.bEnDSP) && (E_BDMA_DSTDEV_DSP == eDst))
609 || ((!_gsHwInfo.bEnTSP) && (E_BDMA_DSTDEV_TSP == eDst)))
610 {
611 BDMA_DBG_ERR("Device:%u is not supported!\n", eDst);
612 return E_BDMA_NOT_SUPPORT;
613 }
614
615 return E_BDMA_OK;
616 }
617
618 ////////////////////////////////////////////////////////////////////////////////
619 /// @brief \b Function \b Name: _BDMA_GetDevCfg
620 /// @brief \b Function \b Description: Get device cfg for BDMA copy
621 /// @param <IN> \b eDev: device
622 /// @param <OUT> \b None :
623 /// @param <RET> \b src & dst device configuration for bdma copy
624 /// @param <GLOBAL> \b None :
625 ////////////////////////////////////////////////////////////////////////////////
_BDMA_GetDevCfg(BDMA_Dev eDev)626 static MS_U8 _BDMA_GetDevCfg(BDMA_Dev eDev)
627 {
628 BDMA_DBG_FUNC();
629
630 if (!_gsHwInfo.bEnDevDw)
631 {
632 return eDev;
633 }
634 return (MS_U8)(HAL_BDMA_GetDevId(eDev) | HAL_BDMA_GetDevDw(eDev));
635 }
636
637 ////////////////////////////////////////////////////////////////////////////////
638 /// @brief \b Function \b Name: _BDMA_Isr_Proc
639 /// @brief \b Function \b Description: BDMA ISR
640 /// @param <IN> \b vpReg: registers status
641 /// @param <IN> \b u32Data: passing data
642 /// @param <OUT> \b None :
643 /// @param <RET> \b None :
644 /// @param <GLOBAL> \b None :
645 ////////////////////////////////////////////////////////////////////////////////
646 #if (BDMA_USE_ISR)
_BDMA_Isr_Proc(InterruptNum eIntNum)647 static void _BDMA_Isr_Proc(InterruptNum eIntNum)
648 {
649 BDMA_Result eRet = E_BDMA_OK;
650
651 BDMA_DBG_INFO("BDMA Ch%u ISR!\n", eIntNum);
652
653 MDrv_BDMA_Stop(eIntNum);
654 pIsrCbf[eIntNum](eRet);
655 }
656 #endif
657 ////////////////////////////////////////////////////////////////////////////////
658 /// @brief \b Function \b Name: _BDMA_GetHwInfo
659 /// @brief \b Function \b Description: Get hardware support facilities
660 /// @param <IN> \b None :
661 /// @param <OUT> \b *psHwInfo: Hardware information
662 /// @param <RET> \b TRUE : Success FALSE: Fail
663 /// @param <GLOBAL> \b None :
664 ////////////////////////////////////////////////////////////////////////////////
_BDMA_GetHwInfo(BDMA_HwInfo * psHwInfo)665 static MS_BOOL _BDMA_GetHwInfo(BDMA_HwInfo *psHwInfo)
666 {
667 if (!psHwInfo)
668 {
669 return FALSE;
670 }
671 BDMA_DBG_FUNC();
672 psHwInfo->bEnMemFill = BDMA_MEM_FILL;
673 psHwInfo->bEnFlsCpy = BDMA_FLASH_COPY;
674 psHwInfo->bEnDevDw = BDMA_DEV_DATA_WIDTH;
675 psHwInfo->bEnDmyWrCnt = BDMA_DUMMY_WRCNT;
676 psHwInfo->bEnDMDMCU = BDMA_DMDMCU;
677 psHwInfo->bEnTSP = BDMA_TSP;
678 psHwInfo->bEnDSP = BDMA_DSP;
679 psHwInfo->bEnHK51_1KSRAM = BDMA_HK51_1KSRAM;
680 return TRUE;
681 }
682
683 ////////////////////////////////////////////////////////////////////////////////
684 /// @brief \b Function \b Name: _BDMA_Check_MIUDev
685 /// @brief \b Function \b Description: check if address within miu range
686 /// @param <IN> \b eDev : device
687 /// @param <IN> \b phy64Addr : start address
688 /// @param <OUT> \b None:
689 /// @param <RET> \b BDMA_Dev: device
690 /// @param <GLOBAL> \b None :
691 ////////////////////////////////////////////////////////////////////////////////
_BDMA_Check_MIUDev(BDMA_Dev eDev,MS_PHY phy64Addr)692 static BDMA_Dev _BDMA_Check_MIUDev(BDMA_Dev eDev, MS_PHY phy64Addr)
693 {
694 MS_U8 u8MiuSel;
695 MS_U32 u32Offset;
696 BDMA_DBG_FUNC();
697
698 _phy_to_miu_offset(u8MiuSel, u32Offset, phy64Addr)
699
700 if (eDev != E_BDMA_DEV_MIU0 && eDev != E_BDMA_DEV_MIU1 && eDev != E_BDMA_DEV_MIU2 && eDev != E_BDMA_DEV_MIU3)
701 return eDev;
702
703 if (u8MiuSel == E_CHIP_MIU_3)
704 {
705 return E_BDMA_DEV_MIU3;
706 }
707 else if (u8MiuSel == E_CHIP_MIU_2)
708 {
709 return E_BDMA_DEV_MIU2;
710 }
711 else if (u8MiuSel == E_CHIP_MIU_1)
712 {
713 return E_BDMA_DEV_MIU1;
714 }
715 else
716 {
717 return E_BDMA_DEV_MIU0;
718 }
719 }
720
721 ////////////////////////////////////////////////////////////////////////////////
722 // Global variable
723 ////////////////////////////////////////////////////////////////////////////////
724 ////////////////////////////////////////////////////////////////////////////////
725 /// @brief \b Function \b Name: MDrv_BDMA_WaitFlashDone
726 /// @brief \b Function \b Description: Wait for flash copy done
727 /// @return \b BDMA_Result
728 ////////////////////////////////////////////////////////////////////////////////
_MDrv_BDMA_WaitFlashDone(void)729 BDMA_Result _MDrv_BDMA_WaitFlashDone(void)
730 {
731 return _BDMA_WaitDone(E_BDMA_ACT_COPY_FLASH, E_BDMA_CH0);
732 }
733
734 ////////////////////////////////////////////////////////////////////////////////
735 /// @brief \b Function \b Name: MDrv_BDMA_GetLibVer
736 /// @brief \b Function \b Description: Show the BDMA driver version
737 /// @param ppVersion \b Out: Library version string
738 /// @return \b BDMA_Result
739 ////////////////////////////////////////////////////////////////////////////////
MDrv_BDMA_GetLibVer(const MSIF_Version ** ppVersion)740 BDMA_Result MDrv_BDMA_GetLibVer(const MSIF_Version **ppVersion)
741 {
742 BDMA_DBG_FUNC();
743
744 if (!ppVersion)
745 {
746 return E_BDMA_FAIL;
747 }
748
749 *ppVersion = &_drv_bdma_version;
750 return E_BDMA_OK;
751 }
752
MDrv_BDMA_Init(MS_PHY phy64Miu1Base)753 BDMA_Result MDrv_BDMA_Init(MS_PHY phy64Miu1Base)
754 {
755 #if BDMA_UTOPIA20
756 if(pInstantBdma == NULL)
757 {
758 if(UtopiaOpen(MODULE_BDMA, &pInstantBdma, 0, pAttributeBdma) != UTOPIA_STATUS_SUCCESS)
759 {
760 printf("Open BDMA fail\n");
761 return E_BDMA_FAIL;
762 }
763 }
764
765 PBDMA_INIT_PARAM pParam;
766 if (NULL == pInstantBdma)
767 return E_BDMA_FAIL;
768 pParam = (PBDMA_INIT_PARAM)malloc(sizeof(BDMA_INIT_PARAM));
769 if (NULL == pParam)
770 return E_BDMA_FAIL;
771 pParam->u64Miu1Base = phy64Miu1Base;
772 if(UtopiaIoctl(pInstantBdma,MDrv_CMD_BDMA_Init,(void*)pParam) != UTOPIA_STATUS_SUCCESS)
773 {
774 ULOGE(TAG_BDMA, "Ioctl MDrv_BDMA_MemCopy fail\n");
775 free(pParam);
776 return E_BDMA_FAIL;
777 }
778 free(pParam);
779 return E_BDMA_OK;
780 #else
781 return _MDrv_BDMA_Init(phy64Miu1Base);
782 #endif
783 }
784
785
786 ////////////////////////////////////////////////////////////////////////////////
787 /// @brief \b Function \b Name: MDrv_BDMA_Init
788 /// @brief \b Function \b Description: Init BDMA driver
789 /// @param phy64Miu1Base \b if 0, not support miu1
790 /// @return \b BDMA_Result
791 ////////////////////////////////////////////////////////////////////////////////
_MDrv_BDMA_Init(MS_PHY phy64Miu1Base)792 BDMA_Result _MDrv_BDMA_Init(MS_PHY phy64Miu1Base)
793 {
794 MS_PHY u32BaseSize = 0;
795
796 if (!_gsInfo.bInit)
797 {
798 _gsInfo.s32Mutex = MsOS_CreateMutex(E_MSOS_FIFO, "Mutex BDMA", MSOS_PROCESS_SHARED);
799 MS_ASSERT(_gsInfo.s32Mutex >= 0);
800
801 #if defined(T3_REMOVE_LATER)
802 if (MDrv_MMIO_GetBASE(&_gsInfo.u32IOMap, &u32BaseSize, MS_MODULE_PM))
803 {
804 HAL_BDMA_SetIOMapBase(_gsInfo.u32IOMap);
805 _gu8ChipVer = HAL_BDMA_ReadByte(0x001ECF);
806 BDMA_DBG_INFO("ChipVer:%u\n", _gu8ChipVer);
807 }
808 #endif
809
810 if(!MDrv_MMIO_GetBASE(&_gsInfo.u32IOMap, &u32BaseSize, MS_MODULE_BDMA))
811 {
812 BDMA_DBG_ERR("Get IOMAP Base faill!\n");
813 return E_BDMA_FAIL;
814 }
815 BDMA_DBG_INFO("Get IOMAP ID:%u Base:%lx!\n", MS_MODULE_BDMA, _gsInfo.u32IOMap);
816 HAL_BDMA_SetIOMapBase(_gsInfo.u32IOMap);
817
818 //test read/write register
819 if (HAL_BDMA_SetSrcAddr(E_BDMA_ACT_CRC32, 0x5A6B7C8F, E_BDMA_CH1)
820 && (0x5A6B7C8F != HAL_BDMA_GetSrcAddr(E_BDMA_ACT_CRC32, E_BDMA_CH1)))
821 {
822 BDMA_DBG_ERR("Reg CMD1 r/w test error: %lx!\n", HAL_BDMA_GetCmd1(E_BDMA_CH1));
823 return E_BDMA_FAIL;
824 }
825
826 if (_BDMA_GetHwInfo(&_gsHwInfo))
827 {
828 _gsHwInfo.bEnMIU1 = (HAL_MIU1_BASE) ? TRUE : FALSE;
829 }
830 _gsInfo.phy64MIU1Base = HAL_MIU1_BASE;
831 BDMA_DBG_INFO("Miu1 base:%lx\n", _gsInfo.phy64MIU1Base);
832 _gsInfo.eDbgLv = E_BDMA_DBGLV_ERR_ONLY;
833 _gsInfo.bInit = TRUE;
834 return E_BDMA_OK;
835 }
836 else
837 {
838 BDMA_DBG_ERR("BDMA had initial!\n");
839 return E_BDMA_OK;
840 }
841
842 return E_BDMA_FAIL;
843 }
844
845 ////////////////////////////////////////////////////////////////////////////////
846 /// @brief \b Function \b Name: MDrv_BDMA_Exit
847 /// @brief \b Function \b Description: Exit BDMA driver
848 /// @return \b BDMA_Result
849 ////////////////////////////////////////////////////////////////////////////////
MDrv_BDMA_Exit()850 BDMA_Result MDrv_BDMA_Exit()
851 {
852 if (!_gsInfo.bInit)
853 {
854 BDMA_DBG_INFO("BDMA not init!\n");
855 return E_BDMA_FAIL;
856 }
857
858 MsOS_DeleteMutex(_gsInfo.s32Mutex);
859 _gsInfo.bInit = FALSE;
860 #if (BDMA_UTOPIA20)
861 if(UtopiaClose(pInstantBdma) != UTOPIA_STATUS_SUCCESS)
862 {
863 ULOGE(TAG_BDMA, "close BDMA fail\n");
864 pInstantBdma = NULL;
865 return E_BDMA_FAIL;
866 }
867 pInstantBdma = NULL;
868 #endif
869 return E_BDMA_OK;
870 }
871
872 ////////////////////////////////////////////////////////////////////////////////
873 /// @brief \b Function \b Name: MDrv_BDMA_SetDbgLevel
874 /// @brief \b Function \b Description: Set debug level for debug message
875 /// @param eLevel \b IN: E_BDMA_DBGLV_NONE/E_BDMA_DBGLV_ERR_ONLY/E_BDMA_DBGLV_INFO/E_BDMA_DBGLV_ALL
876 /// @return \b BDMA_Result
877 ////////////////////////////////////////////////////////////////////////////////
MDrv_BDMA_SetDbgLevel(BDMA_DbgLv eLevel)878 BDMA_Result MDrv_BDMA_SetDbgLevel(BDMA_DbgLv eLevel)
879 {
880 BDMA_DBG_INFO("%s level: %u\n", __FUNCTION__, eLevel);
881
882 _gsInfo.eDbgLv = eLevel;
883 return E_BDMA_OK;
884 }
885
886 ////////////////////////////////////////////////////////////////////////////////
887 /// @brief \b Function \b Name: MDrv_BDMA_Stop
888 /// @brief \b Function \b Description: Stop BDMA actions in specific channel
889 /// @param u8Ch \b IN: Channel 0/1
890 /// @return \b BDMA_Result
891 ////////////////////////////////////////////////////////////////////////////////
MDrv_BDMA_Stop(MS_U8 u8Ch)892 BDMA_Result MDrv_BDMA_Stop(MS_U8 u8Ch)
893 {
894 BDMA_DBG_FUNC();
895 return E_BDMA_NOT_SUPPORT;
896 }
897
898 ////////////////////////////////////////////////////////////////////////////////
899 /// @brief \b Function \b Name: MDrv_BDMA_Stop_All
900 /// @brief \b Function \b Description: Stop all BDMA actions
901 /// @return \b BDMA_Result
902 ////////////////////////////////////////////////////////////////////////////////
MDrv_BDMA_Stop_All(void)903 BDMA_Result MDrv_BDMA_Stop_All(void)
904 {
905 BDMA_DBG_FUNC();
906 return E_BDMA_NOT_SUPPORT;
907 }
908
909 ////////////////////////////////////////////////////////////////////////////////
910 /// @brief \b Function \b Name: MDrv_BDMA_PatternFill
911 /// @brief \b Function \b Description: Fill pattern to filled dst device
912 /// @param u32Addr \b IN: Physical Start address
913 /// @param u32Len \b IN: Fill Pattern length
914 /// @param u32Pattern \b IN: Fill Pattern data
915 /// @param eDev \b IN: filled dst device
916 /// @return \b BDMA_Result
917 ////////////////////////////////////////////////////////////////////////////////
_MDrv_BDMA_PatternFill(MS_PHY phy64Addr,MS_U32 u32Len,MS_U32 u32Pattern,BDMA_DstDev eDev)918 BDMA_Result _MDrv_BDMA_PatternFill(MS_PHY phy64Addr, MS_U32 u32Len, MS_U32 u32Pattern, BDMA_DstDev eDev)
919 {
920 MS_U8 u8Ch;
921 BDMA_OP_CB sOpCB;
922
923 BDMA_DBG_FUNC();
924
925 if (!_BDMA_Is_Init())
926 {
927 return E_BDMA_FAIL;
928 }
929 if (DISABLE == _gsHwInfo.bEnMemFill)
930 {
931 BDMA_DBG_ERR("Mem fill is not supported!\n");
932 return E_BDMA_NOT_SUPPORT;
933 }
934
935 BDMA_DBG_INFO("BDMA Fill pattern start....\n");
936 if (E_BDMA_OK != _BDMA_Check_Device(E_BDMA_SRCDEV_MEM_FILL, eDev))
937 {
938 return E_BDMA_FAIL;
939 }
940
941 sOpCB.eAct = E_BDMA_ACT_MEM_FILL;
942 sOpCB.phy64SrcAddr = 0;
943 sOpCB.phy64DstAddr = phy64Addr;
944 sOpCB.u32DataSize = u32Len;
945
946 sOpCB.u8SrcDevCfg = _BDMA_GetDevCfg(E_BDMA_DEV_MEM_FILL);
947 sOpCB.u8DstDevCfg = _BDMA_GetDevCfg((BDMA_Dev)eDev);
948 sOpCB.u32Cmd0 = u32Pattern;
949 sOpCB.u32Cmd1 = 0;
950 sOpCB.u32Cmd2 = 0;
951 sOpCB.u8OpCfg = BDMA_OPCFG_DEF;
952 sOpCB.u8DmyWrCnt = 0;
953 sOpCB.pCbf = (void *)0;
954
955 _BDMA_MemFlush((BDMA_Dev)eDev, sOpCB.phy64DstAddr, sOpCB.u32DataSize);
956 return _BDMA_CmnHnd(sOpCB, &u8Ch);
957 }
958
959
MDrv_BDMA_CopyHnd(MS_PHY phy64SrcAddr,MS_PHY phy64DstAddr,MS_U32 u32Len,BDMA_CpyType eCpyType,MS_U8 u8OpCfg)960 BDMA_Result MDrv_BDMA_CopyHnd (MS_PHY phy64SrcAddr, MS_PHY phy64DstAddr, MS_U32 u32Len, BDMA_CpyType eCpyType, MS_U8 u8OpCfg)
961 {
962 #if (BDMA_UTOPIA20)
963 PBDMA_COPYHND_PARAM pParam = NULL;
964 if (NULL == pInstantBdma)
965 return E_BDMA_FAIL;
966 pParam = (PBDMA_COPYHND_PARAM)malloc(sizeof(BDMA_COPYHND_PARAM));
967 if (NULL == pParam)
968 return E_BDMA_FAIL;
969 pParam->phy64SrcAddr = phy64SrcAddr;
970 pParam->phy64DstAddr = phy64DstAddr;
971 pParam->u32Len = u32Len;
972 pParam->eCpyType = eCpyType;
973 pParam->u8OpCfg = u8OpCfg;
974 if (UtopiaIoctl(pInstantBdma,MDrv_CMD_BDMA_CopyHnd,(void*)pParam) != UTOPIA_STATUS_SUCCESS)
975 {
976 ULOGE(TAG_BDMA, "Ioctl MDrv_BDMA_CopyHnd fail\n");
977 free(pParam);
978 return E_BDMA_FAIL;
979 }
980 free(pParam);
981 return E_BDMA_OK;
982 #else
983 return _MDrv_BDMA_CopyHnd (phy64SrcAddr, phy64DstAddr, u32Len, eCpyType, u8OpCfg);
984 #endif
985 }
986
987 ////////////////////////////////////////////////////////////////////////////////
988 /// @brief \b Function \b Name: MDrv_BDMA_CopyHnd
989 /// @brief \b Function \b Description: Handle for BDMA copy data from src to dst
990 /// @param phy64SrcAddr \b IN: Physical source address
991 /// @param phy64DstAddr \b IN: Physical dst address
992 /// @param u32Len \b IN: data length
993 /// @param eCpyType \b IN: BDMA copy type
994 /// @param u8OpCfg \b IN: u8OpCfg: default is BDMA_OPCFG_DEF
995 /// - Bit0: inverse mode --> BDMA_OPCFG_INV_COPY
996 /// - Bit2: Copy & CRC check in wait mode --> BDMA_OPCFG_CRC_COPY
997 /// - Bit3: Copy without waiting --> BDMA_OPCFG_NOWAIT_COPY
998 /// @return \b BDMA_Result
999 ////////////////////////////////////////////////////////////////////////////////
_MDrv_BDMA_CopyHnd(MS_PHY phy64SrcAddr,MS_PHY phy64DstAddr,MS_U32 u32Len,BDMA_CpyType eCpyType,MS_U8 u8OpCfg)1000 BDMA_Result _MDrv_BDMA_CopyHnd (MS_PHY phy64SrcAddr, MS_PHY phy64DstAddr, MS_U32 u32Len, BDMA_CpyType eCpyType, MS_U8 u8OpCfg)
1001 {
1002 MS_U8 u8MiuSel;
1003 MS_U8 u8Ch;
1004 MS_U32 u32CRCVal = 0xFFFFFFFF;
1005 MS_U32 u32Offset;
1006 BDMA_OP_CB sOpCB;
1007 BDMA_Dev eSrcDev, eDstDev;
1008 BDMA_Result eRet = E_BDMA_FAIL;
1009
1010 MS_DEBUG_MSG(MS_U32 u32Time = 0);
1011 BDMA_DBG_FUNC();
1012 if (!_BDMA_Is_Init())
1013 {
1014 return eRet;
1015 }
1016
1017 eSrcDev = (BDMA_Dev)(eCpyType & 0x0F);
1018 eDstDev = (BDMA_Dev)_RShift(eCpyType, 8);
1019 if (eSrcDev == eDstDev && phy64SrcAddr == phy64DstAddr)
1020 {
1021 BDMA_DBG_ERR("No meaning copy: Src is same as Dst!\n");
1022 return E_BDMA_OK;
1023 }
1024
1025 if ((!u32Len) || (E_BDMA_CPYTYPE_MAX <= eCpyType))
1026 {
1027 BDMA_DBG_ERR("BDMA copy critical error len:%lu type:%u!!\n", u32Len, eCpyType);
1028 return eRet;
1029 }
1030
1031 sOpCB.phy64SrcAddr = phy64SrcAddr;
1032 sOpCB.phy64DstAddr = phy64DstAddr;
1033 sOpCB.u32DataSize = u32Len;
1034
1035 //avoid address overlapping
1036 if (eSrcDev == eDstDev)
1037 {
1038 if ((phy64SrcAddr < phy64DstAddr) && ((phy64SrcAddr+u32Len-1) >= phy64DstAddr))
1039 {
1040 u8OpCfg |= BDMA_OPCFG_INV_COPY;
1041 }
1042 }
1043
1044 if (u8OpCfg & BDMA_OPCFG_INV_COPY)
1045 {
1046 sOpCB.phy64SrcAddr += (sOpCB.u32DataSize-1);
1047 sOpCB.phy64DstAddr += (sOpCB.u32DataSize-1);
1048 BDMA_DBG_INFO("a4 copy inv src:%lx dst:%lx\n", sOpCB.phy64SrcAddr, sOpCB.phy64DstAddr);
1049 }
1050
1051 if (E_BDMA_OK != _BDMA_Check_Device((BDMA_SrcDev)eSrcDev, (BDMA_DstDev)eDstDev))
1052 {
1053 return eRet;
1054 }
1055 _BDMA_MemFlush(eSrcDev, phy64SrcAddr, sOpCB.u32DataSize);
1056 _BDMA_MemFlush(eDstDev, phy64DstAddr, sOpCB.u32DataSize);
1057
1058 sOpCB.u8SrcDevCfg = _BDMA_GetDevCfg(eSrcDev);
1059 sOpCB.u8DstDevCfg = _BDMA_GetDevCfg(eDstDev);
1060
1061 if((E_BDMA_DSTDEV_MIU1 == (BDMA_DstDev)eDstDev) || (E_BDMA_DSTDEV_MIU2 == (BDMA_DstDev)eDstDev) || (E_BDMA_DSTDEV_MIU3 == (BDMA_DstDev)eDstDev))
1062 {
1063 _phy_to_miu_offset(u8MiuSel, u32Offset, phy64DstAddr);
1064 phy64DstAddr = u32Offset;
1065
1066 _phy_to_miu_offset(u8MiuSel, u32Offset, sOpCB.phy64DstAddr);
1067 sOpCB.phy64DstAddr = u32Offset;
1068 }
1069
1070 if((E_BDMA_SRCDEV_MIU1 == (BDMA_SrcDev)eSrcDev) || (E_BDMA_DSTDEV_MIU2 == (BDMA_DstDev)eDstDev) || (E_BDMA_DSTDEV_MIU3 == (BDMA_DstDev)eDstDev))
1071 {
1072 _phy_to_miu_offset(u8MiuSel, u32Offset, phy64SrcAddr);
1073 phy64SrcAddr = u32Offset;
1074
1075 _phy_to_miu_offset(u8MiuSel, u32Offset, sOpCB.phy64SrcAddr);
1076 sOpCB.phy64SrcAddr = u32Offset;
1077 }
1078
1079 if ((E_BDMA_DEV_MIU0 == eDstDev) || (E_BDMA_DEV_MIU1 == eDstDev) || (E_BDMA_DEV_MIU2 == eDstDev) || (E_BDMA_DEV_MIU3 == eDstDev))
1080 {
1081 sOpCB.u8DmyWrCnt = HAL_BDMA_DMY_WRCNT;
1082 }
1083 else
1084 {
1085 sOpCB.u8DmyWrCnt = 0;
1086 }
1087 sOpCB.u32Cmd0 = sOpCB.phy64DstAddr;
1088 sOpCB.u32Cmd1 = 0;
1089 sOpCB.u32Cmd2 = 0;
1090
1091 sOpCB.u8OpCfg = u8OpCfg;
1092 sOpCB.eAct = (E_BDMA_DEV_FLASH == eSrcDev) ? E_BDMA_ACT_COPY_FLASH : E_BDMA_ACT_COPY_MEM;
1093 //TBD
1094 sOpCB.pCbf = (void *)0;
1095
1096 #if (BDMA_USE_DMA_FLASH_COPY)
1097 //compatible DMA flash copy
1098 if (E_BDMA_DEV_FLASH == eSrcDev)
1099 {
1100 if (!_gsHwInfo.bEnFlsCpy)
1101 return _DMA_FlashCopy(sOpCB);
1102 }
1103 #endif
1104 if (u8OpCfg & BDMA_OPCFG_NOWAIT_COPY)
1105 {
1106 BDMA_DBG_INFO("BDMA no wait copy\n");
1107 return _BDMA_CmnHnd(sOpCB, &u8Ch);
1108 }
1109
1110 MS_DEBUG_MSG(u32Time = MsOS_GetSystemTime());
1111 //Copy and CRC32 check
1112 if (u8OpCfg & BDMA_OPCFG_CRC_COPY)
1113 {
1114 u32CRCVal = MDrv_BDMA_CRC32(phy64SrcAddr, u32Len, BDMA_CRC32_POLY, BDMA_CRC_SEED_0, (BDMA_SrcDev)eSrcDev, FALSE);
1115 }
1116 if(E_BDMA_OK == (eRet = _BDMA_CmnHnd(sOpCB, &u8Ch)))
1117 {
1118 //flush miu FIFO data to MIU
1119 if (!_gsHwInfo.bEnDmyWrCnt && (E_BDMA_DEV_MIU0 == eDstDev || E_BDMA_DEV_MIU1 == eDstDev || E_BDMA_DEV_MIU2 == eDstDev || E_BDMA_DEV_MIU3 == eDstDev))
1120 {
1121 MDrv_BDMA_CRC32(sOpCB.phy64DstAddr, HAL_BDMA_DMY_WRCNT, BDMA_CRC32_POLY, BDMA_CRC_SEED_0, (BDMA_SrcDev)eDstDev, FALSE);
1122 }
1123
1124 if (u8OpCfg & BDMA_OPCFG_CRC_COPY)
1125 {
1126 phy64DstAddr = MDrv_BDMA_CRC32(phy64DstAddr, u32Len, BDMA_CRC32_POLY, BDMA_CRC_SEED_0, (BDMA_SrcDev)eDstDev, FALSE);
1127 if ( (u32CRCVal != phy64DstAddr) )
1128 {
1129 BDMA_DBG_ERR("Copy check CRC error: (%lx != %lx)\n", phy64DstAddr, u32CRCVal);
1130 return E_BDMA_FAIL;
1131 }
1132 }
1133
1134 if (E_BDMA_DBGLV_PERFORMANCE == _gsInfo.eDbgLv)
1135 {
1136 MS_DEBUG_MSG(ULOGD(TAG_BDMA, "bdma copy:%lu ms\n", MsOS_GetSystemTime() - u32Time));
1137 }
1138 return E_BDMA_OK;
1139 }
1140
1141 BDMA_DBG_ERR("Copy error:%u\n", eRet);
1142 return eRet;
1143 }
1144
1145 ////////////////////////////////////////////////////////////////////////////////
1146 /// @brief \b Function \b Name: MDrv_BDMA_MemCopy
1147 /// @brief \b Function \b Description: Copy dram to dram no matter dram address within miu0 or miu1
1148 /// @param phy64SrcAddr \b IN: Physical Source address
1149 /// @param phy64DstAddr \b IN: Physical Dst address
1150 /// @param u32Len \b IN: data length
1151 /// @return \b BDMA_Result
1152 ////////////////////////////////////////////////////////////////////////////////
_MDrv_BDMA_MemCopy(MS_PHY phy64SrcAddr,MS_PHY phy64DstAddr,MS_U32 u32Len)1153 BDMA_Result _MDrv_BDMA_MemCopy(MS_PHY phy64SrcAddr, MS_PHY phy64DstAddr, MS_U32 u32Len)
1154 {
1155 MS_U8 eSrc, eDst;
1156 BDMA_CpyType eCpyType;
1157
1158 eSrc = (MS_U8)_BDMA_Check_MIUDev(E_BDMA_DEV_MIU0, phy64SrcAddr);
1159 eDst = (MS_U8)_BDMA_Check_MIUDev(E_BDMA_DEV_MIU0, phy64DstAddr);
1160 eCpyType = (BDMA_CpyType)(eSrc | _LShift(eDst, 8));
1161 return _MDrv_BDMA_CopyHnd(phy64SrcAddr, phy64DstAddr, u32Len, eCpyType, BDMA_OPCFG_DEF);
1162 }
1163
1164 ////////////////////////////////////////////////////////////////////////////////
1165 /// @brief \b Function \b Name: MDrv_BDMA_FlashCopy2Dram
1166 /// @brief \b Function \b Description: Copy data from flash to dram no matter dram address within miu0 or miu1
1167 /// @param u32FlashAddr \b IN: Physical Source address in flash
1168 /// @param u32DramAddr \b IN: Physical Dst address in dram
1169 /// @param u32Len \b IN: data length
1170 /// @return \b BDMA_Result
1171 ////////////////////////////////////////////////////////////////////////////////
_MDrv_BDMA_FlashCopy2Dram(MS_PHY phy64FlashAddr,MS_PHY phy64DramAddr,MS_U32 u32Len)1172 BDMA_Result _MDrv_BDMA_FlashCopy2Dram(MS_PHY phy64FlashAddr, MS_PHY phy64DramAddr, MS_U32 u32Len)
1173 {
1174 MS_U8 eDst = (MS_U8)_BDMA_Check_MIUDev(E_BDMA_DEV_MIU0, phy64DramAddr);
1175 BDMA_CpyType eCpyType;
1176
1177 eCpyType = (BDMA_CpyType)(E_BDMA_DEV_FLASH | _LShift(eDst, 8));
1178 return _MDrv_BDMA_CopyHnd(phy64FlashAddr, phy64DramAddr, u32Len, eCpyType, BDMA_OPCFG_DEF);
1179 }
1180
1181 ////////////////////////////////////////////////////////////////////////////////
1182 /// @brief \b Function \b Name: MDrv_BDMA_Search
1183 /// @brief \b Function \b Description: Search pattern from MIU
1184 /// @param phy64Addr \b IN: Physical Start address
1185 /// @param u32Len \b IN: Search Pattern length, must > 0
1186 /// @param u32Pattern \b IN: Search Pattern data
1187 /// @param u32ExcluBit \b IN: Don't care bit filter
1188 /// @param eDev \b IN: source device for searching, valid sources are
1189 /// @return \b MS_U32 : matched address, if error, return 0xFFFFFFFF
1190 ////////////////////////////////////////////////////////////////////////////////
_MDrv_BDMA_Search(MS_PHY phy64Addr,MS_U32 u32Len,MS_U32 u32Pattern,MS_U32 u32ExcluBit,BDMA_SrcDev eDev)1191 MS_U32 _MDrv_BDMA_Search(MS_PHY phy64Addr, MS_U32 u32Len, MS_U32 u32Pattern, MS_U32 u32ExcluBit, BDMA_SrcDev eDev)
1192 {
1193 MS_U8 u8Ch;
1194 BDMA_OP_CB sOpCB;
1195
1196 BDMA_DBG_FUNC();
1197
1198 if (!_BDMA_Is_Init()){
1199 MDrv_BDMA_Init(0);
1200 }
1201
1202 if ((!u32Len) || (E_BDMA_OK != _BDMA_Check_Device(eDev, E_BDMA_DSTDEV_SEARCH)))
1203 {
1204 BDMA_DBG_ERR("Critial error! Len:%lx!\n", u32Len);
1205 return 0xFFFFFFFF;
1206 }
1207
1208 sOpCB.eAct = E_BDMA_ACT_SEARCH;
1209 sOpCB.phy64SrcAddr = phy64Addr;
1210 sOpCB.phy64DstAddr = 0;
1211 sOpCB.u32DataSize = u32Len;
1212
1213 sOpCB.u8SrcDevCfg = _BDMA_GetDevCfg((BDMA_Dev)eDev);
1214 sOpCB.u8DstDevCfg = _BDMA_GetDevCfg(E_BDMA_DEV_SEARCH);
1215 sOpCB.u32Cmd0 = u32Pattern;
1216 sOpCB.u32Cmd1 = u32ExcluBit;
1217 sOpCB.u32Cmd2 = 0;
1218
1219 sOpCB.u8OpCfg = BDMA_OPCFG_DEF;
1220 sOpCB.u8DmyWrCnt = 0;
1221 sOpCB.pCbf = (void *)0;
1222
1223 if (E_BDMA_OK == _BDMA_CmnHnd(sOpCB, &u8Ch))
1224 {
1225 if (HAL_BDMA_Is_Found(u8Ch))
1226 {
1227 return HAL_BDMA_GetMatched(phy64Addr, u8Ch);
1228 }
1229 else
1230 {
1231 BDMA_DBG_INFO("Search not found!\n");
1232 }
1233 }
1234
1235 return 0xFFFFFFFF;
1236 }
1237
1238 #ifdef MOBF_ENABLE
1239 ////////////////////////////////////////////////////////////////////////////////
1240 /// @brief \b Function \b Name: MDrv_BDMA_MOBFSearch
1241 /// @brief \b Function \b Description: Search pattern from MIU by De-MOBF channel
1242 /// @param u32Addr \b IN: Physical Start address
1243 /// @param u32Len \b IN: Search Pattern length, must > 0
1244 /// @param u32Pattern \b IN: Search Pattern RAW data
1245 /// @param u32MBOFKey \b IN: MOBF Key
1246 /// @param eDev \b IN: source device for searching, valid sources are
1247 /// @return \b MS_U32 : matched address, if error, return 0xFFFFFFFF
1248 ////////////////////////////////////////////////////////////////////////////////
_MDrv_BDMA_MOBFSearch(MS_PHY phy64Addr,MS_U32 u32Len,BDMA_MOBF_PS * pMobfPsCfg,BDMA_SrcDev eDev)1249 MS_PHY _MDrv_BDMA_MOBFSearch(MS_PHY phy64Addr, MS_U32 u32Len, BDMA_MOBF_PS* pMobfPsCfg, BDMA_SrcDev eDev)
1250 {
1251 MS_U8 u8Ch;
1252 MS_U32 phy64RetAddr = 0xFFFFFFFF;
1253 BDMA_OP_CB sOpCB;
1254
1255 BDMA_DBG_FUNC();
1256 if (!_BDMA_Is_Init() || !u32Len || (E_BDMA_OK != _BDMA_Check_Device(eDev, E_BDMA_DSTDEV_SEARCH)))
1257 {
1258 BDMA_DBG_ERR("%s:Critial error! Len:%lx!\n", __FUNCTION__, u32Len);
1259 return phy64RetAddr;
1260 }
1261
1262 sOpCB.eAct = E_BDMA_ACT_SEARCH;
1263 sOpCB.phy64SrcAddr = phy64Addr;
1264 sOpCB.phy64DstAddr = phy64Addr;
1265 sOpCB.u32DataSize = u32Len;
1266
1267 sOpCB.u8SrcDevCfg = _BDMA_GetDevCfg((BDMA_Dev)eDev);
1268 sOpCB.u8DstDevCfg = _BDMA_GetDevCfg(E_BDMA_DEV_SEARCH);
1269 sOpCB.u32Cmd0 = pMobfPsCfg->u32Pattern;
1270 sOpCB.u32Cmd1 = pMobfPsCfg->u32ExcluBit;
1271 sOpCB.u32Cmd2 = pMobfPsCfg->u32MobfKey;
1272
1273 sOpCB.u8OpCfg = BDMA_OPCFG_MOBF_PS;
1274 sOpCB.u8DmyWrCnt = 0;
1275 sOpCB.pCbf = (void *)0;
1276
1277 if (E_BDMA_OK == _BDMA_CmnHnd(sOpCB, &u8Ch))
1278 {
1279 if (HAL_BDMA_Is_Found(u8Ch))
1280 {
1281 phy64RetAddr = (HAL_BDMA_GetMatched(phy64Addr, u8Ch)-phy64Addr);
1282 }
1283 else
1284 {
1285 BDMA_DBG_INFO("%s : Search not found!\n", __FUNCTION__);
1286 }
1287 }
1288 return phy64RetAddr;
1289 }
1290 #endif
1291
1292 ////////////////////////////////////////////////////////////////////////////////
1293 /// @brief \b Function \b Name: MDrv_BDMA_DumpCB
1294 /// @brief \b Function \b Description: Dump control block informaiton
1295 /// @param *pvOpCB \b IN: control block
1296 /// @return \b BDMA_Result
1297 ////////////////////////////////////////////////////////////////////////////////
MDrv_BDMA_DumpCB(void * pvOpCB)1298 void MDrv_BDMA_DumpCB(void *pvOpCB)
1299 {
1300 MS_DEBUG_MSG(BDMA_OP_CB *psOpCB);
1301
1302 if (E_BDMA_DBGLV_ALL != _gsInfo.eDbgLv)
1303 {
1304 return;
1305 }
1306
1307 if (pvOpCB)
1308 {
1309 MS_DEBUG_MSG(psOpCB = (BDMA_OP_CB *)pvOpCB);
1310 MS_DEBUG_MSG(ULOGD(TAG_BDMA, "\tDump BDMA CB.......\n"));
1311 MS_DEBUG_MSG(ULOGD(TAG_BDMA, "\tAct: %u Src dev: 0x%x Dst dev: 0x%x\n",psOpCB->eAct, psOpCB->u8SrcDevCfg, psOpCB->u8DstDevCfg));
1312 MS_DEBUG_MSG(ULOGD(TAG_BDMA, "\tSrc addr: %lx Dst addr: %lx\n",psOpCB->phy64SrcAddr, psOpCB->phy64DstAddr));
1313 MS_DEBUG_MSG(ULOGD(TAG_BDMA, "\tData len: %lx\n",psOpCB->u32DataSize));
1314 MS_DEBUG_MSG(ULOGD(TAG_BDMA, "\tCmd0: %lx Cmd1: %lx Cmd2: %lx\n",psOpCB->u32Cmd0, psOpCB->u32Cmd1, psOpCB->u32Cmd2));
1315 MS_DEBUG_MSG(ULOGD(TAG_BDMA, "\tDmyWrCnt: %u OpCfg: %u Cbf:%lx\n",psOpCB->u8DmyWrCnt, psOpCB->u8OpCfg, (MS_U32)psOpCB->pCbf));
1316 }
1317 }
1318
1319 ////////////////////////////////////////////////////////////////////////////////
1320 /// @brief \b Function \b Name: MDrv_BDMA_CRC
1321 /// @brief \b Function \b Description: Crc32 for BDMA copy action
1322 /// @param u32Addr \b IN: Physical Start address
1323 /// @param u32Len \b IN: data length
1324 /// @param u32Poly \b IN: CRC Poly Ex: 0xEDB88320 or invert 0x04C11DB7
1325 /// @param u32Seed \b IN: Start value Ex: 0x00000000 or 0xFFFFFFFF
1326 /// @param eDev \b IN: Source device
1327 /// @param bReflect \b IN: TRUE: CRC reflection FALSE: No reflection
1328 /// @return \b MS_U32: result of CRC
1329 ////////////////////////////////////////////////////////////////////////////////
_MDrv_BDMA_CRC32(MS_PHY phy64Addr,MS_U32 u32Len,MS_U32 u32Poly,MS_U32 u32Seed,BDMA_SrcDev eDev,MS_BOOL bReflect)1330 MS_U32 _MDrv_BDMA_CRC32(MS_PHY phy64Addr, MS_U32 u32Len, MS_U32 u32Poly, MS_U32 u32Seed, BDMA_SrcDev eDev, MS_BOOL bReflect)
1331 {
1332 MS_U8 u8Ch;
1333 BDMA_OP_CB sOpCB;
1334
1335 BDMA_DBG_FUNC();
1336
1337 if ((!_BDMA_Is_Init()) || (E_BDMA_OK != _BDMA_Check_Device(eDev, E_BDMA_DSTDEV_CRC32)))
1338 {
1339 return 0xFFFFFFFF;
1340 }
1341 BDMA_DBG_INFO("BDMA CRC32 start....\n");
1342 sOpCB.eAct = E_BDMA_ACT_CRC32;
1343 sOpCB.phy64SrcAddr = phy64Addr;
1344 sOpCB.phy64DstAddr = 0;
1345 sOpCB.u32DataSize = u32Len;
1346
1347 sOpCB.u8SrcDevCfg = _BDMA_GetDevCfg((BDMA_Dev)eDev);
1348 sOpCB.u8DstDevCfg = _BDMA_GetDevCfg(E_BDMA_DEV_CRC32);
1349 sOpCB.u32Cmd0 = u32Poly;
1350 sOpCB.u32Cmd1 = u32Seed;
1351 sOpCB.u32Cmd2 = 0;
1352
1353 //only care reflection bit
1354 sOpCB.u8OpCfg = (bReflect) ? BDMA_OPCFG_CRC_REFLECT : BDMA_OPCFG_DEF;
1355 sOpCB.u8DmyWrCnt = 0;
1356 sOpCB.pCbf = (void *)0;
1357
1358 if (E_BDMA_OK == _BDMA_CmnHnd(sOpCB, &u8Ch))
1359 {
1360 return HAL_BDMA_GetCRC32(u8Ch);
1361 }
1362 return 0xFFFFFFFF;
1363 }
1364
1365 ////////////////////////////////////////////////////////////////////////////////
1366 /// @brief \b Function \b Name: MDrv_BDMA_GetInfo
1367 /// @brief \b Function \b Description: Get BDMA driver information
1368 /// @return \b const BDMA_Info *: bdma driver informaiton
1369 ////////////////////////////////////////////////////////////////////////////////
MDrv_BDMA_GetInfo()1370 const BDMA_Info* MDrv_BDMA_GetInfo()
1371 {
1372 if (!_BDMA_Is_Init())
1373 {
1374 return (BDMA_Info *)0;
1375 }
1376 _gsInfo.u8ChNum = E_BDMA_CH_END;
1377 _gsInfo.sHwCap = _gsHwInfo;
1378 return (&_gsInfo);
1379 }
1380
1381 ////////////////////////////////////////////////////////////////////////////////
1382 /// @brief \b Function \b Name: MDrv_BDMA_GetStatus
1383 /// @brief \b Function \b Description: Get BDMA driver information
1384 /// @param pStatus \b Out: bdma driver status
1385 ////////////////////////////////////////////////////////////////////////////////
_MDrv_BDMA_GetStatus(BDMA_Status * pStatus)1386 void _MDrv_BDMA_GetStatus(BDMA_Status *pStatus)
1387 {
1388 MS_U8 u8Ch = E_BDMA_CH0;
1389
1390 if (pStatus==NULL)
1391 {
1392 return;
1393 }
1394
1395 if (!_BDMA_Is_Init())
1396 {
1397 return;
1398 }
1399 for (; u8Ch <= E_BDMA_CH1; u8Ch++)
1400 {
1401 pStatus->sChSta[u8Ch].bIsBusy = HAL_BDMA_Is_Busy(u8Ch);
1402 pStatus->sChSta[u8Ch].bIsInt = HAL_BDMA_Is_Int(u8Ch);
1403 pStatus->sChSta[u8Ch].bIsFound = HAL_BDMA_Is_Found(u8Ch);
1404 }
1405 pStatus->bInit = _gsInfo.bInit;
1406 pStatus->eDbgLv = _gsInfo.eDbgLv;
1407 }
1408
1409 ////////////////////////////////////////////////////////////////////////////////
1410 /// @brief \b Function \b Name: MDrv_BDMA_GetMinSize
1411 /// @brief \b Function \b Description: Get BDMA service min size
1412 /// @param pStatus \b Out: bdma driver status
1413 ////////////////////////////////////////////////////////////////////////////////
MDrv_BDMA_GetMinSize(void)1414 MS_U32 MDrv_BDMA_GetMinSize(void)
1415 {
1416 return BDMA_MIN_SIZE;
1417 }
1418
1419 ////////////////////////////////////////////////////////////////////////////////
1420 /// @brief \b Function \b Name: MDrv_BDMA_SetSPIOffsetForMCU
1421 /// @brief \b Function \b Description: MCU Reset
1422 /// @param pStatus \b Out: non
1423 ////////////////////////////////////////////////////////////////////////////////
_MDrv_BDMA_SetSPIOffsetForMCU(void)1424 void _MDrv_BDMA_SetSPIOffsetForMCU(void)
1425 {
1426 MS_PHY u32BaseSize = 0;
1427 if(!MDrv_MMIO_GetBASE(&_gsInfo.u32IOMap, &u32BaseSize, MS_MODULE_PM))
1428 {
1429 BDMA_DBG_ERR("Get IOMAP Base faill!\n");
1430 //return E_BDMA_FAIL;
1431 }
1432 HAL_BDMA_SetIOMapBase(_gsInfo.u32IOMap);
1433
1434 HAL_BDMA_SetSPIOffsetForMCU();
1435
1436 if(!MDrv_MMIO_GetBASE(&_gsInfo.u32IOMap, &u32BaseSize, MS_MODULE_BDMA))
1437 {
1438 BDMA_DBG_ERR("Get IOMAP Base faill!\n");
1439 //return E_BDMA_FAIL;
1440 }
1441 HAL_BDMA_SetIOMapBase(_gsInfo.u32IOMap);
1442 }
1443
1444 ////////////////////////////////////////////////////////////////////////////////
1445 /// @brief \b Function \b Name: MDrv_BDMA_Internal_Test
1446 /// @brief \b Function \b Description: Internal_Test
1447 /// @param pStatus \b Out: non
1448 ////////////////////////////////////////////////////////////////////////////////
1449 #if 0
1450 void MDrv_BDMA_Internal_Test(void)
1451 {
1452 MS_U8 tmp;
1453
1454 _BDMA_Get_FreeCh(0);
1455 _BDMA_MemFlush(E_BDMA_DEV_MIU1, 0, 0);
1456 _BDMA_WaitDone(E_BDMA_ACT_MAX, 0);
1457 BDMA_OP_CB sOpCB;
1458 _BDMA_CmnHnd(sOpCB, 0);
1459 _BDMA_GetHwInfo(0);
1460 _BDMA_Check_MIUDev(E_BDMA_DEV_FLASH, 0);
1461 _BDMA_Check_MIUDev(E_BDMA_DEV_MIU0, _gsInfo.phy64MIU1Base);
1462 _BDMA_Check_MIUDev(E_BDMA_DEV_MIU1, 0);
1463 _BDMA_Check_Device(E_BDMA_DEV_NOT_SUPPORT, E_BDMA_DEV_NOT_SUPPORT);
1464 _BDMA_Check_Device(E_BDMA_DEV_MIU1, E_BDMA_DEV_NOT_SUPPORT+1);
1465
1466 tmp = _gsHwInfo.bEnMIU1;
1467 _gsHwInfo.bEnMIU1 = 0;
1468 _BDMA_Check_Device(E_BDMA_DEV_MIU1, E_BDMA_DEV_MIU1);
1469 _gsHwInfo.bEnMIU1 = tmp;
1470
1471 tmp = _gsHwInfo.bEnDMDMCU;
1472 _gsHwInfo.bEnDMDMCU = 0;
1473 _BDMA_Check_Device(E_BDMA_DEV_MIU0, E_BDMA_DEV_DMDMCU);
1474 _gsHwInfo.bEnDMDMCU = tmp;
1475
1476 tmp = _gsHwInfo.bEnDevDw;
1477 _gsHwInfo.bEnDevDw = 0;
1478 _BDMA_GetDevCfg(0);
1479 _gsHwInfo.bEnDevDw = tmp;
1480
1481 tmp = _gsHwInfo.bEnMemFill;
1482 _gsHwInfo.bEnMemFill = 0;
1483 _gsInfo.bInit = TRUE;
1484 MDrv_BDMA_PatternFill(0, 0, 0, 0);
1485 _gsInfo.bInit = FALSE;
1486 _gsHwInfo.bEnMemFill = tmp;
1487 }
1488 #endif
1489
1490 // below are utopia10 interface and will call to utopia20 core
MDrv_BDMA_MemCopy(MS_PHY phy64SrcAddr,MS_PHY phy64DstAddr,MS_U32 u32Len)1491 BDMA_Result MDrv_BDMA_MemCopy(MS_PHY phy64SrcAddr, MS_PHY phy64DstAddr, MS_U32 u32Len)
1492 {
1493 #if (BDMA_UTOPIA20)
1494 PBDMA_MEMCOPY_PARAM pMemCpyParam;
1495 if (NULL == pInstantBdma)
1496 return E_BDMA_FAIL;
1497 pMemCpyParam = (PBDMA_MEMCOPY_PARAM)malloc(sizeof(BDMA_MEMCOPY_PARAM));
1498 if (NULL == pMemCpyParam)
1499 return E_BDMA_FAIL;
1500 pMemCpyParam->phy64SrcAddr = phy64SrcAddr;
1501 pMemCpyParam->phy64DstAddr = phy64DstAddr;
1502 pMemCpyParam->u32Len = u32Len;
1503 if(UtopiaIoctl(pInstantBdma,MDrv_CMD_BDMA_MemCopy,(void*)pMemCpyParam) != UTOPIA_STATUS_SUCCESS)
1504 {
1505 ULOGE(TAG_BDMA, "Ioctl MDrv_BDMA_MemCopy fail\n");
1506 free(pMemCpyParam);
1507 return E_BDMA_FAIL;
1508 }
1509 free(pMemCpyParam);
1510 return E_BDMA_OK;
1511 #else
1512 return _MDrv_BDMA_MemCopy(phy64SrcAddr,phy64DstAddr,u32Len);
1513 #endif
1514 }
1515
MDrv_BDMA_Search(MS_PHY phy64Addr,MS_U32 u32Len,MS_U32 u32Pattern,MS_U32 u32ExcluBit,BDMA_SrcDev eDev)1516 MS_U32 MDrv_BDMA_Search(MS_PHY phy64Addr, MS_U32 u32Len, MS_U32 u32Pattern, MS_U32 u32ExcluBit, BDMA_SrcDev eDev)
1517 {
1518 #if (BDMA_UTOPIA20)
1519 PBDMA_SEARCH_PARAM pSearchParam = NULL;
1520 MS_U32 u32SearchAddr=0;
1521
1522 if (NULL == pInstantBdma)
1523 return E_BDMA_FAIL;
1524 pSearchParam = (PBDMA_SEARCH_PARAM)malloc(sizeof(BDMA_SEARCH_PARAM));
1525 if (NULL == pSearchParam)
1526 return E_BDMA_FAIL;
1527 pSearchParam->u32Addr = phy64Addr;
1528 pSearchParam->u32Len = u32Len;
1529 pSearchParam->u32Pattern = u32Pattern;
1530 pSearchParam->u32ExcluBit = u32ExcluBit;
1531 pSearchParam->eDev = eDev;
1532 pSearchParam->pSearchAddr = 0;
1533 UtopiaIoctl(pInstantBdma,MDrv_CMD_BDMA_Search,(void*)pSearchParam);
1534 u32SearchAddr = pSearchParam->pSearchAddr;
1535
1536 free(pSearchParam);
1537 return u32SearchAddr;
1538 #else
1539 return _MDrv_BDMA_Search(phy64Addr, u32Len, u32Pattern, u32ExcluBit, eDev);
1540 #endif
1541 }
1542
MDrv_BDMA_CRC32(MS_PHY phy64Addr,MS_U32 u32Len,MS_U32 u32Poly,MS_U32 u32Seed,BDMA_SrcDev eDev,MS_BOOL bReflect)1543 MS_U32 MDrv_BDMA_CRC32(MS_PHY phy64Addr, MS_U32 u32Len, MS_U32 u32Poly, MS_U32 u32Seed, BDMA_SrcDev eDev, MS_BOOL bReflect)
1544 {
1545 #if (BDMA_UTOPIA20)
1546 PBDMA_CRC32_PARAM pCRCParam = NULL;
1547 MS_U32 u32CRC32;
1548 if (NULL == pInstantBdma)
1549 return E_BDMA_FAIL;
1550 pCRCParam = (PBDMA_CRC32_PARAM)malloc(sizeof(BDMA_CRC32_PARAM));
1551 if (NULL == pCRCParam)
1552 return E_BDMA_FAIL;
1553 pCRCParam->phy64Addr = phy64Addr;
1554 pCRCParam->u32Len = u32Len;
1555 pCRCParam->u32Poly = u32Poly;
1556 pCRCParam->u32Seed = u32Seed;
1557 pCRCParam->eDev = eDev;
1558 pCRCParam->bReflect = bReflect;
1559 pCRCParam->u32CRC32 = 0;
1560 if(UtopiaIoctl(pInstantBdma,MDrv_CMD_BDMA_CRC32,(void*)pCRCParam) != UTOPIA_STATUS_SUCCESS)
1561 {
1562 free(pCRCParam);
1563 return 0xFFFFFFFF;
1564 }
1565 u32CRC32 = pCRCParam->u32CRC32;
1566 free(pCRCParam);
1567 return u32CRC32;
1568 #else
1569 return _MDrv_BDMA_CRC32(phy64Addr, u32Len, u32Poly, u32Seed, eDev, bReflect);
1570 #endif
1571 }
1572
MDrv_BDMA_PatternFill(MS_PHY phy64Addr,MS_U32 u32Len,MS_U32 u32Pattern,BDMA_DstDev eDev)1573 BDMA_Result MDrv_BDMA_PatternFill(MS_PHY phy64Addr, MS_U32 u32Len, MS_U32 u32Pattern, BDMA_DstDev eDev)
1574 {
1575 #if (BDMA_UTOPIA20)
1576 PBDMA_PATTERN_FILL_PARAM pPattFillParam = NULL;
1577 if (NULL == pInstantBdma)
1578 return E_BDMA_FAIL;
1579 pPattFillParam = (PBDMA_PATTERN_FILL_PARAM)malloc(sizeof(BDMA_PATTERN_FILL_PARAM));
1580 if (NULL == pPattFillParam)
1581 return E_BDMA_FAIL;
1582 pPattFillParam->u32Addr = phy64Addr;
1583 pPattFillParam->u32Len = u32Len;
1584 pPattFillParam->u32Pattern = u32Pattern;
1585 pPattFillParam->eDev = eDev;
1586 if (UtopiaIoctl(pInstantBdma,MDrv_CMD_BDMA_Pattern_Fill,(void*)pPattFillParam) != UTOPIA_STATUS_SUCCESS)
1587 {
1588 ULOGE(TAG_BDMA, "Ioctl MDrv_BDMA_PatternFill fail\n");
1589 free(pPattFillParam);
1590 return E_BDMA_FAIL;
1591 }
1592 free(pPattFillParam);
1593 return E_BDMA_OK;
1594 #else
1595 return _MDrv_BDMA_PatternFill(phy64Addr, u32Len, u32Pattern, eDev);
1596 #endif
1597 }
1598
MDrv_BDMA_FlashCopy2Dram(MS_PHY phy64FlashAddr,MS_PHY phy64DramAddr,MS_U32 u32Len)1599 BDMA_Result MDrv_BDMA_FlashCopy2Dram(MS_PHY phy64FlashAddr, MS_PHY phy64DramAddr, MS_U32 u32Len)
1600 {
1601 #if (BDMA_UTOPIA20)
1602 PBDMA_FLASHCOPY2DRAM_PARAM pFlash2DramParam = NULL;
1603 if (NULL == pInstantBdma)
1604 return E_BDMA_FAIL;
1605 pFlash2DramParam = (PBDMA_FLASHCOPY2DRAM_PARAM)malloc(sizeof(BDMA_FLASHCOPY2DRAM_PARAM));
1606 if (NULL == pFlash2DramParam)
1607 return E_BDMA_FAIL;
1608 pFlash2DramParam->u32FlashAddr = phy64FlashAddr;
1609 pFlash2DramParam->u32DramAddr = phy64DramAddr;
1610 pFlash2DramParam->u32Len = u32Len;
1611 if (UtopiaIoctl(pInstantBdma,MDrv_CMD_BDMA_FlashCopy2Dram,(void*)pFlash2DramParam) != UTOPIA_STATUS_SUCCESS)
1612 {
1613 ULOGE(TAG_BDMA, "Ioctl MDrv_BDMA_FlashCopy2Dram fail\n");
1614 free(pFlash2DramParam);
1615 return E_BDMA_FAIL;
1616 }
1617 free(pFlash2DramParam);
1618 return E_BDMA_OK;
1619 #else
1620 return _MDrv_BDMA_FlashCopy2Dram(phy64FlashAddr, phy64DramAddr, u32Len);
1621 #endif
1622 }
1623
1624 #ifdef MOBF_ENABLE
MDrv_BDMA_MOBFSearch(MS_PHY phy64Addr,MS_U32 u32Len,BDMA_MOBF_PS * pMobfPsCfg,BDMA_SrcDev eDev)1625 MS_PHY MDrv_BDMA_MOBFSearch(MS_PHY phy64Addr, MS_U32 u32Len, BDMA_MOBF_PS* pMobfPsCfg, BDMA_SrcDev eDev)
1626 {
1627 #if (BDMA_UTOPIA20)
1628 PBDMA_MOBFSEARCH_PARAM pMOBFSearchParam = NULL;
1629 MS_PHY phy64Ret;
1630 if (NULL == pInstantBdma)
1631 return E_BDMA_FAIL;
1632 if (NULL == pMobfPsCfg)
1633 return E_BDMA_FAIL;
1634 pMOBFSearchParam = (PBDMA_MOBFSEARCH_PARAM)malloc(sizeof(BDMA_MOBFSEARCH_PARAM));
1635 if (NULL == pMOBFSearchParam)
1636 return E_BDMA_FAIL;
1637 pMOBFSearchParam->phy64Addr = phy64Addr;
1638 pMOBFSearchParam->u32Len = u32Len;
1639 pMOBFSearchParam->pMobfPsCfg = pMobfPsCfg;
1640 pMOBFSearchParam->eDev = eDev;
1641 pMOBFSearchParam->phy64SearchAddr = 0;
1642 if (UtopiaIoctl(pInstantBdma,MDrv_CMD_BDMA_MOBFSearch,(void*)pMOBFSearchParam) != UTOPIA_STATUS_SUCCESS)
1643 {
1644 free(pMOBFSearchParam);
1645 return 0xFFFFFFFF;
1646 }
1647 phy64Ret = pMOBFSearchParam->phy64SearchAddr;
1648 free(pMOBFSearchParam);
1649 return phy64Ret;
1650 #else
1651 return _MDrv_BDMA_MOBFSearch(u32Addr, u32Len, pMobfPsCfg, eDev);
1652 #endif
1653 }
1654 #endif
1655
MDrv_BDMA_GetStatus(BDMA_Status * pStatus)1656 void MDrv_BDMA_GetStatus(BDMA_Status *pStatus)
1657 {
1658 #if (BDMA_UTOPIA20)
1659 PBDMA_GETSTATUS_PARAM pGetStatusParam = NULL;
1660 if (NULL == pInstantBdma)
1661 return;
1662 pGetStatusParam = (PBDMA_GETSTATUS_PARAM)malloc(sizeof(BDMA_GETSTATUS_PARAM));
1663 if (NULL == pGetStatusParam)
1664 return;
1665 pGetStatusParam->pStatus = pStatus;
1666 if (UtopiaIoctl(pInstantBdma,MDrv_CMD_BDMA_GetStatus,(void*)pGetStatusParam) != UTOPIA_STATUS_SUCCESS)
1667 {
1668 ULOGE(TAG_BDMA, "Ioctl MDrv_BDMA_GetStatus fail\n");
1669 }
1670 free(pGetStatusParam);
1671 #else
1672 _MDrv_BDMA_GetStatus(pStatus);
1673 #endif
1674 }
1675
MDrv_BDMA_SetSPIOffsetForMCU(void)1676 void MDrv_BDMA_SetSPIOffsetForMCU(void)
1677 {
1678 #if (BDMA_UTOPIA20)
1679 if (NULL == pInstantBdma)
1680 return;
1681 UtopiaIoctl(pInstantBdma,MDrv_CMD_BDMA_SetSPIOffsetForMCU,(void*)NULL);
1682 #else
1683 _MDrv_BDMA_SetSPIOffsetForMCU();
1684 #endif
1685 }
1686
MDrv_BDMA_WaitFlashDone(void)1687 BDMA_Result MDrv_BDMA_WaitFlashDone(void)
1688 {
1689 #if (BDMA_UTOPIA20)
1690 if (NULL == pInstantBdma)
1691 return E_BDMA_FAIL;
1692 if (UtopiaIoctl(pInstantBdma,MDrv_CMD_BDMA_WaitFlashDone,(void*)NULL) != UTOPIA_STATUS_SUCCESS)
1693 {
1694 ULOGE(TAG_BDMA, "Ioctl MDrv_BDMA_WaitFlashDone fail\n");
1695 return E_BDMA_FAIL;
1696 }
1697 return E_BDMA_OK;
1698 #else
1699 return _MDrv_BDMA_WaitFlashDone();
1700 #endif
1701 }
1702
MDrv_BDMA_SetPowerState(EN_POWER_MODE u16PowerState)1703 MS_U32 MDrv_BDMA_SetPowerState(EN_POWER_MODE u16PowerState)
1704 {
1705 ULOGD(TAG_BDMA, "[Test] %s\n", __FUNCTION__);
1706 static EN_POWER_MODE u16PreBDMAPowerState = E_POWER_MECHANICAL;
1707 MS_U32 u32Return = UTOPIA_STATUS_FAIL;
1708
1709 if (u16PowerState == E_POWER_SUSPEND)
1710 {
1711 u16PreBDMAPowerState = u16PowerState;
1712 u32Return = UTOPIA_STATUS_SUCCESS;//SUSPEND_OK;
1713 }
1714 else if (u16PowerState == E_POWER_RESUME)
1715 {
1716 if (u16PreBDMAPowerState == E_POWER_SUSPEND)
1717 {
1718 MDrv_BDMA_Init(0);
1719
1720 u16PreBDMAPowerState = u16PowerState;
1721 u32Return = UTOPIA_STATUS_SUCCESS;//RESUME_OK;
1722 }
1723 else
1724 {
1725 ULOGE(TAG_BDMA, "[%s,%5d]It is not suspended yet. We shouldn't resume\n",__FUNCTION__,__LINE__);
1726 u32Return = UTOPIA_STATUS_FAIL;//SUSPEND_FAILED;
1727 }
1728 }
1729 else
1730 {
1731 ULOGE(TAG_BDMA, "[%s,%5d]Do Nothing: %d\n",__FUNCTION__,__LINE__,u16PowerState);
1732 u32Return = UTOPIA_STATUS_FAIL;
1733 }
1734
1735 return u32Return;// for success
1736 }
1737
1738