blob: 8c03eaf414486c9590c830d2e551369406afff84 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/**
Dave Airlieb5e89ed2005-09-25 14:28:13 +10002 * \file drm_vm.c
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 * Memory mapping for DRM
Dave Airlieb5e89ed2005-09-25 14:28:13 +10004 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 * \author Rickard E. (Rik) Faith <faith@valinux.com>
6 * \author Gareth Hughes <gareth@valinux.com>
7 */
8
9/*
10 * Created: Mon Jan 4 08:58:31 1999 by faith@valinux.com
11 *
12 * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
13 * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
14 * All Rights Reserved.
15 *
16 * Permission is hereby granted, free of charge, to any person obtaining a
17 * copy of this software and associated documentation files (the "Software"),
18 * to deal in the Software without restriction, including without limitation
19 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
20 * and/or sell copies of the Software, and to permit persons to whom the
21 * Software is furnished to do so, subject to the following conditions:
22 *
23 * The above copyright notice and this permission notice (including the next
24 * paragraph) shall be included in all copies or substantial portions of the
25 * Software.
26 *
27 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
28 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
29 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
30 * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
31 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
32 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
33 * OTHER DEALINGS IN THE SOFTWARE.
34 */
35
36#include "drmP.h"
Paul Gortmaker2d1a8a42011-08-30 18:16:33 -040037#include <linux/export.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#if defined(__ia64__)
39#include <linux/efi.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090040#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041#endif
42
Dave Airliec94f7022005-07-07 21:03:38 +100043static void drm_vm_open(struct vm_area_struct *vma);
44static void drm_vm_close(struct vm_area_struct *vma);
Linus Torvalds1da177e2005-04-16 15:20:36 -070045
Adrian Bunk0bead7c2007-03-11 11:41:16 +110046static pgprot_t drm_io_prot(uint32_t map_type, struct vm_area_struct *vma)
Dave Airlie5cc7f9a2007-02-10 11:53:13 +110047{
48 pgprot_t tmp = vm_get_page_prot(vma->vm_flags);
49
50#if defined(__i386__) || defined(__x86_64__)
51 if (boot_cpu_data.x86 > 3 && map_type != _DRM_AGP) {
52 pgprot_val(tmp) |= _PAGE_PCD;
53 pgprot_val(tmp) &= ~_PAGE_PWT;
54 }
55#elif defined(__powerpc__)
56 pgprot_val(tmp) |= _PAGE_NO_CACHE;
57 if (map_type == _DRM_REGISTERS)
58 pgprot_val(tmp) |= _PAGE_GUARDED;
Benjamin Herrenschmidt6876b3b2008-03-28 14:23:07 -070059#elif defined(__ia64__)
Dave Airlie5cc7f9a2007-02-10 11:53:13 +110060 if (efi_range_is_wc(vma->vm_start, vma->vm_end -
61 vma->vm_start))
62 tmp = pgprot_writecombine(tmp);
63 else
64 tmp = pgprot_noncached(tmp);
Jordan Crouse4b7fb9b2010-05-27 13:40:26 -060065#elif defined(__sparc__) || defined(__arm__)
Benjamin Herrenschmidt6876b3b2008-03-28 14:23:07 -070066 tmp = pgprot_noncached(tmp);
67#endif
68 return tmp;
69}
70
71static pgprot_t drm_dma_prot(uint32_t map_type, struct vm_area_struct *vma)
72{
73 pgprot_t tmp = vm_get_page_prot(vma->vm_flags);
74
75#if defined(__powerpc__) && defined(CONFIG_NOT_COHERENT_CACHE)
76 tmp |= _PAGE_NO_CACHE;
Dave Airlie5cc7f9a2007-02-10 11:53:13 +110077#endif
78 return tmp;
79}
80
Linus Torvalds1da177e2005-04-16 15:20:36 -070081/**
Nick Pigginca0b07d2008-02-07 16:20:50 +100082 * \c fault method for AGP virtual memory.
Linus Torvalds1da177e2005-04-16 15:20:36 -070083 *
84 * \param vma virtual memory area.
85 * \param address access address.
86 * \return pointer to the page structure.
Dave Airlieb5e89ed2005-09-25 14:28:13 +100087 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 * Find the right map and if it's AGP memory find the real physical page to
89 * map, get the page, increment the use count and return it.
90 */
91#if __OS_HAS_AGP
Nick Pigginca0b07d2008-02-07 16:20:50 +100092static int drm_do_vm_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
Linus Torvalds1da177e2005-04-16 15:20:36 -070093{
Dave Airlie84b1fd12007-07-11 15:53:27 +100094 struct drm_file *priv = vma->vm_file->private_data;
Dave Airlie2c14f282008-04-21 16:47:32 +100095 struct drm_device *dev = priv->minor->dev;
Benjamin Herrenschmidtf77d3902009-02-02 16:55:46 +110096 struct drm_local_map *map = NULL;
Dave Airlie55910512007-07-11 16:53:40 +100097 struct drm_map_list *r_list;
Dave Airliee0be4282007-07-12 10:26:44 +100098 struct drm_hash_item *hash;
Linus Torvalds1da177e2005-04-16 15:20:36 -070099
100 /*
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000101 * Find the right map
102 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103 if (!drm_core_has_AGP(dev))
Nick Pigginca0b07d2008-02-07 16:20:50 +1000104 goto vm_fault_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000106 if (!dev->agp || !dev->agp->cant_use_aperture)
Nick Pigginca0b07d2008-02-07 16:20:50 +1000107 goto vm_fault_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108
Thomas Hellstrom15450852007-02-08 16:14:05 +1100109 if (drm_ht_find_item(&dev->map_hash, vma->vm_pgoff, &hash))
Nick Pigginca0b07d2008-02-07 16:20:50 +1000110 goto vm_fault_error;
Thomas Hellstrom8d153f72006-08-07 22:36:47 +1000111
Dave Airlie55910512007-07-11 16:53:40 +1000112 r_list = drm_hash_entry(hash, struct drm_map_list, hash);
Thomas Hellstrom8d153f72006-08-07 22:36:47 +1000113 map = r_list->map;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114
115 if (map && map->type == _DRM_AGP) {
Nick Pigginca0b07d2008-02-07 16:20:50 +1000116 /*
117 * Using vm_pgoff as a selector forces us to use this unusual
118 * addressing scheme.
119 */
Benjamin Herrenschmidt41c2e752009-02-02 16:55:47 +1100120 resource_size_t offset = (unsigned long)vmf->virtual_address -
121 vma->vm_start;
122 resource_size_t baddr = map->offset + offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 struct drm_agp_mem *agpmem;
124 struct page *page;
125
126#ifdef __alpha__
127 /*
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000128 * Adjust to a bus-relative address
129 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 baddr -= dev->hose->mem_space->start;
131#endif
132
133 /*
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000134 * It's AGP memory - find the real physical page to map
135 */
Dave Airliebd1b3312007-05-26 05:01:51 +1000136 list_for_each_entry(agpmem, &dev->agp->memory, head) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 if (agpmem->bound <= baddr &&
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000138 agpmem->bound + agpmem->pages * PAGE_SIZE > baddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 break;
140 }
141
Dan Carpenter161c4812010-08-19 11:39:57 +0200142 if (&agpmem->head == &dev->agp->memory)
Nick Pigginca0b07d2008-02-07 16:20:50 +1000143 goto vm_fault_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144
145 /*
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000146 * Get the page, inc the use count, and return it
147 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148 offset = (baddr - agpmem->bound) >> PAGE_SHIFT;
Dave Airlie07613ba2009-06-12 14:11:41 +1000149 page = agpmem->memory->pages[offset];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 get_page(page);
Nick Pigginca0b07d2008-02-07 16:20:50 +1000151 vmf->page = page;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000153 DRM_DEBUG
Benjamin Herrenschmidt41c2e752009-02-02 16:55:47 +1100154 ("baddr = 0x%llx page = 0x%p, offset = 0x%llx, count=%d\n",
155 (unsigned long long)baddr,
Dave Airlie07613ba2009-06-12 14:11:41 +1000156 agpmem->memory->pages[offset],
Benjamin Herrenschmidt41c2e752009-02-02 16:55:47 +1100157 (unsigned long long)offset,
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000158 page_count(page));
Nick Pigginca0b07d2008-02-07 16:20:50 +1000159 return 0;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000160 }
Nick Pigginca0b07d2008-02-07 16:20:50 +1000161vm_fault_error:
162 return VM_FAULT_SIGBUS; /* Disallow mremap */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163}
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000164#else /* __OS_HAS_AGP */
Nick Pigginca0b07d2008-02-07 16:20:50 +1000165static int drm_do_vm_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166{
Nick Pigginca0b07d2008-02-07 16:20:50 +1000167 return VM_FAULT_SIGBUS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168}
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000169#endif /* __OS_HAS_AGP */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170
171/**
172 * \c nopage method for shared virtual memory.
173 *
174 * \param vma virtual memory area.
175 * \param address access address.
176 * \return pointer to the page structure.
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000177 *
Michael Opdenacker59c51592007-05-09 08:57:56 +0200178 * Get the mapping, find the real physical page to map, get the page, and
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179 * return it.
180 */
Nick Pigginca0b07d2008-02-07 16:20:50 +1000181static int drm_do_vm_shm_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182{
Benjamin Herrenschmidtf77d3902009-02-02 16:55:46 +1100183 struct drm_local_map *map = vma->vm_private_data;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000184 unsigned long offset;
185 unsigned long i;
186 struct page *page;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000188 if (!map)
Nick Pigginca0b07d2008-02-07 16:20:50 +1000189 return VM_FAULT_SIGBUS; /* Nothing allocated */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190
Nick Pigginca0b07d2008-02-07 16:20:50 +1000191 offset = (unsigned long)vmf->virtual_address - vma->vm_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 i = (unsigned long)map->handle + offset;
Hugh Dickins38315872007-03-24 17:55:16 +1100193 page = vmalloc_to_page((void *)i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194 if (!page)
Nick Pigginca0b07d2008-02-07 16:20:50 +1000195 return VM_FAULT_SIGBUS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 get_page(page);
Nick Pigginca0b07d2008-02-07 16:20:50 +1000197 vmf->page = page;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198
Nick Pigginca0b07d2008-02-07 16:20:50 +1000199 DRM_DEBUG("shm_fault 0x%lx\n", offset);
200 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201}
202
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203/**
204 * \c close method for shared virtual memory.
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000205 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 * \param vma virtual memory area.
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000207 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 * Deletes map information if we are the last
209 * person to close a mapping and it's not in the global maplist.
210 */
Dave Airliec94f7022005-07-07 21:03:38 +1000211static void drm_vm_shm_close(struct vm_area_struct *vma)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212{
Dave Airlie84b1fd12007-07-11 15:53:27 +1000213 struct drm_file *priv = vma->vm_file->private_data;
Dave Airlie2c14f282008-04-21 16:47:32 +1000214 struct drm_device *dev = priv->minor->dev;
Dave Airlie8fc2fdf2007-07-11 16:21:47 +1000215 struct drm_vma_entry *pt, *temp;
Benjamin Herrenschmidtf77d3902009-02-02 16:55:46 +1100216 struct drm_local_map *map;
Dave Airlie55910512007-07-11 16:53:40 +1000217 struct drm_map_list *r_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218 int found_maps = 0;
219
220 DRM_DEBUG("0x%08lx,0x%08lx\n",
221 vma->vm_start, vma->vm_end - vma->vm_start);
222 atomic_dec(&dev->vma_count);
223
224 map = vma->vm_private_data;
225
Dave Airlie30e2fb12006-02-02 19:37:46 +1100226 mutex_lock(&dev->struct_mutex);
Dave Airliebd1b3312007-05-26 05:01:51 +1000227 list_for_each_entry_safe(pt, temp, &dev->vmalist, head) {
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000228 if (pt->vma->vm_private_data == map)
229 found_maps++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 if (pt->vma == vma) {
Dave Airliebd1b3312007-05-26 05:01:51 +1000231 list_del(&pt->head);
Eric Anholt9a298b22009-03-24 12:23:04 -0700232 kfree(pt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 }
234 }
Dave Airliebd1b3312007-05-26 05:01:51 +1000235
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 /* We were the only map that was found */
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000237 if (found_maps == 1 && map->flags & _DRM_REMOVABLE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 /* Check to see if we are in the maplist, if we are not, then
239 * we delete this mappings information.
240 */
241 found_maps = 0;
Dave Airliebd1b3312007-05-26 05:01:51 +1000242 list_for_each_entry(r_list, &dev->maplist, head) {
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000243 if (r_list->map == map)
244 found_maps++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 }
246
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000247 if (!found_maps) {
Dave Airlie9c8da5e2005-07-10 15:38:56 +1000248 drm_dma_handle_t dmah;
249
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 switch (map->type) {
251 case _DRM_REGISTERS:
252 case _DRM_FRAME_BUFFER:
253 if (drm_core_has_MTRR(dev) && map->mtrr >= 0) {
254 int retcode;
255 retcode = mtrr_del(map->mtrr,
256 map->offset,
257 map->size);
258 DRM_DEBUG("mtrr_del = %d\n", retcode);
259 }
Christoph Hellwig004a7722007-01-08 21:56:59 +1100260 iounmap(map->handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 break;
262 case _DRM_SHM:
263 vfree(map->handle);
264 break;
265 case _DRM_AGP:
266 case _DRM_SCATTER_GATHER:
267 break;
Dave Airlie2d0f9ea2005-07-10 14:34:13 +1000268 case _DRM_CONSISTENT:
Dave Airlie9c8da5e2005-07-10 15:38:56 +1000269 dmah.vaddr = map->handle;
270 dmah.busaddr = map->offset;
271 dmah.size = map->size;
272 __drm_pci_free(dev, &dmah);
Dave Airlie2d0f9ea2005-07-10 14:34:13 +1000273 break;
Jesse Barnesa2c0a972008-11-05 10:31:53 -0800274 case _DRM_GEM:
275 DRM_ERROR("tried to rmmap GEM object\n");
276 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 }
Eric Anholt9a298b22009-03-24 12:23:04 -0700278 kfree(map);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 }
280 }
Dave Airlie30e2fb12006-02-02 19:37:46 +1100281 mutex_unlock(&dev->struct_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282}
283
284/**
Nick Pigginca0b07d2008-02-07 16:20:50 +1000285 * \c fault method for DMA virtual memory.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 *
287 * \param vma virtual memory area.
288 * \param address access address.
289 * \return pointer to the page structure.
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000290 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 * Determine the page number from the page offset and get it from drm_device_dma::pagelist.
292 */
Nick Pigginca0b07d2008-02-07 16:20:50 +1000293static int drm_do_vm_dma_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294{
Dave Airlie84b1fd12007-07-11 15:53:27 +1000295 struct drm_file *priv = vma->vm_file->private_data;
Dave Airlie2c14f282008-04-21 16:47:32 +1000296 struct drm_device *dev = priv->minor->dev;
Dave Airliecdd55a22007-07-11 16:32:08 +1000297 struct drm_device_dma *dma = dev->dma;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000298 unsigned long offset;
299 unsigned long page_nr;
300 struct page *page;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000302 if (!dma)
Nick Pigginca0b07d2008-02-07 16:20:50 +1000303 return VM_FAULT_SIGBUS; /* Error */
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000304 if (!dma->pagelist)
Nick Pigginca0b07d2008-02-07 16:20:50 +1000305 return VM_FAULT_SIGBUS; /* Nothing allocated */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306
Nick Pigginca0b07d2008-02-07 16:20:50 +1000307 offset = (unsigned long)vmf->virtual_address - vma->vm_start; /* vm_[pg]off[set] should be 0 */
308 page_nr = offset >> PAGE_SHIFT; /* page_nr could just be vmf->pgoff */
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000309 page = virt_to_page((dma->pagelist[page_nr] + (offset & (~PAGE_MASK))));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310
311 get_page(page);
Nick Pigginca0b07d2008-02-07 16:20:50 +1000312 vmf->page = page;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313
Nick Pigginca0b07d2008-02-07 16:20:50 +1000314 DRM_DEBUG("dma_fault 0x%lx (page %lu)\n", offset, page_nr);
315 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316}
317
318/**
Nick Pigginca0b07d2008-02-07 16:20:50 +1000319 * \c fault method for scatter-gather virtual memory.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 *
321 * \param vma virtual memory area.
322 * \param address access address.
323 * \return pointer to the page structure.
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000324 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 * Determine the map offset from the page offset and get it from drm_sg_mem::pagelist.
326 */
Nick Pigginca0b07d2008-02-07 16:20:50 +1000327static int drm_do_vm_sg_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328{
Benjamin Herrenschmidtf77d3902009-02-02 16:55:46 +1100329 struct drm_local_map *map = vma->vm_private_data;
Dave Airlie84b1fd12007-07-11 15:53:27 +1000330 struct drm_file *priv = vma->vm_file->private_data;
Dave Airlie2c14f282008-04-21 16:47:32 +1000331 struct drm_device *dev = priv->minor->dev;
Dave Airlie55910512007-07-11 16:53:40 +1000332 struct drm_sg_mem *entry = dev->sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 unsigned long offset;
334 unsigned long map_offset;
335 unsigned long page_offset;
336 struct page *page;
337
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000338 if (!entry)
Nick Pigginca0b07d2008-02-07 16:20:50 +1000339 return VM_FAULT_SIGBUS; /* Error */
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000340 if (!entry->pagelist)
Nick Pigginca0b07d2008-02-07 16:20:50 +1000341 return VM_FAULT_SIGBUS; /* Nothing allocated */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342
Nick Pigginca0b07d2008-02-07 16:20:50 +1000343 offset = (unsigned long)vmf->virtual_address - vma->vm_start;
Dave Airlied1f2b552005-08-05 22:11:22 +1000344 map_offset = map->offset - (unsigned long)dev->sg->virtual;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 page_offset = (offset >> PAGE_SHIFT) + (map_offset >> PAGE_SHIFT);
346 page = entry->pagelist[page_offset];
347 get_page(page);
Nick Pigginca0b07d2008-02-07 16:20:50 +1000348 vmf->page = page;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349
Nick Pigginca0b07d2008-02-07 16:20:50 +1000350 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351}
352
Nick Pigginca0b07d2008-02-07 16:20:50 +1000353static int drm_vm_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000354{
Nick Pigginca0b07d2008-02-07 16:20:50 +1000355 return drm_do_vm_fault(vma, vmf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356}
357
Nick Pigginca0b07d2008-02-07 16:20:50 +1000358static int drm_vm_shm_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000359{
Nick Pigginca0b07d2008-02-07 16:20:50 +1000360 return drm_do_vm_shm_fault(vma, vmf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361}
362
Nick Pigginca0b07d2008-02-07 16:20:50 +1000363static int drm_vm_dma_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000364{
Nick Pigginca0b07d2008-02-07 16:20:50 +1000365 return drm_do_vm_dma_fault(vma, vmf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366}
367
Nick Pigginca0b07d2008-02-07 16:20:50 +1000368static int drm_vm_sg_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000369{
Nick Pigginca0b07d2008-02-07 16:20:50 +1000370 return drm_do_vm_sg_fault(vma, vmf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371}
372
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373/** AGP virtual memory operations */
Alexey Dobriyanf0f37e22009-09-27 22:29:37 +0400374static const struct vm_operations_struct drm_vm_ops = {
Nick Pigginca0b07d2008-02-07 16:20:50 +1000375 .fault = drm_vm_fault,
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000376 .open = drm_vm_open,
377 .close = drm_vm_close,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378};
379
380/** Shared virtual memory operations */
Alexey Dobriyanf0f37e22009-09-27 22:29:37 +0400381static const struct vm_operations_struct drm_vm_shm_ops = {
Nick Pigginca0b07d2008-02-07 16:20:50 +1000382 .fault = drm_vm_shm_fault,
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000383 .open = drm_vm_open,
384 .close = drm_vm_shm_close,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385};
386
387/** DMA virtual memory operations */
Alexey Dobriyanf0f37e22009-09-27 22:29:37 +0400388static const struct vm_operations_struct drm_vm_dma_ops = {
Nick Pigginca0b07d2008-02-07 16:20:50 +1000389 .fault = drm_vm_dma_fault,
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000390 .open = drm_vm_open,
391 .close = drm_vm_close,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392};
393
394/** Scatter-gather virtual memory operations */
Alexey Dobriyanf0f37e22009-09-27 22:29:37 +0400395static const struct vm_operations_struct drm_vm_sg_ops = {
Nick Pigginca0b07d2008-02-07 16:20:50 +1000396 .fault = drm_vm_sg_fault,
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000397 .open = drm_vm_open,
398 .close = drm_vm_close,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399};
400
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401/**
402 * \c open method for shared virtual memory.
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000403 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 * \param vma virtual memory area.
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000405 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 * Create a new drm_vma_entry structure as the \p vma private data entry and
407 * add it to drm_device::vmalist.
408 */
Jesse Barnesa2c0a972008-11-05 10:31:53 -0800409void drm_vm_open_locked(struct vm_area_struct *vma)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410{
Dave Airlie84b1fd12007-07-11 15:53:27 +1000411 struct drm_file *priv = vma->vm_file->private_data;
Dave Airlie2c14f282008-04-21 16:47:32 +1000412 struct drm_device *dev = priv->minor->dev;
Dave Airlie8fc2fdf2007-07-11 16:21:47 +1000413 struct drm_vma_entry *vma_entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414
415 DRM_DEBUG("0x%08lx,0x%08lx\n",
416 vma->vm_start, vma->vm_end - vma->vm_start);
417 atomic_inc(&dev->vma_count);
418
Eric Anholt9a298b22009-03-24 12:23:04 -0700419 vma_entry = kmalloc(sizeof(*vma_entry), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 if (vma_entry) {
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000421 vma_entry->vma = vma;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000422 vma_entry->pid = current->pid;
Dave Airliebd1b3312007-05-26 05:01:51 +1000423 list_add(&vma_entry->head, &dev->vmalist);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 }
425}
426
Thomas Hellstromd7d8aac2007-03-24 17:52:49 +1100427static void drm_vm_open(struct vm_area_struct *vma)
428{
Dave Airlie84b1fd12007-07-11 15:53:27 +1000429 struct drm_file *priv = vma->vm_file->private_data;
Dave Airlie2c14f282008-04-21 16:47:32 +1000430 struct drm_device *dev = priv->minor->dev;
Thomas Hellstromd7d8aac2007-03-24 17:52:49 +1100431
432 mutex_lock(&dev->struct_mutex);
433 drm_vm_open_locked(vma);
434 mutex_unlock(&dev->struct_mutex);
435}
436
Chris Wilson31dfbc92010-09-27 21:28:30 +0100437void drm_vm_close_locked(struct vm_area_struct *vma)
438{
439 struct drm_file *priv = vma->vm_file->private_data;
440 struct drm_device *dev = priv->minor->dev;
441 struct drm_vma_entry *pt, *temp;
442
443 DRM_DEBUG("0x%08lx,0x%08lx\n",
444 vma->vm_start, vma->vm_end - vma->vm_start);
445 atomic_dec(&dev->vma_count);
446
447 list_for_each_entry_safe(pt, temp, &dev->vmalist, head) {
448 if (pt->vma == vma) {
449 list_del(&pt->head);
450 kfree(pt);
451 break;
452 }
453 }
454}
455
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456/**
457 * \c close method for all virtual memory types.
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000458 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 * \param vma virtual memory area.
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000460 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 * Search the \p vma private data entry in drm_device::vmalist, unlink it, and
462 * free it.
463 */
Dave Airliec94f7022005-07-07 21:03:38 +1000464static void drm_vm_close(struct vm_area_struct *vma)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465{
Dave Airlie84b1fd12007-07-11 15:53:27 +1000466 struct drm_file *priv = vma->vm_file->private_data;
Dave Airlie2c14f282008-04-21 16:47:32 +1000467 struct drm_device *dev = priv->minor->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468
Dave Airlie30e2fb12006-02-02 19:37:46 +1100469 mutex_lock(&dev->struct_mutex);
Chris Wilson31dfbc92010-09-27 21:28:30 +0100470 drm_vm_close_locked(vma);
Dave Airlie30e2fb12006-02-02 19:37:46 +1100471 mutex_unlock(&dev->struct_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472}
473
474/**
475 * mmap DMA memory.
476 *
Eric Anholt6c340ea2007-08-25 20:23:09 +1000477 * \param file_priv DRM file private.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 * \param vma virtual memory area.
479 * \return zero on success or a negative number on failure.
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000480 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 * Sets the virtual memory area operations structure to vm_dma_ops, the file
482 * pointer, and calls vm_open().
483 */
Dave Airliec94f7022005-07-07 21:03:38 +1000484static int drm_mmap_dma(struct file *filp, struct vm_area_struct *vma)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485{
Dave Airlie84b1fd12007-07-11 15:53:27 +1000486 struct drm_file *priv = filp->private_data;
487 struct drm_device *dev;
Dave Airliecdd55a22007-07-11 16:32:08 +1000488 struct drm_device_dma *dma;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000489 unsigned long length = vma->vm_end - vma->vm_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490
Dave Airlie2c14f282008-04-21 16:47:32 +1000491 dev = priv->minor->dev;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000492 dma = dev->dma;
Thomas Hellstrom15450852007-02-08 16:14:05 +1100493 DRM_DEBUG("start = 0x%lx, end = 0x%lx, page offset = 0x%lx\n",
494 vma->vm_start, vma->vm_end, vma->vm_pgoff);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000496 /* Length must match exact page count */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 if (!dma || (length >> PAGE_SHIFT) != dma->page_count) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 return -EINVAL;
499 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500
George Sapountzis3417f332006-10-24 12:03:04 -0700501 if (!capable(CAP_SYS_ADMIN) &&
502 (dma->flags & _DRM_DMA_USE_PCI_RO)) {
503 vma->vm_flags &= ~(VM_WRITE | VM_MAYWRITE);
504#if defined(__i386__) || defined(__x86_64__)
505 pgprot_val(vma->vm_page_prot) &= ~_PAGE_RW;
506#else
507 /* Ye gads this is ugly. With more thought
508 we could move this up higher and use
509 `protection_map' instead. */
510 vma->vm_page_prot =
511 __pgprot(pte_val
512 (pte_wrprotect
513 (__pte(pgprot_val(vma->vm_page_prot)))));
514#endif
515 }
516
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000517 vma->vm_ops = &drm_vm_dma_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000519 vma->vm_flags |= VM_RESERVED; /* Don't swap */
Nick Piggin2f987352008-02-02 03:08:53 +0100520 vma->vm_flags |= VM_DONTEXPAND;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000522 vma->vm_file = filp; /* Needed for drm_vm_open() */
Thomas Hellstromd7d8aac2007-03-24 17:52:49 +1100523 drm_vm_open_locked(vma);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 return 0;
525}
526
Daniel Vettercbc60ca2010-08-23 22:53:28 +0200527static resource_size_t drm_core_get_reg_ofs(struct drm_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528{
529#ifdef __alpha__
Jay Estabrook82ba3fe2011-06-09 18:18:39 -0400530 return dev->hose->dense_mem_base;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531#else
532 return 0;
533#endif
534}
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000535
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536/**
537 * mmap DMA memory.
538 *
Eric Anholt6c340ea2007-08-25 20:23:09 +1000539 * \param file_priv DRM file private.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 * \param vma virtual memory area.
541 * \return zero on success or a negative number on failure.
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000542 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 * If the virtual memory area has no offset associated with it then it's a DMA
544 * area, so calls mmap_dma(). Otherwise searches the map in drm_device::maplist,
545 * checks that the restricted flag is not set, sets the virtual memory operations
546 * according to the mapping type and remaps the pages. Finally sets the file
547 * pointer and calls vm_open().
548 */
Jesse Barnesa2c0a972008-11-05 10:31:53 -0800549int drm_mmap_locked(struct file *filp, struct vm_area_struct *vma)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550{
Dave Airlie84b1fd12007-07-11 15:53:27 +1000551 struct drm_file *priv = filp->private_data;
Dave Airlie2c14f282008-04-21 16:47:32 +1000552 struct drm_device *dev = priv->minor->dev;
Benjamin Herrenschmidtf77d3902009-02-02 16:55:46 +1100553 struct drm_local_map *map = NULL;
Benjamin Herrenschmidt41c2e752009-02-02 16:55:47 +1100554 resource_size_t offset = 0;
Dave Airliee0be4282007-07-12 10:26:44 +1000555 struct drm_hash_item *hash;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556
Thomas Hellstrom15450852007-02-08 16:14:05 +1100557 DRM_DEBUG("start = 0x%lx, end = 0x%lx, page offset = 0x%lx\n",
558 vma->vm_start, vma->vm_end, vma->vm_pgoff);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000560 if (!priv->authenticated)
561 return -EACCES;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562
563 /* We check for "dma". On Apple's UniNorth, it's valid to have
564 * the AGP mapped at physical address 0
565 * --BenH.
566 */
Thomas Hellstrom15450852007-02-08 16:14:05 +1100567 if (!vma->vm_pgoff
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568#if __OS_HAS_AGP
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000569 && (!dev->agp
570 || dev->agp->agp_info.device->vendor != PCI_VENDOR_ID_APPLE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571#endif
572 )
573 return drm_mmap_dma(filp, vma);
574
Thomas Hellstrom15450852007-02-08 16:14:05 +1100575 if (drm_ht_find_item(&dev->map_hash, vma->vm_pgoff, &hash)) {
Thomas Hellstrom8d153f72006-08-07 22:36:47 +1000576 DRM_ERROR("Could not find map\n");
577 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 }
579
Dave Airlie55910512007-07-11 16:53:40 +1000580 map = drm_hash_entry(hash, struct drm_map_list, hash)->map;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000581 if (!map || ((map->flags & _DRM_RESTRICTED) && !capable(CAP_SYS_ADMIN)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 return -EPERM;
583
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000584 /* Check for valid size. */
Dave Airlie54ba2f72007-02-10 12:07:47 +1100585 if (map->size < vma->vm_end - vma->vm_start)
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000586 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587
588 if (!capable(CAP_SYS_ADMIN) && (map->flags & _DRM_READ_ONLY)) {
589 vma->vm_flags &= ~(VM_WRITE | VM_MAYWRITE);
590#if defined(__i386__) || defined(__x86_64__)
591 pgprot_val(vma->vm_page_prot) &= ~_PAGE_RW;
592#else
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000593 /* Ye gads this is ugly. With more thought
594 we could move this up higher and use
595 `protection_map' instead. */
596 vma->vm_page_prot =
597 __pgprot(pte_val
598 (pte_wrprotect
599 (__pte(pgprot_val(vma->vm_page_prot)))));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600#endif
601 }
602
603 switch (map->type) {
Jordan Crouse4b7fb9b2010-05-27 13:40:26 -0600604#if !defined(__arm__)
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000605 case _DRM_AGP:
606 if (drm_core_has_AGP(dev) && dev->agp->cant_use_aperture) {
607 /*
608 * On some platforms we can't talk to bus dma address from the CPU, so for
609 * memory of type DRM_AGP, we'll deal with sorting out the real physical
Nick Pigginca0b07d2008-02-07 16:20:50 +1000610 * pages and mappings in fault()
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000611 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612#if defined(__powerpc__)
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000613 pgprot_val(vma->vm_page_prot) |= _PAGE_NO_CACHE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614#endif
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000615 vma->vm_ops = &drm_vm_ops;
616 break;
617 }
618 /* fall through to _DRM_FRAME_BUFFER... */
Jordan Crouse4b7fb9b2010-05-27 13:40:26 -0600619#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 case _DRM_FRAME_BUFFER:
621 case _DRM_REGISTERS:
Daniel Vettercbc60ca2010-08-23 22:53:28 +0200622 offset = drm_core_get_reg_ofs(dev);
Dave Airlie5cc7f9a2007-02-10 11:53:13 +1100623 vma->vm_flags |= VM_IO; /* not in core dump */
624 vma->vm_page_prot = drm_io_prot(map->type, vma);
Jordan Crouse4b7fb9b2010-05-27 13:40:26 -0600625#if !defined(__arm__)
Dave Airlie9e9c1322007-03-24 17:57:54 +1100626 if (io_remap_pfn_range(vma, vma->vm_start,
627 (map->offset + offset) >> PAGE_SHIFT,
628 vma->vm_end - vma->vm_start,
629 vma->vm_page_prot))
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000630 return -EAGAIN;
Jordan Crouse4b7fb9b2010-05-27 13:40:26 -0600631#else
632 if (remap_pfn_range(vma, vma->vm_start,
633 (map->offset + offset) >> PAGE_SHIFT,
634 vma->vm_end - vma->vm_start,
635 vma->vm_page_prot))
636 return -EAGAIN;
637#endif
638
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 DRM_DEBUG(" Type = %d; start = 0x%lx, end = 0x%lx,"
Benjamin Herrenschmidt41c2e752009-02-02 16:55:47 +1100640 " offset = 0x%llx\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 map->type,
Benjamin Herrenschmidt41c2e752009-02-02 16:55:47 +1100642 vma->vm_start, vma->vm_end, (unsigned long long)(map->offset + offset));
Jordan Crouse4b7fb9b2010-05-27 13:40:26 -0600643
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644 vma->vm_ops = &drm_vm_ops;
645 break;
Dave Airlie2d0f9ea2005-07-10 14:34:13 +1000646 case _DRM_CONSISTENT:
Hugh Dickins38315872007-03-24 17:55:16 +1100647 /* Consistent memory is really like shared memory. But
Nick Pigginca0b07d2008-02-07 16:20:50 +1000648 * it's allocated in a different way, so avoid fault */
Hugh Dickins38315872007-03-24 17:55:16 +1100649 if (remap_pfn_range(vma, vma->vm_start,
650 page_to_pfn(virt_to_page(map->handle)),
651 vma->vm_end - vma->vm_start, vma->vm_page_prot))
652 return -EAGAIN;
Benjamin Herrenschmidt6876b3b2008-03-28 14:23:07 -0700653 vma->vm_page_prot = drm_dma_prot(map->type, vma);
Hugh Dickins38315872007-03-24 17:55:16 +1100654 /* fall through to _DRM_SHM */
655 case _DRM_SHM:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 vma->vm_ops = &drm_vm_shm_ops;
657 vma->vm_private_data = (void *)map;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000658 /* Don't let this area swap. Change when
659 DRM_KERNEL advisory is supported. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 vma->vm_flags |= VM_RESERVED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 break;
662 case _DRM_SCATTER_GATHER:
663 vma->vm_ops = &drm_vm_sg_ops;
664 vma->vm_private_data = (void *)map;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 vma->vm_flags |= VM_RESERVED;
Benjamin Herrenschmidt5ff64612008-04-20 10:26:25 +1000666 vma->vm_page_prot = drm_dma_prot(map->type, vma);
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000667 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 default:
669 return -EINVAL; /* This should never happen. */
670 }
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000671 vma->vm_flags |= VM_RESERVED; /* Don't swap */
Nick Piggin2f987352008-02-02 03:08:53 +0100672 vma->vm_flags |= VM_DONTEXPAND;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000674 vma->vm_file = filp; /* Needed for drm_vm_open() */
Thomas Hellstromd7d8aac2007-03-24 17:52:49 +1100675 drm_vm_open_locked(vma);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 return 0;
677}
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000678
Thomas Hellstromd7d8aac2007-03-24 17:52:49 +1100679int drm_mmap(struct file *filp, struct vm_area_struct *vma)
680{
Dave Airlie84b1fd12007-07-11 15:53:27 +1000681 struct drm_file *priv = filp->private_data;
Dave Airlie2c14f282008-04-21 16:47:32 +1000682 struct drm_device *dev = priv->minor->dev;
Thomas Hellstromd7d8aac2007-03-24 17:52:49 +1100683 int ret;
684
685 mutex_lock(&dev->struct_mutex);
686 ret = drm_mmap_locked(filp, vma);
687 mutex_unlock(&dev->struct_mutex);
688
689 return ret;
690}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691EXPORT_SYMBOL(drm_mmap);