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 k6
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 k6_register_assignment.xls
1023 //1712H 0 1 1 1 1 0 0 0 0 codec_block 0 codec_gp
1024 // reference to k6_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 #if 0 // test code to make sure the MCM function disabled
1060 #define JPD_MCM_BASE 0x71200 //0x71F20
1061 #define BK_MCM_GENERAL(x) (JPD_MCM_BASE+NJPD_OFFSET(x))
1062
1063 // MS_U8 u8i;
1064 // for(u8i=0; u8i<0x16; u8i++)
1065 // {
1066 // __HAL_JPD_Write2Byte(BK_MCM_GENERAL(u8i), 0);
1067 // }
1068
1069 // __HAL_NJPD_Write2Byte(BK_MCM_GENERAL(0x01), 0x0000);
1070 // printf("MCM 0x%lx\n", 0x00);
1071 // __HAL_NJPD_Write2Byte(BK_MCM_GENERAL(0x01), 0xf200);
1072 // printf("MCM 0x%lx\n", 0xf2);
1073
1074 // __HAL_NJPD_Write2Byte(BK_MCM_GENERAL(0x01), 0xf000);
1075 // printf("MCM 0x%lx\n", 0xf0);
1076
1077 __HAL_NJPD_Write2Byte(BK_MCM_GENERAL(0x01), 0x1200);
1078 printf("MCM 0x%lx\n", 0x12);
1079 #endif
1080
1081
1082 #if MEASURE_NJPD_MIU_CLIENT_EFFICIENCY
1083 if(bJPEGFirstTime==0)
1084 {
1085 printf("bank: 0x1012, offset: 0x15, value=0x%x\n", __HAL_NJPD_Read2Byte(BK_MIU0_GENERAL(0x15)));
1086 __HAL_NJPD_Write2Byte(BK_MIU0_GENERAL(0x15), __HAL_NJPD_Read2Byte(BK_MIU0_GENERAL(0x15)) & ~0x80);
1087 printf("bank: 0x1012, offset: 0x15, value=0x%x\n", __HAL_NJPD_Read2Byte(BK_MIU0_GENERAL(0x15)));
1088 printf("bank: 0x1012, offset: 0x0d, value=0x%x\n", __HAL_NJPD_Read2Byte(BK_MIU0_GENERAL(0x0d)));
1089 __HAL_NJPD_Write2Byte(BK_MIU0_GENERAL(0x0d), 0x2734);
1090 printf("bank: 0x1012, offset: 0x0d, value=0x%x\n", __HAL_NJPD_Read2Byte(BK_MIU0_GENERAL(0x0d)));
1091 __HAL_NJPD_Write2Byte(BK_MIU0_GENERAL(0x0d), 0x2735);
1092 printf("bank: 0x1012, offset: 0x0d, value=0x%x\n", __HAL_NJPD_Read2Byte(BK_MIU0_GENERAL(0x0d)));
1093
1094 bJPEGFirstTime=1;
1095 }
1096 #endif
1097 }
1098
1099 /******************************************************************************/
1100 ///
1101 ///@param value \b IN
1102 ///@param value \b OUT
1103 ///@return status
1104 /******************************************************************************/
HAL_NJPD_PowerOff(void)1105 void HAL_NJPD_PowerOff(void)
1106 {
1107 MS_U16 u16reg_val;
1108 u16reg_val = HAL_NJPD_GetClock();
1109 u16reg_val = u16reg_val & 0xFFF2;
1110 u16reg_val |= 0x0001; // set NJPD disable [8] : 1, [3:2] : 00 288MHz
1111 NJPD_DEBUG_HAL_MSG("%s : SetClock : 0x%04x\n", __FUNCTION__ , u16reg_val);
1112 #ifdef CONFIG_MSTAR_CLKM
1113 MS_S32 handle = Drv_Clkm_Get_Handle("g_clk_njpd");
1114 Drv_Clkm_Clk_Gate_Disable(handle);
1115 #else
1116 HAL_NJPD_SetClock(u16reg_val);
1117 #endif
1118
1119
1120 #ifdef CONFIG_MSTAR_SRAMPD
1121 // reference to k6_register_assignment.xls
1122 //1712H 0 1 1 1 1 0 0 0 0 codec_block 0 codec_gp
1123 // reference to k6_block_top_reg.xls
1124 // h11 h10 31 0 reg_codec_sram_sd_en 31 0 32 h00 rw
1125 // bit [18] : jpd
1126 NJPD_DEBUG_HAL_MSG("NJPD sram off\n");
1127 *((volatile MS_U32 *)(MS_VIRT)(NJPD_RIU_MAP + 0x71200*2 + 0x10*2*2)) |= (1UL << 18);
1128 MsOS_DelayTask(1);
1129 #endif
1130 NJPD_DEBUG_HAL_MSG("%s : GetClock : 0x%04x\n", __FUNCTION__ , HAL_NJPD_GetClock());
1131 }
1132
1133 /******************************************************************************/
1134 ///
1135 ///@param value \b IN
1136 ///@param value \b OUT
1137 ///@return status
1138 /******************************************************************************/
HAL_NJPD_InitRegBase(void)1139 void HAL_NJPD_InitRegBase(void)
1140 {
1141 MS_PHY u32NonPMBankSize;
1142 if(!MDrv_MMIO_GetBASE(&u32NJPDRiuBaseAdd, &u32NonPMBankSize, MS_MODULE_JPD))
1143 {
1144 NJPD_DEBUG_HAL_ERR("Get RIUreg base Failed!!!\n");
1145 }
1146 else
1147 {
1148 NJPD_DEBUG_HAL_MSG("RIUreg base = 0x%tx, length = %tx\n", (ptrdiff_t)u32NJPDRiuBaseAdd, (ptrdiff_t)u32NonPMBankSize);
1149 }
1150 }
1151
1152 /******************************************************************************/
1153 ///
1154 ///@param value \b IN
1155 ///@param value \b OUT
1156 ///@return none
1157 /******************************************************************************/
HAL_NJPD_CreateMutex(void)1158 void HAL_NJPD_CreateMutex(void)
1159 {
1160 __HAL_NJPD_MutexCreate();
1161 }
1162
1163 /******************************************************************************/
1164 ///
1165 ///@param value \b IN
1166 ///@param value \b OUT
1167 ///@return none
1168 /******************************************************************************/
HAL_NJPD_DeleteMutex(void)1169 void HAL_NJPD_DeleteMutex(void)
1170 {
1171 __HAL_NJPD_MutexDelete();
1172 }
1173
1174 /******************************************************************************/
1175 ///
1176 ///@param value \b IN
1177 ///@param value \b OUT
1178 ///@return status
1179 /******************************************************************************/
HAL_NJPD_SetRSTIntv(MS_U16 u16Value)1180 void HAL_NJPD_SetRSTIntv(MS_U16 u16Value)
1181 {
1182 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1183 if(eNJPDNum == E_NJPD_NJPD1)
1184 {
1185 __HAL_NJPD_Write2Byte(BK_NJPD1_RESTART_INTERVAL, u16Value);
1186 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetRSTIntv : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_RESTART_INTERVAL));
1187 }
1188 else
1189 {
1190 __HAL_NJPD_Write2Byte(BK_NJPD2_RESTART_INTERVAL, u16Value);
1191 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetRSTIntv : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_RESTART_INTERVAL));
1192 }
1193 }
1194
1195
1196 /******************************************************************************/
1197 ///
1198 ///@param value \b IN
1199 ///@param value \b OUT
1200 ///@return none
1201 /******************************************************************************/
HAL_NJPD_SetDbgLevel(MS_U8 u8DbgLevel)1202 void HAL_NJPD_SetDbgLevel(MS_U8 u8DbgLevel)
1203 {
1204 _u8NJPDHalDbgLevel = u8DbgLevel;
1205 }
1206
1207 /******************************************************************************/
1208 ///
1209 ///@param value \b IN
1210 ///@param value \b OUT
1211 ///@return none
1212 /******************************************************************************/
HAL_NJPD_GetLibVer(NJPD_HAL_Version * pHalVer)1213 void HAL_NJPD_GetLibVer(NJPD_HAL_Version *pHalVer)
1214 {
1215 pHalVer->pu8HalVer = _pu8HalVer;
1216 pHalVer->pu8FwVer = _pu8FwVer;
1217 }
1218
1219 /******************************************************************************/
1220 ///Reset NJPD
1221 ///@param value \b IN
1222 ///@param value \b OUT
1223 ///@return none
1224 /******************************************************************************/
HAL_NJPD_Rst(void)1225 void HAL_NJPD_Rst(void)
1226 {
1227 NJPD_DEBUG_HAL_MSG("%s : start!!\n", __FUNCTION__);
1228 _HAL_NJPD_SetMIUProtectMask(TRUE);
1229
1230 // reset event flag
1231 HAL_NJPD_ClearEventFlag(NJPD_EVENT_ALL);
1232 // reset : low active
1233
1234 #if ENABLE_TEST_NJPD_17_Obuf_Output_Format
1235 HAL_NJPD_SetOutputFormat(TRUE, E_NJPD_OUTPUT_YC_SWAP);
1236 // HAL_NJPD_SetOutputFormat(TRUE, E_NJPD_OUTPUT_UV_SWAP);
1237 // HAL_NJPD_SetOutputFormat(TRUE, E_NJPD_OUTPUT_UV_7BIT);
1238 // HAL_NJPD_SetOutputFormat(TRUE, E_NJPD_OUTPUT_UV_MSB);
1239 #else
1240 if(HAL_NJPD_GetVerificationMode()==E_NJPD17_OBUF_OUTPUT_FORMAT_YC_SWAP)
1241 {
1242 HAL_NJPD_SetOutputFormat(TRUE, E_NJPD_OUTPUT_YC_SWAP);
1243 }
1244 else if(HAL_NJPD_GetVerificationMode()==E_NJPD17_OBUF_OUTPUT_FORMAT_UV_SWAP)
1245 {
1246 HAL_NJPD_SetOutputFormat(TRUE, E_NJPD_OUTPUT_UV_SWAP);
1247 }
1248 else if(HAL_NJPD_GetVerificationMode()==E_NJPD17_OBUF_OUTPUT_FORMAT_UV_7BIT)
1249 {
1250 HAL_NJPD_SetOutputFormat(TRUE, E_NJPD_OUTPUT_UV_7BIT);
1251 }
1252 else if(HAL_NJPD_GetVerificationMode()==E_NJPD17_OBUF_OUTPUT_FORMAT_UV_MSB)
1253 {
1254 HAL_NJPD_SetOutputFormat(TRUE, E_NJPD_OUTPUT_UV_MSB);
1255 }
1256 else
1257 {
1258 HAL_NJPD_SetOutputFormat(TRUE, E_NJPD_OUTPUT_ORIGINAL);
1259 }
1260 #endif
1261
1262 #if ENABLE_NJPD_DEBUG_MSG
1263 HAL_NJPD_Set_GlobalSetting02(0xFC | NJPD_TBC_MODE | NJPD_LITTLE_ENDIAN | NJPD_REMOVE_0xFF00 |
1264 NJPD_REMOVE_0xFFFF | NJPD_HUFF_DATA_LOSS_ERROR);
1265 #else
1266 if(HAL_NJPD_GetVerificationMode()==E_NJPD01_TABLE_READ_WRITE)
1267 {
1268 HAL_NJPD_Set_GlobalSetting02(0xFC | NJPD_TBC_MODE | NJPD_LITTLE_ENDIAN | NJPD_REMOVE_0xFF00 |
1269 NJPD_REMOVE_0xFFFF | NJPD_HUFF_DATA_LOSS_ERROR);
1270 }
1271 else
1272 {
1273 HAL_NJPD_Set_GlobalSetting02(NJPD_TBC_MODE | NJPD_LITTLE_ENDIAN | NJPD_REMOVE_0xFF00 |
1274 NJPD_REMOVE_0xFFFF | NJPD_HUFF_DATA_LOSS_ERROR);
1275 }
1276 #endif
1277 HAL_NJPD_Set_GlobalSetting00(HAL_NJPD_Get_GlobalSetting00() | NJPD_SWRST);
1278 #if 0
1279 HAL_NJPD_MaskEventFlag(0xffff);
1280
1281 #else
1282 HAL_NJPD_MaskEventFlag(~(NJPD_EVENT_DECODE_DONE | NJPD_EVENT_MINICODE_ERR |
1283 NJPD_EVENT_INV_SCAN_ERR | NJPD_EVENT_RES_MARKER_ERR | NJPD_EVENT_RMID_ERR |
1284 NJPD_EVENT_END_IMAGE_ERR | NJPD_EVENT_MRC0_EMPTY | NJPD_EVENT_MRC1_EMPTY |
1285 NJPD_EVENT_WRITE_PROTECT | NJPD_EVENT_DATA_LOSS_ERR |
1286 NJPD_EVENT_HUFF_TABLE_ERR)); // set 0 to turn on the irq
1287 #endif
1288
1289 NJPD_DEBUG_HAL_MSG("Get BK_NJPD_GLOBAL_SETTING00 : 0x%04x\n", HAL_NJPD_Get_GlobalSetting00());
1290 NJPD_DEBUG_HAL_MSG("Get BK_NJPD_GLOBAL_SETTING01 : 0x%04x\n", HAL_NJPD_Get_GlobalSetting01());
1291 NJPD_DEBUG_HAL_MSG("Get BK_NJPD_GLOBAL_SETTING02 : 0x%04x\n", HAL_NJPD_Get_GlobalSetting02());
1292 if(eNJPDNum == E_NJPD_NJPD1)
1293 {
1294 NJPD_DEBUG_HAL_MSG("HAL Get INTEN : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_IRQ_MASK));
1295 NJPD_DEBUG_HAL_MSG("HAL Get EVENTFLAG : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_IRQ_FINAL_S));
1296 }
1297 else
1298 {
1299 NJPD_DEBUG_HAL_MSG("HAL Get INTEN : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_IRQ_MASK));
1300 NJPD_DEBUG_HAL_MSG("HAL Get EVENTFLAG : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_IRQ_FINAL_S));
1301 }
1302
1303 // Edison@20120620 by Arong
1304 // 1. Add the fucntion of auto last buffer when FFD9 is detected (reg_spare00[0])
1305 // 2. Fix last buffer error (reg_spare00[1])
1306 //// 3. write burst_error (reg_spare00[3]) // Edison/Einstein doesnt have this bit
1307 //// 4. Fix read-burst error (reg_spare00[4]) // Edison/Einstein doesnt have this bit
1308 // 5. Coding error (reg_spare00[5])
1309 // 6. read-burst error (reg_spare00[6])
1310
1311 // Kano@20150326 by Ethan Chang
1312 // 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
1313
1314 // Nike&Einstein@20130412 by Tony Tseng
1315 // 9. ECO new error concealment(reg_spare00[9]) // Nike have this bit
1316
1317 HAL_NJPD_SetSpare00(0x2FB);
1318
1319 #if 0
1320 MS_U16 u16Value = ((HAL_NJPD_Get_MARB07() & ~NJPD_JPD_MARB_BURST_SPLIT) | 0x0002<<12);
1321 printf("MARB07=0x%x\n", u16Value);
1322 HAL_NJPD_Set_MARB07(u16Value);
1323 #endif
1324 _HAL_NJPD_SetMIUProtectMask(FALSE);
1325
1326 #if ENABLE_TEST_NJPD_18_Ibuf_Burst_Length_Test
1327 HAL_NJPD_SetIBufReadLength(0x15, 0x1a);
1328 #else
1329 if(HAL_NJPD_GetVerificationMode()==E_NJPD18_IBUF_BURST_LENGTH)
1330 {
1331 HAL_NJPD_SetIBufReadLength(0x15, 0x1a);
1332 }
1333 else
1334 {
1335 if(HAL_NJPD_IsNeedToPatch(E_NJPD_EAGLE_SW_PATCH))
1336 {
1337 NJPD_DEBUG_HAL_MSG("EAGLE_SW_PATCH start!!!!!!\n");
1338 HAL_NJPD_SetIBufReadLength(0x1f, 0x1f);
1339 HAL_NJPD_SetMRBurstThd(0x10);
1340 MS_U16 u16Value = (HAL_NJPD_Get_MARB07() | 0xc01f);
1341 NJPD_DEBUG_HAL_MSG("MARB07=0x%x\n", u16Value);
1342 HAL_NJPD_Set_MARB07(u16Value);
1343 NJPD_DEBUG_HAL_MSG("EAGLE_SW_PATCH end!!!!!!\n");
1344 }
1345 else
1346 {
1347 HAL_NJPD_SetIBufReadLength(0x10, 0x1f);
1348 }
1349 }
1350 #endif
1351
1352 #if ENABLE_NJPD_DEBUG_MSG
1353 //HAL_NJPD_SetCRCReadMode();
1354 HAL_NJPD_SetCRCWriteMode();
1355 #else
1356 if(HAL_NJPD_GetVerificationMode()==E_NJPD01_TABLE_READ_WRITE)
1357 {
1358 HAL_NJPD_SetCRCWriteMode();
1359 }
1360 else
1361 {
1362 HAL_NJPD_SetCRCReadMode();
1363 }
1364 #endif
1365 NJPD_DEBUG_HAL_MSG("%s : end!!\n", __FUNCTION__);
1366 }
1367
HAL_NJPD_SetMWBuffLineNum(MS_U16 u16Value)1368 void HAL_NJPD_SetMWBuffLineNum(MS_U16 u16Value)
1369 {
1370 NJPD_DEBUG_HAL_MSG("%s : NOT IMPLEMENTED!!!\n", __FUNCTION__);
1371 UNUSED(u16Value);
1372 }
1373
1374 /******************************************************************************/
1375 ///
1376 ///@param value \b IN
1377 ///@param value \b OUT
1378 ///@return status
1379 /******************************************************************************/
HAL_NJPD_GetCurMRCAddr(void)1380 MS_U32 HAL_NJPD_GetCurMRCAddr(void)
1381 {
1382 MS_U32 curMRCAddr;
1383 if(eNJPDNum == E_NJPD_NJPD1)
1384 {
1385 curMRCAddr = ((__HAL_NJPD_Read2Byte(BK_NJPD1_MIU_READ_POINTER_ADDR_H) << 16) | __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_READ_POINTER_ADDR_L));
1386 }
1387 else
1388 {
1389 curMRCAddr = ((__HAL_NJPD_Read2Byte(BK_NJPD2_MIU_READ_POINTER_ADDR_H) << 16) | __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_READ_POINTER_ADDR_L));
1390 }
1391
1392 return curMRCAddr;
1393 }
1394
1395 /******************************************************************************/
1396 ///
1397 ///@param value \b IN
1398 ///@param value \b OUT
1399 ///@return status
1400 /******************************************************************************/
HAL_NJPD_GetCurRow(void)1401 MS_U16 HAL_NJPD_GetCurRow(void)
1402 {
1403 if(eNJPDNum == E_NJPD_NJPD1)
1404 {
1405 return __HAL_NJPD_Read2Byte(BK_NJPD1_ROW_IDEX);
1406 }
1407 else
1408 {
1409 return __HAL_NJPD_Read2Byte(BK_NJPD2_ROW_IDEX);
1410 }
1411 }
1412
1413 /******************************************************************************/
1414 ///
1415 ///@param value \b IN
1416 ///@param value \b OUT
1417 ///@return status
1418 /******************************************************************************/
HAL_NJPD_GetCurCol(void)1419 MS_U16 HAL_NJPD_GetCurCol(void)
1420 {
1421 if(eNJPDNum == E_NJPD_NJPD1)
1422 {
1423 return __HAL_NJPD_Read2Byte(BK_NJPD1_COLUMN_IDEX);
1424 }
1425 else
1426 {
1427 return __HAL_NJPD_Read2Byte(BK_NJPD2_COLUMN_IDEX);
1428 }
1429 }
1430
HAL_NJPD_SetWriteProtect(MS_BOOL enable)1431 void HAL_NJPD_SetWriteProtect(MS_BOOL enable)
1432 {
1433 NJPD_DEBUG_HAL_MSG("%s : NOT IMPLEMENTED!!!\n", __FUNCTION__);
1434 UNUSED(enable);
1435 }
1436
HAL_NJPD_SetAutoProtect(MS_BOOL enable)1437 void HAL_NJPD_SetAutoProtect(MS_BOOL enable)
1438 {
1439 MS_U16 u16RegValue;
1440 if(eNJPDNum == E_NJPD_NJPD1)
1441 {
1442 u16RegValue = __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_LBOUND_0_H);
1443 u16RegValue &= 0x1FFF;
1444 u16RegValue |= enable<<13;
1445 __HAL_NJPD_Write2Byte(BK_NJPD1_MARB_LBOUND_0_H, u16RegValue);
1446 NJPD_DEBUG_HAL_MSG("%s : 0x%04X\n", __FUNCTION__, __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_LBOUND_0_H));
1447 }
1448 else
1449 {
1450 u16RegValue = __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_LBOUND_0_H);
1451 u16RegValue &= 0x1FFF;
1452 u16RegValue |= enable<<13;
1453 __HAL_NJPD_Write2Byte(BK_NJPD2_MARB_LBOUND_0_H, u16RegValue);
1454 NJPD_DEBUG_HAL_MSG("%s : 0x%04X\n", __FUNCTION__, __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_LBOUND_0_H));
1455 }
1456 }
1457
1458
HAL_NJPD_Set_MARB06(MS_U16 u16Value)1459 void HAL_NJPD_Set_MARB06(MS_U16 u16Value)
1460 {
1461 NJPD_DEBUG_HAL_MSG("%s : 0x%04X\n", __FUNCTION__, u16Value);
1462 if(eNJPDNum == E_NJPD_NJPD1)
1463 {
1464 __HAL_NJPD_Write2Byte(BK_NJPD1_MARB_SETTING_06, u16Value);
1465 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_Get_MARB06 : 0x%04X\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_SETTING_06));
1466 }
1467 else
1468 {
1469 __HAL_NJPD_Write2Byte(BK_NJPD2_MARB_SETTING_06, u16Value);
1470 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_Get_MARB06 : 0x%04X\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_SETTING_06));
1471 }
1472 }
1473
HAL_NJPD_Get_MARB06(void)1474 MS_U16 HAL_NJPD_Get_MARB06(void)
1475 {
1476 if(eNJPDNum == E_NJPD_NJPD1)
1477 {
1478 return __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_SETTING_06);
1479 }
1480 else
1481 {
1482 return __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_SETTING_06);
1483 }
1484 }
1485
HAL_NJPD_Set_MARB07(MS_U16 u16Value)1486 void HAL_NJPD_Set_MARB07(MS_U16 u16Value)
1487 {
1488 NJPD_DEBUG_HAL_MSG("%s : 0x%04X\n", __FUNCTION__, u16Value);
1489 if(eNJPDNum == E_NJPD_NJPD1)
1490 {
1491 __HAL_NJPD_Write2Byte(BK_NJPD1_MARB_SETTING_07, u16Value);
1492 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_Get_MARB07 : 0x%04X\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_SETTING_07));
1493 }
1494 else
1495 {
1496 __HAL_NJPD_Write2Byte(BK_NJPD2_MARB_SETTING_07, u16Value);
1497 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_Get_MARB07 : 0x%04X\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_SETTING_07));
1498 }
1499 }
1500
HAL_NJPD_Get_MARB07(void)1501 MS_U16 HAL_NJPD_Get_MARB07(void)
1502 {
1503 if(eNJPDNum == E_NJPD_NJPD1)
1504 {
1505 return __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_SETTING_07);
1506 }
1507 else
1508 {
1509 return __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_SETTING_07);
1510 }
1511 }
1512
1513
HAL_NJPD_SetWPENUBound_0_L(MS_U16 u16Value)1514 void HAL_NJPD_SetWPENUBound_0_L(MS_U16 u16Value)
1515 {
1516 NJPD_DEBUG_HAL_MSG("%s : 0x%04X\n", __FUNCTION__, u16Value);
1517 if(eNJPDNum == E_NJPD_NJPD1)
1518 {
1519 __HAL_NJPD_Write2Byte(BK_NJPD1_MARB_UBOUND_0_L, u16Value);
1520 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetWPENUBound_0_L : 0x%04X\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_UBOUND_0_L));
1521 }
1522 else
1523 {
1524 __HAL_NJPD_Write2Byte(BK_NJPD2_MARB_UBOUND_0_L, u16Value);
1525 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetWPENUBound_0_L : 0x%04X\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_UBOUND_0_L));
1526 }
1527 }
HAL_NJPD_SetWPENUBound_0_H(MS_U16 u16Value)1528 void HAL_NJPD_SetWPENUBound_0_H(MS_U16 u16Value)
1529 {
1530 NJPD_DEBUG_HAL_MSG("%s : 0x%04X\n", __FUNCTION__, u16Value);
1531 if(eNJPDNum == E_NJPD_NJPD1)
1532 {
1533 __HAL_NJPD_Write2Byte(BK_NJPD1_MARB_UBOUND_0_H, u16Value);
1534 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetWPENUBound_0_H : 0x%04X\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_UBOUND_0_H));
1535 }
1536 else
1537 {
1538 __HAL_NJPD_Write2Byte(BK_NJPD2_MARB_UBOUND_0_H, u16Value);
1539 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetWPENUBound_0_H : 0x%04X\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_UBOUND_0_H));
1540 }
1541 }
HAL_NJPD_SetWPENLBound_0_L(MS_U16 u16Value)1542 void HAL_NJPD_SetWPENLBound_0_L(MS_U16 u16Value)
1543 {
1544 NJPD_DEBUG_HAL_MSG("%s : 0x%04X\n", __FUNCTION__, u16Value);
1545 if(eNJPDNum == E_NJPD_NJPD1)
1546 {
1547 __HAL_NJPD_Write2Byte(BK_NJPD1_MARB_LBOUND_0_L, u16Value);
1548 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetWPENLBound_0_L : 0x%04X\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_LBOUND_0_L));
1549 }
1550 else
1551 {
1552 __HAL_NJPD_Write2Byte(BK_NJPD2_MARB_LBOUND_0_L, u16Value);
1553 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetWPENLBound_0_L : 0x%04X\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_LBOUND_0_L));
1554 }
1555 }
HAL_NJPD_SetWPENLBound_0_H(MS_U16 u16Value)1556 void HAL_NJPD_SetWPENLBound_0_H(MS_U16 u16Value)
1557 {
1558 MS_U16 u16RegValue;
1559 if(eNJPDNum == E_NJPD_NJPD1)
1560 {
1561 u16RegValue = __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_LBOUND_0_H);
1562 u16RegValue &= 0xE000;
1563 u16Value &= 0x1FFF;
1564 u16RegValue |= u16Value;
1565 NJPD_DEBUG_HAL_MSG("%s : 0x%04X\n", __FUNCTION__, u16RegValue);
1566 __HAL_NJPD_Write2Byte(BK_NJPD1_MARB_LBOUND_0_H, u16RegValue);
1567 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetWPENLBound_0_H : 0x%04X\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_LBOUND_0_H));
1568 }
1569 else
1570 {
1571 u16RegValue = __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_LBOUND_0_H);
1572 u16RegValue &= 0xE000;
1573 u16Value &= 0x1FFF;
1574 u16RegValue |= u16Value;
1575 NJPD_DEBUG_HAL_MSG("%s : 0x%04X\n", __FUNCTION__, u16RegValue);
1576 __HAL_NJPD_Write2Byte(BK_NJPD2_MARB_LBOUND_0_H, u16RegValue);
1577 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetWPENLBound_0_H : 0x%04X\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_LBOUND_0_H));
1578 }
1579 }
1580
HAL_NJPD_SetSpare00(MS_U16 u16Value)1581 void HAL_NJPD_SetSpare00(MS_U16 u16Value)
1582 {
1583 // [0]: hw auto detect ffd9 => cannot be used in svld mode, unless the "last buffer" cannot work, do not enable this
1584 // [1]: input buffer bug => always turn on
1585 // [2]: marb bug => always turn on (not used in 2011/12/28 ECO version)
1586 // [3]: bypass marb => 2011/12/28 ECO version
1587
1588 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1589 if(eNJPDNum == E_NJPD_NJPD1)
1590 {
1591 __HAL_NJPD_Write2Byte(BK_NJPD1_SPARE00, u16Value);
1592 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetSpare00 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE00));
1593 }
1594 else
1595 {
1596 __HAL_NJPD_Write2Byte(BK_NJPD2_SPARE00, u16Value);
1597 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetSpare00 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE00));
1598 }
1599 }
HAL_NJPD_GetSpare00(void)1600 MS_U16 HAL_NJPD_GetSpare00(void)
1601 {
1602 if(eNJPDNum == E_NJPD_NJPD1)
1603 {
1604 return __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE00);
1605 }
1606 else
1607 {
1608 return __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE00);
1609 }
1610 }
1611
HAL_NJPD_SetSpare01(MS_U16 u16Value)1612 void HAL_NJPD_SetSpare01(MS_U16 u16Value)
1613 {
1614 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1615 if(eNJPDNum == E_NJPD_NJPD1)
1616 {
1617 __HAL_NJPD_Write2Byte(BK_NJPD1_SPARE01, u16Value);
1618 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetSpare01 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE01));
1619 }
1620 else
1621 {
1622 __HAL_NJPD_Write2Byte(BK_NJPD2_SPARE01, u16Value);
1623 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetSpare01 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE01));
1624 }
1625 }
HAL_NJPD_GetSpare01(void)1626 MS_U16 HAL_NJPD_GetSpare01(void)
1627 {
1628 if(eNJPDNum == E_NJPD_NJPD1)
1629 {
1630 return __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE01);
1631 }
1632 else
1633 {
1634 return __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE01);
1635 }
1636 }
1637
HAL_NJPD_SetSpare02(MS_U16 u16Value)1638 void HAL_NJPD_SetSpare02(MS_U16 u16Value)
1639 {
1640 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1641 if(eNJPDNum == E_NJPD_NJPD1)
1642 {
1643 __HAL_NJPD_Write2Byte(BK_NJPD1_SPARE02, u16Value);
1644 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetSpare02 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE02));
1645 }
1646 else
1647 {
1648 __HAL_NJPD_Write2Byte(BK_NJPD2_SPARE02, u16Value);
1649 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetSpare02 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE02));
1650 }
1651 }
HAL_NJPD_GetSpare02(void)1652 MS_U16 HAL_NJPD_GetSpare02(void)
1653 {
1654 if(eNJPDNum == E_NJPD_NJPD1)
1655 {
1656 return __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE02);
1657 }
1658 else
1659 {
1660 return __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE02);
1661 }
1662 }
1663
HAL_NJPD_SetSpare03(MS_U16 u16Value)1664 void HAL_NJPD_SetSpare03(MS_U16 u16Value)
1665 {
1666 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1667 if(eNJPDNum == E_NJPD_NJPD1)
1668 {
1669 __HAL_NJPD_Write2Byte(BK_NJPD1_SPARE03, u16Value);
1670 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetSpare03 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE03));
1671 }
1672 else
1673 {
1674 __HAL_NJPD_Write2Byte(BK_NJPD2_SPARE03, u16Value);
1675 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetSpare03 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE03));
1676 }
1677 }
HAL_NJPD_GetSpare03(void)1678 MS_U16 HAL_NJPD_GetSpare03(void)
1679 {
1680 if(eNJPDNum == E_NJPD_NJPD1)
1681 {
1682 return __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE03);
1683 }
1684 else
1685 {
1686 return __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE03);
1687 }
1688 }
1689
HAL_NJPD_SetSpare04(MS_U16 u16Value)1690 void HAL_NJPD_SetSpare04(MS_U16 u16Value)
1691 {
1692 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1693 if(eNJPDNum == E_NJPD_NJPD1)
1694 {
1695 __HAL_NJPD_Write2Byte(BK_NJPD1_SPARE04, u16Value);
1696 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetSpare04 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE04));
1697 }
1698 else
1699 {
1700 __HAL_NJPD_Write2Byte(BK_NJPD2_SPARE04, u16Value);
1701 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetSpare04 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE04));
1702 }
1703 }
HAL_NJPD_GetSpare04(void)1704 MS_U16 HAL_NJPD_GetSpare04(void)
1705 {
1706 if(eNJPDNum == E_NJPD_NJPD1)
1707 {
1708 return __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE04);
1709 }
1710 else
1711 {
1712 return __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE04);
1713 }
1714 }
1715
HAL_NJPD_SetSpare05(MS_U16 u16Value)1716 void HAL_NJPD_SetSpare05(MS_U16 u16Value)
1717 {
1718 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1719 if(eNJPDNum == E_NJPD_NJPD1)
1720 {
1721 __HAL_NJPD_Write2Byte(BK_NJPD1_SPARE05, u16Value);
1722 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetSpare05 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE05));
1723 }
1724 else
1725 {
1726 __HAL_NJPD_Write2Byte(BK_NJPD2_SPARE05, u16Value);
1727 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetSpare05 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE05));
1728 }
1729 }
HAL_NJPD_GetSpare05(void)1730 MS_U16 HAL_NJPD_GetSpare05(void)
1731 {
1732 if(eNJPDNum == E_NJPD_NJPD1)
1733 {
1734 return __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE05);
1735 }
1736 else
1737 {
1738 return __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE05);
1739 }
1740 }
1741
HAL_NJPD_SetSpare06(MS_U16 u16Value)1742 void HAL_NJPD_SetSpare06(MS_U16 u16Value)
1743 {
1744 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1745 if(eNJPDNum == E_NJPD_NJPD1)
1746 {
1747 __HAL_NJPD_Write2Byte(BK_NJPD1_SPARE06, u16Value);
1748 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetSpare06 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE06));
1749 }
1750 else
1751 {
1752 __HAL_NJPD_Write2Byte(BK_NJPD2_SPARE06, u16Value);
1753 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetSpare06 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE06));
1754 }
1755 }
HAL_NJPD_GetSpare06(void)1756 MS_U16 HAL_NJPD_GetSpare06(void)
1757 {
1758 if(eNJPDNum == E_NJPD_NJPD1)
1759 {
1760 return __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE06);
1761 }
1762 else
1763 {
1764 return __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE06);
1765 }
1766 }
1767
HAL_NJPD_SetSpare07(MS_U16 u16Value)1768 void HAL_NJPD_SetSpare07(MS_U16 u16Value)
1769 {
1770 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1771 if(eNJPDNum == E_NJPD_NJPD1)
1772 {
1773 __HAL_NJPD_Write2Byte(BK_NJPD1_SPARE07, u16Value);
1774 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetSpare07 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE07));
1775 }
1776 else
1777 {
1778 __HAL_NJPD_Write2Byte(BK_NJPD2_SPARE07, u16Value);
1779 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetSpare07 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE07));
1780 }
1781 }
HAL_NJPD_GetSpare07(void)1782 MS_U16 HAL_NJPD_GetSpare07(void)
1783 {
1784 if(eNJPDNum == E_NJPD_NJPD1)
1785 {
1786 return __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE07);
1787 }
1788 else
1789 {
1790 return __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE07);
1791 }
1792 }
1793
HAL_NJPD_SetWriteOneClearReg(MS_U16 u16Value)1794 void HAL_NJPD_SetWriteOneClearReg(MS_U16 u16Value)
1795 {
1796 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1797 if(eNJPDNum == E_NJPD_NJPD1)
1798 {
1799 __HAL_NJPD_Write2Byte(BK_NJPD1_WRITE_ONE_CLEAR, u16Value);
1800 }
1801 else
1802 {
1803 __HAL_NJPD_Write2Byte(BK_NJPD2_WRITE_ONE_CLEAR, u16Value);
1804 }
1805 }
1806
HAL_NJPD_SetWriteOneClearReg_2(MS_U16 u16Value)1807 void HAL_NJPD_SetWriteOneClearReg_2(MS_U16 u16Value)
1808 {
1809 // for convience, not to print any message in this function
1810 if(eNJPDNum == E_NJPD_NJPD1)
1811 {
1812 __HAL_NJPD_Write2Byte(BK_NJPD1_WRITE_ONE_CLEAR, u16Value);
1813 }
1814 else
1815 {
1816 __HAL_NJPD_Write2Byte(BK_NJPD2_WRITE_ONE_CLEAR, u16Value);
1817 }
1818 }
1819
HAL_NJPD_GetWriteOneClearReg(void)1820 MS_U16 HAL_NJPD_GetWriteOneClearReg(void)
1821 {
1822 if(eNJPDNum == E_NJPD_NJPD1)
1823 {
1824 return __HAL_NJPD_Read2Byte(BK_NJPD1_WRITE_ONE_CLEAR);
1825 }
1826 else
1827 {
1828 return __HAL_NJPD_Read2Byte(BK_NJPD2_WRITE_ONE_CLEAR);
1829 }
1830 }
1831
HAL_NJPD_SetHTableStart_Low(MS_U16 u16Value)1832 void HAL_NJPD_SetHTableStart_Low(MS_U16 u16Value)
1833 {
1834 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1835 if(eNJPDNum == E_NJPD_NJPD1)
1836 {
1837 __HAL_NJPD_Write2Byte(BK_NJPD1_MIU_HTABLE_START_ADDR_L, u16Value);
1838 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetHTableStart_Low : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_HTABLE_START_ADDR_L));
1839 }
1840 else
1841 {
1842 __HAL_NJPD_Write2Byte(BK_NJPD2_MIU_HTABLE_START_ADDR_L, u16Value);
1843 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetHTableStart_Low : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_HTABLE_START_ADDR_L));
1844 }
1845 }
1846
HAL_NJPD_SetHTableStart_High(MS_U16 u16Value)1847 void HAL_NJPD_SetHTableStart_High(MS_U16 u16Value)
1848 {
1849 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1850 if(eNJPDNum == E_NJPD_NJPD1)
1851 {
1852 __HAL_NJPD_Write2Byte(BK_NJPD1_MIU_HTABLE_START_ADDR_H, u16Value);
1853 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetHTableStart_High : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_HTABLE_START_ADDR_H));
1854 }
1855 else
1856 {
1857 __HAL_NJPD_Write2Byte(BK_NJPD2_MIU_HTABLE_START_ADDR_H, u16Value);
1858 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetHTableStart_High : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_HTABLE_START_ADDR_H));
1859 }
1860 }
1861
HAL_NJPD_SetQTableStart_Low(MS_U16 u16Value)1862 void HAL_NJPD_SetQTableStart_Low(MS_U16 u16Value)
1863 {
1864 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1865 if(eNJPDNum == E_NJPD_NJPD1)
1866 {
1867 __HAL_NJPD_Write2Byte(BK_NJPD1_MIU_QTABLE_START_ADDR_L, u16Value);
1868 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetQTableStart_Low : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_QTABLE_START_ADDR_L));
1869 }
1870 else
1871 {
1872 __HAL_NJPD_Write2Byte(BK_NJPD2_MIU_QTABLE_START_ADDR_L, u16Value);
1873 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetQTableStart_Low : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_QTABLE_START_ADDR_L));
1874 }
1875 }
1876
HAL_NJPD_SetQTableStart_High(MS_U16 u16Value)1877 void HAL_NJPD_SetQTableStart_High(MS_U16 u16Value)
1878 {
1879 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1880 if(eNJPDNum == E_NJPD_NJPD1)
1881 {
1882 __HAL_NJPD_Write2Byte(BK_NJPD1_MIU_QTABLE_START_ADDR_H, u16Value);
1883 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetQTableStart_High : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_QTABLE_START_ADDR_H));
1884 }
1885 else
1886 {
1887 __HAL_NJPD_Write2Byte(BK_NJPD2_MIU_QTABLE_START_ADDR_H, u16Value);
1888 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetQTableStart_High : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_QTABLE_START_ADDR_H));
1889 }
1890 }
1891
HAL_NJPD_SetGTableStart_Low(MS_U16 u16Value)1892 void HAL_NJPD_SetGTableStart_Low(MS_U16 u16Value)
1893 {
1894 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1895 if(eNJPDNum == E_NJPD_NJPD1)
1896 {
1897 __HAL_NJPD_Write2Byte(BK_NJPD1_MIU_GTABLE_START_ADDR_L, u16Value);
1898 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetGTableStart_Low : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_GTABLE_START_ADDR_L));
1899 }
1900 else
1901 {
1902 __HAL_NJPD_Write2Byte(BK_NJPD2_MIU_GTABLE_START_ADDR_L, u16Value);
1903 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetGTableStart_Low : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_GTABLE_START_ADDR_L));
1904 }
1905 }
1906
HAL_NJPD_SetGTableStart_High(MS_U16 u16Value)1907 void HAL_NJPD_SetGTableStart_High(MS_U16 u16Value)
1908 {
1909 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1910 if(eNJPDNum == E_NJPD_NJPD1)
1911 {
1912 __HAL_NJPD_Write2Byte(BK_NJPD1_MIU_GTABLE_START_ADDR_H, u16Value);
1913 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetGTableStart_High : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_GTABLE_START_ADDR_H));
1914 }
1915 else
1916 {
1917 __HAL_NJPD_Write2Byte(BK_NJPD2_MIU_GTABLE_START_ADDR_H, u16Value);
1918 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetGTableStart_High : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_GTABLE_START_ADDR_H));
1919 }
1920 }
1921
HAL_NJPD_SetHTableSize(MS_U16 u16Value)1922 void HAL_NJPD_SetHTableSize(MS_U16 u16Value)
1923 {
1924 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1925 u16Value &=0x00FF;
1926 if(eNJPDNum == E_NJPD_NJPD1)
1927 {
1928 __HAL_NJPD_Write2Byte(BK_NJPD1_MIU_HTABLE_SIZE, u16Value);
1929 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetHTableSize : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_HTABLE_SIZE));
1930 }
1931 else
1932 {
1933 __HAL_NJPD_Write2Byte(BK_NJPD2_MIU_HTABLE_SIZE, u16Value);
1934 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetHTableSize : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_HTABLE_SIZE));
1935 }
1936 }
1937
HAL_NJPD_GetHTableSize()1938 MS_U16 HAL_NJPD_GetHTableSize()
1939 {
1940 if(eNJPDNum == E_NJPD_NJPD1)
1941 {
1942 return __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_HTABLE_SIZE);
1943 }
1944 else
1945 {
1946 return __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_HTABLE_SIZE);
1947 }
1948 }
HAL_NJPD_SetRIUInterface(MS_U16 u16Value)1949 void HAL_NJPD_SetRIUInterface(MS_U16 u16Value)
1950 {
1951 // NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1952 if(eNJPDNum == E_NJPD_NJPD1)
1953 {
1954 __HAL_NJPD_Write2Byte(BK_NJPD1_TBC, u16Value);
1955 // NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetRIUInterface : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_TBC));
1956 }
1957 else
1958 {
1959 __HAL_NJPD_Write2Byte(BK_NJPD2_TBC, u16Value);
1960 // NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetRIUInterface : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_TBC));
1961 }
1962 }
1963
HAL_NJPD_GetRIUInterface(void)1964 MS_U16 HAL_NJPD_GetRIUInterface(void)
1965 {
1966 if(eNJPDNum == E_NJPD_NJPD1)
1967 {
1968 return __HAL_NJPD_Read2Byte(BK_NJPD1_TBC);
1969 }
1970 else
1971 {
1972 return __HAL_NJPD_Read2Byte(BK_NJPD2_TBC);
1973 }
1974 }
1975
HAL_NJPD_TBCReadData_L()1976 MS_U16 HAL_NJPD_TBCReadData_L()
1977 {
1978 if(eNJPDNum == E_NJPD_NJPD1)
1979 {
1980 return __HAL_NJPD_Read2Byte(BK_NJPD1_TBC_RDATA_L);
1981 }
1982 else
1983 {
1984 return __HAL_NJPD_Read2Byte(BK_NJPD2_TBC_RDATA_L);
1985 }
1986 }
1987
HAL_NJPD_TBCReadData_H()1988 MS_U16 HAL_NJPD_TBCReadData_H()
1989 {
1990 if(eNJPDNum == E_NJPD_NJPD1)
1991 {
1992 return __HAL_NJPD_Read2Byte(BK_NJPD1_TBC_RDATA_H);
1993 }
1994 else
1995 {
1996 return __HAL_NJPD_Read2Byte(BK_NJPD2_TBC_RDATA_H);
1997 }
1998 }
1999
HAL_NJPD_SetIBufReadLength(MS_U8 u8Min,MS_U8 u8Max)2000 void HAL_NJPD_SetIBufReadLength(MS_U8 u8Min, MS_U8 u8Max)
2001 {
2002 MS_U16 u16Value;
2003 u16Value = (u8Min<<5) + u8Max;
2004 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
2005 if(eNJPDNum == E_NJPD_NJPD1)
2006 {
2007 u16Value = (u16Value | (__HAL_NJPD_Read2Byte(BK_NJPD1_IBUF_READ_LENGTH) & 0xfc00));
2008 __HAL_NJPD_Write2Byte(BK_NJPD1_IBUF_READ_LENGTH, u16Value);
2009 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetIBufReadLength : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_IBUF_READ_LENGTH));
2010 }
2011 else
2012 {
2013 u16Value = (u16Value | (__HAL_NJPD_Read2Byte(BK_NJPD2_IBUF_READ_LENGTH) & 0xfc00));
2014 __HAL_NJPD_Write2Byte(BK_NJPD2_IBUF_READ_LENGTH, u16Value);
2015 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetIBufReadLength : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_IBUF_READ_LENGTH));
2016 }
2017 }
2018
2019
HAL_NJPD_SetMRBurstThd(MS_U16 u16Value)2020 void HAL_NJPD_SetMRBurstThd(MS_U16 u16Value)
2021 {
2022 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
2023 if(eNJPDNum == E_NJPD_NJPD1)
2024 {
2025 u16Value = (u16Value | (__HAL_NJPD_Read2Byte(BK_NJPD1_MARB_SETTING_04) & 0xffe0));
2026 __HAL_NJPD_Write2Byte(BK_NJPD1_MARB_SETTING_04, u16Value);
2027 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetMARB_SETTING_04 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_SETTING_04));
2028 }
2029 else
2030 {
2031 u16Value = (u16Value | (__HAL_NJPD_Read2Byte(BK_NJPD2_MARB_SETTING_04) & 0xffe0));
2032 __HAL_NJPD_Write2Byte(BK_NJPD2_MARB_SETTING_04, u16Value);
2033 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetMARB_SETTING_04 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_SETTING_04));
2034 }
2035 }
2036
2037
2038
HAL_NJPD_SetCRCReadMode()2039 void HAL_NJPD_SetCRCReadMode()
2040 {
2041 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, 0x200);
2042 if(eNJPDNum == E_NJPD_NJPD1)
2043 {
2044 __HAL_NJPD_Write2Byte(BK_NJPD1_CRC_MODE, 0x200);
2045 }
2046 else
2047 {
2048 __HAL_NJPD_Write2Byte(BK_NJPD2_CRC_MODE, 0x200);
2049 }
2050 }
2051
HAL_NJPD_SetCRCWriteMode()2052 void HAL_NJPD_SetCRCWriteMode()
2053 {
2054 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, 0x300);
2055 if(eNJPDNum == E_NJPD_NJPD1)
2056 {
2057 __HAL_NJPD_Write2Byte(BK_NJPD1_CRC_MODE, 0x300);
2058 }
2059 else
2060 {
2061 __HAL_NJPD_Write2Byte(BK_NJPD2_CRC_MODE, 0x300);
2062 }
2063 }
2064
HAL_NJPD_ResetMarb(void)2065 void HAL_NJPD_ResetMarb(void)
2066 {
2067 NJPD_DEBUG_HAL_MSG("%s\n", __FUNCTION__);
2068 if(eNJPDNum == E_NJPD_NJPD1)
2069 {
2070 NJPD_DEBUG_HAL_MSG("set BK_NJPD1_MARB_RESET to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD1_MARB_RESET) & 0xFE);
2071 __HAL_NJPD_WriteByte(BK_NJPD1_MARB_RESET, __HAL_NJPD_ReadByte(BK_NJPD1_MARB_RESET) & 0xFE);
2072 NJPD_DEBUG_HAL_MSG("set BK_NJPD1_MARB_RESET to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD1_MARB_RESET) | 0x01);
2073 __HAL_NJPD_WriteByte(BK_NJPD1_MARB_RESET, __HAL_NJPD_ReadByte(BK_NJPD1_MARB_RESET) | 0x01);
2074 NJPD_DEBUG_HAL_MSG("set BK_NJPD1_MARB_RESET to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD1_MARB_RESET) & 0xFD);
2075 __HAL_NJPD_WriteByte(BK_NJPD1_MARB_RESET, __HAL_NJPD_ReadByte(BK_NJPD1_MARB_RESET) & 0xFD);
2076 NJPD_DEBUG_HAL_MSG("set BK_NJPD1_MARB_RESET to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD1_MARB_RESET) | 0x02);
2077 __HAL_NJPD_WriteByte(BK_NJPD1_MARB_RESET, __HAL_NJPD_ReadByte(BK_NJPD1_MARB_RESET) | 0x02);
2078 // __HAL_NJPD_WriteByte(BK_NJPD1_MARB_RESET, __HAL_NJPD_ReadByte(BK_NJPD1_MARB_RESET) | 0x12);
2079 // NJPD_DEBUG_HAL_MSG("!!set BK_NJPD1_MARB_RESET to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD1_MARB_RESET));
2080 }
2081 else
2082 {
2083 NJPD_DEBUG_HAL_MSG("set BK_NJPD2_MARB_RESET to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD2_MARB_RESET) & 0xFE);
2084 __HAL_NJPD_WriteByte(BK_NJPD2_MARB_RESET, __HAL_NJPD_ReadByte(BK_NJPD2_MARB_RESET) & 0xFE);
2085 NJPD_DEBUG_HAL_MSG("set BK_NJPD2_MARB_RESET to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD2_MARB_RESET) | 0x01);
2086 __HAL_NJPD_WriteByte(BK_NJPD2_MARB_RESET, __HAL_NJPD_ReadByte(BK_NJPD2_MARB_RESET) | 0x01);
2087 NJPD_DEBUG_HAL_MSG("set BK_NJPD2_MARB_RESET to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD2_MARB_RESET) & 0xFD);
2088 __HAL_NJPD_WriteByte(BK_NJPD2_MARB_RESET, __HAL_NJPD_ReadByte(BK_NJPD2_MARB_RESET) & 0xFD);
2089 NJPD_DEBUG_HAL_MSG("set BK_NJPD2_MARB_RESET to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD2_MARB_RESET) | 0x02);
2090 __HAL_NJPD_WriteByte(BK_NJPD2_MARB_RESET, __HAL_NJPD_ReadByte(BK_NJPD2_MARB_RESET) | 0x02);
2091 // __HAL_NJPD_WriteByte(BK_NJPD2_MARB_RESET, __HAL_NJPD_ReadByte(BK_NJPD2_MARB_RESET) | 0x12);
2092 // NJPD_DEBUG_HAL_MSG("!!set BK_NJPD2_MARB_RESET to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD2_MARB_RESET));
2093 }
2094
2095 }
2096
HAL_NJPD_GetHandshakeCnt()2097 MS_U8 HAL_NJPD_GetHandshakeCnt()
2098 {
2099 MS_U8 u8Cnt;
2100 if(eNJPDNum == E_NJPD_NJPD1)
2101 {
2102 // reg_jpd_handshake_cnt
2103 u8Cnt = (MS_U8)__HAL_NJPD_ReadByte(BK_NJPD1_HANDSHAKE_CNT);
2104 }
2105 else
2106 {
2107 // reg_jpd_handshake_cnt
2108 u8Cnt = (MS_U8)__HAL_NJPD_ReadByte(BK_NJPD2_HANDSHAKE_CNT);
2109 }
2110 return u8Cnt;
2111 }
2112
HAL_NJPD_Handshake_SWRowCountMode(MS_U8 u8Cnt)2113 void HAL_NJPD_Handshake_SWRowCountMode(MS_U8 u8Cnt)
2114 {
2115 NJPD_DEBUG_HAL_MSG("%s() with Count=%d\n", __FUNCTION__, u8Cnt);
2116 if(eNJPDNum == E_NJPD_NJPD1)
2117 {
2118 // reg_jpd_handshake_sw_mode = 1
2119 NJPD_DEBUG_HAL_MSG("set BK_NJPD1_HANDSHAKE to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD1_HANDSHAKE) | 0x04);
2120 __HAL_NJPD_WriteByte(BK_NJPD1_HANDSHAKE, __HAL_NJPD_ReadByte(BK_NJPD1_HANDSHAKE) | 0x04);
2121 // reg_jpd_handshake_en =1
2122 NJPD_DEBUG_HAL_MSG("set BK_NJPD1_HANDSHAKE to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD1_HANDSHAKE) | 0x02);
2123 __HAL_NJPD_WriteByte(BK_NJPD1_HANDSHAKE, __HAL_NJPD_ReadByte(BK_NJPD1_HANDSHAKE) | 0x02);
2124 // reg_jpd_sw_mb_row_cnt
2125 NJPD_DEBUG_HAL_MSG("set BK_NJPD1_SW_MB_ROW_CNT to 0x%02x\n", u8Cnt);
2126 __HAL_NJPD_WriteByte(BK_NJPD1_SW_MB_ROW_CNT, u8Cnt);
2127
2128 // reg_jpd_handshake_sw_woc
2129 HAL_NJPD_SetWriteOneClearReg(NJPD_HANDSHAKE_SW_WOC);
2130 }
2131 else
2132 {
2133 // reg_jpd_handshake_sw_mode = 1
2134 NJPD_DEBUG_HAL_MSG("set BK_NJPD2_HANDSHAKE to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD2_HANDSHAKE) | 0x04);
2135 __HAL_NJPD_WriteByte(BK_NJPD2_HANDSHAKE, __HAL_NJPD_ReadByte(BK_NJPD2_HANDSHAKE) | 0x04);
2136 // reg_jpd_handshake_en =1
2137 NJPD_DEBUG_HAL_MSG("set BK_NJPD2_HANDSHAKE to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD2_HANDSHAKE) | 0x02);
2138 __HAL_NJPD_WriteByte(BK_NJPD2_HANDSHAKE, __HAL_NJPD_ReadByte(BK_NJPD2_HANDSHAKE) | 0x02);
2139 // reg_jpd_sw_mb_row_cnt
2140 NJPD_DEBUG_HAL_MSG("set BK_NJPD2_SW_MB_ROW_CNT to 0x%02x\n", u8Cnt);
2141 __HAL_NJPD_WriteByte(BK_NJPD2_SW_MB_ROW_CNT, u8Cnt);
2142
2143 // reg_jpd_handshake_sw_woc
2144 HAL_NJPD_SetWriteOneClearReg(NJPD_HANDSHAKE_SW_WOC);
2145 }
2146 }
2147
HAL_NJPD_Handshake_HWRowCountMode()2148 void HAL_NJPD_Handshake_HWRowCountMode()
2149 {
2150 NJPD_DEBUG_HAL_MSG("%s()\n", __FUNCTION__);
2151 if(eNJPDNum == E_NJPD_NJPD1)
2152 {
2153 // reset reg_jpd_handshake_cnt_rst
2154 NJPD_DEBUG_HAL_MSG("set BK_NJPD1_HANDSHAKE to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD1_HANDSHAKE) & 0xFE);
2155 __HAL_NJPD_WriteByte(BK_NJPD1_HANDSHAKE, __HAL_NJPD_ReadByte(BK_NJPD1_HANDSHAKE) & 0xFE);
2156 NJPD_DEBUG_HAL_MSG("set BK_NJPD1_HANDSHAKE to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD1_HANDSHAKE) | 0x01);
2157 __HAL_NJPD_WriteByte(BK_NJPD1_HANDSHAKE, __HAL_NJPD_ReadByte(BK_NJPD1_HANDSHAKE) | 0x01);
2158
2159 // reg_jpd_handshake_sw_mode = 0
2160 NJPD_DEBUG_HAL_MSG("set BK_NJPD1_HANDSHAKE to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD1_HANDSHAKE) & 0xFB);
2161 __HAL_NJPD_WriteByte(BK_NJPD1_HANDSHAKE, __HAL_NJPD_ReadByte(BK_NJPD1_HANDSHAKE) & 0xFB);
2162
2163 // reg_jpd_handshake_en =1
2164 NJPD_DEBUG_HAL_MSG("set BK_NJPD1_HANDSHAKE to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD1_HANDSHAKE) | 0x02);
2165 __HAL_NJPD_WriteByte(BK_NJPD1_HANDSHAKE, __HAL_NJPD_ReadByte(BK_NJPD1_HANDSHAKE) | 0x02);
2166 }
2167 else
2168 {
2169 // reset reg_jpd_handshake_cnt_rst
2170 NJPD_DEBUG_HAL_MSG("set BK_NJPD2_HANDSHAKE to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD2_HANDSHAKE) & 0xFE);
2171 __HAL_NJPD_WriteByte(BK_NJPD2_HANDSHAKE, __HAL_NJPD_ReadByte(BK_NJPD2_HANDSHAKE) & 0xFE);
2172 NJPD_DEBUG_HAL_MSG("set BK_NJPD2_HANDSHAKE to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD2_HANDSHAKE) | 0x01);
2173 __HAL_NJPD_WriteByte(BK_NJPD2_HANDSHAKE, __HAL_NJPD_ReadByte(BK_NJPD2_HANDSHAKE) | 0x01);
2174
2175 // reg_jpd_handshake_sw_mode = 0
2176 NJPD_DEBUG_HAL_MSG("set BK_NJPD2_HANDSHAKE to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD2_HANDSHAKE) & 0xFB);
2177 __HAL_NJPD_WriteByte(BK_NJPD2_HANDSHAKE, __HAL_NJPD_ReadByte(BK_NJPD2_HANDSHAKE) & 0xFB);
2178
2179 // reg_jpd_handshake_en =1
2180 NJPD_DEBUG_HAL_MSG("set BK_NJPD2_HANDSHAKE to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD2_HANDSHAKE) | 0x02);
2181 __HAL_NJPD_WriteByte(BK_NJPD2_HANDSHAKE, __HAL_NJPD_ReadByte(BK_NJPD2_HANDSHAKE) | 0x02);
2182 }
2183 }
2184
2185
HAL_NJPD_SetOutputFormat(MS_BOOL bRst,NJPD_OutputFormat eOutputFormat)2186 void HAL_NJPD_SetOutputFormat(MS_BOOL bRst, NJPD_OutputFormat eOutputFormat)
2187 {
2188 switch(eOutputFormat)
2189 {
2190 case E_NJPD_OUTPUT_ORIGINAL:
2191 if(bRst)
2192 {
2193 HAL_NJPD_Set_GlobalSetting00(0);
2194 HAL_NJPD_ResetMarb();
2195 HAL_NJPD_Set_GlobalSetting01(HAL_NJPD_Get_GlobalSetting01()& NJPD_GTABLE_RST);
2196 }
2197 else
2198 {
2199 HAL_NJPD_Set_GlobalSetting00(HAL_NJPD_Get_GlobalSetting00()&0xf3ff);
2200 HAL_NJPD_Set_GlobalSetting01(HAL_NJPD_Get_GlobalSetting01()&0xfcff);
2201 }
2202 break;
2203 case E_NJPD_OUTPUT_YC_SWAP:
2204 if(bRst)
2205 {
2206 HAL_NJPD_Set_GlobalSetting00(NJPD_YC_SWAP);
2207 HAL_NJPD_Set_GlobalSetting01(HAL_NJPD_Get_GlobalSetting01()& NJPD_GTABLE_RST);
2208 }
2209 else
2210 {
2211 HAL_NJPD_Set_GlobalSetting00((HAL_NJPD_Get_GlobalSetting00()&0xf3ff) | NJPD_YC_SWAP);
2212 HAL_NJPD_Set_GlobalSetting01(HAL_NJPD_Get_GlobalSetting01()&0xfcff);
2213 }
2214 break;
2215 case E_NJPD_OUTPUT_UV_SWAP:
2216 if(bRst)
2217 {
2218 HAL_NJPD_Set_GlobalSetting00(NJPD_UV_SWAP);
2219 HAL_NJPD_Set_GlobalSetting01(HAL_NJPD_Get_GlobalSetting01()& NJPD_GTABLE_RST);
2220 }
2221 else
2222 {
2223 HAL_NJPD_Set_GlobalSetting00((HAL_NJPD_Get_GlobalSetting00()&0xf3ff) | NJPD_UV_SWAP);
2224 HAL_NJPD_Set_GlobalSetting01(HAL_NJPD_Get_GlobalSetting01()&0xfcff);
2225 }
2226 break;
2227 case E_NJPD_OUTPUT_UV_7BIT:
2228 if(bRst)
2229 {
2230 HAL_NJPD_Set_GlobalSetting00(0);
2231 // HAL_NJPD_Set_GlobalSetting01(NJPD_UV_7BIT);
2232 HAL_NJPD_Set_GlobalSetting01((HAL_NJPD_Get_GlobalSetting01()& NJPD_GTABLE_RST)|NJPD_UV_7BIT);
2233 }
2234 else
2235 {
2236 HAL_NJPD_Set_GlobalSetting00(HAL_NJPD_Get_GlobalSetting00()&0xf3ff);
2237 HAL_NJPD_Set_GlobalSetting01((HAL_NJPD_Get_GlobalSetting01()&0xfcff) | NJPD_UV_7BIT);
2238 }
2239
2240 break;
2241 case E_NJPD_OUTPUT_UV_MSB:
2242 if(bRst)
2243 {
2244 HAL_NJPD_Set_GlobalSetting00(0);
2245 // HAL_NJPD_Set_GlobalSetting01(NJPD_UV_7BIT | NJPD_UV_MSB);
2246 HAL_NJPD_Set_GlobalSetting01((HAL_NJPD_Get_GlobalSetting01()& NJPD_GTABLE_RST)|(NJPD_UV_7BIT | NJPD_UV_MSB));
2247 }
2248 else
2249 {
2250 HAL_NJPD_Set_GlobalSetting00(HAL_NJPD_Get_GlobalSetting00()&0xf3ff);
2251 HAL_NJPD_Set_GlobalSetting01((HAL_NJPD_Get_GlobalSetting01()&0xfcff) | NJPD_UV_7BIT | NJPD_UV_MSB);
2252 }
2253 break;
2254 }
2255 }
2256
HAL_NJPD_SetMTLBMode(MS_U8 u8MTLB)2257 void HAL_NJPD_SetMTLBMode(MS_U8 u8MTLB)
2258 {
2259 NJPD_DEBUG_HAL_MSG("%s()\n", __FUNCTION__);
2260 if(eNJPDNum == E_NJPD_NJPD1)
2261 {
2262 // set reg_jpd_miu_tlb
2263 NJPD_DEBUG_HAL_MSG("set BK_NJPD1_MIU_TLB to 0x%02x\n", u8MTLB);
2264 __HAL_NJPD_WriteByte(BK_NJPD1_MIU_TLB, u8MTLB);
2265
2266 }
2267 else
2268 {
2269 // set reg_jpd_miu_tlb
2270 NJPD_DEBUG_HAL_MSG("set BK_NJPD2_MIU_TLB to 0x%02x\n", u8MTLB);
2271 __HAL_NJPD_WriteByte(BK_NJPD2_MIU_TLB, u8MTLB);
2272 }
2273 }
2274
HAL_NJPD_SetVerificationMode(NJPD_VerificationMode VerificationMode)2275 void HAL_NJPD_SetVerificationMode(NJPD_VerificationMode VerificationMode)
2276 {
2277 NJPD_DEBUG_HAL_MSG("Set Verification Mode to %x\n", VerificationMode);
2278 eVerificationMode = VerificationMode;
2279 }
2280
HAL_NJPD_GetVerificationMode(void)2281 NJPD_VerificationMode HAL_NJPD_GetVerificationMode(void)
2282 {
2283 return eVerificationMode;
2284 }
2285
HAL_NJPD_Debug(void)2286 void HAL_NJPD_Debug(void)
2287 {
2288 if(eNJPDNum == E_NJPD_NJPD1)
2289 {
2290 NJPD_DEBUG_HAL_MSG("read BK_NJPD1_MARB_CRC_RESULT_0: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_CRC_RESULT_0));
2291 NJPD_DEBUG_HAL_MSG("read BK_NJPD1_MARB_CRC_RESULT_1: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_CRC_RESULT_1));
2292 NJPD_DEBUG_HAL_MSG("read BK_NJPD1_MARB_CRC_RESULT_2: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_CRC_RESULT_2));
2293 NJPD_DEBUG_HAL_MSG("read BK_NJPD1_MARB_CRC_RESULT_3: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_CRC_RESULT_3));
2294 NJPD_DEBUG_HAL_MSG("read BK_NJPD1_GLOBAL_SETTING00: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_GLOBAL_SETTING00));
2295 NJPD_DEBUG_HAL_MSG("read BK_NJPD1_GLOBAL_SETTING01: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_GLOBAL_SETTING01));
2296 NJPD_DEBUG_HAL_MSG("read BK_NJPD1_GLOBAL_SETTING02: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_GLOBAL_SETTING02));
2297 NJPD_DEBUG_HAL_MSG("read BK_NJPD1_MIU_READ_STATUS = 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_READ_STATUS));
2298 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));
2299 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));
2300
2301 MS_U16 u16i;
2302 for(u16i=0; u16i<=0x7b; u16i++)
2303 {
2304 __HAL_NJPD_Write2Byte(BK_NJPD1_DEBUG_BUS_SELECT, u16i);
2305 NJPD_DEBUG_HAL_MSG("BK_NJPD1_DEBUG_BUS[H:L] = [0x%02x][0x%04x:0x%04x]\n", u16i,
2306 __HAL_NJPD_Read2Byte(BK_NJPD1_DEBUG_BUS_H),
2307 __HAL_NJPD_Read2Byte(BK_NJPD1_DEBUG_BUS_L));
2308 }
2309 __HAL_NJPD_Write2Byte(BK_NJPD1_DEBUG_BUS_SELECT, 0xFF);
2310 NJPD_DEBUG_HAL_MSG("BK_NJPD1_DEBUG_BUS[H:L] = [0x%02x][0x%04x:0x%04x]\n", 0xFF,
2311 __HAL_NJPD_Read2Byte(BK_NJPD1_DEBUG_BUS_H),
2312 __HAL_NJPD_Read2Byte(BK_NJPD1_DEBUG_BUS_L));
2313
2314 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2315 NJPD_DEBUG_HAL_MSG("NJPD | 00/08 01/09 02/0A 03/0B 04/0C 05/0D 06/0E 07/0F\n");
2316 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2317 for(u16i=0; u16i<0x80; u16i+=8)
2318 {
2319 NJPD_DEBUG_HAL_MSG("%02x | %04x %04x %04x %04x %04x %04x %04x %04x \n",u16i,
2320 __HAL_NJPD_Read2Byte(BK_NJPD1_GENERAL(u16i)),
2321 __HAL_NJPD_Read2Byte(BK_NJPD1_GENERAL(u16i+1)),
2322 __HAL_NJPD_Read2Byte(BK_NJPD1_GENERAL(u16i+2)),
2323 __HAL_NJPD_Read2Byte(BK_NJPD1_GENERAL(u16i+3)),
2324 __HAL_NJPD_Read2Byte(BK_NJPD1_GENERAL(u16i+4)),
2325 __HAL_NJPD_Read2Byte(BK_NJPD1_GENERAL(u16i+5)),
2326 __HAL_NJPD_Read2Byte(BK_NJPD1_GENERAL(u16i+6)),
2327 __HAL_NJPD_Read2Byte(BK_NJPD1_GENERAL(u16i+7))
2328 );
2329 }
2330 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2331 }
2332 else
2333 {
2334 NJPD_DEBUG_HAL_MSG("read BK_NJPD2_MARB_CRC_RESULT_0: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_CRC_RESULT_0));
2335 NJPD_DEBUG_HAL_MSG("read BK_NJPD2_MARB_CRC_RESULT_1: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_CRC_RESULT_1));
2336 NJPD_DEBUG_HAL_MSG("read BK_NJPD2_MARB_CRC_RESULT_2: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_CRC_RESULT_2));
2337 NJPD_DEBUG_HAL_MSG("read BK_NJPD2_MARB_CRC_RESULT_3: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_CRC_RESULT_3));
2338 NJPD_DEBUG_HAL_MSG("read BK_NJPD2_GLOBAL_SETTING00: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_GLOBAL_SETTING00));
2339 NJPD_DEBUG_HAL_MSG("read BK_NJPD2_GLOBAL_SETTING01: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_GLOBAL_SETTING01));
2340 NJPD_DEBUG_HAL_MSG("read BK_NJPD2_GLOBAL_SETTING02: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_GLOBAL_SETTING02));
2341 NJPD_DEBUG_HAL_MSG("read BK_NJPD2_MIU_READ_STATUS = 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_READ_STATUS));
2342 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));
2343 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));
2344
2345 MS_U16 u16i;
2346 for(u16i=0; u16i<=0x7b; u16i++)
2347 {
2348 __HAL_NJPD_Write2Byte(BK_NJPD2_DEBUG_BUS_SELECT, u16i);
2349 NJPD_DEBUG_HAL_MSG("BK_NJPD2_DEBUG_BUS[H:L] = [0x%02x][0x%04x:0x%04x]\n", u16i,
2350 __HAL_NJPD_Read2Byte(BK_NJPD2_DEBUG_BUS_H),
2351 __HAL_NJPD_Read2Byte(BK_NJPD2_DEBUG_BUS_L));
2352 }
2353 __HAL_NJPD_Write2Byte(BK_NJPD2_DEBUG_BUS_SELECT, 0xFF);
2354 NJPD_DEBUG_HAL_MSG("BK_NJPD2_DEBUG_BUS[H:L] = [0x%02x][0x%04x:0x%04x]\n", 0xFF,
2355 __HAL_NJPD_Read2Byte(BK_NJPD2_DEBUG_BUS_H),
2356 __HAL_NJPD_Read2Byte(BK_NJPD2_DEBUG_BUS_L));
2357
2358 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2359 NJPD_DEBUG_HAL_MSG("NJPD | 00/08 01/09 02/0A 03/0B 04/0C 05/0D 06/0E 07/0F\n");
2360 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2361 for(u16i=0; u16i<0x80; u16i+=8)
2362 {
2363 NJPD_DEBUG_HAL_MSG("%02x | %04x %04x %04x %04x %04x %04x %04x %04x \n",u16i,
2364 __HAL_NJPD_Read2Byte(BK_NJPD2_GENERAL(u16i)),
2365 __HAL_NJPD_Read2Byte(BK_NJPD2_GENERAL(u16i+1)),
2366 __HAL_NJPD_Read2Byte(BK_NJPD2_GENERAL(u16i+2)),
2367 __HAL_NJPD_Read2Byte(BK_NJPD2_GENERAL(u16i+3)),
2368 __HAL_NJPD_Read2Byte(BK_NJPD2_GENERAL(u16i+4)),
2369 __HAL_NJPD_Read2Byte(BK_NJPD2_GENERAL(u16i+5)),
2370 __HAL_NJPD_Read2Byte(BK_NJPD2_GENERAL(u16i+6)),
2371 __HAL_NJPD_Read2Byte(BK_NJPD2_GENERAL(u16i+7))
2372 );
2373 }
2374 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2375 }
2376 MS_U8 u8i;
2377
2378 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2379 NJPD_DEBUG_HAL_MSG("MIU0 | 00/08 01/09 02/0A 03/0B 04/0C 05/0D 06/0E 07/0F\n");
2380 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2381 for(u8i=0; u8i<0x80; u8i+=8)
2382 {
2383 NJPD_DEBUG_HAL_MSG("%02x | %04x %04x %04x %04x %04x %04x %04x %04x \n",u8i,
2384 __HAL_NJPD_Read2Byte(BK_MIU0_GENERAL(u8i)),
2385 __HAL_NJPD_Read2Byte(BK_MIU0_GENERAL(u8i+1)),
2386 __HAL_NJPD_Read2Byte(BK_MIU0_GENERAL(u8i+2)),
2387 __HAL_NJPD_Read2Byte(BK_MIU0_GENERAL(u8i+3)),
2388 __HAL_NJPD_Read2Byte(BK_MIU0_GENERAL(u8i+4)),
2389 __HAL_NJPD_Read2Byte(BK_MIU0_GENERAL(u8i+5)),
2390 __HAL_NJPD_Read2Byte(BK_MIU0_GENERAL(u8i+6)),
2391 __HAL_NJPD_Read2Byte(BK_MIU0_GENERAL(u8i+7))
2392 );
2393 }
2394 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2395
2396 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2397 NJPD_DEBUG_HAL_MSG("MIU1 | 00/08 01/09 02/0A 03/0B 04/0C 05/0D 06/0E 07/0F\n");
2398 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2399 for(u8i=0; u8i<0x80; u8i+=8)
2400 {
2401 NJPD_DEBUG_HAL_MSG("%02x | %04x %04x %04x %04x %04x %04x %04x %04x \n",u8i,
2402 __HAL_NJPD_Read2Byte(BK_MIU1_GENERAL(u8i)),
2403 __HAL_NJPD_Read2Byte(BK_MIU1_GENERAL(u8i+1)),
2404 __HAL_NJPD_Read2Byte(BK_MIU1_GENERAL(u8i+2)),
2405 __HAL_NJPD_Read2Byte(BK_MIU1_GENERAL(u8i+3)),
2406 __HAL_NJPD_Read2Byte(BK_MIU1_GENERAL(u8i+4)),
2407 __HAL_NJPD_Read2Byte(BK_MIU1_GENERAL(u8i+5)),
2408 __HAL_NJPD_Read2Byte(BK_MIU1_GENERAL(u8i+6)),
2409 __HAL_NJPD_Read2Byte(BK_MIU1_GENERAL(u8i+7))
2410 );
2411 }
2412 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2413
2414
2415 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2416 NJPD_DEBUG_HAL_MSG("1608 | 00/08 01/09 02/0A 03/0B 04/0C 05/0D 06/0E 07/0F\n");
2417 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2418 for(u8i=0; u8i<0x80; u8i+=8)
2419 {
2420 NJPD_DEBUG_HAL_MSG("%02x | %04x %04x %04x %04x %04x %04x %04x %04x \n",u8i,
2421 __HAL_NJPD_Read2Byte(BK_1608_GENERAL(u8i)),
2422 __HAL_NJPD_Read2Byte(BK_1608_GENERAL(u8i+1)),
2423 __HAL_NJPD_Read2Byte(BK_1608_GENERAL(u8i+2)),
2424 __HAL_NJPD_Read2Byte(BK_1608_GENERAL(u8i+3)),
2425 __HAL_NJPD_Read2Byte(BK_1608_GENERAL(u8i+4)),
2426 __HAL_NJPD_Read2Byte(BK_1608_GENERAL(u8i+5)),
2427 __HAL_NJPD_Read2Byte(BK_1608_GENERAL(u8i+6)),
2428 __HAL_NJPD_Read2Byte(BK_1608_GENERAL(u8i+7))
2429 );
2430 }
2431 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2432
2433 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2434 NJPD_DEBUG_HAL_MSG("160F | 00/08 01/09 02/0A 03/0B 04/0C 05/0D 06/0E 07/0F\n");
2435 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2436 for(u8i=0; u8i<0x80; u8i+=8)
2437 {
2438 NJPD_DEBUG_HAL_MSG("%02x | %04x %04x %04x %04x %04x %04x %04x %04x \n",u8i,
2439 __HAL_NJPD_Read2Byte(BK_160F_GENERAL(u8i)),
2440 __HAL_NJPD_Read2Byte(BK_160F_GENERAL(u8i+1)),
2441 __HAL_NJPD_Read2Byte(BK_160F_GENERAL(u8i+2)),
2442 __HAL_NJPD_Read2Byte(BK_160F_GENERAL(u8i+3)),
2443 __HAL_NJPD_Read2Byte(BK_160F_GENERAL(u8i+4)),
2444 __HAL_NJPD_Read2Byte(BK_160F_GENERAL(u8i+5)),
2445 __HAL_NJPD_Read2Byte(BK_160F_GENERAL(u8i+6)),
2446 __HAL_NJPD_Read2Byte(BK_160F_GENERAL(u8i+7))
2447 );
2448 }
2449 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2450
2451
2452 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2453 NJPD_DEBUG_HAL_MSG("1615 | 00/08 01/09 02/0A 03/0B 04/0C 05/0D 06/0E 07/0F\n");
2454 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2455 for(u8i=0; u8i<0x80; u8i+=8)
2456 {
2457 NJPD_DEBUG_HAL_MSG("%02x | %04x %04x %04x %04x %04x %04x %04x %04x \n",u8i,
2458 __HAL_NJPD_Read2Byte(BK_1615_GENERAL(u8i)),
2459 __HAL_NJPD_Read2Byte(BK_1615_GENERAL(u8i+1)),
2460 __HAL_NJPD_Read2Byte(BK_1615_GENERAL(u8i+2)),
2461 __HAL_NJPD_Read2Byte(BK_1615_GENERAL(u8i+3)),
2462 __HAL_NJPD_Read2Byte(BK_1615_GENERAL(u8i+4)),
2463 __HAL_NJPD_Read2Byte(BK_1615_GENERAL(u8i+5)),
2464 __HAL_NJPD_Read2Byte(BK_1615_GENERAL(u8i+6)),
2465 __HAL_NJPD_Read2Byte(BK_1615_GENERAL(u8i+7))
2466 );
2467 }
2468 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2469
2470
2471 }
2472
HAL_NJPD_SetNJPDInstance(JPD_Number JPDNum)2473 void HAL_NJPD_SetNJPDInstance(JPD_Number JPDNum)
2474 {
2475 eNJPDNum = JPDNum;
2476 }
2477
HAL_NJPD_IsNeedToPatch(NJPD_PATCH_INDEX eIndex)2478 MS_BOOL HAL_NJPD_IsNeedToPatch(NJPD_PATCH_INDEX eIndex)
2479 {
2480 switch(eIndex)
2481 {
2482 case E_NJPD_MIU_LAST_Z_PATCH:
2483 return FALSE;
2484 break;
2485 case E_NJPD_EAGLE_SW_PATCH:
2486 return FALSE;
2487 break;
2488 default:
2489 break;
2490 }
2491 return FALSE;
2492 }
2493
HAL_NJPD_JPDCount(void)2494 MS_U8 HAL_NJPD_JPDCount(void)
2495 {
2496 return 1;
2497 }
2498