1 #if !defined(MSOS_TYPE_LINUX_KERNEL)
2 #include "string.h"
3 #include <stdio.h>
4 #else
5 #include <linux/string.h>
6 #include <linux/slab.h>
7 #endif
8 #include "MsTypes.h"
9 #include "utopia_dapi.h"
10 #include "drvBDMA.h"
11 #include "drvBDMA_private.h"
12 #include "MsOS.h"
13 #if (BDMA_UTOPIA20)
14 #include "utopia.h"
15 #endif
16
17 #include "ULog.h"
18
19 #define TAG_BDMA "BDMA"
20
21 enum
22 {
23 BDMA_POOL_ID_BDMA0=0
24 } eBdmaPoolID;
25
26 // this func will be call to init by utopia20 framework
BDMARegisterToUtopia(FUtopiaOpen ModuleType)27 void BDMARegisterToUtopia(FUtopiaOpen ModuleType)
28 {
29 // 1. deal with module
30 void* pUtopiaModule = NULL;
31 UtopiaModuleCreate(MODULE_BDMA, 8, &pUtopiaModule);
32 UtopiaModuleRegister(pUtopiaModule);
33 // register func for module, after register here, then ap call UtopiaOpen/UtopiaIoctl/UtopiaClose can call to these registered standard func
34 UtopiaModuleSetupFunctionPtr(pUtopiaModule, (FUtopiaOpen)BDMAOpen, (FUtopiaClose)BDMAClose, (FUtopiaIOctl)BDMAIoctl);
35
36 #if defined(MSOS_TYPE_LINUX_KERNEL)
37 UtopiaModuleSetupSTRFunctionPtr(pUtopiaModule,(FUtopiaSTR)BDMAStr);
38 //UtopiaModuleSetSTRPrivate(pUtopiaModule, STRPrivateDataSize);
39 #endif
40
41 // 2. deal with resource
42 void* psResource = NULL;
43 // start func to add res, call once will create 2 access in resource. Also can declare BDMA_POOL_ID_BDMA1 for another channel depend on driver owner.
44 UtopiaModuleAddResourceStart(pUtopiaModule, BDMA_POOL_ID_BDMA0);
45 // resource can alloc private for internal use, ex, BDMA_RESOURCE_PRIVATE
46 UtopiaResourceCreate("bdma0", sizeof(BDMA_RESOURCE_PRIVATE), &psResource);
47 // func to reg res
48 UtopiaResourceRegister(pUtopiaModule, psResource, BDMA_POOL_ID_BDMA0);
49
50 // when there are 2 ch bdma, call UtopiaResourceCreate for BDMA_POOL_ID_BDMA0 again, then we have 2 resource.
51 #if 0
52 psResource = (UTOPIA_RESOURCE*)UtopiaResourceCreate("bdma1", sizeof(BDMA_RESOURCE_PRIVATE));
53 // func to reg res
54 UtopiaResourceRegister(pUtopiaModule, psResource, BDMA_POOL_ID_BDMA0);
55 #endif
56 // end function to add res
57 UtopiaModuleAddResourceEnd(pUtopiaModule, BDMA_POOL_ID_BDMA0);
58 }
59
BDMAOpen(void ** ppInstance,MS_U32 u32ModuleVersion,void * pAttribute)60 MS_U32 BDMAOpen(void** ppInstance, MS_U32 u32ModuleVersion, void* pAttribute)
61 {
62 BDMA_INSTANT_PRIVATE *pBdmaPri = NULL;
63 void *pBdmaPriVoid = NULL;
64 //printf("\n[BDMA INFO] bdma open");
65 //UTOPIA_TRACE(MS_UTOPIA_DB_LEVEL_TRACE,printf("enter %s %d\n",__FUNCTION__,__LINE__));
66 // instance is allocated here, also can allocate private for internal use, ex, BDMA_INSTANT_PRIVATE
67 UtopiaInstanceCreate(sizeof(BDMA_INSTANT_PRIVATE), ppInstance);
68 // setup func in private and assign the calling func in func ptr in instance private
69 UtopiaInstanceGetPrivate(*ppInstance, &pBdmaPriVoid);
70 pBdmaPri = (BDMA_INSTANT_PRIVATE*)pBdmaPriVoid;
71 pBdmaPri->fpBDMAMemCpy = (IOCTL_BDMA_MEMCPY)_MDrv_BDMA_MemCopy;
72 pBdmaPri->fpBDMASearch = (IOCTL_BDMA_SEARCH)_MDrv_BDMA_Search;
73 pBdmaPri->fpBDMACRC32 = (IOCTL_BDMA_CRC32)_MDrv_BDMA_CRC32;
74 pBdmaPri->fpBDMAPatternFill = (IOCTL_BDMA_PATTERN_FILL)_MDrv_BDMA_PatternFill;
75 pBdmaPri->fpBDMAFlashCopy2Dram = (IOCTL_BDMA_FLASHCOPY2DRAM)_MDrv_BDMA_FlashCopy2Dram;
76 #ifdef MOBF_ENABLE
77 //if (u32ModuleVersion == 0x00010001)
78 {
79 pBdmaPri->fpBDMAMOBFSearch = (IOCTL_BDMA_MOBFSEARCH)_MDrv_BDMA_MOBFSearch;
80 }
81 //else (u32ModuleVersion == 0x00010002)
82 {
83 //pBdmaPri->fpBDMAMOBFSearch = (IOCTL_BDMA_MOBFSEARCH)MDrv_BDMA_MOBFSearch_V2;
84 }
85 #endif
86 pBdmaPri->fpBDMAGetStatus = (IOCTL_BDMA_GETSTATUS)_MDrv_BDMA_GetStatus;
87 pBdmaPri->fpBDMAGetInfo = (IOCTL_BDMA_GETINFO)MDrv_BDMA_GetInfo;
88 pBdmaPri->fpBDMAGetLibVer = (IOCTL_BDMA_GETLIBVER)MDrv_BDMA_GetLibVer;
89 pBdmaPri->fpBDMAGetMinSize = (IOCTL_BDMA_GETMINSIZE)MDrv_BDMA_GetMinSize;
90 pBdmaPri->fpBDMASetDbgLevel = (IOCTL_BDMA_SETDBGLEVEL)MDrv_BDMA_SetDbgLevel;
91 pBdmaPri->fpBDMASetSPIOffsetForMCU = (IOCTL_BDMA_SETSPIOFFSETFORMCU)_MDrv_BDMA_SetSPIOffsetForMCU;
92 pBdmaPri->fpBDMAWaitFlashDone = (IOCTL_BDMA_WAITFLASHDONE)_MDrv_BDMA_WaitFlashDone;
93 pBdmaPri->fpBDMAInit = (IOCTL_BDMA_INIT)_MDrv_BDMA_Init;
94 pBdmaPri->fpBDMACopyHnd = (IOCTL_BDMA_COPYHND)_MDrv_BDMA_CopyHnd;
95
96 return UTOPIA_STATUS_SUCCESS;
97 }
98
99 // FIXME: why static?
BDMAIoctl(void * pInstance,MS_U32 u32Cmd,void * pArgs)100 MS_U32 BDMAIoctl(void* pInstance, MS_U32 u32Cmd, void* pArgs)
101 {
102 void* pModule = NULL;
103 UtopiaInstanceGetModule(pInstance, &pModule);
104 void* pResource = NULL;
105 PBDMA_MEMCOPY_PARAM pMemCpyParam = NULL;
106 PBDMA_SEARCH_PARAM pSearchParam = NULL;
107 PBDMA_CRC32_PARAM pCRC32Param = NULL;
108 PBDMA_PATTERN_FILL_PARAM pPattFillParam = NULL;
109 PBDMA_FLASHCOPY2DRAM_PARAM pFlash2DramParam = NULL;
110 #ifdef MOBF_ENABLE
111 PBDMA_MOBFSEARCH_PARAM pMOBFSearchParam = NULL;
112 #endif
113 PBDMA_GETSTATUS_PARAM pGetStatusParam = NULL;
114 PBDMA_GETINFO_PARAM pGetInfoParam = NULL;
115 PBDMA_GETLIBVER_PARAM pGetLibVerParam = NULL;
116 PBDMA_GETMINSIZE_PARAM pGetMinSize = NULL;
117 PBDMA_SETDBGLEVEL_PARAM pSetDbgLevelParam = NULL;
118 BDMA_Info *pBDMAInfo;
119 MS_U32 u32Ret;
120 MS_PHY phy64SearchAddr;
121 MS_U32 u32CRC32;
122
123 //utopia_secure_check(pInstant->pPrivate); // FIXME: check what?
124
125
126 BDMA_INSTANT_PRIVATE* psBDMAInstPri = NULL;
127 void* psBDMAInstPriVoid = NULL;
128 UtopiaInstanceGetPrivate(pInstance, (void**)&psBDMAInstPriVoid);
129 psBDMAInstPri = (BDMA_INSTANT_PRIVATE*)psBDMAInstPriVoid;
130
131 switch(u32Cmd)
132 {
133 case MDrv_CMD_BDMA_Init:
134 {
135 if (NULL == pArgs)
136 return UTOPIA_STATUS_PARAMETER_ERROR;
137
138 PBDMA_INIT_PARAM pParam = (PBDMA_INIT_PARAM)pArgs;
139 u32Ret = psBDMAInstPri->fpBDMAInit(pParam->u64Miu1Base);
140 if (E_BDMA_OK == u32Ret)
141 return UTOPIA_STATUS_SUCCESS;
142 else
143 return UTOPIA_STATUS_FAIL;
144 }
145 case MDrv_CMD_BDMA_CopyHnd:
146 {
147 if (NULL == pArgs)
148 return UTOPIA_STATUS_PARAMETER_ERROR;
149
150 PBDMA_COPYHND_PARAM pParam = (PBDMA_COPYHND_PARAM)pArgs;
151 u32Ret = psBDMAInstPri->fpBDMACopyHnd(pParam->phy64SrcAddr, pParam->phy64DstAddr, pParam->u32Len, pParam->eCpyType, pParam->u8OpCfg);
152 if (E_BDMA_OK == u32Ret)
153 return UTOPIA_STATUS_SUCCESS;
154 else
155 return UTOPIA_STATUS_FAIL;
156 }
157 case MDrv_CMD_BDMA_MemCopy:
158 //printf("BDMAIoctl - MDrv_CMD_BDMA_MemCopy\n");
159 if (NULL == pArgs)
160 return UTOPIA_STATUS_PARAMETER_ERROR;
161 pMemCpyParam = (PBDMA_MEMCOPY_PARAM)pArgs;
162 // when calling func occpuy h/w, need to call UtopiaResourceObtainToInstant to obtain res to lock other process
163 if(UtopiaResourceObtain(pModule, BDMA_POOL_ID_BDMA0, &pResource) != 0)
164 {
165 ULOGE(TAG_BDMA, "UtopiaResourceObtainToInstant fail\n");
166 return UTOPIA_STATUS_ERR_RESOURCE;
167 }
168 u32Ret = psBDMAInstPri->fpBDMAMemCpy(pMemCpyParam->phy64SrcAddr,pMemCpyParam->phy64DstAddr, pMemCpyParam->u32Len);
169 UtopiaResourceRelease(pResource);
170 if (E_BDMA_OK == u32Ret)
171 return UTOPIA_STATUS_SUCCESS;
172 else
173 return UTOPIA_STATUS_FAIL;
174 case MDrv_CMD_BDMA_Search:
175 //printf("BDMAIoctl - MDrv_CMD_BDMA_Search\n");
176 if (NULL == pArgs)
177 return UTOPIA_STATUS_PARAMETER_ERROR;
178 pSearchParam = (PBDMA_SEARCH_PARAM)pArgs;
179 if(UtopiaResourceObtain(pModule, BDMA_POOL_ID_BDMA0, &pResource) != 0)
180 {
181 ULOGE(TAG_BDMA, "UtopiaResourceObtainToInstant fail\n");
182 return UTOPIA_STATUS_ERR_RESOURCE;
183 }
184 phy64SearchAddr = psBDMAInstPri->fpBDMASearch(pSearchParam->u32Addr, pSearchParam->u32Len, pSearchParam->u32Pattern, pSearchParam->u32ExcluBit, pSearchParam->eDev);
185 pSearchParam->pSearchAddr = phy64SearchAddr;
186 UtopiaResourceRelease(pResource);
187 if (0xFFFFFFFF != phy64SearchAddr)
188 return UTOPIA_STATUS_SUCCESS;
189 else
190 return UTOPIA_STATUS_FAIL;
191 case MDrv_CMD_BDMA_CRC32:
192 //printf("BDMAIoctl - MDrv_CMD_BDMA_CRC32\n");
193 if (NULL == pArgs)
194 return UTOPIA_STATUS_PARAMETER_ERROR;
195 pCRC32Param = (PBDMA_CRC32_PARAM)pArgs;
196 if(UtopiaResourceObtain(pModule, BDMA_POOL_ID_BDMA0, &pResource) != 0)
197 {
198 ULOGE(TAG_BDMA, "UtopiaResourceObtainToInstant fail\n");
199 return UTOPIA_STATUS_ERR_RESOURCE;
200 }
201 u32CRC32 = psBDMAInstPri->fpBDMACRC32(pCRC32Param->phy64Addr,pCRC32Param->u32Len,pCRC32Param->u32Poly,pCRC32Param->u32Seed,pCRC32Param->eDev,pCRC32Param->bReflect);
202 UtopiaResourceRelease(pResource);
203 pCRC32Param->u32CRC32 = u32CRC32;
204 if (0xFFFFFFFF != u32CRC32)
205 return UTOPIA_STATUS_SUCCESS;
206 else
207 return UTOPIA_STATUS_FAIL;
208 case MDrv_CMD_BDMA_Pattern_Fill:
209 //printf("BDMAIoctl - MDrv_CMD_BDMA_Pattern_Fill\n");
210 if (NULL == pArgs)
211 return UTOPIA_STATUS_PARAMETER_ERROR;
212 pPattFillParam = (PBDMA_PATTERN_FILL_PARAM)pArgs;
213 if(UtopiaResourceObtain(pModule, BDMA_POOL_ID_BDMA0, &pResource) != 0)
214 {
215 ULOGE(TAG_BDMA, "UtopiaResourceObtainToInstant fail\n");
216 return UTOPIA_STATUS_ERR_RESOURCE;
217 }
218 u32Ret = psBDMAInstPri->fpBDMAPatternFill(pPattFillParam->u32Addr,pPattFillParam->u32Len,pPattFillParam->u32Pattern,pPattFillParam->eDev);
219 UtopiaResourceRelease(pResource);
220 if (E_BDMA_OK == u32Ret)
221 return UTOPIA_STATUS_SUCCESS;
222 else
223 return UTOPIA_STATUS_FAIL;
224 case MDrv_CMD_BDMA_FlashCopy2Dram:
225 //printf("BDMAIoctl - MDrv_CMD_BDMA_FlashCopy2Dram\n");
226 if (NULL == pArgs)
227 return UTOPIA_STATUS_PARAMETER_ERROR;
228 pFlash2DramParam = (PBDMA_FLASHCOPY2DRAM_PARAM)pArgs;
229 if(UtopiaResourceObtain(pModule, BDMA_POOL_ID_BDMA0, &pResource) != 0)
230 {
231 ULOGE(TAG_BDMA, "UtopiaResourceObtainToInstant fail\n");
232 return UTOPIA_STATUS_ERR_RESOURCE;
233 }
234 u32Ret = psBDMAInstPri->fpBDMAFlashCopy2Dram(pFlash2DramParam->u32FlashAddr,pFlash2DramParam->u32DramAddr,pFlash2DramParam->u32Len);
235 UtopiaResourceRelease(pResource);
236 if (E_BDMA_OK == u32Ret)
237 return UTOPIA_STATUS_SUCCESS;
238 else
239 return UTOPIA_STATUS_FAIL;
240 case MDrv_CMD_BDMA_MOBFSearch:
241 #ifdef MOBF_ENABLE
242 printf("BDMAIoctl - MDrv_CMD_BDMA_MOBFSearch\n");
243 if (NULL == pArgs)
244 return UTOPIA_STATUS_PARAMETER_ERROR;
245 pMOBFSearchParam = (PBDMA_MOBFSEARCH_PARAM)pArgs;
246 if(UtopiaResourceObtain(pModule, BDMA_POOL_ID_BDMA0, &pResource) != 0)
247 {
248 ULOGE(TAG_BDMA, "UtopiaResourceObtainToInstant fail\n");
249 return UTOPIA_STATUS_ERR_RESOURCE;
250 }
251 phy64SearchAddr = psBDMAInstPri->fpBDMAMOBFSearch(pMOBFSearchParam->phy64Addr,pMOBFSearchParam->u32Len,pMOBFSearchParam->pMobfPsCfg,pMOBFSearchParam->eDev);
252 UtopiaResourceRelease(pResource);
253 pMOBFSearchParam->phy64SearchAddr = phy64SearchAddr;
254 if (0xFFFFFFFF != phy64SearchAddr)
255 return UTOPIA_STATUS_SUCCESS;
256 else
257 return UTOPIA_STATUS_FAIL;
258 #else
259 return UTOPIA_STATUS_FAIL;
260 #endif
261 case MDrv_CMD_BDMA_GetStatus:
262 //printf("BDMAIoctl - MDrv_CMD_BDMA_GetStatus\n");
263 if (NULL == pArgs)
264 return UTOPIA_STATUS_PARAMETER_ERROR;
265 pGetStatusParam = (PBDMA_GETSTATUS_PARAM)pArgs;
266 if(UtopiaResourceObtain(pModule, BDMA_POOL_ID_BDMA0, &pResource) != 0)
267 {
268 ULOGE(TAG_BDMA, "UtopiaResourceObtainToInstant fail\n");
269 return UTOPIA_STATUS_ERR_RESOURCE;
270 }
271 psBDMAInstPri->fpBDMAGetStatus(pGetStatusParam->pStatus);
272 UtopiaResourceRelease(pResource);
273 return UTOPIA_STATUS_SUCCESS;
274 case MDrv_CMD_BDMA_GetInfo:
275 //printf("BDMAIoctl - MDrv_CMD_BDMA_GetInfo\n");
276 if (NULL == pArgs)
277 return UTOPIA_STATUS_PARAMETER_ERROR;
278 // this function won't occupy h/w, so don't need to call UtopiaResourceObtainToInstant
279 pGetInfoParam = (PBDMA_GETINFO_PARAM)pArgs;
280 pBDMAInfo = psBDMAInstPri->fpBDMAGetInfo();
281 memcpy (pGetInfoParam,pBDMAInfo,sizeof(BDMA_Info));
282 return UTOPIA_STATUS_SUCCESS;
283 case MDrv_CMD_BDMA_GetLibVer:
284 //printf("BDMAIoctl - MDrv_CMD_BDMA_GetLibVer\n");
285 if (NULL == pArgs)
286 return UTOPIA_STATUS_PARAMETER_ERROR;
287 pGetLibVerParam = (PBDMA_GETLIBVER_PARAM)pArgs;
288 u32Ret = psBDMAInstPri->fpBDMAGetLibVer(pGetLibVerParam->ppVersion);
289 if (E_BDMA_OK == u32Ret)
290 return UTOPIA_STATUS_SUCCESS;
291 else
292 return UTOPIA_STATUS_FAIL;
293 case MDrv_CMD_BDMA_GetMinSize:
294 //printf("BDMAIoctl - MDrv_CMD_BDMA_GetMinSize\n");
295 if (NULL == pArgs)
296 return UTOPIA_STATUS_PARAMETER_ERROR;
297 pGetMinSize = (PBDMA_GETMINSIZE_PARAM)pArgs;
298 pGetMinSize->u32MinSize = (MS_U32)psBDMAInstPri->fpBDMAGetMinSize();
299 return UTOPIA_STATUS_SUCCESS;
300 case MDrv_CMD_BDMA_SetDbgLevel:
301 //printf("BDMAIoctl - MDrv_CMD_BDMA_SetDbgLevel\n");
302 if (NULL == pArgs)
303 return UTOPIA_STATUS_PARAMETER_ERROR;
304 pSetDbgLevelParam = (PBDMA_SETDBGLEVEL_PARAM)pArgs;
305 psBDMAInstPri->fpBDMASetDbgLevel(pSetDbgLevelParam->eLevel);
306 return UTOPIA_STATUS_SUCCESS;
307 case MDrv_CMD_BDMA_SetSPIOffsetForMCU:
308 //printf("BDMAIoctl - MDrv_CMD_BDMA_SetSPIOffsetForMCU\n");
309 if(UtopiaResourceObtain(pModule, BDMA_POOL_ID_BDMA0, &pResource) != 0)
310 {
311 ULOGE(TAG_BDMA, "UtopiaResourceObtainToInstant fail\n");
312 return UTOPIA_STATUS_ERR_RESOURCE;
313 }
314 psBDMAInstPri->fpBDMASetSPIOffsetForMCU();
315 UtopiaResourceRelease(pResource);
316 break;
317 case MDrv_CMD_BDMA_WaitFlashDone:
318 //printf("BDMAIoctl - MDrv_CMD_BDMA_WaitFlashDone\n");
319 if(UtopiaResourceObtain(pModule, BDMA_POOL_ID_BDMA0, &pResource) != 0)
320 {
321 ULOGE(TAG_BDMA, "UtopiaResourceObtainToInstant fail\n");
322 return UTOPIA_STATUS_ERR_RESOURCE;
323 }
324 u32Ret = (MS_U32)psBDMAInstPri->fpBDMAWaitFlashDone();
325 UtopiaResourceRelease(pResource);
326 if (E_BDMA_OK == u32Ret)
327 return UTOPIA_STATUS_SUCCESS;
328 else
329 return UTOPIA_STATUS_FAIL;
330 default:
331 break;
332 };
333
334 return UTOPIA_STATUS_SUCCESS; // FIXME: error code
335 }
336
BDMAClose(void * pInstance)337 MS_U32 BDMAClose(void* pInstance)
338 {
339 UtopiaInstanceDelete(pInstance);
340
341 return UTOPIA_STATUS_SUCCESS;
342 }
343
BDMAStr(MS_U32 u32PowerState,void * pModule)344 MS_U32 BDMAStr(MS_U32 u32PowerState, void* pModule)
345 {
346 MS_U32 u32Return = UTOPIA_STATUS_FAIL;
347
348 //UtopiaModuleGetSTRPrivate(pModule, (void**));
349
350 if (u32PowerState == E_POWER_SUSPEND)
351 {
352 /* Please Implement Module Suspend Flow Here. */
353 u32Return = UTOPIA_STATUS_SUCCESS;//SUSPEND_OK;
354 }
355 else if (u32PowerState == E_POWER_RESUME)
356 {
357 /* Please Implement Module Resume Flow Here. */
358 u32Return = UTOPIA_STATUS_SUCCESS;//RESUME_OK;
359 }
360 else
361 {
362 u32Return = UTOPIA_STATUS_FAIL;
363 }
364 return u32Return;// for success
365 }
366