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