Loading...
1// SPDX-License-Identifier: MIT
2/*
3 * Copyright © 2019 Intel Corporation
4 */
5
6#include <linux/prandom.h>
7
8#include <uapi/drm/i915_drm.h>
9
10#include "intel_memory_region.h"
11#include "i915_drv.h"
12#include "i915_ttm_buddy_manager.h"
13
14static const struct {
15 u16 class;
16 u16 instance;
17} intel_region_map[] = {
18 [INTEL_REGION_SMEM] = {
19 .class = INTEL_MEMORY_SYSTEM,
20 .instance = 0,
21 },
22 [INTEL_REGION_LMEM_0] = {
23 .class = INTEL_MEMORY_LOCAL,
24 .instance = 0,
25 },
26 [INTEL_REGION_STOLEN_SMEM] = {
27 .class = INTEL_MEMORY_STOLEN_SYSTEM,
28 .instance = 0,
29 },
30 [INTEL_REGION_STOLEN_LMEM] = {
31 .class = INTEL_MEMORY_STOLEN_LOCAL,
32 .instance = 0,
33 },
34};
35
36static int __iopagetest(struct intel_memory_region *mem,
37 u8 __iomem *va, int pagesize,
38 u8 value, resource_size_t offset,
39 const void *caller)
40{
41 int byte = get_random_u32_below(pagesize);
42 u8 result[3];
43
44 memset_io(va, value, pagesize); /* or GPF! */
45 wmb();
46
47 result[0] = ioread8(va);
48 result[1] = ioread8(va + byte);
49 result[2] = ioread8(va + pagesize - 1);
50 if (memchr_inv(result, value, sizeof(result))) {
51 dev_err(mem->i915->drm.dev,
52 "Failed to read back from memory region:%pR at [%pa + %pa] for %ps; wrote %x, read (%x, %x, %x)\n",
53 &mem->region, &mem->io_start, &offset, caller,
54 value, result[0], result[1], result[2]);
55 return -EINVAL;
56 }
57
58 return 0;
59}
60
61static int iopagetest(struct intel_memory_region *mem,
62 resource_size_t offset,
63 const void *caller)
64{
65 const u8 val[] = { 0x0, 0xa5, 0xc3, 0xf0 };
66 void __iomem *va;
67 int err;
68 int i;
69
70 va = ioremap_wc(mem->io_start + offset, PAGE_SIZE);
71 if (!va) {
72 dev_err(mem->i915->drm.dev,
73 "Failed to ioremap memory region [%pa + %pa] for %ps\n",
74 &mem->io_start, &offset, caller);
75 return -EFAULT;
76 }
77
78 for (i = 0; i < ARRAY_SIZE(val); i++) {
79 err = __iopagetest(mem, va, PAGE_SIZE, val[i], offset, caller);
80 if (err)
81 break;
82
83 err = __iopagetest(mem, va, PAGE_SIZE, ~val[i], offset, caller);
84 if (err)
85 break;
86 }
87
88 iounmap(va);
89 return err;
90}
91
92static resource_size_t random_page(resource_size_t last)
93{
94 /* Limited to low 44b (16TiB), but should suffice for a spot check */
95 return get_random_u32_below(last >> PAGE_SHIFT) << PAGE_SHIFT;
96}
97
98static int iomemtest(struct intel_memory_region *mem,
99 bool test_all,
100 const void *caller)
101{
102 resource_size_t last, page;
103 int err;
104
105 if (mem->io_size < PAGE_SIZE)
106 return 0;
107
108 last = mem->io_size - PAGE_SIZE;
109
110 /*
111 * Quick test to check read/write access to the iomap (backing store).
112 *
113 * Write a byte, read it back. If the iomapping fails, we expect
114 * a GPF preventing further execution. If the backing store does not
115 * exist, the read back will return garbage. We check a couple of pages,
116 * the first and last of the specified region to confirm the backing
117 * store + iomap does cover the entire memory region; and we check
118 * a random offset within as a quick spot check for bad memory.
119 */
120
121 if (test_all) {
122 for (page = 0; page <= last; page += PAGE_SIZE) {
123 err = iopagetest(mem, page, caller);
124 if (err)
125 return err;
126 }
127 } else {
128 err = iopagetest(mem, 0, caller);
129 if (err)
130 return err;
131
132 err = iopagetest(mem, last, caller);
133 if (err)
134 return err;
135
136 err = iopagetest(mem, random_page(last), caller);
137 if (err)
138 return err;
139 }
140
141 return 0;
142}
143
144struct intel_memory_region *
145intel_memory_region_lookup(struct drm_i915_private *i915,
146 u16 class, u16 instance)
147{
148 struct intel_memory_region *mr;
149 int id;
150
151 /* XXX: consider maybe converting to an rb tree at some point */
152 for_each_memory_region(mr, i915, id) {
153 if (mr->type == class && mr->instance == instance)
154 return mr;
155 }
156
157 return NULL;
158}
159
160struct intel_memory_region *
161intel_memory_region_by_type(struct drm_i915_private *i915,
162 enum intel_memory_type mem_type)
163{
164 struct intel_memory_region *mr;
165 int id;
166
167 for_each_memory_region(mr, i915, id)
168 if (mr->type == mem_type)
169 return mr;
170
171 return NULL;
172}
173
174/**
175 * intel_memory_region_reserve - Reserve a memory range
176 * @mem: The region for which we want to reserve a range.
177 * @offset: Start of the range to reserve.
178 * @size: The size of the range to reserve.
179 *
180 * Return: 0 on success, negative error code on failure.
181 */
182int intel_memory_region_reserve(struct intel_memory_region *mem,
183 resource_size_t offset,
184 resource_size_t size)
185{
186 struct ttm_resource_manager *man = mem->region_private;
187
188 GEM_BUG_ON(mem->is_range_manager);
189
190 return i915_ttm_buddy_man_reserve(man, offset, size);
191}
192
193void intel_memory_region_debug(struct intel_memory_region *mr,
194 struct drm_printer *printer)
195{
196 drm_printf(printer, "%s: ", mr->name);
197
198 if (mr->region_private)
199 ttm_resource_manager_debug(mr->region_private, printer);
200 else
201 drm_printf(printer, "total:%pa bytes\n", &mr->total);
202}
203
204static int intel_memory_region_memtest(struct intel_memory_region *mem,
205 void *caller)
206{
207 struct drm_i915_private *i915 = mem->i915;
208 int err = 0;
209
210 if (!mem->io_start)
211 return 0;
212
213 if (IS_ENABLED(CONFIG_DRM_I915_DEBUG_GEM) || i915->params.memtest)
214 err = iomemtest(mem, i915->params.memtest, caller);
215
216 return err;
217}
218
219struct intel_memory_region *
220intel_memory_region_create(struct drm_i915_private *i915,
221 resource_size_t start,
222 resource_size_t size,
223 resource_size_t min_page_size,
224 resource_size_t io_start,
225 resource_size_t io_size,
226 u16 type,
227 u16 instance,
228 const struct intel_memory_region_ops *ops)
229{
230 struct intel_memory_region *mem;
231 int err;
232
233 mem = kzalloc(sizeof(*mem), GFP_KERNEL);
234 if (!mem)
235 return ERR_PTR(-ENOMEM);
236
237 mem->i915 = i915;
238 mem->region = (struct resource)DEFINE_RES_MEM(start, size);
239 mem->io_start = io_start;
240 mem->io_size = io_size;
241 mem->min_page_size = min_page_size;
242 mem->ops = ops;
243 mem->total = size;
244 mem->type = type;
245 mem->instance = instance;
246
247 mutex_init(&mem->objects.lock);
248 INIT_LIST_HEAD(&mem->objects.list);
249
250 if (ops->init) {
251 err = ops->init(mem);
252 if (err)
253 goto err_free;
254 }
255
256 err = intel_memory_region_memtest(mem, (void *)_RET_IP_);
257 if (err)
258 goto err_release;
259
260 return mem;
261
262err_release:
263 if (mem->ops->release)
264 mem->ops->release(mem);
265err_free:
266 kfree(mem);
267 return ERR_PTR(err);
268}
269
270void intel_memory_region_set_name(struct intel_memory_region *mem,
271 const char *fmt, ...)
272{
273 va_list ap;
274
275 va_start(ap, fmt);
276 vsnprintf(mem->name, sizeof(mem->name), fmt, ap);
277 va_end(ap);
278}
279
280void intel_memory_region_avail(struct intel_memory_region *mr,
281 u64 *avail, u64 *visible_avail)
282{
283 if (mr->type == INTEL_MEMORY_LOCAL) {
284 i915_ttm_buddy_man_avail(mr->region_private,
285 avail, visible_avail);
286 *avail <<= PAGE_SHIFT;
287 *visible_avail <<= PAGE_SHIFT;
288 } else {
289 *avail = mr->total;
290 *visible_avail = mr->total;
291 }
292}
293
294void intel_memory_region_destroy(struct intel_memory_region *mem)
295{
296 int ret = 0;
297
298 if (mem->ops->release)
299 ret = mem->ops->release(mem);
300
301 GEM_WARN_ON(!list_empty_careful(&mem->objects.list));
302 mutex_destroy(&mem->objects.lock);
303 if (!ret)
304 kfree(mem);
305}
306
307/* Global memory region registration -- only slight layer inversions! */
308
309int intel_memory_regions_hw_probe(struct drm_i915_private *i915)
310{
311 int err, i;
312
313 for (i = 0; i < ARRAY_SIZE(i915->mm.regions); i++) {
314 struct intel_memory_region *mem = ERR_PTR(-ENODEV);
315 u16 type, instance;
316
317 if (!HAS_REGION(i915, BIT(i)))
318 continue;
319
320 type = intel_region_map[i].class;
321 instance = intel_region_map[i].instance;
322 switch (type) {
323 case INTEL_MEMORY_SYSTEM:
324 if (IS_DGFX(i915))
325 mem = i915_gem_ttm_system_setup(i915, type,
326 instance);
327 else
328 mem = i915_gem_shmem_setup(i915, type,
329 instance);
330 break;
331 case INTEL_MEMORY_STOLEN_LOCAL:
332 mem = i915_gem_stolen_lmem_setup(i915, type, instance);
333 if (!IS_ERR(mem))
334 i915->mm.stolen_region = mem;
335 break;
336 case INTEL_MEMORY_STOLEN_SYSTEM:
337 mem = i915_gem_stolen_smem_setup(i915, type, instance);
338 if (!IS_ERR(mem))
339 i915->mm.stolen_region = mem;
340 break;
341 default:
342 continue;
343 }
344
345 if (IS_ERR(mem)) {
346 err = PTR_ERR(mem);
347 drm_err(&i915->drm,
348 "Failed to setup region(%d) type=%d\n",
349 err, type);
350 goto out_cleanup;
351 }
352
353 mem->id = i;
354 i915->mm.regions[i] = mem;
355 }
356
357 return 0;
358
359out_cleanup:
360 intel_memory_regions_driver_release(i915);
361 return err;
362}
363
364void intel_memory_regions_driver_release(struct drm_i915_private *i915)
365{
366 int i;
367
368 for (i = 0; i < ARRAY_SIZE(i915->mm.regions); i++) {
369 struct intel_memory_region *region =
370 fetch_and_zero(&i915->mm.regions[i]);
371
372 if (region)
373 intel_memory_region_destroy(region);
374 }
375}
376
377#if IS_ENABLED(CONFIG_DRM_I915_SELFTEST)
378#include "selftests/intel_memory_region.c"
379#include "selftests/mock_region.c"
380#endif
1// SPDX-License-Identifier: MIT
2/*
3 * Copyright © 2019 Intel Corporation
4 */
5
6#include "intel_memory_region.h"
7#include "i915_drv.h"
8
9/* XXX: Hysterical raisins. BIT(inst) needs to just be (inst) at some point. */
10#define REGION_MAP(type, inst) \
11 BIT((type) + INTEL_MEMORY_TYPE_SHIFT) | BIT(inst)
12
13const u32 intel_region_map[] = {
14 [INTEL_REGION_SMEM] = REGION_MAP(INTEL_MEMORY_SYSTEM, 0),
15 [INTEL_REGION_LMEM] = REGION_MAP(INTEL_MEMORY_LOCAL, 0),
16 [INTEL_REGION_STOLEN] = REGION_MAP(INTEL_MEMORY_STOLEN, 0),
17};
18
19struct intel_memory_region *
20intel_memory_region_by_type(struct drm_i915_private *i915,
21 enum intel_memory_type mem_type)
22{
23 struct intel_memory_region *mr;
24 int id;
25
26 for_each_memory_region(mr, i915, id)
27 if (mr->type == mem_type)
28 return mr;
29
30 return NULL;
31}
32
33static u64
34intel_memory_region_free_pages(struct intel_memory_region *mem,
35 struct list_head *blocks)
36{
37 struct i915_buddy_block *block, *on;
38 u64 size = 0;
39
40 list_for_each_entry_safe(block, on, blocks, link) {
41 size += i915_buddy_block_size(&mem->mm, block);
42 i915_buddy_free(&mem->mm, block);
43 }
44 INIT_LIST_HEAD(blocks);
45
46 return size;
47}
48
49void
50__intel_memory_region_put_pages_buddy(struct intel_memory_region *mem,
51 struct list_head *blocks)
52{
53 mutex_lock(&mem->mm_lock);
54 mem->avail += intel_memory_region_free_pages(mem, blocks);
55 mutex_unlock(&mem->mm_lock);
56}
57
58void
59__intel_memory_region_put_block_buddy(struct i915_buddy_block *block)
60{
61 struct list_head blocks;
62
63 INIT_LIST_HEAD(&blocks);
64 list_add(&block->link, &blocks);
65 __intel_memory_region_put_pages_buddy(block->private, &blocks);
66}
67
68int
69__intel_memory_region_get_pages_buddy(struct intel_memory_region *mem,
70 resource_size_t size,
71 unsigned int flags,
72 struct list_head *blocks)
73{
74 unsigned int min_order = 0;
75 unsigned long n_pages;
76
77 GEM_BUG_ON(!IS_ALIGNED(size, mem->mm.chunk_size));
78 GEM_BUG_ON(!list_empty(blocks));
79
80 if (flags & I915_ALLOC_MIN_PAGE_SIZE) {
81 min_order = ilog2(mem->min_page_size) -
82 ilog2(mem->mm.chunk_size);
83 }
84
85 if (flags & I915_ALLOC_CONTIGUOUS) {
86 size = roundup_pow_of_two(size);
87 min_order = ilog2(size) - ilog2(mem->mm.chunk_size);
88 }
89
90 if (size > BIT(mem->mm.max_order) * mem->mm.chunk_size)
91 return -E2BIG;
92
93 n_pages = size >> ilog2(mem->mm.chunk_size);
94
95 mutex_lock(&mem->mm_lock);
96
97 do {
98 struct i915_buddy_block *block;
99 unsigned int order;
100
101 order = fls(n_pages) - 1;
102 GEM_BUG_ON(order > mem->mm.max_order);
103 GEM_BUG_ON(order < min_order);
104
105 do {
106 block = i915_buddy_alloc(&mem->mm, order);
107 if (!IS_ERR(block))
108 break;
109
110 if (order-- == min_order)
111 goto err_free_blocks;
112 } while (1);
113
114 n_pages -= BIT(order);
115
116 block->private = mem;
117 list_add(&block->link, blocks);
118
119 if (!n_pages)
120 break;
121 } while (1);
122
123 mem->avail -= size;
124 mutex_unlock(&mem->mm_lock);
125 return 0;
126
127err_free_blocks:
128 intel_memory_region_free_pages(mem, blocks);
129 mutex_unlock(&mem->mm_lock);
130 return -ENXIO;
131}
132
133struct i915_buddy_block *
134__intel_memory_region_get_block_buddy(struct intel_memory_region *mem,
135 resource_size_t size,
136 unsigned int flags)
137{
138 struct i915_buddy_block *block;
139 LIST_HEAD(blocks);
140 int ret;
141
142 ret = __intel_memory_region_get_pages_buddy(mem, size, flags, &blocks);
143 if (ret)
144 return ERR_PTR(ret);
145
146 block = list_first_entry(&blocks, typeof(*block), link);
147 list_del_init(&block->link);
148 return block;
149}
150
151int intel_memory_region_init_buddy(struct intel_memory_region *mem)
152{
153 return i915_buddy_init(&mem->mm, resource_size(&mem->region),
154 PAGE_SIZE);
155}
156
157void intel_memory_region_release_buddy(struct intel_memory_region *mem)
158{
159 i915_buddy_fini(&mem->mm);
160}
161
162struct intel_memory_region *
163intel_memory_region_create(struct drm_i915_private *i915,
164 resource_size_t start,
165 resource_size_t size,
166 resource_size_t min_page_size,
167 resource_size_t io_start,
168 const struct intel_memory_region_ops *ops)
169{
170 struct intel_memory_region *mem;
171 int err;
172
173 mem = kzalloc(sizeof(*mem), GFP_KERNEL);
174 if (!mem)
175 return ERR_PTR(-ENOMEM);
176
177 mem->i915 = i915;
178 mem->region = (struct resource)DEFINE_RES_MEM(start, size);
179 mem->io_start = io_start;
180 mem->min_page_size = min_page_size;
181 mem->ops = ops;
182 mem->total = size;
183 mem->avail = mem->total;
184
185 mutex_init(&mem->objects.lock);
186 INIT_LIST_HEAD(&mem->objects.list);
187 INIT_LIST_HEAD(&mem->objects.purgeable);
188
189 mutex_init(&mem->mm_lock);
190
191 if (ops->init) {
192 err = ops->init(mem);
193 if (err)
194 goto err_free;
195 }
196
197 kref_init(&mem->kref);
198 return mem;
199
200err_free:
201 kfree(mem);
202 return ERR_PTR(err);
203}
204
205void intel_memory_region_set_name(struct intel_memory_region *mem,
206 const char *fmt, ...)
207{
208 va_list ap;
209
210 va_start(ap, fmt);
211 vsnprintf(mem->name, sizeof(mem->name), fmt, ap);
212 va_end(ap);
213}
214
215static void __intel_memory_region_destroy(struct kref *kref)
216{
217 struct intel_memory_region *mem =
218 container_of(kref, typeof(*mem), kref);
219
220 if (mem->ops->release)
221 mem->ops->release(mem);
222
223 mutex_destroy(&mem->mm_lock);
224 mutex_destroy(&mem->objects.lock);
225 kfree(mem);
226}
227
228struct intel_memory_region *
229intel_memory_region_get(struct intel_memory_region *mem)
230{
231 kref_get(&mem->kref);
232 return mem;
233}
234
235void intel_memory_region_put(struct intel_memory_region *mem)
236{
237 kref_put(&mem->kref, __intel_memory_region_destroy);
238}
239
240/* Global memory region registration -- only slight layer inversions! */
241
242int intel_memory_regions_hw_probe(struct drm_i915_private *i915)
243{
244 int err, i;
245
246 for (i = 0; i < ARRAY_SIZE(i915->mm.regions); i++) {
247 struct intel_memory_region *mem = ERR_PTR(-ENODEV);
248 u32 type;
249
250 if (!HAS_REGION(i915, BIT(i)))
251 continue;
252
253 type = MEMORY_TYPE_FROM_REGION(intel_region_map[i]);
254 switch (type) {
255 case INTEL_MEMORY_SYSTEM:
256 mem = i915_gem_shmem_setup(i915);
257 break;
258 case INTEL_MEMORY_STOLEN:
259 mem = i915_gem_stolen_setup(i915);
260 break;
261 case INTEL_MEMORY_LOCAL:
262 mem = intel_setup_fake_lmem(i915);
263 break;
264 }
265
266 if (IS_ERR(mem)) {
267 err = PTR_ERR(mem);
268 drm_err(&i915->drm,
269 "Failed to setup region(%d) type=%d\n",
270 err, type);
271 goto out_cleanup;
272 }
273
274 mem->id = intel_region_map[i];
275 mem->type = type;
276 mem->instance = MEMORY_INSTANCE_FROM_REGION(intel_region_map[i]);
277
278 i915->mm.regions[i] = mem;
279 }
280
281 return 0;
282
283out_cleanup:
284 intel_memory_regions_driver_release(i915);
285 return err;
286}
287
288void intel_memory_regions_driver_release(struct drm_i915_private *i915)
289{
290 int i;
291
292 for (i = 0; i < ARRAY_SIZE(i915->mm.regions); i++) {
293 struct intel_memory_region *region =
294 fetch_and_zero(&i915->mm.regions[i]);
295
296 if (region)
297 intel_memory_region_put(region);
298 }
299}
300
301#if IS_ENABLED(CONFIG_DRM_I915_SELFTEST)
302#include "selftests/intel_memory_region.c"
303#include "selftests/mock_region.c"
304#endif