Qian Cai | 45b2fda | 2019-07-15 09:42:53 -0400 | [diff] [blame] | 1 | /* |
Dave Airlie | d985c10 | 2006-01-02 21:32:48 +1100 | [diff] [blame] | 2 | * \file drm_agpsupport.c |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3 | * DRM support for AGP/GART backend |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 4 | * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 5 | * \author Rickard E. (Rik) Faith <faith@valinux.com> |
| 6 | * \author Gareth Hughes <gareth@valinux.com> |
| 7 | */ |
| 8 | |
| 9 | /* |
| 10 | * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas. |
| 11 | * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California. |
| 12 | * All Rights Reserved. |
| 13 | * |
| 14 | * Permission is hereby granted, free of charge, to any person obtaining a |
| 15 | * copy of this software and associated documentation files (the "Software"), |
| 16 | * to deal in the Software without restriction, including without limitation |
| 17 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| 18 | * and/or sell copies of the Software, and to permit persons to whom the |
| 19 | * Software is furnished to do so, subject to the following conditions: |
| 20 | * |
| 21 | * The above copyright notice and this permission notice (including the next |
| 22 | * paragraph) shall be included in all copies or substantial portions of the |
| 23 | * Software. |
| 24 | * |
| 25 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| 26 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 27 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| 28 | * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR |
| 29 | * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, |
| 30 | * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR |
| 31 | * OTHER DEALINGS IN THE SOFTWARE. |
| 32 | */ |
| 33 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 34 | #include <linux/module.h> |
Sam Ravnborg | 0500c04 | 2019-05-26 19:35:35 +0200 | [diff] [blame] | 35 | #include <linux/pci.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 36 | #include <linux/slab.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 37 | |
Thomas Zimmermann | eb185a3 | 2021-05-10 16:52:18 +0200 | [diff] [blame] | 38 | #if IS_ENABLED(CONFIG_AGP) |
Eric Anholt | 1bb88ed | 2009-01-15 01:16:25 -0800 | [diff] [blame] | 39 | #include <asm/agp.h> |
Thomas Zimmermann | eb185a3 | 2021-05-10 16:52:18 +0200 | [diff] [blame] | 40 | #endif |
Eric Anholt | 1bb88ed | 2009-01-15 01:16:25 -0800 | [diff] [blame] | 41 | |
Sam Ravnborg | 0500c04 | 2019-05-26 19:35:35 +0200 | [diff] [blame] | 42 | #include <drm/drm_device.h> |
| 43 | #include <drm/drm_drv.h> |
| 44 | #include <drm/drm_file.h> |
| 45 | #include <drm/drm_print.h> |
| 46 | |
| 47 | #include "drm_legacy.h" |
| 48 | |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 49 | #if IS_ENABLED(CONFIG_AGP) |
| 50 | |
Lee Jones | cec7638 | 2021-01-15 18:15:55 +0000 | [diff] [blame] | 51 | /* |
Dave Airlie | 7ab9840 | 2005-07-10 16:56:52 +1000 | [diff] [blame] | 52 | * Get AGP information. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 53 | * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 54 | * \return zero on success or a negative number on failure. |
| 55 | * |
| 56 | * Verifies the AGP device has been initialized and acquired and fills in the |
| 57 | * drm_agp_info structure with the information in drm_agp_head::agp_info. |
| 58 | */ |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 59 | int drm_legacy_agp_info(struct drm_device *dev, struct drm_agp_info *info) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 60 | { |
Daniel Vetter | d2e546b | 2013-12-11 11:34:40 +0100 | [diff] [blame] | 61 | struct agp_kern_info *kern; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 62 | |
| 63 | if (!dev->agp || !dev->agp->acquired) |
| 64 | return -EINVAL; |
| 65 | |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 66 | kern = &dev->agp->agp_info; |
Dave Airlie | 7ab9840 | 2005-07-10 16:56:52 +1000 | [diff] [blame] | 67 | info->agp_version_major = kern->version.major; |
| 68 | info->agp_version_minor = kern->version.minor; |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 69 | info->mode = kern->mode; |
| 70 | info->aperture_base = kern->aper_base; |
| 71 | info->aperture_size = kern->aper_size * 1024 * 1024; |
| 72 | info->memory_allowed = kern->max_memory << PAGE_SHIFT; |
| 73 | info->memory_used = kern->current_memory << PAGE_SHIFT; |
| 74 | info->id_vendor = kern->device->vendor; |
| 75 | info->id_device = kern->device->device; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 76 | |
Dave Airlie | 7ab9840 | 2005-07-10 16:56:52 +1000 | [diff] [blame] | 77 | return 0; |
| 78 | } |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 79 | EXPORT_SYMBOL(drm_legacy_agp_info); |
Dave Airlie | 7ab9840 | 2005-07-10 16:56:52 +1000 | [diff] [blame] | 80 | |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 81 | int drm_legacy_agp_info_ioctl(struct drm_device *dev, void *data, |
| 82 | struct drm_file *file_priv) |
Dave Airlie | 7ab9840 | 2005-07-10 16:56:52 +1000 | [diff] [blame] | 83 | { |
Eric Anholt | c153f45 | 2007-09-03 12:06:45 +1000 | [diff] [blame] | 84 | struct drm_agp_info *info = data; |
Dave Airlie | 7ab9840 | 2005-07-10 16:56:52 +1000 | [diff] [blame] | 85 | int err; |
| 86 | |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 87 | err = drm_legacy_agp_info(dev, info); |
Dave Airlie | 7ab9840 | 2005-07-10 16:56:52 +1000 | [diff] [blame] | 88 | if (err) |
| 89 | return err; |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 90 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 91 | return 0; |
| 92 | } |
| 93 | |
Lee Jones | cec7638 | 2021-01-15 18:15:55 +0000 | [diff] [blame] | 94 | /* |
Dave Airlie | 7ab9840 | 2005-07-10 16:56:52 +1000 | [diff] [blame] | 95 | * Acquire the AGP device. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 96 | * |
Dave Airlie | d985c10 | 2006-01-02 21:32:48 +1100 | [diff] [blame] | 97 | * \param dev DRM device that is to acquire AGP. |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 98 | * \return zero on success or a negative number on failure. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 99 | * |
| 100 | * Verifies the AGP device hasn't been acquired before and calls |
Dave Airlie | 7ab9840 | 2005-07-10 16:56:52 +1000 | [diff] [blame] | 101 | * \c agp_backend_acquire. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 102 | */ |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 103 | int drm_legacy_agp_acquire(struct drm_device *dev) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 104 | { |
Thomas Zimmermann | 36b73b0 | 2021-01-18 14:14:15 +0100 | [diff] [blame] | 105 | struct pci_dev *pdev = to_pci_dev(dev->dev); |
| 106 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 107 | if (!dev->agp) |
| 108 | return -ENODEV; |
| 109 | if (dev->agp->acquired) |
| 110 | return -EBUSY; |
Thomas Zimmermann | 36b73b0 | 2021-01-18 14:14:15 +0100 | [diff] [blame] | 111 | dev->agp->bridge = agp_backend_acquire(pdev); |
Meghana Madhyastha | 182e61d | 2017-09-14 13:40:49 +0530 | [diff] [blame] | 112 | if (!dev->agp->bridge) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 113 | return -ENODEV; |
| 114 | dev->agp->acquired = 1; |
| 115 | return 0; |
| 116 | } |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 117 | EXPORT_SYMBOL(drm_legacy_agp_acquire); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 118 | |
Lee Jones | cec7638 | 2021-01-15 18:15:55 +0000 | [diff] [blame] | 119 | /* |
Dave Airlie | 7ab9840 | 2005-07-10 16:56:52 +1000 | [diff] [blame] | 120 | * Acquire the AGP device (ioctl). |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 121 | * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 122 | * \return zero on success or a negative number on failure. |
| 123 | * |
Dave Airlie | 7ab9840 | 2005-07-10 16:56:52 +1000 | [diff] [blame] | 124 | * Verifies the AGP device hasn't been acquired before and calls |
| 125 | * \c agp_backend_acquire. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 126 | */ |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 127 | int drm_legacy_agp_acquire_ioctl(struct drm_device *dev, void *data, |
| 128 | struct drm_file *file_priv) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 129 | { |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 130 | return drm_legacy_agp_acquire((struct drm_device *)file_priv->minor->dev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 131 | } |
| 132 | |
Lee Jones | cec7638 | 2021-01-15 18:15:55 +0000 | [diff] [blame] | 133 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 134 | * Release the AGP device. |
| 135 | * |
Dave Airlie | d985c10 | 2006-01-02 21:32:48 +1100 | [diff] [blame] | 136 | * \param dev DRM device that is to release AGP. |
Dave Airlie | 7ab9840 | 2005-07-10 16:56:52 +1000 | [diff] [blame] | 137 | * \return zero on success or a negative number on failure. |
| 138 | * |
| 139 | * Verifies the AGP device has been acquired and calls \c agp_backend_release. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 140 | */ |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 141 | int drm_legacy_agp_release(struct drm_device *dev) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 142 | { |
Dave Airlie | 7ab9840 | 2005-07-10 16:56:52 +1000 | [diff] [blame] | 143 | if (!dev->agp || !dev->agp->acquired) |
| 144 | return -EINVAL; |
| 145 | agp_backend_release(dev->agp->bridge); |
| 146 | dev->agp->acquired = 0; |
| 147 | return 0; |
| 148 | } |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 149 | EXPORT_SYMBOL(drm_legacy_agp_release); |
Dave Airlie | 7ab9840 | 2005-07-10 16:56:52 +1000 | [diff] [blame] | 150 | |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 151 | int drm_legacy_agp_release_ioctl(struct drm_device *dev, void *data, |
| 152 | struct drm_file *file_priv) |
Dave Airlie | 7ab9840 | 2005-07-10 16:56:52 +1000 | [diff] [blame] | 153 | { |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 154 | return drm_legacy_agp_release(dev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 155 | } |
| 156 | |
Lee Jones | cec7638 | 2021-01-15 18:15:55 +0000 | [diff] [blame] | 157 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 158 | * Enable the AGP bus. |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 159 | * |
Dave Airlie | 7ab9840 | 2005-07-10 16:56:52 +1000 | [diff] [blame] | 160 | * \param dev DRM device that has previously acquired AGP. |
| 161 | * \param mode Requested AGP mode. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 162 | * \return zero on success or a negative number on failure. |
| 163 | * |
| 164 | * Verifies the AGP device has been acquired but not enabled, and calls |
Dave Airlie | 7ab9840 | 2005-07-10 16:56:52 +1000 | [diff] [blame] | 165 | * \c agp_enable. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 166 | */ |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 167 | int drm_legacy_agp_enable(struct drm_device *dev, struct drm_agp_mode mode) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 168 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 169 | if (!dev->agp || !dev->agp->acquired) |
| 170 | return -EINVAL; |
| 171 | |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 172 | dev->agp->mode = mode.mode; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 173 | agp_enable(dev->agp->bridge, mode.mode); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 174 | dev->agp->enabled = 1; |
| 175 | return 0; |
| 176 | } |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 177 | EXPORT_SYMBOL(drm_legacy_agp_enable); |
Dave Airlie | 7ab9840 | 2005-07-10 16:56:52 +1000 | [diff] [blame] | 178 | |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 179 | int drm_legacy_agp_enable_ioctl(struct drm_device *dev, void *data, |
| 180 | struct drm_file *file_priv) |
Dave Airlie | 7ab9840 | 2005-07-10 16:56:52 +1000 | [diff] [blame] | 181 | { |
Eric Anholt | c153f45 | 2007-09-03 12:06:45 +1000 | [diff] [blame] | 182 | struct drm_agp_mode *mode = data; |
Dave Airlie | 7ab9840 | 2005-07-10 16:56:52 +1000 | [diff] [blame] | 183 | |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 184 | return drm_legacy_agp_enable(dev, *mode); |
Dave Airlie | 7ab9840 | 2005-07-10 16:56:52 +1000 | [diff] [blame] | 185 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 186 | |
Lee Jones | cec7638 | 2021-01-15 18:15:55 +0000 | [diff] [blame] | 187 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 188 | * Allocate AGP memory. |
| 189 | * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 190 | * \return zero on success or a negative number on failure. |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 191 | * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 192 | * Verifies the AGP device is present and has been acquired, allocates the |
Daniel Vetter | 89c3726 | 2010-08-23 22:53:36 +0200 | [diff] [blame] | 193 | * memory via agp_allocate_memory() and creates a drm_agp_mem entry for it. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 194 | */ |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 195 | int drm_legacy_agp_alloc(struct drm_device *dev, struct drm_agp_buffer *request) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 196 | { |
Dave Airlie | 5591051 | 2007-07-11 16:53:40 +1000 | [diff] [blame] | 197 | struct drm_agp_mem *entry; |
Daniel Vetter | d2e546b | 2013-12-11 11:34:40 +0100 | [diff] [blame] | 198 | struct agp_memory *memory; |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 199 | unsigned long pages; |
| 200 | u32 type; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 201 | |
| 202 | if (!dev->agp || !dev->agp->acquired) |
| 203 | return -EINVAL; |
Meghana Madhyastha | 182e61d | 2017-09-14 13:40:49 +0530 | [diff] [blame] | 204 | entry = kzalloc(sizeof(*entry), GFP_KERNEL); |
| 205 | if (!entry) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 206 | return -ENOMEM; |
| 207 | |
Wambui Karuga | b8c8a85 | 2019-10-25 12:49:07 +0300 | [diff] [blame] | 208 | pages = DIV_ROUND_UP(request->size, PAGE_SIZE); |
Dave Airlie | efa5839 | 2005-11-11 22:33:39 +1100 | [diff] [blame] | 209 | type = (u32) request->type; |
Meghana Madhyastha | 182e61d | 2017-09-14 13:40:49 +0530 | [diff] [blame] | 210 | memory = agp_allocate_memory(dev->agp->bridge, pages, type); |
| 211 | if (!memory) { |
Eric Anholt | 9a298b2 | 2009-03-24 12:23:04 -0700 | [diff] [blame] | 212 | kfree(entry); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 213 | return -ENOMEM; |
| 214 | } |
| 215 | |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 216 | entry->handle = (unsigned long)memory->key + 1; |
| 217 | entry->memory = memory; |
| 218 | entry->bound = 0; |
| 219 | entry->pages = pages; |
Dave Airlie | bd1b331 | 2007-05-26 05:01:51 +1000 | [diff] [blame] | 220 | list_add(&entry->head, &dev->agp->memory); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 221 | |
Dave Airlie | efa5839 | 2005-11-11 22:33:39 +1100 | [diff] [blame] | 222 | request->handle = entry->handle; |
| 223 | request->physical = memory->physical; |
| 224 | |
| 225 | return 0; |
| 226 | } |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 227 | EXPORT_SYMBOL(drm_legacy_agp_alloc); |
Dave Airlie | efa5839 | 2005-11-11 22:33:39 +1100 | [diff] [blame] | 228 | |
Eric Anholt | c153f45 | 2007-09-03 12:06:45 +1000 | [diff] [blame] | 229 | |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 230 | int drm_legacy_agp_alloc_ioctl(struct drm_device *dev, void *data, |
Eric Anholt | c153f45 | 2007-09-03 12:06:45 +1000 | [diff] [blame] | 231 | struct drm_file *file_priv) |
Dave Airlie | efa5839 | 2005-11-11 22:33:39 +1100 | [diff] [blame] | 232 | { |
Eric Anholt | c153f45 | 2007-09-03 12:06:45 +1000 | [diff] [blame] | 233 | struct drm_agp_buffer *request = data; |
Dave Airlie | efa5839 | 2005-11-11 22:33:39 +1100 | [diff] [blame] | 234 | |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 235 | return drm_legacy_agp_alloc(dev, request); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 236 | } |
| 237 | |
Lee Jones | cec7638 | 2021-01-15 18:15:55 +0000 | [diff] [blame] | 238 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 239 | * Search for the AGP memory entry associated with a handle. |
| 240 | * |
| 241 | * \param dev DRM device structure. |
| 242 | * \param handle AGP memory handle. |
| 243 | * \return pointer to the drm_agp_mem structure associated with \p handle. |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 244 | * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 245 | * Walks through drm_agp_head::memory until finding a matching handle. |
| 246 | */ |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 247 | static struct drm_agp_mem *drm_legacy_agp_lookup_entry(struct drm_device *dev, |
| 248 | unsigned long handle) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 249 | { |
Dave Airlie | 5591051 | 2007-07-11 16:53:40 +1000 | [diff] [blame] | 250 | struct drm_agp_mem *entry; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 251 | |
Dave Airlie | bd1b331 | 2007-05-26 05:01:51 +1000 | [diff] [blame] | 252 | list_for_each_entry(entry, &dev->agp->memory, head) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 253 | if (entry->handle == handle) |
| 254 | return entry; |
| 255 | } |
| 256 | return NULL; |
| 257 | } |
| 258 | |
Lee Jones | cec7638 | 2021-01-15 18:15:55 +0000 | [diff] [blame] | 259 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 260 | * Unbind AGP memory from the GATT (ioctl). |
| 261 | * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 262 | * \return zero on success or a negative number on failure. |
| 263 | * |
| 264 | * Verifies the AGP device is present and acquired, looks-up the AGP memory |
| 265 | * entry and passes it to the unbind_agp() function. |
| 266 | */ |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 267 | int drm_legacy_agp_unbind(struct drm_device *dev, struct drm_agp_binding *request) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 268 | { |
Dave Airlie | 5591051 | 2007-07-11 16:53:40 +1000 | [diff] [blame] | 269 | struct drm_agp_mem *entry; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 270 | int ret; |
| 271 | |
| 272 | if (!dev->agp || !dev->agp->acquired) |
| 273 | return -EINVAL; |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 274 | entry = drm_legacy_agp_lookup_entry(dev, request->handle); |
Meghana Madhyastha | 182e61d | 2017-09-14 13:40:49 +0530 | [diff] [blame] | 275 | if (!entry || !entry->bound) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 276 | return -EINVAL; |
Thomas Zimmermann | ff28a9f | 2021-01-12 09:10:30 +0100 | [diff] [blame] | 277 | ret = agp_unbind_memory(entry->memory); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 278 | if (ret == 0) |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 279 | entry->bound = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 280 | return ret; |
| 281 | } |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 282 | EXPORT_SYMBOL(drm_legacy_agp_unbind); |
Dave Airlie | efa5839 | 2005-11-11 22:33:39 +1100 | [diff] [blame] | 283 | |
Eric Anholt | c153f45 | 2007-09-03 12:06:45 +1000 | [diff] [blame] | 284 | |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 285 | int drm_legacy_agp_unbind_ioctl(struct drm_device *dev, void *data, |
| 286 | struct drm_file *file_priv) |
Dave Airlie | efa5839 | 2005-11-11 22:33:39 +1100 | [diff] [blame] | 287 | { |
Eric Anholt | c153f45 | 2007-09-03 12:06:45 +1000 | [diff] [blame] | 288 | struct drm_agp_binding *request = data; |
Dave Airlie | efa5839 | 2005-11-11 22:33:39 +1100 | [diff] [blame] | 289 | |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 290 | return drm_legacy_agp_unbind(dev, request); |
Dave Airlie | efa5839 | 2005-11-11 22:33:39 +1100 | [diff] [blame] | 291 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 292 | |
Lee Jones | cec7638 | 2021-01-15 18:15:55 +0000 | [diff] [blame] | 293 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 294 | * Bind AGP memory into the GATT (ioctl) |
| 295 | * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 296 | * \return zero on success or a negative number on failure. |
| 297 | * |
| 298 | * Verifies the AGP device is present and has been acquired and that no memory |
| 299 | * is currently bound into the GATT. Looks-up the AGP memory entry and passes |
| 300 | * it to bind_agp() function. |
| 301 | */ |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 302 | int drm_legacy_agp_bind(struct drm_device *dev, struct drm_agp_binding *request) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 303 | { |
Dave Airlie | 5591051 | 2007-07-11 16:53:40 +1000 | [diff] [blame] | 304 | struct drm_agp_mem *entry; |
Dave Airlie | b5e89ed | 2005-09-25 14:28:13 +1000 | [diff] [blame] | 305 | int retcode; |
| 306 | int page; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 307 | |
| 308 | if (!dev->agp || !dev->agp->acquired) |
| 309 | return -EINVAL; |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 310 | entry = drm_legacy_agp_lookup_entry(dev, request->handle); |
Meghana Madhyastha | 182e61d | 2017-09-14 13:40:49 +0530 | [diff] [blame] | 311 | if (!entry || entry->bound) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 312 | return -EINVAL; |
Wambui Karuga | b8c8a85 | 2019-10-25 12:49:07 +0300 | [diff] [blame] | 313 | page = DIV_ROUND_UP(request->offset, PAGE_SIZE); |
Thomas Zimmermann | ff28a9f | 2021-01-12 09:10:30 +0100 | [diff] [blame] | 314 | retcode = agp_bind_memory(entry->memory, page); |
Meghana Madhyastha | 182e61d | 2017-09-14 13:40:49 +0530 | [diff] [blame] | 315 | if (retcode) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 316 | return retcode; |
| 317 | entry->bound = dev->agp->base + (page << PAGE_SHIFT); |
| 318 | DRM_DEBUG("base = 0x%lx entry->bound = 0x%lx\n", |
| 319 | dev->agp->base, entry->bound); |
| 320 | return 0; |
| 321 | } |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 322 | EXPORT_SYMBOL(drm_legacy_agp_bind); |
Dave Airlie | efa5839 | 2005-11-11 22:33:39 +1100 | [diff] [blame] | 323 | |
Eric Anholt | c153f45 | 2007-09-03 12:06:45 +1000 | [diff] [blame] | 324 | |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 325 | int drm_legacy_agp_bind_ioctl(struct drm_device *dev, void *data, |
| 326 | struct drm_file *file_priv) |
Dave Airlie | efa5839 | 2005-11-11 22:33:39 +1100 | [diff] [blame] | 327 | { |
Eric Anholt | c153f45 | 2007-09-03 12:06:45 +1000 | [diff] [blame] | 328 | struct drm_agp_binding *request = data; |
Dave Airlie | efa5839 | 2005-11-11 22:33:39 +1100 | [diff] [blame] | 329 | |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 330 | return drm_legacy_agp_bind(dev, request); |
Dave Airlie | efa5839 | 2005-11-11 22:33:39 +1100 | [diff] [blame] | 331 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 332 | |
Lee Jones | cec7638 | 2021-01-15 18:15:55 +0000 | [diff] [blame] | 333 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 334 | * Free AGP memory (ioctl). |
| 335 | * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 336 | * \return zero on success or a negative number on failure. |
| 337 | * |
| 338 | * Verifies the AGP device is present and has been acquired and looks up the |
Matt Roper | 1e55a53 | 2019-02-01 17:23:26 -0800 | [diff] [blame] | 339 | * AGP memory entry. If the memory is currently bound, unbind it via |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 340 | * unbind_agp(). Frees it via free_agp() as well as the entry itself |
| 341 | * and unlinks from the doubly linked list it's inserted in. |
| 342 | */ |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 343 | int drm_legacy_agp_free(struct drm_device *dev, struct drm_agp_buffer *request) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 344 | { |
Dave Airlie | 5591051 | 2007-07-11 16:53:40 +1000 | [diff] [blame] | 345 | struct drm_agp_mem *entry; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 346 | |
| 347 | if (!dev->agp || !dev->agp->acquired) |
| 348 | return -EINVAL; |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 349 | entry = drm_legacy_agp_lookup_entry(dev, request->handle); |
Meghana Madhyastha | 182e61d | 2017-09-14 13:40:49 +0530 | [diff] [blame] | 350 | if (!entry) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 351 | return -EINVAL; |
| 352 | if (entry->bound) |
Thomas Zimmermann | ff28a9f | 2021-01-12 09:10:30 +0100 | [diff] [blame] | 353 | agp_unbind_memory(entry->memory); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 354 | |
Dave Airlie | bd1b331 | 2007-05-26 05:01:51 +1000 | [diff] [blame] | 355 | list_del(&entry->head); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 356 | |
Thomas Zimmermann | ff28a9f | 2021-01-12 09:10:30 +0100 | [diff] [blame] | 357 | agp_free_memory(entry->memory); |
Eric Anholt | 9a298b2 | 2009-03-24 12:23:04 -0700 | [diff] [blame] | 358 | kfree(entry); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 359 | return 0; |
| 360 | } |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 361 | EXPORT_SYMBOL(drm_legacy_agp_free); |
Dave Airlie | efa5839 | 2005-11-11 22:33:39 +1100 | [diff] [blame] | 362 | |
Eric Anholt | c153f45 | 2007-09-03 12:06:45 +1000 | [diff] [blame] | 363 | |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 364 | int drm_legacy_agp_free_ioctl(struct drm_device *dev, void *data, |
| 365 | struct drm_file *file_priv) |
Dave Airlie | efa5839 | 2005-11-11 22:33:39 +1100 | [diff] [blame] | 366 | { |
Eric Anholt | c153f45 | 2007-09-03 12:06:45 +1000 | [diff] [blame] | 367 | struct drm_agp_buffer *request = data; |
Dave Airlie | efa5839 | 2005-11-11 22:33:39 +1100 | [diff] [blame] | 368 | |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 369 | return drm_legacy_agp_free(dev, request); |
Dave Airlie | efa5839 | 2005-11-11 22:33:39 +1100 | [diff] [blame] | 370 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 371 | |
Lee Jones | cec7638 | 2021-01-15 18:15:55 +0000 | [diff] [blame] | 372 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 373 | * Initialize the AGP resources. |
| 374 | * |
| 375 | * \return pointer to a drm_agp_head structure. |
| 376 | * |
Dave Airlie | d985c10 | 2006-01-02 21:32:48 +1100 | [diff] [blame] | 377 | * Gets the drm_agp_t structure which is made available by the agpgart module |
| 378 | * via the inter_module_* functions. Creates and initializes a drm_agp_head |
| 379 | * structure. |
Daniel Vetter | d6e4b28 | 2013-12-11 11:34:37 +0100 | [diff] [blame] | 380 | * |
| 381 | * Note that final cleanup of the kmalloced structure is directly done in |
| 382 | * drm_pci_agp_destroy. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 383 | */ |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 384 | struct drm_agp_head *drm_legacy_agp_init(struct drm_device *dev) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 385 | { |
Thomas Zimmermann | 36b73b0 | 2021-01-18 14:14:15 +0100 | [diff] [blame] | 386 | struct pci_dev *pdev = to_pci_dev(dev->dev); |
Dave Airlie | 5591051 | 2007-07-11 16:53:40 +1000 | [diff] [blame] | 387 | struct drm_agp_head *head = NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 388 | |
Meghana Madhyastha | 182e61d | 2017-09-14 13:40:49 +0530 | [diff] [blame] | 389 | head = kzalloc(sizeof(*head), GFP_KERNEL); |
| 390 | if (!head) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 391 | return NULL; |
Thomas Zimmermann | 36b73b0 | 2021-01-18 14:14:15 +0100 | [diff] [blame] | 392 | head->bridge = agp_find_bridge(pdev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 393 | if (!head->bridge) { |
Thomas Zimmermann | 36b73b0 | 2021-01-18 14:14:15 +0100 | [diff] [blame] | 394 | head->bridge = agp_backend_acquire(pdev); |
Meghana Madhyastha | 182e61d | 2017-09-14 13:40:49 +0530 | [diff] [blame] | 395 | if (!head->bridge) { |
Eric Anholt | 9a298b2 | 2009-03-24 12:23:04 -0700 | [diff] [blame] | 396 | kfree(head); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 397 | return NULL; |
| 398 | } |
| 399 | agp_copy_info(head->bridge, &head->agp_info); |
| 400 | agp_backend_release(head->bridge); |
| 401 | } else { |
| 402 | agp_copy_info(head->bridge, &head->agp_info); |
| 403 | } |
| 404 | if (head->agp_info.chipset == NOT_SUPPORTED) { |
Eric Anholt | 9a298b2 | 2009-03-24 12:23:04 -0700 | [diff] [blame] | 405 | kfree(head); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 406 | return NULL; |
| 407 | } |
Dave Airlie | bd1b331 | 2007-05-26 05:01:51 +1000 | [diff] [blame] | 408 | INIT_LIST_HEAD(&head->memory); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 409 | head->cant_use_aperture = head->agp_info.cant_use_aperture; |
| 410 | head->page_mask = head->agp_info.page_mask; |
Eric Anholt | 8b40958 | 2007-11-22 16:40:37 +1000 | [diff] [blame] | 411 | head->base = head->agp_info.aper_base; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 412 | return head; |
| 413 | } |
Daniel Vetter | 49d66d8 | 2017-01-25 07:26:50 +0100 | [diff] [blame] | 414 | /* Only exported for i810.ko */ |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 415 | EXPORT_SYMBOL(drm_legacy_agp_init); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 416 | |
Eric Anholt | 673a394 | 2008-07-30 12:06:12 -0700 | [diff] [blame] | 417 | /** |
Daniel Vetter | 366884b | 2016-04-26 19:29:34 +0200 | [diff] [blame] | 418 | * drm_legacy_agp_clear - Clear AGP resource list |
David Herrmann | 28ec711 | 2013-07-27 16:37:00 +0200 | [diff] [blame] | 419 | * @dev: DRM device |
| 420 | * |
| 421 | * Iterate over all AGP resources and remove them. But keep the AGP head |
| 422 | * intact so it can still be used. It is safe to call this if AGP is disabled or |
| 423 | * was already removed. |
| 424 | * |
Daniel Vetter | fa53864 | 2016-08-03 21:11:10 +0200 | [diff] [blame] | 425 | * Cleanup is only done for drivers who have DRIVER_LEGACY set. |
David Herrmann | 28ec711 | 2013-07-27 16:37:00 +0200 | [diff] [blame] | 426 | */ |
Daniel Vetter | 366884b | 2016-04-26 19:29:34 +0200 | [diff] [blame] | 427 | void drm_legacy_agp_clear(struct drm_device *dev) |
David Herrmann | 28ec711 | 2013-07-27 16:37:00 +0200 | [diff] [blame] | 428 | { |
| 429 | struct drm_agp_mem *entry, *tempe; |
| 430 | |
Daniel Vetter | d990675 | 2013-12-11 11:34:35 +0100 | [diff] [blame] | 431 | if (!dev->agp) |
David Herrmann | 28ec711 | 2013-07-27 16:37:00 +0200 | [diff] [blame] | 432 | return; |
Daniel Vetter | fa53864 | 2016-08-03 21:11:10 +0200 | [diff] [blame] | 433 | if (!drm_core_check_feature(dev, DRIVER_LEGACY)) |
David Herrmann | 28ec711 | 2013-07-27 16:37:00 +0200 | [diff] [blame] | 434 | return; |
| 435 | |
| 436 | list_for_each_entry_safe(entry, tempe, &dev->agp->memory, head) { |
| 437 | if (entry->bound) |
Thomas Zimmermann | ff28a9f | 2021-01-12 09:10:30 +0100 | [diff] [blame] | 438 | agp_unbind_memory(entry->memory); |
| 439 | agp_free_memory(entry->memory); |
David Herrmann | 28ec711 | 2013-07-27 16:37:00 +0200 | [diff] [blame] | 440 | kfree(entry); |
| 441 | } |
| 442 | INIT_LIST_HEAD(&dev->agp->memory); |
| 443 | |
| 444 | if (dev->agp->acquired) |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 445 | drm_legacy_agp_release(dev); |
David Herrmann | 28ec711 | 2013-07-27 16:37:00 +0200 | [diff] [blame] | 446 | |
| 447 | dev->agp->acquired = 0; |
| 448 | dev->agp->enabled = 0; |
| 449 | } |
Thomas Zimmermann | 04dfe19 | 2021-05-07 20:57:09 +0200 | [diff] [blame] | 450 | |
| 451 | #endif |