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-2009 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 #define _HAL_HWI2C_C
94
95 ////////////////////////////////////////////////////////////////////////////////
96 /// @file halHWI2C.c
97 /// @author MStar Semiconductor Inc.
98 /// @brief DRAM byte DMA control driver
99 ////////////////////////////////////////////////////////////////////////////////
100
101 ////////////////////////////////////////////////////////////////////////////////
102 // Header Files
103 ////////////////////////////////////////////////////////////////////////////////
104 #ifdef MSOS_TYPE_LINUX_KERNEL
105 #include <linux/string.h>
106 #else
107 #include <string.h>
108 #endif
109 #include "MsCommon.h"
110 #include "MsTypes.h"
111 #include "halHWI2C.h"
112 #include "halCHIP.h"
113 #include "regHWI2C.h"
114
115 ////////////////////////////////////////////////////////////////////////////////
116 // Define & data type
117 ///////////////////////////////////////////////////////////////////////////////
118 #define HWI2C_HAL_RETRY_TIMES (3)
119 #define HWI2C_HAL_WAIT_TIMEOUT 30000//(1500)
120 #define HWI2C_HAL_FUNC() //{printf("%s\n", __FUNCTION__);}
121 #define HWI2C_HAL_INFO(x, args...) //{printf(x, ##args);}
122 #define HWI2C_HAL_ERR(x, args...) //{printf(x, ##args);}
123 #ifndef UNUSED
124 #define UNUSED(x) ((x)=(x))
125 #endif
126
127 #define HWI2C_DMA_CMD_DATA_LEN 7
128 #define HWI2C_DMA_WAIT_TIMEOUT (30000)
129 #define HWI2C_DMA_WRITE 0
130 #define HWI2C_DMA_READ 1
131 #define _PA2VA(x) (MS_VIRT)MsOS_PA2KSEG1((x))
132 #define _VA2PA(x) (MS_VIRT)MsOS_VA2PA((x))
133
134 ////////////////////////////////////////////////////////////////////////////////
135 // Local variable
136 ////////////////////////////////////////////////////////////////////////////////
137 static MS_VIRT _gMIO_MapBase = 0;
138 static MS_BOOL g_bLastByte[HAL_HWI2C_PORTS];
139 static MS_VIRT g_u32DmaPhyAddr[HAL_HWI2C_PORTS];
140 static HAL_HWI2C_PortCfg g_stPortCfg[HAL_HWI2C_PORTS];
141 static MS_U16 g_u16DmaDelayFactor[HAL_HWI2C_PORTS];
142
143
144 ////////////////////////////////////////////////////////////////////////////////
145 // Extern Function
146 ////////////////////////////////////////////////////////////////////////////////
147
148 ////////////////////////////////////////////////////////////////////////////////
149 // Function Declaration
150 ////////////////////////////////////////////////////////////////////////////////
151
152 ////////////////////////////////////////////////////////////////////////////////
153 // Local Function
154 ////////////////////////////////////////////////////////////////////////////////
155
156 ////////////////////////////////////////////////////////////////////////////////
157 // Global Function
158 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_ExtraDelay(MS_U32 u32Us)159 void HAL_HWI2C_ExtraDelay(MS_U32 u32Us)
160 {
161 // volatile is necessary to avoid optimization
162 MS_U32 volatile u32Dummy = 0;
163 //MS_U32 u32Loop;
164 MS_U32 volatile u32Loop;
165
166 u32Loop = (MS_U32)(50 * u32Us);
167 while (u32Loop--)
168 {
169 u32Dummy++;
170 }
171 }
172
173 ////////////////////////////////////////////////////////////////////////////////
174 /// @brief \b Function \b Name: HAL_HWI2C_SetIOMapBase
175 /// @brief \b Function \b Description: Dump bdma all register
176 /// @param <IN> \b None :
177 /// @param <OUT> \b None :
178 /// @param <RET> \b None :
179 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_SetIOMapBase(MS_VIRT u32Base)180 void HAL_HWI2C_SetIOMapBase(MS_VIRT u32Base)
181 {
182 HWI2C_HAL_FUNC();
183
184 _gMIO_MapBase = u32Base;
185 HWI2C_HAL_INFO("HWI2C IOMap base:%8lx Reg offset:%4x\n", u32Base, (MS_U16)HWI2C_REG_BASE);
186 }
187
188 ////////////////////////////////////////////////////////////////////////////////
189 /// @brief \b Function \b Name: HAL_HWI2C_ReadByte
190 /// @brief \b Function \b Description: read 1 Byte data
191 /// @param <IN> \b u32RegAddr: register address
192 /// @param <OUT> \b None :
193 /// @param <RET> \b MS_U8
194 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_ReadByte(MS_VIRT u32RegAddr)195 MS_U8 HAL_HWI2C_ReadByte(MS_VIRT u32RegAddr)
196 {
197 return ((volatile MS_U8*)(_gMIO_MapBase))[(u32RegAddr << 1) - (u32RegAddr & 1)];
198 }
199
200 ////////////////////////////////////////////////////////////////////////////////
201 /// @brief \b Function \b Name: HAL_HWI2C_Read4Byte
202 /// @brief \b Function \b Description: read 2 Byte data
203 /// @param <IN> \b u32RegAddr: register address
204 /// @param <OUT> \b None :
205 /// @param <RET> \b MS_U16
206 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_Read2Byte(MS_U32 u32RegAddr)207 MS_U16 HAL_HWI2C_Read2Byte(MS_U32 u32RegAddr)
208 {
209 return ((volatile MS_U16*)(_gMIO_MapBase))[u32RegAddr];
210 }
211
212 ////////////////////////////////////////////////////////////////////////////////
213 /// @brief \b Function \b Name: HAL_HWI2C_Read4Byte
214 /// @brief \b Function \b Description: read 4 Byte data
215 /// @param <IN> \b u32RegAddr: register address
216 /// @param <OUT> \b None :
217 /// @param <RET> \b MS_U32
218 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_Read4Byte(MS_U32 u32RegAddr)219 MS_U32 HAL_HWI2C_Read4Byte(MS_U32 u32RegAddr)
220 {
221 return (HAL_HWI2C_Read2Byte(u32RegAddr) | HAL_HWI2C_Read2Byte(u32RegAddr+2) << 16);
222 }
223
224 ////////////////////////////////////////////////////////////////////////////////
225 /// @brief \b Function \b Name: HAL_HWI2C_WriteByte
226 /// @brief \b Function \b Description: write 1 Byte data
227 /// @param <IN> \b u32RegAddr: register address
228 /// @param <IN> \b u8Val : 1 byte data
229 /// @param <OUT> \b None :
230 /// @param <RET> \b TRUE : ok, FALSE : fail
231 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_WriteByte(MS_U32 u32RegAddr,MS_U8 u8Val)232 MS_BOOL HAL_HWI2C_WriteByte(MS_U32 u32RegAddr, MS_U8 u8Val)
233 {
234 if (!u32RegAddr)
235 {
236 HWI2C_HAL_ERR("%s reg error!\n", __FUNCTION__);
237 return FALSE;
238 }
239
240 ((volatile MS_U8*)(_gMIO_MapBase))[(u32RegAddr << 1) - (u32RegAddr & 1)] = u8Val;
241 return TRUE;
242 }
243
244 ////////////////////////////////////////////////////////////////////////////////
245 /// @brief \b Function \b Name: HAL_HWI2C_Write2Byte
246 /// @brief \b Function \b Description: write 2 Byte data
247 /// @param <IN> \b u32RegAddr: register address
248 /// @param <IN> \b u16Val : 2 byte data
249 /// @param <OUT> \b None :
250 /// @param <RET> \b TRUE : ok, FALSE : fail
251 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_Write2Byte(MS_U32 u32RegAddr,MS_U16 u16Val)252 MS_BOOL HAL_HWI2C_Write2Byte(MS_U32 u32RegAddr, MS_U16 u16Val)
253 {
254 if (!u32RegAddr)
255 {
256 HWI2C_HAL_ERR("%s reg error!\n", __FUNCTION__);
257 return FALSE;
258 }
259
260 ((volatile MS_U16*)(_gMIO_MapBase))[u32RegAddr] = u16Val;
261 return TRUE;
262 }
263
264 ////////////////////////////////////////////////////////////////////////////////
265 /// @brief \b Function \b Name: HAL_HWI2C_Write4Byte
266 /// @brief \b Function \b Description: write 4 Byte data
267 /// @param <IN> \b u32RegAddr: register address
268 /// @param <IN> \b u32Val : 4 byte data
269 /// @param <OUT> \b None :
270 /// @param <RET> \b TRUE : ok, FALSE : fail
271 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_Write4Byte(MS_U32 u32RegAddr,MS_U32 u32Val)272 MS_BOOL HAL_HWI2C_Write4Byte(MS_U32 u32RegAddr, MS_U32 u32Val)
273 {
274 if (!u32RegAddr)
275 {
276 HWI2C_HAL_ERR("%s reg error!\n", __FUNCTION__);
277 return FALSE;
278 }
279
280 HAL_HWI2C_Write2Byte(u32RegAddr, u32Val & 0x0000FFFF);
281 HAL_HWI2C_Write2Byte(u32RegAddr+2, u32Val >> 16);
282 return TRUE;
283 }
284
285 ////////////////////////////////////////////////////////////////////////////////
286 /// @brief \b Function \b Name: HAL_HWI2C_WriteRegBit
287 /// @brief \b Function \b Description: write 1 Byte data
288 /// @param <IN> \b u32RegAddr: register address
289 /// @param <IN> \b u8Val : 1 byte data
290 /// @param <OUT> \b None :
291 /// @param <RET> \b TRUE : ok, FALSE : fail
292 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_WriteRegBit(MS_U32 u32RegAddr,MS_U8 u8Mask,MS_BOOL bEnable)293 MS_BOOL HAL_HWI2C_WriteRegBit(MS_U32 u32RegAddr, MS_U8 u8Mask, MS_BOOL bEnable)
294 {
295 MS_U8 u8Val = 0;
296
297 if (!u32RegAddr)
298 {
299 HWI2C_HAL_ERR("%s reg error!\n", __FUNCTION__);
300 return FALSE;
301 }
302
303 u8Val = HAL_HWI2C_ReadByte(u32RegAddr);
304 u8Val = (bEnable) ? (u8Val | u8Mask) : (u8Val & ~u8Mask);
305 HAL_HWI2C_WriteByte(u32RegAddr, u8Val);
306 return TRUE;
307 }
308
309 ////////////////////////////////////////////////////////////////////////////////
310 /// @brief \b Function \b Name: HAL_HWI2C_WriteByteMask
311 /// @brief \b Function \b Description: write data with mask bits
312 /// @param <IN> \b u32RegAddr: register address
313 /// @param <IN> \b u8Val : 1 byte data
314 /// @param <IN> \b u8Mask : mask bits
315 /// @param <OUT> \b None :
316 /// @param <RET> \b TRUE : ok, FALSE : fail
317 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_WriteByteMask(MS_U32 u32RegAddr,MS_U8 u8Val,MS_U8 u8Mask)318 MS_BOOL HAL_HWI2C_WriteByteMask(MS_U32 u32RegAddr, MS_U8 u8Val, MS_U8 u8Mask)
319 {
320 if (!u32RegAddr)
321 {
322 HWI2C_HAL_ERR("%s reg error!\n", __FUNCTION__);
323 return FALSE;
324 }
325
326 u8Val = (HAL_HWI2C_ReadByte(u32RegAddr) & ~u8Mask) | (u8Val & u8Mask);
327 HAL_HWI2C_WriteByte(u32RegAddr, u8Val);
328 return TRUE;
329 }
330
331 //#####################
332 //
333 // MIIC STD Related Functions
334 // Static or Internal use
335 //
336 //#####################
337 ////////////////////////////////////////////////////////////////////////////////
338 /// @brief \b Function \b Name: HAL_HWI2C_EnINT
339 /// @brief \b Function \b Description: Enable Interrupt
340 /// @param <IN> \b bEnable : TRUE: Enable, FALSE: Disable
341 /// @param <OUT> \b None :
342 /// @param <RET> \b TRUE: Ok, FALSE: Fail
343 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_EnINT(MS_U32 u32PortOffset,MS_BOOL bEnable)344 static MS_BOOL HAL_HWI2C_EnINT(MS_U32 u32PortOffset, MS_BOOL bEnable)
345 {
346 HWI2C_HAL_FUNC();
347 return HAL_HWI2C_WriteRegBit(REG_HWI2C_MIIC_CFG+u32PortOffset, _MIIC_CFG_EN_INT, bEnable);
348 }
349
350 ////////////////////////////////////////////////////////////////////////////////
351 /// @brief \b Function \b Name: HAL_HWI2C_EnDMA
352 /// @brief \b Function \b Description: Enable DMA
353 /// @param <IN> \b bEnable : TRUE: Enable, FALSE: Disable
354 /// @param <OUT> \b None :
355 /// @param <RET> \b TRUE: Ok, FALSE: Fail
356 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_EnDMA(MS_U32 u32PortOffset,MS_BOOL bEnable)357 static MS_BOOL HAL_HWI2C_EnDMA(MS_U32 u32PortOffset, MS_BOOL bEnable)
358 {
359 HWI2C_HAL_FUNC();
360 return HAL_HWI2C_WriteRegBit(REG_HWI2C_MIIC_CFG+u32PortOffset, _MIIC_CFG_EN_DMA, bEnable);
361 }
362
363 ////////////////////////////////////////////////////////////////////////////////
364 /// @brief \b Function \b Name: HAL_HWI2C_EnClkStretch
365 /// @brief \b Function \b Description: Enable Clock Stretch
366 /// @param <IN> \b bEnable : TRUE: Enable, FALSE: Disable
367 /// @param <OUT> \b None :
368 /// @param <RET> \b TRUE: Ok, FALSE: Fail
369 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_EnClkStretch(MS_U32 u32PortOffset,MS_BOOL bEnable)370 static MS_BOOL HAL_HWI2C_EnClkStretch(MS_U32 u32PortOffset, MS_BOOL bEnable)
371 {
372 HWI2C_HAL_FUNC();
373 return HAL_HWI2C_WriteRegBit(REG_HWI2C_MIIC_CFG+u32PortOffset, _MIIC_CFG_EN_CLKSTR, bEnable);
374 }
375
376 #if 0//RFU
377 ////////////////////////////////////////////////////////////////////////////////
378 /// @brief \b Function \b Name: HAL_HWI2C_EnTimeoutINT
379 /// @brief \b Function \b Description: Enable Timeout Interrupt
380 /// @param <IN> \b bEnable : TRUE: Enable, FALSE: Disable
381 /// @param <OUT> \b None :
382 /// @param <RET> \b TRUE: Ok, FALSE: Fail
383 ////////////////////////////////////////////////////////////////////////////////
384 static MS_BOOL HAL_HWI2C_EnTimeoutINT(MS_U32 u32PortOffset, MS_BOOL bEnable)
385 {
386 HWI2C_HAL_FUNC();
387 return HAL_HWI2C_WriteRegBit(REG_HWI2C_MIIC_CFG+u32PortOffset, _MIIC_CFG_EN_TMTINT, bEnable);
388 }
389 #endif
390
391 ////////////////////////////////////////////////////////////////////////////////
392 /// @brief \b Function \b Name: HAL_HWI2C_EnFilter
393 /// @brief \b Function \b Description: Enable Filter
394 /// @param <IN> \b bEnable : TRUE: Enable, FALSE: Disable
395 /// @param <OUT> \b None :
396 /// @param <RET> \b TRUE: Ok, FALSE: Fail
397 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_EnFilter(MS_U32 u32PortOffset,MS_BOOL bEnable)398 static MS_BOOL HAL_HWI2C_EnFilter(MS_U32 u32PortOffset, MS_BOOL bEnable)
399 {
400 HWI2C_HAL_FUNC();
401 return HAL_HWI2C_WriteRegBit(REG_HWI2C_MIIC_CFG+u32PortOffset, _MIIC_CFG_EN_FILTER, bEnable);
402 }
403
404 ////////////////////////////////////////////////////////////////////////////////
405 /// @brief \b Function \b Name: HAL_HWI2C_EnPushSda
406 /// @brief \b Function \b Description: Enable push current for SDA
407 /// @param <IN> \b bEnable : TRUE: Enable, FALSE: Disable
408 /// @param <OUT> \b None :
409 /// @param <RET> \b TRUE: Ok, FALSE: Fail
410 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_EnPushSda(MS_U32 u32PortOffset,MS_BOOL bEnable)411 static MS_BOOL HAL_HWI2C_EnPushSda(MS_U32 u32PortOffset, MS_BOOL bEnable)
412 {
413 HWI2C_HAL_FUNC();
414 return HAL_HWI2C_WriteRegBit(REG_HWI2C_MIIC_CFG+u32PortOffset, _MIIC_CFG_EN_PUSH1T, bEnable);
415 }
416
417 //#####################
418 //
419 // MIIC DMA Related Functions
420 // Static or Internal use
421 //
422 //#####################
423 ////////////////////////////////////////////////////////////////////////////////
424 /// @brief \b Function \b Name: HAL_HWI2C_DMA_SetINT
425 /// @brief \b Function \b Description: Initialize HWI2C DMA
426 /// @param <IN> \b bEnable : TRUE: enable INT, FALSE: disable INT
427 /// @param <OUT> \b None :
428 /// @param <RET> \b TRUE : ok, FALSE : fail
429 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_DMA_SetINT(MS_U32 u32PortOffset,MS_BOOL bEnable)430 static MS_BOOL HAL_HWI2C_DMA_SetINT(MS_U32 u32PortOffset, MS_BOOL bEnable)
431 {
432 HWI2C_HAL_FUNC();
433 return HAL_HWI2C_WriteRegBit(REG_HWI2C_DMA_CFG+u32PortOffset, _DMA_CFG_INTEN, bEnable);
434 }
435
436 ////////////////////////////////////////////////////////////////////////////////
437 /// @brief \b Function \b Name: HAL_HWI2C_DMA_Reset
438 /// @brief \b Function \b Description: Reset HWI2C DMA
439 /// @param <IN> \b bReset : TRUE: Not Reset FALSE: Reset
440 /// @param <OUT> \b None :
441 /// @param <RET> \b TRUE : ok, FALSE : fail
442 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_DMA_Reset(MS_U32 u32PortOffset,MS_BOOL bReset)443 static MS_BOOL HAL_HWI2C_DMA_Reset(MS_U32 u32PortOffset, MS_BOOL bReset)
444 {
445 HWI2C_HAL_FUNC();
446 return HAL_HWI2C_WriteRegBit(REG_HWI2C_DMA_CFG+u32PortOffset, _DMA_CFG_RESET, bReset);
447 }
448
449 ////////////////////////////////////////////////////////////////////////////////
450 /// @brief \b Function \b Name: HAL_HWI2C_DMA_MiuReset
451 /// @brief \b Function \b Description: Reset HWI2C DMA MIU
452 /// @param <IN> \b bReset : TRUE: Not Reset FALSE: Reset
453 /// @param <OUT> \b None :
454 /// @param <RET> \b TRUE : ok, FALSE : fail
455 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_DMA_MiuReset(MS_U32 u32PortOffset,MS_BOOL bReset)456 static MS_BOOL HAL_HWI2C_DMA_MiuReset(MS_U32 u32PortOffset, MS_BOOL bReset)
457 {
458 HWI2C_HAL_FUNC();
459 return HAL_HWI2C_WriteRegBit(REG_HWI2C_DMA_CFG+u32PortOffset, _DMA_CFG_MIURST, bReset);
460 }
461
462 ////////////////////////////////////////////////////////////////////////////////
463 /// @brief \b Function \b Name: HAL_HWI2C_DMA_SetMiuPri
464 /// @brief \b Function \b Description: Set HWI2C DMA MIU Priority
465 /// @param <IN> \b eMiuPri : E_HAL_HWI2C_DMA_PRI_LOW, E_HAL_HWI2C_DMA_PRI_HIGH
466 /// @param <OUT> \b None :
467 /// @param <RET> \b TRUE : ok, FALSE : fail
468 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_DMA_SetMiuPri(MS_U32 u32PortOffset,HAL_HWI2C_DMA_MIUPRI eMiuPri)469 static MS_BOOL HAL_HWI2C_DMA_SetMiuPri(MS_U32 u32PortOffset, HAL_HWI2C_DMA_MIUPRI eMiuPri)
470 {
471 MS_BOOL bHighPri;
472
473 HWI2C_HAL_FUNC();
474 if(eMiuPri>=E_HAL_HWI2C_DMA_PRI_MAX)
475 return FALSE;
476 bHighPri = (eMiuPri==E_HAL_HWI2C_DMA_PRI_HIGH)? TRUE : FALSE;
477 return HAL_HWI2C_WriteRegBit(REG_HWI2C_DMA_CFG+u32PortOffset, _DMA_CFG_MIUPRI, bHighPri);
478 }
479
480 ////////////////////////////////////////////////////////////////////////////////
481 /// @brief \b Function \b Name: HAL_HWI2C_DMA_SetMiuAddr
482 /// @brief \b Function \b Description: Set HWI2C DMA MIU Address
483 /// @param <IN> \b u32MiuAddr : MIU Address
484 /// @param <OUT> \b None :
485 /// @param <RET> \b TRUE : ok, FALSE : fail
486 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_DMA_SetMiuAddr(MS_U32 u32PortOffset,MS_U32 u32MiuAddr)487 static MS_BOOL HAL_HWI2C_DMA_SetMiuAddr(MS_U32 u32PortOffset, MS_U32 u32MiuAddr)
488 {
489 MS_U8 u8Port;
490 MS_U32 u32StartOffset;
491 MS_U8 u8MiuSel;
492
493 HWI2C_HAL_FUNC();
494
495 if(HAL_HWI2C_GetPortIdxByOffset(u32PortOffset,&u8Port)==FALSE)
496 return FALSE;
497 g_u32DmaPhyAddr[u8Port] = u32MiuAddr;
498
499 _phy_to_miu_offset(u8MiuSel, u32StartOffset, u32MiuAddr);
500
501 return HAL_HWI2C_Write4Byte(REG_HWI2C_DMA_MIU_ADR+u32PortOffset, u32StartOffset);
502 }
503
504 ////////////////////////////////////////////////////////////////////////////////
505 /// @brief \b Function \b Name: HAL_HWI2C_DMA_Trigger
506 /// @brief \b Function \b Description: Trigger HWI2C DMA
507 /// @param <IN> \b None :
508 /// @param <OUT> \b None :
509 /// @param <RET> \b TRUE : ok, FALSE : fail
510 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_DMA_Trigger(MS_U32 u32PortOffset)511 static MS_BOOL HAL_HWI2C_DMA_Trigger(MS_U32 u32PortOffset)
512 {
513 HWI2C_HAL_FUNC();
514 return HAL_HWI2C_WriteRegBit(REG_HWI2C_DMA_CTL_TRIG+u32PortOffset, _DMA_CTL_TRIG, TRUE);
515 }
516
517 #if 0 //will be used later
518 ////////////////////////////////////////////////////////////////////////////////
519 /// @brief \b Function \b Name: HAL_HWI2C_DMA_ReTrigger
520 /// @brief \b Function \b Description: Re-Trigger HWI2C DMA
521 /// @param <IN> \b None :
522 /// @param <OUT> \b None :
523 /// @param <RET> \b TRUE : ok, FALSE : fail
524 ////////////////////////////////////////////////////////////////////////////////
525 static MS_BOOL HAL_HWI2C_DMA_ReTrigger(MS_U32 u32PortOffset)
526 {
527 HWI2C_HAL_FUNC();
528 return HAL_HWI2C_WriteRegBit(REG_HWI2C_DMA_CTL+u32PortOffset, _DMA_CTL_RETRIG, TRUE);
529 }
530 #endif
531
532 ////////////////////////////////////////////////////////////////////////////////
533 /// @brief \b Function \b Name: HAL_HWI2C_DMA_SetTxfrStop
534 /// @brief \b Function \b Description: Control HWI2C DMA Transfer Format with or w/o STOP
535 /// @param <IN> \b bEnable : TRUE: with STOP, FALSE: without STOP
536 /// @param <OUT> \b None :
537 /// @param <RET> \b TRUE : ok, FALSE : fail
538 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_DMA_SetTxfrStop(MS_U32 u32PortOffset,MS_BOOL bEnable)539 static MS_BOOL HAL_HWI2C_DMA_SetTxfrStop(MS_U32 u32PortOffset, MS_BOOL bEnable)
540 {
541 MS_BOOL bTxNoStop;
542
543 HWI2C_HAL_FUNC();
544 bTxNoStop = (bEnable)? FALSE : TRUE;
545 return HAL_HWI2C_WriteRegBit(REG_HWI2C_DMA_CTL+u32PortOffset, _DMA_CTL_TXNOSTOP, bTxNoStop);
546 }
547
548 ////////////////////////////////////////////////////////////////////////////////
549 /// @brief \b Function \b Name: HAL_HWI2C_DMA_SetReadMode
550 /// @brief \b Function \b Description: Control HWI2C DMA Transfer Format with or w/o STOP
551 /// @param <IN> \b eReadMode : E_HAL_HWI2C_DMA_READ_NOSTOP, E_HAL_HWI2C_DMA_READ_STOP
552 /// @param <OUT> \b None :
553 /// @param <RET> \b TRUE : ok, FALSE : fail
554 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_DMA_SetReadMode(MS_U32 u32PortOffset,HAL_HWI2C_ReadMode eReadMode)555 static MS_BOOL HAL_HWI2C_DMA_SetReadMode(MS_U32 u32PortOffset, HAL_HWI2C_ReadMode eReadMode)
556 {
557 HWI2C_HAL_FUNC();
558 if(eReadMode>=E_HAL_HWI2C_READ_MODE_MAX)
559 return FALSE;
560 if(eReadMode==E_HAL_HWI2C_READ_MODE_DIRECTION_CHANGE)
561 return HAL_HWI2C_DMA_SetTxfrStop(u32PortOffset, FALSE);
562 else
563 if(eReadMode==E_HAL_HWI2C_READ_MODE_DIRECTION_CHANGE_STOP_START)
564 return HAL_HWI2C_DMA_SetTxfrStop(u32PortOffset, TRUE);
565 else
566 return FALSE;
567 }
568
569 ////////////////////////////////////////////////////////////////////////////////
570 /// @brief \b Function \b Name: HAL_HWI2C_DMA_SetRdWrt
571 /// @brief \b Function \b Description: Control HWI2C DMA Read or Write
572 /// @param <IN> \b bRdWrt : TRUE: read ,FALSE: write
573 /// @param <OUT> \b None :
574 /// @param <RET> \b TRUE : ok, FALSE : fail
575 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_DMA_SetRdWrt(MS_U32 u32PortOffset,MS_BOOL bRdWrt)576 static MS_BOOL HAL_HWI2C_DMA_SetRdWrt(MS_U32 u32PortOffset, MS_BOOL bRdWrt)
577 {
578 HWI2C_HAL_FUNC();
579 return HAL_HWI2C_WriteRegBit(REG_HWI2C_DMA_CTL+u32PortOffset, _DMA_CTL_RDWTCMD, bRdWrt);
580 }
581
582 ////////////////////////////////////////////////////////////////////////////////
583 /// @brief \b Function \b Name: HAL_HWI2C_DMA_SetMiuChannel
584 /// @brief \b Function \b Description: Control HWI2C DMA MIU channel
585 /// @param <IN> \b u8MiuCh : E_HAL_HWI2C_DMA_MIU_CH0 , E_HAL_HWI2C_DMA_MIU_CH1
586 /// @param <OUT> \b None :
587 /// @param <RET> \b TRUE : ok, FALSE : fail
588 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_DMA_SetMiuChannel(MS_U32 u32PortOffset,HAL_HWI2C_DMA_MIUCH eMiuCh)589 static MS_BOOL HAL_HWI2C_DMA_SetMiuChannel(MS_U32 u32PortOffset, HAL_HWI2C_DMA_MIUCH eMiuCh)
590 {
591 MS_BOOL bMiuCh1;
592
593 HWI2C_HAL_FUNC();
594 if(eMiuCh>=E_HAL_HWI2C_DMA_MIU_MAX)
595 return FALSE;
596 bMiuCh1 = (eMiuCh==E_HAL_HWI2C_DMA_MIU_CH1)? TRUE : FALSE;
597 return HAL_HWI2C_WriteRegBit(REG_HWI2C_DMA_CTL+u32PortOffset, _DMA_CTL_MIUCHSEL, bMiuCh1);
598 }
599
600 ////////////////////////////////////////////////////////////////////////////////
601 /// @brief \b Function \b Name: HAL_HWI2C_DMA_TxfrDone
602 /// @brief \b Function \b Description: Enable interrupt for HWI2C
603 /// @param <IN> \b None :
604 /// @param <OUT> \b None :
605 /// @param <RET> \b TRUE : ok, FALSE : fail
606 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_DMA_TxfrDone(MS_U32 u32PortOffset)607 static MS_BOOL HAL_HWI2C_DMA_TxfrDone(MS_U32 u32PortOffset)
608 {
609 HWI2C_HAL_FUNC();
610 return HAL_HWI2C_WriteRegBit(REG_HWI2C_DMA_TXR+u32PortOffset, _DMA_TXR_DONE, TRUE);
611 }
612
613 ////////////////////////////////////////////////////////////////////////////////
614 /// @brief \b Function \b Name: HAL_HWI2C_DMA_IsTxfrDone
615 /// @brief \b Function \b Description: Check HWI2C DMA Tx done or not
616 /// @param <IN> \b None :
617 /// @param <OUT> \b None :
618 /// @param <RET> \b TRUE: DMA TX Done, FALSE: DMA TX Not Done
619 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_DMA_IsTxfrDone(MS_U32 u32PortOffset,MS_U8 u8Port)620 static MS_BOOL HAL_HWI2C_DMA_IsTxfrDone(MS_U32 u32PortOffset, MS_U8 u8Port)
621 {
622 HWI2C_HAL_FUNC();
623 //##########################
624 //
625 // [Note] : IMPORTANT !!!
626 // Need to put some delay here,
627 // Otherwise, reading data will fail
628 //
629 //##########################
630 if(u8Port>=HAL_HWI2C_PORTS)
631 return FALSE;
632 HAL_HWI2C_ExtraDelay(g_u16DmaDelayFactor[u8Port]);
633 return (HAL_HWI2C_ReadByte(REG_HWI2C_DMA_TXR+u32PortOffset) & _DMA_TXR_DONE) ? TRUE : FALSE;
634 }
635
636 ////////////////////////////////////////////////////////////////////////////////
637 /// @brief \b Function \b Name: HAL_HWI2C_DMA_SetTxfrCmd
638 /// @brief \b Function \b Description: Set Transfer HWI2C DMA Command & Length
639 /// @param <IN> \b pu8CmdBuf : data pointer
640 /// @param <IN> \b u8CmdLen : command length
641 /// @param <OUT> \b None :
642 /// @param <RET> \b TRUE: cmd len in range, FALSE: cmd len out of range
643 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_DMA_SetTxfrCmd(MS_U32 u32PortOffset,MS_U8 u8CmdLen,MS_U8 * pu8CmdBuf)644 static MS_BOOL HAL_HWI2C_DMA_SetTxfrCmd(MS_U32 u32PortOffset, MS_U8 u8CmdLen, MS_U8* pu8CmdBuf)
645 {
646 MS_U8 k,u8CmdData;
647 MS_U32 u32RegAdr;
648
649 HWI2C_HAL_FUNC();
650 if(u8CmdLen>HWI2C_DMA_CMD_DATA_LEN)
651 return FALSE;
652 for( k=0 ; (k<u8CmdLen)&&(k<HWI2C_DMA_CMD_DATA_LEN); k++ )
653 {
654 u32RegAdr = REG_HWI2C_DMA_CMDDAT0 + k;
655 u8CmdData = *(pu8CmdBuf + k);
656 HAL_HWI2C_WriteByte(u32RegAdr+u32PortOffset, u8CmdData);
657 }
658 HAL_HWI2C_WriteByte(REG_HWI2C_DMA_CMDLEN+u32PortOffset, u8CmdLen&_DMA_CMDLEN_MSK);
659 return TRUE;
660 }
661
662 ////////////////////////////////////////////////////////////////////////////////
663 /// @brief \b Function \b Name: HAL_HWI2C_DMA_SetCmdLen
664 /// @brief \b Function \b Description: Set HWI2C DMA MIU command length
665 /// @param <IN> \b u8CmdLen : command length
666 /// @param <OUT> \b None :
667 /// @param <RET> \b TRUE : ok, FALSE : fail
668 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_DMA_SetCmdLen(MS_U32 u32PortOffset,MS_U8 u8CmdLen)669 static MS_BOOL HAL_HWI2C_DMA_SetCmdLen(MS_U32 u32PortOffset, MS_U8 u8CmdLen)
670 {
671 HWI2C_HAL_FUNC();
672 if(u8CmdLen>HWI2C_DMA_CMD_DATA_LEN)
673 return FALSE;
674 HAL_HWI2C_WriteByte(REG_HWI2C_DMA_CMDLEN+u32PortOffset, u8CmdLen&_DMA_CMDLEN_MSK);
675 return TRUE;
676 }
677
678 ////////////////////////////////////////////////////////////////////////////////
679 /// @brief \b Function \b Name: HAL_HWI2C_DMA_SetDataLen
680 /// @brief \b Function \b Description: Set HWI2C DMA data length
681 /// @param <IN> \b u32DataLen : data length
682 /// @param <OUT> \b None :
683 /// @param <RET> \b TRUE : ok, FALSE : fail
684 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_DMA_SetDataLen(MS_U32 u32PortOffset,MS_U32 u32DataLen)685 static MS_BOOL HAL_HWI2C_DMA_SetDataLen(MS_U32 u32PortOffset, MS_U32 u32DataLen)
686 {
687 MS_U32 u32DataLenSet;
688
689 HWI2C_HAL_FUNC();
690 u32DataLenSet = u32DataLen;
691 return HAL_HWI2C_Write4Byte(REG_HWI2C_DMA_DATLEN+u32PortOffset, u32DataLenSet);
692 }
693
694 #if 0 //will be used later
695 ////////////////////////////////////////////////////////////////////////////////
696 /// @brief \b Function \b Name: HAL_HWI2C_DMA_GetTxfrCnt
697 /// @brief \b Function \b Description: Get MIIC DMA Transfer Count
698 /// @param <IN> \b u32TxfrCnt : transfer count
699 /// @param <OUT> \b None :
700 /// @param <RET> \b None :
701 ////////////////////////////////////////////////////////////////////////////////
702 static MS_U32 HAL_HWI2C_DMA_GetTxfrCnt(MS_U32 u32PortOffset)
703 {
704 HWI2C_HAL_FUNC();
705 return HAL_HWI2C_Read4Byte(REG_HWI2C_DMA_TXFRCNT+u32PortOffset);
706 }
707 #endif
708
709 ////////////////////////////////////////////////////////////////////////////////
710 /// @brief \b Function \b Name: HAL_HWI2C_DMA_GetAddrMode
711 /// @brief \b Function \b Description: Set MIIC DMA Slave Device Address length mode
712 /// @param <IN> \b None :
713 /// @param <OUT> \b None :
714 /// @param <RET> \b E_HAL_HWI2C_DMA_ADDR_10BIT(10 bits mode),
715 /// \b E_HAL_HWI2C_DMA_ADDR_NORMAL(7 bits mode)
716 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_DMA_GetAddrMode(MS_U32 u32PortOffset)717 static HAL_HWI2C_DMA_ADDRMODE HAL_HWI2C_DMA_GetAddrMode(MS_U32 u32PortOffset)
718 {
719 HAL_HWI2C_DMA_ADDRMODE eAddrMode;
720
721 HWI2C_HAL_FUNC();
722 if(HAL_HWI2C_ReadByte(REG_HWI2C_DMA_SLVCFG+u32PortOffset) & _DMA_10BIT_MODE)
723 eAddrMode = E_HAL_HWI2C_DMA_ADDR_10BIT;
724 else
725 eAddrMode = E_HAL_HWI2C_DMA_ADDR_NORMAL;
726 return eAddrMode;
727 }
728
729 ////////////////////////////////////////////////////////////////////////////////
730 /// @brief \b Function \b Name: HAL_HWI2C_DMA_SetSlaveAddr
731 /// @brief \b Function \b Description: Set MIIC DMA Slave Device Address
732 /// @param <IN> \b u32TxfrCnt : slave device address
733 /// @param <OUT> \b None :
734 /// @param <RET> \b TRUE : ok, FALSE : fail
735 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_DMA_SetSlaveAddr(MS_U32 u32PortOffset,MS_U16 u16SlaveAddr)736 static MS_BOOL HAL_HWI2C_DMA_SetSlaveAddr(MS_U32 u32PortOffset, MS_U16 u16SlaveAddr)
737 {
738 HWI2C_HAL_FUNC();
739 if(HAL_HWI2C_DMA_GetAddrMode(u32PortOffset)==E_HAL_HWI2C_DMA_ADDR_10BIT)
740 return HAL_HWI2C_Write2Byte(REG_HWI2C_DMA_SLVADR+u32PortOffset, u16SlaveAddr&_DMA_SLVADR_10BIT_MSK);
741 else
742 return HAL_HWI2C_Write2Byte(REG_HWI2C_DMA_SLVADR+u32PortOffset, u16SlaveAddr&_DMA_SLVADR_NORML_MSK);
743 }
744
745 ////////////////////////////////////////////////////////////////////////////////
746 /// @brief \b Function \b Name: HAL_HWI2C_DMA_SetAddrMode
747 /// @brief \b Function \b Description: Set MIIC DMA Slave Device Address length mode
748 /// @param <IN> \b eAddrMode : E_HAL_HWI2C_DMA_ADDR_NORMAL, E_HAL_HWI2C_DMA_ADDR_10BIT
749 /// @param <OUT> \b None :
750 /// @param <RET> \b TRUE : ok, FALSE : fail
751 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_DMA_SetAddrMode(MS_U32 u32PortOffset,HAL_HWI2C_DMA_ADDRMODE eAddrMode)752 static MS_BOOL HAL_HWI2C_DMA_SetAddrMode(MS_U32 u32PortOffset, HAL_HWI2C_DMA_ADDRMODE eAddrMode)
753 {
754 MS_BOOL b10BitMode;
755
756 HWI2C_HAL_FUNC();
757 if(eAddrMode>=E_HAL_HWI2C_DMA_ADDR_MAX)
758 return FALSE;
759 b10BitMode = (eAddrMode==E_HAL_HWI2C_DMA_ADDR_10BIT)? TRUE : FALSE;
760 return HAL_HWI2C_WriteRegBit(REG_HWI2C_DMA_SLVCFG+u32PortOffset, _DMA_10BIT_MODE, b10BitMode);
761 }
762
HAL_HWI2C_DMA_SetMiuData(MS_U32 u32PortOffset,MS_U32 u32Length,MS_U8 * pu8SrcData)763 static MS_BOOL HAL_HWI2C_DMA_SetMiuData(MS_U32 u32PortOffset, MS_U32 u32Length, MS_U8* pu8SrcData)
764 {
765 MS_U32 u32PhyAddr = 0;
766 MS_VIRT *pMiuData = 0;
767 MS_U8 u8Port;
768
769 HWI2C_HAL_FUNC();
770
771 if(HAL_HWI2C_GetPortIdxByOffset(u32PortOffset,&u8Port)==FALSE)
772 return FALSE;
773 u32PhyAddr =(MS_U32) g_u32DmaPhyAddr[u8Port];
774 pMiuData = (MS_VIRT*)_PA2VA((MS_VIRT)u32PhyAddr);
775 memcpy((void*)pMiuData,(void*)pu8SrcData,u32Length);
776 HAL_HWI2C_DMA_SetDataLen(u32PortOffset,u32Length);
777 return TRUE;
778 }
779
HAL_HWI2C_DMA_GetMiuData(MS_U32 u32PortOffset,MS_U32 u32Length,MS_U8 * pu8DstData)780 static MS_BOOL HAL_HWI2C_DMA_GetMiuData(MS_U32 u32PortOffset, MS_U32 u32Length, MS_U8* pu8DstData)
781 {
782 MS_U32 u32PhyAddr = 0;
783 MS_U8 *pMiuData = 0;
784 MS_U8 u8Port;
785
786 HWI2C_HAL_FUNC();
787
788 if(HAL_HWI2C_GetPortIdxByOffset(u32PortOffset,&u8Port)==FALSE)
789 return FALSE;
790 u32PhyAddr = (MS_U32) g_u32DmaPhyAddr[u8Port];
791 pMiuData = (MS_U8*)_PA2VA((MS_VIRT)u32PhyAddr);
792 memcpy((void*)pu8DstData,(void*)pMiuData,u32Length);
793 return TRUE;
794 }
795
HAL_HWI2C_DMA_WaitDone(MS_U32 u32PortOffset,MS_U8 u8ReadWrite)796 static MS_BOOL HAL_HWI2C_DMA_WaitDone(MS_U32 u32PortOffset, MS_U8 u8ReadWrite)
797 {
798 MS_U16 volatile u16Timeout = HWI2C_DMA_WAIT_TIMEOUT;
799 MS_U8 u8Port;
800
801 HWI2C_HAL_FUNC();
802
803 //################
804 //
805 // IMPORTANT HERE !!!
806 //
807 //################
808 MsOS_FlushMemory();
809 //(2-1) reset DMA engine
810 HAL_HWI2C_DMA_Reset(u32PortOffset,TRUE);
811 HAL_HWI2C_DMA_Reset(u32PortOffset,FALSE);
812 //(2-2) reset MIU module in DMA engine
813 HAL_HWI2C_DMA_MiuReset(u32PortOffset,TRUE);
814 HAL_HWI2C_DMA_MiuReset(u32PortOffset,FALSE);
815
816
817 //get port index for delay factor
818 HAL_HWI2C_GetPortIdxByOffset(u32PortOffset,&u8Port);
819 //clear transfer dine first for savfty
820 HAL_HWI2C_DMA_TxfrDone(u32PortOffset);
821 //set command : 0 for Write, 1 for Read
822 HAL_HWI2C_DMA_SetRdWrt(u32PortOffset,u8ReadWrite);
823 //issue write trigger
824 HAL_HWI2C_DMA_Trigger(u32PortOffset);
825 //check transfer done
826 while(u16Timeout--)
827 {
828 if(HAL_HWI2C_DMA_IsTxfrDone(u32PortOffset,u8Port))
829 {
830 HAL_HWI2C_DMA_TxfrDone(u32PortOffset);
831 HWI2C_HAL_INFO("[DMA]: Transfer DONE!\n");
832 return TRUE;
833 }
834 }
835 HWI2C_HAL_ERR("[DMA]: Transfer NOT Completely!\n");
836 return FALSE;
837 }
838
HAL_HWI2C_DMA_SetDelayFactor(MS_U32 u32PortOffset,HAL_HWI2C_CLKSEL eClkSel)839 static MS_BOOL HAL_HWI2C_DMA_SetDelayFactor(MS_U32 u32PortOffset, HAL_HWI2C_CLKSEL eClkSel)
840 {
841 MS_U8 u8Port;
842
843 HWI2C_HAL_FUNC();
844
845 if(HAL_HWI2C_GetPortIdxByOffset(u32PortOffset,&u8Port)==FALSE)
846 {
847 g_u16DmaDelayFactor[u8Port]=5;
848 return FALSE;
849 }
850 switch(eClkSel)//use Xtal = 24M Hz
851 {
852 case E_HAL_HWI2C_CLKSEL_HIGH: // 400 KHz
853 g_u16DmaDelayFactor[u8Port]=1; break;
854 case E_HAL_HWI2C_CLKSEL_NORMAL: //300 KHz
855 g_u16DmaDelayFactor[u8Port]=1; break;
856 case E_HAL_HWI2C_CLKSEL_SLOW: //200 KHz
857 g_u16DmaDelayFactor[u8Port]=1; break;
858 case E_HAL_HWI2C_CLKSEL_VSLOW: //100 KHz
859 g_u16DmaDelayFactor[u8Port]=2; break;
860 case E_HAL_HWI2C_CLKSEL_USLOW: //50 KHz
861 g_u16DmaDelayFactor[u8Port]=3; break;
862 case E_HAL_HWI2C_CLKSEL_UVSLOW: //25 KHz
863 g_u16DmaDelayFactor[u8Port]=3; break;
864 default:
865 g_u16DmaDelayFactor[u8Port]=5;
866 return FALSE;
867 }
868 return TRUE;
869 }
870
871 //#####################
872 //
873 // MIIC STD Related Functions
874 // External
875 //
876 //#####################
877 ////////////////////////////////////////////////////////////////////////////////
878 /// @brief \b Function \b Name: HAL_HWI2C_Init_Chip
879 /// @brief \b Function \b Description: Init HWI2C chip
880 /// @param <IN> \b None :
881 /// @param <OUT> \b None :
882 /// @param <RET> \b TRUE : ok, FALSE : fail
883 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_Init_Chip(void)884 MS_BOOL HAL_HWI2C_Init_Chip(void)
885 {
886 MS_BOOL bRet = TRUE;
887
888 HWI2C_HAL_FUNC();
889 //not set all pads (except SPI) as input
890 bRet &= HAL_HWI2C_WriteRegBit(CHIP_REG_ALLPADIN, CHIP_ALLPAD_IN, FALSE);
891 return bRet;
892 }
893
894 ////////////////////////////////////////////////////////////////////////////////
895 /// @brief \b Function \b Name: HAL_HWI2C_IsMaster
896 /// @brief \b Function \b Description: Check if Master I2C
897 /// @param <IN> \b None :
898 /// @param <OUT> \b None :
899 /// @param <RET> \b TRUE: Master, FALSE: Slave
900 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_IsMaster(void)901 MS_BOOL HAL_HWI2C_IsMaster(void)
902 {
903 HWI2C_HAL_FUNC();
904 return TRUE;
905 }
906
907 ////////////////////////////////////////////////////////////////////////////////
908 /// @brief \b Function \b Name: HAL_HWI2C_Master_Enable
909 /// @brief \b Function \b Description: Master I2C enable
910 /// @param <IN> \b None :
911 /// @param <OUT> \b None :
912 /// @param <RET> \b TRUE : ok, FALSE : fail
913 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_Master_Enable(MS_U32 u32PortOffset)914 MS_BOOL HAL_HWI2C_Master_Enable(MS_U32 u32PortOffset)
915 {
916 MS_U8 u8Port;
917 MS_BOOL bRet;
918
919 HWI2C_HAL_FUNC();
920
921 if(HAL_HWI2C_GetPortIdxByOffset(u32PortOffset,&u8Port)==FALSE)
922 return FALSE;
923 g_bLastByte[u8Port] = FALSE;
924
925 //(1) clear interrupt
926 HAL_HWI2C_Clear_INT(u32PortOffset);
927 //(2) reset standard master iic
928 HAL_HWI2C_Reset(u32PortOffset,TRUE);
929 HAL_HWI2C_Reset(u32PortOffset,FALSE);
930 //(3) configuration
931 HAL_HWI2C_EnINT(u32PortOffset,TRUE);
932 HAL_HWI2C_EnClkStretch(u32PortOffset,TRUE);
933 HAL_HWI2C_EnFilter(u32PortOffset,TRUE);
934 HAL_HWI2C_EnPushSda(u32PortOffset,TRUE);
935 #if 0
936 HAL_HWI2C_EnTimeoutINT(u32PortOffset,TRUE);
937 HAL_HWI2C_Write2Byte(REG_HWI2C_TMT_CNT+u32PortOffset, 0x100);
938 #endif
939 //(4) Disable DMA
940 bRet = HAL_HWI2C_DMA_Enable(u32PortOffset,FALSE);
941
942 return bRet;
943 }
944
945 ////////////////////////////////////////////////////////////////////////////////
946 /// @brief \b Function \b Name: HAL_HWI2C_SetPortRegOffset
947 /// @brief \b Function \b Description: Set HWI2C port register offset
948 /// @param <IN> \b ePort : HWI2C port number
949 /// @param <OUT> \b pu32PortOffset : port register offset
950 /// @param <RET> \b TRUE : ok, FALSE : fail
951 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_SetPortRegOffset(HAL_HWI2C_PORT ePort,MS_U32 * pu32PortOffset)952 MS_BOOL HAL_HWI2C_SetPortRegOffset(HAL_HWI2C_PORT ePort, MS_U32* pu32PortOffset)
953 {
954 HWI2C_HAL_FUNC();
955
956 if((ePort>=E_HAL_HWI2C_PORT0_0)&&(ePort<=E_HAL_HWI2C_PORT0_7))
957 {//port 0 : bank register address 0x111800
958 *pu32PortOffset = (MS_U32)0x00;
959 }
960 else if((ePort>=E_HAL_HWI2C_PORT1_0)&&(ePort<=E_HAL_HWI2C_PORT1_7))
961 {//port 1 : bank register address 0x111900
962 *pu32PortOffset = (MS_U32)0x100;
963 }
964 else if((ePort>=E_HAL_HWI2C_PORT2_0)&&(ePort<=E_HAL_HWI2C_PORT2_7))
965 {//port 2 : bank register address 0x111A00
966 *pu32PortOffset = (MS_U32)0x200;
967 }
968 else if((ePort>=E_HAL_HWI2C_PORT3_0)&&(ePort<=E_HAL_HWI2C_PORT3_7))
969 {//port 3 : bank register address 0x111B00
970 *pu32PortOffset = (MS_U32)0x300;
971 }
972 else if((ePort>=E_HAL_HWI2C_PORT4_0)&&(ePort<=E_HAL_HWI2C_PORT4_7))
973 {//port 4 : bank register address 0x121C00
974 *pu32PortOffset = (MS_U32)0x10400;
975 }
976 else if((ePort>=E_HAL_HWI2C_PORT5_0)&&(ePort<=E_HAL_HWI2C_PORT5_7))
977 {//port 5 : bank register address 0x122C00
978 *pu32PortOffset = (MS_U32)0x10500;
979 }
980 else
981 {
982 *pu32PortOffset = (MS_U32)0x00;
983 return FALSE;
984 }
985 return TRUE;
986 }
987
988 ////////////////////////////////////////////////////////////////////////////////
989 /// @brief \b Function \b Name: HAL_HWI2C_GetPortIdxByRegOffset
990 /// @brief \b Function \b Description: Get HWI2C port index by register offset
991 /// @param <IN> \b u16Offset : port register offset
992 /// @param <OUT> \b pu8Port : port index
993 /// @param <RET> \b TRUE : ok, FALSE : fail
994 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_GetPortIdxByOffset(MS_U32 u32PortOffset,MS_U8 * pu8Port)995 MS_BOOL HAL_HWI2C_GetPortIdxByOffset(MS_U32 u32PortOffset, MS_U8* pu8Port)
996 {
997 HWI2C_HAL_FUNC();
998
999 if(u32PortOffset==(MS_U32)0x00)
1000 {//port 0 : bank register address 0x11800
1001 *pu8Port = HAL_HWI2C_PORT0;
1002 }
1003 else if(u32PortOffset==(MS_U32)0x100)
1004 {//port 1 : bank register address 0x11900
1005 *pu8Port = HAL_HWI2C_PORT1;
1006 }
1007 else if(u32PortOffset==(MS_U32)0x200)
1008 {//port 2 : bank register address 0x11A00
1009 *pu8Port = HAL_HWI2C_PORT2;
1010 }
1011 else if(u32PortOffset==(MS_U32)0x300)
1012 {//port 3 : bank register address 0x11B00
1013 *pu8Port = HAL_HWI2C_PORT3;
1014 }
1015 else if(u32PortOffset==(MS_U32)0x10400)
1016 {//port 3 : bank register address 0x121C00
1017 *pu8Port = HAL_HWI2C_PORT4;
1018 }
1019 else if(u32PortOffset==(MS_U32)0x10500)
1020 {//port 3 : bank register address 0x122C00
1021 *pu8Port = HAL_HWI2C_PORT5;
1022 }
1023 else
1024 {
1025 *pu8Port = HAL_HWI2C_PORT0;
1026 return FALSE;
1027 }
1028 return TRUE;
1029 }
1030
1031 ////////////////////////////////////////////////////////////////////////////////
1032 /// @brief \b Function \b Name: HAL_HWI2C_GetPortIdxByPort
1033 /// @brief \b Function \b Description: Get HWI2C port index by port number
1034 /// @param <IN> \b ePort : port number
1035 /// @param <OUT> \b pu8Port : port index
1036 /// @param <RET> \b TRUE : ok, FALSE : fail
1037 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_GetPortIdxByPort(HAL_HWI2C_PORT ePort,MS_U8 * pu8Port)1038 MS_BOOL HAL_HWI2C_GetPortIdxByPort(HAL_HWI2C_PORT ePort, MS_U8* pu8Port)
1039 {
1040 HWI2C_HAL_FUNC();
1041
1042 if((ePort>=E_HAL_HWI2C_PORT0_0)&&(ePort<=E_HAL_HWI2C_PORT0_7))
1043 {
1044 *pu8Port = HAL_HWI2C_PORT0;
1045 }
1046 else if((ePort>=E_HAL_HWI2C_PORT1_0)&&(ePort<=E_HAL_HWI2C_PORT1_7))
1047 {
1048 *pu8Port = HAL_HWI2C_PORT1;
1049 }
1050 else if((ePort>=E_HAL_HWI2C_PORT2_0)&&(ePort<=E_HAL_HWI2C_PORT2_7))
1051 {
1052 *pu8Port = HAL_HWI2C_PORT2;
1053 }
1054 else if((ePort>=E_HAL_HWI2C_PORT3_0)&&(ePort<=E_HAL_HWI2C_PORT3_7))
1055 {
1056 *pu8Port = HAL_HWI2C_PORT3;
1057 }
1058 else if((ePort>=E_HAL_HWI2C_PORT4_0)&&(ePort<=E_HAL_HWI2C_PORT4_7))
1059 {
1060 *pu8Port = HAL_HWI2C_PORT4;
1061 }
1062 else if((ePort>=E_HAL_HWI2C_PORT5_0)&&(ePort<=E_HAL_HWI2C_PORT5_7))
1063 {
1064 *pu8Port = HAL_HWI2C_PORT5;
1065 }
1066 else
1067 {
1068 *pu8Port = HAL_HWI2C_PORT0;
1069 return FALSE;
1070 }
1071 return TRUE;
1072 }
1073
1074 ////////////////////////////////////////////////////////////////////////////////
1075 /// @brief \b Function \b Name: HAL_HWI2C_SelectPort
1076 /// @brief \b Function \b Description: Select HWI2C port
1077 /// @param <IN> \b None : HWI2C port
1078 /// @param param \b None :
1079 /// @param <RET> \b TRUE : ok, FALSE : fail
1080 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_SelectPort(HAL_HWI2C_PORT ePort)1081 MS_BOOL HAL_HWI2C_SelectPort(HAL_HWI2C_PORT ePort)
1082 {
1083 MS_U8 u8Value1=0;
1084
1085 HWI2C_HAL_FUNC();
1086
1087 //decide port mask
1088 if((ePort>=E_HAL_HWI2C_PORT0_0)&&(ePort<=E_HAL_HWI2C_PORT0_7))//port 0
1089 {
1090 switch(ePort)
1091 {
1092 case E_HAL_HWI2C_PORT0_0: //miic0 disable
1093 HAL_HWI2C_WriteByteMask(CHIP_REG_HWI2C_MIIC0, CHIP_MIIC0_PAD_0, CHIP_MIIC0_PAD_MSK);
1094 break;
1095 case E_HAL_HWI2C_PORT0_1: //miic0 using PAD_GPIO28/PAD_GPIO29
1096 HAL_HWI2C_WriteByteMask(CHIP_REG_HWI2C_MIIC0, CHIP_MIIC0_PAD_1, CHIP_MIIC0_PAD_MSK);
1097 break;
1098 default:
1099 return FALSE;
1100 }
1101 }
1102 else if((ePort>=E_HAL_HWI2C_PORT1_0)&&(ePort<=E_HAL_HWI2C_PORT1_7))//port 1
1103 {
1104 switch(ePort)
1105 {
1106 case E_HAL_HWI2C_PORT1_0: //miic1 disable
1107 u8Value1 = CHIP_MIIC1_PAD_0;
1108 break;
1109 case E_HAL_HWI2C_PORT1_1: //miic1 using PAD_TGPIO2/PAD_TGPIO3
1110 u8Value1 = CHIP_MIIC1_PAD_1;
1111 break;
1112 default:
1113 return FALSE;
1114 }
1115 HAL_HWI2C_WriteByteMask(CHIP_REG_HWI2C_MIIC1, u8Value1, CHIP_MIIC1_PAD_MSK);
1116 }
1117 else if((ePort>=E_HAL_HWI2C_PORT2_0)&&(ePort<=E_HAL_HWI2C_PORT2_7))//port 2
1118 {
1119 HAL_HWI2C_WriteByteMask(CHIP_REG_HWI2C_MIIC2, CHIP_MIIC2_PAD_0, CHIP_MIIC2_PAD_MSK);
1120 HAL_HWI2C_WriteByteMask(CHIP_REG_HWI2C_MIIC3, CHIP_MIIC3_PAD_0, CHIP_MIIC3_PAD_MSK);
1121 switch(ePort)
1122 {
1123 case E_HAL_HWI2C_PORT2_0: //miic2 disable
1124 break;
1125 case E_HAL_HWI2C_PORT2_1: //miic2 using PAD_I2S_IN_BCK/PAD_I2S_IN_SD
1126 HAL_HWI2C_WriteByteMask(CHIP_REG_HWI2C_MIIC2, CHIP_MIIC2_PAD_1, CHIP_MIIC2_PAD_MSK);
1127 break;
1128 case E_HAL_HWI2C_PORT2_2: //miic3 using PAD_GPIO36/PAD_GPIO37
1129 HAL_HWI2C_WriteByteMask(CHIP_REG_HWI2C_MIIC3, CHIP_MIIC3_PAD_1, CHIP_MIIC3_PAD_MSK);
1130 break;
1131 default:
1132 return FALSE;
1133 }
1134 }
1135 else if((ePort>=E_HAL_HWI2C_PORT3_0)&&(ePort<=E_HAL_HWI2C_PORT3_7))//port 3
1136 {
1137 HAL_HWI2C_WriteByteMask(CHIP_REG_HWI2C_DDCR, CHIP_DDCR_PAD_0, CHIP_DDCR_PAD_MSK);
1138 switch(ePort)
1139 {
1140 case E_HAL_HWI2C_PORT3_0: //ddcr_miic disable
1141 HAL_HWI2C_WriteByteMask(CHIP_REG_HWI2C_DDCR, CHIP_DDCR_PAD_0, CHIP_DDCR_PAD_MSK);
1142 break;
1143 case E_HAL_HWI2C_PORT3_1: //ddcr_miic using PAD_DDCR_CK/PAD_DDCR_DA
1144 HAL_HWI2C_WriteByteMask(CHIP_REG_HWI2C_DDCR, CHIP_DDCR_PAD_1, CHIP_DDCR_PAD_MSK);
1145 break;
1146 default:
1147 return FALSE;
1148 }
1149 }
1150 else if((ePort>=E_HAL_HWI2C_PORT4_0)&&(ePort<=E_HAL_HWI2C_PORT4_7))//port 4
1151 {
1152 switch(ePort)
1153 {
1154 case E_HAL_HWI2C_PORT4_0: //miic2 disable
1155 u8Value1 = CHIP_MIIC4_PAD_0;
1156 break;
1157 case E_HAL_HWI2C_PORT4_1: //miic2 using PAD_GPIO30/PAD_GPIO31
1158 u8Value1 = CHIP_MIIC4_PAD_1;
1159 break;
1160 default:
1161 return FALSE;
1162 }
1163 HAL_HWI2C_WriteByteMask(CHIP_REG_HWI2C_MIIC4, u8Value1, CHIP_MIIC4_PAD_MSK);
1164 }
1165 else if((ePort>=E_HAL_HWI2C_PORT5_0)&&(ePort<=E_HAL_HWI2C_PORT5_7))//port 5
1166 {
1167 switch(ePort)
1168 {
1169 case E_HAL_HWI2C_PORT5_0: //miic2 disable
1170 u8Value1 = CHIP_MIIC5_PAD_0;
1171 break;
1172 case E_HAL_HWI2C_PORT5_1: //miic2 using PAD_GPIO32/PAD_GPIO33
1173 u8Value1 = CHIP_MIIC5_PAD_1;
1174 break;
1175 default:
1176 return FALSE;
1177 }
1178 HAL_HWI2C_WriteByteMask(CHIP_REG_HWI2C_MIIC5, u8Value1, CHIP_MIIC5_PAD_MSK);
1179 }
1180 else
1181 {
1182 return FALSE;
1183 }
1184 return TRUE;
1185 }
1186
1187 ////////////////////////////////////////////////////////////////////////////////
1188 /// @brief \b Function \b Name: HAL_HWI2C_SetClk
1189 /// @brief \b Function \b Description: Set I2C clock
1190 /// @param <IN> \b u8Clk: clock rate
1191 /// @param <OUT> \b None :
1192 /// @param <RET> \b TRUE : ok, FALSE : fail
1193 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_SetClk(MS_U32 u32PortOffset,HAL_HWI2C_CLKSEL eClkSel)1194 MS_BOOL HAL_HWI2C_SetClk(MS_U32 u32PortOffset, HAL_HWI2C_CLKSEL eClkSel)
1195 {
1196 MS_U16 u16ClkHCnt=0,u16ClkLCnt=0;
1197 MS_U16 u16StpCnt=0,u16SdaCnt=0,u16SttCnt=0,u16LchCnt=0;
1198
1199 HWI2C_HAL_FUNC();
1200
1201 if(eClkSel>=E_HAL_HWI2C_CLKSEL_NOSUP)
1202 return FALSE;
1203
1204 switch(eClkSel)//use Xtal = 12M Hz
1205 {
1206 case E_HAL_HWI2C_CLKSEL_HIGH: // 400 KHz
1207 u16ClkHCnt = 9; u16ClkLCnt = 13; break;
1208 case E_HAL_HWI2C_CLKSEL_NORMAL: //300 KHz
1209 u16ClkHCnt = 15; u16ClkLCnt = 17; break;
1210 case E_HAL_HWI2C_CLKSEL_SLOW: //200 KHz
1211 u16ClkHCnt = 25; u16ClkLCnt = 27; break;
1212 case E_HAL_HWI2C_CLKSEL_VSLOW: //100 KHz
1213 u16ClkHCnt = 55; u16ClkLCnt = 57; break;
1214 case E_HAL_HWI2C_CLKSEL_USLOW: //50 KHz
1215 u16ClkHCnt = 115; u16ClkLCnt = 117; break;
1216 case E_HAL_HWI2C_CLKSEL_UVSLOW: //25 KHz
1217 u16ClkHCnt = 235; u16ClkLCnt = 237; break;
1218 default:
1219 u16ClkHCnt = 15; u16ClkLCnt = 17; break;
1220 }
1221 u16SttCnt=8; u16StpCnt=8; u16SdaCnt=5; u16LchCnt=5;
1222
1223 HAL_HWI2C_Write2Byte(REG_HWI2C_CKH_CNT+u32PortOffset, u16ClkHCnt);
1224 HAL_HWI2C_Write2Byte(REG_HWI2C_CKL_CNT+u32PortOffset, u16ClkLCnt);
1225 HAL_HWI2C_Write2Byte(REG_HWI2C_STP_CNT+u32PortOffset, u16StpCnt);
1226 HAL_HWI2C_Write2Byte(REG_HWI2C_SDA_CNT+u32PortOffset, u16SdaCnt);
1227 HAL_HWI2C_Write2Byte(REG_HWI2C_STT_CNT+u32PortOffset, u16SttCnt);
1228 HAL_HWI2C_Write2Byte(REG_HWI2C_LTH_CNT+u32PortOffset, u16LchCnt);
1229 //HAL_HWI2C_Write2Byte(REG_HWI2C_TMT_CNT+u32PortOffset, 0x0000);
1230 return TRUE;
1231 }
1232
1233 ////////////////////////////////////////////////////////////////////////////////
1234 /// @brief \b Function \b Name: HAL_HWI2C_Start
1235 /// @brief \b Function \b Description: Send start condition
1236 /// @param <IN> \b None :
1237 /// @param <OUT> \b None :
1238 /// @param <RET> \b TRUE : ok, FALSE : fail
1239 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_Start(MS_U32 u32PortOffset)1240 MS_BOOL HAL_HWI2C_Start(MS_U32 u32PortOffset)
1241 {
1242 MS_U16 u16Count = HWI2C_HAL_WAIT_TIMEOUT;
1243
1244 HWI2C_HAL_FUNC();
1245
1246 //reset I2C
1247 HAL_HWI2C_WriteRegBit(REG_HWI2C_CMD_START+u32PortOffset, _CMD_START, TRUE);
1248 while((!HAL_HWI2C_Is_INT(u32PortOffset))&&(u16Count > 0))
1249 u16Count--;
1250 HAL_HWI2C_Clear_INT(u32PortOffset);
1251 return (u16Count)? TRUE:FALSE;
1252 }
1253
1254 ////////////////////////////////////////////////////////////////////////////////
1255 /// @brief \b Function \b Name: HAL_HWI2C_Stop
1256 /// @brief \b Function \b Description: Send Stop condition
1257 /// @param <IN> \b None :
1258 /// @param <OUT> \b None :
1259 /// @param <RET> \b TRUE : ok, FALSE : fail
1260 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_Stop(MS_U32 u32PortOffset)1261 MS_BOOL HAL_HWI2C_Stop(MS_U32 u32PortOffset)
1262 {
1263 MS_U16 u16Count = HWI2C_HAL_WAIT_TIMEOUT;
1264
1265 HWI2C_HAL_FUNC();
1266
1267 HAL_HWI2C_WriteRegBit(REG_HWI2C_CMD_STOP+u32PortOffset, _CMD_STOP, TRUE);
1268 while((!HAL_HWI2C_Is_Idle(u32PortOffset))&&(!HAL_HWI2C_Is_INT(u32PortOffset))&&(u16Count > 0))
1269 u16Count--;
1270 HAL_HWI2C_Clear_INT(u32PortOffset);
1271 return (u16Count)? TRUE:FALSE;
1272 }
1273
1274 ////////////////////////////////////////////////////////////////////////////////
1275 /// @brief \b Function \b Name: HAL_HWI2C_ReadRdy
1276 /// @brief \b Function \b Description: Start byte reading
1277 /// @param <IN> \b None :
1278 /// @param <OUT> \b None :
1279 /// @param <RET> \b TRUE : ok, FALSE : fail
1280 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_ReadRdy(MS_U32 u32PortOffset)1281 MS_BOOL HAL_HWI2C_ReadRdy(MS_U32 u32PortOffset)
1282 {
1283 MS_U8 u8Value=0;
1284 MS_U8 u8Port;
1285
1286 HWI2C_HAL_FUNC();
1287
1288 if(HAL_HWI2C_GetPortIdxByOffset(u32PortOffset,&u8Port)==FALSE)
1289 return FALSE;
1290 u8Value = (g_bLastByte[u8Port])? (_RDATA_CFG_TRIG|_RDATA_CFG_ACKBIT) : (_RDATA_CFG_TRIG);
1291 g_bLastByte[u8Port] = FALSE;
1292 return HAL_HWI2C_WriteByte(REG_HWI2C_RDATA_CFG+u32PortOffset, u8Value);
1293 }
1294
1295 ////////////////////////////////////////////////////////////////////////////////
1296 /// @brief \b Function \b Name: HAL_HWI2C_SendData
1297 /// @brief \b Function \b Description: Send 1 byte data to SDA
1298 /// @param <IN> \b None :
1299 /// @param <OUT> \b None :
1300 /// @param <RET> \b TRUE : ok, FALSE : fail
1301 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_SendData(MS_U32 u32PortOffset,MS_U8 u8Data)1302 MS_BOOL HAL_HWI2C_SendData(MS_U32 u32PortOffset, MS_U8 u8Data)
1303 {
1304 HWI2C_HAL_FUNC();
1305
1306 return HAL_HWI2C_WriteByte(REG_HWI2C_WDATA+u32PortOffset, u8Data);
1307 }
1308
1309 ////////////////////////////////////////////////////////////////////////////////
1310 /// @brief \b Function \b Name: HAL_HWI2C_RecvData
1311 /// @brief \b Function \b Description: Receive 1 byte data from SDA
1312 /// @param <IN> \b None :
1313 /// @param <OUT> \b None :
1314 /// @param <RET> \b MS_U8 :
1315 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_RecvData(MS_U32 u32PortOffset)1316 MS_U8 HAL_HWI2C_RecvData(MS_U32 u32PortOffset)
1317 {
1318 HWI2C_HAL_FUNC();
1319
1320 return HAL_HWI2C_ReadByte(REG_HWI2C_RDATA+u32PortOffset);
1321 }
1322
1323 ////////////////////////////////////////////////////////////////////////////////
1324 /// @brief \b Function \b Name: HAL_HWI2C_Get_SendAck
1325 /// @brief \b Function \b Description: Get ack after sending data
1326 /// @param <IN> \b None :
1327 /// @param <OUT> \b None :
1328 /// @param <RET> \b TRUE: Valid ack, FALSE: No ack
1329 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_Get_SendAck(MS_U32 u32PortOffset)1330 MS_BOOL HAL_HWI2C_Get_SendAck(MS_U32 u32PortOffset)
1331 {
1332 HWI2C_HAL_FUNC();
1333
1334 return (HAL_HWI2C_ReadByte(REG_HWI2C_WDATA_GET+u32PortOffset) & _WDATA_GET_ACKBIT) ? FALSE : TRUE;
1335 }
1336
1337 ////////////////////////////////////////////////////////////////////////////////
1338 /// @brief \b Function \b Name: HAL_HWI2C_NoAck
1339 /// @brief \b Function \b Description: generate no ack pulse
1340 /// @param <IN> \b None :
1341 /// @param <OUT> \b None :
1342 /// @param <RET> \b TRUE : ok, FALSE : fail
1343 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_NoAck(MS_U32 u32PortOffset)1344 MS_BOOL HAL_HWI2C_NoAck(MS_U32 u32PortOffset)
1345 {
1346 MS_U8 u8Port;
1347
1348 HWI2C_HAL_FUNC();
1349
1350 if(HAL_HWI2C_GetPortIdxByOffset(u32PortOffset,&u8Port)==FALSE)
1351 return FALSE;
1352 g_bLastByte[u8Port] = TRUE;
1353 return TRUE;
1354 }
1355
1356 ////////////////////////////////////////////////////////////////////////////////
1357 /// @brief \b Function \b Name: HAL_HWI2C_Ack
1358 /// @brief \b Function \b Description: generate ack pulse
1359 /// @param <IN> \b None :
1360 /// @param <OUT> \b None :
1361 /// @param <RET> \b TRUE : ok, FALSE : fail
1362 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_Ack(MS_U32 u32PortOffset)1363 MS_BOOL HAL_HWI2C_Ack(MS_U32 u32PortOffset)
1364 {
1365 MS_U8 u8Port;
1366
1367 HWI2C_HAL_FUNC();
1368
1369 if(HAL_HWI2C_GetPortIdxByOffset(u32PortOffset,&u8Port)==FALSE)
1370 return FALSE;
1371 g_bLastByte[u8Port] = FALSE;
1372 return TRUE;
1373 }
1374
1375 ////////////////////////////////////////////////////////////////////////////////
1376 /// @brief \b Function \b Name: HAL_HWI2C_GetStae
1377 /// @brief \b Function \b Description: Get i2c Current State
1378 /// @param <IN> \b u32PortOffset: HWI2C Port Offset
1379 /// @param <OUT> \b None
1380 /// @param <RET> \b HWI2C current status
1381 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_GetState(MS_U32 u32PortOffset)1382 MS_U8 HAL_HWI2C_GetState(MS_U32 u32PortOffset)
1383 {
1384 HWI2C_HAL_FUNC();
1385
1386 MS_U8 cur_state = HAL_HWI2C_ReadByte(REG_HWI2C_CUR_STATE+u32PortOffset) & _CUR_STATE_MSK;
1387
1388 if (cur_state <= 0) // 0: idle
1389 return E_HAL_HWI2C_STATE_IDEL;
1390 else if (cur_state <= 2) // 1~2:start
1391 return E_HAL_HWI2C_STATE_START;
1392 else if (cur_state <= 6) // 3~6:write
1393 return E_HAL_HWI2C_STATE_WRITE;
1394 else if (cur_state <= 10) // 7~10:read
1395 return E_HAL_HWI2C_STATE_READ;
1396 else if (cur_state <= 11) // 11:interrupt
1397 return E_HAL_HWI2C_STATE_INT;
1398 else if (cur_state <= 12) // 12:wait
1399 return E_HAL_HWI2C_STATE_WAIT;
1400 else // 13~15:stop
1401 return E_HAL_HWI2C_STATE_STOP;
1402 }
1403
1404 ////////////////////////////////////////////////////////////////////////////////
1405 /// @brief \b Function \b Name: HAL_HWI2C_Is_Idle
1406 /// @brief \b Function \b Description: Check if i2c is idle
1407 /// @param <IN> \b u32PortOffset: HWI2C Port Offset
1408 /// @param <OUT> \b None
1409 /// @param <RET> \b TRUE : idle, FALSE : not idle
1410 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_Is_Idle(MS_U32 u32PortOffset)1411 MS_BOOL HAL_HWI2C_Is_Idle(MS_U32 u32PortOffset)
1412 {
1413 HWI2C_HAL_FUNC();
1414
1415 return ((HAL_HWI2C_GetState(u32PortOffset)==E_HAL_HWI2C_STATE_IDEL) ? TRUE : FALSE);
1416 }
1417
1418 ////////////////////////////////////////////////////////////////////////////////
1419 /// @brief \b Function \b Name: HAL_HWI2C_Is_INT
1420 /// @brief \b Function \b Description: Check if i2c is interrupted
1421 /// @param <IN> \b u8Status : queried status
1422 /// @param <IN> \b u8Ch: Channel 0/1
1423 /// @param <OUT> \b None
1424 /// @param <RET> \b TRUE : ok, FALSE : fail
1425 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_Is_INT(MS_U32 u32PortOffset)1426 MS_BOOL HAL_HWI2C_Is_INT(MS_U32 u32PortOffset)
1427 {
1428 HWI2C_HAL_FUNC();
1429
1430 return (HAL_HWI2C_ReadByte(REG_HWI2C_INT_CTL+u32PortOffset) & _INT_CTL) ? TRUE : FALSE;
1431 }
1432
1433 ////////////////////////////////////////////////////////////////////////////////
1434 /// @brief \b Function \b Name: HAL_HWI2C_Clear_INT
1435 /// @brief \b Function \b Description: Enable interrupt for HWI2C
1436 /// @param <IN> \b None :
1437 /// @param <OUT> \b None :
1438 /// @param <RET> \b TRUE : ok, FALSE : fail
1439 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_Clear_INT(MS_U32 u32PortOffset)1440 MS_BOOL HAL_HWI2C_Clear_INT(MS_U32 u32PortOffset)
1441 {
1442 HWI2C_HAL_FUNC();
1443
1444 return HAL_HWI2C_WriteRegBit(REG_HWI2C_INT_CTL+u32PortOffset, _INT_CTL, TRUE);
1445 }
1446
1447 ////////////////////////////////////////////////////////////////////////////////
1448 /// @brief \b Function \b Name: HAL_HWI2C_Reset
1449 /// @brief \b Function \b Description: Reset HWI2C state machine
1450 /// @param <IN> \b bReset : TRUE: Reset FALSE: Not reset
1451 /// @param <OUT> \b None :
1452 /// @param <RET> \b TRUE: Ok, FALSE: Fail
1453 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_Reset(MS_U32 u32PortOffset,MS_BOOL bReset)1454 MS_BOOL HAL_HWI2C_Reset(MS_U32 u32PortOffset, MS_BOOL bReset)
1455 {
1456 HWI2C_HAL_FUNC();
1457
1458 return HAL_HWI2C_WriteRegBit(REG_HWI2C_MIIC_CFG+u32PortOffset, _MIIC_CFG_RESET, bReset);
1459 }
1460
1461 ////////////////////////////////////////////////////////////////////////////////
1462 /// @brief \b Function \b Name: HAL_HWI2C_Send_Byte
1463 /// @brief \b Function \b Description: Send one byte
1464 /// @param u8Data \b IN: 1 byte data
1465 /// @return \b TRUE: Success FALSE: Fail
1466 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_Send_Byte(MS_U32 u32PortOffset,MS_U8 u8Data)1467 MS_BOOL HAL_HWI2C_Send_Byte(MS_U32 u32PortOffset, MS_U8 u8Data)
1468 {
1469 MS_U8 u8Retry = HWI2C_HAL_RETRY_TIMES;
1470 MS_U16 u16Count = HWI2C_HAL_WAIT_TIMEOUT;
1471
1472 HWI2C_HAL_FUNC();
1473
1474 while(u8Retry--)
1475 {
1476 HAL_HWI2C_Clear_INT(u32PortOffset);
1477 if (HAL_HWI2C_SendData(u32PortOffset,u8Data))
1478 {
1479 u16Count = HWI2C_HAL_WAIT_TIMEOUT;
1480 while(u16Count--)
1481 {
1482 if (HAL_HWI2C_Is_INT(u32PortOffset))
1483 {
1484 HAL_HWI2C_Clear_INT(u32PortOffset);
1485 if (HAL_HWI2C_Get_SendAck(u32PortOffset))
1486 {
1487 #if 1
1488 HAL_HWI2C_ExtraDelay(1);
1489 #else
1490 MsOS_DelayTaskUs(1);
1491 #endif
1492 return TRUE;
1493 }
1494 break;
1495 }
1496 }
1497 }
1498 }
1499 HWI2C_HAL_ERR("Send byte 0x%X fail!\n", u8Data);
1500 return FALSE;
1501 }
1502
1503 ////////////////////////////////////////////////////////////////////////////////
1504 /// @brief \b Function \b Name: HAL_HWI2C_Recv_Byte
1505 /// @brief \b Function \b Description: Init HWI2C driver and auto generate ACK
1506 /// @param *pData \b Out: received data
1507 /// @return \b TRUE: Success FALSE: Fail
1508 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_Recv_Byte(MS_U32 u32PortOffset,MS_U8 * pData)1509 MS_BOOL HAL_HWI2C_Recv_Byte(MS_U32 u32PortOffset, MS_U8 *pData)
1510 {
1511 MS_U16 u16Count = HWI2C_HAL_WAIT_TIMEOUT;
1512
1513 HWI2C_HAL_FUNC();
1514
1515 if (!pData)
1516 return FALSE;
1517
1518 HAL_HWI2C_ReadRdy(u32PortOffset);
1519 while((!HAL_HWI2C_Is_INT(u32PortOffset))&&(u16Count > 0))
1520 u16Count--;
1521 HAL_HWI2C_Clear_INT(u32PortOffset);
1522 if (u16Count)
1523 {
1524 //get data before clear int and stop
1525 *pData = HAL_HWI2C_RecvData(u32PortOffset);
1526 //clear interrupt
1527 HAL_HWI2C_Clear_INT(u32PortOffset);
1528 #if 1
1529 HAL_HWI2C_ExtraDelay(1);
1530 #else
1531 MsOS_DelayTaskUs(1);
1532 #endif
1533 return TRUE;
1534 }
1535 HWI2C_HAL_ERR("Recv byte fail!\n");
1536 return FALSE;
1537 }
1538
1539 //#####################
1540 //
1541 // MIIC DMA Related Functions
1542 // External
1543 //
1544 //#####################
1545 ////////////////////////////////////////////////////////////////////////////////
1546 /// @brief \b Function \b Name: HAL_HWI2C_DMA_Enable
1547 /// @brief \b Function \b Description: Enable HWI2C DMA
1548 /// @param <IN> \b bEnable : TRUE: enable DMA, FALSE: disable DMA
1549 /// @param <OUT> \b None :
1550 /// @param <RET> \b TRUE : ok, FALSE : fail
1551 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_DMA_Enable(MS_U32 u32PortOffset,MS_BOOL bEnable)1552 MS_BOOL HAL_HWI2C_DMA_Enable(MS_U32 u32PortOffset, MS_BOOL bEnable)
1553 {
1554 MS_BOOL bRet=TRUE;
1555
1556 HWI2C_HAL_FUNC();
1557
1558 bRet &= HAL_HWI2C_DMA_SetINT(u32PortOffset,bEnable);
1559 bRet &= HAL_HWI2C_EnDMA(u32PortOffset,bEnable);
1560 return bRet;
1561 }
1562
1563 ////////////////////////////////////////////////////////////////////////////////
1564 /// @brief \b Function \b Name: HAL_HWI2C_DMA_Init
1565 /// @brief \b Function \b Description: Initialize HWI2C DMA
1566 /// @param <IN> \b pstCfg : Init structure
1567 /// @param <OUT> \b None :
1568 /// @param <RET> \b TRUE : ok, FALSE : fail
1569 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_DMA_Init(MS_U32 u32PortOffset,HAL_HWI2C_PortCfg * pstPortCfg)1570 MS_BOOL HAL_HWI2C_DMA_Init(MS_U32 u32PortOffset, HAL_HWI2C_PortCfg* pstPortCfg)
1571 {
1572 MS_U8 u8Port = 0;
1573 MS_BOOL bRet=TRUE;
1574
1575 HWI2C_HAL_FUNC();
1576
1577 //check pointer
1578 if(!pstPortCfg)
1579 {
1580 HWI2C_HAL_ERR("Port cfg null pointer!\n");
1581 return FALSE;
1582 }
1583 //(1) clear interrupt
1584 HAL_HWI2C_DMA_TxfrDone(u32PortOffset);
1585 //(2) reset DMA
1586 //(2-1) reset DMA engine
1587 HAL_HWI2C_DMA_Reset(u32PortOffset,TRUE);
1588 HAL_HWI2C_DMA_Reset(u32PortOffset,FALSE);
1589 //(2-2) reset MIU module in DMA engine
1590 HAL_HWI2C_DMA_MiuReset(u32PortOffset,TRUE);
1591 HAL_HWI2C_DMA_MiuReset(u32PortOffset,FALSE);
1592 //(3) default configursation
1593 bRet &= HAL_HWI2C_DMA_SetAddrMode(u32PortOffset,pstPortCfg->eDmaAddrMode);
1594 bRet &= HAL_HWI2C_DMA_SetMiuPri(u32PortOffset,pstPortCfg->eDmaMiuPri);
1595 bRet &= HAL_HWI2C_DMA_SetMiuChannel(u32PortOffset,pstPortCfg->eDmaMiuCh);
1596 bRet &= HAL_HWI2C_DMA_SetMiuAddr(u32PortOffset,pstPortCfg->u32DmaPhyAddr);
1597 bRet &= HAL_HWI2C_DMA_Enable(u32PortOffset,pstPortCfg->bDmaEnable);
1598 bRet &= HAL_HWI2C_DMA_SetDelayFactor(u32PortOffset,pstPortCfg->eSpeed);
1599 //(4) backup configuration info
1600 if(HAL_HWI2C_GetPortIdxByOffset(u32PortOffset,&u8Port))
1601 {
1602 memcpy(&g_stPortCfg[u8Port], pstPortCfg, sizeof(HAL_HWI2C_PortCfg));
1603 }
1604
1605 return bRet;
1606 }
1607
1608 ////////////////////////////////////////////////////////////////////////////////
1609 /// @brief \b Function \b Name: HAL_HWI2C_DMA_WriteBytes
1610 /// @brief \b Function \b Description: Initialize HWI2C DMA
1611 /// @param <IN> \b u16SlaveCfg : slave id
1612 /// @param <IN> \b uAddrCnt : address size in bytes
1613 /// @param <IN> \b pRegAddr : address pointer
1614 /// @param <IN> \b uSize : data size in bytes
1615 /// @param <IN> \b pData : data pointer
1616 /// @param <OUT> \b None :
1617 /// @param <RET> \b TRUE : ok, FALSE : fail
1618 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_DMA_WriteBytes(MS_U32 u32PortOffset,MS_U16 u16SlaveCfg,MS_U32 uAddrCnt,MS_U8 * pRegAddr,MS_U32 uSize,MS_U8 * pData)1619 MS_BOOL HAL_HWI2C_DMA_WriteBytes(MS_U32 u32PortOffset, MS_U16 u16SlaveCfg, MS_U32 uAddrCnt, MS_U8 *pRegAddr, MS_U32 uSize, MS_U8 *pData)
1620 {
1621 MS_U8 u8SlaveAddr = LOW_BYTE(u16SlaveCfg)>>1;
1622
1623 HWI2C_HAL_FUNC();
1624
1625 if (!pRegAddr)
1626 uAddrCnt = 0;
1627 if (!pData)
1628 uSize = 0;
1629 //no meaning operation
1630 if (!uSize)
1631 {
1632 HWI2C_HAL_ERR("[DMA_W]: No data for writing!\n");
1633 return FALSE;
1634 }
1635
1636 //set transfer with stop
1637 HAL_HWI2C_DMA_SetTxfrStop(u32PortOffset,TRUE);
1638 //set slave address
1639 HAL_HWI2C_DMA_SetSlaveAddr(u32PortOffset,u8SlaveAddr);
1640
1641 //#################
1642 // Set WRITE command
1643 //#################
1644 //set command buffer
1645 if(HAL_HWI2C_DMA_SetTxfrCmd(u32PortOffset,(MS_U8)uAddrCnt,pRegAddr)==FALSE)
1646 {
1647 HWI2C_HAL_ERR("[DMA_W]: Set command buffer error!\n");
1648 return FALSE;
1649 }
1650 //set data to dram
1651 if(HAL_HWI2C_DMA_SetMiuData(u32PortOffset,uSize,pData)==FALSE)
1652 {
1653 HWI2C_HAL_ERR("[DMA_W]: Set MIU data error!\n");
1654 return FALSE;
1655 }
1656 //##################
1657 // Trigger to WRITE
1658 if(HAL_HWI2C_DMA_WaitDone(u32PortOffset,HWI2C_DMA_WRITE)==FALSE)
1659 {
1660 HWI2C_HAL_ERR("[DMA_W]: Transfer command error!\n");
1661 return FALSE;
1662 }
1663
1664 return TRUE;
1665 }
1666
1667 ////////////////////////////////////////////////////////////////////////////////
1668 /// @brief \b Function \b Name: HAL_HWI2C_DMA_ReadBytes
1669 /// @brief \b Function \b Description: Initialize HWI2C DMA
1670 /// @param <IN> \b u16SlaveCfg : slave id
1671 /// @param <IN> \b uAddrCnt : address size in bytes
1672 /// @param <IN> \b pRegAddr : address pointer
1673 /// @param <IN> \b uSize : data size in bytes
1674 /// @param <IN> \b pData : data pointer
1675 /// @param <OUT> \b None :
1676 /// @param <RET> \b TRUE : ok, FALSE : fail
1677 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_DMA_ReadBytes(MS_U32 u32PortOffset,MS_U16 u16SlaveCfg,MS_U32 uAddrCnt,MS_U8 * pRegAddr,MS_U32 uSize,MS_U8 * pData)1678 MS_BOOL HAL_HWI2C_DMA_ReadBytes(MS_U32 u32PortOffset, MS_U16 u16SlaveCfg, MS_U32 uAddrCnt, MS_U8 *pRegAddr, MS_U32 uSize, MS_U8 *pData)
1679 {
1680 MS_U8 u8SlaveAddr = LOW_BYTE(u16SlaveCfg)>>1;
1681 MS_U8 u8Port = HIGH_BYTE(u16SlaveCfg);
1682 HAL_HWI2C_ReadMode eReadMode;
1683
1684 HWI2C_HAL_FUNC();
1685
1686 if (!pRegAddr)
1687 uAddrCnt = 0;
1688 if (!pData)
1689 uSize = 0;
1690 //no meaning operation
1691 if (!uSize)
1692 {
1693 HWI2C_HAL_ERR("[DMA_R]: No data for reading!\n");
1694 return FALSE;
1695 }
1696 if (u8Port>=HAL_HWI2C_PORTS)
1697 {
1698 HWI2C_HAL_ERR("[DMA_R]: Port failure!\n");
1699 return FALSE;
1700 }
1701
1702 eReadMode = g_stPortCfg[u8Port].eReadMode;
1703 if(eReadMode>=E_HAL_HWI2C_READ_MODE_MAX)
1704 {
1705 HWI2C_HAL_ERR("[DMA_R]: Read mode failure!\n");
1706 return FALSE;
1707 }
1708
1709 if(eReadMode!=E_HAL_HWI2C_READ_MODE_DIRECT)
1710 {
1711 //set transfer read mode
1712 HAL_HWI2C_DMA_SetReadMode(u32PortOffset,eReadMode);
1713 //set slave address
1714 HAL_HWI2C_DMA_SetSlaveAddr(u32PortOffset,u8SlaveAddr);
1715
1716 //#################
1717 // Set WRITE command
1718 //#################
1719 //set command buffer
1720 if(HAL_HWI2C_DMA_SetTxfrCmd(u32PortOffset,(MS_U8)uAddrCnt,pRegAddr)==FALSE)
1721 {
1722 HWI2C_HAL_ERR("[DMA_R:W]: Set command buffer error!\n");
1723 return FALSE;
1724 }
1725 HAL_HWI2C_DMA_SetDataLen(u32PortOffset,0);
1726
1727 //##################
1728 // Trigger to WRITE
1729 if(HAL_HWI2C_DMA_WaitDone(u32PortOffset,HWI2C_DMA_WRITE)==FALSE)
1730 {
1731 HWI2C_HAL_ERR("[DMA_R:W]: Transfer command error!\n");
1732 return FALSE;
1733 }
1734 }
1735
1736
1737 //#################
1738 // Set READ command
1739 //#################
1740 //set transfer with stop
1741 HAL_HWI2C_DMA_SetTxfrStop(u32PortOffset,TRUE);
1742 //set slave address
1743 HAL_HWI2C_DMA_SetSlaveAddr(u32PortOffset,u8SlaveAddr);
1744 //set command length to 0
1745 HAL_HWI2C_DMA_SetCmdLen(u32PortOffset,0);
1746 //set command length for reading
1747 HAL_HWI2C_DMA_SetDataLen(u32PortOffset,uSize);
1748 //##################
1749 // Trigger to READ
1750 if(HAL_HWI2C_DMA_WaitDone(u32PortOffset,HWI2C_DMA_READ)==FALSE)
1751 {
1752 HWI2C_HAL_ERR("[DMA_R:R]: Transfer command error!\n");
1753 return FALSE;
1754 }
1755 //get data to dram
1756 if(HAL_HWI2C_DMA_GetMiuData(u32PortOffset,uSize,pData)==FALSE)
1757 {
1758 HWI2C_HAL_ERR("[DMA_R:R]: Get MIU data error!\n");
1759 return FALSE;
1760 }
1761
1762 return TRUE;
1763 }
1764
1765 //#####################
1766 //
1767 // MIIC Miscellaneous Functions
1768 //
1769 //#####################
1770 ////////////////////////////////////////////////////////////////////////////////
1771 /// @brief \b Function \b Name: HAL_HWI2C_Init_ExtraProc
1772 /// @brief \b Function \b Description: Do extral procedure after initialization
1773 /// @param <IN> \b None :
1774 /// @param param \b None :
1775 /// @param <RET> \b None :
1776 ////////////////////////////////////////////////////////////////////////////////
HAL_HWI2C_Init_ExtraProc(void)1777 void HAL_HWI2C_Init_ExtraProc(void)
1778 {
1779 HWI2C_HAL_FUNC();
1780 //Extra procedure TODO
1781 }
1782
1783
1784