1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31#define __NO_VERSION__
32#include "drmP.h"
33#include <linux/module.h>
34#if LINUX_VERSION_CODE < 0x020400
35#include "agpsupport-pre24.h"
36#else
37#define DRM_AGP_GET (drm_agp_t *)inter_module_get("drm_agp")
38#define DRM_AGP_PUT inter_module_put("drm_agp")
39#endif
40
41static const drm_agp_t *drm_agp = NULL;
42
43int drm_agp_info(struct inode *inode, struct file *filp, unsigned int cmd,
44 unsigned long arg)
45{
46 drm_file_t *priv = filp->private_data;
47 drm_device_t *dev = priv->dev;
48 agp_kern_info *kern;
49 drm_agp_info_t info;
50
51 if (!dev->agp->acquired || !drm_agp->copy_info) return -EINVAL;
52
53 kern = &dev->agp->agp_info;
54 info.agp_version_major = kern->version.major;
55 info.agp_version_minor = kern->version.minor;
56 info.mode = kern->mode;
57 info.aperture_base = kern->aper_base;
58 info.aperture_size = kern->aper_size * 1024 * 1024;
59 info.memory_allowed = kern->max_memory << PAGE_SHIFT;
60 info.memory_used = kern->current_memory << PAGE_SHIFT;
61 info.id_vendor = kern->device->vendor;
62 info.id_device = kern->device->device;
63
64 if (copy_to_user((drm_agp_info_t *)arg, &info, sizeof(info)))
65 return -EFAULT;
66 return 0;
67}
68
69int drm_agp_acquire(struct inode *inode, struct file *filp, unsigned int cmd,
70 unsigned long arg)
71{
72 drm_file_t *priv = filp->private_data;
73 drm_device_t *dev = priv->dev;
74 int retcode;
75
76 if (dev->agp->acquired || !drm_agp->acquire) return -EINVAL;
77 if ((retcode = drm_agp->acquire())) return retcode;
78 dev->agp->acquired = 1;
79 return 0;
80}
81
82int drm_agp_release(struct inode *inode, struct file *filp, unsigned int cmd,
83 unsigned long arg)
84{
85 drm_file_t *priv = filp->private_data;
86 drm_device_t *dev = priv->dev;
87
88 if (!dev->agp->acquired || !drm_agp->release) return -EINVAL;
89 drm_agp->release();
90 dev->agp->acquired = 0;
91 return 0;
92
93}
94
95void _drm_agp_release(void)
96{
97 if (drm_agp->release) drm_agp->release();
98}
99
100int drm_agp_enable(struct inode *inode, struct file *filp, unsigned int cmd,
101 unsigned long arg)
102{
103 drm_file_t *priv = filp->private_data;
104 drm_device_t *dev = priv->dev;
105 drm_agp_mode_t mode;
106
107 if (!dev->agp->acquired || !drm_agp->enable) return -EINVAL;
108
109 if (copy_from_user(&mode, (drm_agp_mode_t *)arg, sizeof(mode)))
110 return -EFAULT;
111
112 dev->agp->mode = mode.mode;
113 drm_agp->enable(mode.mode);
114 dev->agp->base = dev->agp->agp_info.aper_base;
115 dev->agp->enabled = 1;
116 return 0;
117}
118
119int drm_agp_alloc(struct inode *inode, struct file *filp, unsigned int cmd,
120 unsigned long arg)
121{
122 drm_file_t *priv = filp->private_data;
123 drm_device_t *dev = priv->dev;
124 drm_agp_buffer_t request;
125 drm_agp_mem_t *entry;
126 agp_memory *memory;
127 unsigned long pages;
128 u32 type;
129 if (!dev->agp->acquired) return -EINVAL;
130 if (copy_from_user(&request, (drm_agp_buffer_t *)arg, sizeof(request)))
131 return -EFAULT;
132 if (!(entry = drm_alloc(sizeof(*entry), DRM_MEM_AGPLISTS)))
133 return -ENOMEM;
134
135 memset(entry, 0, sizeof(*entry));
136
137 pages = (request.size + PAGE_SIZE - 1) / PAGE_SIZE;
138 type = (u32) request.type;
139
140 if (!(memory = drm_alloc_agp(pages, type))) {
141 drm_free(entry, sizeof(*entry), DRM_MEM_AGPLISTS);
142 return -ENOMEM;
143 }
144
145 entry->handle = (unsigned long)memory->memory;
146 entry->memory = memory;
147 entry->bound = 0;
148 entry->pages = pages;
149 entry->prev = NULL;
150 entry->next = dev->agp->memory;
151 if (dev->agp->memory) dev->agp->memory->prev = entry;
152 dev->agp->memory = entry;
153
154 request.handle = entry->handle;
155 request.physical = memory->physical;
156
157 if (copy_to_user((drm_agp_buffer_t *)arg, &request, sizeof(request))) {
158 dev->agp->memory = entry->next;
159 dev->agp->memory->prev = NULL;
160 drm_free_agp(memory, pages);
161 drm_free(entry, sizeof(*entry), DRM_MEM_AGPLISTS);
162 return -EFAULT;
163 }
164 return 0;
165}
166
167static drm_agp_mem_t *drm_agp_lookup_entry(drm_device_t *dev,
168 unsigned long handle)
169{
170 drm_agp_mem_t *entry;
171
172 for (entry = dev->agp->memory; entry; entry = entry->next) {
173 if (entry->handle == handle) return entry;
174 }
175 return NULL;
176}
177
178int drm_agp_unbind(struct inode *inode, struct file *filp, unsigned int cmd,
179 unsigned long arg)
180{
181 drm_file_t *priv = filp->private_data;
182 drm_device_t *dev = priv->dev;
183 drm_agp_binding_t request;
184 drm_agp_mem_t *entry;
185
186 if (!dev->agp->acquired) return -EINVAL;
187 if (copy_from_user(&request, (drm_agp_binding_t *)arg, sizeof(request)))
188 return -EFAULT;
189 if (!(entry = drm_agp_lookup_entry(dev, request.handle)))
190 return -EINVAL;
191 if (!entry->bound) return -EINVAL;
192 return drm_unbind_agp(entry->memory);
193}
194
195int drm_agp_bind(struct inode *inode, struct file *filp, unsigned int cmd,
196 unsigned long arg)
197{
198 drm_file_t *priv = filp->private_data;
199 drm_device_t *dev = priv->dev;
200 drm_agp_binding_t request;
201 drm_agp_mem_t *entry;
202 int retcode;
203 int page;
204
205 if (!dev->agp->acquired || !drm_agp->bind_memory) return -EINVAL;
206 if (copy_from_user(&request, (drm_agp_binding_t *)arg, sizeof(request)))
207 return -EFAULT;
208 if (!(entry = drm_agp_lookup_entry(dev, request.handle)))
209 return -EINVAL;
210 if (entry->bound) return -EINVAL;
211 page = (request.offset + PAGE_SIZE - 1) / PAGE_SIZE;
212 if ((retcode = drm_bind_agp(entry->memory, page))) return retcode;
213 entry->bound = dev->agp->base + (page << PAGE_SHIFT);
214 DRM_DEBUG("base = 0x%lx entry->bound = 0x%lx\n",
215 dev->agp->base, entry->bound);
216 return 0;
217}
218
219int drm_agp_free(struct inode *inode, struct file *filp, unsigned int cmd,
220 unsigned long arg)
221{
222 drm_file_t *priv = filp->private_data;
223 drm_device_t *dev = priv->dev;
224 drm_agp_buffer_t request;
225 drm_agp_mem_t *entry;
226
227 if (!dev->agp->acquired) return -EINVAL;
228 if (copy_from_user(&request, (drm_agp_buffer_t *)arg, sizeof(request)))
229 return -EFAULT;
230 if (!(entry = drm_agp_lookup_entry(dev, request.handle)))
231 return -EINVAL;
232 if (entry->bound) drm_unbind_agp(entry->memory);
233
234 if (entry->prev) entry->prev->next = entry->next;
235 else dev->agp->memory = entry->next;
236 if (entry->next) entry->next->prev = entry->prev;
237 drm_free_agp(entry->memory, entry->pages);
238 drm_free(entry, sizeof(*entry), DRM_MEM_AGPLISTS);
239 return 0;
240}
241
242drm_agp_head_t *drm_agp_init(void)
243{
244 drm_agp_head_t *head = NULL;
245
246 drm_agp = DRM_AGP_GET;
247 if (drm_agp) {
248 if (!(head = drm_alloc(sizeof(*head), DRM_MEM_AGPLISTS)))
249 return NULL;
250 memset((void *)head, 0, sizeof(*head));
251 drm_agp->copy_info(&head->agp_info);
252 if (head->agp_info.chipset == NOT_SUPPORTED) {
253 drm_free(head, sizeof(*head), DRM_MEM_AGPLISTS);
254 return NULL;
255 }
256 head->memory = NULL;
257 switch (head->agp_info.chipset) {
258 case INTEL_GENERIC: head->chipset = "Intel"; break;
259 case INTEL_LX: head->chipset = "Intel 440LX"; break;
260 case INTEL_BX: head->chipset = "Intel 440BX"; break;
261 case INTEL_GX: head->chipset = "Intel 440GX"; break;
262 case INTEL_I810: head->chipset = "Intel i810"; break;
263
264#if LINUX_VERSION_CODE >= 0x020400
265 case INTEL_I840: head->chipset = "Intel i840"; break;
266#endif
267
268 case VIA_GENERIC: head->chipset = "VIA"; break;
269 case VIA_VP3: head->chipset = "VIA VP3"; break;
270 case VIA_MVP3: head->chipset = "VIA MVP3"; break;
271
272#if LINUX_VERSION_CODE >= 0x020400
273 case VIA_MVP4: head->chipset = "VIA MVP4"; break;
274 case VIA_APOLLO_KX133: head->chipset = "VIA Apollo KX133";
275 break;
276 case VIA_APOLLO_KT133: head->chipset = "VIA Apollo KT133";
277 break;
278 case VIA_APOLLO_KT400: head->chipset = "VIA Apollo KT400";
279 break;
280 case VIA_APOLLO_P4X400: head->chipset = "VIA Apollo P4X400";
281 break;
282#endif
283
284 case VIA_APOLLO_PRO: head->chipset = "VIA Apollo Pro";
285 break;
286 case SIS_GENERIC: head->chipset = "SiS"; break;
287 case AMD_GENERIC: head->chipset = "AMD"; break;
288 case AMD_IRONGATE: head->chipset = "AMD Irongate"; break;
289 case ALI_GENERIC: head->chipset = "ALi"; break;
290 case ALI_M1541: head->chipset = "ALi M1541"; break;
291 case ALI_M1621: head->chipset = "ALi M1621"; break;
292 case ALI_M1631: head->chipset = "ALi M1631"; break;
293 case ALI_M1632: head->chipset = "ALi M1632"; break;
294 case ALI_M1641: head->chipset = "ALi M1641"; break;
295 case ALI_M1647: head->chipset = "ALi M1647"; break;
296 case ALI_M1651: head->chipset = "ALi M1651"; break;
297 case SVWRKS_GENERIC: head->chipset = "Serverworks Generic";
298 break;
299 case SVWRKS_HE: head->chipset = "Serverworks HE"; break;
300 case SVWRKS_LE: head->chipset = "Serverworks LE"; break;
301
302 default: head->chipset = "Unknown"; break;
303 }
304 DRM_INFO("AGP %d.%d on %s @ 0x%08lx %ZuMB\n",
305 head->agp_info.version.major,
306 head->agp_info.version.minor,
307 head->chipset,
308 head->agp_info.aper_base,
309 head->agp_info.aper_size);
310 }
311 return head;
312}
313
314void drm_agp_uninit(void)
315{
316 DRM_AGP_PUT;
317 drm_agp = NULL;
318}
319
320agp_memory *drm_agp_allocate_memory(size_t pages, u32 type)
321{
322 if (!drm_agp->allocate_memory) return NULL;
323 return drm_agp->allocate_memory(pages, type);
324}
325
326int drm_agp_free_memory(agp_memory *handle)
327{
328 if (!handle || !drm_agp->free_memory) return 0;
329 drm_agp->free_memory(handle);
330 return 1;
331}
332
333int drm_agp_bind_memory(agp_memory *handle, off_t start)
334{
335 if (!handle || !drm_agp->bind_memory) return -EINVAL;
336 return drm_agp->bind_memory(handle, start);
337}
338
339int drm_agp_unbind_memory(agp_memory *handle)
340{
341 if (!handle || !drm_agp->unbind_memory) return -EINVAL;
342 return drm_agp->unbind_memory(handle);
343}
344
