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) 2006-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 ////////////////////////////////////////////////////////////////////////////////
94
95 ///////////////////////////////////////////////////////////////////////////////////////////////////
96 ///
97 /// file drvMIU.c
98 /// @brief MIU Driver Interface
99 /// @author MStar Semiconductor Inc.
100 ///////////////////////////////////////////////////////////////////////////////////////////////////
101
102 //-------------------------------------------------------------------------------------------------
103 // Include Files
104 //-------------------------------------------------------------------------------------------------
105 #ifdef MSOS_TYPE_LINUX_KERNEL
106 #include <linux/string.h>
107 #include <linux/slab.h>
108 #else
109 #include <string.h>
110 #endif
111 #include "MsCommon.h"
112 #include "MsVersion.h"
113 #include "MsTypes.h"
114 #include "drvMIU.h"
115 #include "drvMIU_private.h"
116 #include "halMIU.h"
117 #include "drvMMIO.h"
118 #include "MsOS.h"
119 #include "utopia.h"
120 //#include <assert.h>
121 #include "ULog.h"
122 //-------------------------------------------------------------------------------------------------
123 // Local Defines
124 //-------------------------------------------------------------------------------------------------
125 #define TAG_MIU "MIU"
126
127
128 //-------------------------------------------------------------------------------------------------
129 // Macros
130 //-------------------------------------------------------------------------------------------------
131
132
133 //-------------------------------------------------------------------------------------------------
134 // Global Variables
135 //-------------------------------------------------------------------------------------------------
136
137 //-------------------------------------------------------------------------------------------------
138 // Local Variables
139 //-------------------------------------------------------------------------------------------------
140 static MSIF_Version _drv_miu_version = {
141 .DDI = { MIU_DRV_VERSION },
142 };
143
144 MS_U8 MIU0_request_mask_count[MIU_CLIENT_MAX];
145 MS_U8 MIU1_request_mask_count[MIU_CLIENT_MAX];
146
147 void* pInstantMIU = NULL;
148 void* pAttributeMIU = NULL;
149 static MS_BOOL bMiuInit = FALSE;
150
151 //-------------------------------------------------------------------------------------------------
152 // Local Function Prototypes
153 //-------------------------------------------------------------------------------------------------
154 MS_BOOL MDrv_MIU_Exit(void);
155
156 ////////////////////////////////////////////////////////////////////////////////
157 /// @brief \b Function \b Name: _MDrv_MIU_Init
158 /// @brief \b Function \b Description: set MIU I/O Map base address and parse occupied resource to software structure
159 /// @param None \b IN :
160 /// @param None \b OUT :
161 /// @param MS_BOOL \b RET
162 /// @param None \b GLOBAL :
163 ////////////////////////////////////////////////////////////////////////////////
_MDrv_MIU_Init(void)164 MS_BOOL _MDrv_MIU_Init(void)
165 {
166 MS_VIRT virtMMIOBaseAdr = 0;
167 MS_PHY u32NonPMBankSize = 0;
168
169 if( !MDrv_MMIO_GetBASE(&virtMMIOBaseAdr, &u32NonPMBankSize, MS_MODULE_MIU))
170 {
171 MS_DEBUG_MSG(ULOGE(TAG_MIU, "Get IOMap failure\n"));
172 MS_ASSERT(0);
173 return FALSE;
174 }
175
176 HAL_MIU_SetIOMapBase(virtMMIOBaseAdr);
177
178 if( !MDrv_MMIO_GetBASE(&virtMMIOBaseAdr, &u32NonPMBankSize, MS_MODULE_PM))
179 {
180 MS_DEBUG_MSG(ULOGE(TAG_MIU, "Get IOMap failure\n"));
181 MS_ASSERT(0);
182 return FALSE;
183 }
184 HAL_MIU_SetPMIOMapBase(virtMMIOBaseAdr);
185 HAL_MIU_ParseOccupiedResource();
186 bMiuInit = TRUE;
187
188 return TRUE;
189 }
190
191 ////////////////////////////////////////////////////////////////////////////////
192 /// @brief \b Function \b Name: MDrv_MIU_SetIOMapBase
193 /// @brief \b Function \b Description: set MIU I/O Map base address
194 /// @param None \b IN :
195 /// @param None \b OUT :
196 /// @param MS_BOOL \b RET
197 /// @param None \b GLOBAL :
198 ////////////////////////////////////////////////////////////////////////////////
MDrv_MIU_SetIOMapBase(void)199 MS_BOOL MDrv_MIU_SetIOMapBase(void)
200 {
201 MS_VIRT virtMMIOBaseAdr = 0;
202 MS_PHY u32NonPMBankSize = 0;
203
204 if( !MDrv_MMIO_GetBASE(&virtMMIOBaseAdr, &u32NonPMBankSize, MS_MODULE_MIU))
205 {
206 MS_DEBUG_MSG(ULOGE(TAG_MIU, "Get IOMap failure\n"));
207 MS_ASSERT(0);
208 return FALSE;
209 }
210 HAL_MIU_SetIOMapBase(virtMMIOBaseAdr);
211
212
213 if( !MDrv_MMIO_GetBASE(&virtMMIOBaseAdr, &u32NonPMBankSize, MS_MODULE_PM))
214 {
215 MS_DEBUG_MSG(ULOGE(TAG_MIU, "Get IOMap failure\n"));
216 MS_ASSERT(0);
217 return FALSE;
218 }
219 HAL_MIU_SetPMIOMapBase(virtMMIOBaseAdr);
220 return TRUE;
221 }
222
223 ////////////////////////////////////////////////////////////////////////////////
224 /// @brief \b Function \b Name: MDrv_MIU_GetDefaultClientID_KernelProtect()
225 /// @brief \b Function \b Description: Get default client id array pointer for protect kernel
226 /// @param <RET> \b : The pointer of Array of client IDs
227 ////////////////////////////////////////////////////////////////////////////////
MDrv_MIU_GetDefaultClientID_KernelProtect(void)228 MS_U8* MDrv_MIU_GetDefaultClientID_KernelProtect(void)
229 {
230 return HAL_MIU_GetDefaultClientID_KernelProtect();
231 }
232
233 ////////////////////////////////////////////////////////////////////////////////
234 /// @brief \b Function \b Name: MDrv_MIU_ProtectAlign()
235 /// @brief \b Function \b Description: Get the page shift for MIU protect
236 /// @param <*u32PageShift>\b IN: Page shift
237 /// @param <RET> \b OUT: None
238 ////////////////////////////////////////////////////////////////////////////////
_MDrv_MIU_ProtectAlign(MS_U32 * u32PageShift)239 MS_BOOL _MDrv_MIU_ProtectAlign(MS_U32 *u32PageShift)
240 {
241 *u32PageShift = HAL_MIU_ProtectAlign();
242
243 if(*u32PageShift > 0)
244 return TRUE;
245 else
246 return FALSE;
247 }
248
249 ////////////////////////////////////////////////////////////////////////////////
250 /// @brief \b Function \b Name: MDrv_MIU_Dram_Size()
251 /// @brief \b Function \b Description: Write the DRAM size reg for MIU protect
252 /// @param MiuID \b IN : MIU ID
253 /// @param DramSize \b IN : Specified Dram size for MIU protect
254 /// @param <OUT> \b None :
255 /// @param <RET> \b None :
256 /// @param <GLOBAL> \b None :
257 ////////////////////////////////////////////////////////////////////////////////
_MDrv_MIU_Dram_Size(MS_U8 MiuID,MS_U8 DramSize)258 MS_BOOL _MDrv_MIU_Dram_Size(MS_U8 MiuID, MS_U8 DramSize)
259 {
260 return HAL_MIU_Dram_Size(MiuID, DramSize);
261 }
262
263 ////////////////////////////////////////////////////////////////////////////////
264 /// @brief \b Function \b Name: MDrv_MIU_Dram_ReadSize()
265 /// @brief \b Function \b Description: Read the DRAM size
266 /// @param MiuID \b IN : MIU ID
267 /// @param DramSize \b IN : Dram size for MIU protect
268 /// @param <OUT> \b None :
269 /// @param <RET> \b None :
270 /// @param <GLOBAL> \b None :
271 ////////////////////////////////////////////////////////////////////////////////
MDrv_MIU_Dram_ReadSize(MS_U8 MiuID,MIU_DDR_SIZE * pDramSize)272 MS_BOOL MDrv_MIU_Dram_ReadSize(MS_U8 MiuID, MIU_DDR_SIZE *pDramSize)
273 {
274 return HAL_MIU_Dram_ReadSize(MiuID, pDramSize);
275 }
276
277 ////////////////////////////////////////////////////////////////////////////////
278 /// @brief \b Function \b Name: MDrv_MIU_GetClinetNumber()
279 /// @brief \b Function \b Description: Get the number of clients for specific MIU block
280 /// @param DramSize \b IN : MIU Block to protect (0 ~ 3)
281 /// @param <OUT> \b None :
282 /// @param <RET> \b None :
283 /// @param <GLOBAL> \b None :
284 ////////////////////////////////////////////////////////////////////////////////
MDrv_MIU_ClinetNumber(MS_U8 u8Blockx)285 MS_U8 MDrv_MIU_ClinetNumber(MS_U8 u8Blockx)
286 {
287 return HAL_MIU_ClinetNumber(u8Blockx);
288 }
289
290 ////////////////////////////////////////////////////////////////////////////////
291 /// @brief \b Function \b Name: _MDrv_MIU_Protect()
292 /// @brief \b Function \b Description: Enable/Disable MIU Protection mode
293 /// @param u8Blockx \b IN : MIU Block to protect (0 ~ 3)
294 /// @param *pu8ProtectId \b IN : Allow specified client IDs to write
295 /// @param phy64Start \b IN : Starting address
296 /// @param phy64End \b IN : End address
297 /// @param bSetFlag \b IN : Disable or Enable MIU protection
298 /// - -Disable(0)
299 /// - -Enable(1)
300 /// @param <OUT> \b None :
301 /// @param <RET> \b None :
302 /// @param <GLOBAL> \b None :
303 ////////////////////////////////////////////////////////////////////////////////
_MDrv_MIU_Protect(MS_U8 u8Blockx,MS_U8 * pu8ProtectId,MS_PHY phy64Start,MS_PHY phy64End,MS_BOOL bSetFlag)304 MS_BOOL _MDrv_MIU_Protect(
305 MS_U8 u8Blockx,
306 MS_U8 *pu8ProtectId,
307 MS_PHY phy64Start,
308 MS_PHY phy64End,
309 MS_BOOL bSetFlag
310 )
311 {
312 MS_BOOL Result;
313
314 Result = HAL_MIU_Protect(u8Blockx, pu8ProtectId, phy64Start, phy64End, bSetFlag);
315
316 if(Result == TRUE)
317 {
318 return TRUE;
319 }
320 else
321 {
322 MS_ASSERT(0);
323 return FALSE;
324 }
325 }
326
327 ////////////////////////////////////////////////////////////////////////////////
328 /// @brief \b Function \b Name: _MDrv_MIU_ProtectEx()
329 /// @brief \b Function \b Description: Enable/Disable MIU Protection mode
330 /// @param u8Blockx \b IN : MIU Block to protect (0 ~ 3)
331 /// @param *pu8ProtectId \b IN : Allow specified client IDs to write
332 /// @param phy64Start \b IN : Starting address
333 /// @param phy64End \b IN : End address
334 /// @param bSetFlag \b IN : Disable or Enable MIU protection
335 /// - -Disable(0)
336 /// - -Enable(1)
337 /// @param <OUT> \b None :
338 /// @param <RET> \b None :
339 /// @param <GLOBAL> \b None :
340 ////////////////////////////////////////////////////////////////////////////////
_MDrv_MIU_ProtectEx(MS_U8 u8Blockx,MS_U32 * pu32ProtectId,MS_PHY phy64Start,MS_PHY phy64End,MS_BOOL bSetFlag)341 MS_BOOL _MDrv_MIU_ProtectEx(
342 MS_U8 u8Blockx,
343 MS_U32 *pu32ProtectId,
344 MS_PHY phy64Start,
345 MS_PHY phy64End,
346 MS_BOOL bSetFlag
347 )
348 {
349 MS_BOOL Result;
350
351 Result = HAL_MIU_ProtectEx(u8Blockx, pu32ProtectId, phy64Start, phy64End, bSetFlag);
352
353 if(Result == TRUE)
354 {
355 return TRUE;
356 }
357 else
358 {
359 MS_ASSERT(0);
360 return FALSE;
361 }
362 }
363
364
365
366 ////////////////////////////////////////////////////////////////////////////////
367 /// @brief \b Function \b Name: _MDrv_MIU_SetSsc()
368 /// @brief \b Function \b Description: _MDrv_MIU_SetSsc, @Step & Span
369 /// @param u16Fmodulation \b IN : 20KHz ~ 40KHz (Input Value = 20 ~ 40)
370 /// @param u16FDeviation \b IN : under 0.1% ~ 3% (Input Value = 1 ~ 30)
371 /// @param bEnable \b IN :
372 /// @param None \b OUT :
373 /// @param None \b RET :
374 /// @param None \b GLOBAL :
375 ////////////////////////////////////////////////////////////////////////////////
_MDrv_MIU_SetSsc(MS_U16 u16Fmodulation,MS_U16 u16FDeviation,MS_BOOL bEnable)376 MS_BOOL _MDrv_MIU_SetSsc(MS_U16 u16Fmodulation,
377 MS_U16 u16FDeviation,
378 MS_BOOL bEnable)
379 {
380 return HAL_MIU_SetSsc(0, u16Fmodulation, u16FDeviation, bEnable);
381 }
382
383 ////////////////////////////////////////////////////////////////////////////////
384 /// @brief \b Function \b Name: _MDrv_MIU_SetSscValue()
385 /// @brief \b Function \b Description: _MDrv_MIU_SetSscValue, @Step & Span
386 /// @param u8Miu \b IN : 0: MIU0 1:MIU1
387 /// @param u16Fmodulation \b IN : 20KHz ~ 40KHz (Input Value = 20 ~ 40)
388 /// @param u16FDeviation \b IN : under 0.1% ~ 3% (Input Value = 1 ~ 30)
389 /// @param bEnable \b IN :
390 /// @param None \b OUT :
391 /// @param None \b RET :
392 /// @param None \b GLOBAL :
393 ////////////////////////////////////////////////////////////////////////////////
_MDrv_MIU_SetSscValue(MS_U8 u8MiuDev,MS_U16 u16Fmodulation,MS_U16 u16FDeviation,MS_BOOL bEnable)394 MS_BOOL _MDrv_MIU_SetSscValue(MS_U8 u8MiuDev,
395 MS_U16 u16Fmodulation,
396 MS_U16 u16FDeviation,
397 MS_BOOL bEnable)
398 {
399 return HAL_MIU_SetSsc(u8MiuDev, u16Fmodulation, u16FDeviation, bEnable);
400 }
401
402 ////////////////////////////////////////////////////////////////////////////////
403 /// @brief \b Function \b Name: _MDrv_MIU_MaskReq()
404 /// @brief \b Function \b Description: Mask MIU request
405 /// @param u8Miu \b IN : 0: MIU0 1:MIU1
406 /// @param eClientID \b IN : Client ID
407 /// @param None \b OUT :
408 /// @param None \b RET :
409 ///////////////////////////////////////////////////////////////////////////////
_MDrv_MIU_MaskReq(MS_U8 u8Miu,eMIUClientID eClientID)410 void _MDrv_MIU_MaskReq(MS_U8 u8Miu, eMIUClientID eClientID)
411 {
412 HAL_MIU_MaskReq(u8Miu, eClientID);
413 }
414
415 ////////////////////////////////////////////////////////////////////////////////
416 /// @brief \b Function \b Name: _MDrv_MIU_UnMaskReq()
417 /// @brief \b Function \b Description: Unmak MIU request
418 /// @param u8Miu \b IN : 0: MIU0 1:MIU1
419 /// @param eClientID \b IN : Client ID
420 /// @param None \b OUT :
421 /// @param None \b RET :
422 ///////////////////////////////////////////////////////////////////////////////
_MDrv_MIU_UnMaskReq(MS_U8 u8Miu,eMIUClientID eClientID)423 void _MDrv_MIU_UnMaskReq(MS_U8 u8Miu, eMIUClientID eClientID)
424 {
425 HAL_MIU_UnMaskReq(u8Miu, eClientID);
426 }
427
428 ////////////////////////////////////////////////////////////////////////////////
429 /// @brief \b Function \b Name: _MDrv_MIU_Mask_Req_OPM_R()
430 /// @brief \b Function \b Description:
431 /// @param None \b IN :
432 /// @param None \b OUT :
433 /// @param None \b RET :
434 ///////////////////////////////////////////////////////////////////////////////
_MDrv_MIU_Mask_Req_OPM_R(MS_U8 u8Mask,MS_U8 u8Miu)435 void _MDrv_MIU_Mask_Req_OPM_R(MS_U8 u8Mask, MS_U8 u8Miu)
436 {
437 HAL_MIU_Mask_Req_OPM_R(u8Mask, u8Miu);
438 }
439
440 ////////////////////////////////////////////////////////////////////////////////
441 /// @brief \b Function \b Name: _MDrv_MIU_Mask_Req_DNRB_R()
442 /// @brief \b Function \b Description:
443 /// @param None \b IN :
444 /// @param None \b OUT :
445 /// @param None \b RET :
446 ///////////////////////////////////////////////////////////////////////////////
_MDrv_MIU_Mask_Req_DNRB_R(MS_U8 u8Mask,MS_U8 u8Miu)447 void _MDrv_MIU_Mask_Req_DNRB_R(MS_U8 u8Mask, MS_U8 u8Miu)
448 {
449 HAL_MIU_Mask_Req_DNRB_R( u8Mask, u8Miu);
450 }
451
452 ////////////////////////////////////////////////////////////////////////////////
453 /// @brief \b Function \b Name: _MDrv_MIU_Mask_Req_DNRB_W()
454 /// @brief \b Function \b Description:
455 /// @param None \b IN :
456 /// @param None \b OUT :
457 /// @param None \b RET :
458 ///////////////////////////////////////////////////////////////////////////////
_MDrv_MIU_Mask_Req_DNRB_W(MS_U8 u8Mask,MS_U8 u8Miu)459 void _MDrv_MIU_Mask_Req_DNRB_W(MS_U8 u8Mask, MS_U8 u8Miu)
460 {
461 HAL_MIU_Mask_Req_DNRB_W( u8Mask, u8Miu);
462
463 }
464
465 ////////////////////////////////////////////////////////////////////////////////
466 /// @brief \b Function \b Name: _MDrv_MIU_Mask_Req_DNRB_RW()
467 /// @brief \b Function \b Description:
468 /// @param None \b IN :
469 /// @param None \b OUT :
470 /// @param None \b RET :
471 ///////////////////////////////////////////////////////////////////////////////
_MDrv_MIU_Mask_Req_DNRB_RW(MS_U8 u8Mask,MS_U8 u8Miu)472 void _MDrv_MIU_Mask_Req_DNRB_RW(MS_U8 u8Mask, MS_U8 u8Miu)
473 {
474 HAL_MIU_Mask_Req_DNRB_RW( u8Mask, u8Miu);
475 }
476
477
478 ////////////////////////////////////////////////////////////////////////////////
479 /// @brief \b Function \b Name: _MDrv_MIU_Mask_Req_SC_RW()
480 /// @brief \b Function \b Description:
481 /// @param None \b IN :
482 /// @param None \b OUT :
483 /// @param None \b RET :
484 ///////////////////////////////////////////////////////////////////////////////
_MDrv_MIU_Mask_Req_SC_RW(MS_U8 u8Mask,MS_U8 u8Miu)485 void _MDrv_MIU_Mask_Req_SC_RW(MS_U8 u8Mask, MS_U8 u8Miu)
486 {
487 HAL_MIU_Mask_Req_SC_RW( u8Mask, u8Miu);
488 }
489
490
491 ////////////////////////////////////////////////////////////////////////////////
492 /// @brief \b Function \b Name: _MDrv_MIU_Mask_Req_MVOP_R()
493 /// @brief \b Function \b Description:
494 /// @param None \b IN :
495 /// @param None \b OUT :
496 /// @param None \b RET :
497 ///////////////////////////////////////////////////////////////////////////////
_MDrv_MIU_Mask_Req_MVOP_R(MS_U8 u8Mask,MS_U8 u8Miu)498 void _MDrv_MIU_Mask_Req_MVOP_R(MS_U8 u8Mask, MS_U8 u8Miu)
499 {
500 HAL_MIU_Mask_Req_MVOP_R( u8Mask, u8Miu);
501 }
502
503
504 ////////////////////////////////////////////////////////////////////////////////
505 /// @brief \b Function \b Name: _MDrv_MIU_Mask_Req_MVD_R()
506 /// @brief \b Function \b Description:
507 /// @param None \b IN :
508 /// @param None \b OUT :
509 /// @param None \b RET :
510 ///////////////////////////////////////////////////////////////////////////////
_MDrv_MIU_Mask_Req_MVD_R(MS_U8 u8Mask,MS_U8 u8Miu)511 void _MDrv_MIU_Mask_Req_MVD_R(MS_U8 u8Mask, MS_U8 u8Miu)
512 {
513 HAL_MIU_Mask_Req_MVD_R( u8Mask, u8Miu);
514 }
515
516
517 ////////////////////////////////////////////////////////////////////////////////
518 /// @brief \b Function \b Name: _MDrv_MIU_Mask_Req_MVD_W()
519 /// @brief \b Function \b Description:
520 /// @param None \b IN :
521 /// @param None \b OUT :
522 /// @param None \b RET :
523 ///////////////////////////////////////////////////////////////////////////////
_MDrv_MIU_Mask_Req_MVD_W(MS_U8 u8Mask,MS_U8 u8Miu)524 void _MDrv_MIU_Mask_Req_MVD_W(MS_U8 u8Mask, MS_U8 u8Miu)
525 {
526 HAL_MIU_Mask_Req_MVD_W( u8Mask, u8Miu);
527 }
528
529
530 ////////////////////////////////////////////////////////////////////////////////
531 /// @brief \b Function \b Name: _MDrv_MIU_Mask_Req_MVD_RW()
532 /// @brief \b Function \b Description:
533 /// @param None \b IN :
534 /// @param None \b OUT :
535 /// @param None \b RET :
536 ///////////////////////////////////////////////////////////////////////////////
_MDrv_MIU_Mask_Req_MVD_RW(MS_U8 u8Mask,MS_U8 u8Miu)537 void _MDrv_MIU_Mask_Req_MVD_RW(MS_U8 u8Mask, MS_U8 u8Miu)
538 {
539 HAL_MIU_Mask_Req_MVD_RW( u8Mask, u8Miu);
540 }
541
542
543 ////////////////////////////////////////////////////////////////////////////////
544 /// @brief \b Function \b Name: _MDrv_MIU_Mask_Req_AUDIO_RW()
545 /// @brief \b Function \b Description:
546 /// @param None \b IN :
547 /// @param None \b OUT :
548 /// @param None \b RET :
549 ///////////////////////////////////////////////////////////////////////////////
_MDrv_MIU_Mask_Req_AUDIO_RW(MS_U8 u8Mask,MS_U8 u8Miu)550 void _MDrv_MIU_Mask_Req_AUDIO_RW(MS_U8 u8Mask, MS_U8 u8Miu)
551 {
552 HAL_MIU_Mask_Req_AUDIO_RW( u8Mask, u8Miu);
553 }
554
555 ////////////////////////////////////////////////////////////////////////////////
556 /// @brief \b Function \b Name: MDrv_MIU_InitCounter()
557 /// @brief \b Function \b Description: This function clear all request mask counter of
558 /// MIU driver
559 /// @param None \b IN:
560 /// @param None \b RET:
561 ////////////////////////////////////////////////////////////////////////////////
MDrv_MIU_InitCounter(void)562 void MDrv_MIU_InitCounter(void)
563 {
564 MS_U8 i;
565
566 for(i=0;i<MIU_CLIENT_MAX;i++)
567 {
568 MIU0_request_mask_count[i]=0;
569 MIU1_request_mask_count[i]=0;
570 }
571 }
572
573 ////////////////////////////////////////////////////////////////////////////////
574 /// @brief \b Function \b Name: MDrv_MIU_SwitchMIU()
575 /// @brief \b Function \b Description: This function for switch miu
576 ///
577 /// @param u8MiuID \b IN : select MIU0 or MIU1
578 /// @param None \b RET:
579 ////////////////////////////////////////////////////////////////////////////////
MDrv_MIU_SwitchMIU(MS_U8 u8MiuID)580 void MDrv_MIU_SwitchMIU(MS_U8 u8MiuID)
581 {
582 HAL_MIU_VOP_SwitchMIU(u8MiuID);
583 }
584
585 ////////////////////////////////////////////////////////////////////////////////
586 /// @brief \b Function \b Name: _MDrv_MIU_SwitchMIU()
587 /// @brief \b Function \b Description: This function for switch miu
588 ///
589 /// @param u8MiuID \b IN : select MIU0 or MIU1
590 /// @param None \b RET:
591 ////////////////////////////////////////////////////////////////////////////////
_MDrv_MIU_SelMIU(eMIUClientID eClientID,eMIU_SelType eType)592 MS_BOOL _MDrv_MIU_SelMIU(eMIUClientID eClientID, eMIU_SelType eType)
593 {
594 MS_BOOL ret = TRUE;
595
596 _MDrv_MIU_MaskReq(0, eClientID);
597 _MDrv_MIU_MaskReq(1, eClientID);
598 ret &= HAL_MIU_SelMIU(eType, eClientID);
599 if (MIU_SELTYPE_MIU_ALL == eType)
600 {
601 _MDrv_MIU_UnMaskReq(0, eClientID);
602 _MDrv_MIU_UnMaskReq(1, eClientID);
603 }
604 else
605 _MDrv_MIU_UnMaskReq((MS_U8)eType, eClientID);
606
607 return ret;
608 }
609
610 ////////////////////////////////////////////////////////////////////////////////
611 /// @brief \b Function \b Name: MDrv_MIU_IsSupportMIU1()
612 /// @brief \b Function \b Description: This function for checking if support miu1
613 ///
614 /// @param None \b RET: TRUE: Support miu1 FALSE: no miu1
615 ////////////////////////////////////////////////////////////////////////////////
MDrv_MIU_IsSupportMIU1(void)616 MS_BOOL MDrv_MIU_IsSupportMIU1(void)
617 {
618 return HAL_MIU_IsInitMiu1();
619 }
620
621 ////////////////////////////////////////////////////////////////////////////////
622 /// @brief \b Function \b Name: MDrv_MIU_GetBusWidth()
623 /// @brief \b Function \b Description: This function for querying data bus width
624 ///
625 /// @param None \b RET: 0: not support or 64 or 128 bits
626 ////////////////////////////////////////////////////////////////////////////////
MDrv_MIU_GetBusWidth(void)627 MS_U16 MDrv_MIU_GetBusWidth(void)
628 {
629 return HAL_MIU_IsI64Mode();
630 }
631
632 ////////////////////////////////////////////////////////////////////////////////
633 /// @brief \b Function \b Name: MDrv_MIU_GetClientInfo()
634 /// @brief \b Function \b Description: This function for querying client ID info
635 /// @param u8MiuDev \b IN : select MIU0 or MIU1
636 /// @param eClientID \b IN : Client ID
637 /// @param pInfo \b OUT : Client Info
638 /// @param None \b RET: 0: Fail 1: Ok
639 ////////////////////////////////////////////////////////////////////////////////
MDrv_MIU_GetClientInfo(MS_U8 u8MiuDev,eMIUClientID eClientID,MIU_ClientInfo * pInfo)640 MS_BOOL MDrv_MIU_GetClientInfo(MS_U8 u8MiuDev, eMIUClientID eClientID, MIU_ClientInfo *pInfo)
641 {
642 MS_S16 sVal;
643 if (!pInfo)
644 return FALSE;
645
646 sVal = HAL_MIU_GetClientInfo(u8MiuDev, eClientID);
647 if (sVal < 0)
648 return FALSE;
649 pInfo->u8BitPos = (MS_U8)MIU_GET_CLIENT_POS(sVal);
650 pInfo->u8Gp = (MS_U8)MIU_GET_CLIENT_GROUP(sVal);
651 return TRUE;
652 }
653
654 ////////////////////////////////////////////////////////////////////////////////
655 /// @brief \b Function \b Name: _MDrv_MIU_GetProtectInfo()
656 /// @brief \b Function \b Description: This function for querying client ID info
657 /// @param u8MiuDev \b IN : select MIU0 or MIU1
658 /// @param eClientID \b IN : Client ID
659 /// @param pInfo \b OUT : Client Info
660 /// @param None \b RET: 0: Fail 1: Ok
661 ////////////////////////////////////////////////////////////////////////////////
_MDrv_MIU_GetProtectInfo(MS_U8 u8MiuDev,MIU_PortectInfo * pInfo)662 MS_BOOL _MDrv_MIU_GetProtectInfo(MS_U8 u8MiuDev, MIU_PortectInfo *pInfo)
663 {
664 MS_U32 ret;
665 ret = HAL_MIU_GetProtectInfo(u8MiuDev, pInfo);
666
667 //if(pInfo->bHit)
668 //{
669 // if(MsOS_GetKattribute("miuprot")==1)
670 // MS_ASSERT(0);
671 //}
672
673 return ret;
674 }
675
676 ////////////////////////////////////////////////////////////////////////////////
677 /// @brief \b Function \b Name: _MDrv_MIU_SetGroupPriority()
678 /// @brief \b Function \b Description: This function for querying client ID info
679 /// @param u8MiuDev \b IN : select MIU0 or MIU1
680 /// @param eClientID \b IN : Client ID
681 /// @param pInfo \b OUT : Client Info
682 /// @param None \b RET: 0: Fail 1: Ok
683 ////////////////////////////////////////////////////////////////////////////////
_MDrv_MIU_SetGroupPriority(MS_U8 u8MiuDev,MIU_GroupPriority sPriority)684 MS_BOOL _MDrv_MIU_SetGroupPriority(MS_U8 u8MiuDev, MIU_GroupPriority sPriority)
685 {
686 return HAL_MIU_SetGroupPriority(u8MiuDev, sPriority);
687 }
688
689 ////////////////////////////////////////////////////////////////////////////////
690 /// @brief \b Function \b Name: _MDrv_MIU_SetHPriorityMask()
691 /// @brief \b Function \b Description: Set miu high priority mask
692 /// @param u8MiuDev \b IN : select MIU0 or MIU1
693 /// @param eClientID \b IN : Client ID
694 /// @param pInfo \b OUT : Client Info
695 /// @param None \b RET: 0: Fail 1: Ok
696 ////////////////////////////////////////////////////////////////////////////////
_MDrv_MIU_SetHPriorityMask(MS_U8 u8MiuDev,eMIUClientID eClientID,MS_BOOL bMask)697 MS_BOOL _MDrv_MIU_SetHPriorityMask(MS_U8 u8MiuDev, eMIUClientID eClientID, MS_BOOL bMask)
698 {
699 return HAL_MIU_SetHPriorityMask(u8MiuDev, eClientID, bMask);
700 }
701
702 ////////////////////////////////////////////////////////////////////////////////
703 /// @brief \b Function \b Name: MDrv_MIU_GetLibVer
704 /// @brief \b Function \b Description: Show the MIU driver version
705 /// @param ppVersion \b Out: Library version string
706 /// @return \b 0: Fail 1: Ok
707 ////////////////////////////////////////////////////////////////////////////////
MDrv_MIU_GetLibVer(const MSIF_Version ** ppVersion)708 MS_BOOL MDrv_MIU_GetLibVer(const MSIF_Version **ppVersion)
709 {
710 if (!ppVersion)
711 return FALSE;
712
713 *ppVersion = &_drv_miu_version;
714 return TRUE;
715 }
716
717 ////////////////////////////////////////////////////////////////////////////////
718 /// @brief \b Function \b Name: MDrv_MIU_EnableScramble
719 /// @brief \b Function \b Description: Enable MIU Scramble
720 /// @param bEnable \b In: Enable MIU Scramble
721 /// @return \b 0: Fail 1: Ok
722 ////////////////////////////////////////////////////////////////////////////////
MDrv_MIU_EnableScramble(MS_BOOL bEnable)723 MS_BOOL MDrv_MIU_EnableScramble(MS_BOOL bEnable)
724 {
725 return HAL_MIU_EnableScramble(bEnable);
726 }
727
728 ////////////////////////////////////////////////////////////////////////////////
729 /// @brief \b Function \b Name: MDrv_MIU_IsScrambleEnabled
730 /// @brief \b Function \b Description: Check if the MIU Scramble enabled
731 /// @return \b 0: Disabled 1: Enabled
732 ////////////////////////////////////////////////////////////////////////////////
MDrv_MIU_IsScrambleEnabled(void)733 MS_BOOL MDrv_MIU_IsScrambleEnabled(void)
734 {
735 return HAL_MIU_IsScrambleEnabled();
736 }
737
738 #ifdef _MIU_INTERNEL_USE
739 ////////////////////////////////////////////////////////////////////////////////
740 /// @brief \b Function \b Name: MDrv_MIU_GetLoading
741 /// @brief \b Function \b Description: Get the percentage of MIU loading
742 /// @param u8MiuDev \b IN : select MIU0 or MIU1
743 /// @param *Loading \b IN : percentage of MIU loading
744 /// @return \b 0: Fail 1: OK
745 ////////////////////////////////////////////////////////////////////////////////
MDrv_MIU_GetLoading(MS_U8 u8MiuDev,MS_U32 * u32Loading)746 MS_BOOL MDrv_MIU_GetLoading(MS_U8 u8MiuDev, MS_U32 *u32Loading)
747 {
748 HAL_MIU_SetLoadingRequest(u8MiuDev);
749
750 MsOS_DelayTask(1000);
751
752 HAL_MIU_GetLoadingRequest(u8MiuDev, u32Loading);
753
754 return TRUE;
755 }
756 #endif
757
758
_MDrv_MIU_PrintProtectInfo(void)759 void _MDrv_MIU_PrintProtectInfo(void)
760 {
761 HAL_MIU_PrintMIUProtectInfo();
762 }
763
764 ////////////////////////////////////////////////////////////////////////////////
765 /// @brief \b Function \b Name: MDrv_MIU_Exit
766 /// @brief \b Function \b Description: Exit MIU driver
767 /// @return \b 0: Fail 1: OK
768 ////////////////////////////////////////////////////////////////////////////////
MDrv_MIU_Exit(void)769 MS_BOOL MDrv_MIU_Exit(void)
770 {
771 if (bMiuInit == FALSE)
772 {
773 ULOGE(TAG_MIU, "MIU is not be initialized\n");
774 return TRUE;
775 }
776
777 if(UtopiaClose(pInstantMIU) != UTOPIA_STATUS_SUCCESS)
778 {
779 ULOGE(TAG_MIU, "close MIU fail\n");
780 pInstantMIU = NULL;
781 return FALSE;
782 }
783
784 pInstantMIU = NULL;
785 bMiuInit = FALSE;
786
787 return TRUE;
788 }
789
_MDrv_MIU_MaskReqUtopia20IOCtrl(eMIUIoctlCmd eMIUIOCmd,MS_U8 u8Mask,MS_U8 u8Miu)790 void _MDrv_MIU_MaskReqUtopia20IOCtrl(eMIUIoctlCmd eMIUIOCmd, MS_U8 u8Mask, MS_U8 u8Miu)
791 {
792 PMIU_MIU_MASK pMIUMask;
793 if (NULL != pInstantMIU)
794 {
795 pMIUMask = (PMIU_MIU_MASK)malloc(sizeof(MIU_MIU_MASK));
796 if (pMIUMask == NULL)
797 return;
798 pMIUMask->u8Mask = u8Mask;
799 pMIUMask->u8Miu = u8Miu;
800 if(UtopiaIoctl(pInstantMIU,eMIUIOCmd,(void*)pMIUMask) != UTOPIA_STATUS_SUCCESS)
801 {
802 ULOGE(TAG_MIU, "Ioctl MDrv_CMD_MIU_Mask_Req fail in IP %d\n",eMIUIOCmd);
803 free(pMIUMask);
804 return;
805 }
806 free(pMIUMask);
807 }
808 }
809
MDrv_MIU_Mask_Req_OPM_R(MS_U8 u8Mask,MS_U8 u8Miu)810 void MDrv_MIU_Mask_Req_OPM_R(MS_U8 u8Mask, MS_U8 u8Miu)
811 {
812 // utopia20 flow code
813 _MDrv_MIU_MaskReqUtopia20IOCtrl(MDrv_CMD_MIU_Mask_Req_OPM_R, u8Mask, u8Miu);
814 }
815
MDrv_MIU_Mask_Req_DNRB_R(MS_U8 u8Mask,MS_U8 u8Miu)816 void MDrv_MIU_Mask_Req_DNRB_R(MS_U8 u8Mask, MS_U8 u8Miu)
817 {
818 _MDrv_MIU_MaskReqUtopia20IOCtrl(MDrv_CMD_MIU_Mask_Req_DNRB_R, u8Mask, u8Miu);
819 }
820
MDrv_MIU_Mask_Req_DNRB_W(MS_U8 u8Mask,MS_U8 u8Miu)821 void MDrv_MIU_Mask_Req_DNRB_W(MS_U8 u8Mask, MS_U8 u8Miu)
822 {
823 _MDrv_MIU_MaskReqUtopia20IOCtrl(MDrv_CMD_MIU_Mask_Req_DNRB_W, u8Mask, u8Miu);
824 }
825
MDrv_MIU_Mask_Req_DNRB_RW(MS_U8 u8Mask,MS_U8 u8Miu)826 void MDrv_MIU_Mask_Req_DNRB_RW(MS_U8 u8Mask, MS_U8 u8Miu)
827 {
828 _MDrv_MIU_MaskReqUtopia20IOCtrl(MDrv_CMD_MIU_Mask_Req_DNRB_RW, u8Mask, u8Miu);
829 }
830
MDrv_MIU_Mask_Req_SC_RW(MS_U8 u8Mask,MS_U8 u8Miu)831 void MDrv_MIU_Mask_Req_SC_RW(MS_U8 u8Mask, MS_U8 u8Miu)
832 {
833 _MDrv_MIU_MaskReqUtopia20IOCtrl(MDrv_CMD_MIU_Mask_Req_SC_RW, u8Mask, u8Miu);
834 }
835
MDrv_MIU_Mask_Req_MVOP_R(MS_U8 u8Mask,MS_U8 u8Miu)836 void MDrv_MIU_Mask_Req_MVOP_R(MS_U8 u8Mask, MS_U8 u8Miu)
837 {
838 _MDrv_MIU_MaskReqUtopia20IOCtrl(MDrv_CMD_MIU_Mask_Req_MVOP_R, u8Mask, u8Miu);
839 }
840
MDrv_MIU_Mask_Req_MVD_R(MS_U8 u8Mask,MS_U8 u8Miu)841 void MDrv_MIU_Mask_Req_MVD_R(MS_U8 u8Mask, MS_U8 u8Miu)
842 {
843 _MDrv_MIU_MaskReqUtopia20IOCtrl(MDrv_CMD_MIU_Mask_Req_MVD_R, u8Mask, u8Miu);
844 }
845
MDrv_MIU_Mask_Req_MVD_W(MS_U8 u8Mask,MS_U8 u8Miu)846 void MDrv_MIU_Mask_Req_MVD_W(MS_U8 u8Mask, MS_U8 u8Miu)
847 {
848 _MDrv_MIU_MaskReqUtopia20IOCtrl(MDrv_CMD_MIU_Mask_Req_MVD_W, u8Mask, u8Miu);
849 }
850
MDrv_MIU_Mask_Req_MVD_RW(MS_U8 u8Mask,MS_U8 u8Miu)851 void MDrv_MIU_Mask_Req_MVD_RW(MS_U8 u8Mask, MS_U8 u8Miu)
852 {
853 _MDrv_MIU_MaskReqUtopia20IOCtrl(MDrv_CMD_MIU_Mask_Req_MVD_RW, u8Mask, u8Miu);
854 }
855
MDrv_MIU_Mask_Req_AUDIO_RW(MS_U8 u8Mask,MS_U8 u8Miu)856 void MDrv_MIU_Mask_Req_AUDIO_RW(MS_U8 u8Mask, MS_U8 u8Miu)
857 {
858 _MDrv_MIU_MaskReqUtopia20IOCtrl(MDrv_CMD_MIU_Mask_Req_AUDIO_RW, u8Mask, u8Miu);
859 }
860
MDrv_MIU_MaskReq(MS_U8 u8Miu,eMIUClientID eClientID)861 void MDrv_MIU_MaskReq(MS_U8 u8Miu, eMIUClientID eClientID)
862 {
863 PMIU_MIUREQ_MASK pMIUMaskReq;
864
865 if (NULL != pInstantMIU)
866 {
867 pMIUMaskReq = (PMIU_MIUREQ_MASK)malloc(sizeof(MIU_MIUREQ_MASK));
868 if (pMIUMaskReq == NULL)
869 return;
870 pMIUMaskReq->u8Miu = u8Miu;
871 pMIUMaskReq->eClientID = eClientID;
872 if(UtopiaIoctl(pInstantMIU,MDrv_CMD_MIU_Mask_Req,(void*)pMIUMaskReq) != UTOPIA_STATUS_SUCCESS)
873 {
874 ULOGE(TAG_MIU, "Ioctl MDrv_MIU_MaskReq fail\n");
875 free(pMIUMaskReq);
876 return;
877 }
878 free(pMIUMaskReq);
879 }
880 }
881
MDrv_MIU_UnMaskReq(MS_U8 u8Miu,eMIUClientID eClientID)882 void MDrv_MIU_UnMaskReq(MS_U8 u8Miu, eMIUClientID eClientID)
883 {
884 PMIU_MIUREQ_MASK pMIUMaskReq;
885
886 if (NULL != pInstantMIU)
887 {
888 pMIUMaskReq = (PMIU_MIUREQ_MASK)malloc(sizeof(MIU_MIUREQ_MASK));
889 if (pMIUMaskReq == NULL)
890 return;
891 pMIUMaskReq->u8Miu = u8Miu;
892 pMIUMaskReq->eClientID = eClientID;
893 if(UtopiaIoctl(pInstantMIU,MDrv_CMD_MIU_UnMask_Req,(void*)pMIUMaskReq) != UTOPIA_STATUS_SUCCESS)
894 {
895 ULOGE(TAG_MIU, "Ioctl MDrv_CMD_MIU_UnMask_Req fail\n");
896 free(pMIUMaskReq);
897 return;
898 }
899 free(pMIUMaskReq);
900 }
901 }
902
MDrv_MIU_SetSsc(MS_U16 u16Fmodulation,MS_U16 u16FDeviation,MS_BOOL bEnable)903 MS_BOOL MDrv_MIU_SetSsc(MS_U16 u16Fmodulation, MS_U16 u16FDeviation,MS_BOOL bEnable)
904 {
905 PMIU_SET_SSC pMIUSetSsc;
906 MS_BOOL bRet = TRUE;
907
908 if (NULL != pInstantMIU)
909 {
910 pMIUSetSsc = (PMIU_SET_SSC)malloc(sizeof(MIU_SET_SSC));
911 if (pMIUSetSsc == NULL)
912 return FALSE;
913 pMIUSetSsc->u16Fmodulation = u16Fmodulation;
914 pMIUSetSsc->u16FDeviation = u16FDeviation;
915 pMIUSetSsc->bEnable = bEnable;
916 if(UtopiaIoctl(pInstantMIU,MDrv_CMD_MIU_SetSsc,(void*)pMIUSetSsc) != UTOPIA_STATUS_SUCCESS)
917 {
918 ULOGE(TAG_MIU, "Ioctl MDrv_CMD_MIU_SetSsc fail\n");
919 bRet = FALSE;
920 }
921 else
922 {
923 bRet = TRUE;
924 }
925 free(pMIUSetSsc);
926 }
927 else
928 {
929 bRet = FALSE;
930 }
931
932 return bRet;
933 }
934
MDrv_MIU_SetSscValue(MS_U8 u8MiuDev,MS_U16 u16Fmodulation,MS_U16 u16FDeviation,MS_BOOL bEnable)935 MS_BOOL MDrv_MIU_SetSscValue(MS_U8 u8MiuDev, MS_U16 u16Fmodulation, MS_U16 u16FDeviation, MS_BOOL bEnable)
936 {
937 PMIU_SET_SSCVALUE pMIUSetSscValue;
938 MS_BOOL bRet = TRUE;
939
940 if (NULL != pInstantMIU)
941 {
942 pMIUSetSscValue = (PMIU_SET_SSCVALUE)malloc(sizeof(MIU_SET_SSCVALUE));
943 if (pMIUSetSscValue == NULL)
944 return FALSE;
945 pMIUSetSscValue->u8MiuDev = u8MiuDev;
946 pMIUSetSscValue->u16Fmodulation = u16Fmodulation;
947 pMIUSetSscValue->u16FDeviation = u16FDeviation;
948 pMIUSetSscValue->bEnable = bEnable;
949 if(UtopiaIoctl(pInstantMIU,MDrv_CMD_MIU_SetSscValue,(void*)pMIUSetSscValue) != UTOPIA_STATUS_SUCCESS)
950 {
951 ULOGE(TAG_MIU, "Ioctl MDrv_CMD_MIU_SetSscValue fail\n");
952 bRet = FALSE;
953 }
954 else
955 {
956 bRet = TRUE;
957 }
958 free(pMIUSetSscValue);
959 }
960 else
961 {
962 bRet = FALSE;
963 }
964
965 return bRet;
966 }
967
MDrv_MIU_Protect(MS_U8 u8Blockx,MS_U8 * pu8ProtectId,MS_PHY phy64Start,MS_PHY phy64End,MS_BOOL bSetFlag)968 MS_BOOL MDrv_MIU_Protect( MS_U8 u8Blockx, MS_U8 *pu8ProtectId, MS_PHY phy64Start, MS_PHY phy64End, MS_BOOL bSetFlag )
969 {
970 PMIU_PROTECT pMIUProtect;
971 MS_BOOL bRet = TRUE;
972
973 if (NULL != pInstantMIU)
974 {
975 pMIUProtect = (PMIU_PROTECT)malloc(sizeof(MIU_PROTECT));
976 if (pMIUProtect == NULL)
977 return FALSE;
978 pMIUProtect->u8Blockx = u8Blockx;
979 pMIUProtect->pu8ProtectId = pu8ProtectId;
980 pMIUProtect->phy64Start = phy64Start;
981 pMIUProtect->phy64End = phy64End;
982 pMIUProtect->bSetFlag = bSetFlag;
983 if(UtopiaIoctl(pInstantMIU,MDrv_CMD_MIU_Protect,(void*)pMIUProtect) != UTOPIA_STATUS_SUCCESS)
984 {
985 ULOGE(TAG_MIU, "Ioctl MDrv_CMD_MIU_Protect fail\n");
986 bRet = FALSE;
987 }
988 else
989 {
990 bRet = TRUE;
991 }
992 free(pMIUProtect);
993 }
994 else
995 {
996 bRet = FALSE;
997 }
998
999 return bRet;
1000 }
1001
MDrv_MIU_ProtectEx(MS_U8 u8Blockx,MS_U32 * pu32ProtectId,MS_PHY phy64Start,MS_PHY phy64End,MS_BOOL bSetFlag)1002 MS_BOOL MDrv_MIU_ProtectEx( MS_U8 u8Blockx, MS_U32 *pu32ProtectId, MS_PHY phy64Start, MS_PHY phy64End, MS_BOOL bSetFlag )
1003 {
1004 PMIU_PROTECTEx pMIUProtect;
1005
1006 if (NULL != pInstantMIU)
1007 {
1008 pMIUProtect = (PMIU_PROTECTEx)malloc(sizeof(MIU_PROTECTEx));
1009 if (pMIUProtect == NULL)
1010 return FALSE;
1011 pMIUProtect->u8Blockx = u8Blockx;
1012 pMIUProtect->pu32ProtectId = pu32ProtectId;
1013 pMIUProtect->phy64Start = phy64Start;
1014 pMIUProtect->phy64End = phy64End;
1015 pMIUProtect->bSetFlag = bSetFlag;
1016 if(UtopiaIoctl(pInstantMIU,MDrv_CMD_MIU_ProtectEx,(void*)pMIUProtect) != UTOPIA_STATUS_SUCCESS)
1017 {
1018 printf("Ioctl MDrv_CMD_MIU_Protect fail\n");
1019 free(pMIUProtect);
1020 return FALSE;
1021 }
1022 free(pMIUProtect);
1023 }
1024 return TRUE;
1025 }
1026
MDrv_MIU_SelMIU(eMIUClientID eClientID,eMIU_SelType eType)1027 MS_BOOL MDrv_MIU_SelMIU(eMIUClientID eClientID, eMIU_SelType eType)
1028 {
1029 PMIU_SELMIU pMIUSelMIU;
1030 MS_BOOL bRet = TRUE;
1031 if (NULL != pInstantMIU)
1032 {
1033 pMIUSelMIU = (PMIU_SELMIU)malloc(sizeof(MIU_SELMIU));
1034 if (pMIUSelMIU == NULL)
1035 return FALSE;
1036 pMIUSelMIU->eClientID = eClientID;
1037 pMIUSelMIU->eType = eType;
1038 if(UtopiaIoctl(pInstantMIU,MDrv_CMD_MIU_SelMIU,(void*)pMIUSelMIU) != UTOPIA_STATUS_SUCCESS)
1039 {
1040 ULOGE(TAG_MIU, "Ioctl MDrv_CMD_MIU_SelMIU fail\n");
1041 bRet = FALSE;
1042 }
1043 else
1044 {
1045 bRet = TRUE;
1046 }
1047
1048 free(pMIUSelMIU);
1049 }
1050 else
1051 {
1052 bRet = FALSE;
1053 }
1054
1055 return bRet;
1056 }
1057
MDrv_MIU_GetProtectInfo(MS_U8 u8MiuDev,MIU_PortectInfo * pInfo)1058 MS_BOOL MDrv_MIU_GetProtectInfo(MS_U8 u8MiuDev, MIU_PortectInfo *pInfo)
1059 {
1060 PMIU_GETPROTECTINFO pMIUGetProtectInfo;
1061 MS_BOOL bRet = TRUE;
1062
1063 if (NULL != pInstantMIU)
1064 {
1065 pMIUGetProtectInfo = (PMIU_GETPROTECTINFO)malloc(sizeof(MIU_GETPROTECTINFO));
1066 if (pMIUGetProtectInfo == NULL)
1067 return FALSE;
1068 pMIUGetProtectInfo->u8MiuDev = u8MiuDev;
1069 pMIUGetProtectInfo->pInfo = pInfo;
1070 if(UtopiaIoctl(pInstantMIU,MDrv_CMD_MIU_GetProtectInfo,(void*)pMIUGetProtectInfo) != UTOPIA_STATUS_SUCCESS)
1071 {
1072 ULOGE(TAG_MIU, "Ioctl MDrv_CMD_MIU_GetProtectInfo fail\n");
1073 bRet = FALSE;
1074 }
1075 else
1076 {
1077 bRet = TRUE;
1078 }
1079 free(pMIUGetProtectInfo);
1080 }
1081 else
1082 {
1083 bRet = FALSE;
1084 }
1085
1086 return bRet;
1087 }
1088
MDrv_MIU_SetGroupPriority(MS_U8 u8MiuDev,MIU_GroupPriority sPriority)1089 MS_BOOL MDrv_MIU_SetGroupPriority(MS_U8 u8MiuDev, MIU_GroupPriority sPriority)
1090 {
1091 PMIU_SETGROUPPRIORITY pMIUSetGroupPri;
1092
1093 if (NULL != pInstantMIU)
1094 {
1095 pMIUSetGroupPri = (PMIU_SETGROUPPRIORITY)malloc(sizeof(MIU_SETGROUPPRIORITY));
1096 if (pMIUSetGroupPri == NULL)
1097 return FALSE;
1098 pMIUSetGroupPri->u8MiuDev = u8MiuDev;
1099 pMIUSetGroupPri->sPriority = sPriority;
1100 if(UtopiaIoctl(pInstantMIU,MDrv_CMD_MIU_SetGroupPriority,(void*)pMIUSetGroupPri) != UTOPIA_STATUS_SUCCESS)
1101 {
1102 ULOGE(TAG_MIU, "Ioctl MDrv_CMD_MIU_SetGroupPriority fail\n");
1103 free(pMIUSetGroupPri);
1104 return FALSE;
1105 }
1106 free(pMIUSetGroupPri);
1107 }
1108 return TRUE;
1109 }
1110
1111
MDrv_MIU_SetHPriorityMask(MS_U8 u8MiuDev,eMIUClientID eClientID,MS_BOOL bMask)1112 MS_BOOL MDrv_MIU_SetHPriorityMask(MS_U8 u8MiuDev, eMIUClientID eClientID, MS_BOOL bMask)
1113 {
1114 PMIU_SETHIGHPRIORITY pMIUSetHighPri;
1115
1116 if (NULL != pInstantMIU)
1117 {
1118 pMIUSetHighPri = (PMIU_SETHIGHPRIORITY)malloc(sizeof(MIU_SETHIGHPRIORITY));
1119 if (pMIUSetHighPri == NULL)
1120 return FALSE;
1121 pMIUSetHighPri->u8MiuDev = u8MiuDev;
1122 pMIUSetHighPri->eClientID = eClientID;
1123 pMIUSetHighPri->bMask = bMask;
1124 if(UtopiaIoctl(pInstantMIU,MDrv_CMD_MIU_SetHighPriority,(void*)pMIUSetHighPri) != UTOPIA_STATUS_SUCCESS)
1125 {
1126 ULOGE(TAG_MIU, "Ioctl MDrv_MIU_SetHPriorityMask fail\n");
1127 free(pMIUSetHighPri);
1128 return FALSE;
1129 }
1130 free(pMIUSetHighPri);
1131 }
1132 return TRUE;
1133 }
1134
1135
1136
MDrv_MIU_Init(void)1137 MS_BOOL MDrv_MIU_Init(void)
1138 {
1139 PMIU_RET pMIURet;
1140 MS_BOOL bRet = TRUE;
1141 if ( bMiuInit == FALSE)
1142 {
1143 //if(UtopiaOpen(MODULE_MIU | KERNEL_MODE, &pInstantMIU, 0, pAttributeMIU) != UTOPIA_STATUS_SUCCESS)
1144 if(UtopiaOpen(MODULE_MIU, &pInstantMIU, 0, pAttributeMIU) != UTOPIA_STATUS_SUCCESS)
1145 {
1146 ULOGE(TAG_MIU, "MIU had been initialized\n");
1147 return FALSE;
1148 }
1149 }
1150 if (NULL != pInstantMIU)
1151 {
1152 pMIURet = (PMIU_RET)malloc(sizeof(MIU_RET));
1153
1154 if(pMIURet == NULL)
1155 return FALSE;
1156
1157 if(UtopiaIoctl(pInstantMIU, MDrv_CMD_MIU_Init,(void*)pMIURet) != UTOPIA_STATUS_SUCCESS)
1158 {
1159 ULOGE(TAG_MIU, "Ioctl MDrv_MIU_SetHPriorityMask fail\n");
1160 bRet = FALSE;
1161 }
1162 else
1163 {
1164 bRet = TRUE;
1165 }
1166
1167 free(pMIURet);
1168 }
1169 else
1170 {
1171 bRet = FALSE;
1172 }
1173
1174 return bRet;
1175
1176 //return _MDrv_MIU_Init();
1177 }
1178
MDrv_MIU_PrintMIUProtectInfo(void)1179 void MDrv_MIU_PrintMIUProtectInfo(void)
1180 {
1181 return;
1182 if (NULL != pInstantMIU)
1183 {
1184 if(UtopiaIoctl(pInstantMIU,MDrv_CMD_MIU_PrintProtectInfo,(void*)NULL) != UTOPIA_STATUS_SUCCESS)
1185 {
1186 ULOGE(TAG_MIU, "Ioctl MDrv_MIU_SetHPriorityMask fail\n");
1187 return;
1188 }
1189 }
1190 return;
1191 }
1192
1193
1194
MDrv_MIU_Dram_Size(MS_U8 u8MiuDev,MS_U8 DramSize)1195 MS_BOOL MDrv_MIU_Dram_Size(MS_U8 u8MiuDev, MS_U8 DramSize)
1196 {
1197 PMIU_DRAM_SIZE pMIUDramSize = NULL;
1198 MS_BOOL bRet = TRUE;
1199
1200 if (NULL != pInstantMIU)
1201 {
1202 pMIUDramSize = (PMIU_DRAM_SIZE)malloc(sizeof(MIU_DRAM_SIZE));
1203 if (pMIUDramSize == NULL)
1204 return FALSE;
1205 pMIUDramSize->u8MiuDev = u8MiuDev;
1206 pMIUDramSize->DramSize = DramSize;
1207 pMIUDramSize->bRet = FALSE;
1208 if(UtopiaIoctl(pInstantMIU,MDrv_CMD_MIU_Dram_Size,(void*)pMIUDramSize) != UTOPIA_STATUS_SUCCESS)
1209 {
1210 ULOGE(TAG_MIU, "Ioctl MDrv_CMD_MIU_Dram_Size fail\n");
1211 bRet = FALSE;
1212 }
1213 else
1214 {
1215 bRet = pMIUDramSize->bRet;
1216 }
1217
1218 free(pMIUDramSize);
1219 }
1220 else
1221 {
1222 bRet = FALSE;
1223 }
1224
1225 return bRet;
1226 }
1227
MDrv_MIU_ProtectAlign(MS_U32 * u32PageShift)1228 MS_BOOL MDrv_MIU_ProtectAlign(MS_U32 *u32PageShift)
1229 {
1230 PMIU_PROTECT_ALIGN pMIUProtectAlign = NULL;
1231 MS_BOOL bRet = TRUE;
1232
1233 if (NULL != pInstantMIU)
1234 {
1235 pMIUProtectAlign = (PMIU_PROTECT_ALIGN)malloc(sizeof(MIU_PROTECT_ALIGN));
1236 if(pMIUProtectAlign == NULL)
1237 return FALSE;
1238 pMIUProtectAlign->u32PageShift = u32PageShift;
1239 pMIUProtectAlign->bRet = FALSE;
1240 if(UtopiaIoctl(pInstantMIU, MDrv_CMD_MIU_ProtectAlign,(void*)pMIUProtectAlign) != UTOPIA_STATUS_SUCCESS)
1241 {
1242 printf("Ioctl MDrv_CMD_MIU_ProtectAlign fail\n");
1243 bRet = FALSE;
1244 }
1245 else
1246 {
1247 bRet = pMIUProtectAlign->bRet;
1248 }
1249
1250 free(pMIUProtectAlign);
1251 }
1252 else
1253 {
1254 bRet = FALSE;
1255 }
1256
1257 return bRet;
1258 }
1259
MDrv_MIU_SetPowerState(EN_POWER_MODE u16PowerState)1260 MS_U32 MDrv_MIU_SetPowerState(EN_POWER_MODE u16PowerState)
1261 {
1262 static EN_POWER_MODE u16PreMIUPowerState = E_POWER_MECHANICAL;
1263 MS_U32 u32Return = UTOPIA_STATUS_FAIL;
1264
1265 if (u16PowerState == E_POWER_SUSPEND)
1266 {
1267 MDrv_MIU_Exit();
1268 u16PreMIUPowerState = u16PowerState;
1269 u32Return = UTOPIA_STATUS_SUCCESS;//SUSPEND_OK;
1270 }
1271 else if (u16PowerState == E_POWER_RESUME)
1272 {
1273 if (u16PreMIUPowerState == E_POWER_SUSPEND)
1274 {
1275 MDrv_MIU_Init();
1276
1277 u16PreMIUPowerState = u16PowerState;
1278 u32Return = UTOPIA_STATUS_SUCCESS;//RESUME_OK;
1279 }
1280 else
1281 {
1282 ULOGE(TAG_MIU, "[%s,%5d]It is not suspended yet. We shouldn't resume\n",__FUNCTION__,__LINE__);
1283 u32Return = UTOPIA_STATUS_FAIL;//SUSPEND_FAILED;
1284 }
1285 }
1286 else
1287 {
1288 ULOGE(TAG_MIU, "[%s,%5d]Do Nothing: %d\n",__FUNCTION__,__LINE__,u16PowerState);
1289 u32Return = UTOPIA_STATUS_FAIL;
1290 }
1291
1292 return u32Return;// for success
1293 }
1294
_MDrv_MIU_PrintMIUProtectInfo(void)1295 void _MDrv_MIU_PrintMIUProtectInfo(void)
1296 {
1297 HAL_MIU_PrintMIUProtectInfo();
1298 }
1299
1300 ////////////////////////////////////////////////////////////////////////////////
1301 /// @brief \b Function \b Name: MDrv_MIU_GetClientWidth
1302 /// @brief \b Function \b Description: Get MIU client bus width
1303 /// @param u8MiuDev \b IN : select MIU0 or MIU1
1304 /// @param eClientID \b IN : client ID
1305 /// @param pClientWidth \b IN : client bus width
1306 /// @return \b 0 : Fail 1: OK
1307 ////////////////////////////////////////////////////////////////////////////////
MDrv_MIU_GetClientWidth(MS_U8 u8MiuDevi,eMIUClientID eClientID,eMIU_ClientWidth * pClientWidth)1308 MS_BOOL MDrv_MIU_GetClientWidth(MS_U8 u8MiuDevi, eMIUClientID eClientID, eMIU_ClientWidth *pClientWidth)
1309 {
1310 return HAL_MIU_GetClientWidth(u8MiuDevi, eClientID, pClientWidth);
1311 }
1312
1313
MDrv_MIU_GetDramType(MIU_ID eMiu,MIU_DDR_TYPE * pType)1314 MS_BOOL MDrv_MIU_GetDramType(MIU_ID eMiu, MIU_DDR_TYPE* pType)
1315 {
1316 MIU_GETDRAMTYPE args;
1317 MS_BOOL bRet = TRUE;
1318
1319 if (NULL != pInstantMIU)
1320 {
1321 args.eMiu = eMiu;
1322 args.pType = pType;
1323
1324 if(UtopiaIoctl(pInstantMIU,MDrv_CMD_MIU_GetDramType,(void*)&args) != UTOPIA_STATUS_SUCCESS)
1325 {
1326 ULOGE(TAG_MIU, "Ioctl MDrv_CMD_MIU_GetDramType fail\n");
1327 bRet = FALSE;
1328 }
1329 }
1330 else
1331 {
1332 bRet = FALSE;
1333 }
1334
1335 return bRet;
1336 }
1337
_MDrv_MIU_GetDramType(MIU_ID eMiu,MIU_DDR_TYPE * pType)1338 MS_BOOL _MDrv_MIU_GetDramType(MIU_ID eMiu, MIU_DDR_TYPE* pType)
1339 {
1340 return HAL_MIU_GetDramType(eMiu, pType);
1341 }
1342