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