Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright (c) 2007, Intel Corporation.
4 * All Rights Reserved.
5 *
6 * Authors: Thomas Hellstrom <thomas-at-tungstengraphics.com>
7 * Alan Cox <alan@linux.intel.com>
8 */
9
10#include "gem.h" /* TODO: for struct psb_gem_object, see psb_gtt_restore() */
11#include "psb_drv.h"
12
13
14/*
15 * GTT resource allocator - manage page mappings in GTT space
16 */
17
18int psb_gtt_allocate_resource(struct drm_psb_private *pdev, struct resource *res,
19 const char *name, resource_size_t size, resource_size_t align,
20 bool stolen, u32 *offset)
21{
22 struct resource *root = pdev->gtt_mem;
23 resource_size_t start, end;
24 int ret;
25
26 if (stolen) {
27 /* The start of the GTT is backed by stolen pages. */
28 start = root->start;
29 end = root->start + pdev->gtt.stolen_size - 1;
30 } else {
31 /* The rest is backed by system pages. */
32 start = root->start + pdev->gtt.stolen_size;
33 end = root->end;
34 }
35
36 res->name = name;
37 ret = allocate_resource(root, res, size, start, end, align, NULL, NULL);
38 if (ret)
39 return ret;
40 *offset = res->start - root->start;
41
42 return 0;
43}
44
45/**
46 * psb_gtt_mask_pte - generate GTT pte entry
47 * @pfn: page number to encode
48 * @type: type of memory in the GTT
49 *
50 * Set the GTT entry for the appropriate memory type.
51 */
52uint32_t psb_gtt_mask_pte(uint32_t pfn, int type)
53{
54 uint32_t mask = PSB_PTE_VALID;
55
56 /* Ensure we explode rather than put an invalid low mapping of
57 a high mapping page into the gtt */
58 BUG_ON(pfn & ~(0xFFFFFFFF >> PAGE_SHIFT));
59
60 if (type & PSB_MMU_CACHED_MEMORY)
61 mask |= PSB_PTE_CACHED;
62 if (type & PSB_MMU_RO_MEMORY)
63 mask |= PSB_PTE_RO;
64 if (type & PSB_MMU_WO_MEMORY)
65 mask |= PSB_PTE_WO;
66
67 return (pfn << PAGE_SHIFT) | mask;
68}
69
70static u32 __iomem *psb_gtt_entry(struct drm_psb_private *pdev, const struct resource *res)
71{
72 unsigned long offset = res->start - pdev->gtt_mem->start;
73
74 return pdev->gtt_map + (offset >> PAGE_SHIFT);
75}
76
77/* Acquires GTT mutex internally. */
78void psb_gtt_insert_pages(struct drm_psb_private *pdev, const struct resource *res,
79 struct page **pages)
80{
81 resource_size_t npages, i;
82 u32 __iomem *gtt_slot;
83 u32 pte;
84
85 mutex_lock(&pdev->gtt_mutex);
86
87 /* Write our page entries into the GTT itself */
88
89 npages = resource_size(res) >> PAGE_SHIFT;
90 gtt_slot = psb_gtt_entry(pdev, res);
91
92 for (i = 0; i < npages; ++i, ++gtt_slot) {
93 pte = psb_gtt_mask_pte(page_to_pfn(pages[i]), PSB_MMU_CACHED_MEMORY);
94 iowrite32(pte, gtt_slot);
95 }
96
97 /* Make sure all the entries are set before we return */
98 ioread32(gtt_slot - 1);
99
100 mutex_unlock(&pdev->gtt_mutex);
101}
102
103/* Acquires GTT mutex internally. */
104void psb_gtt_remove_pages(struct drm_psb_private *pdev, const struct resource *res)
105{
106 resource_size_t npages, i;
107 u32 __iomem *gtt_slot;
108 u32 pte;
109
110 mutex_lock(&pdev->gtt_mutex);
111
112 /* Install scratch page for the resource */
113
114 pte = psb_gtt_mask_pte(page_to_pfn(pdev->scratch_page), PSB_MMU_CACHED_MEMORY);
115
116 npages = resource_size(res) >> PAGE_SHIFT;
117 gtt_slot = psb_gtt_entry(pdev, res);
118
119 for (i = 0; i < npages; ++i, ++gtt_slot)
120 iowrite32(pte, gtt_slot);
121
122 /* Make sure all the entries are set before we return */
123 ioread32(gtt_slot - 1);
124
125 mutex_unlock(&pdev->gtt_mutex);
126}
127
128static int psb_gtt_enable(struct drm_psb_private *dev_priv)
129{
130 struct drm_device *dev = &dev_priv->dev;
131 struct pci_dev *pdev = to_pci_dev(dev->dev);
132 int ret;
133
134 ret = pci_read_config_word(pdev, PSB_GMCH_CTRL, &dev_priv->gmch_ctrl);
135 if (ret)
136 return pcibios_err_to_errno(ret);
137 ret = pci_write_config_word(pdev, PSB_GMCH_CTRL, dev_priv->gmch_ctrl | _PSB_GMCH_ENABLED);
138 if (ret)
139 return pcibios_err_to_errno(ret);
140
141 dev_priv->pge_ctl = PSB_RVDC32(PSB_PGETBL_CTL);
142 PSB_WVDC32(dev_priv->pge_ctl | _PSB_PGETBL_ENABLED, PSB_PGETBL_CTL);
143
144 (void)PSB_RVDC32(PSB_PGETBL_CTL);
145
146 return 0;
147}
148
149static void psb_gtt_disable(struct drm_psb_private *dev_priv)
150{
151 struct drm_device *dev = &dev_priv->dev;
152 struct pci_dev *pdev = to_pci_dev(dev->dev);
153
154 pci_write_config_word(pdev, PSB_GMCH_CTRL, dev_priv->gmch_ctrl);
155 PSB_WVDC32(dev_priv->pge_ctl, PSB_PGETBL_CTL);
156
157 (void)PSB_RVDC32(PSB_PGETBL_CTL);
158}
159
160void psb_gtt_fini(struct drm_device *dev)
161{
162 struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
163
164 iounmap(dev_priv->gtt_map);
165 psb_gtt_disable(dev_priv);
166 mutex_destroy(&dev_priv->gtt_mutex);
167}
168
169/* Clear GTT. Use a scratch page to avoid accidents or scribbles. */
170static void psb_gtt_clear(struct drm_psb_private *pdev)
171{
172 resource_size_t pfn_base;
173 unsigned long i;
174 uint32_t pte;
175
176 pfn_base = page_to_pfn(pdev->scratch_page);
177 pte = psb_gtt_mask_pte(pfn_base, PSB_MMU_CACHED_MEMORY);
178
179 for (i = 0; i < pdev->gtt.gtt_pages; ++i)
180 iowrite32(pte, pdev->gtt_map + i);
181
182 (void)ioread32(pdev->gtt_map + i - 1);
183}
184
185static void psb_gtt_init_ranges(struct drm_psb_private *dev_priv)
186{
187 struct drm_device *dev = &dev_priv->dev;
188 struct pci_dev *pdev = to_pci_dev(dev->dev);
189 struct psb_gtt *pg = &dev_priv->gtt;
190 resource_size_t gtt_phys_start, mmu_gatt_start, gtt_start, gtt_pages,
191 gatt_start, gatt_pages;
192 struct resource *gtt_mem;
193
194 /* The root resource we allocate address space from */
195 gtt_phys_start = dev_priv->pge_ctl & PAGE_MASK;
196
197 /*
198 * The video MMU has a HW bug when accessing 0x0d0000000. Make
199 * GATT start at 0x0e0000000. This doesn't actually matter for
200 * us now, but maybe will if the video acceleration ever gets
201 * opened up.
202 */
203 mmu_gatt_start = 0xe0000000;
204
205 gtt_start = pci_resource_start(pdev, PSB_GTT_RESOURCE);
206 gtt_pages = pci_resource_len(pdev, PSB_GTT_RESOURCE) >> PAGE_SHIFT;
207
208 /* CDV doesn't report this. In which case the system has 64 gtt pages */
209 if (!gtt_start || !gtt_pages) {
210 dev_dbg(dev->dev, "GTT PCI BAR not initialized.\n");
211 gtt_pages = 64;
212 gtt_start = dev_priv->pge_ctl;
213 }
214
215 gatt_start = pci_resource_start(pdev, PSB_GATT_RESOURCE);
216 gatt_pages = pci_resource_len(pdev, PSB_GATT_RESOURCE) >> PAGE_SHIFT;
217
218 if (!gatt_pages || !gatt_start) {
219 static struct resource fudge; /* Preferably peppermint */
220
221 /*
222 * This can occur on CDV systems. Fudge it in this case. We
223 * really don't care what imaginary space is being allocated
224 * at this point.
225 */
226 dev_dbg(dev->dev, "GATT PCI BAR not initialized.\n");
227 gatt_start = 0x40000000;
228 gatt_pages = (128 * 1024 * 1024) >> PAGE_SHIFT;
229
230 /*
231 * This is a little confusing but in fact the GTT is providing
232 * a view from the GPU into memory and not vice versa. As such
233 * this is really allocating space that is not the same as the
234 * CPU address space on CDV.
235 */
236 fudge.start = 0x40000000;
237 fudge.end = 0x40000000 + 128 * 1024 * 1024 - 1;
238 fudge.name = "fudge";
239 fudge.flags = IORESOURCE_MEM;
240
241 gtt_mem = &fudge;
242 } else {
243 gtt_mem = &pdev->resource[PSB_GATT_RESOURCE];
244 }
245
246 pg->gtt_phys_start = gtt_phys_start;
247 pg->mmu_gatt_start = mmu_gatt_start;
248 pg->gtt_start = gtt_start;
249 pg->gtt_pages = gtt_pages;
250 pg->gatt_start = gatt_start;
251 pg->gatt_pages = gatt_pages;
252 dev_priv->gtt_mem = gtt_mem;
253}
254
255int psb_gtt_init(struct drm_device *dev)
256{
257 struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
258 struct psb_gtt *pg = &dev_priv->gtt;
259 int ret;
260
261 mutex_init(&dev_priv->gtt_mutex);
262
263 ret = psb_gtt_enable(dev_priv);
264 if (ret)
265 goto err_mutex_destroy;
266
267 psb_gtt_init_ranges(dev_priv);
268
269 dev_priv->gtt_map = ioremap(pg->gtt_phys_start, pg->gtt_pages << PAGE_SHIFT);
270 if (!dev_priv->gtt_map) {
271 dev_err(dev->dev, "Failure to map gtt.\n");
272 ret = -ENOMEM;
273 goto err_psb_gtt_disable;
274 }
275
276 psb_gtt_clear(dev_priv);
277
278 return 0;
279
280err_psb_gtt_disable:
281 psb_gtt_disable(dev_priv);
282err_mutex_destroy:
283 mutex_destroy(&dev_priv->gtt_mutex);
284 return ret;
285}
286
287int psb_gtt_resume(struct drm_device *dev)
288{
289 struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
290 struct psb_gtt *pg = &dev_priv->gtt;
291 unsigned int old_gtt_pages = pg->gtt_pages;
292 int ret;
293
294 /* Enable the GTT */
295 ret = psb_gtt_enable(dev_priv);
296 if (ret)
297 return ret;
298
299 psb_gtt_init_ranges(dev_priv);
300
301 if (old_gtt_pages != pg->gtt_pages) {
302 dev_err(dev->dev, "GTT resume error.\n");
303 ret = -ENODEV;
304 goto err_psb_gtt_disable;
305 }
306
307 psb_gtt_clear(dev_priv);
308
309err_psb_gtt_disable:
310 psb_gtt_disable(dev_priv);
311 return ret;
312}
1/*
2 * Copyright (c) 2007, Intel Corporation.
3 * All Rights Reserved.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms and conditions of the GNU General Public License,
7 * version 2, as published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
17 *
18 * Authors: Thomas Hellstrom <thomas-at-tungstengraphics.com>
19 * Alan Cox <alan@linux.intel.com>
20 */
21
22#include <drm/drmP.h>
23#include <linux/shmem_fs.h>
24#include "psb_drv.h"
25
26
27/*
28 * GTT resource allocator - manage page mappings in GTT space
29 */
30
31/**
32 * psb_gtt_mask_pte - generate GTT pte entry
33 * @pfn: page number to encode
34 * @type: type of memory in the GTT
35 *
36 * Set the GTT entry for the appropriate memory type.
37 */
38static inline uint32_t psb_gtt_mask_pte(uint32_t pfn, int type)
39{
40 uint32_t mask = PSB_PTE_VALID;
41
42 /* Ensure we explode rather than put an invalid low mapping of
43 a high mapping page into the gtt */
44 BUG_ON(pfn & ~(0xFFFFFFFF >> PAGE_SHIFT));
45
46 if (type & PSB_MMU_CACHED_MEMORY)
47 mask |= PSB_PTE_CACHED;
48 if (type & PSB_MMU_RO_MEMORY)
49 mask |= PSB_PTE_RO;
50 if (type & PSB_MMU_WO_MEMORY)
51 mask |= PSB_PTE_WO;
52
53 return (pfn << PAGE_SHIFT) | mask;
54}
55
56/**
57 * psb_gtt_entry - find the GTT entries for a gtt_range
58 * @dev: our DRM device
59 * @r: our GTT range
60 *
61 * Given a gtt_range object return the GTT offset of the page table
62 * entries for this gtt_range
63 */
64static u32 __iomem *psb_gtt_entry(struct drm_device *dev, struct gtt_range *r)
65{
66 struct drm_psb_private *dev_priv = dev->dev_private;
67 unsigned long offset;
68
69 offset = r->resource.start - dev_priv->gtt_mem->start;
70
71 return dev_priv->gtt_map + (offset >> PAGE_SHIFT);
72}
73
74/**
75 * psb_gtt_insert - put an object into the GTT
76 * @dev: our DRM device
77 * @r: our GTT range
78 *
79 * Take our preallocated GTT range and insert the GEM object into
80 * the GTT. This is protected via the gtt mutex which the caller
81 * must hold.
82 */
83static int psb_gtt_insert(struct drm_device *dev, struct gtt_range *r)
84{
85 u32 __iomem *gtt_slot;
86 u32 pte;
87 struct page **pages;
88 int i;
89
90 if (r->pages == NULL) {
91 WARN_ON(1);
92 return -EINVAL;
93 }
94
95 WARN_ON(r->stolen); /* refcount these maybe ? */
96
97 gtt_slot = psb_gtt_entry(dev, r);
98 pages = r->pages;
99
100 /* Make sure changes are visible to the GPU */
101 set_pages_array_wc(pages, r->npage);
102
103 /* Write our page entries into the GTT itself */
104 for (i = r->roll; i < r->npage; i++) {
105 pte = psb_gtt_mask_pte(page_to_pfn(r->pages[i]), 0);
106 iowrite32(pte, gtt_slot++);
107 }
108 for (i = 0; i < r->roll; i++) {
109 pte = psb_gtt_mask_pte(page_to_pfn(r->pages[i]), 0);
110 iowrite32(pte, gtt_slot++);
111 }
112 /* Make sure all the entries are set before we return */
113 ioread32(gtt_slot - 1);
114
115 return 0;
116}
117
118/**
119 * psb_gtt_remove - remove an object from the GTT
120 * @dev: our DRM device
121 * @r: our GTT range
122 *
123 * Remove a preallocated GTT range from the GTT. Overwrite all the
124 * page table entries with the dummy page. This is protected via the gtt
125 * mutex which the caller must hold.
126 */
127static void psb_gtt_remove(struct drm_device *dev, struct gtt_range *r)
128{
129 struct drm_psb_private *dev_priv = dev->dev_private;
130 u32 __iomem *gtt_slot;
131 u32 pte;
132 int i;
133
134 WARN_ON(r->stolen);
135
136 gtt_slot = psb_gtt_entry(dev, r);
137 pte = psb_gtt_mask_pte(page_to_pfn(dev_priv->scratch_page), 0);
138
139 for (i = 0; i < r->npage; i++)
140 iowrite32(pte, gtt_slot++);
141 ioread32(gtt_slot - 1);
142 set_pages_array_wb(r->pages, r->npage);
143}
144
145/**
146 * psb_gtt_roll - set scrolling position
147 * @dev: our DRM device
148 * @r: the gtt mapping we are using
149 * @roll: roll offset
150 *
151 * Roll an existing pinned mapping by moving the pages through the GTT.
152 * This allows us to implement hardware scrolling on the consoles without
153 * a 2D engine
154 */
155void psb_gtt_roll(struct drm_device *dev, struct gtt_range *r, int roll)
156{
157 u32 __iomem *gtt_slot;
158 u32 pte;
159 int i;
160
161 if (roll >= r->npage) {
162 WARN_ON(1);
163 return;
164 }
165
166 r->roll = roll;
167
168 /* Not currently in the GTT - no worry we will write the mapping at
169 the right position when it gets pinned */
170 if (!r->stolen && !r->in_gart)
171 return;
172
173 gtt_slot = psb_gtt_entry(dev, r);
174
175 for (i = r->roll; i < r->npage; i++) {
176 pte = psb_gtt_mask_pte(page_to_pfn(r->pages[i]), 0);
177 iowrite32(pte, gtt_slot++);
178 }
179 for (i = 0; i < r->roll; i++) {
180 pte = psb_gtt_mask_pte(page_to_pfn(r->pages[i]), 0);
181 iowrite32(pte, gtt_slot++);
182 }
183 ioread32(gtt_slot - 1);
184}
185
186/**
187 * psb_gtt_attach_pages - attach and pin GEM pages
188 * @gt: the gtt range
189 *
190 * Pin and build an in kernel list of the pages that back our GEM object.
191 * While we hold this the pages cannot be swapped out. This is protected
192 * via the gtt mutex which the caller must hold.
193 */
194static int psb_gtt_attach_pages(struct gtt_range *gt)
195{
196 struct inode *inode;
197 struct address_space *mapping;
198 int i;
199 struct page *p;
200 int pages = gt->gem.size / PAGE_SIZE;
201
202 WARN_ON(gt->pages);
203
204 /* This is the shared memory object that backs the GEM resource */
205 inode = gt->gem.filp->f_path.dentry->d_inode;
206 mapping = inode->i_mapping;
207
208 gt->pages = kmalloc(pages * sizeof(struct page *), GFP_KERNEL);
209 if (gt->pages == NULL)
210 return -ENOMEM;
211 gt->npage = pages;
212
213 for (i = 0; i < pages; i++) {
214 p = shmem_read_mapping_page(mapping, i);
215 if (IS_ERR(p))
216 goto err;
217 gt->pages[i] = p;
218 }
219 return 0;
220
221err:
222 while (i--)
223 page_cache_release(gt->pages[i]);
224 kfree(gt->pages);
225 gt->pages = NULL;
226 return PTR_ERR(p);
227}
228
229/**
230 * psb_gtt_detach_pages - attach and pin GEM pages
231 * @gt: the gtt range
232 *
233 * Undo the effect of psb_gtt_attach_pages. At this point the pages
234 * must have been removed from the GTT as they could now be paged out
235 * and move bus address. This is protected via the gtt mutex which the
236 * caller must hold.
237 */
238static void psb_gtt_detach_pages(struct gtt_range *gt)
239{
240 int i;
241 for (i = 0; i < gt->npage; i++) {
242 /* FIXME: do we need to force dirty */
243 set_page_dirty(gt->pages[i]);
244 page_cache_release(gt->pages[i]);
245 }
246 kfree(gt->pages);
247 gt->pages = NULL;
248}
249
250/**
251 * psb_gtt_pin - pin pages into the GTT
252 * @gt: range to pin
253 *
254 * Pin a set of pages into the GTT. The pins are refcounted so that
255 * multiple pins need multiple unpins to undo.
256 *
257 * Non GEM backed objects treat this as a no-op as they are always GTT
258 * backed objects.
259 */
260int psb_gtt_pin(struct gtt_range *gt)
261{
262 int ret = 0;
263 struct drm_device *dev = gt->gem.dev;
264 struct drm_psb_private *dev_priv = dev->dev_private;
265
266 mutex_lock(&dev_priv->gtt_mutex);
267
268 if (gt->in_gart == 0 && gt->stolen == 0) {
269 ret = psb_gtt_attach_pages(gt);
270 if (ret < 0)
271 goto out;
272 ret = psb_gtt_insert(dev, gt);
273 if (ret < 0) {
274 psb_gtt_detach_pages(gt);
275 goto out;
276 }
277 }
278 gt->in_gart++;
279out:
280 mutex_unlock(&dev_priv->gtt_mutex);
281 return ret;
282}
283
284/**
285 * psb_gtt_unpin - Drop a GTT pin requirement
286 * @gt: range to pin
287 *
288 * Undoes the effect of psb_gtt_pin. On the last drop the GEM object
289 * will be removed from the GTT which will also drop the page references
290 * and allow the VM to clean up or page stuff.
291 *
292 * Non GEM backed objects treat this as a no-op as they are always GTT
293 * backed objects.
294 */
295void psb_gtt_unpin(struct gtt_range *gt)
296{
297 struct drm_device *dev = gt->gem.dev;
298 struct drm_psb_private *dev_priv = dev->dev_private;
299
300 mutex_lock(&dev_priv->gtt_mutex);
301
302 WARN_ON(!gt->in_gart);
303
304 gt->in_gart--;
305 if (gt->in_gart == 0 && gt->stolen == 0) {
306 psb_gtt_remove(dev, gt);
307 psb_gtt_detach_pages(gt);
308 }
309 mutex_unlock(&dev_priv->gtt_mutex);
310}
311
312/*
313 * GTT resource allocator - allocate and manage GTT address space
314 */
315
316/**
317 * psb_gtt_alloc_range - allocate GTT address space
318 * @dev: Our DRM device
319 * @len: length (bytes) of address space required
320 * @name: resource name
321 * @backed: resource should be backed by stolen pages
322 *
323 * Ask the kernel core to find us a suitable range of addresses
324 * to use for a GTT mapping.
325 *
326 * Returns a gtt_range structure describing the object, or NULL on
327 * error. On successful return the resource is both allocated and marked
328 * as in use.
329 */
330struct gtt_range *psb_gtt_alloc_range(struct drm_device *dev, int len,
331 const char *name, int backed)
332{
333 struct drm_psb_private *dev_priv = dev->dev_private;
334 struct gtt_range *gt;
335 struct resource *r = dev_priv->gtt_mem;
336 int ret;
337 unsigned long start, end;
338
339 if (backed) {
340 /* The start of the GTT is the stolen pages */
341 start = r->start;
342 end = r->start + dev_priv->gtt.stolen_size - 1;
343 } else {
344 /* The rest we will use for GEM backed objects */
345 start = r->start + dev_priv->gtt.stolen_size;
346 end = r->end;
347 }
348
349 gt = kzalloc(sizeof(struct gtt_range), GFP_KERNEL);
350 if (gt == NULL)
351 return NULL;
352 gt->resource.name = name;
353 gt->stolen = backed;
354 gt->in_gart = backed;
355 gt->roll = 0;
356 /* Ensure this is set for non GEM objects */
357 gt->gem.dev = dev;
358 ret = allocate_resource(dev_priv->gtt_mem, >->resource,
359 len, start, end, PAGE_SIZE, NULL, NULL);
360 if (ret == 0) {
361 gt->offset = gt->resource.start - r->start;
362 return gt;
363 }
364 kfree(gt);
365 return NULL;
366}
367
368/**
369 * psb_gtt_free_range - release GTT address space
370 * @dev: our DRM device
371 * @gt: a mapping created with psb_gtt_alloc_range
372 *
373 * Release a resource that was allocated with psb_gtt_alloc_range. If the
374 * object has been pinned by mmap users we clean this up here currently.
375 */
376void psb_gtt_free_range(struct drm_device *dev, struct gtt_range *gt)
377{
378 /* Undo the mmap pin if we are destroying the object */
379 if (gt->mmapping) {
380 psb_gtt_unpin(gt);
381 gt->mmapping = 0;
382 }
383 WARN_ON(gt->in_gart && !gt->stolen);
384 release_resource(>->resource);
385 kfree(gt);
386}
387
388static void psb_gtt_alloc(struct drm_device *dev)
389{
390 struct drm_psb_private *dev_priv = dev->dev_private;
391 init_rwsem(&dev_priv->gtt.sem);
392}
393
394void psb_gtt_takedown(struct drm_device *dev)
395{
396 struct drm_psb_private *dev_priv = dev->dev_private;
397
398 if (dev_priv->gtt_map) {
399 iounmap(dev_priv->gtt_map);
400 dev_priv->gtt_map = NULL;
401 }
402 if (dev_priv->gtt_initialized) {
403 pci_write_config_word(dev->pdev, PSB_GMCH_CTRL,
404 dev_priv->gmch_ctrl);
405 PSB_WVDC32(dev_priv->pge_ctl, PSB_PGETBL_CTL);
406 (void) PSB_RVDC32(PSB_PGETBL_CTL);
407 }
408 if (dev_priv->vram_addr)
409 iounmap(dev_priv->gtt_map);
410}
411
412int psb_gtt_init(struct drm_device *dev, int resume)
413{
414 struct drm_psb_private *dev_priv = dev->dev_private;
415 unsigned gtt_pages;
416 unsigned long stolen_size, vram_stolen_size;
417 unsigned i, num_pages;
418 unsigned pfn_base;
419 struct psb_gtt *pg;
420
421 int ret = 0;
422 uint32_t pte;
423
424 mutex_init(&dev_priv->gtt_mutex);
425
426 psb_gtt_alloc(dev);
427 pg = &dev_priv->gtt;
428
429 /* Enable the GTT */
430 pci_read_config_word(dev->pdev, PSB_GMCH_CTRL, &dev_priv->gmch_ctrl);
431 pci_write_config_word(dev->pdev, PSB_GMCH_CTRL,
432 dev_priv->gmch_ctrl | _PSB_GMCH_ENABLED);
433
434 dev_priv->pge_ctl = PSB_RVDC32(PSB_PGETBL_CTL);
435 PSB_WVDC32(dev_priv->pge_ctl | _PSB_PGETBL_ENABLED, PSB_PGETBL_CTL);
436 (void) PSB_RVDC32(PSB_PGETBL_CTL);
437
438 /* The root resource we allocate address space from */
439 dev_priv->gtt_initialized = 1;
440
441 pg->gtt_phys_start = dev_priv->pge_ctl & PAGE_MASK;
442
443 /*
444 * The video mmu has a hw bug when accessing 0x0D0000000.
445 * Make gatt start at 0x0e000,0000. This doesn't actually
446 * matter for us but may do if the video acceleration ever
447 * gets opened up.
448 */
449 pg->mmu_gatt_start = 0xE0000000;
450
451 pg->gtt_start = pci_resource_start(dev->pdev, PSB_GTT_RESOURCE);
452 gtt_pages = pci_resource_len(dev->pdev, PSB_GTT_RESOURCE)
453 >> PAGE_SHIFT;
454 /* CDV doesn't report this. In which case the system has 64 gtt pages */
455 if (pg->gtt_start == 0 || gtt_pages == 0) {
456 dev_dbg(dev->dev, "GTT PCI BAR not initialized.\n");
457 gtt_pages = 64;
458 pg->gtt_start = dev_priv->pge_ctl;
459 }
460
461 pg->gatt_start = pci_resource_start(dev->pdev, PSB_GATT_RESOURCE);
462 pg->gatt_pages = pci_resource_len(dev->pdev, PSB_GATT_RESOURCE)
463 >> PAGE_SHIFT;
464 dev_priv->gtt_mem = &dev->pdev->resource[PSB_GATT_RESOURCE];
465
466 if (pg->gatt_pages == 0 || pg->gatt_start == 0) {
467 static struct resource fudge; /* Preferably peppermint */
468 /* This can occur on CDV systems. Fudge it in this case.
469 We really don't care what imaginary space is being allocated
470 at this point */
471 dev_dbg(dev->dev, "GATT PCI BAR not initialized.\n");
472 pg->gatt_start = 0x40000000;
473 pg->gatt_pages = (128 * 1024 * 1024) >> PAGE_SHIFT;
474 /* This is a little confusing but in fact the GTT is providing
475 a view from the GPU into memory and not vice versa. As such
476 this is really allocating space that is not the same as the
477 CPU address space on CDV */
478 fudge.start = 0x40000000;
479 fudge.end = 0x40000000 + 128 * 1024 * 1024 - 1;
480 fudge.name = "fudge";
481 fudge.flags = IORESOURCE_MEM;
482 dev_priv->gtt_mem = &fudge;
483 }
484
485 pci_read_config_dword(dev->pdev, PSB_BSM, &dev_priv->stolen_base);
486 vram_stolen_size = pg->gtt_phys_start - dev_priv->stolen_base
487 - PAGE_SIZE;
488
489 stolen_size = vram_stolen_size;
490
491 dev_dbg(dev->dev, "Stolen memory base 0x%x, size %luK\n",
492 dev_priv->stolen_base, vram_stolen_size / 1024);
493
494 if (resume && (gtt_pages != pg->gtt_pages) &&
495 (stolen_size != pg->stolen_size)) {
496 dev_err(dev->dev, "GTT resume error.\n");
497 ret = -EINVAL;
498 goto out_err;
499 }
500
501 pg->gtt_pages = gtt_pages;
502 pg->stolen_size = stolen_size;
503 dev_priv->vram_stolen_size = vram_stolen_size;
504
505 /*
506 * Map the GTT and the stolen memory area
507 */
508 dev_priv->gtt_map = ioremap_nocache(pg->gtt_phys_start,
509 gtt_pages << PAGE_SHIFT);
510 if (!dev_priv->gtt_map) {
511 dev_err(dev->dev, "Failure to map gtt.\n");
512 ret = -ENOMEM;
513 goto out_err;
514 }
515
516 dev_priv->vram_addr = ioremap_wc(dev_priv->stolen_base, stolen_size);
517 if (!dev_priv->vram_addr) {
518 dev_err(dev->dev, "Failure to map stolen base.\n");
519 ret = -ENOMEM;
520 goto out_err;
521 }
522
523 /*
524 * Insert vram stolen pages into the GTT
525 */
526
527 pfn_base = dev_priv->stolen_base >> PAGE_SHIFT;
528 num_pages = vram_stolen_size >> PAGE_SHIFT;
529 dev_dbg(dev->dev, "Set up %d stolen pages starting at 0x%08x, GTT offset %dK\n",
530 num_pages, pfn_base << PAGE_SHIFT, 0);
531 for (i = 0; i < num_pages; ++i) {
532 pte = psb_gtt_mask_pte(pfn_base + i, 0);
533 iowrite32(pte, dev_priv->gtt_map + i);
534 }
535
536 /*
537 * Init rest of GTT to the scratch page to avoid accidents or scribbles
538 */
539
540 pfn_base = page_to_pfn(dev_priv->scratch_page);
541 pte = psb_gtt_mask_pte(pfn_base, 0);
542 for (; i < gtt_pages; ++i)
543 iowrite32(pte, dev_priv->gtt_map + i);
544
545 (void) ioread32(dev_priv->gtt_map + i - 1);
546 return 0;
547
548out_err:
549 psb_gtt_takedown(dev);
550 return ret;
551}