2010-11-05 21:23:30 +00:00
|
|
|
/*
|
|
|
|
* Copyright © 2010 Daniel Vetter
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
|
|
* to deal in the Software without restriction, including without limitation
|
|
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice (including the next
|
|
|
|
* paragraph) shall be included in all copies or substantial portions of the
|
|
|
|
* Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
|
|
* IN THE SOFTWARE.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2012-10-02 17:01:07 +00:00
|
|
|
#include <drm/drmP.h>
|
|
|
|
#include <drm/i915_drm.h>
|
2010-11-05 21:23:30 +00:00
|
|
|
#include "i915_drv.h"
|
|
|
|
#include "i915_trace.h"
|
|
|
|
#include "intel_drv.h"
|
|
|
|
|
2012-02-09 16:15:46 +00:00
|
|
|
/* PPGTT support for Sandybdrige/Gen6 and later */
|
|
|
|
static void i915_ppgtt_clear_range(struct i915_hw_ppgtt *ppgtt,
|
|
|
|
unsigned first_entry,
|
|
|
|
unsigned num_entries)
|
|
|
|
{
|
|
|
|
uint32_t *pt_vaddr;
|
|
|
|
uint32_t scratch_pte;
|
2012-02-09 16:15:47 +00:00
|
|
|
unsigned act_pd = first_entry / I915_PPGTT_PT_ENTRIES;
|
|
|
|
unsigned first_pte = first_entry % I915_PPGTT_PT_ENTRIES;
|
|
|
|
unsigned last_pte, i;
|
2012-02-09 16:15:46 +00:00
|
|
|
|
|
|
|
scratch_pte = GEN6_PTE_ADDR_ENCODE(ppgtt->scratch_page_dma_addr);
|
|
|
|
scratch_pte |= GEN6_PTE_VALID | GEN6_PTE_CACHE_LLC;
|
|
|
|
|
2012-02-09 16:15:47 +00:00
|
|
|
while (num_entries) {
|
|
|
|
last_pte = first_pte + num_entries;
|
|
|
|
if (last_pte > I915_PPGTT_PT_ENTRIES)
|
|
|
|
last_pte = I915_PPGTT_PT_ENTRIES;
|
|
|
|
|
|
|
|
pt_vaddr = kmap_atomic(ppgtt->pt_pages[act_pd]);
|
2012-02-09 16:15:46 +00:00
|
|
|
|
2012-02-09 16:15:47 +00:00
|
|
|
for (i = first_pte; i < last_pte; i++)
|
|
|
|
pt_vaddr[i] = scratch_pte;
|
2012-02-09 16:15:46 +00:00
|
|
|
|
|
|
|
kunmap_atomic(pt_vaddr);
|
|
|
|
|
2012-02-09 16:15:47 +00:00
|
|
|
num_entries -= last_pte - first_pte;
|
|
|
|
first_pte = 0;
|
|
|
|
act_pd++;
|
|
|
|
}
|
2012-02-09 16:15:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int i915_gem_init_aliasing_ppgtt(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
struct i915_hw_ppgtt *ppgtt;
|
|
|
|
unsigned first_pd_entry_in_global_pt;
|
|
|
|
int i;
|
|
|
|
int ret = -ENOMEM;
|
|
|
|
|
|
|
|
/* ppgtt PDEs reside in the global gtt pagetable, which has 512*1024
|
|
|
|
* entries. For aliasing ppgtt support we just steal them at the end for
|
|
|
|
* now. */
|
2012-08-24 08:12:22 +00:00
|
|
|
first_pd_entry_in_global_pt = dev_priv->mm.gtt->gtt_total_entries - I915_PPGTT_PD_ENTRIES;
|
2012-02-09 16:15:46 +00:00
|
|
|
|
|
|
|
ppgtt = kzalloc(sizeof(*ppgtt), GFP_KERNEL);
|
|
|
|
if (!ppgtt)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
ppgtt->num_pd_entries = I915_PPGTT_PD_ENTRIES;
|
|
|
|
ppgtt->pt_pages = kzalloc(sizeof(struct page *)*ppgtt->num_pd_entries,
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!ppgtt->pt_pages)
|
|
|
|
goto err_ppgtt;
|
|
|
|
|
|
|
|
for (i = 0; i < ppgtt->num_pd_entries; i++) {
|
|
|
|
ppgtt->pt_pages[i] = alloc_page(GFP_KERNEL);
|
|
|
|
if (!ppgtt->pt_pages[i])
|
|
|
|
goto err_pt_alloc;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dev_priv->mm.gtt->needs_dmar) {
|
|
|
|
ppgtt->pt_dma_addr = kzalloc(sizeof(dma_addr_t)
|
|
|
|
*ppgtt->num_pd_entries,
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!ppgtt->pt_dma_addr)
|
|
|
|
goto err_pt_alloc;
|
|
|
|
|
2012-04-10 15:29:17 +00:00
|
|
|
for (i = 0; i < ppgtt->num_pd_entries; i++) {
|
|
|
|
dma_addr_t pt_addr;
|
|
|
|
|
2012-02-09 16:15:46 +00:00
|
|
|
pt_addr = pci_map_page(dev->pdev, ppgtt->pt_pages[i],
|
|
|
|
0, 4096,
|
|
|
|
PCI_DMA_BIDIRECTIONAL);
|
|
|
|
|
|
|
|
if (pci_dma_mapping_error(dev->pdev,
|
|
|
|
pt_addr)) {
|
|
|
|
ret = -EIO;
|
|
|
|
goto err_pd_pin;
|
|
|
|
|
|
|
|
}
|
|
|
|
ppgtt->pt_dma_addr[i] = pt_addr;
|
2012-04-10 15:29:17 +00:00
|
|
|
}
|
2012-02-09 16:15:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ppgtt->scratch_page_dma_addr = dev_priv->mm.gtt->scratch_page_dma;
|
|
|
|
|
|
|
|
i915_ppgtt_clear_range(ppgtt, 0,
|
|
|
|
ppgtt->num_pd_entries*I915_PPGTT_PT_ENTRIES);
|
|
|
|
|
|
|
|
ppgtt->pd_offset = (first_pd_entry_in_global_pt)*sizeof(uint32_t);
|
|
|
|
|
|
|
|
dev_priv->mm.aliasing_ppgtt = ppgtt;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_pd_pin:
|
|
|
|
if (ppgtt->pt_dma_addr) {
|
|
|
|
for (i--; i >= 0; i--)
|
|
|
|
pci_unmap_page(dev->pdev, ppgtt->pt_dma_addr[i],
|
|
|
|
4096, PCI_DMA_BIDIRECTIONAL);
|
|
|
|
}
|
|
|
|
err_pt_alloc:
|
|
|
|
kfree(ppgtt->pt_dma_addr);
|
|
|
|
for (i = 0; i < ppgtt->num_pd_entries; i++) {
|
|
|
|
if (ppgtt->pt_pages[i])
|
|
|
|
__free_page(ppgtt->pt_pages[i]);
|
|
|
|
}
|
|
|
|
kfree(ppgtt->pt_pages);
|
|
|
|
err_ppgtt:
|
|
|
|
kfree(ppgtt);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
void i915_gem_cleanup_aliasing_ppgtt(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
struct i915_hw_ppgtt *ppgtt = dev_priv->mm.aliasing_ppgtt;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!ppgtt)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (ppgtt->pt_dma_addr) {
|
|
|
|
for (i = 0; i < ppgtt->num_pd_entries; i++)
|
|
|
|
pci_unmap_page(dev->pdev, ppgtt->pt_dma_addr[i],
|
|
|
|
4096, PCI_DMA_BIDIRECTIONAL);
|
|
|
|
}
|
|
|
|
|
|
|
|
kfree(ppgtt->pt_dma_addr);
|
|
|
|
for (i = 0; i < ppgtt->num_pd_entries; i++)
|
|
|
|
__free_page(ppgtt->pt_pages[i]);
|
|
|
|
kfree(ppgtt->pt_pages);
|
|
|
|
kfree(ppgtt);
|
|
|
|
}
|
|
|
|
|
2012-02-09 16:15:47 +00:00
|
|
|
static void i915_ppgtt_insert_sg_entries(struct i915_hw_ppgtt *ppgtt,
|
2012-06-01 14:20:22 +00:00
|
|
|
const struct sg_table *pages,
|
2012-02-09 16:15:47 +00:00
|
|
|
unsigned first_entry,
|
|
|
|
uint32_t pte_flags)
|
|
|
|
{
|
|
|
|
uint32_t *pt_vaddr, pte;
|
|
|
|
unsigned act_pd = first_entry / I915_PPGTT_PT_ENTRIES;
|
|
|
|
unsigned first_pte = first_entry % I915_PPGTT_PT_ENTRIES;
|
|
|
|
unsigned i, j, m, segment_len;
|
|
|
|
dma_addr_t page_addr;
|
|
|
|
struct scatterlist *sg;
|
|
|
|
|
|
|
|
/* init sg walking */
|
2012-06-01 14:20:22 +00:00
|
|
|
sg = pages->sgl;
|
2012-02-09 16:15:47 +00:00
|
|
|
i = 0;
|
|
|
|
segment_len = sg_dma_len(sg) >> PAGE_SHIFT;
|
|
|
|
m = 0;
|
|
|
|
|
2012-06-01 14:20:22 +00:00
|
|
|
while (i < pages->nents) {
|
2012-02-09 16:15:47 +00:00
|
|
|
pt_vaddr = kmap_atomic(ppgtt->pt_pages[act_pd]);
|
|
|
|
|
|
|
|
for (j = first_pte; j < I915_PPGTT_PT_ENTRIES; j++) {
|
|
|
|
page_addr = sg_dma_address(sg) + (m << PAGE_SHIFT);
|
|
|
|
pte = GEN6_PTE_ADDR_ENCODE(page_addr);
|
|
|
|
pt_vaddr[j] = pte | pte_flags;
|
|
|
|
|
|
|
|
/* grab the next page */
|
2012-06-01 14:20:22 +00:00
|
|
|
if (++m == segment_len) {
|
|
|
|
if (++i == pages->nents)
|
2012-02-09 16:15:47 +00:00
|
|
|
break;
|
|
|
|
|
2012-06-01 14:20:22 +00:00
|
|
|
sg = sg_next(sg);
|
2012-02-09 16:15:47 +00:00
|
|
|
segment_len = sg_dma_len(sg) >> PAGE_SHIFT;
|
|
|
|
m = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
kunmap_atomic(pt_vaddr);
|
|
|
|
|
|
|
|
first_pte = 0;
|
|
|
|
act_pd++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void i915_ppgtt_bind_object(struct i915_hw_ppgtt *ppgtt,
|
|
|
|
struct drm_i915_gem_object *obj,
|
|
|
|
enum i915_cache_level cache_level)
|
|
|
|
{
|
|
|
|
uint32_t pte_flags = GEN6_PTE_VALID;
|
|
|
|
|
|
|
|
switch (cache_level) {
|
|
|
|
case I915_CACHE_LLC_MLC:
|
|
|
|
pte_flags |= GEN6_PTE_CACHE_LLC_MLC;
|
|
|
|
break;
|
|
|
|
case I915_CACHE_LLC:
|
|
|
|
pte_flags |= GEN6_PTE_CACHE_LLC;
|
|
|
|
break;
|
|
|
|
case I915_CACHE_NONE:
|
2012-06-01 14:20:22 +00:00
|
|
|
if (IS_HASWELL(obj->base.dev))
|
2012-08-14 14:42:14 +00:00
|
|
|
pte_flags |= HSW_PTE_UNCACHED;
|
|
|
|
else
|
|
|
|
pte_flags |= GEN6_PTE_UNCACHED;
|
2012-02-09 16:15:47 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
|
2012-06-01 14:20:22 +00:00
|
|
|
i915_ppgtt_insert_sg_entries(ppgtt,
|
2012-09-04 20:02:58 +00:00
|
|
|
obj->pages,
|
2012-06-01 14:20:22 +00:00
|
|
|
obj->gtt_space->start >> PAGE_SHIFT,
|
|
|
|
pte_flags);
|
2012-02-09 16:15:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void i915_ppgtt_unbind_object(struct i915_hw_ppgtt *ppgtt,
|
|
|
|
struct drm_i915_gem_object *obj)
|
|
|
|
{
|
|
|
|
i915_ppgtt_clear_range(ppgtt,
|
|
|
|
obj->gtt_space->start >> PAGE_SHIFT,
|
|
|
|
obj->base.size >> PAGE_SHIFT);
|
|
|
|
}
|
|
|
|
|
2011-03-29 23:59:50 +00:00
|
|
|
/* XXX kill agp_type! */
|
|
|
|
static unsigned int cache_level_to_agp_type(struct drm_device *dev,
|
|
|
|
enum i915_cache_level cache_level)
|
|
|
|
{
|
|
|
|
switch (cache_level) {
|
|
|
|
case I915_CACHE_LLC_MLC:
|
|
|
|
if (INTEL_INFO(dev)->gen >= 6)
|
|
|
|
return AGP_USER_CACHED_MEMORY_LLC_MLC;
|
|
|
|
/* Older chipsets do not have this extra level of CPU
|
|
|
|
* cacheing, so fallthrough and request the PTE simply
|
|
|
|
* as cached.
|
|
|
|
*/
|
|
|
|
case I915_CACHE_LLC:
|
|
|
|
return AGP_USER_CACHED_MEMORY;
|
|
|
|
default:
|
|
|
|
case I915_CACHE_NONE:
|
|
|
|
return AGP_USER_MEMORY;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-10-17 22:51:55 +00:00
|
|
|
static bool do_idling(struct drm_i915_private *dev_priv)
|
|
|
|
{
|
|
|
|
bool ret = dev_priv->mm.interruptible;
|
|
|
|
|
|
|
|
if (unlikely(dev_priv->mm.gtt->do_idle_maps)) {
|
|
|
|
dev_priv->mm.interruptible = false;
|
2012-04-26 23:02:58 +00:00
|
|
|
if (i915_gpu_idle(dev_priv->dev)) {
|
2011-10-17 22:51:55 +00:00
|
|
|
DRM_ERROR("Couldn't idle GPU\n");
|
|
|
|
/* Wait a bit, in hopes it avoids the hang */
|
|
|
|
udelay(10);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void undo_idling(struct drm_i915_private *dev_priv, bool interruptible)
|
|
|
|
{
|
|
|
|
if (unlikely(dev_priv->mm.gtt->do_idle_maps))
|
|
|
|
dev_priv->mm.interruptible = interruptible;
|
|
|
|
}
|
|
|
|
|
2010-11-05 21:23:30 +00:00
|
|
|
void i915_gem_restore_gtt_mappings(struct drm_device *dev)
|
|
|
|
{
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
2010-11-08 19:18:58 +00:00
|
|
|
struct drm_i915_gem_object *obj;
|
2010-11-05 21:23:30 +00:00
|
|
|
|
2011-01-21 10:54:32 +00:00
|
|
|
/* First fill our portion of the GTT with scratch pages */
|
|
|
|
intel_gtt_clear_range(dev_priv->mm.gtt_start / PAGE_SIZE,
|
|
|
|
(dev_priv->mm.gtt_end - dev_priv->mm.gtt_start) / PAGE_SIZE);
|
|
|
|
|
drm/i915: Track unbound pages
When dealing with a working set larger than the GATT, or even the
mappable aperture when touching through the GTT, we end up with evicting
objects only to rebind them at a new offset again later. Moving an
object into and out of the GTT requires clflushing the pages, thus
causing a double-clflush penalty for rebinding.
To avoid having to clflush on rebinding, we can track the pages as they
are evicted from the GTT and only relinquish those pages on memory
pressure.
As usual, if it were not for the handling of out-of-memory condition and
having to manually shrink our own bo caches, it would be a net reduction
of code. Alas.
Note: The patch also contains a few changes to the last-hope
evict_everything logic in i916_gem_execbuffer.c - we no longer try to
only evict the purgeable stuff in a first try (since that's superflous
and only helps in OOM corner-cases, not fragmented-gtt trashing
situations).
Also, the extraction of the get_pages retry loop from bind_to_gtt (and
other callsites) to get_pages should imo have been a separate patch.
v2: Ditch the newly added put_pages (for unbound objects only) in
i915_gem_reset. A quick irc discussion hasn't revealed any important
reason for this, so if we need this, I'd like to have a git blame'able
explanation for it.
v3: Undo the s/drm_malloc_ab/kmalloc/ in get_pages that Chris noticed.
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
[danvet: Split out code movements and rant a bit in the commit message
with a few Notes. Done v2]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
2012-08-20 09:40:46 +00:00
|
|
|
list_for_each_entry(obj, &dev_priv->mm.bound_list, gtt_list) {
|
2010-12-08 14:28:54 +00:00
|
|
|
i915_gem_clflush_object(obj);
|
2012-02-15 22:50:21 +00:00
|
|
|
i915_gem_gtt_bind_object(obj, obj->cache_level);
|
2010-11-05 21:23:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
intel_gtt_chipset_flush();
|
|
|
|
}
|
2010-11-06 09:10:47 +00:00
|
|
|
|
2012-02-15 22:50:21 +00:00
|
|
|
int i915_gem_gtt_prepare_object(struct drm_i915_gem_object *obj)
|
2010-11-06 09:10:47 +00:00
|
|
|
{
|
2012-06-01 14:20:22 +00:00
|
|
|
if (obj->has_dma_mapping)
|
2012-02-15 22:50:21 +00:00
|
|
|
return 0;
|
2012-06-01 14:20:22 +00:00
|
|
|
|
|
|
|
if (!dma_map_sg(&obj->base.dev->pdev->dev,
|
|
|
|
obj->pages->sgl, obj->pages->nents,
|
|
|
|
PCI_DMA_BIDIRECTIONAL))
|
|
|
|
return -ENOSPC;
|
|
|
|
|
|
|
|
return 0;
|
2010-11-06 09:10:47 +00:00
|
|
|
}
|
|
|
|
|
2012-02-15 22:50:21 +00:00
|
|
|
void i915_gem_gtt_bind_object(struct drm_i915_gem_object *obj,
|
|
|
|
enum i915_cache_level cache_level)
|
2011-04-14 05:48:26 +00:00
|
|
|
{
|
|
|
|
struct drm_device *dev = obj->base.dev;
|
|
|
|
unsigned int agp_type = cache_level_to_agp_type(dev, cache_level);
|
|
|
|
|
2012-09-04 20:02:58 +00:00
|
|
|
intel_gtt_insert_sg_entries(obj->pages,
|
2012-06-01 14:20:22 +00:00
|
|
|
obj->gtt_space->start >> PAGE_SHIFT,
|
|
|
|
agp_type);
|
2012-02-15 22:50:22 +00:00
|
|
|
obj->has_global_gtt_mapping = 1;
|
2011-04-14 05:48:26 +00:00
|
|
|
}
|
|
|
|
|
2010-11-08 19:18:58 +00:00
|
|
|
void i915_gem_gtt_unbind_object(struct drm_i915_gem_object *obj)
|
2012-02-15 22:50:21 +00:00
|
|
|
{
|
|
|
|
intel_gtt_clear_range(obj->gtt_space->start >> PAGE_SHIFT,
|
|
|
|
obj->base.size >> PAGE_SHIFT);
|
2012-02-15 22:50:22 +00:00
|
|
|
|
|
|
|
obj->has_global_gtt_mapping = 0;
|
2012-02-15 22:50:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void i915_gem_gtt_finish_object(struct drm_i915_gem_object *obj)
|
2010-11-06 09:10:47 +00:00
|
|
|
{
|
2011-10-17 22:51:55 +00:00
|
|
|
struct drm_device *dev = obj->base.dev;
|
|
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
|
|
bool interruptible;
|
|
|
|
|
|
|
|
interruptible = do_idling(dev_priv);
|
|
|
|
|
2012-06-01 14:20:22 +00:00
|
|
|
if (!obj->has_dma_mapping)
|
|
|
|
dma_unmap_sg(&dev->pdev->dev,
|
|
|
|
obj->pages->sgl, obj->pages->nents,
|
|
|
|
PCI_DMA_BIDIRECTIONAL);
|
2011-10-17 22:51:55 +00:00
|
|
|
|
|
|
|
undo_idling(dev_priv, interruptible);
|
2010-11-06 09:10:47 +00:00
|
|
|
}
|
2012-03-26 07:45:40 +00:00
|
|
|
|
2012-07-26 10:49:32 +00:00
|
|
|
static void i915_gtt_color_adjust(struct drm_mm_node *node,
|
|
|
|
unsigned long color,
|
|
|
|
unsigned long *start,
|
|
|
|
unsigned long *end)
|
|
|
|
{
|
|
|
|
if (node->color != color)
|
|
|
|
*start += 4096;
|
|
|
|
|
|
|
|
if (!list_empty(&node->node_list)) {
|
|
|
|
node = list_entry(node->node_list.next,
|
|
|
|
struct drm_mm_node,
|
|
|
|
node_list);
|
|
|
|
if (node->allocated && node->color != color)
|
|
|
|
*end -= 4096;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-03-26 07:45:40 +00:00
|
|
|
void i915_gem_init_global_gtt(struct drm_device *dev,
|
|
|
|
unsigned long start,
|
|
|
|
unsigned long mappable_end,
|
|
|
|
unsigned long end)
|
|
|
|
{
|
|
|
|
drm_i915_private_t *dev_priv = dev->dev_private;
|
|
|
|
|
2012-03-26 07:45:42 +00:00
|
|
|
/* Substract the guard page ... */
|
|
|
|
drm_mm_init(&dev_priv->mm.gtt_space, start, end - start - PAGE_SIZE);
|
2012-07-26 10:49:32 +00:00
|
|
|
if (!HAS_LLC(dev))
|
|
|
|
dev_priv->mm.gtt_space.color_adjust = i915_gtt_color_adjust;
|
2012-03-26 07:45:40 +00:00
|
|
|
|
|
|
|
dev_priv->mm.gtt_start = start;
|
|
|
|
dev_priv->mm.gtt_mappable_end = mappable_end;
|
|
|
|
dev_priv->mm.gtt_end = end;
|
|
|
|
dev_priv->mm.gtt_total = end - start;
|
|
|
|
dev_priv->mm.mappable_gtt_total = min(end, mappable_end) - start;
|
|
|
|
|
2012-03-26 07:45:42 +00:00
|
|
|
/* ... but ensure that we clear the entire range. */
|
2012-03-26 07:45:40 +00:00
|
|
|
intel_gtt_clear_range(start / PAGE_SIZE, (end-start) / PAGE_SIZE);
|
|
|
|
}
|