1 /*- 2 * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas. 3 * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California. 4 * All Rights Reserved. 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a 7 * copy of this software and associated documentation files (the "Software"), 8 * to deal in the Software without restriction, including without limitation 9 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 10 * and/or sell copies of the Software, and to permit persons to whom the 11 * Software is furnished to do so, subject to the following conditions: 12 * 13 * The above copyright notice and this permission notice (including the next 14 * paragraph) shall be included in all copies or substantial portions of the 15 * Software. 16 * 17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 20 * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 21 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 22 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 23 * OTHER DEALINGS IN THE SOFTWARE. 24 * 25 * Author: 26 * Rickard E. (Rik) Faith <faith@valinux.com> 27 * Gareth Hughes <gareth@valinux.com> 28 * 29 */ 30 31 /* 32 * Support code for tying the kernel AGP support to DRM drivers and 33 * the DRM's AGP ioctls. 34 */ 35 36 #include "drmP.h" 37 38 struct drm_agp_mem *drm_agp_lookup_entry(struct drm_device *, void *); 39 void drm_agp_remove_entry(struct drm_device *, 40 struct drm_agp_mem *); 41 42 int 43 drm_agp_info(struct drm_device * dev, struct drm_agp_info *info) 44 { 45 struct agp_info *kern; 46 47 if (dev->agp == NULL || !dev->agp->acquired) 48 return (EINVAL); 49 50 kern = &dev->agp->info; 51 #ifndef DRM_NO_AGP 52 agp_get_info(dev->agp->agpdev, kern); 53 #endif 54 info->agp_version_major = 1; 55 info->agp_version_minor = 0; 56 info->mode = kern->ai_mode; 57 info->aperture_base = kern->ai_aperture_base; 58 info->aperture_size = kern->ai_aperture_size; 59 info->memory_allowed = kern->ai_memory_allowed; 60 info->memory_used = kern->ai_memory_used; 61 info->id_vendor = kern->ai_devid & 0xffff; 62 info->id_device = kern->ai_devid >> 16; 63 64 return (0); 65 } 66 67 int 68 drm_agp_info_ioctl(struct drm_device *dev, void *data, 69 struct drm_file *file_priv) 70 { 71 struct drm_agp_info *info = data; 72 73 return (drm_agp_info(dev, info)); 74 } 75 76 int 77 drm_agp_acquire_ioctl(struct drm_device *dev, void *data, 78 struct drm_file *file_priv) 79 { 80 return (drm_agp_acquire(dev)); 81 } 82 83 int 84 drm_agp_acquire(struct drm_device *dev) 85 { 86 #ifndef DRM_NO_AGP 87 int retcode; 88 89 if (dev->agp == NULL || dev->agp->acquired) 90 return (EINVAL); 91 92 retcode = agp_acquire(dev->agp->agpdev); 93 if (retcode) 94 return (retcode); 95 96 dev->agp->acquired = 1; 97 #endif 98 return (0); 99 } 100 101 int 102 drm_agp_release_ioctl(struct drm_device *dev, void *data, 103 struct drm_file *file_priv) 104 { 105 return (drm_agp_release(dev)); 106 } 107 108 int 109 drm_agp_release(struct drm_device * dev) 110 { 111 #ifndef DRM_NO_AGP 112 if (dev->agp == NULL || !dev->agp->acquired) 113 return (EINVAL); 114 agp_release(dev->agp->agpdev); 115 dev->agp->acquired = 0; 116 #endif 117 return (0); 118 } 119 120 int 121 drm_agp_enable(struct drm_device *dev, drm_agp_mode_t mode) 122 { 123 int retcode = 0; 124 #ifndef DRM_NO_AGP 125 if (dev->agp == NULL || !dev->agp->acquired) 126 return (EINVAL); 127 128 dev->agp->mode = mode.mode; 129 if ((retcode = agp_enable(dev->agp->agpdev, mode.mode)) == 0) 130 dev->agp->enabled = 1; 131 #endif 132 return (retcode); 133 } 134 135 int 136 drm_agp_enable_ioctl(struct drm_device *dev, void *data, 137 struct drm_file *file_priv) 138 { 139 struct drm_agp_mode *mode = data; 140 141 return (drm_agp_enable(dev, *mode)); 142 } 143 144 int 145 drm_agp_alloc(struct drm_device *dev, struct drm_agp_buffer *request) 146 { 147 #ifndef DRM_NO_AGP 148 struct drm_agp_mem *entry; 149 void *handle; 150 struct agp_memory_info info; 151 unsigned long pages; 152 u_int32_t type; 153 154 if (dev->agp == NULL || !dev->agp->acquired) 155 return (EINVAL); 156 157 entry = drm_alloc(sizeof(*entry)); 158 if (entry == NULL) 159 return (ENOMEM); 160 161 pages = (request->size + PAGE_SIZE - 1) / PAGE_SIZE; 162 type = (u_int32_t)request->type; 163 164 handle = agp_alloc_memory(dev->agp->agpdev, type, 165 pages << AGP_PAGE_SHIFT); 166 if (handle == NULL) { 167 drm_free(entry); 168 return (ENOMEM); 169 } 170 171 entry->handle = handle; 172 entry->bound = 0; 173 entry->pages = pages; 174 175 agp_memory_info(dev->agp->agpdev, entry->handle, &info); 176 177 request->handle = (unsigned long)entry->handle; 178 request->physical = info.ami_physical; 179 DRM_LOCK(); 180 TAILQ_INSERT_HEAD(&dev->agp->memory, entry, link); 181 DRM_UNLOCK(); 182 #endif 183 184 return (0); 185 } 186 187 int 188 drm_agp_alloc_ioctl(struct drm_device *dev, void *data, 189 struct drm_file *file_priv) 190 { 191 struct drm_agp_buffer *request = data; 192 193 return (drm_agp_alloc(dev, request)); 194 } 195 196 /* 197 * find entry on agp list. Must be called with dev_lock locked. 198 */ 199 struct drm_agp_mem * 200 drm_agp_lookup_entry(struct drm_device *dev, void *handle) 201 { 202 struct drm_agp_mem *entry; 203 204 TAILQ_FOREACH(entry, &dev->agp->memory, link) { 205 if (entry->handle == handle) 206 break; 207 } 208 return (entry); 209 } 210 211 int 212 drm_agp_unbind(struct drm_device *dev, struct drm_agp_binding *request) 213 { 214 struct drm_agp_mem *entry; 215 int retcode; 216 217 if (dev->agp == NULL || !dev->agp->acquired) 218 return (EINVAL); 219 220 DRM_LOCK(); 221 entry = drm_agp_lookup_entry(dev, (void *)request->handle); 222 if (entry == NULL || !entry->bound) { 223 DRM_UNLOCK(); 224 return (EINVAL); 225 } 226 227 retcode = agp_unbind_memory(dev->agp->agpdev, entry->handle); 228 229 if (retcode == 0) 230 entry->bound = 0; 231 DRM_UNLOCK(); 232 233 return (retcode); 234 } 235 236 int 237 drm_agp_unbind_ioctl(struct drm_device *dev, void *data, 238 struct drm_file *file_priv) 239 { 240 struct drm_agp_binding *request = data; 241 242 return (drm_agp_unbind(dev, request)); 243 } 244 245 int 246 drm_agp_bind(struct drm_device *dev, struct drm_agp_binding *request) 247 { 248 struct drm_agp_mem *entry; 249 int retcode, page; 250 251 if (dev->agp == NULL || !dev->agp->acquired) 252 return (EINVAL); 253 254 DRM_DEBUG("agp_bind, page_size=%x\n", PAGE_SIZE); 255 256 DRM_LOCK(); 257 entry = drm_agp_lookup_entry(dev, (void *)request->handle); 258 if (entry == NULL || entry->bound) { 259 DRM_UNLOCK(); 260 return (EINVAL); 261 } 262 263 page = (request->offset + PAGE_SIZE - 1) / PAGE_SIZE; 264 265 retcode = agp_bind_memory(dev->agp->agpdev, entry->handle, 266 page * PAGE_SIZE); 267 if (retcode == 0) 268 entry->bound = dev->agp->base + (page << PAGE_SHIFT); 269 DRM_UNLOCK(); 270 271 return (retcode); 272 } 273 274 int 275 drm_agp_bind_ioctl(struct drm_device *dev, void *data, 276 struct drm_file *file_priv) 277 { 278 struct drm_agp_binding *request = data; 279 280 return (drm_agp_bind(dev, request)); 281 } 282 283 /* 284 * Remove entry from list and free. Call locked. 285 */ 286 void 287 drm_agp_remove_entry(struct drm_device *dev, struct drm_agp_mem *entry) 288 { 289 TAILQ_REMOVE(&dev->agp->memory, entry, link); 290 291 if (entry->bound) 292 agp_unbind_memory(dev->agp->agpdev, entry->handle); 293 agp_free_memory(dev->agp->agpdev, entry->handle); 294 drm_free(entry); 295 } 296 297 void 298 drm_agp_takedown(struct drm_device *dev) 299 { 300 struct drm_agp_mem *entry; 301 302 if (dev->agp == NULL) 303 return; 304 305 /* 306 * Remove AGP resources, but leave dev->agp intact until 307 * we detach the device 308 */ 309 DRM_LOCK(); 310 while ((entry = TAILQ_FIRST(&dev->agp->memory)) != NULL) 311 drm_agp_remove_entry(dev, entry); 312 DRM_UNLOCK(); 313 314 drm_agp_release(dev); 315 dev->agp->enabled = 0; 316 } 317 318 int 319 drm_agp_free(struct drm_device *dev, struct drm_agp_buffer *request) 320 { 321 struct drm_agp_mem *entry; 322 323 if (dev->agp == NULL || !dev->agp->acquired) 324 return (EINVAL); 325 326 DRM_LOCK(); 327 entry = drm_agp_lookup_entry(dev, (void*)request->handle); 328 if (entry == NULL) { 329 DRM_UNLOCK(); 330 return (EINVAL); 331 } 332 333 drm_agp_remove_entry(dev, entry); 334 DRM_UNLOCK(); 335 336 return (0); 337 } 338 339 int 340 drm_agp_free_ioctl(struct drm_device *dev, void *data, 341 struct drm_file *file_priv) 342 { 343 struct drm_agp_buffer *request = data; 344 345 return (drm_agp_free(dev, request)); 346 } 347 348 struct drm_agp_head * 349 drm_agp_init(void) 350 { 351 #ifndef DRM_NO_AGP 352 struct device *agpdev; 353 struct drm_agp_head *head = NULL; 354 int agp_available = 1; 355 356 agpdev = agp_find_device(0); 357 if (agpdev == NULL) 358 agp_available = 0; 359 360 DRM_DEBUG("agp_available = %d\n", agp_available); 361 362 if (agp_available) { 363 head = drm_calloc(1, sizeof(*head)); 364 if (head == NULL) 365 return (NULL); 366 head->agpdev = agpdev; 367 agp_get_info(agpdev, &head->info); 368 head->base = head->info.ai_aperture_base; 369 TAILQ_INIT(&head->memory); 370 } 371 return (head); 372 #else 373 return (NULL); 374 #endif 375 } 376