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