etnaviv_dump.c 5.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Copyright (C) 2015-2018 Etnaviv Project
  4. */
  5. #include <linux/devcoredump.h>
  6. #include <linux/moduleparam.h>
  7. #include "etnaviv_cmdbuf.h"
  8. #include "etnaviv_dump.h"
  9. #include "etnaviv_gem.h"
  10. #include "etnaviv_gpu.h"
  11. #include "etnaviv_mmu.h"
  12. #include "etnaviv_sched.h"
  13. #include "state.xml.h"
  14. #include "state_hi.xml.h"
  15. static bool etnaviv_dump_core = true;
  16. module_param_named(dump_core, etnaviv_dump_core, bool, 0600);
  17. struct core_dump_iterator {
  18. void *start;
  19. struct etnaviv_dump_object_header *hdr;
  20. void *data;
  21. };
  22. static const unsigned short etnaviv_dump_registers[] = {
  23. VIVS_HI_AXI_STATUS,
  24. VIVS_HI_CLOCK_CONTROL,
  25. VIVS_HI_IDLE_STATE,
  26. VIVS_HI_AXI_CONFIG,
  27. VIVS_HI_INTR_ENBL,
  28. VIVS_HI_CHIP_IDENTITY,
  29. VIVS_HI_CHIP_FEATURE,
  30. VIVS_HI_CHIP_MODEL,
  31. VIVS_HI_CHIP_REV,
  32. VIVS_HI_CHIP_DATE,
  33. VIVS_HI_CHIP_TIME,
  34. VIVS_HI_CHIP_MINOR_FEATURE_0,
  35. VIVS_HI_CACHE_CONTROL,
  36. VIVS_HI_AXI_CONTROL,
  37. VIVS_PM_POWER_CONTROLS,
  38. VIVS_PM_MODULE_CONTROLS,
  39. VIVS_PM_MODULE_STATUS,
  40. VIVS_PM_PULSE_EATER,
  41. VIVS_MC_MMU_FE_PAGE_TABLE,
  42. VIVS_MC_MMU_TX_PAGE_TABLE,
  43. VIVS_MC_MMU_PE_PAGE_TABLE,
  44. VIVS_MC_MMU_PEZ_PAGE_TABLE,
  45. VIVS_MC_MMU_RA_PAGE_TABLE,
  46. VIVS_MC_DEBUG_MEMORY,
  47. VIVS_MC_MEMORY_BASE_ADDR_RA,
  48. VIVS_MC_MEMORY_BASE_ADDR_FE,
  49. VIVS_MC_MEMORY_BASE_ADDR_TX,
  50. VIVS_MC_MEMORY_BASE_ADDR_PEZ,
  51. VIVS_MC_MEMORY_BASE_ADDR_PE,
  52. VIVS_MC_MEMORY_TIMING_CONTROL,
  53. VIVS_MC_BUS_CONFIG,
  54. VIVS_FE_DMA_STATUS,
  55. VIVS_FE_DMA_DEBUG_STATE,
  56. VIVS_FE_DMA_ADDRESS,
  57. VIVS_FE_DMA_LOW,
  58. VIVS_FE_DMA_HIGH,
  59. VIVS_FE_AUTO_FLUSH,
  60. };
  61. static void etnaviv_core_dump_header(struct core_dump_iterator *iter,
  62. u32 type, void *data_end)
  63. {
  64. struct etnaviv_dump_object_header *hdr = iter->hdr;
  65. hdr->magic = cpu_to_le32(ETDUMP_MAGIC);
  66. hdr->type = cpu_to_le32(type);
  67. hdr->file_offset = cpu_to_le32(iter->data - iter->start);
  68. hdr->file_size = cpu_to_le32(data_end - iter->data);
  69. iter->hdr++;
  70. iter->data += hdr->file_size;
  71. }
  72. static void etnaviv_core_dump_registers(struct core_dump_iterator *iter,
  73. struct etnaviv_gpu *gpu)
  74. {
  75. struct etnaviv_dump_registers *reg = iter->data;
  76. unsigned int i;
  77. for (i = 0; i < ARRAY_SIZE(etnaviv_dump_registers); i++, reg++) {
  78. reg->reg = etnaviv_dump_registers[i];
  79. reg->value = gpu_read(gpu, etnaviv_dump_registers[i]);
  80. }
  81. etnaviv_core_dump_header(iter, ETDUMP_BUF_REG, reg);
  82. }
  83. static void etnaviv_core_dump_mmu(struct core_dump_iterator *iter,
  84. struct etnaviv_iommu_context *mmu, size_t mmu_size)
  85. {
  86. etnaviv_iommu_dump(mmu, iter->data);
  87. etnaviv_core_dump_header(iter, ETDUMP_BUF_MMU, iter->data + mmu_size);
  88. }
  89. static void etnaviv_core_dump_mem(struct core_dump_iterator *iter, u32 type,
  90. void *ptr, size_t size, u64 iova)
  91. {
  92. memcpy(iter->data, ptr, size);
  93. iter->hdr->iova = cpu_to_le64(iova);
  94. etnaviv_core_dump_header(iter, type, iter->data + size);
  95. }
  96. void etnaviv_core_dump(struct etnaviv_gem_submit *submit)
  97. {
  98. struct etnaviv_gpu *gpu = submit->gpu;
  99. struct core_dump_iterator iter;
  100. struct etnaviv_gem_object *obj;
  101. unsigned int n_obj, n_bomap_pages;
  102. size_t file_size, mmu_size;
  103. __le64 *bomap, *bomap_start;
  104. int i;
  105. /* Only catch the first event, or when manually re-armed */
  106. if (!etnaviv_dump_core)
  107. return;
  108. etnaviv_dump_core = false;
  109. mutex_lock(&gpu->mmu_context->lock);
  110. mmu_size = etnaviv_iommu_dump_size(gpu->mmu_context);
  111. /* We always dump registers, mmu, ring, hanging cmdbuf and end marker */
  112. n_obj = 5;
  113. n_bomap_pages = 0;
  114. file_size = ARRAY_SIZE(etnaviv_dump_registers) *
  115. sizeof(struct etnaviv_dump_registers) +
  116. mmu_size + gpu->buffer.size + submit->cmdbuf.size;
  117. /* Add in the active buffer objects */
  118. for (i = 0; i < submit->nr_bos; i++) {
  119. obj = submit->bos[i].obj;
  120. file_size += obj->base.size;
  121. n_bomap_pages += obj->base.size >> PAGE_SHIFT;
  122. n_obj++;
  123. }
  124. /* If we have any buffer objects, add a bomap object */
  125. if (n_bomap_pages) {
  126. file_size += n_bomap_pages * sizeof(__le64);
  127. n_obj++;
  128. }
  129. /* Add the size of the headers */
  130. file_size += sizeof(*iter.hdr) * n_obj;
  131. /* Allocate the file in vmalloc memory, it's likely to be big */
  132. iter.start = __vmalloc(file_size, GFP_KERNEL | __GFP_NOWARN |
  133. __GFP_NORETRY);
  134. if (!iter.start) {
  135. mutex_unlock(&gpu->mmu_context->lock);
  136. dev_warn(gpu->dev, "failed to allocate devcoredump file\n");
  137. return;
  138. }
  139. /* Point the data member after the headers */
  140. iter.hdr = iter.start;
  141. iter.data = &iter.hdr[n_obj];
  142. memset(iter.hdr, 0, iter.data - iter.start);
  143. etnaviv_core_dump_registers(&iter, gpu);
  144. etnaviv_core_dump_mmu(&iter, gpu->mmu_context, mmu_size);
  145. etnaviv_core_dump_mem(&iter, ETDUMP_BUF_RING, gpu->buffer.vaddr,
  146. gpu->buffer.size,
  147. etnaviv_cmdbuf_get_va(&gpu->buffer,
  148. &gpu->mmu_context->cmdbuf_mapping));
  149. etnaviv_core_dump_mem(&iter, ETDUMP_BUF_CMD,
  150. submit->cmdbuf.vaddr, submit->cmdbuf.size,
  151. etnaviv_cmdbuf_get_va(&submit->cmdbuf,
  152. &gpu->mmu_context->cmdbuf_mapping));
  153. mutex_unlock(&gpu->mmu_context->lock);
  154. /* Reserve space for the bomap */
  155. if (n_bomap_pages) {
  156. bomap_start = bomap = iter.data;
  157. memset(bomap, 0, sizeof(*bomap) * n_bomap_pages);
  158. etnaviv_core_dump_header(&iter, ETDUMP_BUF_BOMAP,
  159. bomap + n_bomap_pages);
  160. } else {
  161. /* Silence warning */
  162. bomap_start = bomap = NULL;
  163. }
  164. for (i = 0; i < submit->nr_bos; i++) {
  165. struct etnaviv_vram_mapping *vram;
  166. struct page **pages;
  167. void *vaddr;
  168. obj = submit->bos[i].obj;
  169. vram = submit->bos[i].mapping;
  170. mutex_lock(&obj->lock);
  171. pages = etnaviv_gem_get_pages(obj);
  172. mutex_unlock(&obj->lock);
  173. if (!IS_ERR(pages)) {
  174. int j;
  175. iter.hdr->data[0] = bomap - bomap_start;
  176. for (j = 0; j < obj->base.size >> PAGE_SHIFT; j++)
  177. *bomap++ = cpu_to_le64(page_to_phys(*pages++));
  178. }
  179. iter.hdr->iova = cpu_to_le64(vram->iova);
  180. vaddr = etnaviv_gem_vmap(&obj->base);
  181. if (vaddr)
  182. memcpy(iter.data, vaddr, obj->base.size);
  183. etnaviv_core_dump_header(&iter, ETDUMP_BUF_BO, iter.data +
  184. obj->base.size);
  185. }
  186. etnaviv_core_dump_header(&iter, ETDUMP_BUF_END, iter.data);
  187. dev_coredumpv(gpu->dev, iter.start, iter.data - iter.start, GFP_KERNEL);
  188. }