• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright © 2008-2012 Intel Corporation
3  *
4  * Permission is hereby granted, free of charge, to any person obtaining a
5  * copy of this software and associated documentation files (the "Software"),
6  * to deal in the Software without restriction, including without limitation
7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8  * and/or sell copies of the Software, and to permit persons to whom the
9  * Software is furnished to do so, subject to the following conditions:
10  *
11  * The above copyright notice and this permission notice (including the next
12  * paragraph) shall be included in all copies or substantial portions of the
13  * Software.
14  *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
21  * IN THE SOFTWARE.
22  *
23  * Authors:
24  *    Eric Anholt <eric@anholt.net>
25  *    Chris Wilson <chris@chris-wilson.co.uk>
26  *
27  */
28 
29 #include <drm/drmP.h>
30 #include <drm/i915_drm.h>
31 #include "i915_drv.h"
32 
33 /*
34  * The BIOS typically reserves some of the system's memory for the exclusive
35  * use of the integrated graphics. This memory is no longer available for
36  * use by the OS and so the user finds that his system has less memory
37  * available than he put in. We refer to this memory as stolen.
38  *
39  * The BIOS will allocate its framebuffer from the stolen memory. Our
40  * goal is try to reuse that object for our own fbcon which must always
41  * be available for panics. Anything else we can reuse the stolen memory
42  * for is a boon.
43  */
44 
i915_stolen_to_physical(struct drm_device * dev)45 static unsigned long i915_stolen_to_physical(struct drm_device *dev)
46 {
47 	struct drm_i915_private *dev_priv = dev->dev_private;
48 	struct pci_dev *pdev = dev_priv->bridge_dev;
49 	u32 base;
50 
51 	/* On the machines I have tested the Graphics Base of Stolen Memory
52 	 * is unreliable, so on those compute the base by subtracting the
53 	 * stolen memory from the Top of Low Usable DRAM which is where the
54 	 * BIOS places the graphics stolen memory.
55 	 *
56 	 * On gen2, the layout is slightly different with the Graphics Segment
57 	 * immediately following Top of Memory (or Top of Usable DRAM). Note
58 	 * it appears that TOUD is only reported by 865g, so we just use the
59 	 * top of memory as determined by the e820 probe.
60 	 *
61 	 * XXX gen2 requires an unavailable symbol and 945gm fails with
62 	 * its value of TOLUD.
63 	 */
64 	base = 0;
65 	if (INTEL_INFO(dev)->gen >= 6) {
66 		/* Read Base Data of Stolen Memory Register (BDSM) directly.
67 		 * Note that there is also a MCHBAR miror at 0x1080c0 or
68 		 * we could use device 2:0x5c instead.
69 		*/
70 		pci_read_config_dword(pdev, 0xB0, &base);
71 		base &= ~4095; /* lower bits used for locking register */
72 	} else if (INTEL_INFO(dev)->gen > 3 || IS_G33(dev)) {
73 		/* Read Graphics Base of Stolen Memory directly */
74 		pci_read_config_dword(pdev, 0xA4, &base);
75 #if 0
76 	} else if (IS_GEN3(dev)) {
77 		u8 val;
78 		/* Stolen is immediately below Top of Low Usable DRAM */
79 		pci_read_config_byte(pdev, 0x9c, &val);
80 		base = val >> 3 << 27;
81 		base -= dev_priv->mm.gtt->stolen_size;
82 	} else {
83 		/* Stolen is immediately above Top of Memory */
84 		base = max_low_pfn_mapped << PAGE_SHIFT;
85 #endif
86 	}
87 
88 	return base;
89 }
90 
i915_setup_compression(struct drm_device * dev,int size)91 static int i915_setup_compression(struct drm_device *dev, int size)
92 {
93 	struct drm_i915_private *dev_priv = dev->dev_private;
94 	struct drm_mm_node *compressed_fb, *uninitialized_var(compressed_llb);
95 
96 	/* Try to over-allocate to reduce reallocations and fragmentation */
97 	compressed_fb = drm_mm_search_free(&dev_priv->mm.stolen,
98 					   size <<= 1, 4096, 0);
99 	if (!compressed_fb)
100 		compressed_fb = drm_mm_search_free(&dev_priv->mm.stolen,
101 						   size >>= 1, 4096, 0);
102 	if (compressed_fb)
103 		compressed_fb = drm_mm_get_block(compressed_fb, size, 4096);
104 	if (!compressed_fb)
105 		goto err;
106 
107 	if (HAS_PCH_SPLIT(dev))
108 		I915_WRITE(ILK_DPFC_CB_BASE, compressed_fb->start);
109 	else if (IS_GM45(dev)) {
110 		I915_WRITE(DPFC_CB_BASE, compressed_fb->start);
111 	} else {
112 		compressed_llb = drm_mm_search_free(&dev_priv->mm.stolen,
113 						    4096, 4096, 0);
114 		if (compressed_llb)
115 			compressed_llb = drm_mm_get_block(compressed_llb,
116 							  4096, 4096);
117 		if (!compressed_llb)
118 			goto err_fb;
119 
120 		dev_priv->compressed_llb = compressed_llb;
121 
122 		I915_WRITE(FBC_CFB_BASE,
123 			   dev_priv->mm.stolen_base + compressed_fb->start);
124 		I915_WRITE(FBC_LL_BASE,
125 			   dev_priv->mm.stolen_base + compressed_llb->start);
126 	}
127 
128 	dev_priv->compressed_fb = compressed_fb;
129 	dev_priv->cfb_size = size;
130 
131 	DRM_DEBUG_KMS("reserved %d bytes of contiguous stolen space for FBC\n",
132 		      size);
133 
134 	return 0;
135 
136 err_fb:
137 	drm_mm_put_block(compressed_fb);
138 err:
139 	return -ENOSPC;
140 }
141 
i915_gem_stolen_setup_compression(struct drm_device * dev,int size)142 int i915_gem_stolen_setup_compression(struct drm_device *dev, int size)
143 {
144 	struct drm_i915_private *dev_priv = dev->dev_private;
145 
146 	if (dev_priv->mm.stolen_base == 0)
147 		return -ENODEV;
148 
149 	if (size < dev_priv->cfb_size)
150 		return 0;
151 
152 	/* Release any current block */
153 	i915_gem_stolen_cleanup_compression(dev);
154 
155 	return i915_setup_compression(dev, size);
156 }
157 
i915_gem_stolen_cleanup_compression(struct drm_device * dev)158 void i915_gem_stolen_cleanup_compression(struct drm_device *dev)
159 {
160 	struct drm_i915_private *dev_priv = dev->dev_private;
161 
162 	if (dev_priv->cfb_size == 0)
163 		return;
164 
165 	if (dev_priv->compressed_fb)
166 		drm_mm_put_block(dev_priv->compressed_fb);
167 
168 	if (dev_priv->compressed_llb)
169 		drm_mm_put_block(dev_priv->compressed_llb);
170 
171 	dev_priv->cfb_size = 0;
172 }
173 
i915_gem_cleanup_stolen(struct drm_device * dev)174 void i915_gem_cleanup_stolen(struct drm_device *dev)
175 {
176 	struct drm_i915_private *dev_priv = dev->dev_private;
177 
178 	i915_gem_stolen_cleanup_compression(dev);
179 	drm_mm_takedown(&dev_priv->mm.stolen);
180 }
181 
i915_gem_init_stolen(struct drm_device * dev)182 int i915_gem_init_stolen(struct drm_device *dev)
183 {
184 	struct drm_i915_private *dev_priv = dev->dev_private;
185 
186 	dev_priv->mm.stolen_base = i915_stolen_to_physical(dev);
187 	if (dev_priv->mm.stolen_base == 0)
188 		return 0;
189 
190 	DRM_DEBUG_KMS("found %zd bytes of stolen memory at %08lx\n",
191 		      dev_priv->gtt.stolen_size, dev_priv->mm.stolen_base);
192 
193 	/* Basic memrange allocator for stolen space */
194 	drm_mm_init(&dev_priv->mm.stolen, 0, dev_priv->gtt.stolen_size);
195 
196 	return 0;
197 }
198 
199 static struct sg_table *
i915_pages_create_for_stolen(struct drm_device * dev,u32 offset,u32 size)200 i915_pages_create_for_stolen(struct drm_device *dev,
201 			     u32 offset, u32 size)
202 {
203 	struct drm_i915_private *dev_priv = dev->dev_private;
204 	struct sg_table *st;
205 	struct scatterlist *sg;
206 
207 	DRM_DEBUG_DRIVER("offset=0x%x, size=%d\n", offset, size);
208 	BUG_ON(offset > dev_priv->gtt.stolen_size - size);
209 
210 	/* We hide that we have no struct page backing our stolen object
211 	 * by wrapping the contiguous physical allocation with a fake
212 	 * dma mapping in a single scatterlist.
213 	 */
214 
215 	st = kmalloc(sizeof(*st), GFP_KERNEL);
216 	if (st == NULL)
217 		return NULL;
218 
219 	if (sg_alloc_table(st, 1, GFP_KERNEL)) {
220 		kfree(st);
221 		return NULL;
222 	}
223 
224 	sg = st->sgl;
225 	sg->offset = offset;
226 	sg->length = size;
227 
228 	sg_dma_address(sg) = (dma_addr_t)dev_priv->mm.stolen_base + offset;
229 	sg_dma_len(sg) = size;
230 
231 	return st;
232 }
233 
i915_gem_object_get_pages_stolen(struct drm_i915_gem_object * obj)234 static int i915_gem_object_get_pages_stolen(struct drm_i915_gem_object *obj)
235 {
236 	BUG();
237 	return -EINVAL;
238 }
239 
i915_gem_object_put_pages_stolen(struct drm_i915_gem_object * obj)240 static void i915_gem_object_put_pages_stolen(struct drm_i915_gem_object *obj)
241 {
242 	/* Should only be called during free */
243 	sg_free_table(obj->pages);
244 	kfree(obj->pages);
245 }
246 
247 static const struct drm_i915_gem_object_ops i915_gem_object_stolen_ops = {
248 	.get_pages = i915_gem_object_get_pages_stolen,
249 	.put_pages = i915_gem_object_put_pages_stolen,
250 };
251 
252 static struct drm_i915_gem_object *
_i915_gem_object_create_stolen(struct drm_device * dev,struct drm_mm_node * stolen)253 _i915_gem_object_create_stolen(struct drm_device *dev,
254 			       struct drm_mm_node *stolen)
255 {
256 	struct drm_i915_gem_object *obj;
257 
258 	obj = i915_gem_object_alloc(dev);
259 	if (obj == NULL)
260 		return NULL;
261 
262 	if (drm_gem_private_object_init(dev, &obj->base, stolen->size))
263 		goto cleanup;
264 
265 	i915_gem_object_init(obj, &i915_gem_object_stolen_ops);
266 
267 	obj->pages = i915_pages_create_for_stolen(dev,
268 						  stolen->start, stolen->size);
269 	if (obj->pages == NULL)
270 		goto cleanup;
271 
272 	obj->has_dma_mapping = true;
273 	obj->pages_pin_count = 1;
274 	obj->stolen = stolen;
275 
276 	obj->base.write_domain = I915_GEM_DOMAIN_GTT;
277 	obj->base.read_domains = I915_GEM_DOMAIN_GTT;
278 	obj->cache_level = I915_CACHE_NONE;
279 
280 	return obj;
281 
282 cleanup:
283 	i915_gem_object_free(obj);
284 	return NULL;
285 }
286 
287 struct drm_i915_gem_object *
i915_gem_object_create_stolen(struct drm_device * dev,u32 size)288 i915_gem_object_create_stolen(struct drm_device *dev, u32 size)
289 {
290 	struct drm_i915_private *dev_priv = dev->dev_private;
291 	struct drm_i915_gem_object *obj;
292 	struct drm_mm_node *stolen;
293 
294 	if (dev_priv->mm.stolen_base == 0)
295 		return NULL;
296 
297 	DRM_DEBUG_KMS("creating stolen object: size=%x\n", size);
298 	if (size == 0)
299 		return NULL;
300 
301 	stolen = drm_mm_search_free(&dev_priv->mm.stolen, size, 4096, 0);
302 	if (stolen)
303 		stolen = drm_mm_get_block(stolen, size, 4096);
304 	if (stolen == NULL)
305 		return NULL;
306 
307 	obj = _i915_gem_object_create_stolen(dev, stolen);
308 	if (obj)
309 		return obj;
310 
311 	drm_mm_put_block(stolen);
312 	return NULL;
313 }
314 
315 struct drm_i915_gem_object *
i915_gem_object_create_stolen_for_preallocated(struct drm_device * dev,u32 stolen_offset,u32 gtt_offset,u32 size)316 i915_gem_object_create_stolen_for_preallocated(struct drm_device *dev,
317 					       u32 stolen_offset,
318 					       u32 gtt_offset,
319 					       u32 size)
320 {
321 	struct drm_i915_private *dev_priv = dev->dev_private;
322 	struct drm_i915_gem_object *obj;
323 	struct drm_mm_node *stolen;
324 
325 	if (dev_priv->mm.stolen_base == 0)
326 		return NULL;
327 
328 	DRM_DEBUG_KMS("creating preallocated stolen object: stolen_offset=%x, gtt_offset=%x, size=%x\n",
329 			stolen_offset, gtt_offset, size);
330 
331 	/* KISS and expect everything to be page-aligned */
332 	BUG_ON(stolen_offset & 4095);
333 	BUG_ON(gtt_offset & 4095);
334 	BUG_ON(size & 4095);
335 
336 	if (WARN_ON(size == 0))
337 		return NULL;
338 
339 	stolen = drm_mm_create_block(&dev_priv->mm.stolen,
340 				     stolen_offset, size,
341 				     false);
342 	if (stolen == NULL) {
343 		DRM_DEBUG_KMS("failed to allocate stolen space\n");
344 		return NULL;
345 	}
346 
347 	obj = _i915_gem_object_create_stolen(dev, stolen);
348 	if (obj == NULL) {
349 		DRM_DEBUG_KMS("failed to allocate stolen object\n");
350 		drm_mm_put_block(stolen);
351 		return NULL;
352 	}
353 
354 	/* To simplify the initialisation sequence between KMS and GTT,
355 	 * we allow construction of the stolen object prior to
356 	 * setting up the GTT space. The actual reservation will occur
357 	 * later.
358 	 */
359 	if (drm_mm_initialized(&dev_priv->mm.gtt_space)) {
360 		obj->gtt_space = drm_mm_create_block(&dev_priv->mm.gtt_space,
361 						     gtt_offset, size,
362 						     false);
363 		if (obj->gtt_space == NULL) {
364 			DRM_DEBUG_KMS("failed to allocate stolen GTT space\n");
365 			drm_gem_object_unreference(&obj->base);
366 			return NULL;
367 		}
368 	} else
369 		obj->gtt_space = I915_GTT_RESERVED;
370 
371 	obj->gtt_offset = gtt_offset;
372 	obj->has_global_gtt_mapping = 1;
373 
374 	list_add_tail(&obj->gtt_list, &dev_priv->mm.bound_list);
375 	list_add_tail(&obj->mm_list, &dev_priv->mm.inactive_list);
376 
377 	return obj;
378 }
379 
380 void
i915_gem_object_release_stolen(struct drm_i915_gem_object * obj)381 i915_gem_object_release_stolen(struct drm_i915_gem_object *obj)
382 {
383 	if (obj->stolen) {
384 		drm_mm_put_block(obj->stolen);
385 		obj->stolen = NULL;
386 	}
387 }
388