mali_gp.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337
  1. /*
  2. * This confidential and proprietary software may be used only as
  3. * authorised by a licensing agreement from ARM Limited
  4. * (C) COPYRIGHT 2011-2013 ARM Limited
  5. * ALL RIGHTS RESERVED
  6. * The entire notice above must be reproduced on all authorised
  7. * copies and copies may only be made to the extent permitted
  8. * by a licensing agreement from ARM Limited.
  9. */
  10. #include "mali_gp.h"
  11. #include "mali_hw_core.h"
  12. #include "mali_group.h"
  13. #include "mali_osk.h"
  14. #include "regs/mali_gp_regs.h"
  15. #include "mali_kernel_common.h"
  16. #include "mali_kernel_core.h"
  17. #if defined(CONFIG_MALI400_PROFILING)
  18. #include "mali_osk_profiling.h"
  19. #endif
  20. static struct mali_gp_core *mali_global_gp_core = NULL;
  21. /* Interrupt handlers */
  22. static void mali_gp_irq_probe_trigger(void *data);
  23. static _mali_osk_errcode_t mali_gp_irq_probe_ack(void *data);
  24. struct mali_gp_core *mali_gp_create(const _mali_osk_resource_t * resource, struct mali_group *group)
  25. {
  26. struct mali_gp_core* core = NULL;
  27. MALI_DEBUG_ASSERT(NULL == mali_global_gp_core);
  28. MALI_DEBUG_PRINT(2, ("Mali GP: Creating Mali GP core: %s\n", resource->description));
  29. core = _mali_osk_malloc(sizeof(struct mali_gp_core));
  30. if (NULL != core) {
  31. if (_MALI_OSK_ERR_OK == mali_hw_core_create(&core->hw_core, resource, MALIGP2_REGISTER_ADDRESS_SPACE_SIZE)) {
  32. _mali_osk_errcode_t ret;
  33. ret = mali_gp_reset(core);
  34. if (_MALI_OSK_ERR_OK == ret) {
  35. ret = mali_group_add_gp_core(group, core);
  36. if (_MALI_OSK_ERR_OK == ret) {
  37. /* Setup IRQ handlers (which will do IRQ probing if needed) */
  38. core->irq = _mali_osk_irq_init(resource->irq,
  39. mali_group_upper_half_gp,
  40. group,
  41. mali_gp_irq_probe_trigger,
  42. mali_gp_irq_probe_ack,
  43. core,
  44. resource->description);
  45. if (NULL != core->irq) {
  46. MALI_DEBUG_PRINT(4, ("Mali GP: set global gp core from 0x%08X to 0x%08X\n", mali_global_gp_core, core));
  47. mali_global_gp_core = core;
  48. return core;
  49. } else {
  50. MALI_PRINT_ERROR(("Mali GP: Failed to setup interrupt handlers for GP core %s\n", core->hw_core.description));
  51. }
  52. mali_group_remove_gp_core(group);
  53. } else {
  54. MALI_PRINT_ERROR(("Mali GP: Failed to add core %s to group\n", core->hw_core.description));
  55. }
  56. }
  57. mali_hw_core_delete(&core->hw_core);
  58. }
  59. _mali_osk_free(core);
  60. } else {
  61. MALI_PRINT_ERROR(("Failed to allocate memory for GP core\n"));
  62. }
  63. return NULL;
  64. }
  65. void mali_gp_delete(struct mali_gp_core *core)
  66. {
  67. MALI_DEBUG_ASSERT_POINTER(core);
  68. _mali_osk_irq_term(core->irq);
  69. mali_hw_core_delete(&core->hw_core);
  70. mali_global_gp_core = NULL;
  71. _mali_osk_free(core);
  72. }
  73. void mali_gp_stop_bus(struct mali_gp_core *core)
  74. {
  75. MALI_DEBUG_ASSERT_POINTER(core);
  76. mali_hw_core_register_write(&core->hw_core, MALIGP2_REG_ADDR_MGMT_CMD, MALIGP2_REG_VAL_CMD_STOP_BUS);
  77. }
  78. _mali_osk_errcode_t mali_gp_stop_bus_wait(struct mali_gp_core *core)
  79. {
  80. int i;
  81. MALI_DEBUG_ASSERT_POINTER(core);
  82. /* Send the stop bus command. */
  83. mali_gp_stop_bus(core);
  84. /* Wait for bus to be stopped */
  85. for (i = 0; i < MALI_REG_POLL_COUNT_FAST; i++) {
  86. if (mali_hw_core_register_read(&core->hw_core, MALIGP2_REG_ADDR_MGMT_STATUS) & MALIGP2_REG_VAL_STATUS_BUS_STOPPED) {
  87. break;
  88. }
  89. }
  90. if (MALI_REG_POLL_COUNT_FAST == i) {
  91. MALI_PRINT_ERROR(("Mali GP: Failed to stop bus on %s\n", core->hw_core.description));
  92. return _MALI_OSK_ERR_FAULT;
  93. }
  94. return _MALI_OSK_ERR_OK;
  95. }
  96. void mali_gp_hard_reset(struct mali_gp_core *core)
  97. {
  98. const u32 reset_wait_target_register = MALIGP2_REG_ADDR_MGMT_WRITE_BOUND_LOW;
  99. const u32 reset_invalid_value = 0xC0FFE000;
  100. const u32 reset_check_value = 0xC01A0000;
  101. const u32 reset_default_value = 0;
  102. int i;
  103. MALI_DEBUG_ASSERT_POINTER(core);
  104. MALI_DEBUG_PRINT(4, ("Mali GP: Hard reset of core %s\n", core->hw_core.description));
  105. mali_hw_core_register_write(&core->hw_core, reset_wait_target_register, reset_invalid_value);
  106. mali_hw_core_register_write(&core->hw_core, MALIGP2_REG_ADDR_MGMT_CMD, MALIGP2_REG_VAL_CMD_RESET);
  107. for (i = 0; i < MALI_REG_POLL_COUNT_FAST; i++) {
  108. mali_hw_core_register_write(&core->hw_core, reset_wait_target_register, reset_check_value);
  109. if (reset_check_value == mali_hw_core_register_read(&core->hw_core, reset_wait_target_register)) {
  110. break;
  111. }
  112. }
  113. if (MALI_REG_POLL_COUNT_FAST == i) {
  114. MALI_PRINT_ERROR(("Mali GP: The hard reset loop didn't work, unable to recover\n"));
  115. }
  116. mali_hw_core_register_write(&core->hw_core, reset_wait_target_register, reset_default_value); /* set it back to the default */
  117. /* Re-enable interrupts */
  118. mali_hw_core_register_write(&core->hw_core, MALIGP2_REG_ADDR_MGMT_INT_CLEAR, MALIGP2_REG_VAL_IRQ_MASK_ALL);
  119. mali_hw_core_register_write(&core->hw_core, MALIGP2_REG_ADDR_MGMT_INT_MASK, MALIGP2_REG_VAL_IRQ_MASK_USED);
  120. }
  121. void mali_gp_reset_async(struct mali_gp_core *core)
  122. {
  123. MALI_DEBUG_ASSERT_POINTER(core);
  124. MALI_DEBUG_PRINT(4, ("Mali GP: Reset of core %s\n", core->hw_core.description));
  125. mali_hw_core_register_write(&core->hw_core, MALIGP2_REG_ADDR_MGMT_INT_MASK, 0); /* disable the IRQs */
  126. mali_hw_core_register_write(&core->hw_core, MALIGP2_REG_ADDR_MGMT_INT_CLEAR, MALI400GP_REG_VAL_IRQ_RESET_COMPLETED);
  127. mali_hw_core_register_write(&core->hw_core, MALIGP2_REG_ADDR_MGMT_CMD, MALI400GP_REG_VAL_CMD_SOFT_RESET);
  128. }
  129. _mali_osk_errcode_t mali_gp_reset_wait(struct mali_gp_core *core)
  130. {
  131. int i;
  132. u32 rawstat = 0;
  133. MALI_DEBUG_ASSERT_POINTER(core);
  134. for (i = 0; i < MALI_REG_POLL_COUNT_FAST; i++) {
  135. rawstat = mali_hw_core_register_read(&core->hw_core, MALIGP2_REG_ADDR_MGMT_INT_RAWSTAT);
  136. if (rawstat & MALI400GP_REG_VAL_IRQ_RESET_COMPLETED) {
  137. break;
  138. }
  139. }
  140. if (i == MALI_REG_POLL_COUNT_FAST) {
  141. MALI_PRINT_ERROR(("Mali GP: Failed to reset core %s, rawstat: 0x%08x\n",
  142. core->hw_core.description, rawstat));
  143. return _MALI_OSK_ERR_FAULT;
  144. }
  145. /* Re-enable interrupts */
  146. mali_hw_core_register_write(&core->hw_core, MALIGP2_REG_ADDR_MGMT_INT_CLEAR, MALIGP2_REG_VAL_IRQ_MASK_ALL);
  147. mali_hw_core_register_write(&core->hw_core, MALIGP2_REG_ADDR_MGMT_INT_MASK, MALIGP2_REG_VAL_IRQ_MASK_USED);
  148. return _MALI_OSK_ERR_OK;
  149. }
  150. _mali_osk_errcode_t mali_gp_reset(struct mali_gp_core *core)
  151. {
  152. mali_gp_reset_async(core);
  153. return mali_gp_reset_wait(core);
  154. }
  155. void mali_gp_job_start(struct mali_gp_core *core, struct mali_gp_job *job)
  156. {
  157. u32 startcmd = 0;
  158. u32 *frame_registers = mali_gp_job_get_frame_registers(job);
  159. u32 counter_src0 = mali_gp_job_get_perf_counter_src0(job);
  160. u32 counter_src1 = mali_gp_job_get_perf_counter_src1(job);
  161. MALI_DEBUG_ASSERT_POINTER(core);
  162. if (mali_gp_job_has_vs_job(job)) {
  163. startcmd |= (u32) MALIGP2_REG_VAL_CMD_START_VS;
  164. }
  165. if (mali_gp_job_has_plbu_job(job)) {
  166. startcmd |= (u32) MALIGP2_REG_VAL_CMD_START_PLBU;
  167. }
  168. MALI_DEBUG_ASSERT(0 != startcmd);
  169. mali_hw_core_register_write_array_relaxed(&core->hw_core, MALIGP2_REG_ADDR_MGMT_VSCL_START_ADDR, frame_registers, MALIGP2_NUM_REGS_FRAME);
  170. if (MALI_HW_CORE_NO_COUNTER != counter_src0) {
  171. mali_hw_core_register_write(&core->hw_core, MALIGP2_REG_ADDR_MGMT_PERF_CNT_0_SRC, counter_src0);
  172. mali_hw_core_register_write(&core->hw_core, MALIGP2_REG_ADDR_MGMT_PERF_CNT_0_ENABLE, MALIGP2_REG_VAL_PERF_CNT_ENABLE);
  173. }
  174. if (MALI_HW_CORE_NO_COUNTER != counter_src1) {
  175. mali_hw_core_register_write(&core->hw_core, MALIGP2_REG_ADDR_MGMT_PERF_CNT_1_SRC, counter_src1);
  176. mali_hw_core_register_write(&core->hw_core, MALIGP2_REG_ADDR_MGMT_PERF_CNT_1_ENABLE, MALIGP2_REG_VAL_PERF_CNT_ENABLE);
  177. }
  178. MALI_DEBUG_PRINT(3, ("Mali GP: Starting job (0x%08x) on core %s with command 0x%08X\n", job, core->hw_core.description, startcmd));
  179. mali_hw_core_register_write_relaxed(&core->hw_core, MALIGP2_REG_ADDR_MGMT_CMD, MALIGP2_REG_VAL_CMD_UPDATE_PLBU_ALLOC);
  180. /* Barrier to make sure the previous register write is finished */
  181. _mali_osk_write_mem_barrier();
  182. /* This is the command that starts the core. */
  183. mali_hw_core_register_write_relaxed(&core->hw_core, MALIGP2_REG_ADDR_MGMT_CMD, startcmd);
  184. /* Barrier to make sure the previous register write is finished */
  185. _mali_osk_write_mem_barrier();
  186. }
  187. void mali_gp_resume_with_new_heap(struct mali_gp_core *core, u32 start_addr, u32 end_addr)
  188. {
  189. u32 irq_readout;
  190. MALI_DEBUG_ASSERT_POINTER(core);
  191. irq_readout = mali_hw_core_register_read(&core->hw_core, MALIGP2_REG_ADDR_MGMT_INT_RAWSTAT);
  192. if (irq_readout & MALIGP2_REG_VAL_IRQ_PLBU_OUT_OF_MEM) {
  193. mali_hw_core_register_write(&core->hw_core, MALIGP2_REG_ADDR_MGMT_INT_CLEAR, (MALIGP2_REG_VAL_IRQ_PLBU_OUT_OF_MEM | MALIGP2_REG_VAL_IRQ_HANG));
  194. mali_hw_core_register_write(&core->hw_core, MALIGP2_REG_ADDR_MGMT_INT_MASK, MALIGP2_REG_VAL_IRQ_MASK_USED); /* re-enable interrupts */
  195. mali_hw_core_register_write_relaxed(&core->hw_core, MALIGP2_REG_ADDR_MGMT_PLBU_ALLOC_START_ADDR, start_addr);
  196. mali_hw_core_register_write_relaxed(&core->hw_core, MALIGP2_REG_ADDR_MGMT_PLBU_ALLOC_END_ADDR, end_addr);
  197. MALI_DEBUG_PRINT(3, ("Mali GP: Resuming job\n"));
  198. mali_hw_core_register_write(&core->hw_core, MALIGP2_REG_ADDR_MGMT_CMD, MALIGP2_REG_VAL_CMD_UPDATE_PLBU_ALLOC);
  199. _mali_osk_write_mem_barrier();
  200. }
  201. /*
  202. * else: core has been reset between PLBU_OUT_OF_MEM interrupt and this new heap response.
  203. * A timeout or a page fault on Mali-200 PP core can cause this behaviour.
  204. */
  205. }
  206. u32 mali_gp_core_get_version(struct mali_gp_core *core)
  207. {
  208. MALI_DEBUG_ASSERT_POINTER(core);
  209. return mali_hw_core_register_read(&core->hw_core, MALIGP2_REG_ADDR_MGMT_VERSION);
  210. }
  211. struct mali_gp_core *mali_gp_get_global_gp_core(void)
  212. {
  213. return mali_global_gp_core;
  214. }
  215. /* ------------- interrupt handling below ------------------ */
  216. static void mali_gp_irq_probe_trigger(void *data)
  217. {
  218. struct mali_gp_core *core = (struct mali_gp_core *)data;
  219. mali_hw_core_register_write(&core->hw_core, MALIGP2_REG_ADDR_MGMT_INT_MASK, MALIGP2_REG_VAL_IRQ_MASK_USED);
  220. mali_hw_core_register_write(&core->hw_core, MALIGP2_REG_ADDR_MGMT_INT_RAWSTAT, MALIGP2_REG_VAL_CMD_FORCE_HANG);
  221. _mali_osk_mem_barrier();
  222. }
  223. static _mali_osk_errcode_t mali_gp_irq_probe_ack(void *data)
  224. {
  225. struct mali_gp_core *core = (struct mali_gp_core *)data;
  226. u32 irq_readout;
  227. irq_readout = mali_hw_core_register_read(&core->hw_core, MALIGP2_REG_ADDR_MGMT_INT_STAT);
  228. if (MALIGP2_REG_VAL_IRQ_FORCE_HANG & irq_readout) {
  229. mali_hw_core_register_write(&core->hw_core, MALIGP2_REG_ADDR_MGMT_INT_CLEAR, MALIGP2_REG_VAL_IRQ_FORCE_HANG);
  230. _mali_osk_mem_barrier();
  231. return _MALI_OSK_ERR_OK;
  232. }
  233. return _MALI_OSK_ERR_FAULT;
  234. }
  235. /* ------ local helper functions below --------- */
  236. #if MALI_STATE_TRACKING
  237. u32 mali_gp_dump_state(struct mali_gp_core *core, char *buf, u32 size)
  238. {
  239. int n = 0;
  240. n += _mali_osk_snprintf(buf + n, size - n, "\tGP: %s\n", core->hw_core.description);
  241. return n;
  242. }
  243. #endif
  244. void mali_gp_update_performance_counters(struct mali_gp_core *core, struct mali_gp_job *job, mali_bool suspend)
  245. {
  246. u32 val0 = 0;
  247. u32 val1 = 0;
  248. u32 counter_src0 = mali_gp_job_get_perf_counter_src0(job);
  249. u32 counter_src1 = mali_gp_job_get_perf_counter_src1(job);
  250. if (MALI_HW_CORE_NO_COUNTER != counter_src0) {
  251. val0 = mali_hw_core_register_read(&core->hw_core, MALIGP2_REG_ADDR_MGMT_PERF_CNT_0_VALUE);
  252. mali_gp_job_set_perf_counter_value0(job, val0);
  253. #if defined(CONFIG_MALI400_PROFILING)
  254. _mali_osk_profiling_report_hw_counter(COUNTER_VP_0_C0, val0);
  255. #endif
  256. }
  257. if (MALI_HW_CORE_NO_COUNTER != counter_src1) {
  258. val1 = mali_hw_core_register_read(&core->hw_core, MALIGP2_REG_ADDR_MGMT_PERF_CNT_1_VALUE);
  259. mali_gp_job_set_perf_counter_value1(job, val1);
  260. #if defined(CONFIG_MALI400_PROFILING)
  261. _mali_osk_profiling_report_hw_counter(COUNTER_VP_0_C1, val1);
  262. #endif
  263. }
  264. }