Merge master.kernel.org:/pub/scm/linux/kernel/git/davej/agpgart
[linux-2.6] / drivers / char / drm / drm_agpsupport.c
1 /**
2  * \file drm_agpsupport.h
3  * DRM support for AGP/GART backend
4  *
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
34 #include "drmP.h"
35 #include <linux/module.h>
36
37 #if __OS_HAS_AGP
38
39 /**
40  * Get AGP information.
41  *
42  * \param inode device inode.
43  * \param filp file pointer.
44  * \param cmd command.
45  * \param arg pointer to a (output) drm_agp_info structure.
46  * \return zero on success or a negative number on failure.
47  *
48  * Verifies the AGP device has been initialized and acquired and fills in the
49  * drm_agp_info structure with the information in drm_agp_head::agp_info.
50  */
51 int drm_agp_info(drm_device_t * dev, drm_agp_info_t * info)
52 {
53         DRM_AGP_KERN *kern;
54
55         if (!dev->agp || !dev->agp->acquired)
56                 return -EINVAL;
57
58         kern = &dev->agp->agp_info;
59         info->agp_version_major = kern->version.major;
60         info->agp_version_minor = kern->version.minor;
61         info->mode = kern->mode;
62         info->aperture_base = kern->aper_base;
63         info->aperture_size = kern->aper_size * 1024 * 1024;
64         info->memory_allowed = kern->max_memory << PAGE_SHIFT;
65         info->memory_used = kern->current_memory << PAGE_SHIFT;
66         info->id_vendor = kern->device->vendor;
67         info->id_device = kern->device->device;
68
69         return 0;
70 }
71
72 EXPORT_SYMBOL(drm_agp_info);
73
74 int drm_agp_info_ioctl(struct inode *inode, struct file *filp,
75                        unsigned int cmd, unsigned long arg)
76 {
77         drm_file_t *priv = filp->private_data;
78         drm_device_t *dev = priv->head->dev;
79         drm_agp_info_t info;
80         int err;
81
82         err = drm_agp_info(dev, &info);
83         if (err)
84                 return err;
85
86         if (copy_to_user((drm_agp_info_t __user *) arg, &info, sizeof(info)))
87                 return -EFAULT;
88         return 0;
89 }
90
91 /**
92  * Acquire the AGP device.
93  *
94  * \param dev DRM device that is to acquire AGP
95  * \return zero on success or a negative number on failure.
96  *
97  * Verifies the AGP device hasn't been acquired before and calls
98  * \c agp_backend_acquire.
99  */
100 int drm_agp_acquire(drm_device_t * dev)
101 {
102         if (!dev->agp)
103                 return -ENODEV;
104         if (dev->agp->acquired)
105                 return -EBUSY;
106         if (!(dev->agp->bridge = agp_backend_acquire(dev->pdev)))
107                 return -ENODEV;
108         dev->agp->acquired = 1;
109         return 0;
110 }
111
112 EXPORT_SYMBOL(drm_agp_acquire);
113
114 /**
115  * Acquire the AGP device (ioctl).
116  *
117  * \param inode device inode.
118  * \param filp file pointer.
119  * \param cmd command.
120  * \param arg user argument.
121  * \return zero on success or a negative number on failure.
122  *
123  * Verifies the AGP device hasn't been acquired before and calls
124  * \c agp_backend_acquire.
125  */
126 int drm_agp_acquire_ioctl(struct inode *inode, struct file *filp,
127                           unsigned int cmd, unsigned long arg)
128 {
129         drm_file_t *priv = filp->private_data;
130
131         return drm_agp_acquire((drm_device_t *) priv->head->dev);
132 }
133
134 /**
135  * Release the AGP device.
136  *
137  * \param dev DRM device that is to release AGP
138  * \return zero on success or a negative number on failure.
139  *
140  * Verifies the AGP device has been acquired and calls \c agp_backend_release.
141  */
142 int drm_agp_release(drm_device_t * dev)
143 {
144         if (!dev->agp || !dev->agp->acquired)
145                 return -EINVAL;
146         agp_backend_release(dev->agp->bridge);
147         dev->agp->acquired = 0;
148         return 0;
149 }
150
151 EXPORT_SYMBOL(drm_agp_release);
152
153 int drm_agp_release_ioctl(struct inode *inode, struct file *filp,
154                           unsigned int cmd, unsigned long arg)
155 {
156         drm_file_t *priv = filp->private_data;
157         drm_device_t *dev = priv->head->dev;
158
159         return drm_agp_release(dev);
160 }
161
162 /**
163  * Enable the AGP bus.
164  *
165  * \param dev DRM device that has previously acquired AGP.
166  * \param mode Requested AGP mode.
167  * \return zero on success or a negative number on failure.
168  *
169  * Verifies the AGP device has been acquired but not enabled, and calls
170  * \c agp_enable.
171  */
172 int drm_agp_enable(drm_device_t * dev, drm_agp_mode_t mode)
173 {
174         if (!dev->agp || !dev->agp->acquired)
175                 return -EINVAL;
176
177         dev->agp->mode = mode.mode;
178         agp_enable(dev->agp->bridge, mode.mode);
179         dev->agp->base = dev->agp->agp_info.aper_base;
180         dev->agp->enabled = 1;
181         return 0;
182 }
183
184 EXPORT_SYMBOL(drm_agp_enable);
185
186 int drm_agp_enable_ioctl(struct inode *inode, struct file *filp,
187                          unsigned int cmd, unsigned long arg)
188 {
189         drm_file_t *priv = filp->private_data;
190         drm_device_t *dev = priv->head->dev;
191         drm_agp_mode_t mode;
192
193         if (copy_from_user(&mode, (drm_agp_mode_t __user *) arg, sizeof(mode)))
194                 return -EFAULT;
195
196         return drm_agp_enable(dev, mode);
197 }
198
199 /**
200  * Allocate AGP memory.
201  *
202  * \param inode device inode.
203  * \param filp file pointer.
204  * \param cmd command.
205  * \param arg pointer to a drm_agp_buffer structure.
206  * \return zero on success or a negative number on failure.
207  *
208  * Verifies the AGP device is present and has been acquired, allocates the
209  * memory via alloc_agp() and creates a drm_agp_mem entry for it.
210  */
211 int drm_agp_alloc(struct inode *inode, struct file *filp,
212                   unsigned int cmd, unsigned long arg)
213 {
214         drm_file_t *priv = filp->private_data;
215         drm_device_t *dev = priv->head->dev;
216         drm_agp_buffer_t request;
217         drm_agp_mem_t *entry;
218         DRM_AGP_MEM *memory;
219         unsigned long pages;
220         u32 type;
221         drm_agp_buffer_t __user *argp = (void __user *)arg;
222
223         if (!dev->agp || !dev->agp->acquired)
224                 return -EINVAL;
225         if (copy_from_user(&request, argp, sizeof(request)))
226                 return -EFAULT;
227         if (!(entry = drm_alloc(sizeof(*entry), DRM_MEM_AGPLISTS)))
228                 return -ENOMEM;
229
230         memset(entry, 0, sizeof(*entry));
231
232         pages = (request.size + PAGE_SIZE - 1) / PAGE_SIZE;
233         type = (u32) request.type;
234
235         if (!(memory = drm_alloc_agp(dev, pages, type))) {
236                 drm_free(entry, sizeof(*entry), DRM_MEM_AGPLISTS);
237                 return -ENOMEM;
238         }
239
240         entry->handle = (unsigned long)memory->key + 1;
241         entry->memory = memory;
242         entry->bound = 0;
243         entry->pages = pages;
244         entry->prev = NULL;
245         entry->next = dev->agp->memory;
246         if (dev->agp->memory)
247                 dev->agp->memory->prev = entry;
248         dev->agp->memory = entry;
249
250         request.handle = entry->handle;
251         request.physical = memory->physical;
252
253         if (copy_to_user(argp, &request, sizeof(request))) {
254                 dev->agp->memory = entry->next;
255                 dev->agp->memory->prev = NULL;
256                 drm_free_agp(memory, pages);
257                 drm_free(entry, sizeof(*entry), DRM_MEM_AGPLISTS);
258                 return -EFAULT;
259         }
260         return 0;
261 }
262
263 /**
264  * Search for the AGP memory entry associated with a handle.
265  *
266  * \param dev DRM device structure.
267  * \param handle AGP memory handle.
268  * \return pointer to the drm_agp_mem structure associated with \p handle.
269  *
270  * Walks through drm_agp_head::memory until finding a matching handle.
271  */
272 static drm_agp_mem_t *drm_agp_lookup_entry(drm_device_t * dev,
273                                            unsigned long handle)
274 {
275         drm_agp_mem_t *entry;
276
277         for (entry = dev->agp->memory; entry; entry = entry->next) {
278                 if (entry->handle == handle)
279                         return entry;
280         }
281         return NULL;
282 }
283
284 /**
285  * Unbind AGP memory from the GATT (ioctl).
286  *
287  * \param inode device inode.
288  * \param filp file pointer.
289  * \param cmd command.
290  * \param arg pointer to a drm_agp_binding structure.
291  * \return zero on success or a negative number on failure.
292  *
293  * Verifies the AGP device is present and acquired, looks-up the AGP memory
294  * entry and passes it to the unbind_agp() function.
295  */
296 int drm_agp_unbind(struct inode *inode, struct file *filp,
297                    unsigned int cmd, unsigned long arg)
298 {
299         drm_file_t *priv = filp->private_data;
300         drm_device_t *dev = priv->head->dev;
301         drm_agp_binding_t request;
302         drm_agp_mem_t *entry;
303         int ret;
304
305         if (!dev->agp || !dev->agp->acquired)
306                 return -EINVAL;
307         if (copy_from_user
308             (&request, (drm_agp_binding_t __user *) arg, sizeof(request)))
309                 return -EFAULT;
310         if (!(entry = drm_agp_lookup_entry(dev, request.handle)))
311                 return -EINVAL;
312         if (!entry->bound)
313                 return -EINVAL;
314         ret = drm_unbind_agp(entry->memory);
315         if (ret == 0)
316                 entry->bound = 0;
317         return ret;
318 }
319
320 /**
321  * Bind AGP memory into the GATT (ioctl)
322  *
323  * \param inode device inode.
324  * \param filp file pointer.
325  * \param cmd command.
326  * \param arg pointer to a drm_agp_binding structure.
327  * \return zero on success or a negative number on failure.
328  *
329  * Verifies the AGP device is present and has been acquired and that no memory
330  * is currently bound into the GATT. Looks-up the AGP memory entry and passes
331  * it to bind_agp() function.
332  */
333 int drm_agp_bind(struct inode *inode, struct file *filp,
334                  unsigned int cmd, unsigned long arg)
335 {
336         drm_file_t *priv = filp->private_data;
337         drm_device_t *dev = priv->head->dev;
338         drm_agp_binding_t request;
339         drm_agp_mem_t *entry;
340         int retcode;
341         int page;
342
343         if (!dev->agp || !dev->agp->acquired)
344                 return -EINVAL;
345         if (copy_from_user
346             (&request, (drm_agp_binding_t __user *) arg, sizeof(request)))
347                 return -EFAULT;
348         if (!(entry = drm_agp_lookup_entry(dev, request.handle)))
349                 return -EINVAL;
350         if (entry->bound)
351                 return -EINVAL;
352         page = (request.offset + PAGE_SIZE - 1) / PAGE_SIZE;
353         if ((retcode = drm_bind_agp(entry->memory, page)))
354                 return retcode;
355         entry->bound = dev->agp->base + (page << PAGE_SHIFT);
356         DRM_DEBUG("base = 0x%lx entry->bound = 0x%lx\n",
357                   dev->agp->base, entry->bound);
358         return 0;
359 }
360
361 /**
362  * Free AGP memory (ioctl).
363  *
364  * \param inode device inode.
365  * \param filp file pointer.
366  * \param cmd command.
367  * \param arg pointer to a drm_agp_buffer structure.
368  * \return zero on success or a negative number on failure.
369  *
370  * Verifies the AGP device is present and has been acquired and looks up the
371  * AGP memory entry. If the memory it's currently bound, unbind it via
372  * unbind_agp(). Frees it via free_agp() as well as the entry itself
373  * and unlinks from the doubly linked list it's inserted in.
374  */
375 int drm_agp_free(struct inode *inode, struct file *filp,
376                  unsigned int cmd, unsigned long arg)
377 {
378         drm_file_t *priv = filp->private_data;
379         drm_device_t *dev = priv->head->dev;
380         drm_agp_buffer_t request;
381         drm_agp_mem_t *entry;
382
383         if (!dev->agp || !dev->agp->acquired)
384                 return -EINVAL;
385         if (copy_from_user
386             (&request, (drm_agp_buffer_t __user *) arg, sizeof(request)))
387                 return -EFAULT;
388         if (!(entry = drm_agp_lookup_entry(dev, request.handle)))
389                 return -EINVAL;
390         if (entry->bound)
391                 drm_unbind_agp(entry->memory);
392
393         if (entry->prev)
394                 entry->prev->next = entry->next;
395         else
396                 dev->agp->memory = entry->next;
397
398         if (entry->next)
399                 entry->next->prev = entry->prev;
400
401         drm_free_agp(entry->memory, entry->pages);
402         drm_free(entry, sizeof(*entry), DRM_MEM_AGPLISTS);
403         return 0;
404 }
405
406 /**
407  * Initialize the AGP resources.
408  *
409  * \return pointer to a drm_agp_head structure.
410  *
411  */
412 drm_agp_head_t *drm_agp_init(drm_device_t * dev)
413 {
414         drm_agp_head_t *head = NULL;
415
416         if (!(head = drm_alloc(sizeof(*head), DRM_MEM_AGPLISTS)))
417                 return NULL;
418         memset((void *)head, 0, sizeof(*head));
419         head->bridge = agp_find_bridge(dev->pdev);
420         if (!head->bridge) {
421                 if (!(head->bridge = agp_backend_acquire(dev->pdev))) {
422                         drm_free(head, sizeof(*head), DRM_MEM_AGPLISTS);
423                         return NULL;
424                 }
425                 agp_copy_info(head->bridge, &head->agp_info);
426                 agp_backend_release(head->bridge);
427         } else {
428                 agp_copy_info(head->bridge, &head->agp_info);
429         }
430         if (head->agp_info.chipset == NOT_SUPPORTED) {
431                 drm_free(head, sizeof(*head), DRM_MEM_AGPLISTS);
432                 return NULL;
433         }
434         head->memory = NULL;
435         head->cant_use_aperture = head->agp_info.cant_use_aperture;
436         head->page_mask = head->agp_info.page_mask;
437
438         return head;
439 }
440
441 /** Calls agp_allocate_memory() */
442 DRM_AGP_MEM *drm_agp_allocate_memory(struct agp_bridge_data * bridge,
443                                      size_t pages, u32 type)
444 {
445         return agp_allocate_memory(bridge, pages, type);
446 }
447
448 /** Calls agp_free_memory() */
449 int drm_agp_free_memory(DRM_AGP_MEM * handle)
450 {
451         if (!handle)
452                 return 0;
453         agp_free_memory(handle);
454         return 1;
455 }
456
457 /** Calls agp_bind_memory() */
458 int drm_agp_bind_memory(DRM_AGP_MEM * handle, off_t start)
459 {
460         if (!handle)
461                 return -EINVAL;
462         return agp_bind_memory(handle, start);
463 }
464
465 EXPORT_SYMBOL(drm_agp_bind_memory);
466
467 /** Calls agp_unbind_memory() */
468 int drm_agp_unbind_memory(DRM_AGP_MEM * handle)
469 {
470         if (!handle)
471                 return -EINVAL;
472         return agp_unbind_memory(handle);
473 }
474
475 #endif                          /* __OS_HAS_AGP */