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

drm: Mark AGP implementation and ioctls as legacy

Only UMs drivers use DRM's core AGP code and ioctls. Mark the icotls
as legacy. Add the _legacy_ infix to all AGP functions. Move the
declarations to the public and internal legacy header files. The agp
field in struct drm_device is now located in the structure's legacy
section. Adapt drivers to the changes.

AGP code now depends on CONFIG_DRM_LEGACY.

Signed-off-by: Thomas Zimmermann <tzimmermann@suse.de>
Reviewed-by: Alex Deucher <alexander.deucher@amd.com>
Acked-by: Christian König <christian.koenig@amd.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20210507185709.22797-5-tzimmermann@suse.de

Thomas Zimmermann 04dfe19a 6bff2279

+198 -210
+3 -3
drivers/gpu/drm/Makefile
··· 20 20 drm_client_modeset.o drm_atomic_uapi.o drm_hdcp.o \ 21 21 drm_managed.o drm_vblank_work.o 22 22 23 - drm-$(CONFIG_DRM_LEGACY) += drm_bufs.o drm_context.o drm_dma.o drm_legacy_misc.o drm_lock.o \ 24 - drm_memory.o drm_scatter.o drm_vm.o 23 + drm-$(CONFIG_DRM_LEGACY) += drm_agpsupport.o drm_bufs.o drm_context.o drm_dma.o \ 24 + drm_legacy_misc.o drm_lock.o drm_memory.o drm_scatter.o \ 25 + drm_vm.o 25 26 drm-$(CONFIG_DRM_LIB_RANDOM) += lib/drm_random.o 26 27 drm-$(CONFIG_COMPAT) += drm_ioc32.o 27 28 drm-$(CONFIG_DRM_GEM_CMA_HELPER) += drm_gem_cma_helper.o 28 29 drm-$(CONFIG_DRM_GEM_SHMEM_HELPER) += drm_gem_shmem_helper.o 29 30 drm-$(CONFIG_DRM_PANEL) += drm_panel.o 30 31 drm-$(CONFIG_OF) += drm_of.o 31 - drm-$(CONFIG_AGP) += drm_agpsupport.o 32 32 drm-$(CONFIG_PCI) += drm_pci.o 33 33 drm-$(CONFIG_DEBUG_FS) += drm_debugfs.o drm_debugfs_crc.o 34 34 drm-$(CONFIG_DRM_LOAD_EDID_FIRMWARE) += drm_edid_load.o
+51 -48
drivers/gpu/drm/drm_agpsupport.c
··· 37 37 38 38 #include <asm/agp.h> 39 39 40 - #include <drm/drm_agpsupport.h> 41 40 #include <drm/drm_device.h> 42 41 #include <drm/drm_drv.h> 43 42 #include <drm/drm_file.h> 44 43 #include <drm/drm_print.h> 45 44 46 45 #include "drm_legacy.h" 46 + 47 + #if IS_ENABLED(CONFIG_AGP) 47 48 48 49 /* 49 50 * Get AGP information. ··· 54 53 * Verifies the AGP device has been initialized and acquired and fills in the 55 54 * drm_agp_info structure with the information in drm_agp_head::agp_info. 56 55 */ 57 - int drm_agp_info(struct drm_device *dev, struct drm_agp_info *info) 56 + int drm_legacy_agp_info(struct drm_device *dev, struct drm_agp_info *info) 58 57 { 59 58 struct agp_kern_info *kern; 60 59 ··· 74 73 75 74 return 0; 76 75 } 77 - EXPORT_SYMBOL(drm_agp_info); 76 + EXPORT_SYMBOL(drm_legacy_agp_info); 78 77 79 - int drm_agp_info_ioctl(struct drm_device *dev, void *data, 80 - struct drm_file *file_priv) 78 + int drm_legacy_agp_info_ioctl(struct drm_device *dev, void *data, 79 + struct drm_file *file_priv) 81 80 { 82 81 struct drm_agp_info *info = data; 83 82 int err; 84 83 85 - err = drm_agp_info(dev, info); 84 + err = drm_legacy_agp_info(dev, info); 86 85 if (err) 87 86 return err; 88 87 ··· 98 97 * Verifies the AGP device hasn't been acquired before and calls 99 98 * \c agp_backend_acquire. 100 99 */ 101 - int drm_agp_acquire(struct drm_device *dev) 100 + int drm_legacy_agp_acquire(struct drm_device *dev) 102 101 { 103 102 struct pci_dev *pdev = to_pci_dev(dev->dev); 104 103 ··· 112 111 dev->agp->acquired = 1; 113 112 return 0; 114 113 } 115 - EXPORT_SYMBOL(drm_agp_acquire); 114 + EXPORT_SYMBOL(drm_legacy_agp_acquire); 116 115 117 116 /* 118 117 * Acquire the AGP device (ioctl). ··· 122 121 * Verifies the AGP device hasn't been acquired before and calls 123 122 * \c agp_backend_acquire. 124 123 */ 125 - int drm_agp_acquire_ioctl(struct drm_device *dev, void *data, 126 - struct drm_file *file_priv) 124 + int drm_legacy_agp_acquire_ioctl(struct drm_device *dev, void *data, 125 + struct drm_file *file_priv) 127 126 { 128 - return drm_agp_acquire((struct drm_device *) file_priv->minor->dev); 127 + return drm_legacy_agp_acquire((struct drm_device *)file_priv->minor->dev); 129 128 } 130 129 131 130 /* ··· 136 135 * 137 136 * Verifies the AGP device has been acquired and calls \c agp_backend_release. 138 137 */ 139 - int drm_agp_release(struct drm_device *dev) 138 + int drm_legacy_agp_release(struct drm_device *dev) 140 139 { 141 140 if (!dev->agp || !dev->agp->acquired) 142 141 return -EINVAL; ··· 144 143 dev->agp->acquired = 0; 145 144 return 0; 146 145 } 147 - EXPORT_SYMBOL(drm_agp_release); 146 + EXPORT_SYMBOL(drm_legacy_agp_release); 148 147 149 - int drm_agp_release_ioctl(struct drm_device *dev, void *data, 150 - struct drm_file *file_priv) 148 + int drm_legacy_agp_release_ioctl(struct drm_device *dev, void *data, 149 + struct drm_file *file_priv) 151 150 { 152 - return drm_agp_release(dev); 151 + return drm_legacy_agp_release(dev); 153 152 } 154 153 155 154 /* ··· 162 161 * Verifies the AGP device has been acquired but not enabled, and calls 163 162 * \c agp_enable. 164 163 */ 165 - int drm_agp_enable(struct drm_device *dev, struct drm_agp_mode mode) 164 + int drm_legacy_agp_enable(struct drm_device *dev, struct drm_agp_mode mode) 166 165 { 167 166 if (!dev->agp || !dev->agp->acquired) 168 167 return -EINVAL; ··· 172 171 dev->agp->enabled = 1; 173 172 return 0; 174 173 } 175 - EXPORT_SYMBOL(drm_agp_enable); 174 + EXPORT_SYMBOL(drm_legacy_agp_enable); 176 175 177 - int drm_agp_enable_ioctl(struct drm_device *dev, void *data, 178 - struct drm_file *file_priv) 176 + int drm_legacy_agp_enable_ioctl(struct drm_device *dev, void *data, 177 + struct drm_file *file_priv) 179 178 { 180 179 struct drm_agp_mode *mode = data; 181 180 182 - return drm_agp_enable(dev, *mode); 181 + return drm_legacy_agp_enable(dev, *mode); 183 182 } 184 183 185 184 /* ··· 190 189 * Verifies the AGP device is present and has been acquired, allocates the 191 190 * memory via agp_allocate_memory() and creates a drm_agp_mem entry for it. 192 191 */ 193 - int drm_agp_alloc(struct drm_device *dev, struct drm_agp_buffer *request) 192 + int drm_legacy_agp_alloc(struct drm_device *dev, struct drm_agp_buffer *request) 194 193 { 195 194 struct drm_agp_mem *entry; 196 195 struct agp_memory *memory; ··· 222 221 223 222 return 0; 224 223 } 225 - EXPORT_SYMBOL(drm_agp_alloc); 224 + EXPORT_SYMBOL(drm_legacy_agp_alloc); 226 225 227 226 228 - int drm_agp_alloc_ioctl(struct drm_device *dev, void *data, 227 + int drm_legacy_agp_alloc_ioctl(struct drm_device *dev, void *data, 229 228 struct drm_file *file_priv) 230 229 { 231 230 struct drm_agp_buffer *request = data; 232 231 233 - return drm_agp_alloc(dev, request); 232 + return drm_legacy_agp_alloc(dev, request); 234 233 } 235 234 236 235 /* ··· 242 241 * 243 242 * Walks through drm_agp_head::memory until finding a matching handle. 244 243 */ 245 - static struct drm_agp_mem *drm_agp_lookup_entry(struct drm_device *dev, 246 - unsigned long handle) 244 + static struct drm_agp_mem *drm_legacy_agp_lookup_entry(struct drm_device *dev, 245 + unsigned long handle) 247 246 { 248 247 struct drm_agp_mem *entry; 249 248 ··· 262 261 * Verifies the AGP device is present and acquired, looks-up the AGP memory 263 262 * entry and passes it to the unbind_agp() function. 264 263 */ 265 - int drm_agp_unbind(struct drm_device *dev, struct drm_agp_binding *request) 264 + int drm_legacy_agp_unbind(struct drm_device *dev, struct drm_agp_binding *request) 266 265 { 267 266 struct drm_agp_mem *entry; 268 267 int ret; 269 268 270 269 if (!dev->agp || !dev->agp->acquired) 271 270 return -EINVAL; 272 - entry = drm_agp_lookup_entry(dev, request->handle); 271 + entry = drm_legacy_agp_lookup_entry(dev, request->handle); 273 272 if (!entry || !entry->bound) 274 273 return -EINVAL; 275 274 ret = agp_unbind_memory(entry->memory); ··· 277 276 entry->bound = 0; 278 277 return ret; 279 278 } 280 - EXPORT_SYMBOL(drm_agp_unbind); 279 + EXPORT_SYMBOL(drm_legacy_agp_unbind); 281 280 282 281 283 - int drm_agp_unbind_ioctl(struct drm_device *dev, void *data, 284 - struct drm_file *file_priv) 282 + int drm_legacy_agp_unbind_ioctl(struct drm_device *dev, void *data, 283 + struct drm_file *file_priv) 285 284 { 286 285 struct drm_agp_binding *request = data; 287 286 288 - return drm_agp_unbind(dev, request); 287 + return drm_legacy_agp_unbind(dev, request); 289 288 } 290 289 291 290 /* ··· 297 296 * is currently bound into the GATT. Looks-up the AGP memory entry and passes 298 297 * it to bind_agp() function. 299 298 */ 300 - int drm_agp_bind(struct drm_device *dev, struct drm_agp_binding *request) 299 + int drm_legacy_agp_bind(struct drm_device *dev, struct drm_agp_binding *request) 301 300 { 302 301 struct drm_agp_mem *entry; 303 302 int retcode; ··· 305 304 306 305 if (!dev->agp || !dev->agp->acquired) 307 306 return -EINVAL; 308 - entry = drm_agp_lookup_entry(dev, request->handle); 307 + entry = drm_legacy_agp_lookup_entry(dev, request->handle); 309 308 if (!entry || entry->bound) 310 309 return -EINVAL; 311 310 page = DIV_ROUND_UP(request->offset, PAGE_SIZE); ··· 317 316 dev->agp->base, entry->bound); 318 317 return 0; 319 318 } 320 - EXPORT_SYMBOL(drm_agp_bind); 319 + EXPORT_SYMBOL(drm_legacy_agp_bind); 321 320 322 321 323 - int drm_agp_bind_ioctl(struct drm_device *dev, void *data, 324 - struct drm_file *file_priv) 322 + int drm_legacy_agp_bind_ioctl(struct drm_device *dev, void *data, 323 + struct drm_file *file_priv) 325 324 { 326 325 struct drm_agp_binding *request = data; 327 326 328 - return drm_agp_bind(dev, request); 327 + return drm_legacy_agp_bind(dev, request); 329 328 } 330 329 331 330 /* ··· 338 337 * unbind_agp(). Frees it via free_agp() as well as the entry itself 339 338 * and unlinks from the doubly linked list it's inserted in. 340 339 */ 341 - int drm_agp_free(struct drm_device *dev, struct drm_agp_buffer *request) 340 + int drm_legacy_agp_free(struct drm_device *dev, struct drm_agp_buffer *request) 342 341 { 343 342 struct drm_agp_mem *entry; 344 343 345 344 if (!dev->agp || !dev->agp->acquired) 346 345 return -EINVAL; 347 - entry = drm_agp_lookup_entry(dev, request->handle); 346 + entry = drm_legacy_agp_lookup_entry(dev, request->handle); 348 347 if (!entry) 349 348 return -EINVAL; 350 349 if (entry->bound) ··· 356 355 kfree(entry); 357 356 return 0; 358 357 } 359 - EXPORT_SYMBOL(drm_agp_free); 358 + EXPORT_SYMBOL(drm_legacy_agp_free); 360 359 361 360 362 - int drm_agp_free_ioctl(struct drm_device *dev, void *data, 363 - struct drm_file *file_priv) 361 + int drm_legacy_agp_free_ioctl(struct drm_device *dev, void *data, 362 + struct drm_file *file_priv) 364 363 { 365 364 struct drm_agp_buffer *request = data; 366 365 367 - return drm_agp_free(dev, request); 366 + return drm_legacy_agp_free(dev, request); 368 367 } 369 368 370 369 /* ··· 379 378 * Note that final cleanup of the kmalloced structure is directly done in 380 379 * drm_pci_agp_destroy. 381 380 */ 382 - struct drm_agp_head *drm_agp_init(struct drm_device *dev) 381 + struct drm_agp_head *drm_legacy_agp_init(struct drm_device *dev) 383 382 { 384 383 struct pci_dev *pdev = to_pci_dev(dev->dev); 385 384 struct drm_agp_head *head = NULL; ··· 410 409 return head; 411 410 } 412 411 /* Only exported for i810.ko */ 413 - EXPORT_SYMBOL(drm_agp_init); 412 + EXPORT_SYMBOL(drm_legacy_agp_init); 414 413 415 414 /** 416 415 * drm_legacy_agp_clear - Clear AGP resource list ··· 440 439 INIT_LIST_HEAD(&dev->agp->memory); 441 440 442 441 if (dev->agp->acquired) 443 - drm_agp_release(dev); 442 + drm_legacy_agp_release(dev); 444 443 445 444 dev->agp->acquired = 0; 446 445 dev->agp->enabled = 0; 447 446 } 447 + 448 + #endif
-1
drivers/gpu/drm/drm_bufs.c
··· 40 40 41 41 #include <asm/shmparam.h> 42 42 43 - #include <drm/drm_agpsupport.h> 44 43 #include <drm/drm_device.h> 45 44 #include <drm/drm_drv.h> 46 45 #include <drm/drm_file.h>
+9 -10
drivers/gpu/drm/drm_ioc32.c
··· 31 31 #include <linux/ratelimit.h> 32 32 #include <linux/export.h> 33 33 34 - #include <drm/drm_agpsupport.h> 35 34 #include <drm/drm_file.h> 36 35 #include <drm/drm_print.h> 37 36 ··· 618 619 } 619 620 #endif 620 621 622 + #if IS_ENABLED(CONFIG_DRM_LEGACY) 621 623 #if IS_ENABLED(CONFIG_AGP) 622 624 typedef struct drm_agp_mode32 { 623 625 u32 mode; /**< AGP mode */ ··· 633 633 if (get_user(mode.mode, &argp->mode)) 634 634 return -EFAULT; 635 635 636 - return drm_ioctl_kernel(file, drm_agp_enable_ioctl, &mode, 636 + return drm_ioctl_kernel(file, drm_legacy_agp_enable_ioctl, &mode, 637 637 DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY); 638 638 } 639 639 ··· 659 659 struct drm_agp_info info; 660 660 int err; 661 661 662 - err = drm_ioctl_kernel(file, drm_agp_info_ioctl, &info, DRM_AUTH); 662 + err = drm_ioctl_kernel(file, drm_legacy_agp_info_ioctl, &info, DRM_AUTH); 663 663 if (err) 664 664 return err; 665 665 ··· 698 698 699 699 request.size = req32.size; 700 700 request.type = req32.type; 701 - err = drm_ioctl_kernel(file, drm_agp_alloc_ioctl, &request, 701 + err = drm_ioctl_kernel(file, drm_legacy_agp_alloc_ioctl, &request, 702 702 DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY); 703 703 if (err) 704 704 return err; ··· 706 706 req32.handle = request.handle; 707 707 req32.physical = request.physical; 708 708 if (copy_to_user(argp, &req32, sizeof(req32))) { 709 - drm_ioctl_kernel(file, drm_agp_free_ioctl, &request, 709 + drm_ioctl_kernel(file, drm_legacy_agp_free_ioctl, &request, 710 710 DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY); 711 711 return -EFAULT; 712 712 } ··· 723 723 if (get_user(request.handle, &argp->handle)) 724 724 return -EFAULT; 725 725 726 - return drm_ioctl_kernel(file, drm_agp_free_ioctl, &request, 726 + return drm_ioctl_kernel(file, drm_legacy_agp_free_ioctl, &request, 727 727 DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY); 728 728 } 729 729 ··· 744 744 745 745 request.handle = req32.handle; 746 746 request.offset = req32.offset; 747 - return drm_ioctl_kernel(file, drm_agp_bind_ioctl, &request, 747 + return drm_ioctl_kernel(file, drm_legacy_agp_bind_ioctl, &request, 748 748 DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY); 749 749 } 750 750 ··· 757 757 if (get_user(request.handle, &argp->handle)) 758 758 return -EFAULT; 759 759 760 - return drm_ioctl_kernel(file, drm_agp_unbind_ioctl, &request, 760 + return drm_ioctl_kernel(file, drm_legacy_agp_unbind_ioctl, &request, 761 761 DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY); 762 762 } 763 763 #endif /* CONFIG_AGP */ 764 764 765 - #if IS_ENABLED(CONFIG_DRM_LEGACY) 766 765 typedef struct drm_scatter_gather32 { 767 766 u32 size; /**< In bytes -- will round to page boundary */ 768 767 u32 handle; /**< Used for mapping / unmapping */ ··· 934 935 DRM_IOCTL32_DEF(DRM_IOCTL_GET_SAREA_CTX, compat_drm_getsareactx), 935 936 DRM_IOCTL32_DEF(DRM_IOCTL_RES_CTX, compat_drm_resctx), 936 937 DRM_IOCTL32_DEF(DRM_IOCTL_DMA, compat_drm_dma), 937 - #endif 938 938 #if IS_ENABLED(CONFIG_AGP) 939 939 DRM_IOCTL32_DEF(DRM_IOCTL_AGP_ENABLE, compat_drm_agp_enable), 940 940 DRM_IOCTL32_DEF(DRM_IOCTL_AGP_INFO, compat_drm_agp_info), ··· 941 943 DRM_IOCTL32_DEF(DRM_IOCTL_AGP_FREE, compat_drm_agp_free), 942 944 DRM_IOCTL32_DEF(DRM_IOCTL_AGP_BIND, compat_drm_agp_bind), 943 945 DRM_IOCTL32_DEF(DRM_IOCTL_AGP_UNBIND, compat_drm_agp_unbind), 946 + #endif 944 947 #endif 945 948 #if IS_ENABLED(CONFIG_DRM_LEGACY) 946 949 DRM_IOCTL32_DEF(DRM_IOCTL_SG_ALLOC, compat_drm_sg_alloc),
+15 -9
drivers/gpu/drm/drm_ioctl.c
··· 33 33 #include <linux/pci.h> 34 34 #include <linux/uaccess.h> 35 35 36 - #include <drm/drm_agpsupport.h> 37 36 #include <drm/drm_auth.h> 38 37 #include <drm/drm_crtc.h> 39 38 #include <drm/drm_drv.h> ··· 626 627 DRM_LEGACY_IOCTL_DEF(DRM_IOCTL_CONTROL, drm_legacy_irq_control, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 627 628 628 629 #if IS_ENABLED(CONFIG_AGP) 629 - DRM_IOCTL_DEF(DRM_IOCTL_AGP_ACQUIRE, drm_agp_acquire_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 630 - DRM_IOCTL_DEF(DRM_IOCTL_AGP_RELEASE, drm_agp_release_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 631 - DRM_IOCTL_DEF(DRM_IOCTL_AGP_ENABLE, drm_agp_enable_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 632 - DRM_IOCTL_DEF(DRM_IOCTL_AGP_INFO, drm_agp_info_ioctl, DRM_AUTH), 633 - DRM_IOCTL_DEF(DRM_IOCTL_AGP_ALLOC, drm_agp_alloc_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 634 - DRM_IOCTL_DEF(DRM_IOCTL_AGP_FREE, drm_agp_free_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 635 - DRM_IOCTL_DEF(DRM_IOCTL_AGP_BIND, drm_agp_bind_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 636 - DRM_IOCTL_DEF(DRM_IOCTL_AGP_UNBIND, drm_agp_unbind_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 630 + DRM_LEGACY_IOCTL_DEF(DRM_IOCTL_AGP_ACQUIRE, drm_legacy_agp_acquire_ioctl, 631 + DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 632 + DRM_LEGACY_IOCTL_DEF(DRM_IOCTL_AGP_RELEASE, drm_legacy_agp_release_ioctl, 633 + DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 634 + DRM_LEGACY_IOCTL_DEF(DRM_IOCTL_AGP_ENABLE, drm_legacy_agp_enable_ioctl, 635 + DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 636 + DRM_LEGACY_IOCTL_DEF(DRM_IOCTL_AGP_INFO, drm_legacy_agp_info_ioctl, DRM_AUTH), 637 + DRM_LEGACY_IOCTL_DEF(DRM_IOCTL_AGP_ALLOC, drm_legacy_agp_alloc_ioctl, 638 + DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 639 + DRM_LEGACY_IOCTL_DEF(DRM_IOCTL_AGP_FREE, drm_legacy_agp_free_ioctl, 640 + DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 641 + DRM_LEGACY_IOCTL_DEF(DRM_IOCTL_AGP_BIND, drm_legacy_agp_bind_ioctl, 642 + DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 643 + DRM_LEGACY_IOCTL_DEF(DRM_IOCTL_AGP_UNBIND, drm_legacy_agp_unbind_ioctl, 644 + DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), 637 645 #endif 638 646 639 647 DRM_LEGACY_IOCTL_DEF(DRM_IOCTL_SG_ALLOC, drm_legacy_sg_alloc, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
+24
drivers/gpu/drm/drm_legacy.h
··· 148 148 struct list_head head; 149 149 }; 150 150 151 + /* drm_agpsupport.c */ 152 + #if IS_ENABLED(CONFIG_DRM_LEGACY) && IS_ENABLED(CONFIG_AGP) 153 + void drm_legacy_agp_clear(struct drm_device *dev); 154 + 155 + int drm_legacy_agp_acquire_ioctl(struct drm_device *dev, void *data, 156 + struct drm_file *file_priv); 157 + int drm_legacy_agp_release_ioctl(struct drm_device *dev, void *data, 158 + struct drm_file *file_priv); 159 + int drm_legacy_agp_enable_ioctl(struct drm_device *dev, void *data, 160 + struct drm_file *file_priv); 161 + int drm_legacy_agp_info_ioctl(struct drm_device *dev, void *data, 162 + struct drm_file *file_priv); 163 + int drm_legacy_agp_alloc_ioctl(struct drm_device *dev, void *data, 164 + struct drm_file *file_priv); 165 + int drm_legacy_agp_free_ioctl(struct drm_device *dev, void *data, 166 + struct drm_file *file_priv); 167 + int drm_legacy_agp_unbind_ioctl(struct drm_device *dev, void *data, 168 + struct drm_file *file_priv); 169 + int drm_legacy_agp_bind_ioctl(struct drm_device *dev, void *data, 170 + struct drm_file *file_priv); 171 + #else 172 + static inline void drm_legacy_agp_clear(struct drm_device *dev) {} 173 + #endif 174 + 151 175 /* drm_lock.c */ 152 176 #if IS_ENABLED(CONFIG_DRM_LEGACY) 153 177 int drm_legacy_lock(struct drm_device *d, void *v, struct drm_file *f);
-1
drivers/gpu/drm/drm_legacy_misc.c
··· 33 33 * OTHER DEALINGS IN THE SOFTWARE. 34 34 */ 35 35 36 - #include <drm/drm_agpsupport.h> 37 36 #include <drm/drm_device.h> 38 37 #include <drm/drm_drv.h> 39 38 #include <drm/drm_irq.h>
-1
drivers/gpu/drm/drm_memory.c
··· 38 38 #include <linux/pci.h> 39 39 #include <linux/vmalloc.h> 40 40 41 - #include <drm/drm_agpsupport.h> 42 41 #include <drm/drm_cache.h> 43 42 #include <drm/drm_device.h> 44 43
+1 -2
drivers/gpu/drm/drm_pci.c
··· 30 30 #include <linux/slab.h> 31 31 32 32 #include <drm/drm.h> 33 - #include <drm/drm_agpsupport.h> 34 33 #include <drm/drm_drv.h> 35 34 #include <drm/drm_print.h> 36 35 ··· 134 135 { 135 136 if (drm_core_check_feature(dev, DRIVER_USE_AGP)) { 136 137 if (pci_find_capability(to_pci_dev(dev->dev), PCI_CAP_ID_AGP)) 137 - dev->agp = drm_agp_init(dev); 138 + dev->agp = drm_legacy_agp_init(dev); 138 139 if (dev->agp) { 139 140 dev->agp->agp_mtrr = arch_phys_wc_add( 140 141 dev->agp->agp_info.aper_base,
-2
drivers/gpu/drm/drm_vm.c
··· 45 45 #endif 46 46 #include <linux/mem_encrypt.h> 47 47 48 - 49 - #include <drm/drm_agpsupport.h> 50 48 #include <drm/drm_device.h> 51 49 #include <drm/drm_drv.h> 52 50 #include <drm/drm_file.h>
+1 -2
drivers/gpu/drm/i810/i810_dma.c
··· 34 34 #include <linux/mman.h> 35 35 #include <linux/pci.h> 36 36 37 - #include <drm/drm_agpsupport.h> 38 37 #include <drm/drm_device.h> 39 38 #include <drm/drm_drv.h> 40 39 #include <drm/drm_file.h> ··· 1198 1199 { 1199 1200 struct pci_dev *pdev = to_pci_dev(dev->dev); 1200 1201 1201 - dev->agp = drm_agp_init(dev); 1202 + dev->agp = drm_legacy_agp_init(dev); 1202 1203 if (dev->agp) { 1203 1204 dev->agp->agp_mtrr = arch_phys_wc_add( 1204 1205 dev->agp->agp_info.aper_base,
+8 -8
drivers/gpu/drm/mga/mga_dma.c
··· 469 469 struct drm_agp_binding bind_req; 470 470 471 471 /* Acquire AGP. */ 472 - err = drm_agp_acquire(dev); 472 + err = drm_legacy_agp_acquire(dev); 473 473 if (err) { 474 474 DRM_ERROR("Unable to acquire AGP: %d\n", err); 475 475 return err; 476 476 } 477 477 478 - err = drm_agp_info(dev, &info); 478 + err = drm_legacy_agp_info(dev, &info); 479 479 if (err) { 480 480 DRM_ERROR("Unable to get AGP info: %d\n", err); 481 481 return err; 482 482 } 483 483 484 484 mode.mode = (info.mode & ~0x07) | dma_bs->agp_mode; 485 - err = drm_agp_enable(dev, mode); 485 + err = drm_legacy_agp_enable(dev, mode); 486 486 if (err) { 487 487 DRM_ERROR("Unable to enable AGP (mode = 0x%lx)\n", mode.mode); 488 488 return err; ··· 502 502 /* Allocate and bind AGP memory. */ 503 503 agp_req.size = agp_size; 504 504 agp_req.type = 0; 505 - err = drm_agp_alloc(dev, &agp_req); 505 + err = drm_legacy_agp_alloc(dev, &agp_req); 506 506 if (err) { 507 507 dev_priv->agp_size = 0; 508 508 DRM_ERROR("Unable to allocate %uMB AGP memory\n", ··· 515 515 516 516 bind_req.handle = agp_req.handle; 517 517 bind_req.offset = 0; 518 - err = drm_agp_bind(dev, &bind_req); 518 + err = drm_legacy_agp_bind(dev, &bind_req); 519 519 if (err) { 520 520 DRM_ERROR("Unable to bind AGP memory: %d\n", err); 521 521 return err; ··· 972 972 struct drm_agp_buffer free_req; 973 973 974 974 unbind_req.handle = dev_priv->agp_handle; 975 - drm_agp_unbind(dev, &unbind_req); 975 + drm_legacy_agp_unbind(dev, &unbind_req); 976 976 977 977 free_req.handle = dev_priv->agp_handle; 978 - drm_agp_free(dev, &free_req); 978 + drm_legacy_agp_free(dev, &free_req); 979 979 980 980 dev_priv->agp_textures = NULL; 981 981 dev_priv->agp_size = 0; ··· 983 983 } 984 984 985 985 if ((dev->agp != NULL) && dev->agp->acquired) 986 - err = drm_agp_release(dev); 986 + err = drm_legacy_agp_release(dev); 987 987 #endif 988 988 } 989 989
-1
drivers/gpu/drm/mga/mga_drv.h
··· 35 35 #include <linux/pci.h> 36 36 #include <linux/slab.h> 37 37 38 - #include <drm/drm_agpsupport.h> 39 38 #include <drm/drm_device.h> 40 39 #include <drm/drm_file.h> 41 40 #include <drm/drm_ioctl.h>
+1 -1
drivers/gpu/drm/r128/r128_cce.c
··· 37 37 #include <linux/slab.h> 38 38 #include <linux/uaccess.h> 39 39 40 - #include <drm/drm_agpsupport.h> 41 40 #include <drm/drm_device.h> 42 41 #include <drm/drm_file.h> 43 42 #include <drm/drm_irq.h> 43 + #include <drm/drm_legacy.h> 44 44 #include <drm/drm_print.h> 45 45 #include <drm/r128_drm.h> 46 46
-1
drivers/gpu/drm/via/via_dma.c
··· 38 38 #include <linux/uaccess.h> 39 39 40 40 #include <drm/drm.h> 41 - #include <drm/drm_agpsupport.h> 42 41 #include <drm/drm_device.h> 43 42 #include <drm/drm_file.h> 44 43 #include <drm/via_drm.h>
-117
include/drm/drm_agpsupport.h
··· 1 - /* SPDX-License-Identifier: GPL-2.0 */ 2 - #ifndef _DRM_AGPSUPPORT_H_ 3 - #define _DRM_AGPSUPPORT_H_ 4 - 5 - #include <linux/agp_backend.h> 6 - #include <linux/kernel.h> 7 - #include <linux/list.h> 8 - #include <linux/mm.h> 9 - #include <linux/mutex.h> 10 - #include <linux/types.h> 11 - #include <uapi/drm/drm.h> 12 - 13 - struct drm_device; 14 - struct drm_file; 15 - 16 - struct drm_agp_head { 17 - struct agp_kern_info agp_info; 18 - struct list_head memory; 19 - unsigned long mode; 20 - struct agp_bridge_data *bridge; 21 - int enabled; 22 - int acquired; 23 - unsigned long base; 24 - int agp_mtrr; 25 - int cant_use_aperture; 26 - unsigned long page_mask; 27 - }; 28 - 29 - #if IS_ENABLED(CONFIG_AGP) 30 - 31 - struct drm_agp_head *drm_agp_init(struct drm_device *dev); 32 - void drm_legacy_agp_clear(struct drm_device *dev); 33 - int drm_agp_acquire(struct drm_device *dev); 34 - int drm_agp_acquire_ioctl(struct drm_device *dev, void *data, 35 - struct drm_file *file_priv); 36 - int drm_agp_release(struct drm_device *dev); 37 - int drm_agp_release_ioctl(struct drm_device *dev, void *data, 38 - struct drm_file *file_priv); 39 - int drm_agp_enable(struct drm_device *dev, struct drm_agp_mode mode); 40 - int drm_agp_enable_ioctl(struct drm_device *dev, void *data, 41 - struct drm_file *file_priv); 42 - int drm_agp_info(struct drm_device *dev, struct drm_agp_info *info); 43 - int drm_agp_info_ioctl(struct drm_device *dev, void *data, 44 - struct drm_file *file_priv); 45 - int drm_agp_alloc(struct drm_device *dev, struct drm_agp_buffer *request); 46 - int drm_agp_alloc_ioctl(struct drm_device *dev, void *data, 47 - struct drm_file *file_priv); 48 - int drm_agp_free(struct drm_device *dev, struct drm_agp_buffer *request); 49 - int drm_agp_free_ioctl(struct drm_device *dev, void *data, 50 - struct drm_file *file_priv); 51 - int drm_agp_unbind(struct drm_device *dev, struct drm_agp_binding *request); 52 - int drm_agp_unbind_ioctl(struct drm_device *dev, void *data, 53 - struct drm_file *file_priv); 54 - int drm_agp_bind(struct drm_device *dev, struct drm_agp_binding *request); 55 - int drm_agp_bind_ioctl(struct drm_device *dev, void *data, 56 - struct drm_file *file_priv); 57 - 58 - #else /* CONFIG_AGP */ 59 - 60 - static inline struct drm_agp_head *drm_agp_init(struct drm_device *dev) 61 - { 62 - return NULL; 63 - } 64 - 65 - static inline void drm_legacy_agp_clear(struct drm_device *dev) 66 - { 67 - } 68 - 69 - static inline int drm_agp_acquire(struct drm_device *dev) 70 - { 71 - return -ENODEV; 72 - } 73 - 74 - static inline int drm_agp_release(struct drm_device *dev) 75 - { 76 - return -ENODEV; 77 - } 78 - 79 - static inline int drm_agp_enable(struct drm_device *dev, 80 - struct drm_agp_mode mode) 81 - { 82 - return -ENODEV; 83 - } 84 - 85 - static inline int drm_agp_info(struct drm_device *dev, 86 - struct drm_agp_info *info) 87 - { 88 - return -ENODEV; 89 - } 90 - 91 - static inline int drm_agp_alloc(struct drm_device *dev, 92 - struct drm_agp_buffer *request) 93 - { 94 - return -ENODEV; 95 - } 96 - 97 - static inline int drm_agp_free(struct drm_device *dev, 98 - struct drm_agp_buffer *request) 99 - { 100 - return -ENODEV; 101 - } 102 - 103 - static inline int drm_agp_unbind(struct drm_device *dev, 104 - struct drm_agp_binding *request) 105 - { 106 - return -ENODEV; 107 - } 108 - 109 - static inline int drm_agp_bind(struct drm_device *dev, 110 - struct drm_agp_binding *request) 111 - { 112 - return -ENODEV; 113 - } 114 - 115 - #endif /* CONFIG_AGP */ 116 - 117 - #endif /* _DRM_AGPSUPPORT_H_ */
+3 -3
include/drm/drm_device.h
··· 276 276 */ 277 277 spinlock_t event_lock; 278 278 279 - /** @agp: AGP data */ 280 - struct drm_agp_head *agp; 281 - 282 279 /** @num_crtcs: Number of CRTCs on this device */ 283 280 unsigned int num_crtcs; 284 281 ··· 322 325 /** @hose: PCI hose, only used on ALPHA platforms. */ 323 326 struct pci_controller *hose; 324 327 #endif 328 + 329 + /* AGP data */ 330 + struct drm_agp_head *agp; 325 331 326 332 /* Context handle management - linked list of context handles */ 327 333 struct list_head ctxlist;
+82
include/drm/drm_legacy.h
··· 33 33 * OTHER DEALINGS IN THE SOFTWARE. 34 34 */ 35 35 36 + #include <linux/agp_backend.h> 37 + 36 38 #include <drm/drm.h> 37 39 #include <drm/drm_auth.h> 38 40 #include <drm/drm_hashtab.h> ··· 225 223 { 226 224 } 227 225 226 + #endif 227 + 228 + /* 229 + * AGP Support 230 + */ 231 + 232 + struct drm_agp_head { 233 + struct agp_kern_info agp_info; 234 + struct list_head memory; 235 + unsigned long mode; 236 + struct agp_bridge_data *bridge; 237 + int enabled; 238 + int acquired; 239 + unsigned long base; 240 + int agp_mtrr; 241 + int cant_use_aperture; 242 + unsigned long page_mask; 243 + }; 244 + 245 + #if IS_ENABLED(CONFIG_DRM_LEGACY) && IS_ENABLED(CONFIG_AGP) 246 + struct drm_agp_head *drm_legacy_agp_init(struct drm_device *dev); 247 + int drm_legacy_agp_acquire(struct drm_device *dev); 248 + int drm_legacy_agp_release(struct drm_device *dev); 249 + int drm_legacy_agp_enable(struct drm_device *dev, struct drm_agp_mode mode); 250 + int drm_legacy_agp_info(struct drm_device *dev, struct drm_agp_info *info); 251 + int drm_legacy_agp_alloc(struct drm_device *dev, struct drm_agp_buffer *request); 252 + int drm_legacy_agp_free(struct drm_device *dev, struct drm_agp_buffer *request); 253 + int drm_legacy_agp_unbind(struct drm_device *dev, struct drm_agp_binding *request); 254 + int drm_legacy_agp_bind(struct drm_device *dev, struct drm_agp_binding *request); 255 + #else 256 + static inline struct drm_agp_head *drm_legacy_agp_init(struct drm_device *dev) 257 + { 258 + return NULL; 259 + } 260 + 261 + static inline int drm_legacy_agp_acquire(struct drm_device *dev) 262 + { 263 + return -ENODEV; 264 + } 265 + 266 + static inline int drm_legacy_agp_release(struct drm_device *dev) 267 + { 268 + return -ENODEV; 269 + } 270 + 271 + static inline int drm_legacy_agp_enable(struct drm_device *dev, 272 + struct drm_agp_mode mode) 273 + { 274 + return -ENODEV; 275 + } 276 + 277 + static inline int drm_legacy_agp_info(struct drm_device *dev, 278 + struct drm_agp_info *info) 279 + { 280 + return -ENODEV; 281 + } 282 + 283 + static inline int drm_legacy_agp_alloc(struct drm_device *dev, 284 + struct drm_agp_buffer *request) 285 + { 286 + return -ENODEV; 287 + } 288 + 289 + static inline int drm_legacy_agp_free(struct drm_device *dev, 290 + struct drm_agp_buffer *request) 291 + { 292 + return -ENODEV; 293 + } 294 + 295 + static inline int drm_legacy_agp_unbind(struct drm_device *dev, 296 + struct drm_agp_binding *request) 297 + { 298 + return -ENODEV; 299 + } 300 + 301 + static inline int drm_legacy_agp_bind(struct drm_device *dev, 302 + struct drm_agp_binding *request) 303 + { 304 + return -ENODEV; 305 + } 228 306 #endif 229 307 230 308 /* drm_memory.c */