tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

Merge branch 'drm-legacy-cleanup' of git://people.freedesktop.org/~airlied/linux into drm-next

Pull legacy cleanups from Dave.

Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
From: Dave Airlie <airlied@gmail.com>
Link: https://patchwork.freedesktop.org/patch/msgid/CAPM=9tztr1GoR0gr1CXPv8FsAXE4iuoRZDWKYovtnb6oDGF-Lg@mail.gmail.com

Daniel Vetter 08269364 abbc0697

+285 -97
+4
drivers/gpu/drm/Kconfig
··· 255 255 256 256 If M is selected the module will be called vkms. 257 257 258 + config DRM_ATI_PCIGART 259 + bool 260 + 258 261 source "drivers/gpu/drm/exynos/Kconfig" 259 262 260 263 source "drivers/gpu/drm/rockchip/Kconfig" ··· 350 347 bool "Enable legacy drivers (DANGEROUS)" 351 348 depends on DRM && MMU 352 349 select DRM_VM 350 + select DRM_ATI_PCIGART if PCI 353 351 help 354 352 Enable legacy DRI1 drivers. Those drivers expose unsafe and dangerous 355 353 APIs to user-space, which can be used to circumvent access
+4 -5
drivers/gpu/drm/Makefile
··· 3 3 # Makefile for the drm device driver. This driver provides support for the 4 4 # Direct Rendering Infrastructure (DRI) in XFree86 4.1.0 and higher. 5 5 6 - drm-y := drm_auth.o drm_bufs.o drm_cache.o \ 7 - drm_context.o drm_dma.o \ 6 + drm-y := drm_auth.o drm_cache.o \ 8 7 drm_file.o drm_gem.o drm_ioctl.o drm_irq.o \ 9 - drm_lock.o drm_memory.o drm_drv.o \ 10 - drm_scatter.o drm_pci.o \ 8 + drm_memory.o drm_drv.o drm_pci.o \ 11 9 drm_sysfs.o drm_hashtab.o drm_mm.o \ 12 10 drm_crtc.o drm_fourcc.o drm_modes.o drm_edid.o \ 13 11 drm_encoder_slave.o \ ··· 19 21 drm_syncobj.o drm_lease.o drm_writeback.o drm_client.o \ 20 22 drm_atomic_uapi.o 21 23 24 + drm-$(CONFIG_DRM_LEGACY) += drm_legacy_misc.o drm_bufs.o drm_context.o drm_dma.o drm_scatter.o drm_lock.o 22 25 drm-$(CONFIG_DRM_LIB_RANDOM) += lib/drm_random.o 23 26 drm-$(CONFIG_DRM_VM) += drm_vm.o 24 27 drm-$(CONFIG_COMPAT) += drm_ioc32.o 25 28 drm-$(CONFIG_DRM_GEM_CMA_HELPER) += drm_gem_cma_helper.o 26 29 drm-$(CONFIG_DRM_GEM_SHMEM_HELPER) += drm_gem_shmem_helper.o 27 - drm-$(CONFIG_PCI) += ati_pcigart.o 30 + drm-$(CONFIG_DRM_ATI_PCIGART) += ati_pcigart.o 28 31 drm-$(CONFIG_DRM_PANEL) += drm_panel.o 29 32 drm-$(CONFIG_OF) += drm_of.o 30 33 drm-$(CONFIG_AGP) += drm_agpsupport.o
+2 -17
drivers/gpu/drm/drm_auth.c
··· 103 103 return NULL; 104 104 105 105 kref_init(&master->refcount); 106 - spin_lock_init(&master->lock.spinlock); 107 - init_waitqueue_head(&master->lock.lock_queue); 106 + drm_master_legacy_init(master); 108 107 idr_init(&master->magic_map); 109 108 master->dev = dev; 110 109 ··· 273 274 if (!drm_is_current_master(file_priv)) 274 275 goto out; 275 276 276 - if (drm_core_check_feature(dev, DRIVER_LEGACY)) { 277 - /* 278 - * Since the master is disappearing, so is the 279 - * possibility to lock. 280 - */ 281 - mutex_lock(&dev->struct_mutex); 282 - if (master->lock.hw_lock) { 283 - if (dev->sigdata.lock == master->lock.hw_lock) 284 - dev->sigdata.lock = NULL; 285 - master->lock.hw_lock = NULL; 286 - master->lock.file_priv = NULL; 287 - wake_up_interruptible_all(&master->lock.lock_queue); 288 - } 289 - mutex_unlock(&dev->struct_mutex); 290 - } 277 + drm_legacy_lock_master_cleanup(dev, master); 291 278 292 279 if (dev->master == file_priv->master) 293 280 drm_drop_master(dev, file_priv);
+8
drivers/gpu/drm/drm_bufs.c
··· 584 584 mutex_unlock(&dev->struct_mutex); 585 585 } 586 586 587 + void drm_legacy_rmmaps(struct drm_device *dev) 588 + { 589 + struct drm_map_list *r_list, *list_temp; 590 + 591 + list_for_each_entry_safe(r_list, list_temp, &dev->maplist, head) 592 + drm_legacy_rmmap(dev, r_list->map); 593 + } 594 + 587 595 /* The rmmap ioctl appears to be unnecessary. All mappings are torn down on 588 596 * the last close of the device, and this is necessary for cleanup when things 589 597 * exit uncleanly. Therefore, having userland manually remove mappings seems
+7 -14
drivers/gpu/drm/drm_drv.c
··· 659 659 /* no per-device feature limits by default */ 660 660 dev->driver_features = ~0u; 661 661 662 + drm_legacy_init_members(dev); 662 663 INIT_LIST_HEAD(&dev->filelist); 663 664 INIT_LIST_HEAD(&dev->filelist_internal); 664 665 INIT_LIST_HEAD(&dev->clientlist); 665 - INIT_LIST_HEAD(&dev->ctxlist); 666 - INIT_LIST_HEAD(&dev->vmalist); 667 - INIT_LIST_HEAD(&dev->maplist); 668 666 INIT_LIST_HEAD(&dev->vblank_event_list); 669 667 670 - spin_lock_init(&dev->buf_lock); 671 668 spin_lock_init(&dev->event_lock); 672 669 mutex_init(&dev->struct_mutex); 673 670 mutex_init(&dev->filelist_mutex); 674 671 mutex_init(&dev->clientlist_mutex); 675 - mutex_init(&dev->ctxlist_mutex); 676 672 mutex_init(&dev->master_mutex); 677 673 678 674 dev->anon_inode = drm_fs_inode_new(); ··· 688 692 if (ret) 689 693 goto err_minors; 690 694 691 - ret = drm_ht_create(&dev->map_hash, 12); 695 + ret = drm_legacy_create_map_hash(dev); 692 696 if (ret) 693 697 goto err_minors; 694 698 ··· 713 717 drm_gem_destroy(dev); 714 718 err_ctxbitmap: 715 719 drm_legacy_ctxbitmap_cleanup(dev); 716 - drm_ht_remove(&dev->map_hash); 720 + drm_legacy_remove_map_hash(dev); 717 721 err_minors: 718 722 drm_minor_free(dev, DRM_MINOR_PRIMARY); 719 723 drm_minor_free(dev, DRM_MINOR_RENDER); ··· 721 725 err_free: 722 726 put_device(dev->dev); 723 727 mutex_destroy(&dev->master_mutex); 724 - mutex_destroy(&dev->ctxlist_mutex); 725 728 mutex_destroy(&dev->clientlist_mutex); 726 729 mutex_destroy(&dev->filelist_mutex); 727 730 mutex_destroy(&dev->struct_mutex); 731 + drm_legacy_destroy_members(dev); 728 732 return ret; 729 733 } 730 734 EXPORT_SYMBOL(drm_dev_init); ··· 788 792 drm_gem_destroy(dev); 789 793 790 794 drm_legacy_ctxbitmap_cleanup(dev); 791 - drm_ht_remove(&dev->map_hash); 795 + drm_legacy_remove_map_hash(dev); 792 796 drm_fs_inode_free(dev->anon_inode); 793 797 794 798 drm_minor_free(dev, DRM_MINOR_PRIMARY); ··· 797 801 put_device(dev->dev); 798 802 799 803 mutex_destroy(&dev->master_mutex); 800 - mutex_destroy(&dev->ctxlist_mutex); 801 804 mutex_destroy(&dev->clientlist_mutex); 802 805 mutex_destroy(&dev->filelist_mutex); 803 806 mutex_destroy(&dev->struct_mutex); 807 + drm_legacy_destroy_members(dev); 804 808 kfree(dev->unique); 805 809 } 806 810 EXPORT_SYMBOL(drm_dev_fini); ··· 1034 1038 */ 1035 1039 void drm_dev_unregister(struct drm_device *dev) 1036 1040 { 1037 - struct drm_map_list *r_list, *list_temp; 1038 - 1039 1041 if (drm_core_check_feature(dev, DRIVER_LEGACY)) 1040 1042 drm_lastclose(dev); 1041 1043 ··· 1050 1056 if (dev->agp) 1051 1057 drm_pci_agp_destroy(dev); 1052 1058 1053 - list_for_each_entry_safe(r_list, list_temp, &dev->maplist, head) 1054 - drm_legacy_rmmap(dev, r_list->map); 1059 + drm_legacy_rmmaps(dev); 1055 1060 1056 1061 remove_compat_control_link(dev); 1057 1062 drm_minor_unregister(dev, DRM_MINOR_PRIMARY);
-25
drivers/gpu/drm/drm_file.c
··· 128 128 129 129 /* for compatibility root is always authenticated */ 130 130 file->authenticated = capable(CAP_SYS_ADMIN); 131 - file->lock_count = 0; 132 131 133 132 INIT_LIST_HEAD(&file->lhead); 134 133 INIT_LIST_HEAD(&file->fbs); ··· 422 423 #endif 423 424 424 425 return 0; 425 - } 426 - 427 - static void drm_legacy_dev_reinit(struct drm_device *dev) 428 - { 429 - if (dev->irq_enabled) 430 - drm_irq_uninstall(dev); 431 - 432 - mutex_lock(&dev->struct_mutex); 433 - 434 - drm_legacy_agp_clear(dev); 435 - 436 - drm_legacy_sg_cleanup(dev); 437 - drm_legacy_vma_flush(dev); 438 - drm_legacy_dma_takedown(dev); 439 - 440 - mutex_unlock(&dev->struct_mutex); 441 - 442 - dev->sigdata.lock = NULL; 443 - 444 - dev->context_flag = 0; 445 - dev->last_context = 0; 446 - dev->if_version = 0; 447 - 448 - DRM_DEBUG("lastclose completed\n"); 449 426 } 450 427 451 428 void drm_lastclose(struct drm_device * dev)
+2
drivers/gpu/drm/drm_internal.h
··· 71 71 /* drm_irq.c */ 72 72 73 73 /* IOCTLS */ 74 + #if IS_ENABLED(CONFIG_DRM_LEGACY) 74 75 int drm_legacy_irq_control(struct drm_device *dev, void *data, 75 76 struct drm_file *file_priv); 77 + #endif 76 78 77 79 int drm_crtc_get_sequence_ioctl(struct drm_device *dev, void *data, 78 80 struct drm_file *filp);
+12 -1
drivers/gpu/drm/drm_ioc32.c
··· 156 156 return -EINVAL; 157 157 } 158 158 159 + #if IS_ENABLED(CONFIG_DRM_LEGACY) 159 160 typedef struct drm_map32 { 160 161 u32 offset; /* Requested physical address (0 for SAREA) */ 161 162 u32 size; /* Requested physical size (bytes) */ ··· 240 239 map.handle = compat_ptr(handle); 241 240 return drm_ioctl_kernel(file, drm_legacy_rmmap_ioctl, &map, DRM_AUTH); 242 241 } 242 + #endif 243 243 244 244 typedef struct drm_client32 { 245 245 int idx; /* Which client desired? */ ··· 303 301 return 0; 304 302 } 305 303 304 + #if IS_ENABLED(CONFIG_DRM_LEGACY) 306 305 typedef struct drm_buf_desc32 { 307 306 int count; /* Number of buffers of this size */ 308 307 int size; /* Size in bytes */ ··· 607 604 608 605 return 0; 609 606 } 607 + #endif 610 608 611 609 #if IS_ENABLED(CONFIG_AGP) 612 610 typedef struct drm_agp_mode32 { ··· 752 748 } 753 749 #endif /* CONFIG_AGP */ 754 750 751 + #if IS_ENABLED(CONFIG_DRM_LEGACY) 755 752 typedef struct drm_scatter_gather32 { 756 753 u32 size; /**< In bytes -- will round to page boundary */ 757 754 u32 handle; /**< Used for mapping / unmapping */ ··· 793 788 return drm_ioctl_kernel(file, drm_legacy_sg_free, &request, 794 789 DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY); 795 790 } 796 - 791 + #endif 797 792 #if defined(CONFIG_X86) 798 793 typedef struct drm_update_draw32 { 799 794 drm_drawable_t handle; ··· 908 903 #define DRM_IOCTL32_DEF(n, f) [DRM_IOCTL_NR(n##32)] = {.fn = f, .name = #n} 909 904 DRM_IOCTL32_DEF(DRM_IOCTL_VERSION, compat_drm_version), 910 905 DRM_IOCTL32_DEF(DRM_IOCTL_GET_UNIQUE, compat_drm_getunique), 906 + #if IS_ENABLED(CONFIG_DRM_LEGACY) 911 907 DRM_IOCTL32_DEF(DRM_IOCTL_GET_MAP, compat_drm_getmap), 908 + #endif 912 909 DRM_IOCTL32_DEF(DRM_IOCTL_GET_CLIENT, compat_drm_getclient), 913 910 DRM_IOCTL32_DEF(DRM_IOCTL_GET_STATS, compat_drm_getstats), 914 911 DRM_IOCTL32_DEF(DRM_IOCTL_SET_UNIQUE, compat_drm_setunique), 912 + #if IS_ENABLED(CONFIG_DRM_LEGACY) 915 913 DRM_IOCTL32_DEF(DRM_IOCTL_ADD_MAP, compat_drm_addmap), 916 914 DRM_IOCTL32_DEF(DRM_IOCTL_ADD_BUFS, compat_drm_addbufs), 917 915 DRM_IOCTL32_DEF(DRM_IOCTL_MARK_BUFS, compat_drm_markbufs), ··· 926 918 DRM_IOCTL32_DEF(DRM_IOCTL_GET_SAREA_CTX, compat_drm_getsareactx), 927 919 DRM_IOCTL32_DEF(DRM_IOCTL_RES_CTX, compat_drm_resctx), 928 920 DRM_IOCTL32_DEF(DRM_IOCTL_DMA, compat_drm_dma), 921 + #endif 929 922 #if IS_ENABLED(CONFIG_AGP) 930 923 DRM_IOCTL32_DEF(DRM_IOCTL_AGP_ENABLE, compat_drm_agp_enable), 931 924 DRM_IOCTL32_DEF(DRM_IOCTL_AGP_INFO, compat_drm_agp_info), ··· 935 926 DRM_IOCTL32_DEF(DRM_IOCTL_AGP_BIND, compat_drm_agp_bind), 936 927 DRM_IOCTL32_DEF(DRM_IOCTL_AGP_UNBIND, compat_drm_agp_unbind), 937 928 #endif 929 + #if IS_ENABLED(CONFIG_DRM_LEGACY) 938 930 DRM_IOCTL32_DEF(DRM_IOCTL_SG_ALLOC, compat_drm_sg_alloc), 939 931 DRM_IOCTL32_DEF(DRM_IOCTL_SG_FREE, compat_drm_sg_free), 932 + #endif 940 933 #if defined(CONFIG_X86) || defined(CONFIG_IA64) 941 934 DRM_IOCTL32_DEF(DRM_IOCTL_UPDATE_DRAW, compat_drm_update_draw), 942 935 #endif
+31 -24
drivers/gpu/drm/drm_ioctl.c
··· 553 553 .name = #ioctl \ 554 554 } 555 555 556 + #if IS_ENABLED(CONFIG_DRM_LEGACY) 557 + #define DRM_LEGACY_IOCTL_DEF(ioctl, _func, _flags) DRM_IOCTL_DEF(ioctl, _func, _flags) 558 + #else 559 + #define DRM_LEGACY_IOCTL_DEF(ioctl, _func, _flags) DRM_IOCTL_DEF(ioctl, drm_invalid_op, _flags) 560 + #endif 561 + 556 562 /* Ioctl table */ 557 563 static const struct drm_ioctl_desc drm_ioctls[] = { 558 564 DRM_IOCTL_DEF(DRM_IOCTL_VERSION, drm_version, ··· 566 560 DRM_IOCTL_DEF(DRM_IOCTL_GET_UNIQUE, drm_getunique, DRM_UNLOCKED), 567 561 DRM_IOCTL_DEF(DRM_IOCTL_GET_MAGIC, drm_getmagic, DRM_UNLOCKED), 568 562 DRM_IOCTL_DEF(DRM_IOCTL_IRQ_BUSID, drm_irq_by_busid, DRM_MASTER|DRM_ROOT_ONLY), 569 - DRM_IOCTL_DEF(DRM_IOCTL_GET_MAP, drm_legacy_getmap_ioctl, DRM_UNLOCKED), 563 + 564 + DRM_LEGACY_IOCTL_DEF(DRM_IOCTL_GET_MAP, drm_legacy_getmap_ioctl, DRM_UNLOCKED), 565 + 570 566 DRM_IOCTL_DEF(DRM_IOCTL_GET_CLIENT, drm_getclient, DRM_UNLOCKED), 571 567 DRM_IOCTL_DEF(DRM_IOCTL_GET_STATS, drm_getstats, DRM_UNLOCKED), 572 568 DRM_IOCTL_DEF(DRM_IOCTL_GET_CAP, drm_getcap, DRM_UNLOCKED|DRM_RENDER_ALLOW), ··· 580 572 DRM_IOCTL_DEF(DRM_IOCTL_UNBLOCK, drm_noop, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 581 573 DRM_IOCTL_DEF(DRM_IOCTL_AUTH_MAGIC, drm_authmagic, DRM_UNLOCKED|DRM_MASTER), 582 574 583 - DRM_IOCTL_DEF(DRM_IOCTL_ADD_MAP, drm_legacy_addmap_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 584 - DRM_IOCTL_DEF(DRM_IOCTL_RM_MAP, drm_legacy_rmmap_ioctl, DRM_AUTH), 575 + DRM_LEGACY_IOCTL_DEF(DRM_IOCTL_ADD_MAP, drm_legacy_addmap_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 576 + DRM_LEGACY_IOCTL_DEF(DRM_IOCTL_RM_MAP, drm_legacy_rmmap_ioctl, DRM_AUTH), 585 577 586 - DRM_IOCTL_DEF(DRM_IOCTL_SET_SAREA_CTX, drm_legacy_setsareactx, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 587 - DRM_IOCTL_DEF(DRM_IOCTL_GET_SAREA_CTX, drm_legacy_getsareactx, DRM_AUTH), 578 + DRM_LEGACY_IOCTL_DEF(DRM_IOCTL_SET_SAREA_CTX, drm_legacy_setsareactx, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 579 + DRM_LEGACY_IOCTL_DEF(DRM_IOCTL_GET_SAREA_CTX, drm_legacy_getsareactx, DRM_AUTH), 588 580 589 581 DRM_IOCTL_DEF(DRM_IOCTL_SET_MASTER, drm_setmaster_ioctl, DRM_UNLOCKED|DRM_ROOT_ONLY), 590 582 DRM_IOCTL_DEF(DRM_IOCTL_DROP_MASTER, drm_dropmaster_ioctl, DRM_UNLOCKED|DRM_ROOT_ONLY), 591 583 592 - DRM_IOCTL_DEF(DRM_IOCTL_ADD_CTX, drm_legacy_addctx, DRM_AUTH|DRM_ROOT_ONLY), 593 - DRM_IOCTL_DEF(DRM_IOCTL_RM_CTX, drm_legacy_rmctx, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 594 - DRM_IOCTL_DEF(DRM_IOCTL_MOD_CTX, drm_noop, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 595 - DRM_IOCTL_DEF(DRM_IOCTL_GET_CTX, drm_legacy_getctx, DRM_AUTH), 596 - DRM_IOCTL_DEF(DRM_IOCTL_SWITCH_CTX, drm_legacy_switchctx, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 597 - DRM_IOCTL_DEF(DRM_IOCTL_NEW_CTX, drm_legacy_newctx, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 598 - DRM_IOCTL_DEF(DRM_IOCTL_RES_CTX, drm_legacy_resctx, DRM_AUTH), 584 + DRM_LEGACY_IOCTL_DEF(DRM_IOCTL_ADD_CTX, drm_legacy_addctx, DRM_AUTH|DRM_ROOT_ONLY), 585 + DRM_LEGACY_IOCTL_DEF(DRM_IOCTL_RM_CTX, drm_legacy_rmctx, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 586 + DRM_LEGACY_IOCTL_DEF(DRM_IOCTL_MOD_CTX, drm_noop, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 587 + DRM_LEGACY_IOCTL_DEF(DRM_IOCTL_GET_CTX, drm_legacy_getctx, DRM_AUTH), 588 + DRM_LEGACY_IOCTL_DEF(DRM_IOCTL_SWITCH_CTX, drm_legacy_switchctx, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 589 + DRM_LEGACY_IOCTL_DEF(DRM_IOCTL_NEW_CTX, drm_legacy_newctx, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 590 + DRM_LEGACY_IOCTL_DEF(DRM_IOCTL_RES_CTX, drm_legacy_resctx, DRM_AUTH), 599 591 600 592 DRM_IOCTL_DEF(DRM_IOCTL_ADD_DRAW, drm_noop, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 601 593 DRM_IOCTL_DEF(DRM_IOCTL_RM_DRAW, drm_noop, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 602 594 603 - DRM_IOCTL_DEF(DRM_IOCTL_LOCK, drm_legacy_lock, DRM_AUTH), 604 - DRM_IOCTL_DEF(DRM_IOCTL_UNLOCK, drm_legacy_unlock, DRM_AUTH), 595 + DRM_LEGACY_IOCTL_DEF(DRM_IOCTL_LOCK, drm_legacy_lock, DRM_AUTH), 596 + DRM_LEGACY_IOCTL_DEF(DRM_IOCTL_UNLOCK, drm_legacy_unlock, DRM_AUTH), 605 597 606 598 DRM_IOCTL_DEF(DRM_IOCTL_FINISH, drm_noop, DRM_AUTH), 607 599 608 - DRM_IOCTL_DEF(DRM_IOCTL_ADD_BUFS, drm_legacy_addbufs, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 609 - DRM_IOCTL_DEF(DRM_IOCTL_MARK_BUFS, drm_legacy_markbufs, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 610 - DRM_IOCTL_DEF(DRM_IOCTL_INFO_BUFS, drm_legacy_infobufs, DRM_AUTH), 611 - DRM_IOCTL_DEF(DRM_IOCTL_MAP_BUFS, drm_legacy_mapbufs, DRM_AUTH), 612 - DRM_IOCTL_DEF(DRM_IOCTL_FREE_BUFS, drm_legacy_freebufs, DRM_AUTH), 613 - DRM_IOCTL_DEF(DRM_IOCTL_DMA, drm_legacy_dma_ioctl, DRM_AUTH), 614 - 615 - DRM_IOCTL_DEF(DRM_IOCTL_CONTROL, drm_legacy_irq_control, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 600 + DRM_LEGACY_IOCTL_DEF(DRM_IOCTL_ADD_BUFS, drm_legacy_addbufs, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 601 + DRM_LEGACY_IOCTL_DEF(DRM_IOCTL_MARK_BUFS, drm_legacy_markbufs, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 602 + DRM_LEGACY_IOCTL_DEF(DRM_IOCTL_INFO_BUFS, drm_legacy_infobufs, DRM_AUTH), 603 + DRM_LEGACY_IOCTL_DEF(DRM_IOCTL_MAP_BUFS, drm_legacy_mapbufs, DRM_AUTH), 604 + DRM_LEGACY_IOCTL_DEF(DRM_IOCTL_FREE_BUFS, drm_legacy_freebufs, DRM_AUTH), 605 + DRM_LEGACY_IOCTL_DEF(DRM_IOCTL_DMA, drm_legacy_dma_ioctl, DRM_AUTH), 606 + DRM_LEGACY_IOCTL_DEF(DRM_IOCTL_CONTROL, drm_legacy_irq_control, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 616 607 617 608 #if IS_ENABLED(CONFIG_AGP) 618 609 DRM_IOCTL_DEF(DRM_IOCTL_AGP_ACQUIRE, drm_agp_acquire_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), ··· 624 617 DRM_IOCTL_DEF(DRM_IOCTL_AGP_UNBIND, drm_agp_unbind_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 625 618 #endif 626 619 627 - DRM_IOCTL_DEF(DRM_IOCTL_SG_ALLOC, drm_legacy_sg_alloc, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 628 - DRM_IOCTL_DEF(DRM_IOCTL_SG_FREE, drm_legacy_sg_free, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 620 + DRM_LEGACY_IOCTL_DEF(DRM_IOCTL_SG_ALLOC, drm_legacy_sg_alloc, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 621 + DRM_LEGACY_IOCTL_DEF(DRM_IOCTL_SG_FREE, drm_legacy_sg_free, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 629 622 630 623 DRM_IOCTL_DEF(DRM_IOCTL_WAIT_VBLANK, drm_wait_vblank_ioctl, DRM_UNLOCKED), 631 624
+2
drivers/gpu/drm/drm_irq.c
··· 213 213 } 214 214 EXPORT_SYMBOL(drm_irq_uninstall); 215 215 216 + #if IS_ENABLED(CONFIG_DRM_LEGACY) 216 217 int drm_legacy_irq_control(struct drm_device *dev, void *data, 217 218 struct drm_file *file_priv) 218 219 { ··· 254 253 return -EINVAL; 255 254 } 256 255 } 256 + #endif
+85 -2
drivers/gpu/drm/drm_legacy.h
··· 42 42 #define DRM_KERNEL_CONTEXT 0 43 43 #define DRM_RESERVED_CONTEXTS 1 44 44 45 + #if IS_ENABLED(CONFIG_DRM_LEGACY) 45 46 void drm_legacy_ctxbitmap_init(struct drm_device *dev); 46 47 void drm_legacy_ctxbitmap_cleanup(struct drm_device *dev); 47 - void drm_legacy_ctxbitmap_free(struct drm_device *dev, int ctx_handle); 48 48 void drm_legacy_ctxbitmap_flush(struct drm_device *dev, struct drm_file *file); 49 + #else 50 + static inline void drm_legacy_ctxbitmap_init(struct drm_device *dev) {} 51 + static inline void drm_legacy_ctxbitmap_cleanup(struct drm_device *dev) {} 52 + static inline void drm_legacy_ctxbitmap_flush(struct drm_device *dev, struct drm_file *file) {} 53 + #endif 49 54 55 + void drm_legacy_ctxbitmap_free(struct drm_device *dev, int ctx_handle); 56 + 57 + #if IS_ENABLED(CONFIG_DRM_LEGACY) 50 58 int drm_legacy_resctx(struct drm_device *d, void *v, struct drm_file *f); 51 59 int drm_legacy_addctx(struct drm_device *d, void *v, struct drm_file *f); 52 60 int drm_legacy_getctx(struct drm_device *d, void *v, struct drm_file *f); ··· 64 56 65 57 int drm_legacy_setsareactx(struct drm_device *d, void *v, struct drm_file *f); 66 58 int drm_legacy_getsareactx(struct drm_device *d, void *v, struct drm_file *f); 59 + #endif 67 60 68 61 /* 69 62 * Generic Buffer Management ··· 72 63 73 64 #define DRM_MAP_HASH_OFFSET 0x10000000 74 65 66 + #if IS_ENABLED(CONFIG_DRM_LEGACY) 67 + static inline int drm_legacy_create_map_hash(struct drm_device *dev) 68 + { 69 + return drm_ht_create(&dev->map_hash, 12); 70 + } 71 + 72 + static inline void drm_legacy_remove_map_hash(struct drm_device *dev) 73 + { 74 + drm_ht_remove(&dev->map_hash); 75 + } 76 + #else 77 + static inline int drm_legacy_create_map_hash(struct drm_device *dev) 78 + { 79 + return 0; 80 + } 81 + 82 + static inline void drm_legacy_remove_map_hash(struct drm_device *dev) {} 83 + #endif 84 + 85 + 86 + #if IS_ENABLED(CONFIG_DRM_LEGACY) 75 87 int drm_legacy_getmap_ioctl(struct drm_device *dev, void *data, 76 88 struct drm_file *file_priv); 77 89 int drm_legacy_addmap_ioctl(struct drm_device *d, void *v, struct drm_file *f); 78 90 int drm_legacy_rmmap_ioctl(struct drm_device *d, void *v, struct drm_file *f); 91 + 79 92 int drm_legacy_addbufs(struct drm_device *d, void *v, struct drm_file *f); 80 93 int drm_legacy_infobufs(struct drm_device *d, void *v, struct drm_file *f); 81 94 int drm_legacy_markbufs(struct drm_device *d, void *v, struct drm_file *f); 82 95 int drm_legacy_freebufs(struct drm_device *d, void *v, struct drm_file *f); 83 96 int drm_legacy_mapbufs(struct drm_device *d, void *v, struct drm_file *f); 84 97 int drm_legacy_dma_ioctl(struct drm_device *d, void *v, struct drm_file *f); 98 + #endif 85 99 86 100 int __drm_legacy_infobufs(struct drm_device *, void *, int *, 87 101 int (*)(void *, int, struct drm_buf_entry *)); ··· 113 81 int (*)(void *, int, unsigned long, struct drm_buf *), 114 82 struct drm_file *); 115 83 116 - #ifdef CONFIG_DRM_VM 84 + #if IS_ENABLED(CONFIG_DRM_LEGACY) 85 + void drm_legacy_master_rmmaps(struct drm_device *dev, 86 + struct drm_master *master); 87 + void drm_legacy_rmmaps(struct drm_device *dev); 88 + #else 89 + static inline void drm_legacy_master_rmmaps(struct drm_device *dev, 90 + struct drm_master *master) {} 91 + static inline void drm_legacy_rmmaps(struct drm_device *dev) {} 92 + #endif 93 + 94 + #if IS_ENABLED(CONFIG_DRM_VM) && IS_ENABLED(CONFIG_DRM_LEGACY) 117 95 void drm_legacy_vma_flush(struct drm_device *d); 118 96 #else 119 97 static inline void drm_legacy_vma_flush(struct drm_device *d) ··· 145 103 }; 146 104 147 105 /* drm_lock.c */ 106 + #if IS_ENABLED(CONFIG_DRM_LEGACY) 148 107 int drm_legacy_lock(struct drm_device *d, void *v, struct drm_file *f); 149 108 int drm_legacy_unlock(struct drm_device *d, void *v, struct drm_file *f); 150 109 void drm_legacy_lock_release(struct drm_device *dev, struct file *filp); 110 + #else 111 + static inline void drm_legacy_lock_release(struct drm_device *dev, struct file *filp) {} 112 + #endif 151 113 152 114 /* DMA support */ 115 + #if IS_ENABLED(CONFIG_DRM_LEGACY) 153 116 int drm_legacy_dma_setup(struct drm_device *dev); 154 117 void drm_legacy_dma_takedown(struct drm_device *dev); 118 + #else 119 + static inline int drm_legacy_dma_setup(struct drm_device *dev) 120 + { 121 + return 0; 122 + } 123 + #endif 124 + 155 125 void drm_legacy_free_buffer(struct drm_device *dev, 156 126 struct drm_buf * buf); 127 + #if IS_ENABLED(CONFIG_DRM_LEGACY) 157 128 void drm_legacy_reclaim_buffers(struct drm_device *dev, 158 129 struct drm_file *filp); 130 + #else 131 + static inline void drm_legacy_reclaim_buffers(struct drm_device *dev, 132 + struct drm_file *filp) {} 133 + #endif 159 134 160 135 /* Scatter Gather Support */ 136 + #if IS_ENABLED(CONFIG_DRM_LEGACY) 161 137 void drm_legacy_sg_cleanup(struct drm_device *dev); 162 138 int drm_legacy_sg_alloc(struct drm_device *dev, void *data, 163 139 struct drm_file *file_priv); 164 140 int drm_legacy_sg_free(struct drm_device *dev, void *data, 165 141 struct drm_file *file_priv); 142 + #endif 143 + 144 + #if IS_ENABLED(CONFIG_DRM_LEGACY) 145 + void drm_legacy_init_members(struct drm_device *dev); 146 + void drm_legacy_destroy_members(struct drm_device *dev); 147 + void drm_legacy_dev_reinit(struct drm_device *dev); 148 + #else 149 + static inline void drm_legacy_init_members(struct drm_device *dev) {} 150 + static inline void drm_legacy_destroy_members(struct drm_device *dev) {} 151 + static inline void drm_legacy_dev_reinit(struct drm_device *dev) {} 152 + #endif 153 + 154 + #if IS_ENABLED(CONFIG_DRM_LEGACY) 155 + void drm_legacy_lock_master_cleanup(struct drm_device *dev, struct drm_master *master); 156 + #else 157 + static inline void drm_legacy_lock_master_cleanup(struct drm_device *dev, struct drm_master *master) {} 158 + #endif 159 + 160 + #if IS_ENABLED(CONFIG_DRM_LEGACY) 161 + void drm_master_legacy_init(struct drm_master *master); 162 + #else 163 + static inline void drm_master_legacy_init(struct drm_master *master) {} 164 + #endif 166 165 167 166 #endif /* __DRM_LEGACY_H__ */
+82
drivers/gpu/drm/drm_legacy_misc.c
··· 1 + /** 2 + * \file drm_legacy_misc.c 3 + * Misc legacy support functions. 4 + * 5 + * \author Rickard E. (Rik) Faith <faith@valinux.com> 6 + * \author Gareth Hughes <gareth@valinux.com> 7 + */ 8 + 9 + /* 10 + * Created: Tue Feb 2 08:37:54 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 "drm_internal.h" 38 + #include "drm_legacy.h" 39 + 40 + void drm_legacy_init_members(struct drm_device *dev) 41 + { 42 + INIT_LIST_HEAD(&dev->ctxlist); 43 + INIT_LIST_HEAD(&dev->vmalist); 44 + INIT_LIST_HEAD(&dev->maplist); 45 + spin_lock_init(&dev->buf_lock); 46 + mutex_init(&dev->ctxlist_mutex); 47 + } 48 + 49 + void drm_legacy_destroy_members(struct drm_device *dev) 50 + { 51 + mutex_destroy(&dev->ctxlist_mutex); 52 + } 53 + 54 + void drm_legacy_dev_reinit(struct drm_device *dev) 55 + { 56 + if (dev->irq_enabled) 57 + drm_irq_uninstall(dev); 58 + 59 + mutex_lock(&dev->struct_mutex); 60 + 61 + drm_legacy_agp_clear(dev); 62 + 63 + drm_legacy_sg_cleanup(dev); 64 + drm_legacy_vma_flush(dev); 65 + drm_legacy_dma_takedown(dev); 66 + 67 + mutex_unlock(&dev->struct_mutex); 68 + 69 + dev->sigdata.lock = NULL; 70 + 71 + dev->context_flag = 0; 72 + dev->last_context = 0; 73 + dev->if_version = 0; 74 + 75 + DRM_DEBUG("lastclose completed\n"); 76 + } 77 + 78 + void drm_master_legacy_init(struct drm_master *master) 79 + { 80 + spin_lock_init(&master->lock.spinlock); 81 + init_waitqueue_head(&master->lock.lock_queue); 82 + }
+19
drivers/gpu/drm/drm_lock.c
··· 347 347 _DRM_LOCKING_CONTEXT(file_priv->master->lock.hw_lock->lock)); 348 348 } 349 349 } 350 + 351 + void drm_legacy_lock_master_cleanup(struct drm_device *dev, struct drm_master *master) 352 + { 353 + if (!drm_core_check_feature(dev, DRIVER_LEGACY)) 354 + return; 355 + 356 + /* 357 + * Since the master is disappearing, so is the 358 + * possibility to lock. 359 + */ mutex_lock(&dev->struct_mutex); 360 + if (master->lock.hw_lock) { 361 + if (dev->sigdata.lock == master->lock.hw_lock) 362 + dev->sigdata.lock = NULL; 363 + master->lock.hw_lock = NULL; 364 + master->lock.file_priv = NULL; 365 + wake_up_interruptible_all(&master->lock.lock_queue); 366 + } 367 + mutex_unlock(&dev->struct_mutex); 368 + }
+2
drivers/gpu/drm/drm_vm.c
··· 646 646 } 647 647 EXPORT_SYMBOL(drm_legacy_mmap); 648 648 649 + #if IS_ENABLED(CONFIG_DRM_LEGACY) 649 650 void drm_legacy_vma_flush(struct drm_device *dev) 650 651 { 651 652 struct drm_vma_entry *vma, *vma_temp; ··· 657 656 kfree(vma); 658 657 } 659 658 } 659 + #endif
+12 -1
drivers/gpu/drm/nouveau/Kconfig
··· 17 17 select INPUT if ACPI && X86 18 18 select THERMAL if ACPI && X86 19 19 select ACPI_VIDEO if ACPI && X86 20 - select DRM_VM 21 20 help 22 21 Choose this option for open-source NVIDIA support. 22 + 23 + config NOUVEAU_LEGACY_CTX_SUPPORT 24 + bool "Nouveau legacy context support" 25 + depends on DRM_NOUVEAU 26 + select DRM_LEGACY 27 + default y 28 + help 29 + There was a version of the nouveau DDX that relied on legacy 30 + ctx ioctls not erroring out. But that was back in time a long 31 + ways, so offer a way to disable it now. For uapi compat with 32 + old nouveau ddx this should be on by default, but modern distros 33 + should consider turning it off. 23 34 24 35 config NOUVEAU_PLATFORM_DRIVER 25 36 bool "Nouveau (NVIDIA) SoC GPUs"
+5 -2
drivers/gpu/drm/nouveau/nouveau_drm.c
··· 1094 1094 static struct drm_driver 1095 1095 driver_stub = { 1096 1096 .driver_features = 1097 - DRIVER_GEM | DRIVER_MODESET | DRIVER_PRIME | DRIVER_RENDER | 1098 - DRIVER_KMS_LEGACY_CONTEXT, 1097 + DRIVER_GEM | DRIVER_MODESET | DRIVER_PRIME | DRIVER_RENDER 1098 + #if defined(CONFIG_NOUVEAU_LEGACY_CTX_SUPPORT) 1099 + | DRIVER_KMS_LEGACY_CONTEXT 1100 + #endif 1101 + , 1099 1102 1100 1103 .open = nouveau_drm_open, 1101 1104 .postclose = nouveau_drm_postclose,
-1
drivers/gpu/drm/radeon/radeon_drv.h
··· 35 35 #include <linux/platform_device.h> 36 36 #include <drm/drm_legacy.h> 37 37 38 - #include <drm/ati_pcigart.h> 39 38 #include "radeon_family.h" 40 39 41 40 /* General customization:
+4 -2
include/drm/drm_auth.h
··· 50 50 * 51 51 * @refcount: Refcount for this master object. 52 52 * @dev: Link back to the DRM device 53 - * @lock: DRI1 lock information. 54 53 * @driver_priv: Pointer to driver-private information. 55 54 * @lessor: Lease holder 56 55 * @lessee_id: id for lessees. Owners always have id 0 ··· 79 80 * &drm_device.master_mutex. 80 81 */ 81 82 struct idr magic_map; 82 - struct drm_lock_data lock; 83 83 void *driver_priv; 84 84 85 85 /* Tree of display resource leases, each of which is a drm_master struct ··· 93 95 struct list_head lessees; 94 96 struct idr leases; 95 97 struct idr lessee_idr; 98 + /* private: */ 99 + #if IS_ENABLED(CONFIG_DRM_LEGACY) 100 + struct drm_lock_data lock; 101 + #endif 96 102 }; 97 103 98 104 struct drm_master *drm_master_get(struct drm_master *master);
+2 -1
include/drm/drm_device.h
··· 306 306 307 307 /* Everything below here is for legacy driver, never use! */ 308 308 /* private: */ 309 - 309 + #if IS_ENABLED(CONFIG_DRM_LEGACY) 310 310 /* Context handle management - linked list of context handles */ 311 311 struct list_head ctxlist; 312 312 ··· 353 353 354 354 /* Scatter gather memory */ 355 355 struct drm_sg_mem *sg; 356 + #endif 356 357 }; 357 358 358 359 #endif
+2
include/drm/drm_file.h
··· 335 335 struct drm_prime_file_private prime; 336 336 337 337 /* private: */ 338 + #if IS_ENABLED(CONFIG_DRM_LEGACY) 338 339 unsigned long lock_count; /* DRI1 legacy lock count */ 340 + #endif 339 341 }; 340 342 341 343 /**
-2
include/drm/drm_legacy.h
··· 162 162 struct drm_local_map *drm_legacy_findmap(struct drm_device *dev, unsigned int token); 163 163 void drm_legacy_rmmap(struct drm_device *d, struct drm_local_map *map); 164 164 int drm_legacy_rmmap_locked(struct drm_device *d, struct drm_local_map *map); 165 - void drm_legacy_master_rmmaps(struct drm_device *dev, 166 - struct drm_master *master); 167 165 struct drm_local_map *drm_legacy_getsarea(struct drm_device *dev); 168 166 int drm_legacy_mmap(struct file *filp, struct vm_area_struct *vma); 169 167