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