gh_i2c.h 31 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758
  1. /*!
  2. *******************************************************************************
  3. **
  4. ** \file gh_i2c.h
  5. **
  6. ** \brief I2C Interface..
  7. **
  8. ** Copyright: 2012 - 2013 (C) GoKe Microelectronics ShangHai Branch
  9. **
  10. ** \attention THIS SAMPLE CODE IS PROVIDED AS IS. GOKE MICROELECTRONICS
  11. ** ACCEPTS NO RESPONSIBILITY OR LIABILITY FOR ANY ERRORS OR
  12. ** OMMISSIONS.
  13. **
  14. ** \note Do not modify this file as it is generated automatically.
  15. **
  16. ******************************************************************************/
  17. #ifndef _GH_I2C_H
  18. #define _GH_I2C_H
  19. #ifdef __LINUX__
  20. #include "reg4linux.h"
  21. #else
  22. #define FIO_ADDRESS(block,address) (address)
  23. #define FIO_MOFFSET(block,moffset) (moffset)
  24. #endif
  25. #ifndef __LINUX__
  26. #include "gtypes.h" /* global type definitions */
  27. #include "gh_lib_cfg.h" /* configuration */
  28. #endif
  29. #define GH_I2C_ENABLE_DEBUG_PRINT 0
  30. #ifdef __LINUX__
  31. #define GH_I2C_DEBUG_PRINT_FUNCTION printk
  32. #else
  33. #define GH_I2C_DEBUG_PRINT_FUNCTION printf
  34. #endif
  35. #ifndef __LINUX__
  36. #if GH_I2C_ENABLE_DEBUG_PRINT
  37. #include <stdio.h>
  38. #endif
  39. #endif
  40. /* check configuration */
  41. #ifndef GH_INLINE_LEVEL
  42. #error "GH_INLINE_LEVEL is not defined!"
  43. #endif
  44. #if GH_INLINE_LEVEL > 2
  45. #error "GH_INLINE_LEVEL must be set 0, 1 or 2!"
  46. #endif
  47. #ifndef GH_INLINE
  48. #error "GH_INLINE is not defined!"
  49. #endif
  50. /* disable inlining for debugging */
  51. #ifdef DEBUG
  52. #undef GH_INLINE_LEVEL
  53. #define GH_INLINE_LEVEL 0
  54. #endif
  55. /*----------------------------------------------------------------------------*/
  56. /* registers */
  57. /*----------------------------------------------------------------------------*/
  58. #define REG_I2C_ENABLE FIO_ADDRESS(I2C,0xA0003014) /* read/write */
  59. #define REG_I2C_CONTROL FIO_ADDRESS(I2C,0xA000300C) /* read/write */
  60. #define REG_I2C_DATA FIO_ADDRESS(I2C,0xA0003018) /* read/write */
  61. #define REG_I2C_STATUS FIO_ADDRESS(I2C,0xA0003010) /* read */
  62. #define REG_I2C_PRESCALEL FIO_ADDRESS(I2C,0xA0003000) /* read/write */
  63. #define REG_I2C_PRESCALEH FIO_ADDRESS(I2C,0xA0003004) /* read/write */
  64. #define REG_I2C_FMCONTROL FIO_ADDRESS(I2C,0xA0003008) /* read/write */
  65. #define REG_I2C_FMDATA FIO_ADDRESS(I2C,0xA000301C) /* read/write */
  66. /*----------------------------------------------------------------------------*/
  67. /* bit group structures */
  68. /*----------------------------------------------------------------------------*/
  69. typedef union { /* I2C_ENABLE */
  70. U32 all;
  71. struct {
  72. U32 en : 1;
  73. U32 : 31;
  74. } bitc;
  75. } GH_I2C_ENABLE_S;
  76. typedef union { /* I2C_CONTROL */
  77. U32 all;
  78. struct {
  79. U32 stop : 1;
  80. U32 start : 1;
  81. U32 ack : 1;
  82. U32 intflag : 1;
  83. U32 clrautofifo : 1;
  84. U32 : 27;
  85. } bitc;
  86. } GH_I2C_CONTROL_S;
  87. typedef union { /* I2C_DATA */
  88. U32 all;
  89. struct {
  90. U32 data : 8;
  91. U32 : 24;
  92. } bitc;
  93. } GH_I2C_DATA_S;
  94. typedef union { /* I2C_STATUS */
  95. U32 all;
  96. struct {
  97. U32 mode : 1;
  98. U32 : 31;
  99. } bitc;
  100. } GH_I2C_STATUS_S;
  101. typedef union { /* I2C_PRESCALEL */
  102. U32 all;
  103. struct {
  104. U32 scale : 8;
  105. U32 : 24;
  106. } bitc;
  107. } GH_I2C_PRESCALEL_S;
  108. typedef union { /* I2C_PRESCALEH */
  109. U32 all;
  110. struct {
  111. U32 scale : 8;
  112. U32 : 24;
  113. } bitc;
  114. } GH_I2C_PRESCALEH_S;
  115. typedef union { /* I2C_FMCONTROL */
  116. U32 all;
  117. struct {
  118. U32 stop : 1;
  119. U32 start : 1;
  120. U32 : 2;
  121. U32 is : 1;
  122. U32 : 27;
  123. } bitc;
  124. } GH_I2C_FMCONTROL_S;
  125. typedef union { /* I2C_FMDATA */
  126. U32 all;
  127. struct {
  128. U32 data : 8;
  129. U32 : 24;
  130. } bitc;
  131. } GH_I2C_FMDATA_S;
  132. /*----------------------------------------------------------------------------*/
  133. /* mirror variables */
  134. /*----------------------------------------------------------------------------*/
  135. #ifdef __cplusplus
  136. extern "C" {
  137. #endif
  138. /*----------------------------------------------------------------------------*/
  139. /* register I2C_ENABLE (read/write) */
  140. /*----------------------------------------------------------------------------*/
  141. #if GH_INLINE_LEVEL == 0
  142. /*! \brief Writes the register 'I2C_ENABLE'. */
  143. void GH_I2C_set_ENABLE(U8 index, U32 data);
  144. /*! \brief Reads the register 'I2C_ENABLE'. */
  145. U32 GH_I2C_get_ENABLE(U8 index);
  146. /*! \brief Writes the bit group 'en' of register 'I2C_ENABLE'. */
  147. void GH_I2C_set_ENABLE_en(U8 index, U8 data);
  148. /*! \brief Reads the bit group 'en' of register 'I2C_ENABLE'. */
  149. U8 GH_I2C_get_ENABLE_en(U8 index);
  150. #else /* GH_INLINE_LEVEL == 0 */
  151. GH_INLINE void GH_I2C_set_ENABLE(U8 index, U32 data)
  152. {
  153. *(volatile U32 *)(REG_I2C_ENABLE + index * FIO_MOFFSET(I2C,0x00001000)) = data;
  154. #if GH_I2C_ENABLE_DEBUG_PRINT
  155. GH_I2C_DEBUG_PRINT_FUNCTION( "WRREG(0x%08x,0x%08x); \\\\ [GH_I2C_set_ENABLE] <-- 0x%08x\n",
  156. (REG_I2C_ENABLE + index * FIO_MOFFSET(I2C,0x00001000)),data,data);
  157. #endif
  158. }
  159. GH_INLINE U32 GH_I2C_get_ENABLE(U8 index)
  160. {
  161. U32 value = (*(volatile U32 *)(REG_I2C_ENABLE + index * FIO_MOFFSET(I2C,0x00001000)));
  162. #if GH_I2C_ENABLE_DEBUG_PRINT
  163. GH_I2C_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_I2C_get_ENABLE] --> 0x%08x\n",
  164. (REG_I2C_ENABLE + index * FIO_MOFFSET(I2C,0x00001000)),value);
  165. #endif
  166. return value;
  167. }
  168. GH_INLINE void GH_I2C_set_ENABLE_en(U8 index, U8 data)
  169. {
  170. GH_I2C_ENABLE_S d;
  171. d.all = *(volatile U32 *)(REG_I2C_ENABLE + index * FIO_MOFFSET(I2C,0x00001000));
  172. d.bitc.en = data;
  173. *(volatile U32 *)(REG_I2C_ENABLE + index * FIO_MOFFSET(I2C,0x00001000)) = d.all;
  174. #if GH_I2C_ENABLE_DEBUG_PRINT
  175. GH_I2C_DEBUG_PRINT_FUNCTION( "WRREG(0x%08x,0x%08x); \\\\ [GH_I2C_set_ENABLE_en] <-- 0x%08x\n",
  176. (REG_I2C_ENABLE + index * FIO_MOFFSET(I2C,0x00001000)),d.all,d.all);
  177. #endif
  178. }
  179. GH_INLINE U8 GH_I2C_get_ENABLE_en(U8 index)
  180. {
  181. GH_I2C_ENABLE_S tmp_value;
  182. U32 value = (*(volatile U32 *)(REG_I2C_ENABLE + index * FIO_MOFFSET(I2C,0x00001000)));
  183. tmp_value.all = value;
  184. #if GH_I2C_ENABLE_DEBUG_PRINT
  185. GH_I2C_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_I2C_get_ENABLE_en] --> 0x%08x\n",
  186. (REG_I2C_ENABLE + index * FIO_MOFFSET(I2C,0x00001000)),value);
  187. #endif
  188. return tmp_value.bitc.en;
  189. }
  190. #endif /* GH_INLINE_LEVEL == 0 */
  191. /*----------------------------------------------------------------------------*/
  192. /* register I2C_CONTROL (read/write) */
  193. /*----------------------------------------------------------------------------*/
  194. #if GH_INLINE_LEVEL == 0
  195. /*! \brief Writes the register 'I2C_CONTROL'. */
  196. void GH_I2C_set_CONTROL(U8 index, U32 data);
  197. /*! \brief Reads the register 'I2C_CONTROL'. */
  198. U32 GH_I2C_get_CONTROL(U8 index);
  199. /*! \brief Writes the bit group 'stop' of register 'I2C_CONTROL'. */
  200. void GH_I2C_set_CONTROL_stop(U8 index, U8 data);
  201. /*! \brief Reads the bit group 'stop' of register 'I2C_CONTROL'. */
  202. U8 GH_I2C_get_CONTROL_stop(U8 index);
  203. /*! \brief Writes the bit group 'start' of register 'I2C_CONTROL'. */
  204. void GH_I2C_set_CONTROL_start(U8 index, U8 data);
  205. /*! \brief Reads the bit group 'start' of register 'I2C_CONTROL'. */
  206. U8 GH_I2C_get_CONTROL_start(U8 index);
  207. /*! \brief Writes the bit group 'ack' of register 'I2C_CONTROL'. */
  208. void GH_I2C_set_CONTROL_ack(U8 index, U8 data);
  209. /*! \brief Reads the bit group 'ack' of register 'I2C_CONTROL'. */
  210. U8 GH_I2C_get_CONTROL_ack(U8 index);
  211. /*! \brief Writes the bit group 'IntFlag' of register 'I2C_CONTROL'. */
  212. void GH_I2C_set_CONTROL_IntFlag(U8 index, U8 data);
  213. /*! \brief Reads the bit group 'IntFlag' of register 'I2C_CONTROL'. */
  214. U8 GH_I2C_get_CONTROL_IntFlag(U8 index);
  215. /*! \brief Writes the bit group 'ClrAutoFifo' of register 'I2C_CONTROL'. */
  216. void GH_I2C_set_CONTROL_ClrAutoFifo(U8 index, U8 data);
  217. /*! \brief Reads the bit group 'ClrAutoFifo' of register 'I2C_CONTROL'. */
  218. U8 GH_I2C_get_CONTROL_ClrAutoFifo(U8 index);
  219. #else /* GH_INLINE_LEVEL == 0 */
  220. GH_INLINE void GH_I2C_set_CONTROL(U8 index, U32 data)
  221. {
  222. *(volatile U32 *)(REG_I2C_CONTROL + index * FIO_MOFFSET(I2C,0x00001000)) = data;
  223. #if GH_I2C_ENABLE_DEBUG_PRINT
  224. GH_I2C_DEBUG_PRINT_FUNCTION( "WRREG(0x%08x,0x%08x); \\\\ [GH_I2C_set_CONTROL] <-- 0x%08x\n",
  225. (REG_I2C_CONTROL + index * FIO_MOFFSET(I2C,0x00001000)),data,data);
  226. #endif
  227. }
  228. GH_INLINE U32 GH_I2C_get_CONTROL(U8 index)
  229. {
  230. U32 value = (*(volatile U32 *)(REG_I2C_CONTROL + index * FIO_MOFFSET(I2C,0x00001000)));
  231. #if GH_I2C_ENABLE_DEBUG_PRINT
  232. GH_I2C_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_I2C_get_CONTROL] --> 0x%08x\n",
  233. (REG_I2C_CONTROL + index * FIO_MOFFSET(I2C,0x00001000)),value);
  234. #endif
  235. return value;
  236. }
  237. GH_INLINE void GH_I2C_set_CONTROL_stop(U8 index, U8 data)
  238. {
  239. GH_I2C_CONTROL_S d;
  240. d.all = *(volatile U32 *)(REG_I2C_CONTROL + index * FIO_MOFFSET(I2C,0x00001000));
  241. d.bitc.stop = data;
  242. *(volatile U32 *)(REG_I2C_CONTROL + index * FIO_MOFFSET(I2C,0x00001000)) = d.all;
  243. #if GH_I2C_ENABLE_DEBUG_PRINT
  244. GH_I2C_DEBUG_PRINT_FUNCTION( "WRREG(0x%08x,0x%08x); \\\\ [GH_I2C_set_CONTROL_stop] <-- 0x%08x\n",
  245. (REG_I2C_CONTROL + index * FIO_MOFFSET(I2C,0x00001000)),d.all,d.all);
  246. #endif
  247. }
  248. GH_INLINE U8 GH_I2C_get_CONTROL_stop(U8 index)
  249. {
  250. GH_I2C_CONTROL_S tmp_value;
  251. U32 value = (*(volatile U32 *)(REG_I2C_CONTROL + index * FIO_MOFFSET(I2C,0x00001000)));
  252. tmp_value.all = value;
  253. #if GH_I2C_ENABLE_DEBUG_PRINT
  254. GH_I2C_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_I2C_get_CONTROL_stop] --> 0x%08x\n",
  255. (REG_I2C_CONTROL + index * FIO_MOFFSET(I2C,0x00001000)),value);
  256. #endif
  257. return tmp_value.bitc.stop;
  258. }
  259. GH_INLINE void GH_I2C_set_CONTROL_start(U8 index, U8 data)
  260. {
  261. GH_I2C_CONTROL_S d;
  262. d.all = *(volatile U32 *)(REG_I2C_CONTROL + index * FIO_MOFFSET(I2C,0x00001000));
  263. d.bitc.start = data;
  264. *(volatile U32 *)(REG_I2C_CONTROL + index * FIO_MOFFSET(I2C,0x00001000)) = d.all;
  265. #if GH_I2C_ENABLE_DEBUG_PRINT
  266. GH_I2C_DEBUG_PRINT_FUNCTION( "WRREG(0x%08x,0x%08x); \\\\ [GH_I2C_set_CONTROL_start] <-- 0x%08x\n",
  267. (REG_I2C_CONTROL + index * FIO_MOFFSET(I2C,0x00001000)),d.all,d.all);
  268. #endif
  269. }
  270. GH_INLINE U8 GH_I2C_get_CONTROL_start(U8 index)
  271. {
  272. GH_I2C_CONTROL_S tmp_value;
  273. U32 value = (*(volatile U32 *)(REG_I2C_CONTROL + index * FIO_MOFFSET(I2C,0x00001000)));
  274. tmp_value.all = value;
  275. #if GH_I2C_ENABLE_DEBUG_PRINT
  276. GH_I2C_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_I2C_get_CONTROL_start] --> 0x%08x\n",
  277. (REG_I2C_CONTROL + index * FIO_MOFFSET(I2C,0x00001000)),value);
  278. #endif
  279. return tmp_value.bitc.start;
  280. }
  281. GH_INLINE void GH_I2C_set_CONTROL_ack(U8 index, U8 data)
  282. {
  283. GH_I2C_CONTROL_S d;
  284. d.all = *(volatile U32 *)(REG_I2C_CONTROL + index * FIO_MOFFSET(I2C,0x00001000));
  285. d.bitc.ack = data;
  286. *(volatile U32 *)(REG_I2C_CONTROL + index * FIO_MOFFSET(I2C,0x00001000)) = d.all;
  287. #if GH_I2C_ENABLE_DEBUG_PRINT
  288. GH_I2C_DEBUG_PRINT_FUNCTION( "WRREG(0x%08x,0x%08x); \\\\ [GH_I2C_set_CONTROL_ack] <-- 0x%08x\n",
  289. (REG_I2C_CONTROL + index * FIO_MOFFSET(I2C,0x00001000)),d.all,d.all);
  290. #endif
  291. }
  292. GH_INLINE U8 GH_I2C_get_CONTROL_ack(U8 index)
  293. {
  294. GH_I2C_CONTROL_S tmp_value;
  295. U32 value = (*(volatile U32 *)(REG_I2C_CONTROL + index * FIO_MOFFSET(I2C,0x00001000)));
  296. tmp_value.all = value;
  297. #if GH_I2C_ENABLE_DEBUG_PRINT
  298. GH_I2C_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_I2C_get_CONTROL_ack] --> 0x%08x\n",
  299. (REG_I2C_CONTROL + index * FIO_MOFFSET(I2C,0x00001000)),value);
  300. #endif
  301. return tmp_value.bitc.ack;
  302. }
  303. GH_INLINE void GH_I2C_set_CONTROL_IntFlag(U8 index, U8 data)
  304. {
  305. GH_I2C_CONTROL_S d;
  306. d.all = *(volatile U32 *)(REG_I2C_CONTROL + index * FIO_MOFFSET(I2C,0x00001000));
  307. d.bitc.intflag = data;
  308. *(volatile U32 *)(REG_I2C_CONTROL + index * FIO_MOFFSET(I2C,0x00001000)) = d.all;
  309. #if GH_I2C_ENABLE_DEBUG_PRINT
  310. GH_I2C_DEBUG_PRINT_FUNCTION( "WRREG(0x%08x,0x%08x); \\\\ [GH_I2C_set_CONTROL_IntFlag] <-- 0x%08x\n",
  311. (REG_I2C_CONTROL + index * FIO_MOFFSET(I2C,0x00001000)),d.all,d.all);
  312. #endif
  313. }
  314. GH_INLINE U8 GH_I2C_get_CONTROL_IntFlag(U8 index)
  315. {
  316. GH_I2C_CONTROL_S tmp_value;
  317. U32 value = (*(volatile U32 *)(REG_I2C_CONTROL + index * FIO_MOFFSET(I2C,0x00001000)));
  318. tmp_value.all = value;
  319. #if GH_I2C_ENABLE_DEBUG_PRINT
  320. GH_I2C_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_I2C_get_CONTROL_IntFlag] --> 0x%08x\n",
  321. (REG_I2C_CONTROL + index * FIO_MOFFSET(I2C,0x00001000)),value);
  322. #endif
  323. return tmp_value.bitc.intflag;
  324. }
  325. GH_INLINE void GH_I2C_set_CONTROL_ClrAutoFifo(U8 index, U8 data)
  326. {
  327. GH_I2C_CONTROL_S d;
  328. d.all = *(volatile U32 *)(REG_I2C_CONTROL + index * FIO_MOFFSET(I2C,0x00001000));
  329. d.bitc.clrautofifo = data;
  330. *(volatile U32 *)(REG_I2C_CONTROL + index * FIO_MOFFSET(I2C,0x00001000)) = d.all;
  331. #if GH_I2C_ENABLE_DEBUG_PRINT
  332. GH_I2C_DEBUG_PRINT_FUNCTION( "WRREG(0x%08x,0x%08x); \\\\ [GH_I2C_set_CONTROL_ClrAutoFifo] <-- 0x%08x\n",
  333. (REG_I2C_CONTROL + index * FIO_MOFFSET(I2C,0x00001000)),d.all,d.all);
  334. #endif
  335. }
  336. GH_INLINE U8 GH_I2C_get_CONTROL_ClrAutoFifo(U8 index)
  337. {
  338. GH_I2C_CONTROL_S tmp_value;
  339. U32 value = (*(volatile U32 *)(REG_I2C_CONTROL + index * FIO_MOFFSET(I2C,0x00001000)));
  340. tmp_value.all = value;
  341. #if GH_I2C_ENABLE_DEBUG_PRINT
  342. GH_I2C_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_I2C_get_CONTROL_ClrAutoFifo] --> 0x%08x\n",
  343. (REG_I2C_CONTROL + index * FIO_MOFFSET(I2C,0x00001000)),value);
  344. #endif
  345. return tmp_value.bitc.clrautofifo;
  346. }
  347. #endif /* GH_INLINE_LEVEL == 0 */
  348. /*----------------------------------------------------------------------------*/
  349. /* register I2C_DATA (read/write) */
  350. /*----------------------------------------------------------------------------*/
  351. #if GH_INLINE_LEVEL == 0
  352. /*! \brief Writes the register 'I2C_DATA'. */
  353. void GH_I2C_set_DATA(U8 index, U32 data);
  354. /*! \brief Reads the register 'I2C_DATA'. */
  355. U32 GH_I2C_get_DATA(U8 index);
  356. /*! \brief Writes the bit group 'Data' of register 'I2C_DATA'. */
  357. void GH_I2C_set_DATA_Data(U8 index, U8 data);
  358. /*! \brief Reads the bit group 'Data' of register 'I2C_DATA'. */
  359. U8 GH_I2C_get_DATA_Data(U8 index);
  360. #else /* GH_INLINE_LEVEL == 0 */
  361. GH_INLINE void GH_I2C_set_DATA(U8 index, U32 data)
  362. {
  363. *(volatile U32 *)(REG_I2C_DATA + index * FIO_MOFFSET(I2C,0x00001000)) = data;
  364. #if GH_I2C_ENABLE_DEBUG_PRINT
  365. GH_I2C_DEBUG_PRINT_FUNCTION( "WRREG(0x%08x,0x%08x); \\\\ [GH_I2C_set_DATA] <-- 0x%08x\n",
  366. (REG_I2C_DATA + index * FIO_MOFFSET(I2C,0x00001000)),data,data);
  367. #endif
  368. }
  369. GH_INLINE U32 GH_I2C_get_DATA(U8 index)
  370. {
  371. U32 value = (*(volatile U32 *)(REG_I2C_DATA + index * FIO_MOFFSET(I2C,0x00001000)));
  372. #if GH_I2C_ENABLE_DEBUG_PRINT
  373. GH_I2C_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_I2C_get_DATA] --> 0x%08x\n",
  374. (REG_I2C_DATA + index * FIO_MOFFSET(I2C,0x00001000)),value);
  375. #endif
  376. return value;
  377. }
  378. GH_INLINE void GH_I2C_set_DATA_Data(U8 index, U8 data)
  379. {
  380. GH_I2C_DATA_S d;
  381. d.all = *(volatile U32 *)(REG_I2C_DATA + index * FIO_MOFFSET(I2C,0x00001000));
  382. d.bitc.data = data;
  383. *(volatile U32 *)(REG_I2C_DATA + index * FIO_MOFFSET(I2C,0x00001000)) = d.all;
  384. #if GH_I2C_ENABLE_DEBUG_PRINT
  385. GH_I2C_DEBUG_PRINT_FUNCTION( "WRREG(0x%08x,0x%08x); \\\\ [GH_I2C_set_DATA_Data] <-- 0x%08x\n",
  386. (REG_I2C_DATA + index * FIO_MOFFSET(I2C,0x00001000)),d.all,d.all);
  387. #endif
  388. }
  389. GH_INLINE U8 GH_I2C_get_DATA_Data(U8 index)
  390. {
  391. GH_I2C_DATA_S tmp_value;
  392. U32 value = (*(volatile U32 *)(REG_I2C_DATA + index * FIO_MOFFSET(I2C,0x00001000)));
  393. tmp_value.all = value;
  394. #if GH_I2C_ENABLE_DEBUG_PRINT
  395. GH_I2C_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_I2C_get_DATA_Data] --> 0x%08x\n",
  396. (REG_I2C_DATA + index * FIO_MOFFSET(I2C,0x00001000)),value);
  397. #endif
  398. return tmp_value.bitc.data;
  399. }
  400. #endif /* GH_INLINE_LEVEL == 0 */
  401. /*----------------------------------------------------------------------------*/
  402. /* register I2C_STATUS (read) */
  403. /*----------------------------------------------------------------------------*/
  404. #if GH_INLINE_LEVEL == 0
  405. /*! \brief Reads the register 'I2C_STATUS'. */
  406. U32 GH_I2C_get_STATUS(U8 index);
  407. /*! \brief Reads the bit group 'mode' of register 'I2C_STATUS'. */
  408. U8 GH_I2C_get_STATUS_mode(U8 index);
  409. #else /* GH_INLINE_LEVEL == 0 */
  410. GH_INLINE U32 GH_I2C_get_STATUS(U8 index)
  411. {
  412. U32 value = (*(volatile U32 *)(REG_I2C_STATUS + index * FIO_MOFFSET(I2C,0x00001000)));
  413. #if GH_I2C_ENABLE_DEBUG_PRINT
  414. GH_I2C_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_I2C_get_STATUS] --> 0x%08x\n",
  415. (REG_I2C_STATUS + index * FIO_MOFFSET(I2C,0x00001000)),value);
  416. #endif
  417. return value;
  418. }
  419. GH_INLINE U8 GH_I2C_get_STATUS_mode(U8 index)
  420. {
  421. GH_I2C_STATUS_S tmp_value;
  422. U32 value = (*(volatile U32 *)(REG_I2C_STATUS + index * FIO_MOFFSET(I2C,0x00001000)));
  423. tmp_value.all = value;
  424. #if GH_I2C_ENABLE_DEBUG_PRINT
  425. GH_I2C_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_I2C_get_STATUS_mode] --> 0x%08x\n",
  426. (REG_I2C_STATUS + index * FIO_MOFFSET(I2C,0x00001000)),value);
  427. #endif
  428. return tmp_value.bitc.mode;
  429. }
  430. #endif /* GH_INLINE_LEVEL == 0 */
  431. /*----------------------------------------------------------------------------*/
  432. /* register I2C_PRESCALEL (read/write) */
  433. /*----------------------------------------------------------------------------*/
  434. #if GH_INLINE_LEVEL == 0
  435. /*! \brief Writes the register 'I2C_PRESCALEL'. */
  436. void GH_I2C_set_PRESCALEL(U8 index, U32 data);
  437. /*! \brief Reads the register 'I2C_PRESCALEL'. */
  438. U32 GH_I2C_get_PRESCALEL(U8 index);
  439. /*! \brief Writes the bit group 'scale' of register 'I2C_PRESCALEL'. */
  440. void GH_I2C_set_PRESCALEL_scale(U8 index, U8 data);
  441. /*! \brief Reads the bit group 'scale' of register 'I2C_PRESCALEL'. */
  442. U8 GH_I2C_get_PRESCALEL_scale(U8 index);
  443. #else /* GH_INLINE_LEVEL == 0 */
  444. GH_INLINE void GH_I2C_set_PRESCALEL(U8 index, U32 data)
  445. {
  446. *(volatile U32 *)(REG_I2C_PRESCALEL + index * FIO_MOFFSET(I2C,0x00001000)) = data;
  447. #if GH_I2C_ENABLE_DEBUG_PRINT
  448. GH_I2C_DEBUG_PRINT_FUNCTION( "WRREG(0x%08x,0x%08x); \\\\ [GH_I2C_set_PRESCALEL] <-- 0x%08x\n",
  449. (REG_I2C_PRESCALEL + index * FIO_MOFFSET(I2C,0x00001000)),data,data);
  450. #endif
  451. }
  452. GH_INLINE U32 GH_I2C_get_PRESCALEL(U8 index)
  453. {
  454. U32 value = (*(volatile U32 *)(REG_I2C_PRESCALEL + index * FIO_MOFFSET(I2C,0x00001000)));
  455. #if GH_I2C_ENABLE_DEBUG_PRINT
  456. GH_I2C_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_I2C_get_PRESCALEL] --> 0x%08x\n",
  457. (REG_I2C_PRESCALEL + index * FIO_MOFFSET(I2C,0x00001000)),value);
  458. #endif
  459. return value;
  460. }
  461. GH_INLINE void GH_I2C_set_PRESCALEL_scale(U8 index, U8 data)
  462. {
  463. GH_I2C_PRESCALEL_S d;
  464. d.all = *(volatile U32 *)(REG_I2C_PRESCALEL + index * FIO_MOFFSET(I2C,0x00001000));
  465. d.bitc.scale = data;
  466. *(volatile U32 *)(REG_I2C_PRESCALEL + index * FIO_MOFFSET(I2C,0x00001000)) = d.all;
  467. #if GH_I2C_ENABLE_DEBUG_PRINT
  468. GH_I2C_DEBUG_PRINT_FUNCTION( "WRREG(0x%08x,0x%08x); \\\\ [GH_I2C_set_PRESCALEL_scale] <-- 0x%08x\n",
  469. (REG_I2C_PRESCALEL + index * FIO_MOFFSET(I2C,0x00001000)),d.all,d.all);
  470. #endif
  471. }
  472. GH_INLINE U8 GH_I2C_get_PRESCALEL_scale(U8 index)
  473. {
  474. GH_I2C_PRESCALEL_S tmp_value;
  475. U32 value = (*(volatile U32 *)(REG_I2C_PRESCALEL + index * FIO_MOFFSET(I2C,0x00001000)));
  476. tmp_value.all = value;
  477. #if GH_I2C_ENABLE_DEBUG_PRINT
  478. GH_I2C_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_I2C_get_PRESCALEL_scale] --> 0x%08x\n",
  479. (REG_I2C_PRESCALEL + index * FIO_MOFFSET(I2C,0x00001000)),value);
  480. #endif
  481. return tmp_value.bitc.scale;
  482. }
  483. #endif /* GH_INLINE_LEVEL == 0 */
  484. /*----------------------------------------------------------------------------*/
  485. /* register I2C_PRESCALEH (read/write) */
  486. /*----------------------------------------------------------------------------*/
  487. #if GH_INLINE_LEVEL == 0
  488. /*! \brief Writes the register 'I2C_PRESCALEH'. */
  489. void GH_I2C_set_PRESCALEH(U8 index, U32 data);
  490. /*! \brief Reads the register 'I2C_PRESCALEH'. */
  491. U32 GH_I2C_get_PRESCALEH(U8 index);
  492. /*! \brief Writes the bit group 'scale' of register 'I2C_PRESCALEH'. */
  493. void GH_I2C_set_PRESCALEH_scale(U8 index, U8 data);
  494. /*! \brief Reads the bit group 'scale' of register 'I2C_PRESCALEH'. */
  495. U8 GH_I2C_get_PRESCALEH_scale(U8 index);
  496. #else /* GH_INLINE_LEVEL == 0 */
  497. GH_INLINE void GH_I2C_set_PRESCALEH(U8 index, U32 data)
  498. {
  499. *(volatile U32 *)(REG_I2C_PRESCALEH + index * FIO_MOFFSET(I2C,0x00001000)) = data;
  500. #if GH_I2C_ENABLE_DEBUG_PRINT
  501. GH_I2C_DEBUG_PRINT_FUNCTION( "WRREG(0x%08x,0x%08x); \\\\ [GH_I2C_set_PRESCALEH] <-- 0x%08x\n",
  502. (REG_I2C_PRESCALEH + index * FIO_MOFFSET(I2C,0x00001000)),data,data);
  503. #endif
  504. }
  505. GH_INLINE U32 GH_I2C_get_PRESCALEH(U8 index)
  506. {
  507. U32 value = (*(volatile U32 *)(REG_I2C_PRESCALEH + index * FIO_MOFFSET(I2C,0x00001000)));
  508. #if GH_I2C_ENABLE_DEBUG_PRINT
  509. GH_I2C_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_I2C_get_PRESCALEH] --> 0x%08x\n",
  510. (REG_I2C_PRESCALEH + index * FIO_MOFFSET(I2C,0x00001000)),value);
  511. #endif
  512. return value;
  513. }
  514. GH_INLINE void GH_I2C_set_PRESCALEH_scale(U8 index, U8 data)
  515. {
  516. GH_I2C_PRESCALEH_S d;
  517. d.all = *(volatile U32 *)(REG_I2C_PRESCALEH + index * FIO_MOFFSET(I2C,0x00001000));
  518. d.bitc.scale = data;
  519. *(volatile U32 *)(REG_I2C_PRESCALEH + index * FIO_MOFFSET(I2C,0x00001000)) = d.all;
  520. #if GH_I2C_ENABLE_DEBUG_PRINT
  521. GH_I2C_DEBUG_PRINT_FUNCTION( "WRREG(0x%08x,0x%08x); \\\\ [GH_I2C_set_PRESCALEH_scale] <-- 0x%08x\n",
  522. (REG_I2C_PRESCALEH + index * FIO_MOFFSET(I2C,0x00001000)),d.all,d.all);
  523. #endif
  524. }
  525. GH_INLINE U8 GH_I2C_get_PRESCALEH_scale(U8 index)
  526. {
  527. GH_I2C_PRESCALEH_S tmp_value;
  528. U32 value = (*(volatile U32 *)(REG_I2C_PRESCALEH + index * FIO_MOFFSET(I2C,0x00001000)));
  529. tmp_value.all = value;
  530. #if GH_I2C_ENABLE_DEBUG_PRINT
  531. GH_I2C_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_I2C_get_PRESCALEH_scale] --> 0x%08x\n",
  532. (REG_I2C_PRESCALEH + index * FIO_MOFFSET(I2C,0x00001000)),value);
  533. #endif
  534. return tmp_value.bitc.scale;
  535. }
  536. #endif /* GH_INLINE_LEVEL == 0 */
  537. /*----------------------------------------------------------------------------*/
  538. /* register I2C_FMCONTROL (read/write) */
  539. /*----------------------------------------------------------------------------*/
  540. #if GH_INLINE_LEVEL == 0
  541. /*! \brief Writes the register 'I2C_FMCONTROL'. */
  542. void GH_I2C_set_FMCONTROL(U8 index, U32 data);
  543. /*! \brief Reads the register 'I2C_FMCONTROL'. */
  544. U32 GH_I2C_get_FMCONTROL(U8 index);
  545. /*! \brief Writes the bit group 'stop' of register 'I2C_FMCONTROL'. */
  546. void GH_I2C_set_FMCONTROL_stop(U8 index, U8 data);
  547. /*! \brief Reads the bit group 'stop' of register 'I2C_FMCONTROL'. */
  548. U8 GH_I2C_get_FMCONTROL_stop(U8 index);
  549. /*! \brief Writes the bit group 'start' of register 'I2C_FMCONTROL'. */
  550. void GH_I2C_set_FMCONTROL_start(U8 index, U8 data);
  551. /*! \brief Reads the bit group 'start' of register 'I2C_FMCONTROL'. */
  552. U8 GH_I2C_get_FMCONTROL_start(U8 index);
  553. /*! \brief Writes the bit group 'is' of register 'I2C_FMCONTROL'. */
  554. void GH_I2C_set_FMCONTROL_is(U8 index, U8 data);
  555. /*! \brief Reads the bit group 'is' of register 'I2C_FMCONTROL'. */
  556. U8 GH_I2C_get_FMCONTROL_is(U8 index);
  557. #else /* GH_INLINE_LEVEL == 0 */
  558. GH_INLINE void GH_I2C_set_FMCONTROL(U8 index, U32 data)
  559. {
  560. *(volatile U32 *)(REG_I2C_FMCONTROL + index * FIO_MOFFSET(I2C,0x00001000)) = data;
  561. #if GH_I2C_ENABLE_DEBUG_PRINT
  562. GH_I2C_DEBUG_PRINT_FUNCTION( "WRREG(0x%08x,0x%08x); \\\\ [GH_I2C_set_FMCONTROL] <-- 0x%08x\n",
  563. (REG_I2C_FMCONTROL + index * FIO_MOFFSET(I2C,0x00001000)),data,data);
  564. #endif
  565. }
  566. GH_INLINE U32 GH_I2C_get_FMCONTROL(U8 index)
  567. {
  568. U32 value = (*(volatile U32 *)(REG_I2C_FMCONTROL + index * FIO_MOFFSET(I2C,0x00001000)));
  569. #if GH_I2C_ENABLE_DEBUG_PRINT
  570. GH_I2C_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_I2C_get_FMCONTROL] --> 0x%08x\n",
  571. (REG_I2C_FMCONTROL + index * FIO_MOFFSET(I2C,0x00001000)),value);
  572. #endif
  573. return value;
  574. }
  575. GH_INLINE void GH_I2C_set_FMCONTROL_stop(U8 index, U8 data)
  576. {
  577. GH_I2C_FMCONTROL_S d;
  578. d.all = *(volatile U32 *)(REG_I2C_FMCONTROL + index * FIO_MOFFSET(I2C,0x00001000));
  579. d.bitc.stop = data;
  580. *(volatile U32 *)(REG_I2C_FMCONTROL + index * FIO_MOFFSET(I2C,0x00001000)) = d.all;
  581. #if GH_I2C_ENABLE_DEBUG_PRINT
  582. GH_I2C_DEBUG_PRINT_FUNCTION( "WRREG(0x%08x,0x%08x); \\\\ [GH_I2C_set_FMCONTROL_stop] <-- 0x%08x\n",
  583. (REG_I2C_FMCONTROL + index * FIO_MOFFSET(I2C,0x00001000)),d.all,d.all);
  584. #endif
  585. }
  586. GH_INLINE U8 GH_I2C_get_FMCONTROL_stop(U8 index)
  587. {
  588. GH_I2C_FMCONTROL_S tmp_value;
  589. U32 value = (*(volatile U32 *)(REG_I2C_FMCONTROL + index * FIO_MOFFSET(I2C,0x00001000)));
  590. tmp_value.all = value;
  591. #if GH_I2C_ENABLE_DEBUG_PRINT
  592. GH_I2C_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_I2C_get_FMCONTROL_stop] --> 0x%08x\n",
  593. (REG_I2C_FMCONTROL + index * FIO_MOFFSET(I2C,0x00001000)),value);
  594. #endif
  595. return tmp_value.bitc.stop;
  596. }
  597. GH_INLINE void GH_I2C_set_FMCONTROL_start(U8 index, U8 data)
  598. {
  599. GH_I2C_FMCONTROL_S d;
  600. d.all = *(volatile U32 *)(REG_I2C_FMCONTROL + index * FIO_MOFFSET(I2C,0x00001000));
  601. d.bitc.start = data;
  602. *(volatile U32 *)(REG_I2C_FMCONTROL + index * FIO_MOFFSET(I2C,0x00001000)) = d.all;
  603. #if GH_I2C_ENABLE_DEBUG_PRINT
  604. GH_I2C_DEBUG_PRINT_FUNCTION( "WRREG(0x%08x,0x%08x); \\\\ [GH_I2C_set_FMCONTROL_start] <-- 0x%08x\n",
  605. (REG_I2C_FMCONTROL + index * FIO_MOFFSET(I2C,0x00001000)),d.all,d.all);
  606. #endif
  607. }
  608. GH_INLINE U8 GH_I2C_get_FMCONTROL_start(U8 index)
  609. {
  610. GH_I2C_FMCONTROL_S tmp_value;
  611. U32 value = (*(volatile U32 *)(REG_I2C_FMCONTROL + index * FIO_MOFFSET(I2C,0x00001000)));
  612. tmp_value.all = value;
  613. #if GH_I2C_ENABLE_DEBUG_PRINT
  614. GH_I2C_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_I2C_get_FMCONTROL_start] --> 0x%08x\n",
  615. (REG_I2C_FMCONTROL + index * FIO_MOFFSET(I2C,0x00001000)),value);
  616. #endif
  617. return tmp_value.bitc.start;
  618. }
  619. GH_INLINE void GH_I2C_set_FMCONTROL_is(U8 index, U8 data)
  620. {
  621. GH_I2C_FMCONTROL_S d;
  622. d.all = *(volatile U32 *)(REG_I2C_FMCONTROL + index * FIO_MOFFSET(I2C,0x00001000));
  623. d.bitc.is = data;
  624. *(volatile U32 *)(REG_I2C_FMCONTROL + index * FIO_MOFFSET(I2C,0x00001000)) = d.all;
  625. #if GH_I2C_ENABLE_DEBUG_PRINT
  626. GH_I2C_DEBUG_PRINT_FUNCTION( "WRREG(0x%08x,0x%08x); \\\\ [GH_I2C_set_FMCONTROL_is] <-- 0x%08x\n",
  627. (REG_I2C_FMCONTROL + index * FIO_MOFFSET(I2C,0x00001000)),d.all,d.all);
  628. #endif
  629. }
  630. GH_INLINE U8 GH_I2C_get_FMCONTROL_is(U8 index)
  631. {
  632. GH_I2C_FMCONTROL_S tmp_value;
  633. U32 value = (*(volatile U32 *)(REG_I2C_FMCONTROL + index * FIO_MOFFSET(I2C,0x00001000)));
  634. tmp_value.all = value;
  635. #if GH_I2C_ENABLE_DEBUG_PRINT
  636. GH_I2C_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_I2C_get_FMCONTROL_is] --> 0x%08x\n",
  637. (REG_I2C_FMCONTROL + index * FIO_MOFFSET(I2C,0x00001000)),value);
  638. #endif
  639. return tmp_value.bitc.is;
  640. }
  641. #endif /* GH_INLINE_LEVEL == 0 */
  642. /*----------------------------------------------------------------------------*/
  643. /* register I2C_FMDATA (read/write) */
  644. /*----------------------------------------------------------------------------*/
  645. #if GH_INLINE_LEVEL == 0
  646. /*! \brief Writes the register 'I2C_FMDATA'. */
  647. void GH_I2C_set_FMDATA(U8 index, U32 data);
  648. /*! \brief Reads the register 'I2C_FMDATA'. */
  649. U32 GH_I2C_get_FMDATA(U8 index);
  650. /*! \brief Writes the bit group 'Data' of register 'I2C_FMDATA'. */
  651. void GH_I2C_set_FMDATA_Data(U8 index, U8 data);
  652. /*! \brief Reads the bit group 'Data' of register 'I2C_FMDATA'. */
  653. U8 GH_I2C_get_FMDATA_Data(U8 index);
  654. #else /* GH_INLINE_LEVEL == 0 */
  655. GH_INLINE void GH_I2C_set_FMDATA(U8 index, U32 data)
  656. {
  657. *(volatile U32 *)(REG_I2C_FMDATA + index * FIO_MOFFSET(I2C,0x00001000)) = data;
  658. #if GH_I2C_ENABLE_DEBUG_PRINT
  659. GH_I2C_DEBUG_PRINT_FUNCTION( "WRREG(0x%08x,0x%08x); \\\\ [GH_I2C_set_FMDATA] <-- 0x%08x\n",
  660. (REG_I2C_FMDATA + index * FIO_MOFFSET(I2C,0x00001000)),data,data);
  661. #endif
  662. }
  663. GH_INLINE U32 GH_I2C_get_FMDATA(U8 index)
  664. {
  665. U32 value = (*(volatile U32 *)(REG_I2C_FMDATA + index * FIO_MOFFSET(I2C,0x00001000)));
  666. #if GH_I2C_ENABLE_DEBUG_PRINT
  667. GH_I2C_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_I2C_get_FMDATA] --> 0x%08x\n",
  668. (REG_I2C_FMDATA + index * FIO_MOFFSET(I2C,0x00001000)),value);
  669. #endif
  670. return value;
  671. }
  672. GH_INLINE void GH_I2C_set_FMDATA_Data(U8 index, U8 data)
  673. {
  674. GH_I2C_FMDATA_S d;
  675. d.all = *(volatile U32 *)(REG_I2C_FMDATA + index * FIO_MOFFSET(I2C,0x00001000));
  676. d.bitc.data = data;
  677. *(volatile U32 *)(REG_I2C_FMDATA + index * FIO_MOFFSET(I2C,0x00001000)) = d.all;
  678. #if GH_I2C_ENABLE_DEBUG_PRINT
  679. GH_I2C_DEBUG_PRINT_FUNCTION( "WRREG(0x%08x,0x%08x); \\\\ [GH_I2C_set_FMDATA_Data] <-- 0x%08x\n",
  680. (REG_I2C_FMDATA + index * FIO_MOFFSET(I2C,0x00001000)),d.all,d.all);
  681. #endif
  682. }
  683. GH_INLINE U8 GH_I2C_get_FMDATA_Data(U8 index)
  684. {
  685. GH_I2C_FMDATA_S tmp_value;
  686. U32 value = (*(volatile U32 *)(REG_I2C_FMDATA + index * FIO_MOFFSET(I2C,0x00001000)));
  687. tmp_value.all = value;
  688. #if GH_I2C_ENABLE_DEBUG_PRINT
  689. GH_I2C_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_I2C_get_FMDATA_Data] --> 0x%08x\n",
  690. (REG_I2C_FMDATA + index * FIO_MOFFSET(I2C,0x00001000)),value);
  691. #endif
  692. return tmp_value.bitc.data;
  693. }
  694. #endif /* GH_INLINE_LEVEL == 0 */
  695. /*----------------------------------------------------------------------------*/
  696. /* init function */
  697. /*----------------------------------------------------------------------------*/
  698. /*! \brief Initialises the registers and mirror variables. */
  699. void GH_I2C_init(void);
  700. #ifdef __cplusplus
  701. }
  702. #endif
  703. #endif /* _GH_I2C_H */
  704. /*----------------------------------------------------------------------------*/
  705. /* end of file */
  706. /*----------------------------------------------------------------------------*/