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/macan/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 // @20151022, from rik's mail, offset 0x21, bit3
403 __HAL_NJPD_WriteBit(NJPD_MIU_GROUP1_I64, 0, NJPD_MIU0_CLIENT_NJPD_CS3);
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 // Ethan@20150429, I64 : �Qtie��1'b0�F ���ӨS�k��register�U��
421 // __HAL_NJPD_WriteBit(NJPD_MIU_GROUP1_I64, 1, NJPD_MIU0_CLIENT_NJPD_CS3);
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 // Kano@20150326 by Ethan Chang
1224 // 7. let IP to MIU's last signel would trigger down when ready_ack(reg_spare00[7]=1 // When Kano BWP function enable would affect the result
1225
1226 // Nike&Einstein@20130412 by Tony Tseng
1227 // 9. ECO new error concealment(reg_spare00[9]) // Nike have this bit
1228
1229 HAL_NJPD_SetSpare00(0x2FB);
1230
1231 #if 0
1232 MS_U16 u16Value = ((HAL_NJPD_Get_MARB07() & ~NJPD_JPD_MARB_BURST_SPLIT) | 0x0002<<12);
1233 printf("MARB07=0x%x\n", u16Value);
1234 HAL_NJPD_Set_MARB07(u16Value);
1235 #endif
1236 _HAL_NJPD_SetMIUProtectMask(FALSE);
1237
1238 #if ENABLE_TEST_NJPD_18_Ibuf_Burst_Length_Test
1239 HAL_NJPD_SetIBufReadLength(0x15, 0x1a);
1240 #else
1241 if(HAL_NJPD_GetVerificationMode()==E_NJPD18_IBUF_BURST_LENGTH)
1242 {
1243 HAL_NJPD_SetIBufReadLength(0x15, 0x1a);
1244 }
1245 else
1246 {
1247 if(HAL_NJPD_IsNeedToPatch(E_NJPD_EAGLE_SW_PATCH))
1248 {
1249 NJPD_DEBUG_HAL_MSG("EAGLE_SW_PATCH start!!!!!!\n");
1250 HAL_NJPD_SetIBufReadLength(0x1f, 0x1f);
1251 HAL_NJPD_SetMRBurstThd(0x10);
1252 MS_U16 u16Value = (HAL_NJPD_Get_MARB07() | 0xc01f);
1253 NJPD_DEBUG_HAL_MSG("MARB07=0x%x\n", u16Value);
1254 HAL_NJPD_Set_MARB07(u16Value);
1255 NJPD_DEBUG_HAL_MSG("EAGLE_SW_PATCH end!!!!!!\n");
1256 }
1257 else
1258 {
1259 HAL_NJPD_SetIBufReadLength(0x10, 0x1f);
1260 }
1261 }
1262 #endif
1263
1264 #if ENABLE_NJPD_DEBUG_MSG
1265 //HAL_NJPD_SetCRCReadMode();
1266 HAL_NJPD_SetCRCWriteMode();
1267 #else
1268 if(HAL_NJPD_GetVerificationMode()==E_NJPD01_TABLE_READ_WRITE)
1269 {
1270 HAL_NJPD_SetCRCWriteMode();
1271 }
1272 else
1273 {
1274 HAL_NJPD_SetCRCReadMode();
1275 }
1276 #endif
1277 NJPD_DEBUG_HAL_MSG("%s : end!!\n", __FUNCTION__);
1278 }
1279
HAL_NJPD_SetMWBuffLineNum(MS_U16 u16Value)1280 void HAL_NJPD_SetMWBuffLineNum(MS_U16 u16Value)
1281 {
1282 NJPD_DEBUG_HAL_MSG("%s : NOT IMPLEMENTED!!!\n", __FUNCTION__);
1283 UNUSED(u16Value);
1284 }
1285
1286 /******************************************************************************/
1287 ///
1288 ///@param value \b IN
1289 ///@param value \b OUT
1290 ///@return status
1291 /******************************************************************************/
HAL_NJPD_GetCurMRCAddr(void)1292 MS_U32 HAL_NJPD_GetCurMRCAddr(void)
1293 {
1294 MS_U32 curMRCAddr;
1295 if(eNJPDNum == E_NJPD_NJPD1)
1296 {
1297 curMRCAddr = ((__HAL_NJPD_Read2Byte(BK_NJPD1_MIU_READ_POINTER_ADDR_H) << 16) | __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_READ_POINTER_ADDR_L));
1298 }
1299 else
1300 {
1301 curMRCAddr = ((__HAL_NJPD_Read2Byte(BK_NJPD2_MIU_READ_POINTER_ADDR_H) << 16) | __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_READ_POINTER_ADDR_L));
1302 }
1303
1304 return curMRCAddr;
1305 }
1306
1307 /******************************************************************************/
1308 ///
1309 ///@param value \b IN
1310 ///@param value \b OUT
1311 ///@return status
1312 /******************************************************************************/
HAL_NJPD_GetCurRow(void)1313 MS_U16 HAL_NJPD_GetCurRow(void)
1314 {
1315 if(eNJPDNum == E_NJPD_NJPD1)
1316 {
1317 return __HAL_NJPD_Read2Byte(BK_NJPD1_ROW_IDEX);
1318 }
1319 else
1320 {
1321 return __HAL_NJPD_Read2Byte(BK_NJPD2_ROW_IDEX);
1322 }
1323 }
1324
1325 /******************************************************************************/
1326 ///
1327 ///@param value \b IN
1328 ///@param value \b OUT
1329 ///@return status
1330 /******************************************************************************/
HAL_NJPD_GetCurCol(void)1331 MS_U16 HAL_NJPD_GetCurCol(void)
1332 {
1333 if(eNJPDNum == E_NJPD_NJPD1)
1334 {
1335 return __HAL_NJPD_Read2Byte(BK_NJPD1_COLUMN_IDEX);
1336 }
1337 else
1338 {
1339 return __HAL_NJPD_Read2Byte(BK_NJPD2_COLUMN_IDEX);
1340 }
1341 }
1342
HAL_NJPD_SetWriteProtect(MS_BOOL enable)1343 void HAL_NJPD_SetWriteProtect(MS_BOOL enable)
1344 {
1345 NJPD_DEBUG_HAL_MSG("%s : NOT IMPLEMENTED!!!\n", __FUNCTION__);
1346 UNUSED(enable);
1347 }
1348
HAL_NJPD_SetAutoProtect(MS_BOOL enable)1349 void HAL_NJPD_SetAutoProtect(MS_BOOL enable)
1350 {
1351 MS_U16 u16RegValue;
1352 if(eNJPDNum == E_NJPD_NJPD1)
1353 {
1354 u16RegValue = __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_LBOUND_0_H);
1355 u16RegValue &= 0x1FFF;
1356 u16RegValue |= enable<<13;
1357 __HAL_NJPD_Write2Byte(BK_NJPD1_MARB_LBOUND_0_H, u16RegValue);
1358 NJPD_DEBUG_HAL_MSG("%s : 0x%04X\n", __FUNCTION__, __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_LBOUND_0_H));
1359 }
1360 else
1361 {
1362 u16RegValue = __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_LBOUND_0_H);
1363 u16RegValue &= 0x1FFF;
1364 u16RegValue |= enable<<13;
1365 __HAL_NJPD_Write2Byte(BK_NJPD2_MARB_LBOUND_0_H, u16RegValue);
1366 NJPD_DEBUG_HAL_MSG("%s : 0x%04X\n", __FUNCTION__, __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_LBOUND_0_H));
1367 }
1368 }
1369
1370
HAL_NJPD_Set_MARB06(MS_U16 u16Value)1371 void HAL_NJPD_Set_MARB06(MS_U16 u16Value)
1372 {
1373 NJPD_DEBUG_HAL_MSG("%s : 0x%04X\n", __FUNCTION__, u16Value);
1374 if(eNJPDNum == E_NJPD_NJPD1)
1375 {
1376 __HAL_NJPD_Write2Byte(BK_NJPD1_MARB_SETTING_06, u16Value);
1377 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_Get_MARB06 : 0x%04X\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_SETTING_06));
1378 }
1379 else
1380 {
1381 __HAL_NJPD_Write2Byte(BK_NJPD2_MARB_SETTING_06, u16Value);
1382 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_Get_MARB06 : 0x%04X\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_SETTING_06));
1383 }
1384 }
1385
HAL_NJPD_Get_MARB06(void)1386 MS_U16 HAL_NJPD_Get_MARB06(void)
1387 {
1388 if(eNJPDNum == E_NJPD_NJPD1)
1389 {
1390 return __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_SETTING_06);
1391 }
1392 else
1393 {
1394 return __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_SETTING_06);
1395 }
1396 }
1397
HAL_NJPD_Set_MARB07(MS_U16 u16Value)1398 void HAL_NJPD_Set_MARB07(MS_U16 u16Value)
1399 {
1400 NJPD_DEBUG_HAL_MSG("%s : 0x%04X\n", __FUNCTION__, u16Value);
1401 if(eNJPDNum == E_NJPD_NJPD1)
1402 {
1403 __HAL_NJPD_Write2Byte(BK_NJPD1_MARB_SETTING_07, u16Value);
1404 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_Get_MARB07 : 0x%04X\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_SETTING_07));
1405 }
1406 else
1407 {
1408 __HAL_NJPD_Write2Byte(BK_NJPD2_MARB_SETTING_07, u16Value);
1409 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_Get_MARB07 : 0x%04X\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_SETTING_07));
1410 }
1411 }
1412
HAL_NJPD_Get_MARB07(void)1413 MS_U16 HAL_NJPD_Get_MARB07(void)
1414 {
1415 if(eNJPDNum == E_NJPD_NJPD1)
1416 {
1417 return __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_SETTING_07);
1418 }
1419 else
1420 {
1421 return __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_SETTING_07);
1422 }
1423 }
1424
1425
HAL_NJPD_SetWPENUBound_0_L(MS_U16 u16Value)1426 void HAL_NJPD_SetWPENUBound_0_L(MS_U16 u16Value)
1427 {
1428 NJPD_DEBUG_HAL_MSG("%s : 0x%04X\n", __FUNCTION__, u16Value);
1429 if(eNJPDNum == E_NJPD_NJPD1)
1430 {
1431 __HAL_NJPD_Write2Byte(BK_NJPD1_MARB_UBOUND_0_L, u16Value);
1432 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetWPENUBound_0_L : 0x%04X\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_UBOUND_0_L));
1433 }
1434 else
1435 {
1436 __HAL_NJPD_Write2Byte(BK_NJPD2_MARB_UBOUND_0_L, u16Value);
1437 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetWPENUBound_0_L : 0x%04X\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_UBOUND_0_L));
1438 }
1439 }
HAL_NJPD_SetWPENUBound_0_H(MS_U16 u16Value)1440 void HAL_NJPD_SetWPENUBound_0_H(MS_U16 u16Value)
1441 {
1442 NJPD_DEBUG_HAL_MSG("%s : 0x%04X\n", __FUNCTION__, u16Value);
1443 if(eNJPDNum == E_NJPD_NJPD1)
1444 {
1445 __HAL_NJPD_Write2Byte(BK_NJPD1_MARB_UBOUND_0_H, u16Value);
1446 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetWPENUBound_0_H : 0x%04X\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_UBOUND_0_H));
1447 }
1448 else
1449 {
1450 __HAL_NJPD_Write2Byte(BK_NJPD2_MARB_UBOUND_0_H, u16Value);
1451 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetWPENUBound_0_H : 0x%04X\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_UBOUND_0_H));
1452 }
1453 }
HAL_NJPD_SetWPENLBound_0_L(MS_U16 u16Value)1454 void HAL_NJPD_SetWPENLBound_0_L(MS_U16 u16Value)
1455 {
1456 NJPD_DEBUG_HAL_MSG("%s : 0x%04X\n", __FUNCTION__, u16Value);
1457 if(eNJPDNum == E_NJPD_NJPD1)
1458 {
1459 __HAL_NJPD_Write2Byte(BK_NJPD1_MARB_LBOUND_0_L, u16Value);
1460 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetWPENLBound_0_L : 0x%04X\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_LBOUND_0_L));
1461 }
1462 else
1463 {
1464 __HAL_NJPD_Write2Byte(BK_NJPD2_MARB_LBOUND_0_L, u16Value);
1465 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetWPENLBound_0_L : 0x%04X\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_LBOUND_0_L));
1466 }
1467 }
HAL_NJPD_SetWPENLBound_0_H(MS_U16 u16Value)1468 void HAL_NJPD_SetWPENLBound_0_H(MS_U16 u16Value)
1469 {
1470 MS_U16 u16RegValue;
1471 if(eNJPDNum == E_NJPD_NJPD1)
1472 {
1473 u16RegValue = __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_LBOUND_0_H);
1474 u16RegValue &= 0xE000;
1475 u16Value &= 0x1FFF;
1476 u16RegValue |= u16Value;
1477 NJPD_DEBUG_HAL_MSG("%s : 0x%04X\n", __FUNCTION__, u16RegValue);
1478 __HAL_NJPD_Write2Byte(BK_NJPD1_MARB_LBOUND_0_H, u16RegValue);
1479 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetWPENLBound_0_H : 0x%04X\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_LBOUND_0_H));
1480 }
1481 else
1482 {
1483 u16RegValue = __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_LBOUND_0_H);
1484 u16RegValue &= 0xE000;
1485 u16Value &= 0x1FFF;
1486 u16RegValue |= u16Value;
1487 NJPD_DEBUG_HAL_MSG("%s : 0x%04X\n", __FUNCTION__, u16RegValue);
1488 __HAL_NJPD_Write2Byte(BK_NJPD2_MARB_LBOUND_0_H, u16RegValue);
1489 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetWPENLBound_0_H : 0x%04X\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_LBOUND_0_H));
1490 }
1491 }
1492
HAL_NJPD_SetSpare00(MS_U16 u16Value)1493 void HAL_NJPD_SetSpare00(MS_U16 u16Value)
1494 {
1495 // [0]: hw auto detect ffd9 => cannot be used in svld mode, unless the "last buffer" cannot work, do not enable this
1496 // [1]: input buffer bug => always turn on
1497 // [2]: marb bug => always turn on (not used in 2011/12/28 ECO version)
1498 // [3]: bypass marb => 2011/12/28 ECO version
1499
1500 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1501 if(eNJPDNum == E_NJPD_NJPD1)
1502 {
1503 __HAL_NJPD_Write2Byte(BK_NJPD1_SPARE00, u16Value);
1504 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetSpare00 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE00));
1505 }
1506 else
1507 {
1508 __HAL_NJPD_Write2Byte(BK_NJPD2_SPARE00, u16Value);
1509 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetSpare00 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE00));
1510 }
1511 }
HAL_NJPD_GetSpare00(void)1512 MS_U16 HAL_NJPD_GetSpare00(void)
1513 {
1514 if(eNJPDNum == E_NJPD_NJPD1)
1515 {
1516 return __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE00);
1517 }
1518 else
1519 {
1520 return __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE00);
1521 }
1522 }
1523
HAL_NJPD_SetSpare01(MS_U16 u16Value)1524 void HAL_NJPD_SetSpare01(MS_U16 u16Value)
1525 {
1526 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1527 if(eNJPDNum == E_NJPD_NJPD1)
1528 {
1529 __HAL_NJPD_Write2Byte(BK_NJPD1_SPARE01, u16Value);
1530 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetSpare01 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE01));
1531 }
1532 else
1533 {
1534 __HAL_NJPD_Write2Byte(BK_NJPD2_SPARE01, u16Value);
1535 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetSpare01 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE01));
1536 }
1537 }
HAL_NJPD_GetSpare01(void)1538 MS_U16 HAL_NJPD_GetSpare01(void)
1539 {
1540 if(eNJPDNum == E_NJPD_NJPD1)
1541 {
1542 return __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE01);
1543 }
1544 else
1545 {
1546 return __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE01);
1547 }
1548 }
1549
HAL_NJPD_SetSpare02(MS_U16 u16Value)1550 void HAL_NJPD_SetSpare02(MS_U16 u16Value)
1551 {
1552 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1553 if(eNJPDNum == E_NJPD_NJPD1)
1554 {
1555 __HAL_NJPD_Write2Byte(BK_NJPD1_SPARE02, u16Value);
1556 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetSpare02 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE02));
1557 }
1558 else
1559 {
1560 __HAL_NJPD_Write2Byte(BK_NJPD2_SPARE02, u16Value);
1561 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetSpare02 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE02));
1562 }
1563 }
HAL_NJPD_GetSpare02(void)1564 MS_U16 HAL_NJPD_GetSpare02(void)
1565 {
1566 if(eNJPDNum == E_NJPD_NJPD1)
1567 {
1568 return __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE02);
1569 }
1570 else
1571 {
1572 return __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE02);
1573 }
1574 }
1575
HAL_NJPD_SetSpare03(MS_U16 u16Value)1576 void HAL_NJPD_SetSpare03(MS_U16 u16Value)
1577 {
1578 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1579 if(eNJPDNum == E_NJPD_NJPD1)
1580 {
1581 __HAL_NJPD_Write2Byte(BK_NJPD1_SPARE03, u16Value);
1582 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetSpare03 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE03));
1583 }
1584 else
1585 {
1586 __HAL_NJPD_Write2Byte(BK_NJPD2_SPARE03, u16Value);
1587 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetSpare03 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE03));
1588 }
1589 }
HAL_NJPD_GetSpare03(void)1590 MS_U16 HAL_NJPD_GetSpare03(void)
1591 {
1592 if(eNJPDNum == E_NJPD_NJPD1)
1593 {
1594 return __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE03);
1595 }
1596 else
1597 {
1598 return __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE03);
1599 }
1600 }
1601
HAL_NJPD_SetSpare04(MS_U16 u16Value)1602 void HAL_NJPD_SetSpare04(MS_U16 u16Value)
1603 {
1604 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1605 if(eNJPDNum == E_NJPD_NJPD1)
1606 {
1607 __HAL_NJPD_Write2Byte(BK_NJPD1_SPARE04, u16Value);
1608 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetSpare04 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE04));
1609 }
1610 else
1611 {
1612 __HAL_NJPD_Write2Byte(BK_NJPD2_SPARE04, u16Value);
1613 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetSpare04 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE04));
1614 }
1615 }
HAL_NJPD_GetSpare04(void)1616 MS_U16 HAL_NJPD_GetSpare04(void)
1617 {
1618 if(eNJPDNum == E_NJPD_NJPD1)
1619 {
1620 return __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE04);
1621 }
1622 else
1623 {
1624 return __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE04);
1625 }
1626 }
1627
HAL_NJPD_SetSpare05(MS_U16 u16Value)1628 void HAL_NJPD_SetSpare05(MS_U16 u16Value)
1629 {
1630 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1631 if(eNJPDNum == E_NJPD_NJPD1)
1632 {
1633 __HAL_NJPD_Write2Byte(BK_NJPD1_SPARE05, u16Value);
1634 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetSpare05 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE05));
1635 }
1636 else
1637 {
1638 __HAL_NJPD_Write2Byte(BK_NJPD2_SPARE05, u16Value);
1639 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetSpare05 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE05));
1640 }
1641 }
HAL_NJPD_GetSpare05(void)1642 MS_U16 HAL_NJPD_GetSpare05(void)
1643 {
1644 if(eNJPDNum == E_NJPD_NJPD1)
1645 {
1646 return __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE05);
1647 }
1648 else
1649 {
1650 return __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE05);
1651 }
1652 }
1653
HAL_NJPD_SetSpare06(MS_U16 u16Value)1654 void HAL_NJPD_SetSpare06(MS_U16 u16Value)
1655 {
1656 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1657 if(eNJPDNum == E_NJPD_NJPD1)
1658 {
1659 __HAL_NJPD_Write2Byte(BK_NJPD1_SPARE06, u16Value);
1660 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetSpare06 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE06));
1661 }
1662 else
1663 {
1664 __HAL_NJPD_Write2Byte(BK_NJPD2_SPARE06, u16Value);
1665 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetSpare06 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE06));
1666 }
1667 }
HAL_NJPD_GetSpare06(void)1668 MS_U16 HAL_NJPD_GetSpare06(void)
1669 {
1670 if(eNJPDNum == E_NJPD_NJPD1)
1671 {
1672 return __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE06);
1673 }
1674 else
1675 {
1676 return __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE06);
1677 }
1678 }
1679
HAL_NJPD_SetSpare07(MS_U16 u16Value)1680 void HAL_NJPD_SetSpare07(MS_U16 u16Value)
1681 {
1682 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1683 if(eNJPDNum == E_NJPD_NJPD1)
1684 {
1685 __HAL_NJPD_Write2Byte(BK_NJPD1_SPARE07, u16Value);
1686 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetSpare07 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE07));
1687 }
1688 else
1689 {
1690 __HAL_NJPD_Write2Byte(BK_NJPD2_SPARE07, u16Value);
1691 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetSpare07 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE07));
1692 }
1693 }
HAL_NJPD_GetSpare07(void)1694 MS_U16 HAL_NJPD_GetSpare07(void)
1695 {
1696 if(eNJPDNum == E_NJPD_NJPD1)
1697 {
1698 return __HAL_NJPD_Read2Byte(BK_NJPD1_SPARE07);
1699 }
1700 else
1701 {
1702 return __HAL_NJPD_Read2Byte(BK_NJPD2_SPARE07);
1703 }
1704 }
1705
HAL_NJPD_SetWriteOneClearReg(MS_U16 u16Value)1706 void HAL_NJPD_SetWriteOneClearReg(MS_U16 u16Value)
1707 {
1708 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1709 if(eNJPDNum == E_NJPD_NJPD1)
1710 {
1711 __HAL_NJPD_Write2Byte(BK_NJPD1_WRITE_ONE_CLEAR, u16Value);
1712 }
1713 else
1714 {
1715 __HAL_NJPD_Write2Byte(BK_NJPD2_WRITE_ONE_CLEAR, u16Value);
1716 }
1717 }
1718
HAL_NJPD_SetWriteOneClearReg_2(MS_U16 u16Value)1719 void HAL_NJPD_SetWriteOneClearReg_2(MS_U16 u16Value)
1720 {
1721 // for convience, not to print any message in this function
1722 if(eNJPDNum == E_NJPD_NJPD1)
1723 {
1724 __HAL_NJPD_Write2Byte(BK_NJPD1_WRITE_ONE_CLEAR, u16Value);
1725 }
1726 else
1727 {
1728 __HAL_NJPD_Write2Byte(BK_NJPD2_WRITE_ONE_CLEAR, u16Value);
1729 }
1730 }
1731
HAL_NJPD_GetWriteOneClearReg(void)1732 MS_U16 HAL_NJPD_GetWriteOneClearReg(void)
1733 {
1734 if(eNJPDNum == E_NJPD_NJPD1)
1735 {
1736 return __HAL_NJPD_Read2Byte(BK_NJPD1_WRITE_ONE_CLEAR);
1737 }
1738 else
1739 {
1740 return __HAL_NJPD_Read2Byte(BK_NJPD2_WRITE_ONE_CLEAR);
1741 }
1742 }
1743
HAL_NJPD_SetHTableStart_Low(MS_U16 u16Value)1744 void HAL_NJPD_SetHTableStart_Low(MS_U16 u16Value)
1745 {
1746 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1747 if(eNJPDNum == E_NJPD_NJPD1)
1748 {
1749 __HAL_NJPD_Write2Byte(BK_NJPD1_MIU_HTABLE_START_ADDR_L, u16Value);
1750 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetHTableStart_Low : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_HTABLE_START_ADDR_L));
1751 }
1752 else
1753 {
1754 __HAL_NJPD_Write2Byte(BK_NJPD2_MIU_HTABLE_START_ADDR_L, u16Value);
1755 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetHTableStart_Low : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_HTABLE_START_ADDR_L));
1756 }
1757 }
1758
HAL_NJPD_SetHTableStart_High(MS_U16 u16Value)1759 void HAL_NJPD_SetHTableStart_High(MS_U16 u16Value)
1760 {
1761 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1762 if(eNJPDNum == E_NJPD_NJPD1)
1763 {
1764 __HAL_NJPD_Write2Byte(BK_NJPD1_MIU_HTABLE_START_ADDR_H, u16Value);
1765 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetHTableStart_High : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_HTABLE_START_ADDR_H));
1766 }
1767 else
1768 {
1769 __HAL_NJPD_Write2Byte(BK_NJPD2_MIU_HTABLE_START_ADDR_H, u16Value);
1770 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetHTableStart_High : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_HTABLE_START_ADDR_H));
1771 }
1772 }
1773
HAL_NJPD_SetQTableStart_Low(MS_U16 u16Value)1774 void HAL_NJPD_SetQTableStart_Low(MS_U16 u16Value)
1775 {
1776 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1777 if(eNJPDNum == E_NJPD_NJPD1)
1778 {
1779 __HAL_NJPD_Write2Byte(BK_NJPD1_MIU_QTABLE_START_ADDR_L, u16Value);
1780 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetQTableStart_Low : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_QTABLE_START_ADDR_L));
1781 }
1782 else
1783 {
1784 __HAL_NJPD_Write2Byte(BK_NJPD2_MIU_QTABLE_START_ADDR_L, u16Value);
1785 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetQTableStart_Low : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_QTABLE_START_ADDR_L));
1786 }
1787 }
1788
HAL_NJPD_SetQTableStart_High(MS_U16 u16Value)1789 void HAL_NJPD_SetQTableStart_High(MS_U16 u16Value)
1790 {
1791 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1792 if(eNJPDNum == E_NJPD_NJPD1)
1793 {
1794 __HAL_NJPD_Write2Byte(BK_NJPD1_MIU_QTABLE_START_ADDR_H, u16Value);
1795 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetQTableStart_High : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_QTABLE_START_ADDR_H));
1796 }
1797 else
1798 {
1799 __HAL_NJPD_Write2Byte(BK_NJPD2_MIU_QTABLE_START_ADDR_H, u16Value);
1800 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetQTableStart_High : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_QTABLE_START_ADDR_H));
1801 }
1802 }
1803
HAL_NJPD_SetGTableStart_Low(MS_U16 u16Value)1804 void HAL_NJPD_SetGTableStart_Low(MS_U16 u16Value)
1805 {
1806 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1807 if(eNJPDNum == E_NJPD_NJPD1)
1808 {
1809 __HAL_NJPD_Write2Byte(BK_NJPD1_MIU_GTABLE_START_ADDR_L, u16Value);
1810 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetGTableStart_Low : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_GTABLE_START_ADDR_L));
1811 }
1812 else
1813 {
1814 __HAL_NJPD_Write2Byte(BK_NJPD2_MIU_GTABLE_START_ADDR_L, u16Value);
1815 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetGTableStart_Low : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_GTABLE_START_ADDR_L));
1816 }
1817 }
1818
HAL_NJPD_SetGTableStart_High(MS_U16 u16Value)1819 void HAL_NJPD_SetGTableStart_High(MS_U16 u16Value)
1820 {
1821 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1822 if(eNJPDNum == E_NJPD_NJPD1)
1823 {
1824 __HAL_NJPD_Write2Byte(BK_NJPD1_MIU_GTABLE_START_ADDR_H, u16Value);
1825 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetGTableStart_High : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_GTABLE_START_ADDR_H));
1826 }
1827 else
1828 {
1829 __HAL_NJPD_Write2Byte(BK_NJPD2_MIU_GTABLE_START_ADDR_H, u16Value);
1830 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetGTableStart_High : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_GTABLE_START_ADDR_H));
1831 }
1832 }
1833
HAL_NJPD_SetHTableSize(MS_U16 u16Value)1834 void HAL_NJPD_SetHTableSize(MS_U16 u16Value)
1835 {
1836 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1837 u16Value &=0x00FF;
1838 if(eNJPDNum == E_NJPD_NJPD1)
1839 {
1840 __HAL_NJPD_Write2Byte(BK_NJPD1_MIU_HTABLE_SIZE, u16Value);
1841 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetHTableSize : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_HTABLE_SIZE));
1842 }
1843 else
1844 {
1845 __HAL_NJPD_Write2Byte(BK_NJPD2_MIU_HTABLE_SIZE, u16Value);
1846 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetHTableSize : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_HTABLE_SIZE));
1847 }
1848 }
1849
HAL_NJPD_GetHTableSize()1850 MS_U16 HAL_NJPD_GetHTableSize()
1851 {
1852 if(eNJPDNum == E_NJPD_NJPD1)
1853 {
1854 return __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_HTABLE_SIZE);
1855 }
1856 else
1857 {
1858 return __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_HTABLE_SIZE);
1859 }
1860 }
HAL_NJPD_SetRIUInterface(MS_U16 u16Value)1861 void HAL_NJPD_SetRIUInterface(MS_U16 u16Value)
1862 {
1863 // NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1864 if(eNJPDNum == E_NJPD_NJPD1)
1865 {
1866 __HAL_NJPD_Write2Byte(BK_NJPD1_TBC, u16Value);
1867 // NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetRIUInterface : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_TBC));
1868 }
1869 else
1870 {
1871 __HAL_NJPD_Write2Byte(BK_NJPD2_TBC, u16Value);
1872 // NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetRIUInterface : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_TBC));
1873 }
1874 }
1875
HAL_NJPD_GetRIUInterface(void)1876 MS_U16 HAL_NJPD_GetRIUInterface(void)
1877 {
1878 if(eNJPDNum == E_NJPD_NJPD1)
1879 {
1880 return __HAL_NJPD_Read2Byte(BK_NJPD1_TBC);
1881 }
1882 else
1883 {
1884 return __HAL_NJPD_Read2Byte(BK_NJPD2_TBC);
1885 }
1886 }
1887
HAL_NJPD_TBCReadData_L()1888 MS_U16 HAL_NJPD_TBCReadData_L()
1889 {
1890 if(eNJPDNum == E_NJPD_NJPD1)
1891 {
1892 return __HAL_NJPD_Read2Byte(BK_NJPD1_TBC_RDATA_L);
1893 }
1894 else
1895 {
1896 return __HAL_NJPD_Read2Byte(BK_NJPD2_TBC_RDATA_L);
1897 }
1898 }
1899
HAL_NJPD_TBCReadData_H()1900 MS_U16 HAL_NJPD_TBCReadData_H()
1901 {
1902 if(eNJPDNum == E_NJPD_NJPD1)
1903 {
1904 return __HAL_NJPD_Read2Byte(BK_NJPD1_TBC_RDATA_H);
1905 }
1906 else
1907 {
1908 return __HAL_NJPD_Read2Byte(BK_NJPD2_TBC_RDATA_H);
1909 }
1910 }
1911
HAL_NJPD_SetIBufReadLength(MS_U8 u8Min,MS_U8 u8Max)1912 void HAL_NJPD_SetIBufReadLength(MS_U8 u8Min, MS_U8 u8Max)
1913 {
1914 MS_U16 u16Value;
1915 u16Value = (u8Min<<5) + u8Max;
1916 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1917 if(eNJPDNum == E_NJPD_NJPD1)
1918 {
1919 u16Value = (u16Value | (__HAL_NJPD_Read2Byte(BK_NJPD1_IBUF_READ_LENGTH) & 0xfc00));
1920 __HAL_NJPD_Write2Byte(BK_NJPD1_IBUF_READ_LENGTH, u16Value);
1921 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetIBufReadLength : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_IBUF_READ_LENGTH));
1922 }
1923 else
1924 {
1925 u16Value = (u16Value | (__HAL_NJPD_Read2Byte(BK_NJPD2_IBUF_READ_LENGTH) & 0xfc00));
1926 __HAL_NJPD_Write2Byte(BK_NJPD2_IBUF_READ_LENGTH, u16Value);
1927 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetIBufReadLength : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_IBUF_READ_LENGTH));
1928 }
1929 }
1930
1931
HAL_NJPD_SetMRBurstThd(MS_U16 u16Value)1932 void HAL_NJPD_SetMRBurstThd(MS_U16 u16Value)
1933 {
1934 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, u16Value);
1935 if(eNJPDNum == E_NJPD_NJPD1)
1936 {
1937 u16Value = (u16Value | (__HAL_NJPD_Read2Byte(BK_NJPD1_MARB_SETTING_04) & 0xffe0));
1938 __HAL_NJPD_Write2Byte(BK_NJPD1_MARB_SETTING_04, u16Value);
1939 NJPD_DEBUG_HAL_MSG("HAL_NJPD1_GetMARB_SETTING_04 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_SETTING_04));
1940 }
1941 else
1942 {
1943 u16Value = (u16Value | (__HAL_NJPD_Read2Byte(BK_NJPD2_MARB_SETTING_04) & 0xffe0));
1944 __HAL_NJPD_Write2Byte(BK_NJPD2_MARB_SETTING_04, u16Value);
1945 NJPD_DEBUG_HAL_MSG("HAL_NJPD2_GetMARB_SETTING_04 : 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_SETTING_04));
1946 }
1947 }
1948
1949
1950
HAL_NJPD_SetCRCReadMode()1951 void HAL_NJPD_SetCRCReadMode()
1952 {
1953 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, 0x200);
1954 if(eNJPDNum == E_NJPD_NJPD1)
1955 {
1956 __HAL_NJPD_Write2Byte(BK_NJPD1_CRC_MODE, 0x200);
1957 }
1958 else
1959 {
1960 __HAL_NJPD_Write2Byte(BK_NJPD2_CRC_MODE, 0x200);
1961 }
1962 }
1963
HAL_NJPD_SetCRCWriteMode()1964 void HAL_NJPD_SetCRCWriteMode()
1965 {
1966 NJPD_DEBUG_HAL_MSG("%s : 0x%04x\n", __FUNCTION__, 0x300);
1967 if(eNJPDNum == E_NJPD_NJPD1)
1968 {
1969 __HAL_NJPD_Write2Byte(BK_NJPD1_CRC_MODE, 0x300);
1970 }
1971 else
1972 {
1973 __HAL_NJPD_Write2Byte(BK_NJPD2_CRC_MODE, 0x300);
1974 }
1975 }
1976
HAL_NJPD_ResetMarb(void)1977 void HAL_NJPD_ResetMarb(void)
1978 {
1979 NJPD_DEBUG_HAL_MSG("%s\n", __FUNCTION__);
1980 if(eNJPDNum == E_NJPD_NJPD1)
1981 {
1982 NJPD_DEBUG_HAL_MSG("set BK_NJPD1_MARB_RESET to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD1_MARB_RESET) & 0xFE);
1983 __HAL_NJPD_WriteByte(BK_NJPD1_MARB_RESET, __HAL_NJPD_ReadByte(BK_NJPD1_MARB_RESET) & 0xFE);
1984 NJPD_DEBUG_HAL_MSG("set BK_NJPD1_MARB_RESET to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD1_MARB_RESET) | 0x01);
1985 __HAL_NJPD_WriteByte(BK_NJPD1_MARB_RESET, __HAL_NJPD_ReadByte(BK_NJPD1_MARB_RESET) | 0x01);
1986 NJPD_DEBUG_HAL_MSG("set BK_NJPD1_MARB_RESET to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD1_MARB_RESET) & 0xFD);
1987 __HAL_NJPD_WriteByte(BK_NJPD1_MARB_RESET, __HAL_NJPD_ReadByte(BK_NJPD1_MARB_RESET) & 0xFD);
1988 NJPD_DEBUG_HAL_MSG("set BK_NJPD1_MARB_RESET to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD1_MARB_RESET) | 0x02);
1989 __HAL_NJPD_WriteByte(BK_NJPD1_MARB_RESET, __HAL_NJPD_ReadByte(BK_NJPD1_MARB_RESET) | 0x02);
1990 // __HAL_NJPD_WriteByte(BK_NJPD1_MARB_RESET, __HAL_NJPD_ReadByte(BK_NJPD1_MARB_RESET) | 0x12);
1991 // NJPD_DEBUG_HAL_MSG("!!set BK_NJPD1_MARB_RESET to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD1_MARB_RESET));
1992 }
1993 else
1994 {
1995 NJPD_DEBUG_HAL_MSG("set BK_NJPD2_MARB_RESET to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD2_MARB_RESET) & 0xFE);
1996 __HAL_NJPD_WriteByte(BK_NJPD2_MARB_RESET, __HAL_NJPD_ReadByte(BK_NJPD2_MARB_RESET) & 0xFE);
1997 NJPD_DEBUG_HAL_MSG("set BK_NJPD2_MARB_RESET to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD2_MARB_RESET) | 0x01);
1998 __HAL_NJPD_WriteByte(BK_NJPD2_MARB_RESET, __HAL_NJPD_ReadByte(BK_NJPD2_MARB_RESET) | 0x01);
1999 NJPD_DEBUG_HAL_MSG("set BK_NJPD2_MARB_RESET to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD2_MARB_RESET) & 0xFD);
2000 __HAL_NJPD_WriteByte(BK_NJPD2_MARB_RESET, __HAL_NJPD_ReadByte(BK_NJPD2_MARB_RESET) & 0xFD);
2001 NJPD_DEBUG_HAL_MSG("set BK_NJPD2_MARB_RESET to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD2_MARB_RESET) | 0x02);
2002 __HAL_NJPD_WriteByte(BK_NJPD2_MARB_RESET, __HAL_NJPD_ReadByte(BK_NJPD2_MARB_RESET) | 0x02);
2003 // __HAL_NJPD_WriteByte(BK_NJPD2_MARB_RESET, __HAL_NJPD_ReadByte(BK_NJPD2_MARB_RESET) | 0x12);
2004 // NJPD_DEBUG_HAL_MSG("!!set BK_NJPD2_MARB_RESET to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD2_MARB_RESET));
2005 }
2006
2007 }
2008
HAL_NJPD_GetHandshakeCnt()2009 MS_U8 HAL_NJPD_GetHandshakeCnt()
2010 {
2011 MS_U8 u8Cnt;
2012 if(eNJPDNum == E_NJPD_NJPD1)
2013 {
2014 // reg_jpd_handshake_cnt
2015 u8Cnt = (MS_U8)__HAL_NJPD_ReadByte(BK_NJPD1_HANDSHAKE_CNT);
2016 }
2017 else
2018 {
2019 // reg_jpd_handshake_cnt
2020 u8Cnt = (MS_U8)__HAL_NJPD_ReadByte(BK_NJPD2_HANDSHAKE_CNT);
2021 }
2022 return u8Cnt;
2023 }
2024
HAL_NJPD_Handshake_SWRowCountMode(MS_U8 u8Cnt)2025 void HAL_NJPD_Handshake_SWRowCountMode(MS_U8 u8Cnt)
2026 {
2027 NJPD_DEBUG_HAL_MSG("%s() with Count=%d\n", __FUNCTION__, u8Cnt);
2028 if(eNJPDNum == E_NJPD_NJPD1)
2029 {
2030 // reg_jpd_handshake_sw_mode = 1
2031 NJPD_DEBUG_HAL_MSG("set BK_NJPD1_HANDSHAKE to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD1_HANDSHAKE) | 0x04);
2032 __HAL_NJPD_WriteByte(BK_NJPD1_HANDSHAKE, __HAL_NJPD_ReadByte(BK_NJPD1_HANDSHAKE) | 0x04);
2033 // reg_jpd_handshake_en =1
2034 NJPD_DEBUG_HAL_MSG("set BK_NJPD1_HANDSHAKE to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD1_HANDSHAKE) | 0x02);
2035 __HAL_NJPD_WriteByte(BK_NJPD1_HANDSHAKE, __HAL_NJPD_ReadByte(BK_NJPD1_HANDSHAKE) | 0x02);
2036 // reg_jpd_sw_mb_row_cnt
2037 NJPD_DEBUG_HAL_MSG("set BK_NJPD1_SW_MB_ROW_CNT to 0x%02x\n", u8Cnt);
2038 __HAL_NJPD_WriteByte(BK_NJPD1_SW_MB_ROW_CNT, u8Cnt);
2039
2040 // reg_jpd_handshake_sw_woc
2041 HAL_NJPD_SetWriteOneClearReg(NJPD_HANDSHAKE_SW_WOC);
2042 }
2043 else
2044 {
2045 // reg_jpd_handshake_sw_mode = 1
2046 NJPD_DEBUG_HAL_MSG("set BK_NJPD2_HANDSHAKE to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD2_HANDSHAKE) | 0x04);
2047 __HAL_NJPD_WriteByte(BK_NJPD2_HANDSHAKE, __HAL_NJPD_ReadByte(BK_NJPD2_HANDSHAKE) | 0x04);
2048 // reg_jpd_handshake_en =1
2049 NJPD_DEBUG_HAL_MSG("set BK_NJPD2_HANDSHAKE to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD2_HANDSHAKE) | 0x02);
2050 __HAL_NJPD_WriteByte(BK_NJPD2_HANDSHAKE, __HAL_NJPD_ReadByte(BK_NJPD2_HANDSHAKE) | 0x02);
2051 // reg_jpd_sw_mb_row_cnt
2052 NJPD_DEBUG_HAL_MSG("set BK_NJPD2_SW_MB_ROW_CNT to 0x%02x\n", u8Cnt);
2053 __HAL_NJPD_WriteByte(BK_NJPD2_SW_MB_ROW_CNT, u8Cnt);
2054
2055 // reg_jpd_handshake_sw_woc
2056 HAL_NJPD_SetWriteOneClearReg(NJPD_HANDSHAKE_SW_WOC);
2057 }
2058 }
2059
HAL_NJPD_Handshake_HWRowCountMode()2060 void HAL_NJPD_Handshake_HWRowCountMode()
2061 {
2062 NJPD_DEBUG_HAL_MSG("%s()\n", __FUNCTION__);
2063 if(eNJPDNum == E_NJPD_NJPD1)
2064 {
2065 // reset reg_jpd_handshake_cnt_rst
2066 NJPD_DEBUG_HAL_MSG("set BK_NJPD1_HANDSHAKE to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD1_HANDSHAKE) & 0xFE);
2067 __HAL_NJPD_WriteByte(BK_NJPD1_HANDSHAKE, __HAL_NJPD_ReadByte(BK_NJPD1_HANDSHAKE) & 0xFE);
2068 NJPD_DEBUG_HAL_MSG("set BK_NJPD1_HANDSHAKE to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD1_HANDSHAKE) | 0x01);
2069 __HAL_NJPD_WriteByte(BK_NJPD1_HANDSHAKE, __HAL_NJPD_ReadByte(BK_NJPD1_HANDSHAKE) | 0x01);
2070
2071 // reg_jpd_handshake_sw_mode = 0
2072 NJPD_DEBUG_HAL_MSG("set BK_NJPD1_HANDSHAKE to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD1_HANDSHAKE) & 0xFB);
2073 __HAL_NJPD_WriteByte(BK_NJPD1_HANDSHAKE, __HAL_NJPD_ReadByte(BK_NJPD1_HANDSHAKE) & 0xFB);
2074
2075 // reg_jpd_handshake_en =1
2076 NJPD_DEBUG_HAL_MSG("set BK_NJPD1_HANDSHAKE to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD1_HANDSHAKE) | 0x02);
2077 __HAL_NJPD_WriteByte(BK_NJPD1_HANDSHAKE, __HAL_NJPD_ReadByte(BK_NJPD1_HANDSHAKE) | 0x02);
2078 }
2079 else
2080 {
2081 // reset reg_jpd_handshake_cnt_rst
2082 NJPD_DEBUG_HAL_MSG("set BK_NJPD2_HANDSHAKE to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD2_HANDSHAKE) & 0xFE);
2083 __HAL_NJPD_WriteByte(BK_NJPD2_HANDSHAKE, __HAL_NJPD_ReadByte(BK_NJPD2_HANDSHAKE) & 0xFE);
2084 NJPD_DEBUG_HAL_MSG("set BK_NJPD2_HANDSHAKE to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD2_HANDSHAKE) | 0x01);
2085 __HAL_NJPD_WriteByte(BK_NJPD2_HANDSHAKE, __HAL_NJPD_ReadByte(BK_NJPD2_HANDSHAKE) | 0x01);
2086
2087 // reg_jpd_handshake_sw_mode = 0
2088 NJPD_DEBUG_HAL_MSG("set BK_NJPD2_HANDSHAKE to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD2_HANDSHAKE) & 0xFB);
2089 __HAL_NJPD_WriteByte(BK_NJPD2_HANDSHAKE, __HAL_NJPD_ReadByte(BK_NJPD2_HANDSHAKE) & 0xFB);
2090
2091 // reg_jpd_handshake_en =1
2092 NJPD_DEBUG_HAL_MSG("set BK_NJPD2_HANDSHAKE to 0x%02x\n", __HAL_NJPD_ReadByte(BK_NJPD2_HANDSHAKE) | 0x02);
2093 __HAL_NJPD_WriteByte(BK_NJPD2_HANDSHAKE, __HAL_NJPD_ReadByte(BK_NJPD2_HANDSHAKE) | 0x02);
2094 }
2095 }
2096
2097
HAL_NJPD_SetOutputFormat(MS_BOOL bRst,NJPD_OutputFormat eOutputFormat)2098 void HAL_NJPD_SetOutputFormat(MS_BOOL bRst, NJPD_OutputFormat eOutputFormat)
2099 {
2100 switch(eOutputFormat)
2101 {
2102 case E_NJPD_OUTPUT_ORIGINAL:
2103 if(bRst)
2104 {
2105 HAL_NJPD_Set_GlobalSetting00(0);
2106 HAL_NJPD_ResetMarb();
2107 HAL_NJPD_Set_GlobalSetting01(HAL_NJPD_Get_GlobalSetting01()& NJPD_GTABLE_RST);
2108 }
2109 else
2110 {
2111 HAL_NJPD_Set_GlobalSetting00(HAL_NJPD_Get_GlobalSetting00()&0xf3ff);
2112 HAL_NJPD_Set_GlobalSetting01(HAL_NJPD_Get_GlobalSetting01()&0xfcff);
2113 }
2114 break;
2115 case E_NJPD_OUTPUT_YC_SWAP:
2116 if(bRst)
2117 {
2118 HAL_NJPD_Set_GlobalSetting00(NJPD_YC_SWAP);
2119 HAL_NJPD_Set_GlobalSetting01(HAL_NJPD_Get_GlobalSetting01()& NJPD_GTABLE_RST);
2120 }
2121 else
2122 {
2123 HAL_NJPD_Set_GlobalSetting00((HAL_NJPD_Get_GlobalSetting00()&0xf3ff) | NJPD_YC_SWAP);
2124 HAL_NJPD_Set_GlobalSetting01(HAL_NJPD_Get_GlobalSetting01()&0xfcff);
2125 }
2126 break;
2127 case E_NJPD_OUTPUT_UV_SWAP:
2128 if(bRst)
2129 {
2130 HAL_NJPD_Set_GlobalSetting00(NJPD_UV_SWAP);
2131 HAL_NJPD_Set_GlobalSetting01(HAL_NJPD_Get_GlobalSetting01()& NJPD_GTABLE_RST);
2132 }
2133 else
2134 {
2135 HAL_NJPD_Set_GlobalSetting00((HAL_NJPD_Get_GlobalSetting00()&0xf3ff) | NJPD_UV_SWAP);
2136 HAL_NJPD_Set_GlobalSetting01(HAL_NJPD_Get_GlobalSetting01()&0xfcff);
2137 }
2138 break;
2139 case E_NJPD_OUTPUT_UV_7BIT:
2140 if(bRst)
2141 {
2142 HAL_NJPD_Set_GlobalSetting00(0);
2143 // HAL_NJPD_Set_GlobalSetting01(NJPD_UV_7BIT);
2144 HAL_NJPD_Set_GlobalSetting01((HAL_NJPD_Get_GlobalSetting01()& NJPD_GTABLE_RST)|NJPD_UV_7BIT);
2145 }
2146 else
2147 {
2148 HAL_NJPD_Set_GlobalSetting00(HAL_NJPD_Get_GlobalSetting00()&0xf3ff);
2149 HAL_NJPD_Set_GlobalSetting01((HAL_NJPD_Get_GlobalSetting01()&0xfcff) | NJPD_UV_7BIT);
2150 }
2151
2152 break;
2153 case E_NJPD_OUTPUT_UV_MSB:
2154 if(bRst)
2155 {
2156 HAL_NJPD_Set_GlobalSetting00(0);
2157 // HAL_NJPD_Set_GlobalSetting01(NJPD_UV_7BIT | NJPD_UV_MSB);
2158 HAL_NJPD_Set_GlobalSetting01((HAL_NJPD_Get_GlobalSetting01()& NJPD_GTABLE_RST)|(NJPD_UV_7BIT | NJPD_UV_MSB));
2159 }
2160 else
2161 {
2162 HAL_NJPD_Set_GlobalSetting00(HAL_NJPD_Get_GlobalSetting00()&0xf3ff);
2163 HAL_NJPD_Set_GlobalSetting01((HAL_NJPD_Get_GlobalSetting01()&0xfcff) | NJPD_UV_7BIT | NJPD_UV_MSB);
2164 }
2165 break;
2166 }
2167 }
2168
HAL_NJPD_SetMTLBMode(MS_U8 u8MTLB)2169 void HAL_NJPD_SetMTLBMode(MS_U8 u8MTLB)
2170 {
2171 NJPD_DEBUG_HAL_MSG("%s()\n", __FUNCTION__);
2172 if(eNJPDNum == E_NJPD_NJPD1)
2173 {
2174 // set reg_jpd_miu_tlb
2175 NJPD_DEBUG_HAL_MSG("set BK_NJPD1_MIU_TLB to 0x%02x\n", u8MTLB);
2176 __HAL_NJPD_WriteByte(BK_NJPD1_MIU_TLB, u8MTLB);
2177
2178 }
2179 else
2180 {
2181 // set reg_jpd_miu_tlb
2182 NJPD_DEBUG_HAL_MSG("set BK_NJPD2_MIU_TLB to 0x%02x\n", u8MTLB);
2183 __HAL_NJPD_WriteByte(BK_NJPD2_MIU_TLB, u8MTLB);
2184 }
2185 }
2186
HAL_NJPD_SetVerificationMode(NJPD_VerificationMode VerificationMode)2187 void HAL_NJPD_SetVerificationMode(NJPD_VerificationMode VerificationMode)
2188 {
2189 NJPD_DEBUG_HAL_MSG("Set Verification Mode to %x\n", VerificationMode);
2190 eVerificationMode = VerificationMode;
2191 }
2192
HAL_NJPD_GetVerificationMode(void)2193 NJPD_VerificationMode HAL_NJPD_GetVerificationMode(void)
2194 {
2195 return eVerificationMode;
2196 }
2197
HAL_NJPD_Debug(void)2198 void HAL_NJPD_Debug(void)
2199 {
2200 if(eNJPDNum == E_NJPD_NJPD1)
2201 {
2202 NJPD_DEBUG_HAL_MSG("read BK_NJPD1_MARB_CRC_RESULT_0: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_CRC_RESULT_0));
2203 NJPD_DEBUG_HAL_MSG("read BK_NJPD1_MARB_CRC_RESULT_1: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_CRC_RESULT_1));
2204 NJPD_DEBUG_HAL_MSG("read BK_NJPD1_MARB_CRC_RESULT_2: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_CRC_RESULT_2));
2205 NJPD_DEBUG_HAL_MSG("read BK_NJPD1_MARB_CRC_RESULT_3: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MARB_CRC_RESULT_3));
2206 NJPD_DEBUG_HAL_MSG("read BK_NJPD1_GLOBAL_SETTING00: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_GLOBAL_SETTING00));
2207 NJPD_DEBUG_HAL_MSG("read BK_NJPD1_GLOBAL_SETTING01: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_GLOBAL_SETTING01));
2208 NJPD_DEBUG_HAL_MSG("read BK_NJPD1_GLOBAL_SETTING02: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_GLOBAL_SETTING02));
2209 NJPD_DEBUG_HAL_MSG("read BK_NJPD1_MIU_READ_STATUS = 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD1_MIU_READ_STATUS));
2210 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));
2211 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));
2212
2213 MS_U16 u16i;
2214 for(u16i=0; u16i<=0x7b; u16i++)
2215 {
2216 __HAL_NJPD_Write2Byte(BK_NJPD1_DEBUG_BUS_SELECT, u16i);
2217 NJPD_DEBUG_HAL_MSG("BK_NJPD1_DEBUG_BUS[H:L] = [0x%02x][0x%04x:0x%04x]\n", u16i,
2218 __HAL_NJPD_Read2Byte(BK_NJPD1_DEBUG_BUS_H),
2219 __HAL_NJPD_Read2Byte(BK_NJPD1_DEBUG_BUS_L));
2220 }
2221 __HAL_NJPD_Write2Byte(BK_NJPD1_DEBUG_BUS_SELECT, 0xFF);
2222 NJPD_DEBUG_HAL_MSG("BK_NJPD1_DEBUG_BUS[H:L] = [0x%02x][0x%04x:0x%04x]\n", 0xFF,
2223 __HAL_NJPD_Read2Byte(BK_NJPD1_DEBUG_BUS_H),
2224 __HAL_NJPD_Read2Byte(BK_NJPD1_DEBUG_BUS_L));
2225
2226 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2227 NJPD_DEBUG_HAL_MSG("NJPD | 00/08 01/09 02/0A 03/0B 04/0C 05/0D 06/0E 07/0F\n");
2228 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2229 for(u16i=0; u16i<0x80; u16i+=8)
2230 {
2231 NJPD_DEBUG_HAL_MSG("%02x | %04x %04x %04x %04x %04x %04x %04x %04x \n",u16i,
2232 __HAL_NJPD_Read2Byte(BK_NJPD1_GENERAL(u16i)),
2233 __HAL_NJPD_Read2Byte(BK_NJPD1_GENERAL(u16i+1)),
2234 __HAL_NJPD_Read2Byte(BK_NJPD1_GENERAL(u16i+2)),
2235 __HAL_NJPD_Read2Byte(BK_NJPD1_GENERAL(u16i+3)),
2236 __HAL_NJPD_Read2Byte(BK_NJPD1_GENERAL(u16i+4)),
2237 __HAL_NJPD_Read2Byte(BK_NJPD1_GENERAL(u16i+5)),
2238 __HAL_NJPD_Read2Byte(BK_NJPD1_GENERAL(u16i+6)),
2239 __HAL_NJPD_Read2Byte(BK_NJPD1_GENERAL(u16i+7))
2240 );
2241 }
2242 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2243 }
2244 else
2245 {
2246 NJPD_DEBUG_HAL_MSG("read BK_NJPD2_MARB_CRC_RESULT_0: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_CRC_RESULT_0));
2247 NJPD_DEBUG_HAL_MSG("read BK_NJPD2_MARB_CRC_RESULT_1: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_CRC_RESULT_1));
2248 NJPD_DEBUG_HAL_MSG("read BK_NJPD2_MARB_CRC_RESULT_2: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_CRC_RESULT_2));
2249 NJPD_DEBUG_HAL_MSG("read BK_NJPD2_MARB_CRC_RESULT_3: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MARB_CRC_RESULT_3));
2250 NJPD_DEBUG_HAL_MSG("read BK_NJPD2_GLOBAL_SETTING00: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_GLOBAL_SETTING00));
2251 NJPD_DEBUG_HAL_MSG("read BK_NJPD2_GLOBAL_SETTING01: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_GLOBAL_SETTING01));
2252 NJPD_DEBUG_HAL_MSG("read BK_NJPD2_GLOBAL_SETTING02: 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_GLOBAL_SETTING02));
2253 NJPD_DEBUG_HAL_MSG("read BK_NJPD2_MIU_READ_STATUS = 0x%04x\n", __HAL_NJPD_Read2Byte(BK_NJPD2_MIU_READ_STATUS));
2254 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));
2255 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));
2256
2257 MS_U16 u16i;
2258 for(u16i=0; u16i<=0x7b; u16i++)
2259 {
2260 __HAL_NJPD_Write2Byte(BK_NJPD2_DEBUG_BUS_SELECT, u16i);
2261 NJPD_DEBUG_HAL_MSG("BK_NJPD2_DEBUG_BUS[H:L] = [0x%02x][0x%04x:0x%04x]\n", u16i,
2262 __HAL_NJPD_Read2Byte(BK_NJPD2_DEBUG_BUS_H),
2263 __HAL_NJPD_Read2Byte(BK_NJPD2_DEBUG_BUS_L));
2264 }
2265 __HAL_NJPD_Write2Byte(BK_NJPD2_DEBUG_BUS_SELECT, 0xFF);
2266 NJPD_DEBUG_HAL_MSG("BK_NJPD2_DEBUG_BUS[H:L] = [0x%02x][0x%04x:0x%04x]\n", 0xFF,
2267 __HAL_NJPD_Read2Byte(BK_NJPD2_DEBUG_BUS_H),
2268 __HAL_NJPD_Read2Byte(BK_NJPD2_DEBUG_BUS_L));
2269
2270 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2271 NJPD_DEBUG_HAL_MSG("NJPD | 00/08 01/09 02/0A 03/0B 04/0C 05/0D 06/0E 07/0F\n");
2272 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2273 for(u16i=0; u16i<0x80; u16i+=8)
2274 {
2275 NJPD_DEBUG_HAL_MSG("%02x | %04x %04x %04x %04x %04x %04x %04x %04x \n",u16i,
2276 __HAL_NJPD_Read2Byte(BK_NJPD2_GENERAL(u16i)),
2277 __HAL_NJPD_Read2Byte(BK_NJPD2_GENERAL(u16i+1)),
2278 __HAL_NJPD_Read2Byte(BK_NJPD2_GENERAL(u16i+2)),
2279 __HAL_NJPD_Read2Byte(BK_NJPD2_GENERAL(u16i+3)),
2280 __HAL_NJPD_Read2Byte(BK_NJPD2_GENERAL(u16i+4)),
2281 __HAL_NJPD_Read2Byte(BK_NJPD2_GENERAL(u16i+5)),
2282 __HAL_NJPD_Read2Byte(BK_NJPD2_GENERAL(u16i+6)),
2283 __HAL_NJPD_Read2Byte(BK_NJPD2_GENERAL(u16i+7))
2284 );
2285 }
2286 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2287 }
2288 MS_U8 u8i;
2289
2290 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2291 NJPD_DEBUG_HAL_MSG("MIU0 | 00/08 01/09 02/0A 03/0B 04/0C 05/0D 06/0E 07/0F\n");
2292 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2293 for(u8i=0; u8i<0x80; u8i+=8)
2294 {
2295 NJPD_DEBUG_HAL_MSG("%02x | %04x %04x %04x %04x %04x %04x %04x %04x \n",u8i,
2296 __HAL_NJPD_Read2Byte(BK_MIU0_GENERAL(u8i)),
2297 __HAL_NJPD_Read2Byte(BK_MIU0_GENERAL(u8i+1)),
2298 __HAL_NJPD_Read2Byte(BK_MIU0_GENERAL(u8i+2)),
2299 __HAL_NJPD_Read2Byte(BK_MIU0_GENERAL(u8i+3)),
2300 __HAL_NJPD_Read2Byte(BK_MIU0_GENERAL(u8i+4)),
2301 __HAL_NJPD_Read2Byte(BK_MIU0_GENERAL(u8i+5)),
2302 __HAL_NJPD_Read2Byte(BK_MIU0_GENERAL(u8i+6)),
2303 __HAL_NJPD_Read2Byte(BK_MIU0_GENERAL(u8i+7))
2304 );
2305 }
2306 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2307
2308 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2309 NJPD_DEBUG_HAL_MSG("MIU1 | 00/08 01/09 02/0A 03/0B 04/0C 05/0D 06/0E 07/0F\n");
2310 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2311 for(u8i=0; u8i<0x80; u8i+=8)
2312 {
2313 NJPD_DEBUG_HAL_MSG("%02x | %04x %04x %04x %04x %04x %04x %04x %04x \n",u8i,
2314 __HAL_NJPD_Read2Byte(BK_MIU1_GENERAL(u8i)),
2315 __HAL_NJPD_Read2Byte(BK_MIU1_GENERAL(u8i+1)),
2316 __HAL_NJPD_Read2Byte(BK_MIU1_GENERAL(u8i+2)),
2317 __HAL_NJPD_Read2Byte(BK_MIU1_GENERAL(u8i+3)),
2318 __HAL_NJPD_Read2Byte(BK_MIU1_GENERAL(u8i+4)),
2319 __HAL_NJPD_Read2Byte(BK_MIU1_GENERAL(u8i+5)),
2320 __HAL_NJPD_Read2Byte(BK_MIU1_GENERAL(u8i+6)),
2321 __HAL_NJPD_Read2Byte(BK_MIU1_GENERAL(u8i+7))
2322 );
2323 }
2324 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2325
2326
2327 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2328 NJPD_DEBUG_HAL_MSG("1608 | 00/08 01/09 02/0A 03/0B 04/0C 05/0D 06/0E 07/0F\n");
2329 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2330 for(u8i=0; u8i<0x80; u8i+=8)
2331 {
2332 NJPD_DEBUG_HAL_MSG("%02x | %04x %04x %04x %04x %04x %04x %04x %04x \n",u8i,
2333 __HAL_NJPD_Read2Byte(BK_1608_GENERAL(u8i)),
2334 __HAL_NJPD_Read2Byte(BK_1608_GENERAL(u8i+1)),
2335 __HAL_NJPD_Read2Byte(BK_1608_GENERAL(u8i+2)),
2336 __HAL_NJPD_Read2Byte(BK_1608_GENERAL(u8i+3)),
2337 __HAL_NJPD_Read2Byte(BK_1608_GENERAL(u8i+4)),
2338 __HAL_NJPD_Read2Byte(BK_1608_GENERAL(u8i+5)),
2339 __HAL_NJPD_Read2Byte(BK_1608_GENERAL(u8i+6)),
2340 __HAL_NJPD_Read2Byte(BK_1608_GENERAL(u8i+7))
2341 );
2342 }
2343 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2344
2345 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2346 NJPD_DEBUG_HAL_MSG("160F | 00/08 01/09 02/0A 03/0B 04/0C 05/0D 06/0E 07/0F\n");
2347 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2348 for(u8i=0; u8i<0x80; u8i+=8)
2349 {
2350 NJPD_DEBUG_HAL_MSG("%02x | %04x %04x %04x %04x %04x %04x %04x %04x \n",u8i,
2351 __HAL_NJPD_Read2Byte(BK_160F_GENERAL(u8i)),
2352 __HAL_NJPD_Read2Byte(BK_160F_GENERAL(u8i+1)),
2353 __HAL_NJPD_Read2Byte(BK_160F_GENERAL(u8i+2)),
2354 __HAL_NJPD_Read2Byte(BK_160F_GENERAL(u8i+3)),
2355 __HAL_NJPD_Read2Byte(BK_160F_GENERAL(u8i+4)),
2356 __HAL_NJPD_Read2Byte(BK_160F_GENERAL(u8i+5)),
2357 __HAL_NJPD_Read2Byte(BK_160F_GENERAL(u8i+6)),
2358 __HAL_NJPD_Read2Byte(BK_160F_GENERAL(u8i+7))
2359 );
2360 }
2361 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2362
2363
2364 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2365 NJPD_DEBUG_HAL_MSG("1615 | 00/08 01/09 02/0A 03/0B 04/0C 05/0D 06/0E 07/0F\n");
2366 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2367 for(u8i=0; u8i<0x80; u8i+=8)
2368 {
2369 NJPD_DEBUG_HAL_MSG("%02x | %04x %04x %04x %04x %04x %04x %04x %04x \n",u8i,
2370 __HAL_NJPD_Read2Byte(BK_1615_GENERAL(u8i)),
2371 __HAL_NJPD_Read2Byte(BK_1615_GENERAL(u8i+1)),
2372 __HAL_NJPD_Read2Byte(BK_1615_GENERAL(u8i+2)),
2373 __HAL_NJPD_Read2Byte(BK_1615_GENERAL(u8i+3)),
2374 __HAL_NJPD_Read2Byte(BK_1615_GENERAL(u8i+4)),
2375 __HAL_NJPD_Read2Byte(BK_1615_GENERAL(u8i+5)),
2376 __HAL_NJPD_Read2Byte(BK_1615_GENERAL(u8i+6)),
2377 __HAL_NJPD_Read2Byte(BK_1615_GENERAL(u8i+7))
2378 );
2379 }
2380 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2381
2382
2383 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2384 NJPD_DEBUG_HAL_MSG("1620 | 00/08 01/09 02/0A 03/0B 04/0C 05/0D 06/0E 07/0F\n");
2385 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2386 for(u8i=0; u8i<0x80; u8i+=8)
2387 {
2388 NJPD_DEBUG_HAL_MSG("%02x | %04x %04x %04x %04x %04x %04x %04x %04x \n",u8i,
2389 __HAL_NJPD_Read2Byte(BK_1620_GENERAL(u8i)),
2390 __HAL_NJPD_Read2Byte(BK_1620_GENERAL(u8i+1)),
2391 __HAL_NJPD_Read2Byte(BK_1620_GENERAL(u8i+2)),
2392 __HAL_NJPD_Read2Byte(BK_1620_GENERAL(u8i+3)),
2393 __HAL_NJPD_Read2Byte(BK_1620_GENERAL(u8i+4)),
2394 __HAL_NJPD_Read2Byte(BK_1620_GENERAL(u8i+5)),
2395 __HAL_NJPD_Read2Byte(BK_1620_GENERAL(u8i+6)),
2396 __HAL_NJPD_Read2Byte(BK_1620_GENERAL(u8i+7))
2397 );
2398 }
2399 NJPD_DEBUG_HAL_MSG("=======================================================\n");
2400
2401
2402 }
2403
HAL_NJPD_SetNJPDInstance(JPD_Number JPDNum)2404 void HAL_NJPD_SetNJPDInstance(JPD_Number JPDNum)
2405 {
2406 eNJPDNum = JPDNum;
2407 }
2408
HAL_NJPD_IsNeedToPatch(NJPD_PATCH_INDEX eIndex)2409 MS_BOOL HAL_NJPD_IsNeedToPatch(NJPD_PATCH_INDEX eIndex)
2410 {
2411 switch(eIndex)
2412 {
2413 case E_NJPD_MIU_LAST_Z_PATCH:
2414 return FALSE;
2415 break;
2416 case E_NJPD_EAGLE_SW_PATCH:
2417 return FALSE;
2418 break;
2419 default:
2420 break;
2421 }
2422 return FALSE;
2423 }
2424
HAL_NJPD_JPDCount(void)2425 MS_U8 HAL_NJPD_JPDCount(void)
2426 {
2427 return 1;
2428 }
2429
2430
2431