2 * \file drm_agpsupport.c
3 * DRM support for AGP/GART backend
5 * \author Rickard E. (Rik) Faith <faith@valinux.com>
6 * \author Gareth Hughes <gareth@valinux.com>
10 * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
11 * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
12 * All Rights Reserved.
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:
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
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.
35 #include <linux/module.h>
36 #include <linux/slab.h>
43 * Get AGP information.
45 * \param inode device inode.
46 * \param file_priv DRM file private.
48 * \param arg pointer to a (output) drm_agp_info structure.
49 * \return zero on success or a negative number on failure.
51 * Verifies the AGP device has been initialized and acquired and fills in the
52 * drm_agp_info structure with the information in drm_agp_head::agp_info.
54 int drm_agp_info(struct drm_device
*dev
, struct drm_agp_info
*info
)
58 if (!dev
->agp
|| !dev
->agp
->acquired
)
61 kern
= &dev
->agp
->agp_info
;
62 info
->agp_version_major
= kern
->version
.major
;
63 info
->agp_version_minor
= kern
->version
.minor
;
64 info
->mode
= kern
->mode
;
65 info
->aperture_base
= kern
->aper_base
;
66 info
->aperture_size
= kern
->aper_size
* 1024 * 1024;
67 info
->memory_allowed
= kern
->max_memory
<< PAGE_SHIFT
;
68 info
->memory_used
= kern
->current_memory
<< PAGE_SHIFT
;
69 info
->id_vendor
= kern
->device
->vendor
;
70 info
->id_device
= kern
->device
->device
;
75 EXPORT_SYMBOL(drm_agp_info
);
77 int drm_agp_info_ioctl(struct drm_device
*dev
, void *data
,
78 struct drm_file
*file_priv
)
80 struct drm_agp_info
*info
= data
;
83 err
= drm_agp_info(dev
, info
);
91 * Acquire the AGP device.
93 * \param dev DRM device that is to acquire AGP.
94 * \return zero on success or a negative number on failure.
96 * Verifies the AGP device hasn't been acquired before and calls
97 * \c agp_backend_acquire.
99 int drm_agp_acquire(struct drm_device
* dev
)
103 if (dev
->agp
->acquired
)
105 if (!(dev
->agp
->bridge
= agp_backend_acquire(dev
->pdev
)))
107 dev
->agp
->acquired
= 1;
111 EXPORT_SYMBOL(drm_agp_acquire
);
114 * Acquire the AGP device (ioctl).
116 * \param inode device inode.
117 * \param file_priv DRM file private.
118 * \param cmd command.
119 * \param arg user argument.
120 * \return zero on success or a negative number on failure.
122 * Verifies the AGP device hasn't been acquired before and calls
123 * \c agp_backend_acquire.
125 int drm_agp_acquire_ioctl(struct drm_device
*dev
, void *data
,
126 struct drm_file
*file_priv
)
128 return drm_agp_acquire((struct drm_device
*) file_priv
->minor
->dev
);
132 * Release the AGP device.
134 * \param dev DRM device that is to release AGP.
135 * \return zero on success or a negative number on failure.
137 * Verifies the AGP device has been acquired and calls \c agp_backend_release.
139 int drm_agp_release(struct drm_device
* dev
)
141 if (!dev
->agp
|| !dev
->agp
->acquired
)
143 agp_backend_release(dev
->agp
->bridge
);
144 dev
->agp
->acquired
= 0;
147 EXPORT_SYMBOL(drm_agp_release
);
149 int drm_agp_release_ioctl(struct drm_device
*dev
, void *data
,
150 struct drm_file
*file_priv
)
152 return drm_agp_release(dev
);
156 * Enable the AGP bus.
158 * \param dev DRM device that has previously acquired AGP.
159 * \param mode Requested AGP mode.
160 * \return zero on success or a negative number on failure.
162 * Verifies the AGP device has been acquired but not enabled, and calls
165 int drm_agp_enable(struct drm_device
* dev
, struct drm_agp_mode mode
)
167 if (!dev
->agp
|| !dev
->agp
->acquired
)
170 dev
->agp
->mode
= mode
.mode
;
171 agp_enable(dev
->agp
->bridge
, mode
.mode
);
172 dev
->agp
->enabled
= 1;
176 EXPORT_SYMBOL(drm_agp_enable
);
178 int drm_agp_enable_ioctl(struct drm_device
*dev
, void *data
,
179 struct drm_file
*file_priv
)
181 struct drm_agp_mode
*mode
= data
;
183 return drm_agp_enable(dev
, *mode
);
187 * Allocate AGP memory.
189 * \param inode device inode.
190 * \param file_priv file private pointer.
191 * \param cmd command.
192 * \param arg pointer to a drm_agp_buffer structure.
193 * \return zero on success or a negative number on failure.
195 * Verifies the AGP device is present and has been acquired, allocates the
196 * memory via agp_allocate_memory() and creates a drm_agp_mem entry for it.
198 int drm_agp_alloc(struct drm_device
*dev
, struct drm_agp_buffer
*request
)
200 struct drm_agp_mem
*entry
;
205 if (!dev
->agp
|| !dev
->agp
->acquired
)
207 if (!(entry
= kmalloc(sizeof(*entry
), GFP_KERNEL
)))
210 memset(entry
, 0, sizeof(*entry
));
212 pages
= (request
->size
+ PAGE_SIZE
- 1) / PAGE_SIZE
;
213 type
= (u32
) request
->type
;
214 if (!(memory
= agp_allocate_memory(dev
->agp
->bridge
, pages
, type
))) {
219 entry
->handle
= (unsigned long)memory
->key
+ 1;
220 entry
->memory
= memory
;
222 entry
->pages
= pages
;
223 list_add(&entry
->head
, &dev
->agp
->memory
);
225 request
->handle
= entry
->handle
;
226 request
->physical
= memory
->physical
;
230 EXPORT_SYMBOL(drm_agp_alloc
);
233 int drm_agp_alloc_ioctl(struct drm_device
*dev
, void *data
,
234 struct drm_file
*file_priv
)
236 struct drm_agp_buffer
*request
= data
;
238 return drm_agp_alloc(dev
, request
);
242 * Search for the AGP memory entry associated with a handle.
244 * \param dev DRM device structure.
245 * \param handle AGP memory handle.
246 * \return pointer to the drm_agp_mem structure associated with \p handle.
248 * Walks through drm_agp_head::memory until finding a matching handle.
250 static struct drm_agp_mem
*drm_agp_lookup_entry(struct drm_device
* dev
,
251 unsigned long handle
)
253 struct drm_agp_mem
*entry
;
255 list_for_each_entry(entry
, &dev
->agp
->memory
, head
) {
256 if (entry
->handle
== handle
)
263 * Unbind AGP memory from the GATT (ioctl).
265 * \param inode device inode.
266 * \param file_priv DRM file private.
267 * \param cmd command.
268 * \param arg pointer to a drm_agp_binding structure.
269 * \return zero on success or a negative number on failure.
271 * Verifies the AGP device is present and acquired, looks-up the AGP memory
272 * entry and passes it to the unbind_agp() function.
274 int drm_agp_unbind(struct drm_device
*dev
, struct drm_agp_binding
*request
)
276 struct drm_agp_mem
*entry
;
279 if (!dev
->agp
|| !dev
->agp
->acquired
)
281 if (!(entry
= drm_agp_lookup_entry(dev
, request
->handle
)))
285 ret
= drm_unbind_agp(entry
->memory
);
290 EXPORT_SYMBOL(drm_agp_unbind
);
293 int drm_agp_unbind_ioctl(struct drm_device
*dev
, void *data
,
294 struct drm_file
*file_priv
)
296 struct drm_agp_binding
*request
= data
;
298 return drm_agp_unbind(dev
, request
);
302 * Bind AGP memory into the GATT (ioctl)
304 * \param inode device inode.
305 * \param file_priv DRM file private.
306 * \param cmd command.
307 * \param arg pointer to a drm_agp_binding structure.
308 * \return zero on success or a negative number on failure.
310 * Verifies the AGP device is present and has been acquired and that no memory
311 * is currently bound into the GATT. Looks-up the AGP memory entry and passes
312 * it to bind_agp() function.
314 int drm_agp_bind(struct drm_device
*dev
, struct drm_agp_binding
*request
)
316 struct drm_agp_mem
*entry
;
320 if (!dev
->agp
|| !dev
->agp
->acquired
)
322 if (!(entry
= drm_agp_lookup_entry(dev
, request
->handle
)))
326 page
= (request
->offset
+ PAGE_SIZE
- 1) / PAGE_SIZE
;
327 if ((retcode
= drm_bind_agp(entry
->memory
, page
)))
329 entry
->bound
= dev
->agp
->base
+ (page
<< PAGE_SHIFT
);
330 DRM_DEBUG("base = 0x%lx entry->bound = 0x%lx\n",
331 dev
->agp
->base
, entry
->bound
);
334 EXPORT_SYMBOL(drm_agp_bind
);
337 int drm_agp_bind_ioctl(struct drm_device
*dev
, void *data
,
338 struct drm_file
*file_priv
)
340 struct drm_agp_binding
*request
= data
;
342 return drm_agp_bind(dev
, request
);
346 * Free AGP memory (ioctl).
348 * \param inode device inode.
349 * \param file_priv DRM file private.
350 * \param cmd command.
351 * \param arg pointer to a drm_agp_buffer structure.
352 * \return zero on success or a negative number on failure.
354 * Verifies the AGP device is present and has been acquired and looks up the
355 * AGP memory entry. If the memory it's currently bound, unbind it via
356 * unbind_agp(). Frees it via free_agp() as well as the entry itself
357 * and unlinks from the doubly linked list it's inserted in.
359 int drm_agp_free(struct drm_device
*dev
, struct drm_agp_buffer
*request
)
361 struct drm_agp_mem
*entry
;
363 if (!dev
->agp
|| !dev
->agp
->acquired
)
365 if (!(entry
= drm_agp_lookup_entry(dev
, request
->handle
)))
368 drm_unbind_agp(entry
->memory
);
370 list_del(&entry
->head
);
372 drm_free_agp(entry
->memory
, entry
->pages
);
376 EXPORT_SYMBOL(drm_agp_free
);
380 int drm_agp_free_ioctl(struct drm_device
*dev
, void *data
,
381 struct drm_file
*file_priv
)
383 struct drm_agp_buffer
*request
= data
;
385 return drm_agp_free(dev
, request
);
389 * Initialize the AGP resources.
391 * \return pointer to a drm_agp_head structure.
393 * Gets the drm_agp_t structure which is made available by the agpgart module
394 * via the inter_module_* functions. Creates and initializes a drm_agp_head
397 struct drm_agp_head
*drm_agp_init(struct drm_device
*dev
)
399 struct drm_agp_head
*head
= NULL
;
401 if (!(head
= kmalloc(sizeof(*head
), GFP_KERNEL
)))
403 memset((void *)head
, 0, sizeof(*head
));
404 head
->bridge
= agp_find_bridge(dev
->pdev
);
406 if (!(head
->bridge
= agp_backend_acquire(dev
->pdev
))) {
410 agp_copy_info(head
->bridge
, &head
->agp_info
);
411 agp_backend_release(head
->bridge
);
413 agp_copy_info(head
->bridge
, &head
->agp_info
);
415 if (head
->agp_info
.chipset
== NOT_SUPPORTED
) {
419 INIT_LIST_HEAD(&head
->memory
);
420 head
->cant_use_aperture
= head
->agp_info
.cant_use_aperture
;
421 head
->page_mask
= head
->agp_info
.page_mask
;
422 head
->base
= head
->agp_info
.aper_base
;
427 * drm_agp_clear - Clear AGP resource list
430 * Iterate over all AGP resources and remove them. But keep the AGP head
431 * intact so it can still be used. It is safe to call this if AGP is disabled or
432 * was already removed.
434 * If DRIVER_MODESET is active, nothing is done to protect the modesetting
435 * resources from getting destroyed. Drivers are responsible of cleaning them up
436 * during device shutdown.
438 void drm_agp_clear(struct drm_device
*dev
)
440 struct drm_agp_mem
*entry
, *tempe
;
442 if (!drm_core_has_AGP(dev
) || !dev
->agp
)
444 if (drm_core_check_feature(dev
, DRIVER_MODESET
))
447 list_for_each_entry_safe(entry
, tempe
, &dev
->agp
->memory
, head
) {
449 drm_unbind_agp(entry
->memory
);
450 drm_free_agp(entry
->memory
, entry
->pages
);
453 INIT_LIST_HEAD(&dev
->agp
->memory
);
455 if (dev
->agp
->acquired
)
456 drm_agp_release(dev
);
458 dev
->agp
->acquired
= 0;
459 dev
->agp
->enabled
= 0;
463 * drm_agp_destroy - Destroy AGP head
466 * Destroy resources that were previously allocated via drm_agp_initp. Caller
467 * must ensure to clean up all AGP resources before calling this. See
470 * Call this to destroy AGP heads allocated via drm_agp_init().
472 void drm_agp_destroy(struct drm_agp_head
*agp
)
478 * Binds a collection of pages into AGP memory at the given offset, returning
479 * the AGP memory structure containing them.
481 * No reference is held on the pages during this time -- it is up to the
482 * caller to handle that.
485 drm_agp_bind_pages(struct drm_device
*dev
,
487 unsigned long num_pages
,
496 mem
= agp_allocate_memory(dev
->agp
->bridge
, num_pages
,
499 DRM_ERROR("Failed to allocate memory for %ld pages\n",
504 for (i
= 0; i
< num_pages
; i
++)
505 mem
->pages
[i
] = pages
[i
];
506 mem
->page_count
= num_pages
;
508 mem
->is_flushed
= true;
509 ret
= agp_bind_memory(mem
, gtt_offset
/ PAGE_SIZE
);
511 DRM_ERROR("Failed to bind AGP memory: %d\n", ret
);
512 agp_free_memory(mem
);
518 EXPORT_SYMBOL(drm_agp_bind_pages
);
520 #endif /* __OS_HAS_AGP */