1 #include "MsTypes.h"
2 #ifdef MSOS_TYPE_LINUX_KERNEL
3 #include <linux/module.h> /* Needed by all modules */
4 #include <linux/kernel.h>
5 #else
6 #include <stdio.h>
7 #endif
8 #include "utopia_dapi.h"
9 #include "utopia.h"
10 #include "drvMIU.h"
11 #include "drvMIU_private.h"
12 #include "MsOS.h"
13 #include "ULog.h"
14
15 #define MIUDBG(x)
16 #define TAG_MIU "MIU"
17
18 enum
19 {
20 MIU_POOL_ID_MIU0=0
21 } eMIUPoolID;
22
23 // this func will be call to init by utopia20 framework
MIURegisterToUtopia(FUtopiaOpen ModuleType)24 void MIURegisterToUtopia(FUtopiaOpen ModuleType)
25 {
26 // 1. deal with module
27 void* pUtopiaModule = NULL;
28 UtopiaModuleCreate(MODULE_MIU, 8, &pUtopiaModule);
29 UtopiaModuleRegister(pUtopiaModule);
30 // register func for module, after register here, then ap call UtopiaOpen/UtopiaIoctl/UtopiaClose can call to these registered standard func
31 UtopiaModuleSetupFunctionPtr(pUtopiaModule, (FUtopiaOpen)MIUOpen, (FUtopiaClose)MIUClose, (FUtopiaIOctl)MIUIoctl);
32
33 // 2. deal with resource
34 void* psResource = NULL;
35 // start func to add res, call once will create 2 access in resource.
36 UtopiaModuleAddResourceStart(pUtopiaModule, MIU_POOL_ID_MIU0);
37 // resource can alloc private for internal use, ex, MIU_RESOURCE_PRIVATE
38 UtopiaResourceCreate("miu0", sizeof(MIU_RESOURCE_PRIVATE), &psResource);
39 // func to reg res
40 UtopiaResourceRegister(pUtopiaModule, psResource, MIU_POOL_ID_MIU0);
41
42 // end function to add res
43 UtopiaModuleAddResourceEnd(pUtopiaModule, MIU_POOL_ID_MIU0);
44 // MIURegisterToUtopia only call once, so driver init code can put here,
45 //MDrv_MIU_Init();
46 }
47
MIUOpen(void ** ppInstance,MS_U32 u32ModuleVersion,void * pAttribute)48 MS_U32 MIUOpen(void** ppInstance, MS_U32 u32ModuleVersion, void* pAttribute)
49 {
50 MIU_INSTANT_PRIVATE *pMIUPri = NULL;
51 void *pMIUPriVoid = NULL;
52 ULOGD(TAG_MIU, "\n[MIU INFO] miu open");
53 //UTOPIA_TRACE(MS_UTOPIA_DB_LEVEL_TRACE,printf("enter %s %d\n",__FUNCTION__,__LINE__));
54 // instance is allocated here, also can allocate private for internal use, ex, MIU_INSTANT_PRIVATE
55 UtopiaInstanceCreate(sizeof(MIU_INSTANT_PRIVATE), ppInstance);
56 // setup func in private and assign the calling func in func ptr in instance private
57 UtopiaInstanceGetPrivate(*ppInstance, &pMIUPriVoid);
58 pMIUPri = (MIU_INSTANT_PRIVATE*)pMIUPriVoid;
59
60 pMIUPri->fpMIU_Init = (IOCTL_MIU_INIT)_MDrv_MIU_Init;
61 pMIUPri->fpMIU_Mask_Req_OPM_R = (IOCTL_MIU_MASK_IP)_MDrv_MIU_Mask_Req_OPM_R;
62 pMIUPri->fpMIU_Mask_Req_DNRB_R = (IOCTL_MIU_MASK_IP)_MDrv_MIU_Mask_Req_DNRB_R;
63 pMIUPri->fpMIU_Mask_Req_DNRB_W = (IOCTL_MIU_MASK_IP)_MDrv_MIU_Mask_Req_DNRB_W;
64 pMIUPri->fpMIU_Mask_Req_DNRB_RW = (IOCTL_MIU_MASK_IP)_MDrv_MIU_Mask_Req_DNRB_RW;
65 pMIUPri->fpMIU_Mask_Req_SC_RW = (IOCTL_MIU_MASK_IP)_MDrv_MIU_Mask_Req_SC_RW;
66 pMIUPri->fpMIU_Mask_Req_MVOP_R = (IOCTL_MIU_MASK_IP)_MDrv_MIU_Mask_Req_MVOP_R;
67 pMIUPri->fpMIU_Mask_Req_MVD_R = (IOCTL_MIU_MASK_IP)_MDrv_MIU_Mask_Req_MVD_R;
68 pMIUPri->fpMIU_Mask_Req_MVD_W = (IOCTL_MIU_MASK_IP)_MDrv_MIU_Mask_Req_MVD_W;
69 pMIUPri->fpMIU_Mask_Req_MVD_RW = (IOCTL_MIU_MASK_IP)_MDrv_MIU_Mask_Req_MVD_RW;
70 pMIUPri->fpMIU_Mask_Req_AUDIO_RW = (IOCTL_MIU_MASK_IP)_MDrv_MIU_Mask_Req_AUDIO_RW;
71 pMIUPri->fpMIU_Mask_Req = (IOCTL_MIU_MASK_REQ)_MDrv_MIU_MaskReq;
72 pMIUPri->fpMIU_UnMask_Req = (IOCTL_MIU_MASK_REQ)_MDrv_MIU_UnMaskReq;
73 pMIUPri->fpMIU_SetSsc = (IOCTL_MIU_SET_SSC)_MDrv_MIU_SetSsc;
74 pMIUPri->fpMIU_SetSscValue = (IOCTL_MIU_SET_SSCVALUE)_MDrv_MIU_SetSscValue;
75 pMIUPri->fpMIU_Protect = (IOCTL_MIU_PROTECT)_MDrv_MIU_Protect;
76 pMIUPri->fpMIU_ProtectEx = (IOCTL_MIU_PROTECTEx)_MDrv_MIU_ProtectEx;
77 pMIUPri->fpMIU_SelMIU = (IOCTL_MIU_SELMIU)_MDrv_MIU_SelMIU;
78 pMIUPri->fpMIU_GetProtectInfo = (IOCTL_MIU_GETPROTECTINFO)_MDrv_MIU_GetProtectInfo;
79 pMIUPri->fpMIU_SetGroupPriority = (IOCTL_MIU_SETGROUPPRIORITY)_MDrv_MIU_SetGroupPriority;
80 pMIUPri->fpMIU_SetHighPriority = (IOCTL_MIU_SETHIGHPRIORITY)_MDrv_MIU_SetHPriorityMask;
81 pMIUPri->fpMIU_PrintProtectInfo = (IOCTL_MIU_PRINTPROTECTINFO)_MDrv_MIU_PrintProtectInfo;
82 pMIUPri->fpMIU_Dram_Size = (IOCTL_MIU_DRAM_SIZE)_MDrv_MIU_Dram_Size;
83 pMIUPri->fpMIU_ProtectAlign = (IOCTL_MIU_PROTECTALIGN)_MDrv_MIU_ProtectAlign;
84 pMIUPri->fpMIU_GetDramType = (IOCTL_MIU_GETDRAMTYPE)_MDrv_MIU_GetDramType;
85
86 return UTOPIA_STATUS_SUCCESS;
87 }
88
89 // FIXME: why static?
MIUIoctl(void * pInstance,MS_U32 u32Cmd,void * pArgs)90 MS_U32 MIUIoctl(void* pInstance, MS_U32 u32Cmd, void* pArgs)
91 {
92 void* pModule = NULL;
93 UtopiaInstanceGetModule(pInstance, &pModule);
94 void* pResource = NULL;
95 PMIU_MIU_MASK pMIUMask;
96 PMIU_MIUREQ_MASK pMIUMaskReq;
97 PMIU_SET_SSC pMIUSetSsc;
98 PMIU_SET_SSCVALUE pMIUSetSscValue;
99 PMIU_PROTECT pMIUProtect;
100 PMIU_PROTECTEx pMIUProtectEx;
101 PMIU_SELMIU pMIUSelMIU;
102 PMIU_GETPROTECTINFO pMIUGetProtectInfo;
103 PMIU_SETGROUPPRIORITY pMIUSetGroupPri;
104 PMIU_SETHIGHPRIORITY pMIUSetHighPri;
105 PMIU_DRAM_SIZE pMIUDramSizePri;
106 PMIU_PROTECT_ALIGN pMIUProtectAlignPri;
107 PMIU_GETDRAMTYPE pMIUGetDramTypePri;
108 MS_BOOL bRet = FALSE;
109 //MS_U32 u32Ret;
110
111 //utopia_secure_check(pInstant->pPrivate); // FIXME: check what?
112
113 //if (NULL == pArgs)
114 // return UTOPIA_STATUS_PARAMETER_ERROR;
115
116 MIU_INSTANT_PRIVATE* psMIUInstPri = NULL;
117 void* psMIUInstPriVoid = NULL;
118 UtopiaInstanceGetPrivate(pInstance, (void**)&psMIUInstPriVoid);
119 psMIUInstPri = (MIU_INSTANT_PRIVATE*)psMIUInstPriVoid;
120
121 switch(u32Cmd)
122 {
123 case MDrv_CMD_MIU_Init:
124 MIUDBG("MIUIoctl - MDrv_CMD_MIU_Init\n");
125 // when calling func occpuy h/w, need to call UtopiaResourceObtainToInstant to obtain res to lock other process
126 if(UtopiaResourceObtain(pModule, MIU_POOL_ID_MIU0, &pResource) != 0)
127 {
128 ULOGE(TAG_MIU, "UtopiaResourceObtainToInstant fail\n");
129 return UTOPIA_STATUS_ERR_RESOURCE;
130 }
131 bRet = psMIUInstPri->fpMIU_Init();
132 UtopiaResourceRelease(pResource);
133 if (TRUE == bRet)
134 return UTOPIA_STATUS_SUCCESS;
135 else
136 return UTOPIA_STATUS_FAIL;
137
138 case MDrv_CMD_MIU_Mask_Req_OPM_R:
139 MIUDBG("MIUIoctl - MDrv_CMD_MIU_Mask_Req_OPM_R\n");
140 pMIUMask = (PMIU_MIU_MASK)pArgs;
141 // when calling func occpuy h/w, need to call UtopiaResourceObtainToInstant to obtain res to lock other process
142 if(UtopiaResourceObtain(pModule, MIU_POOL_ID_MIU0, &pResource) != 0)
143 {
144 ULOGE(TAG_MIU, "UtopiaResourceObtainToInstant fail\n");
145 return UTOPIA_STATUS_ERR_RESOURCE;
146 }
147 psMIUInstPri->fpMIU_Mask_Req_OPM_R(pMIUMask->u8Mask,pMIUMask->u8Miu);
148 UtopiaResourceRelease(pResource);
149 return UTOPIA_STATUS_SUCCESS;
150
151 case MDrv_CMD_MIU_Mask_Req_DNRB_R:
152 MIUDBG("MIUIoctl - MDrv_CMD_MIU_Mask_Req_DNRB_R\n");
153 pMIUMask = (PMIU_MIU_MASK)pArgs;
154 // when calling func occpuy h/w, need to call UtopiaResourceObtainToInstant to obtain res to lock other process
155 if(UtopiaResourceObtain(pModule, MIU_POOL_ID_MIU0, &pResource) != 0)
156 {
157 ULOGE(TAG_MIU, "UtopiaResourceObtainToInstant fail\n");
158 return UTOPIA_STATUS_ERR_RESOURCE;
159 }
160 psMIUInstPri->fpMIU_Mask_Req_DNRB_R(pMIUMask->u8Mask,pMIUMask->u8Miu);
161 UtopiaResourceRelease(pResource);
162 return UTOPIA_STATUS_SUCCESS;
163
164 case MDrv_CMD_MIU_Mask_Req_DNRB_W:
165 MIUDBG("MIUIoctl - MDrv_CMD_MIU_Mask_Req_DNRB_W\n");
166 pMIUMask = (PMIU_MIU_MASK)pArgs;
167 // when calling func occpuy h/w, need to call UtopiaResourceObtainToInstant to obtain res to lock other process
168 if(UtopiaResourceObtain(pModule, MIU_POOL_ID_MIU0, &pResource) != 0)
169 {
170 ULOGE(TAG_MIU, "UtopiaResourceObtainToInstant fail\n");
171 return UTOPIA_STATUS_ERR_RESOURCE;
172 }
173 psMIUInstPri->fpMIU_Mask_Req_DNRB_W(pMIUMask->u8Mask,pMIUMask->u8Miu);
174 UtopiaResourceRelease(pResource);
175 return UTOPIA_STATUS_SUCCESS;
176
177 case MDrv_CMD_MIU_Mask_Req_DNRB_RW:
178 MIUDBG("MIUIoctl - MDrv_CMD_MIU_Mask_Req_DNRB_RW\n");
179 pMIUMask = (PMIU_MIU_MASK)pArgs;
180 // when calling func occpuy h/w, need to call UtopiaResourceObtainToInstant to obtain res to lock other process
181 if(UtopiaResourceObtain(pModule, MIU_POOL_ID_MIU0, &pResource) != 0)
182 {
183 ULOGE(TAG_MIU, "UtopiaResourceObtainToInstant fail\n");
184 return UTOPIA_STATUS_ERR_RESOURCE;
185 }
186 psMIUInstPri->fpMIU_Mask_Req_DNRB_RW(pMIUMask->u8Mask,pMIUMask->u8Miu);
187 UtopiaResourceRelease(pResource);
188 return UTOPIA_STATUS_SUCCESS;
189
190 case MDrv_CMD_MIU_Mask_Req_SC_RW:
191 MIUDBG("MIUIoctl - MDrv_CMD_MIU_Mask_Req_SC_RW\n");
192 pMIUMask = (PMIU_MIU_MASK)pArgs;
193 // when calling func occpuy h/w, need to call UtopiaResourceObtainToInstant to obtain res to lock other process
194 if(UtopiaResourceObtain(pModule, MIU_POOL_ID_MIU0, &pResource) != 0)
195 {
196 ULOGE(TAG_MIU, "UtopiaResourceObtainToInstant fail\n");
197 return UTOPIA_STATUS_ERR_RESOURCE;
198 }
199 psMIUInstPri->fpMIU_Mask_Req_SC_RW(pMIUMask->u8Mask,pMIUMask->u8Miu);
200 UtopiaResourceRelease(pResource);
201 return UTOPIA_STATUS_SUCCESS;
202
203 case MDrv_CMD_MIU_Mask_Req_MVOP_R:
204 MIUDBG("MIUIoctl - MDrv_CMD_MIU_Mask_Req_MVOP_R\n");
205 pMIUMask = (PMIU_MIU_MASK)pArgs;
206 // when calling func occpuy h/w, need to call UtopiaResourceObtainToInstant to obtain res to lock other process
207 if(UtopiaResourceObtain(pModule, MIU_POOL_ID_MIU0, &pResource) != 0)
208 {
209 ULOGE(TAG_MIU, "UtopiaResourceObtainToInstant fail\n");
210 return UTOPIA_STATUS_ERR_RESOURCE;
211 }
212 psMIUInstPri->fpMIU_Mask_Req_MVOP_R(pMIUMask->u8Mask,pMIUMask->u8Miu);
213 UtopiaResourceRelease(pResource);
214 return UTOPIA_STATUS_SUCCESS;
215
216 case MDrv_CMD_MIU_Mask_Req_MVD_R:
217 MIUDBG("MIUIoctl - MDrv_CMD_MIU_Mask_Req_MVD_R\n");
218 pMIUMask = (PMIU_MIU_MASK)pArgs;
219 // when calling func occpuy h/w, need to call UtopiaResourceObtainToInstant to obtain res to lock other process
220 if(UtopiaResourceObtain(pModule, MIU_POOL_ID_MIU0, &pResource) != 0)
221 {
222 ULOGE(TAG_MIU, "UtopiaResourceObtainToInstant fail\n");
223 return UTOPIA_STATUS_ERR_RESOURCE;
224 }
225 psMIUInstPri->fpMIU_Mask_Req_MVD_R(pMIUMask->u8Mask,pMIUMask->u8Miu);
226 UtopiaResourceRelease(pResource);
227 return UTOPIA_STATUS_SUCCESS;
228
229 case MDrv_CMD_MIU_Mask_Req_MVD_W:
230 MIUDBG("MIUIoctl - MDrv_CMD_MIU_Mask_Req_MVD_W\n");
231 pMIUMask = (PMIU_MIU_MASK)pArgs;
232 // when calling func occpuy h/w, need to call UtopiaResourceObtainToInstant to obtain res to lock other process
233 if(UtopiaResourceObtain(pModule, MIU_POOL_ID_MIU0, &pResource) != 0)
234 {
235 ULOGE(TAG_MIU, "UtopiaResourceObtainToInstant fail\n");
236 return UTOPIA_STATUS_ERR_RESOURCE;
237 }
238 psMIUInstPri->fpMIU_Mask_Req_MVD_W(pMIUMask->u8Mask,pMIUMask->u8Miu);
239 UtopiaResourceRelease(pResource);
240 return UTOPIA_STATUS_SUCCESS;
241
242 case MDrv_CMD_MIU_Mask_Req_MVD_RW:
243 MIUDBG("MIUIoctl - MDrv_CMD_MIU_Mask_Req_MVD_RW\n");
244 pMIUMask = (PMIU_MIU_MASK)pArgs;
245 // when calling func occpuy h/w, need to call UtopiaResourceObtainToInstant to obtain res to lock other process
246 if(UtopiaResourceObtain(pModule, MIU_POOL_ID_MIU0, &pResource) != 0)
247 {
248 ULOGE(TAG_MIU, "UtopiaResourceObtainToInstant fail\n");
249 return UTOPIA_STATUS_ERR_RESOURCE;
250 }
251 psMIUInstPri->fpMIU_Mask_Req_MVD_RW(pMIUMask->u8Mask,pMIUMask->u8Miu);
252 UtopiaResourceRelease(pResource);
253 return UTOPIA_STATUS_SUCCESS;
254
255 case MDrv_CMD_MIU_Mask_Req_AUDIO_RW:
256 MIUDBG("MIUIoctl - MDrv_CMD_MIU_Mask_Req_AUDIO_RW\n");
257 pMIUMask = (PMIU_MIU_MASK)pArgs;
258 // when calling func occpuy h/w, need to call UtopiaResourceObtainToInstant to obtain res to lock other process
259 if(UtopiaResourceObtain(pModule, MIU_POOL_ID_MIU0, &pResource) != 0)
260 {
261 ULOGE(TAG_MIU, "UtopiaResourceObtainToInstant fail\n");
262 return UTOPIA_STATUS_ERR_RESOURCE;
263 }
264 psMIUInstPri->fpMIU_Mask_Req_AUDIO_RW(pMIUMask->u8Mask,pMIUMask->u8Miu);
265 UtopiaResourceRelease(pResource);
266 return UTOPIA_STATUS_SUCCESS;
267
268 case MDrv_CMD_MIU_Mask_Req:
269 MIUDBG("MIUIoctl - MDrv_CMD_MIU_Mask_Req\n");
270 pMIUMaskReq = (PMIU_MIUREQ_MASK)pArgs;
271 // when calling func occpuy h/w, need to call UtopiaResourceObtainToInstant to obtain res to lock other process
272 if(UtopiaResourceObtain(pModule, MIU_POOL_ID_MIU0, &pResource) != 0)
273 {
274 ULOGE(TAG_MIU, "UtopiaResourceObtainToInstant fail\n");
275 return UTOPIA_STATUS_ERR_RESOURCE;
276 }
277 psMIUInstPri->fpMIU_Mask_Req(pMIUMaskReq->u8Miu,pMIUMaskReq->eClientID);
278 UtopiaResourceRelease(pResource);
279 return UTOPIA_STATUS_SUCCESS;
280
281 case MDrv_CMD_MIU_UnMask_Req:
282 MIUDBG("MIUIoctl - MDrv_CMD_MIU_UnMask_Req\n");
283 pMIUMaskReq = (PMIU_MIUREQ_MASK)pArgs;
284 // when calling func occpuy h/w, need to call UtopiaResourceObtainToInstant to obtain res to lock other process
285 if(UtopiaResourceObtain(pModule, MIU_POOL_ID_MIU0, &pResource) != 0)
286 {
287 ULOGE(TAG_MIU, "UtopiaResourceObtainToInstant fail\n");
288 return UTOPIA_STATUS_ERR_RESOURCE;
289 }
290 psMIUInstPri->fpMIU_UnMask_Req(pMIUMaskReq->u8Miu,pMIUMaskReq->eClientID);
291 UtopiaResourceRelease(pResource);
292 return UTOPIA_STATUS_SUCCESS;
293
294 case MDrv_CMD_MIU_SetSsc:
295 MIUDBG("MIUIoctl - MDrv_CMD_MIU_SetSsc\n");
296 pMIUSetSsc = (PMIU_SET_SSC)pArgs;
297 // when calling func occpuy h/w, need to call UtopiaResourceObtainToInstant to obtain res to lock other process
298 if(UtopiaResourceObtain(pModule, MIU_POOL_ID_MIU0, &pResource) != 0)
299 {
300 ULOGE(TAG_MIU, "UtopiaResourceObtainToInstant fail\n");
301 return UTOPIA_STATUS_ERR_RESOURCE;
302 }
303 bRet = psMIUInstPri->fpMIU_SetSsc(pMIUSetSsc->u16Fmodulation,pMIUSetSsc->u16FDeviation,pMIUSetSsc->bEnable);
304 pMIUSetSsc->bRet = bRet;
305 UtopiaResourceRelease(pResource);
306 if (TRUE == bRet)
307 return UTOPIA_STATUS_SUCCESS;
308 else
309 return UTOPIA_STATUS_FAIL;
310
311 case MDrv_CMD_MIU_SetSscValue:
312 MIUDBG("MIUIoctl - MDrv_CMD_MIU_SetSscValue\n");
313 pMIUSetSscValue = (PMIU_SET_SSCVALUE)pArgs;
314 // when calling func occpuy h/w, need to call UtopiaResourceObtainToInstant to obtain res to lock other process
315 if(UtopiaResourceObtain(pModule, MIU_POOL_ID_MIU0, &pResource) != 0)
316 {
317 ULOGE(TAG_MIU, "UtopiaResourceObtainToInstant fail\n");
318 return UTOPIA_STATUS_ERR_RESOURCE;
319 }
320 bRet = psMIUInstPri->fpMIU_SetSscValue(pMIUSetSscValue->u8MiuDev,pMIUSetSscValue->u16Fmodulation,pMIUSetSscValue->u16FDeviation,pMIUSetSscValue->bEnable);
321 UtopiaResourceRelease(pResource);
322 if (TRUE == bRet)
323 return UTOPIA_STATUS_SUCCESS;
324 else
325 return UTOPIA_STATUS_FAIL;
326
327 case MDrv_CMD_MIU_Protect:
328 MIUDBG("MIUIoctl - MDrv_CMD_MIU_Protect\n");
329 pMIUProtect = (PMIU_PROTECT)pArgs;
330 // when calling func occpuy h/w, need to call UtopiaResourceObtainToInstant to obtain res to lock other process
331 if(UtopiaResourceObtain(pModule, MIU_POOL_ID_MIU0, &pResource) != 0)
332 {
333 ULOGE(TAG_MIU, "UtopiaResourceObtainToInstant fail\n");
334 return UTOPIA_STATUS_ERR_RESOURCE;
335 }
336 bRet = psMIUInstPri->fpMIU_Protect(pMIUProtect->u8Blockx, pMIUProtect->pu8ProtectId, pMIUProtect->phy64Start, pMIUProtect->phy64End, pMIUProtect->bSetFlag);
337 pMIUProtect->bRet = bRet;
338 UtopiaResourceRelease(pResource);
339 if (TRUE == bRet)
340 return UTOPIA_STATUS_SUCCESS;
341 else
342 return UTOPIA_STATUS_FAIL;
343
344 case MDrv_CMD_MIU_ProtectEx:
345 MIUDBG("MIUIoctl - MDrv_CMD_MIU_ProtectEx\n");
346 pMIUProtectEx = (PMIU_PROTECTEx)pArgs;
347 // when calling func occpuy h/w, need to call UtopiaResourceObtainToInstant to obtain res to lock other process
348 if(UtopiaResourceObtain(pModule, MIU_POOL_ID_MIU0, &pResource) != 0)
349 {
350 printf("UtopiaResourceObtainToInstant fail\n");
351 return UTOPIA_STATUS_ERR_RESOURCE;
352 }
353 bRet = psMIUInstPri->fpMIU_ProtectEx(pMIUProtectEx->u8Blockx, pMIUProtectEx->pu32ProtectId, pMIUProtectEx->phy64Start, pMIUProtectEx->phy64End, pMIUProtectEx->bSetFlag);
354 UtopiaResourceRelease(pResource);
355 if (TRUE == bRet)
356 return UTOPIA_STATUS_SUCCESS;
357 else
358 return UTOPIA_STATUS_FAIL;
359
360 case MDrv_CMD_MIU_SelMIU:
361 MIUDBG("MIUIoctl - MDrv_CMD_MIU_SelMIU\n");
362 pMIUSelMIU = (PMIU_SELMIU)pArgs;
363 // when calling func occpuy h/w, need to call UtopiaResourceObtainToInstant to obtain res to lock other process
364 if(UtopiaResourceObtain(pModule, MIU_POOL_ID_MIU0, &pResource) != 0)
365 {
366 ULOGE(TAG_MIU, "UtopiaResourceObtainToInstant fail\n");
367 return UTOPIA_STATUS_ERR_RESOURCE;
368 }
369 bRet = psMIUInstPri->fpMIU_SelMIU(pMIUSelMIU->eClientID, pMIUSelMIU->eType);
370 UtopiaResourceRelease(pResource);
371 if (TRUE == bRet)
372 return UTOPIA_STATUS_SUCCESS;
373 else
374 return UTOPIA_STATUS_FAIL;
375
376 case MDrv_CMD_MIU_GetProtectInfo:
377 MIUDBG("MIUIoctl - MDrv_CMD_MIU_GetProtectInfo\n");
378 pMIUGetProtectInfo = (PMIU_GETPROTECTINFO)pArgs;
379 // when calling func occpuy h/w, need to call UtopiaResourceObtainToInstant to obtain res to lock other process
380 if(UtopiaResourceObtain(pModule, MIU_POOL_ID_MIU0, &pResource) != 0)
381 {
382 ULOGE(TAG_MIU, "UtopiaResourceObtainToInstant fail\n");
383 return UTOPIA_STATUS_ERR_RESOURCE;
384 }
385 bRet = psMIUInstPri->fpMIU_GetProtectInfo(pMIUGetProtectInfo->u8MiuDev, pMIUGetProtectInfo->pInfo);
386 pMIUGetProtectInfo->bRet = bRet;
387 UtopiaResourceRelease(pResource);
388 if (TRUE == bRet)
389 return UTOPIA_STATUS_SUCCESS;
390 else
391 return UTOPIA_STATUS_FAIL;
392
393 case MDrv_CMD_MIU_SetGroupPriority:
394 MIUDBG("MIUIoctl - MDrv_CMD_MIU_SetGroupPriority\n");
395 pMIUSetGroupPri = (PMIU_SETGROUPPRIORITY)pArgs;
396 // when calling func occpuy h/w, need to call UtopiaResourceObtainToInstant to obtain res to lock other process
397 if(UtopiaResourceObtain(pModule, MIU_POOL_ID_MIU0, &pResource) != 0)
398 {
399 ULOGE(TAG_MIU, "UtopiaResourceObtainToInstant fail\n");
400 return UTOPIA_STATUS_ERR_RESOURCE;
401 }
402 bRet = psMIUInstPri->fpMIU_SetGroupPriority(pMIUSetGroupPri->u8MiuDev, pMIUSetGroupPri->sPriority);
403 pMIUSetGroupPri->bRet = bRet;
404 UtopiaResourceRelease(pResource);
405 if (TRUE == bRet)
406 return UTOPIA_STATUS_SUCCESS;
407 else
408 return UTOPIA_STATUS_FAIL;
409
410 case MDrv_CMD_MIU_SetHighPriority:
411 MIUDBG("MIUIoctl - MDrv_CMD_MIU_SetHighPriority\n");
412 pMIUSetHighPri = (PMIU_SETHIGHPRIORITY)pArgs;
413 // when calling func occpuy h/w, need to call UtopiaResourceObtainToInstant to obtain res to lock other process
414 if(UtopiaResourceObtain(pModule, MIU_POOL_ID_MIU0, &pResource) != 0)
415 {
416 ULOGE(TAG_MIU, "UtopiaResourceObtainToInstant fail\n");
417 return UTOPIA_STATUS_ERR_RESOURCE;
418 }
419 bRet = psMIUInstPri->fpMIU_SetHighPriority(pMIUSetHighPri->u8MiuDev,pMIUSetHighPri->eClientID,pMIUSetHighPri->bMask);
420 pMIUSetHighPri->bRet = bRet;
421 UtopiaResourceRelease(pResource);
422 if (TRUE == bRet)
423 return UTOPIA_STATUS_SUCCESS;
424 else
425 return UTOPIA_STATUS_FAIL;
426
427 case MDrv_CMD_MIU_PrintProtectInfo:
428 MIUDBG("MIUIoctl - MDrv_CMD_MIU_PrintProtectInfo\n");
429 // when calling func occpuy h/w, need to call UtopiaResourceObtainToInstant to obtain res to lock other process
430 if(UtopiaResourceObtain(pModule, MIU_POOL_ID_MIU0, &pResource) != 0)
431 {
432 ULOGE(TAG_MIU, "Ioctl UtopiaResourceObtainToInstant fail\n");
433 return UTOPIA_STATUS_ERR_RESOURCE;
434 }
435 psMIUInstPri->fpMIU_PrintProtectInfo();
436 UtopiaResourceRelease(pResource);
437 return UTOPIA_STATUS_SUCCESS;
438
439 case MDrv_CMD_MIU_Dram_Size:
440 MIUDBG("MIUIoctl - MDrv_CMD_MIU_Dram_Size\n");
441 pMIUDramSizePri = (PMIU_DRAM_SIZE)pArgs;
442 // when calling func occpuy h/w, need to call UtopiaResourceObtainToInstant to obtain res to lock other process
443 if(UtopiaResourceObtain(pModule, MIU_POOL_ID_MIU0, &pResource) != 0)
444 {
445 ULOGE(TAG_MIU, "Ioctl UtopiaResourceObtainToInstant fail\n");
446 return UTOPIA_STATUS_ERR_RESOURCE;
447 }
448 bRet = psMIUInstPri->fpMIU_Dram_Size(pMIUDramSizePri->u8MiuDev, pMIUDramSizePri->DramSize);
449 pMIUDramSizePri->bRet = bRet;
450 UtopiaResourceRelease(pResource);
451 if (TRUE == bRet)
452 return UTOPIA_STATUS_SUCCESS;
453 else
454 return UTOPIA_STATUS_FAIL;
455
456 case MDrv_CMD_MIU_GetDramType:
457 MIUDBG("MIUIoctl - MDrv_CMD_MIU_GetDramType\n");
458 pMIUGetDramTypePri = (PMIU_GETDRAMTYPE)pArgs;
459 bRet = psMIUInstPri->fpMIU_GetDramType(pMIUGetDramTypePri->eMiu, pMIUGetDramTypePri->pType);
460 if (TRUE == bRet)
461 return UTOPIA_STATUS_SUCCESS;
462 else
463 return UTOPIA_STATUS_FAIL;
464
465 case MDrv_CMD_MIU_ProtectAlign:
466 MIUDBG("MIUIoctl - MDrv_CMD_MIU_ProtectAlign\n");
467 pMIUProtectAlignPri = (PMIU_PROTECT_ALIGN)pArgs;
468 // when calling func occpuy h/w, need to call UtopiaResourceObtainToInstant to obtain res to lock other process
469 if(UtopiaResourceObtain(pModule, MIU_POOL_ID_MIU0, &pResource) != 0)
470 {
471 printf("UtopiaResourceObtainToInstant fail\n");
472 return UTOPIA_STATUS_ERR_RESOURCE;
473 }
474 bRet = psMIUInstPri->fpMIU_ProtectAlign(pMIUProtectAlignPri->u32PageShift);
475 pMIUProtectAlignPri->bRet = bRet;
476 UtopiaResourceRelease(pResource);
477 if (TRUE == bRet)
478 return UTOPIA_STATUS_SUCCESS;
479 else
480 return UTOPIA_STATUS_FAIL;
481
482 default:
483 break;
484 };
485
486 return UTOPIA_STATUS_SUCCESS; // FIXME: error code
487 }
488
MIUClose(void * pInstance)489 MS_U32 MIUClose(void* pInstance)
490 {
491 UtopiaInstanceDelete(pInstance);
492
493 return UTOPIA_STATUS_SUCCESS;
494 }
495
496
497
498