blob: b5c5af7328df200a2ff119bafeb92664bb1738cb [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
David Howells760285e2012-10-02 18:01:07 +010036#include <drm/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
Andy Lutomirskiff47eaf2013-05-13 23:58:42 +000046static pgprot_t drm_io_prot(struct drm_local_map *map,
47 struct vm_area_struct *vma)
Dave Airlie5cc7f9a2007-02-10 11:53:13 +110048{
49 pgprot_t tmp = vm_get_page_prot(vma->vm_flags);
50
51#if defined(__i386__) || defined(__x86_64__)
Andy Lutomirskif4350462013-05-13 23:58:43 +000052 if (map->type == _DRM_REGISTERS && !(map->flags & _DRM_WRITE_COMBINING))
53 tmp = pgprot_noncached(tmp);
54 else
55 tmp = pgprot_writecombine(tmp);
Dave Airlie5cc7f9a2007-02-10 11:53:13 +110056#elif defined(__powerpc__)
57 pgprot_val(tmp) |= _PAGE_NO_CACHE;
Andy Lutomirskiff47eaf2013-05-13 23:58:42 +000058 if (map->type == _DRM_REGISTERS)
Dave Airlie5cc7f9a2007-02-10 11:53:13 +110059 pgprot_val(tmp) |= _PAGE_GUARDED;
Benjamin Herrenschmidt6876b3b2008-03-28 14:23:07 -070060#elif defined(__ia64__)
Dave Airlie5cc7f9a2007-02-10 11:53:13 +110061 if (efi_range_is_wc(vma->vm_start, vma->vm_end -
62 vma->vm_start))
63 tmp = pgprot_writecombine(tmp);
64 else
65 tmp = pgprot_noncached(tmp);
Huacai Chen04cf55e2012-08-11 09:32:17 +000066#elif defined(__sparc__) || defined(__arm__) || defined(__mips__)
Benjamin Herrenschmidt6876b3b2008-03-28 14:23:07 -070067 tmp = pgprot_noncached(tmp);
68#endif
69 return tmp;
70}
71
72static pgprot_t drm_dma_prot(uint32_t map_type, struct vm_area_struct *vma)
73{
74 pgprot_t tmp = vm_get_page_prot(vma->vm_flags);
75
76#if defined(__powerpc__) && defined(CONFIG_NOT_COHERENT_CACHE)
77 tmp |= _PAGE_NO_CACHE;
Dave Airlie5cc7f9a2007-02-10 11:53:13 +110078#endif
79 return tmp;
80}
81
Linus Torvalds1da177e2005-04-16 15:20:36 -070082/**
Nick Pigginca0b07d2008-02-07 16:20:50 +100083 * \c fault method for AGP virtual memory.
Linus Torvalds1da177e2005-04-16 15:20:36 -070084 *
85 * \param vma virtual memory area.
86 * \param address access address.
87 * \return pointer to the page structure.
Dave Airlieb5e89ed2005-09-25 14:28:13 +100088 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070089 * Find the right map and if it's AGP memory find the real physical page to
90 * map, get the page, increment the use count and return it.
91 */
92#if __OS_HAS_AGP
Nick Pigginca0b07d2008-02-07 16:20:50 +100093static int drm_do_vm_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
Linus Torvalds1da177e2005-04-16 15:20:36 -070094{
Dave Airlie84b1fd12007-07-11 15:53:27 +100095 struct drm_file *priv = vma->vm_file->private_data;
Dave Airlie2c14f282008-04-21 16:47:32 +100096 struct drm_device *dev = priv->minor->dev;
Benjamin Herrenschmidtf77d3902009-02-02 16:55:46 +110097 struct drm_local_map *map = NULL;
Dave Airlie55910512007-07-11 16:53:40 +100098 struct drm_map_list *r_list;
Dave Airliee0be4282007-07-12 10:26:44 +100099 struct drm_hash_item *hash;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100
101 /*
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000102 * Find the right map
103 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 if (!drm_core_has_AGP(dev))
Nick Pigginca0b07d2008-02-07 16:20:50 +1000105 goto vm_fault_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000107 if (!dev->agp || !dev->agp->cant_use_aperture)
Nick Pigginca0b07d2008-02-07 16:20:50 +1000108 goto vm_fault_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109
Thomas Hellstrom15450852007-02-08 16:14:05 +1100110 if (drm_ht_find_item(&dev->map_hash, vma->vm_pgoff, &hash))
Nick Pigginca0b07d2008-02-07 16:20:50 +1000111 goto vm_fault_error;
Thomas Hellstrom8d153f72006-08-07 22:36:47 +1000112
Dave Airlie55910512007-07-11 16:53:40 +1000113 r_list = drm_hash_entry(hash, struct drm_map_list, hash);
Thomas Hellstrom8d153f72006-08-07 22:36:47 +1000114 map = r_list->map;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115
116 if (map && map->type == _DRM_AGP) {
Nick Pigginca0b07d2008-02-07 16:20:50 +1000117 /*
118 * Using vm_pgoff as a selector forces us to use this unusual
119 * addressing scheme.
120 */
Benjamin Herrenschmidt41c2e752009-02-02 16:55:47 +1100121 resource_size_t offset = (unsigned long)vmf->virtual_address -
122 vma->vm_start;
123 resource_size_t baddr = map->offset + offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 struct drm_agp_mem *agpmem;
125 struct page *page;
126
127#ifdef __alpha__
128 /*
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000129 * Adjust to a bus-relative address
130 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131 baddr -= dev->hose->mem_space->start;
132#endif
133
134 /*
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000135 * It's AGP memory - find the real physical page to map
136 */
Dave Airliebd1b3312007-05-26 05:01:51 +1000137 list_for_each_entry(agpmem, &dev->agp->memory, head) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 if (agpmem->bound <= baddr &&
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000139 agpmem->bound + agpmem->pages * PAGE_SIZE > baddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 break;
141 }
142
Dan Carpenter161c4812010-08-19 11:39:57 +0200143 if (&agpmem->head == &dev->agp->memory)
Nick Pigginca0b07d2008-02-07 16:20:50 +1000144 goto vm_fault_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145
146 /*
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000147 * Get the page, inc the use count, and return it
148 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 offset = (baddr - agpmem->bound) >> PAGE_SHIFT;
Dave Airlie07613ba2009-06-12 14:11:41 +1000150 page = agpmem->memory->pages[offset];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151 get_page(page);
Nick Pigginca0b07d2008-02-07 16:20:50 +1000152 vmf->page = page;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000154 DRM_DEBUG
Benjamin Herrenschmidt41c2e752009-02-02 16:55:47 +1100155 ("baddr = 0x%llx page = 0x%p, offset = 0x%llx, count=%d\n",
156 (unsigned long long)baddr,
Dave Airlie07613ba2009-06-12 14:11:41 +1000157 agpmem->memory->pages[offset],
Benjamin Herrenschmidt41c2e752009-02-02 16:55:47 +1100158 (unsigned long long)offset,
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000159 page_count(page));
Nick Pigginca0b07d2008-02-07 16:20:50 +1000160 return 0;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000161 }
Nick Pigginca0b07d2008-02-07 16:20:50 +1000162vm_fault_error:
163 return VM_FAULT_SIGBUS; /* Disallow mremap */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164}
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000165#else /* __OS_HAS_AGP */
Nick Pigginca0b07d2008-02-07 16:20:50 +1000166static int drm_do_vm_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167{
Nick Pigginca0b07d2008-02-07 16:20:50 +1000168 return VM_FAULT_SIGBUS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169}
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000170#endif /* __OS_HAS_AGP */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171
172/**
173 * \c nopage method for shared virtual memory.
174 *
175 * \param vma virtual memory area.
176 * \param address access address.
177 * \return pointer to the page structure.
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000178 *
Michael Opdenacker59c51592007-05-09 08:57:56 +0200179 * Get the mapping, find the real physical page to map, get the page, and
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 * return it.
181 */
Nick Pigginca0b07d2008-02-07 16:20:50 +1000182static int drm_do_vm_shm_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183{
Benjamin Herrenschmidtf77d3902009-02-02 16:55:46 +1100184 struct drm_local_map *map = vma->vm_private_data;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000185 unsigned long offset;
186 unsigned long i;
187 struct page *page;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000189 if (!map)
Nick Pigginca0b07d2008-02-07 16:20:50 +1000190 return VM_FAULT_SIGBUS; /* Nothing allocated */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191
Nick Pigginca0b07d2008-02-07 16:20:50 +1000192 offset = (unsigned long)vmf->virtual_address - vma->vm_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 i = (unsigned long)map->handle + offset;
Hugh Dickins38315872007-03-24 17:55:16 +1100194 page = vmalloc_to_page((void *)i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 if (!page)
Nick Pigginca0b07d2008-02-07 16:20:50 +1000196 return VM_FAULT_SIGBUS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 get_page(page);
Nick Pigginca0b07d2008-02-07 16:20:50 +1000198 vmf->page = page;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199
Nick Pigginca0b07d2008-02-07 16:20:50 +1000200 DRM_DEBUG("shm_fault 0x%lx\n", offset);
201 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202}
203
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204/**
205 * \c close method for shared virtual memory.
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000206 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 * \param vma virtual memory area.
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000208 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 * Deletes map information if we are the last
210 * person to close a mapping and it's not in the global maplist.
211 */
Dave Airliec94f7022005-07-07 21:03:38 +1000212static void drm_vm_shm_close(struct vm_area_struct *vma)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213{
Dave Airlie84b1fd12007-07-11 15:53:27 +1000214 struct drm_file *priv = vma->vm_file->private_data;
Dave Airlie2c14f282008-04-21 16:47:32 +1000215 struct drm_device *dev = priv->minor->dev;
Dave Airlie8fc2fdf2007-07-11 16:21:47 +1000216 struct drm_vma_entry *pt, *temp;
Benjamin Herrenschmidtf77d3902009-02-02 16:55:46 +1100217 struct drm_local_map *map;
Dave Airlie55910512007-07-11 16:53:40 +1000218 struct drm_map_list *r_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219 int found_maps = 0;
220
221 DRM_DEBUG("0x%08lx,0x%08lx\n",
222 vma->vm_start, vma->vm_end - vma->vm_start);
223 atomic_dec(&dev->vma_count);
224
225 map = vma->vm_private_data;
226
Dave Airlie30e2fb12006-02-02 19:37:46 +1100227 mutex_lock(&dev->struct_mutex);
Dave Airliebd1b3312007-05-26 05:01:51 +1000228 list_for_each_entry_safe(pt, temp, &dev->vmalist, head) {
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000229 if (pt->vma->vm_private_data == map)
230 found_maps++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 if (pt->vma == vma) {
Dave Airliebd1b3312007-05-26 05:01:51 +1000232 list_del(&pt->head);
Eric Anholt9a298b22009-03-24 12:23:04 -0700233 kfree(pt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 }
235 }
Dave Airliebd1b3312007-05-26 05:01:51 +1000236
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 /* We were the only map that was found */
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000238 if (found_maps == 1 && map->flags & _DRM_REMOVABLE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 /* Check to see if we are in the maplist, if we are not, then
240 * we delete this mappings information.
241 */
242 found_maps = 0;
Dave Airliebd1b3312007-05-26 05:01:51 +1000243 list_for_each_entry(r_list, &dev->maplist, head) {
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000244 if (r_list->map == map)
245 found_maps++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 }
247
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000248 if (!found_maps) {
Dave Airlie9c8da5e2005-07-10 15:38:56 +1000249 drm_dma_handle_t dmah;
250
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 switch (map->type) {
252 case _DRM_REGISTERS:
253 case _DRM_FRAME_BUFFER:
Daniel Vetter28185642013-08-08 15:41:27 +0200254 arch_phys_wc_del(map->mtrr);
Christoph Hellwig004a7722007-01-08 21:56:59 +1100255 iounmap(map->handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 break;
257 case _DRM_SHM:
258 vfree(map->handle);
259 break;
260 case _DRM_AGP:
261 case _DRM_SCATTER_GATHER:
262 break;
Dave Airlie2d0f9ea2005-07-10 14:34:13 +1000263 case _DRM_CONSISTENT:
Dave Airlie9c8da5e2005-07-10 15:38:56 +1000264 dmah.vaddr = map->handle;
265 dmah.busaddr = map->offset;
266 dmah.size = map->size;
267 __drm_pci_free(dev, &dmah);
Dave Airlie2d0f9ea2005-07-10 14:34:13 +1000268 break;
Jesse Barnesa2c0a972008-11-05 10:31:53 -0800269 case _DRM_GEM:
270 DRM_ERROR("tried to rmmap GEM object\n");
271 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 }
Eric Anholt9a298b22009-03-24 12:23:04 -0700273 kfree(map);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 }
275 }
Dave Airlie30e2fb12006-02-02 19:37:46 +1100276 mutex_unlock(&dev->struct_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277}
278
279/**
Nick Pigginca0b07d2008-02-07 16:20:50 +1000280 * \c fault method for DMA virtual memory.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 *
282 * \param vma virtual memory area.
283 * \param address access address.
284 * \return pointer to the page structure.
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000285 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 * Determine the page number from the page offset and get it from drm_device_dma::pagelist.
287 */
Nick Pigginca0b07d2008-02-07 16:20:50 +1000288static int drm_do_vm_dma_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289{
Dave Airlie84b1fd12007-07-11 15:53:27 +1000290 struct drm_file *priv = vma->vm_file->private_data;
Dave Airlie2c14f282008-04-21 16:47:32 +1000291 struct drm_device *dev = priv->minor->dev;
Dave Airliecdd55a22007-07-11 16:32:08 +1000292 struct drm_device_dma *dma = dev->dma;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000293 unsigned long offset;
294 unsigned long page_nr;
295 struct page *page;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000297 if (!dma)
Nick Pigginca0b07d2008-02-07 16:20:50 +1000298 return VM_FAULT_SIGBUS; /* Error */
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000299 if (!dma->pagelist)
Nick Pigginca0b07d2008-02-07 16:20:50 +1000300 return VM_FAULT_SIGBUS; /* Nothing allocated */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301
Nick Pigginca0b07d2008-02-07 16:20:50 +1000302 offset = (unsigned long)vmf->virtual_address - vma->vm_start; /* vm_[pg]off[set] should be 0 */
303 page_nr = offset >> PAGE_SHIFT; /* page_nr could just be vmf->pgoff */
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000304 page = virt_to_page((dma->pagelist[page_nr] + (offset & (~PAGE_MASK))));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305
306 get_page(page);
Nick Pigginca0b07d2008-02-07 16:20:50 +1000307 vmf->page = page;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308
Nick Pigginca0b07d2008-02-07 16:20:50 +1000309 DRM_DEBUG("dma_fault 0x%lx (page %lu)\n", offset, page_nr);
310 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311}
312
313/**
Nick Pigginca0b07d2008-02-07 16:20:50 +1000314 * \c fault method for scatter-gather virtual memory.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 *
316 * \param vma virtual memory area.
317 * \param address access address.
318 * \return pointer to the page structure.
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000319 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 * Determine the map offset from the page offset and get it from drm_sg_mem::pagelist.
321 */
Nick Pigginca0b07d2008-02-07 16:20:50 +1000322static int drm_do_vm_sg_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323{
Benjamin Herrenschmidtf77d3902009-02-02 16:55:46 +1100324 struct drm_local_map *map = vma->vm_private_data;
Dave Airlie84b1fd12007-07-11 15:53:27 +1000325 struct drm_file *priv = vma->vm_file->private_data;
Dave Airlie2c14f282008-04-21 16:47:32 +1000326 struct drm_device *dev = priv->minor->dev;
Dave Airlie55910512007-07-11 16:53:40 +1000327 struct drm_sg_mem *entry = dev->sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 unsigned long offset;
329 unsigned long map_offset;
330 unsigned long page_offset;
331 struct page *page;
332
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000333 if (!entry)
Nick Pigginca0b07d2008-02-07 16:20:50 +1000334 return VM_FAULT_SIGBUS; /* Error */
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000335 if (!entry->pagelist)
Nick Pigginca0b07d2008-02-07 16:20:50 +1000336 return VM_FAULT_SIGBUS; /* Nothing allocated */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337
Nick Pigginca0b07d2008-02-07 16:20:50 +1000338 offset = (unsigned long)vmf->virtual_address - vma->vm_start;
Dave Airlied1f2b552005-08-05 22:11:22 +1000339 map_offset = map->offset - (unsigned long)dev->sg->virtual;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 page_offset = (offset >> PAGE_SHIFT) + (map_offset >> PAGE_SHIFT);
341 page = entry->pagelist[page_offset];
342 get_page(page);
Nick Pigginca0b07d2008-02-07 16:20:50 +1000343 vmf->page = page;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344
Nick Pigginca0b07d2008-02-07 16:20:50 +1000345 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346}
347
Nick Pigginca0b07d2008-02-07 16:20:50 +1000348static int drm_vm_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000349{
Nick Pigginca0b07d2008-02-07 16:20:50 +1000350 return drm_do_vm_fault(vma, vmf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351}
352
Nick Pigginca0b07d2008-02-07 16:20:50 +1000353static int drm_vm_shm_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_shm_fault(vma, vmf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356}
357
Nick Pigginca0b07d2008-02-07 16:20:50 +1000358static int drm_vm_dma_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_dma_fault(vma, vmf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361}
362
Nick Pigginca0b07d2008-02-07 16:20:50 +1000363static int drm_vm_sg_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_sg_fault(vma, vmf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366}
367
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368/** AGP virtual memory operations */
Alexey Dobriyanf0f37e22009-09-27 22:29:37 +0400369static const struct vm_operations_struct drm_vm_ops = {
Nick Pigginca0b07d2008-02-07 16:20:50 +1000370 .fault = drm_vm_fault,
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000371 .open = drm_vm_open,
372 .close = drm_vm_close,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373};
374
375/** Shared virtual memory operations */
Alexey Dobriyanf0f37e22009-09-27 22:29:37 +0400376static const struct vm_operations_struct drm_vm_shm_ops = {
Nick Pigginca0b07d2008-02-07 16:20:50 +1000377 .fault = drm_vm_shm_fault,
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000378 .open = drm_vm_open,
379 .close = drm_vm_shm_close,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380};
381
382/** DMA virtual memory operations */
Alexey Dobriyanf0f37e22009-09-27 22:29:37 +0400383static const struct vm_operations_struct drm_vm_dma_ops = {
Nick Pigginca0b07d2008-02-07 16:20:50 +1000384 .fault = drm_vm_dma_fault,
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000385 .open = drm_vm_open,
386 .close = drm_vm_close,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387};
388
389/** Scatter-gather virtual memory operations */
Alexey Dobriyanf0f37e22009-09-27 22:29:37 +0400390static const struct vm_operations_struct drm_vm_sg_ops = {
Nick Pigginca0b07d2008-02-07 16:20:50 +1000391 .fault = drm_vm_sg_fault,
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000392 .open = drm_vm_open,
393 .close = drm_vm_close,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394};
395
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396/**
397 * \c open method for shared virtual memory.
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000398 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 * \param vma virtual memory area.
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000400 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 * Create a new drm_vma_entry structure as the \p vma private data entry and
402 * add it to drm_device::vmalist.
403 */
Rob Clarkb06d66b2012-05-01 11:04:51 -0500404void drm_vm_open_locked(struct drm_device *dev,
405 struct vm_area_struct *vma)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406{
Dave Airlie8fc2fdf2007-07-11 16:21:47 +1000407 struct drm_vma_entry *vma_entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408
409 DRM_DEBUG("0x%08lx,0x%08lx\n",
410 vma->vm_start, vma->vm_end - vma->vm_start);
411 atomic_inc(&dev->vma_count);
412
Eric Anholt9a298b22009-03-24 12:23:04 -0700413 vma_entry = kmalloc(sizeof(*vma_entry), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 if (vma_entry) {
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000415 vma_entry->vma = vma;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000416 vma_entry->pid = current->pid;
Dave Airliebd1b3312007-05-26 05:01:51 +1000417 list_add(&vma_entry->head, &dev->vmalist);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 }
419}
Arnd Bergmannd5028992013-04-25 19:28:52 +0200420EXPORT_SYMBOL_GPL(drm_vm_open_locked);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421
Thomas Hellstromd7d8aac2007-03-24 17:52:49 +1100422static void drm_vm_open(struct vm_area_struct *vma)
423{
Dave Airlie84b1fd12007-07-11 15:53:27 +1000424 struct drm_file *priv = vma->vm_file->private_data;
Dave Airlie2c14f282008-04-21 16:47:32 +1000425 struct drm_device *dev = priv->minor->dev;
Thomas Hellstromd7d8aac2007-03-24 17:52:49 +1100426
427 mutex_lock(&dev->struct_mutex);
Rob Clarkb06d66b2012-05-01 11:04:51 -0500428 drm_vm_open_locked(dev, vma);
Thomas Hellstromd7d8aac2007-03-24 17:52:49 +1100429 mutex_unlock(&dev->struct_mutex);
430}
431
Rob Clarkb06d66b2012-05-01 11:04:51 -0500432void drm_vm_close_locked(struct drm_device *dev,
433 struct vm_area_struct *vma)
Chris Wilson31dfbc92010-09-27 21:28:30 +0100434{
Chris Wilson31dfbc92010-09-27 21:28:30 +0100435 struct drm_vma_entry *pt, *temp;
436
437 DRM_DEBUG("0x%08lx,0x%08lx\n",
438 vma->vm_start, vma->vm_end - vma->vm_start);
439 atomic_dec(&dev->vma_count);
440
441 list_for_each_entry_safe(pt, temp, &dev->vmalist, head) {
442 if (pt->vma == vma) {
443 list_del(&pt->head);
444 kfree(pt);
445 break;
446 }
447 }
448}
449
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450/**
451 * \c close method for all virtual memory types.
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000452 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 * \param vma virtual memory area.
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000454 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 * Search the \p vma private data entry in drm_device::vmalist, unlink it, and
456 * free it.
457 */
Dave Airliec94f7022005-07-07 21:03:38 +1000458static void drm_vm_close(struct vm_area_struct *vma)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459{
Dave Airlie84b1fd12007-07-11 15:53:27 +1000460 struct drm_file *priv = vma->vm_file->private_data;
Dave Airlie2c14f282008-04-21 16:47:32 +1000461 struct drm_device *dev = priv->minor->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462
Dave Airlie30e2fb12006-02-02 19:37:46 +1100463 mutex_lock(&dev->struct_mutex);
Rob Clarkb06d66b2012-05-01 11:04:51 -0500464 drm_vm_close_locked(dev, vma);
Dave Airlie30e2fb12006-02-02 19:37:46 +1100465 mutex_unlock(&dev->struct_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466}
467
468/**
469 * mmap DMA memory.
470 *
Eric Anholt6c340ea2007-08-25 20:23:09 +1000471 * \param file_priv DRM file private.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 * \param vma virtual memory area.
473 * \return zero on success or a negative number on failure.
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000474 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 * Sets the virtual memory area operations structure to vm_dma_ops, the file
476 * pointer, and calls vm_open().
477 */
Dave Airliec94f7022005-07-07 21:03:38 +1000478static int drm_mmap_dma(struct file *filp, struct vm_area_struct *vma)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479{
Dave Airlie84b1fd12007-07-11 15:53:27 +1000480 struct drm_file *priv = filp->private_data;
481 struct drm_device *dev;
Dave Airliecdd55a22007-07-11 16:32:08 +1000482 struct drm_device_dma *dma;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000483 unsigned long length = vma->vm_end - vma->vm_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484
Dave Airlie2c14f282008-04-21 16:47:32 +1000485 dev = priv->minor->dev;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000486 dma = dev->dma;
Thomas Hellstrom15450852007-02-08 16:14:05 +1100487 DRM_DEBUG("start = 0x%lx, end = 0x%lx, page offset = 0x%lx\n",
488 vma->vm_start, vma->vm_end, vma->vm_pgoff);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000490 /* Length must match exact page count */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491 if (!dma || (length >> PAGE_SHIFT) != dma->page_count) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 return -EINVAL;
493 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494
George Sapountzis3417f332006-10-24 12:03:04 -0700495 if (!capable(CAP_SYS_ADMIN) &&
496 (dma->flags & _DRM_DMA_USE_PCI_RO)) {
497 vma->vm_flags &= ~(VM_WRITE | VM_MAYWRITE);
498#if defined(__i386__) || defined(__x86_64__)
499 pgprot_val(vma->vm_page_prot) &= ~_PAGE_RW;
500#else
501 /* Ye gads this is ugly. With more thought
502 we could move this up higher and use
503 `protection_map' instead. */
504 vma->vm_page_prot =
505 __pgprot(pte_val
506 (pte_wrprotect
507 (__pte(pgprot_val(vma->vm_page_prot)))));
508#endif
509 }
510
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000511 vma->vm_ops = &drm_vm_dma_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512
Konstantin Khlebnikov314e51b2012-10-08 16:29:02 -0700513 vma->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514
Rob Clarkb06d66b2012-05-01 11:04:51 -0500515 drm_vm_open_locked(dev, vma);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 return 0;
517}
518
Daniel Vettercbc60ca2010-08-23 22:53:28 +0200519static resource_size_t drm_core_get_reg_ofs(struct drm_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520{
521#ifdef __alpha__
Jay Estabrook82ba3fe2011-06-09 18:18:39 -0400522 return dev->hose->dense_mem_base;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523#else
524 return 0;
525#endif
526}
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000527
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528/**
529 * mmap DMA memory.
530 *
Eric Anholt6c340ea2007-08-25 20:23:09 +1000531 * \param file_priv DRM file private.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532 * \param vma virtual memory area.
533 * \return zero on success or a negative number on failure.
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000534 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 * If the virtual memory area has no offset associated with it then it's a DMA
536 * area, so calls mmap_dma(). Otherwise searches the map in drm_device::maplist,
537 * checks that the restricted flag is not set, sets the virtual memory operations
538 * according to the mapping type and remaps the pages. Finally sets the file
539 * pointer and calls vm_open().
540 */
Jesse Barnesa2c0a972008-11-05 10:31:53 -0800541int drm_mmap_locked(struct file *filp, struct vm_area_struct *vma)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542{
Dave Airlie84b1fd12007-07-11 15:53:27 +1000543 struct drm_file *priv = filp->private_data;
Dave Airlie2c14f282008-04-21 16:47:32 +1000544 struct drm_device *dev = priv->minor->dev;
Benjamin Herrenschmidtf77d3902009-02-02 16:55:46 +1100545 struct drm_local_map *map = NULL;
Benjamin Herrenschmidt41c2e752009-02-02 16:55:47 +1100546 resource_size_t offset = 0;
Dave Airliee0be4282007-07-12 10:26:44 +1000547 struct drm_hash_item *hash;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548
Thomas Hellstrom15450852007-02-08 16:14:05 +1100549 DRM_DEBUG("start = 0x%lx, end = 0x%lx, page offset = 0x%lx\n",
550 vma->vm_start, vma->vm_end, vma->vm_pgoff);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000552 if (!priv->authenticated)
553 return -EACCES;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554
555 /* We check for "dma". On Apple's UniNorth, it's valid to have
556 * the AGP mapped at physical address 0
557 * --BenH.
558 */
Thomas Hellstrom15450852007-02-08 16:14:05 +1100559 if (!vma->vm_pgoff
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560#if __OS_HAS_AGP
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000561 && (!dev->agp
562 || dev->agp->agp_info.device->vendor != PCI_VENDOR_ID_APPLE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563#endif
564 )
565 return drm_mmap_dma(filp, vma);
566
Thomas Hellstrom15450852007-02-08 16:14:05 +1100567 if (drm_ht_find_item(&dev->map_hash, vma->vm_pgoff, &hash)) {
Thomas Hellstrom8d153f72006-08-07 22:36:47 +1000568 DRM_ERROR("Could not find map\n");
569 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 }
571
Dave Airlie55910512007-07-11 16:53:40 +1000572 map = drm_hash_entry(hash, struct drm_map_list, hash)->map;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000573 if (!map || ((map->flags & _DRM_RESTRICTED) && !capable(CAP_SYS_ADMIN)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 return -EPERM;
575
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000576 /* Check for valid size. */
Dave Airlie54ba2f72007-02-10 12:07:47 +1100577 if (map->size < vma->vm_end - vma->vm_start)
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000578 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579
580 if (!capable(CAP_SYS_ADMIN) && (map->flags & _DRM_READ_ONLY)) {
581 vma->vm_flags &= ~(VM_WRITE | VM_MAYWRITE);
582#if defined(__i386__) || defined(__x86_64__)
583 pgprot_val(vma->vm_page_prot) &= ~_PAGE_RW;
584#else
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000585 /* Ye gads this is ugly. With more thought
586 we could move this up higher and use
587 `protection_map' instead. */
588 vma->vm_page_prot =
589 __pgprot(pte_val
590 (pte_wrprotect
591 (__pte(pgprot_val(vma->vm_page_prot)))));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592#endif
593 }
594
595 switch (map->type) {
Jordan Crouse4b7fb9b2010-05-27 13:40:26 -0600596#if !defined(__arm__)
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000597 case _DRM_AGP:
598 if (drm_core_has_AGP(dev) && dev->agp->cant_use_aperture) {
599 /*
600 * On some platforms we can't talk to bus dma address from the CPU, so for
601 * memory of type DRM_AGP, we'll deal with sorting out the real physical
Nick Pigginca0b07d2008-02-07 16:20:50 +1000602 * pages and mappings in fault()
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000603 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604#if defined(__powerpc__)
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000605 pgprot_val(vma->vm_page_prot) |= _PAGE_NO_CACHE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606#endif
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000607 vma->vm_ops = &drm_vm_ops;
608 break;
609 }
610 /* fall through to _DRM_FRAME_BUFFER... */
Jordan Crouse4b7fb9b2010-05-27 13:40:26 -0600611#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 case _DRM_FRAME_BUFFER:
613 case _DRM_REGISTERS:
Daniel Vettercbc60ca2010-08-23 22:53:28 +0200614 offset = drm_core_get_reg_ofs(dev);
Andy Lutomirskiff47eaf2013-05-13 23:58:42 +0000615 vma->vm_page_prot = drm_io_prot(map, vma);
Dave Airlie9e9c1322007-03-24 17:57:54 +1100616 if (io_remap_pfn_range(vma, vma->vm_start,
617 (map->offset + offset) >> PAGE_SHIFT,
618 vma->vm_end - vma->vm_start,
619 vma->vm_page_prot))
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000620 return -EAGAIN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 DRM_DEBUG(" Type = %d; start = 0x%lx, end = 0x%lx,"
Benjamin Herrenschmidt41c2e752009-02-02 16:55:47 +1100622 " offset = 0x%llx\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 map->type,
Benjamin Herrenschmidt41c2e752009-02-02 16:55:47 +1100624 vma->vm_start, vma->vm_end, (unsigned long long)(map->offset + offset));
Jordan Crouse4b7fb9b2010-05-27 13:40:26 -0600625
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 vma->vm_ops = &drm_vm_ops;
627 break;
Dave Airlie2d0f9ea2005-07-10 14:34:13 +1000628 case _DRM_CONSISTENT:
Hugh Dickins38315872007-03-24 17:55:16 +1100629 /* Consistent memory is really like shared memory. But
Nick Pigginca0b07d2008-02-07 16:20:50 +1000630 * it's allocated in a different way, so avoid fault */
Hugh Dickins38315872007-03-24 17:55:16 +1100631 if (remap_pfn_range(vma, vma->vm_start,
632 page_to_pfn(virt_to_page(map->handle)),
633 vma->vm_end - vma->vm_start, vma->vm_page_prot))
634 return -EAGAIN;
Benjamin Herrenschmidt6876b3b2008-03-28 14:23:07 -0700635 vma->vm_page_prot = drm_dma_prot(map->type, vma);
Hugh Dickins38315872007-03-24 17:55:16 +1100636 /* fall through to _DRM_SHM */
637 case _DRM_SHM:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 vma->vm_ops = &drm_vm_shm_ops;
639 vma->vm_private_data = (void *)map;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 break;
641 case _DRM_SCATTER_GATHER:
642 vma->vm_ops = &drm_vm_sg_ops;
643 vma->vm_private_data = (void *)map;
Benjamin Herrenschmidt5ff64612008-04-20 10:26:25 +1000644 vma->vm_page_prot = drm_dma_prot(map->type, vma);
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000645 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646 default:
647 return -EINVAL; /* This should never happen. */
648 }
Konstantin Khlebnikov314e51b2012-10-08 16:29:02 -0700649 vma->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650
Rob Clarkb06d66b2012-05-01 11:04:51 -0500651 drm_vm_open_locked(dev, vma);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652 return 0;
653}
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000654
Thomas Hellstromd7d8aac2007-03-24 17:52:49 +1100655int drm_mmap(struct file *filp, struct vm_area_struct *vma)
656{
Dave Airlie84b1fd12007-07-11 15:53:27 +1000657 struct drm_file *priv = filp->private_data;
Dave Airlie2c14f282008-04-21 16:47:32 +1000658 struct drm_device *dev = priv->minor->dev;
Thomas Hellstromd7d8aac2007-03-24 17:52:49 +1100659 int ret;
660
Dave Airlie2c07a212012-02-20 14:18:07 +0000661 if (drm_device_is_unplugged(dev))
662 return -ENODEV;
663
Thomas Hellstromd7d8aac2007-03-24 17:52:49 +1100664 mutex_lock(&dev->struct_mutex);
665 ret = drm_mmap_locked(filp, vma);
666 mutex_unlock(&dev->struct_mutex);
667
668 return ret;
669}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670EXPORT_SYMBOL(drm_mmap);