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!¡L) 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 // Common Definition
96 #ifndef MHAL_DYNAMICSCALING_C
97 #define MHAL_DYNAMICSCALING_C
98
99 #include "MsCommon.h"
100 #include "MsOS.h"
101 #include "mhal_xc_chip_config.h"
102 #include "utopia.h"
103 #include "utopia_dapi.h"
104 #if (SUPPORT_KERNEL_DS == 1)
105 #include "../../../drv/xc/mdrv_xc_st.h"
106 #include "../../../drv/xc/mdrv_xc_io.h"
107 #ifndef MSOS_TYPE_LINUX_KERNEL
108 #if (defined MSOS_TYPE_LINUX) || (defined ANDROID)
109 #include <sys/ioctl.h>
110 #include <sys/types.h>
111 #include <sys/stat.h>
112 #include <fcntl.h>
113 #include <unistd.h>
114 #endif
115 #endif
116 #endif
117
118 #include "halCHIP.h"
119 #include "drvXC_IOPort.h"
120 #include "xc_hwreg_utility2.h"
121 #include "hwreg_sc.h"
122 #include "apiXC.h"
123 #include "apiXC_Adc.h"
124 #include "apiXC_Auto.h"
125 #include "drv_sc_display.h"
126 #include "drv_sc_isr.h"
127 #include "apiXC_PCMonitor.h"
128 #include "apiXC_ModeParse.h"
129 #include "drvXC_HDMI_if.h"
130 #include "mvideo_context.h"
131 #include "drv_sc_ip.h"
132 #if (LD_ENABLE==1)
133 #include "mdrv_ld.h"
134 #include "mdrv_ldalgo.h"
135 #endif
136 #include "mdrv_sc_3d.h"
137 #include "drv_sc_menuload.h"
138 #include "drvXC_ADC_Internal.h"
139 #include "mhal_dynamicscaling.h"
140 #include "mhal_sc.h"
141 #if FRC_INSIDE
142 #include "mdrv_frc.h"
143 #include "mhal_frc.h"
144 #endif
145 #include "mhal_menuload.h"
146 #include "XC_private.h"
147 #include "apiXC_v2.h"
148 #include "mdrv_sc_dynamicscaling.h"
149
150 #ifdef MSOS_TYPE_LINUX
151 #include <assert.h>
152 #else
153 #define assert(b) \
154 do { \
155 if (!(b)){ \
156 printf("assert at [%s][%d] \n", __FUNCTION__, __LINE__); \
157 *((int*)0) = 0; \
158 } \
159 } while(0)
160 #endif
161
162 #define DS_DBG(x) //x
163 #define SLZ_DBG(x) //x
164
165 #if (SUPPORT_KERNEL_DS == 1)
166 #if (defined MSOS_TYPE_LINUX) || (defined ANDROID)
167 static MS_S32 _s32FdScaler = -1;
168 #endif
169 #endif
170
171 #if SUPPORT_SEAMLESS_ZAPPING
_Hal_SC_ResetDSCommand(SCALER_WIN eWindow,MS_U8 u8DSIndex)172 static void _Hal_SC_ResetDSCommand(SCALER_WIN eWindow, MS_U8 u8DSIndex)
173 {
174 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
175 UtopiaResourceGetPrivate(g_pXCResource[E_XC_POOL_ID_INTERNAL_VARIABLE],(void**)(&pXCResourcePrivate));
176 MS_PHY u32IndexBase = pXCResourcePrivate->sthal_SC.u32DynamicScalingBaseAddr + (MS_U32)u8DSIndex * pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth * MS_MLOAD_MEM_BASE_UNIT;
177 MS_U32 *pu32Data = NULL;
178 int i = 0;
179 SLZ_DBG(printf("@@#@@[%s]pXCResourcePrivate->sthal_SC.u32DynamicScalingBaseAddr=%lx, pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth=%u\n",
180 __FUNCTION__,
181 pXCResourcePrivate->sthal_SC.u32DynamicScalingBaseAddr,
182 pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth));
183 SLZ_DBG(printf("@@#@@u32IndexBase=%lx\n",u32IndexBase));
184 for(i = 0; i < (pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth * MS_MLOAD_MEM_BASE_UNIT)/4; i++)
185 {
186 if(i % 8 < 4)
187 {
188 if(MAIN_WINDOW == eWindow)
189 {
190 if(i % 4 < 2)
191 {
192 pu32Data = (MS_U32*)MsOS_PA2KSEG1(u32IndexBase + (i*4));
193 if(0 == pu32Data)
194 {
195 printf("%s :pu32Data_1 = 0!,error!!!\n", __FUNCTION__);
196 assert(pu32Data != 0);
197 }
198 *pu32Data = 0xFFFF0000;
199 }
200 }
201 else //SUB_WINDOW == eWindow
202 {
203 if(i % 4 >= 2)
204 {
205 pu32Data = (MS_U32*)MsOS_PA2KSEG1(u32IndexBase + (i*4));
206 if(0 == pu32Data)
207 {
208 printf("%s :pu32Data_2 = 0!,error!!!\n", __FUNCTION__);
209 assert(pu32Data != 0);
210 }
211 *pu32Data = 0xFFFF0000;
212 }
213 }
214 }
215 else
216 {
217 if(MAIN_WINDOW == eWindow)
218 {
219 if(i % 4 < 2)
220 {
221 pu32Data = (MS_U32*)MsOS_PA2KSEG1(u32IndexBase + (i*4));
222 if(0 == pu32Data)
223 {
224 printf("%s :pu32Data_3 = 0!,error!!!\n", __FUNCTION__);
225 assert(pu32Data != 0);
226 }
227 *pu32Data = 0xFFFF0000;//0;
228 }
229 }
230 else //SUB_WINDOW == eWindow
231 {
232 if(i % 4 >= 2)
233 {
234 pu32Data = (MS_U32*)MsOS_PA2KSEG1(u32IndexBase + (i*4));
235 if(0 == pu32Data)
236 {
237 printf("%s :pu32Data_4 = 0!,error!!!\n", __FUNCTION__);
238 assert(pu32Data != 0);
239 }
240 *pu32Data = 0xFFFF0000;
241 }
242 }
243 }
244 }
245 }
246
_Hal_SC_WriteDSCommand(SCALER_WIN eWindow,MS_U16 u16CmdRegAddr,MS_U16 u16CmdRegValue)247 static void _Hal_SC_WriteDSCommand(SCALER_WIN eWindow, MS_U16 u16CmdRegAddr, MS_U16 u16CmdRegValue)
248 {
249 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
250 UtopiaResourceGetPrivate(g_pXCResource[E_XC_POOL_ID_INTERNAL_VARIABLE],(void**)(&pXCResourcePrivate));
251
252 MS_PHY u32Addr = pXCResourcePrivate->sthal_SC.u32DynamicScalingBaseAddr + pXCResourcePrivate->sthal_SC.u8SeamlessZappingNextIndex[eWindow] * pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth * MS_MLOAD_MEM_BASE_UNIT;
253 MS_U32 *pu32Data = NULL;
254 MS_U8 u8Count = pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth;
255 MS_PHY u32Command = 0;
256
257 if(SUB_WINDOW == eWindow)
258 {
259 u32Addr += 8; // Move to OP sub command
260 }
261
262 u32Command = u16CmdRegValue + ((u16CmdRegAddr & 0x00FF) << 15) + ((u16CmdRegAddr & 0xFF00) << 16);
263
264 while(u8Count > 0)
265 {
266 pu32Data = (MS_U32*)MsOS_PA2KSEG1(u32Addr);
267 if(0 == pu32Data)
268 {
269 printf("%s :pu32Data = 0!,error!!!\n", __FUNCTION__);
270 assert(pu32Data != 0);
271 }
272 // Found null command
273 if(*pu32Data == 0xFFFF0000)
274 {
275 break;
276 }
277 // Found duplicated command
278 if(*pu32Data == u32Command)
279 {
280 DS_DBG(printf("Command duplicated\n"));
281 return;
282 }
283 u32Addr += MS_MLOAD_MEM_BASE_UNIT;
284 u8Count--;
285 }
286
287 if(*pu32Data == 0xFFFF0000)
288 {
289 *pu32Data = u32Command;
290 }
291 else
292 {
293 printf("DS buffer is full for this index %u!\n", pXCResourcePrivate->sthal_SC.u8SeamlessZappingNextIndex[eWindow]);
294 }
295 //printf("@@[%s][%u]u16CmdRegAddr=%x, u16CmdRegValue=%x\n",__FUNCTION__, __LINE__, u16CmdRegAddr, u16CmdRegValue);
296 }
297
Hal_SC_PrepareSeamlessZapping(SCALER_WIN eWindow)298 void Hal_SC_PrepareSeamlessZapping(SCALER_WIN eWindow )
299 {
300 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
301 UtopiaResourceGetPrivate(g_pXCResource[E_XC_POOL_ID_INTERNAL_VARIABLE],(void**)(&pXCResourcePrivate));
302
303
304 SLZ_DBG(printf("@@#@@1.[%s]@@FRZ=%x,pXCResourcePrivate->sthal_SC.u8SeamlessZappingCurIndex[MAIN_WINDOW]=%x, pXCResourcePrivate->sthal_SC.u8SeamlessZappingNextIndex[MAIN_WINDOW]=%x\n",
305 __FUNCTION__,
306 Hal_SC_get_freezeimg(MAIN_WINDOW),
307 pXCResourcePrivate->sthal_SC.u8SeamlessZappingCurIndex[MAIN_WINDOW],
308 pXCResourcePrivate->sthal_SC.u8SeamlessZappingNextIndex[MAIN_WINDOW]));
309
310 /// Reset the DS Memory
311
312 /// for 2nd Seamless Zapping operating
313 if(pXCResourcePrivate->sthal_SC.u8SeamlessZappingCurIndex[eWindow] == 0)
314 {
315 pXCResourcePrivate->sthal_SC.u8SeamlessZappingNextIndex[eWindow] = 1;
316 }
317 else
318 {
319 pXCResourcePrivate->sthal_SC.u8SeamlessZappingNextIndex[eWindow] = 0;
320 }
321 SLZ_DBG(printf("@@#@@2.[%s]@@FRZ=%x,pXCResourcePrivate->sthal_SC.u8SeamlessZappingCurIndex[MAIN_WINDOW]=%x, pXCResourcePrivate->sthal_SC.u8SeamlessZappingNextIndex[MAIN_WINDOW]=%x\n",
322 __FUNCTION__,
323 Hal_SC_get_freezeimg(MAIN_WINDOW),
324 pXCResourcePrivate->sthal_SC.u8SeamlessZappingCurIndex[MAIN_WINDOW],
325 pXCResourcePrivate->sthal_SC.u8SeamlessZappingNextIndex[MAIN_WINDOW]));
326
327 {
328 MS_U8 u8index = 0;
329 for(u8index=0; u8index<(sizeof(pXCResourcePrivate->sthal_SC.u8SeamlessZappingNextIndex)/sizeof(pXCResourcePrivate->sthal_SC.u8SeamlessZappingNextIndex[0])); u8index++)
330 {
331 _Hal_SC_ResetDSCommand(eWindow, u8index);
332 }
333 }
334 }
335 #endif
336
337 //CMD in DRAM: with dummy command
338 // |------ 128 bit ------|
339 // | CMD0 | CMD1 |
340 // | dummy | dummy |
341 // | CMD2 | CMD3 |
342 // | dummy | dummy |
343 //CMD in DRAM: no dummy command
344 // |------ 128 bit ------|
345 // | CMD0 | CMD1 |
346 // | CMD2 | CMD3 |
347 // | CMD4 | CMD5 |
348 // | CMD6 | CMD7 |
Hal_SC_WriteDSCommand(void * pInstance,ds_reg_ip_op_sel IPOP_Sel,MS_U32 u32Index,MS_U64 u64DSCmd,SCALER_WIN eWindow)349 void Hal_SC_WriteDSCommand(void *pInstance, ds_reg_ip_op_sel IPOP_Sel, MS_U32 u32Index, MS_U64 u64DSCmd, SCALER_WIN eWindow)
350 {
351 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
352 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
353 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
354 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
355
356 MS_PHY u32IndexBase = 0;
357 MS_U32 u32Offset = 0;
358 MS_U64 *pu64Data = NULL;
359 MS_U32 u32CmdCntPerMIUBus = (MS_MLOAD_BUS_WIDTH/DS_CMD_LEN_64BITS);
360
361 if (u32CmdCntPerMIUBus == 0)
362 {
363 printf("assert! u32CmdCntPerMIUBus=0!! \n");
364 assert(0);
365 }
366
367 u32Offset = (u32Index/u32CmdCntPerMIUBus)*MS_MLOAD_MEM_BASE_UNIT + (u32Index%u32CmdCntPerMIUBus)*DS_CMD_LEN_64BITS;
368
369 if(eWindow == MAIN_WINDOW)
370 {
371 if(IPOP_Sel == DS_IP)
372 {
373 u32IndexBase= pXCResourcePrivate->sthal_SC.u32DynamicScalingBaseAddr;
374 }
375 else
376 {
377 u32IndexBase= pXCResourcePrivate->sthal_SC.u32DynamicScalingBaseAddr_OPM;
378 }
379 }
380 else
381 {
382 if(IPOP_Sel == DS_IP)
383 {
384 u32IndexBase= pXCResourcePrivate->sthal_SC.u32DynamicScalingBaseAddr_IPS;
385 }
386 else
387 {
388 u32IndexBase= pXCResourcePrivate->sthal_SC.u32DynamicScalingBaseAddr_OPS;
389 }
390 }
391
392 u32IndexBase += (MS_U32)pXCResourcePrivate->sthal_SC.u8DynamicScalingCurrentIndex_Ring[eWindow] * pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth * MS_MLOAD_MEM_BASE_UNIT + u32Offset;
393 pu64Data = (MS_U64*)MsOS_PA2KSEG1(u32IndexBase);
394 *pu64Data = u64DSCmd;
395 }
396
397 #if (SUPPORT_KERNEL_DS == 1)
398 #ifdef MSOS_TYPE_LINUX_KERNEL
399 extern E_K_APIXC_ReturnValue KApi_XC_Set_DSForceIndex(EN_KDRV_SC_DEVICE u32DeviceID, MS_BOOL bEnable, MS_U8 u8Index, EN_KDRV_WINDOW eWindow);
400 extern void KApi_XC_WriteSWDSCommand(EN_KDRV_SC_DEVICE u32DeviceID,EN_KDRV_WINDOW eWindow,E_DS_CLIENT client, MS_U32 u32CmdRegAddr, MS_U16 u16CmdRegValue,k_ds_reg_ip_op_sel IPOP_Sel,k_ds_reg_source_sel Source_Select,K_XC_DS_CMDCNT *pstXC_DS_CmdCnt);
401 extern void KApi_XC_WriteSWDSCommandNonXC(EN_KDRV_SC_DEVICE u32DeviceID, EN_KDRV_WINDOW eWindow, E_DS_CLIENT client, MS_U32 u32Bank, MS_U16 u32Addr, MS_U32 u16Data, MS_U16 u16Mask, k_ds_reg_ip_op_sel IPOP_Sel, K_XC_DS_CMDCNT *pstXC_DS_CmdCnt);
402 extern void KApi_XC_WriteSWDSCommand_Mask(EN_KDRV_SC_DEVICE u32DeviceID,EN_KDRV_WINDOW eWindow,E_DS_CLIENT client, MS_U32 u32CmdRegAddr, MS_U16 u16CmdRegValue,k_ds_reg_ip_op_sel IPOP_Sel,k_ds_reg_source_sel Source_Select,K_XC_DS_CMDCNT *pstXC_DS_CmdCnt,MS_U16 u16Mask);
403 extern void KApi_XC_Add_NullCommand(EN_KDRV_SC_DEVICE u32DeviceID,EN_KDRV_WINDOW eWindow,E_DS_CLIENT client,k_ds_reg_ip_op_sel IPOP_Sel,K_XC_DS_CMDCNT *pstXC_DS_CmdCnt);
404 #endif
405 #endif
406 //clear DS Buffer
Hal_SC_ResetSWDSCommand(void * pInstance,SCALER_WIN eWindow,MS_U8 u8DSIndex)407 void Hal_SC_ResetSWDSCommand(void *pInstance,SCALER_WIN eWindow, MS_U8 u8DSIndex)
408 {
409 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
410 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
411 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
412 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
413
414 #if ENABLE_64BITS_SPREAD_MODE
415
416 MS_PHY u32IndexBase = pXCResourcePrivate->sthal_SC.u32DynamicScalingBaseAddr;
417
418 MS_U16 u16TotalCmdCnt = pXCResourcePrivate->sthal_SC.u32DynamicScalingBufSize/DS_CMD_LEN_64BITS/2;
419 MS_U16 i = 0;
420
421 MS_U16 u16SWRstCmd_Pointer = (BYTE_PER_WORD*(pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth-1))/DS_CMD_LEN_64BITS;
422 MS_U64 *pu64Data = NULL;
423 MS_U32 ActiveSWClearEn = 0;
424 MS_U16 u16CmdCntPerIndex = pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth*(BYTE_PER_WORD/DS_CMD_LEN_64BITS);
425
426 if((u16SWRstCmd_Pointer == 0 ) || (u16SWRstCmd_Pointer == 1))
427 {
428 printf("%s :u16SWRstCmd_Pointer <= 0,error!!!\n", __FUNCTION__);
429 MS_ASSERT(u16SWRstCmd_Pointer > 0);
430 }
431 else
432 {
433 MS_PHY u32IPBaseAddr = u32IndexBase;
434 for(i = 0; i < u16TotalCmdCnt; i++)
435 {
436 pu64Data = (MS_U64*)MsOS_PA2KSEG1(u32IPBaseAddr + i*DS_CMD_LEN_64BITS);
437
438 if((i%u16CmdCntPerIndex) == 0)
439 {
440 //0xFFFF00098F97048F; //BK1F_17[10] : reg_ds_ipm_active_sel: 0:HW 1:SW
441
442 MS_U32 u32SW_Reset_Enable = 0;
443 //ActiveSWClearEn enable in first DS IP command ;
444 u32SW_Reset_Enable = 0x4000; // bit14: reg_ds_active_sw_clr_en,set ds_activating cleared by SW
445 ActiveSWClearEn = SC_R2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK1F_17_L, 0xFFFF);
446 ActiveSWClearEn |= u32SW_Reset_Enable;
447
448 *pu64Data = Hal_SC_GenSpreadModeCmd(pInstance, REG_SC_BK1F_17_L, (MS_U16)(ActiveSWClearEn), 0xFFFF, DS_XC);
449 }
450 else if((i%u16CmdCntPerIndex) == u16SWRstCmd_Pointer)
451 {
452 //toggle reg_ds_ipm_active_set in last DS IP command
453 //0xFFFF00098F97058F;//BK1F_17[8] : reg_ds_ipm_active_set
454 MS_U32 u32SW_Reset_IPM = 0;
455 u32SW_Reset_IPM = 0x0010 ;//bit4 : reg_ds_ipm_active_clr
456 ActiveSWClearEn |= u32SW_Reset_IPM;
457
458 *pu64Data = Hal_SC_GenSpreadModeCmd(pInstance, REG_SC_BK1F_17_L, (MS_U16)(ActiveSWClearEn), 0xFFFF, DS_XC);
459 }
460 else
461 {
462 *pu64Data = MS_DS_NULL_CMD_64BITS; //Dummy cmd BKFF_7F=0x0000
463 }
464 }
465
466 MS_PHY u32OPBaseAddr = u32IndexBase + pXCResourcePrivate->sthal_SC.u32DynamicScalingBufSize/2;
467 for(i = 0; i < u16TotalCmdCnt; i++)
468 {
469 pu64Data = (MS_U64*)MsOS_PA2KSEG1(u32OPBaseAddr + i*DS_CMD_LEN_64BITS);
470 *pu64Data = MS_DS_NULL_CMD_64BITS; //Dummy cmd BKFF_7F=0x0000
471 }
472 }
473 #else
474 MS_PHY u32IndexBase = pXCResourcePrivate->sthal_SC.u32DynamicScalingBaseAddr + (MS_U32)u8DSIndex * pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth * MS_MLOAD_MEM_BASE_UNIT;
475
476 MS_U32 *pu32Data = NULL;
477 int i = 0;
478
479 //XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[%s,%5d] [DS] u32DSBaseAddr:%lx u32IndexBase:%ld u8DSIndexDepth:%d \n",__func__,__LINE__,pXCResourcePrivate->sthal_SC.u32DynamicScalingBaseAddr,u32IndexBase,pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth);
480
481 for(i = 0; i < (pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth * MS_MLOAD_MEM_BASE_UNIT)/4; i++) //need check
482 {
483 if(i % 8 < 4)
484 {
485 if(MAIN_WINDOW == eWindow)
486 {
487 if(i % 4 < 2)
488 {
489 pu32Data = (MS_U32*)MsOS_PA2KSEG1(u32IndexBase + (i*4));
490 if(0 == pu32Data)
491 {
492 printf("%s :pu32Data_1 = 0!,error!!!\n", __FUNCTION__);
493 assert(pu32Data != 0);
494 }
495 *pu32Data = 0xFFFF0000;
496 }
497 }
498 else //SUB_WINDOW == eWindow
499 {
500 if(i % 4 >= 2)
501 {
502 pu32Data = (MS_U32*)MsOS_PA2KSEG1(u32IndexBase + (i*4));
503 if(0 == pu32Data)
504 {
505 printf("%s :pu32Data_2 = 0!,error!!!\n", __FUNCTION__);
506 assert(pu32Data != 0);
507 }
508 *pu32Data = 0xFFFF0000;
509 }
510 }
511 }
512 else
513 {
514 if(MAIN_WINDOW == eWindow)
515 {
516 if(i % 4 < 2)
517 {
518 pu32Data = (MS_U32*)MsOS_PA2KSEG1(u32IndexBase + (i*4));
519 if(0 == pu32Data)
520 {
521 printf("%s :pu32Data_3 = 0!,error!!!\n", __FUNCTION__);
522 assert(pu32Data != 0);
523 }
524 *pu32Data = 0xFFFF0000;//0;
525
526 //printf("[szuhua] [%s,%5d] [IP] 0xFFFF0000 \n",__func__,__LINE__);
527 }
528 }
529 else //SUB_WINDOW == eWindow
530 {
531 if(i % 4 >= 2)
532 {
533 pu32Data = (MS_U32*)MsOS_PA2KSEG1(u32IndexBase + (i*4));
534 if(0 == pu32Data)
535 {
536 printf("%s :pu32Data_4 = 0!,error!!!\n", __FUNCTION__);
537 assert(pu32Data != 0);
538 }
539 *pu32Data = 0xFFFF0000;
540 }
541 }
542 }
543 }
544 #endif
545 }
546
Hal_SC_WriteSWDSCommand(void * pInstance,SCALER_WIN eWindow,MS_U32 u32CmdRegAddr,MS_U16 u16CmdRegValue,ds_reg_ip_op_sel IPOP_Sel,ds_reg_source_sel Source_Select,XC_DS_CMDCNT * pstXC_DS_CmdCnt)547 void Hal_SC_WriteSWDSCommand(void *pInstance,SCALER_WIN eWindow, MS_U32 u32CmdRegAddr, MS_U16 u16CmdRegValue,ds_reg_ip_op_sel IPOP_Sel,ds_reg_source_sel Source_Select,XC_DS_CMDCNT *pstXC_DS_CmdCnt)
548 {
549 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
550 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
551 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
552 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
553 #if (SUPPORT_KERNEL_DS == 1)
554 #ifdef MSOS_TYPE_LINUX_KERNEL
555 EN_KDRV_SC_DEVICE u32DeviceID;
556 if(psXCInstPri->u32DeviceID == 0)
557 {
558 u32DeviceID = E_KDRV_XC_SC0;
559 }
560 else
561 {
562 u32DeviceID = E_KDRV_XC_SC1;
563 }
564 KApi_XC_WriteSWDSCommand(u32DeviceID,eWindow,E_DS_CLIENT_XC,u32CmdRegAddr,u16CmdRegValue,IPOP_Sel,Source_Select,(K_XC_DS_CMDCNT *)pstXC_DS_CmdCnt);
565 return;
566 #else
567 #if (defined MSOS_TYPE_LINUX) || (defined ANDROID)
568 if(0 > _s32FdScaler)
569 {
570 _s32FdScaler = open("/dev/scaler", O_WRONLY | O_NDELAY);
571 }
572
573 if (0 > _s32FdScaler)
574 {
575 printf("\nUnable to open /dev/scaler\n");
576 return ;
577 }
578 else
579 {
580 ST_KDRV_DS_WriteSWDSCommand k_ds_WriteSWDSCommand;
581 if(psXCInstPri->u32DeviceID == 0)
582 k_ds_WriteSWDSCommand.u32DeviceID = E_KDRV_XC_SC0;
583 else
584 k_ds_WriteSWDSCommand.u32DeviceID = E_KDRV_XC_SC1;
585 k_ds_WriteSWDSCommand.eWindow = eWindow;
586 k_ds_WriteSWDSCommand.client = E_DS_CLIENT_XC;
587 k_ds_WriteSWDSCommand.u32CmdRegAddr = u32CmdRegAddr;
588 k_ds_WriteSWDSCommand.u16CmdRegValue = u16CmdRegValue;
589 k_ds_WriteSWDSCommand.IPOP_Sel = IPOP_Sel;
590 k_ds_WriteSWDSCommand.Source_Select = Source_Select;
591 k_ds_WriteSWDSCommand.pstXC_DS_CmdCnt = (K_XC_DS_CMDCNT *)pstXC_DS_CmdCnt;
592 if (-1 == ioctl(_s32FdScaler, MDRV_XC_IOC_DS_WRITE_SWDS_CMD,&k_ds_WriteSWDSCommand))
593 {
594 perror("ioctl");
595 return ;
596 }
597 return ;
598 }
599 #endif
600 #endif
601 #else
602
603 #if ENABLE_DS_4_BASEADDR_MODE
604 MS_PHY u32Addr = pXCResourcePrivate->sthal_SC.u32DynamicScalingBaseAddr + pXCResourcePrivate->sthal_SC.u8DynamicScalingCurrentIndex_Ring[eWindow] * pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth * MS_MLOAD_MEM_BASE_UNIT;
605 MS_PHY u32Addr_IPS = pXCResourcePrivate->sthal_SC.u32DynamicScalingBaseAddr_IPS + pXCResourcePrivate->sthal_SC.u8DynamicScalingCurrentIndex_Ring[eWindow] * pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth * MS_MLOAD_MEM_BASE_UNIT;
606 #else
607 MS_PHY u32Addr = pXCResourcePrivate->sthal_SC.u32DynamicScalingBaseAddr + pXCResourcePrivate->sthal_SC.u8DynamicScalingCurrentIndex_Ring[eWindow] * pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth * MS_MLOAD_MEM_BASE_UNIT;
608 #endif
609
610 //XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[%s,%5d] [DS] u32DynamicScalingBaseAddr:%x CurIdx:%d IdxDepth:%d BYTE_PER_WORD:%d \n",__func__,__LINE__,(int)pXCResourcePrivate->sthal_SC.u32DynamicScalingBaseAddr,(int)pXCResourcePrivate->sthal_SC.u8DynamicScalingCurrentIndex[eWindow],(int)pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth,(int)BYTE_PER_WORD);
611 //XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[%s,%5d] [DS] u32Addr:%x \n",__func__,__LINE__,(int)u32Addr);
612
613 #if ENABLE_DS_4_BASEADDR_MODE
614
615 MS_U64 *pu64Data = NULL;
616 MS_U64 u64CmdTemp = 0;
617 MS_U8 u8AddrTemp = 0;
618 MS_U16 u16BankTemp = 0;
619 MS_U16 u16DataTemp = 0;
620 MS_U16 u16MaskTemp = 0;
621 MS_U8 u8MaxCmdCnt = pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth * (Hal_XC_MLoad_Get_64Bits_MIU_Bus_Sel(pInstance) + 1);
622
623 //===========================================================//
624 // 64bit command format (spread mode)
625 // |-------------|-------------|----------------------------|-------------|
626 // | Bit-En | Unused | Addr(FULL RIU ADDR) | Data |
627 // |-------------|-------------|----------------------------|-------------|
628 // | [63:48] | [47:40] | [39:16] | [15:0] |
629 // |-------------|-------------|----------------------------|-------------|
630
631 //Addr: FULL RIU ADDRESS !!!
632
633 //For example: Subbank:0x01 addr:0x40 Data:0x0001
634 // Spread mode : 0x1301 addr:0x40 Data:0x0001
635
636 //|----------------------------------------------------|
637 //| Bank | addr |
638 //|----------------------------------------------------|
639 //| 0x1301 | 0x40 |
640 //|----------------------------------------------------|
641 // FULL RIU ADDRESS: |0001 0011 0000 0001 | 100 0000 |
642 // FULL RIU ADDRESS: 0x0980C1
643 //===========================================================//
644
645 if(Source_Select == DS_XC)
646 {
647 u16MaskTemp = 0xFFFF;
648 u16DataTemp = (SC_R2BYTE(psXCInstPri->u32DeviceID,u32CmdRegAddr) & ~0xFFFF) | (u16CmdRegValue & 0xFFFF);
649
650 u8AddrTemp= (u32CmdRegAddr & 0x000000FF) >> 1;
651 u16BankTemp= 0x1300 | ((u32CmdRegAddr >> 8) & 0x000000FF); // 0x13XX xc sread mode address
652
653 u64CmdTemp|= (MS_U64)u16DataTemp;
654 u64CmdTemp|= ((MS_U64)u8AddrTemp<<16);
655 u64CmdTemp|= ((MS_U64)u16BankTemp<<23);
656 u64CmdTemp|= ((MS_U64)u16MaskTemp<<48);
657
658 if(IPOP_Sel == DS_IP)
659 {
660 if(eWindow == MAIN_WINDOW)
661 {
662 if(pstXC_DS_CmdCnt->u16CMDCNT_IPM < u8MaxCmdCnt)
663 {
664 Hal_SC_WriteDSCommand(pInstance, DS_IP, pstXC_DS_CmdCnt->u16CMDCNT_IPM, u64CmdTemp, eWindow);
665 pstXC_DS_CmdCnt->u16CMDCNT_IPM++;
666 }
667 else
668 {
669 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[%s,%5d] [DS] IPM Command count overflow !! u16CMDCNT_IPM:%d Max command count: %d\n",__func__,__LINE__,pstXC_DS_CmdCnt->u16CMDCNT_IPM,pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth);
670 }
671 }
672 else//subwindow
673 {
674 if(pstXC_DS_CmdCnt->u16CMDCNT_IPS < u8MaxCmdCnt)
675 {
676 Hal_SC_WriteDSCommand(pInstance, DS_IP, pstXC_DS_CmdCnt->u16CMDCNT_IPS, u64CmdTemp, eWindow);
677 pstXC_DS_CmdCnt->u16CMDCNT_IPS++;
678 }
679 else
680 {
681 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[%s,%5d] [DS] IPS Command count overflow !! u16CMDCNT_IPS:%d Max command count: %d\n",__func__,__LINE__,pstXC_DS_CmdCnt->u16CMDCNT_IPS,pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth);
682 }
683 }
684 }
685 else//DS_OP
686 {
687 if(eWindow == MAIN_WINDOW)
688 {
689 if(pstXC_DS_CmdCnt->u16CMDCNT_OPM < u8MaxCmdCnt)
690 {
691 Hal_SC_WriteDSCommand(pInstance, DS_OP, pstXC_DS_CmdCnt->u16CMDCNT_OPM, u64CmdTemp, eWindow);
692 pstXC_DS_CmdCnt->u16CMDCNT_OPM++;
693 }
694 else
695 {
696 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[%s,%5d] [DS] OPM Command count overflow !! u16CMDCNT_OPM:%d Max command count: %d\n",__func__,__LINE__,pstXC_DS_CmdCnt->u16CMDCNT_OPM,pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth);
697 }
698 }
699 else
700 {
701 if(pstXC_DS_CmdCnt->u16CMDCNT_OPS < u8MaxCmdCnt)
702 {
703 Hal_SC_WriteDSCommand(pInstance, DS_OP, pstXC_DS_CmdCnt->u16CMDCNT_OPS, u64CmdTemp, eWindow);
704 pstXC_DS_CmdCnt->u16CMDCNT_OPS++;
705 }
706 else
707 {
708 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[%s,%5d] [DS] OPS Command count overflow !! u16CMDCNT_OPS:%d Max command count: %d\n",__func__,__LINE__,pstXC_DS_CmdCnt->u16CMDCNT_OPS,pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth);
709 }
710 }
711 }
712 }
713 else if(Source_Select == DS_MVOP)// only in IP cmd
714 {
715 if(IPOP_Sel == DS_IP)
716 {
717 u16DataTemp = u16CmdRegValue;
718 u8AddrTemp = (u32CmdRegAddr&0x000000FF);
719 u16BankTemp = (u32CmdRegAddr&0x00FFFF00) >> 8; //EX: mvop mainwinodw: 0x1014 mvop bank
720 u16MaskTemp = 0xFFFF;
721
722 u64CmdTemp|= (MS_U64)u16DataTemp;
723 u64CmdTemp|= ((MS_U64)u8AddrTemp<<16) >> 1;
724 u64CmdTemp|= ((MS_U64)u16BankTemp<<23);
725 u64CmdTemp|= ((MS_U64)u16MaskTemp<<48);
726
727 if(eWindow == MAIN_WINDOW)
728 {
729 MS_U32 u32MemShift_IPM;
730
731 if((MS_MLOAD_BUS_WIDTH == 16) && (BYTE_PER_WORD == 32))
732 {
733 //CMD in DRAM: with dummy command
734
735 // |------ 128 bit ------|
736 // | CMD0 | CMD1 |
737 // | dummy | dummy |
738 // | CMD2 | CMD3 |
739 // | dummy | dummy |
740
741 if((pstXC_DS_CmdCnt->u16CMDCNT_IPM % 2) == 0)
742 {
743 u32MemShift_IPM = (pstXC_DS_CmdCnt->u16CMDCNT_IPM / 2) * MS_MLOAD_MEM_BASE_UNIT;
744 }
745 else
746 {
747 u32MemShift_IPM = (pstXC_DS_CmdCnt->u16CMDCNT_IPM / 2) * MS_MLOAD_MEM_BASE_UNIT + DS_CMD_LEN_64BITS;
748 }
749 }
750 else // ((MS_MLOAD_BUS_WIDTH == 16) && (BYTE_PER_WORD == 16)) or ((MS_MLOAD_BUS_WIDTH == 32) && (BYTE_PER_WORD == 32))
751 {
752 //CMD in DRAM: no dummy command
753
754 // |------ 128 bit ------|
755 // | CMD0 | CMD1 |
756 // | CMD2 | CMD3 |
757 // | CMD4 | CMD5 |
758 // | CMD6 | CMD7 |
759
760 u32MemShift_IPM = pstXC_DS_CmdCnt->u16CMDCNT_IPM * DS_CMD_LEN_64BITS;
761 }
762
763 //XC_PRINTF("[%s,%5d] [DS_IP(MVOP)]pstXC_DS_CmdCnt->u16CMDCNT_IPM:%d u32MemShift_IPM:%lx \n",__func__,__LINE__,pstXC_DS_CmdCnt->u16CMDCNT_IPM,(MS_U32)u32MemShift_IPM);
764 //u32Addr = u32Addr + DS_CMD_LEN_64BITS * pstXC_DS_CmdCnt->u16CMDCNT_IPM;
765 u32Addr = u32Addr + u32MemShift_IPM;
766 pu64Data = (MS_U64*)MsOS_PA2KSEG1(u32Addr);//IPM
767
768 if(pstXC_DS_CmdCnt->u16CMDCNT_IPM < u8MaxCmdCnt)
769 {
770 *pu64Data = u64CmdTemp;
771 pstXC_DS_CmdCnt->u16CMDCNT_IPM++;
772 }
773 else
774 {
775 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[%s,%5d] [DS] Command count overflow !! u16CMDCNT_IPM:%d Max command count: %d\n",__func__,__LINE__,pstXC_DS_CmdCnt->u16CMDCNT_IPM,u8MaxCmdCnt);
776 }
777 }
778 else
779 {
780 MS_U32 u32MemShift_IPS;
781
782 if((MS_MLOAD_BUS_WIDTH == 16) && (BYTE_PER_WORD == 32))
783 {
784 //CMD in DRAM: with dummy command
785
786 // |------ 128 bit ------|
787 // | CMD0 | CMD1 |
788 // | dummy | dummy |
789 // | CMD2 | CMD3 |
790 // | dummy | dummy |
791
792 if((pstXC_DS_CmdCnt->u16CMDCNT_IPS % 2) == 0)
793 {
794 u32MemShift_IPS = (pstXC_DS_CmdCnt->u16CMDCNT_IPS / 2) * MS_MLOAD_MEM_BASE_UNIT;
795 }
796 else
797 {
798 u32MemShift_IPS = (pstXC_DS_CmdCnt->u16CMDCNT_IPS / 2) * MS_MLOAD_MEM_BASE_UNIT + DS_CMD_LEN_64BITS;
799 }
800 }
801 else // ((MS_MLOAD_BUS_WIDTH == 16) && (BYTE_PER_WORD == 16)) or ((MS_MLOAD_BUS_WIDTH == 32) && (BYTE_PER_WORD == 32))
802 {
803 //CMD in DRAM: no dummy command
804
805 // |------ 128 bit ------|
806 // | CMD0 | CMD1 |
807 // | CMD2 | CMD3 |
808 // | CMD4 | CMD5 |
809 // | CMD6 | CMD7 |
810
811 u32MemShift_IPS = pstXC_DS_CmdCnt->u16CMDCNT_IPS * DS_CMD_LEN_64BITS;
812 }
813
814 //XC_PRINTF("[%s,%5d] [DS_IP(MVOP)]pstXC_DS_CmdCnt->u16CMDCNT_IPS:%d u32MemShift_IPS:%lx \n",__func__,__LINE__,pstXC_DS_CmdCnt->u16CMDCNT_IPS,(MS_U32)u32MemShift_IPS);
815
816 u32Addr_IPS = u32Addr_IPS + u32MemShift_IPS;
817 pu64Data = (MS_U64*)MsOS_PA2KSEG1(u32Addr_IPS); // IPS
818
819 if(pstXC_DS_CmdCnt->u16CMDCNT_IPS < u8MaxCmdCnt)
820 {
821 *pu64Data = u64CmdTemp;
822 pstXC_DS_CmdCnt->u16CMDCNT_IPS++;
823 }
824 else
825 {
826 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[%s,%5d] [DS] IPS Command count overflow !! u16CMDCNT_IPS:%d Max command count: %d\n",__func__,__LINE__,pstXC_DS_CmdCnt->u16CMDCNT_IPS,u8MaxCmdCnt);
827 }
828 }
829 }
830 else
831 {
832 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[%s,%5d] [DS] MVOP is IP cmd not OP cmd !! \n",__func__,__LINE__);
833 }
834
835 }
836 else if(Source_Select == DS_GOP)
837 {
838
839 }
840 else
841 {
842 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[%s,%5d] [DS] Only can support XC/MVOP/GOP NOW !! \n",__func__,__LINE__);
843 }
844
845 #else
846
847 //=============================================//
848 // 32bit command format
849 // |-------------|-------------|-------------|
850 // | Bank | Addr | Data |
851 // |-------------|-------------|-------------|
852 // | [31:24] | [23:16] | [15:0] |
853 // |-------------|-------------|-------------|
854
855 //Bank: Subbank
856 //=============================================//
857
858 if(IPOP_Sel == DS_OP)
859 {
860 MS_PHY u32OPAddr = u32Addr;
861 MS_U32 *pu32Data = NULL;
862 MS_U8 u8OPCount = pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth;
863 // MS_U8 u8OPCount = IdxDepth;
864 MS_PHY u32Command = 0;
865
866 u32Command = u16CmdRegValue + ((u32CmdRegAddr & 0x00FF) << 15) + ((u32CmdRegAddr & 0xFF00) << 16);
867
868 while(u8OPCount > 0)
869 {
870 pu32Data = (MS_U32*)MsOS_PA2KSEG1(u32OPAddr);
871 if(0 == pu32Data)
872 {
873 printf("%s :pu32Data = 0!,error!!!\n", __FUNCTION__);
874
875 assert(pu32Data != 0);
876 }
877 // Found null command
878 if((MS_U32)(*pu32Data) == 0xFFFF0000)
879 {
880 break;
881 }
882 // Found duplicated command
883 if((MS_U32)(*pu32Data) == u32Command)
884 {
885 //SC_DBG(printf("Command duplicated\n"));
886
887 return;
888 }
889 u32OPAddr += MS_MLOAD_MEM_BASE_UNIT;
890 u8OPCount--;
891 }
892
893 if((MS_U32)(*pu32Data) == 0xFFFF0000)
894 {
895 *pu32Data = u32Command;
896 }
897 else
898 {
899 printf("DS OP command buffer is full for this index %u!\n", pXCResourcePrivate->sthal_SC.u8DynamicScalingCurrentIndex[eWindow]);
900 }
901 //printf("@@[%s][%u]u16CmdRegAddr=%x, u16CmdRegValue=%x\n",__FUNCTION__, __LINE__, u16CmdRegAddr, u16CmdRegValue);
902 }
903
904 else
905 {
906 // (OP : IP : Unused : Unused) (4 byte : 4 byte : 4 byte : 4 byte) if MIU 128bit
907 // (OPmain : IPmain : OPsub : IPsub) (4 byte : 4 byte : 4 byte : 4 byte) if MIU 128bit
908
909 MS_PHY u32IPAddr = u32Addr + DS_OP_CMD_LEN;
910 MS_U32 *pu32Data = NULL;
911 MS_U8 u8IPCount = pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth;
912 //MS_U8 u8IPCount = IdxDepth;
913 MS_PHY u32Command = 0;
914
915 u32Command = u16CmdRegValue + ((u32CmdRegAddr & 0x00FF) << 15) + ((u32CmdRegAddr & 0xFF00) << 16);
916
917 while(u8IPCount > 0)
918 {
919 pu32Data = (MS_U32*)MsOS_PA2KSEG1(u32IPAddr);
920 if(0 == pu32Data)
921 {
922 printf("%s :pu32Data = 0!,error!!!\n", __FUNCTION__);
923
924 assert(pu32Data != 0);
925 }
926 // Found null command
927 if((MS_U32)(*pu32Data) == 0xFFFF0000)
928 {
929 break;
930 }
931 // Found duplicated command
932 if((MS_U32)(*pu32Data) == u32Command)
933 {
934 return;
935 }
936 u32IPAddr += MS_MLOAD_MEM_BASE_UNIT;
937 u8IPCount--;
938 }
939
940 if((MS_U32)(*pu32Data) == 0xFFFF0000)
941 {
942 *pu32Data = u32Command;
943 }
944 else
945 {
946 printf("DS IP command buffer is full for this index %u!\n", pXCResourcePrivate->sthal_SC.u8DynamicScalingCurrentIndex[eWindow]);
947 }
948 //printf("@@[%s][%u]u16CmdRegAddr=%x, u16CmdRegValue=%x\n",__FUNCTION__, __LINE__, u16CmdRegAddr, u16CmdRegValue);
949 }
950 #endif
951 #endif //SUPPORT_KERNEL_DS
952 }
953
954 //WriteDSCommand for general case @u32Addr:8bit address
Hal_SC_WriteSWDSCommand_NonXC(void * pInstance,SCALER_WIN eWindow,MS_U32 u32Bank,MS_U32 u32Addr,MS_U16 u16Data,MS_U16 u16Mask,ds_reg_ip_op_sel IPOP_Sel,XC_DS_CMDCNT * pstXC_DS_CmdCnt)955 void Hal_SC_WriteSWDSCommand_NonXC(void *pInstance,SCALER_WIN eWindow,MS_U32 u32Bank,MS_U32 u32Addr, MS_U16 u16Data, MS_U16 u16Mask,ds_reg_ip_op_sel IPOP_Sel,XC_DS_CMDCNT *pstXC_DS_CmdCnt)
956 {
957 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
958 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
959 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
960 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
961 #if (SUPPORT_KERNEL_DS == 1)
962 #ifdef MSOS_TYPE_LINUX_KERNEL
963 EN_KDRV_SC_DEVICE u32DeviceID;
964 if(psXCInstPri->u32DeviceID == 0)
965 {
966 u32DeviceID = E_KDRV_XC_SC0;
967 }
968 else
969 {
970 u32DeviceID = E_KDRV_XC_SC1;
971 }
972 KApi_XC_WriteSWDSCommandNonXC(u32DeviceID,eWindow,E_DS_CLIENT_XC,u32Bank,u32Addr,u16Data,u16Mask,IPOP_Sel,(K_XC_DS_CMDCNT *)pstXC_DS_CmdCnt);
973 return;
974 #else
975 #if (defined MSOS_TYPE_LINUX) || (defined ANDROID)
976 if(0 > _s32FdScaler)
977 {
978 _s32FdScaler = open("/dev/scaler", O_WRONLY | O_NDELAY);
979 }
980
981 if (0 > _s32FdScaler)
982 {
983 printf("\nUnable to open /dev/scaler\n");
984 return ;
985 }
986 else
987 {
988 ST_KDRV_DS_WriteSWDSCommandNonXC k_ds_WriteSWDSCommandNonXC;
989 if(psXCInstPri->u32DeviceID == 0)
990 k_ds_WriteSWDSCommandNonXC.u32DeviceID = E_KDRV_XC_SC0;
991 else
992 k_ds_WriteSWDSCommandNonXC.u32DeviceID = E_KDRV_XC_SC1;
993 k_ds_WriteSWDSCommandNonXC.client = E_DS_CLIENT_XC;
994 k_ds_WriteSWDSCommandNonXC.eWindow = eWindow;
995 k_ds_WriteSWDSCommandNonXC.u32Bank = u32Bank;
996 k_ds_WriteSWDSCommandNonXC.u32Addr = u32Addr;
997 k_ds_WriteSWDSCommandNonXC.u16Data = u16Data;
998 k_ds_WriteSWDSCommandNonXC.u16Mask = u16Mask;
999 k_ds_WriteSWDSCommandNonXC.IPOP_Sel = IPOP_Sel;
1000 k_ds_WriteSWDSCommandNonXC.pstXC_DS_CmdCnt = (K_XC_DS_CMDCNT *)pstXC_DS_CmdCnt;
1001 if (-1 == ioctl(_s32FdScaler, MDRV_XC_IOC_DS_WRITE_SWDS_NONXC_CMD, &k_ds_WriteSWDSCommandNonXC))
1002 {
1003 perror("ioctl");
1004 return ;
1005 }
1006 return ;
1007 }
1008 #endif
1009 #endif
1010 #else
1011
1012 #if ENABLE_DS_4_BASEADDR_MODE
1013 MS_PHY u32Addr_OPM = pXCResourcePrivate->sthal_SC.u32DynamicScalingBaseAddr_OPM + pXCResourcePrivate->sthal_SC.u8DynamicScalingCurrentIndex_Ring[eWindow] * pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth * MS_MLOAD_MEM_BASE_UNIT;
1014 MS_PHY u32Addr_IPS = pXCResourcePrivate->sthal_SC.u32DynamicScalingBaseAddr_IPS + pXCResourcePrivate->sthal_SC.u8DynamicScalingCurrentIndex_Ring[eWindow] * pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth * MS_MLOAD_MEM_BASE_UNIT;
1015 MS_PHY u32Addr_OPS = pXCResourcePrivate->sthal_SC.u32DynamicScalingBaseAddr_OPS + pXCResourcePrivate->sthal_SC.u8DynamicScalingCurrentIndex_Ring[eWindow] * pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth * MS_MLOAD_MEM_BASE_UNIT;
1016 #endif
1017 MS_PHY u32Addr_IPM = pXCResourcePrivate->sthal_SC.u32DynamicScalingBaseAddr + pXCResourcePrivate->sthal_SC.u8DynamicScalingCurrentIndex_Ring[eWindow] * pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth * MS_MLOAD_MEM_BASE_UNIT;
1018
1019
1020 MS_U8 u8MaxCmdCnt = pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth * (Hal_XC_MLoad_Get_64Bits_MIU_Bus_Sel(pInstance) + 1);
1021 MS_U64 *pu64Data = NULL;
1022 MS_U64 u64CmdTemp = 0;
1023
1024 u64CmdTemp = ((MS_U64)((MDrv_Read2Byte((u32Bank<<8)| u32Addr) & ~u16Mask) | (u16Data & u16Mask)));
1025 u64CmdTemp|= ((MS_U64) ((u32Addr<<16) >>1));
1026 u64CmdTemp|= ((MS_U64)u32Bank<<23);
1027 u64CmdTemp|= ((MS_U64)0xFFFF<<48);
1028
1029 if(IPOP_Sel == DS_IP)
1030 {
1031 if(eWindow == MAIN_WINDOW)
1032 {
1033 MS_U32 u32MemShift_IPM;
1034
1035 if((MS_MLOAD_BUS_WIDTH == 16) && (BYTE_PER_WORD == 32))
1036 {
1037 //CMD in DRAM: with dummy command
1038
1039 // |------ 128 bit ------|
1040 // | CMD0 | CMD1 |
1041 // | dummy | dummy |
1042 // | CMD2 | CMD3 |
1043 // | dummy | dummy |
1044 if((pstXC_DS_CmdCnt->u16CMDCNT_IPM % 2) == 0)
1045 {
1046 u32MemShift_IPM = (pstXC_DS_CmdCnt->u16CMDCNT_IPM / 2) * MS_MLOAD_MEM_BASE_UNIT;
1047 }
1048 else
1049 {
1050 u32MemShift_IPM = (pstXC_DS_CmdCnt->u16CMDCNT_IPM / 2) * MS_MLOAD_MEM_BASE_UNIT + DS_CMD_LEN_64BITS;
1051 }
1052 }
1053 else // ((MS_MLOAD_BUS_WIDTH == 16) && (BYTE_PER_WORD == 16)) or ((MS_MLOAD_BUS_WIDTH == 32) && (BYTE_PER_WORD == 32))
1054 {
1055 //CMD in DRAM: no dummy command
1056
1057 // |------ 128 bit ------|
1058 // | CMD0 | CMD1 |
1059 // | CMD2 | CMD3 |
1060 // | CMD4 | CMD5 |
1061 // | CMD6 | CMD7 |
1062
1063 u32MemShift_IPM = pstXC_DS_CmdCnt->u16CMDCNT_IPM * DS_CMD_LEN_64BITS;
1064 }
1065
1066 //XC_PRINTF("[%s,%5d] [DS_IP]pstXC_DS_CmdCnt->u16CMDCNT_IPM:%d u32MemShift_IPM:%lx \n",__func__,__LINE__,pstXC_DS_CmdCnt->u16CMDCNT_IPM,(MS_U32)u32MemShift_IPM);
1067 //u32Addr = u32Addr + DS_CMD_LEN_64BITS * pstXC_DS_CmdCnt->u16CMDCNT_IPM;
1068 u32Addr_IPM = u32Addr_IPM + u32MemShift_IPM;
1069 pu64Data = (MS_U64*)MsOS_PA2KSEG1(u32Addr_IPM);//IPM
1070
1071 if(pstXC_DS_CmdCnt->u16CMDCNT_IPM < u8MaxCmdCnt)
1072 {
1073 *pu64Data = u64CmdTemp;
1074 pstXC_DS_CmdCnt->u16CMDCNT_IPM++;
1075 }
1076 else
1077 {
1078 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[%s,%5d] [DS] IPM Command count overflow !! u16CMDCNT_IPM:%d Max command count: %d\n",__func__,__LINE__,pstXC_DS_CmdCnt->u16CMDCNT_IPM,u8MaxCmdCnt);
1079 }
1080 }
1081 else//subwindow
1082 {
1083 MS_U32 u32MemShift_IPS;
1084
1085 if((MS_MLOAD_BUS_WIDTH == 16) && (BYTE_PER_WORD == 32))
1086 {
1087 //CMD in DRAM: with dummy command
1088
1089 // |------ 128 bit ------|
1090 // | CMD0 | CMD1 |
1091 // | dummy | dummy |
1092 // | CMD2 | CMD3 |
1093 // | dummy | dummy |
1094
1095 if((pstXC_DS_CmdCnt->u16CMDCNT_IPS % 2) == 0)
1096 {
1097 u32MemShift_IPS = (pstXC_DS_CmdCnt->u16CMDCNT_IPS / 2) * MS_MLOAD_MEM_BASE_UNIT;
1098 }
1099 else
1100 {
1101 u32MemShift_IPS = (pstXC_DS_CmdCnt->u16CMDCNT_IPS / 2) * MS_MLOAD_MEM_BASE_UNIT + DS_CMD_LEN_64BITS;
1102 }
1103 }
1104 else // ((MS_MLOAD_BUS_WIDTH == 16) && (BYTE_PER_WORD == 16)) or ((MS_MLOAD_BUS_WIDTH == 32) && (BYTE_PER_WORD == 32))
1105 {
1106 //CMD in DRAM: no dummy command
1107
1108 // |------ 128 bit ------|
1109 // | CMD0 | CMD1 |
1110 // | CMD2 | CMD3 |
1111 // | CMD4 | CMD5 |
1112 // | CMD6 | CMD7 |
1113
1114 u32MemShift_IPS = pstXC_DS_CmdCnt->u16CMDCNT_IPS * DS_CMD_LEN_64BITS;
1115 }
1116
1117 //XC_PRINTF("[%s,%5d] [DS_IP(MVOP)]pstXC_DS_CmdCnt->u16CMDCNT_IPS:%d u32MemShift_IPS:%lx \n",__func__,__LINE__,pstXC_DS_CmdCnt->u16CMDCNT_IPS,(MS_U32)u32MemShift_IPS);
1118
1119 u32Addr_IPS = u32Addr_IPS + u32MemShift_IPS;
1120 pu64Data = (MS_U64*)MsOS_PA2KSEG1(u32Addr_IPS); // IPS
1121
1122 if(pstXC_DS_CmdCnt->u16CMDCNT_IPS < u8MaxCmdCnt)
1123 {
1124 *pu64Data = u64CmdTemp;
1125 pstXC_DS_CmdCnt->u16CMDCNT_IPS++;
1126 }
1127 else
1128 {
1129 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[%s,%5d] [DS] IPS Command count overflow !! u16CMDCNT_IPS:%d Max command count: %d\n",__func__,__LINE__,pstXC_DS_CmdCnt->u16CMDCNT_IPS,u8MaxCmdCnt);
1130 }
1131 }
1132 }
1133 else// DS_OP
1134 {
1135 if(eWindow == MAIN_WINDOW)
1136 {
1137 MS_U32 u32MemShift_OPM;
1138
1139 if((MS_MLOAD_BUS_WIDTH == 16) && (BYTE_PER_WORD == 32))
1140 {
1141 //CMD in DRAM: with dummy command
1142
1143 // |------ 128 bit ------|
1144 // | CMD0 | CMD1 |
1145 // | dummy | dummy |
1146 // | CMD2 | CMD3 |
1147 // | dummy | dummy |
1148 if((pstXC_DS_CmdCnt->u16CMDCNT_OPM % 2) == 0)
1149 {
1150 u32MemShift_OPM = (pstXC_DS_CmdCnt->u16CMDCNT_OPM / 2) * MS_MLOAD_MEM_BASE_UNIT;
1151 }
1152 else
1153 {
1154 u32MemShift_OPM = (pstXC_DS_CmdCnt->u16CMDCNT_OPM / 2) * MS_MLOAD_MEM_BASE_UNIT + DS_CMD_LEN_64BITS;
1155 }
1156 }
1157 else // ((MS_MLOAD_BUS_WIDTH == 16) && (BYTE_PER_WORD == 16)) or ((MS_MLOAD_BUS_WIDTH == 32) && (BYTE_PER_WORD == 32))
1158 {
1159 //CMD in DRAM: no dummy command
1160
1161 // |------ 128 bit ------|
1162 // | CMD0 | CMD1 |
1163 // | CMD2 | CMD3 |
1164 // | CMD4 | CMD5 |
1165 // | CMD6 | CMD7 |
1166
1167 u32MemShift_OPM = pstXC_DS_CmdCnt->u16CMDCNT_OPM * DS_CMD_LEN_64BITS;
1168 }
1169 //XC_PRINTF("[%s,%5d] [DS_OP]pstXC_DS_CmdCnt->u16CMDCNT_OPM:%d u32MemShift_OPM:%lx \n",__func__,__LINE__,pstXC_DS_CmdCnt->u16CMDCNT_OPM,(MS_U32)u32MemShift_OPM);
1170 //u32Addr_OPM = u32Addr_OPM + DS_CMD_LEN_64BITS * pstXC_DS_CmdCnt->u16CMDCNT_OPM;
1171 u32Addr_OPM = u32Addr_OPM + u32MemShift_OPM;
1172 pu64Data = (MS_U64*)MsOS_PA2KSEG1(u32Addr_OPM);//OPM
1173
1174 //XC_PRINTF("[%s,%5d] u64CmdTemp:%llx \n",__func__,__LINE__,u64CmdTemp);
1175
1176 if(pstXC_DS_CmdCnt->u16CMDCNT_OPM < u8MaxCmdCnt)
1177 {
1178 *pu64Data = u64CmdTemp;
1179 pstXC_DS_CmdCnt->u16CMDCNT_OPM++;
1180 }
1181 else
1182 {
1183 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[%s,%5d] [DS] OPM Command count overflow !! u16CMDCNT_OPM:%d Max command count: %d\n",__func__,__LINE__,pstXC_DS_CmdCnt->u16CMDCNT_OPM,u8MaxCmdCnt);
1184 }
1185
1186 }
1187 else
1188 {
1189 MS_U32 u32MemShift_OPS;
1190
1191 if((MS_MLOAD_BUS_WIDTH == 16) && (BYTE_PER_WORD == 32))
1192 {
1193 //CMD in DRAM: with dummy command
1194
1195 // |------ 128 bit ------|
1196 // | CMD0 | CMD1 |
1197 // | dummy | dummy |
1198 // | CMD2 | CMD3 |
1199 // | dummy | dummy |
1200
1201 if((pstXC_DS_CmdCnt->u16CMDCNT_OPS % 2) == 0)
1202 {
1203 u32MemShift_OPS = (pstXC_DS_CmdCnt->u16CMDCNT_OPS / 2) * MS_MLOAD_MEM_BASE_UNIT;
1204 }
1205 else
1206 {
1207 u32MemShift_OPS = (pstXC_DS_CmdCnt->u16CMDCNT_OPS / 2) * MS_MLOAD_MEM_BASE_UNIT + DS_CMD_LEN_64BITS;
1208 }
1209 }
1210 else // ((MS_MLOAD_BUS_WIDTH == 16) && (BYTE_PER_WORD == 16)) or ((MS_MLOAD_BUS_WIDTH == 32) && (BYTE_PER_WORD == 32))
1211 {
1212 //CMD in DRAM: no dummy command
1213
1214 // |------ 128 bit ------|
1215 // | CMD0 | CMD1 |
1216 // | CMD2 | CMD3 |
1217 // | CMD4 | CMD5 |
1218 // | CMD6 | CMD7 |
1219
1220 u32MemShift_OPS = pstXC_DS_CmdCnt->u16CMDCNT_OPS * DS_CMD_LEN_64BITS;
1221 }
1222
1223 //XC_PRINTF("[%s,%5d] [DS_IP(MVOP)]pstXC_DS_CmdCnt->u16CMDCNT_OPS:%d u32MemShift_OPS:%lx \n",__func__,__LINE__,pstXC_DS_CmdCnt->u16CMDCNT_OPS,(MS_U32)u32MemShift_OPS);
1224
1225 u32Addr_OPS = u32Addr_OPS + u32MemShift_OPS;
1226 pu64Data = (MS_U64*)MsOS_PA2KSEG1(u32Addr_OPS); // IPS
1227
1228 if(pstXC_DS_CmdCnt->u16CMDCNT_OPS < u8MaxCmdCnt)
1229 {
1230 *pu64Data = u64CmdTemp;
1231 pstXC_DS_CmdCnt->u16CMDCNT_OPS++;
1232 }
1233 else
1234 {
1235 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[%s,%5d] [DS] IPS Command count overflow !! u16CMDCNT_IPS:%d Max command count: %d\n",__func__,__LINE__,pstXC_DS_CmdCnt->u16CMDCNT_OPS,u8MaxCmdCnt);
1236 }
1237 }
1238 }
1239 #endif
1240 }
1241
Hal_SC_WriteSWDSCommand_Mask(void * pInstance,SCALER_WIN eWindow,MS_U32 u32CmdRegAddr,MS_U16 u16CmdRegValue,ds_reg_ip_op_sel IPOP_Sel,ds_reg_source_sel Source_Select,XC_DS_CMDCNT * pstXC_DS_CmdCnt,MS_U16 u16Mask)1242 void Hal_SC_WriteSWDSCommand_Mask(void *pInstance,SCALER_WIN eWindow, MS_U32 u32CmdRegAddr, MS_U16 u16CmdRegValue,ds_reg_ip_op_sel IPOP_Sel,ds_reg_source_sel Source_Select,XC_DS_CMDCNT *pstXC_DS_CmdCnt,MS_U16 u16Mask)
1243 {
1244 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1245 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1246 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1247 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1248 #if (SUPPORT_KERNEL_DS == 1)
1249 #ifdef MSOS_TYPE_LINUX_KERNEL
1250 EN_KDRV_SC_DEVICE u32DeviceID;
1251 if(psXCInstPri->u32DeviceID == 0)
1252 {
1253 u32DeviceID = E_KDRV_XC_SC0;
1254 }
1255 else
1256 {
1257 u32DeviceID = E_KDRV_XC_SC1;
1258 }
1259 KApi_XC_WriteSWDSCommand_Mask(u32DeviceID,eWindow,E_DS_CLIENT_XC,u32CmdRegAddr,u16CmdRegValue,IPOP_Sel,Source_Select,(K_XC_DS_CMDCNT *)pstXC_DS_CmdCnt,u16Mask);
1260 return;
1261 #else
1262 #if (defined MSOS_TYPE_LINUX) || (defined ANDROID)
1263 if(0 > _s32FdScaler)
1264 {
1265 _s32FdScaler = open("/dev/scaler", O_WRONLY | O_NDELAY);
1266 }
1267
1268 if (0 > _s32FdScaler)
1269 {
1270 printf("\nUnable to open /dev/scaler\n");
1271 return ;
1272 }
1273 else
1274 {
1275 ST_KDRV_DS_WriteSWDSCommand_Mask k_ds_WriteSWDSCommand_Mask;
1276 if(psXCInstPri->u32DeviceID == 0)
1277 k_ds_WriteSWDSCommand_Mask.u32DeviceID = E_KDRV_XC_SC0;
1278 else
1279 k_ds_WriteSWDSCommand_Mask.u32DeviceID = E_KDRV_XC_SC1;
1280 k_ds_WriteSWDSCommand_Mask.eWindow = eWindow;
1281 k_ds_WriteSWDSCommand_Mask.client = E_DS_CLIENT_XC;
1282 k_ds_WriteSWDSCommand_Mask.u32CmdRegAddr = u32CmdRegAddr;
1283 k_ds_WriteSWDSCommand_Mask.u16CmdRegValue = u16CmdRegValue;
1284 k_ds_WriteSWDSCommand_Mask.u16Mask = u16Mask;
1285 k_ds_WriteSWDSCommand_Mask.IPOP_Sel = IPOP_Sel;
1286 k_ds_WriteSWDSCommand_Mask.Source_Select = Source_Select;
1287 k_ds_WriteSWDSCommand_Mask.pstXC_DS_CmdCnt = (K_XC_DS_CMDCNT *)pstXC_DS_CmdCnt;
1288 if (-1 == ioctl(_s32FdScaler, MDRV_XC_IOC_DS_WRITE_SWDS_CMD_MASK,&k_ds_WriteSWDSCommand_Mask))
1289 {
1290 perror("ioctl");
1291 return ;
1292 }
1293 return ;
1294 }
1295 #endif
1296 #endif
1297
1298
1299 #else
1300
1301 #if ENABLE_DS_4_BASEADDR_MODE
1302 MS_PHY u32Addr = pXCResourcePrivate->sthal_SC.u32DynamicScalingBaseAddr + pXCResourcePrivate->sthal_SC.u8DynamicScalingCurrentIndex_Ring[eWindow] * pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth * MS_MLOAD_MEM_BASE_UNIT;
1303 MS_PHY u32Addr_IPS = pXCResourcePrivate->sthal_SC.u32DynamicScalingBaseAddr_IPS + pXCResourcePrivate->sthal_SC.u8DynamicScalingCurrentIndex_Ring[eWindow] * pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth * MS_MLOAD_MEM_BASE_UNIT;
1304 #else
1305 MS_PHY u32Addr = pXCResourcePrivate->sthal_SC.u32DynamicScalingBaseAddr + pXCResourcePrivate->sthal_SC.u8DynamicScalingCurrentIndex_Ring[eWindow] * pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth * MS_MLOAD_MEM_BASE_UNIT;
1306 #endif
1307
1308 //XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[%s,%5d] [DS] u32DynamicScalingBaseAddr:%x CurIdx:%d IdxDepth:%d BYTE_PER_WORD:%d \n",__func__,__LINE__,(int)pXCResourcePrivate->sthal_SC.u32DynamicScalingBaseAddr,(int)pXCResourcePrivate->sthal_SC.u8DynamicScalingCurrentIndex[eWindow],(int)pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth,(int)BYTE_PER_WORD);
1309 //XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[%s,%5d] [DS] u32Addr:%x \n",__func__,__LINE__,(int)u32Addr);
1310
1311 #if ENABLE_DS_4_BASEADDR_MODE
1312
1313 MS_U64 *pu64Data = NULL;
1314 MS_U64 u64CmdTemp = 0;
1315 MS_U8 u8AddrTemp = 0;
1316 MS_U16 u16BankTemp = 0;
1317 MS_U16 u16DataTemp = 0;
1318 //MS_U16 u16MaskTemp = 0;
1319 MS_U8 u8MaxCmdCnt = pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth * (Hal_XC_MLoad_Get_64Bits_MIU_Bus_Sel(pInstance) + 1);
1320
1321 //===========================================================//
1322 // 64bit command format (spread mode)
1323 // |-------------|-------------|----------------------------|-------------|
1324 // | Bit-En | Unused | Addr(FULL RIU ADDR) | Data |
1325 // |-------------|-------------|----------------------------|-------------|
1326 // | [63:48] | [47:40] | [39:16] | [15:0] |
1327 // |-------------|-------------|----------------------------|-------------|
1328
1329 //Addr: FULL RIU ADDRESS !!!
1330
1331 //For example: Subbank:0x01 addr:0x40 Data:0x0001
1332 // Spread mode : 0x1301 addr:0x40 Data:0x0001
1333
1334 //|----------------------------------------------------|
1335 //| Bank | addr |
1336 //|----------------------------------------------------|
1337 //| 0x1301 | 0x40 |
1338 //|----------------------------------------------------|
1339 // FULL RIU ADDRESS: |0001 0011 0000 0001 | 100 0000 |
1340 // FULL RIU ADDRESS: 0x0980C1
1341 //===========================================================//
1342
1343 if(Source_Select == DS_XC)
1344 {
1345
1346 //u16MaskTemp = 0xFFFF;
1347 //u16DataTemp = (SC_R2BYTE(psXCInstPri->u32DeviceID,u32CmdRegAddr) & ~u16MaskTemp) | (u16CmdRegValue & u16MaskTemp);
1348 //u16DataTemp = (SC_R2BYTE(psXCInstPri->u32DeviceID,u32CmdRegAddr) & ~u16Mask) | (u16CmdRegValue & u16Mask);
1349
1350 //printf("\033[1;31m[%s:%d] u32CmdRegAddr:%x u16CmdRegValue:%x u16Mask:%x \033[m\n",__FUNCTION__,__LINE__,u32CmdRegAddr,u16CmdRegValue,u16Mask);
1351
1352 u8AddrTemp= (u32CmdRegAddr & 0x000000FF) >> 1;
1353 u16BankTemp= 0x1300 | ((u32CmdRegAddr >> 8) & 0x000000FF); // 0x13XX xc sread mode address
1354
1355 //u64CmdTemp|= (MS_U64)u16DataTemp;
1356 u64CmdTemp|= (MS_U64)u16CmdRegValue;
1357 u64CmdTemp|= ((MS_U64)u8AddrTemp<<16);
1358 u64CmdTemp|= ((MS_U64)u16BankTemp<<23);
1359 //u64CmdTemp|= ((MS_U64)u16MaskTemp<<48);
1360 u64CmdTemp|= ((MS_U64)(~u16Mask)<<48);
1361
1362 if(IPOP_Sel == DS_IP)
1363 {
1364 if(eWindow == MAIN_WINDOW)
1365 {
1366 if(pstXC_DS_CmdCnt->u16CMDCNT_IPM < u8MaxCmdCnt)
1367 {
1368 Hal_SC_WriteDSCommand(pInstance, DS_IP, pstXC_DS_CmdCnt->u16CMDCNT_IPM, u64CmdTemp, eWindow);
1369 pstXC_DS_CmdCnt->u16CMDCNT_IPM++;
1370 }
1371 else
1372 {
1373 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[%s,%5d] [DS] IPM Command count overflow !! u16CMDCNT_IPM:%d Max command count: %d\n",__func__,__LINE__,pstXC_DS_CmdCnt->u16CMDCNT_IPM,pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth);
1374 }
1375 }
1376 else//subwindow
1377 {
1378 if(pstXC_DS_CmdCnt->u16CMDCNT_IPS < u8MaxCmdCnt)
1379 {
1380 Hal_SC_WriteDSCommand(pInstance, DS_IP, pstXC_DS_CmdCnt->u16CMDCNT_IPS, u64CmdTemp, eWindow);
1381 pstXC_DS_CmdCnt->u16CMDCNT_IPS++;
1382 }
1383 else
1384 {
1385 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[%s,%5d] [DS] IPS Command count overflow !! u16CMDCNT_IPS:%d Max command count: %d\n",__func__,__LINE__,pstXC_DS_CmdCnt->u16CMDCNT_IPS,pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth);
1386 }
1387 }
1388 }
1389 else//DS_OP
1390 {
1391 if(eWindow == MAIN_WINDOW)
1392 {
1393 if(pstXC_DS_CmdCnt->u16CMDCNT_OPM < u8MaxCmdCnt)
1394 {
1395 Hal_SC_WriteDSCommand(pInstance, DS_OP, pstXC_DS_CmdCnt->u16CMDCNT_OPM, u64CmdTemp, eWindow);
1396 pstXC_DS_CmdCnt->u16CMDCNT_OPM++;
1397 }
1398 else
1399 {
1400 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[%s,%5d] [DS] OPM Command count overflow !! u16CMDCNT_OPM:%d Max command count: %d\n",__func__,__LINE__,pstXC_DS_CmdCnt->u16CMDCNT_OPM,pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth);
1401 }
1402 }
1403 else
1404 {
1405 if(pstXC_DS_CmdCnt->u16CMDCNT_OPS < u8MaxCmdCnt)
1406 {
1407 Hal_SC_WriteDSCommand(pInstance, DS_OP, pstXC_DS_CmdCnt->u16CMDCNT_OPS, u64CmdTemp, eWindow);
1408 pstXC_DS_CmdCnt->u16CMDCNT_OPS++;
1409 }
1410 else
1411 {
1412 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[%s,%5d] [DS] OPS Command count overflow !! u16CMDCNT_OPS:%d Max command count: %d\n",__func__,__LINE__,pstXC_DS_CmdCnt->u16CMDCNT_OPS,pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth);
1413 }
1414 }
1415 }
1416 }
1417 else if(Source_Select == DS_MVOP)// only in IP cmd
1418 {
1419 if(IPOP_Sel == DS_IP)
1420 {
1421 u16DataTemp = u16CmdRegValue;
1422 u8AddrTemp = (u32CmdRegAddr&0x000000FF);
1423 u16BankTemp = (u32CmdRegAddr&0x00FFFF00) >> 8; //EX: mvop mainwinodw: 0x1014 mvop bank
1424 //u16MaskTemp = 0xFFFF;
1425
1426 u64CmdTemp|= (MS_U64)u16DataTemp;
1427 u64CmdTemp|= ((MS_U64)u8AddrTemp<<16) >> 1;
1428 u64CmdTemp|= ((MS_U64)u16BankTemp<<23);
1429 //u64CmdTemp|= ((MS_U64)u16MaskTemp<<48);
1430 u64CmdTemp|= ((MS_U64)~u16Mask<<48);
1431
1432 if(eWindow == MAIN_WINDOW)
1433 {
1434 MS_U32 u32MemShift_IPM;
1435
1436 if((MS_MLOAD_BUS_WIDTH == 16) && (BYTE_PER_WORD == 32))
1437 {
1438 //CMD in DRAM: with dummy command
1439
1440 // |------ 128 bit ------|
1441 // | CMD0 | CMD1 |
1442 // | dummy | dummy |
1443 // | CMD2 | CMD3 |
1444 // | dummy | dummy |
1445
1446 if((pstXC_DS_CmdCnt->u16CMDCNT_IPM % 2) == 0)
1447 {
1448 u32MemShift_IPM = (pstXC_DS_CmdCnt->u16CMDCNT_IPM / 2) * MS_MLOAD_MEM_BASE_UNIT;
1449 }
1450 else
1451 {
1452 u32MemShift_IPM = (pstXC_DS_CmdCnt->u16CMDCNT_IPM / 2) * MS_MLOAD_MEM_BASE_UNIT + DS_CMD_LEN_64BITS;
1453 }
1454 }
1455 else // ((MS_MLOAD_BUS_WIDTH == 16) && (BYTE_PER_WORD == 16)) or ((MS_MLOAD_BUS_WIDTH == 32) && (BYTE_PER_WORD == 32))
1456 {
1457 //CMD in DRAM: no dummy command
1458
1459 // |------ 128 bit ------|
1460 // | CMD0 | CMD1 |
1461 // | CMD2 | CMD3 |
1462 // | CMD4 | CMD5 |
1463 // | CMD6 | CMD7 |
1464
1465 u32MemShift_IPM = pstXC_DS_CmdCnt->u16CMDCNT_IPM * DS_CMD_LEN_64BITS;
1466 }
1467
1468 //XC_PRINTF("[%s,%5d] [DS_IP(MVOP)]pstXC_DS_CmdCnt->u16CMDCNT_IPM:%d u32MemShift_IPM:%lx \n",__func__,__LINE__,pstXC_DS_CmdCnt->u16CMDCNT_IPM,(MS_U32)u32MemShift_IPM);
1469 //u32Addr = u32Addr + DS_CMD_LEN_64BITS * pstXC_DS_CmdCnt->u16CMDCNT_IPM;
1470 u32Addr = u32Addr + u32MemShift_IPM;
1471 pu64Data = (MS_U64*)MsOS_PA2KSEG1(u32Addr);//IPM
1472
1473 if(pstXC_DS_CmdCnt->u16CMDCNT_IPM < u8MaxCmdCnt)
1474 {
1475 *pu64Data = u64CmdTemp;
1476 pstXC_DS_CmdCnt->u16CMDCNT_IPM++;
1477 }
1478 else
1479 {
1480 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[%s,%5d] [DS] Command count overflow !! u16CMDCNT_IPM:%d Max command count: %d\n",__func__,__LINE__,pstXC_DS_CmdCnt->u16CMDCNT_IPM,u8MaxCmdCnt);
1481 }
1482 }
1483 else
1484 {
1485 MS_U32 u32MemShift_IPS;
1486
1487 if((MS_MLOAD_BUS_WIDTH == 16) && (BYTE_PER_WORD == 32))
1488 {
1489 //CMD in DRAM: with dummy command
1490
1491 // |------ 128 bit ------|
1492 // | CMD0 | CMD1 |
1493 // | dummy | dummy |
1494 // | CMD2 | CMD3 |
1495 // | dummy | dummy |
1496
1497 if((pstXC_DS_CmdCnt->u16CMDCNT_IPS % 2) == 0)
1498 {
1499 u32MemShift_IPS = (pstXC_DS_CmdCnt->u16CMDCNT_IPS / 2) * MS_MLOAD_MEM_BASE_UNIT;
1500 }
1501 else
1502 {
1503 u32MemShift_IPS = (pstXC_DS_CmdCnt->u16CMDCNT_IPS / 2) * MS_MLOAD_MEM_BASE_UNIT + DS_CMD_LEN_64BITS;
1504 }
1505 }
1506 else // ((MS_MLOAD_BUS_WIDTH == 16) && (BYTE_PER_WORD == 16)) or ((MS_MLOAD_BUS_WIDTH == 32) && (BYTE_PER_WORD == 32))
1507 {
1508 //CMD in DRAM: no dummy command
1509
1510 // |------ 128 bit ------|
1511 // | CMD0 | CMD1 |
1512 // | CMD2 | CMD3 |
1513 // | CMD4 | CMD5 |
1514 // | CMD6 | CMD7 |
1515
1516 u32MemShift_IPS = pstXC_DS_CmdCnt->u16CMDCNT_IPS * DS_CMD_LEN_64BITS;
1517 }
1518
1519 //XC_PRINTF("[%s,%5d] [DS_IP(MVOP)]pstXC_DS_CmdCnt->u16CMDCNT_IPS:%d u32MemShift_IPS:%lx \n",__func__,__LINE__,pstXC_DS_CmdCnt->u16CMDCNT_IPS,(MS_U32)u32MemShift_IPS);
1520
1521 u32Addr_IPS = u32Addr_IPS + u32MemShift_IPS;
1522 pu64Data = (MS_U64*)MsOS_PA2KSEG1(u32Addr_IPS); // IPS
1523
1524 if(pstXC_DS_CmdCnt->u16CMDCNT_IPS < u8MaxCmdCnt)
1525 {
1526 *pu64Data = u64CmdTemp;
1527 pstXC_DS_CmdCnt->u16CMDCNT_IPS++;
1528 }
1529 else
1530 {
1531 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[%s,%5d] [DS] IPS Command count overflow !! u16CMDCNT_IPS:%d Max command count: %d\n",__func__,__LINE__,pstXC_DS_CmdCnt->u16CMDCNT_IPS,u8MaxCmdCnt);
1532 }
1533 }
1534 }
1535 else
1536 {
1537 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[%s,%5d] [DS] MVOP is IP cmd not OP cmd !! \n",__func__,__LINE__);
1538 }
1539
1540 }
1541 else if(Source_Select == DS_GOP)
1542 {
1543
1544 }
1545 else
1546 {
1547 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[%s,%5d] [DS] Only can support XC/MVOP/GOP NOW !! \n",__func__,__LINE__);
1548 }
1549 #endif
1550 #endif //SUPPORT_KERNEL_DS
1551 }
1552
Hal_SC_Add_NullCommand(void * pInstance,SCALER_WIN eWindow,ds_reg_ip_op_sel IPOP_Sel,XC_DS_CMDCNT * pstXC_DS_CmdCnt)1553 void Hal_SC_Add_NullCommand(void *pInstance,SCALER_WIN eWindow,ds_reg_ip_op_sel IPOP_Sel,XC_DS_CMDCNT *pstXC_DS_CmdCnt)
1554 {
1555 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1556 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1557 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1558 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1559 #if (SUPPORT_KERNEL_DS == 1)
1560 #ifdef MSOS_TYPE_LINUX_KERNEL
1561 EN_KDRV_SC_DEVICE u32DeviceID;
1562 if(psXCInstPri->u32DeviceID == 0)
1563 {
1564 u32DeviceID = E_KDRV_XC_SC0;
1565 }
1566 else
1567 {
1568 u32DeviceID = E_KDRV_XC_SC1;
1569 }
1570 KApi_XC_Add_NullCommand(u32DeviceID,eWindow,E_DS_CLIENT_XC,IPOP_Sel,(K_XC_DS_CMDCNT *)pstXC_DS_CmdCnt);
1571 return;
1572 #else
1573 #if (defined MSOS_TYPE_LINUX) || (defined ANDROID)
1574 if(0 > _s32FdScaler)
1575 {
1576 _s32FdScaler = open("/dev/scaler", O_WRONLY | O_NDELAY);
1577 }
1578
1579 if (0 > _s32FdScaler)
1580 {
1581 printf("\nUnable to open /dev/scaler\n");
1582 return ;
1583 }
1584 else
1585 {
1586 ST_KDRV_DS_Add_NullCommand k_ds_Add_NullCommand;
1587 if(psXCInstPri->u32DeviceID == 0)
1588 k_ds_Add_NullCommand.u32DeviceID = E_KDRV_XC_SC0;
1589 else
1590 k_ds_Add_NullCommand.u32DeviceID = E_KDRV_XC_SC1;
1591 k_ds_Add_NullCommand.eWindow = eWindow;
1592 k_ds_Add_NullCommand.client = E_DS_CLIENT_XC;
1593 k_ds_Add_NullCommand.IPOP_Sel = IPOP_Sel;
1594 k_ds_Add_NullCommand.pstXC_DS_CmdCnt = (K_XC_DS_CMDCNT *)pstXC_DS_CmdCnt;
1595 if (-1 == ioctl(_s32FdScaler, MDRV_XC_IOC_DS_ADD_NULL_CMD,&k_ds_Add_NullCommand))
1596 {
1597 perror("ioctl");
1598 return ;
1599 }
1600
1601 return ;
1602 }
1603 #endif
1604 #endif
1605 #else
1606
1607 MS_U16 u16MaxCmdCnt = pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth * (Hal_XC_MLoad_Get_64Bits_MIU_Bus_Sel(pInstance) + 1); // It has four 64bit commands per MIU bus width
1608 MS_U16 i = 0;
1609
1610 if(eWindow == MAIN_WINDOW)
1611 {
1612 if(IPOP_Sel == DS_IP)
1613 {
1614 for (i = pstXC_DS_CmdCnt->u16CMDCNT_IPM; i < u16MaxCmdCnt; i++)
1615 {
1616 Hal_SC_WriteDSCommand(pInstance, DS_IP, i, 0x00000009FFFF0000, eWindow);
1617 }
1618 }
1619 else
1620 {
1621 for (i = pstXC_DS_CmdCnt->u16CMDCNT_OPM; i < u16MaxCmdCnt; i++)
1622 {
1623 Hal_SC_WriteDSCommand(pInstance, DS_OP, i, 0x00000009FFFF0000, eWindow);
1624 }
1625 }
1626 }
1627 else
1628 {
1629 if(IPOP_Sel == DS_IP)
1630 {
1631 for(i = pstXC_DS_CmdCnt->u16CMDCNT_IPS; i < u16MaxCmdCnt; i++)
1632 {
1633 Hal_SC_WriteDSCommand(pInstance, DS_IP, i, 0x00000009FFFF0000, eWindow);
1634 }
1635 }
1636 else
1637 {
1638 for(i = pstXC_DS_CmdCnt->u16CMDCNT_OPS; i < u16MaxCmdCnt; i++)
1639 {
1640 Hal_SC_WriteDSCommand(pInstance, DS_IP, i, 0x00000009FFFF0000, eWindow);
1641 }
1642 }
1643 }
1644 #endif
1645 }
1646
MHAL_SC_Set_DynamicScaling(void * pInstance,MS_PHY u32MemBaseAddr,MS_U8 u8MIU_Select,MS_U8 u8IdxDepth,MS_BOOL bOP_On,MS_BOOL bIPS_On,MS_BOOL bIPM_On,SCALER_WIN eWindow)1647 MS_BOOL MHAL_SC_Set_DynamicScaling(void *pInstance,MS_PHY u32MemBaseAddr, MS_U8 u8MIU_Select, MS_U8 u8IdxDepth, MS_BOOL bOP_On, MS_BOOL bIPS_On, MS_BOOL bIPM_On,SCALER_WIN eWindow)
1648 {
1649 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1650 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1651 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1652 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1653 MS_U16 u16OnOff = 0;
1654 MS_U16 u16MIU_Sel_bit1 = 0;
1655
1656 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[%s,%5d] [DS] u8MIU_Select:%d \n",__func__,__LINE__,u8MIU_Select);
1657 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[%s,%5d] [DS] bOP_On:%d bIPS_On:%d bIPM_On:%d \n",__func__,__LINE__,bOP_On,bIPS_On,bIPM_On);
1658
1659 // disable DS before modifying DS configuration
1660 if (MDrv_XC_MLoad_GetStatus(pInstance) == E_MLOAD_ENABLED)
1661 {
1662 MS_U16 u16DSOnOff = SC_R2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK1F_10_L) & 0x0E00;
1663 if (u16DSOnOff != 0)
1664 {
1665 _MLOAD_ENTRY(pInstance);
1666 MDrv_XC_MLoad_WriteCmd(pInstance, REG_SC_BK1F_10_L, 0, 0x0E00);
1667 MDrv_XC_MLoad_Fire(pInstance, TRUE);
1668 _MLOAD_RETURN(pInstance);
1669 }
1670 }
1671 else
1672 {
1673 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK1F_10_L, 0, 0x0E00);
1674 }
1675
1676 // enable/disable
1677 // we only memorize riu enable bit because mload and ds shares the same riu enable bit
1678 u16OnOff = SC_R2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK1F_10_L) & 0x1000;
1679
1680 u16OnOff |= ((bOP_On << 9) | (bIPS_On << 10) | (bIPM_On << 11));
1681
1682 #if ENABLE_DS_4_BASEADDR_MODE
1683
1684 //===============================================================//
1685 // old 32bit command in DRAM (per 16 Byte)
1686 // |-------------|-------------|-------------|-------------|
1687 // | DS_OP(main) | DS_IP(main) | DS_OP(sub) | DS_IP(sub) |
1688 // |-------------|-------------|-------------|-------------|
1689 // | 4 byte | 4 byte | 4 byte | 4 byte |
1690 // |-------------|-------------|-------------|-------------|
1691
1692 // new 64bit command in DRAM (per 16 Byte)
1693 // |---------------------------|---------------------------|
1694 // | DS_IP(main) | DS_IP(main) |
1695 // |---------------------------|---------------------------|
1696 // | 8 byte | 8 byte |
1697 // |---------------------------|---------------------------|
1698 //===============================================================//
1699
1700 //pXCResourcePrivate->sthal_SC.u32DynamicScalingBufSize = BYTE_PER_WORD * u8IdxDepth * DS_MAX_INDEX;
1701
1702 //Index depth is decided by utopia
1703 pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth = 20;
1704
1705 pXCResourcePrivate->sthal_SC.u32DynamicScalingBufSize = 0x1F00;
1706
1707 MS_U32 u32DSBufLen = pXCResourcePrivate->sthal_SC.u32DynamicScalingBufSize / 4;
1708
1709 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[%s,%5d] [DS] u32DynamicScalingBufSize:%d u32DSBufLen:%d \n",__func__,__LINE__,pXCResourcePrivate->sthal_SC.u32DynamicScalingBufSize,u32DSBufLen);
1710
1711 if(eWindow == MAIN_WINDOW)
1712 {
1713 pXCResourcePrivate->sthal_SC.u32DynamicScalingBaseAddr = u32MemBaseAddr; //IPM
1714 pXCResourcePrivate->sthal_SC.u32DynamicScalingBaseAddr_OPM = u32MemBaseAddr + u32DSBufLen*2;
1715 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[%s,%5d] [DS] u32DynamicScalingBaseAddr_IPM:%x u32DynamicScalingBaseAddr_OPM:%x \n",__func__,__LINE__,(int)pXCResourcePrivate->sthal_SC.u32DynamicScalingBaseAddr,(int)pXCResourcePrivate->sthal_SC.u32DynamicScalingBaseAddr_OPM);
1716 }
1717
1718 if(eWindow == SUB_WINDOW)
1719 {
1720 pXCResourcePrivate->sthal_SC.u32DynamicScalingBaseAddr_IPS = u32MemBaseAddr + u32DSBufLen;
1721 pXCResourcePrivate->sthal_SC.u32DynamicScalingBaseAddr_OPS = u32MemBaseAddr + u32DSBufLen*3;
1722 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[%s,%5d] [DS] u32DynamicScalingBaseAddr_IPS:%x u32DynamicScalingBaseAddr_OPS:%x \n",__func__,__LINE__,(int)pXCResourcePrivate->sthal_SC.u32DynamicScalingBaseAddr_OPM,(int)pXCResourcePrivate->sthal_SC.u32DynamicScalingBaseAddr_OPS);
1723 }
1724 Hal_XC_Enable_DS_4_Baseaddress_Mode(pInstance, TRUE);
1725 #else
1726 pXCResourcePrivate->sthal_SC.u32DynamicScalingBaseAddr = u32MemBaseAddr;
1727 pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth = u8IdxDepth; //MaxDepth(IP/OP)
1728 pXCResourcePrivate->sthal_SC.u32DynamicScalingBufSize = BYTE_PER_WORD * u8IdxDepth * DS_MAX_INDEX;
1729 #endif
1730
1731 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[%s,%5d] [DS] u32DynamicScalingBaseAddr:%x u8DynamicScalingIndexDepth:%d u32DynamicScalingBufSize:%d \n",__func__,__LINE__,(int)pXCResourcePrivate->sthal_SC.u32DynamicScalingBaseAddr,(int)pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth,pXCResourcePrivate->sthal_SC.u32DynamicScalingBufSize);
1732
1733 //Befor DS On, Clean the DS memory
1734 if(u16OnOff & 0x0E00)
1735 {
1736 if( (pXCResourcePrivate->stdrvXC_3D.ePreInputMode == E_XC_3D_INPUT_MODE_NONE) && (pXCResourcePrivate->stdrvXC_3D.ePreOutputMode == E_XC_3D_OUTPUT_MODE_NONE)
1737 && (pXCResourcePrivate->stdrvXC_3D._eInput3DMode[MAIN_WINDOW] == E_XC_3D_INPUT_MODE_NONE) && (pXCResourcePrivate->stdrvXC_3D._eOutput3DMode == E_XC_3D_OUTPUT_MODE_NONE) ) //mantis:0740226
1738 {
1739 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[%s,%5d] [DS] u8IdxDepth:%d DS_MAX_INDEX:%d BYTE_PER_WORD:%d \n",__func__,__LINE__,u8IdxDepth,DS_MAX_INDEX,BYTE_PER_WORD);
1740
1741 pXCResourcePrivate->sthal_SC.u8DynamicScalingCurrentIndex[eWindow] = 0;
1742 pXCResourcePrivate->sthal_SC.u8DynamicScalingNextIndex[eWindow] = 0;
1743 pXCResourcePrivate->sthal_SC.u8DynamicScalingCurrentIndex_Ring[eWindow] = 0;
1744
1745 #if ENABLE_DS_4_BASEADDR_MODE
1746 Hal_SC_ResetSWDSCommand(pInstance,eWindow,0);
1747 #else
1748 MS_U8 u8index = 0;
1749
1750 for(u8index=0; u8index < DS_MAX_INDEX; u8index++)
1751 {
1752 Hal_SC_ResetSWDSCommand(pInstance,eWindow, u8index);
1753 }
1754 #endif
1755 }
1756 }
1757
1758 if(u16OnOff & 0x0E00)
1759 {
1760 // ENABLE DS
1761 u16OnOff |= BIT(12); // enable write register through RIU
1762 pXCResourcePrivate->sthal_SC.bDynamicScalingEnable = TRUE;
1763
1764 // currently, these 3 will use same MIU
1765 u16OnOff |= ((u8MIU_Select & 0x01) << 13); // MIU select of OP
1766 u16OnOff |= ((u8MIU_Select & 0x01) << 14); // MIU select of IPS
1767 u16OnOff |= ((u8MIU_Select & 0x01) << 15); // MIU select of IPM
1768
1769 u16MIU_Sel_bit1 |= ((u8MIU_Select & 0x02) << 12); // MIU select of OP
1770 u16MIU_Sel_bit1 |= ((u8MIU_Select & 0x02) << 13); // MIU select of IPS
1771 u16MIU_Sel_bit1 |= ((u8MIU_Select & 0x02) << 14); // MIU select of IPM
1772
1773 // patch IP1F2_21[15:14] r/w bank
1774
1775 if(pXCResourcePrivate->sthal_SC.sbOldValueReaded == FALSE)
1776 {
1777 pXCResourcePrivate->sthal_SC.su16OldValue = SC_R2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK01_21_L);
1778 pXCResourcePrivate->sthal_SC.su16OldValue_BWD_Status = SC_R2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK46_01_L,0x000C);
1779
1780 pXCResourcePrivate->sthal_SC.sbOldValueReaded = TRUE;
1781 }
1782 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK01_21_L, 0x4000, 0xC000);
1783 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK46_01_L, 0x0, 0x000C); //Disable BWD [2]:BWDcrtl_memconfig [3]:BWDcrtl_baseaddr
1784
1785 Hal_XC_MLoad_set_opm_lock(pInstance, OPM_LOCK_DS);
1786 }
1787 else
1788 {
1789 pXCResourcePrivate->sthal_SC.bDynamicScalingEnable = FALSE;
1790 // DISABLE DS
1791 if(pXCResourcePrivate->sthal_SC.sbOldValueReaded)
1792 {
1793 SC_W2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK01_21_L, pXCResourcePrivate->sthal_SC.su16OldValue);
1794 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK46_01_L, pXCResourcePrivate->sthal_SC.su16OldValue_BWD_Status, 0x000C);
1795
1796 pXCResourcePrivate->sthal_SC.sbOldValueReaded = FALSE;
1797 }
1798 Hal_XC_MLoad_set_opm_lock(pInstance, OPM_LOCK_INIT_STATE);
1799 }
1800
1801 // if disabled, need to set dynamic scaling ratio to 1:1
1802 if(!bOP_On)
1803 {
1804 SC_W4BYTE(psXCInstPri->u32DeviceID, REG_SC_BK23_1C_L, 0x00100000);
1805 SC_W4BYTE(psXCInstPri->u32DeviceID, REG_SC_BK23_1E_L, 0x00100000);
1806 }
1807
1808 if(u16OnOff & 0x0E00)
1809 {
1810 if (FALSE == pXCResourcePrivate->sthal_SC.bTrig_pStored)
1811 {
1812 Hal_XC_Set_DS_BaseAddress(pInstance,u32MemBaseAddr);
1813 Hal_XC_Set_DS_IndexDepth(pInstance);
1814 Hal_XC_Set_DS_MIU_Sel(pInstance,u16OnOff,u16MIU_Sel_bit1);
1815
1816 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK12_06_L, BIT(7), BIT(7));//enable ipm tune after DS when DS on
1817
1818 // set DMA threthold, length, fixed value, no need to change
1819 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK1F_10_L, 0x88, 0x00FF);
1820
1821 // store
1822 Hal_XC_MLoad_get_trig_p(pInstance, &pXCResourcePrivate->sthal_SC.u16OldValue[E_STORE_VALUE_AUTO_TUNE_AREA_TRIG], &pXCResourcePrivate->sthal_SC.u16OldValue[E_STORE_VALUE_DISP_AREA_TRIG]);
1823 pXCResourcePrivate->sthal_SC.bTrig_pStored = TRUE;
1824
1825 // set the trigger point from delayed line, DS: 0x08, Train:0x14, Disp:0x18
1826 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK20_21_L, 0x08, 0xFF); // ds_trig_dly
1827 pXCResourcePrivate->sthal_SC.u16NewValue[E_STORE_VALUE_AUTO_TUNE_AREA_TRIG] = 0x14;
1828 pXCResourcePrivate->sthal_SC.u16NewValue[E_STORE_VALUE_DISP_AREA_TRIG] = 0x18;
1829 pXCResourcePrivate->sthal_SC.bUsingNewValue[E_STORE_VALUE_AUTO_TUNE_AREA_TRIG] = TRUE;
1830 pXCResourcePrivate->sthal_SC.bUsingNewValue[E_STORE_VALUE_DISP_AREA_TRIG] = TRUE;
1831 Hal_SC_ControlMloadTrig(pInstance);
1832
1833 //add
1834 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK10_5D_L, 0x0828, 0xFFFF);
1835
1836 // set trigger source to trigger
1837 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK20_19_L, 0x08B8, 0x08BC);
1838
1839 if (IS_SUPPORT_64BITS_COMMAND(ENABLE_64BITS_COMMAND, psXCInstPri->u32DeviceID))
1840 {
1841 Hal_XC_Enable_DS_64Bits_Command(pInstance,TRUE);
1842 if(ENABLE_64BITS_SPREAD_MODE)
1843 {
1844 Hal_XC_Enable_DS_64Bits_Sread_Mode(pInstance,TRUE);
1845 }
1846 Hal_XC_Set_DS_64Bits_MIU_Bus_Sel(pInstance);
1847 }
1848 }
1849
1850 }
1851 else
1852 {
1853 // restore
1854 if (pXCResourcePrivate->sthal_SC.bTrig_pStored)
1855 {
1856 pXCResourcePrivate->sthal_SC.bTrig_pStored = FALSE;
1857
1858 MDrv_XC_MLoad_set_IP_trig_p(pInstance, 0x03, 0x05); // reset to HW default setting
1859
1860 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK12_06_L, 0x0, BIT(7));//disable ipm tune after DS when DS off
1861
1862 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK68_23_L,0, BIT(0));
1863 }
1864 }
1865
1866 // set DS in IPS[10],ipm[11],op[9](fb case) On/Off
1867 if ((gSrcInfo[MAIN_WINDOW].bR_FBL) || (gSrcInfo[MAIN_WINDOW].bFBL))
1868 {
1869 u16OnOff = u16OnOff & ~0x0200;
1870 }
1871 MS_U16 u16DSCurrentOnOff = SC_R2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK1F_10_L) & 0x1E00;
1872 if (u16DSCurrentOnOff != u16OnOff)
1873 {
1874 if (MDrv_XC_MLoad_GetStatus(pInstance) == E_MLOAD_ENABLED)
1875 {
1876 _MLOAD_ENTRY(pInstance);
1877 MDrv_XC_MLoad_WriteCmd(pInstance, REG_SC_BK1F_10_L, u16OnOff & 0x1E00, 0x1E00);
1878 MDrv_XC_MLoad_Fire(pInstance, TRUE);
1879 _MLOAD_RETURN(pInstance);
1880 }
1881 else
1882 {
1883 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK1F_10_L, u16OnOff & 0x1E00, 0x1E00);
1884 }
1885 }
1886
1887 return TRUE;
1888 }
1889
MHAL_SC_Set_DynamicScalingFlag(void * pInstance,MS_BOOL bEnable)1890 void MHAL_SC_Set_DynamicScalingFlag(void *pInstance, MS_BOOL bEnable)
1891 {
1892 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1893 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1894 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1895 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1896 pXCResourcePrivate->sthal_SC.bDynamicScalingEnable = bEnable;
1897 }
1898
MHAL_SC_Get_DynamicScaling_Status(void * pInstance)1899 MS_BOOL MHAL_SC_Get_DynamicScaling_Status(void *pInstance)
1900 {
1901 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1902 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1903 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1904 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1905 return pXCResourcePrivate->sthal_SC.bDynamicScalingEnable;
1906 }
1907
MHAL_SC_Enable_IPMTuneAfterDS(void * pInstance,MS_BOOL bEnable)1908 MS_BOOL MHAL_SC_Enable_IPMTuneAfterDS(void *pInstance, MS_BOOL bEnable)
1909 {
1910 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1911 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1912
1913 //Null function for Monet , ipm mask(IPM tune after DS) is controlled by first IP command
1914
1915 // ENABLE IPM TUNE AFTER DS
1916 //SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK12_06_L, BIT(7), BIT(7));
1917
1918 //reg_ds_ipm_active_sel: 0:HW 1:SW
1919 //SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK1F_17_L, BIT(10), BIT(10));
1920
1921 // Clear DS active pulse every vsync
1922 //SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK1F_17_L, BIT(6), BIT(6));
1923 return TRUE;
1924 }
1925
MHal_SC_DynamicScaling_SWReset(void)1926 void MHal_SC_DynamicScaling_SWReset(void)
1927 {
1928 SC_W2BYTEMSK(0, REG_SC_BK1F_13_L, 0x400, 0x400);
1929 SC_W2BYTEMSK(0, REG_SC_BK1F_13_L, 0x800, 0x800);
1930 SC_W2BYTEMSK(0, REG_SC_BK1F_13_L, 0x1000, 0x1000);
1931
1932 SC_W2BYTEMSK(0, REG_SC_BK1F_13_L, 0x0, 0x1000);
1933 SC_W2BYTEMSK(0, REG_SC_BK1F_13_L, 0x0, 0x800);
1934 SC_W2BYTEMSK(0, REG_SC_BK1F_13_L, 0x0, 0x400);
1935 }
MHal_XC_Get_DSForceIndexSupported(void * pInstance,SCALER_WIN eWindow)1936 MS_BOOL MHal_XC_Get_DSForceIndexSupported(void *pInstance, SCALER_WIN eWindow)
1937 {
1938 if (eWindow >= MAX_WINDOW)
1939 {
1940 printf("[%s,%5d] maximum window exceeded",__FUNCTION__,__LINE__);
1941 return FALSE;
1942 }
1943
1944 return TRUE;
1945 }
1946
MHal_XC_Set_DSForceIndex(void * pInstance,MS_BOOL bEnable,MS_U8 u8Index,SCALER_WIN eWindow)1947 void MHal_XC_Set_DSForceIndex(void *pInstance, MS_BOOL bEnable, MS_U8 u8Index, SCALER_WIN eWindow)
1948 {
1949 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1950 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1951 #if (SUPPORT_KERNEL_DS == 1)
1952 #ifdef MSOS_TYPE_LINUX_KERNEL
1953 EN_KDRV_SC_DEVICE u32DeviceID;
1954 if(psXCInstPri->u32DeviceID == 0)
1955 {
1956 u32DeviceID = E_KDRV_XC_SC0;
1957 }
1958 else
1959 {
1960 u32DeviceID = E_KDRV_XC_SC1;
1961 }
1962 KApi_XC_Set_DSForceIndex(u32DeviceID,bEnable,u8Index,eWindow);
1963 return;
1964 #else
1965 #if (defined MSOS_TYPE_LINUX) || (defined ANDROID)
1966 if(0 > _s32FdScaler)
1967 {
1968 _s32FdScaler = open("/dev/scaler", O_WRONLY | O_NDELAY);
1969 }
1970
1971 if (0 > _s32FdScaler)
1972 {
1973 printf("\nUnable to open /dev/scaler\n");
1974 return ;
1975 }
1976 else
1977 {
1978 ST_KDRV_DS_SET_DSForceIndex k_ds_set_ForceIndex;
1979 if(psXCInstPri->u32DeviceID == 0)
1980 k_ds_set_ForceIndex.u32DeviceID = E_KDRV_XC_SC0;
1981 else
1982 k_ds_set_ForceIndex.u32DeviceID = E_KDRV_XC_SC1;
1983 k_ds_set_ForceIndex.bEnable = bEnable;
1984 k_ds_set_ForceIndex.u8Index = u8Index;
1985 k_ds_set_ForceIndex.eWindow = eWindow;
1986 if (-1 == ioctl(_s32FdScaler, MDRV_XC_IOC_DS_SET_DSFORCE_INDEX,&k_ds_set_ForceIndex))
1987 {
1988 perror("ioctl");
1989 return ;
1990 }
1991
1992 return ;
1993 }
1994 #endif
1995 #endif
1996 #else
1997 if (eWindow >= MAX_WINDOW)
1998 {
1999 printf("[%s,%5d] maximum window exceeded",__FUNCTION__,__LINE__);
2000 return;
2001 }
2002
2003 if (eWindow == MAIN_WINDOW)
2004 {
2005 // reg_idxg_force_en
2006 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK1F_77_L, bEnable?(BIT(0)|BIT(2)):0 , BIT(0)|BIT(2));
2007
2008 // reg_idxg_force_idx_f2
2009 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK1F_76_L, (MS_U16)u8Index << 8 , 0xFF00);
2010 }
2011 else // eWindow == SUB_WINDOW
2012 {
2013 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK1F_77_L, bEnable?(BIT(8)|BIT(10)):0 , BIT(8)|BIT(10));
2014
2015 // reg_idxg_force_idx_f1
2016 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK1F_75_L, (MS_U16)u8Index << 8 , 0xFF00);
2017 }
2018 #endif
2019 }
2020
MHal_XC_Set_DSIndexSourceSelect(void * pInstance,E_XC_DS_INDEX_SOURCE eDSIdxSrc,SCALER_WIN eWindow)2021 void MHal_XC_Set_DSIndexSourceSelect(void *pInstance, E_XC_DS_INDEX_SOURCE eDSIdxSrc, SCALER_WIN eWindow)
2022 {
2023 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2024 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2025 if (eWindow >= MAX_WINDOW)
2026 {
2027 printf("[%s,%5d] maximum window exceeded",__FUNCTION__,__LINE__);
2028 return;
2029 }
2030
2031 if (eDSIdxSrc >= E_XC_DS_INDEX_MAX)
2032 {
2033 printf("[%s,%5d] Maximum index exceeded, the index is (%d)\n",__FUNCTION__,__LINE__,eDSIdxSrc);
2034 return;
2035 }
2036
2037 if(eWindow == MAIN_WINDOW)
2038 {
2039 // reg_idxg_en_f2
2040 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK00_37_L, eDSIdxSrc, BIT(0));
2041 }
2042 else
2043 {
2044 // reg_idxg_en_f1
2045 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK00_37_L, eDSIdxSrc << 8, BIT(8));
2046 }
2047 }
2048
Hal_XC_Enable_DS_64Bits_Command(void * pInstance,MS_BOOL bEn)2049 void Hal_XC_Enable_DS_64Bits_Command(void *pInstance,MS_BOOL bEn)
2050 {
2051 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2052 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2053
2054 SC_W2BYTEMSK(psXCInstPri->u32DeviceID,REG_SC_BK1F_70_L, bEn?BIT(0):0x00, BIT(0));
2055 }
2056
Hal_XC_Enable_DS_64Bits_Sread_Mode(void * pInstance,MS_BOOL bEn)2057 void Hal_XC_Enable_DS_64Bits_Sread_Mode(void *pInstance,MS_BOOL bEn)
2058 {
2059 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2060 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2061
2062 SC_W2BYTEMSK(psXCInstPri->u32DeviceID,REG_SC_BK1F_70_L, bEn?BIT(15):0x00, BIT(15));
2063 }
2064
Hal_XC_Enable_DS_4_Baseaddress_Mode(void * pInstance,MS_BOOL bEn)2065 void Hal_XC_Enable_DS_4_Baseaddress_Mode(void *pInstance,MS_BOOL bEn)
2066 {
2067 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2068 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2069
2070 SC_W2BYTEMSK(psXCInstPri->u32DeviceID,REG_SC_BK1F_17_L, bEn?BIT(7):0x00, BIT(7));
2071 }
2072
Hal_XC_Set_DS_64Bits_MIU_Bus_Sel(void * pInstance)2073 void Hal_XC_Set_DS_64Bits_MIU_Bus_Sel(void *pInstance)
2074 {
2075 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2076 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2077
2078 MS_U16 u16sel = 0x00;
2079
2080 if( MS_MLOAD_BUS_WIDTH == 8 )
2081 {
2082 u16sel = 0x00;
2083 }
2084 else if( MS_MLOAD_BUS_WIDTH == 16 )
2085 {
2086 u16sel = 0x01;
2087 }
2088 else if( MS_MLOAD_BUS_WIDTH == 32 )
2089 {
2090 u16sel = 0x3;
2091 }
2092 else
2093 {
2094 printf("MIU Bus not support !!!!!!!!!!!!!!!!!\n");
2095 u16sel = 0x00;
2096 }
2097
2098 u16sel = (u16sel & 0x0003)<<14;
2099 SC_W2BYTEMSK(psXCInstPri->u32DeviceID,REG_SC_BK1F_13_L, u16sel, 0xC000);
2100 }
2101
Hal_XC_Set_DS_BaseAddress(void * pInstance,MS_PHY u32Base)2102 void Hal_XC_Set_DS_BaseAddress(void *pInstance,MS_PHY u32Base)
2103 {
2104 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2105 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2106 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
2107 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
2108
2109 if( u32Base > HAL_MIU1_BASE)
2110 {
2111 u32Base = u32Base - HAL_MIU1_BASE;
2112 }
2113
2114 MS_PHY u32Base_OPM = 0;
2115 u32Base_OPM = pXCResourcePrivate->sthal_SC.u32DynamicScalingBaseAddr_OPM;
2116
2117 if( u32Base_OPM > HAL_MIU1_BASE)
2118 {
2119 u32Base_OPM = u32Base_OPM - HAL_MIU1_BASE;
2120 }
2121
2122 u32Base = u32Base/MS_MLOAD_MEM_BASE_UNIT;
2123
2124 #if ENABLE_DS_4_BASEADDR_MODE
2125 // set IPM
2126 SC_W2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK1F_11_L, u32Base & 0xFFFF);
2127 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK1F_12_L, (u32Base >> 16),0xFFFF);
2128
2129 //set IPS
2130 SC_W2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK1F_0C_L, (pXCResourcePrivate->sthal_SC.u32DynamicScalingBaseAddr_IPS / MS_MLOAD_MEM_BASE_UNIT) & 0xFFFF);
2131 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK1F_0D_L, ((pXCResourcePrivate->sthal_SC.u32DynamicScalingBaseAddr_IPS / MS_MLOAD_MEM_BASE_UNIT) >> 16),0xFFFF);
2132
2133 if(!((gSrcInfo[MAIN_WINDOW].bR_FBL) || (gSrcInfo[MAIN_WINDOW].bFBL)))
2134 {
2135 //set OPM
2136 SC_W2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK1F_0E_L, (u32Base_OPM / MS_MLOAD_MEM_BASE_UNIT) & 0xFFFF);
2137 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK1F_0F_L, ((u32Base_OPM / MS_MLOAD_MEM_BASE_UNIT) >> 16),0xFFFF);
2138
2139 //set OPS
2140 SC_W2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK1F_60_L, (pXCResourcePrivate->sthal_SC.u32DynamicScalingBaseAddr_OPS / MS_MLOAD_MEM_BASE_UNIT) & 0xFFFF);
2141 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK1F_61_L, ((pXCResourcePrivate->sthal_SC.u32DynamicScalingBaseAddr_OPS / MS_MLOAD_MEM_BASE_UNIT) >> 16),0xFFFF);
2142 }
2143 #else
2144 // set DS base address
2145 SC_W2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK1F_11_L, u32Base & 0xFFFF);
2146 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK1F_12_L, (u32Base >> 16),0xFFFF);
2147 #endif
2148
2149 }
2150
Hal_XC_Set_DS_IndexDepth(void * pInstance)2151 void Hal_XC_Set_DS_IndexDepth(void *pInstance)
2152 {
2153 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2154 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2155 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
2156 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
2157
2158 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK1F_13_L, pXCResourcePrivate->sthal_SC.u8DynamicScalingIndexDepth , 0x00FF);
2159 }
2160
Hal_XC_Set_DS_MIU_Sel(void * pInstance,MS_U16 u16DSOnOff,MS_U16 u16DS_MIU_Sel_bit1)2161 void Hal_XC_Set_DS_MIU_Sel(void *pInstance,MS_U16 u16DSOnOff,MS_U16 u16DS_MIU_Sel_bit1)
2162 {
2163 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
2164 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
2165
2166 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK1F_10_L, u16DSOnOff & 0xE000, 0xE000);
2167 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK1F_71_L, u16DS_MIU_Sel_bit1 & 0xE000, 0xE000);
2168 }
2169
Hal_SC_GenSpreadModeCmd(void * pInstance,MS_U32 u32CmdRegAddr,MS_U16 u16CmdRegValue,MS_U16 u16Mask,ds_reg_source_sel eSourceSelect)2170 MS_U64 Hal_SC_GenSpreadModeCmd(void *pInstance, MS_U32 u32CmdRegAddr, MS_U16 u16CmdRegValue, MS_U16 u16Mask, ds_reg_source_sel eSourceSelect)
2171 {
2172 MS_U64 u64CmdTemp = 0;
2173 MS_U8 u8AddrTemp = 0;
2174 MS_U16 u16BankTemp = 0;
2175 MS_U16 u16DataTemp = 0;
2176
2177 if(eSourceSelect == DS_XC)
2178 {
2179 u64CmdTemp = Hal_XC_MLoad_Gen_64bits_spreadMode(pInstance, u32CmdRegAddr, u16CmdRegValue, u16Mask);
2180 }
2181 else if(eSourceSelect == DS_MVOP)
2182 {
2183 u16DataTemp = u16CmdRegValue;
2184 u8AddrTemp = (u32CmdRegAddr&0x000000FF);
2185 u16BankTemp = (u32CmdRegAddr&0x00FFFF00) >> 8; //EX: mvop mainwinodw: 0x1014 mvop bank
2186 u64CmdTemp = Hal_XC_MLoad_Gen_64bits_spreadMode_NonXC(pInstance, u16BankTemp, u8AddrTemp, u16DataTemp, u16Mask);
2187 }
2188 else if(eSourceSelect == DS_GOP)
2189 {
2190 //TO DO
2191 }
2192 else
2193 {
2194 XC_LOG_TRACE(XC_DBGLEVEL_SETWINDOW,"[%s,%5d] [DS] Only can support XC/MVOP/GOP NOW !! \n",__func__,__LINE__);
2195 }
2196
2197 return u64CmdTemp;
2198 }
2199
2200 #endif // MHAL_DYNAMICSCALING_C
2201
2202