gh_debug_memd.h 47 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056
  1. /*!
  2. *******************************************************************************
  3. **
  4. ** \file gh_debug_memd.h
  5. **
  6. ** \brief MEMD Debug Registers.
  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_DEBUG_MEMD_H
  18. #define _GH_DEBUG_MEMD_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_DEBUG_MEMD_ENABLE_DEBUG_PRINT 0
  30. #ifdef __LINUX__
  31. #define GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION printk
  32. #else
  33. #define GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION printf
  34. #endif
  35. #ifndef __LINUX__
  36. #if GH_DEBUG_MEMD_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_DEBUG_MEMD_MEMD_CR_TRESET_ADDR FIO_ADDRESS(DEBUG_MEMD,0xa0150000) /* read/write */
  59. #define REG_DEBUG_MEMD_MEMD_CR_IC_INVLD_ADDR FIO_ADDRESS(DEBUG_MEMD,0xa0150004) /* write */
  60. #define REG_DEBUG_MEMD_MEMD_CR_RESET_PC_ADDR FIO_ADDRESS(DEBUG_MEMD,0xa0150008) /* read/write */
  61. #define REG_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR FIO_ADDRESS(DEBUG_MEMD,0xa015000C) /* read/write */
  62. #define REG_DEBUG_MEMD_MEMD_CR_TS_T0_ADDR FIO_ADDRESS(DEBUG_MEMD,0xa0150010) /* read */
  63. #define REG_DEBUG_MEMD_MEMD_CR_TS_T1_ADDR FIO_ADDRESS(DEBUG_MEMD,0xa0150014) /* read */
  64. #define REG_DEBUG_MEMD_MEMD_CR_TS_T2_ADDR FIO_ADDRESS(DEBUG_MEMD,0xa0150018) /* read */
  65. #define REG_DEBUG_MEMD_MEMD_CR_TS_T3_ADDR FIO_ADDRESS(DEBUG_MEMD,0xa015001C) /* read */
  66. #define REG_DEBUG_MEMD_MEMD_CR_IS_ADDR FIO_ADDRESS(DEBUG_MEMD,0xa0150020) /* read */
  67. #define REG_DEBUG_MEMD_MEMD_CR_LRU_ADDR FIO_ADDRESS(DEBUG_MEMD,0xa0150024) /* read */
  68. #define REG_DEBUG_MEMD_MEMD_CR_PC_T0_ADDR FIO_ADDRESS(DEBUG_MEMD,0xa0150028) /* read */
  69. #define REG_DEBUG_MEMD_MEMD_CR_PC_T1_ADDR FIO_ADDRESS(DEBUG_MEMD,0xa015002C) /* read */
  70. #define REG_DEBUG_MEMD_MEMD_CR_PC_T2_ADDR FIO_ADDRESS(DEBUG_MEMD,0xa0150030) /* read */
  71. #define REG_DEBUG_MEMD_MEMD_CR_PC_T3_ADDR FIO_ADDRESS(DEBUG_MEMD,0xa0150034) /* read */
  72. #define REG_DEBUG_MEMD_MEMD_CR_PC_D_ADDR FIO_ADDRESS(DEBUG_MEMD,0xa0150038) /* read */
  73. #define REG_DEBUG_MEMD_MEMD_CR_OP_D_ADDR FIO_ADDRESS(DEBUG_MEMD,0xa015003C) /* read */
  74. #define REG_DEBUG_MEMD_MEMD_CR_STALL_ADDR FIO_ADDRESS(DEBUG_MEMD,0xa0150040) /* read */
  75. #define REG_DEBUG_MEMD_MEMD_CR_DMAQ0_ADDR FIO_ADDRESS(DEBUG_MEMD,0xa0150044) /* read */
  76. #define REG_DEBUG_MEMD_MEMD_CR_DMAQ1_ADDR FIO_ADDRESS(DEBUG_MEMD,0xa0150048) /* read */
  77. #define REG_DEBUG_MEMD_MEMD_CR_DMAQ2_ADDR FIO_ADDRESS(DEBUG_MEMD,0xa015004C) /* read */
  78. #define REG_DEBUG_MEMD_MEMD_CR_CMDQ0_ADDR FIO_ADDRESS(DEBUG_MEMD,0xa0150050) /* read */
  79. #define REG_DEBUG_MEMD_MEMD_CR_ME_ADDR FIO_ADDRESS(DEBUG_MEMD,0xa0150060) /* read */
  80. #define REG_DEBUG_MEMD_MEMD_CR_MD_ADDR FIO_ADDRESS(DEBUG_MEMD,0xa0150064) /* read */
  81. #define REG_DEBUG_MEMD_MEMD_CR_RF_ADDR FIO_ADDRESS(DEBUG_MEMD,0xa0150800) /* read/write */
  82. /*----------------------------------------------------------------------------*/
  83. /* bit group structures */
  84. /*----------------------------------------------------------------------------*/
  85. typedef union { /* DEBUG_MEMD_MEMD_CR_TRESET_ADDR */
  86. U32 all;
  87. struct {
  88. U32 reset : 4;
  89. U32 suspend : 4;
  90. U32 : 23;
  91. U32 orc_reset : 1;
  92. } bitc;
  93. } GH_DEBUG_MEMD_MEMD_CR_TRESET_ADDR_S;
  94. typedef union { /* DEBUG_MEMD_MEMD_CR_IC_INVLD_ADDR */
  95. U32 all;
  96. struct {
  97. U32 icache : 1;
  98. U32 : 31;
  99. } bitc;
  100. } GH_DEBUG_MEMD_MEMD_CR_IC_INVLD_ADDR_S;
  101. typedef union { /* DEBUG_MEMD_MEMD_CR_RESET_PC_ADDR */
  102. U32 all;
  103. struct {
  104. U32 reset : 32;
  105. } bitc;
  106. } GH_DEBUG_MEMD_MEMD_CR_RESET_PC_ADDR_S;
  107. typedef union { /* DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR */
  108. U32 all;
  109. struct {
  110. U32 mctf : 1;
  111. U32 me : 1;
  112. U32 md : 1;
  113. U32 : 1;
  114. U32 mctf_hw : 1;
  115. U32 me_hw : 1;
  116. U32 md_hw : 1;
  117. U32 : 25;
  118. } bitc;
  119. } GH_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR_S;
  120. typedef union { /* DEBUG_MEMD_MEMD_CR_LRU_ADDR */
  121. U32 all;
  122. struct {
  123. U32 entry0 : 4;
  124. U32 entry1 : 4;
  125. U32 entry2 : 4;
  126. U32 entry3 : 4;
  127. U32 : 16;
  128. } bitc;
  129. } GH_DEBUG_MEMD_MEMD_CR_LRU_ADDR_S;
  130. typedef union { /* DEBUG_MEMD_MEMD_CR_PC_D_ADDR */
  131. U32 all;
  132. struct {
  133. U32 pc_d : 20;
  134. U32 : 11;
  135. U32 vld_d : 1;
  136. } bitc;
  137. } GH_DEBUG_MEMD_MEMD_CR_PC_D_ADDR_S;
  138. /*----------------------------------------------------------------------------*/
  139. /* mirror variables */
  140. /*----------------------------------------------------------------------------*/
  141. extern GH_DEBUG_MEMD_MEMD_CR_IC_INVLD_ADDR_S m_debug_memd_memd_cr_ic_invld_addr;
  142. #ifdef __cplusplus
  143. extern "C" {
  144. #endif
  145. /*----------------------------------------------------------------------------*/
  146. /* register DEBUG_MEMD_MEMD_CR_TRESET_ADDR (read/write) */
  147. /*----------------------------------------------------------------------------*/
  148. #if GH_INLINE_LEVEL == 0
  149. /*! \brief Writes the register 'DEBUG_MEMD_MEMD_CR_TRESET_ADDR'. */
  150. void GH_DEBUG_MEMD_set_MEMD_CR_TRESET_ADDR(U32 data);
  151. /*! \brief Reads the register 'DEBUG_MEMD_MEMD_CR_TRESET_ADDR'. */
  152. U32 GH_DEBUG_MEMD_get_MEMD_CR_TRESET_ADDR(void);
  153. /*! \brief Writes the bit group 'reset' of register 'DEBUG_MEMD_MEMD_CR_TRESET_ADDR'. */
  154. void GH_DEBUG_MEMD_set_MEMD_CR_TRESET_ADDR_reset(U8 data);
  155. /*! \brief Reads the bit group 'reset' of register 'DEBUG_MEMD_MEMD_CR_TRESET_ADDR'. */
  156. U8 GH_DEBUG_MEMD_get_MEMD_CR_TRESET_ADDR_reset(void);
  157. /*! \brief Writes the bit group 'suspend' of register 'DEBUG_MEMD_MEMD_CR_TRESET_ADDR'. */
  158. void GH_DEBUG_MEMD_set_MEMD_CR_TRESET_ADDR_suspend(U8 data);
  159. /*! \brief Reads the bit group 'suspend' of register 'DEBUG_MEMD_MEMD_CR_TRESET_ADDR'. */
  160. U8 GH_DEBUG_MEMD_get_MEMD_CR_TRESET_ADDR_suspend(void);
  161. /*! \brief Writes the bit group 'ORC_reset' of register 'DEBUG_MEMD_MEMD_CR_TRESET_ADDR'. */
  162. void GH_DEBUG_MEMD_set_MEMD_CR_TRESET_ADDR_ORC_reset(U8 data);
  163. /*! \brief Reads the bit group 'ORC_reset' of register 'DEBUG_MEMD_MEMD_CR_TRESET_ADDR'. */
  164. U8 GH_DEBUG_MEMD_get_MEMD_CR_TRESET_ADDR_ORC_reset(void);
  165. #else /* GH_INLINE_LEVEL == 0 */
  166. GH_INLINE void GH_DEBUG_MEMD_set_MEMD_CR_TRESET_ADDR(U32 data)
  167. {
  168. *(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_TRESET_ADDR = data;
  169. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  170. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "WRREG(0x%08x,0x%08x); \\\\ [GH_DEBUG_MEMD_set_MEMD_CR_TRESET_ADDR] <-- 0x%08x\n",
  171. REG_DEBUG_MEMD_MEMD_CR_TRESET_ADDR,data,data);
  172. #endif
  173. }
  174. GH_INLINE U32 GH_DEBUG_MEMD_get_MEMD_CR_TRESET_ADDR(void)
  175. {
  176. U32 value = (*(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_TRESET_ADDR);
  177. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  178. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_DEBUG_MEMD_get_MEMD_CR_TRESET_ADDR] --> 0x%08x\n",
  179. REG_DEBUG_MEMD_MEMD_CR_TRESET_ADDR,value);
  180. #endif
  181. return value;
  182. }
  183. GH_INLINE void GH_DEBUG_MEMD_set_MEMD_CR_TRESET_ADDR_reset(U8 data)
  184. {
  185. GH_DEBUG_MEMD_MEMD_CR_TRESET_ADDR_S d;
  186. d.all = *(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_TRESET_ADDR;
  187. d.bitc.reset = data;
  188. *(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_TRESET_ADDR = d.all;
  189. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  190. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "WRREG(0x%08x,0x%08x); \\\\ [GH_DEBUG_MEMD_set_MEMD_CR_TRESET_ADDR_reset] <-- 0x%08x\n",
  191. REG_DEBUG_MEMD_MEMD_CR_TRESET_ADDR,d.all,d.all);
  192. #endif
  193. }
  194. GH_INLINE U8 GH_DEBUG_MEMD_get_MEMD_CR_TRESET_ADDR_reset(void)
  195. {
  196. GH_DEBUG_MEMD_MEMD_CR_TRESET_ADDR_S tmp_value;
  197. U32 value = (*(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_TRESET_ADDR);
  198. tmp_value.all = value;
  199. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  200. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_DEBUG_MEMD_get_MEMD_CR_TRESET_ADDR_reset] --> 0x%08x\n",
  201. REG_DEBUG_MEMD_MEMD_CR_TRESET_ADDR,value);
  202. #endif
  203. return tmp_value.bitc.reset;
  204. }
  205. GH_INLINE void GH_DEBUG_MEMD_set_MEMD_CR_TRESET_ADDR_suspend(U8 data)
  206. {
  207. GH_DEBUG_MEMD_MEMD_CR_TRESET_ADDR_S d;
  208. d.all = *(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_TRESET_ADDR;
  209. d.bitc.suspend = data;
  210. *(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_TRESET_ADDR = d.all;
  211. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  212. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "WRREG(0x%08x,0x%08x); \\\\ [GH_DEBUG_MEMD_set_MEMD_CR_TRESET_ADDR_suspend] <-- 0x%08x\n",
  213. REG_DEBUG_MEMD_MEMD_CR_TRESET_ADDR,d.all,d.all);
  214. #endif
  215. }
  216. GH_INLINE U8 GH_DEBUG_MEMD_get_MEMD_CR_TRESET_ADDR_suspend(void)
  217. {
  218. GH_DEBUG_MEMD_MEMD_CR_TRESET_ADDR_S tmp_value;
  219. U32 value = (*(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_TRESET_ADDR);
  220. tmp_value.all = value;
  221. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  222. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_DEBUG_MEMD_get_MEMD_CR_TRESET_ADDR_suspend] --> 0x%08x\n",
  223. REG_DEBUG_MEMD_MEMD_CR_TRESET_ADDR,value);
  224. #endif
  225. return tmp_value.bitc.suspend;
  226. }
  227. GH_INLINE void GH_DEBUG_MEMD_set_MEMD_CR_TRESET_ADDR_ORC_reset(U8 data)
  228. {
  229. GH_DEBUG_MEMD_MEMD_CR_TRESET_ADDR_S d;
  230. d.all = *(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_TRESET_ADDR;
  231. d.bitc.orc_reset = data;
  232. *(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_TRESET_ADDR = d.all;
  233. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  234. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "WRREG(0x%08x,0x%08x); \\\\ [GH_DEBUG_MEMD_set_MEMD_CR_TRESET_ADDR_ORC_reset] <-- 0x%08x\n",
  235. REG_DEBUG_MEMD_MEMD_CR_TRESET_ADDR,d.all,d.all);
  236. #endif
  237. }
  238. GH_INLINE U8 GH_DEBUG_MEMD_get_MEMD_CR_TRESET_ADDR_ORC_reset(void)
  239. {
  240. GH_DEBUG_MEMD_MEMD_CR_TRESET_ADDR_S tmp_value;
  241. U32 value = (*(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_TRESET_ADDR);
  242. tmp_value.all = value;
  243. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  244. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_DEBUG_MEMD_get_MEMD_CR_TRESET_ADDR_ORC_reset] --> 0x%08x\n",
  245. REG_DEBUG_MEMD_MEMD_CR_TRESET_ADDR,value);
  246. #endif
  247. return tmp_value.bitc.orc_reset;
  248. }
  249. #endif /* GH_INLINE_LEVEL == 0 */
  250. /*----------------------------------------------------------------------------*/
  251. /* register DEBUG_MEMD_MEMD_CR_IC_INVLD_ADDR (write) */
  252. /*----------------------------------------------------------------------------*/
  253. #if GH_INLINE_LEVEL < 2
  254. /*! \brief Writes the register 'DEBUG_MEMD_MEMD_CR_IC_INVLD_ADDR'. */
  255. void GH_DEBUG_MEMD_set_MEMD_CR_IC_INVLD_ADDR(U32 data);
  256. /*! \brief Reads the mirror variable of the register 'DEBUG_MEMD_MEMD_CR_IC_INVLD_ADDR'. */
  257. U32 GH_DEBUG_MEMD_getm_MEMD_CR_IC_INVLD_ADDR(void);
  258. /*! \brief Writes the bit group 'icache' of register 'DEBUG_MEMD_MEMD_CR_IC_INVLD_ADDR'. */
  259. void GH_DEBUG_MEMD_set_MEMD_CR_IC_INVLD_ADDR_icache(U8 data);
  260. /*! \brief Reads the bit group 'icache' from the mirror variable of register 'DEBUG_MEMD_MEMD_CR_IC_INVLD_ADDR'. */
  261. U8 GH_DEBUG_MEMD_getm_MEMD_CR_IC_INVLD_ADDR_icache(void);
  262. #else /* GH_INLINE_LEVEL < 2 */
  263. GH_INLINE void GH_DEBUG_MEMD_set_MEMD_CR_IC_INVLD_ADDR(U32 data)
  264. {
  265. m_debug_memd_memd_cr_ic_invld_addr.all = data;
  266. *(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_IC_INVLD_ADDR = data;
  267. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  268. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "WRREG(0x%08x,0x%08x); \\\\ [GH_DEBUG_MEMD_set_MEMD_CR_IC_INVLD_ADDR] <-- 0x%08x\n",
  269. REG_DEBUG_MEMD_MEMD_CR_IC_INVLD_ADDR,data,data);
  270. #endif
  271. }
  272. GH_INLINE U32 GH_DEBUG_MEMD_getm_MEMD_CR_IC_INVLD_ADDR(void)
  273. {
  274. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  275. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "[GH_DEBUG_MEMD_getm_MEMD_CR_IC_INVLD_ADDR] --> 0x%08x\n",
  276. m_debug_memd_memd_cr_ic_invld_addr.all);
  277. #endif
  278. return m_debug_memd_memd_cr_ic_invld_addr.all;
  279. }
  280. GH_INLINE void GH_DEBUG_MEMD_set_MEMD_CR_IC_INVLD_ADDR_icache(U8 data)
  281. {
  282. m_debug_memd_memd_cr_ic_invld_addr.bitc.icache = data;
  283. *(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_IC_INVLD_ADDR = m_debug_memd_memd_cr_ic_invld_addr.all;
  284. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  285. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "WRREG(0x%08x,0x%08x); \\\\ [GH_DEBUG_MEMD_set_MEMD_CR_IC_INVLD_ADDR_icache] <-- 0x%08x\n",
  286. REG_DEBUG_MEMD_MEMD_CR_IC_INVLD_ADDR,m_debug_memd_memd_cr_ic_invld_addr.all,m_debug_memd_memd_cr_ic_invld_addr.all);
  287. #endif
  288. }
  289. GH_INLINE U8 GH_DEBUG_MEMD_getm_MEMD_CR_IC_INVLD_ADDR_icache(void)
  290. {
  291. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  292. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "[GH_DEBUG_MEMD_getm_MEMD_CR_IC_INVLD_ADDR_icache] --> 0x%08x\n",
  293. m_debug_memd_memd_cr_ic_invld_addr.bitc.icache);
  294. #endif
  295. return m_debug_memd_memd_cr_ic_invld_addr.bitc.icache;
  296. }
  297. #endif /* GH_INLINE_LEVEL < 2 */
  298. /*----------------------------------------------------------------------------*/
  299. /* register DEBUG_MEMD_MEMD_CR_RESET_PC_ADDR (read/write) */
  300. /*----------------------------------------------------------------------------*/
  301. #if GH_INLINE_LEVEL == 0
  302. /*! \brief Writes the register 'DEBUG_MEMD_MEMD_CR_RESET_PC_ADDR'. */
  303. void GH_DEBUG_MEMD_set_MEMD_CR_RESET_PC_ADDR(U32 data);
  304. /*! \brief Reads the register 'DEBUG_MEMD_MEMD_CR_RESET_PC_ADDR'. */
  305. U32 GH_DEBUG_MEMD_get_MEMD_CR_RESET_PC_ADDR(void);
  306. /*! \brief Writes the bit group 'reset' of register 'DEBUG_MEMD_MEMD_CR_RESET_PC_ADDR'. */
  307. void GH_DEBUG_MEMD_set_MEMD_CR_RESET_PC_ADDR_reset(U32 data);
  308. /*! \brief Reads the bit group 'reset' of register 'DEBUG_MEMD_MEMD_CR_RESET_PC_ADDR'. */
  309. U32 GH_DEBUG_MEMD_get_MEMD_CR_RESET_PC_ADDR_reset(void);
  310. #else /* GH_INLINE_LEVEL == 0 */
  311. GH_INLINE void GH_DEBUG_MEMD_set_MEMD_CR_RESET_PC_ADDR(U32 data)
  312. {
  313. *(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_RESET_PC_ADDR = data;
  314. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  315. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "WRREG(0x%08x,0x%08x); \\\\ [GH_DEBUG_MEMD_set_MEMD_CR_RESET_PC_ADDR] <-- 0x%08x\n",
  316. REG_DEBUG_MEMD_MEMD_CR_RESET_PC_ADDR,data,data);
  317. #endif
  318. }
  319. GH_INLINE U32 GH_DEBUG_MEMD_get_MEMD_CR_RESET_PC_ADDR(void)
  320. {
  321. U32 value = (*(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_RESET_PC_ADDR);
  322. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  323. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_DEBUG_MEMD_get_MEMD_CR_RESET_PC_ADDR] --> 0x%08x\n",
  324. REG_DEBUG_MEMD_MEMD_CR_RESET_PC_ADDR,value);
  325. #endif
  326. return value;
  327. }
  328. GH_INLINE void GH_DEBUG_MEMD_set_MEMD_CR_RESET_PC_ADDR_reset(U32 data)
  329. {
  330. GH_DEBUG_MEMD_MEMD_CR_RESET_PC_ADDR_S d;
  331. d.all = *(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_RESET_PC_ADDR;
  332. d.bitc.reset = data;
  333. *(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_RESET_PC_ADDR = d.all;
  334. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  335. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "WRREG(0x%08x,0x%08x); \\\\ [GH_DEBUG_MEMD_set_MEMD_CR_RESET_PC_ADDR_reset] <-- 0x%08x\n",
  336. REG_DEBUG_MEMD_MEMD_CR_RESET_PC_ADDR,d.all,d.all);
  337. #endif
  338. }
  339. GH_INLINE U32 GH_DEBUG_MEMD_get_MEMD_CR_RESET_PC_ADDR_reset(void)
  340. {
  341. GH_DEBUG_MEMD_MEMD_CR_RESET_PC_ADDR_S tmp_value;
  342. U32 value = (*(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_RESET_PC_ADDR);
  343. tmp_value.all = value;
  344. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  345. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_DEBUG_MEMD_get_MEMD_CR_RESET_PC_ADDR_reset] --> 0x%08x\n",
  346. REG_DEBUG_MEMD_MEMD_CR_RESET_PC_ADDR,value);
  347. #endif
  348. return tmp_value.bitc.reset;
  349. }
  350. #endif /* GH_INLINE_LEVEL == 0 */
  351. /*----------------------------------------------------------------------------*/
  352. /* register DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR (read/write) */
  353. /*----------------------------------------------------------------------------*/
  354. #if GH_INLINE_LEVEL == 0
  355. /*! \brief Writes the register 'DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR'. */
  356. void GH_DEBUG_MEMD_set_MEMD_CR_CLKCTRL_ADDR(U32 data);
  357. /*! \brief Reads the register 'DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR'. */
  358. U32 GH_DEBUG_MEMD_get_MEMD_CR_CLKCTRL_ADDR(void);
  359. /*! \brief Writes the bit group 'MCTF' of register 'DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR'. */
  360. void GH_DEBUG_MEMD_set_MEMD_CR_CLKCTRL_ADDR_MCTF(U8 data);
  361. /*! \brief Reads the bit group 'MCTF' of register 'DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR'. */
  362. U8 GH_DEBUG_MEMD_get_MEMD_CR_CLKCTRL_ADDR_MCTF(void);
  363. /*! \brief Writes the bit group 'ME' of register 'DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR'. */
  364. void GH_DEBUG_MEMD_set_MEMD_CR_CLKCTRL_ADDR_ME(U8 data);
  365. /*! \brief Reads the bit group 'ME' of register 'DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR'. */
  366. U8 GH_DEBUG_MEMD_get_MEMD_CR_CLKCTRL_ADDR_ME(void);
  367. /*! \brief Writes the bit group 'MD' of register 'DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR'. */
  368. void GH_DEBUG_MEMD_set_MEMD_CR_CLKCTRL_ADDR_MD(U8 data);
  369. /*! \brief Reads the bit group 'MD' of register 'DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR'. */
  370. U8 GH_DEBUG_MEMD_get_MEMD_CR_CLKCTRL_ADDR_MD(void);
  371. /*! \brief Writes the bit group 'MCTF_HW' of register 'DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR'. */
  372. void GH_DEBUG_MEMD_set_MEMD_CR_CLKCTRL_ADDR_MCTF_HW(U8 data);
  373. /*! \brief Reads the bit group 'MCTF_HW' of register 'DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR'. */
  374. U8 GH_DEBUG_MEMD_get_MEMD_CR_CLKCTRL_ADDR_MCTF_HW(void);
  375. /*! \brief Writes the bit group 'ME_HW' of register 'DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR'. */
  376. void GH_DEBUG_MEMD_set_MEMD_CR_CLKCTRL_ADDR_ME_HW(U8 data);
  377. /*! \brief Reads the bit group 'ME_HW' of register 'DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR'. */
  378. U8 GH_DEBUG_MEMD_get_MEMD_CR_CLKCTRL_ADDR_ME_HW(void);
  379. /*! \brief Writes the bit group 'MD_HW' of register 'DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR'. */
  380. void GH_DEBUG_MEMD_set_MEMD_CR_CLKCTRL_ADDR_MD_HW(U8 data);
  381. /*! \brief Reads the bit group 'MD_HW' of register 'DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR'. */
  382. U8 GH_DEBUG_MEMD_get_MEMD_CR_CLKCTRL_ADDR_MD_HW(void);
  383. #else /* GH_INLINE_LEVEL == 0 */
  384. GH_INLINE void GH_DEBUG_MEMD_set_MEMD_CR_CLKCTRL_ADDR(U32 data)
  385. {
  386. *(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR = data;
  387. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  388. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "WRREG(0x%08x,0x%08x); \\\\ [GH_DEBUG_MEMD_set_MEMD_CR_CLKCTRL_ADDR] <-- 0x%08x\n",
  389. REG_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR,data,data);
  390. #endif
  391. }
  392. GH_INLINE U32 GH_DEBUG_MEMD_get_MEMD_CR_CLKCTRL_ADDR(void)
  393. {
  394. U32 value = (*(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR);
  395. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  396. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_DEBUG_MEMD_get_MEMD_CR_CLKCTRL_ADDR] --> 0x%08x\n",
  397. REG_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR,value);
  398. #endif
  399. return value;
  400. }
  401. GH_INLINE void GH_DEBUG_MEMD_set_MEMD_CR_CLKCTRL_ADDR_MCTF(U8 data)
  402. {
  403. GH_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR_S d;
  404. d.all = *(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR;
  405. d.bitc.mctf = data;
  406. *(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR = d.all;
  407. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  408. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "WRREG(0x%08x,0x%08x); \\\\ [GH_DEBUG_MEMD_set_MEMD_CR_CLKCTRL_ADDR_MCTF] <-- 0x%08x\n",
  409. REG_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR,d.all,d.all);
  410. #endif
  411. }
  412. GH_INLINE U8 GH_DEBUG_MEMD_get_MEMD_CR_CLKCTRL_ADDR_MCTF(void)
  413. {
  414. GH_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR_S tmp_value;
  415. U32 value = (*(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR);
  416. tmp_value.all = value;
  417. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  418. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_DEBUG_MEMD_get_MEMD_CR_CLKCTRL_ADDR_MCTF] --> 0x%08x\n",
  419. REG_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR,value);
  420. #endif
  421. return tmp_value.bitc.mctf;
  422. }
  423. GH_INLINE void GH_DEBUG_MEMD_set_MEMD_CR_CLKCTRL_ADDR_ME(U8 data)
  424. {
  425. GH_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR_S d;
  426. d.all = *(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR;
  427. d.bitc.me = data;
  428. *(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR = d.all;
  429. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  430. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "WRREG(0x%08x,0x%08x); \\\\ [GH_DEBUG_MEMD_set_MEMD_CR_CLKCTRL_ADDR_ME] <-- 0x%08x\n",
  431. REG_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR,d.all,d.all);
  432. #endif
  433. }
  434. GH_INLINE U8 GH_DEBUG_MEMD_get_MEMD_CR_CLKCTRL_ADDR_ME(void)
  435. {
  436. GH_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR_S tmp_value;
  437. U32 value = (*(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR);
  438. tmp_value.all = value;
  439. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  440. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_DEBUG_MEMD_get_MEMD_CR_CLKCTRL_ADDR_ME] --> 0x%08x\n",
  441. REG_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR,value);
  442. #endif
  443. return tmp_value.bitc.me;
  444. }
  445. GH_INLINE void GH_DEBUG_MEMD_set_MEMD_CR_CLKCTRL_ADDR_MD(U8 data)
  446. {
  447. GH_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR_S d;
  448. d.all = *(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR;
  449. d.bitc.md = data;
  450. *(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR = d.all;
  451. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  452. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "WRREG(0x%08x,0x%08x); \\\\ [GH_DEBUG_MEMD_set_MEMD_CR_CLKCTRL_ADDR_MD] <-- 0x%08x\n",
  453. REG_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR,d.all,d.all);
  454. #endif
  455. }
  456. GH_INLINE U8 GH_DEBUG_MEMD_get_MEMD_CR_CLKCTRL_ADDR_MD(void)
  457. {
  458. GH_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR_S tmp_value;
  459. U32 value = (*(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR);
  460. tmp_value.all = value;
  461. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  462. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_DEBUG_MEMD_get_MEMD_CR_CLKCTRL_ADDR_MD] --> 0x%08x\n",
  463. REG_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR,value);
  464. #endif
  465. return tmp_value.bitc.md;
  466. }
  467. GH_INLINE void GH_DEBUG_MEMD_set_MEMD_CR_CLKCTRL_ADDR_MCTF_HW(U8 data)
  468. {
  469. GH_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR_S d;
  470. d.all = *(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR;
  471. d.bitc.mctf_hw = data;
  472. *(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR = d.all;
  473. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  474. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "WRREG(0x%08x,0x%08x); \\\\ [GH_DEBUG_MEMD_set_MEMD_CR_CLKCTRL_ADDR_MCTF_HW] <-- 0x%08x\n",
  475. REG_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR,d.all,d.all);
  476. #endif
  477. }
  478. GH_INLINE U8 GH_DEBUG_MEMD_get_MEMD_CR_CLKCTRL_ADDR_MCTF_HW(void)
  479. {
  480. GH_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR_S tmp_value;
  481. U32 value = (*(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR);
  482. tmp_value.all = value;
  483. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  484. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_DEBUG_MEMD_get_MEMD_CR_CLKCTRL_ADDR_MCTF_HW] --> 0x%08x\n",
  485. REG_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR,value);
  486. #endif
  487. return tmp_value.bitc.mctf_hw;
  488. }
  489. GH_INLINE void GH_DEBUG_MEMD_set_MEMD_CR_CLKCTRL_ADDR_ME_HW(U8 data)
  490. {
  491. GH_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR_S d;
  492. d.all = *(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR;
  493. d.bitc.me_hw = data;
  494. *(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR = d.all;
  495. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  496. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "WRREG(0x%08x,0x%08x); \\\\ [GH_DEBUG_MEMD_set_MEMD_CR_CLKCTRL_ADDR_ME_HW] <-- 0x%08x\n",
  497. REG_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR,d.all,d.all);
  498. #endif
  499. }
  500. GH_INLINE U8 GH_DEBUG_MEMD_get_MEMD_CR_CLKCTRL_ADDR_ME_HW(void)
  501. {
  502. GH_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR_S tmp_value;
  503. U32 value = (*(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR);
  504. tmp_value.all = value;
  505. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  506. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_DEBUG_MEMD_get_MEMD_CR_CLKCTRL_ADDR_ME_HW] --> 0x%08x\n",
  507. REG_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR,value);
  508. #endif
  509. return tmp_value.bitc.me_hw;
  510. }
  511. GH_INLINE void GH_DEBUG_MEMD_set_MEMD_CR_CLKCTRL_ADDR_MD_HW(U8 data)
  512. {
  513. GH_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR_S d;
  514. d.all = *(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR;
  515. d.bitc.md_hw = data;
  516. *(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR = d.all;
  517. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  518. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "WRREG(0x%08x,0x%08x); \\\\ [GH_DEBUG_MEMD_set_MEMD_CR_CLKCTRL_ADDR_MD_HW] <-- 0x%08x\n",
  519. REG_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR,d.all,d.all);
  520. #endif
  521. }
  522. GH_INLINE U8 GH_DEBUG_MEMD_get_MEMD_CR_CLKCTRL_ADDR_MD_HW(void)
  523. {
  524. GH_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR_S tmp_value;
  525. U32 value = (*(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR);
  526. tmp_value.all = value;
  527. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  528. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_DEBUG_MEMD_get_MEMD_CR_CLKCTRL_ADDR_MD_HW] --> 0x%08x\n",
  529. REG_DEBUG_MEMD_MEMD_CR_CLKCTRL_ADDR,value);
  530. #endif
  531. return tmp_value.bitc.md_hw;
  532. }
  533. #endif /* GH_INLINE_LEVEL == 0 */
  534. /*----------------------------------------------------------------------------*/
  535. /* register DEBUG_MEMD_MEMD_CR_TS_T0_ADDR (read) */
  536. /*----------------------------------------------------------------------------*/
  537. #if GH_INLINE_LEVEL == 0
  538. /*! \brief Reads the register 'DEBUG_MEMD_MEMD_CR_TS_T0_ADDR'. */
  539. U32 GH_DEBUG_MEMD_get_MEMD_CR_TS_T0_ADDR(void);
  540. #else /* GH_INLINE_LEVEL == 0 */
  541. GH_INLINE U32 GH_DEBUG_MEMD_get_MEMD_CR_TS_T0_ADDR(void)
  542. {
  543. U32 value = (*(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_TS_T0_ADDR);
  544. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  545. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_DEBUG_MEMD_get_MEMD_CR_TS_T0_ADDR] --> 0x%08x\n",
  546. REG_DEBUG_MEMD_MEMD_CR_TS_T0_ADDR,value);
  547. #endif
  548. return value;
  549. }
  550. #endif /* GH_INLINE_LEVEL == 0 */
  551. /*----------------------------------------------------------------------------*/
  552. /* register DEBUG_MEMD_MEMD_CR_TS_T1_ADDR (read) */
  553. /*----------------------------------------------------------------------------*/
  554. #if GH_INLINE_LEVEL == 0
  555. /*! \brief Reads the register 'DEBUG_MEMD_MEMD_CR_TS_T1_ADDR'. */
  556. U32 GH_DEBUG_MEMD_get_MEMD_CR_TS_T1_ADDR(void);
  557. #else /* GH_INLINE_LEVEL == 0 */
  558. GH_INLINE U32 GH_DEBUG_MEMD_get_MEMD_CR_TS_T1_ADDR(void)
  559. {
  560. U32 value = (*(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_TS_T1_ADDR);
  561. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  562. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_DEBUG_MEMD_get_MEMD_CR_TS_T1_ADDR] --> 0x%08x\n",
  563. REG_DEBUG_MEMD_MEMD_CR_TS_T1_ADDR,value);
  564. #endif
  565. return value;
  566. }
  567. #endif /* GH_INLINE_LEVEL == 0 */
  568. /*----------------------------------------------------------------------------*/
  569. /* register DEBUG_MEMD_MEMD_CR_TS_T2_ADDR (read) */
  570. /*----------------------------------------------------------------------------*/
  571. #if GH_INLINE_LEVEL == 0
  572. /*! \brief Reads the register 'DEBUG_MEMD_MEMD_CR_TS_T2_ADDR'. */
  573. U32 GH_DEBUG_MEMD_get_MEMD_CR_TS_T2_ADDR(void);
  574. #else /* GH_INLINE_LEVEL == 0 */
  575. GH_INLINE U32 GH_DEBUG_MEMD_get_MEMD_CR_TS_T2_ADDR(void)
  576. {
  577. U32 value = (*(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_TS_T2_ADDR);
  578. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  579. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_DEBUG_MEMD_get_MEMD_CR_TS_T2_ADDR] --> 0x%08x\n",
  580. REG_DEBUG_MEMD_MEMD_CR_TS_T2_ADDR,value);
  581. #endif
  582. return value;
  583. }
  584. #endif /* GH_INLINE_LEVEL == 0 */
  585. /*----------------------------------------------------------------------------*/
  586. /* register DEBUG_MEMD_MEMD_CR_TS_T3_ADDR (read) */
  587. /*----------------------------------------------------------------------------*/
  588. #if GH_INLINE_LEVEL == 0
  589. /*! \brief Reads the register 'DEBUG_MEMD_MEMD_CR_TS_T3_ADDR'. */
  590. U32 GH_DEBUG_MEMD_get_MEMD_CR_TS_T3_ADDR(void);
  591. #else /* GH_INLINE_LEVEL == 0 */
  592. GH_INLINE U32 GH_DEBUG_MEMD_get_MEMD_CR_TS_T3_ADDR(void)
  593. {
  594. U32 value = (*(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_TS_T3_ADDR);
  595. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  596. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_DEBUG_MEMD_get_MEMD_CR_TS_T3_ADDR] --> 0x%08x\n",
  597. REG_DEBUG_MEMD_MEMD_CR_TS_T3_ADDR,value);
  598. #endif
  599. return value;
  600. }
  601. #endif /* GH_INLINE_LEVEL == 0 */
  602. /*----------------------------------------------------------------------------*/
  603. /* register DEBUG_MEMD_MEMD_CR_IS_ADDR (read) */
  604. /*----------------------------------------------------------------------------*/
  605. #if GH_INLINE_LEVEL == 0
  606. /*! \brief Reads the register 'DEBUG_MEMD_MEMD_CR_IS_ADDR'. */
  607. U32 GH_DEBUG_MEMD_get_MEMD_CR_IS_ADDR(void);
  608. #else /* GH_INLINE_LEVEL == 0 */
  609. GH_INLINE U32 GH_DEBUG_MEMD_get_MEMD_CR_IS_ADDR(void)
  610. {
  611. U32 value = (*(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_IS_ADDR);
  612. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  613. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_DEBUG_MEMD_get_MEMD_CR_IS_ADDR] --> 0x%08x\n",
  614. REG_DEBUG_MEMD_MEMD_CR_IS_ADDR,value);
  615. #endif
  616. return value;
  617. }
  618. #endif /* GH_INLINE_LEVEL == 0 */
  619. /*----------------------------------------------------------------------------*/
  620. /* register DEBUG_MEMD_MEMD_CR_LRU_ADDR (read) */
  621. /*----------------------------------------------------------------------------*/
  622. #if GH_INLINE_LEVEL == 0
  623. /*! \brief Reads the register 'DEBUG_MEMD_MEMD_CR_LRU_ADDR'. */
  624. U32 GH_DEBUG_MEMD_get_MEMD_CR_LRU_ADDR(void);
  625. /*! \brief Reads the bit group 'entry0' of register 'DEBUG_MEMD_MEMD_CR_LRU_ADDR'. */
  626. U8 GH_DEBUG_MEMD_get_MEMD_CR_LRU_ADDR_entry0(void);
  627. /*! \brief Reads the bit group 'entry1' of register 'DEBUG_MEMD_MEMD_CR_LRU_ADDR'. */
  628. U8 GH_DEBUG_MEMD_get_MEMD_CR_LRU_ADDR_entry1(void);
  629. /*! \brief Reads the bit group 'entry2' of register 'DEBUG_MEMD_MEMD_CR_LRU_ADDR'. */
  630. U8 GH_DEBUG_MEMD_get_MEMD_CR_LRU_ADDR_entry2(void);
  631. /*! \brief Reads the bit group 'entry3' of register 'DEBUG_MEMD_MEMD_CR_LRU_ADDR'. */
  632. U8 GH_DEBUG_MEMD_get_MEMD_CR_LRU_ADDR_entry3(void);
  633. #else /* GH_INLINE_LEVEL == 0 */
  634. GH_INLINE U32 GH_DEBUG_MEMD_get_MEMD_CR_LRU_ADDR(void)
  635. {
  636. U32 value = (*(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_LRU_ADDR);
  637. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  638. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_DEBUG_MEMD_get_MEMD_CR_LRU_ADDR] --> 0x%08x\n",
  639. REG_DEBUG_MEMD_MEMD_CR_LRU_ADDR,value);
  640. #endif
  641. return value;
  642. }
  643. GH_INLINE U8 GH_DEBUG_MEMD_get_MEMD_CR_LRU_ADDR_entry0(void)
  644. {
  645. GH_DEBUG_MEMD_MEMD_CR_LRU_ADDR_S tmp_value;
  646. U32 value = (*(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_LRU_ADDR);
  647. tmp_value.all = value;
  648. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  649. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_DEBUG_MEMD_get_MEMD_CR_LRU_ADDR_entry0] --> 0x%08x\n",
  650. REG_DEBUG_MEMD_MEMD_CR_LRU_ADDR,value);
  651. #endif
  652. return tmp_value.bitc.entry0;
  653. }
  654. GH_INLINE U8 GH_DEBUG_MEMD_get_MEMD_CR_LRU_ADDR_entry1(void)
  655. {
  656. GH_DEBUG_MEMD_MEMD_CR_LRU_ADDR_S tmp_value;
  657. U32 value = (*(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_LRU_ADDR);
  658. tmp_value.all = value;
  659. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  660. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_DEBUG_MEMD_get_MEMD_CR_LRU_ADDR_entry1] --> 0x%08x\n",
  661. REG_DEBUG_MEMD_MEMD_CR_LRU_ADDR,value);
  662. #endif
  663. return tmp_value.bitc.entry1;
  664. }
  665. GH_INLINE U8 GH_DEBUG_MEMD_get_MEMD_CR_LRU_ADDR_entry2(void)
  666. {
  667. GH_DEBUG_MEMD_MEMD_CR_LRU_ADDR_S tmp_value;
  668. U32 value = (*(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_LRU_ADDR);
  669. tmp_value.all = value;
  670. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  671. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_DEBUG_MEMD_get_MEMD_CR_LRU_ADDR_entry2] --> 0x%08x\n",
  672. REG_DEBUG_MEMD_MEMD_CR_LRU_ADDR,value);
  673. #endif
  674. return tmp_value.bitc.entry2;
  675. }
  676. GH_INLINE U8 GH_DEBUG_MEMD_get_MEMD_CR_LRU_ADDR_entry3(void)
  677. {
  678. GH_DEBUG_MEMD_MEMD_CR_LRU_ADDR_S tmp_value;
  679. U32 value = (*(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_LRU_ADDR);
  680. tmp_value.all = value;
  681. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  682. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_DEBUG_MEMD_get_MEMD_CR_LRU_ADDR_entry3] --> 0x%08x\n",
  683. REG_DEBUG_MEMD_MEMD_CR_LRU_ADDR,value);
  684. #endif
  685. return tmp_value.bitc.entry3;
  686. }
  687. #endif /* GH_INLINE_LEVEL == 0 */
  688. /*----------------------------------------------------------------------------*/
  689. /* register DEBUG_MEMD_MEMD_CR_PC_T0_ADDR (read) */
  690. /*----------------------------------------------------------------------------*/
  691. #if GH_INLINE_LEVEL == 0
  692. /*! \brief Reads the register 'DEBUG_MEMD_MEMD_CR_PC_T0_ADDR'. */
  693. U32 GH_DEBUG_MEMD_get_MEMD_CR_PC_T0_ADDR(void);
  694. #else /* GH_INLINE_LEVEL == 0 */
  695. GH_INLINE U32 GH_DEBUG_MEMD_get_MEMD_CR_PC_T0_ADDR(void)
  696. {
  697. U32 value = (*(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_PC_T0_ADDR);
  698. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  699. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_DEBUG_MEMD_get_MEMD_CR_PC_T0_ADDR] --> 0x%08x\n",
  700. REG_DEBUG_MEMD_MEMD_CR_PC_T0_ADDR,value);
  701. #endif
  702. return value;
  703. }
  704. #endif /* GH_INLINE_LEVEL == 0 */
  705. /*----------------------------------------------------------------------------*/
  706. /* register DEBUG_MEMD_MEMD_CR_PC_T1_ADDR (read) */
  707. /*----------------------------------------------------------------------------*/
  708. #if GH_INLINE_LEVEL == 0
  709. /*! \brief Reads the register 'DEBUG_MEMD_MEMD_CR_PC_T1_ADDR'. */
  710. U32 GH_DEBUG_MEMD_get_MEMD_CR_PC_T1_ADDR(void);
  711. #else /* GH_INLINE_LEVEL == 0 */
  712. GH_INLINE U32 GH_DEBUG_MEMD_get_MEMD_CR_PC_T1_ADDR(void)
  713. {
  714. U32 value = (*(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_PC_T1_ADDR);
  715. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  716. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_DEBUG_MEMD_get_MEMD_CR_PC_T1_ADDR] --> 0x%08x\n",
  717. REG_DEBUG_MEMD_MEMD_CR_PC_T1_ADDR,value);
  718. #endif
  719. return value;
  720. }
  721. #endif /* GH_INLINE_LEVEL == 0 */
  722. /*----------------------------------------------------------------------------*/
  723. /* register DEBUG_MEMD_MEMD_CR_PC_T2_ADDR (read) */
  724. /*----------------------------------------------------------------------------*/
  725. #if GH_INLINE_LEVEL == 0
  726. /*! \brief Reads the register 'DEBUG_MEMD_MEMD_CR_PC_T2_ADDR'. */
  727. U32 GH_DEBUG_MEMD_get_MEMD_CR_PC_T2_ADDR(void);
  728. #else /* GH_INLINE_LEVEL == 0 */
  729. GH_INLINE U32 GH_DEBUG_MEMD_get_MEMD_CR_PC_T2_ADDR(void)
  730. {
  731. U32 value = (*(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_PC_T2_ADDR);
  732. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  733. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_DEBUG_MEMD_get_MEMD_CR_PC_T2_ADDR] --> 0x%08x\n",
  734. REG_DEBUG_MEMD_MEMD_CR_PC_T2_ADDR,value);
  735. #endif
  736. return value;
  737. }
  738. #endif /* GH_INLINE_LEVEL == 0 */
  739. /*----------------------------------------------------------------------------*/
  740. /* register DEBUG_MEMD_MEMD_CR_PC_T3_ADDR (read) */
  741. /*----------------------------------------------------------------------------*/
  742. #if GH_INLINE_LEVEL == 0
  743. /*! \brief Reads the register 'DEBUG_MEMD_MEMD_CR_PC_T3_ADDR'. */
  744. U32 GH_DEBUG_MEMD_get_MEMD_CR_PC_T3_ADDR(void);
  745. #else /* GH_INLINE_LEVEL == 0 */
  746. GH_INLINE U32 GH_DEBUG_MEMD_get_MEMD_CR_PC_T3_ADDR(void)
  747. {
  748. U32 value = (*(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_PC_T3_ADDR);
  749. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  750. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_DEBUG_MEMD_get_MEMD_CR_PC_T3_ADDR] --> 0x%08x\n",
  751. REG_DEBUG_MEMD_MEMD_CR_PC_T3_ADDR,value);
  752. #endif
  753. return value;
  754. }
  755. #endif /* GH_INLINE_LEVEL == 0 */
  756. /*----------------------------------------------------------------------------*/
  757. /* register DEBUG_MEMD_MEMD_CR_PC_D_ADDR (read) */
  758. /*----------------------------------------------------------------------------*/
  759. #if GH_INLINE_LEVEL == 0
  760. /*! \brief Reads the register 'DEBUG_MEMD_MEMD_CR_PC_D_ADDR'. */
  761. U32 GH_DEBUG_MEMD_get_MEMD_CR_PC_D_ADDR(void);
  762. /*! \brief Reads the bit group 'pc_d' of register 'DEBUG_MEMD_MEMD_CR_PC_D_ADDR'. */
  763. U32 GH_DEBUG_MEMD_get_MEMD_CR_PC_D_ADDR_pc_d(void);
  764. /*! \brief Reads the bit group 'vld_d' of register 'DEBUG_MEMD_MEMD_CR_PC_D_ADDR'. */
  765. U8 GH_DEBUG_MEMD_get_MEMD_CR_PC_D_ADDR_vld_d(void);
  766. #else /* GH_INLINE_LEVEL == 0 */
  767. GH_INLINE U32 GH_DEBUG_MEMD_get_MEMD_CR_PC_D_ADDR(void)
  768. {
  769. U32 value = (*(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_PC_D_ADDR);
  770. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  771. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_DEBUG_MEMD_get_MEMD_CR_PC_D_ADDR] --> 0x%08x\n",
  772. REG_DEBUG_MEMD_MEMD_CR_PC_D_ADDR,value);
  773. #endif
  774. return value;
  775. }
  776. GH_INLINE U32 GH_DEBUG_MEMD_get_MEMD_CR_PC_D_ADDR_pc_d(void)
  777. {
  778. GH_DEBUG_MEMD_MEMD_CR_PC_D_ADDR_S tmp_value;
  779. U32 value = (*(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_PC_D_ADDR);
  780. tmp_value.all = value;
  781. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  782. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_DEBUG_MEMD_get_MEMD_CR_PC_D_ADDR_pc_d] --> 0x%08x\n",
  783. REG_DEBUG_MEMD_MEMD_CR_PC_D_ADDR,value);
  784. #endif
  785. return tmp_value.bitc.pc_d;
  786. }
  787. GH_INLINE U8 GH_DEBUG_MEMD_get_MEMD_CR_PC_D_ADDR_vld_d(void)
  788. {
  789. GH_DEBUG_MEMD_MEMD_CR_PC_D_ADDR_S tmp_value;
  790. U32 value = (*(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_PC_D_ADDR);
  791. tmp_value.all = value;
  792. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  793. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_DEBUG_MEMD_get_MEMD_CR_PC_D_ADDR_vld_d] --> 0x%08x\n",
  794. REG_DEBUG_MEMD_MEMD_CR_PC_D_ADDR,value);
  795. #endif
  796. return tmp_value.bitc.vld_d;
  797. }
  798. #endif /* GH_INLINE_LEVEL == 0 */
  799. /*----------------------------------------------------------------------------*/
  800. /* register DEBUG_MEMD_MEMD_CR_OP_D_ADDR (read) */
  801. /*----------------------------------------------------------------------------*/
  802. #if GH_INLINE_LEVEL == 0
  803. /*! \brief Reads the register 'DEBUG_MEMD_MEMD_CR_OP_D_ADDR'. */
  804. U32 GH_DEBUG_MEMD_get_MEMD_CR_OP_D_ADDR(void);
  805. #else /* GH_INLINE_LEVEL == 0 */
  806. GH_INLINE U32 GH_DEBUG_MEMD_get_MEMD_CR_OP_D_ADDR(void)
  807. {
  808. U32 value = (*(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_OP_D_ADDR);
  809. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  810. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_DEBUG_MEMD_get_MEMD_CR_OP_D_ADDR] --> 0x%08x\n",
  811. REG_DEBUG_MEMD_MEMD_CR_OP_D_ADDR,value);
  812. #endif
  813. return value;
  814. }
  815. #endif /* GH_INLINE_LEVEL == 0 */
  816. /*----------------------------------------------------------------------------*/
  817. /* register DEBUG_MEMD_MEMD_CR_STALL_ADDR (read) */
  818. /*----------------------------------------------------------------------------*/
  819. #if GH_INLINE_LEVEL == 0
  820. /*! \brief Reads the register 'DEBUG_MEMD_MEMD_CR_STALL_ADDR'. */
  821. U32 GH_DEBUG_MEMD_get_MEMD_CR_STALL_ADDR(void);
  822. #else /* GH_INLINE_LEVEL == 0 */
  823. GH_INLINE U32 GH_DEBUG_MEMD_get_MEMD_CR_STALL_ADDR(void)
  824. {
  825. U32 value = (*(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_STALL_ADDR);
  826. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  827. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_DEBUG_MEMD_get_MEMD_CR_STALL_ADDR] --> 0x%08x\n",
  828. REG_DEBUG_MEMD_MEMD_CR_STALL_ADDR,value);
  829. #endif
  830. return value;
  831. }
  832. #endif /* GH_INLINE_LEVEL == 0 */
  833. /*----------------------------------------------------------------------------*/
  834. /* register DEBUG_MEMD_MEMD_CR_DMAQ0_ADDR (read) */
  835. /*----------------------------------------------------------------------------*/
  836. #if GH_INLINE_LEVEL == 0
  837. /*! \brief Reads the register 'DEBUG_MEMD_MEMD_CR_DMAQ0_ADDR'. */
  838. U32 GH_DEBUG_MEMD_get_MEMD_CR_DMAQ0_ADDR(void);
  839. #else /* GH_INLINE_LEVEL == 0 */
  840. GH_INLINE U32 GH_DEBUG_MEMD_get_MEMD_CR_DMAQ0_ADDR(void)
  841. {
  842. U32 value = (*(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_DMAQ0_ADDR);
  843. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  844. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_DEBUG_MEMD_get_MEMD_CR_DMAQ0_ADDR] --> 0x%08x\n",
  845. REG_DEBUG_MEMD_MEMD_CR_DMAQ0_ADDR,value);
  846. #endif
  847. return value;
  848. }
  849. #endif /* GH_INLINE_LEVEL == 0 */
  850. /*----------------------------------------------------------------------------*/
  851. /* register DEBUG_MEMD_MEMD_CR_DMAQ1_ADDR (read) */
  852. /*----------------------------------------------------------------------------*/
  853. #if GH_INLINE_LEVEL == 0
  854. /*! \brief Reads the register 'DEBUG_MEMD_MEMD_CR_DMAQ1_ADDR'. */
  855. U32 GH_DEBUG_MEMD_get_MEMD_CR_DMAQ1_ADDR(void);
  856. #else /* GH_INLINE_LEVEL == 0 */
  857. GH_INLINE U32 GH_DEBUG_MEMD_get_MEMD_CR_DMAQ1_ADDR(void)
  858. {
  859. U32 value = (*(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_DMAQ1_ADDR);
  860. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  861. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_DEBUG_MEMD_get_MEMD_CR_DMAQ1_ADDR] --> 0x%08x\n",
  862. REG_DEBUG_MEMD_MEMD_CR_DMAQ1_ADDR,value);
  863. #endif
  864. return value;
  865. }
  866. #endif /* GH_INLINE_LEVEL == 0 */
  867. /*----------------------------------------------------------------------------*/
  868. /* register DEBUG_MEMD_MEMD_CR_DMAQ2_ADDR (read) */
  869. /*----------------------------------------------------------------------------*/
  870. #if GH_INLINE_LEVEL == 0
  871. /*! \brief Reads the register 'DEBUG_MEMD_MEMD_CR_DMAQ2_ADDR'. */
  872. U32 GH_DEBUG_MEMD_get_MEMD_CR_DMAQ2_ADDR(void);
  873. #else /* GH_INLINE_LEVEL == 0 */
  874. GH_INLINE U32 GH_DEBUG_MEMD_get_MEMD_CR_DMAQ2_ADDR(void)
  875. {
  876. U32 value = (*(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_DMAQ2_ADDR);
  877. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  878. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_DEBUG_MEMD_get_MEMD_CR_DMAQ2_ADDR] --> 0x%08x\n",
  879. REG_DEBUG_MEMD_MEMD_CR_DMAQ2_ADDR,value);
  880. #endif
  881. return value;
  882. }
  883. #endif /* GH_INLINE_LEVEL == 0 */
  884. /*----------------------------------------------------------------------------*/
  885. /* register DEBUG_MEMD_MEMD_CR_CMDQ0_ADDR (read) */
  886. /*----------------------------------------------------------------------------*/
  887. #if GH_INLINE_LEVEL == 0
  888. /*! \brief Reads the register 'DEBUG_MEMD_MEMD_CR_CMDQ0_ADDR'. */
  889. U32 GH_DEBUG_MEMD_get_MEMD_CR_CMDQ0_ADDR(void);
  890. #else /* GH_INLINE_LEVEL == 0 */
  891. GH_INLINE U32 GH_DEBUG_MEMD_get_MEMD_CR_CMDQ0_ADDR(void)
  892. {
  893. U32 value = (*(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_CMDQ0_ADDR);
  894. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  895. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_DEBUG_MEMD_get_MEMD_CR_CMDQ0_ADDR] --> 0x%08x\n",
  896. REG_DEBUG_MEMD_MEMD_CR_CMDQ0_ADDR,value);
  897. #endif
  898. return value;
  899. }
  900. #endif /* GH_INLINE_LEVEL == 0 */
  901. /*----------------------------------------------------------------------------*/
  902. /* register DEBUG_MEMD_MEMD_CR_ME_ADDR (read) */
  903. /*----------------------------------------------------------------------------*/
  904. #if GH_INLINE_LEVEL == 0
  905. /*! \brief Reads the register 'DEBUG_MEMD_MEMD_CR_ME_ADDR'. */
  906. U32 GH_DEBUG_MEMD_get_MEMD_CR_ME_ADDR(void);
  907. #else /* GH_INLINE_LEVEL == 0 */
  908. GH_INLINE U32 GH_DEBUG_MEMD_get_MEMD_CR_ME_ADDR(void)
  909. {
  910. U32 value = (*(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_ME_ADDR);
  911. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  912. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_DEBUG_MEMD_get_MEMD_CR_ME_ADDR] --> 0x%08x\n",
  913. REG_DEBUG_MEMD_MEMD_CR_ME_ADDR,value);
  914. #endif
  915. return value;
  916. }
  917. #endif /* GH_INLINE_LEVEL == 0 */
  918. /*----------------------------------------------------------------------------*/
  919. /* register DEBUG_MEMD_MEMD_CR_MD_ADDR (read) */
  920. /*----------------------------------------------------------------------------*/
  921. #if GH_INLINE_LEVEL == 0
  922. /*! \brief Reads the register 'DEBUG_MEMD_MEMD_CR_MD_ADDR'. */
  923. U32 GH_DEBUG_MEMD_get_MEMD_CR_MD_ADDR(void);
  924. #else /* GH_INLINE_LEVEL == 0 */
  925. GH_INLINE U32 GH_DEBUG_MEMD_get_MEMD_CR_MD_ADDR(void)
  926. {
  927. U32 value = (*(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_MD_ADDR);
  928. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  929. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_DEBUG_MEMD_get_MEMD_CR_MD_ADDR] --> 0x%08x\n",
  930. REG_DEBUG_MEMD_MEMD_CR_MD_ADDR,value);
  931. #endif
  932. return value;
  933. }
  934. #endif /* GH_INLINE_LEVEL == 0 */
  935. /*----------------------------------------------------------------------------*/
  936. /* register DEBUG_MEMD_MEMD_CR_RF_ADDR (read/write) */
  937. /*----------------------------------------------------------------------------*/
  938. #if GH_INLINE_LEVEL == 0
  939. /*! \brief Writes the register 'DEBUG_MEMD_MEMD_CR_RF_ADDR'. */
  940. void GH_DEBUG_MEMD_set_MEMD_CR_RF_ADDR(U32 data);
  941. /*! \brief Reads the register 'DEBUG_MEMD_MEMD_CR_RF_ADDR'. */
  942. U32 GH_DEBUG_MEMD_get_MEMD_CR_RF_ADDR(void);
  943. #else /* GH_INLINE_LEVEL == 0 */
  944. GH_INLINE void GH_DEBUG_MEMD_set_MEMD_CR_RF_ADDR(U32 data)
  945. {
  946. *(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_RF_ADDR = data;
  947. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  948. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "WRREG(0x%08x,0x%08x); \\\\ [GH_DEBUG_MEMD_set_MEMD_CR_RF_ADDR] <-- 0x%08x\n",
  949. REG_DEBUG_MEMD_MEMD_CR_RF_ADDR,data,data);
  950. #endif
  951. }
  952. GH_INLINE U32 GH_DEBUG_MEMD_get_MEMD_CR_RF_ADDR(void)
  953. {
  954. U32 value = (*(volatile U32 *)REG_DEBUG_MEMD_MEMD_CR_RF_ADDR);
  955. #if GH_DEBUG_MEMD_ENABLE_DEBUG_PRINT
  956. GH_DEBUG_MEMD_DEBUG_PRINT_FUNCTION( "value = RDREG(0x%08x); \\\\ [GH_DEBUG_MEMD_get_MEMD_CR_RF_ADDR] --> 0x%08x\n",
  957. REG_DEBUG_MEMD_MEMD_CR_RF_ADDR,value);
  958. #endif
  959. return value;
  960. }
  961. #endif /* GH_INLINE_LEVEL == 0 */
  962. /*----------------------------------------------------------------------------*/
  963. /* init function */
  964. /*----------------------------------------------------------------------------*/
  965. /*! \brief Initialises the registers and mirror variables. */
  966. void GH_DEBUG_MEMD_init(void);
  967. #ifdef __cplusplus
  968. }
  969. #endif
  970. #endif /* _GH_DEBUG_MEMD_H */
  971. /*----------------------------------------------------------------------------*/
  972. /* end of file */
  973. /*----------------------------------------------------------------------------*/