2 * Copyright © 2010 Daniel Vetter
3 * Copyright © 2011-2014 Intel Corporation
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
12 * The above copyright notice and this permission notice (including the next
13 * paragraph) shall be included in all copies or substantial portions of the
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
26 #include <linux/slab.h> /* fault-inject.h is not standalone! */
28 #include <linux/fault-inject.h>
29 #include <linux/log2.h>
30 #include <linux/random.h>
31 #include <linux/seq_file.h>
32 #include <linux/stop_machine.h>
34 #include <asm/set_memory.h>
37 #include <drm/i915_drm.h>
40 #include "i915_vgpu.h"
41 #include "i915_trace.h"
42 #include "intel_drv.h"
43 #include "intel_frontbuffer.h"
45 #define I915_GFP_ALLOW_FAIL (GFP_KERNEL | __GFP_RETRY_MAYFAIL | __GFP_NOWARN)
48 * DOC: Global GTT views
50 * Background and previous state
52 * Historically objects could exists (be bound) in global GTT space only as
53 * singular instances with a view representing all of the object's backing pages
54 * in a linear fashion. This view will be called a normal view.
56 * To support multiple views of the same object, where the number of mapped
57 * pages is not equal to the backing store, or where the layout of the pages
58 * is not linear, concept of a GGTT view was added.
60 * One example of an alternative view is a stereo display driven by a single
61 * image. In this case we would have a framebuffer looking like this
67 * Above would represent a normal GGTT view as normally mapped for GPU or CPU
68 * rendering. In contrast, fed to the display engine would be an alternative
69 * view which could look something like this:
74 * In this example both the size and layout of pages in the alternative view is
75 * different from the normal view.
77 * Implementation and usage
79 * GGTT views are implemented using VMAs and are distinguished via enum
80 * i915_ggtt_view_type and struct i915_ggtt_view.
82 * A new flavour of core GEM functions which work with GGTT bound objects were
83 * added with the _ggtt_ infix, and sometimes with _view postfix to avoid
84 * renaming in large amounts of code. They take the struct i915_ggtt_view
85 * parameter encapsulating all metadata required to implement a view.
87 * As a helper for callers which are only interested in the normal view,
88 * globally const i915_ggtt_view_normal singleton instance exists. All old core
89 * GEM API functions, the ones not taking the view parameter, are operating on,
90 * or with the normal GGTT view.
92 * Code wanting to add or use a new GGTT view needs to:
94 * 1. Add a new enum with a suitable name.
95 * 2. Extend the metadata in the i915_ggtt_view structure if required.
96 * 3. Add support to i915_get_vma_pages().
98 * New views are required to build a scatter-gather table from within the
99 * i915_get_vma_pages function. This table is stored in the vma.ggtt_view and
100 * exists for the lifetime of an VMA.
102 * Core API is designed to have copy semantics which means that passed in
103 * struct i915_ggtt_view does not need to be persistent (left around after
104 * calling the core API functions).
109 i915_get_ggtt_vma_pages(struct i915_vma *vma);
111 static void gen6_ggtt_invalidate(struct drm_i915_private *dev_priv)
114 * Note that as an uncached mmio write, this will flush the
115 * WCB of the writes into the GGTT before it triggers the invalidate.
117 I915_WRITE(GFX_FLSH_CNTL_GEN6, GFX_FLSH_CNTL_EN);
120 static void guc_ggtt_invalidate(struct drm_i915_private *dev_priv)
122 gen6_ggtt_invalidate(dev_priv);
123 I915_WRITE(GEN8_GTCR, GEN8_GTCR_INVALIDATE);
126 static void gmch_ggtt_invalidate(struct drm_i915_private *dev_priv)
128 intel_gtt_chipset_flush();
131 static inline void i915_ggtt_invalidate(struct drm_i915_private *i915)
133 i915->ggtt.invalidate(i915);
136 static int ppgtt_bind_vma(struct i915_vma *vma,
137 enum i915_cache_level cache_level,
143 if (!(vma->flags & I915_VMA_LOCAL_BIND)) {
144 err = vma->vm->allocate_va_range(vma->vm,
145 vma->node.start, vma->size);
150 /* Applicable to VLV, and gen8+ */
152 if (i915_gem_object_is_readonly(vma->obj))
153 pte_flags |= PTE_READ_ONLY;
155 vma->vm->insert_entries(vma->vm, vma, cache_level, pte_flags);
160 static void ppgtt_unbind_vma(struct i915_vma *vma)
162 vma->vm->clear_range(vma->vm, vma->node.start, vma->size);
165 static int ppgtt_set_pages(struct i915_vma *vma)
167 GEM_BUG_ON(vma->pages);
169 vma->pages = vma->obj->mm.pages;
171 vma->page_sizes = vma->obj->mm.page_sizes;
176 static void clear_pages(struct i915_vma *vma)
178 GEM_BUG_ON(!vma->pages);
180 if (vma->pages != vma->obj->mm.pages) {
181 sg_free_table(vma->pages);
186 memset(&vma->page_sizes, 0, sizeof(vma->page_sizes));
189 static u64 gen8_pte_encode(dma_addr_t addr,
190 enum i915_cache_level level,
193 gen8_pte_t pte = addr | _PAGE_PRESENT | _PAGE_RW;
195 if (unlikely(flags & PTE_READ_ONLY))
199 case I915_CACHE_NONE:
200 pte |= PPAT_UNCACHED;
203 pte |= PPAT_DISPLAY_ELLC;
213 static gen8_pde_t gen8_pde_encode(const dma_addr_t addr,
214 const enum i915_cache_level level)
216 gen8_pde_t pde = _PAGE_PRESENT | _PAGE_RW;
218 if (level != I915_CACHE_NONE)
219 pde |= PPAT_CACHED_PDE;
221 pde |= PPAT_UNCACHED;
225 #define gen8_pdpe_encode gen8_pde_encode
226 #define gen8_pml4e_encode gen8_pde_encode
228 static u64 snb_pte_encode(dma_addr_t addr,
229 enum i915_cache_level level,
232 gen6_pte_t pte = GEN6_PTE_VALID;
233 pte |= GEN6_PTE_ADDR_ENCODE(addr);
236 case I915_CACHE_L3_LLC:
238 pte |= GEN6_PTE_CACHE_LLC;
240 case I915_CACHE_NONE:
241 pte |= GEN6_PTE_UNCACHED;
250 static u64 ivb_pte_encode(dma_addr_t addr,
251 enum i915_cache_level level,
254 gen6_pte_t pte = GEN6_PTE_VALID;
255 pte |= GEN6_PTE_ADDR_ENCODE(addr);
258 case I915_CACHE_L3_LLC:
259 pte |= GEN7_PTE_CACHE_L3_LLC;
262 pte |= GEN6_PTE_CACHE_LLC;
264 case I915_CACHE_NONE:
265 pte |= GEN6_PTE_UNCACHED;
274 static u64 byt_pte_encode(dma_addr_t addr,
275 enum i915_cache_level level,
278 gen6_pte_t pte = GEN6_PTE_VALID;
279 pte |= GEN6_PTE_ADDR_ENCODE(addr);
281 if (!(flags & PTE_READ_ONLY))
282 pte |= BYT_PTE_WRITEABLE;
284 if (level != I915_CACHE_NONE)
285 pte |= BYT_PTE_SNOOPED_BY_CPU_CACHES;
290 static u64 hsw_pte_encode(dma_addr_t addr,
291 enum i915_cache_level level,
294 gen6_pte_t pte = GEN6_PTE_VALID;
295 pte |= HSW_PTE_ADDR_ENCODE(addr);
297 if (level != I915_CACHE_NONE)
298 pte |= HSW_WB_LLC_AGE3;
303 static u64 iris_pte_encode(dma_addr_t addr,
304 enum i915_cache_level level,
307 gen6_pte_t pte = GEN6_PTE_VALID;
308 pte |= HSW_PTE_ADDR_ENCODE(addr);
311 case I915_CACHE_NONE:
314 pte |= HSW_WT_ELLC_LLC_AGE3;
317 pte |= HSW_WB_ELLC_LLC_AGE3;
324 static void stash_init(struct pagestash *stash)
326 pagevec_init(&stash->pvec);
327 spin_lock_init(&stash->lock);
330 static struct page *stash_pop_page(struct pagestash *stash)
332 struct page *page = NULL;
334 spin_lock(&stash->lock);
335 if (likely(stash->pvec.nr))
336 page = stash->pvec.pages[--stash->pvec.nr];
337 spin_unlock(&stash->lock);
342 static void stash_push_pagevec(struct pagestash *stash, struct pagevec *pvec)
346 spin_lock_nested(&stash->lock, SINGLE_DEPTH_NESTING);
348 nr = min_t(int, pvec->nr, pagevec_space(&stash->pvec));
349 memcpy(stash->pvec.pages + stash->pvec.nr,
350 pvec->pages + pvec->nr - nr,
351 sizeof(pvec->pages[0]) * nr);
352 stash->pvec.nr += nr;
354 spin_unlock(&stash->lock);
359 static struct page *vm_alloc_page(struct i915_address_space *vm, gfp_t gfp)
361 struct pagevec stack;
364 if (I915_SELFTEST_ONLY(should_fail(&vm->fault_attr, 1)))
365 i915_gem_shrink_all(vm->i915);
367 page = stash_pop_page(&vm->free_pages);
372 return alloc_page(gfp);
374 /* Look in our global stash of WC pages... */
375 page = stash_pop_page(&vm->i915->mm.wc_stash);
380 * Otherwise batch allocate pages to amortize cost of set_pages_wc.
382 * We have to be careful as page allocation may trigger the shrinker
383 * (via direct reclaim) which will fill up the WC stash underneath us.
384 * So we add our WB pages into a temporary pvec on the stack and merge
385 * them into the WC stash after all the allocations are complete.
387 pagevec_init(&stack);
391 page = alloc_page(gfp);
395 stack.pages[stack.nr++] = page;
396 } while (pagevec_space(&stack));
398 if (stack.nr && !set_pages_array_wc(stack.pages, stack.nr)) {
399 page = stack.pages[--stack.nr];
401 /* Merge spare WC pages to the global stash */
402 stash_push_pagevec(&vm->i915->mm.wc_stash, &stack);
404 /* Push any surplus WC pages onto the local VM stash */
406 stash_push_pagevec(&vm->free_pages, &stack);
409 /* Return unwanted leftovers */
410 if (unlikely(stack.nr)) {
411 WARN_ON_ONCE(set_pages_array_wb(stack.pages, stack.nr));
412 __pagevec_release(&stack);
418 static void vm_free_pages_release(struct i915_address_space *vm,
421 struct pagevec *pvec = &vm->free_pages.pvec;
422 struct pagevec stack;
424 lockdep_assert_held(&vm->free_pages.lock);
425 GEM_BUG_ON(!pagevec_count(pvec));
427 if (vm->pt_kmap_wc) {
429 * When we use WC, first fill up the global stash and then
430 * only if full immediately free the overflow.
432 stash_push_pagevec(&vm->i915->mm.wc_stash, pvec);
435 * As we have made some room in the VM's free_pages,
436 * we can wait for it to fill again. Unless we are
437 * inside i915_address_space_fini() and must
438 * immediately release the pages!
440 if (pvec->nr <= (immediate ? 0 : PAGEVEC_SIZE - 1))
444 * We have to drop the lock to allow ourselves to sleep,
445 * so take a copy of the pvec and clear the stash for
446 * others to use it as we sleep.
449 pagevec_reinit(pvec);
450 spin_unlock(&vm->free_pages.lock);
453 set_pages_array_wb(pvec->pages, pvec->nr);
455 spin_lock(&vm->free_pages.lock);
458 __pagevec_release(pvec);
461 static void vm_free_page(struct i915_address_space *vm, struct page *page)
464 * On !llc, we need to change the pages back to WB. We only do so
465 * in bulk, so we rarely need to change the page attributes here,
466 * but doing so requires a stop_machine() from deep inside arch/x86/mm.
467 * To make detection of the possible sleep more likely, use an
468 * unconditional might_sleep() for everybody.
471 spin_lock(&vm->free_pages.lock);
472 if (!pagevec_add(&vm->free_pages.pvec, page))
473 vm_free_pages_release(vm, false);
474 spin_unlock(&vm->free_pages.lock);
477 static void i915_address_space_init(struct i915_address_space *vm,
478 struct drm_i915_private *dev_priv)
481 * The vm->mutex must be reclaim safe (for use in the shrinker).
482 * Do a dummy acquire now under fs_reclaim so that any allocation
483 * attempt holding the lock is immediately reported by lockdep.
485 mutex_init(&vm->mutex);
486 i915_gem_shrinker_taints_mutex(&vm->mutex);
488 GEM_BUG_ON(!vm->total);
489 drm_mm_init(&vm->mm, 0, vm->total);
490 vm->mm.head_node.color = I915_COLOR_UNEVICTABLE;
492 stash_init(&vm->free_pages);
494 INIT_LIST_HEAD(&vm->active_list);
495 INIT_LIST_HEAD(&vm->inactive_list);
496 INIT_LIST_HEAD(&vm->unbound_list);
499 static void i915_address_space_fini(struct i915_address_space *vm)
501 spin_lock(&vm->free_pages.lock);
502 if (pagevec_count(&vm->free_pages.pvec))
503 vm_free_pages_release(vm, true);
504 GEM_BUG_ON(pagevec_count(&vm->free_pages.pvec));
505 spin_unlock(&vm->free_pages.lock);
507 drm_mm_takedown(&vm->mm);
509 mutex_destroy(&vm->mutex);
512 static int __setup_page_dma(struct i915_address_space *vm,
513 struct i915_page_dma *p,
516 p->page = vm_alloc_page(vm, gfp | I915_GFP_ALLOW_FAIL);
517 if (unlikely(!p->page))
520 p->daddr = dma_map_page_attrs(vm->dma,
521 p->page, 0, PAGE_SIZE,
522 PCI_DMA_BIDIRECTIONAL,
523 DMA_ATTR_SKIP_CPU_SYNC |
525 if (unlikely(dma_mapping_error(vm->dma, p->daddr))) {
526 vm_free_page(vm, p->page);
533 static int setup_page_dma(struct i915_address_space *vm,
534 struct i915_page_dma *p)
536 return __setup_page_dma(vm, p, __GFP_HIGHMEM);
539 static void cleanup_page_dma(struct i915_address_space *vm,
540 struct i915_page_dma *p)
542 dma_unmap_page(vm->dma, p->daddr, PAGE_SIZE, PCI_DMA_BIDIRECTIONAL);
543 vm_free_page(vm, p->page);
546 #define kmap_atomic_px(px) kmap_atomic(px_base(px)->page)
548 #define setup_px(vm, px) setup_page_dma((vm), px_base(px))
549 #define cleanup_px(vm, px) cleanup_page_dma((vm), px_base(px))
550 #define fill_px(vm, px, v) fill_page_dma((vm), px_base(px), (v))
551 #define fill32_px(vm, px, v) fill_page_dma_32((vm), px_base(px), (v))
553 static void fill_page_dma(struct i915_address_space *vm,
554 struct i915_page_dma *p,
557 u64 * const vaddr = kmap_atomic(p->page);
559 memset64(vaddr, val, PAGE_SIZE / sizeof(val));
561 kunmap_atomic(vaddr);
564 static void fill_page_dma_32(struct i915_address_space *vm,
565 struct i915_page_dma *p,
568 fill_page_dma(vm, p, (u64)v << 32 | v);
572 setup_scratch_page(struct i915_address_space *vm, gfp_t gfp)
577 * In order to utilize 64K pages for an object with a size < 2M, we will
578 * need to support a 64K scratch page, given that every 16th entry for a
579 * page-table operating in 64K mode must point to a properly aligned 64K
580 * region, including any PTEs which happen to point to scratch.
582 * This is only relevant for the 48b PPGTT where we support
583 * huge-gtt-pages, see also i915_vma_insert(). However, as we share the
584 * scratch (read-only) between all vm, we create one 64k scratch page
587 size = I915_GTT_PAGE_SIZE_4K;
588 if (i915_vm_is_48bit(vm) &&
589 HAS_PAGE_SIZES(vm->i915, I915_GTT_PAGE_SIZE_64K)) {
590 size = I915_GTT_PAGE_SIZE_64K;
593 gfp |= __GFP_ZERO | __GFP_RETRY_MAYFAIL;
596 int order = get_order(size);
600 page = alloc_pages(gfp, order);
604 addr = dma_map_page_attrs(vm->dma,
606 PCI_DMA_BIDIRECTIONAL,
607 DMA_ATTR_SKIP_CPU_SYNC |
609 if (unlikely(dma_mapping_error(vm->dma, addr)))
612 if (unlikely(!IS_ALIGNED(addr, size)))
615 vm->scratch_page.page = page;
616 vm->scratch_page.daddr = addr;
617 vm->scratch_page.order = order;
621 dma_unmap_page(vm->dma, addr, size, PCI_DMA_BIDIRECTIONAL);
623 __free_pages(page, order);
625 if (size == I915_GTT_PAGE_SIZE_4K)
628 size = I915_GTT_PAGE_SIZE_4K;
629 gfp &= ~__GFP_NOWARN;
633 static void cleanup_scratch_page(struct i915_address_space *vm)
635 struct i915_page_dma *p = &vm->scratch_page;
637 dma_unmap_page(vm->dma, p->daddr, BIT(p->order) << PAGE_SHIFT,
638 PCI_DMA_BIDIRECTIONAL);
639 __free_pages(p->page, p->order);
642 static struct i915_page_table *alloc_pt(struct i915_address_space *vm)
644 struct i915_page_table *pt;
646 pt = kmalloc(sizeof(*pt), I915_GFP_ALLOW_FAIL);
648 return ERR_PTR(-ENOMEM);
650 if (unlikely(setup_px(vm, pt))) {
652 return ERR_PTR(-ENOMEM);
659 static void free_pt(struct i915_address_space *vm, struct i915_page_table *pt)
665 static void gen8_initialize_pt(struct i915_address_space *vm,
666 struct i915_page_table *pt)
668 fill_px(vm, pt, vm->scratch_pte);
671 static void gen6_initialize_pt(struct i915_address_space *vm,
672 struct i915_page_table *pt)
674 fill32_px(vm, pt, vm->scratch_pte);
677 static struct i915_page_directory *alloc_pd(struct i915_address_space *vm)
679 struct i915_page_directory *pd;
681 pd = kzalloc(sizeof(*pd), I915_GFP_ALLOW_FAIL);
683 return ERR_PTR(-ENOMEM);
685 if (unlikely(setup_px(vm, pd))) {
687 return ERR_PTR(-ENOMEM);
694 static void free_pd(struct i915_address_space *vm,
695 struct i915_page_directory *pd)
701 static void gen8_initialize_pd(struct i915_address_space *vm,
702 struct i915_page_directory *pd)
705 gen8_pde_encode(px_dma(vm->scratch_pt), I915_CACHE_LLC));
706 memset_p((void **)pd->page_table, vm->scratch_pt, I915_PDES);
709 static int __pdp_init(struct i915_address_space *vm,
710 struct i915_page_directory_pointer *pdp)
712 const unsigned int pdpes = i915_pdpes_per_pdp(vm);
714 pdp->page_directory = kmalloc_array(pdpes, sizeof(*pdp->page_directory),
715 I915_GFP_ALLOW_FAIL);
716 if (unlikely(!pdp->page_directory))
719 memset_p((void **)pdp->page_directory, vm->scratch_pd, pdpes);
724 static void __pdp_fini(struct i915_page_directory_pointer *pdp)
726 kfree(pdp->page_directory);
727 pdp->page_directory = NULL;
730 static inline bool use_4lvl(const struct i915_address_space *vm)
732 return i915_vm_is_48bit(vm);
735 static struct i915_page_directory_pointer *
736 alloc_pdp(struct i915_address_space *vm)
738 struct i915_page_directory_pointer *pdp;
741 GEM_BUG_ON(!use_4lvl(vm));
743 pdp = kzalloc(sizeof(*pdp), GFP_KERNEL);
745 return ERR_PTR(-ENOMEM);
747 ret = __pdp_init(vm, pdp);
751 ret = setup_px(vm, pdp);
765 static void free_pdp(struct i915_address_space *vm,
766 struct i915_page_directory_pointer *pdp)
777 static void gen8_initialize_pdp(struct i915_address_space *vm,
778 struct i915_page_directory_pointer *pdp)
780 gen8_ppgtt_pdpe_t scratch_pdpe;
782 scratch_pdpe = gen8_pdpe_encode(px_dma(vm->scratch_pd), I915_CACHE_LLC);
784 fill_px(vm, pdp, scratch_pdpe);
787 static void gen8_initialize_pml4(struct i915_address_space *vm,
788 struct i915_pml4 *pml4)
791 gen8_pml4e_encode(px_dma(vm->scratch_pdp), I915_CACHE_LLC));
792 memset_p((void **)pml4->pdps, vm->scratch_pdp, GEN8_PML4ES_PER_PML4);
795 /* PDE TLBs are a pain to invalidate on GEN8+. When we modify
796 * the page table structures, we mark them dirty so that
797 * context switching/execlist queuing code takes extra steps
798 * to ensure that tlbs are flushed.
800 static void mark_tlbs_dirty(struct i915_hw_ppgtt *ppgtt)
802 ppgtt->pd_dirty_rings = INTEL_INFO(ppgtt->vm.i915)->ring_mask;
805 /* Removes entries from a single page table, releasing it if it's empty.
806 * Caller can use the return value to update higher-level entries.
808 static bool gen8_ppgtt_clear_pt(const struct i915_address_space *vm,
809 struct i915_page_table *pt,
810 u64 start, u64 length)
812 unsigned int num_entries = gen8_pte_count(start, length);
813 unsigned int pte = gen8_pte_index(start);
814 unsigned int pte_end = pte + num_entries;
817 GEM_BUG_ON(num_entries > pt->used_ptes);
819 pt->used_ptes -= num_entries;
823 vaddr = kmap_atomic_px(pt);
824 while (pte < pte_end)
825 vaddr[pte++] = vm->scratch_pte;
826 kunmap_atomic(vaddr);
831 static void gen8_ppgtt_set_pde(struct i915_address_space *vm,
832 struct i915_page_directory *pd,
833 struct i915_page_table *pt,
838 pd->page_table[pde] = pt;
840 vaddr = kmap_atomic_px(pd);
841 vaddr[pde] = gen8_pde_encode(px_dma(pt), I915_CACHE_LLC);
842 kunmap_atomic(vaddr);
845 static bool gen8_ppgtt_clear_pd(struct i915_address_space *vm,
846 struct i915_page_directory *pd,
847 u64 start, u64 length)
849 struct i915_page_table *pt;
852 gen8_for_each_pde(pt, pd, start, length, pde) {
853 GEM_BUG_ON(pt == vm->scratch_pt);
855 if (!gen8_ppgtt_clear_pt(vm, pt, start, length))
858 gen8_ppgtt_set_pde(vm, pd, vm->scratch_pt, pde);
859 GEM_BUG_ON(!pd->used_pdes);
865 return !pd->used_pdes;
868 static void gen8_ppgtt_set_pdpe(struct i915_address_space *vm,
869 struct i915_page_directory_pointer *pdp,
870 struct i915_page_directory *pd,
873 gen8_ppgtt_pdpe_t *vaddr;
875 pdp->page_directory[pdpe] = pd;
879 vaddr = kmap_atomic_px(pdp);
880 vaddr[pdpe] = gen8_pdpe_encode(px_dma(pd), I915_CACHE_LLC);
881 kunmap_atomic(vaddr);
884 /* Removes entries from a single page dir pointer, releasing it if it's empty.
885 * Caller can use the return value to update higher-level entries
887 static bool gen8_ppgtt_clear_pdp(struct i915_address_space *vm,
888 struct i915_page_directory_pointer *pdp,
889 u64 start, u64 length)
891 struct i915_page_directory *pd;
894 gen8_for_each_pdpe(pd, pdp, start, length, pdpe) {
895 GEM_BUG_ON(pd == vm->scratch_pd);
897 if (!gen8_ppgtt_clear_pd(vm, pd, start, length))
900 gen8_ppgtt_set_pdpe(vm, pdp, vm->scratch_pd, pdpe);
901 GEM_BUG_ON(!pdp->used_pdpes);
907 return !pdp->used_pdpes;
910 static void gen8_ppgtt_clear_3lvl(struct i915_address_space *vm,
911 u64 start, u64 length)
913 gen8_ppgtt_clear_pdp(vm, &i915_vm_to_ppgtt(vm)->pdp, start, length);
916 static void gen8_ppgtt_set_pml4e(struct i915_pml4 *pml4,
917 struct i915_page_directory_pointer *pdp,
920 gen8_ppgtt_pml4e_t *vaddr;
922 pml4->pdps[pml4e] = pdp;
924 vaddr = kmap_atomic_px(pml4);
925 vaddr[pml4e] = gen8_pml4e_encode(px_dma(pdp), I915_CACHE_LLC);
926 kunmap_atomic(vaddr);
929 /* Removes entries from a single pml4.
930 * This is the top-level structure in 4-level page tables used on gen8+.
931 * Empty entries are always scratch pml4e.
933 static void gen8_ppgtt_clear_4lvl(struct i915_address_space *vm,
934 u64 start, u64 length)
936 struct i915_hw_ppgtt *ppgtt = i915_vm_to_ppgtt(vm);
937 struct i915_pml4 *pml4 = &ppgtt->pml4;
938 struct i915_page_directory_pointer *pdp;
941 GEM_BUG_ON(!use_4lvl(vm));
943 gen8_for_each_pml4e(pdp, pml4, start, length, pml4e) {
944 GEM_BUG_ON(pdp == vm->scratch_pdp);
946 if (!gen8_ppgtt_clear_pdp(vm, pdp, start, length))
949 gen8_ppgtt_set_pml4e(pml4, vm->scratch_pdp, pml4e);
955 static inline struct sgt_dma {
956 struct scatterlist *sg;
958 } sgt_dma(struct i915_vma *vma) {
959 struct scatterlist *sg = vma->pages->sgl;
960 dma_addr_t addr = sg_dma_address(sg);
961 return (struct sgt_dma) { sg, addr, addr + sg->length };
964 struct gen8_insert_pte {
971 static __always_inline struct gen8_insert_pte gen8_insert_pte(u64 start)
973 return (struct gen8_insert_pte) {
974 gen8_pml4e_index(start),
975 gen8_pdpe_index(start),
976 gen8_pde_index(start),
977 gen8_pte_index(start),
981 static __always_inline bool
982 gen8_ppgtt_insert_pte_entries(struct i915_hw_ppgtt *ppgtt,
983 struct i915_page_directory_pointer *pdp,
984 struct sgt_dma *iter,
985 struct gen8_insert_pte *idx,
986 enum i915_cache_level cache_level,
989 struct i915_page_directory *pd;
990 const gen8_pte_t pte_encode = gen8_pte_encode(0, cache_level, flags);
994 GEM_BUG_ON(idx->pdpe >= i915_pdpes_per_pdp(&ppgtt->vm));
995 pd = pdp->page_directory[idx->pdpe];
996 vaddr = kmap_atomic_px(pd->page_table[idx->pde]);
998 vaddr[idx->pte] = pte_encode | iter->dma;
1000 iter->dma += I915_GTT_PAGE_SIZE;
1001 if (iter->dma >= iter->max) {
1002 iter->sg = __sg_next(iter->sg);
1008 iter->dma = sg_dma_address(iter->sg);
1009 iter->max = iter->dma + iter->sg->length;
1012 if (++idx->pte == GEN8_PTES) {
1015 if (++idx->pde == I915_PDES) {
1018 /* Limited by sg length for 3lvl */
1019 if (++idx->pdpe == GEN8_PML4ES_PER_PML4) {
1025 GEM_BUG_ON(idx->pdpe >= i915_pdpes_per_pdp(&ppgtt->vm));
1026 pd = pdp->page_directory[idx->pdpe];
1029 kunmap_atomic(vaddr);
1030 vaddr = kmap_atomic_px(pd->page_table[idx->pde]);
1033 kunmap_atomic(vaddr);
1038 static void gen8_ppgtt_insert_3lvl(struct i915_address_space *vm,
1039 struct i915_vma *vma,
1040 enum i915_cache_level cache_level,
1043 struct i915_hw_ppgtt *ppgtt = i915_vm_to_ppgtt(vm);
1044 struct sgt_dma iter = sgt_dma(vma);
1045 struct gen8_insert_pte idx = gen8_insert_pte(vma->node.start);
1047 gen8_ppgtt_insert_pte_entries(ppgtt, &ppgtt->pdp, &iter, &idx,
1048 cache_level, flags);
1050 vma->page_sizes.gtt = I915_GTT_PAGE_SIZE;
1053 static void gen8_ppgtt_insert_huge_entries(struct i915_vma *vma,
1054 struct i915_page_directory_pointer **pdps,
1055 struct sgt_dma *iter,
1056 enum i915_cache_level cache_level,
1059 const gen8_pte_t pte_encode = gen8_pte_encode(0, cache_level, flags);
1060 u64 start = vma->node.start;
1061 dma_addr_t rem = iter->sg->length;
1064 struct gen8_insert_pte idx = gen8_insert_pte(start);
1065 struct i915_page_directory_pointer *pdp = pdps[idx.pml4e];
1066 struct i915_page_directory *pd = pdp->page_directory[idx.pdpe];
1067 unsigned int page_size;
1068 bool maybe_64K = false;
1069 gen8_pte_t encode = pte_encode;
1073 if (vma->page_sizes.sg & I915_GTT_PAGE_SIZE_2M &&
1074 IS_ALIGNED(iter->dma, I915_GTT_PAGE_SIZE_2M) &&
1075 rem >= I915_GTT_PAGE_SIZE_2M && !idx.pte) {
1078 page_size = I915_GTT_PAGE_SIZE_2M;
1080 encode |= GEN8_PDE_PS_2M;
1082 vaddr = kmap_atomic_px(pd);
1084 struct i915_page_table *pt = pd->page_table[idx.pde];
1088 page_size = I915_GTT_PAGE_SIZE;
1091 vma->page_sizes.sg & I915_GTT_PAGE_SIZE_64K &&
1092 IS_ALIGNED(iter->dma, I915_GTT_PAGE_SIZE_64K) &&
1093 (IS_ALIGNED(rem, I915_GTT_PAGE_SIZE_64K) ||
1094 rem >= (max - index) * I915_GTT_PAGE_SIZE))
1097 vaddr = kmap_atomic_px(pt);
1101 GEM_BUG_ON(iter->sg->length < page_size);
1102 vaddr[index++] = encode | iter->dma;
1105 iter->dma += page_size;
1107 if (iter->dma >= iter->max) {
1108 iter->sg = __sg_next(iter->sg);
1112 rem = iter->sg->length;
1113 iter->dma = sg_dma_address(iter->sg);
1114 iter->max = iter->dma + rem;
1116 if (maybe_64K && index < max &&
1117 !(IS_ALIGNED(iter->dma, I915_GTT_PAGE_SIZE_64K) &&
1118 (IS_ALIGNED(rem, I915_GTT_PAGE_SIZE_64K) ||
1119 rem >= (max - index) * I915_GTT_PAGE_SIZE)))
1122 if (unlikely(!IS_ALIGNED(iter->dma, page_size)))
1125 } while (rem >= page_size && index < max);
1127 kunmap_atomic(vaddr);
1130 * Is it safe to mark the 2M block as 64K? -- Either we have
1131 * filled whole page-table with 64K entries, or filled part of
1132 * it and have reached the end of the sg table and we have
1137 (i915_vm_has_scratch_64K(vma->vm) &&
1138 !iter->sg && IS_ALIGNED(vma->node.start +
1140 I915_GTT_PAGE_SIZE_2M)))) {
1141 vaddr = kmap_atomic_px(pd);
1142 vaddr[idx.pde] |= GEN8_PDE_IPS_64K;
1143 kunmap_atomic(vaddr);
1144 page_size = I915_GTT_PAGE_SIZE_64K;
1147 * We write all 4K page entries, even when using 64K
1148 * pages. In order to verify that the HW isn't cheating
1149 * by using the 4K PTE instead of the 64K PTE, we want
1150 * to remove all the surplus entries. If the HW skipped
1151 * the 64K PTE, it will read/write into the scratch page
1152 * instead - which we detect as missing results during
1155 if (I915_SELFTEST_ONLY(vma->vm->scrub_64K)) {
1158 encode = vma->vm->scratch_pte;
1159 vaddr = kmap_atomic_px(pd->page_table[idx.pde]);
1161 for (i = 1; i < index; i += 16)
1162 memset64(vaddr + i, encode, 15);
1164 kunmap_atomic(vaddr);
1168 vma->page_sizes.gtt |= page_size;
1172 static void gen8_ppgtt_insert_4lvl(struct i915_address_space *vm,
1173 struct i915_vma *vma,
1174 enum i915_cache_level cache_level,
1177 struct i915_hw_ppgtt *ppgtt = i915_vm_to_ppgtt(vm);
1178 struct sgt_dma iter = sgt_dma(vma);
1179 struct i915_page_directory_pointer **pdps = ppgtt->pml4.pdps;
1181 if (vma->page_sizes.sg > I915_GTT_PAGE_SIZE) {
1182 gen8_ppgtt_insert_huge_entries(vma, pdps, &iter, cache_level,
1185 struct gen8_insert_pte idx = gen8_insert_pte(vma->node.start);
1187 while (gen8_ppgtt_insert_pte_entries(ppgtt, pdps[idx.pml4e++],
1188 &iter, &idx, cache_level,
1190 GEM_BUG_ON(idx.pml4e >= GEN8_PML4ES_PER_PML4);
1192 vma->page_sizes.gtt = I915_GTT_PAGE_SIZE;
1196 static void gen8_free_page_tables(struct i915_address_space *vm,
1197 struct i915_page_directory *pd)
1201 for (i = 0; i < I915_PDES; i++) {
1202 if (pd->page_table[i] != vm->scratch_pt)
1203 free_pt(vm, pd->page_table[i]);
1207 static int gen8_init_scratch(struct i915_address_space *vm)
1212 * If everybody agrees to not to write into the scratch page,
1213 * we can reuse it for all vm, keeping contexts and processes separate.
1215 if (vm->has_read_only &&
1216 vm->i915->kernel_context &&
1217 vm->i915->kernel_context->ppgtt) {
1218 struct i915_address_space *clone =
1219 &vm->i915->kernel_context->ppgtt->vm;
1221 GEM_BUG_ON(!clone->has_read_only);
1223 vm->scratch_page.order = clone->scratch_page.order;
1224 vm->scratch_pte = clone->scratch_pte;
1225 vm->scratch_pt = clone->scratch_pt;
1226 vm->scratch_pd = clone->scratch_pd;
1227 vm->scratch_pdp = clone->scratch_pdp;
1231 ret = setup_scratch_page(vm, __GFP_HIGHMEM);
1236 gen8_pte_encode(vm->scratch_page.daddr,
1240 vm->scratch_pt = alloc_pt(vm);
1241 if (IS_ERR(vm->scratch_pt)) {
1242 ret = PTR_ERR(vm->scratch_pt);
1243 goto free_scratch_page;
1246 vm->scratch_pd = alloc_pd(vm);
1247 if (IS_ERR(vm->scratch_pd)) {
1248 ret = PTR_ERR(vm->scratch_pd);
1253 vm->scratch_pdp = alloc_pdp(vm);
1254 if (IS_ERR(vm->scratch_pdp)) {
1255 ret = PTR_ERR(vm->scratch_pdp);
1260 gen8_initialize_pt(vm, vm->scratch_pt);
1261 gen8_initialize_pd(vm, vm->scratch_pd);
1263 gen8_initialize_pdp(vm, vm->scratch_pdp);
1268 free_pd(vm, vm->scratch_pd);
1270 free_pt(vm, vm->scratch_pt);
1272 cleanup_scratch_page(vm);
1277 static int gen8_ppgtt_notify_vgt(struct i915_hw_ppgtt *ppgtt, bool create)
1279 struct i915_address_space *vm = &ppgtt->vm;
1280 struct drm_i915_private *dev_priv = vm->i915;
1281 enum vgt_g2v_type msg;
1285 const u64 daddr = px_dma(&ppgtt->pml4);
1287 I915_WRITE(vgtif_reg(pdp[0].lo), lower_32_bits(daddr));
1288 I915_WRITE(vgtif_reg(pdp[0].hi), upper_32_bits(daddr));
1290 msg = (create ? VGT_G2V_PPGTT_L4_PAGE_TABLE_CREATE :
1291 VGT_G2V_PPGTT_L4_PAGE_TABLE_DESTROY);
1293 for (i = 0; i < GEN8_3LVL_PDPES; i++) {
1294 const u64 daddr = i915_page_dir_dma_addr(ppgtt, i);
1296 I915_WRITE(vgtif_reg(pdp[i].lo), lower_32_bits(daddr));
1297 I915_WRITE(vgtif_reg(pdp[i].hi), upper_32_bits(daddr));
1300 msg = (create ? VGT_G2V_PPGTT_L3_PAGE_TABLE_CREATE :
1301 VGT_G2V_PPGTT_L3_PAGE_TABLE_DESTROY);
1304 I915_WRITE(vgtif_reg(g2v_notify), msg);
1309 static void gen8_free_scratch(struct i915_address_space *vm)
1311 if (!vm->scratch_page.daddr)
1315 free_pdp(vm, vm->scratch_pdp);
1316 free_pd(vm, vm->scratch_pd);
1317 free_pt(vm, vm->scratch_pt);
1318 cleanup_scratch_page(vm);
1321 static void gen8_ppgtt_cleanup_3lvl(struct i915_address_space *vm,
1322 struct i915_page_directory_pointer *pdp)
1324 const unsigned int pdpes = i915_pdpes_per_pdp(vm);
1327 for (i = 0; i < pdpes; i++) {
1328 if (pdp->page_directory[i] == vm->scratch_pd)
1331 gen8_free_page_tables(vm, pdp->page_directory[i]);
1332 free_pd(vm, pdp->page_directory[i]);
1338 static void gen8_ppgtt_cleanup_4lvl(struct i915_hw_ppgtt *ppgtt)
1342 for (i = 0; i < GEN8_PML4ES_PER_PML4; i++) {
1343 if (ppgtt->pml4.pdps[i] == ppgtt->vm.scratch_pdp)
1346 gen8_ppgtt_cleanup_3lvl(&ppgtt->vm, ppgtt->pml4.pdps[i]);
1349 cleanup_px(&ppgtt->vm, &ppgtt->pml4);
1352 static void gen8_ppgtt_cleanup(struct i915_address_space *vm)
1354 struct drm_i915_private *dev_priv = vm->i915;
1355 struct i915_hw_ppgtt *ppgtt = i915_vm_to_ppgtt(vm);
1357 if (intel_vgpu_active(dev_priv))
1358 gen8_ppgtt_notify_vgt(ppgtt, false);
1361 gen8_ppgtt_cleanup_4lvl(ppgtt);
1363 gen8_ppgtt_cleanup_3lvl(&ppgtt->vm, &ppgtt->pdp);
1365 gen8_free_scratch(vm);
1368 static int gen8_ppgtt_alloc_pd(struct i915_address_space *vm,
1369 struct i915_page_directory *pd,
1370 u64 start, u64 length)
1372 struct i915_page_table *pt;
1376 gen8_for_each_pde(pt, pd, start, length, pde) {
1377 int count = gen8_pte_count(start, length);
1379 if (pt == vm->scratch_pt) {
1388 if (count < GEN8_PTES || intel_vgpu_active(vm->i915))
1389 gen8_initialize_pt(vm, pt);
1391 gen8_ppgtt_set_pde(vm, pd, pt, pde);
1392 GEM_BUG_ON(pd->used_pdes > I915_PDES);
1395 pt->used_ptes += count;
1400 gen8_ppgtt_clear_pd(vm, pd, from, start - from);
1404 static int gen8_ppgtt_alloc_pdp(struct i915_address_space *vm,
1405 struct i915_page_directory_pointer *pdp,
1406 u64 start, u64 length)
1408 struct i915_page_directory *pd;
1413 gen8_for_each_pdpe(pd, pdp, start, length, pdpe) {
1414 if (pd == vm->scratch_pd) {
1423 gen8_initialize_pd(vm, pd);
1424 gen8_ppgtt_set_pdpe(vm, pdp, pd, pdpe);
1425 GEM_BUG_ON(pdp->used_pdpes > i915_pdpes_per_pdp(vm));
1427 mark_tlbs_dirty(i915_vm_to_ppgtt(vm));
1430 ret = gen8_ppgtt_alloc_pd(vm, pd, start, length);
1438 if (!pd->used_pdes) {
1439 gen8_ppgtt_set_pdpe(vm, pdp, vm->scratch_pd, pdpe);
1440 GEM_BUG_ON(!pdp->used_pdpes);
1445 gen8_ppgtt_clear_pdp(vm, pdp, from, start - from);
1449 static int gen8_ppgtt_alloc_3lvl(struct i915_address_space *vm,
1450 u64 start, u64 length)
1452 return gen8_ppgtt_alloc_pdp(vm,
1453 &i915_vm_to_ppgtt(vm)->pdp, start, length);
1456 static int gen8_ppgtt_alloc_4lvl(struct i915_address_space *vm,
1457 u64 start, u64 length)
1459 struct i915_hw_ppgtt *ppgtt = i915_vm_to_ppgtt(vm);
1460 struct i915_pml4 *pml4 = &ppgtt->pml4;
1461 struct i915_page_directory_pointer *pdp;
1466 gen8_for_each_pml4e(pdp, pml4, start, length, pml4e) {
1467 if (pml4->pdps[pml4e] == vm->scratch_pdp) {
1468 pdp = alloc_pdp(vm);
1472 gen8_initialize_pdp(vm, pdp);
1473 gen8_ppgtt_set_pml4e(pml4, pdp, pml4e);
1476 ret = gen8_ppgtt_alloc_pdp(vm, pdp, start, length);
1484 if (!pdp->used_pdpes) {
1485 gen8_ppgtt_set_pml4e(pml4, vm->scratch_pdp, pml4e);
1489 gen8_ppgtt_clear_4lvl(vm, from, start - from);
1493 static void gen8_dump_pdp(struct i915_hw_ppgtt *ppgtt,
1494 struct i915_page_directory_pointer *pdp,
1495 u64 start, u64 length,
1496 gen8_pte_t scratch_pte,
1499 struct i915_address_space *vm = &ppgtt->vm;
1500 struct i915_page_directory *pd;
1503 gen8_for_each_pdpe(pd, pdp, start, length, pdpe) {
1504 struct i915_page_table *pt;
1505 u64 pd_len = length;
1506 u64 pd_start = start;
1509 if (pdp->page_directory[pdpe] == ppgtt->vm.scratch_pd)
1512 seq_printf(m, "\tPDPE #%d\n", pdpe);
1513 gen8_for_each_pde(pt, pd, pd_start, pd_len, pde) {
1515 gen8_pte_t *pt_vaddr;
1517 if (pd->page_table[pde] == ppgtt->vm.scratch_pt)
1520 pt_vaddr = kmap_atomic_px(pt);
1521 for (pte = 0; pte < GEN8_PTES; pte += 4) {
1522 u64 va = (pdpe << GEN8_PDPE_SHIFT |
1523 pde << GEN8_PDE_SHIFT |
1524 pte << GEN8_PTE_SHIFT);
1528 for (i = 0; i < 4; i++)
1529 if (pt_vaddr[pte + i] != scratch_pte)
1534 seq_printf(m, "\t\t0x%llx [%03d,%03d,%04d]: =", va, pdpe, pde, pte);
1535 for (i = 0; i < 4; i++) {
1536 if (pt_vaddr[pte + i] != scratch_pte)
1537 seq_printf(m, " %llx", pt_vaddr[pte + i]);
1539 seq_puts(m, " SCRATCH ");
1543 kunmap_atomic(pt_vaddr);
1548 static void gen8_dump_ppgtt(struct i915_hw_ppgtt *ppgtt, struct seq_file *m)
1550 struct i915_address_space *vm = &ppgtt->vm;
1551 const gen8_pte_t scratch_pte = vm->scratch_pte;
1552 u64 start = 0, length = ppgtt->vm.total;
1556 struct i915_pml4 *pml4 = &ppgtt->pml4;
1557 struct i915_page_directory_pointer *pdp;
1559 gen8_for_each_pml4e(pdp, pml4, start, length, pml4e) {
1560 if (pml4->pdps[pml4e] == ppgtt->vm.scratch_pdp)
1563 seq_printf(m, " PML4E #%llu\n", pml4e);
1564 gen8_dump_pdp(ppgtt, pdp, start, length, scratch_pte, m);
1567 gen8_dump_pdp(ppgtt, &ppgtt->pdp, start, length, scratch_pte, m);
1571 static int gen8_preallocate_top_level_pdp(struct i915_hw_ppgtt *ppgtt)
1573 struct i915_address_space *vm = &ppgtt->vm;
1574 struct i915_page_directory_pointer *pdp = &ppgtt->pdp;
1575 struct i915_page_directory *pd;
1576 u64 start = 0, length = ppgtt->vm.total;
1580 gen8_for_each_pdpe(pd, pdp, start, length, pdpe) {
1585 gen8_initialize_pd(vm, pd);
1586 gen8_ppgtt_set_pdpe(vm, pdp, pd, pdpe);
1590 pdp->used_pdpes++; /* never remove */
1595 gen8_for_each_pdpe(pd, pdp, from, start, pdpe) {
1596 gen8_ppgtt_set_pdpe(vm, pdp, vm->scratch_pd, pdpe);
1599 pdp->used_pdpes = 0;
1604 * GEN8 legacy ppgtt programming is accomplished through a max 4 PDP registers
1605 * with a net effect resembling a 2-level page table in normal x86 terms. Each
1606 * PDP represents 1GB of memory 4 * 512 * 512 * 4096 = 4GB legacy 32b address
1610 static struct i915_hw_ppgtt *gen8_ppgtt_create(struct drm_i915_private *i915)
1612 struct i915_hw_ppgtt *ppgtt;
1615 ppgtt = kzalloc(sizeof(*ppgtt), GFP_KERNEL);
1617 return ERR_PTR(-ENOMEM);
1619 kref_init(&ppgtt->ref);
1621 ppgtt->vm.i915 = i915;
1622 ppgtt->vm.dma = &i915->drm.pdev->dev;
1624 ppgtt->vm.total = HAS_FULL_48BIT_PPGTT(i915) ?
1628 /* From bdw, there is support for read-only pages in the PPGTT. */
1629 ppgtt->vm.has_read_only = true;
1631 i915_address_space_init(&ppgtt->vm, i915);
1633 /* There are only few exceptions for gen >=6. chv and bxt.
1634 * And we are not sure about the latter so play safe for now.
1636 if (IS_CHERRYVIEW(i915) || IS_BROXTON(i915))
1637 ppgtt->vm.pt_kmap_wc = true;
1639 err = gen8_init_scratch(&ppgtt->vm);
1643 if (use_4lvl(&ppgtt->vm)) {
1644 err = setup_px(&ppgtt->vm, &ppgtt->pml4);
1648 gen8_initialize_pml4(&ppgtt->vm, &ppgtt->pml4);
1650 ppgtt->vm.allocate_va_range = gen8_ppgtt_alloc_4lvl;
1651 ppgtt->vm.insert_entries = gen8_ppgtt_insert_4lvl;
1652 ppgtt->vm.clear_range = gen8_ppgtt_clear_4lvl;
1654 err = __pdp_init(&ppgtt->vm, &ppgtt->pdp);
1658 if (intel_vgpu_active(i915)) {
1659 err = gen8_preallocate_top_level_pdp(ppgtt);
1661 __pdp_fini(&ppgtt->pdp);
1666 ppgtt->vm.allocate_va_range = gen8_ppgtt_alloc_3lvl;
1667 ppgtt->vm.insert_entries = gen8_ppgtt_insert_3lvl;
1668 ppgtt->vm.clear_range = gen8_ppgtt_clear_3lvl;
1671 if (intel_vgpu_active(i915))
1672 gen8_ppgtt_notify_vgt(ppgtt, true);
1674 ppgtt->vm.cleanup = gen8_ppgtt_cleanup;
1675 ppgtt->debug_dump = gen8_dump_ppgtt;
1677 ppgtt->vm.vma_ops.bind_vma = ppgtt_bind_vma;
1678 ppgtt->vm.vma_ops.unbind_vma = ppgtt_unbind_vma;
1679 ppgtt->vm.vma_ops.set_pages = ppgtt_set_pages;
1680 ppgtt->vm.vma_ops.clear_pages = clear_pages;
1685 gen8_free_scratch(&ppgtt->vm);
1688 return ERR_PTR(err);
1691 static void gen6_dump_ppgtt(struct i915_hw_ppgtt *base, struct seq_file *m)
1693 struct gen6_hw_ppgtt *ppgtt = to_gen6_ppgtt(base);
1694 const gen6_pte_t scratch_pte = base->vm.scratch_pte;
1695 struct i915_page_table *pt;
1698 gen6_for_all_pdes(pt, &base->pd, pde) {
1701 if (pt == base->vm.scratch_pt)
1704 if (i915_vma_is_bound(ppgtt->vma, I915_VMA_GLOBAL_BIND)) {
1706 GEN6_PDE_ADDR_ENCODE(px_dma(pt)) |
1708 u32 pd_entry = readl(ppgtt->pd_addr + pde);
1710 if (pd_entry != expected)
1712 "\tPDE #%d mismatch: Actual PDE: %x Expected PDE: %x\n",
1717 seq_printf(m, "\tPDE: %x\n", pd_entry);
1720 vaddr = kmap_atomic_px(base->pd.page_table[pde]);
1721 for (pte = 0; pte < GEN6_PTES; pte += 4) {
1724 for (i = 0; i < 4; i++)
1725 if (vaddr[pte + i] != scratch_pte)
1730 seq_printf(m, "\t\t(%03d, %04d) %08llx: ",
1732 (pde * GEN6_PTES + pte) * I915_GTT_PAGE_SIZE);
1733 for (i = 0; i < 4; i++) {
1734 if (vaddr[pte + i] != scratch_pte)
1735 seq_printf(m, " %08x", vaddr[pte + i]);
1737 seq_puts(m, " SCRATCH");
1741 kunmap_atomic(vaddr);
1745 /* Write pde (index) from the page directory @pd to the page table @pt */
1746 static inline void gen6_write_pde(const struct gen6_hw_ppgtt *ppgtt,
1747 const unsigned int pde,
1748 const struct i915_page_table *pt)
1750 /* Caller needs to make sure the write completes if necessary */
1751 iowrite32(GEN6_PDE_ADDR_ENCODE(px_dma(pt)) | GEN6_PDE_VALID,
1752 ppgtt->pd_addr + pde);
1755 static void gen7_ppgtt_enable(struct drm_i915_private *dev_priv)
1757 struct intel_engine_cs *engine;
1758 u32 ecochk, ecobits;
1759 enum intel_engine_id id;
1761 ecobits = I915_READ(GAC_ECO_BITS);
1762 I915_WRITE(GAC_ECO_BITS, ecobits | ECOBITS_PPGTT_CACHE64B);
1764 ecochk = I915_READ(GAM_ECOCHK);
1765 if (IS_HASWELL(dev_priv)) {
1766 ecochk |= ECOCHK_PPGTT_WB_HSW;
1768 ecochk |= ECOCHK_PPGTT_LLC_IVB;
1769 ecochk &= ~ECOCHK_PPGTT_GFDT_IVB;
1771 I915_WRITE(GAM_ECOCHK, ecochk);
1773 for_each_engine(engine, dev_priv, id) {
1774 /* GFX_MODE is per-ring on gen7+ */
1775 I915_WRITE(RING_MODE_GEN7(engine),
1776 _MASKED_BIT_ENABLE(GFX_PPGTT_ENABLE));
1780 static void gen6_ppgtt_enable(struct drm_i915_private *dev_priv)
1782 u32 ecochk, gab_ctl, ecobits;
1784 ecobits = I915_READ(GAC_ECO_BITS);
1785 I915_WRITE(GAC_ECO_BITS, ecobits | ECOBITS_SNB_BIT |
1786 ECOBITS_PPGTT_CACHE64B);
1788 gab_ctl = I915_READ(GAB_CTL);
1789 I915_WRITE(GAB_CTL, gab_ctl | GAB_CTL_CONT_AFTER_PAGEFAULT);
1791 ecochk = I915_READ(GAM_ECOCHK);
1792 I915_WRITE(GAM_ECOCHK, ecochk | ECOCHK_SNB_BIT | ECOCHK_PPGTT_CACHE64B);
1794 if (HAS_PPGTT(dev_priv)) /* may be disabled for VT-d */
1795 I915_WRITE(GFX_MODE, _MASKED_BIT_ENABLE(GFX_PPGTT_ENABLE));
1798 /* PPGTT support for Sandybdrige/Gen6 and later */
1799 static void gen6_ppgtt_clear_range(struct i915_address_space *vm,
1800 u64 start, u64 length)
1802 struct gen6_hw_ppgtt *ppgtt = to_gen6_ppgtt(i915_vm_to_ppgtt(vm));
1803 unsigned int first_entry = start / I915_GTT_PAGE_SIZE;
1804 unsigned int pde = first_entry / GEN6_PTES;
1805 unsigned int pte = first_entry % GEN6_PTES;
1806 unsigned int num_entries = length / I915_GTT_PAGE_SIZE;
1807 const gen6_pte_t scratch_pte = vm->scratch_pte;
1809 while (num_entries) {
1810 struct i915_page_table *pt = ppgtt->base.pd.page_table[pde++];
1811 const unsigned int end = min(pte + num_entries, GEN6_PTES);
1812 const unsigned int count = end - pte;
1815 GEM_BUG_ON(pt == vm->scratch_pt);
1817 num_entries -= count;
1819 GEM_BUG_ON(count > pt->used_ptes);
1820 pt->used_ptes -= count;
1822 ppgtt->scan_for_unused_pt = true;
1825 * Note that the hw doesn't support removing PDE on the fly
1826 * (they are cached inside the context with no means to
1827 * invalidate the cache), so we can only reset the PTE
1828 * entries back to scratch.
1831 vaddr = kmap_atomic_px(pt);
1833 vaddr[pte++] = scratch_pte;
1834 } while (pte < end);
1835 kunmap_atomic(vaddr);
1841 static void gen6_ppgtt_insert_entries(struct i915_address_space *vm,
1842 struct i915_vma *vma,
1843 enum i915_cache_level cache_level,
1846 struct i915_hw_ppgtt *ppgtt = i915_vm_to_ppgtt(vm);
1847 unsigned first_entry = vma->node.start / I915_GTT_PAGE_SIZE;
1848 unsigned act_pt = first_entry / GEN6_PTES;
1849 unsigned act_pte = first_entry % GEN6_PTES;
1850 const u32 pte_encode = vm->pte_encode(0, cache_level, flags);
1851 struct sgt_dma iter = sgt_dma(vma);
1854 GEM_BUG_ON(ppgtt->pd.page_table[act_pt] == vm->scratch_pt);
1856 vaddr = kmap_atomic_px(ppgtt->pd.page_table[act_pt]);
1858 vaddr[act_pte] = pte_encode | GEN6_PTE_ADDR_ENCODE(iter.dma);
1860 iter.dma += I915_GTT_PAGE_SIZE;
1861 if (iter.dma == iter.max) {
1862 iter.sg = __sg_next(iter.sg);
1866 iter.dma = sg_dma_address(iter.sg);
1867 iter.max = iter.dma + iter.sg->length;
1870 if (++act_pte == GEN6_PTES) {
1871 kunmap_atomic(vaddr);
1872 vaddr = kmap_atomic_px(ppgtt->pd.page_table[++act_pt]);
1876 kunmap_atomic(vaddr);
1878 vma->page_sizes.gtt = I915_GTT_PAGE_SIZE;
1881 static int gen6_alloc_va_range(struct i915_address_space *vm,
1882 u64 start, u64 length)
1884 struct gen6_hw_ppgtt *ppgtt = to_gen6_ppgtt(i915_vm_to_ppgtt(vm));
1885 struct i915_page_table *pt;
1890 gen6_for_each_pde(pt, &ppgtt->base.pd, start, length, pde) {
1891 const unsigned int count = gen6_pte_count(start, length);
1893 if (pt == vm->scratch_pt) {
1898 gen6_initialize_pt(vm, pt);
1899 ppgtt->base.pd.page_table[pde] = pt;
1901 if (i915_vma_is_bound(ppgtt->vma,
1902 I915_VMA_GLOBAL_BIND)) {
1903 gen6_write_pde(ppgtt, pde, pt);
1907 GEM_BUG_ON(pt->used_ptes);
1910 pt->used_ptes += count;
1914 mark_tlbs_dirty(&ppgtt->base);
1915 gen6_ggtt_invalidate(ppgtt->base.vm.i915);
1921 gen6_ppgtt_clear_range(vm, from, start - from);
1925 static int gen6_ppgtt_init_scratch(struct gen6_hw_ppgtt *ppgtt)
1927 struct i915_address_space * const vm = &ppgtt->base.vm;
1928 struct i915_page_table *unused;
1932 ret = setup_scratch_page(vm, __GFP_HIGHMEM);
1936 vm->scratch_pte = vm->pte_encode(vm->scratch_page.daddr,
1940 vm->scratch_pt = alloc_pt(vm);
1941 if (IS_ERR(vm->scratch_pt)) {
1942 cleanup_scratch_page(vm);
1943 return PTR_ERR(vm->scratch_pt);
1946 gen6_initialize_pt(vm, vm->scratch_pt);
1947 gen6_for_all_pdes(unused, &ppgtt->base.pd, pde)
1948 ppgtt->base.pd.page_table[pde] = vm->scratch_pt;
1953 static void gen6_ppgtt_free_scratch(struct i915_address_space *vm)
1955 free_pt(vm, vm->scratch_pt);
1956 cleanup_scratch_page(vm);
1959 static void gen6_ppgtt_free_pd(struct gen6_hw_ppgtt *ppgtt)
1961 struct i915_page_table *pt;
1964 gen6_for_all_pdes(pt, &ppgtt->base.pd, pde)
1965 if (pt != ppgtt->base.vm.scratch_pt)
1966 free_pt(&ppgtt->base.vm, pt);
1969 static void gen6_ppgtt_cleanup(struct i915_address_space *vm)
1971 struct gen6_hw_ppgtt *ppgtt = to_gen6_ppgtt(i915_vm_to_ppgtt(vm));
1973 i915_vma_destroy(ppgtt->vma);
1975 gen6_ppgtt_free_pd(ppgtt);
1976 gen6_ppgtt_free_scratch(vm);
1979 static int pd_vma_set_pages(struct i915_vma *vma)
1981 vma->pages = ERR_PTR(-ENODEV);
1985 static void pd_vma_clear_pages(struct i915_vma *vma)
1987 GEM_BUG_ON(!vma->pages);
1992 static int pd_vma_bind(struct i915_vma *vma,
1993 enum i915_cache_level cache_level,
1996 struct i915_ggtt *ggtt = i915_vm_to_ggtt(vma->vm);
1997 struct gen6_hw_ppgtt *ppgtt = vma->private;
1998 u32 ggtt_offset = i915_ggtt_offset(vma) / I915_GTT_PAGE_SIZE;
1999 struct i915_page_table *pt;
2002 ppgtt->base.pd.base.ggtt_offset = ggtt_offset * sizeof(gen6_pte_t);
2003 ppgtt->pd_addr = (gen6_pte_t __iomem *)ggtt->gsm + ggtt_offset;
2005 gen6_for_all_pdes(pt, &ppgtt->base.pd, pde)
2006 gen6_write_pde(ppgtt, pde, pt);
2008 mark_tlbs_dirty(&ppgtt->base);
2009 gen6_ggtt_invalidate(ppgtt->base.vm.i915);
2014 static void pd_vma_unbind(struct i915_vma *vma)
2016 struct gen6_hw_ppgtt *ppgtt = vma->private;
2017 struct i915_page_table * const scratch_pt = ppgtt->base.vm.scratch_pt;
2018 struct i915_page_table *pt;
2021 if (!ppgtt->scan_for_unused_pt)
2024 /* Free all no longer used page tables */
2025 gen6_for_all_pdes(pt, &ppgtt->base.pd, pde) {
2026 if (pt->used_ptes || pt == scratch_pt)
2029 free_pt(&ppgtt->base.vm, pt);
2030 ppgtt->base.pd.page_table[pde] = scratch_pt;
2033 ppgtt->scan_for_unused_pt = false;
2036 static const struct i915_vma_ops pd_vma_ops = {
2037 .set_pages = pd_vma_set_pages,
2038 .clear_pages = pd_vma_clear_pages,
2039 .bind_vma = pd_vma_bind,
2040 .unbind_vma = pd_vma_unbind,
2043 static struct i915_vma *pd_vma_create(struct gen6_hw_ppgtt *ppgtt, int size)
2045 struct drm_i915_private *i915 = ppgtt->base.vm.i915;
2046 struct i915_ggtt *ggtt = &i915->ggtt;
2047 struct i915_vma *vma;
2049 GEM_BUG_ON(!IS_ALIGNED(size, I915_GTT_PAGE_SIZE));
2050 GEM_BUG_ON(size > ggtt->vm.total);
2052 vma = kmem_cache_zalloc(i915->vmas, GFP_KERNEL);
2054 return ERR_PTR(-ENOMEM);
2056 init_request_active(&vma->last_fence, NULL);
2058 vma->vm = &ggtt->vm;
2059 vma->ops = &pd_vma_ops;
2060 vma->private = ppgtt;
2062 vma->active = RB_ROOT;
2065 vma->fence_size = size;
2066 vma->flags = I915_VMA_GGTT;
2067 vma->ggtt_view.type = I915_GGTT_VIEW_ROTATED; /* prevent fencing */
2069 INIT_LIST_HEAD(&vma->obj_link);
2070 list_add(&vma->vm_link, &vma->vm->unbound_list);
2075 int gen6_ppgtt_pin(struct i915_hw_ppgtt *base)
2077 struct gen6_hw_ppgtt *ppgtt = to_gen6_ppgtt(base);
2080 * Workaround the limited maximum vma->pin_count and the aliasing_ppgtt
2081 * which will be pinned into every active context.
2082 * (When vma->pin_count becomes atomic, I expect we will naturally
2083 * need a larger, unpacked, type and kill this redundancy.)
2085 if (ppgtt->pin_count++)
2089 * PPGTT PDEs reside in the GGTT and consists of 512 entries. The
2090 * allocator works in address space sizes, so it's multiplied by page
2091 * size. We allocate at the top of the GTT to avoid fragmentation.
2093 return i915_vma_pin(ppgtt->vma,
2095 PIN_GLOBAL | PIN_HIGH);
2098 void gen6_ppgtt_unpin(struct i915_hw_ppgtt *base)
2100 struct gen6_hw_ppgtt *ppgtt = to_gen6_ppgtt(base);
2102 GEM_BUG_ON(!ppgtt->pin_count);
2103 if (--ppgtt->pin_count)
2106 i915_vma_unpin(ppgtt->vma);
2109 static struct i915_hw_ppgtt *gen6_ppgtt_create(struct drm_i915_private *i915)
2111 struct i915_ggtt * const ggtt = &i915->ggtt;
2112 struct gen6_hw_ppgtt *ppgtt;
2115 ppgtt = kzalloc(sizeof(*ppgtt), GFP_KERNEL);
2117 return ERR_PTR(-ENOMEM);
2119 kref_init(&ppgtt->base.ref);
2121 ppgtt->base.vm.i915 = i915;
2122 ppgtt->base.vm.dma = &i915->drm.pdev->dev;
2124 ppgtt->base.vm.total = I915_PDES * GEN6_PTES * I915_GTT_PAGE_SIZE;
2126 i915_address_space_init(&ppgtt->base.vm, i915);
2128 ppgtt->base.vm.allocate_va_range = gen6_alloc_va_range;
2129 ppgtt->base.vm.clear_range = gen6_ppgtt_clear_range;
2130 ppgtt->base.vm.insert_entries = gen6_ppgtt_insert_entries;
2131 ppgtt->base.vm.cleanup = gen6_ppgtt_cleanup;
2132 ppgtt->base.debug_dump = gen6_dump_ppgtt;
2134 ppgtt->base.vm.vma_ops.bind_vma = ppgtt_bind_vma;
2135 ppgtt->base.vm.vma_ops.unbind_vma = ppgtt_unbind_vma;
2136 ppgtt->base.vm.vma_ops.set_pages = ppgtt_set_pages;
2137 ppgtt->base.vm.vma_ops.clear_pages = clear_pages;
2139 ppgtt->base.vm.pte_encode = ggtt->vm.pte_encode;
2141 err = gen6_ppgtt_init_scratch(ppgtt);
2145 ppgtt->vma = pd_vma_create(ppgtt, GEN6_PD_SIZE);
2146 if (IS_ERR(ppgtt->vma)) {
2147 err = PTR_ERR(ppgtt->vma);
2151 return &ppgtt->base;
2154 gen6_ppgtt_free_scratch(&ppgtt->base.vm);
2157 return ERR_PTR(err);
2160 static void gtt_write_workarounds(struct drm_i915_private *dev_priv)
2162 /* This function is for gtt related workarounds. This function is
2163 * called on driver load and after a GPU reset, so you can place
2164 * workarounds here even if they get overwritten by GPU reset.
2166 /* WaIncreaseDefaultTLBEntries:chv,bdw,skl,bxt,kbl,glk,cfl,cnl,icl */
2167 if (IS_BROADWELL(dev_priv))
2168 I915_WRITE(GEN8_L3_LRA_1_GPGPU, GEN8_L3_LRA_1_GPGPU_DEFAULT_VALUE_BDW);
2169 else if (IS_CHERRYVIEW(dev_priv))
2170 I915_WRITE(GEN8_L3_LRA_1_GPGPU, GEN8_L3_LRA_1_GPGPU_DEFAULT_VALUE_CHV);
2171 else if (IS_GEN9_LP(dev_priv))
2172 I915_WRITE(GEN8_L3_LRA_1_GPGPU, GEN9_L3_LRA_1_GPGPU_DEFAULT_VALUE_BXT);
2173 else if (INTEL_GEN(dev_priv) >= 9)
2174 I915_WRITE(GEN8_L3_LRA_1_GPGPU, GEN9_L3_LRA_1_GPGPU_DEFAULT_VALUE_SKL);
2177 * To support 64K PTEs we need to first enable the use of the
2178 * Intermediate-Page-Size(IPS) bit of the PDE field via some magical
2179 * mmio, otherwise the page-walker will simply ignore the IPS bit. This
2180 * shouldn't be needed after GEN10.
2182 * 64K pages were first introduced from BDW+, although technically they
2183 * only *work* from gen9+. For pre-BDW we instead have the option for
2184 * 32K pages, but we don't currently have any support for it in our
2187 if (HAS_PAGE_SIZES(dev_priv, I915_GTT_PAGE_SIZE_64K) &&
2188 INTEL_GEN(dev_priv) <= 10)
2189 I915_WRITE(GEN8_GAMW_ECO_DEV_RW_IA,
2190 I915_READ(GEN8_GAMW_ECO_DEV_RW_IA) |
2191 GAMW_ECO_ENABLE_64K_IPS_FIELD);
2194 int i915_ppgtt_init_hw(struct drm_i915_private *dev_priv)
2196 gtt_write_workarounds(dev_priv);
2198 if (IS_GEN6(dev_priv))
2199 gen6_ppgtt_enable(dev_priv);
2200 else if (IS_GEN7(dev_priv))
2201 gen7_ppgtt_enable(dev_priv);
2206 static struct i915_hw_ppgtt *
2207 __hw_ppgtt_create(struct drm_i915_private *i915)
2209 if (INTEL_GEN(i915) < 8)
2210 return gen6_ppgtt_create(i915);
2212 return gen8_ppgtt_create(i915);
2215 struct i915_hw_ppgtt *
2216 i915_ppgtt_create(struct drm_i915_private *i915,
2217 struct drm_i915_file_private *fpriv)
2219 struct i915_hw_ppgtt *ppgtt;
2221 ppgtt = __hw_ppgtt_create(i915);
2225 ppgtt->vm.file = fpriv;
2227 trace_i915_ppgtt_create(&ppgtt->vm);
2232 void i915_ppgtt_close(struct i915_address_space *vm)
2234 GEM_BUG_ON(vm->closed);
2238 static void ppgtt_destroy_vma(struct i915_address_space *vm)
2240 struct list_head *phases[] = {
2248 for (phase = phases; *phase; phase++) {
2249 struct i915_vma *vma, *vn;
2251 list_for_each_entry_safe(vma, vn, *phase, vm_link)
2252 i915_vma_destroy(vma);
2256 void i915_ppgtt_release(struct kref *kref)
2258 struct i915_hw_ppgtt *ppgtt =
2259 container_of(kref, struct i915_hw_ppgtt, ref);
2261 trace_i915_ppgtt_release(&ppgtt->vm);
2263 ppgtt_destroy_vma(&ppgtt->vm);
2265 GEM_BUG_ON(!list_empty(&ppgtt->vm.active_list));
2266 GEM_BUG_ON(!list_empty(&ppgtt->vm.inactive_list));
2267 GEM_BUG_ON(!list_empty(&ppgtt->vm.unbound_list));
2269 ppgtt->vm.cleanup(&ppgtt->vm);
2270 i915_address_space_fini(&ppgtt->vm);
2274 /* Certain Gen5 chipsets require require idling the GPU before
2275 * unmapping anything from the GTT when VT-d is enabled.
2277 static bool needs_idle_maps(struct drm_i915_private *dev_priv)
2279 /* Query intel_iommu to see if we need the workaround. Presumably that
2282 return IS_GEN5(dev_priv) && IS_MOBILE(dev_priv) && intel_vtd_active();
2285 static void gen6_check_faults(struct drm_i915_private *dev_priv)
2287 struct intel_engine_cs *engine;
2288 enum intel_engine_id id;
2291 for_each_engine(engine, dev_priv, id) {
2292 fault = I915_READ(RING_FAULT_REG(engine));
2293 if (fault & RING_FAULT_VALID) {
2294 DRM_DEBUG_DRIVER("Unexpected fault\n"
2296 "\tAddress space: %s\n"
2300 fault & RING_FAULT_GTTSEL_MASK ? "GGTT" : "PPGTT",
2301 RING_FAULT_SRCID(fault),
2302 RING_FAULT_FAULT_TYPE(fault));
2307 static void gen8_check_faults(struct drm_i915_private *dev_priv)
2309 u32 fault = I915_READ(GEN8_RING_FAULT_REG);
2311 if (fault & RING_FAULT_VALID) {
2312 u32 fault_data0, fault_data1;
2315 fault_data0 = I915_READ(GEN8_FAULT_TLB_DATA0);
2316 fault_data1 = I915_READ(GEN8_FAULT_TLB_DATA1);
2317 fault_addr = ((u64)(fault_data1 & FAULT_VA_HIGH_BITS) << 44) |
2318 ((u64)fault_data0 << 12);
2320 DRM_DEBUG_DRIVER("Unexpected fault\n"
2321 "\tAddr: 0x%08x_%08x\n"
2322 "\tAddress space: %s\n"
2326 upper_32_bits(fault_addr),
2327 lower_32_bits(fault_addr),
2328 fault_data1 & FAULT_GTT_SEL ? "GGTT" : "PPGTT",
2329 GEN8_RING_FAULT_ENGINE_ID(fault),
2330 RING_FAULT_SRCID(fault),
2331 RING_FAULT_FAULT_TYPE(fault));
2335 void i915_check_and_clear_faults(struct drm_i915_private *dev_priv)
2337 /* From GEN8 onwards we only have one 'All Engine Fault Register' */
2338 if (INTEL_GEN(dev_priv) >= 8)
2339 gen8_check_faults(dev_priv);
2340 else if (INTEL_GEN(dev_priv) >= 6)
2341 gen6_check_faults(dev_priv);
2345 i915_clear_error_registers(dev_priv);
2348 void i915_gem_suspend_gtt_mappings(struct drm_i915_private *dev_priv)
2350 struct i915_ggtt *ggtt = &dev_priv->ggtt;
2352 /* Don't bother messing with faults pre GEN6 as we have little
2353 * documentation supporting that it's a good idea.
2355 if (INTEL_GEN(dev_priv) < 6)
2358 i915_check_and_clear_faults(dev_priv);
2360 ggtt->vm.clear_range(&ggtt->vm, 0, ggtt->vm.total);
2362 i915_ggtt_invalidate(dev_priv);
2365 int i915_gem_gtt_prepare_pages(struct drm_i915_gem_object *obj,
2366 struct sg_table *pages)
2369 if (dma_map_sg_attrs(&obj->base.dev->pdev->dev,
2370 pages->sgl, pages->nents,
2371 PCI_DMA_BIDIRECTIONAL,
2375 /* If the DMA remap fails, one cause can be that we have
2376 * too many objects pinned in a small remapping table,
2377 * such as swiotlb. Incrementally purge all other objects and
2378 * try again - if there are no more pages to remove from
2379 * the DMA remapper, i915_gem_shrink will return 0.
2381 GEM_BUG_ON(obj->mm.pages == pages);
2382 } while (i915_gem_shrink(to_i915(obj->base.dev),
2383 obj->base.size >> PAGE_SHIFT, NULL,
2385 I915_SHRINK_UNBOUND |
2386 I915_SHRINK_ACTIVE));
2391 static void gen8_set_pte(void __iomem *addr, gen8_pte_t pte)
2396 static void gen8_ggtt_insert_page(struct i915_address_space *vm,
2399 enum i915_cache_level level,
2402 struct i915_ggtt *ggtt = i915_vm_to_ggtt(vm);
2403 gen8_pte_t __iomem *pte =
2404 (gen8_pte_t __iomem *)ggtt->gsm + offset / I915_GTT_PAGE_SIZE;
2406 gen8_set_pte(pte, gen8_pte_encode(addr, level, 0));
2408 ggtt->invalidate(vm->i915);
2411 static void gen8_ggtt_insert_entries(struct i915_address_space *vm,
2412 struct i915_vma *vma,
2413 enum i915_cache_level level,
2416 struct i915_ggtt *ggtt = i915_vm_to_ggtt(vm);
2417 struct sgt_iter sgt_iter;
2418 gen8_pte_t __iomem *gtt_entries;
2419 const gen8_pte_t pte_encode = gen8_pte_encode(0, level, 0);
2423 * Note that we ignore PTE_READ_ONLY here. The caller must be careful
2424 * not to allow the user to override access to a read only page.
2427 gtt_entries = (gen8_pte_t __iomem *)ggtt->gsm;
2428 gtt_entries += vma->node.start / I915_GTT_PAGE_SIZE;
2429 for_each_sgt_dma(addr, sgt_iter, vma->pages)
2430 gen8_set_pte(gtt_entries++, pte_encode | addr);
2433 * We want to flush the TLBs only after we're certain all the PTE
2434 * updates have finished.
2436 ggtt->invalidate(vm->i915);
2439 static void gen6_ggtt_insert_page(struct i915_address_space *vm,
2442 enum i915_cache_level level,
2445 struct i915_ggtt *ggtt = i915_vm_to_ggtt(vm);
2446 gen6_pte_t __iomem *pte =
2447 (gen6_pte_t __iomem *)ggtt->gsm + offset / I915_GTT_PAGE_SIZE;
2449 iowrite32(vm->pte_encode(addr, level, flags), pte);
2451 ggtt->invalidate(vm->i915);
2455 * Binds an object into the global gtt with the specified cache level. The object
2456 * will be accessible to the GPU via commands whose operands reference offsets
2457 * within the global GTT as well as accessible by the GPU through the GMADR
2458 * mapped BAR (dev_priv->mm.gtt->gtt).
2460 static void gen6_ggtt_insert_entries(struct i915_address_space *vm,
2461 struct i915_vma *vma,
2462 enum i915_cache_level level,
2465 struct i915_ggtt *ggtt = i915_vm_to_ggtt(vm);
2466 gen6_pte_t __iomem *entries = (gen6_pte_t __iomem *)ggtt->gsm;
2467 unsigned int i = vma->node.start / I915_GTT_PAGE_SIZE;
2468 struct sgt_iter iter;
2470 for_each_sgt_dma(addr, iter, vma->pages)
2471 iowrite32(vm->pte_encode(addr, level, flags), &entries[i++]);
2474 * We want to flush the TLBs only after we're certain all the PTE
2475 * updates have finished.
2477 ggtt->invalidate(vm->i915);
2480 static void nop_clear_range(struct i915_address_space *vm,
2481 u64 start, u64 length)
2485 static void gen8_ggtt_clear_range(struct i915_address_space *vm,
2486 u64 start, u64 length)
2488 struct i915_ggtt *ggtt = i915_vm_to_ggtt(vm);
2489 unsigned first_entry = start / I915_GTT_PAGE_SIZE;
2490 unsigned num_entries = length / I915_GTT_PAGE_SIZE;
2491 const gen8_pte_t scratch_pte = vm->scratch_pte;
2492 gen8_pte_t __iomem *gtt_base =
2493 (gen8_pte_t __iomem *)ggtt->gsm + first_entry;
2494 const int max_entries = ggtt_total_entries(ggtt) - first_entry;
2497 if (WARN(num_entries > max_entries,
2498 "First entry = %d; Num entries = %d (max=%d)\n",
2499 first_entry, num_entries, max_entries))
2500 num_entries = max_entries;
2502 for (i = 0; i < num_entries; i++)
2503 gen8_set_pte(>t_base[i], scratch_pte);
2506 static void bxt_vtd_ggtt_wa(struct i915_address_space *vm)
2508 struct drm_i915_private *dev_priv = vm->i915;
2511 * Make sure the internal GAM fifo has been cleared of all GTT
2512 * writes before exiting stop_machine(). This guarantees that
2513 * any aperture accesses waiting to start in another process
2514 * cannot back up behind the GTT writes causing a hang.
2515 * The register can be any arbitrary GAM register.
2517 POSTING_READ(GFX_FLSH_CNTL_GEN6);
2520 struct insert_page {
2521 struct i915_address_space *vm;
2524 enum i915_cache_level level;
2527 static int bxt_vtd_ggtt_insert_page__cb(void *_arg)
2529 struct insert_page *arg = _arg;
2531 gen8_ggtt_insert_page(arg->vm, arg->addr, arg->offset, arg->level, 0);
2532 bxt_vtd_ggtt_wa(arg->vm);
2537 static void bxt_vtd_ggtt_insert_page__BKL(struct i915_address_space *vm,
2540 enum i915_cache_level level,
2543 struct insert_page arg = { vm, addr, offset, level };
2545 stop_machine(bxt_vtd_ggtt_insert_page__cb, &arg, NULL);
2548 struct insert_entries {
2549 struct i915_address_space *vm;
2550 struct i915_vma *vma;
2551 enum i915_cache_level level;
2555 static int bxt_vtd_ggtt_insert_entries__cb(void *_arg)
2557 struct insert_entries *arg = _arg;
2559 gen8_ggtt_insert_entries(arg->vm, arg->vma, arg->level, arg->flags);
2560 bxt_vtd_ggtt_wa(arg->vm);
2565 static void bxt_vtd_ggtt_insert_entries__BKL(struct i915_address_space *vm,
2566 struct i915_vma *vma,
2567 enum i915_cache_level level,
2570 struct insert_entries arg = { vm, vma, level, flags };
2572 stop_machine(bxt_vtd_ggtt_insert_entries__cb, &arg, NULL);
2575 struct clear_range {
2576 struct i915_address_space *vm;
2581 static int bxt_vtd_ggtt_clear_range__cb(void *_arg)
2583 struct clear_range *arg = _arg;
2585 gen8_ggtt_clear_range(arg->vm, arg->start, arg->length);
2586 bxt_vtd_ggtt_wa(arg->vm);
2591 static void bxt_vtd_ggtt_clear_range__BKL(struct i915_address_space *vm,
2595 struct clear_range arg = { vm, start, length };
2597 stop_machine(bxt_vtd_ggtt_clear_range__cb, &arg, NULL);
2600 static void gen6_ggtt_clear_range(struct i915_address_space *vm,
2601 u64 start, u64 length)
2603 struct i915_ggtt *ggtt = i915_vm_to_ggtt(vm);
2604 unsigned first_entry = start / I915_GTT_PAGE_SIZE;
2605 unsigned num_entries = length / I915_GTT_PAGE_SIZE;
2606 gen6_pte_t scratch_pte, __iomem *gtt_base =
2607 (gen6_pte_t __iomem *)ggtt->gsm + first_entry;
2608 const int max_entries = ggtt_total_entries(ggtt) - first_entry;
2611 if (WARN(num_entries > max_entries,
2612 "First entry = %d; Num entries = %d (max=%d)\n",
2613 first_entry, num_entries, max_entries))
2614 num_entries = max_entries;
2616 scratch_pte = vm->scratch_pte;
2618 for (i = 0; i < num_entries; i++)
2619 iowrite32(scratch_pte, >t_base[i]);
2622 static void i915_ggtt_insert_page(struct i915_address_space *vm,
2625 enum i915_cache_level cache_level,
2628 unsigned int flags = (cache_level == I915_CACHE_NONE) ?
2629 AGP_USER_MEMORY : AGP_USER_CACHED_MEMORY;
2631 intel_gtt_insert_page(addr, offset >> PAGE_SHIFT, flags);
2634 static void i915_ggtt_insert_entries(struct i915_address_space *vm,
2635 struct i915_vma *vma,
2636 enum i915_cache_level cache_level,
2639 unsigned int flags = (cache_level == I915_CACHE_NONE) ?
2640 AGP_USER_MEMORY : AGP_USER_CACHED_MEMORY;
2642 intel_gtt_insert_sg_entries(vma->pages, vma->node.start >> PAGE_SHIFT,
2646 static void i915_ggtt_clear_range(struct i915_address_space *vm,
2647 u64 start, u64 length)
2649 intel_gtt_clear_range(start >> PAGE_SHIFT, length >> PAGE_SHIFT);
2652 static int ggtt_bind_vma(struct i915_vma *vma,
2653 enum i915_cache_level cache_level,
2656 struct drm_i915_private *i915 = vma->vm->i915;
2657 struct drm_i915_gem_object *obj = vma->obj;
2660 /* Applicable to VLV (gen8+ do not support RO in the GGTT) */
2662 if (i915_gem_object_is_readonly(obj))
2663 pte_flags |= PTE_READ_ONLY;
2665 intel_runtime_pm_get(i915);
2666 vma->vm->insert_entries(vma->vm, vma, cache_level, pte_flags);
2667 intel_runtime_pm_put(i915);
2669 vma->page_sizes.gtt = I915_GTT_PAGE_SIZE;
2672 * Without aliasing PPGTT there's no difference between
2673 * GLOBAL/LOCAL_BIND, it's all the same ptes. Hence unconditionally
2674 * upgrade to both bound if we bind either to avoid double-binding.
2676 vma->flags |= I915_VMA_GLOBAL_BIND | I915_VMA_LOCAL_BIND;
2681 static void ggtt_unbind_vma(struct i915_vma *vma)
2683 struct drm_i915_private *i915 = vma->vm->i915;
2685 intel_runtime_pm_get(i915);
2686 vma->vm->clear_range(vma->vm, vma->node.start, vma->size);
2687 intel_runtime_pm_put(i915);
2690 static int aliasing_gtt_bind_vma(struct i915_vma *vma,
2691 enum i915_cache_level cache_level,
2694 struct drm_i915_private *i915 = vma->vm->i915;
2698 /* Currently applicable only to VLV */
2700 if (i915_gem_object_is_readonly(vma->obj))
2701 pte_flags |= PTE_READ_ONLY;
2703 if (flags & I915_VMA_LOCAL_BIND) {
2704 struct i915_hw_ppgtt *appgtt = i915->mm.aliasing_ppgtt;
2706 if (!(vma->flags & I915_VMA_LOCAL_BIND)) {
2707 ret = appgtt->vm.allocate_va_range(&appgtt->vm,
2714 appgtt->vm.insert_entries(&appgtt->vm, vma, cache_level,
2718 if (flags & I915_VMA_GLOBAL_BIND) {
2719 intel_runtime_pm_get(i915);
2720 vma->vm->insert_entries(vma->vm, vma, cache_level, pte_flags);
2721 intel_runtime_pm_put(i915);
2727 static void aliasing_gtt_unbind_vma(struct i915_vma *vma)
2729 struct drm_i915_private *i915 = vma->vm->i915;
2731 if (vma->flags & I915_VMA_GLOBAL_BIND) {
2732 intel_runtime_pm_get(i915);
2733 vma->vm->clear_range(vma->vm, vma->node.start, vma->size);
2734 intel_runtime_pm_put(i915);
2737 if (vma->flags & I915_VMA_LOCAL_BIND) {
2738 struct i915_address_space *vm = &i915->mm.aliasing_ppgtt->vm;
2740 vm->clear_range(vm, vma->node.start, vma->size);
2744 void i915_gem_gtt_finish_pages(struct drm_i915_gem_object *obj,
2745 struct sg_table *pages)
2747 struct drm_i915_private *dev_priv = to_i915(obj->base.dev);
2748 struct device *kdev = &dev_priv->drm.pdev->dev;
2749 struct i915_ggtt *ggtt = &dev_priv->ggtt;
2751 if (unlikely(ggtt->do_idle_maps)) {
2752 if (i915_gem_wait_for_idle(dev_priv, 0, MAX_SCHEDULE_TIMEOUT)) {
2753 DRM_ERROR("Failed to wait for idle; VT'd may hang.\n");
2754 /* Wait a bit, in hopes it avoids the hang */
2759 dma_unmap_sg(kdev, pages->sgl, pages->nents, PCI_DMA_BIDIRECTIONAL);
2762 static int ggtt_set_pages(struct i915_vma *vma)
2766 GEM_BUG_ON(vma->pages);
2768 ret = i915_get_ggtt_vma_pages(vma);
2772 vma->page_sizes = vma->obj->mm.page_sizes;
2777 static void i915_gtt_color_adjust(const struct drm_mm_node *node,
2778 unsigned long color,
2782 if (node->allocated && node->color != color)
2783 *start += I915_GTT_PAGE_SIZE;
2785 /* Also leave a space between the unallocated reserved node after the
2786 * GTT and any objects within the GTT, i.e. we use the color adjustment
2787 * to insert a guard page to prevent prefetches crossing over the
2790 node = list_next_entry(node, node_list);
2791 if (node->color != color)
2792 *end -= I915_GTT_PAGE_SIZE;
2795 int i915_gem_init_aliasing_ppgtt(struct drm_i915_private *i915)
2797 struct i915_ggtt *ggtt = &i915->ggtt;
2798 struct i915_hw_ppgtt *ppgtt;
2801 ppgtt = i915_ppgtt_create(i915, ERR_PTR(-EPERM));
2803 return PTR_ERR(ppgtt);
2805 if (GEM_WARN_ON(ppgtt->vm.total < ggtt->vm.total)) {
2811 * Note we only pre-allocate as far as the end of the global
2812 * GTT. On 48b / 4-level page-tables, the difference is very,
2813 * very significant! We have to preallocate as GVT/vgpu does
2814 * not like the page directory disappearing.
2816 err = ppgtt->vm.allocate_va_range(&ppgtt->vm, 0, ggtt->vm.total);
2820 i915->mm.aliasing_ppgtt = ppgtt;
2822 GEM_BUG_ON(ggtt->vm.vma_ops.bind_vma != ggtt_bind_vma);
2823 ggtt->vm.vma_ops.bind_vma = aliasing_gtt_bind_vma;
2825 GEM_BUG_ON(ggtt->vm.vma_ops.unbind_vma != ggtt_unbind_vma);
2826 ggtt->vm.vma_ops.unbind_vma = aliasing_gtt_unbind_vma;
2831 i915_ppgtt_put(ppgtt);
2835 void i915_gem_fini_aliasing_ppgtt(struct drm_i915_private *i915)
2837 struct i915_ggtt *ggtt = &i915->ggtt;
2838 struct i915_hw_ppgtt *ppgtt;
2840 ppgtt = fetch_and_zero(&i915->mm.aliasing_ppgtt);
2844 i915_ppgtt_put(ppgtt);
2846 ggtt->vm.vma_ops.bind_vma = ggtt_bind_vma;
2847 ggtt->vm.vma_ops.unbind_vma = ggtt_unbind_vma;
2850 int i915_gem_init_ggtt(struct drm_i915_private *dev_priv)
2852 /* Let GEM Manage all of the aperture.
2854 * However, leave one page at the end still bound to the scratch page.
2855 * There are a number of places where the hardware apparently prefetches
2856 * past the end of the object, and we've seen multiple hangs with the
2857 * GPU head pointer stuck in a batchbuffer bound at the last page of the
2858 * aperture. One page should be enough to keep any prefetching inside
2861 struct i915_ggtt *ggtt = &dev_priv->ggtt;
2862 unsigned long hole_start, hole_end;
2863 struct drm_mm_node *entry;
2867 * GuC requires all resources that we're sharing with it to be placed in
2868 * non-WOPCM memory. If GuC is not present or not in use we still need a
2869 * small bias as ring wraparound at offset 0 sometimes hangs. No idea
2872 ggtt->pin_bias = max_t(u32, I915_GTT_PAGE_SIZE,
2873 intel_guc_reserved_gtt_size(&dev_priv->guc));
2875 ret = intel_vgt_balloon(dev_priv);
2879 /* Reserve a mappable slot for our lockless error capture */
2880 ret = drm_mm_insert_node_in_range(&ggtt->vm.mm, &ggtt->error_capture,
2881 PAGE_SIZE, 0, I915_COLOR_UNEVICTABLE,
2882 0, ggtt->mappable_end,
2887 /* Clear any non-preallocated blocks */
2888 drm_mm_for_each_hole(entry, &ggtt->vm.mm, hole_start, hole_end) {
2889 DRM_DEBUG_KMS("clearing unused GTT space: [%lx, %lx]\n",
2890 hole_start, hole_end);
2891 ggtt->vm.clear_range(&ggtt->vm, hole_start,
2892 hole_end - hole_start);
2895 /* And finally clear the reserved guard page */
2896 ggtt->vm.clear_range(&ggtt->vm, ggtt->vm.total - PAGE_SIZE, PAGE_SIZE);
2898 if (INTEL_PPGTT(dev_priv) == INTEL_PPGTT_ALIASING) {
2899 ret = i915_gem_init_aliasing_ppgtt(dev_priv);
2907 drm_mm_remove_node(&ggtt->error_capture);
2912 * i915_ggtt_cleanup_hw - Clean up GGTT hardware initialization
2913 * @dev_priv: i915 device
2915 void i915_ggtt_cleanup_hw(struct drm_i915_private *dev_priv)
2917 struct i915_ggtt *ggtt = &dev_priv->ggtt;
2918 struct i915_vma *vma, *vn;
2919 struct pagevec *pvec;
2921 ggtt->vm.closed = true;
2923 mutex_lock(&dev_priv->drm.struct_mutex);
2924 i915_gem_fini_aliasing_ppgtt(dev_priv);
2926 GEM_BUG_ON(!list_empty(&ggtt->vm.active_list));
2927 list_for_each_entry_safe(vma, vn, &ggtt->vm.inactive_list, vm_link)
2928 WARN_ON(i915_vma_unbind(vma));
2930 if (drm_mm_node_allocated(&ggtt->error_capture))
2931 drm_mm_remove_node(&ggtt->error_capture);
2933 if (drm_mm_initialized(&ggtt->vm.mm)) {
2934 intel_vgt_deballoon(dev_priv);
2935 i915_address_space_fini(&ggtt->vm);
2938 ggtt->vm.cleanup(&ggtt->vm);
2940 pvec = &dev_priv->mm.wc_stash.pvec;
2942 set_pages_array_wb(pvec->pages, pvec->nr);
2943 __pagevec_release(pvec);
2946 mutex_unlock(&dev_priv->drm.struct_mutex);
2948 arch_phys_wc_del(ggtt->mtrr);
2949 io_mapping_fini(&ggtt->iomap);
2951 i915_gem_cleanup_stolen(dev_priv);
2954 static unsigned int gen6_get_total_gtt_size(u16 snb_gmch_ctl)
2956 snb_gmch_ctl >>= SNB_GMCH_GGMS_SHIFT;
2957 snb_gmch_ctl &= SNB_GMCH_GGMS_MASK;
2958 return snb_gmch_ctl << 20;
2961 static unsigned int gen8_get_total_gtt_size(u16 bdw_gmch_ctl)
2963 bdw_gmch_ctl >>= BDW_GMCH_GGMS_SHIFT;
2964 bdw_gmch_ctl &= BDW_GMCH_GGMS_MASK;
2966 bdw_gmch_ctl = 1 << bdw_gmch_ctl;
2968 #ifdef CONFIG_X86_32
2969 /* Limit 32b platforms to a 2GB GGTT: 4 << 20 / pte size * I915_GTT_PAGE_SIZE */
2970 if (bdw_gmch_ctl > 4)
2974 return bdw_gmch_ctl << 20;
2977 static unsigned int chv_get_total_gtt_size(u16 gmch_ctrl)
2979 gmch_ctrl >>= SNB_GMCH_GGMS_SHIFT;
2980 gmch_ctrl &= SNB_GMCH_GGMS_MASK;
2983 return 1 << (20 + gmch_ctrl);
2988 static int ggtt_probe_common(struct i915_ggtt *ggtt, u64 size)
2990 struct drm_i915_private *dev_priv = ggtt->vm.i915;
2991 struct pci_dev *pdev = dev_priv->drm.pdev;
2992 phys_addr_t phys_addr;
2995 /* For Modern GENs the PTEs and register space are split in the BAR */
2996 phys_addr = pci_resource_start(pdev, 0) + pci_resource_len(pdev, 0) / 2;
2999 * On BXT+/CNL+ writes larger than 64 bit to the GTT pagetable range
3000 * will be dropped. For WC mappings in general we have 64 byte burst
3001 * writes when the WC buffer is flushed, so we can't use it, but have to
3002 * resort to an uncached mapping. The WC issue is easily caught by the
3003 * readback check when writing GTT PTE entries.
3005 if (IS_GEN9_LP(dev_priv) || INTEL_GEN(dev_priv) >= 10)
3006 ggtt->gsm = ioremap_nocache(phys_addr, size);
3008 ggtt->gsm = ioremap_wc(phys_addr, size);
3010 DRM_ERROR("Failed to map the ggtt page table\n");
3014 ret = setup_scratch_page(&ggtt->vm, GFP_DMA32);
3016 DRM_ERROR("Scratch setup failed\n");
3017 /* iounmap will also get called at remove, but meh */
3022 ggtt->vm.scratch_pte =
3023 ggtt->vm.pte_encode(ggtt->vm.scratch_page.daddr,
3024 I915_CACHE_NONE, 0);
3029 static struct intel_ppat_entry *
3030 __alloc_ppat_entry(struct intel_ppat *ppat, unsigned int index, u8 value)
3032 struct intel_ppat_entry *entry = &ppat->entries[index];
3034 GEM_BUG_ON(index >= ppat->max_entries);
3035 GEM_BUG_ON(test_bit(index, ppat->used));
3038 entry->value = value;
3039 kref_init(&entry->ref);
3040 set_bit(index, ppat->used);
3041 set_bit(index, ppat->dirty);
3046 static void __free_ppat_entry(struct intel_ppat_entry *entry)
3048 struct intel_ppat *ppat = entry->ppat;
3049 unsigned int index = entry - ppat->entries;
3051 GEM_BUG_ON(index >= ppat->max_entries);
3052 GEM_BUG_ON(!test_bit(index, ppat->used));
3054 entry->value = ppat->clear_value;
3055 clear_bit(index, ppat->used);
3056 set_bit(index, ppat->dirty);
3060 * intel_ppat_get - get a usable PPAT entry
3061 * @i915: i915 device instance
3062 * @value: the PPAT value required by the caller
3064 * The function tries to search if there is an existing PPAT entry which
3065 * matches with the required value. If perfectly matched, the existing PPAT
3066 * entry will be used. If only partially matched, it will try to check if
3067 * there is any available PPAT index. If yes, it will allocate a new PPAT
3068 * index for the required entry and update the HW. If not, the partially
3069 * matched entry will be used.
3071 const struct intel_ppat_entry *
3072 intel_ppat_get(struct drm_i915_private *i915, u8 value)
3074 struct intel_ppat *ppat = &i915->ppat;
3075 struct intel_ppat_entry *entry = NULL;
3076 unsigned int scanned, best_score;
3079 GEM_BUG_ON(!ppat->max_entries);
3081 scanned = best_score = 0;
3082 for_each_set_bit(i, ppat->used, ppat->max_entries) {
3085 score = ppat->match(ppat->entries[i].value, value);
3086 if (score > best_score) {
3087 entry = &ppat->entries[i];
3088 if (score == INTEL_PPAT_PERFECT_MATCH) {
3089 kref_get(&entry->ref);
3097 if (scanned == ppat->max_entries) {
3099 return ERR_PTR(-ENOSPC);
3101 kref_get(&entry->ref);
3105 i = find_first_zero_bit(ppat->used, ppat->max_entries);
3106 entry = __alloc_ppat_entry(ppat, i, value);
3107 ppat->update_hw(i915);
3111 static void release_ppat(struct kref *kref)
3113 struct intel_ppat_entry *entry =
3114 container_of(kref, struct intel_ppat_entry, ref);
3115 struct drm_i915_private *i915 = entry->ppat->i915;
3117 __free_ppat_entry(entry);
3118 entry->ppat->update_hw(i915);
3122 * intel_ppat_put - put back the PPAT entry got from intel_ppat_get()
3123 * @entry: an intel PPAT entry
3125 * Put back the PPAT entry got from intel_ppat_get(). If the PPAT index of the
3126 * entry is dynamically allocated, its reference count will be decreased. Once
3127 * the reference count becomes into zero, the PPAT index becomes free again.
3129 void intel_ppat_put(const struct intel_ppat_entry *entry)
3131 struct intel_ppat *ppat = entry->ppat;
3132 unsigned int index = entry - ppat->entries;
3134 GEM_BUG_ON(!ppat->max_entries);
3136 kref_put(&ppat->entries[index].ref, release_ppat);
3139 static void cnl_private_pat_update_hw(struct drm_i915_private *dev_priv)
3141 struct intel_ppat *ppat = &dev_priv->ppat;
3144 for_each_set_bit(i, ppat->dirty, ppat->max_entries) {
3145 I915_WRITE(GEN10_PAT_INDEX(i), ppat->entries[i].value);
3146 clear_bit(i, ppat->dirty);
3150 static void bdw_private_pat_update_hw(struct drm_i915_private *dev_priv)
3152 struct intel_ppat *ppat = &dev_priv->ppat;
3156 for (i = 0; i < ppat->max_entries; i++)
3157 pat |= GEN8_PPAT(i, ppat->entries[i].value);
3159 bitmap_clear(ppat->dirty, 0, ppat->max_entries);
3161 I915_WRITE(GEN8_PRIVATE_PAT_LO, lower_32_bits(pat));
3162 I915_WRITE(GEN8_PRIVATE_PAT_HI, upper_32_bits(pat));
3165 static unsigned int bdw_private_pat_match(u8 src, u8 dst)
3167 unsigned int score = 0;
3174 /* Cache attribute has to be matched. */
3175 if (GEN8_PPAT_GET_CA(src) != GEN8_PPAT_GET_CA(dst))
3180 if (GEN8_PPAT_GET_TC(src) == GEN8_PPAT_GET_TC(dst))
3183 if (GEN8_PPAT_GET_AGE(src) == GEN8_PPAT_GET_AGE(dst))
3186 if (score == (AGE_MATCH | TC_MATCH | CA_MATCH))
3187 return INTEL_PPAT_PERFECT_MATCH;
3192 static unsigned int chv_private_pat_match(u8 src, u8 dst)
3194 return (CHV_PPAT_GET_SNOOP(src) == CHV_PPAT_GET_SNOOP(dst)) ?
3195 INTEL_PPAT_PERFECT_MATCH : 0;
3198 static void cnl_setup_private_ppat(struct intel_ppat *ppat)
3200 ppat->max_entries = 8;
3201 ppat->update_hw = cnl_private_pat_update_hw;
3202 ppat->match = bdw_private_pat_match;
3203 ppat->clear_value = GEN8_PPAT_WB | GEN8_PPAT_LLCELLC | GEN8_PPAT_AGE(3);
3205 __alloc_ppat_entry(ppat, 0, GEN8_PPAT_WB | GEN8_PPAT_LLC);
3206 __alloc_ppat_entry(ppat, 1, GEN8_PPAT_WC | GEN8_PPAT_LLCELLC);
3207 __alloc_ppat_entry(ppat, 2, GEN8_PPAT_WT | GEN8_PPAT_LLCELLC);
3208 __alloc_ppat_entry(ppat, 3, GEN8_PPAT_UC);
3209 __alloc_ppat_entry(ppat, 4, GEN8_PPAT_WB | GEN8_PPAT_LLCELLC | GEN8_PPAT_AGE(0));
3210 __alloc_ppat_entry(ppat, 5, GEN8_PPAT_WB | GEN8_PPAT_LLCELLC | GEN8_PPAT_AGE(1));
3211 __alloc_ppat_entry(ppat, 6, GEN8_PPAT_WB | GEN8_PPAT_LLCELLC | GEN8_PPAT_AGE(2));
3212 __alloc_ppat_entry(ppat, 7, GEN8_PPAT_WB | GEN8_PPAT_LLCELLC | GEN8_PPAT_AGE(3));
3215 /* The GGTT and PPGTT need a private PPAT setup in order to handle cacheability
3216 * bits. When using advanced contexts each context stores its own PAT, but
3217 * writing this data shouldn't be harmful even in those cases. */
3218 static void bdw_setup_private_ppat(struct intel_ppat *ppat)
3220 ppat->max_entries = 8;
3221 ppat->update_hw = bdw_private_pat_update_hw;
3222 ppat->match = bdw_private_pat_match;
3223 ppat->clear_value = GEN8_PPAT_WB | GEN8_PPAT_LLCELLC | GEN8_PPAT_AGE(3);
3225 if (!HAS_PPGTT(ppat->i915)) {
3226 /* Spec: "For GGTT, there is NO pat_sel[2:0] from the entry,
3227 * so RTL will always use the value corresponding to
3229 * So let's disable cache for GGTT to avoid screen corruptions.
3230 * MOCS still can be used though.
3231 * - System agent ggtt writes (i.e. cpu gtt mmaps) already work
3232 * before this patch, i.e. the same uncached + snooping access
3233 * like on gen6/7 seems to be in effect.
3234 * - So this just fixes blitter/render access. Again it looks
3235 * like it's not just uncached access, but uncached + snooping.
3236 * So we can still hold onto all our assumptions wrt cpu
3237 * clflushing on LLC machines.
3239 __alloc_ppat_entry(ppat, 0, GEN8_PPAT_UC);
3243 __alloc_ppat_entry(ppat, 0, GEN8_PPAT_WB | GEN8_PPAT_LLC); /* for normal objects, no eLLC */
3244 __alloc_ppat_entry(ppat, 1, GEN8_PPAT_WC | GEN8_PPAT_LLCELLC); /* for something pointing to ptes? */
3245 __alloc_ppat_entry(ppat, 2, GEN8_PPAT_WT | GEN8_PPAT_LLCELLC); /* for scanout with eLLC */
3246 __alloc_ppat_entry(ppat, 3, GEN8_PPAT_UC); /* Uncached objects, mostly for scanout */
3247 __alloc_ppat_entry(ppat, 4, GEN8_PPAT_WB | GEN8_PPAT_LLCELLC | GEN8_PPAT_AGE(0));
3248 __alloc_ppat_entry(ppat, 5, GEN8_PPAT_WB | GEN8_PPAT_LLCELLC | GEN8_PPAT_AGE(1));
3249 __alloc_ppat_entry(ppat, 6, GEN8_PPAT_WB | GEN8_PPAT_LLCELLC | GEN8_PPAT_AGE(2));
3250 __alloc_ppat_entry(ppat, 7, GEN8_PPAT_WB | GEN8_PPAT_LLCELLC | GEN8_PPAT_AGE(3));
3253 static void chv_setup_private_ppat(struct intel_ppat *ppat)
3255 ppat->max_entries = 8;
3256 ppat->update_hw = bdw_private_pat_update_hw;
3257 ppat->match = chv_private_pat_match;
3258 ppat->clear_value = CHV_PPAT_SNOOP;
3261 * Map WB on BDW to snooped on CHV.
3263 * Only the snoop bit has meaning for CHV, the rest is
3266 * The hardware will never snoop for certain types of accesses:
3267 * - CPU GTT (GMADR->GGTT->no snoop->memory)
3268 * - PPGTT page tables
3269 * - some other special cycles
3271 * As with BDW, we also need to consider the following for GT accesses:
3272 * "For GGTT, there is NO pat_sel[2:0] from the entry,
3273 * so RTL will always use the value corresponding to
3275 * Which means we must set the snoop bit in PAT entry 0
3276 * in order to keep the global status page working.
3279 __alloc_ppat_entry(ppat, 0, CHV_PPAT_SNOOP);
3280 __alloc_ppat_entry(ppat, 1, 0);
3281 __alloc_ppat_entry(ppat, 2, 0);
3282 __alloc_ppat_entry(ppat, 3, 0);
3283 __alloc_ppat_entry(ppat, 4, CHV_PPAT_SNOOP);
3284 __alloc_ppat_entry(ppat, 5, CHV_PPAT_SNOOP);
3285 __alloc_ppat_entry(ppat, 6, CHV_PPAT_SNOOP);
3286 __alloc_ppat_entry(ppat, 7, CHV_PPAT_SNOOP);
3289 static void gen6_gmch_remove(struct i915_address_space *vm)
3291 struct i915_ggtt *ggtt = i915_vm_to_ggtt(vm);
3294 cleanup_scratch_page(vm);
3297 static void setup_private_pat(struct drm_i915_private *dev_priv)
3299 struct intel_ppat *ppat = &dev_priv->ppat;
3302 ppat->i915 = dev_priv;
3304 if (INTEL_GEN(dev_priv) >= 10)
3305 cnl_setup_private_ppat(ppat);
3306 else if (IS_CHERRYVIEW(dev_priv) || IS_GEN9_LP(dev_priv))
3307 chv_setup_private_ppat(ppat);
3309 bdw_setup_private_ppat(ppat);
3311 GEM_BUG_ON(ppat->max_entries > INTEL_MAX_PPAT_ENTRIES);
3313 for_each_clear_bit(i, ppat->used, ppat->max_entries) {
3314 ppat->entries[i].value = ppat->clear_value;
3315 ppat->entries[i].ppat = ppat;
3316 set_bit(i, ppat->dirty);
3319 ppat->update_hw(dev_priv);
3322 static int gen8_gmch_probe(struct i915_ggtt *ggtt)
3324 struct drm_i915_private *dev_priv = ggtt->vm.i915;
3325 struct pci_dev *pdev = dev_priv->drm.pdev;
3330 /* TODO: We're not aware of mappable constraints on gen8 yet */
3332 (struct resource) DEFINE_RES_MEM(pci_resource_start(pdev, 2),
3333 pci_resource_len(pdev, 2));
3334 ggtt->mappable_end = resource_size(&ggtt->gmadr);
3336 err = pci_set_dma_mask(pdev, DMA_BIT_MASK(39));
3338 err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(39));
3340 DRM_ERROR("Can't set DMA mask/consistent mask (%d)\n", err);
3342 pci_read_config_word(pdev, SNB_GMCH_CTRL, &snb_gmch_ctl);
3343 if (IS_CHERRYVIEW(dev_priv))
3344 size = chv_get_total_gtt_size(snb_gmch_ctl);
3346 size = gen8_get_total_gtt_size(snb_gmch_ctl);
3348 ggtt->vm.total = (size / sizeof(gen8_pte_t)) * I915_GTT_PAGE_SIZE;
3349 ggtt->vm.cleanup = gen6_gmch_remove;
3350 ggtt->vm.insert_page = gen8_ggtt_insert_page;
3351 ggtt->vm.clear_range = nop_clear_range;
3352 if (intel_scanout_needs_vtd_wa(dev_priv))
3353 ggtt->vm.clear_range = gen8_ggtt_clear_range;
3355 ggtt->vm.insert_entries = gen8_ggtt_insert_entries;
3357 /* Serialize GTT updates with aperture access on BXT if VT-d is on. */
3358 if (intel_ggtt_update_needs_vtd_wa(dev_priv)) {
3359 ggtt->vm.insert_entries = bxt_vtd_ggtt_insert_entries__BKL;
3360 ggtt->vm.insert_page = bxt_vtd_ggtt_insert_page__BKL;
3361 if (ggtt->vm.clear_range != nop_clear_range)
3362 ggtt->vm.clear_range = bxt_vtd_ggtt_clear_range__BKL;
3364 /* Prevent recursively calling stop_machine() and deadlocks. */
3365 dev_info(dev_priv->drm.dev,
3366 "Disabling error capture for VT-d workaround\n");
3367 i915_disable_error_state(dev_priv, -ENODEV);
3370 ggtt->invalidate = gen6_ggtt_invalidate;
3372 ggtt->vm.vma_ops.bind_vma = ggtt_bind_vma;
3373 ggtt->vm.vma_ops.unbind_vma = ggtt_unbind_vma;
3374 ggtt->vm.vma_ops.set_pages = ggtt_set_pages;
3375 ggtt->vm.vma_ops.clear_pages = clear_pages;
3377 ggtt->vm.pte_encode = gen8_pte_encode;
3379 setup_private_pat(dev_priv);
3381 return ggtt_probe_common(ggtt, size);
3384 static int gen6_gmch_probe(struct i915_ggtt *ggtt)
3386 struct drm_i915_private *dev_priv = ggtt->vm.i915;
3387 struct pci_dev *pdev = dev_priv->drm.pdev;
3393 (struct resource) DEFINE_RES_MEM(pci_resource_start(pdev, 2),
3394 pci_resource_len(pdev, 2));
3395 ggtt->mappable_end = resource_size(&ggtt->gmadr);
3397 /* 64/512MB is the current min/max we actually know of, but this is just
3398 * a coarse sanity check.
3400 if (ggtt->mappable_end < (64<<20) || ggtt->mappable_end > (512<<20)) {
3401 DRM_ERROR("Unknown GMADR size (%pa)\n", &ggtt->mappable_end);
3405 err = pci_set_dma_mask(pdev, DMA_BIT_MASK(40));
3407 err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(40));
3409 DRM_ERROR("Can't set DMA mask/consistent mask (%d)\n", err);
3410 pci_read_config_word(pdev, SNB_GMCH_CTRL, &snb_gmch_ctl);
3412 size = gen6_get_total_gtt_size(snb_gmch_ctl);
3413 ggtt->vm.total = (size / sizeof(gen6_pte_t)) * I915_GTT_PAGE_SIZE;
3415 ggtt->vm.clear_range = gen6_ggtt_clear_range;
3416 ggtt->vm.insert_page = gen6_ggtt_insert_page;
3417 ggtt->vm.insert_entries = gen6_ggtt_insert_entries;
3418 ggtt->vm.cleanup = gen6_gmch_remove;
3420 ggtt->invalidate = gen6_ggtt_invalidate;
3422 if (HAS_EDRAM(dev_priv))
3423 ggtt->vm.pte_encode = iris_pte_encode;
3424 else if (IS_HASWELL(dev_priv))
3425 ggtt->vm.pte_encode = hsw_pte_encode;
3426 else if (IS_VALLEYVIEW(dev_priv))
3427 ggtt->vm.pte_encode = byt_pte_encode;
3428 else if (INTEL_GEN(dev_priv) >= 7)
3429 ggtt->vm.pte_encode = ivb_pte_encode;
3431 ggtt->vm.pte_encode = snb_pte_encode;
3433 ggtt->vm.vma_ops.bind_vma = ggtt_bind_vma;
3434 ggtt->vm.vma_ops.unbind_vma = ggtt_unbind_vma;
3435 ggtt->vm.vma_ops.set_pages = ggtt_set_pages;
3436 ggtt->vm.vma_ops.clear_pages = clear_pages;
3438 return ggtt_probe_common(ggtt, size);
3441 static void i915_gmch_remove(struct i915_address_space *vm)
3443 intel_gmch_remove();
3446 static int i915_gmch_probe(struct i915_ggtt *ggtt)
3448 struct drm_i915_private *dev_priv = ggtt->vm.i915;
3449 phys_addr_t gmadr_base;
3452 ret = intel_gmch_probe(dev_priv->bridge_dev, dev_priv->drm.pdev, NULL);
3454 DRM_ERROR("failed to set up gmch\n");
3458 intel_gtt_get(&ggtt->vm.total, &gmadr_base, &ggtt->mappable_end);
3461 (struct resource) DEFINE_RES_MEM(gmadr_base,
3462 ggtt->mappable_end);
3464 ggtt->do_idle_maps = needs_idle_maps(dev_priv);
3465 ggtt->vm.insert_page = i915_ggtt_insert_page;
3466 ggtt->vm.insert_entries = i915_ggtt_insert_entries;
3467 ggtt->vm.clear_range = i915_ggtt_clear_range;
3468 ggtt->vm.cleanup = i915_gmch_remove;
3470 ggtt->invalidate = gmch_ggtt_invalidate;
3472 ggtt->vm.vma_ops.bind_vma = ggtt_bind_vma;
3473 ggtt->vm.vma_ops.unbind_vma = ggtt_unbind_vma;
3474 ggtt->vm.vma_ops.set_pages = ggtt_set_pages;
3475 ggtt->vm.vma_ops.clear_pages = clear_pages;
3477 if (unlikely(ggtt->do_idle_maps))
3478 DRM_INFO("applying Ironlake quirks for intel_iommu\n");
3484 * i915_ggtt_probe_hw - Probe GGTT hardware location
3485 * @dev_priv: i915 device
3487 int i915_ggtt_probe_hw(struct drm_i915_private *dev_priv)
3489 struct i915_ggtt *ggtt = &dev_priv->ggtt;
3492 ggtt->vm.i915 = dev_priv;
3493 ggtt->vm.dma = &dev_priv->drm.pdev->dev;
3495 if (INTEL_GEN(dev_priv) <= 5)
3496 ret = i915_gmch_probe(ggtt);
3497 else if (INTEL_GEN(dev_priv) < 8)
3498 ret = gen6_gmch_probe(ggtt);
3500 ret = gen8_gmch_probe(ggtt);
3504 /* Trim the GGTT to fit the GuC mappable upper range (when enabled).
3505 * This is easier than doing range restriction on the fly, as we
3506 * currently don't have any bits spare to pass in this upper
3509 if (USES_GUC(dev_priv)) {
3510 ggtt->vm.total = min_t(u64, ggtt->vm.total, GUC_GGTT_TOP);
3511 ggtt->mappable_end =
3512 min_t(u64, ggtt->mappable_end, ggtt->vm.total);
3515 if ((ggtt->vm.total - 1) >> 32) {
3516 DRM_ERROR("We never expected a Global GTT with more than 32bits"
3517 " of address space! Found %lldM!\n",
3518 ggtt->vm.total >> 20);
3519 ggtt->vm.total = 1ULL << 32;
3520 ggtt->mappable_end =
3521 min_t(u64, ggtt->mappable_end, ggtt->vm.total);
3524 if (ggtt->mappable_end > ggtt->vm.total) {
3525 DRM_ERROR("mappable aperture extends past end of GGTT,"
3526 " aperture=%pa, total=%llx\n",
3527 &ggtt->mappable_end, ggtt->vm.total);
3528 ggtt->mappable_end = ggtt->vm.total;
3531 /* GMADR is the PCI mmio aperture into the global GTT. */
3532 DRM_DEBUG_DRIVER("GGTT size = %lluM\n", ggtt->vm.total >> 20);
3533 DRM_DEBUG_DRIVER("GMADR size = %lluM\n", (u64)ggtt->mappable_end >> 20);
3534 DRM_DEBUG_DRIVER("DSM size = %lluM\n",
3535 (u64)resource_size(&intel_graphics_stolen_res) >> 20);
3536 if (intel_vtd_active())
3537 DRM_INFO("VT-d active for gfx access\n");
3543 * i915_ggtt_init_hw - Initialize GGTT hardware
3544 * @dev_priv: i915 device
3546 int i915_ggtt_init_hw(struct drm_i915_private *dev_priv)
3548 struct i915_ggtt *ggtt = &dev_priv->ggtt;
3551 stash_init(&dev_priv->mm.wc_stash);
3553 /* Note that we use page colouring to enforce a guard page at the
3554 * end of the address space. This is required as the CS may prefetch
3555 * beyond the end of the batch buffer, across the page boundary,
3556 * and beyond the end of the GTT if we do not provide a guard.
3558 mutex_lock(&dev_priv->drm.struct_mutex);
3559 i915_address_space_init(&ggtt->vm, dev_priv);
3561 ggtt->vm.is_ggtt = true;
3563 /* Only VLV supports read-only GGTT mappings */
3564 ggtt->vm.has_read_only = IS_VALLEYVIEW(dev_priv);
3566 if (!HAS_LLC(dev_priv) && !HAS_PPGTT(dev_priv))
3567 ggtt->vm.mm.color_adjust = i915_gtt_color_adjust;
3568 mutex_unlock(&dev_priv->drm.struct_mutex);
3570 if (!io_mapping_init_wc(&dev_priv->ggtt.iomap,
3571 dev_priv->ggtt.gmadr.start,
3572 dev_priv->ggtt.mappable_end)) {
3574 goto out_gtt_cleanup;
3577 ggtt->mtrr = arch_phys_wc_add(ggtt->gmadr.start, ggtt->mappable_end);
3580 * Initialise stolen early so that we may reserve preallocated
3581 * objects for the BIOS to KMS transition.
3583 ret = i915_gem_init_stolen(dev_priv);
3585 goto out_gtt_cleanup;
3590 ggtt->vm.cleanup(&ggtt->vm);
3594 int i915_ggtt_enable_hw(struct drm_i915_private *dev_priv)
3596 if (INTEL_GEN(dev_priv) < 6 && !intel_enable_gtt())
3602 void i915_ggtt_enable_guc(struct drm_i915_private *i915)
3604 GEM_BUG_ON(i915->ggtt.invalidate != gen6_ggtt_invalidate);
3606 i915->ggtt.invalidate = guc_ggtt_invalidate;
3608 i915_ggtt_invalidate(i915);
3611 void i915_ggtt_disable_guc(struct drm_i915_private *i915)
3613 /* XXX Temporary pardon for error unload */
3614 if (i915->ggtt.invalidate == gen6_ggtt_invalidate)
3617 /* We should only be called after i915_ggtt_enable_guc() */
3618 GEM_BUG_ON(i915->ggtt.invalidate != guc_ggtt_invalidate);
3620 i915->ggtt.invalidate = gen6_ggtt_invalidate;
3622 i915_ggtt_invalidate(i915);
3625 void i915_gem_restore_gtt_mappings(struct drm_i915_private *dev_priv)
3627 struct i915_ggtt *ggtt = &dev_priv->ggtt;
3628 struct i915_vma *vma, *vn;
3630 i915_check_and_clear_faults(dev_priv);
3632 /* First fill our portion of the GTT with scratch pages */
3633 ggtt->vm.clear_range(&ggtt->vm, 0, ggtt->vm.total);
3635 ggtt->vm.closed = true; /* skip rewriting PTE on VMA unbind */
3637 /* clflush objects bound into the GGTT and rebind them. */
3638 GEM_BUG_ON(!list_empty(&ggtt->vm.active_list));
3639 list_for_each_entry_safe(vma, vn, &ggtt->vm.inactive_list, vm_link) {
3640 struct drm_i915_gem_object *obj = vma->obj;
3642 if (!(vma->flags & I915_VMA_GLOBAL_BIND))
3645 if (!i915_vma_unbind(vma))
3648 WARN_ON(i915_vma_bind(vma,
3649 obj ? obj->cache_level : 0,
3652 WARN_ON(i915_gem_object_set_to_gtt_domain(obj, false));
3655 ggtt->vm.closed = false;
3656 i915_ggtt_invalidate(dev_priv);
3658 if (INTEL_GEN(dev_priv) >= 8) {
3659 struct intel_ppat *ppat = &dev_priv->ppat;
3661 bitmap_set(ppat->dirty, 0, ppat->max_entries);
3662 dev_priv->ppat.update_hw(dev_priv);
3667 static struct scatterlist *
3668 rotate_pages(struct drm_i915_gem_object *obj, unsigned int offset,
3669 unsigned int width, unsigned int height,
3670 unsigned int stride,
3671 struct sg_table *st, struct scatterlist *sg)
3673 unsigned int column, row;
3674 unsigned int src_idx;
3676 for (column = 0; column < width; column++) {
3677 src_idx = stride * (height - 1) + column + offset;
3678 for (row = 0; row < height; row++) {
3680 /* We don't need the pages, but need to initialize
3681 * the entries so the sg list can be happily traversed.
3682 * The only thing we need are DMA addresses.
3684 sg_set_page(sg, NULL, I915_GTT_PAGE_SIZE, 0);
3685 sg_dma_address(sg) =
3686 i915_gem_object_get_dma_address(obj, src_idx);
3687 sg_dma_len(sg) = I915_GTT_PAGE_SIZE;
3696 static noinline struct sg_table *
3697 intel_rotate_pages(struct intel_rotation_info *rot_info,
3698 struct drm_i915_gem_object *obj)
3700 unsigned int size = intel_rotation_info_size(rot_info);
3701 struct sg_table *st;
3702 struct scatterlist *sg;
3706 /* Allocate target SG list. */
3707 st = kmalloc(sizeof(*st), GFP_KERNEL);
3711 ret = sg_alloc_table(st, size, GFP_KERNEL);
3718 for (i = 0 ; i < ARRAY_SIZE(rot_info->plane); i++) {
3719 sg = rotate_pages(obj, rot_info->plane[i].offset,
3720 rot_info->plane[i].width, rot_info->plane[i].height,
3721 rot_info->plane[i].stride, st, sg);
3730 DRM_DEBUG_DRIVER("Failed to create rotated mapping for object size %zu! (%ux%u tiles, %u pages)\n",
3731 obj->base.size, rot_info->plane[0].width, rot_info->plane[0].height, size);
3733 return ERR_PTR(ret);
3736 static noinline struct sg_table *
3737 intel_partial_pages(const struct i915_ggtt_view *view,
3738 struct drm_i915_gem_object *obj)
3740 struct sg_table *st;
3741 struct scatterlist *sg, *iter;
3742 unsigned int count = view->partial.size;
3743 unsigned int offset;
3746 st = kmalloc(sizeof(*st), GFP_KERNEL);
3750 ret = sg_alloc_table(st, count, GFP_KERNEL);
3754 iter = i915_gem_object_get_sg(obj, view->partial.offset, &offset);
3762 len = min(iter->length - (offset << PAGE_SHIFT),
3763 count << PAGE_SHIFT);
3764 sg_set_page(sg, NULL, len, 0);
3765 sg_dma_address(sg) =
3766 sg_dma_address(iter) + (offset << PAGE_SHIFT);
3767 sg_dma_len(sg) = len;
3770 count -= len >> PAGE_SHIFT;
3773 i915_sg_trim(st); /* Drop any unused tail entries. */
3779 iter = __sg_next(iter);
3786 return ERR_PTR(ret);
3790 i915_get_ggtt_vma_pages(struct i915_vma *vma)
3794 /* The vma->pages are only valid within the lifespan of the borrowed
3795 * obj->mm.pages. When the obj->mm.pages sg_table is regenerated, so
3796 * must be the vma->pages. A simple rule is that vma->pages must only
3797 * be accessed when the obj->mm.pages are pinned.
3799 GEM_BUG_ON(!i915_gem_object_has_pinned_pages(vma->obj));
3801 switch (vma->ggtt_view.type) {
3803 GEM_BUG_ON(vma->ggtt_view.type);
3805 case I915_GGTT_VIEW_NORMAL:
3806 vma->pages = vma->obj->mm.pages;
3809 case I915_GGTT_VIEW_ROTATED:
3811 intel_rotate_pages(&vma->ggtt_view.rotated, vma->obj);
3814 case I915_GGTT_VIEW_PARTIAL:
3815 vma->pages = intel_partial_pages(&vma->ggtt_view, vma->obj);
3820 if (unlikely(IS_ERR(vma->pages))) {
3821 ret = PTR_ERR(vma->pages);
3823 DRM_ERROR("Failed to get pages for VMA view type %u (%d)!\n",
3824 vma->ggtt_view.type, ret);
3830 * i915_gem_gtt_reserve - reserve a node in an address_space (GTT)
3831 * @vm: the &struct i915_address_space
3832 * @node: the &struct drm_mm_node (typically i915_vma.mode)
3833 * @size: how much space to allocate inside the GTT,
3834 * must be #I915_GTT_PAGE_SIZE aligned
3835 * @offset: where to insert inside the GTT,
3836 * must be #I915_GTT_MIN_ALIGNMENT aligned, and the node
3837 * (@offset + @size) must fit within the address space
3838 * @color: color to apply to node, if this node is not from a VMA,
3839 * color must be #I915_COLOR_UNEVICTABLE
3840 * @flags: control search and eviction behaviour
3842 * i915_gem_gtt_reserve() tries to insert the @node at the exact @offset inside
3843 * the address space (using @size and @color). If the @node does not fit, it
3844 * tries to evict any overlapping nodes from the GTT, including any
3845 * neighbouring nodes if the colors do not match (to ensure guard pages between
3846 * differing domains). See i915_gem_evict_for_node() for the gory details
3847 * on the eviction algorithm. #PIN_NONBLOCK may used to prevent waiting on
3848 * evicting active overlapping objects, and any overlapping node that is pinned
3849 * or marked as unevictable will also result in failure.
3851 * Returns: 0 on success, -ENOSPC if no suitable hole is found, -EINTR if
3852 * asked to wait for eviction and interrupted.
3854 int i915_gem_gtt_reserve(struct i915_address_space *vm,
3855 struct drm_mm_node *node,
3856 u64 size, u64 offset, unsigned long color,
3862 GEM_BUG_ON(!IS_ALIGNED(size, I915_GTT_PAGE_SIZE));
3863 GEM_BUG_ON(!IS_ALIGNED(offset, I915_GTT_MIN_ALIGNMENT));
3864 GEM_BUG_ON(range_overflows(offset, size, vm->total));
3865 GEM_BUG_ON(vm == &vm->i915->mm.aliasing_ppgtt->vm);
3866 GEM_BUG_ON(drm_mm_node_allocated(node));
3869 node->start = offset;
3870 node->color = color;
3872 err = drm_mm_reserve_node(&vm->mm, node);
3876 if (flags & PIN_NOEVICT)
3879 err = i915_gem_evict_for_node(vm, node, flags);
3881 err = drm_mm_reserve_node(&vm->mm, node);
3886 static u64 random_offset(u64 start, u64 end, u64 len, u64 align)
3890 GEM_BUG_ON(range_overflows(start, len, end));
3891 GEM_BUG_ON(round_up(start, align) > round_down(end - len, align));
3893 range = round_down(end - len, align) - round_up(start, align);
3895 if (sizeof(unsigned long) == sizeof(u64)) {
3896 addr = get_random_long();
3898 addr = get_random_int();
3899 if (range > U32_MAX) {
3901 addr |= get_random_int();
3904 div64_u64_rem(addr, range, &addr);
3908 return round_up(start, align);
3912 * i915_gem_gtt_insert - insert a node into an address_space (GTT)
3913 * @vm: the &struct i915_address_space
3914 * @node: the &struct drm_mm_node (typically i915_vma.node)
3915 * @size: how much space to allocate inside the GTT,
3916 * must be #I915_GTT_PAGE_SIZE aligned
3917 * @alignment: required alignment of starting offset, may be 0 but
3918 * if specified, this must be a power-of-two and at least
3919 * #I915_GTT_MIN_ALIGNMENT
3920 * @color: color to apply to node
3921 * @start: start of any range restriction inside GTT (0 for all),
3922 * must be #I915_GTT_PAGE_SIZE aligned
3923 * @end: end of any range restriction inside GTT (U64_MAX for all),
3924 * must be #I915_GTT_PAGE_SIZE aligned if not U64_MAX
3925 * @flags: control search and eviction behaviour
3927 * i915_gem_gtt_insert() first searches for an available hole into which
3928 * is can insert the node. The hole address is aligned to @alignment and
3929 * its @size must then fit entirely within the [@start, @end] bounds. The
3930 * nodes on either side of the hole must match @color, or else a guard page
3931 * will be inserted between the two nodes (or the node evicted). If no
3932 * suitable hole is found, first a victim is randomly selected and tested
3933 * for eviction, otherwise then the LRU list of objects within the GTT
3934 * is scanned to find the first set of replacement nodes to create the hole.
3935 * Those old overlapping nodes are evicted from the GTT (and so must be
3936 * rebound before any future use). Any node that is currently pinned cannot
3937 * be evicted (see i915_vma_pin()). Similar if the node's VMA is currently
3938 * active and #PIN_NONBLOCK is specified, that node is also skipped when
3939 * searching for an eviction candidate. See i915_gem_evict_something() for
3940 * the gory details on the eviction algorithm.
3942 * Returns: 0 on success, -ENOSPC if no suitable hole is found, -EINTR if
3943 * asked to wait for eviction and interrupted.
3945 int i915_gem_gtt_insert(struct i915_address_space *vm,
3946 struct drm_mm_node *node,
3947 u64 size, u64 alignment, unsigned long color,
3948 u64 start, u64 end, unsigned int flags)
3950 enum drm_mm_insert_mode mode;
3954 lockdep_assert_held(&vm->i915->drm.struct_mutex);
3956 GEM_BUG_ON(!IS_ALIGNED(size, I915_GTT_PAGE_SIZE));
3957 GEM_BUG_ON(alignment && !is_power_of_2(alignment));
3958 GEM_BUG_ON(alignment && !IS_ALIGNED(alignment, I915_GTT_MIN_ALIGNMENT));
3959 GEM_BUG_ON(start >= end);
3960 GEM_BUG_ON(start > 0 && !IS_ALIGNED(start, I915_GTT_PAGE_SIZE));
3961 GEM_BUG_ON(end < U64_MAX && !IS_ALIGNED(end, I915_GTT_PAGE_SIZE));
3962 GEM_BUG_ON(vm == &vm->i915->mm.aliasing_ppgtt->vm);
3963 GEM_BUG_ON(drm_mm_node_allocated(node));
3965 if (unlikely(range_overflows(start, size, end)))
3968 if (unlikely(round_up(start, alignment) > round_down(end - size, alignment)))
3971 mode = DRM_MM_INSERT_BEST;
3972 if (flags & PIN_HIGH)
3973 mode = DRM_MM_INSERT_HIGHEST;
3974 if (flags & PIN_MAPPABLE)
3975 mode = DRM_MM_INSERT_LOW;
3977 /* We only allocate in PAGE_SIZE/GTT_PAGE_SIZE (4096) chunks,
3978 * so we know that we always have a minimum alignment of 4096.
3979 * The drm_mm range manager is optimised to return results
3980 * with zero alignment, so where possible use the optimal
3983 BUILD_BUG_ON(I915_GTT_MIN_ALIGNMENT > I915_GTT_PAGE_SIZE);
3984 if (alignment <= I915_GTT_MIN_ALIGNMENT)
3987 err = drm_mm_insert_node_in_range(&vm->mm, node,
3988 size, alignment, color,
3993 if (mode & DRM_MM_INSERT_ONCE) {
3994 err = drm_mm_insert_node_in_range(&vm->mm, node,
3995 size, alignment, color,
3997 DRM_MM_INSERT_BEST);
4002 if (flags & PIN_NOEVICT)
4005 /* No free space, pick a slot at random.
4007 * There is a pathological case here using a GTT shared between
4008 * mmap and GPU (i.e. ggtt/aliasing_ppgtt but not full-ppgtt):
4010 * |<-- 256 MiB aperture -->||<-- 1792 MiB unmappable -->|
4011 * (64k objects) (448k objects)
4013 * Now imagine that the eviction LRU is ordered top-down (just because
4014 * pathology meets real life), and that we need to evict an object to
4015 * make room inside the aperture. The eviction scan then has to walk
4016 * the 448k list before it finds one within range. And now imagine that
4017 * it has to search for a new hole between every byte inside the memcpy,
4018 * for several simultaneous clients.
4020 * On a full-ppgtt system, if we have run out of available space, there
4021 * will be lots and lots of objects in the eviction list! Again,
4022 * searching that LRU list may be slow if we are also applying any
4023 * range restrictions (e.g. restriction to low 4GiB) and so, for
4024 * simplicity and similarilty between different GTT, try the single
4025 * random replacement first.
4027 offset = random_offset(start, end,
4028 size, alignment ?: I915_GTT_MIN_ALIGNMENT);
4029 err = i915_gem_gtt_reserve(vm, node, size, offset, color, flags);
4033 /* Randomly selected placement is pinned, do a search */
4034 err = i915_gem_evict_something(vm, size, alignment, color,
4039 return drm_mm_insert_node_in_range(&vm->mm, node,
4040 size, alignment, color,
4041 start, end, DRM_MM_INSERT_EVICT);
4044 #if IS_ENABLED(CONFIG_DRM_I915_SELFTEST)
4045 #include "selftests/mock_gtt.c"
4046 #include "selftests/i915_gem_gtt.c"