drm_vm.c revision 281856477cdaba70032af502ee7192fe7aa54f69
1/** 2 * \file drm_vm.c 3 * Memory mapping for DRM 4 * 5 * \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 <drm/drmP.h> 37#include <linux/export.h> 38#if defined(__ia64__) 39#include <linux/efi.h> 40#include <linux/slab.h> 41#endif 42 43static void drm_vm_open(struct vm_area_struct *vma); 44static void drm_vm_close(struct vm_area_struct *vma); 45 46static pgprot_t drm_io_prot(struct drm_local_map *map, 47 struct vm_area_struct *vma) 48{ 49 pgprot_t tmp = vm_get_page_prot(vma->vm_flags); 50 51#if defined(__i386__) || defined(__x86_64__) 52 if (map->type == _DRM_REGISTERS && !(map->flags & _DRM_WRITE_COMBINING)) 53 tmp = pgprot_noncached(tmp); 54 else 55 tmp = pgprot_writecombine(tmp); 56#elif defined(__powerpc__) 57 pgprot_val(tmp) |= _PAGE_NO_CACHE; 58 if (map->type == _DRM_REGISTERS) 59 pgprot_val(tmp) |= _PAGE_GUARDED; 60#elif defined(__ia64__) 61 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); 66#elif defined(__sparc__) || defined(__arm__) || defined(__mips__) 67 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; 78#endif 79 return tmp; 80} 81 82/** 83 * \c fault method for AGP virtual memory. 84 * 85 * \param vma virtual memory area. 86 * \param address access address. 87 * \return pointer to the page structure. 88 * 89 * 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 93static int drm_do_vm_fault(struct vm_area_struct *vma, struct vm_fault *vmf) 94{ 95 struct drm_file *priv = vma->vm_file->private_data; 96 struct drm_device *dev = priv->minor->dev; 97 struct drm_local_map *map = NULL; 98 struct drm_map_list *r_list; 99 struct drm_hash_item *hash; 100 101 /* 102 * Find the right map 103 */ 104 if (!drm_core_has_AGP(dev)) 105 goto vm_fault_error; 106 107 if (!dev->agp || !dev->agp->cant_use_aperture) 108 goto vm_fault_error; 109 110 if (drm_ht_find_item(&dev->map_hash, vma->vm_pgoff, &hash)) 111 goto vm_fault_error; 112 113 r_list = drm_hash_entry(hash, struct drm_map_list, hash); 114 map = r_list->map; 115 116 if (map && map->type == _DRM_AGP) { 117 /* 118 * Using vm_pgoff as a selector forces us to use this unusual 119 * addressing scheme. 120 */ 121 resource_size_t offset = (unsigned long)vmf->virtual_address - 122 vma->vm_start; 123 resource_size_t baddr = map->offset + offset; 124 struct drm_agp_mem *agpmem; 125 struct page *page; 126 127#ifdef __alpha__ 128 /* 129 * Adjust to a bus-relative address 130 */ 131 baddr -= dev->hose->mem_space->start; 132#endif 133 134 /* 135 * It's AGP memory - find the real physical page to map 136 */ 137 list_for_each_entry(agpmem, &dev->agp->memory, head) { 138 if (agpmem->bound <= baddr && 139 agpmem->bound + agpmem->pages * PAGE_SIZE > baddr) 140 break; 141 } 142 143 if (&agpmem->head == &dev->agp->memory) 144 goto vm_fault_error; 145 146 /* 147 * Get the page, inc the use count, and return it 148 */ 149 offset = (baddr - agpmem->bound) >> PAGE_SHIFT; 150 page = agpmem->memory->pages[offset]; 151 get_page(page); 152 vmf->page = page; 153 154 DRM_DEBUG 155 ("baddr = 0x%llx page = 0x%p, offset = 0x%llx, count=%d\n", 156 (unsigned long long)baddr, 157 agpmem->memory->pages[offset], 158 (unsigned long long)offset, 159 page_count(page)); 160 return 0; 161 } 162vm_fault_error: 163 return VM_FAULT_SIGBUS; /* Disallow mremap */ 164} 165#else /* __OS_HAS_AGP */ 166static int drm_do_vm_fault(struct vm_area_struct *vma, struct vm_fault *vmf) 167{ 168 return VM_FAULT_SIGBUS; 169} 170#endif /* __OS_HAS_AGP */ 171 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. 178 * 179 * Get the mapping, find the real physical page to map, get the page, and 180 * return it. 181 */ 182static int drm_do_vm_shm_fault(struct vm_area_struct *vma, struct vm_fault *vmf) 183{ 184 struct drm_local_map *map = vma->vm_private_data; 185 unsigned long offset; 186 unsigned long i; 187 struct page *page; 188 189 if (!map) 190 return VM_FAULT_SIGBUS; /* Nothing allocated */ 191 192 offset = (unsigned long)vmf->virtual_address - vma->vm_start; 193 i = (unsigned long)map->handle + offset; 194 page = vmalloc_to_page((void *)i); 195 if (!page) 196 return VM_FAULT_SIGBUS; 197 get_page(page); 198 vmf->page = page; 199 200 DRM_DEBUG("shm_fault 0x%lx\n", offset); 201 return 0; 202} 203 204/** 205 * \c close method for shared virtual memory. 206 * 207 * \param vma virtual memory area. 208 * 209 * Deletes map information if we are the last 210 * person to close a mapping and it's not in the global maplist. 211 */ 212static void drm_vm_shm_close(struct vm_area_struct *vma) 213{ 214 struct drm_file *priv = vma->vm_file->private_data; 215 struct drm_device *dev = priv->minor->dev; 216 struct drm_vma_entry *pt, *temp; 217 struct drm_local_map *map; 218 struct drm_map_list *r_list; 219 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 227 mutex_lock(&dev->struct_mutex); 228 list_for_each_entry_safe(pt, temp, &dev->vmalist, head) { 229 if (pt->vma->vm_private_data == map) 230 found_maps++; 231 if (pt->vma == vma) { 232 list_del(&pt->head); 233 kfree(pt); 234 } 235 } 236 237 /* We were the only map that was found */ 238 if (found_maps == 1 && map->flags & _DRM_REMOVABLE) { 239 /* 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; 243 list_for_each_entry(r_list, &dev->maplist, head) { 244 if (r_list->map == map) 245 found_maps++; 246 } 247 248 if (!found_maps) { 249 drm_dma_handle_t dmah; 250 251 switch (map->type) { 252 case _DRM_REGISTERS: 253 case _DRM_FRAME_BUFFER: 254 arch_phys_wc_del(map->mtrr); 255 iounmap(map->handle); 256 break; 257 case _DRM_SHM: 258 vfree(map->handle); 259 break; 260 case _DRM_AGP: 261 case _DRM_SCATTER_GATHER: 262 break; 263 case _DRM_CONSISTENT: 264 dmah.vaddr = map->handle; 265 dmah.busaddr = map->offset; 266 dmah.size = map->size; 267 __drm_pci_free(dev, &dmah); 268 break; 269 case _DRM_GEM: 270 DRM_ERROR("tried to rmmap GEM object\n"); 271 break; 272 } 273 kfree(map); 274 } 275 } 276 mutex_unlock(&dev->struct_mutex); 277} 278 279/** 280 * \c fault method for DMA virtual memory. 281 * 282 * \param vma virtual memory area. 283 * \param address access address. 284 * \return pointer to the page structure. 285 * 286 * Determine the page number from the page offset and get it from drm_device_dma::pagelist. 287 */ 288static int drm_do_vm_dma_fault(struct vm_area_struct *vma, struct vm_fault *vmf) 289{ 290 struct drm_file *priv = vma->vm_file->private_data; 291 struct drm_device *dev = priv->minor->dev; 292 struct drm_device_dma *dma = dev->dma; 293 unsigned long offset; 294 unsigned long page_nr; 295 struct page *page; 296 297 if (!dma) 298 return VM_FAULT_SIGBUS; /* Error */ 299 if (!dma->pagelist) 300 return VM_FAULT_SIGBUS; /* Nothing allocated */ 301 302 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 */ 304 page = virt_to_page((dma->pagelist[page_nr] + (offset & (~PAGE_MASK)))); 305 306 get_page(page); 307 vmf->page = page; 308 309 DRM_DEBUG("dma_fault 0x%lx (page %lu)\n", offset, page_nr); 310 return 0; 311} 312 313/** 314 * \c fault method for scatter-gather virtual memory. 315 * 316 * \param vma virtual memory area. 317 * \param address access address. 318 * \return pointer to the page structure. 319 * 320 * Determine the map offset from the page offset and get it from drm_sg_mem::pagelist. 321 */ 322static int drm_do_vm_sg_fault(struct vm_area_struct *vma, struct vm_fault *vmf) 323{ 324 struct drm_local_map *map = vma->vm_private_data; 325 struct drm_file *priv = vma->vm_file->private_data; 326 struct drm_device *dev = priv->minor->dev; 327 struct drm_sg_mem *entry = dev->sg; 328 unsigned long offset; 329 unsigned long map_offset; 330 unsigned long page_offset; 331 struct page *page; 332 333 if (!entry) 334 return VM_FAULT_SIGBUS; /* Error */ 335 if (!entry->pagelist) 336 return VM_FAULT_SIGBUS; /* Nothing allocated */ 337 338 offset = (unsigned long)vmf->virtual_address - vma->vm_start; 339 map_offset = map->offset - (unsigned long)dev->sg->virtual; 340 page_offset = (offset >> PAGE_SHIFT) + (map_offset >> PAGE_SHIFT); 341 page = entry->pagelist[page_offset]; 342 get_page(page); 343 vmf->page = page; 344 345 return 0; 346} 347 348static int drm_vm_fault(struct vm_area_struct *vma, struct vm_fault *vmf) 349{ 350 return drm_do_vm_fault(vma, vmf); 351} 352 353static int drm_vm_shm_fault(struct vm_area_struct *vma, struct vm_fault *vmf) 354{ 355 return drm_do_vm_shm_fault(vma, vmf); 356} 357 358static int drm_vm_dma_fault(struct vm_area_struct *vma, struct vm_fault *vmf) 359{ 360 return drm_do_vm_dma_fault(vma, vmf); 361} 362 363static int drm_vm_sg_fault(struct vm_area_struct *vma, struct vm_fault *vmf) 364{ 365 return drm_do_vm_sg_fault(vma, vmf); 366} 367 368/** AGP virtual memory operations */ 369static const struct vm_operations_struct drm_vm_ops = { 370 .fault = drm_vm_fault, 371 .open = drm_vm_open, 372 .close = drm_vm_close, 373}; 374 375/** Shared virtual memory operations */ 376static const struct vm_operations_struct drm_vm_shm_ops = { 377 .fault = drm_vm_shm_fault, 378 .open = drm_vm_open, 379 .close = drm_vm_shm_close, 380}; 381 382/** DMA virtual memory operations */ 383static const struct vm_operations_struct drm_vm_dma_ops = { 384 .fault = drm_vm_dma_fault, 385 .open = drm_vm_open, 386 .close = drm_vm_close, 387}; 388 389/** Scatter-gather virtual memory operations */ 390static const struct vm_operations_struct drm_vm_sg_ops = { 391 .fault = drm_vm_sg_fault, 392 .open = drm_vm_open, 393 .close = drm_vm_close, 394}; 395 396/** 397 * \c open method for shared virtual memory. 398 * 399 * \param vma virtual memory area. 400 * 401 * Create a new drm_vma_entry structure as the \p vma private data entry and 402 * add it to drm_device::vmalist. 403 */ 404void drm_vm_open_locked(struct drm_device *dev, 405 struct vm_area_struct *vma) 406{ 407 struct drm_vma_entry *vma_entry; 408 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 413 vma_entry = kmalloc(sizeof(*vma_entry), GFP_KERNEL); 414 if (vma_entry) { 415 vma_entry->vma = vma; 416 vma_entry->pid = current->pid; 417 list_add(&vma_entry->head, &dev->vmalist); 418 } 419} 420EXPORT_SYMBOL_GPL(drm_vm_open_locked); 421 422static void drm_vm_open(struct vm_area_struct *vma) 423{ 424 struct drm_file *priv = vma->vm_file->private_data; 425 struct drm_device *dev = priv->minor->dev; 426 427 mutex_lock(&dev->struct_mutex); 428 drm_vm_open_locked(dev, vma); 429 mutex_unlock(&dev->struct_mutex); 430} 431 432void drm_vm_close_locked(struct drm_device *dev, 433 struct vm_area_struct *vma) 434{ 435 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 450/** 451 * \c close method for all virtual memory types. 452 * 453 * \param vma virtual memory area. 454 * 455 * Search the \p vma private data entry in drm_device::vmalist, unlink it, and 456 * free it. 457 */ 458static void drm_vm_close(struct vm_area_struct *vma) 459{ 460 struct drm_file *priv = vma->vm_file->private_data; 461 struct drm_device *dev = priv->minor->dev; 462 463 mutex_lock(&dev->struct_mutex); 464 drm_vm_close_locked(dev, vma); 465 mutex_unlock(&dev->struct_mutex); 466} 467 468/** 469 * mmap DMA memory. 470 * 471 * \param file_priv DRM file private. 472 * \param vma virtual memory area. 473 * \return zero on success or a negative number on failure. 474 * 475 * Sets the virtual memory area operations structure to vm_dma_ops, the file 476 * pointer, and calls vm_open(). 477 */ 478static int drm_mmap_dma(struct file *filp, struct vm_area_struct *vma) 479{ 480 struct drm_file *priv = filp->private_data; 481 struct drm_device *dev; 482 struct drm_device_dma *dma; 483 unsigned long length = vma->vm_end - vma->vm_start; 484 485 dev = priv->minor->dev; 486 dma = dev->dma; 487 DRM_DEBUG("start = 0x%lx, end = 0x%lx, page offset = 0x%lx\n", 488 vma->vm_start, vma->vm_end, vma->vm_pgoff); 489 490 /* Length must match exact page count */ 491 if (!dma || (length >> PAGE_SHIFT) != dma->page_count) { 492 return -EINVAL; 493 } 494 495 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 511 vma->vm_ops = &drm_vm_dma_ops; 512 513 vma->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP; 514 515 drm_vm_open_locked(dev, vma); 516 return 0; 517} 518 519static resource_size_t drm_core_get_reg_ofs(struct drm_device *dev) 520{ 521#ifdef __alpha__ 522 return dev->hose->dense_mem_base; 523#else 524 return 0; 525#endif 526} 527 528/** 529 * mmap DMA memory. 530 * 531 * \param file_priv DRM file private. 532 * \param vma virtual memory area. 533 * \return zero on success or a negative number on failure. 534 * 535 * 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 */ 541int drm_mmap_locked(struct file *filp, struct vm_area_struct *vma) 542{ 543 struct drm_file *priv = filp->private_data; 544 struct drm_device *dev = priv->minor->dev; 545 struct drm_local_map *map = NULL; 546 resource_size_t offset = 0; 547 struct drm_hash_item *hash; 548 549 DRM_DEBUG("start = 0x%lx, end = 0x%lx, page offset = 0x%lx\n", 550 vma->vm_start, vma->vm_end, vma->vm_pgoff); 551 552 if (!priv->authenticated) 553 return -EACCES; 554 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 */ 559 if (!vma->vm_pgoff 560#if __OS_HAS_AGP 561 && (!dev->agp 562 || dev->agp->agp_info.device->vendor != PCI_VENDOR_ID_APPLE) 563#endif 564 ) 565 return drm_mmap_dma(filp, vma); 566 567 if (drm_ht_find_item(&dev->map_hash, vma->vm_pgoff, &hash)) { 568 DRM_ERROR("Could not find map\n"); 569 return -EINVAL; 570 } 571 572 map = drm_hash_entry(hash, struct drm_map_list, hash)->map; 573 if (!map || ((map->flags & _DRM_RESTRICTED) && !capable(CAP_SYS_ADMIN))) 574 return -EPERM; 575 576 /* Check for valid size. */ 577 if (map->size < vma->vm_end - vma->vm_start) 578 return -EINVAL; 579 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 585 /* 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))))); 592#endif 593 } 594 595 switch (map->type) { 596#if !defined(__arm__) 597 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 602 * pages and mappings in fault() 603 */ 604#if defined(__powerpc__) 605 pgprot_val(vma->vm_page_prot) |= _PAGE_NO_CACHE; 606#endif 607 vma->vm_ops = &drm_vm_ops; 608 break; 609 } 610 /* fall through to _DRM_FRAME_BUFFER... */ 611#endif 612 case _DRM_FRAME_BUFFER: 613 case _DRM_REGISTERS: 614 offset = drm_core_get_reg_ofs(dev); 615 vma->vm_page_prot = drm_io_prot(map, vma); 616 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)) 620 return -EAGAIN; 621 DRM_DEBUG(" Type = %d; start = 0x%lx, end = 0x%lx," 622 " offset = 0x%llx\n", 623 map->type, 624 vma->vm_start, vma->vm_end, (unsigned long long)(map->offset + offset)); 625 626 vma->vm_ops = &drm_vm_ops; 627 break; 628 case _DRM_CONSISTENT: 629 /* Consistent memory is really like shared memory. But 630 * it's allocated in a different way, so avoid fault */ 631 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; 635 vma->vm_page_prot = drm_dma_prot(map->type, vma); 636 /* fall through to _DRM_SHM */ 637 case _DRM_SHM: 638 vma->vm_ops = &drm_vm_shm_ops; 639 vma->vm_private_data = (void *)map; 640 break; 641 case _DRM_SCATTER_GATHER: 642 vma->vm_ops = &drm_vm_sg_ops; 643 vma->vm_private_data = (void *)map; 644 vma->vm_page_prot = drm_dma_prot(map->type, vma); 645 break; 646 default: 647 return -EINVAL; /* This should never happen. */ 648 } 649 vma->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP; 650 651 drm_vm_open_locked(dev, vma); 652 return 0; 653} 654 655int drm_mmap(struct file *filp, struct vm_area_struct *vma) 656{ 657 struct drm_file *priv = filp->private_data; 658 struct drm_device *dev = priv->minor->dev; 659 int ret; 660 661 if (drm_device_is_unplugged(dev)) 662 return -ENODEV; 663 664 mutex_lock(&dev->struct_mutex); 665 ret = drm_mmap_locked(filp, vma); 666 mutex_unlock(&dev->struct_mutex); 667 668 return ret; 669} 670EXPORT_SYMBOL(drm_mmap); 671