1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright 2021 Collabora ltd. */
3
4 #include <linux/err.h>
5 #include <linux/device.h>
6 #include <linux/devcoredump.h>
7 #include <linux/moduleparam.h>
8 #include <linux/iosys-map.h>
9 #include <drm/panfrost_drm.h>
10 #include <drm/drm_device.h>
11
12 #include "panfrost_job.h"
13 #include "panfrost_gem.h"
14 #include "panfrost_regs.h"
15 #include "panfrost_dump.h"
16 #include "panfrost_device.h"
17
18 static bool panfrost_dump_core = true;
19 module_param_named(dump_core, panfrost_dump_core, bool, 0600);
20
21 struct panfrost_dump_iterator {
22 void *start;
23 struct panfrost_dump_object_header *hdr;
24 void *data;
25 };
26
27 static const unsigned short panfrost_dump_registers[] = {
28 SHADER_READY_LO,
29 SHADER_READY_HI,
30 TILER_READY_LO,
31 TILER_READY_HI,
32 L2_READY_LO,
33 L2_READY_HI,
34 JOB_INT_MASK,
35 JOB_INT_STAT,
36 JS_HEAD_LO(0),
37 JS_HEAD_HI(0),
38 JS_TAIL_LO(0),
39 JS_TAIL_HI(0),
40 JS_AFFINITY_LO(0),
41 JS_AFFINITY_HI(0),
42 JS_CONFIG(0),
43 JS_STATUS(0),
44 JS_HEAD_NEXT_LO(0),
45 JS_HEAD_NEXT_HI(0),
46 JS_AFFINITY_NEXT_LO(0),
47 JS_AFFINITY_NEXT_HI(0),
48 JS_CONFIG_NEXT(0),
49 MMU_INT_MASK,
50 MMU_INT_STAT,
51 AS_TRANSTAB_LO(0),
52 AS_TRANSTAB_HI(0),
53 AS_MEMATTR_LO(0),
54 AS_MEMATTR_HI(0),
55 AS_FAULTSTATUS(0),
56 AS_FAULTADDRESS_LO(0),
57 AS_FAULTADDRESS_HI(0),
58 AS_STATUS(0),
59 };
60
panfrost_core_dump_header(struct panfrost_dump_iterator * iter,u32 type,void * data_end)61 static void panfrost_core_dump_header(struct panfrost_dump_iterator *iter,
62 u32 type, void *data_end)
63 {
64 struct panfrost_dump_object_header *hdr = iter->hdr;
65
66 hdr->magic = PANFROSTDUMP_MAGIC;
67 hdr->type = type;
68 hdr->file_offset = iter->data - iter->start;
69 hdr->file_size = data_end - iter->data;
70
71 iter->hdr++;
72 iter->data += hdr->file_size;
73 }
74
75 static void
panfrost_core_dump_registers(struct panfrost_dump_iterator * iter,struct panfrost_device * pfdev,u32 as_nr,int slot)76 panfrost_core_dump_registers(struct panfrost_dump_iterator *iter,
77 struct panfrost_device *pfdev,
78 u32 as_nr, int slot)
79 {
80 struct panfrost_dump_registers *dumpreg = iter->data;
81 unsigned int i;
82
83 for (i = 0; i < ARRAY_SIZE(panfrost_dump_registers); i++, dumpreg++) {
84 unsigned int js_as_offset = 0;
85 unsigned int reg;
86
87 if (panfrost_dump_registers[i] >= JS_BASE &&
88 panfrost_dump_registers[i] <= JS_BASE + JS_SLOT_STRIDE)
89 js_as_offset = slot * JS_SLOT_STRIDE;
90 else if (panfrost_dump_registers[i] >= MMU_BASE &&
91 panfrost_dump_registers[i] <= MMU_BASE + MMU_AS_STRIDE)
92 js_as_offset = (as_nr << MMU_AS_SHIFT);
93
94 reg = panfrost_dump_registers[i] + js_as_offset;
95
96 dumpreg->reg = reg;
97 dumpreg->value = gpu_read(pfdev, reg);
98 }
99
100 panfrost_core_dump_header(iter, PANFROSTDUMP_BUF_REG, dumpreg);
101 }
102
panfrost_core_dump(struct panfrost_job * job)103 void panfrost_core_dump(struct panfrost_job *job)
104 {
105 struct panfrost_device *pfdev = job->pfdev;
106 struct panfrost_dump_iterator iter;
107 struct drm_gem_object *dbo;
108 unsigned int n_obj, n_bomap_pages;
109 u64 *bomap, *bomap_start;
110 size_t file_size;
111 u32 as_nr;
112 int slot;
113 int ret, i;
114
115 as_nr = job->mmu->as;
116 slot = panfrost_job_get_slot(job);
117
118 /* Only catch the first event, or when manually re-armed */
119 if (!panfrost_dump_core)
120 return;
121 panfrost_dump_core = false;
122
123 /* At least, we dump registers and end marker */
124 n_obj = 2;
125 n_bomap_pages = 0;
126 file_size = ARRAY_SIZE(panfrost_dump_registers) *
127 sizeof(struct panfrost_dump_registers);
128
129 /* Add in the active buffer objects */
130 for (i = 0; i < job->bo_count; i++) {
131 /*
132 * Even though the CPU could be configured to use 16K or 64K pages, this
133 * is a very unusual situation for most kernel setups on SoCs that have
134 * a Panfrost device. Also many places across the driver make the somewhat
135 * arbitrary assumption that Panfrost's MMU page size is the same as the CPU's,
136 * so let's have a sanity check to ensure that's always the case
137 */
138 dbo = job->bos[i];
139 WARN_ON(!IS_ALIGNED(dbo->size, PAGE_SIZE));
140
141 file_size += dbo->size;
142 n_bomap_pages += dbo->size >> PAGE_SHIFT;
143 n_obj++;
144 }
145
146 /* If we have any buffer objects, add a bomap object */
147 if (n_bomap_pages) {
148 file_size += n_bomap_pages * sizeof(*bomap);
149 n_obj++;
150 }
151
152 /* Add the size of the headers */
153 file_size += sizeof(*iter.hdr) * n_obj;
154
155 /*
156 * Allocate the file in vmalloc memory, it's likely to be big.
157 * The reason behind these GFP flags is that we don't want to trigger the
158 * OOM killer in the event that not enough memory could be found for our
159 * dump file. We also don't want the allocator to do any error reporting,
160 * as the right behaviour is failing gracefully if a big enough buffer
161 * could not be allocated.
162 */
163 iter.start = __vmalloc(file_size, GFP_KERNEL | __GFP_NOWARN |
164 __GFP_NORETRY);
165 if (!iter.start) {
166 dev_warn(pfdev->dev, "failed to allocate devcoredump file\n");
167 return;
168 }
169
170 /* Point the data member after the headers */
171 iter.hdr = iter.start;
172 iter.data = &iter.hdr[n_obj];
173
174 memset(iter.hdr, 0, iter.data - iter.start);
175
176 /*
177 * For now, we write the job identifier in the register dump header,
178 * so that we can decode the entire dump later with pandecode
179 */
180 iter.hdr->reghdr.jc = job->jc;
181 iter.hdr->reghdr.major = PANFROSTDUMP_MAJOR;
182 iter.hdr->reghdr.minor = PANFROSTDUMP_MINOR;
183 iter.hdr->reghdr.gpu_id = pfdev->features.id;
184 iter.hdr->reghdr.nbos = job->bo_count;
185
186 panfrost_core_dump_registers(&iter, pfdev, as_nr, slot);
187
188 /* Reserve space for the bomap */
189 if (job->bo_count) {
190 bomap_start = bomap = iter.data;
191 memset(bomap, 0, sizeof(*bomap) * n_bomap_pages);
192 panfrost_core_dump_header(&iter, PANFROSTDUMP_BUF_BOMAP,
193 bomap + n_bomap_pages);
194 }
195
196 for (i = 0; i < job->bo_count; i++) {
197 struct iosys_map map;
198 struct panfrost_gem_mapping *mapping;
199 struct panfrost_gem_object *bo;
200 struct sg_page_iter page_iter;
201 void *vaddr;
202
203 bo = to_panfrost_bo(job->bos[i]);
204 mapping = job->mappings[i];
205
206 if (!bo->base.sgt) {
207 dev_err(pfdev->dev, "Panfrost Dump: BO has no sgt, cannot dump\n");
208 iter.hdr->bomap.valid = 0;
209 goto dump_header;
210 }
211
212 ret = drm_gem_vmap_unlocked(&bo->base.base, &map);
213 if (ret) {
214 dev_err(pfdev->dev, "Panfrost Dump: couldn't map Buffer Object\n");
215 iter.hdr->bomap.valid = 0;
216 goto dump_header;
217 }
218
219 WARN_ON(!mapping->active);
220
221 iter.hdr->bomap.data[0] = bomap - bomap_start;
222
223 for_each_sgtable_page(bo->base.sgt, &page_iter, 0) {
224 struct page *page = sg_page_iter_page(&page_iter);
225
226 if (!IS_ERR(page)) {
227 *bomap++ = page_to_phys(page);
228 } else {
229 dev_err(pfdev->dev, "Panfrost Dump: wrong page\n");
230 *bomap++ = 0;
231 }
232 }
233
234 iter.hdr->bomap.iova = mapping->mmnode.start << PAGE_SHIFT;
235
236 vaddr = map.vaddr;
237 memcpy(iter.data, vaddr, bo->base.base.size);
238
239 drm_gem_vunmap_unlocked(&bo->base.base, &map);
240
241 iter.hdr->bomap.valid = 1;
242
243 dump_header: panfrost_core_dump_header(&iter, PANFROSTDUMP_BUF_BO, iter.data +
244 bo->base.base.size);
245 }
246 panfrost_core_dump_header(&iter, PANFROSTDUMP_BUF_TRAILER, iter.data);
247
248 dev_coredumpv(pfdev->dev, iter.start, iter.data - iter.start, GFP_KERNEL);
249 }
250
