WIP FPC-III support
[linux/fpc-iii.git] / drivers / gpu / drm / gma500 / gtt.c
blobd246b1f703668286f089cdade355be4cc3c75bfb
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (c) 2007, Intel Corporation.
4 * All Rights Reserved.
6 * Authors: Thomas Hellstrom <thomas-at-tungstengraphics.com>
7 * Alan Cox <alan@linux.intel.com>
8 */
10 #include <linux/shmem_fs.h>
12 #include <asm/set_memory.h>
14 #include "blitter.h"
15 #include "psb_drv.h"
19 * GTT resource allocator - manage page mappings in GTT space
22 /**
23 * psb_gtt_mask_pte - generate GTT pte entry
24 * @pfn: page number to encode
25 * @type: type of memory in the GTT
27 * Set the GTT entry for the appropriate memory type.
29 static inline uint32_t psb_gtt_mask_pte(uint32_t pfn, int type)
31 uint32_t mask = PSB_PTE_VALID;
33 /* Ensure we explode rather than put an invalid low mapping of
34 a high mapping page into the gtt */
35 BUG_ON(pfn & ~(0xFFFFFFFF >> PAGE_SHIFT));
37 if (type & PSB_MMU_CACHED_MEMORY)
38 mask |= PSB_PTE_CACHED;
39 if (type & PSB_MMU_RO_MEMORY)
40 mask |= PSB_PTE_RO;
41 if (type & PSB_MMU_WO_MEMORY)
42 mask |= PSB_PTE_WO;
44 return (pfn << PAGE_SHIFT) | mask;
47 /**
48 * psb_gtt_entry - find the GTT entries for a gtt_range
49 * @dev: our DRM device
50 * @r: our GTT range
52 * Given a gtt_range object return the GTT offset of the page table
53 * entries for this gtt_range
55 static u32 __iomem *psb_gtt_entry(struct drm_device *dev, struct gtt_range *r)
57 struct drm_psb_private *dev_priv = dev->dev_private;
58 unsigned long offset;
60 offset = r->resource.start - dev_priv->gtt_mem->start;
62 return dev_priv->gtt_map + (offset >> PAGE_SHIFT);
65 /**
66 * psb_gtt_insert - put an object into the GTT
67 * @dev: our DRM device
68 * @r: our GTT range
69 * @resume: on resume
71 * Take our preallocated GTT range and insert the GEM object into
72 * the GTT. This is protected via the gtt mutex which the caller
73 * must hold.
75 static int psb_gtt_insert(struct drm_device *dev, struct gtt_range *r,
76 int resume)
78 u32 __iomem *gtt_slot;
79 u32 pte;
80 struct page **pages;
81 int i;
83 if (r->pages == NULL) {
84 WARN_ON(1);
85 return -EINVAL;
88 WARN_ON(r->stolen); /* refcount these maybe ? */
90 gtt_slot = psb_gtt_entry(dev, r);
91 pages = r->pages;
93 if (!resume) {
94 /* Make sure changes are visible to the GPU */
95 set_pages_array_wc(pages, r->npage);
98 /* Write our page entries into the GTT itself */
99 for (i = 0; i < r->npage; i++) {
100 pte = psb_gtt_mask_pte(page_to_pfn(r->pages[i]),
101 PSB_MMU_CACHED_MEMORY);
102 iowrite32(pte, gtt_slot++);
105 /* Make sure all the entries are set before we return */
106 ioread32(gtt_slot - 1);
108 return 0;
112 * psb_gtt_remove - remove an object from the GTT
113 * @dev: our DRM device
114 * @r: our GTT range
116 * Remove a preallocated GTT range from the GTT. Overwrite all the
117 * page table entries with the dummy page. This is protected via the gtt
118 * mutex which the caller must hold.
120 static void psb_gtt_remove(struct drm_device *dev, struct gtt_range *r)
122 struct drm_psb_private *dev_priv = dev->dev_private;
123 u32 __iomem *gtt_slot;
124 u32 pte;
125 int i;
127 WARN_ON(r->stolen);
129 gtt_slot = psb_gtt_entry(dev, r);
130 pte = psb_gtt_mask_pte(page_to_pfn(dev_priv->scratch_page),
131 PSB_MMU_CACHED_MEMORY);
133 for (i = 0; i < r->npage; i++)
134 iowrite32(pte, gtt_slot++);
135 ioread32(gtt_slot - 1);
136 set_pages_array_wb(r->pages, r->npage);
140 * psb_gtt_attach_pages - attach and pin GEM pages
141 * @gt: the gtt range
143 * Pin and build an in kernel list of the pages that back our GEM object.
144 * While we hold this the pages cannot be swapped out. This is protected
145 * via the gtt mutex which the caller must hold.
147 static int psb_gtt_attach_pages(struct gtt_range *gt)
149 struct page **pages;
151 WARN_ON(gt->pages);
153 pages = drm_gem_get_pages(&gt->gem);
154 if (IS_ERR(pages))
155 return PTR_ERR(pages);
157 gt->npage = gt->gem.size / PAGE_SIZE;
158 gt->pages = pages;
160 return 0;
164 * psb_gtt_detach_pages - attach and pin GEM pages
165 * @gt: the gtt range
167 * Undo the effect of psb_gtt_attach_pages. At this point the pages
168 * must have been removed from the GTT as they could now be paged out
169 * and move bus address. This is protected via the gtt mutex which the
170 * caller must hold.
172 static void psb_gtt_detach_pages(struct gtt_range *gt)
174 drm_gem_put_pages(&gt->gem, gt->pages, true, false);
175 gt->pages = NULL;
179 * psb_gtt_pin - pin pages into the GTT
180 * @gt: range to pin
182 * Pin a set of pages into the GTT. The pins are refcounted so that
183 * multiple pins need multiple unpins to undo.
185 * Non GEM backed objects treat this as a no-op as they are always GTT
186 * backed objects.
188 int psb_gtt_pin(struct gtt_range *gt)
190 int ret = 0;
191 struct drm_device *dev = gt->gem.dev;
192 struct drm_psb_private *dev_priv = dev->dev_private;
193 u32 gpu_base = dev_priv->gtt.gatt_start;
195 mutex_lock(&dev_priv->gtt_mutex);
197 if (gt->in_gart == 0 && gt->stolen == 0) {
198 ret = psb_gtt_attach_pages(gt);
199 if (ret < 0)
200 goto out;
201 ret = psb_gtt_insert(dev, gt, 0);
202 if (ret < 0) {
203 psb_gtt_detach_pages(gt);
204 goto out;
206 psb_mmu_insert_pages(psb_mmu_get_default_pd(dev_priv->mmu),
207 gt->pages, (gpu_base + gt->offset),
208 gt->npage, 0, 0, PSB_MMU_CACHED_MEMORY);
210 gt->in_gart++;
211 out:
212 mutex_unlock(&dev_priv->gtt_mutex);
213 return ret;
217 * psb_gtt_unpin - Drop a GTT pin requirement
218 * @gt: range to pin
220 * Undoes the effect of psb_gtt_pin. On the last drop the GEM object
221 * will be removed from the GTT which will also drop the page references
222 * and allow the VM to clean up or page stuff.
224 * Non GEM backed objects treat this as a no-op as they are always GTT
225 * backed objects.
227 void psb_gtt_unpin(struct gtt_range *gt)
229 struct drm_device *dev = gt->gem.dev;
230 struct drm_psb_private *dev_priv = dev->dev_private;
231 u32 gpu_base = dev_priv->gtt.gatt_start;
232 int ret;
234 /* While holding the gtt_mutex no new blits can be initiated */
235 mutex_lock(&dev_priv->gtt_mutex);
237 /* Wait for any possible usage of the memory to be finished */
238 ret = gma_blt_wait_idle(dev_priv);
239 if (ret) {
240 DRM_ERROR("Failed to idle the blitter, unpin failed!");
241 goto out;
244 WARN_ON(!gt->in_gart);
246 gt->in_gart--;
247 if (gt->in_gart == 0 && gt->stolen == 0) {
248 psb_mmu_remove_pages(psb_mmu_get_default_pd(dev_priv->mmu),
249 (gpu_base + gt->offset), gt->npage, 0, 0);
250 psb_gtt_remove(dev, gt);
251 psb_gtt_detach_pages(gt);
254 out:
255 mutex_unlock(&dev_priv->gtt_mutex);
259 * GTT resource allocator - allocate and manage GTT address space
263 * psb_gtt_alloc_range - allocate GTT address space
264 * @dev: Our DRM device
265 * @len: length (bytes) of address space required
266 * @name: resource name
267 * @backed: resource should be backed by stolen pages
268 * @align: requested alignment
270 * Ask the kernel core to find us a suitable range of addresses
271 * to use for a GTT mapping.
273 * Returns a gtt_range structure describing the object, or NULL on
274 * error. On successful return the resource is both allocated and marked
275 * as in use.
277 struct gtt_range *psb_gtt_alloc_range(struct drm_device *dev, int len,
278 const char *name, int backed, u32 align)
280 struct drm_psb_private *dev_priv = dev->dev_private;
281 struct gtt_range *gt;
282 struct resource *r = dev_priv->gtt_mem;
283 int ret;
284 unsigned long start, end;
286 if (backed) {
287 /* The start of the GTT is the stolen pages */
288 start = r->start;
289 end = r->start + dev_priv->gtt.stolen_size - 1;
290 } else {
291 /* The rest we will use for GEM backed objects */
292 start = r->start + dev_priv->gtt.stolen_size;
293 end = r->end;
296 gt = kzalloc(sizeof(struct gtt_range), GFP_KERNEL);
297 if (gt == NULL)
298 return NULL;
299 gt->resource.name = name;
300 gt->stolen = backed;
301 gt->in_gart = backed;
302 /* Ensure this is set for non GEM objects */
303 gt->gem.dev = dev;
304 ret = allocate_resource(dev_priv->gtt_mem, &gt->resource,
305 len, start, end, align, NULL, NULL);
306 if (ret == 0) {
307 gt->offset = gt->resource.start - r->start;
308 return gt;
310 kfree(gt);
311 return NULL;
315 * psb_gtt_free_range - release GTT address space
316 * @dev: our DRM device
317 * @gt: a mapping created with psb_gtt_alloc_range
319 * Release a resource that was allocated with psb_gtt_alloc_range. If the
320 * object has been pinned by mmap users we clean this up here currently.
322 void psb_gtt_free_range(struct drm_device *dev, struct gtt_range *gt)
324 /* Undo the mmap pin if we are destroying the object */
325 if (gt->mmapping) {
326 psb_gtt_unpin(gt);
327 gt->mmapping = 0;
329 WARN_ON(gt->in_gart && !gt->stolen);
330 release_resource(&gt->resource);
331 kfree(gt);
334 static void psb_gtt_alloc(struct drm_device *dev)
336 struct drm_psb_private *dev_priv = dev->dev_private;
337 init_rwsem(&dev_priv->gtt.sem);
340 void psb_gtt_takedown(struct drm_device *dev)
342 struct drm_psb_private *dev_priv = dev->dev_private;
344 if (dev_priv->gtt_map) {
345 iounmap(dev_priv->gtt_map);
346 dev_priv->gtt_map = NULL;
348 if (dev_priv->gtt_initialized) {
349 pci_write_config_word(dev->pdev, PSB_GMCH_CTRL,
350 dev_priv->gmch_ctrl);
351 PSB_WVDC32(dev_priv->pge_ctl, PSB_PGETBL_CTL);
352 (void) PSB_RVDC32(PSB_PGETBL_CTL);
354 if (dev_priv->vram_addr)
355 iounmap(dev_priv->gtt_map);
358 int psb_gtt_init(struct drm_device *dev, int resume)
360 struct drm_psb_private *dev_priv = dev->dev_private;
361 unsigned gtt_pages;
362 unsigned long stolen_size, vram_stolen_size;
363 unsigned i, num_pages;
364 unsigned pfn_base;
365 struct psb_gtt *pg;
367 int ret = 0;
368 uint32_t pte;
370 if (!resume) {
371 mutex_init(&dev_priv->gtt_mutex);
372 mutex_init(&dev_priv->mmap_mutex);
373 psb_gtt_alloc(dev);
376 pg = &dev_priv->gtt;
378 /* Enable the GTT */
379 pci_read_config_word(dev->pdev, PSB_GMCH_CTRL, &dev_priv->gmch_ctrl);
380 pci_write_config_word(dev->pdev, PSB_GMCH_CTRL,
381 dev_priv->gmch_ctrl | _PSB_GMCH_ENABLED);
383 dev_priv->pge_ctl = PSB_RVDC32(PSB_PGETBL_CTL);
384 PSB_WVDC32(dev_priv->pge_ctl | _PSB_PGETBL_ENABLED, PSB_PGETBL_CTL);
385 (void) PSB_RVDC32(PSB_PGETBL_CTL);
387 /* The root resource we allocate address space from */
388 dev_priv->gtt_initialized = 1;
390 pg->gtt_phys_start = dev_priv->pge_ctl & PAGE_MASK;
393 * The video mmu has a hw bug when accessing 0x0D0000000.
394 * Make gatt start at 0x0e000,0000. This doesn't actually
395 * matter for us but may do if the video acceleration ever
396 * gets opened up.
398 pg->mmu_gatt_start = 0xE0000000;
400 pg->gtt_start = pci_resource_start(dev->pdev, PSB_GTT_RESOURCE);
401 gtt_pages = pci_resource_len(dev->pdev, PSB_GTT_RESOURCE)
402 >> PAGE_SHIFT;
403 /* CDV doesn't report this. In which case the system has 64 gtt pages */
404 if (pg->gtt_start == 0 || gtt_pages == 0) {
405 dev_dbg(dev->dev, "GTT PCI BAR not initialized.\n");
406 gtt_pages = 64;
407 pg->gtt_start = dev_priv->pge_ctl;
410 pg->gatt_start = pci_resource_start(dev->pdev, PSB_GATT_RESOURCE);
411 pg->gatt_pages = pci_resource_len(dev->pdev, PSB_GATT_RESOURCE)
412 >> PAGE_SHIFT;
413 dev_priv->gtt_mem = &dev->pdev->resource[PSB_GATT_RESOURCE];
415 if (pg->gatt_pages == 0 || pg->gatt_start == 0) {
416 static struct resource fudge; /* Preferably peppermint */
417 /* This can occur on CDV systems. Fudge it in this case.
418 We really don't care what imaginary space is being allocated
419 at this point */
420 dev_dbg(dev->dev, "GATT PCI BAR not initialized.\n");
421 pg->gatt_start = 0x40000000;
422 pg->gatt_pages = (128 * 1024 * 1024) >> PAGE_SHIFT;
423 /* This is a little confusing but in fact the GTT is providing
424 a view from the GPU into memory and not vice versa. As such
425 this is really allocating space that is not the same as the
426 CPU address space on CDV */
427 fudge.start = 0x40000000;
428 fudge.end = 0x40000000 + 128 * 1024 * 1024 - 1;
429 fudge.name = "fudge";
430 fudge.flags = IORESOURCE_MEM;
431 dev_priv->gtt_mem = &fudge;
434 pci_read_config_dword(dev->pdev, PSB_BSM, &dev_priv->stolen_base);
435 vram_stolen_size = pg->gtt_phys_start - dev_priv->stolen_base
436 - PAGE_SIZE;
438 stolen_size = vram_stolen_size;
440 dev_dbg(dev->dev, "Stolen memory base 0x%x, size %luK\n",
441 dev_priv->stolen_base, vram_stolen_size / 1024);
443 if (resume && (gtt_pages != pg->gtt_pages) &&
444 (stolen_size != pg->stolen_size)) {
445 dev_err(dev->dev, "GTT resume error.\n");
446 ret = -EINVAL;
447 goto out_err;
450 pg->gtt_pages = gtt_pages;
451 pg->stolen_size = stolen_size;
452 dev_priv->vram_stolen_size = vram_stolen_size;
455 * Map the GTT and the stolen memory area
457 if (!resume)
458 dev_priv->gtt_map = ioremap(pg->gtt_phys_start,
459 gtt_pages << PAGE_SHIFT);
460 if (!dev_priv->gtt_map) {
461 dev_err(dev->dev, "Failure to map gtt.\n");
462 ret = -ENOMEM;
463 goto out_err;
466 if (!resume)
467 dev_priv->vram_addr = ioremap_wc(dev_priv->stolen_base,
468 stolen_size);
470 if (!dev_priv->vram_addr) {
471 dev_err(dev->dev, "Failure to map stolen base.\n");
472 ret = -ENOMEM;
473 goto out_err;
477 * Insert vram stolen pages into the GTT
480 pfn_base = dev_priv->stolen_base >> PAGE_SHIFT;
481 num_pages = vram_stolen_size >> PAGE_SHIFT;
482 dev_dbg(dev->dev, "Set up %d stolen pages starting at 0x%08x, GTT offset %dK\n",
483 num_pages, pfn_base << PAGE_SHIFT, 0);
484 for (i = 0; i < num_pages; ++i) {
485 pte = psb_gtt_mask_pte(pfn_base + i, PSB_MMU_CACHED_MEMORY);
486 iowrite32(pte, dev_priv->gtt_map + i);
490 * Init rest of GTT to the scratch page to avoid accidents or scribbles
493 pfn_base = page_to_pfn(dev_priv->scratch_page);
494 pte = psb_gtt_mask_pte(pfn_base, PSB_MMU_CACHED_MEMORY);
495 for (; i < gtt_pages; ++i)
496 iowrite32(pte, dev_priv->gtt_map + i);
498 (void) ioread32(dev_priv->gtt_map + i - 1);
499 return 0;
501 out_err:
502 psb_gtt_takedown(dev);
503 return ret;
506 int psb_gtt_restore(struct drm_device *dev)
508 struct drm_psb_private *dev_priv = dev->dev_private;
509 struct resource *r = dev_priv->gtt_mem->child;
510 struct gtt_range *range;
511 unsigned int restored = 0, total = 0, size = 0;
513 /* On resume, the gtt_mutex is already initialized */
514 mutex_lock(&dev_priv->gtt_mutex);
515 psb_gtt_init(dev, 1);
517 while (r != NULL) {
518 range = container_of(r, struct gtt_range, resource);
519 if (range->pages) {
520 psb_gtt_insert(dev, range, 1);
521 size += range->resource.end - range->resource.start;
522 restored++;
524 r = r->sibling;
525 total++;
527 mutex_unlock(&dev_priv->gtt_mutex);
528 DRM_DEBUG_DRIVER("Restored %u of %u gtt ranges (%u KB)", restored,
529 total, (size / 1024));
531 return 0;