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