?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 2.4.0-test7-pre4
[davej-history.git] / drivers / char / drm / agpsupport.c
blob42a1bc2f6d559e5541ccfcb59815828a8ceeb260
1 /* agpsupport.c -- DRM support for AGP/GART backend -*- linux-c -*-
2 * Created: Mon Dec 13 09:56:45 1999 by faith@precisioninsight.com
3 *
4 * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
5 * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
6 * All Rights Reserved.
7 *
8 * Permission is hereby granted, free of charge, to any person obtaining a
9 * copy of this software and associated documentation files (the "Software"),
10 * to deal in the Software without restriction, including without limitation
11 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
12 * and/or sell copies of the Software, and to permit persons to whom the
13 * Software is furnished to do so, subject to the following conditions:
14 *
15 * The above copyright notice and this permission notice (including the next
16 * paragraph) shall be included in all copies or substantial portions of the
17 * Software.
18 *
19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
22 * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
23 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
24 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
25 * DEALINGS IN THE SOFTWARE.
26 *
27 * Author: Rickard E. (Rik) Faith <faith@valinux.com>
28 *
29 */
30
31 #define __NO_VERSION__
32 #include "drmP.h"
33 #include <linux/module.h>
34
35 drm_agp_func_t drm_agp = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL };
36
37 /* The C standard says that 'void *' is not guaranteed to hold a function
38 pointer, so we use this union to define a generic pointer that is
39 guaranteed to hold any of the function pointers we care about. */
40 typedef union {
41 void (*free_memory)(agp_memory *);
42 agp_memory *(*allocate_memory)(size_t, u32);
43 int (*bind_memory)(agp_memory *, off_t);
44 int (*unbind_memory)(agp_memory *);
45 void (*enable)(u32);
46 int (*acquire)(void);
47 void (*release)(void);
48 void (*copy_info)(agp_kern_info *);
49 unsigned long address;
50 } drm_agp_func_u;
51
52 typedef struct drm_agp_fill {
53 const char *name;
54 drm_agp_func_u *f;
55 } drm_agp_fill_t;
56
57 static drm_agp_fill_t drm_agp_fill[] = {
58 { __MODULE_STRING(agp_free_memory),
59 (drm_agp_func_u *)&drm_agp.free_memory },
60 { __MODULE_STRING(agp_allocate_memory),
61 (drm_agp_func_u *)&drm_agp.allocate_memory },
62 { __MODULE_STRING(agp_bind_memory),
63 (drm_agp_func_u *)&drm_agp.bind_memory },
64 { __MODULE_STRING(agp_unbind_memory),
65 (drm_agp_func_u *)&drm_agp.unbind_memory },
66 { __MODULE_STRING(agp_enable),
67 (drm_agp_func_u *)&drm_agp.enable },
68 { __MODULE_STRING(agp_backend_acquire),
69 (drm_agp_func_u *)&drm_agp.acquire },
70 { __MODULE_STRING(agp_backend_release),
71 (drm_agp_func_u *)&drm_agp.release },
72 { __MODULE_STRING(agp_copy_info),
73 (drm_agp_func_u *)&drm_agp.copy_info },
74 { NULL, NULL }
75 };
76
77 int drm_agp_info(struct inode *inode, struct file *filp, unsigned int cmd,
78 unsigned long arg)
79 {
80 drm_file_t *priv = filp->private_data;
81 drm_device_t *dev = priv->dev;
82 agp_kern_info *kern;
83 drm_agp_info_t info;
84
85 if (!dev->agp->acquired || !drm_agp.copy_info) return -EINVAL;
86
87 kern = &dev->agp->agp_info;
88 info.agp_version_major = kern->version.major;
89 info.agp_version_minor = kern->version.minor;
90 info.mode = kern->mode;
91 info.aperture_base = kern->aper_base;
92 info.aperture_size = kern->aper_size * 1024 * 1024;
93 info.memory_allowed = kern->max_memory << PAGE_SHIFT;
94 info.memory_used = kern->current_memory << PAGE_SHIFT;
95 info.id_vendor = kern->device->vendor;
96 info.id_device = kern->device->device;
97
98 copy_to_user_ret((drm_agp_info_t *)arg, &info, sizeof(info), -EFAULT);
99 return 0;
100 }
101
102 int drm_agp_acquire(struct inode *inode, struct file *filp, unsigned int cmd,
103 unsigned long arg)
104 {
105 drm_file_t *priv = filp->private_data;
106 drm_device_t *dev = priv->dev;
107 int retcode;
108
109 if (dev->agp->acquired || !drm_agp.acquire) return -EINVAL;
110 if ((retcode = (*drm_agp.acquire)())) return retcode;
111 dev->agp->acquired = 1;
112 return 0;
113 }
114
115 int drm_agp_release(struct inode *inode, struct file *filp, unsigned int cmd,
116 unsigned long arg)
117 {
118 drm_file_t *priv = filp->private_data;
119 drm_device_t *dev = priv->dev;
120
121 if (!dev->agp->acquired || !drm_agp.release) return -EINVAL;
122 (*drm_agp.release)();
123 dev->agp->acquired = 0;
124 return 0;
125
126 }
127
128 int drm_agp_enable(struct inode *inode, struct file *filp, unsigned int cmd,
129 unsigned long arg)
130 {
131 drm_file_t *priv = filp->private_data;
132 drm_device_t *dev = priv->dev;
133 drm_agp_mode_t mode;
134
135 if (!dev->agp->acquired || !drm_agp.enable) return -EINVAL;
136
137 copy_from_user_ret(&mode, (drm_agp_mode_t *)arg, sizeof(mode),
138 -EFAULT);
139
140 dev->agp->mode = mode.mode;
141 (*drm_agp.enable)(mode.mode);
142 dev->agp->base = dev->agp->agp_info.aper_base;
143 dev->agp->enabled = 1;
144 return 0;
145 }
146
147 int drm_agp_alloc(struct inode *inode, struct file *filp, unsigned int cmd,
148 unsigned long arg)
149 {
150 drm_file_t *priv = filp->private_data;
151 drm_device_t *dev = priv->dev;
152 drm_agp_buffer_t request;
153 drm_agp_mem_t *entry;
154 agp_memory *memory;
155 unsigned long pages;
156 u32 type;
157 if (!dev->agp->acquired) return -EINVAL;
158 copy_from_user_ret(&request, (drm_agp_buffer_t *)arg, sizeof(request),
159 -EFAULT);
160 if (!(entry = drm_alloc(sizeof(*entry), DRM_MEM_AGPLISTS)))
161 return -ENOMEM;
162
163 memset(entry, 0, sizeof(*entry));
164
165 pages = (request.size + PAGE_SIZE - 1) / PAGE_SIZE;
166 type = (u32) request.type;
167
168 if (!(memory = drm_alloc_agp(pages, type))) {
169 drm_free(entry, sizeof(*entry), DRM_MEM_AGPLISTS);
170 return -ENOMEM;
171 }
172
173 entry->handle = (unsigned long)memory->memory;
174 entry->memory = memory;
175 entry->bound = 0;
176 entry->pages = pages;
177 entry->prev = NULL;
178 entry->next = dev->agp->memory;
179 if (dev->agp->memory) dev->agp->memory->prev = entry;
180 dev->agp->memory = entry;
181
182 request.handle = entry->handle;
183 request.physical = memory->physical;
184
185 if (copy_to_user((drm_agp_buffer_t *)arg, &request, sizeof(request))) {
186 dev->agp->memory = entry->next;
187 dev->agp->memory->prev = NULL;
188 drm_free_agp(memory, pages);
189 drm_free(entry, sizeof(*entry), DRM_MEM_AGPLISTS);
190 return -EFAULT;
191 }
192 return 0;
193 }
194
195 static drm_agp_mem_t *drm_agp_lookup_entry(drm_device_t *dev,
196 unsigned long handle)
197 {
198 drm_agp_mem_t *entry;
199
200 for (entry = dev->agp->memory; entry; entry = entry->next) {
201 if (entry->handle == handle) return entry;
202 }
203 return NULL;
204 }
205
206 int drm_agp_unbind(struct inode *inode, struct file *filp, unsigned int cmd,
207 unsigned long arg)
208 {
209 drm_file_t *priv = filp->private_data;
210 drm_device_t *dev = priv->dev;
211 drm_agp_binding_t request;
212 drm_agp_mem_t *entry;
213
214 if (!dev->agp->acquired) return -EINVAL;
215 copy_from_user_ret(&request, (drm_agp_binding_t *)arg, sizeof(request),
216 -EFAULT);
217 if (!(entry = drm_agp_lookup_entry(dev, request.handle)))
218 return -EINVAL;
219 if (!entry->bound) return -EINVAL;
220 return drm_unbind_agp(entry->memory);
221 }
222
223 int drm_agp_bind(struct inode *inode, struct file *filp, unsigned int cmd,
224 unsigned long arg)
225 {
226 drm_file_t *priv = filp->private_data;
227 drm_device_t *dev = priv->dev;
228 drm_agp_binding_t request;
229 drm_agp_mem_t *entry;
230 int retcode;
231 int page;
232
233 if (!dev->agp->acquired || !drm_agp.bind_memory) return -EINVAL;
234 copy_from_user_ret(&request, (drm_agp_binding_t *)arg, sizeof(request),
235 -EFAULT);
236 if (!(entry = drm_agp_lookup_entry(dev, request.handle)))
237 return -EINVAL;
238 if (entry->bound) return -EINVAL;
239 page = (request.offset + PAGE_SIZE - 1) / PAGE_SIZE;
240 if ((retcode = drm_bind_agp(entry->memory, page))) return retcode;
241 entry->bound = dev->agp->base + (page << PAGE_SHIFT);
242 DRM_DEBUG("base = 0x%lx entry->bound = 0x%lx\n",
243 dev->agp->base, entry->bound);
244 return 0;
245 }
246
247 int drm_agp_free(struct inode *inode, struct file *filp, unsigned int cmd,
248 unsigned long arg)
249 {
250 drm_file_t *priv = filp->private_data;
251 drm_device_t *dev = priv->dev;
252 drm_agp_buffer_t request;
253 drm_agp_mem_t *entry;
254
255 if (!dev->agp->acquired) return -EINVAL;
256 copy_from_user_ret(&request, (drm_agp_buffer_t *)arg, sizeof(request),
257 -EFAULT);
258 if (!(entry = drm_agp_lookup_entry(dev, request.handle)))
259 return -EINVAL;
260 if (entry->bound) drm_unbind_agp(entry->memory);
261
262 if (entry->prev) entry->prev->next = entry->next;
263 else dev->agp->memory = entry->next;
264 if (entry->next) entry->next->prev = entry->prev;
265 drm_free_agp(entry->memory, entry->pages);
266 drm_free(entry, sizeof(*entry), DRM_MEM_AGPLISTS);
267 return 0;
268 }
269
270 drm_agp_head_t *drm_agp_init(void)
271 {
272 drm_agp_fill_t *fill;
273 drm_agp_head_t *head = NULL;
274 int agp_available = 1;
275
276 for (fill = &drm_agp_fill[0]; fill->name; fill++) {
277 char *n = (char *)fill->name;
278 *fill->f = (drm_agp_func_u)get_module_symbol(NULL, n);
279 DRM_DEBUG("%s resolves to 0x%08lx\n", n, (*fill->f).address);
280 if (!(*fill->f).address) agp_available = 0;
281 }
282
283 DRM_DEBUG("agp_available = %d\n", agp_available);
284
285 if (agp_available) {
286 if (!(head = drm_alloc(sizeof(*head), DRM_MEM_AGPLISTS)))
287 return NULL;
288 memset((void *)head, 0, sizeof(*head));
289 (*drm_agp.copy_info)(&head->agp_info);
290 if (head->agp_info.chipset == NOT_SUPPORTED) {
291 drm_free(head, sizeof(*head), DRM_MEM_AGPLISTS);
292 return NULL;
293 }
294 head->memory = NULL;
295 switch (head->agp_info.chipset) {
296 case INTEL_GENERIC: head->chipset = "Intel"; break;
297 case INTEL_LX: head->chipset = "Intel 440LX"; break;
298 case INTEL_BX: head->chipset = "Intel 440BX"; break;
299 case INTEL_GX: head->chipset = "Intel 440GX"; break;
300 case INTEL_I810: head->chipset = "Intel i810"; break;
301
302 #if LINUX_VERSION_CODE >= 0x020400
303 case INTEL_I840: head->chipset = "Intel i840"; break;
304 #endif
305
306 case VIA_GENERIC: head->chipset = "VIA"; break;
307 case VIA_VP3: head->chipset = "VIA VP3"; break;
308 case VIA_MVP3: head->chipset = "VIA MVP3"; break;
309
310 #if LINUX_VERSION_CODE >= 0x020400
311 case VIA_MVP4: head->chipset = "VIA MVP4"; break;
312 case VIA_APOLLO_KX133: head->chipset = "VIA Apollo KX133";
313 break;
314 case VIA_APOLLO_KT133: head->chipset = "VIA Apollo KT133";
315 break;
316 #endif
317
318 case VIA_APOLLO_PRO: head->chipset = "VIA Apollo Pro";
319 break;
320 case SIS_GENERIC: head->chipset = "SiS"; break;
321 case AMD_GENERIC: head->chipset = "AMD"; break;
322 case AMD_IRONGATE: head->chipset = "AMD Irongate"; break;
323 case ALI_GENERIC: head->chipset = "ALi"; break;
324 case ALI_M1541: head->chipset = "ALi M1541"; break;
325 default: head->chipset = "Unknown"; break;
326 }
327 DRM_INFO("AGP %d.%d on %s @ 0x%08lx %ZuMB\n",
328 head->agp_info.version.major,
329 head->agp_info.version.minor,
330 head->chipset,
331 head->agp_info.aper_base,
332 head->agp_info.aper_size);
333 }
334 return head;
335 }
336
337 void drm_agp_uninit(void)
338 {
339 drm_agp_fill_t *fill;
340
341 for (fill = &drm_agp_fill[0]; fill->name; fill++) {
342 #if LINUX_VERSION_CODE >= 0x020400
343 if ((*fill->f).address) put_module_symbol((*fill->f).address);
344 #endif
345 (*fill->f).address = 0;
346 }
347 }
Copy of Dave Jones history.git as used by http://archive.org/details/git-history-of-linux