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-2011 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 halNJPD.c
98 /// @brief NJPD hal interface
99 /// @author MStar Semiconductor Inc.
100 ///////////////////////////////////////////////////////////////////////////////////////////////////
101
102
103 //-------------------------------------------------------------------------------------------------
104 // Include Files
105 //-------------------------------------------------------------------------------------------------
106 // Common Definition
107 #include "MsCommon.h"
108 #include "MsOS.h"
109 #include "halCHIP.h"
110 // Internal Definition
111 //#include "regCHIP.h"
112 #include "drvMMIO.h" //get RIU base
113 #include "osalNJPD.h"
114 #include "drvNJPD.h"
115 #include "regNJPD.h"
116 #include "halNJPD.h"
117 #ifdef CONFIG_MSTAR_CLKM
118 #ifdef MSOS_TYPE_LINUX_KERNEL
119 #include <linux/clkm.h>
120 #else
121 #include "drvCLKM.h"
122 #endif
123 #endif
124
125
126 #include "drvSYS.h"
127
128 // MJPEG
129 #define USE_FW_HVD 1
130
131 #if USE_FW_HVD
132 //#include "../hvd_ex/fwHVD_if.h"
133 #define NJPD_FW_VERSION "NJPD.FW.00130062"
134 #else
135 #include "fwNJPD.h"
136 #endif
137
138 // For MVD Power On
139 void HAL_MVD_RegSetBase(MS_U32 u32Base);
140 void HAL_MVD_PowerCtrl(MS_BOOL bOn);
141 void HAL_MVD_SetSyncClk(MS_BOOL bEnable);
142 MS_BOOL HAL_MVD_RstHW(void);
143
144 //-------------------------------------------------------------------------------------------------
145 // Driver Compiler Options
146 //-------------------------------------------------------------------------------------------------
147 #define HAL_NJPD_ENABLE 1
148 #define HAL_NJPD_DISABLE 0
149
150 #define HAL_NJPD_MUTEX_SUPPORT HAL_NJPD_ENABLE
151 #define HAL_NJPD_MIU_PROTECT HAL_NJPD_ENABLE
152 #define MEASURE_NJPD_MIU_CLIENT_EFFICIENCY FALSE//TRUE
153
154 //-------------------------------------------------------------------------------------------------
155 // Local Defines
156 //-------------------------------------------------------------------------------------------------
157
158 #define __HAL_NJPD_DelayMs(x) do { MS_U32 ticks=0; while((ticks++)>(x*10)); } while(0)
159
160 #define NJPD_RIU_MAP u32NJPDRiuBaseAdd //obtain in init
161
162 #ifndef ANDROID
163 #define NJPD_DEBUG_HAL_MSG(format, args...) do{if(_u8NJPDHalDbgLevel & E_NJPD_DEBUG_HAL_MSG) printf(format, ##args);}while(0)
164 #define NJPD_DEBUG_HAL_ERR(format, args...) do{if(_u8NJPDHalDbgLevel & E_NJPD_DEBUG_HAL_ERR) printf(format, ##args);}while(0)
165 #else
166 #define LOG_TAG "HAL_JPD"
167 #include <cutils/log.h>
168 #ifndef LOGD
169 #define NJPD_DEBUG_HAL_MSG(format, args...) do{if(_u8NJPDHalDbgLevel & E_NJPD_DEBUG_HAL_MSG) ALOGI(format, ##args);}while(0)
170 #define NJPD_DEBUG_HAL_ERR(format, args...) do{if(_u8NJPDHalDbgLevel & E_NJPD_DEBUG_HAL_ERR) ALOGE(format, ##args);}while(0)
171 #else
172 #define NJPD_DEBUG_HAL_MSG(format, args...) do{if(_u8NJPDHalDbgLevel & E_NJPD_DEBUG_HAL_MSG) LOGI(format, ##args);}while(0)
173 #define NJPD_DEBUG_HAL_ERR(format, args...) do{if(_u8NJPDHalDbgLevel & E_NJPD_DEBUG_HAL_ERR) LOGE(format, ##args);}while(0)
174 #endif
175
176 #endif
177
178 #ifndef READ_BYTE
179 #define READ_BYTE(_reg) (*(volatile MS_U8*)(_reg))
180 #define READ_WORD(_reg) (*(volatile MS_U16*)(_reg))
181 #define READ_LONG(_reg) (*(volatile MS_U32*)(_reg))
182 #define WRITE_BYTE(_reg, _val) { (*((volatile MS_U8*)(_reg))) = (MS_U8)(_val); }
183 #define WRITE_WORD(_reg, _val) { (*((volatile MS_U16*)(_reg))) = (MS_U16)(_val); }
184 #define WRITE_LONG(_reg, _val) { (*((volatile MS_U32*)(_reg))) = (MS_U32)(_val); }
185 #endif
186
187 #define NJPD_READ_BYTE(addr) READ_BYTE( (NJPD_RIU_MAP + (addr)) )
188 #define NJPD_READ_WORD(addr) READ_WORD( (NJPD_RIU_MAP + (addr)) )
189 #define NJPD_WRITE_BYTE(addr, val) WRITE_BYTE( (NJPD_RIU_MAP + (addr)), (val) )
190 #define NJPD_WRITE_WORD(addr, val) WRITE_WORD( (NJPD_RIU_MAP + (addr)), (val) )
191
192 #define NJPD_MACRO_START do {
193 #define NJPD_MACRO_END } while (0)
194
195 #define __HAL_NJPD_ReadByte( u32Reg ) NJPD_READ_BYTE(((u32Reg) << 1) - ((u32Reg) & 1))
196
197 #define __HAL_NJPD_Read2Byte( u32Reg ) (NJPD_READ_WORD((u32Reg)<<1))
198
199 #define __HAL_NJPD_Read4Byte( u32Reg ) ( (MS_U32)NJPD_READ_WORD((u32Reg)<<1) | ((MS_U32)NJPD_READ_WORD(((u32Reg)+2)<<1)<<16 ) )
200
201 #define __HAL_NJPD_ReadBit( u32Reg, u8Mask ) (NJPD_READ_BYTE(((u32Reg)<<1) - ((u32Reg) & 1)) & (u8Mask))
202
203 #define __HAL_NJPD_WriteBit( u32Reg, bEnable, u8Mask ) \
204 NJPD_MACRO_START \
205 NJPD_WRITE_BYTE( (((u32Reg) <<1) - ((u32Reg) & 1)) , (bEnable) ? (NJPD_READ_BYTE( (((u32Reg) <<1) - ((u32Reg) & 1)) ) | (u8Mask)) : \
206 (NJPD_READ_BYTE( (((u32Reg) <<1) - ((u32Reg) & 1)) ) & ~(u8Mask))); \
207 NJPD_MACRO_END
208
209 #define __HAL_NJPD_WriteByte( u32Reg, u8Val ) \
210 NJPD_MACRO_START \
211 NJPD_WRITE_BYTE(((u32Reg) << 1) - ((u32Reg) & 1), (u8Val)); \
212 NJPD_MACRO_END
213
214 #define __HAL_NJPD_Write2Byte( u32Reg, u16Val ) \
215 NJPD_MACRO_START \
216 if ( ((u32Reg) & 0x01) ) \
217 { \
218 NJPD_WRITE_BYTE(((u32Reg) << 1) - 1, (MS_U8)((u16Val))); \
219 NJPD_WRITE_BYTE(((u32Reg) + 1) << 1, (MS_U8)((u16Val) >> 8)); \
220 } \
221 else \
222 { \
223 NJPD_WRITE_WORD( ((u32Reg)<<1) , u16Val); \
224 } \
225 NJPD_MACRO_END
226
227 #define __HAL_NJPD_Write4Byte( u32Reg, u32Val ) \
228 NJPD_MACRO_START \
229 if ((u32Reg) & 0x01) \
230 { \
231 NJPD_WRITE_BYTE( ((u32Reg) << 1) - 1 , (u32Val)); \
232 NJPD_WRITE_WORD( ((u32Reg) + 1)<<1 , ( (u32Val) >> 8)); \
233 NJPD_WRITE_BYTE( (((u32Reg) + 3) << 1) , ((u32Val) >> 24)); \
234 } \
235 else \
236 { \
237 NJPD_WRITE_WORD( (u32Reg)<<1 , (u32Val)); \
238 NJPD_WRITE_WORD( ((u32Reg) + 2)<<1 , ((u32Val) >> 16)); \
239 } \
240 NJPD_MACRO_END
241
242 //NJPD mutex
243 #if (HAL_NJPD_MUTEX_SUPPORT == HAL_NJPD_ENABLE)
244 static MS_S32 _s32NJPDMutexID = -1;
245 MS_U8 strNJPD[10] = "NJPD_Mutex";
246
247 #define __HAL_NJPD_MutexCreate() \
248 NJPD_MACRO_START \
249 if( _s32NJPDMutexID < 0 ) \
250 { \
251 _s32NJPDMutexID = OSAL_NJPD_MutexCreate( strNJPD ); \
252 } \
253 NJPD_MACRO_END
254 #define __HAL_NJPD_MutexDelete() \
255 NJPD_MACRO_START \
256 if( _s32NJPDMutexID >= 0 ) \
257 { \
258 OSAL_NJPD_MutexDelete(_s32NJPDMutexID); \
259 _s32NJPDMutexID = -1; \
260 } \
261 NJPD_MACRO_END
262 #define __HAL_NJPD_MutexEntry() \
263 NJPD_MACRO_START \
264 if( _s32NJPDMutexID >= 0 ) \
265 { \
266 if (!OSAL_NJPD_MutexObtain(_s32NJPDMutexID, OSAL_NJPD_MUTEX_TIMEOUT)) \
267 { \
268 NJPD_DEBUG_HAL_MSG("[HAL NJPD][%s][%06d] Mutex taking timeout\n", __FUNCTION__, __LINE__); \
269 } \
270 } \
271 NJPD_MACRO_END
272 #define __HAL_NJPD_MutexExit() \
273 NJPD_MACRO_START \
274 if( _s32NJPDMutexID >= 0 ) \
275 { \
276 OSAL_NJPD_MutexRelease(_s32NJPDMutexID); \
277 } \
278 NJPD_MACRO_END
279 #else //HAL_NJPD_MUTEX_SUPPORT
280 #define __HAL_NJPD_MutexCreate()
281 #define __HAL_NJPD_MutexDelete()
282 #define __HAL_NJPD_MutexEntry()
283 #define __HAL_NJPD_MutexExit()
284 #endif //HAL_NJPD_MUTEX_SUPPORT
285
286 #define MAX_MJPEG_DEC_NUM 2
287
288 //-------------------------------------------------------------------------------------------------
289 // Local Structurs
290 //-------------------------------------------------------------------------------------------------
291
292 //-------------------------------------------------------------------------------------------------
293 // Global Variables
294 //-------------------------------------------------------------------------------------------------
295 MS_VIRT u32NJPDRiuBaseAdd = 0x0;
296
297 //-------------------------------------------------------------------------------------------------
298 // Local Variables
299 //-------------------------------------------------------------------------------------------------
300 static MS_U8 _pu8HalVer[] = NJPD_HAL_VERSION;
301 static MS_U8 _pu8FwVer[] = NJPD_FW_VERSION;
302 static MS_U8 _u8NJPDHalDbgLevel = E_NJPD_DEBUG_HAL_NONE;
303
304
305 static JPD_Number eNJPDNum = E_NJPD_NJPD1;
306 static NJPD_VerificationMode eVerificationMode = E_NJPD00_NONE;
307
308 #if MEASURE_NJPD_MIU_CLIENT_EFFICIENCY
309 static MS_U8 bJPEGFirstTime=0;
310 #endif
311 //-------------------------------------------------------------------------------------------------
312 // Debug Functions
313 //-------------------------------------------------------------------------------------------------
314
315 //-------------------------------------------------------------------------------------------------
316 // Local Functions
317 //-------------------------------------------------------------------------------------------------
_HAL_NJPD_SetMIUProtectMask(MS_BOOL bEnable)318 static void _HAL_NJPD_SetMIUProtectMask(MS_BOOL bEnable)
319 {
320 #if (HAL_NJPD_MIU_PROTECT == HAL_NJPD_ENABLE)
321 if(eNJPDNum == E_NJPD_NJPD1)
322 {
323 __HAL_NJPD_WriteBit(NJPD_MIU0_RQ2_MASK, bEnable, NJPD0_MIU0_CLIENT_NJPD);
324 __HAL_NJPD_WriteBit(NJPD_MIU1_RQ2_MASK, bEnable, NJPD0_MIU1_CLIENT_NJPD);
325
326 NJPD_DEBUG_HAL_MSG("%s MIU0 : 0x%04x\n", __FUNCTION__, __HAL_NJPD_Read2Byte(NJPD_MIU0_RQ2_MASK));
327 NJPD_DEBUG_HAL_MSG("%s MIU1 : 0x%04x\n", __FUNCTION__, __HAL_NJPD_Read2Byte(NJPD_MIU1_RQ2_MASK));
328 }
329 else
330 {
331 __HAL_NJPD_WriteBit(NJPD_MIU0_RQ2_MASK, bEnable, NJPD0_MIU0_CLIENT_NJPD);
332 __HAL_NJPD_WriteBit(NJPD_MIU1_RQ2_MASK, bEnable, NJPD0_MIU1_CLIENT_NJPD);
333
334 NJPD_DEBUG_HAL_MSG("%s MIU0 : 0x%04x\n", __FUNCTION__, __HAL_NJPD_Read2Byte(NJPD_MIU0_RQ2_MASK));
335 NJPD_DEBUG_HAL_MSG("%s MIU1 : 0x%04x\n", __FUNCTION__, __HAL_NJPD_Read2Byte(NJPD_MIU1_RQ2_MASK));
336 }
337 #endif
338 return;
339 }
340
341
342 //-------------------------------------------------------------------------------------------------
343 // Global Functions
344 //-------------------------------------------------------------------------------------------------
345
346 /******************************************************************************/
347 ///
348 ///@param value \b IN
349 ///@param value \b OUT
350 ///@return status
351 /******************************************************************************/
HAL_NJPD_SetMIU(MS_U8 u8Idx)352 void HAL_NJPD_SetMIU(MS_U8 u8Idx)
353 {
354 #if 1
355 if(eNJPDNum == E_NJPD_NJPD1)
356 {
357 NJPD_DEBUG_HAL_MSG("NJPD0, ");
358 __HAL_NJPD_WriteBit(NJPD0_MIU1_MIU_SEL2, 1, NJPD0_MIU1_CLIENT_NJPD);
359
360 MS_U16 u16Reg = (MS_U16)u8Idx;
361 u16Reg = u16Reg << NJPD_MIU_SEL_SHIFT;
362 u16Reg = u16Reg | (__HAL_NJPD_Read2Byte(BK_NJPD1_IBUF_READ_LENGTH) & ~(NJPD_MIU_SEL|NJPD_MIU_SEL_1));
363 __HAL_NJPD_Write2Byte(BK_NJPD1_IBUF_READ_LENGTH, u16Reg);
364 }
365 else
366 {
367 // Note: there is no NJPD1 in curry
368 NJPD_DEBUG_HAL_MSG("NJPD1, ");
369 __HAL_NJPD_WriteBit(NJPD0_MIU1_MIU_SEL2, 1, NJPD0_MIU1_CLIENT_NJPD);
370
371 MS_U16 u16Reg = (MS_U16)u8Idx;
372 u16Reg = u16Reg << NJPD_MIU_SEL_SHIFT;
373 u16Reg = u16Reg | (__HAL_NJPD_Read2Byte(BK_NJPD2_IBUF_READ_LENGTH) & ~(NJPD_MIU_SEL|NJPD_MIU_SEL_1));
374 __HAL_NJPD_Write2Byte(BK_NJPD2_IBUF_READ_LENGTH, u16Reg);
375 }
376
377 #else
378 if(eNJPDNum == E_NJPD_NJPD1)
379 {
380 NJPD_DEBUG_HAL_MSG("NJPD0, ");
381 __HAL_NJPD_WriteBit(NJPD0_MIU1_MIU_SEL2, 0, NJPD0_MIU1_CLIENT_NJPD);
382 if(u8Idx)
383 {
384 NJPD_DEBUG_HAL_MSG("MIU 1\n");
385 __HAL_NJPD_WriteBit(NJPD0_MIU0_MIU_SEL2, 1, NJPD0_MIU0_CLIENT_NJPD);
386 }
387 else
388 {
389 NJPD_DEBUG_HAL_MSG("MIU 0\n");
390 __HAL_NJPD_WriteBit(NJPD0_MIU0_MIU_SEL2, 0, NJPD0_MIU0_CLIENT_NJPD);
391 }
392 }
393 else
394 {
395 NJPD_DEBUG_HAL_MSG("NJPD1, ");
396 __HAL_NJPD_WriteBit(NJPD0_MIU1_MIU_SEL2, 0, NJPD0_MIU1_CLIENT_NJPD);
397 if(u8Idx)
398 {
399 NJPD_DEBUG_HAL_MSG("MIU 1\n");
400 __HAL_NJPD_WriteBit(NJPD0_MIU0_MIU_SEL2, 1, NJPD0_MIU0_CLIENT_NJPD);
401 }
402 else
403 {
404 NJPD_DEBUG_HAL_MSG("MIU 0\n");
405 __HAL_NJPD_WriteBit(NJPD0_MIU0_MIU_SEL2, 0, NJPD0_MIU0_CLIENT_NJPD);
406 }
407 }
408 #endif
409 }
410
HAL_NJPD_JPDSelect(MS_BOOL bNJPD)411 void HAL_NJPD_JPDSelect(MS_BOOL bNJPD)
412 {
413 if(bNJPD)
414 {
415 __HAL_NJPD_WriteBit(NJPD_MIU_GROUP2_I64, 0, NJPD_MIU0_CLIENT_NJPD_CS2);
416
417 if(eNJPDNum == E_NJPD_NJPD1)
418 {
419 __HAL_NJPD_WriteBit(BK_NJPD1_TOP_MARB_PORT_ENABLE, 1, NJPD_TOP_MARB_P0_ENABLE);
420 __HAL_NJPD_WriteBit(BK_NJPD1_TOP_MARB_PORT_ENABLE, 1, NJPD_TOP_MARB_P1_ENABLE);
421 __HAL_NJPD_WriteBit(BK_NJPD1_TOP_MARB_PORT_ENABLE, 0, NJPD_TOP_MARB_P2_ENABLE);
422 }
423 else
424 {
425 __HAL_NJPD_WriteBit(BK_NJPD2_TOP_MARB_PORT_ENABLE, 1, NJPD_TOP_MARB_P0_ENABLE);
426 __HAL_NJPD_WriteBit(BK_NJPD2_TOP_MARB_PORT_ENABLE, 1, NJPD_TOP_MARB_P1_ENABLE);
427 __HAL_NJPD_WriteBit(BK_NJPD2_TOP_MARB_PORT_ENABLE, 0, NJPD_TOP_MARB_P2_ENABLE);
428 }
429 }
430 else
431 {
432 __HAL_NJPD_WriteBit(NJPD_MIU_GROUP2_I64, 1, NJPD_MIU0_CLIENT_NJPD_CS2);
433
434 if(eNJPDNum == E_NJPD_NJPD1)
435 {
436 __HAL_NJPD_WriteBit(BK_NJPD1_TOP_MARB_PORT_ENABLE, 0, NJPD_TOP_MARB_P0_ENABLE);
437 __HAL_NJPD_WriteBit(BK_NJPD1_TOP_MARB_PORT_ENABLE, 0, NJPD_TOP_MARB_P1_ENABLE);
438 __HAL_NJPD_WriteBit(BK_NJPD1_TOP_MARB_PORT_ENABLE, 1, NJPD_TOP_MARB_P2_ENABLE);
439 }
440 else
441 {
442 __HAL_NJPD_WriteBit(BK_NJPD2_TOP_MARB_PORT_ENABLE, 0, NJPD_TOP_MARB_P0_ENABLE);
443 __HAL_NJPD_WriteBit(BK_NJPD2_TOP_MARB_PORT_ENABLE, 0, NJPD_TOP_MARB_P1_ENABLE);
444 __HAL_NJPD_WriteBit(BK_NJPD2_TOP_MARB_PORT_ENABLE, 1, NJPD_TOP_MARB_P2_ENABLE);
445 }
446 }
447 #if 1
448 if(eNJPDNum == E_NJPD_NJPD1)
449 {
450 __HAL_NJPD_WriteBit(BK_NJPD1_TOP_MARB_PORT_ENABLE, 1, NJPD_TOP_MARB_P0_W_BYPASS_ENABLE);
451 __HAL_NJPD_WriteBit(BK_NJPD1_TOP_MARB_PORT_ENABLE, 1, NJPD_TOP_MARB_P1_W_BYPASS_ENABLE);
452 __HAL_NJPD_WriteBit(BK_NJPD1_TOP_MARB_PORT_ENABLE, 1, NJPD_TOP_MARB_P2_W_BYPASS_ENABLE);
453 __HAL_NJPD_WriteBit(BK_NJPD1_TOP_MARB_PORT_ENABLE, 1, NJPD_TOP_MARB_P0_R_BYPASS_ENABLE);
454 __HAL_NJPD_WriteBit(BK_NJPD1_TOP_MARB_PORT_ENABLE+1, 1, NJPD_TOP_MARB_P1_R_BYPASS_ENABLE);
455 __HAL_NJPD_WriteBit(BK_NJPD1_TOP_MARB_PORT_ENABLE+1, 1, NJPD_TOP_MARB_P2_R_BYPASS_ENABLE);
456 }
457 else
458 {
459 __HAL_NJPD_WriteBit(BK_NJPD2_TOP_MARB_PORT_ENABLE, 1, NJPD_TOP_MARB_P0_W_BYPASS_ENABLE);
460 __HAL_NJPD_WriteBit(BK_NJPD2_TOP_MARB_PORT_ENABLE, 1, NJPD_TOP_MARB_P1_W_BYPASS_ENABLE);
461 __HAL_NJPD_WriteBit(BK_NJPD2_TOP_MARB_PORT_ENABLE, 1, NJPD_TOP_MARB_P2_W_BYPASS_ENABLE);
462 __HAL_NJPD_WriteBit(BK_NJPD2_TOP_MARB_PORT_ENABLE, 1, NJPD_TOP_MARB_P0_R_BYPASS_ENABLE);
463 __HAL_NJPD_WriteBit(BK_NJPD2_TOP_MARB_PORT_ENABLE+1, 1, NJPD_TOP_MARB_P1_R_BYPASS_ENABLE);
464 __HAL_NJPD_WriteBit(BK_NJPD2_TOP_MARB_PORT_ENABLE+1, 1, NJPD_TOP_MARB_P2_R_BYPASS_ENABLE);
465 }
466 #endif
467 }
468
HAL_NJPD_Set_GlobalSetting00(MS_U16 u16Value)469 void HAL_NJPD_Set_GlobalSetting00(MS_U16 u16Value)
470 {
471 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
472 if(eNJPDNum == E_NJPD_NJPD1)
473 {
474 __HAL_NJPD_Write2Byte(BK_NJPD1_GLOBAL_SETTING00, u16Value);
475 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_Get_GlobalSetting00 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_GLOBAL_SETTING00));
476 }
477 else
478 {
479 __HAL_NJPD_Write2Byte(BK_NJPD2_GLOBAL_SETTING00, u16Value);
480 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_Get_GlobalSetting00 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_GLOBAL_SETTING00));
481 }
482 }
483
HAL_NJPD_Get_GlobalSetting00(void)484 MS_U16 HAL_NJPD_Get_GlobalSetting00(void)
485 {
486 if(eNJPDNum == E_NJPD_NJPD1)
487 {
488 return __HAL_NJPD_Read2Byte(BK_NJPD1_GLOBAL_SETTING00);
489 }
490 else
491 {
492 return __HAL_NJPD_Read2Byte(BK_NJPD2_GLOBAL_SETTING00);
493 }
494 }
495
HAL_NJPD_Set_GlobalSetting01(MS_U16 u16Value)496 void HAL_NJPD_Set_GlobalSetting01(MS_U16 u16Value)
497 {
498 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
499 if(eNJPDNum == E_NJPD_NJPD1)
500 {
501 __HAL_NJPD_Write2Byte(BK_NJPD1_GLOBAL_SETTING01, u16Value);
502 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_Get_GlobalSetting01 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_GLOBAL_SETTING01));
503 }
504 else
505 {
506 __HAL_NJPD_Write2Byte(BK_NJPD2_GLOBAL_SETTING01, u16Value);
507 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_Get_GlobalSetting01 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_GLOBAL_SETTING01));
508 }
509 }
510
HAL_NJPD_Get_GlobalSetting01(void)511 MS_U16 HAL_NJPD_Get_GlobalSetting01(void)
512 {
513 if(eNJPDNum == E_NJPD_NJPD1)
514 {
515 return __HAL_NJPD_Read2Byte(BK_NJPD1_GLOBAL_SETTING01);
516 }
517 else
518 {
519 return __HAL_NJPD_Read2Byte(BK_NJPD2_GLOBAL_SETTING01);
520 }
521 }
522
HAL_NJPD_Set_GlobalSetting02(MS_U16 u16Value)523 void HAL_NJPD_Set_GlobalSetting02(MS_U16 u16Value)
524 {
525 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
526 if(eNJPDNum == E_NJPD_NJPD1)
527 {
528 __HAL_NJPD_Write2Byte(BK_NJPD1_GLOBAL_SETTING02, u16Value);
529 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_Get_GlobalSetting02 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_GLOBAL_SETTING02));
530 }
531 else
532 {
533 __HAL_NJPD_Write2Byte(BK_NJPD2_GLOBAL_SETTING02, u16Value);
534 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_Get_GlobalSetting02 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_GLOBAL_SETTING02));
535 }
536 }
537
HAL_NJPD_Get_GlobalSetting02(void)538 MS_U16 HAL_NJPD_Get_GlobalSetting02(void)
539 {
540 if(eNJPDNum == E_NJPD_NJPD1)
541 {
542 return __HAL_NJPD_Read2Byte(BK_NJPD1_GLOBAL_SETTING02);
543 }
544 else
545 {
546 return __HAL_NJPD_Read2Byte(BK_NJPD2_GLOBAL_SETTING02);
547 }
548 }
549
550
HAL_NJPD_SetMRCBuf0_StartLow(MS_U16 u16Value)551 void HAL_NJPD_SetMRCBuf0_StartLow(MS_U16 u16Value)
552 {
553 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
554 if(eNJPDNum == E_NJPD_NJPD1)
555 {
556 __HAL_NJPD_Write2Byte(BK_NJPD1_MIU_READ_BUFFER0_START_ADDR_L, u16Value);
557 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetMRCBuf0_StartLow : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_READ_BUFFER0_START_ADDR_L));
558 }
559 else
560 {
561 __HAL_NJPD_Write2Byte(BK_NJPD2_MIU_READ_BUFFER0_START_ADDR_L, u16Value);
562 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetMRCBuf0_StartLow : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_READ_BUFFER0_START_ADDR_L));
563 }
564 }
565
HAL_NJPD_SetMRCBuf0_StartHigh(MS_U16 u16Value)566 void HAL_NJPD_SetMRCBuf0_StartHigh(MS_U16 u16Value)
567 {
568 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
569 if(eNJPDNum == E_NJPD_NJPD1)
570 {
571 __HAL_NJPD_Write2Byte(BK_NJPD1_MIU_READ_BUFFER0_START_ADDR_H, u16Value);
572 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetMRCBuf0_StartHigh : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_READ_BUFFER0_START_ADDR_H));
573 }
574 else
575 {
576 __HAL_NJPD_Write2Byte(BK_NJPD2_MIU_READ_BUFFER0_START_ADDR_H, u16Value);
577 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetMRCBuf0_StartHigh : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_READ_BUFFER0_START_ADDR_H));
578 }
579 }
580
HAL_NJPD_SetMRCBuf0_EndLow(MS_U16 u16Value)581 void HAL_NJPD_SetMRCBuf0_EndLow(MS_U16 u16Value)
582 {
583 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
584 if(eNJPDNum == E_NJPD_NJPD1)
585 {
586 __HAL_NJPD_Write2Byte(BK_NJPD1_MIU_READ_BUFFER0_END_ADDR_L, u16Value);
587 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetMRCBuf0_EndLow : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_READ_BUFFER0_END_ADDR_L));
588 }
589 else
590 {
591 __HAL_NJPD_Write2Byte(BK_NJPD2_MIU_READ_BUFFER0_END_ADDR_L, u16Value);
592 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetMRCBuf0_EndLow : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_READ_BUFFER0_END_ADDR_L));
593 }
594 }
595
HAL_NJPD_SetMRCBuf0_EndHigh(MS_U16 u16Value)596 void HAL_NJPD_SetMRCBuf0_EndHigh(MS_U16 u16Value)
597 {
598 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
599 if(eNJPDNum == E_NJPD_NJPD1)
600 {
601 __HAL_NJPD_Write2Byte(BK_NJPD1_MIU_READ_BUFFER0_END_ADDR_H, u16Value);
602 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetMRCBuf0_EndHigh : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_READ_BUFFER0_END_ADDR_H));
603 }
604 else
605 {
606 __HAL_NJPD_Write2Byte(BK_NJPD2_MIU_READ_BUFFER0_END_ADDR_H, u16Value);
607 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetMRCBuf0_EndHigh : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_READ_BUFFER0_END_ADDR_H));
608 }
609 }
610
HAL_NJPD_SetMRCBuf1_StartLow(MS_U16 u16Value)611 void HAL_NJPD_SetMRCBuf1_StartLow(MS_U16 u16Value)
612 {
613 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
614 if(eNJPDNum == E_NJPD_NJPD1)
615 {
616 __HAL_NJPD_Write2Byte(BK_NJPD1_MIU_READ_BUFFER1_START_ADDR_L, u16Value);
617 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetMRCBuf1_StartLow : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_READ_BUFFER1_START_ADDR_L));
618 }
619 else
620 {
621 __HAL_NJPD_Write2Byte(BK_NJPD2_MIU_READ_BUFFER1_START_ADDR_L, u16Value);
622 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetMRCBuf1_StartLow : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_READ_BUFFER1_START_ADDR_L));
623 }
624 }
625
HAL_NJPD_SetMRCBuf1_StartHigh(MS_U16 u16Value)626 void HAL_NJPD_SetMRCBuf1_StartHigh(MS_U16 u16Value)
627 {
628 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
629 if(eNJPDNum == E_NJPD_NJPD1)
630 {
631 __HAL_NJPD_Write2Byte(BK_NJPD1_MIU_READ_BUFFER1_START_ADDR_H, u16Value);
632 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetMRCBuf1_StartHigh : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_READ_BUFFER1_START_ADDR_H));
633 }
634 else
635 {
636 __HAL_NJPD_Write2Byte(BK_NJPD2_MIU_READ_BUFFER1_START_ADDR_H, u16Value);
637 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetMRCBuf1_StartHigh : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_READ_BUFFER1_START_ADDR_H));
638 }
639 }
640
HAL_NJPD_SetMRCBuf1_EndLow(MS_U16 u16Value)641 void HAL_NJPD_SetMRCBuf1_EndLow(MS_U16 u16Value)
642 {
643 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
644 if(eNJPDNum == E_NJPD_NJPD1)
645 {
646 __HAL_NJPD_Write2Byte(BK_NJPD1_MIU_READ_BUFFER1_END_ADDR_L, u16Value);
647 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetMRCBuf1_EndLow : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_READ_BUFFER1_END_ADDR_L));
648 }
649 else
650 {
651 __HAL_NJPD_Write2Byte(BK_NJPD2_MIU_READ_BUFFER1_END_ADDR_L, u16Value);
652 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetMRCBuf1_EndLow : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_READ_BUFFER1_END_ADDR_L));
653 }
654 }
655
HAL_NJPD_SetMRCBuf1_EndHigh(MS_U16 u16Value)656 void HAL_NJPD_SetMRCBuf1_EndHigh(MS_U16 u16Value)
657 {
658 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
659 if(eNJPDNum == E_NJPD_NJPD1)
660 {
661 __HAL_NJPD_Write2Byte(BK_NJPD1_MIU_READ_BUFFER1_END_ADDR_H, u16Value);
662 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetMRCBuf1_EndHigh : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_READ_BUFFER1_END_ADDR_H));
663 }
664 else
665 {
666 __HAL_NJPD_Write2Byte(BK_NJPD2_MIU_READ_BUFFER1_END_ADDR_H, u16Value);
667 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetMRCBuf1_EndHigh : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_READ_BUFFER1_END_ADDR_H));
668 }
669 }
670
671
HAL_NJPD_SetMRCStart_Low(MS_U16 u16Value)672 void HAL_NJPD_SetMRCStart_Low(MS_U16 u16Value)
673 {
674 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
675 if(eNJPDNum == E_NJPD_NJPD1)
676 {
677 __HAL_NJPD_Write2Byte(BK_NJPD1_MIU_READ_START_ADDR_L, u16Value);
678 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetMRCStart_Low : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_READ_START_ADDR_L));
679 }
680 else
681 {
682 __HAL_NJPD_Write2Byte(BK_NJPD2_MIU_READ_START_ADDR_L, u16Value);
683 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetMRCStart_Low : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_READ_START_ADDR_L));
684 }
685 }
686
HAL_NJPD_SetMRCStart_High(MS_U16 u16Value)687 void HAL_NJPD_SetMRCStart_High(MS_U16 u16Value)
688 {
689 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
690 if(eNJPDNum == E_NJPD_NJPD1)
691 {
692 __HAL_NJPD_Write2Byte(BK_NJPD1_MIU_READ_START_ADDR_H, u16Value);
693 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetMRCStart_High : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_READ_START_ADDR_H));
694 }
695 else
696 {
697 __HAL_NJPD_Write2Byte(BK_NJPD2_MIU_READ_START_ADDR_H, u16Value);
698 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetMRCStart_High : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_READ_START_ADDR_H));
699 }
700 }
701
702
HAL_NJPD_SetMWCBuf_StartLow(MS_U16 u16Value)703 void HAL_NJPD_SetMWCBuf_StartLow(MS_U16 u16Value)
704 {
705 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
706 if(eNJPDNum == E_NJPD_NJPD1)
707 {
708 __HAL_NJPD_Write2Byte(BK_NJPD1_MIU_WRITE_START_ADDR_L, u16Value);
709 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetMWCBuf_StartLow : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_WRITE_START_ADDR_L));
710 }
711 else
712 {
713 __HAL_NJPD_Write2Byte(BK_NJPD2_MIU_WRITE_START_ADDR_L, u16Value);
714 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetMWCBuf_StartLow : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_WRITE_START_ADDR_L));
715 }
716 }
717
HAL_NJPD_SetMWCBuf_StartHigh(MS_U16 u16Value)718 void HAL_NJPD_SetMWCBuf_StartHigh(MS_U16 u16Value)
719 {
720 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
721 if(eNJPDNum == E_NJPD_NJPD1)
722 {
723 __HAL_NJPD_Write2Byte(BK_NJPD1_MIU_WRITE_START_ADDR_H, u16Value);
724 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetMWCBuf_StartHigh : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_WRITE_START_ADDR_H));
725 }
726 else
727 {
728 __HAL_NJPD_Write2Byte(BK_NJPD2_MIU_WRITE_START_ADDR_H, u16Value);
729 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetMWCBuf_StartHigh : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_WRITE_START_ADDR_H));
730 }
731 }
732
HAL_NJPD_GetMWCBuf_StartLow(void)733 MS_U16 HAL_NJPD_GetMWCBuf_StartLow(void)
734 {
735 if(eNJPDNum == E_NJPD_NJPD1)
736 {
737 return __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_WRITE_START_ADDR_L);
738 }
739 else
740 {
741 return __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_WRITE_START_ADDR_L);
742 }
743 }
744
HAL_NJPD_GetMWCBuf_StartHigh(void)745 MS_U16 HAL_NJPD_GetMWCBuf_StartHigh(void)
746 {
747 if(eNJPDNum == E_NJPD_NJPD1)
748 {
749 return __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_WRITE_START_ADDR_H);
750 }
751 else
752 {
753 return __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_WRITE_START_ADDR_H);
754 }
755 }
756
757
HAL_NJPD_GetMWCBuf_WritePtrLow(void)758 MS_U16 HAL_NJPD_GetMWCBuf_WritePtrLow(void)
759 {
760 if(eNJPDNum == E_NJPD_NJPD1)
761 {
762 return __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_WRITE_POINTER_ADDR_L);
763 }
764 else
765 {
766 return __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_WRITE_POINTER_ADDR_L);
767 }
768 }
769
HAL_NJPD_GetMWCBuf_WritePtrHigh(void)770 MS_U16 HAL_NJPD_GetMWCBuf_WritePtrHigh(void)
771 {
772 if(eNJPDNum == E_NJPD_NJPD1)
773 {
774 return __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_WRITE_POINTER_ADDR_H);
775 }
776 else
777 {
778 return __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_WRITE_POINTER_ADDR_H);
779 }
780 }
781
782 /******************************************************************************/
783 ///
784 ///@param value \b IN
785 ///@param value \b OUT
786 ///@return status
787 /******************************************************************************/
HAL_NJPD_SetPic_H(MS_U16 u16Value)788 void HAL_NJPD_SetPic_H(MS_U16 u16Value)
789 {
790 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
791 if(eNJPDNum == E_NJPD_NJPD1)
792 {
793 __HAL_NJPD_Write2Byte(BK_NJPD1_IMG_HSIZE, u16Value);
794 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetPic_H : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_IMG_HSIZE));
795 }
796 else
797 {
798 __HAL_NJPD_Write2Byte(BK_NJPD2_IMG_HSIZE, u16Value);
799 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetPic_H : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_IMG_HSIZE));
800 }
801 }
802
803 /******************************************************************************/
804 ///
805 ///@param value \b IN
806 ///@param value \b OUT
807 ///@return status
808 /******************************************************************************/
HAL_NJPD_SetPic_V(MS_U16 u16Value)809 void HAL_NJPD_SetPic_V(MS_U16 u16Value)
810 {
811 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
812 if(eNJPDNum == E_NJPD_NJPD1)
813 {
814 __HAL_NJPD_Write2Byte(BK_NJPD1_IMG_VSIZE, u16Value);
815 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetPic_V : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_IMG_VSIZE));
816 }
817 else
818 {
819 __HAL_NJPD_Write2Byte(BK_NJPD2_IMG_VSIZE, u16Value);
820 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetPic_V : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_IMG_VSIZE));
821 }
822 }
823
HAL_NJPD_ClearEventFlag(MS_U16 u16Value)824 void HAL_NJPD_ClearEventFlag(MS_U16 u16Value)
825 {
826 // Write 1 clear
827 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
828 if(eNJPDNum == E_NJPD_NJPD1)
829 {
830 __HAL_NJPD_Write2Byte(BK_NJPD1_IRQ_CLEAR, u16Value);
831 }
832 else
833 {
834 __HAL_NJPD_Write2Byte(BK_NJPD2_IRQ_CLEAR, u16Value);
835 }
836 }
HAL_NJPD_ForceEventFlag(MS_U16 u16Value)837 void HAL_NJPD_ForceEventFlag(MS_U16 u16Value)
838 {
839 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
840 if(eNJPDNum == E_NJPD_NJPD1)
841 {
842 __HAL_NJPD_Write2Byte(BK_NJPD1_IRQ_FORCE, u16Value);
843 }
844 else
845 {
846 __HAL_NJPD_Write2Byte(BK_NJPD2_IRQ_FORCE, u16Value);
847 }
848 }
HAL_NJPD_MaskEventFlag(MS_U16 u16Value)849 void HAL_NJPD_MaskEventFlag(MS_U16 u16Value)
850 {
851 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
852 if(eNJPDNum == E_NJPD_NJPD1)
853 {
854 __HAL_NJPD_Write2Byte(BK_NJPD1_IRQ_MASK, u16Value);
855 }
856 else
857 {
858 __HAL_NJPD_Write2Byte(BK_NJPD2_IRQ_MASK, u16Value);
859 }
860 }
HAL_NJPD_GetEventFlag(void)861 MS_U16 HAL_NJPD_GetEventFlag(void)
862 {
863 if(eNJPDNum == E_NJPD_NJPD1)
864 {
865 #if MEASURE_NJPD_MIU_CLIENT_EFFICIENCY
866 MsOS_DelayTask(1);
867 printf("bank: 0x1012, offset: 0x0e, value=0x%x(%d), efficiency=%d%%\n", __HAL_NJPD_Read2Byte(BK_MIU0_GENERAL(0x0e)),
868 __HAL_NJPD_Read2Byte(BK_MIU0_GENERAL(0x0e)), __HAL_NJPD_Read2Byte(BK_MIU0_GENERAL(0x0e))*100/1024);
869 #endif
870 return __HAL_NJPD_Read2Byte(BK_NJPD1_IRQ_FINAL_S);
871 }
872 else
873 {
874 return __HAL_NJPD_Read2Byte(BK_NJPD2_IRQ_FINAL_S);
875 }
876 }
877
878 /******************************************************************************/
879 ///
880 ///@param value \b IN
881 ///@param value \b OUT
882 ///@return status
883 /******************************************************************************/
HAL_NJPD_SetROI_H(MS_U16 u16Value)884 void HAL_NJPD_SetROI_H(MS_U16 u16Value)
885 {
886 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
887 if(eNJPDNum == E_NJPD_NJPD1)
888 {
889 __HAL_NJPD_Write2Byte(BK_NJPD1_ROI_H_START, u16Value);
890 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetROI_H : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_ROI_H_START));
891 }
892 else
893 {
894 __HAL_NJPD_Write2Byte(BK_NJPD2_ROI_H_START, u16Value);
895 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetROI_H : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_ROI_H_START));
896 }
897 }
898
899 /******************************************************************************/
900 ///
901 ///@param value \b IN
902 ///@param value \b OUT
903 ///@return status
904 /******************************************************************************/
HAL_NJPD_SetROI_V(MS_U16 u16Value)905 void HAL_NJPD_SetROI_V(MS_U16 u16Value)
906 {
907 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
908 if(eNJPDNum == E_NJPD_NJPD1)
909 {
910 __HAL_NJPD_Write2Byte(BK_NJPD1_ROI_V_START, u16Value);
911 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetROI_V : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_ROI_V_START));
912 }
913 else
914 {
915 __HAL_NJPD_Write2Byte(BK_NJPD2_ROI_V_START, u16Value);
916 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetROI_V : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_ROI_V_START));
917 }
918 }
919
920 /******************************************************************************/
921 ///
922 ///@param value \b IN
923 ///@param value \b OUT
924 ///@return status
925 /******************************************************************************/
HAL_NJPD_SetROIWidth(MS_U16 u16Value)926 void HAL_NJPD_SetROIWidth(MS_U16 u16Value)
927 {
928 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
929 if(eNJPDNum == E_NJPD_NJPD1)
930 {
931 __HAL_NJPD_Write2Byte(BK_NJPD1_ROI_H_SIZE, u16Value);
932 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetROIWidth : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_ROI_H_SIZE));
933 }
934 else
935 {
936 __HAL_NJPD_Write2Byte(BK_NJPD2_ROI_H_SIZE, u16Value);
937 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetROIWidth : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_ROI_H_SIZE));
938 }
939 }
940
941 /******************************************************************************/
942 ///
943 ///@param value \b IN
944 ///@param value \b OUT
945 ///@return status
946 /******************************************************************************/
HAL_NJPD_SetROIHeight(MS_U16 u16Value)947 void HAL_NJPD_SetROIHeight(MS_U16 u16Value)
948 {
949 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
950 if(eNJPDNum == E_NJPD_NJPD1)
951 {
952 __HAL_NJPD_Write2Byte(BK_NJPD1_ROI_V_SIZE, u16Value);
953 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetROIHeight : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_ROI_V_SIZE));
954 }
955 else
956 {
957 __HAL_NJPD_Write2Byte(BK_NJPD2_ROI_V_SIZE, u16Value);
958 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetROIHeight : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_ROI_V_SIZE));
959 }
960 }
961
962 /******************************************************************************/
963 ///
964 ///@param value \b IN
965 ///@param value \b OUT
966 ///@return status
967 /******************************************************************************/
HAL_NJPD_SetClock(MS_U16 u16Value)968 void HAL_NJPD_SetClock(MS_U16 u16Value)
969 {
970 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
971 __HAL_NJPD_Write2Byte(NJPD_CLOCK, u16Value);
972 NJPD_DEBUG_HAL_MSG("HAL_NJPD_GetClock : 0x%04x\n", __HAL_NJPD_Read2Byte(NJPD_CLOCK));
973 }
974
975 /******************************************************************************/
976 ///
977 ///@param value \b IN
978 ///@param value \b OUT
979 ///@return status
980 /******************************************************************************/
HAL_NJPD_SetClockGate(MS_U16 u16Value)981 void HAL_NJPD_SetClockGate(MS_U16 u16Value)
982 {
983 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
984 if(eNJPDNum == E_NJPD_NJPD1)
985 {
986 __HAL_NJPD_Write2Byte(BK_NJPD1_GATED_CLOCK_CTRL, u16Value);
987 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetClockGate : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_GATED_CLOCK_CTRL));
988 }
989 else
990 {
991 __HAL_NJPD_Write2Byte(BK_NJPD2_GATED_CLOCK_CTRL, u16Value);
992 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetClockGate : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_GATED_CLOCK_CTRL));
993 }
994 }
995
996 /******************************************************************************/
997 ///
998 ///@param value \b IN
999 ///@param value \b OUT
1000 ///@return status
1001 /******************************************************************************/
HAL_NJPD_GetClock(void)1002 MS_U16 HAL_NJPD_GetClock(void)
1003 {
1004 return __HAL_NJPD_Read2Byte(NJPD_CLOCK);
1005 }
1006
1007 /******************************************************************************/
1008 ///
1009 ///@param value \b IN
1010 ///@param value \b OUT
1011 ///@return status
1012 /******************************************************************************/
HAL_NJPD_PowerOn()1013 void HAL_NJPD_PowerOn()
1014 {
1015 MS_U16 u16reg_val;
1016 u16reg_val = HAL_NJPD_GetClock();
1017 u16reg_val = u16reg_val & 0xFFF2;
1018 u16reg_val |= 0x0000; // set NJPD disable [0] : 0, [3:2] : 00 288MHz
1019 NJPD_DEBUG_HAL_MSG("%s : SetClock : 0x%04x\n", __FUNCTION__ , u16reg_val);
1020
1021 #ifdef CONFIG_MSTAR_SRAMPD
1022 // reference to 00_curry_register_assignment.xls
1023 //1712H 0 1 1 1 1 0 0 0 0 codec_block 0 codec_gp
1024 // reference to curry_block_top_reg.xls
1025 // h11 h10 31 0 reg_codec_sram_sd_en 31 0 32 h00 rw
1026 // bit [18] : jpd
1027 NJPD_DEBUG_HAL_MSG("NJPD sram on\n");
1028 *((volatile MS_U32 *)(MS_VIRT)(NJPD_RIU_MAP + 0x71200*2 + 0x10*2*2)) &= ~(1UL << 18);
1029 MsOS_DelayTask(1);
1030 #endif
1031
1032 #ifdef CONFIG_MSTAR_CLKM
1033 MS_S32 handle = Drv_Clkm_Get_Handle("g_clk_njpd");
1034 Drv_Clkm_Set_Clk_Source(handle , "720p60fps_mode");
1035 #else
1036 HAL_NJPD_SetClock(u16reg_val);
1037 #endif
1038 NJPD_DEBUG_HAL_MSG("%s : GetClock : 0x%04x\n", __FUNCTION__ , HAL_NJPD_GetClock());
1039 HAL_NJPD_JPDSelect(TRUE);
1040 #if 0
1041 // set the security range for test
1042 __HAL_NJPD_Write2Byte(NJPD_NONPM_SECURE_20, 0x0000);
1043 __HAL_NJPD_Write2Byte(NJPD_NONPM_SECURE_21, 0x0000);
1044 __HAL_NJPD_Write2Byte(NJPD_NONPM_SECURE_22, 0x0000);
1045 __HAL_NJPD_Write2Byte(NJPD_NONPM_SECURE_23, 0x0000);
1046 __HAL_NJPD_Write2Byte(NJPD_NONPM_SECURE_24, 0x0000);
1047 __HAL_NJPD_Write2Byte(NJPD_NONPM_SECURE_25, 0x0000);
1048 __HAL_NJPD_Write2Byte(NJPD_NONPM_SECURE_26, 0x0000);
1049 __HAL_NJPD_Write2Byte(NJPD_NONPM_SECURE_27, 0x0000);
1050 __HAL_NJPD_Write2Byte(NJPD_NONPM_SECURE_28, 0x0000);
1051 __HAL_NJPD_Write2Byte(NJPD_NONPM_SECURE_29, 0x0000);
1052 __HAL_NJPD_Write2Byte(NJPD_NONPM_SECURE_2A, 0x0000);
1053 __HAL_NJPD_Write2Byte(NJPD_NONPM_SECURE_2B, 0x0000);
1054 __HAL_NJPD_Write2Byte(NJPD_NONPM_SECURE_2C, 0x0000);
1055 __HAL_NJPD_Write2Byte(NJPD_NONPM_SECURE_2D, 0x0000);
1056 __HAL_NJPD_Write2Byte(NJPD_NONPM_SECURE_2E, 0x0000);
1057 __HAL_NJPD_Write2Byte(NJPD_NONPM_SECURE_2F, 0x0000);
1058 #endif
1059
1060 #if 0 // test code to make sure the MCM function disabled
1061 #define JPD_MCM_BASE 0x71200 //0x71F20
1062 #define BK_MCM_GENERAL(x) (JPD_MCM_BASE+NJPD_OFFSET(x))
1063
1064 // MS_U8 u8i;
1065 // for(u8i=0; u8i<0x16; u8i++)
1066 // {
1067 // __HAL_JPD_Write2Byte(BK_MCM_GENERAL(u8i), 0);
1068 // }
1069
1070 // __HAL_NJPD_Write2Byte(BK_MCM_GENERAL(0x09), 0x0000);
1071 // printf("MCM 0x%lx\n", 0x00);
1072 // __HAL_NJPD_Write2Byte(BK_MCM_GENERAL(0x09), 0xf200);
1073 // printf("MCM 0x%lx\n", 0xf2);
1074
1075 // __HAL_NJPD_Write2Byte(BK_MCM_GENERAL(0x09), 0xf000);
1076 // printf("MCM 0x%lx\n", 0xf0);
1077
1078 __HAL_NJPD_Write2Byte(BK_MCM_GENERAL(0x09), 0x1200);
1079 printf("MCM 0x%lx\n", 0x12);
1080 #endif
1081
1082
1083 #if MEASURE_NJPD_MIU_CLIENT_EFFICIENCY
1084 if(bJPEGFirstTime==0)
1085 {
1086 printf("bank: 0x1012, offset: 0x15, value=0x%x\n", __HAL_NJPD_Read2Byte(BK_MIU0_GENERAL(0x15)));
1087 __HAL_NJPD_Write2Byte(BK_MIU0_GENERAL(0x15), __HAL_NJPD_Read2Byte(BK_MIU0_GENERAL(0x15)) & ~0x80);
1088 printf("bank: 0x1012, offset: 0x15, value=0x%x\n", __HAL_NJPD_Read2Byte(BK_MIU0_GENERAL(0x15)));
1089 printf("bank: 0x1012, offset: 0x0d, value=0x%x\n", __HAL_NJPD_Read2Byte(BK_MIU0_GENERAL(0x0d)));
1090 __HAL_NJPD_Write2Byte(BK_MIU0_GENERAL(0x0d), 0x2734);
1091 printf("bank: 0x1012, offset: 0x0d, value=0x%x\n", __HAL_NJPD_Read2Byte(BK_MIU0_GENERAL(0x0d)));
1092 __HAL_NJPD_Write2Byte(BK_MIU0_GENERAL(0x0d), 0x2735);
1093 printf("bank: 0x1012, offset: 0x0d, value=0x%x\n", __HAL_NJPD_Read2Byte(BK_MIU0_GENERAL(0x0d)));
1094
1095 bJPEGFirstTime=1;
1096 }
1097 #endif
1098 }
1099
1100 /******************************************************************************/
1101 ///
1102 ///@param value \b IN
1103 ///@param value \b OUT
1104 ///@return status
1105 /******************************************************************************/
HAL_NJPD_PowerOff(void)1106 void HAL_NJPD_PowerOff(void)
1107 {
1108 MS_U16 u16reg_val;
1109 u16reg_val = HAL_NJPD_GetClock();
1110 u16reg_val = u16reg_val & 0xFFF2;
1111 u16reg_val |= 0x0001; // set NJPD disable [8] : 1, [3:2] : 00 288MHz
1112 NJPD_DEBUG_HAL_MSG("%s : SetClock : 0x%04x\n", __FUNCTION__ , u16reg_val);
1113 #ifdef CONFIG_MSTAR_CLKM
1114 MS_S32 handle = Drv_Clkm_Get_Handle("g_clk_njpd");
1115 Drv_Clkm_Clk_Gate_Disable(handle);
1116 #else
1117 HAL_NJPD_SetClock(u16reg_val);
1118 #endif
1119
1120
1121 #ifdef CONFIG_MSTAR_SRAMPD
1122 // reference to 00_curry_register_assignment.xls
1123 //1712H 0 1 1 1 1 0 0 0 0 codec_block 0 codec_gp
1124 // reference to curry_block_top_reg.xls
1125 // h11 h10 31 0 reg_codec_sram_sd_en 31 0 32 h00 rw
1126 // bit [18] : jpd
1127 NJPD_DEBUG_HAL_MSG("NJPD sram off\n");
1128 *((volatile MS_U32 *)(MS_VIRT)(NJPD_RIU_MAP + 0x71200*2 + 0x10*2*2)) |= (1UL << 18);
1129 MsOS_DelayTask(1);
1130 #endif
1131 NJPD_DEBUG_HAL_MSG("%s : GetClock : 0x%04x\n", __FUNCTION__ , HAL_NJPD_GetClock());
1132 }
1133
1134 /******************************************************************************/
1135 ///
1136 ///@param value \b IN
1137 ///@param value \b OUT
1138 ///@return status
1139 /******************************************************************************/
HAL_NJPD_InitRegBase(void)1140 void HAL_NJPD_InitRegBase(void)
1141 {
1142 MS_PHY u32NonPMBankSize;
1143 if(!MDrv_MMIO_GetBASE(&u32NJPDRiuBaseAdd, &u32NonPMBankSize, MS_MODULE_JPD))
1144 {
1145 NJPD_DEBUG_HAL_ERR("Get RIUreg base Failed!!!\n");
1146 }
1147 else
1148 {
1149 NJPD_DEBUG_HAL_MSG("RIUreg base = 0x%tx, length = %tx\n", (ptrdiff_t)u32NJPDRiuBaseAdd, (ptrdiff_t)u32NonPMBankSize);
1150 }
1151 }
1152
1153 /******************************************************************************/
1154 ///
1155 ///@param value \b IN
1156 ///@param value \b OUT
1157 ///@return none
1158 /******************************************************************************/
HAL_NJPD_CreateMutex(void)1159 void HAL_NJPD_CreateMutex(void)
1160 {
1161 __HAL_NJPD_MutexCreate();
1162 }
1163
1164 /******************************************************************************/
1165 ///
1166 ///@param value \b IN
1167 ///@param value \b OUT
1168 ///@return none
1169 /******************************************************************************/
HAL_NJPD_DeleteMutex(void)1170 void HAL_NJPD_DeleteMutex(void)
1171 {
1172 __HAL_NJPD_MutexDelete();
1173 }
1174
1175 /******************************************************************************/
1176 ///
1177 ///@param value \b IN
1178 ///@param value \b OUT
1179 ///@return status
1180 /******************************************************************************/
HAL_NJPD_SetRSTIntv(MS_U16 u16Value)1181 void HAL_NJPD_SetRSTIntv(MS_U16 u16Value)
1182 {
1183 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1184 if(eNJPDNum == E_NJPD_NJPD1)
1185 {
1186 __HAL_NJPD_Write2Byte(BK_NJPD1_RESTART_INTERVAL, u16Value);
1187 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetRSTIntv : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_RESTART_INTERVAL));
1188 }
1189 else
1190 {
1191 __HAL_NJPD_Write2Byte(BK_NJPD2_RESTART_INTERVAL, u16Value);
1192 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetRSTIntv : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_RESTART_INTERVAL));
1193 }
1194 }
1195
1196
1197 /******************************************************************************/
1198 ///
1199 ///@param value \b IN
1200 ///@param value \b OUT
1201 ///@return none
1202 /******************************************************************************/
HAL_NJPD_SetDbgLevel(MS_U8 u8DbgLevel)1203 void HAL_NJPD_SetDbgLevel(MS_U8 u8DbgLevel)
1204 {
1205 _u8NJPDHalDbgLevel = u8DbgLevel;
1206 }
1207
1208 /******************************************************************************/
1209 ///
1210 ///@param value \b IN
1211 ///@param value \b OUT
1212 ///@return none
1213 /******************************************************************************/
HAL_NJPD_GetLibVer(NJPD_HAL_Version * pHalVer)1214 void HAL_NJPD_GetLibVer(NJPD_HAL_Version *pHalVer)
1215 {
1216 pHalVer->pu8HalVer = _pu8HalVer;
1217 pHalVer->pu8FwVer = _pu8FwVer;
1218 }
1219
1220 /******************************************************************************/
1221 ///Reset NJPD
1222 ///@param value \b IN
1223 ///@param value \b OUT
1224 ///@return none
1225 /******************************************************************************/
HAL_NJPD_Rst(void)1226 void HAL_NJPD_Rst(void)
1227 {
1228 NJPD_DEBUG_HAL_MSG("%s : start!!\n", __FUNCTION__);
1229 _HAL_NJPD_SetMIUProtectMask(TRUE);
1230
1231 // reset event flag
1232 HAL_NJPD_ClearEventFlag(NJPD_EVENT_ALL);
1233 // reset : low active
1234
1235 #if ENABLE_TEST_NJPD_17_Obuf_Output_Format
1236 HAL_NJPD_SetOutputFormat(TRUE, E_NJPD_OUTPUT_YC_SWAP);
1237 // HAL_NJPD_SetOutputFormat(TRUE, E_NJPD_OUTPUT_UV_SWAP);
1238 // HAL_NJPD_SetOutputFormat(TRUE, E_NJPD_OUTPUT_UV_7BIT);
1239 // HAL_NJPD_SetOutputFormat(TRUE, E_NJPD_OUTPUT_UV_MSB);
1240 #else
1241 if(HAL_NJPD_GetVerificationMode()==E_NJPD17_OBUF_OUTPUT_FORMAT_YC_SWAP)
1242 {
1243 HAL_NJPD_SetOutputFormat(TRUE, E_NJPD_OUTPUT_YC_SWAP);
1244 }
1245 else if(HAL_NJPD_GetVerificationMode()==E_NJPD17_OBUF_OUTPUT_FORMAT_UV_SWAP)
1246 {
1247 HAL_NJPD_SetOutputFormat(TRUE, E_NJPD_OUTPUT_UV_SWAP);
1248 }
1249 else if(HAL_NJPD_GetVerificationMode()==E_NJPD17_OBUF_OUTPUT_FORMAT_UV_7BIT)
1250 {
1251 HAL_NJPD_SetOutputFormat(TRUE, E_NJPD_OUTPUT_UV_7BIT);
1252 }
1253 else if(HAL_NJPD_GetVerificationMode()==E_NJPD17_OBUF_OUTPUT_FORMAT_UV_MSB)
1254 {
1255 HAL_NJPD_SetOutputFormat(TRUE, E_NJPD_OUTPUT_UV_MSB);
1256 }
1257 else
1258 {
1259 HAL_NJPD_SetOutputFormat(TRUE, E_NJPD_OUTPUT_ORIGINAL);
1260 }
1261 #endif
1262
1263 #if ENABLE_NJPD_DEBUG_MSG
1264 HAL_NJPD_Set_GlobalSetting02(0xFC | NJPD_TBC_MODE | NJPD_LITTLE_ENDIAN | NJPD_REMOVE_0xFF00 |
1265 NJPD_REMOVE_0xFFFF | NJPD_HUFF_DATA_LOSS_ERROR);
1266 #else
1267 if(HAL_NJPD_GetVerificationMode()==E_NJPD01_TABLE_READ_WRITE)
1268 {
1269 HAL_NJPD_Set_GlobalSetting02(0xFC | NJPD_TBC_MODE | NJPD_LITTLE_ENDIAN | NJPD_REMOVE_0xFF00 |
1270 NJPD_REMOVE_0xFFFF | NJPD_HUFF_DATA_LOSS_ERROR);
1271 }
1272 else
1273 {
1274 HAL_NJPD_Set_GlobalSetting02(NJPD_TBC_MODE | NJPD_LITTLE_ENDIAN | NJPD_REMOVE_0xFF00 |
1275 NJPD_REMOVE_0xFFFF | NJPD_HUFF_DATA_LOSS_ERROR);
1276 }
1277 #endif
1278 HAL_NJPD_Set_GlobalSetting00(HAL_NJPD_Get_GlobalSetting00() | NJPD_SWRST);
1279 #if 0
1280 HAL_NJPD_MaskEventFlag(0xffff);
1281
1282 #else
1283 HAL_NJPD_MaskEventFlag(~(NJPD_EVENT_DECODE_DONE | NJPD_EVENT_MINICODE_ERR |
1284 NJPD_EVENT_INV_SCAN_ERR | NJPD_EVENT_RES_MARKER_ERR | NJPD_EVENT_RMID_ERR |
1285 NJPD_EVENT_END_IMAGE_ERR | NJPD_EVENT_MRC0_EMPTY | NJPD_EVENT_MRC1_EMPTY |
1286 NJPD_EVENT_WRITE_PROTECT | NJPD_EVENT_DATA_LOSS_ERR |
1287 NJPD_EVENT_HUFF_TABLE_ERR)); // set 0 to turn on the irq
1288 #endif
1289
1290 NJPD_DEBUG_HAL_MSG("Get BK_NJPD_GLOBAL_SETTING00 : 0x%04x\n", HAL_NJPD_Get_GlobalSetting00());
1291 NJPD_DEBUG_HAL_MSG("Get BK_NJPD_GLOBAL_SETTING01 : 0x%04x\n", HAL_NJPD_Get_GlobalSetting01());
1292 NJPD_DEBUG_HAL_MSG("Get BK_NJPD_GLOBAL_SETTING02 : 0x%04x\n", HAL_NJPD_Get_GlobalSetting02());
1293 if(eNJPDNum == E_NJPD_NJPD1)
1294 {
1295 NJPD_DEBUG_HAL_MSG("HAL Get INTEN : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_IRQ_MASK));
1296 NJPD_DEBUG_HAL_MSG("HAL Get EVENTFLAG : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_IRQ_FINAL_S));
1297 }
1298 else
1299 {
1300 NJPD_DEBUG_HAL_MSG("HAL Get INTEN : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_IRQ_MASK));
1301 NJPD_DEBUG_HAL_MSG("HAL Get EVENTFLAG : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_IRQ_FINAL_S));
1302 }
1303
1304 // Edison@20120620 by Arong
1305 // 1. Add the fucntion of auto last buffer when FFD9 is detected (reg_spare00[0])
1306 // 2. Fix last buffer error (reg_spare00[1])
1307 //// 3. write burst_error (reg_spare00[3]) // Edison/Einstein doesnt have this bit
1308 //// 4. Fix read-burst error (reg_spare00[4]) // Edison/Einstein doesnt have this bit
1309 // 5. Coding error (reg_spare00[5])
1310 // 6. read-burst error (reg_spare00[6])
1311
1312 // Kano@20150326 by Ethan Chang
1313 // 7. let IP to MIU's last signel would trigger down when ready_ack(reg_spare00[7]=1 // When Kano BWP function enable would affect the result
1314
1315 // Nike&Einstein@20130412 by Tony Tseng
1316 // 9. ECO new error concealment(reg_spare00[9]) // Nike have this bit
1317
1318 HAL_NJPD_SetSpare00(0x2FB);
1319
1320 #if 0
1321 MS_U16 u16Value = ((HAL_NJPD_Get_MARB07() & ~NJPD_JPD_MARB_BURST_SPLIT) | 0x0002<<12);
1322 printf("MARB07=0x%x\n", u16Value);
1323 HAL_NJPD_Set_MARB07(u16Value);
1324 #endif
1325 _HAL_NJPD_SetMIUProtectMask(FALSE);
1326
1327 #if ENABLE_TEST_NJPD_18_Ibuf_Burst_Length_Test
1328 HAL_NJPD_SetIBufReadLength(0x15, 0x1a);
1329 #else
1330 if(HAL_NJPD_GetVerificationMode()==E_NJPD18_IBUF_BURST_LENGTH)
1331 {
1332 HAL_NJPD_SetIBufReadLength(0x15, 0x1a);
1333 }
1334 else
1335 {
1336 if(HAL_NJPD_IsNeedToPatch(E_NJPD_EAGLE_SW_PATCH))
1337 {
1338 NJPD_DEBUG_HAL_MSG("EAGLE_SW_PATCH start!!!!!!\n");
1339 HAL_NJPD_SetIBufReadLength(0x1f, 0x1f);
1340 HAL_NJPD_SetMRBurstThd(0x10);
1341 MS_U16 u16Value = (HAL_NJPD_Get_MARB07() | 0xc01f);
1342 NJPD_DEBUG_HAL_MSG("MARB07=0x%x\n", u16Value);
1343 HAL_NJPD_Set_MARB07(u16Value);
1344 NJPD_DEBUG_HAL_MSG("EAGLE_SW_PATCH end!!!!!!\n");
1345 }
1346 else
1347 {
1348 HAL_NJPD_SetIBufReadLength(0x10, 0x1f);
1349 }
1350 }
1351 #endif
1352
1353 #if ENABLE_NJPD_DEBUG_MSG
1354 //HAL_NJPD_SetCRCReadMode();
1355 HAL_NJPD_SetCRCWriteMode();
1356 #else
1357 if(HAL_NJPD_GetVerificationMode()==E_NJPD01_TABLE_READ_WRITE)
1358 {
1359 HAL_NJPD_SetCRCWriteMode();
1360 }
1361 else
1362 {
1363 HAL_NJPD_SetCRCReadMode();
1364 }
1365 #endif
1366 NJPD_DEBUG_HAL_MSG("%s : end!!\n", __FUNCTION__);
1367 }
1368
HAL_NJPD_SetMWBuffLineNum(MS_U16 u16Value)1369 void HAL_NJPD_SetMWBuffLineNum(MS_U16 u16Value)
1370 {
1371 NJPD_DEBUG_HAL_MSG("%s : NOT IMPLEMENTED!!!\n", __FUNCTION__);
1372 UNUSED(u16Value);
1373 }
1374
1375 /******************************************************************************/
1376 ///
1377 ///@param value \b IN
1378 ///@param value \b OUT
1379 ///@return status
1380 /******************************************************************************/
HAL_NJPD_GetCurMRCAddr(void)1381 MS_U32 HAL_NJPD_GetCurMRCAddr(void)
1382 {
1383 MS_U32 curMRCAddr;
1384 if(eNJPDNum == E_NJPD_NJPD1)
1385 {
1386 curMRCAddr = ((__HAL_NJPD_Read2Byte(BK_NJPD1_MIU_READ_POINTER_ADDR_H) << 16) | __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_READ_POINTER_ADDR_L));
1387 }
1388 else
1389 {
1390 curMRCAddr = ((__HAL_NJPD_Read2Byte(BK_NJPD2_MIU_READ_POINTER_ADDR_H) << 16) | __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_READ_POINTER_ADDR_L));
1391 }
1392
1393 return curMRCAddr;
1394 }
1395
1396 /******************************************************************************/
1397 ///
1398 ///@param value \b IN
1399 ///@param value \b OUT
1400 ///@return status
1401 /******************************************************************************/
HAL_NJPD_GetCurRow(void)1402 MS_U16 HAL_NJPD_GetCurRow(void)
1403 {
1404 if(eNJPDNum == E_NJPD_NJPD1)
1405 {
1406 return __HAL_NJPD_Read2Byte(BK_NJPD1_ROW_IDEX);
1407 }
1408 else
1409 {
1410 return __HAL_NJPD_Read2Byte(BK_NJPD2_ROW_IDEX);
1411 }
1412 }
1413
1414 /******************************************************************************/
1415 ///
1416 ///@param value \b IN
1417 ///@param value \b OUT
1418 ///@return status
1419 /******************************************************************************/
HAL_NJPD_GetCurCol(void)1420 MS_U16 HAL_NJPD_GetCurCol(void)
1421 {
1422 if(eNJPDNum == E_NJPD_NJPD1)
1423 {
1424 return __HAL_NJPD_Read2Byte(BK_NJPD1_COLUMN_IDEX);
1425 }
1426 else
1427 {
1428 return __HAL_NJPD_Read2Byte(BK_NJPD2_COLUMN_IDEX);
1429 }
1430 }
1431
HAL_NJPD_SetWriteProtect(MS_BOOL enable)1432 void HAL_NJPD_SetWriteProtect(MS_BOOL enable)
1433 {
1434 NJPD_DEBUG_HAL_MSG("%s : NOT IMPLEMENTED!!!\n", __FUNCTION__);
1435 UNUSED(enable);
1436 }
1437
HAL_NJPD_SetAutoProtect(MS_BOOL enable)1438 void HAL_NJPD_SetAutoProtect(MS_BOOL enable)
1439 {
1440 MS_U16 u16RegValue;
1441 if(eNJPDNum == E_NJPD_NJPD1)
1442 {
1443 u16RegValue = __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_LBOUND_0_H);
1444 u16RegValue &= 0x1FFF;
1445 u16RegValue |= enable<<13;
1446 __HAL_NJPD_Write2Byte(BK_NJPD1_MARB_LBOUND_0_H, u16RegValue);
1447 NJPD_DEBUG_HAL_MSG("%s : 0x%04X\n", __FUNCTION__, __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_LBOUND_0_H));
1448 }
1449 else
1450 {
1451 u16RegValue = __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_LBOUND_0_H);
1452 u16RegValue &= 0x1FFF;
1453 u16RegValue |= enable<<13;
1454 __HAL_NJPD_Write2Byte(BK_NJPD2_MARB_LBOUND_0_H, u16RegValue);
1455 NJPD_DEBUG_HAL_MSG("%s : 0x%04X\n", __FUNCTION__, __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_LBOUND_0_H));
1456 }
1457 }
1458
1459
HAL_NJPD_Set_MARB06(MS_U16 u16Value)1460 void HAL_NJPD_Set_MARB06(MS_U16 u16Value)
1461 {
1462 NJPD_DEBUG_HAL_MSG("%s : 0x%04X\n", __FUNCTION__, u16Value);
1463 if(eNJPDNum == E_NJPD_NJPD1)
1464 {
1465 __HAL_NJPD_Write2Byte(BK_NJPD1_MARB_SETTING_06, u16Value);
1466 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_Get_MARB06 : 0x%04X\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_SETTING_06));
1467 }
1468 else
1469 {
1470 __HAL_NJPD_Write2Byte(BK_NJPD2_MARB_SETTING_06, u16Value);
1471 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_Get_MARB06 : 0x%04X\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_SETTING_06));
1472 }
1473 }
1474
HAL_NJPD_Get_MARB06(void)1475 MS_U16 HAL_NJPD_Get_MARB06(void)
1476 {
1477 if(eNJPDNum == E_NJPD_NJPD1)
1478 {
1479 return __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_SETTING_06);
1480 }
1481 else
1482 {
1483 return __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_SETTING_06);
1484 }
1485 }
1486
HAL_NJPD_Set_MARB07(MS_U16 u16Value)1487 void HAL_NJPD_Set_MARB07(MS_U16 u16Value)
1488 {
1489 NJPD_DEBUG_HAL_MSG("%s : 0x%04X\n", __FUNCTION__, u16Value);
1490 if(eNJPDNum == E_NJPD_NJPD1)
1491 {
1492 __HAL_NJPD_Write2Byte(BK_NJPD1_MARB_SETTING_07, u16Value);
1493 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_Get_MARB07 : 0x%04X\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_SETTING_07));
1494 }
1495 else
1496 {
1497 __HAL_NJPD_Write2Byte(BK_NJPD2_MARB_SETTING_07, u16Value);
1498 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_Get_MARB07 : 0x%04X\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_SETTING_07));
1499 }
1500 }
1501
HAL_NJPD_Get_MARB07(void)1502 MS_U16 HAL_NJPD_Get_MARB07(void)
1503 {
1504 if(eNJPDNum == E_NJPD_NJPD1)
1505 {
1506 return __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_SETTING_07);
1507 }
1508 else
1509 {
1510 return __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_SETTING_07);
1511 }
1512 }
1513
1514
HAL_NJPD_SetWPENUBound_0_L(MS_U16 u16Value)1515 void HAL_NJPD_SetWPENUBound_0_L(MS_U16 u16Value)
1516 {
1517 NJPD_DEBUG_HAL_MSG("%s : 0x%04X\n", __FUNCTION__, u16Value);
1518 if(eNJPDNum == E_NJPD_NJPD1)
1519 {
1520 __HAL_NJPD_Write2Byte(BK_NJPD1_MARB_UBOUND_0_L, u16Value);
1521 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetWPENUBound_0_L : 0x%04X\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_UBOUND_0_L));
1522 }
1523 else
1524 {
1525 __HAL_NJPD_Write2Byte(BK_NJPD2_MARB_UBOUND_0_L, u16Value);
1526 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetWPENUBound_0_L : 0x%04X\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_UBOUND_0_L));
1527 }
1528 }
HAL_NJPD_SetWPENUBound_0_H(MS_U16 u16Value)1529 void HAL_NJPD_SetWPENUBound_0_H(MS_U16 u16Value)
1530 {
1531 NJPD_DEBUG_HAL_MSG("%s : 0x%04X\n", __FUNCTION__, u16Value);
1532 if(eNJPDNum == E_NJPD_NJPD1)
1533 {
1534 __HAL_NJPD_Write2Byte(BK_NJPD1_MARB_UBOUND_0_H, u16Value);
1535 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetWPENUBound_0_H : 0x%04X\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_UBOUND_0_H));
1536 }
1537 else
1538 {
1539 __HAL_NJPD_Write2Byte(BK_NJPD2_MARB_UBOUND_0_H, u16Value);
1540 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetWPENUBound_0_H : 0x%04X\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_UBOUND_0_H));
1541 }
1542 }
HAL_NJPD_SetWPENLBound_0_L(MS_U16 u16Value)1543 void HAL_NJPD_SetWPENLBound_0_L(MS_U16 u16Value)
1544 {
1545 NJPD_DEBUG_HAL_MSG("%s : 0x%04X\n", __FUNCTION__, u16Value);
1546 if(eNJPDNum == E_NJPD_NJPD1)
1547 {
1548 __HAL_NJPD_Write2Byte(BK_NJPD1_MARB_LBOUND_0_L, u16Value);
1549 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetWPENLBound_0_L : 0x%04X\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_LBOUND_0_L));
1550 }
1551 else
1552 {
1553 __HAL_NJPD_Write2Byte(BK_NJPD2_MARB_LBOUND_0_L, u16Value);
1554 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetWPENLBound_0_L : 0x%04X\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_LBOUND_0_L));
1555 }
1556 }
HAL_NJPD_SetWPENLBound_0_H(MS_U16 u16Value)1557 void HAL_NJPD_SetWPENLBound_0_H(MS_U16 u16Value)
1558 {
1559 MS_U16 u16RegValue;
1560 if(eNJPDNum == E_NJPD_NJPD1)
1561 {
1562 u16RegValue = __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_LBOUND_0_H);
1563 u16RegValue &= 0xE000;
1564 u16Value &= 0x1FFF;
1565 u16RegValue |= u16Value;
1566 NJPD_DEBUG_HAL_MSG("%s : 0x%04X\n", __FUNCTION__, u16RegValue);
1567 __HAL_NJPD_Write2Byte(BK_NJPD1_MARB_LBOUND_0_H, u16RegValue);
1568 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetWPENLBound_0_H : 0x%04X\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_LBOUND_0_H));
1569 }
1570 else
1571 {
1572 u16RegValue = __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_LBOUND_0_H);
1573 u16RegValue &= 0xE000;
1574 u16Value &= 0x1FFF;
1575 u16RegValue |= u16Value;
1576 NJPD_DEBUG_HAL_MSG("%s : 0x%04X\n", __FUNCTION__, u16RegValue);
1577 __HAL_NJPD_Write2Byte(BK_NJPD2_MARB_LBOUND_0_H, u16RegValue);
1578 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetWPENLBound_0_H : 0x%04X\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_LBOUND_0_H));
1579 }
1580 }
1581
HAL_NJPD_SetSpare00(MS_U16 u16Value)1582 void HAL_NJPD_SetSpare00(MS_U16 u16Value)
1583 {
1584 // [0]: hw auto detect ffd9 => cannot be used in svld mode, unless the "last buffer" cannot work, do not enable this
1585 // [1]: input buffer bug => always turn on
1586 // [2]: marb bug => always turn on (not used in 2011/12/28 ECO version)
1587 // [3]: bypass marb => 2011/12/28 ECO version
1588
1589 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1590 if(eNJPDNum == E_NJPD_NJPD1)
1591 {
1592 __HAL_NJPD_Write2Byte(BK_NJPD1_SPARE00, u16Value);
1593 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetSpare00 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE00));
1594 }
1595 else
1596 {
1597 __HAL_NJPD_Write2Byte(BK_NJPD2_SPARE00, u16Value);
1598 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetSpare00 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE00));
1599 }
1600 }
HAL_NJPD_GetSpare00(void)1601 MS_U16 HAL_NJPD_GetSpare00(void)
1602 {
1603 if(eNJPDNum == E_NJPD_NJPD1)
1604 {
1605 return __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE00);
1606 }
1607 else
1608 {
1609 return __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE00);
1610 }
1611 }
1612
HAL_NJPD_SetSpare01(MS_U16 u16Value)1613 void HAL_NJPD_SetSpare01(MS_U16 u16Value)
1614 {
1615 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1616 if(eNJPDNum == E_NJPD_NJPD1)
1617 {
1618 __HAL_NJPD_Write2Byte(BK_NJPD1_SPARE01, u16Value);
1619 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetSpare01 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE01));
1620 }
1621 else
1622 {
1623 __HAL_NJPD_Write2Byte(BK_NJPD2_SPARE01, u16Value);
1624 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetSpare01 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE01));
1625 }
1626 }
HAL_NJPD_GetSpare01(void)1627 MS_U16 HAL_NJPD_GetSpare01(void)
1628 {
1629 if(eNJPDNum == E_NJPD_NJPD1)
1630 {
1631 return __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE01);
1632 }
1633 else
1634 {
1635 return __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE01);
1636 }
1637 }
1638
HAL_NJPD_SetSpare02(MS_U16 u16Value)1639 void HAL_NJPD_SetSpare02(MS_U16 u16Value)
1640 {
1641 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1642 if(eNJPDNum == E_NJPD_NJPD1)
1643 {
1644 __HAL_NJPD_Write2Byte(BK_NJPD1_SPARE02, u16Value);
1645 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetSpare02 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE02));
1646 }
1647 else
1648 {
1649 __HAL_NJPD_Write2Byte(BK_NJPD2_SPARE02, u16Value);
1650 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetSpare02 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE02));
1651 }
1652 }
HAL_NJPD_GetSpare02(void)1653 MS_U16 HAL_NJPD_GetSpare02(void)
1654 {
1655 if(eNJPDNum == E_NJPD_NJPD1)
1656 {
1657 return __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE02);
1658 }
1659 else
1660 {
1661 return __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE02);
1662 }
1663 }
1664
HAL_NJPD_SetSpare03(MS_U16 u16Value)1665 void HAL_NJPD_SetSpare03(MS_U16 u16Value)
1666 {
1667 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1668 if(eNJPDNum == E_NJPD_NJPD1)
1669 {
1670 __HAL_NJPD_Write2Byte(BK_NJPD1_SPARE03, u16Value);
1671 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetSpare03 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE03));
1672 }
1673 else
1674 {
1675 __HAL_NJPD_Write2Byte(BK_NJPD2_SPARE03, u16Value);
1676 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetSpare03 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE03));
1677 }
1678 }
HAL_NJPD_GetSpare03(void)1679 MS_U16 HAL_NJPD_GetSpare03(void)
1680 {
1681 if(eNJPDNum == E_NJPD_NJPD1)
1682 {
1683 return __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE03);
1684 }
1685 else
1686 {
1687 return __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE03);
1688 }
1689 }
1690
HAL_NJPD_SetSpare04(MS_U16 u16Value)1691 void HAL_NJPD_SetSpare04(MS_U16 u16Value)
1692 {
1693 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1694 if(eNJPDNum == E_NJPD_NJPD1)
1695 {
1696 __HAL_NJPD_Write2Byte(BK_NJPD1_SPARE04, u16Value);
1697 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetSpare04 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE04));
1698 }
1699 else
1700 {
1701 __HAL_NJPD_Write2Byte(BK_NJPD2_SPARE04, u16Value);
1702 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetSpare04 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE04));
1703 }
1704 }
HAL_NJPD_GetSpare04(void)1705 MS_U16 HAL_NJPD_GetSpare04(void)
1706 {
1707 if(eNJPDNum == E_NJPD_NJPD1)
1708 {
1709 return __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE04);
1710 }
1711 else
1712 {
1713 return __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE04);
1714 }
1715 }
1716
HAL_NJPD_SetSpare05(MS_U16 u16Value)1717 void HAL_NJPD_SetSpare05(MS_U16 u16Value)
1718 {
1719 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1720 if(eNJPDNum == E_NJPD_NJPD1)
1721 {
1722 __HAL_NJPD_Write2Byte(BK_NJPD1_SPARE05, u16Value);
1723 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetSpare05 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE05));
1724 }
1725 else
1726 {
1727 __HAL_NJPD_Write2Byte(BK_NJPD2_SPARE05, u16Value);
1728 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetSpare05 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE05));
1729 }
1730 }
HAL_NJPD_GetSpare05(void)1731 MS_U16 HAL_NJPD_GetSpare05(void)
1732 {
1733 if(eNJPDNum == E_NJPD_NJPD1)
1734 {
1735 return __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE05);
1736 }
1737 else
1738 {
1739 return __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE05);
1740 }
1741 }
1742
HAL_NJPD_SetSpare06(MS_U16 u16Value)1743 void HAL_NJPD_SetSpare06(MS_U16 u16Value)
1744 {
1745 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1746 if(eNJPDNum == E_NJPD_NJPD1)
1747 {
1748 __HAL_NJPD_Write2Byte(BK_NJPD1_SPARE06, u16Value);
1749 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetSpare06 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE06));
1750 }
1751 else
1752 {
1753 __HAL_NJPD_Write2Byte(BK_NJPD2_SPARE06, u16Value);
1754 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetSpare06 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE06));
1755 }
1756 }
HAL_NJPD_GetSpare06(void)1757 MS_U16 HAL_NJPD_GetSpare06(void)
1758 {
1759 if(eNJPDNum == E_NJPD_NJPD1)
1760 {
1761 return __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE06);
1762 }
1763 else
1764 {
1765 return __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE06);
1766 }
1767 }
1768
HAL_NJPD_SetSpare07(MS_U16 u16Value)1769 void HAL_NJPD_SetSpare07(MS_U16 u16Value)
1770 {
1771 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1772 if(eNJPDNum == E_NJPD_NJPD1)
1773 {
1774 __HAL_NJPD_Write2Byte(BK_NJPD1_SPARE07, u16Value);
1775 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetSpare07 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE07));
1776 }
1777 else
1778 {
1779 __HAL_NJPD_Write2Byte(BK_NJPD2_SPARE07, u16Value);
1780 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetSpare07 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE07));
1781 }
1782 }
HAL_NJPD_GetSpare07(void)1783 MS_U16 HAL_NJPD_GetSpare07(void)
1784 {
1785 if(eNJPDNum == E_NJPD_NJPD1)
1786 {
1787 return __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE07);
1788 }
1789 else
1790 {
1791 return __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE07);
1792 }
1793 }
1794
HAL_NJPD_SetWriteOneClearReg(MS_U16 u16Value)1795 void HAL_NJPD_SetWriteOneClearReg(MS_U16 u16Value)
1796 {
1797 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1798 if(eNJPDNum == E_NJPD_NJPD1)
1799 {
1800 __HAL_NJPD_Write2Byte(BK_NJPD1_WRITE_ONE_CLEAR, u16Value);
1801 }
1802 else
1803 {
1804 __HAL_NJPD_Write2Byte(BK_NJPD2_WRITE_ONE_CLEAR, u16Value);
1805 }
1806 }
1807
HAL_NJPD_SetWriteOneClearReg_2(MS_U16 u16Value)1808 void HAL_NJPD_SetWriteOneClearReg_2(MS_U16 u16Value)
1809 {
1810 // for convience, not to print any message in this function
1811 if(eNJPDNum == E_NJPD_NJPD1)
1812 {
1813 __HAL_NJPD_Write2Byte(BK_NJPD1_WRITE_ONE_CLEAR, u16Value);
1814 }
1815 else
1816 {
1817 __HAL_NJPD_Write2Byte(BK_NJPD2_WRITE_ONE_CLEAR, u16Value);
1818 }
1819 }
1820
HAL_NJPD_GetWriteOneClearReg(void)1821 MS_U16 HAL_NJPD_GetWriteOneClearReg(void)
1822 {
1823 if(eNJPDNum == E_NJPD_NJPD1)
1824 {
1825 return __HAL_NJPD_Read2Byte(BK_NJPD1_WRITE_ONE_CLEAR);
1826 }
1827 else
1828 {
1829 return __HAL_NJPD_Read2Byte(BK_NJPD2_WRITE_ONE_CLEAR);
1830 }
1831 }
1832
HAL_NJPD_SetHTableStart_Low(MS_U16 u16Value)1833 void HAL_NJPD_SetHTableStart_Low(MS_U16 u16Value)
1834 {
1835 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1836 if(eNJPDNum == E_NJPD_NJPD1)
1837 {
1838 __HAL_NJPD_Write2Byte(BK_NJPD1_MIU_HTABLE_START_ADDR_L, u16Value);
1839 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetHTableStart_Low : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_HTABLE_START_ADDR_L));
1840 }
1841 else
1842 {
1843 __HAL_NJPD_Write2Byte(BK_NJPD2_MIU_HTABLE_START_ADDR_L, u16Value);
1844 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetHTableStart_Low : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_HTABLE_START_ADDR_L));
1845 }
1846 }
1847
HAL_NJPD_SetHTableStart_High(MS_U16 u16Value)1848 void HAL_NJPD_SetHTableStart_High(MS_U16 u16Value)
1849 {
1850 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1851 if(eNJPDNum == E_NJPD_NJPD1)
1852 {
1853 __HAL_NJPD_Write2Byte(BK_NJPD1_MIU_HTABLE_START_ADDR_H, u16Value);
1854 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetHTableStart_High : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_HTABLE_START_ADDR_H));
1855 }
1856 else
1857 {
1858 __HAL_NJPD_Write2Byte(BK_NJPD2_MIU_HTABLE_START_ADDR_H, u16Value);
1859 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetHTableStart_High : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_HTABLE_START_ADDR_H));
1860 }
1861 }
1862
HAL_NJPD_SetQTableStart_Low(MS_U16 u16Value)1863 void HAL_NJPD_SetQTableStart_Low(MS_U16 u16Value)
1864 {
1865 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1866 if(eNJPDNum == E_NJPD_NJPD1)
1867 {
1868 __HAL_NJPD_Write2Byte(BK_NJPD1_MIU_QTABLE_START_ADDR_L, u16Value);
1869 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetQTableStart_Low : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_QTABLE_START_ADDR_L));
1870 }
1871 else
1872 {
1873 __HAL_NJPD_Write2Byte(BK_NJPD2_MIU_QTABLE_START_ADDR_L, u16Value);
1874 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetQTableStart_Low : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_QTABLE_START_ADDR_L));
1875 }
1876 }
1877
HAL_NJPD_SetQTableStart_High(MS_U16 u16Value)1878 void HAL_NJPD_SetQTableStart_High(MS_U16 u16Value)
1879 {
1880 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1881 if(eNJPDNum == E_NJPD_NJPD1)
1882 {
1883 __HAL_NJPD_Write2Byte(BK_NJPD1_MIU_QTABLE_START_ADDR_H, u16Value);
1884 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetQTableStart_High : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_QTABLE_START_ADDR_H));
1885 }
1886 else
1887 {
1888 __HAL_NJPD_Write2Byte(BK_NJPD2_MIU_QTABLE_START_ADDR_H, u16Value);
1889 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetQTableStart_High : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_QTABLE_START_ADDR_H));
1890 }
1891 }
1892
HAL_NJPD_SetGTableStart_Low(MS_U16 u16Value)1893 void HAL_NJPD_SetGTableStart_Low(MS_U16 u16Value)
1894 {
1895 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1896 if(eNJPDNum == E_NJPD_NJPD1)
1897 {
1898 __HAL_NJPD_Write2Byte(BK_NJPD1_MIU_GTABLE_START_ADDR_L, u16Value);
1899 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetGTableStart_Low : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_GTABLE_START_ADDR_L));
1900 }
1901 else
1902 {
1903 __HAL_NJPD_Write2Byte(BK_NJPD2_MIU_GTABLE_START_ADDR_L, u16Value);
1904 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetGTableStart_Low : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_GTABLE_START_ADDR_L));
1905 }
1906 }
1907
HAL_NJPD_SetGTableStart_High(MS_U16 u16Value)1908 void HAL_NJPD_SetGTableStart_High(MS_U16 u16Value)
1909 {
1910 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1911 if(eNJPDNum == E_NJPD_NJPD1)
1912 {
1913 __HAL_NJPD_Write2Byte(BK_NJPD1_MIU_GTABLE_START_ADDR_H, u16Value);
1914 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetGTableStart_High : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_GTABLE_START_ADDR_H));
1915 }
1916 else
1917 {
1918 __HAL_NJPD_Write2Byte(BK_NJPD2_MIU_GTABLE_START_ADDR_H, u16Value);
1919 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetGTableStart_High : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_GTABLE_START_ADDR_H));
1920 }
1921 }
1922
HAL_NJPD_SetHTableSize(MS_U16 u16Value)1923 void HAL_NJPD_SetHTableSize(MS_U16 u16Value)
1924 {
1925 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1926 u16Value &=0x00FF;
1927 if(eNJPDNum == E_NJPD_NJPD1)
1928 {
1929 __HAL_NJPD_Write2Byte(BK_NJPD1_MIU_HTABLE_SIZE, u16Value);
1930 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetHTableSize : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_HTABLE_SIZE));
1931 }
1932 else
1933 {
1934 __HAL_NJPD_Write2Byte(BK_NJPD2_MIU_HTABLE_SIZE, u16Value);
1935 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetHTableSize : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_HTABLE_SIZE));
1936 }
1937 }
1938
HAL_NJPD_GetHTableSize()1939 MS_U16 HAL_NJPD_GetHTableSize()
1940 {
1941 if(eNJPDNum == E_NJPD_NJPD1)
1942 {
1943 return __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_HTABLE_SIZE);
1944 }
1945 else
1946 {
1947 return __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_HTABLE_SIZE);
1948 }
1949 }
HAL_NJPD_SetRIUInterface(MS_U16 u16Value)1950 void HAL_NJPD_SetRIUInterface(MS_U16 u16Value)
1951 {
1952 // NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1953 if(eNJPDNum == E_NJPD_NJPD1)
1954 {
1955 __HAL_NJPD_Write2Byte(BK_NJPD1_TBC, u16Value);
1956 // NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetRIUInterface : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_TBC));
1957 }
1958 else
1959 {
1960 __HAL_NJPD_Write2Byte(BK_NJPD2_TBC, u16Value);
1961 // NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetRIUInterface : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_TBC));
1962 }
1963 }
1964
HAL_NJPD_GetRIUInterface(void)1965 MS_U16 HAL_NJPD_GetRIUInterface(void)
1966 {
1967 if(eNJPDNum == E_NJPD_NJPD1)
1968 {
1969 return __HAL_NJPD_Read2Byte(BK_NJPD1_TBC);
1970 }
1971 else
1972 {
1973 return __HAL_NJPD_Read2Byte(BK_NJPD2_TBC);
1974 }
1975 }
1976
HAL_NJPD_TBCReadData_L()1977 MS_U16 HAL_NJPD_TBCReadData_L()
1978 {
1979 if(eNJPDNum == E_NJPD_NJPD1)
1980 {
1981 return __HAL_NJPD_Read2Byte(BK_NJPD1_TBC_RDATA_L);
1982 }
1983 else
1984 {
1985 return __HAL_NJPD_Read2Byte(BK_NJPD2_TBC_RDATA_L);
1986 }
1987 }
1988
HAL_NJPD_TBCReadData_H()1989 MS_U16 HAL_NJPD_TBCReadData_H()
1990 {
1991 if(eNJPDNum == E_NJPD_NJPD1)
1992 {
1993 return __HAL_NJPD_Read2Byte(BK_NJPD1_TBC_RDATA_H);
1994 }
1995 else
1996 {
1997 return __HAL_NJPD_Read2Byte(BK_NJPD2_TBC_RDATA_H);
1998 }
1999 }
2000
HAL_NJPD_SetIBufReadLength(MS_U8 u8Min,MS_U8 u8Max)2001 void HAL_NJPD_SetIBufReadLength(MS_U8 u8Min, MS_U8 u8Max)
2002 {
2003 MS_U16 u16Value;
2004 u16Value = (u8Min<<5) + u8Max;
2005 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
2006 if(eNJPDNum == E_NJPD_NJPD1)
2007 {
2008 u16Value = (u16Value | (__HAL_NJPD_Read2Byte(BK_NJPD1_IBUF_READ_LENGTH) & 0xfc00));
2009 __HAL_NJPD_Write2Byte(BK_NJPD1_IBUF_READ_LENGTH, u16Value);
2010 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetIBufReadLength : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_IBUF_READ_LENGTH));
2011 }
2012 else
2013 {
2014 u16Value = (u16Value | (__HAL_NJPD_Read2Byte(BK_NJPD2_IBUF_READ_LENGTH) & 0xfc00));
2015 __HAL_NJPD_Write2Byte(BK_NJPD2_IBUF_READ_LENGTH, u16Value);
2016 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetIBufReadLength : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_IBUF_READ_LENGTH));
2017 }
2018 }
2019
2020
HAL_NJPD_SetMRBurstThd(MS_U16 u16Value)2021 void HAL_NJPD_SetMRBurstThd(MS_U16 u16Value)
2022 {
2023 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
2024 if(eNJPDNum == E_NJPD_NJPD1)
2025 {
2026 u16Value = (u16Value | (__HAL_NJPD_Read2Byte(BK_NJPD1_MARB_SETTING_04) & 0xffe0));
2027 __HAL_NJPD_Write2Byte(BK_NJPD1_MARB_SETTING_04, u16Value);
2028 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetMARB_SETTING_04 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_SETTING_04));
2029 }
2030 else
2031 {
2032 u16Value = (u16Value | (__HAL_NJPD_Read2Byte(BK_NJPD2_MARB_SETTING_04) & 0xffe0));
2033 __HAL_NJPD_Write2Byte(BK_NJPD2_MARB_SETTING_04, u16Value);
2034 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetMARB_SETTING_04 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_SETTING_04));
2035 }
2036 }
2037
2038
2039
HAL_NJPD_SetCRCReadMode()2040 void HAL_NJPD_SetCRCReadMode()
2041 {
2042 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, 0x200);
2043 if(eNJPDNum == E_NJPD_NJPD1)
2044 {
2045 __HAL_NJPD_Write2Byte(BK_NJPD1_CRC_MODE, 0x200);
2046 }
2047 else
2048 {
2049 __HAL_NJPD_Write2Byte(BK_NJPD2_CRC_MODE, 0x200);
2050 }
2051 }
2052
HAL_NJPD_SetCRCWriteMode()2053 void HAL_NJPD_SetCRCWriteMode()
2054 {
2055 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, 0x300);
2056 if(eNJPDNum == E_NJPD_NJPD1)
2057 {
2058 __HAL_NJPD_Write2Byte(BK_NJPD1_CRC_MODE, 0x300);
2059 }
2060 else
2061 {
2062 __HAL_NJPD_Write2Byte(BK_NJPD2_CRC_MODE, 0x300);
2063 }
2064 }
2065
HAL_NJPD_ResetMarb(void)2066 void HAL_NJPD_ResetMarb(void)
2067 {
2068 NJPD_DEBUG_HAL_MSG("%s\n", __FUNCTION__);
2069 if(eNJPDNum == E_NJPD_NJPD1)
2070 {
2071 NJPD_DEBUG_HAL_MSG("set BK_NJPD1_MARB_RESET to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD1_MARB_RESET) & 0xFE);
2072 __HAL_NJPD_WriteByte(BK_NJPD1_MARB_RESET, __HAL_NJPD_ReadByte(BK_NJPD1_MARB_RESET) & 0xFE);
2073 NJPD_DEBUG_HAL_MSG("set BK_NJPD1_MARB_RESET to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD1_MARB_RESET) | 0x01);
2074 __HAL_NJPD_WriteByte(BK_NJPD1_MARB_RESET, __HAL_NJPD_ReadByte(BK_NJPD1_MARB_RESET) | 0x01);
2075 NJPD_DEBUG_HAL_MSG("set BK_NJPD1_MARB_RESET to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD1_MARB_RESET) & 0xFD);
2076 __HAL_NJPD_WriteByte(BK_NJPD1_MARB_RESET, __HAL_NJPD_ReadByte(BK_NJPD1_MARB_RESET) & 0xFD);
2077 NJPD_DEBUG_HAL_MSG("set BK_NJPD1_MARB_RESET to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD1_MARB_RESET) | 0x02);
2078 __HAL_NJPD_WriteByte(BK_NJPD1_MARB_RESET, __HAL_NJPD_ReadByte(BK_NJPD1_MARB_RESET) | 0x02);
2079 // __HAL_NJPD_WriteByte(BK_NJPD1_MARB_RESET, __HAL_NJPD_ReadByte(BK_NJPD1_MARB_RESET) | 0x12);
2080 // NJPD_DEBUG_HAL_MSG("!!set BK_NJPD1_MARB_RESET to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD1_MARB_RESET));
2081 }
2082 else
2083 {
2084 NJPD_DEBUG_HAL_MSG("set BK_NJPD2_MARB_RESET to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD2_MARB_RESET) & 0xFE);
2085 __HAL_NJPD_WriteByte(BK_NJPD2_MARB_RESET, __HAL_NJPD_ReadByte(BK_NJPD2_MARB_RESET) & 0xFE);
2086 NJPD_DEBUG_HAL_MSG("set BK_NJPD2_MARB_RESET to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD2_MARB_RESET) | 0x01);
2087 __HAL_NJPD_WriteByte(BK_NJPD2_MARB_RESET, __HAL_NJPD_ReadByte(BK_NJPD2_MARB_RESET) | 0x01);
2088 NJPD_DEBUG_HAL_MSG("set BK_NJPD2_MARB_RESET to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD2_MARB_RESET) & 0xFD);
2089 __HAL_NJPD_WriteByte(BK_NJPD2_MARB_RESET, __HAL_NJPD_ReadByte(BK_NJPD2_MARB_RESET) & 0xFD);
2090 NJPD_DEBUG_HAL_MSG("set BK_NJPD2_MARB_RESET to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD2_MARB_RESET) | 0x02);
2091 __HAL_NJPD_WriteByte(BK_NJPD2_MARB_RESET, __HAL_NJPD_ReadByte(BK_NJPD2_MARB_RESET) | 0x02);
2092 // __HAL_NJPD_WriteByte(BK_NJPD2_MARB_RESET, __HAL_NJPD_ReadByte(BK_NJPD2_MARB_RESET) | 0x12);
2093 // NJPD_DEBUG_HAL_MSG("!!set BK_NJPD2_MARB_RESET to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD2_MARB_RESET));
2094 }
2095
2096 }
2097
HAL_NJPD_GetHandshakeCnt()2098 MS_U8 HAL_NJPD_GetHandshakeCnt()
2099 {
2100 MS_U8 u8Cnt;
2101 if(eNJPDNum == E_NJPD_NJPD1)
2102 {
2103 // reg_jpd_handshake_cnt
2104 u8Cnt = (MS_U8)__HAL_NJPD_ReadByte(BK_NJPD1_HANDSHAKE_CNT);
2105 }
2106 else
2107 {
2108 // reg_jpd_handshake_cnt
2109 u8Cnt = (MS_U8)__HAL_NJPD_ReadByte(BK_NJPD2_HANDSHAKE_CNT);
2110 }
2111 return u8Cnt;
2112 }
2113
HAL_NJPD_Handshake_SWRowCountMode(MS_U8 u8Cnt)2114 void HAL_NJPD_Handshake_SWRowCountMode(MS_U8 u8Cnt)
2115 {
2116 NJPD_DEBUG_HAL_MSG("%s() with Count=%d\n", __FUNCTION__, u8Cnt);
2117 if(eNJPDNum == E_NJPD_NJPD1)
2118 {
2119 // reg_jpd_handshake_sw_mode = 1
2120 NJPD_DEBUG_HAL_MSG("set BK_NJPD1_HANDSHAKE to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD1_HANDSHAKE) | 0x04);
2121 __HAL_NJPD_WriteByte(BK_NJPD1_HANDSHAKE, __HAL_NJPD_ReadByte(BK_NJPD1_HANDSHAKE) | 0x04);
2122 // reg_jpd_handshake_en =1
2123 NJPD_DEBUG_HAL_MSG("set BK_NJPD1_HANDSHAKE to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD1_HANDSHAKE) | 0x02);
2124 __HAL_NJPD_WriteByte(BK_NJPD1_HANDSHAKE, __HAL_NJPD_ReadByte(BK_NJPD1_HANDSHAKE) | 0x02);
2125 // reg_jpd_sw_mb_row_cnt
2126 NJPD_DEBUG_HAL_MSG("set BK_NJPD1_SW_MB_ROW_CNT to 0x%02x\n", u8Cnt);
2127 __HAL_NJPD_WriteByte(BK_NJPD1_SW_MB_ROW_CNT, u8Cnt);
2128
2129 // reg_jpd_handshake_sw_woc
2130 HAL_NJPD_SetWriteOneClearReg(NJPD_HANDSHAKE_SW_WOC);
2131 }
2132 else
2133 {
2134 // reg_jpd_handshake_sw_mode = 1
2135 NJPD_DEBUG_HAL_MSG("set BK_NJPD2_HANDSHAKE to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD2_HANDSHAKE) | 0x04);
2136 __HAL_NJPD_WriteByte(BK_NJPD2_HANDSHAKE, __HAL_NJPD_ReadByte(BK_NJPD2_HANDSHAKE) | 0x04);
2137 // reg_jpd_handshake_en =1
2138 NJPD_DEBUG_HAL_MSG("set BK_NJPD2_HANDSHAKE to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD2_HANDSHAKE) | 0x02);
2139 __HAL_NJPD_WriteByte(BK_NJPD2_HANDSHAKE, __HAL_NJPD_ReadByte(BK_NJPD2_HANDSHAKE) | 0x02);
2140 // reg_jpd_sw_mb_row_cnt
2141 NJPD_DEBUG_HAL_MSG("set BK_NJPD2_SW_MB_ROW_CNT to 0x%02x\n", u8Cnt);
2142 __HAL_NJPD_WriteByte(BK_NJPD2_SW_MB_ROW_CNT, u8Cnt);
2143
2144 // reg_jpd_handshake_sw_woc
2145 HAL_NJPD_SetWriteOneClearReg(NJPD_HANDSHAKE_SW_WOC);
2146 }
2147 }
2148
HAL_NJPD_Handshake_HWRowCountMode()2149 void HAL_NJPD_Handshake_HWRowCountMode()
2150 {
2151 NJPD_DEBUG_HAL_MSG("%s()\n", __FUNCTION__);
2152 if(eNJPDNum == E_NJPD_NJPD1)
2153 {
2154 // reset reg_jpd_handshake_cnt_rst
2155 NJPD_DEBUG_HAL_MSG("set BK_NJPD1_HANDSHAKE to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD1_HANDSHAKE) & 0xFE);
2156 __HAL_NJPD_WriteByte(BK_NJPD1_HANDSHAKE, __HAL_NJPD_ReadByte(BK_NJPD1_HANDSHAKE) & 0xFE);
2157 NJPD_DEBUG_HAL_MSG("set BK_NJPD1_HANDSHAKE to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD1_HANDSHAKE) | 0x01);
2158 __HAL_NJPD_WriteByte(BK_NJPD1_HANDSHAKE, __HAL_NJPD_ReadByte(BK_NJPD1_HANDSHAKE) | 0x01);
2159
2160 // reg_jpd_handshake_sw_mode = 0
2161 NJPD_DEBUG_HAL_MSG("set BK_NJPD1_HANDSHAKE to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD1_HANDSHAKE) & 0xFB);
2162 __HAL_NJPD_WriteByte(BK_NJPD1_HANDSHAKE, __HAL_NJPD_ReadByte(BK_NJPD1_HANDSHAKE) & 0xFB);
2163
2164 // reg_jpd_handshake_en =1
2165 NJPD_DEBUG_HAL_MSG("set BK_NJPD1_HANDSHAKE to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD1_HANDSHAKE) | 0x02);
2166 __HAL_NJPD_WriteByte(BK_NJPD1_HANDSHAKE, __HAL_NJPD_ReadByte(BK_NJPD1_HANDSHAKE) | 0x02);
2167 }
2168 else
2169 {
2170 // reset reg_jpd_handshake_cnt_rst
2171 NJPD_DEBUG_HAL_MSG("set BK_NJPD2_HANDSHAKE to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD2_HANDSHAKE) & 0xFE);
2172 __HAL_NJPD_WriteByte(BK_NJPD2_HANDSHAKE, __HAL_NJPD_ReadByte(BK_NJPD2_HANDSHAKE) & 0xFE);
2173 NJPD_DEBUG_HAL_MSG("set BK_NJPD2_HANDSHAKE to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD2_HANDSHAKE) | 0x01);
2174 __HAL_NJPD_WriteByte(BK_NJPD2_HANDSHAKE, __HAL_NJPD_ReadByte(BK_NJPD2_HANDSHAKE) | 0x01);
2175
2176 // reg_jpd_handshake_sw_mode = 0
2177 NJPD_DEBUG_HAL_MSG("set BK_NJPD2_HANDSHAKE to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD2_HANDSHAKE) & 0xFB);
2178 __HAL_NJPD_WriteByte(BK_NJPD2_HANDSHAKE, __HAL_NJPD_ReadByte(BK_NJPD2_HANDSHAKE) & 0xFB);
2179
2180 // reg_jpd_handshake_en =1
2181 NJPD_DEBUG_HAL_MSG("set BK_NJPD2_HANDSHAKE to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD2_HANDSHAKE) | 0x02);
2182 __HAL_NJPD_WriteByte(BK_NJPD2_HANDSHAKE, __HAL_NJPD_ReadByte(BK_NJPD2_HANDSHAKE) | 0x02);
2183 }
2184 }
2185
2186
HAL_NJPD_SetOutputFormat(MS_BOOL bRst,NJPD_OutputFormat eOutputFormat)2187 void HAL_NJPD_SetOutputFormat(MS_BOOL bRst, NJPD_OutputFormat eOutputFormat)
2188 {
2189 switch(eOutputFormat)
2190 {
2191 case E_NJPD_OUTPUT_ORIGINAL:
2192 if(bRst)
2193 {
2194 HAL_NJPD_Set_GlobalSetting00(0);
2195 HAL_NJPD_ResetMarb();
2196 HAL_NJPD_Set_GlobalSetting01(HAL_NJPD_Get_GlobalSetting01()& NJPD_GTABLE_RST);
2197 }
2198 else
2199 {
2200 HAL_NJPD_Set_GlobalSetting00(HAL_NJPD_Get_GlobalSetting00()&0xf3ff);
2201 HAL_NJPD_Set_GlobalSetting01(HAL_NJPD_Get_GlobalSetting01()&0xfcff);
2202 }
2203 break;
2204 case E_NJPD_OUTPUT_YC_SWAP:
2205 if(bRst)
2206 {
2207 HAL_NJPD_Set_GlobalSetting00(NJPD_YC_SWAP);
2208 HAL_NJPD_Set_GlobalSetting01(HAL_NJPD_Get_GlobalSetting01()& NJPD_GTABLE_RST);
2209 }
2210 else
2211 {
2212 HAL_NJPD_Set_GlobalSetting00((HAL_NJPD_Get_GlobalSetting00()&0xf3ff) | NJPD_YC_SWAP);
2213 HAL_NJPD_Set_GlobalSetting01(HAL_NJPD_Get_GlobalSetting01()&0xfcff);
2214 }
2215 break;
2216 case E_NJPD_OUTPUT_UV_SWAP:
2217 if(bRst)
2218 {
2219 HAL_NJPD_Set_GlobalSetting00(NJPD_UV_SWAP);
2220 HAL_NJPD_Set_GlobalSetting01(HAL_NJPD_Get_GlobalSetting01()& NJPD_GTABLE_RST);
2221 }
2222 else
2223 {
2224 HAL_NJPD_Set_GlobalSetting00((HAL_NJPD_Get_GlobalSetting00()&0xf3ff) | NJPD_UV_SWAP);
2225 HAL_NJPD_Set_GlobalSetting01(HAL_NJPD_Get_GlobalSetting01()&0xfcff);
2226 }
2227 break;
2228 case E_NJPD_OUTPUT_UV_7BIT:
2229 if(bRst)
2230 {
2231 HAL_NJPD_Set_GlobalSetting00(0);
2232 // HAL_NJPD_Set_GlobalSetting01(NJPD_UV_7BIT);
2233 HAL_NJPD_Set_GlobalSetting01((HAL_NJPD_Get_GlobalSetting01()& NJPD_GTABLE_RST)|NJPD_UV_7BIT);
2234 }
2235 else
2236 {
2237 HAL_NJPD_Set_GlobalSetting00(HAL_NJPD_Get_GlobalSetting00()&0xf3ff);
2238 HAL_NJPD_Set_GlobalSetting01((HAL_NJPD_Get_GlobalSetting01()&0xfcff) | NJPD_UV_7BIT);
2239 }
2240
2241 break;
2242 case E_NJPD_OUTPUT_UV_MSB:
2243 if(bRst)
2244 {
2245 HAL_NJPD_Set_GlobalSetting00(0);
2246 // HAL_NJPD_Set_GlobalSetting01(NJPD_UV_7BIT | NJPD_UV_MSB);
2247 HAL_NJPD_Set_GlobalSetting01((HAL_NJPD_Get_GlobalSetting01()& NJPD_GTABLE_RST)|(NJPD_UV_7BIT | NJPD_UV_MSB));
2248 }
2249 else
2250 {
2251 HAL_NJPD_Set_GlobalSetting00(HAL_NJPD_Get_GlobalSetting00()&0xf3ff);
2252 HAL_NJPD_Set_GlobalSetting01((HAL_NJPD_Get_GlobalSetting01()&0xfcff) | NJPD_UV_7BIT | NJPD_UV_MSB);
2253 }
2254 break;
2255 }
2256 }
2257
HAL_NJPD_SetMTLBMode(MS_U8 u8MTLB)2258 void HAL_NJPD_SetMTLBMode(MS_U8 u8MTLB)
2259 {
2260 NJPD_DEBUG_HAL_MSG("%s()\n", __FUNCTION__);
2261 if(eNJPDNum == E_NJPD_NJPD1)
2262 {
2263 // set reg_jpd_miu_tlb
2264 NJPD_DEBUG_HAL_MSG("set BK_NJPD1_MIU_TLB to 0x%02x\n", u8MTLB);
2265 __HAL_NJPD_WriteByte(BK_NJPD1_MIU_TLB, u8MTLB);
2266
2267 }
2268 else
2269 {
2270 // set reg_jpd_miu_tlb
2271 NJPD_DEBUG_HAL_MSG("set BK_NJPD2_MIU_TLB to 0x%02x\n", u8MTLB);
2272 __HAL_NJPD_WriteByte(BK_NJPD2_MIU_TLB, u8MTLB);
2273 }
2274 }
2275
HAL_NJPD_SetVerificationMode(NJPD_VerificationMode VerificationMode)2276 void HAL_NJPD_SetVerificationMode(NJPD_VerificationMode VerificationMode)
2277 {
2278 NJPD_DEBUG_HAL_MSG("Set Verification Mode to %x\n", VerificationMode);
2279 eVerificationMode = VerificationMode;
2280 }
2281
HAL_NJPD_GetVerificationMode(void)2282 NJPD_VerificationMode HAL_NJPD_GetVerificationMode(void)
2283 {
2284 return eVerificationMode;
2285 }
2286
HAL_NJPD_Debug(void)2287 void HAL_NJPD_Debug(void)
2288 {
2289 if(eNJPDNum == E_NJPD_NJPD1)
2290 {
2291 NJPD_DEBUG_HAL_MSG("read BK_NJPD1_MARB_CRC_RESULT_0: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_CRC_RESULT_0));
2292 NJPD_DEBUG_HAL_MSG("read BK_NJPD1_MARB_CRC_RESULT_1: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_CRC_RESULT_1));
2293 NJPD_DEBUG_HAL_MSG("read BK_NJPD1_MARB_CRC_RESULT_2: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_CRC_RESULT_2));
2294 NJPD_DEBUG_HAL_MSG("read BK_NJPD1_MARB_CRC_RESULT_3: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_CRC_RESULT_3));
2295 NJPD_DEBUG_HAL_MSG("read BK_NJPD1_GLOBAL_SETTING00: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_GLOBAL_SETTING00));
2296 NJPD_DEBUG_HAL_MSG("read BK_NJPD1_GLOBAL_SETTING01: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_GLOBAL_SETTING01));
2297 NJPD_DEBUG_HAL_MSG("read BK_NJPD1_GLOBAL_SETTING02: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_GLOBAL_SETTING02));
2298 NJPD_DEBUG_HAL_MSG("read BK_NJPD1_MIU_READ_STATUS = 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_READ_STATUS));
2299 NJPD_DEBUG_HAL_MSG("read BK_NJPD1_MIU_READ_POINTER_ADDR_L: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_READ_POINTER_ADDR_L));
2300 NJPD_DEBUG_HAL_MSG("read BK_NJPD1_MIU_READ_POINTER_ADDR_H: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_READ_POINTER_ADDR_H));
2301
2302 MS_U16 u16i;
2303 for(u16i=0; u16i<=0x7b; u16i++)
2304 {
2305 __HAL_NJPD_Write2Byte(BK_NJPD1_DEBUG_BUS_SELECT, u16i);
2306 NJPD_DEBUG_HAL_MSG("BK_NJPD1_DEBUG_BUS[H:L] = [0x%02x][0x%04x:0x%04x]\n", u16i,
2307 __HAL_NJPD_Read2Byte(BK_NJPD1_DEBUG_BUS_H),
2308 __HAL_NJPD_Read2Byte(BK_NJPD1_DEBUG_BUS_L));
2309 }
2310 __HAL_NJPD_Write2Byte(BK_NJPD1_DEBUG_BUS_SELECT, 0xFF);
2311 NJPD_DEBUG_HAL_MSG("BK_NJPD1_DEBUG_BUS[H:L] = [0x%02x][0x%04x:0x%04x]\n", 0xFF,
2312 __HAL_NJPD_Read2Byte(BK_NJPD1_DEBUG_BUS_H),
2313 __HAL_NJPD_Read2Byte(BK_NJPD1_DEBUG_BUS_L));
2314
2315 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2316 NJPD_DEBUG_HAL_MSG("NJPD | 00/08 01/09 02/0A 03/0B 04/0C 05/0D 06/0E 07/0F\n");
2317 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2318 for(u16i=0; u16i<0x80; u16i+=8)
2319 {
2320 NJPD_DEBUG_HAL_MSG("%02x | %04x %04x %04x %04x %04x %04x %04x %04x \n",u16i,
2321 __HAL_NJPD_Read2Byte(BK_NJPD1_GENERAL(u16i)),
2322 __HAL_NJPD_Read2Byte(BK_NJPD1_GENERAL(u16i+1)),
2323 __HAL_NJPD_Read2Byte(BK_NJPD1_GENERAL(u16i+2)),
2324 __HAL_NJPD_Read2Byte(BK_NJPD1_GENERAL(u16i+3)),
2325 __HAL_NJPD_Read2Byte(BK_NJPD1_GENERAL(u16i+4)),
2326 __HAL_NJPD_Read2Byte(BK_NJPD1_GENERAL(u16i+5)),
2327 __HAL_NJPD_Read2Byte(BK_NJPD1_GENERAL(u16i+6)),
2328 __HAL_NJPD_Read2Byte(BK_NJPD1_GENERAL(u16i+7))
2329 );
2330 }
2331 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2332 }
2333 else
2334 {
2335 NJPD_DEBUG_HAL_MSG("read BK_NJPD2_MARB_CRC_RESULT_0: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_CRC_RESULT_0));
2336 NJPD_DEBUG_HAL_MSG("read BK_NJPD2_MARB_CRC_RESULT_1: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_CRC_RESULT_1));
2337 NJPD_DEBUG_HAL_MSG("read BK_NJPD2_MARB_CRC_RESULT_2: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_CRC_RESULT_2));
2338 NJPD_DEBUG_HAL_MSG("read BK_NJPD2_MARB_CRC_RESULT_3: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_CRC_RESULT_3));
2339 NJPD_DEBUG_HAL_MSG("read BK_NJPD2_GLOBAL_SETTING00: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_GLOBAL_SETTING00));
2340 NJPD_DEBUG_HAL_MSG("read BK_NJPD2_GLOBAL_SETTING01: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_GLOBAL_SETTING01));
2341 NJPD_DEBUG_HAL_MSG("read BK_NJPD2_GLOBAL_SETTING02: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_GLOBAL_SETTING02));
2342 NJPD_DEBUG_HAL_MSG("read BK_NJPD2_MIU_READ_STATUS = 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_READ_STATUS));
2343 NJPD_DEBUG_HAL_MSG("read BK_NJPD2_MIU_READ_POINTER_ADDR_L: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_READ_POINTER_ADDR_L));
2344 NJPD_DEBUG_HAL_MSG("read BK_NJPD2_MIU_READ_POINTER_ADDR_H: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_READ_POINTER_ADDR_H));
2345
2346 MS_U16 u16i;
2347 for(u16i=0; u16i<=0x7b; u16i++)
2348 {
2349 __HAL_NJPD_Write2Byte(BK_NJPD2_DEBUG_BUS_SELECT, u16i);
2350 NJPD_DEBUG_HAL_MSG("BK_NJPD2_DEBUG_BUS[H:L] = [0x%02x][0x%04x:0x%04x]\n", u16i,
2351 __HAL_NJPD_Read2Byte(BK_NJPD2_DEBUG_BUS_H),
2352 __HAL_NJPD_Read2Byte(BK_NJPD2_DEBUG_BUS_L));
2353 }
2354 __HAL_NJPD_Write2Byte(BK_NJPD2_DEBUG_BUS_SELECT, 0xFF);
2355 NJPD_DEBUG_HAL_MSG("BK_NJPD2_DEBUG_BUS[H:L] = [0x%02x][0x%04x:0x%04x]\n", 0xFF,
2356 __HAL_NJPD_Read2Byte(BK_NJPD2_DEBUG_BUS_H),
2357 __HAL_NJPD_Read2Byte(BK_NJPD2_DEBUG_BUS_L));
2358
2359 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2360 NJPD_DEBUG_HAL_MSG("NJPD | 00/08 01/09 02/0A 03/0B 04/0C 05/0D 06/0E 07/0F\n");
2361 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2362 for(u16i=0; u16i<0x80; u16i+=8)
2363 {
2364 NJPD_DEBUG_HAL_MSG("%02x | %04x %04x %04x %04x %04x %04x %04x %04x \n",u16i,
2365 __HAL_NJPD_Read2Byte(BK_NJPD2_GENERAL(u16i)),
2366 __HAL_NJPD_Read2Byte(BK_NJPD2_GENERAL(u16i+1)),
2367 __HAL_NJPD_Read2Byte(BK_NJPD2_GENERAL(u16i+2)),
2368 __HAL_NJPD_Read2Byte(BK_NJPD2_GENERAL(u16i+3)),
2369 __HAL_NJPD_Read2Byte(BK_NJPD2_GENERAL(u16i+4)),
2370 __HAL_NJPD_Read2Byte(BK_NJPD2_GENERAL(u16i+5)),
2371 __HAL_NJPD_Read2Byte(BK_NJPD2_GENERAL(u16i+6)),
2372 __HAL_NJPD_Read2Byte(BK_NJPD2_GENERAL(u16i+7))
2373 );
2374 }
2375 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2376 }
2377 MS_U8 u8i;
2378
2379 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2380 NJPD_DEBUG_HAL_MSG("MIU0 | 00/08 01/09 02/0A 03/0B 04/0C 05/0D 06/0E 07/0F\n");
2381 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2382 for(u8i=0; u8i<0x80; u8i+=8)
2383 {
2384 NJPD_DEBUG_HAL_MSG("%02x | %04x %04x %04x %04x %04x %04x %04x %04x \n",u8i,
2385 __HAL_NJPD_Read2Byte(BK_MIU0_GENERAL(u8i)),
2386 __HAL_NJPD_Read2Byte(BK_MIU0_GENERAL(u8i+1)),
2387 __HAL_NJPD_Read2Byte(BK_MIU0_GENERAL(u8i+2)),
2388 __HAL_NJPD_Read2Byte(BK_MIU0_GENERAL(u8i+3)),
2389 __HAL_NJPD_Read2Byte(BK_MIU0_GENERAL(u8i+4)),
2390 __HAL_NJPD_Read2Byte(BK_MIU0_GENERAL(u8i+5)),
2391 __HAL_NJPD_Read2Byte(BK_MIU0_GENERAL(u8i+6)),
2392 __HAL_NJPD_Read2Byte(BK_MIU0_GENERAL(u8i+7))
2393 );
2394 }
2395 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2396
2397 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2398 NJPD_DEBUG_HAL_MSG("MIU1 | 00/08 01/09 02/0A 03/0B 04/0C 05/0D 06/0E 07/0F\n");
2399 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2400 for(u8i=0; u8i<0x80; u8i+=8)
2401 {
2402 NJPD_DEBUG_HAL_MSG("%02x | %04x %04x %04x %04x %04x %04x %04x %04x \n",u8i,
2403 __HAL_NJPD_Read2Byte(BK_MIU1_GENERAL(u8i)),
2404 __HAL_NJPD_Read2Byte(BK_MIU1_GENERAL(u8i+1)),
2405 __HAL_NJPD_Read2Byte(BK_MIU1_GENERAL(u8i+2)),
2406 __HAL_NJPD_Read2Byte(BK_MIU1_GENERAL(u8i+3)),
2407 __HAL_NJPD_Read2Byte(BK_MIU1_GENERAL(u8i+4)),
2408 __HAL_NJPD_Read2Byte(BK_MIU1_GENERAL(u8i+5)),
2409 __HAL_NJPD_Read2Byte(BK_MIU1_GENERAL(u8i+6)),
2410 __HAL_NJPD_Read2Byte(BK_MIU1_GENERAL(u8i+7))
2411 );
2412 }
2413 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2414
2415
2416 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2417 NJPD_DEBUG_HAL_MSG("1608 | 00/08 01/09 02/0A 03/0B 04/0C 05/0D 06/0E 07/0F\n");
2418 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2419 for(u8i=0; u8i<0x80; u8i+=8)
2420 {
2421 NJPD_DEBUG_HAL_MSG("%02x | %04x %04x %04x %04x %04x %04x %04x %04x \n",u8i,
2422 __HAL_NJPD_Read2Byte(BK_1608_GENERAL(u8i)),
2423 __HAL_NJPD_Read2Byte(BK_1608_GENERAL(u8i+1)),
2424 __HAL_NJPD_Read2Byte(BK_1608_GENERAL(u8i+2)),
2425 __HAL_NJPD_Read2Byte(BK_1608_GENERAL(u8i+3)),
2426 __HAL_NJPD_Read2Byte(BK_1608_GENERAL(u8i+4)),
2427 __HAL_NJPD_Read2Byte(BK_1608_GENERAL(u8i+5)),
2428 __HAL_NJPD_Read2Byte(BK_1608_GENERAL(u8i+6)),
2429 __HAL_NJPD_Read2Byte(BK_1608_GENERAL(u8i+7))
2430 );
2431 }
2432 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2433
2434 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2435 NJPD_DEBUG_HAL_MSG("160F | 00/08 01/09 02/0A 03/0B 04/0C 05/0D 06/0E 07/0F\n");
2436 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2437 for(u8i=0; u8i<0x80; u8i+=8)
2438 {
2439 NJPD_DEBUG_HAL_MSG("%02x | %04x %04x %04x %04x %04x %04x %04x %04x \n",u8i,
2440 __HAL_NJPD_Read2Byte(BK_160F_GENERAL(u8i)),
2441 __HAL_NJPD_Read2Byte(BK_160F_GENERAL(u8i+1)),
2442 __HAL_NJPD_Read2Byte(BK_160F_GENERAL(u8i+2)),
2443 __HAL_NJPD_Read2Byte(BK_160F_GENERAL(u8i+3)),
2444 __HAL_NJPD_Read2Byte(BK_160F_GENERAL(u8i+4)),
2445 __HAL_NJPD_Read2Byte(BK_160F_GENERAL(u8i+5)),
2446 __HAL_NJPD_Read2Byte(BK_160F_GENERAL(u8i+6)),
2447 __HAL_NJPD_Read2Byte(BK_160F_GENERAL(u8i+7))
2448 );
2449 }
2450 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2451
2452
2453 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2454 NJPD_DEBUG_HAL_MSG("1615 | 00/08 01/09 02/0A 03/0B 04/0C 05/0D 06/0E 07/0F\n");
2455 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2456 for(u8i=0; u8i<0x80; u8i+=8)
2457 {
2458 NJPD_DEBUG_HAL_MSG("%02x | %04x %04x %04x %04x %04x %04x %04x %04x \n",u8i,
2459 __HAL_NJPD_Read2Byte(BK_1615_GENERAL(u8i)),
2460 __HAL_NJPD_Read2Byte(BK_1615_GENERAL(u8i+1)),
2461 __HAL_NJPD_Read2Byte(BK_1615_GENERAL(u8i+2)),
2462 __HAL_NJPD_Read2Byte(BK_1615_GENERAL(u8i+3)),
2463 __HAL_NJPD_Read2Byte(BK_1615_GENERAL(u8i+4)),
2464 __HAL_NJPD_Read2Byte(BK_1615_GENERAL(u8i+5)),
2465 __HAL_NJPD_Read2Byte(BK_1615_GENERAL(u8i+6)),
2466 __HAL_NJPD_Read2Byte(BK_1615_GENERAL(u8i+7))
2467 );
2468 }
2469 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2470
2471
2472 }
2473
HAL_NJPD_SetNJPDInstance(JPD_Number JPDNum)2474 void HAL_NJPD_SetNJPDInstance(JPD_Number JPDNum)
2475 {
2476 eNJPDNum = JPDNum;
2477 }
2478
HAL_NJPD_IsNeedToPatch(NJPD_PATCH_INDEX eIndex)2479 MS_BOOL HAL_NJPD_IsNeedToPatch(NJPD_PATCH_INDEX eIndex)
2480 {
2481 switch(eIndex)
2482 {
2483 case E_NJPD_MIU_LAST_Z_PATCH:
2484 return FALSE;
2485 break;
2486 case E_NJPD_EAGLE_SW_PATCH:
2487 return FALSE;
2488 break;
2489 default:
2490 break;
2491 }
2492 return FALSE;
2493 }
2494
HAL_NJPD_JPDCount(void)2495 MS_U8 HAL_NJPD_JPDCount(void)
2496 {
2497 return 1;
2498 }
2499