419 lines · c
1// SPDX-License-Identifier: MIT2/*3 * Copyright © 2019 Intel Corporation4 */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 (resource_size(&mem->io) < PAGE_SIZE)106 return 0;107 108 last = resource_size(&mem->io) - 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 expect114 * a GPF preventing further execution. If the backing store does not115 * 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 backing117 * store + iomap does cover the entire memory region; and we check118 * 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 range176 * @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 else201 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 219static const char *region_type_str(u16 type)220{221 switch (type) {222 case INTEL_MEMORY_SYSTEM:223 return "system";224 case INTEL_MEMORY_LOCAL:225 return "local";226 case INTEL_MEMORY_STOLEN_LOCAL:227 return "stolen-local";228 case INTEL_MEMORY_STOLEN_SYSTEM:229 return "stolen-system";230 default:231 return "unknown";232 }233}234 235struct intel_memory_region *236intel_memory_region_create(struct drm_i915_private *i915,237 resource_size_t start,238 resource_size_t size,239 resource_size_t min_page_size,240 resource_size_t io_start,241 resource_size_t io_size,242 u16 type,243 u16 instance,244 const struct intel_memory_region_ops *ops)245{246 struct intel_memory_region *mem;247 int err;248 249 mem = kzalloc(sizeof(*mem), GFP_KERNEL);250 if (!mem)251 return ERR_PTR(-ENOMEM);252 253 mem->i915 = i915;254 mem->region = DEFINE_RES_MEM(start, size);255 mem->io = DEFINE_RES_MEM(io_start, io_size);256 mem->min_page_size = min_page_size;257 mem->ops = ops;258 mem->total = size;259 mem->type = type;260 mem->instance = instance;261 262 snprintf(mem->uabi_name, sizeof(mem->uabi_name), "%s%u",263 region_type_str(type), instance);264 265 mutex_init(&mem->objects.lock);266 INIT_LIST_HEAD(&mem->objects.list);267 268 if (ops->init) {269 err = ops->init(mem);270 if (err)271 goto err_free;272 }273 274 err = intel_memory_region_memtest(mem, (void *)_RET_IP_);275 if (err)276 goto err_release;277 278 return mem;279 280err_release:281 if (mem->ops->release)282 mem->ops->release(mem);283err_free:284 kfree(mem);285 return ERR_PTR(err);286}287 288void intel_memory_region_set_name(struct intel_memory_region *mem,289 const char *fmt, ...)290{291 va_list ap;292 293 va_start(ap, fmt);294 vsnprintf(mem->name, sizeof(mem->name), fmt, ap);295 va_end(ap);296}297 298void intel_memory_region_avail(struct intel_memory_region *mr,299 u64 *avail, u64 *visible_avail)300{301 if (mr->type == INTEL_MEMORY_LOCAL) {302 i915_ttm_buddy_man_avail(mr->region_private,303 avail, visible_avail);304 *avail <<= PAGE_SHIFT;305 *visible_avail <<= PAGE_SHIFT;306 } else {307 *avail = mr->total;308 *visible_avail = mr->total;309 }310}311 312void intel_memory_region_destroy(struct intel_memory_region *mem)313{314 int ret = 0;315 316 if (mem->ops->release)317 ret = mem->ops->release(mem);318 319 GEM_WARN_ON(!list_empty_careful(&mem->objects.list));320 mutex_destroy(&mem->objects.lock);321 if (!ret)322 kfree(mem);323}324 325/* Global memory region registration -- only slight layer inversions! */326 327int intel_memory_regions_hw_probe(struct drm_i915_private *i915)328{329 int err, i;330 331 for (i = 0; i < ARRAY_SIZE(i915->mm.regions); i++) {332 struct intel_memory_region *mem = ERR_PTR(-ENODEV);333 u16 type, instance;334 335 if (!HAS_REGION(i915, i))336 continue;337 338 type = intel_region_map[i].class;339 instance = intel_region_map[i].instance;340 switch (type) {341 case INTEL_MEMORY_SYSTEM:342 if (IS_DGFX(i915))343 mem = i915_gem_ttm_system_setup(i915, type,344 instance);345 else346 mem = i915_gem_shmem_setup(i915, type,347 instance);348 break;349 case INTEL_MEMORY_STOLEN_LOCAL:350 mem = i915_gem_stolen_lmem_setup(i915, type, instance);351 if (!IS_ERR(mem))352 i915->mm.stolen_region = mem;353 break;354 case INTEL_MEMORY_STOLEN_SYSTEM:355 mem = i915_gem_stolen_smem_setup(i915, type, instance);356 if (!IS_ERR(mem))357 i915->mm.stolen_region = mem;358 break;359 default:360 continue;361 }362 363 if (IS_ERR(mem)) {364 err = PTR_ERR(mem);365 drm_err(&i915->drm,366 "Failed to setup region(%d) type=%d\n",367 err, type);368 goto out_cleanup;369 }370 371 if (mem) { /* Skip on non-fatal errors */372 mem->id = i;373 i915->mm.regions[i] = mem;374 }375 }376 377 for (i = 0; i < ARRAY_SIZE(i915->mm.regions); i++) {378 struct intel_memory_region *mem = i915->mm.regions[i];379 u64 region_size, io_size;380 381 if (!mem)382 continue;383 384 region_size = resource_size(&mem->region) >> 20;385 io_size = resource_size(&mem->io) >> 20;386 387 if (resource_size(&mem->io))388 drm_dbg(&i915->drm, "Memory region(%d): %s: %llu MiB %pR, io: %llu MiB %pR\n",389 mem->id, mem->name, region_size, &mem->region, io_size, &mem->io);390 else391 drm_dbg(&i915->drm, "Memory region(%d): %s: %llu MiB %pR, io: n/a\n",392 mem->id, mem->name, region_size, &mem->region);393 }394 395 return 0;396 397out_cleanup:398 intel_memory_regions_driver_release(i915);399 return err;400}401 402void intel_memory_regions_driver_release(struct drm_i915_private *i915)403{404 int i;405 406 for (i = 0; i < ARRAY_SIZE(i915->mm.regions); i++) {407 struct intel_memory_region *region =408 fetch_and_zero(&i915->mm.regions[i]);409 410 if (region)411 intel_memory_region_destroy(region);412 }413}414 415#if IS_ENABLED(CONFIG_DRM_I915_SELFTEST)416#include "selftests/intel_memory_region.c"417#include "selftests/mock_region.c"418#endif419