Branch data Line data Source code
1 : : /*
2 : : * AGPGART driver.
3 : : * Copyright (C) 2004 Silicon Graphics, Inc.
4 : : * Copyright (C) 2002-2005 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, 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/pagemap.h>
33 : : #include <linux/miscdevice.h>
34 : : #include <linux/pm.h>
35 : : #include <linux/agp_backend.h>
36 : : #include <linux/vmalloc.h>
37 : : #include <linux/dma-mapping.h>
38 : : #include <linux/mm.h>
39 : : #include <linux/sched.h>
40 : : #include <linux/slab.h>
41 : : #include <asm/io.h>
42 : : #ifdef CONFIG_X86
43 : : #include <asm/set_memory.h>
44 : : #endif
45 : : #include <asm/pgtable.h>
46 : : #include "agp.h"
47 : :
48 : : __u32 *agp_gatt_table;
49 : : int agp_memory_reserved;
50 : :
51 : : /*
52 : : * Needed by the Nforce GART driver for the time being. Would be
53 : : * nice to do this some other way instead of needing this export.
54 : : */
55 : : EXPORT_SYMBOL_GPL(agp_memory_reserved);
56 : :
57 : : /*
58 : : * Generic routines for handling agp_memory structures -
59 : : * They use the basic page allocation routines to do the brunt of the work.
60 : : */
61 : :
62 : 0 : void agp_free_key(int key)
63 : : {
64 [ # # ]: 0 : if (key < 0)
65 : : return;
66 : :
67 [ # # # # : 0 : if (key < MAXKEY)
# # # # #
# ]
68 : 0 : clear_bit(key, agp_bridge->key_list);
69 : : }
70 : : EXPORT_SYMBOL(agp_free_key);
71 : :
72 : :
73 : 0 : static int agp_get_key(void)
74 : : {
75 : 0 : int bit;
76 : :
77 : 0 : bit = find_first_zero_bit(agp_bridge->key_list, MAXKEY);
78 [ # # ]: 0 : if (bit < MAXKEY) {
79 : 0 : set_bit(bit, agp_bridge->key_list);
80 : 0 : return bit;
81 : : }
82 : : return -1;
83 : : }
84 : :
85 : : /*
86 : : * Use kmalloc if possible for the page list. Otherwise fall back to
87 : : * vmalloc. This speeds things up and also saves memory for small AGP
88 : : * regions.
89 : : */
90 : :
91 : 0 : void agp_alloc_page_array(size_t size, struct agp_memory *mem)
92 : : {
93 : 0 : mem->pages = kvmalloc(size, GFP_KERNEL);
94 : 0 : }
95 : : EXPORT_SYMBOL(agp_alloc_page_array);
96 : :
97 : 0 : static struct agp_memory *agp_create_user_memory(unsigned long num_agp_pages)
98 : : {
99 : 0 : struct agp_memory *new;
100 : 0 : unsigned long alloc_size = num_agp_pages*sizeof(struct page *);
101 : :
102 [ # # ]: 0 : if (INT_MAX/sizeof(struct page *) < num_agp_pages)
103 : : return NULL;
104 : :
105 : 0 : new = kzalloc(sizeof(struct agp_memory), GFP_KERNEL);
106 [ # # ]: 0 : if (new == NULL)
107 : : return NULL;
108 : :
109 : 0 : new->key = agp_get_key();
110 : :
111 [ # # ]: 0 : if (new->key < 0) {
112 : 0 : kfree(new);
113 : 0 : return NULL;
114 : : }
115 : :
116 : 0 : agp_alloc_page_array(alloc_size, new);
117 : :
118 [ # # ]: 0 : if (new->pages == NULL) {
119 [ # # ]: 0 : agp_free_key(new->key);
120 : 0 : kfree(new);
121 : 0 : return NULL;
122 : : }
123 : 0 : new->num_scratch_pages = 0;
124 : 0 : return new;
125 : : }
126 : :
127 : 0 : struct agp_memory *agp_create_memory(int scratch_pages)
128 : : {
129 : 0 : struct agp_memory *new;
130 : :
131 : 0 : new = kzalloc(sizeof(struct agp_memory), GFP_KERNEL);
132 [ # # ]: 0 : if (new == NULL)
133 : : return NULL;
134 : :
135 : 0 : new->key = agp_get_key();
136 : :
137 [ # # ]: 0 : if (new->key < 0) {
138 : 0 : kfree(new);
139 : 0 : return NULL;
140 : : }
141 : :
142 : 0 : agp_alloc_page_array(PAGE_SIZE * scratch_pages, new);
143 : :
144 [ # # ]: 0 : if (new->pages == NULL) {
145 [ # # ]: 0 : agp_free_key(new->key);
146 : 0 : kfree(new);
147 : 0 : return NULL;
148 : : }
149 : 0 : new->num_scratch_pages = scratch_pages;
150 : 0 : new->type = AGP_NORMAL_MEMORY;
151 : 0 : return new;
152 : : }
153 : : EXPORT_SYMBOL(agp_create_memory);
154 : :
155 : : /**
156 : : * agp_free_memory - free memory associated with an agp_memory pointer.
157 : : *
158 : : * @curr: agp_memory pointer to be freed.
159 : : *
160 : : * It is the only function that can be called when the backend is not owned
161 : : * by the caller. (So it can free memory on client death.)
162 : : */
163 : 0 : void agp_free_memory(struct agp_memory *curr)
164 : : {
165 : 0 : size_t i;
166 : :
167 [ # # ]: 0 : if (curr == NULL)
168 : : return;
169 : :
170 [ # # ]: 0 : if (curr->is_bound)
171 : 0 : agp_unbind_memory(curr);
172 : :
173 [ # # ]: 0 : if (curr->type >= AGP_USER_TYPES) {
174 : 0 : agp_generic_free_by_type(curr);
175 : 0 : return;
176 : : }
177 : :
178 [ # # ]: 0 : if (curr->type != 0) {
179 : 0 : curr->bridge->driver->free_by_type(curr);
180 : 0 : return;
181 : : }
182 [ # # ]: 0 : if (curr->page_count != 0) {
183 [ # # ]: 0 : if (curr->bridge->driver->agp_destroy_pages) {
184 : 0 : curr->bridge->driver->agp_destroy_pages(curr);
185 : : } else {
186 : :
187 [ # # ]: 0 : for (i = 0; i < curr->page_count; i++) {
188 : 0 : curr->bridge->driver->agp_destroy_page(
189 : 0 : curr->pages[i],
190 : : AGP_PAGE_DESTROY_UNMAP);
191 : : }
192 [ # # ]: 0 : for (i = 0; i < curr->page_count; i++) {
193 : 0 : curr->bridge->driver->agp_destroy_page(
194 : 0 : curr->pages[i],
195 : : AGP_PAGE_DESTROY_FREE);
196 : : }
197 : : }
198 : : }
199 [ # # ]: 0 : agp_free_key(curr->key);
200 : 0 : agp_free_page_array(curr);
201 : 0 : kfree(curr);
202 : : }
203 : : EXPORT_SYMBOL(agp_free_memory);
204 : :
205 : : #define ENTRIES_PER_PAGE (PAGE_SIZE / sizeof(unsigned long))
206 : :
207 : : /**
208 : : * agp_allocate_memory - allocate a group of pages of a certain type.
209 : : *
210 : : * @bridge: an agp_bridge_data struct allocated for the AGP host bridge.
211 : : * @page_count: size_t argument of the number of pages
212 : : * @type: u32 argument of the type of memory to be allocated.
213 : : *
214 : : * Every agp bridge device will allow you to allocate AGP_NORMAL_MEMORY which
215 : : * maps to physical ram. Any other type is device dependent.
216 : : *
217 : : * It returns NULL whenever memory is unavailable.
218 : : */
219 : 0 : struct agp_memory *agp_allocate_memory(struct agp_bridge_data *bridge,
220 : : size_t page_count, u32 type)
221 : : {
222 : 0 : int scratch_pages;
223 : 0 : struct agp_memory *new;
224 : 0 : size_t i;
225 : 0 : int cur_memory;
226 : :
227 [ # # ]: 0 : if (!bridge)
228 : : return NULL;
229 : :
230 : 0 : cur_memory = atomic_read(&bridge->current_memory_agp);
231 [ # # # # ]: 0 : if ((cur_memory + page_count > bridge->max_memory_agp) ||
232 : : (cur_memory + page_count < page_count))
233 : : return NULL;
234 : :
235 [ # # ]: 0 : if (type >= AGP_USER_TYPES) {
236 : 0 : new = agp_generic_alloc_user(page_count, type);
237 [ # # ]: 0 : if (new)
238 : 0 : new->bridge = bridge;
239 : 0 : return new;
240 : : }
241 : :
242 [ # # ]: 0 : if (type != 0) {
243 : 0 : new = bridge->driver->alloc_by_type(page_count, type);
244 [ # # ]: 0 : if (new)
245 : 0 : new->bridge = bridge;
246 : 0 : return new;
247 : : }
248 : :
249 : 0 : scratch_pages = (page_count + ENTRIES_PER_PAGE - 1) / ENTRIES_PER_PAGE;
250 : :
251 : 0 : new = agp_create_memory(scratch_pages);
252 : :
253 [ # # ]: 0 : if (new == NULL)
254 : : return NULL;
255 : :
256 [ # # ]: 0 : if (bridge->driver->agp_alloc_pages) {
257 [ # # ]: 0 : if (bridge->driver->agp_alloc_pages(bridge, new, page_count)) {
258 : 0 : agp_free_memory(new);
259 : 0 : return NULL;
260 : : }
261 : 0 : new->bridge = bridge;
262 : 0 : return new;
263 : : }
264 : :
265 [ # # ]: 0 : for (i = 0; i < page_count; i++) {
266 : 0 : struct page *page = bridge->driver->agp_alloc_page(bridge);
267 : :
268 [ # # ]: 0 : if (page == NULL) {
269 : 0 : agp_free_memory(new);
270 : 0 : return NULL;
271 : : }
272 : 0 : new->pages[i] = page;
273 : 0 : new->page_count++;
274 : : }
275 : 0 : new->bridge = bridge;
276 : :
277 : 0 : return new;
278 : : }
279 : : EXPORT_SYMBOL(agp_allocate_memory);
280 : :
281 : :
282 : : /* End - Generic routines for handling agp_memory structures */
283 : :
284 : :
285 : 0 : static int agp_return_size(void)
286 : : {
287 : 0 : int current_size;
288 : 0 : void *temp;
289 : :
290 : 0 : temp = agp_bridge->current_size;
291 : :
292 [ # # # # : 0 : switch (agp_bridge->driver->size_type) {
# # ]
293 : 0 : case U8_APER_SIZE:
294 : 0 : current_size = A_SIZE_8(temp)->size;
295 : 0 : break;
296 : 0 : case U16_APER_SIZE:
297 : 0 : current_size = A_SIZE_16(temp)->size;
298 : 0 : break;
299 : 0 : case U32_APER_SIZE:
300 : 0 : current_size = A_SIZE_32(temp)->size;
301 : 0 : break;
302 : 0 : case LVL2_APER_SIZE:
303 : 0 : current_size = A_SIZE_LVL2(temp)->size;
304 : 0 : break;
305 : 0 : case FIXED_APER_SIZE:
306 : 0 : current_size = A_SIZE_FIX(temp)->size;
307 : 0 : break;
308 : : default:
309 : : current_size = 0;
310 : : break;
311 : : }
312 : :
313 : 0 : current_size -= (agp_memory_reserved / (1024*1024));
314 : 0 : if (current_size <0)
315 : : current_size = 0;
316 : 0 : return current_size;
317 : : }
318 : :
319 : :
320 : 0 : int agp_num_entries(void)
321 : : {
322 : 0 : int num_entries;
323 : 0 : void *temp;
324 : :
325 : 0 : temp = agp_bridge->current_size;
326 : :
327 [ # # # # : 0 : switch (agp_bridge->driver->size_type) {
# # ]
328 : 0 : case U8_APER_SIZE:
329 : 0 : num_entries = A_SIZE_8(temp)->num_entries;
330 : 0 : break;
331 : 0 : case U16_APER_SIZE:
332 : 0 : num_entries = A_SIZE_16(temp)->num_entries;
333 : 0 : break;
334 : 0 : case U32_APER_SIZE:
335 : 0 : num_entries = A_SIZE_32(temp)->num_entries;
336 : 0 : break;
337 : 0 : case LVL2_APER_SIZE:
338 : 0 : num_entries = A_SIZE_LVL2(temp)->num_entries;
339 : 0 : break;
340 : 0 : case FIXED_APER_SIZE:
341 : 0 : num_entries = A_SIZE_FIX(temp)->num_entries;
342 : 0 : break;
343 : : default:
344 : : num_entries = 0;
345 : : break;
346 : : }
347 : :
348 : 0 : num_entries -= agp_memory_reserved>>PAGE_SHIFT;
349 : 0 : if (num_entries<0)
350 : : num_entries = 0;
351 : 0 : return num_entries;
352 : : }
353 : : EXPORT_SYMBOL_GPL(agp_num_entries);
354 : :
355 : :
356 : : /**
357 : : * agp_copy_info - copy bridge state information
358 : : *
359 : : * @bridge: an agp_bridge_data struct allocated for the AGP host bridge.
360 : : * @info: agp_kern_info pointer. The caller should insure that this pointer is valid.
361 : : *
362 : : * This function copies information about the agp bridge device and the state of
363 : : * the agp backend into an agp_kern_info pointer.
364 : : */
365 : 0 : int agp_copy_info(struct agp_bridge_data *bridge, struct agp_kern_info *info)
366 : : {
367 : 0 : memset(info, 0, sizeof(struct agp_kern_info));
368 [ # # ]: 0 : if (!bridge) {
369 : 0 : info->chipset = NOT_SUPPORTED;
370 : 0 : return -EIO;
371 : : }
372 : :
373 : 0 : info->version.major = bridge->version->major;
374 : 0 : info->version.minor = bridge->version->minor;
375 : 0 : info->chipset = SUPPORTED;
376 : 0 : info->device = bridge->dev;
377 [ # # ]: 0 : if (bridge->mode & AGPSTAT_MODE_3_0)
378 : 0 : info->mode = bridge->mode & ~AGP3_RESERVED_MASK;
379 : : else
380 : 0 : info->mode = bridge->mode & ~AGP2_RESERVED_MASK;
381 : 0 : info->aper_base = bridge->gart_bus_addr;
382 : 0 : info->aper_size = agp_return_size();
383 : 0 : info->max_memory = bridge->max_memory_agp;
384 : 0 : info->current_memory = atomic_read(&bridge->current_memory_agp);
385 : 0 : info->cant_use_aperture = bridge->driver->cant_use_aperture;
386 : 0 : info->vm_ops = bridge->vm_ops;
387 : 0 : info->page_mask = ~0UL;
388 : 0 : return 0;
389 : : }
390 : : EXPORT_SYMBOL(agp_copy_info);
391 : :
392 : : /* End - Routine to copy over information structure */
393 : :
394 : : /*
395 : : * Routines for handling swapping of agp_memory into the GATT -
396 : : * These routines take agp_memory and insert them into the GATT.
397 : : * They call device specific routines to actually write to the GATT.
398 : : */
399 : :
400 : : /**
401 : : * agp_bind_memory - Bind an agp_memory structure into the GATT.
402 : : *
403 : : * @curr: agp_memory pointer
404 : : * @pg_start: an offset into the graphics aperture translation table
405 : : *
406 : : * It returns -EINVAL if the pointer == NULL.
407 : : * It returns -EBUSY if the area of the table requested is already in use.
408 : : */
409 : 0 : int agp_bind_memory(struct agp_memory *curr, off_t pg_start)
410 : : {
411 : 0 : int ret_val;
412 : :
413 [ # # ]: 0 : if (curr == NULL)
414 : : return -EINVAL;
415 : :
416 [ # # ]: 0 : if (curr->is_bound) {
417 : 0 : printk(KERN_INFO PFX "memory %p is already bound!\n", curr);
418 : 0 : return -EINVAL;
419 : : }
420 [ # # ]: 0 : if (!curr->is_flushed) {
421 : 0 : curr->bridge->driver->cache_flush();
422 : 0 : curr->is_flushed = true;
423 : : }
424 : :
425 : 0 : ret_val = curr->bridge->driver->insert_memory(curr, pg_start, curr->type);
426 : :
427 [ # # ]: 0 : if (ret_val != 0)
428 : : return ret_val;
429 : :
430 : 0 : curr->is_bound = true;
431 : 0 : curr->pg_start = pg_start;
432 : 0 : spin_lock(&agp_bridge->mapped_lock);
433 : 0 : list_add(&curr->mapped_list, &agp_bridge->mapped_list);
434 : 0 : spin_unlock(&agp_bridge->mapped_lock);
435 : :
436 : 0 : return 0;
437 : : }
438 : : EXPORT_SYMBOL(agp_bind_memory);
439 : :
440 : :
441 : : /**
442 : : * agp_unbind_memory - Removes an agp_memory structure from the GATT
443 : : *
444 : : * @curr: agp_memory pointer to be removed from the GATT.
445 : : *
446 : : * It returns -EINVAL if this piece of agp_memory is not currently bound to
447 : : * the graphics aperture translation table or if the agp_memory pointer == NULL
448 : : */
449 : 0 : int agp_unbind_memory(struct agp_memory *curr)
450 : : {
451 : 0 : int ret_val;
452 : :
453 [ # # ]: 0 : if (curr == NULL)
454 : : return -EINVAL;
455 : :
456 [ # # ]: 0 : if (!curr->is_bound) {
457 : 0 : printk(KERN_INFO PFX "memory %p was not bound!\n", curr);
458 : 0 : return -EINVAL;
459 : : }
460 : :
461 : 0 : ret_val = curr->bridge->driver->remove_memory(curr, curr->pg_start, curr->type);
462 : :
463 [ # # ]: 0 : if (ret_val != 0)
464 : : return ret_val;
465 : :
466 : 0 : curr->is_bound = false;
467 : 0 : curr->pg_start = 0;
468 : 0 : spin_lock(&curr->bridge->mapped_lock);
469 : 0 : list_del(&curr->mapped_list);
470 : 0 : spin_unlock(&curr->bridge->mapped_lock);
471 : 0 : return 0;
472 : : }
473 : : EXPORT_SYMBOL(agp_unbind_memory);
474 : :
475 : :
476 : : /* End - Routines for handling swapping of agp_memory into the GATT */
477 : :
478 : :
479 : : /* Generic Agp routines - Start */
480 : 0 : static void agp_v2_parse_one(u32 *requested_mode, u32 *bridge_agpstat, u32 *vga_agpstat)
481 : : {
482 : 0 : u32 tmp;
483 : :
484 [ # # ]: 0 : if (*requested_mode & AGP2_RESERVED_MASK) {
485 : 0 : printk(KERN_INFO PFX "reserved bits set (%x) in mode 0x%x. Fixed.\n",
486 : : *requested_mode & AGP2_RESERVED_MASK, *requested_mode);
487 : 0 : *requested_mode &= ~AGP2_RESERVED_MASK;
488 : : }
489 : :
490 : : /*
491 : : * Some dumb bridges are programmed to disobey the AGP2 spec.
492 : : * This is likely a BIOS misprogramming rather than poweron default, or
493 : : * it would be a lot more common.
494 : : * https://bugs.freedesktop.org/show_bug.cgi?id=8816
495 : : * AGPv2 spec 6.1.9 states:
496 : : * The RATE field indicates the data transfer rates supported by this
497 : : * device. A.G.P. devices must report all that apply.
498 : : * Fix them up as best we can.
499 : : */
500 [ # # # ]: 0 : switch (*bridge_agpstat & 7) {
501 : 0 : case 4:
502 : 0 : *bridge_agpstat |= (AGPSTAT2_2X | AGPSTAT2_1X);
503 : 0 : printk(KERN_INFO PFX "BIOS bug. AGP bridge claims to only support x4 rate. "
504 : : "Fixing up support for x2 & x1\n");
505 : 0 : break;
506 : 0 : case 2:
507 : 0 : *bridge_agpstat |= AGPSTAT2_1X;
508 : 0 : printk(KERN_INFO PFX "BIOS bug. AGP bridge claims to only support x2 rate. "
509 : : "Fixing up support for x1\n");
510 : 0 : break;
511 : : default:
512 : : break;
513 : : }
514 : :
515 : : /* Check the speed bits make sense. Only one should be set. */
516 : 0 : tmp = *requested_mode & 7;
517 [ # # # # ]: 0 : switch (tmp) {
518 : : case 0:
519 : 0 : printk(KERN_INFO PFX "%s tried to set rate=x0. Setting to x1 mode.\n", current->comm);
520 : 0 : *requested_mode |= AGPSTAT2_1X;
521 : 0 : break;
522 : : case 1:
523 : : case 2:
524 : : break;
525 : 0 : case 3:
526 : 0 : *requested_mode &= ~(AGPSTAT2_1X); /* rate=2 */
527 : 0 : break;
528 : : case 4:
529 : : break;
530 : 0 : case 5:
531 : : case 6:
532 : : case 7:
533 : 0 : *requested_mode &= ~(AGPSTAT2_1X|AGPSTAT2_2X); /* rate=4*/
534 : 0 : break;
535 : : }
536 : :
537 : : /* disable SBA if it's not supported */
538 [ # # # # : 0 : if (!((*bridge_agpstat & AGPSTAT_SBA) && (*vga_agpstat & AGPSTAT_SBA) && (*requested_mode & AGPSTAT_SBA)))
# # ]
539 : 0 : *bridge_agpstat &= ~AGPSTAT_SBA;
540 : :
541 : : /* Set rate */
542 [ # # # # : 0 : if (!((*bridge_agpstat & AGPSTAT2_4X) && (*vga_agpstat & AGPSTAT2_4X) && (*requested_mode & AGPSTAT2_4X)))
# # ]
543 : 0 : *bridge_agpstat &= ~AGPSTAT2_4X;
544 : :
545 [ # # # # : 0 : if (!((*bridge_agpstat & AGPSTAT2_2X) && (*vga_agpstat & AGPSTAT2_2X) && (*requested_mode & AGPSTAT2_2X)))
# # ]
546 : 0 : *bridge_agpstat &= ~AGPSTAT2_2X;
547 : :
548 [ # # # # : 0 : if (!((*bridge_agpstat & AGPSTAT2_1X) && (*vga_agpstat & AGPSTAT2_1X) && (*requested_mode & AGPSTAT2_1X)))
# # ]
549 : 0 : *bridge_agpstat &= ~AGPSTAT2_1X;
550 : :
551 : : /* Now we know what mode it should be, clear out the unwanted bits. */
552 [ # # ]: 0 : if (*bridge_agpstat & AGPSTAT2_4X)
553 : 0 : *bridge_agpstat &= ~(AGPSTAT2_1X | AGPSTAT2_2X); /* 4X */
554 : :
555 [ # # ]: 0 : if (*bridge_agpstat & AGPSTAT2_2X)
556 : 0 : *bridge_agpstat &= ~(AGPSTAT2_1X | AGPSTAT2_4X); /* 2X */
557 : :
558 [ # # ]: 0 : if (*bridge_agpstat & AGPSTAT2_1X)
559 : 0 : *bridge_agpstat &= ~(AGPSTAT2_2X | AGPSTAT2_4X); /* 1X */
560 : :
561 : : /* Apply any errata. */
562 [ # # ]: 0 : if (agp_bridge->flags & AGP_ERRATA_FASTWRITES)
563 : 0 : *bridge_agpstat &= ~AGPSTAT_FW;
564 : :
565 [ # # ]: 0 : if (agp_bridge->flags & AGP_ERRATA_SBA)
566 : 0 : *bridge_agpstat &= ~AGPSTAT_SBA;
567 : :
568 [ # # ]: 0 : if (agp_bridge->flags & AGP_ERRATA_1X) {
569 : 0 : *bridge_agpstat &= ~(AGPSTAT2_2X | AGPSTAT2_4X);
570 : 0 : *bridge_agpstat |= AGPSTAT2_1X;
571 : : }
572 : :
573 : : /* If we've dropped down to 1X, disable fast writes. */
574 [ # # ]: 0 : if (*bridge_agpstat & AGPSTAT2_1X)
575 : 0 : *bridge_agpstat &= ~AGPSTAT_FW;
576 : 0 : }
577 : :
578 : : /*
579 : : * requested_mode = Mode requested by (typically) X.
580 : : * bridge_agpstat = PCI_AGP_STATUS from agp bridge.
581 : : * vga_agpstat = PCI_AGP_STATUS from graphic card.
582 : : */
583 : 0 : static void agp_v3_parse_one(u32 *requested_mode, u32 *bridge_agpstat, u32 *vga_agpstat)
584 : : {
585 : 0 : u32 origbridge=*bridge_agpstat, origvga=*vga_agpstat;
586 : 0 : u32 tmp;
587 : :
588 [ # # ]: 0 : if (*requested_mode & AGP3_RESERVED_MASK) {
589 : 0 : printk(KERN_INFO PFX "reserved bits set (%x) in mode 0x%x. Fixed.\n",
590 : : *requested_mode & AGP3_RESERVED_MASK, *requested_mode);
591 : 0 : *requested_mode &= ~AGP3_RESERVED_MASK;
592 : : }
593 : :
594 : : /* Check the speed bits make sense. */
595 : 0 : tmp = *requested_mode & 7;
596 [ # # ]: 0 : if (tmp == 0) {
597 : 0 : printk(KERN_INFO PFX "%s tried to set rate=x0. Setting to AGP3 x4 mode.\n", current->comm);
598 : 0 : *requested_mode |= AGPSTAT3_4X;
599 : : }
600 [ # # ]: 0 : if (tmp >= 3) {
601 : 0 : printk(KERN_INFO PFX "%s tried to set rate=x%d. Setting to AGP3 x8 mode.\n", current->comm, tmp * 4);
602 : 0 : *requested_mode = (*requested_mode & ~7) | AGPSTAT3_8X;
603 : : }
604 : :
605 : : /* ARQSZ - Set the value to the maximum one.
606 : : * Don't allow the mode register to override values. */
607 : 0 : *bridge_agpstat = ((*bridge_agpstat & ~AGPSTAT_ARQSZ) |
608 : 0 : max_t(u32,(*bridge_agpstat & AGPSTAT_ARQSZ),(*vga_agpstat & AGPSTAT_ARQSZ)));
609 : :
610 : : /* Calibration cycle.
611 : : * Don't allow the mode register to override values. */
612 : 0 : *bridge_agpstat = ((*bridge_agpstat & ~AGPSTAT_CAL_MASK) |
613 : 0 : min_t(u32,(*bridge_agpstat & AGPSTAT_CAL_MASK),(*vga_agpstat & AGPSTAT_CAL_MASK)));
614 : :
615 : : /* SBA *must* be supported for AGP v3 */
616 : 0 : *bridge_agpstat |= AGPSTAT_SBA;
617 : :
618 : : /*
619 : : * Set speed.
620 : : * Check for invalid speeds. This can happen when applications
621 : : * written before the AGP 3.0 standard pass AGP2.x modes to AGP3 hardware
622 : : */
623 [ # # ]: 0 : if (*requested_mode & AGPSTAT_MODE_3_0) {
624 : : /*
625 : : * Caller hasn't a clue what it is doing. Bridge is in 3.0 mode,
626 : : * have been passed a 3.0 mode, but with 2.x speed bits set.
627 : : * AGP2.x 4x -> AGP3.0 4x.
628 : : */
629 [ # # ]: 0 : if (*requested_mode & AGPSTAT2_4X) {
630 : 0 : printk(KERN_INFO PFX "%s passes broken AGP3 flags (%x). Fixed.\n",
631 : 0 : current->comm, *requested_mode);
632 : 0 : *requested_mode &= ~AGPSTAT2_4X;
633 : 0 : *requested_mode |= AGPSTAT3_4X;
634 : : }
635 : : } else {
636 : : /*
637 : : * The caller doesn't know what they are doing. We are in 3.0 mode,
638 : : * but have been passed an AGP 2.x mode.
639 : : * Convert AGP 1x,2x,4x -> AGP 3.0 4x.
640 : : */
641 : 0 : printk(KERN_INFO PFX "%s passes broken AGP2 flags (%x) in AGP3 mode. Fixed.\n",
642 : 0 : current->comm, *requested_mode);
643 : 0 : *requested_mode &= ~(AGPSTAT2_4X | AGPSTAT2_2X | AGPSTAT2_1X);
644 : 0 : *requested_mode |= AGPSTAT3_4X;
645 : : }
646 : :
647 [ # # ]: 0 : if (*requested_mode & AGPSTAT3_8X) {
648 [ # # ]: 0 : if (!(*bridge_agpstat & AGPSTAT3_8X)) {
649 : 0 : *bridge_agpstat &= ~(AGPSTAT3_8X | AGPSTAT3_RSVD);
650 : 0 : *bridge_agpstat |= AGPSTAT3_4X;
651 : 0 : printk(KERN_INFO PFX "%s requested AGPx8 but bridge not capable.\n", current->comm);
652 : 0 : return;
653 : : }
654 [ # # ]: 0 : if (!(*vga_agpstat & AGPSTAT3_8X)) {
655 : 0 : *bridge_agpstat &= ~(AGPSTAT3_8X | AGPSTAT3_RSVD);
656 : 0 : *bridge_agpstat |= AGPSTAT3_4X;
657 : 0 : printk(KERN_INFO PFX "%s requested AGPx8 but graphic card not capable.\n", current->comm);
658 : 0 : return;
659 : : }
660 : : /* All set, bridge & device can do AGP x8*/
661 : 0 : *bridge_agpstat &= ~(AGPSTAT3_4X | AGPSTAT3_RSVD);
662 : 0 : goto done;
663 : :
664 [ # # ]: 0 : } else if (*requested_mode & AGPSTAT3_4X) {
665 : 0 : *bridge_agpstat &= ~(AGPSTAT3_8X | AGPSTAT3_RSVD);
666 : 0 : *bridge_agpstat |= AGPSTAT3_4X;
667 : 0 : goto done;
668 : :
669 : : } else {
670 : :
671 : : /*
672 : : * If we didn't specify an AGP mode, we see if both
673 : : * the graphics card, and the bridge can do x8, and use if so.
674 : : * If not, we fall back to x4 mode.
675 : : */
676 [ # # # # ]: 0 : if ((*bridge_agpstat & AGPSTAT3_8X) && (*vga_agpstat & AGPSTAT3_8X)) {
677 : 0 : printk(KERN_INFO PFX "No AGP mode specified. Setting to highest mode "
678 : : "supported by bridge & card (x8).\n");
679 : 0 : *bridge_agpstat &= ~(AGPSTAT3_4X | AGPSTAT3_RSVD);
680 : 0 : *vga_agpstat &= ~(AGPSTAT3_4X | AGPSTAT3_RSVD);
681 : : } else {
682 : 0 : printk(KERN_INFO PFX "Fell back to AGPx4 mode because ");
683 [ # # ]: 0 : if (!(*bridge_agpstat & AGPSTAT3_8X)) {
684 : 0 : printk(KERN_INFO PFX "bridge couldn't do x8. bridge_agpstat:%x (orig=%x)\n",
685 : : *bridge_agpstat, origbridge);
686 : 0 : *bridge_agpstat &= ~(AGPSTAT3_8X | AGPSTAT3_RSVD);
687 : 0 : *bridge_agpstat |= AGPSTAT3_4X;
688 : : }
689 [ # # ]: 0 : if (!(*vga_agpstat & AGPSTAT3_8X)) {
690 : 0 : printk(KERN_INFO PFX "graphics card couldn't do x8. vga_agpstat:%x (orig=%x)\n",
691 : : *vga_agpstat, origvga);
692 : 0 : *vga_agpstat &= ~(AGPSTAT3_8X | AGPSTAT3_RSVD);
693 : 0 : *vga_agpstat |= AGPSTAT3_4X;
694 : : }
695 : : }
696 : : }
697 : :
698 : 0 : done:
699 : : /* Apply any errata. */
700 [ # # ]: 0 : if (agp_bridge->flags & AGP_ERRATA_FASTWRITES)
701 : 0 : *bridge_agpstat &= ~AGPSTAT_FW;
702 : :
703 [ # # ]: 0 : if (agp_bridge->flags & AGP_ERRATA_SBA)
704 : 0 : *bridge_agpstat &= ~AGPSTAT_SBA;
705 : :
706 [ # # ]: 0 : if (agp_bridge->flags & AGP_ERRATA_1X) {
707 : 0 : *bridge_agpstat &= ~(AGPSTAT2_2X | AGPSTAT2_4X);
708 : 0 : *bridge_agpstat |= AGPSTAT2_1X;
709 : : }
710 : : }
711 : :
712 : :
713 : : /**
714 : : * agp_collect_device_status - determine correct agp_cmd from various agp_stat's
715 : : * @bridge: an agp_bridge_data struct allocated for the AGP host bridge.
716 : : * @requested_mode: requested agp_stat from userspace (Typically from X)
717 : : * @bridge_agpstat: current agp_stat from AGP bridge.
718 : : *
719 : : * This function will hunt for an AGP graphics card, and try to match
720 : : * the requested mode to the capabilities of both the bridge and the card.
721 : : */
722 : 0 : u32 agp_collect_device_status(struct agp_bridge_data *bridge, u32 requested_mode, u32 bridge_agpstat)
723 : : {
724 : 0 : struct pci_dev *device = NULL;
725 : 0 : u32 vga_agpstat;
726 : 0 : u8 cap_ptr;
727 : :
728 : 0 : for (;;) {
729 : 0 : device = pci_get_class(PCI_CLASS_DISPLAY_VGA << 8, device);
730 [ # # ]: 0 : if (!device) {
731 : 0 : printk(KERN_INFO PFX "Couldn't find an AGP VGA controller.\n");
732 : 0 : return 0;
733 : : }
734 : 0 : cap_ptr = pci_find_capability(device, PCI_CAP_ID_AGP);
735 [ # # ]: 0 : if (cap_ptr)
736 : : break;
737 : : }
738 : :
739 : : /*
740 : : * Ok, here we have a AGP device. Disable impossible
741 : : * settings, and adjust the readqueue to the minimum.
742 : : */
743 : 0 : pci_read_config_dword(device, cap_ptr+PCI_AGP_STATUS, &vga_agpstat);
744 : :
745 : : /* adjust RQ depth */
746 : 0 : bridge_agpstat = ((bridge_agpstat & ~AGPSTAT_RQ_DEPTH) |
747 : 0 : min_t(u32, (requested_mode & AGPSTAT_RQ_DEPTH),
748 : : min_t(u32, (bridge_agpstat & AGPSTAT_RQ_DEPTH), (vga_agpstat & AGPSTAT_RQ_DEPTH))));
749 : :
750 : : /* disable FW if it's not supported */
751 [ # # ]: 0 : if (!((bridge_agpstat & AGPSTAT_FW) &&
752 [ # # ]: 0 : (vga_agpstat & AGPSTAT_FW) &&
753 [ # # ]: 0 : (requested_mode & AGPSTAT_FW)))
754 : 0 : bridge_agpstat &= ~AGPSTAT_FW;
755 : :
756 : : /* Check to see if we are operating in 3.0 mode */
757 [ # # ]: 0 : if (agp_bridge->mode & AGPSTAT_MODE_3_0)
758 : 0 : agp_v3_parse_one(&requested_mode, &bridge_agpstat, &vga_agpstat);
759 : : else
760 : 0 : agp_v2_parse_one(&requested_mode, &bridge_agpstat, &vga_agpstat);
761 : :
762 : 0 : pci_dev_put(device);
763 : 0 : return bridge_agpstat;
764 : : }
765 : : EXPORT_SYMBOL(agp_collect_device_status);
766 : :
767 : :
768 : 0 : void agp_device_command(u32 bridge_agpstat, bool agp_v3)
769 : : {
770 : 0 : struct pci_dev *device = NULL;
771 : 0 : int mode;
772 : :
773 : 0 : mode = bridge_agpstat & 0x7;
774 [ # # ]: 0 : if (agp_v3)
775 : 0 : mode *= 4;
776 : :
777 [ # # ]: 0 : for_each_pci_dev(device) {
778 : 0 : u8 agp = pci_find_capability(device, PCI_CAP_ID_AGP);
779 [ # # ]: 0 : if (!agp)
780 : 0 : continue;
781 : :
782 [ # # ]: 0 : dev_info(&device->dev, "putting AGP V%d device into %dx mode\n",
783 : : agp_v3 ? 3 : 2, mode);
784 : 0 : pci_write_config_dword(device, agp + PCI_AGP_COMMAND, bridge_agpstat);
785 : : }
786 : 0 : }
787 : : EXPORT_SYMBOL(agp_device_command);
788 : :
789 : :
790 : 0 : void get_agp_version(struct agp_bridge_data *bridge)
791 : : {
792 : 0 : u32 ncapid;
793 : :
794 : : /* Exit early if already set by errata workarounds. */
795 [ # # ]: 0 : if (bridge->major_version != 0)
796 : 0 : return;
797 : :
798 : 0 : pci_read_config_dword(bridge->dev, bridge->capndx, &ncapid);
799 : 0 : bridge->major_version = (ncapid >> AGP_MAJOR_VERSION_SHIFT) & 0xf;
800 : 0 : bridge->minor_version = (ncapid >> AGP_MINOR_VERSION_SHIFT) & 0xf;
801 : : }
802 : : EXPORT_SYMBOL(get_agp_version);
803 : :
804 : :
805 : 0 : void agp_generic_enable(struct agp_bridge_data *bridge, u32 requested_mode)
806 : : {
807 : 0 : u32 bridge_agpstat, temp;
808 : :
809 : 0 : get_agp_version(agp_bridge);
810 : :
811 : 0 : dev_info(&agp_bridge->dev->dev, "AGP %d.%d bridge\n",
812 : : agp_bridge->major_version, agp_bridge->minor_version);
813 : :
814 : 0 : pci_read_config_dword(agp_bridge->dev,
815 : 0 : agp_bridge->capndx + PCI_AGP_STATUS, &bridge_agpstat);
816 : :
817 : 0 : bridge_agpstat = agp_collect_device_status(agp_bridge, requested_mode, bridge_agpstat);
818 [ # # ]: 0 : if (bridge_agpstat == 0)
819 : : /* Something bad happened. FIXME: Return error code? */
820 : 0 : return;
821 : :
822 : 0 : bridge_agpstat |= AGPSTAT_AGP_ENABLE;
823 : :
824 : : /* Do AGP version specific frobbing. */
825 [ # # ]: 0 : if (bridge->major_version >= 3) {
826 [ # # ]: 0 : if (bridge->mode & AGPSTAT_MODE_3_0) {
827 : : /* If we have 3.5, we can do the isoch stuff. */
828 [ # # ]: 0 : if (bridge->minor_version >= 5)
829 : 0 : agp_3_5_enable(bridge);
830 : 0 : agp_device_command(bridge_agpstat, true);
831 : 0 : return;
832 : : } else {
833 : : /* Disable calibration cycle in RX91<1> when not in AGP3.0 mode of operation.*/
834 : 0 : bridge_agpstat &= ~(7<<10) ;
835 : 0 : pci_read_config_dword(bridge->dev,
836 : 0 : bridge->capndx+AGPCTRL, &temp);
837 : 0 : temp |= (1<<9);
838 : 0 : pci_write_config_dword(bridge->dev,
839 : 0 : bridge->capndx+AGPCTRL, temp);
840 : :
841 : 0 : dev_info(&bridge->dev->dev, "bridge is in legacy mode, falling back to 2.x\n");
842 : : }
843 : : }
844 : :
845 : : /* AGP v<3 */
846 : 0 : agp_device_command(bridge_agpstat, false);
847 : : }
848 : : EXPORT_SYMBOL(agp_generic_enable);
849 : :
850 : :
851 : 0 : int agp_generic_create_gatt_table(struct agp_bridge_data *bridge)
852 : : {
853 : 0 : char *table;
854 : 0 : char *table_end;
855 : 0 : int page_order;
856 : 0 : int num_entries;
857 : 0 : int i;
858 : 0 : void *temp;
859 : 0 : struct page *page;
860 : :
861 : : /* The generic routines can't handle 2 level gatt's */
862 [ # # ]: 0 : if (bridge->driver->size_type == LVL2_APER_SIZE)
863 : : return -EINVAL;
864 : :
865 : 0 : table = NULL;
866 : 0 : i = bridge->aperture_size_idx;
867 : 0 : temp = bridge->current_size;
868 : 0 : page_order = num_entries = 0;
869 : :
870 [ # # ]: 0 : if (bridge->driver->size_type != FIXED_APER_SIZE) {
871 : 0 : do {
872 [ # # # # ]: 0 : switch (bridge->driver->size_type) {
873 : 0 : case U8_APER_SIZE:
874 : 0 : page_order =
875 : : A_SIZE_8(temp)->page_order;
876 : 0 : num_entries =
877 : : A_SIZE_8(temp)->num_entries;
878 : 0 : break;
879 : 0 : case U16_APER_SIZE:
880 : 0 : page_order = A_SIZE_16(temp)->page_order;
881 : 0 : num_entries = A_SIZE_16(temp)->num_entries;
882 : 0 : break;
883 : 0 : case U32_APER_SIZE:
884 : 0 : page_order = A_SIZE_32(temp)->page_order;
885 : 0 : num_entries = A_SIZE_32(temp)->num_entries;
886 : 0 : break;
887 : : /* This case will never really happen. */
888 : : case FIXED_APER_SIZE:
889 : : case LVL2_APER_SIZE:
890 : : default:
891 : : page_order = num_entries = 0;
892 : : break;
893 : : }
894 : :
895 : 0 : table = alloc_gatt_pages(page_order);
896 : :
897 [ # # ]: 0 : if (table == NULL) {
898 : 0 : i++;
899 [ # # # # ]: 0 : switch (bridge->driver->size_type) {
900 : 0 : case U8_APER_SIZE:
901 : 0 : bridge->current_size = A_IDX8(bridge);
902 : 0 : break;
903 : 0 : case U16_APER_SIZE:
904 : 0 : bridge->current_size = A_IDX16(bridge);
905 : 0 : break;
906 : 0 : case U32_APER_SIZE:
907 : 0 : bridge->current_size = A_IDX32(bridge);
908 : 0 : break;
909 : : /* These cases will never really happen. */
910 : : case FIXED_APER_SIZE:
911 : : case LVL2_APER_SIZE:
912 : : default:
913 : : break;
914 : : }
915 : 0 : temp = bridge->current_size;
916 : : } else {
917 : 0 : bridge->aperture_size_idx = i;
918 : : }
919 [ # # # # ]: 0 : } while (!table && (i < bridge->driver->num_aperture_sizes));
920 : : } else {
921 : 0 : page_order = ((struct aper_size_info_fixed *) temp)->page_order;
922 : 0 : num_entries = ((struct aper_size_info_fixed *) temp)->num_entries;
923 : 0 : table = alloc_gatt_pages(page_order);
924 : : }
925 : :
926 [ # # ]: 0 : if (table == NULL)
927 : : return -ENOMEM;
928 : :
929 : 0 : table_end = table + ((PAGE_SIZE * (1 << page_order)) - 1);
930 : :
931 [ # # # # : 0 : for (page = virt_to_page(table); page <= virt_to_page(table_end); page++)
# # ]
932 : 0 : SetPageReserved(page);
933 : :
934 : 0 : bridge->gatt_table_real = (u32 *) table;
935 : 0 : agp_gatt_table = (void *)table;
936 : :
937 : 0 : bridge->driver->cache_flush();
938 : : #ifdef CONFIG_X86
939 [ # # ]: 0 : if (set_memory_uc((unsigned long)table, 1 << page_order))
940 : 0 : printk(KERN_WARNING "Could not set GATT table memory to UC!\n");
941 : :
942 : 0 : bridge->gatt_table = (u32 __iomem *)table;
943 : : #else
944 : : bridge->gatt_table = ioremap(virt_to_phys(table),
945 : : (PAGE_SIZE * (1 << page_order)));
946 : : bridge->driver->cache_flush();
947 : : #endif
948 : :
949 : 0 : if (bridge->gatt_table == NULL) {
950 : : for (page = virt_to_page(table); page <= virt_to_page(table_end); page++)
951 : : ClearPageReserved(page);
952 : :
953 : : free_gatt_pages(table, page_order);
954 : :
955 : : return -ENOMEM;
956 : : }
957 [ # # ]: 0 : bridge->gatt_bus_addr = virt_to_phys(bridge->gatt_table_real);
958 : :
959 : : /* AK: bogus, should encode addresses > 4GB */
960 [ # # ]: 0 : for (i = 0; i < num_entries; i++) {
961 : 0 : writel(bridge->scratch_page, bridge->gatt_table+i);
962 : 0 : readl(bridge->gatt_table+i); /* PCI Posting. */
963 : : }
964 : :
965 : : return 0;
966 : : }
967 : : EXPORT_SYMBOL(agp_generic_create_gatt_table);
968 : :
969 : 0 : int agp_generic_free_gatt_table(struct agp_bridge_data *bridge)
970 : : {
971 : 0 : int page_order;
972 : 0 : char *table, *table_end;
973 : 0 : void *temp;
974 : 0 : struct page *page;
975 : :
976 : 0 : temp = bridge->current_size;
977 : :
978 [ # # # # : 0 : switch (bridge->driver->size_type) {
# # ]
979 : 0 : case U8_APER_SIZE:
980 : 0 : page_order = A_SIZE_8(temp)->page_order;
981 : 0 : break;
982 : 0 : case U16_APER_SIZE:
983 : 0 : page_order = A_SIZE_16(temp)->page_order;
984 : 0 : break;
985 : 0 : case U32_APER_SIZE:
986 : 0 : page_order = A_SIZE_32(temp)->page_order;
987 : 0 : break;
988 : 0 : case FIXED_APER_SIZE:
989 : 0 : page_order = A_SIZE_FIX(temp)->page_order;
990 : 0 : break;
991 : : case LVL2_APER_SIZE:
992 : : /* The generic routines can't deal with 2 level gatt's */
993 : : return -EINVAL;
994 : : default:
995 : : page_order = 0;
996 : : break;
997 : : }
998 : :
999 : : /* Do not worry about freeing memory, because if this is
1000 : : * called, then all agp memory is deallocated and removed
1001 : : * from the table. */
1002 : :
1003 : : #ifdef CONFIG_X86
1004 : 0 : set_memory_wb((unsigned long)bridge->gatt_table, 1 << page_order);
1005 : : #else
1006 : : iounmap(bridge->gatt_table);
1007 : : #endif
1008 : 0 : table = (char *) bridge->gatt_table_real;
1009 : 0 : table_end = table + ((PAGE_SIZE * (1 << page_order)) - 1);
1010 : :
1011 [ # # # # : 0 : for (page = virt_to_page(table); page <= virt_to_page(table_end); page++)
# # ]
1012 : 0 : ClearPageReserved(page);
1013 : :
1014 : 0 : free_gatt_pages(bridge->gatt_table_real, page_order);
1015 : :
1016 : 0 : agp_gatt_table = NULL;
1017 : 0 : bridge->gatt_table = NULL;
1018 : 0 : bridge->gatt_table_real = NULL;
1019 : 0 : bridge->gatt_bus_addr = 0;
1020 : :
1021 : 0 : return 0;
1022 : : }
1023 : : EXPORT_SYMBOL(agp_generic_free_gatt_table);
1024 : :
1025 : :
1026 : 0 : int agp_generic_insert_memory(struct agp_memory * mem, off_t pg_start, int type)
1027 : : {
1028 : 0 : int num_entries;
1029 : 0 : size_t i;
1030 : 0 : off_t j;
1031 : 0 : void *temp;
1032 : 0 : struct agp_bridge_data *bridge;
1033 : 0 : int mask_type;
1034 : :
1035 : 0 : bridge = mem->bridge;
1036 [ # # ]: 0 : if (!bridge)
1037 : : return -EINVAL;
1038 : :
1039 [ # # ]: 0 : if (mem->page_count == 0)
1040 : : return 0;
1041 : :
1042 : 0 : temp = bridge->current_size;
1043 : :
1044 [ # # # # : 0 : switch (bridge->driver->size_type) {
# # ]
1045 : 0 : case U8_APER_SIZE:
1046 : 0 : num_entries = A_SIZE_8(temp)->num_entries;
1047 : 0 : break;
1048 : 0 : case U16_APER_SIZE:
1049 : 0 : num_entries = A_SIZE_16(temp)->num_entries;
1050 : 0 : break;
1051 : 0 : case U32_APER_SIZE:
1052 : 0 : num_entries = A_SIZE_32(temp)->num_entries;
1053 : 0 : break;
1054 : 0 : case FIXED_APER_SIZE:
1055 : 0 : num_entries = A_SIZE_FIX(temp)->num_entries;
1056 : 0 : break;
1057 : : case LVL2_APER_SIZE:
1058 : : /* The generic routines can't deal with 2 level gatt's */
1059 : : return -EINVAL;
1060 : : default:
1061 : : num_entries = 0;
1062 : : break;
1063 : : }
1064 : :
1065 : 0 : num_entries -= agp_memory_reserved/PAGE_SIZE;
1066 : 0 : if (num_entries < 0) num_entries = 0;
1067 : :
1068 [ # # ]: 0 : if (type != mem->type)
1069 : : return -EINVAL;
1070 : :
1071 : 0 : mask_type = bridge->driver->agp_type_to_mask_type(bridge, type);
1072 [ # # ]: 0 : if (mask_type != 0) {
1073 : : /* The generic routines know nothing of memory types */
1074 : : return -EINVAL;
1075 : : }
1076 : :
1077 [ # # # # ]: 0 : if (((pg_start + mem->page_count) > num_entries) ||
1078 : : ((pg_start + mem->page_count) < pg_start))
1079 : : return -EINVAL;
1080 : :
1081 : : j = pg_start;
1082 : :
1083 [ # # ]: 0 : while (j < (pg_start + mem->page_count)) {
1084 [ # # # # ]: 0 : if (!PGE_EMPTY(bridge, readl(bridge->gatt_table+j)))
1085 : : return -EBUSY;
1086 : 0 : j++;
1087 : : }
1088 : :
1089 [ # # ]: 0 : if (!mem->is_flushed) {
1090 : 0 : bridge->driver->cache_flush();
1091 : 0 : mem->is_flushed = true;
1092 : : }
1093 : :
1094 [ # # ]: 0 : for (i = 0, j = pg_start; i < mem->page_count; i++, j++) {
1095 : 0 : writel(bridge->driver->mask_memory(bridge,
1096 : 0 : page_to_phys(mem->pages[i]),
1097 : : mask_type),
1098 : 0 : bridge->gatt_table+j);
1099 : : }
1100 : 0 : readl(bridge->gatt_table+j-1); /* PCI Posting. */
1101 : :
1102 : 0 : bridge->driver->tlb_flush(mem);
1103 : 0 : return 0;
1104 : : }
1105 : : EXPORT_SYMBOL(agp_generic_insert_memory);
1106 : :
1107 : :
1108 : 0 : int agp_generic_remove_memory(struct agp_memory *mem, off_t pg_start, int type)
1109 : : {
1110 : 0 : size_t i;
1111 : 0 : struct agp_bridge_data *bridge;
1112 : 0 : int mask_type, num_entries;
1113 : :
1114 : 0 : bridge = mem->bridge;
1115 [ # # ]: 0 : if (!bridge)
1116 : : return -EINVAL;
1117 : :
1118 [ # # ]: 0 : if (mem->page_count == 0)
1119 : : return 0;
1120 : :
1121 [ # # ]: 0 : if (type != mem->type)
1122 : : return -EINVAL;
1123 : :
1124 : 0 : num_entries = agp_num_entries();
1125 [ # # # # ]: 0 : if (((pg_start + mem->page_count) > num_entries) ||
1126 : : ((pg_start + mem->page_count) < pg_start))
1127 : : return -EINVAL;
1128 : :
1129 : 0 : mask_type = bridge->driver->agp_type_to_mask_type(bridge, type);
1130 [ # # ]: 0 : if (mask_type != 0) {
1131 : : /* The generic routines know nothing of memory types */
1132 : : return -EINVAL;
1133 : : }
1134 : :
1135 : : /* AK: bogus, should encode addresses > 4GB */
1136 [ # # ]: 0 : for (i = pg_start; i < (mem->page_count + pg_start); i++) {
1137 : 0 : writel(bridge->scratch_page, bridge->gatt_table+i);
1138 : : }
1139 : 0 : readl(bridge->gatt_table+i-1); /* PCI Posting. */
1140 : :
1141 : 0 : bridge->driver->tlb_flush(mem);
1142 : 0 : return 0;
1143 : : }
1144 : : EXPORT_SYMBOL(agp_generic_remove_memory);
1145 : :
1146 : 0 : struct agp_memory *agp_generic_alloc_by_type(size_t page_count, int type)
1147 : : {
1148 : 0 : return NULL;
1149 : : }
1150 : : EXPORT_SYMBOL(agp_generic_alloc_by_type);
1151 : :
1152 : 0 : void agp_generic_free_by_type(struct agp_memory *curr)
1153 : : {
1154 : 0 : agp_free_page_array(curr);
1155 [ # # ]: 0 : agp_free_key(curr->key);
1156 : 0 : kfree(curr);
1157 : 0 : }
1158 : : EXPORT_SYMBOL(agp_generic_free_by_type);
1159 : :
1160 : 0 : struct agp_memory *agp_generic_alloc_user(size_t page_count, int type)
1161 : : {
1162 : 0 : struct agp_memory *new;
1163 : 0 : int i;
1164 : 0 : int pages;
1165 : :
1166 : 0 : pages = (page_count + ENTRIES_PER_PAGE - 1) / ENTRIES_PER_PAGE;
1167 : 0 : new = agp_create_user_memory(page_count);
1168 [ # # ]: 0 : if (new == NULL)
1169 : : return NULL;
1170 : :
1171 [ # # ]: 0 : for (i = 0; i < page_count; i++)
1172 : 0 : new->pages[i] = NULL;
1173 : 0 : new->page_count = 0;
1174 : 0 : new->type = type;
1175 : 0 : new->num_scratch_pages = pages;
1176 : :
1177 : 0 : return new;
1178 : : }
1179 : : EXPORT_SYMBOL(agp_generic_alloc_user);
1180 : :
1181 : : /*
1182 : : * Basic Page Allocation Routines -
1183 : : * These routines handle page allocation and by default they reserve the allocated
1184 : : * memory. They also handle incrementing the current_memory_agp value, Which is checked
1185 : : * against a maximum value.
1186 : : */
1187 : :
1188 : 0 : int agp_generic_alloc_pages(struct agp_bridge_data *bridge, struct agp_memory *mem, size_t num_pages)
1189 : : {
1190 : 0 : struct page * page;
1191 : 0 : int i, ret = -ENOMEM;
1192 : :
1193 [ # # ]: 0 : for (i = 0; i < num_pages; i++) {
1194 : 0 : page = alloc_page(GFP_KERNEL | GFP_DMA32 | __GFP_ZERO);
1195 : : /* agp_free_memory() needs gart address */
1196 [ # # ]: 0 : if (page == NULL)
1197 : 0 : goto out;
1198 : :
1199 : : #ifndef CONFIG_X86
1200 : : map_page_into_agp(page);
1201 : : #endif
1202 [ # # ]: 0 : get_page(page);
1203 : 0 : atomic_inc(&agp_bridge->current_memory_agp);
1204 : :
1205 : 0 : mem->pages[i] = page;
1206 : 0 : mem->page_count++;
1207 : : }
1208 : :
1209 : : #ifdef CONFIG_X86
1210 : 0 : set_pages_array_uc(mem->pages, num_pages);
1211 : : #endif
1212 : 0 : ret = 0;
1213 : 0 : out:
1214 : 0 : return ret;
1215 : : }
1216 : : EXPORT_SYMBOL(agp_generic_alloc_pages);
1217 : :
1218 : 0 : struct page *agp_generic_alloc_page(struct agp_bridge_data *bridge)
1219 : : {
1220 : 0 : struct page * page;
1221 : :
1222 : 0 : page = alloc_page(GFP_KERNEL | GFP_DMA32 | __GFP_ZERO);
1223 [ # # ]: 0 : if (page == NULL)
1224 : : return NULL;
1225 : :
1226 : 0 : map_page_into_agp(page);
1227 : :
1228 [ # # ]: 0 : get_page(page);
1229 : 0 : atomic_inc(&agp_bridge->current_memory_agp);
1230 : 0 : return page;
1231 : : }
1232 : : EXPORT_SYMBOL(agp_generic_alloc_page);
1233 : :
1234 : 0 : void agp_generic_destroy_pages(struct agp_memory *mem)
1235 : : {
1236 : 0 : int i;
1237 : 0 : struct page *page;
1238 : :
1239 [ # # ]: 0 : if (!mem)
1240 : : return;
1241 : :
1242 : : #ifdef CONFIG_X86
1243 : 0 : set_pages_array_wb(mem->pages, mem->page_count);
1244 : : #endif
1245 : :
1246 [ # # ]: 0 : for (i = 0; i < mem->page_count; i++) {
1247 : 0 : page = mem->pages[i];
1248 : :
1249 : : #ifndef CONFIG_X86
1250 : : unmap_page_from_agp(page);
1251 : : #endif
1252 : 0 : put_page(page);
1253 : 0 : __free_page(page);
1254 : 0 : atomic_dec(&agp_bridge->current_memory_agp);
1255 : 0 : mem->pages[i] = NULL;
1256 : : }
1257 : : }
1258 : : EXPORT_SYMBOL(agp_generic_destroy_pages);
1259 : :
1260 : 0 : void agp_generic_destroy_page(struct page *page, int flags)
1261 : : {
1262 [ # # ]: 0 : if (page == NULL)
1263 : : return;
1264 : :
1265 [ # # ]: 0 : if (flags & AGP_PAGE_DESTROY_UNMAP)
1266 : 0 : unmap_page_from_agp(page);
1267 : :
1268 [ # # ]: 0 : if (flags & AGP_PAGE_DESTROY_FREE) {
1269 : 0 : put_page(page);
1270 : 0 : __free_page(page);
1271 : 0 : atomic_dec(&agp_bridge->current_memory_agp);
1272 : : }
1273 : : }
1274 : : EXPORT_SYMBOL(agp_generic_destroy_page);
1275 : :
1276 : : /* End Basic Page Allocation Routines */
1277 : :
1278 : :
1279 : : /**
1280 : : * agp_enable - initialise the agp point-to-point connection.
1281 : : *
1282 : : * @bridge: an agp_bridge_data struct allocated for the AGP host bridge.
1283 : : * @mode: agp mode register value to configure with.
1284 : : */
1285 : 0 : void agp_enable(struct agp_bridge_data *bridge, u32 mode)
1286 : : {
1287 [ # # ]: 0 : if (!bridge)
1288 : : return;
1289 : 0 : bridge->driver->agp_enable(bridge, mode);
1290 : : }
1291 : : EXPORT_SYMBOL(agp_enable);
1292 : :
1293 : : /* When we remove the global variable agp_bridge from all drivers
1294 : : * then agp_alloc_bridge and agp_generic_find_bridge need to be updated
1295 : : */
1296 : :
1297 : 0 : struct agp_bridge_data *agp_generic_find_bridge(struct pci_dev *pdev)
1298 : : {
1299 [ # # ]: 0 : if (list_empty(&agp_bridges))
1300 : : return NULL;
1301 : :
1302 : 0 : return agp_bridge;
1303 : : }
1304 : :
1305 : 0 : static void ipi_handler(void *null)
1306 : : {
1307 : 0 : flush_agp_cache();
1308 : 0 : }
1309 : :
1310 : 0 : void global_cache_flush(void)
1311 : : {
1312 : 0 : on_each_cpu(ipi_handler, NULL, 1);
1313 : 0 : }
1314 : : EXPORT_SYMBOL(global_cache_flush);
1315 : :
1316 : 0 : unsigned long agp_generic_mask_memory(struct agp_bridge_data *bridge,
1317 : : dma_addr_t addr, int type)
1318 : : {
1319 : : /* memory type is ignored in the generic routine */
1320 [ # # ]: 0 : if (bridge->driver->masks)
1321 : 0 : return addr | bridge->driver->masks[0].mask;
1322 : : else
1323 : : return addr;
1324 : : }
1325 : : EXPORT_SYMBOL(agp_generic_mask_memory);
1326 : :
1327 : 0 : int agp_generic_type_to_mask_type(struct agp_bridge_data *bridge,
1328 : : int type)
1329 : : {
1330 [ # # ]: 0 : if (type >= AGP_USER_TYPES)
1331 : 0 : return 0;
1332 : : return type;
1333 : : }
1334 : : EXPORT_SYMBOL(agp_generic_type_to_mask_type);
1335 : :
1336 : : /*
1337 : : * These functions are implemented according to the AGPv3 spec,
1338 : : * which covers implementation details that had previously been
1339 : : * left open.
1340 : : */
1341 : :
1342 : 0 : int agp3_generic_fetch_size(void)
1343 : : {
1344 : 0 : u16 temp_size;
1345 : 0 : int i;
1346 : 0 : struct aper_size_info_16 *values;
1347 : :
1348 : 0 : pci_read_config_word(agp_bridge->dev, agp_bridge->capndx+AGPAPSIZE, &temp_size);
1349 : 0 : values = A_SIZE_16(agp_bridge->driver->aperture_sizes);
1350 : :
1351 [ # # ]: 0 : for (i = 0; i < agp_bridge->driver->num_aperture_sizes; i++) {
1352 [ # # ]: 0 : if (temp_size == values[i].size_value) {
1353 : 0 : agp_bridge->previous_size =
1354 : 0 : agp_bridge->current_size = (void *) (values + i);
1355 : :
1356 : 0 : agp_bridge->aperture_size_idx = i;
1357 : 0 : return values[i].size;
1358 : : }
1359 : : }
1360 : : return 0;
1361 : : }
1362 : : EXPORT_SYMBOL(agp3_generic_fetch_size);
1363 : :
1364 : 0 : void agp3_generic_tlbflush(struct agp_memory *mem)
1365 : : {
1366 : 0 : u32 ctrl;
1367 : 0 : pci_read_config_dword(agp_bridge->dev, agp_bridge->capndx+AGPCTRL, &ctrl);
1368 : 0 : pci_write_config_dword(agp_bridge->dev, agp_bridge->capndx+AGPCTRL, ctrl & ~AGPCTRL_GTLBEN);
1369 : 0 : pci_write_config_dword(agp_bridge->dev, agp_bridge->capndx+AGPCTRL, ctrl);
1370 : 0 : }
1371 : : EXPORT_SYMBOL(agp3_generic_tlbflush);
1372 : :
1373 : 0 : int agp3_generic_configure(void)
1374 : : {
1375 : 0 : u32 temp;
1376 : 0 : struct aper_size_info_16 *current_size;
1377 : :
1378 : 0 : current_size = A_SIZE_16(agp_bridge->current_size);
1379 : :
1380 : 0 : agp_bridge->gart_bus_addr = pci_bus_address(agp_bridge->dev,
1381 : : AGP_APERTURE_BAR);
1382 : :
1383 : : /* set aperture size */
1384 : 0 : pci_write_config_word(agp_bridge->dev, agp_bridge->capndx+AGPAPSIZE, current_size->size_value);
1385 : : /* set gart pointer */
1386 : 0 : pci_write_config_dword(agp_bridge->dev, agp_bridge->capndx+AGPGARTLO, agp_bridge->gatt_bus_addr);
1387 : : /* enable aperture and GTLB */
1388 : 0 : pci_read_config_dword(agp_bridge->dev, agp_bridge->capndx+AGPCTRL, &temp);
1389 : 0 : pci_write_config_dword(agp_bridge->dev, agp_bridge->capndx+AGPCTRL, temp | AGPCTRL_APERENB | AGPCTRL_GTLBEN);
1390 : 0 : return 0;
1391 : : }
1392 : : EXPORT_SYMBOL(agp3_generic_configure);
1393 : :
1394 : 0 : void agp3_generic_cleanup(void)
1395 : : {
1396 : 0 : u32 ctrl;
1397 : 0 : pci_read_config_dword(agp_bridge->dev, agp_bridge->capndx+AGPCTRL, &ctrl);
1398 : 0 : pci_write_config_dword(agp_bridge->dev, agp_bridge->capndx+AGPCTRL, ctrl & ~AGPCTRL_APERENB);
1399 : 0 : }
1400 : : EXPORT_SYMBOL(agp3_generic_cleanup);
1401 : :
1402 : : const struct aper_size_info_16 agp3_generic_sizes[AGP_GENERIC_SIZES_ENTRIES] =
1403 : : {
1404 : : {4096, 1048576, 10,0x000},
1405 : : {2048, 524288, 9, 0x800},
1406 : : {1024, 262144, 8, 0xc00},
1407 : : { 512, 131072, 7, 0xe00},
1408 : : { 256, 65536, 6, 0xf00},
1409 : : { 128, 32768, 5, 0xf20},
1410 : : { 64, 16384, 4, 0xf30},
1411 : : { 32, 8192, 3, 0xf38},
1412 : : { 16, 4096, 2, 0xf3c},
1413 : : { 8, 2048, 1, 0xf3e},
1414 : : { 4, 1024, 0, 0xf3f}
1415 : : };
1416 : : EXPORT_SYMBOL(agp3_generic_sizes);
1417 : :
|
