Commit | Line | Data |
---|---|---|
8335fd65 CW |
1 | /* |
2 | * Copyright © 2016 Intel Corporation | |
3 | * | |
4 | * Permission is hereby granted, free of charge, to any person obtaining a | |
5 | * copy of this software and associated documentation files (the "Software"), | |
6 | * to deal in the Software without restriction, including without limitation | |
7 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, | |
8 | * and/or sell copies of the Software, and to permit persons to whom the | |
9 | * Software is furnished to do so, subject to the following conditions: | |
10 | * | |
11 | * The above copyright notice and this permission notice (including the next | |
12 | * paragraph) shall be included in all copies or substantial portions of the | |
13 | * Software. | |
14 | * | |
15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
16 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
17 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
18 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
19 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING | |
20 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS | |
21 | * IN THE SOFTWARE. | |
22 | * | |
23 | */ | |
24 | ||
25 | #include "../i915_selftest.h" | |
26 | ||
27 | #include "mock_gem_device.h" | |
3d81d589 | 28 | #include "huge_gem_object.h" |
8335fd65 CW |
29 | |
30 | static int igt_gem_object(void *arg) | |
31 | { | |
32 | struct drm_i915_private *i915 = arg; | |
33 | struct drm_i915_gem_object *obj; | |
34 | int err = -ENOMEM; | |
35 | ||
36 | /* Basic test to ensure we can create an object */ | |
37 | ||
38 | obj = i915_gem_object_create(i915, PAGE_SIZE); | |
39 | if (IS_ERR(obj)) { | |
40 | err = PTR_ERR(obj); | |
41 | pr_err("i915_gem_object_create failed, err=%d\n", err); | |
42 | goto out; | |
43 | } | |
44 | ||
45 | err = 0; | |
46 | i915_gem_object_put(obj); | |
47 | out: | |
48 | return err; | |
49 | } | |
50 | ||
51 | static int igt_phys_object(void *arg) | |
52 | { | |
53 | struct drm_i915_private *i915 = arg; | |
54 | struct drm_i915_gem_object *obj; | |
55 | int err; | |
56 | ||
57 | /* Create an object and bind it to a contiguous set of physical pages, | |
58 | * i.e. exercise the i915_gem_object_phys API. | |
59 | */ | |
60 | ||
61 | obj = i915_gem_object_create(i915, PAGE_SIZE); | |
62 | if (IS_ERR(obj)) { | |
63 | err = PTR_ERR(obj); | |
64 | pr_err("i915_gem_object_create failed, err=%d\n", err); | |
65 | goto out; | |
66 | } | |
67 | ||
68 | mutex_lock(&i915->drm.struct_mutex); | |
69 | err = i915_gem_object_attach_phys(obj, PAGE_SIZE); | |
70 | mutex_unlock(&i915->drm.struct_mutex); | |
71 | if (err) { | |
72 | pr_err("i915_gem_object_attach_phys failed, err=%d\n", err); | |
73 | goto out_obj; | |
74 | } | |
75 | ||
76 | if (obj->ops != &i915_gem_phys_ops) { | |
77 | pr_err("i915_gem_object_attach_phys did not create a phys object\n"); | |
78 | err = -EINVAL; | |
79 | goto out_obj; | |
80 | } | |
81 | ||
82 | if (!atomic_read(&obj->mm.pages_pin_count)) { | |
83 | pr_err("i915_gem_object_attach_phys did not pin its phys pages\n"); | |
84 | err = -EINVAL; | |
85 | goto out_obj; | |
86 | } | |
87 | ||
88 | /* Make the object dirty so that put_pages must do copy back the data */ | |
89 | mutex_lock(&i915->drm.struct_mutex); | |
90 | err = i915_gem_object_set_to_gtt_domain(obj, true); | |
91 | mutex_unlock(&i915->drm.struct_mutex); | |
92 | if (err) { | |
93 | pr_err("i915_gem_object_set_to_gtt_domain failed with err=%d\n", | |
94 | err); | |
95 | goto out_obj; | |
96 | } | |
97 | ||
98 | out_obj: | |
99 | i915_gem_object_put(obj); | |
100 | out: | |
101 | return err; | |
102 | } | |
103 | ||
12d30d87 CW |
104 | static int igt_gem_huge(void *arg) |
105 | { | |
106 | const unsigned int nreal = 509; /* just to be awkward */ | |
107 | struct drm_i915_private *i915 = arg; | |
108 | struct drm_i915_gem_object *obj; | |
109 | unsigned int n; | |
110 | int err; | |
111 | ||
112 | /* Basic sanitycheck of our huge fake object allocation */ | |
113 | ||
114 | obj = huge_gem_object(i915, | |
115 | nreal * PAGE_SIZE, | |
116 | i915->ggtt.base.total + PAGE_SIZE); | |
117 | if (IS_ERR(obj)) | |
118 | return PTR_ERR(obj); | |
119 | ||
120 | err = i915_gem_object_pin_pages(obj); | |
121 | if (err) { | |
122 | pr_err("Failed to allocate %u pages (%lu total), err=%d\n", | |
123 | nreal, obj->base.size / PAGE_SIZE, err); | |
124 | goto out; | |
125 | } | |
126 | ||
127 | for (n = 0; n < obj->base.size / PAGE_SIZE; n++) { | |
128 | if (i915_gem_object_get_page(obj, n) != | |
129 | i915_gem_object_get_page(obj, n % nreal)) { | |
130 | pr_err("Page lookup mismatch at index %u [%u]\n", | |
131 | n, n % nreal); | |
132 | err = -EINVAL; | |
133 | goto out_unpin; | |
134 | } | |
135 | } | |
136 | ||
137 | out_unpin: | |
138 | i915_gem_object_unpin_pages(obj); | |
139 | out: | |
140 | i915_gem_object_put(obj); | |
141 | return err; | |
142 | } | |
143 | ||
48d89817 CW |
144 | struct tile { |
145 | unsigned int width; | |
146 | unsigned int height; | |
147 | unsigned int stride; | |
148 | unsigned int size; | |
149 | unsigned int tiling; | |
150 | unsigned int swizzle; | |
151 | }; | |
152 | ||
153 | static u64 swizzle_bit(unsigned int bit, u64 offset) | |
154 | { | |
155 | return (offset & BIT_ULL(bit)) >> (bit - 6); | |
156 | } | |
157 | ||
158 | static u64 tiled_offset(const struct tile *tile, u64 v) | |
159 | { | |
160 | u64 x, y; | |
161 | ||
162 | if (tile->tiling == I915_TILING_NONE) | |
163 | return v; | |
164 | ||
165 | y = div64_u64_rem(v, tile->stride, &x); | |
166 | v = div64_u64_rem(y, tile->height, &y) * tile->stride * tile->height; | |
167 | ||
168 | if (tile->tiling == I915_TILING_X) { | |
169 | v += y * tile->width; | |
170 | v += div64_u64_rem(x, tile->width, &x) << tile->size; | |
171 | v += x; | |
172 | } else { | |
173 | const unsigned int ytile_span = 16; | |
174 | const unsigned int ytile_height = 32 * ytile_span; | |
175 | ||
176 | v += y * ytile_span; | |
177 | v += div64_u64_rem(x, ytile_span, &x) * ytile_height; | |
178 | v += x; | |
179 | } | |
180 | ||
181 | switch (tile->swizzle) { | |
182 | case I915_BIT_6_SWIZZLE_9: | |
183 | v ^= swizzle_bit(9, v); | |
184 | break; | |
185 | case I915_BIT_6_SWIZZLE_9_10: | |
186 | v ^= swizzle_bit(9, v) ^ swizzle_bit(10, v); | |
187 | break; | |
188 | case I915_BIT_6_SWIZZLE_9_11: | |
189 | v ^= swizzle_bit(9, v) ^ swizzle_bit(11, v); | |
190 | break; | |
191 | case I915_BIT_6_SWIZZLE_9_10_11: | |
192 | v ^= swizzle_bit(9, v) ^ swizzle_bit(10, v) ^ swizzle_bit(11, v); | |
193 | break; | |
194 | } | |
195 | ||
196 | return v; | |
197 | } | |
198 | ||
199 | static int check_partial_mapping(struct drm_i915_gem_object *obj, | |
200 | const struct tile *tile, | |
201 | unsigned long end_time) | |
202 | { | |
203 | const unsigned int nreal = obj->scratch / PAGE_SIZE; | |
204 | const unsigned long npages = obj->base.size / PAGE_SIZE; | |
205 | struct i915_vma *vma; | |
206 | unsigned long page; | |
207 | int err; | |
208 | ||
209 | if (igt_timeout(end_time, | |
210 | "%s: timed out before tiling=%d stride=%d\n", | |
211 | __func__, tile->tiling, tile->stride)) | |
212 | return -EINTR; | |
213 | ||
214 | err = i915_gem_object_set_tiling(obj, tile->tiling, tile->stride); | |
215 | if (err) | |
216 | return err; | |
217 | ||
218 | GEM_BUG_ON(i915_gem_object_get_tiling(obj) != tile->tiling); | |
219 | GEM_BUG_ON(i915_gem_object_get_stride(obj) != tile->stride); | |
220 | ||
221 | for_each_prime_number_from(page, 1, npages) { | |
222 | struct i915_ggtt_view view = | |
223 | compute_partial_view(obj, page, MIN_CHUNK_PAGES); | |
224 | u32 __iomem *io; | |
225 | struct page *p; | |
226 | unsigned int n; | |
227 | u64 offset; | |
228 | u32 *cpu; | |
229 | ||
230 | GEM_BUG_ON(view.partial.size > nreal); | |
231 | ||
232 | err = i915_gem_object_set_to_gtt_domain(obj, true); | |
233 | if (err) | |
234 | return err; | |
235 | ||
236 | vma = i915_gem_object_ggtt_pin(obj, &view, 0, 0, PIN_MAPPABLE); | |
237 | if (IS_ERR(vma)) { | |
238 | pr_err("Failed to pin partial view: offset=%lu\n", | |
239 | page); | |
240 | return PTR_ERR(vma); | |
241 | } | |
242 | ||
243 | n = page - view.partial.offset; | |
244 | GEM_BUG_ON(n >= view.partial.size); | |
245 | ||
246 | io = i915_vma_pin_iomap(vma); | |
247 | i915_vma_unpin(vma); | |
248 | if (IS_ERR(io)) { | |
249 | pr_err("Failed to iomap partial view: offset=%lu\n", | |
250 | page); | |
251 | return PTR_ERR(io); | |
252 | } | |
253 | ||
48d89817 CW |
254 | iowrite32(page, io + n * PAGE_SIZE/sizeof(*io)); |
255 | i915_vma_unpin_iomap(vma); | |
256 | ||
257 | offset = tiled_offset(tile, page << PAGE_SHIFT); | |
258 | if (offset >= obj->base.size) | |
259 | continue; | |
260 | ||
ef74921b | 261 | flush_write_domain(obj, ~I915_GEM_DOMAIN_CPU); |
48d89817 CW |
262 | |
263 | p = i915_gem_object_get_page(obj, offset >> PAGE_SHIFT); | |
264 | cpu = kmap(p) + offset_in_page(offset); | |
265 | drm_clflush_virt_range(cpu, sizeof(*cpu)); | |
266 | if (*cpu != (u32)page) { | |
267 | pr_err("Partial view for %lu [%u] (offset=%llu, size=%u [%llu, row size %u], fence=%d, tiling=%d, stride=%d) misalignment, expected write to page (%llu + %u [0x%llx]) of 0x%x, found 0x%x\n", | |
268 | page, n, | |
269 | view.partial.offset, | |
270 | view.partial.size, | |
271 | vma->size >> PAGE_SHIFT, | |
272 | tile_row_pages(obj), | |
273 | vma->fence ? vma->fence->id : -1, tile->tiling, tile->stride, | |
274 | offset >> PAGE_SHIFT, | |
275 | (unsigned int)offset_in_page(offset), | |
276 | offset, | |
277 | (u32)page, *cpu); | |
278 | err = -EINVAL; | |
279 | } | |
280 | *cpu = 0; | |
281 | drm_clflush_virt_range(cpu, sizeof(*cpu)); | |
282 | kunmap(p); | |
283 | if (err) | |
284 | return err; | |
285 | } | |
286 | ||
287 | return 0; | |
288 | } | |
289 | ||
290 | static int igt_partial_tiling(void *arg) | |
291 | { | |
292 | const unsigned int nreal = 1 << 12; /* largest tile row x2 */ | |
293 | struct drm_i915_private *i915 = arg; | |
294 | struct drm_i915_gem_object *obj; | |
295 | int tiling; | |
296 | int err; | |
297 | ||
298 | /* We want to check the page mapping and fencing of a large object | |
299 | * mmapped through the GTT. The object we create is larger than can | |
300 | * possibly be mmaped as a whole, and so we must use partial GGTT vma. | |
301 | * We then check that a write through each partial GGTT vma ends up | |
302 | * in the right set of pages within the object, and with the expected | |
303 | * tiling, which we verify by manual swizzling. | |
304 | */ | |
305 | ||
306 | obj = huge_gem_object(i915, | |
307 | nreal << PAGE_SHIFT, | |
308 | (1 + next_prime_number(i915->ggtt.base.total >> PAGE_SHIFT)) << PAGE_SHIFT); | |
309 | if (IS_ERR(obj)) | |
310 | return PTR_ERR(obj); | |
311 | ||
312 | err = i915_gem_object_pin_pages(obj); | |
313 | if (err) { | |
314 | pr_err("Failed to allocate %u pages (%lu total), err=%d\n", | |
315 | nreal, obj->base.size / PAGE_SIZE, err); | |
316 | goto out; | |
317 | } | |
318 | ||
319 | mutex_lock(&i915->drm.struct_mutex); | |
320 | ||
321 | if (1) { | |
322 | IGT_TIMEOUT(end); | |
323 | struct tile tile; | |
324 | ||
325 | tile.height = 1; | |
326 | tile.width = 1; | |
327 | tile.size = 0; | |
328 | tile.stride = 0; | |
329 | tile.swizzle = I915_BIT_6_SWIZZLE_NONE; | |
330 | tile.tiling = I915_TILING_NONE; | |
331 | ||
332 | err = check_partial_mapping(obj, &tile, end); | |
333 | if (err && err != -EINTR) | |
334 | goto out_unlock; | |
335 | } | |
336 | ||
337 | for (tiling = I915_TILING_X; tiling <= I915_TILING_Y; tiling++) { | |
338 | IGT_TIMEOUT(end); | |
339 | unsigned int max_pitch; | |
340 | unsigned int pitch; | |
341 | struct tile tile; | |
342 | ||
343 | tile.tiling = tiling; | |
344 | switch (tiling) { | |
345 | case I915_TILING_X: | |
346 | tile.swizzle = i915->mm.bit_6_swizzle_x; | |
347 | break; | |
348 | case I915_TILING_Y: | |
349 | tile.swizzle = i915->mm.bit_6_swizzle_y; | |
350 | break; | |
351 | } | |
352 | ||
353 | if (tile.swizzle == I915_BIT_6_SWIZZLE_UNKNOWN || | |
354 | tile.swizzle == I915_BIT_6_SWIZZLE_9_10_17) | |
355 | continue; | |
356 | ||
357 | if (INTEL_GEN(i915) <= 2) { | |
358 | tile.height = 16; | |
359 | tile.width = 128; | |
360 | tile.size = 11; | |
361 | } else if (tile.tiling == I915_TILING_Y && | |
362 | HAS_128_BYTE_Y_TILING(i915)) { | |
363 | tile.height = 32; | |
364 | tile.width = 128; | |
365 | tile.size = 12; | |
366 | } else { | |
367 | tile.height = 8; | |
368 | tile.width = 512; | |
369 | tile.size = 12; | |
370 | } | |
371 | ||
372 | if (INTEL_GEN(i915) < 4) | |
373 | max_pitch = 8192 / tile.width; | |
374 | else if (INTEL_GEN(i915) < 7) | |
375 | max_pitch = 128 * I965_FENCE_MAX_PITCH_VAL / tile.width; | |
376 | else | |
377 | max_pitch = 128 * GEN7_FENCE_MAX_PITCH_VAL / tile.width; | |
378 | ||
379 | for (pitch = max_pitch; pitch; pitch >>= 1) { | |
380 | tile.stride = tile.width * pitch; | |
381 | err = check_partial_mapping(obj, &tile, end); | |
382 | if (err == -EINTR) | |
383 | goto next_tiling; | |
384 | if (err) | |
385 | goto out_unlock; | |
386 | ||
387 | if (pitch > 2 && INTEL_GEN(i915) >= 4) { | |
388 | tile.stride = tile.width * (pitch - 1); | |
389 | err = check_partial_mapping(obj, &tile, end); | |
390 | if (err == -EINTR) | |
391 | goto next_tiling; | |
392 | if (err) | |
393 | goto out_unlock; | |
394 | } | |
395 | ||
396 | if (pitch < max_pitch && INTEL_GEN(i915) >= 4) { | |
397 | tile.stride = tile.width * (pitch + 1); | |
398 | err = check_partial_mapping(obj, &tile, end); | |
399 | if (err == -EINTR) | |
400 | goto next_tiling; | |
401 | if (err) | |
402 | goto out_unlock; | |
403 | } | |
404 | } | |
405 | ||
406 | if (INTEL_GEN(i915) >= 4) { | |
407 | for_each_prime_number(pitch, max_pitch) { | |
408 | tile.stride = tile.width * pitch; | |
409 | err = check_partial_mapping(obj, &tile, end); | |
410 | if (err == -EINTR) | |
411 | goto next_tiling; | |
412 | if (err) | |
413 | goto out_unlock; | |
414 | } | |
415 | } | |
416 | ||
417 | next_tiling: ; | |
418 | } | |
419 | ||
420 | out_unlock: | |
421 | mutex_unlock(&i915->drm.struct_mutex); | |
422 | i915_gem_object_unpin_pages(obj); | |
423 | out: | |
424 | i915_gem_object_put(obj); | |
425 | return err; | |
426 | } | |
427 | ||
3d81d589 CW |
428 | static int make_obj_busy(struct drm_i915_gem_object *obj) |
429 | { | |
430 | struct drm_i915_private *i915 = to_i915(obj->base.dev); | |
431 | struct drm_i915_gem_request *rq; | |
432 | struct i915_vma *vma; | |
433 | int err; | |
434 | ||
435 | vma = i915_vma_instance(obj, &i915->ggtt.base, NULL); | |
436 | if (IS_ERR(vma)) | |
437 | return PTR_ERR(vma); | |
438 | ||
439 | err = i915_vma_pin(vma, 0, 0, PIN_USER); | |
440 | if (err) | |
441 | return err; | |
442 | ||
443 | rq = i915_gem_request_alloc(i915->engine[RCS], i915->kernel_context); | |
444 | if (IS_ERR(rq)) { | |
445 | i915_vma_unpin(vma); | |
446 | return PTR_ERR(rq); | |
447 | } | |
448 | ||
449 | i915_vma_move_to_active(vma, rq, 0); | |
450 | i915_add_request(rq); | |
451 | ||
452 | i915_gem_object_set_active_reference(obj); | |
453 | i915_vma_unpin(vma); | |
454 | return 0; | |
455 | } | |
456 | ||
457 | static bool assert_mmap_offset(struct drm_i915_private *i915, | |
458 | unsigned long size, | |
459 | int expected) | |
460 | { | |
461 | struct drm_i915_gem_object *obj; | |
462 | int err; | |
463 | ||
464 | obj = i915_gem_object_create_internal(i915, size); | |
465 | if (IS_ERR(obj)) | |
466 | return PTR_ERR(obj); | |
467 | ||
468 | err = i915_gem_object_create_mmap_offset(obj); | |
469 | i915_gem_object_put(obj); | |
470 | ||
471 | return err == expected; | |
472 | } | |
473 | ||
474 | static int igt_mmap_offset_exhaustion(void *arg) | |
475 | { | |
476 | struct drm_i915_private *i915 = arg; | |
477 | struct drm_mm *mm = &i915->drm.vma_offset_manager->vm_addr_space_mm; | |
478 | struct drm_i915_gem_object *obj; | |
479 | struct drm_mm_node resv, *hole; | |
480 | u64 hole_start, hole_end; | |
481 | int loop, err; | |
482 | ||
483 | /* Trim the device mmap space to only a page */ | |
484 | memset(&resv, 0, sizeof(resv)); | |
485 | drm_mm_for_each_hole(hole, mm, hole_start, hole_end) { | |
486 | resv.start = hole_start; | |
487 | resv.size = hole_end - hole_start - 1; /* PAGE_SIZE units */ | |
488 | err = drm_mm_reserve_node(mm, &resv); | |
489 | if (err) { | |
490 | pr_err("Failed to trim VMA manager, err=%d\n", err); | |
491 | return err; | |
492 | } | |
493 | break; | |
494 | } | |
495 | ||
496 | /* Just fits! */ | |
497 | if (!assert_mmap_offset(i915, PAGE_SIZE, 0)) { | |
498 | pr_err("Unable to insert object into single page hole\n"); | |
499 | err = -EINVAL; | |
500 | goto out; | |
501 | } | |
502 | ||
503 | /* Too large */ | |
504 | if (!assert_mmap_offset(i915, 2*PAGE_SIZE, -ENOSPC)) { | |
505 | pr_err("Unexpectedly succeeded in inserting too large object into single page hole\n"); | |
506 | err = -EINVAL; | |
507 | goto out; | |
508 | } | |
509 | ||
510 | /* Fill the hole, further allocation attempts should then fail */ | |
511 | obj = i915_gem_object_create_internal(i915, PAGE_SIZE); | |
512 | if (IS_ERR(obj)) { | |
513 | err = PTR_ERR(obj); | |
514 | goto out; | |
515 | } | |
516 | ||
517 | err = i915_gem_object_create_mmap_offset(obj); | |
518 | if (err) { | |
519 | pr_err("Unable to insert object into reclaimed hole\n"); | |
520 | goto err_obj; | |
521 | } | |
522 | ||
523 | if (!assert_mmap_offset(i915, PAGE_SIZE, -ENOSPC)) { | |
524 | pr_err("Unexpectedly succeeded in inserting object into no holes!\n"); | |
525 | err = -EINVAL; | |
526 | goto err_obj; | |
527 | } | |
528 | ||
529 | i915_gem_object_put(obj); | |
530 | ||
531 | /* Now fill with busy dead objects that we expect to reap */ | |
532 | for (loop = 0; loop < 3; loop++) { | |
533 | obj = i915_gem_object_create_internal(i915, PAGE_SIZE); | |
534 | if (IS_ERR(obj)) { | |
535 | err = PTR_ERR(obj); | |
536 | goto out; | |
537 | } | |
538 | ||
539 | mutex_lock(&i915->drm.struct_mutex); | |
10e9bd9a | 540 | intel_runtime_pm_get(i915); |
3d81d589 | 541 | err = make_obj_busy(obj); |
10e9bd9a | 542 | intel_runtime_pm_put(i915); |
3d81d589 CW |
543 | mutex_unlock(&i915->drm.struct_mutex); |
544 | if (err) { | |
545 | pr_err("[loop %d] Failed to busy the object\n", loop); | |
546 | goto err_obj; | |
547 | } | |
548 | ||
549 | GEM_BUG_ON(!i915_gem_object_is_active(obj)); | |
550 | err = i915_gem_object_create_mmap_offset(obj); | |
551 | if (err) { | |
552 | pr_err("[loop %d] i915_gem_object_create_mmap_offset failed with err=%d\n", | |
553 | loop, err); | |
554 | goto out; | |
555 | } | |
556 | } | |
557 | ||
558 | out: | |
559 | drm_mm_remove_node(&resv); | |
560 | return err; | |
561 | err_obj: | |
562 | i915_gem_object_put(obj); | |
563 | goto out; | |
564 | } | |
565 | ||
8335fd65 CW |
566 | int i915_gem_object_mock_selftests(void) |
567 | { | |
568 | static const struct i915_subtest tests[] = { | |
569 | SUBTEST(igt_gem_object), | |
570 | SUBTEST(igt_phys_object), | |
571 | }; | |
572 | struct drm_i915_private *i915; | |
573 | int err; | |
574 | ||
575 | i915 = mock_gem_device(); | |
576 | if (!i915) | |
577 | return -ENOMEM; | |
578 | ||
579 | err = i915_subtests(tests, i915); | |
580 | ||
581 | drm_dev_unref(&i915->drm); | |
582 | return err; | |
583 | } | |
12d30d87 CW |
584 | |
585 | int i915_gem_object_live_selftests(struct drm_i915_private *i915) | |
586 | { | |
587 | static const struct i915_subtest tests[] = { | |
588 | SUBTEST(igt_gem_huge), | |
48d89817 | 589 | SUBTEST(igt_partial_tiling), |
3d81d589 | 590 | SUBTEST(igt_mmap_offset_exhaustion), |
12d30d87 CW |
591 | }; |
592 | ||
593 | return i915_subtests(tests, i915); | |
594 | } |