Subversion Repositories Kolibri OS

	 * stolen memory from the Top of Low Usable DRAM which is where the

	 * BIOS places the graphics stolen memory.

	 *

	 * On gen2, the layout is slightly different with the Graphics Segment

	 * immediately following Top of Memory (or Top of Usable DRAM). Note

	 * it appears that TOUD is only reported by 865g, so we just use the

	 * top of memory as determined by the e820 probe.

	 *

	 * XXX gen2 requires an unavailable symbol and 945gm fails with

	 * its value of TOLUD.

	 */

	base = 0;

	if (INTEL_INFO(dev)->gen >= 6) {

		/* Read Base Data of Stolen Memory Register (BDSM) directly.

		 * we could use device 2:0x5c instead.

	 */

	} else if (IS_GEN3(dev)) {

		base = val >> 3 << 27;

	base -= dev_priv->mm.gtt->stolen_size;

	} else {

static int i915_setup_compression(struct drm_device *dev, int size)

	struct drm_i915_private *dev_priv = dev->dev_private;

	struct drm_mm_node *compressed_fb, *uninitialized_var(compressed_llb);

	/* Try to over-allocate to reduce reallocations and fragmentation */

						   size >>= 1, 4096, 0);

	if (!compressed_fb)

						    4096, 4096, 0);

		if (compressed_llb)

			compressed_llb = drm_mm_get_block(compressed_llb,

		dev_priv->compressed_llb = compressed_llb;

	dev_priv->compressed_fb = compressed_fb;

	dev_priv->cfb_size = size;

	DRM_DEBUG_KMS("reserved %d bytes of contiguous stolen space for FBC\n",

		      size);

	return 0;

err_fb:

	drm_mm_put_block(compressed_fb);

err:

	return -ENOSPC;

}

{

	struct drm_i915_private *dev_priv = dev->dev_private;

	if (size < dev_priv->cfb_size)

		return 0;

	/* Release any current block */

void i915_gem_stolen_cleanup_compression(struct drm_device *dev)

		return;

	if (dev_priv->compressed_fb)

	dev_priv->cfb_size = 0;

}

void i915_gem_cleanup_stolen(struct drm_device *dev)

{

int i915_gem_init_stolen(struct drm_device *dev)

{

	struct drm_i915_private *dev_priv = dev->dev_private;

	dev_priv->mm.stolen_base = i915_stolen_to_physical(dev);

	if (dev_priv->mm.stolen_base == 0)

		return 0;

	DRM_DEBUG_KMS("found %zd bytes of stolen memory at %08lx\n",

		      dev_priv->gtt.stolen_size, dev_priv->mm.stolen_base);

	/* Basic memrange allocator for stolen space */

	drm_mm_init(&dev_priv->mm.stolen, 0, dev_priv->gtt.stolen_size);

	return 0;

}

static struct sg_table *

i915_pages_create_for_stolen(struct drm_device *dev,

			     u32 offset, u32 size)

{

	struct drm_i915_private *dev_priv = dev->dev_private;

	struct sg_table *st;

	struct scatterlist *sg;

	DRM_DEBUG_DRIVER("offset=0x%x, size=%d\n", offset, size);

	BUG_ON(offset > dev_priv->gtt.stolen_size - size);

	/* We hide that we have no struct page backing our stolen object

	 * by wrapping the contiguous physical allocation with a fake

	 * dma mapping in a single scatterlist.

	st = kmalloc(sizeof(*st), GFP_KERNEL);

	if (st == NULL)

		return NULL;

	if (sg_alloc_table(st, 1, GFP_KERNEL)) {

		kfree(st);

		return NULL;

	}

	sg = st->sgl;

	sg->offset = offset;

	sg->length = size;

	sg_dma_address(sg) = (dma_addr_t)dev_priv->mm.stolen_base + offset;

	sg_dma_len(sg) = size;

	return st;

}

static int i915_gem_object_get_pages_stolen(struct drm_i915_gem_object *obj)

{

	BUG();

	return -EINVAL;

}

static void i915_gem_object_put_pages_stolen(struct drm_i915_gem_object *obj)

{

	/* Should only be called during free */

	sg_free_table(obj->pages);

	kfree(obj->pages);

}

static const struct drm_i915_gem_object_ops i915_gem_object_stolen_ops = {

	.get_pages = i915_gem_object_get_pages_stolen,

	.put_pages = i915_gem_object_put_pages_stolen,

};

static struct drm_i915_gem_object *

_i915_gem_object_create_stolen(struct drm_device *dev,

			       struct drm_mm_node *stolen)

{

	struct drm_i915_gem_object *obj;

	obj = i915_gem_object_alloc(dev);

	if (obj == NULL)

		return NULL;

	if (drm_gem_private_object_init(dev, &obj->base, stolen->size))

		goto cleanup;

	i915_gem_object_init(obj, &i915_gem_object_stolen_ops);

	obj->pages = i915_pages_create_for_stolen(dev,

						  stolen->start, stolen->size);

	if (obj->pages == NULL)

		goto cleanup;

	obj->has_dma_mapping = true;

	obj->pages_pin_count = 1;

	obj->stolen = stolen;

	obj->base.write_domain = I915_GEM_DOMAIN_GTT;

	obj->base.read_domains = I915_GEM_DOMAIN_GTT;

	obj->cache_level = I915_CACHE_NONE;

	return obj;

cleanup:

	i915_gem_object_free(obj);

	return NULL;

}

struct drm_i915_gem_object *

i915_gem_object_create_stolen(struct drm_device *dev, u32 size)

{

	struct drm_i915_private *dev_priv = dev->dev_private;

	struct drm_i915_gem_object *obj;

	struct drm_mm_node *stolen;

	if (dev_priv->mm.stolen_base == 0)

		return NULL;

	DRM_DEBUG_KMS("creating stolen object: size=%x\n", size);

	if (size == 0)

		return NULL;

	stolen = drm_mm_search_free(&dev_priv->mm.stolen, size, 4096, 0);

	if (stolen)

		stolen = drm_mm_get_block(stolen, size, 4096);