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