]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
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> | |
5a0e3ad6 | 33 | #include <linux/slab.h> |
1da177e4 LT |
34 | #include <linux/pagemap.h> |
35 | #include <linux/miscdevice.h> | |
36 | #include <linux/pm.h> | |
37 | #include <linux/agp_backend.h> | |
38 | #include <linux/agpgart.h> | |
39 | #include <linux/vmalloc.h> | |
40 | #include <asm/io.h> | |
41 | #include "agp.h" | |
42 | ||
43 | /* Due to XFree86 brain-damage, we can't go to 1.0 until they | |
44 | * fix some real stupidity. It's only by chance we can bump | |
45 | * past 0.99 at all due to some boolean logic error. */ | |
46 | #define AGPGART_VERSION_MAJOR 0 | |
a13af4b4 | 47 | #define AGPGART_VERSION_MINOR 103 |
e7745d4e | 48 | static const struct agp_version agp_current_version = |
1da177e4 LT |
49 | { |
50 | .major = AGPGART_VERSION_MAJOR, | |
51 | .minor = AGPGART_VERSION_MINOR, | |
52 | }; | |
53 | ||
54 | struct agp_bridge_data *(*agp_find_bridge)(struct pci_dev *) = | |
55 | &agp_generic_find_bridge; | |
56 | ||
57 | struct agp_bridge_data *agp_bridge; | |
58 | LIST_HEAD(agp_bridges); | |
59 | EXPORT_SYMBOL(agp_bridge); | |
60 | EXPORT_SYMBOL(agp_bridges); | |
61 | EXPORT_SYMBOL(agp_find_bridge); | |
62 | ||
63 | /** | |
64 | * agp_backend_acquire - attempt to acquire an agp backend. | |
65 | * | |
66 | */ | |
67 | struct agp_bridge_data *agp_backend_acquire(struct pci_dev *pdev) | |
68 | { | |
69 | struct agp_bridge_data *bridge; | |
70 | ||
71 | bridge = agp_find_bridge(pdev); | |
72 | ||
73 | if (!bridge) | |
74 | return NULL; | |
75 | ||
76 | if (atomic_read(&bridge->agp_in_use)) | |
77 | return NULL; | |
78 | atomic_inc(&bridge->agp_in_use); | |
79 | return bridge; | |
80 | } | |
81 | EXPORT_SYMBOL(agp_backend_acquire); | |
82 | ||
83 | ||
84 | /** | |
85 | * agp_backend_release - release the lock on the agp backend. | |
86 | * | |
87 | * The caller must insure that the graphics aperture translation table | |
88 | * is read for use by another entity. | |
89 | * | |
90 | * (Ensure that all memory it bound is unbound.) | |
91 | */ | |
92 | void agp_backend_release(struct agp_bridge_data *bridge) | |
93 | { | |
94 | ||
95 | if (bridge) | |
96 | atomic_dec(&bridge->agp_in_use); | |
97 | } | |
98 | EXPORT_SYMBOL(agp_backend_release); | |
99 | ||
100 | ||
5e9ad06a | 101 | static const struct { int mem, agp; } maxes_table[] = { |
1da177e4 LT |
102 | {0, 0}, |
103 | {32, 4}, | |
104 | {64, 28}, | |
105 | {128, 96}, | |
106 | {256, 204}, | |
107 | {512, 440}, | |
108 | {1024, 942}, | |
109 | {2048, 1920}, | |
110 | {4096, 3932} | |
111 | }; | |
112 | ||
113 | static int agp_find_max(void) | |
114 | { | |
115 | long memory, index, result; | |
116 | ||
117 | #if PAGE_SHIFT < 20 | |
4481374c | 118 | memory = totalram_pages >> (20 - PAGE_SHIFT); |
1da177e4 | 119 | #else |
4481374c | 120 | memory = totalram_pages << (PAGE_SHIFT - 20); |
1da177e4 LT |
121 | #endif |
122 | index = 1; | |
123 | ||
124 | while ((memory > maxes_table[index].mem) && (index < 8)) | |
125 | index++; | |
126 | ||
127 | result = maxes_table[index - 1].agp + | |
128 | ( (memory - maxes_table[index - 1].mem) * | |
129 | (maxes_table[index].agp - maxes_table[index - 1].agp)) / | |
130 | (maxes_table[index].mem - maxes_table[index - 1].mem); | |
131 | ||
132 | result = result << (20 - PAGE_SHIFT); | |
133 | return result; | |
134 | } | |
135 | ||
136 | ||
137 | static int agp_backend_initialize(struct agp_bridge_data *bridge) | |
138 | { | |
139 | int size_value, rc, got_gatt=0, got_keylist=0; | |
140 | ||
141 | bridge->max_memory_agp = agp_find_max(); | |
142 | bridge->version = &agp_current_version; | |
143 | ||
144 | if (bridge->driver->needs_scratch_page) { | |
07613ba2 | 145 | struct page *page = bridge->driver->agp_alloc_page(bridge); |
1da177e4 | 146 | |
07613ba2 | 147 | if (!page) { |
e3cf6951 BH |
148 | dev_err(&bridge->dev->dev, |
149 | "can't get memory for scratch page\n"); | |
1da177e4 LT |
150 | return -ENOMEM; |
151 | } | |
152 | ||
c2980d8c | 153 | bridge->scratch_page_page = page; |
56ec4c1e | 154 | if (bridge->driver->agp_map_page) { |
c2980d8c | 155 | if (bridge->driver->agp_map_page(page, |
56ec4c1e DW |
156 | &bridge->scratch_page_dma)) { |
157 | dev_err(&bridge->dev->dev, | |
158 | "unable to dma-map scratch page\n"); | |
159 | rc = -ENOMEM; | |
160 | goto err_out_nounmap; | |
161 | } | |
162 | } else { | |
6a12235c | 163 | bridge->scratch_page_dma = page_to_phys(page); |
ff663cf8 | 164 | } |
56ec4c1e DW |
165 | |
166 | bridge->scratch_page = bridge->driver->mask_memory(bridge, | |
167 | bridge->scratch_page_dma, 0); | |
1da177e4 LT |
168 | } |
169 | ||
170 | size_value = bridge->driver->fetch_size(); | |
171 | if (size_value == 0) { | |
e3cf6951 | 172 | dev_err(&bridge->dev->dev, "can't determine aperture size\n"); |
1da177e4 LT |
173 | rc = -EINVAL; |
174 | goto err_out; | |
175 | } | |
176 | if (bridge->driver->create_gatt_table(bridge)) { | |
e3cf6951 BH |
177 | dev_err(&bridge->dev->dev, |
178 | "can't get memory for graphics translation table\n"); | |
1da177e4 LT |
179 | rc = -ENOMEM; |
180 | goto err_out; | |
181 | } | |
182 | got_gatt = 1; | |
183 | ||
184 | bridge->key_list = vmalloc(PAGE_SIZE * 4); | |
185 | if (bridge->key_list == NULL) { | |
e3cf6951 BH |
186 | dev_err(&bridge->dev->dev, |
187 | "can't allocate memory for key lists\n"); | |
1da177e4 LT |
188 | rc = -ENOMEM; |
189 | goto err_out; | |
190 | } | |
191 | got_keylist = 1; | |
192 | ||
193 | /* FIXME vmalloc'd memory not guaranteed contiguous */ | |
194 | memset(bridge->key_list, 0, PAGE_SIZE * 4); | |
195 | ||
196 | if (bridge->driver->configure()) { | |
e3cf6951 | 197 | dev_err(&bridge->dev->dev, "error configuring host chipset\n"); |
1da177e4 LT |
198 | rc = -EINVAL; |
199 | goto err_out; | |
200 | } | |
a8c84df9 KP |
201 | INIT_LIST_HEAD(&bridge->mapped_list); |
202 | spin_lock_init(&bridge->mapped_lock); | |
1da177e4 LT |
203 | |
204 | return 0; | |
205 | ||
206 | err_out: | |
ff663cf8 ZW |
207 | if (bridge->driver->needs_scratch_page && |
208 | bridge->driver->agp_unmap_page) { | |
c2980d8c DW |
209 | bridge->driver->agp_unmap_page(bridge->scratch_page_page, |
210 | bridge->scratch_page_dma); | |
ff663cf8 ZW |
211 | } |
212 | err_out_nounmap: | |
88d51967 | 213 | if (bridge->driver->needs_scratch_page) { |
c2980d8c | 214 | void *va = page_address(bridge->scratch_page_page); |
da503fa6 JB |
215 | |
216 | bridge->driver->agp_destroy_page(va, AGP_PAGE_DESTROY_UNMAP); | |
217 | bridge->driver->agp_destroy_page(va, AGP_PAGE_DESTROY_FREE); | |
88d51967 | 218 | } |
1da177e4 LT |
219 | if (got_gatt) |
220 | bridge->driver->free_gatt_table(bridge); | |
221 | if (got_keylist) { | |
222 | vfree(bridge->key_list); | |
223 | bridge->key_list = NULL; | |
224 | } | |
225 | return rc; | |
226 | } | |
227 | ||
228 | /* cannot be __exit b/c as it could be called from __init code */ | |
229 | static void agp_backend_cleanup(struct agp_bridge_data *bridge) | |
230 | { | |
231 | if (bridge->driver->cleanup) | |
232 | bridge->driver->cleanup(); | |
233 | if (bridge->driver->free_gatt_table) | |
234 | bridge->driver->free_gatt_table(bridge); | |
f9101210 JJ |
235 | |
236 | vfree(bridge->key_list); | |
237 | bridge->key_list = NULL; | |
1da177e4 LT |
238 | |
239 | if (bridge->driver->agp_destroy_page && | |
88d51967 | 240 | bridge->driver->needs_scratch_page) { |
c2980d8c | 241 | void *va = page_address(bridge->scratch_page_page); |
da503fa6 | 242 | |
ff663cf8 | 243 | if (bridge->driver->agp_unmap_page) |
c2980d8c DW |
244 | bridge->driver->agp_unmap_page(bridge->scratch_page_page, |
245 | bridge->scratch_page_dma); | |
ff663cf8 | 246 | |
da503fa6 JB |
247 | bridge->driver->agp_destroy_page(va, AGP_PAGE_DESTROY_UNMAP); |
248 | bridge->driver->agp_destroy_page(va, AGP_PAGE_DESTROY_FREE); | |
88d51967 | 249 | } |
1da177e4 LT |
250 | } |
251 | ||
252 | /* When we remove the global variable agp_bridge from all drivers | |
253 | * then agp_alloc_bridge and agp_generic_find_bridge need to be updated | |
254 | */ | |
255 | ||
256 | struct agp_bridge_data *agp_alloc_bridge(void) | |
257 | { | |
0ea27d9f | 258 | struct agp_bridge_data *bridge; |
6a92a4e0 | 259 | |
0ea27d9f | 260 | bridge = kzalloc(sizeof(*bridge), GFP_KERNEL); |
1da177e4 LT |
261 | if (!bridge) |
262 | return NULL; | |
263 | ||
1da177e4 LT |
264 | atomic_set(&bridge->agp_in_use, 0); |
265 | atomic_set(&bridge->current_memory_agp, 0); | |
266 | ||
267 | if (list_empty(&agp_bridges)) | |
268 | agp_bridge = bridge; | |
269 | ||
270 | return bridge; | |
271 | } | |
272 | EXPORT_SYMBOL(agp_alloc_bridge); | |
273 | ||
274 | ||
275 | void agp_put_bridge(struct agp_bridge_data *bridge) | |
276 | { | |
277 | kfree(bridge); | |
278 | ||
279 | if (list_empty(&agp_bridges)) | |
280 | agp_bridge = NULL; | |
281 | } | |
282 | EXPORT_SYMBOL(agp_put_bridge); | |
283 | ||
284 | ||
285 | int agp_add_bridge(struct agp_bridge_data *bridge) | |
286 | { | |
287 | int error; | |
288 | ||
3f50b022 KW |
289 | if (agp_off) { |
290 | error = -ENODEV; | |
291 | goto err_put_bridge; | |
292 | } | |
1da177e4 LT |
293 | |
294 | if (!bridge->dev) { | |
295 | printk (KERN_DEBUG PFX "Erk, registering with no pci_dev!\n"); | |
3f50b022 KW |
296 | error = -EINVAL; |
297 | goto err_put_bridge; | |
1da177e4 LT |
298 | } |
299 | ||
300 | /* Grab reference on the chipset driver. */ | |
301 | if (!try_module_get(bridge->driver->owner)) { | |
e3cf6951 | 302 | dev_info(&bridge->dev->dev, "can't lock chipset driver\n"); |
3f50b022 KW |
303 | error = -EINVAL; |
304 | goto err_put_bridge; | |
1da177e4 LT |
305 | } |
306 | ||
307 | error = agp_backend_initialize(bridge); | |
308 | if (error) { | |
e3cf6951 BH |
309 | dev_info(&bridge->dev->dev, |
310 | "agp_backend_initialize() failed\n"); | |
1da177e4 LT |
311 | goto err_out; |
312 | } | |
313 | ||
314 | if (list_empty(&agp_bridges)) { | |
315 | error = agp_frontend_initialize(); | |
316 | if (error) { | |
e3cf6951 BH |
317 | dev_info(&bridge->dev->dev, |
318 | "agp_frontend_initialize() failed\n"); | |
1da177e4 LT |
319 | goto frontend_err; |
320 | } | |
321 | ||
e3cf6951 BH |
322 | dev_info(&bridge->dev->dev, "AGP aperture is %dM @ 0x%lx\n", |
323 | bridge->driver->fetch_size(), bridge->gart_bus_addr); | |
1da177e4 LT |
324 | |
325 | } | |
326 | ||
327 | list_add(&bridge->list, &agp_bridges); | |
328 | return 0; | |
329 | ||
330 | frontend_err: | |
331 | agp_backend_cleanup(bridge); | |
332 | err_out: | |
333 | module_put(bridge->driver->owner); | |
3f50b022 | 334 | err_put_bridge: |
1da177e4 LT |
335 | agp_put_bridge(bridge); |
336 | return error; | |
337 | } | |
338 | EXPORT_SYMBOL_GPL(agp_add_bridge); | |
339 | ||
340 | ||
341 | void agp_remove_bridge(struct agp_bridge_data *bridge) | |
342 | { | |
343 | agp_backend_cleanup(bridge); | |
344 | list_del(&bridge->list); | |
345 | if (list_empty(&agp_bridges)) | |
346 | agp_frontend_cleanup(); | |
347 | module_put(bridge->driver->owner); | |
348 | } | |
349 | EXPORT_SYMBOL_GPL(agp_remove_bridge); | |
350 | ||
351 | int agp_off; | |
352 | int agp_try_unsupported_boot; | |
353 | EXPORT_SYMBOL(agp_off); | |
354 | EXPORT_SYMBOL(agp_try_unsupported_boot); | |
355 | ||
356 | static int __init agp_init(void) | |
357 | { | |
358 | if (!agp_off) | |
70e8992e | 359 | printk(KERN_INFO "Linux agpgart interface v%d.%d\n", |
1da177e4 LT |
360 | AGPGART_VERSION_MAJOR, AGPGART_VERSION_MINOR); |
361 | return 0; | |
362 | } | |
363 | ||
408b664a | 364 | static void __exit agp_exit(void) |
1da177e4 LT |
365 | { |
366 | } | |
367 | ||
368 | #ifndef MODULE | |
369 | static __init int agp_setup(char *s) | |
370 | { | |
371 | if (!strcmp(s,"off")) | |
372 | agp_off = 1; | |
373 | if (!strcmp(s,"try_unsupported")) | |
374 | agp_try_unsupported_boot = 1; | |
375 | return 1; | |
376 | } | |
377 | __setup("agp=", agp_setup); | |
378 | #endif | |
379 | ||
f4432c5c | 380 | MODULE_AUTHOR("Dave Jones <davej@redhat.com>"); |
1da177e4 LT |
381 | MODULE_DESCRIPTION("AGP GART driver"); |
382 | MODULE_LICENSE("GPL and additional rights"); | |
383 | MODULE_ALIAS_MISCDEV(AGPGART_MINOR); | |
384 | ||
385 | module_init(agp_init); | |
386 | module_exit(agp_exit); | |
387 |