Branch data Line data Source code
1 : : // SPDX-License-Identifier: MIT
2 : : /*
3 : : * Copyright © 2020 Intel Corporation
4 : : */
5 : :
6 : : #include <linux/log2.h>
7 : :
8 : : #include "gen6_ppgtt.h"
9 : : #include "i915_scatterlist.h"
10 : : #include "i915_trace.h"
11 : : #include "i915_vgpu.h"
12 : : #include "intel_gt.h"
13 : :
14 : : /* Write pde (index) from the page directory @pd to the page table @pt */
15 : 0 : static inline void gen6_write_pde(const struct gen6_ppgtt *ppgtt,
16 : : const unsigned int pde,
17 : : const struct i915_page_table *pt)
18 : : {
19 : : /* Caller needs to make sure the write completes if necessary */
20 : 0 : iowrite32(GEN6_PDE_ADDR_ENCODE(px_dma(pt)) | GEN6_PDE_VALID,
21 : 0 : ppgtt->pd_addr + pde);
22 : : }
23 : :
24 : 0 : void gen7_ppgtt_enable(struct intel_gt *gt)
25 : : {
26 : 0 : struct drm_i915_private *i915 = gt->i915;
27 : 0 : struct intel_uncore *uncore = gt->uncore;
28 : 0 : struct intel_engine_cs *engine;
29 : 0 : enum intel_engine_id id;
30 : 0 : u32 ecochk;
31 : :
32 : 0 : intel_uncore_rmw(uncore, GAC_ECO_BITS, 0, ECOBITS_PPGTT_CACHE64B);
33 : :
34 : 0 : ecochk = intel_uncore_read(uncore, GAM_ECOCHK);
35 [ # # ]: 0 : if (IS_HASWELL(i915)) {
36 : 0 : ecochk |= ECOCHK_PPGTT_WB_HSW;
37 : : } else {
38 : 0 : ecochk |= ECOCHK_PPGTT_LLC_IVB;
39 : 0 : ecochk &= ~ECOCHK_PPGTT_GFDT_IVB;
40 : : }
41 : 0 : intel_uncore_write(uncore, GAM_ECOCHK, ecochk);
42 : :
43 [ # # # # ]: 0 : for_each_engine(engine, gt, id) {
44 : : /* GFX_MODE is per-ring on gen7+ */
45 : 0 : ENGINE_WRITE(engine,
46 : : RING_MODE_GEN7,
47 : : _MASKED_BIT_ENABLE(GFX_PPGTT_ENABLE));
48 : : }
49 : 0 : }
50 : :
51 : 0 : void gen6_ppgtt_enable(struct intel_gt *gt)
52 : : {
53 : 0 : struct intel_uncore *uncore = gt->uncore;
54 : :
55 : 0 : intel_uncore_rmw(uncore,
56 : 0 : GAC_ECO_BITS,
57 : : 0,
58 : : ECOBITS_SNB_BIT | ECOBITS_PPGTT_CACHE64B);
59 : :
60 : 0 : intel_uncore_rmw(uncore,
61 : 0 : GAB_CTL,
62 : : 0,
63 : : GAB_CTL_CONT_AFTER_PAGEFAULT);
64 : :
65 : 0 : intel_uncore_rmw(uncore,
66 : 0 : GAM_ECOCHK,
67 : : 0,
68 : : ECOCHK_SNB_BIT | ECOCHK_PPGTT_CACHE64B);
69 : :
70 [ # # ]: 0 : if (HAS_PPGTT(uncore->i915)) /* may be disabled for VT-d */
71 : 0 : intel_uncore_write(uncore,
72 : : GFX_MODE,
73 : 0 : _MASKED_BIT_ENABLE(GFX_PPGTT_ENABLE));
74 : 0 : }
75 : :
76 : : /* PPGTT support for Sandybdrige/Gen6 and later */
77 : 0 : static void gen6_ppgtt_clear_range(struct i915_address_space *vm,
78 : : u64 start, u64 length)
79 : : {
80 : 0 : struct gen6_ppgtt * const ppgtt = to_gen6_ppgtt(i915_vm_to_ppgtt(vm));
81 : 0 : const unsigned int first_entry = start / I915_GTT_PAGE_SIZE;
82 : 0 : const gen6_pte_t scratch_pte = vm->scratch[0].encode;
83 : 0 : unsigned int pde = first_entry / GEN6_PTES;
84 : 0 : unsigned int pte = first_entry % GEN6_PTES;
85 : 0 : unsigned int num_entries = length / I915_GTT_PAGE_SIZE;
86 : :
87 [ # # ]: 0 : while (num_entries) {
88 : 0 : struct i915_page_table * const pt =
89 : 0 : i915_pt_entry(ppgtt->base.pd, pde++);
90 : 0 : const unsigned int count = min(num_entries, GEN6_PTES - pte);
91 : 0 : gen6_pte_t *vaddr;
92 : :
93 : 0 : GEM_BUG_ON(px_base(pt) == px_base(&vm->scratch[1]));
94 : :
95 : 0 : num_entries -= count;
96 : :
97 : 0 : GEM_BUG_ON(count > atomic_read(&pt->used));
98 [ # # ]: 0 : if (!atomic_sub_return(count, &pt->used))
99 : 0 : ppgtt->scan_for_unused_pt = true;
100 : :
101 : : /*
102 : : * Note that the hw doesn't support removing PDE on the fly
103 : : * (they are cached inside the context with no means to
104 : : * invalidate the cache), so we can only reset the PTE
105 : : * entries back to scratch.
106 : : */
107 : :
108 : 0 : vaddr = kmap_atomic_px(pt);
109 : 0 : memset32(vaddr + pte, scratch_pte, count);
110 : 0 : kunmap_atomic(vaddr);
111 : :
112 : 0 : pte = 0;
113 : : }
114 : 0 : }
115 : :
116 : 0 : static void gen6_ppgtt_insert_entries(struct i915_address_space *vm,
117 : : struct i915_vma *vma,
118 : : enum i915_cache_level cache_level,
119 : : u32 flags)
120 : : {
121 : 0 : struct i915_ppgtt *ppgtt = i915_vm_to_ppgtt(vm);
122 : 0 : struct i915_page_directory * const pd = ppgtt->pd;
123 : 0 : unsigned int first_entry = vma->node.start / I915_GTT_PAGE_SIZE;
124 : 0 : unsigned int act_pt = first_entry / GEN6_PTES;
125 : 0 : unsigned int act_pte = first_entry % GEN6_PTES;
126 : 0 : const u32 pte_encode = vm->pte_encode(0, cache_level, flags);
127 : 0 : struct sgt_dma iter = sgt_dma(vma);
128 : 0 : gen6_pte_t *vaddr;
129 : :
130 : 0 : GEM_BUG_ON(pd->entry[act_pt] == &vm->scratch[1]);
131 : :
132 : 0 : vaddr = kmap_atomic_px(i915_pt_entry(pd, act_pt));
133 : 0 : do {
134 : 0 : GEM_BUG_ON(iter.sg->length < I915_GTT_PAGE_SIZE);
135 : 0 : vaddr[act_pte] = pte_encode | GEN6_PTE_ADDR_ENCODE(iter.dma);
136 : :
137 : 0 : iter.dma += I915_GTT_PAGE_SIZE;
138 [ # # ]: 0 : if (iter.dma == iter.max) {
139 [ # # ]: 0 : iter.sg = __sg_next(iter.sg);
140 [ # # ]: 0 : if (!iter.sg)
141 : : break;
142 : :
143 : 0 : iter.dma = sg_dma_address(iter.sg);
144 : 0 : iter.max = iter.dma + iter.sg->length;
145 : : }
146 : :
147 [ # # ]: 0 : if (++act_pte == GEN6_PTES) {
148 : 0 : kunmap_atomic(vaddr);
149 : 0 : vaddr = kmap_atomic_px(i915_pt_entry(pd, ++act_pt));
150 : 0 : act_pte = 0;
151 : : }
152 : : } while (1);
153 : 0 : kunmap_atomic(vaddr);
154 : :
155 : 0 : vma->page_sizes.gtt = I915_GTT_PAGE_SIZE;
156 : 0 : }
157 : :
158 : 0 : static void gen6_flush_pd(struct gen6_ppgtt *ppgtt, u64 start, u64 end)
159 : : {
160 : 0 : struct i915_page_directory * const pd = ppgtt->base.pd;
161 : 0 : struct i915_page_table *pt;
162 : 0 : unsigned int pde;
163 : :
164 : 0 : start = round_down(start, SZ_64K);
165 : 0 : end = round_up(end, SZ_64K) - start;
166 : :
167 : 0 : mutex_lock(&ppgtt->flush);
168 : :
169 [ # # ]: 0 : gen6_for_each_pde(pt, pd, start, end, pde)
170 : 0 : gen6_write_pde(ppgtt, pde, pt);
171 : :
172 : 0 : mb();
173 : 0 : ioread32(ppgtt->pd_addr + pde - 1);
174 : 0 : gen6_ggtt_invalidate(ppgtt->base.vm.gt->ggtt);
175 : 0 : mb();
176 : :
177 : 0 : mutex_unlock(&ppgtt->flush);
178 : 0 : }
179 : :
180 : 0 : static int gen6_alloc_va_range(struct i915_address_space *vm,
181 : : u64 start, u64 length)
182 : : {
183 : 0 : struct gen6_ppgtt *ppgtt = to_gen6_ppgtt(i915_vm_to_ppgtt(vm));
184 : 0 : struct i915_page_directory * const pd = ppgtt->base.pd;
185 : 0 : struct i915_page_table *pt, *alloc = NULL;
186 : 0 : intel_wakeref_t wakeref;
187 : 0 : u64 from = start;
188 : 0 : unsigned int pde;
189 : 0 : int ret = 0;
190 : :
191 : 0 : wakeref = intel_runtime_pm_get(&vm->i915->runtime_pm);
192 : :
193 : 0 : spin_lock(&pd->lock);
194 [ # # # # ]: 0 : gen6_for_each_pde(pt, pd, start, length, pde) {
195 [ # # ]: 0 : const unsigned int count = gen6_pte_count(start, length);
196 : :
197 [ # # ]: 0 : if (px_base(pt) == px_base(&vm->scratch[1])) {
198 : 0 : spin_unlock(&pd->lock);
199 : :
200 : 0 : pt = fetch_and_zero(&alloc);
201 [ # # ]: 0 : if (!pt)
202 : 0 : pt = alloc_pt(vm);
203 [ # # ]: 0 : if (IS_ERR(pt)) {
204 : 0 : ret = PTR_ERR(pt);
205 : 0 : goto unwind_out;
206 : : }
207 : :
208 : 0 : fill32_px(pt, vm->scratch[0].encode);
209 : :
210 : 0 : spin_lock(&pd->lock);
211 [ # # ]: 0 : if (pd->entry[pde] == &vm->scratch[1]) {
212 : 0 : pd->entry[pde] = pt;
213 : : } else {
214 : : alloc = pt;
215 : : pt = pd->entry[pde];
216 : : }
217 : : }
218 : :
219 : 0 : atomic_add(count, &pt->used);
220 : : }
221 : 0 : spin_unlock(&pd->lock);
222 : :
223 [ # # ]: 0 : if (i915_vma_is_bound(ppgtt->vma, I915_VMA_GLOBAL_BIND))
224 : 0 : gen6_flush_pd(ppgtt, from, start);
225 : :
226 : 0 : goto out;
227 : :
228 : : unwind_out:
229 : 0 : gen6_ppgtt_clear_range(vm, from, start - from);
230 : : out:
231 [ # # ]: 0 : if (alloc)
232 : 0 : free_px(vm, alloc);
233 : 0 : intel_runtime_pm_put(&vm->i915->runtime_pm, wakeref);
234 : 0 : return ret;
235 : : }
236 : :
237 : 0 : static int gen6_ppgtt_init_scratch(struct gen6_ppgtt *ppgtt)
238 : : {
239 : 0 : struct i915_address_space * const vm = &ppgtt->base.vm;
240 : 0 : struct i915_page_directory * const pd = ppgtt->base.pd;
241 : 0 : int ret;
242 : :
243 : 0 : ret = setup_scratch_page(vm, __GFP_HIGHMEM);
244 [ # # ]: 0 : if (ret)
245 : : return ret;
246 : :
247 : 0 : vm->scratch[0].encode =
248 : 0 : vm->pte_encode(px_dma(&vm->scratch[0]),
249 : : I915_CACHE_NONE, PTE_READ_ONLY);
250 : :
251 [ # # ]: 0 : if (unlikely(setup_page_dma(vm, px_base(&vm->scratch[1])))) {
252 : 0 : cleanup_scratch_page(vm);
253 : 0 : return -ENOMEM;
254 : : }
255 : :
256 : 0 : fill32_px(&vm->scratch[1], vm->scratch[0].encode);
257 : 0 : memset_p(pd->entry, &vm->scratch[1], I915_PDES);
258 : :
259 : 0 : return 0;
260 : : }
261 : :
262 : 0 : static void gen6_ppgtt_free_pd(struct gen6_ppgtt *ppgtt)
263 : : {
264 : 0 : struct i915_page_directory * const pd = ppgtt->base.pd;
265 : 0 : struct i915_page_dma * const scratch =
266 : 0 : px_base(&ppgtt->base.vm.scratch[1]);
267 : 0 : struct i915_page_table *pt;
268 : 0 : u32 pde;
269 : :
270 [ # # # # ]: 0 : gen6_for_all_pdes(pt, pd, pde)
271 [ # # ]: 0 : if (px_base(pt) != scratch)
272 : 0 : free_px(&ppgtt->base.vm, pt);
273 : 0 : }
274 : :
275 : 0 : static void gen6_ppgtt_cleanup(struct i915_address_space *vm)
276 : : {
277 : 0 : struct gen6_ppgtt *ppgtt = to_gen6_ppgtt(i915_vm_to_ppgtt(vm));
278 : :
279 : 0 : __i915_vma_put(ppgtt->vma);
280 : :
281 : 0 : gen6_ppgtt_free_pd(ppgtt);
282 : 0 : free_scratch(vm);
283 : :
284 : 0 : mutex_destroy(&ppgtt->flush);
285 : 0 : mutex_destroy(&ppgtt->pin_mutex);
286 : 0 : kfree(ppgtt->base.pd);
287 : 0 : }
288 : :
289 : 0 : static int pd_vma_set_pages(struct i915_vma *vma)
290 : : {
291 : 0 : vma->pages = ERR_PTR(-ENODEV);
292 : 0 : return 0;
293 : : }
294 : :
295 : 0 : static void pd_vma_clear_pages(struct i915_vma *vma)
296 : : {
297 : 0 : GEM_BUG_ON(!vma->pages);
298 : :
299 : 0 : vma->pages = NULL;
300 : 0 : }
301 : :
302 : 0 : static int pd_vma_bind(struct i915_vma *vma,
303 : : enum i915_cache_level cache_level,
304 : : u32 unused)
305 : : {
306 : 0 : struct i915_ggtt *ggtt = i915_vm_to_ggtt(vma->vm);
307 : 0 : struct gen6_ppgtt *ppgtt = vma->private;
308 : 0 : u32 ggtt_offset = i915_ggtt_offset(vma) / I915_GTT_PAGE_SIZE;
309 : :
310 : 0 : px_base(ppgtt->base.pd)->ggtt_offset = ggtt_offset * sizeof(gen6_pte_t);
311 : 0 : ppgtt->pd_addr = (gen6_pte_t __iomem *)ggtt->gsm + ggtt_offset;
312 : :
313 : 0 : gen6_flush_pd(ppgtt, 0, ppgtt->base.vm.total);
314 : 0 : return 0;
315 : : }
316 : :
317 : 0 : static void pd_vma_unbind(struct i915_vma *vma)
318 : : {
319 : 0 : struct gen6_ppgtt *ppgtt = vma->private;
320 : 0 : struct i915_page_directory * const pd = ppgtt->base.pd;
321 : 0 : struct i915_page_dma * const scratch =
322 : 0 : px_base(&ppgtt->base.vm.scratch[1]);
323 : 0 : struct i915_page_table *pt;
324 : 0 : unsigned int pde;
325 : :
326 [ # # ]: 0 : if (!ppgtt->scan_for_unused_pt)
327 : : return;
328 : :
329 : : /* Free all no longer used page tables */
330 [ # # # # ]: 0 : gen6_for_all_pdes(pt, ppgtt->base.pd, pde) {
331 [ # # # # ]: 0 : if (px_base(pt) == scratch || atomic_read(&pt->used))
332 : 0 : continue;
333 : :
334 : 0 : free_px(&ppgtt->base.vm, pt);
335 : 0 : pd->entry[pde] = scratch;
336 : : }
337 : :
338 : 0 : ppgtt->scan_for_unused_pt = false;
339 : : }
340 : :
341 : : static const struct i915_vma_ops pd_vma_ops = {
342 : : .set_pages = pd_vma_set_pages,
343 : : .clear_pages = pd_vma_clear_pages,
344 : : .bind_vma = pd_vma_bind,
345 : : .unbind_vma = pd_vma_unbind,
346 : : };
347 : :
348 : 0 : static struct i915_vma *pd_vma_create(struct gen6_ppgtt *ppgtt, int size)
349 : : {
350 : 0 : struct i915_ggtt *ggtt = ppgtt->base.vm.gt->ggtt;
351 : 0 : struct i915_vma *vma;
352 : :
353 : 0 : GEM_BUG_ON(!IS_ALIGNED(size, I915_GTT_PAGE_SIZE));
354 : 0 : GEM_BUG_ON(size > ggtt->vm.total);
355 : :
356 : 0 : vma = i915_vma_alloc();
357 [ # # ]: 0 : if (!vma)
358 : : return ERR_PTR(-ENOMEM);
359 : :
360 : 0 : i915_active_init(&vma->active, NULL, NULL);
361 : :
362 : 0 : kref_init(&vma->ref);
363 : 0 : mutex_init(&vma->pages_mutex);
364 : 0 : vma->vm = i915_vm_get(&ggtt->vm);
365 : 0 : vma->ops = &pd_vma_ops;
366 : 0 : vma->private = ppgtt;
367 : :
368 : 0 : vma->size = size;
369 : 0 : vma->fence_size = size;
370 : 0 : atomic_set(&vma->flags, I915_VMA_GGTT);
371 : 0 : vma->ggtt_view.type = I915_GGTT_VIEW_ROTATED; /* prevent fencing */
372 : :
373 : 0 : INIT_LIST_HEAD(&vma->obj_link);
374 : 0 : INIT_LIST_HEAD(&vma->closed_link);
375 : :
376 : 0 : return vma;
377 : : }
378 : :
379 : 0 : int gen6_ppgtt_pin(struct i915_ppgtt *base)
380 : : {
381 : 0 : struct gen6_ppgtt *ppgtt = to_gen6_ppgtt(base);
382 : 0 : int err;
383 : :
384 : 0 : GEM_BUG_ON(!atomic_read(&ppgtt->base.vm.open));
385 : :
386 : : /*
387 : : * Workaround the limited maximum vma->pin_count and the aliasing_ppgtt
388 : : * which will be pinned into every active context.
389 : : * (When vma->pin_count becomes atomic, I expect we will naturally
390 : : * need a larger, unpacked, type and kill this redundancy.)
391 : : */
392 [ # # ]: 0 : if (atomic_add_unless(&ppgtt->pin_count, 1, 0))
393 : : return 0;
394 : :
395 [ # # ]: 0 : if (mutex_lock_interruptible(&ppgtt->pin_mutex))
396 : : return -EINTR;
397 : :
398 : : /*
399 : : * PPGTT PDEs reside in the GGTT and consists of 512 entries. The
400 : : * allocator works in address space sizes, so it's multiplied by page
401 : : * size. We allocate at the top of the GTT to avoid fragmentation.
402 : : */
403 : 0 : err = 0;
404 [ # # ]: 0 : if (!atomic_read(&ppgtt->pin_count))
405 : 0 : err = i915_ggtt_pin(ppgtt->vma, GEN6_PD_ALIGN, PIN_HIGH);
406 [ # # ]: 0 : if (!err)
407 : 0 : atomic_inc(&ppgtt->pin_count);
408 : 0 : mutex_unlock(&ppgtt->pin_mutex);
409 : :
410 : 0 : return err;
411 : : }
412 : :
413 : 0 : void gen6_ppgtt_unpin(struct i915_ppgtt *base)
414 : : {
415 : 0 : struct gen6_ppgtt *ppgtt = to_gen6_ppgtt(base);
416 : :
417 : 0 : GEM_BUG_ON(!atomic_read(&ppgtt->pin_count));
418 [ # # ]: 0 : if (atomic_dec_and_test(&ppgtt->pin_count))
419 : 0 : i915_vma_unpin(ppgtt->vma);
420 : 0 : }
421 : :
422 : 0 : void gen6_ppgtt_unpin_all(struct i915_ppgtt *base)
423 : : {
424 : 0 : struct gen6_ppgtt *ppgtt = to_gen6_ppgtt(base);
425 : :
426 [ # # ]: 0 : if (!atomic_read(&ppgtt->pin_count))
427 : : return;
428 : :
429 : 0 : i915_vma_unpin(ppgtt->vma);
430 : 0 : atomic_set(&ppgtt->pin_count, 0);
431 : : }
432 : :
433 : 0 : struct i915_ppgtt *gen6_ppgtt_create(struct intel_gt *gt)
434 : : {
435 : 0 : struct i915_ggtt * const ggtt = gt->ggtt;
436 : 0 : struct gen6_ppgtt *ppgtt;
437 : 0 : int err;
438 : :
439 : 0 : ppgtt = kzalloc(sizeof(*ppgtt), GFP_KERNEL);
440 [ # # ]: 0 : if (!ppgtt)
441 : : return ERR_PTR(-ENOMEM);
442 : :
443 : 0 : mutex_init(&ppgtt->flush);
444 : 0 : mutex_init(&ppgtt->pin_mutex);
445 : :
446 : 0 : ppgtt_init(&ppgtt->base, gt);
447 : 0 : ppgtt->base.vm.top = 1;
448 : :
449 : 0 : ppgtt->base.vm.bind_async_flags = I915_VMA_LOCAL_BIND;
450 : 0 : ppgtt->base.vm.allocate_va_range = gen6_alloc_va_range;
451 : 0 : ppgtt->base.vm.clear_range = gen6_ppgtt_clear_range;
452 : 0 : ppgtt->base.vm.insert_entries = gen6_ppgtt_insert_entries;
453 : 0 : ppgtt->base.vm.cleanup = gen6_ppgtt_cleanup;
454 : :
455 : 0 : ppgtt->base.vm.pte_encode = ggtt->vm.pte_encode;
456 : :
457 : 0 : ppgtt->base.pd = __alloc_pd(sizeof(*ppgtt->base.pd));
458 [ # # ]: 0 : if (!ppgtt->base.pd) {
459 : 0 : err = -ENOMEM;
460 : 0 : goto err_free;
461 : : }
462 : :
463 : 0 : err = gen6_ppgtt_init_scratch(ppgtt);
464 [ # # ]: 0 : if (err)
465 : 0 : goto err_pd;
466 : :
467 : 0 : ppgtt->vma = pd_vma_create(ppgtt, GEN6_PD_SIZE);
468 [ # # ]: 0 : if (IS_ERR(ppgtt->vma)) {
469 : 0 : err = PTR_ERR(ppgtt->vma);
470 : 0 : goto err_scratch;
471 : : }
472 : :
473 : : return &ppgtt->base;
474 : :
475 : : err_scratch:
476 : 0 : free_scratch(&ppgtt->base.vm);
477 : 0 : err_pd:
478 : 0 : kfree(ppgtt->base.pd);
479 : 0 : err_free:
480 : 0 : mutex_destroy(&ppgtt->pin_mutex);
481 : 0 : kfree(ppgtt);
482 : 0 : return ERR_PTR(err);
483 : : }
|
