1 /*
2 * AGPGART driver backend routines.
3 * Copyright (C) 2002-2003 Dave Jones.
4 * Copyright (C) 1999 Jeff Hartmann.
5 * Copyright (C) 1999 Precision Insight, Inc.
6 * Copyright (C) 1999 Xi Graphics, Inc.
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 shall be included
16 * in all copies or substantial portions of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
21 * JEFF HARTMANN, DAVE JONES, OR ANY OTHER CONTRIBUTORS BE LIABLE FOR ANY CLAIM,
22 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
23 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
24 * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 *
26 * TODO:
27 * - Allocate more than order 0 pages to avoid too much linear map splitting.
28 */
29 #include <linux/module.h>
30 #include <linux/pci.h>
31 #include <linux/init.h>
32 #include <linux/pagemap.h>
33 #include <linux/miscdevice.h>
34 #include <linux/pm.h>
35 #include <linux/agp_backend.h>
36 #include <linux/agpgart.h>
37 #include <linux/vmalloc.h>
38 #include <asm/io.h>
39 #include "agp.h"
40
41 /* Due to XFree86 brain-damage, we can't go to 1.0 until they
42 * fix some real stupidity. It's only by chance we can bump
43 * past 0.99 at all due to some boolean logic error. */
44 #define AGPGART_VERSION_MAJOR 0
45 #define AGPGART_VERSION_MINOR 100
46 static struct agp_version agp_current_version =
47 {
48 .major = AGPGART_VERSION_MAJOR,
49 .minor = AGPGART_VERSION_MINOR,
50 };
51
52 static int agp_count=0;
53
54 struct agp_bridge_data agp_bridge_dummy = { .type = NOT_SUPPORTED };
55 struct agp_bridge_data *agp_bridge = &agp_bridge_dummy;
56 EXPORT_SYMBOL(agp_bridge);
57
58
59 /**
60 * agp_backend_acquire - attempt to acquire the agp backend.
61 *
62 * returns -EBUSY if agp is in use,
63 * returns 0 if the caller owns the agp backend
64 */
65 int agp_backend_acquire(void)
66 {
67 if (agp_bridge->type == NOT_SUPPORTED)
68 return -EINVAL;
69 if (atomic_read(&agp_bridge->agp_in_use))
70 return -EBUSY;
71 atomic_inc(&agp_bridge->agp_in_use);
72 return 0;
73 }
74 EXPORT_SYMBOL(agp_backend_acquire);
75
76
77 /**
78 * agp_backend_release - release the lock on the agp backend.
79 *
80 * The caller must insure that the graphics aperture translation table
81 * is read for use by another entity.
82 *
83 * (Ensure that all memory it bound is unbound.)
84 */
85 void agp_backend_release(void)
86 {
87 if (agp_bridge->type != NOT_SUPPORTED)
88 atomic_dec(&agp_bridge->agp_in_use);
89 }
90 EXPORT_SYMBOL(agp_backend_release);
91
92
93 struct { int mem, agp; } maxes_table[] = {
94 {0, 0},
95 {32, 4},
96 {64, 28},
97 {128, 96},
98 {256, 204},
99 {512, 440},
100 {1024, 942},
101 {2048, 1920},
102 {4096, 3932}
103 };
104
105 static int agp_find_max(void)
106 {
107 long memory, index, result;
108
109 #if PAGE_SHIFT < 20
110 memory = num_physpages >> (20 - PAGE_SHIFT);
111 #else
112 memory = num_physpages << (PAGE_SHIFT - 20);
113 #endif
114 index = 1;
115
116 while ((memory > maxes_table[index].mem) && (index < 8))
117 index++;
118
119 result = maxes_table[index - 1].agp +
120 ( (memory - maxes_table[index - 1].mem) *
121 (maxes_table[index].agp - maxes_table[index - 1].agp)) /
122 (maxes_table[index].mem - maxes_table[index - 1].mem);
123
124 printk(KERN_INFO PFX "Maximum main memory to use for agp memory: %ldM\n", result);
125 result = result << (20 - PAGE_SHIFT);
126 return result;
127 }
128
129
130 static int agp_backend_initialize(struct agp_bridge_data *bridge)
131 {
132 int size_value, rc, got_gatt=0, got_keylist=0;
133
134 bridge->max_memory_agp = agp_find_max();
135 bridge->version = &agp_current_version;
136
137 if (bridge->driver->needs_scratch_page) {
138 void *addr = bridge->driver->agp_alloc_page();
139
140 if (!addr) {
141 printk(KERN_ERR PFX "unable to get memory for scratch page.\n");
142 return -ENOMEM;
143 }
144
145 bridge->scratch_page_real = virt_to_phys(addr);
146 bridge->scratch_page =
147 bridge->driver->mask_memory(bridge->scratch_page_real, 0);
148 }
149
150 size_value = bridge->driver->fetch_size();
151 if (size_value == 0) {
152 printk(KERN_ERR PFX "unable to determine aperture size.\n");
153 rc = -EINVAL;
154 goto err_out;
155 }
156 if (bridge->driver->create_gatt_table()) {
157 printk(KERN_ERR PFX
158 "unable to get memory for graphics translation table.\n");
159 rc = -ENOMEM;
160 goto err_out;
161 }
162 got_gatt = 1;
163
164 bridge->key_list = vmalloc(PAGE_SIZE * 4);
165 if (bridge->key_list == NULL) {
166 printk(KERN_ERR PFX "error allocating memory for key lists.\n");
167 rc = -ENOMEM;
168 goto err_out;
169 }
170 got_keylist = 1;
171
172 /* FIXME vmalloc'd memory not guaranteed contiguous */
173 memset(bridge->key_list, 0, PAGE_SIZE * 4);
174
175 if (bridge->driver->configure()) {
176 printk(KERN_ERR PFX "error configuring host chipset.\n");
177 rc = -EINVAL;
178 goto err_out;
179 }
180
181 printk(KERN_INFO PFX "AGP aperture is %dM @ 0x%lx\n",
182 size_value, bridge->gart_bus_addr);
183
184 return 0;
185
186 err_out:
187 if (bridge->driver->needs_scratch_page)
188 bridge->driver->agp_destroy_page(
189 phys_to_virt(bridge->scratch_page_real));
190 if (got_gatt)
191 bridge->driver->free_gatt_table();
192 if (got_keylist) {
193 vfree(bridge->key_list);
194 bridge->key_list = NULL;
195 }
196 return rc;
197 }
198
199 /* cannot be __exit b/c as it could be called from __init code */
200 static void agp_backend_cleanup(struct agp_bridge_data *bridge)
201 {
202 if (bridge->driver->cleanup)
203 bridge->driver->cleanup();
204 if (bridge->driver->free_gatt_table)
205 bridge->driver->free_gatt_table();
206 if (bridge->key_list) {
207 vfree(bridge->key_list);
208 bridge->key_list = NULL;
209 }
210
211 if (bridge->driver->agp_destroy_page &&
212 bridge->driver->needs_scratch_page)
213 bridge->driver->agp_destroy_page(
214 phys_to_virt(bridge->scratch_page_real));
215 }
216
217 /* XXX Kludge alert: agpgart isn't ready for multiple bridges yet */
218 struct agp_bridge_data *agp_alloc_bridge(void)
219 {
220 return agp_bridge;
221 }
222 EXPORT_SYMBOL(agp_alloc_bridge);
223
224
225 void agp_put_bridge(struct agp_bridge_data *bridge)
226 {
227 }
228 EXPORT_SYMBOL(agp_put_bridge);
229
230
231 int agp_add_bridge(struct agp_bridge_data *bridge)
232 {
233 int error;
234
235 if (agp_off)
236 return -ENODEV;
237
238 if (!bridge->dev) {
239 printk (KERN_DEBUG PFX "Erk, registering with no pci_dev!\n");
240 return -EINVAL;
241 }
242
243 if (agp_count) {
244 printk (KERN_INFO PFX
245 "Only one agpgart device currently supported.\n");
246 return -ENODEV;
247 }
248
249 /* Grab reference on the chipset driver. */
250 if (!try_module_get(bridge->driver->owner)) {
251 printk (KERN_INFO PFX "Couldn't lock chipset driver.\n");
252 return -EINVAL;
253 }
254
255 bridge->type = SUPPORTED;
256
257 error = agp_backend_initialize(agp_bridge);
258 if (error) {
259 printk (KERN_INFO PFX "agp_backend_initialize() failed.\n");
260 goto err_out;
261 }
262
263 error = agp_frontend_initialize();
264 if (error) {
265 printk (KERN_INFO PFX "agp_frontend_initialize() failed.\n");
266 goto frontend_err;
267 }
268
269 agp_count++;
270 return 0;
271
272 frontend_err:
273 agp_backend_cleanup(agp_bridge);
274 err_out:
275 bridge->type = NOT_SUPPORTED;
276 module_put(bridge->driver->owner);
277 return error;
278 }
279 EXPORT_SYMBOL_GPL(agp_add_bridge);
280
281
282 void agp_remove_bridge(struct agp_bridge_data *bridge)
283 {
284 bridge->type = NOT_SUPPORTED;
285 agp_frontend_cleanup();
286 agp_backend_cleanup(bridge);
287 agp_count--;
288 module_put(bridge->driver->owner);
289 }
290 EXPORT_SYMBOL_GPL(agp_remove_bridge);
291
292 int agp_off;
293 int agp_try_unsupported_boot;
294 EXPORT_SYMBOL(agp_off);
295 EXPORT_SYMBOL(agp_try_unsupported_boot);
296
297 static int __init agp_init(void)
298 {
299 if (!agp_off)
300 printk(KERN_INFO "Linux agpgart interface v%d.%d (c) Dave Jones\n",
301 AGPGART_VERSION_MAJOR, AGPGART_VERSION_MINOR);
302 return 0;
303 }
304
305 void __exit agp_exit(void)
306 {
307 }
308
309 #ifndef MODULE
310 static __init int agp_setup(char *s)
311 {
312 if (!strcmp(s,"off"))
313 agp_off = 1;
314 if (!strcmp(s,"try_unsupported"))
315 agp_try_unsupported_boot = 1;
316 return 1;
317 }
318 __setup("agp=", agp_setup);
319 #endif
320
321 MODULE_AUTHOR("Dave Jones <davej@codemonkey.org.uk>");
322 MODULE_DESCRIPTION("AGP GART driver");
323 MODULE_LICENSE("GPL and additional rights");
324 MODULE_ALIAS_MISCDEV(AGPGART_MINOR);
325
326 module_init(agp_init);
327 module_exit(agp_exit);
328
329
|
This page was automatically generated by the
LXR engine.
|