blob: eaa1a355bb326a483b270689347fc49a80cbe05a [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#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/vmalloc.h>
38#include <linux/dma-mapping.h>
39#include <linux/mm.h>
Alexey Dobriyane8edc6e2007-05-21 01:22:52 +040040#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041#include <asm/io.h>
42#include <asm/cacheflush.h>
43#include <asm/pgtable.h>
44#include "agp.h"
45
46__u32 *agp_gatt_table;
47int agp_memory_reserved;
48
49/*
50 * Needed by the Nforce GART driver for the time being. Would be
51 * nice to do this some other way instead of needing this export.
52 */
53EXPORT_SYMBOL_GPL(agp_memory_reserved);
54
Linus Torvalds1da177e2005-04-16 15:20:36 -070055/*
56 * Generic routines for handling agp_memory structures -
57 * They use the basic page allocation routines to do the brunt of the work.
58 */
59
60void agp_free_key(int key)
61{
62 if (key < 0)
63 return;
64
65 if (key < MAXKEY)
66 clear_bit(key, agp_bridge->key_list);
67}
68EXPORT_SYMBOL(agp_free_key);
69
70
71static int agp_get_key(void)
72{
73 int bit;
74
75 bit = find_first_zero_bit(agp_bridge->key_list, MAXKEY);
76 if (bit < MAXKEY) {
77 set_bit(bit, agp_bridge->key_list);
78 return bit;
79 }
80 return -1;
81}
82
Dave Airliea13af4b2007-10-29 15:14:03 +100083void agp_flush_chipset(struct agp_bridge_data *bridge)
84{
85 if (bridge->driver->chipset_flush)
86 bridge->driver->chipset_flush(bridge);
87}
88EXPORT_SYMBOL(agp_flush_chipset);
89
Thomas Hellstroma030ce42007-01-23 10:33:43 +010090/*
91 * Use kmalloc if possible for the page list. Otherwise fall back to
92 * vmalloc. This speeds things up and also saves memory for small AGP
93 * regions.
94 */
95
96void agp_alloc_page_array(size_t size, struct agp_memory *mem)
97{
98 mem->memory = NULL;
Dave Airlie9516b032008-06-19 10:42:17 +100099 mem->vmalloc_flag = false;
Thomas Hellstroma030ce42007-01-23 10:33:43 +0100100
Andrew Morton1c14cfb2007-02-05 16:09:35 -0800101 if (size <= 2*PAGE_SIZE)
Thomas Hellstroma030ce42007-01-23 10:33:43 +0100102 mem->memory = kmalloc(size, GFP_KERNEL | __GFP_NORETRY);
Thomas Hellstroma030ce42007-01-23 10:33:43 +0100103 if (mem->memory == NULL) {
104 mem->memory = vmalloc(size);
Dave Airlie9516b032008-06-19 10:42:17 +1000105 mem->vmalloc_flag = true;
Thomas Hellstroma030ce42007-01-23 10:33:43 +0100106 }
107}
108EXPORT_SYMBOL(agp_alloc_page_array);
109
110void agp_free_page_array(struct agp_memory *mem)
111{
112 if (mem->vmalloc_flag) {
113 vfree(mem->memory);
114 } else {
115 kfree(mem->memory);
116 }
117}
118EXPORT_SYMBOL(agp_free_page_array);
119
120
121static struct agp_memory *agp_create_user_memory(unsigned long num_agp_pages)
122{
123 struct agp_memory *new;
124 unsigned long alloc_size = num_agp_pages*sizeof(struct page *);
125
Andrew Morton1c14cfb2007-02-05 16:09:35 -0800126 new = kzalloc(sizeof(struct agp_memory), GFP_KERNEL);
Thomas Hellstroma030ce42007-01-23 10:33:43 +0100127 if (new == NULL)
128 return NULL;
129
Thomas Hellstroma030ce42007-01-23 10:33:43 +0100130 new->key = agp_get_key();
131
132 if (new->key < 0) {
133 kfree(new);
134 return NULL;
135 }
136
137 agp_alloc_page_array(alloc_size, new);
138
139 if (new->memory == NULL) {
140 agp_free_key(new->key);
141 kfree(new);
142 return NULL;
143 }
144 new->num_scratch_pages = 0;
145 return new;
146}
147
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148struct agp_memory *agp_create_memory(int scratch_pages)
149{
150 struct agp_memory *new;
151
Dave Jones0ea27d92005-10-20 15:12:16 -0700152 new = kzalloc(sizeof(struct agp_memory), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 if (new == NULL)
154 return NULL;
155
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 new->key = agp_get_key();
157
158 if (new->key < 0) {
159 kfree(new);
160 return NULL;
161 }
Thomas Hellstroma030ce42007-01-23 10:33:43 +0100162
163 agp_alloc_page_array(PAGE_SIZE * scratch_pages, new);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164
165 if (new->memory == NULL) {
166 agp_free_key(new->key);
167 kfree(new);
168 return NULL;
169 }
170 new->num_scratch_pages = scratch_pages;
Thomas Hellstroma030ce42007-01-23 10:33:43 +0100171 new->type = AGP_NORMAL_MEMORY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172 return new;
173}
174EXPORT_SYMBOL(agp_create_memory);
175
176/**
177 * agp_free_memory - free memory associated with an agp_memory pointer.
178 *
179 * @curr: agp_memory pointer to be freed.
180 *
181 * It is the only function that can be called when the backend is not owned
182 * by the caller. (So it can free memory on client death.)
183 */
184void agp_free_memory(struct agp_memory *curr)
185{
186 size_t i;
187
188 if (curr == NULL)
189 return;
190
Joe Perchesc7258012008-03-26 14:10:02 -0700191 if (curr->is_bound)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 agp_unbind_memory(curr);
193
Thomas Hellstroma030ce42007-01-23 10:33:43 +0100194 if (curr->type >= AGP_USER_TYPES) {
195 agp_generic_free_by_type(curr);
196 return;
197 }
198
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 if (curr->type != 0) {
200 curr->bridge->driver->free_by_type(curr);
201 return;
202 }
203 if (curr->page_count != 0) {
204 for (i = 0; i < curr->page_count; i++) {
Jan Beulichda503fa2008-06-18 09:28:00 +0100205 curr->memory[i] = (unsigned long)gart_to_virt(curr->memory[i]);
206 curr->bridge->driver->agp_destroy_page((void *)curr->memory[i],
207 AGP_PAGE_DESTROY_UNMAP);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 }
Dave Airliea2721e92007-10-15 10:19:16 +1000209 for (i = 0; i < curr->page_count; i++) {
Jan Beulichda503fa2008-06-18 09:28:00 +0100210 curr->bridge->driver->agp_destroy_page((void *)curr->memory[i],
211 AGP_PAGE_DESTROY_FREE);
Dave Airliea2721e92007-10-15 10:19:16 +1000212 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 }
214 agp_free_key(curr->key);
Thomas Hellstroma030ce42007-01-23 10:33:43 +0100215 agp_free_page_array(curr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 kfree(curr);
217}
218EXPORT_SYMBOL(agp_free_memory);
219
220#define ENTRIES_PER_PAGE (PAGE_SIZE / sizeof(unsigned long))
221
222/**
223 * agp_allocate_memory - allocate a group of pages of a certain type.
224 *
225 * @page_count: size_t argument of the number of pages
226 * @type: u32 argument of the type of memory to be allocated.
227 *
228 * Every agp bridge device will allow you to allocate AGP_NORMAL_MEMORY which
229 * maps to physical ram. Any other type is device dependent.
230 *
231 * It returns NULL whenever memory is unavailable.
232 */
233struct agp_memory *agp_allocate_memory(struct agp_bridge_data *bridge,
234 size_t page_count, u32 type)
235{
236 int scratch_pages;
237 struct agp_memory *new;
238 size_t i;
239
240 if (!bridge)
241 return NULL;
242
243 if ((atomic_read(&bridge->current_memory_agp) + page_count) > bridge->max_memory_agp)
244 return NULL;
245
Thomas Hellstroma030ce42007-01-23 10:33:43 +0100246 if (type >= AGP_USER_TYPES) {
247 new = agp_generic_alloc_user(page_count, type);
248 if (new)
249 new->bridge = bridge;
250 return new;
251 }
252
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 if (type != 0) {
254 new = bridge->driver->alloc_by_type(page_count, type);
255 if (new)
256 new->bridge = bridge;
257 return new;
258 }
259
260 scratch_pages = (page_count + ENTRIES_PER_PAGE - 1) / ENTRIES_PER_PAGE;
261
262 new = agp_create_memory(scratch_pages);
263
264 if (new == NULL)
265 return NULL;
266
267 for (i = 0; i < page_count; i++) {
268 void *addr = bridge->driver->agp_alloc_page(bridge);
269
270 if (addr == NULL) {
271 agp_free_memory(new);
272 return NULL;
273 }
Keir Fraser07eee782005-03-30 13:17:04 -0800274 new->memory[i] = virt_to_gart(addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 new->page_count++;
276 }
Alan Hourihane88d51962005-11-06 23:35:34 -0800277 new->bridge = bridge;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 return new;
280}
281EXPORT_SYMBOL(agp_allocate_memory);
282
283
284/* End - Generic routines for handling agp_memory structures */
285
286
287static int agp_return_size(void)
288{
289 int current_size;
290 void *temp;
291
292 temp = agp_bridge->current_size;
293
294 switch (agp_bridge->driver->size_type) {
295 case U8_APER_SIZE:
296 current_size = A_SIZE_8(temp)->size;
297 break;
298 case U16_APER_SIZE:
299 current_size = A_SIZE_16(temp)->size;
300 break;
301 case U32_APER_SIZE:
302 current_size = A_SIZE_32(temp)->size;
303 break;
304 case LVL2_APER_SIZE:
305 current_size = A_SIZE_LVL2(temp)->size;
306 break;
307 case FIXED_APER_SIZE:
308 current_size = A_SIZE_FIX(temp)->size;
309 break;
310 default:
311 current_size = 0;
312 break;
313 }
314
315 current_size -= (agp_memory_reserved / (1024*1024));
316 if (current_size <0)
317 current_size = 0;
318 return current_size;
319}
320
321
322int agp_num_entries(void)
323{
324 int num_entries;
325 void *temp;
326
327 temp = agp_bridge->current_size;
328
329 switch (agp_bridge->driver->size_type) {
330 case U8_APER_SIZE:
331 num_entries = A_SIZE_8(temp)->num_entries;
332 break;
333 case U16_APER_SIZE:
334 num_entries = A_SIZE_16(temp)->num_entries;
335 break;
336 case U32_APER_SIZE:
337 num_entries = A_SIZE_32(temp)->num_entries;
338 break;
339 case LVL2_APER_SIZE:
340 num_entries = A_SIZE_LVL2(temp)->num_entries;
341 break;
342 case FIXED_APER_SIZE:
343 num_entries = A_SIZE_FIX(temp)->num_entries;
344 break;
345 default:
346 num_entries = 0;
347 break;
348 }
349
350 num_entries -= agp_memory_reserved>>PAGE_SHIFT;
351 if (num_entries<0)
352 num_entries = 0;
353 return num_entries;
354}
355EXPORT_SYMBOL_GPL(agp_num_entries);
356
357
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358/**
359 * agp_copy_info - copy bridge state information
360 *
Dave Jones6a92a4e2006-02-28 00:54:25 -0500361 * @info: agp_kern_info pointer. The caller should insure that this pointer is valid.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 *
363 * This function copies information about the agp bridge device and the state of
364 * the agp backend into an agp_kern_info pointer.
365 */
366int agp_copy_info(struct agp_bridge_data *bridge, struct agp_kern_info *info)
367{
368 memset(info, 0, sizeof(struct agp_kern_info));
369 if (!bridge) {
370 info->chipset = NOT_SUPPORTED;
371 return -EIO;
372 }
373
374 info->version.major = bridge->version->major;
375 info->version.minor = bridge->version->minor;
376 info->chipset = SUPPORTED;
377 info->device = bridge->dev;
David Mosberger66bb8bf2005-04-04 13:29:43 -0700378 if (bridge->mode & AGPSTAT_MODE_3_0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 info->mode = bridge->mode & ~AGP3_RESERVED_MASK;
380 else
381 info->mode = bridge->mode & ~AGP2_RESERVED_MASK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 info->aper_base = bridge->gart_bus_addr;
383 info->aper_size = agp_return_size();
384 info->max_memory = bridge->max_memory_agp;
385 info->current_memory = atomic_read(&bridge->current_memory_agp);
386 info->cant_use_aperture = bridge->driver->cant_use_aperture;
387 info->vm_ops = bridge->vm_ops;
388 info->page_mask = ~0UL;
389 return 0;
390}
391EXPORT_SYMBOL(agp_copy_info);
392
393/* End - Routine to copy over information structure */
394
395/*
396 * Routines for handling swapping of agp_memory into the GATT -
397 * These routines take agp_memory and insert them into the GATT.
398 * They call device specific routines to actually write to the GATT.
399 */
400
401/**
402 * agp_bind_memory - Bind an agp_memory structure into the GATT.
403 *
404 * @curr: agp_memory pointer
405 * @pg_start: an offset into the graphics aperture translation table
406 *
407 * It returns -EINVAL if the pointer == NULL.
408 * It returns -EBUSY if the area of the table requested is already in use.
409 */
410int agp_bind_memory(struct agp_memory *curr, off_t pg_start)
411{
412 int ret_val;
413
414 if (curr == NULL)
415 return -EINVAL;
416
Joe Perchesc7258012008-03-26 14:10:02 -0700417 if (curr->is_bound) {
Dave Jones8c8b8382005-08-17 23:08:11 -0700418 printk(KERN_INFO PFX "memory %p is already bound!\n", curr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 return -EINVAL;
420 }
Joe Perchesc7258012008-03-26 14:10:02 -0700421 if (!curr->is_flushed) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 curr->bridge->driver->cache_flush();
Joe Perchesc7258012008-03-26 14:10:02 -0700423 curr->is_flushed = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 }
425 ret_val = curr->bridge->driver->insert_memory(curr, pg_start, curr->type);
426
427 if (ret_val != 0)
428 return ret_val;
429
Joe Perchesc7258012008-03-26 14:10:02 -0700430 curr->is_bound = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 curr->pg_start = pg_start;
432 return 0;
433}
434EXPORT_SYMBOL(agp_bind_memory);
435
436
437/**
438 * agp_unbind_memory - Removes an agp_memory structure from the GATT
439 *
440 * @curr: agp_memory pointer to be removed from the GATT.
441 *
442 * It returns -EINVAL if this piece of agp_memory is not currently bound to
443 * the graphics aperture translation table or if the agp_memory pointer == NULL
444 */
445int agp_unbind_memory(struct agp_memory *curr)
446{
447 int ret_val;
448
449 if (curr == NULL)
450 return -EINVAL;
451
Joe Perchesc7258012008-03-26 14:10:02 -0700452 if (!curr->is_bound) {
Dave Jones8c8b8382005-08-17 23:08:11 -0700453 printk(KERN_INFO PFX "memory %p was not bound!\n", curr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 return -EINVAL;
455 }
456
457 ret_val = curr->bridge->driver->remove_memory(curr, curr->pg_start, curr->type);
458
459 if (ret_val != 0)
460 return ret_val;
461
Joe Perchesc7258012008-03-26 14:10:02 -0700462 curr->is_bound = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 curr->pg_start = 0;
464 return 0;
465}
466EXPORT_SYMBOL(agp_unbind_memory);
467
468/* End - Routines for handling swapping of agp_memory into the GATT */
469
470
471/* Generic Agp routines - Start */
472static void agp_v2_parse_one(u32 *requested_mode, u32 *bridge_agpstat, u32 *vga_agpstat)
473{
474 u32 tmp;
475
476 if (*requested_mode & AGP2_RESERVED_MASK) {
Dave Jonesc4dd4582005-11-04 15:18:56 -0800477 printk(KERN_INFO PFX "reserved bits set (%x) in mode 0x%x. Fixed.\n",
478 *requested_mode & AGP2_RESERVED_MASK, *requested_mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 *requested_mode &= ~AGP2_RESERVED_MASK;
480 }
481
Dave Jones28af24b2006-11-03 15:13:27 -0500482 /*
483 * Some dumb bridges are programmed to disobey the AGP2 spec.
484 * This is likely a BIOS misprogramming rather than poweron default, or
485 * it would be a lot more common.
486 * https://bugs.freedesktop.org/show_bug.cgi?id=8816
487 * AGPv2 spec 6.1.9 states:
488 * The RATE field indicates the data transfer rates supported by this
489 * device. A.G.P. devices must report all that apply.
490 * Fix them up as best we can.
491 */
492 switch (*bridge_agpstat & 7) {
493 case 4:
494 *bridge_agpstat |= (AGPSTAT2_2X | AGPSTAT2_1X);
495 printk(KERN_INFO PFX "BIOS bug. AGP bridge claims to only support x4 rate"
496 "Fixing up support for x2 & x1\n");
497 break;
498 case 2:
499 *bridge_agpstat |= AGPSTAT2_1X;
500 printk(KERN_INFO PFX "BIOS bug. AGP bridge claims to only support x2 rate"
501 "Fixing up support for x1\n");
502 break;
503 default:
504 break;
505 }
506
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 /* Check the speed bits make sense. Only one should be set. */
508 tmp = *requested_mode & 7;
509 switch (tmp) {
510 case 0:
Dave Jones8c8b8382005-08-17 23:08:11 -0700511 printk(KERN_INFO PFX "%s tried to set rate=x0. Setting to x1 mode.\n", current->comm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 *requested_mode |= AGPSTAT2_1X;
513 break;
514 case 1:
515 case 2:
516 break;
517 case 3:
518 *requested_mode &= ~(AGPSTAT2_1X); /* rate=2 */
519 break;
520 case 4:
521 break;
522 case 5:
523 case 6:
524 case 7:
525 *requested_mode &= ~(AGPSTAT2_1X|AGPSTAT2_2X); /* rate=4*/
526 break;
527 }
528
529 /* disable SBA if it's not supported */
530 if (!((*bridge_agpstat & AGPSTAT_SBA) && (*vga_agpstat & AGPSTAT_SBA) && (*requested_mode & AGPSTAT_SBA)))
531 *bridge_agpstat &= ~AGPSTAT_SBA;
532
533 /* Set rate */
534 if (!((*bridge_agpstat & AGPSTAT2_4X) && (*vga_agpstat & AGPSTAT2_4X) && (*requested_mode & AGPSTAT2_4X)))
535 *bridge_agpstat &= ~AGPSTAT2_4X;
536
537 if (!((*bridge_agpstat & AGPSTAT2_2X) && (*vga_agpstat & AGPSTAT2_2X) && (*requested_mode & AGPSTAT2_2X)))
538 *bridge_agpstat &= ~AGPSTAT2_2X;
539
540 if (!((*bridge_agpstat & AGPSTAT2_1X) && (*vga_agpstat & AGPSTAT2_1X) && (*requested_mode & AGPSTAT2_1X)))
541 *bridge_agpstat &= ~AGPSTAT2_1X;
542
543 /* Now we know what mode it should be, clear out the unwanted bits. */
544 if (*bridge_agpstat & AGPSTAT2_4X)
545 *bridge_agpstat &= ~(AGPSTAT2_1X | AGPSTAT2_2X); /* 4X */
546
547 if (*bridge_agpstat & AGPSTAT2_2X)
548 *bridge_agpstat &= ~(AGPSTAT2_1X | AGPSTAT2_4X); /* 2X */
549
550 if (*bridge_agpstat & AGPSTAT2_1X)
551 *bridge_agpstat &= ~(AGPSTAT2_2X | AGPSTAT2_4X); /* 1X */
552
553 /* Apply any errata. */
554 if (agp_bridge->flags & AGP_ERRATA_FASTWRITES)
555 *bridge_agpstat &= ~AGPSTAT_FW;
556
557 if (agp_bridge->flags & AGP_ERRATA_SBA)
558 *bridge_agpstat &= ~AGPSTAT_SBA;
559
560 if (agp_bridge->flags & AGP_ERRATA_1X) {
561 *bridge_agpstat &= ~(AGPSTAT2_2X | AGPSTAT2_4X);
562 *bridge_agpstat |= AGPSTAT2_1X;
563 }
564
565 /* If we've dropped down to 1X, disable fast writes. */
566 if (*bridge_agpstat & AGPSTAT2_1X)
567 *bridge_agpstat &= ~AGPSTAT_FW;
568}
569
570/*
571 * requested_mode = Mode requested by (typically) X.
572 * bridge_agpstat = PCI_AGP_STATUS from agp bridge.
573 * vga_agpstat = PCI_AGP_STATUS from graphic card.
574 */
575static void agp_v3_parse_one(u32 *requested_mode, u32 *bridge_agpstat, u32 *vga_agpstat)
576{
577 u32 origbridge=*bridge_agpstat, origvga=*vga_agpstat;
578 u32 tmp;
579
580 if (*requested_mode & AGP3_RESERVED_MASK) {
Dave Jonesc4dd4582005-11-04 15:18:56 -0800581 printk(KERN_INFO PFX "reserved bits set (%x) in mode 0x%x. Fixed.\n",
582 *requested_mode & AGP3_RESERVED_MASK, *requested_mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 *requested_mode &= ~AGP3_RESERVED_MASK;
584 }
585
586 /* Check the speed bits make sense. */
587 tmp = *requested_mode & 7;
588 if (tmp == 0) {
Dave Jones8c8b8382005-08-17 23:08:11 -0700589 printk(KERN_INFO PFX "%s tried to set rate=x0. Setting to AGP3 x4 mode.\n", current->comm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 *requested_mode |= AGPSTAT3_4X;
591 }
592 if (tmp >= 3) {
Dave Jones8c8b8382005-08-17 23:08:11 -0700593 printk(KERN_INFO PFX "%s tried to set rate=x%d. Setting to AGP3 x8 mode.\n", current->comm, tmp * 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594 *requested_mode = (*requested_mode & ~7) | AGPSTAT3_8X;
595 }
596
597 /* ARQSZ - Set the value to the maximum one.
598 * Don't allow the mode register to override values. */
599 *bridge_agpstat = ((*bridge_agpstat & ~AGPSTAT_ARQSZ) |
600 max_t(u32,(*bridge_agpstat & AGPSTAT_ARQSZ),(*vga_agpstat & AGPSTAT_ARQSZ)));
601
602 /* Calibration cycle.
603 * Don't allow the mode register to override values. */
604 *bridge_agpstat = ((*bridge_agpstat & ~AGPSTAT_CAL_MASK) |
605 min_t(u32,(*bridge_agpstat & AGPSTAT_CAL_MASK),(*vga_agpstat & AGPSTAT_CAL_MASK)));
606
607 /* SBA *must* be supported for AGP v3 */
608 *bridge_agpstat |= AGPSTAT_SBA;
609
610 /*
611 * Set speed.
612 * Check for invalid speeds. This can happen when applications
613 * written before the AGP 3.0 standard pass AGP2.x modes to AGP3 hardware
614 */
615 if (*requested_mode & AGPSTAT_MODE_3_0) {
616 /*
617 * Caller hasn't a clue what it is doing. Bridge is in 3.0 mode,
618 * have been passed a 3.0 mode, but with 2.x speed bits set.
619 * AGP2.x 4x -> AGP3.0 4x.
620 */
621 if (*requested_mode & AGPSTAT2_4X) {
Dave Jones8c8b8382005-08-17 23:08:11 -0700622 printk(KERN_INFO PFX "%s passes broken AGP3 flags (%x). Fixed.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 current->comm, *requested_mode);
624 *requested_mode &= ~AGPSTAT2_4X;
625 *requested_mode |= AGPSTAT3_4X;
626 }
627 } else {
628 /*
629 * The caller doesn't know what they are doing. We are in 3.0 mode,
630 * but have been passed an AGP 2.x mode.
631 * Convert AGP 1x,2x,4x -> AGP 3.0 4x.
632 */
Dave Jones8c8b8382005-08-17 23:08:11 -0700633 printk(KERN_INFO PFX "%s passes broken AGP2 flags (%x) in AGP3 mode. Fixed.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 current->comm, *requested_mode);
635 *requested_mode &= ~(AGPSTAT2_4X | AGPSTAT2_2X | AGPSTAT2_1X);
636 *requested_mode |= AGPSTAT3_4X;
637 }
638
639 if (*requested_mode & AGPSTAT3_8X) {
640 if (!(*bridge_agpstat & AGPSTAT3_8X)) {
641 *bridge_agpstat &= ~(AGPSTAT3_8X | AGPSTAT3_RSVD);
642 *bridge_agpstat |= AGPSTAT3_4X;
Dave Jones8c8b8382005-08-17 23:08:11 -0700643 printk(KERN_INFO PFX "%s requested AGPx8 but bridge not capable.\n", current->comm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644 return;
645 }
646 if (!(*vga_agpstat & AGPSTAT3_8X)) {
647 *bridge_agpstat &= ~(AGPSTAT3_8X | AGPSTAT3_RSVD);
648 *bridge_agpstat |= AGPSTAT3_4X;
Dave Jones8c8b8382005-08-17 23:08:11 -0700649 printk(KERN_INFO PFX "%s requested AGPx8 but graphic card not capable.\n", current->comm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 return;
651 }
652 /* All set, bridge & device can do AGP x8*/
653 *bridge_agpstat &= ~(AGPSTAT3_4X | AGPSTAT3_RSVD);
654 goto done;
655
Dave Jonesedf03fb2006-09-10 21:12:20 -0400656 } else if (*requested_mode & AGPSTAT3_4X) {
657 *bridge_agpstat &= ~(AGPSTAT3_8X | AGPSTAT3_RSVD);
658 *bridge_agpstat |= AGPSTAT3_4X;
659 goto done;
660
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 } else {
662
663 /*
Dave Jonesedf03fb2006-09-10 21:12:20 -0400664 * If we didn't specify an AGP mode, we see if both
665 * the graphics card, and the bridge can do x8, and use if so.
666 * If not, we fall back to x4 mode.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667 */
Dave Jonesedf03fb2006-09-10 21:12:20 -0400668 if ((*bridge_agpstat & AGPSTAT3_8X) && (*vga_agpstat & AGPSTAT3_8X)) {
Dave Jones2cc1a412006-09-28 19:50:07 -0400669 printk(KERN_INFO PFX "No AGP mode specified. Setting to highest mode "
670 "supported by bridge & card (x8).\n");
Dave Jonesedf03fb2006-09-10 21:12:20 -0400671 *bridge_agpstat &= ~(AGPSTAT3_4X | AGPSTAT3_RSVD);
672 *vga_agpstat &= ~(AGPSTAT3_4X | AGPSTAT3_RSVD);
673 } else {
674 printk(KERN_INFO PFX "Fell back to AGPx4 mode because");
675 if (!(*bridge_agpstat & AGPSTAT3_8X)) {
Dave Jones2cc1a412006-09-28 19:50:07 -0400676 printk(KERN_INFO PFX "bridge couldn't do x8. bridge_agpstat:%x (orig=%x)\n",
677 *bridge_agpstat, origbridge);
Dave Jonesedf03fb2006-09-10 21:12:20 -0400678 *bridge_agpstat &= ~(AGPSTAT3_8X | AGPSTAT3_RSVD);
679 *bridge_agpstat |= AGPSTAT3_4X;
680 }
681 if (!(*vga_agpstat & AGPSTAT3_8X)) {
Dave Jones2cc1a412006-09-28 19:50:07 -0400682 printk(KERN_INFO PFX "graphics card couldn't do x8. vga_agpstat:%x (orig=%x)\n",
683 *vga_agpstat, origvga);
Dave Jonesedf03fb2006-09-10 21:12:20 -0400684 *vga_agpstat &= ~(AGPSTAT3_8X | AGPSTAT3_RSVD);
685 *vga_agpstat |= AGPSTAT3_4X;
686 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 }
688 }
689
690done:
691 /* Apply any errata. */
692 if (agp_bridge->flags & AGP_ERRATA_FASTWRITES)
693 *bridge_agpstat &= ~AGPSTAT_FW;
694
695 if (agp_bridge->flags & AGP_ERRATA_SBA)
696 *bridge_agpstat &= ~AGPSTAT_SBA;
697
698 if (agp_bridge->flags & AGP_ERRATA_1X) {
699 *bridge_agpstat &= ~(AGPSTAT2_2X | AGPSTAT2_4X);
700 *bridge_agpstat |= AGPSTAT2_1X;
701 }
702}
703
704
705/**
706 * agp_collect_device_status - determine correct agp_cmd from various agp_stat's
707 * @bridge: an agp_bridge_data struct allocated for the AGP host bridge.
708 * @requested_mode: requested agp_stat from userspace (Typically from X)
709 * @bridge_agpstat: current agp_stat from AGP bridge.
710 *
711 * This function will hunt for an AGP graphics card, and try to match
712 * the requested mode to the capabilities of both the bridge and the card.
713 */
714u32 agp_collect_device_status(struct agp_bridge_data *bridge, u32 requested_mode, u32 bridge_agpstat)
715{
716 struct pci_dev *device = NULL;
717 u32 vga_agpstat;
718 u8 cap_ptr;
719
720 for (;;) {
721 device = pci_get_class(PCI_CLASS_DISPLAY_VGA << 8, device);
722 if (!device) {
Dave Jones8c8b8382005-08-17 23:08:11 -0700723 printk(KERN_INFO PFX "Couldn't find an AGP VGA controller.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 return 0;
725 }
726 cap_ptr = pci_find_capability(device, PCI_CAP_ID_AGP);
727 if (cap_ptr)
728 break;
729 }
730
731 /*
732 * Ok, here we have a AGP device. Disable impossible
733 * settings, and adjust the readqueue to the minimum.
734 */
735 pci_read_config_dword(device, cap_ptr+PCI_AGP_STATUS, &vga_agpstat);
736
737 /* adjust RQ depth */
738 bridge_agpstat = ((bridge_agpstat & ~AGPSTAT_RQ_DEPTH) |
739 min_t(u32, (requested_mode & AGPSTAT_RQ_DEPTH),
740 min_t(u32, (bridge_agpstat & AGPSTAT_RQ_DEPTH), (vga_agpstat & AGPSTAT_RQ_DEPTH))));
741
742 /* disable FW if it's not supported */
743 if (!((bridge_agpstat & AGPSTAT_FW) &&
744 (vga_agpstat & AGPSTAT_FW) &&
745 (requested_mode & AGPSTAT_FW)))
746 bridge_agpstat &= ~AGPSTAT_FW;
747
748 /* Check to see if we are operating in 3.0 mode */
David Mosberger66bb8bf2005-04-04 13:29:43 -0700749 if (agp_bridge->mode & AGPSTAT_MODE_3_0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 agp_v3_parse_one(&requested_mode, &bridge_agpstat, &vga_agpstat);
751 else
752 agp_v2_parse_one(&requested_mode, &bridge_agpstat, &vga_agpstat);
753
754 pci_dev_put(device);
755 return bridge_agpstat;
756}
757EXPORT_SYMBOL(agp_collect_device_status);
758
759
Joe Perchesc7258012008-03-26 14:10:02 -0700760void agp_device_command(u32 bridge_agpstat, bool agp_v3)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761{
762 struct pci_dev *device = NULL;
763 int mode;
764
765 mode = bridge_agpstat & 0x7;
766 if (agp_v3)
767 mode *= 4;
768
769 for_each_pci_dev(device) {
770 u8 agp = pci_find_capability(device, PCI_CAP_ID_AGP);
771 if (!agp)
772 continue;
773
774 printk(KERN_INFO PFX "Putting AGP V%d device at %s into %dx mode\n",
775 agp_v3 ? 3 : 2, pci_name(device), mode);
776 pci_write_config_dword(device, agp + PCI_AGP_COMMAND, bridge_agpstat);
777 }
778}
779EXPORT_SYMBOL(agp_device_command);
780
781
782void get_agp_version(struct agp_bridge_data *bridge)
783{
784 u32 ncapid;
785
786 /* Exit early if already set by errata workarounds. */
787 if (bridge->major_version != 0)
788 return;
789
790 pci_read_config_dword(bridge->dev, bridge->capndx, &ncapid);
791 bridge->major_version = (ncapid >> AGP_MAJOR_VERSION_SHIFT) & 0xf;
792 bridge->minor_version = (ncapid >> AGP_MINOR_VERSION_SHIFT) & 0xf;
793}
794EXPORT_SYMBOL(get_agp_version);
795
796
797void agp_generic_enable(struct agp_bridge_data *bridge, u32 requested_mode)
798{
799 u32 bridge_agpstat, temp;
800
801 get_agp_version(agp_bridge);
802
803 printk(KERN_INFO PFX "Found an AGP %d.%d compliant device at %s.\n",
804 agp_bridge->major_version,
805 agp_bridge->minor_version,
806 pci_name(agp_bridge->dev));
807
808 pci_read_config_dword(agp_bridge->dev,
809 agp_bridge->capndx + PCI_AGP_STATUS, &bridge_agpstat);
810
811 bridge_agpstat = agp_collect_device_status(agp_bridge, requested_mode, bridge_agpstat);
812 if (bridge_agpstat == 0)
813 /* Something bad happened. FIXME: Return error code? */
814 return;
815
816 bridge_agpstat |= AGPSTAT_AGP_ENABLE;
817
818 /* Do AGP version specific frobbing. */
819 if (bridge->major_version >= 3) {
David Mosberger66bb8bf2005-04-04 13:29:43 -0700820 if (bridge->mode & AGPSTAT_MODE_3_0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 /* If we have 3.5, we can do the isoch stuff. */
822 if (bridge->minor_version >= 5)
823 agp_3_5_enable(bridge);
Joe Perchesc7258012008-03-26 14:10:02 -0700824 agp_device_command(bridge_agpstat, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825 return;
826 } else {
827 /* Disable calibration cycle in RX91<1> when not in AGP3.0 mode of operation.*/
828 bridge_agpstat &= ~(7<<10) ;
829 pci_read_config_dword(bridge->dev,
830 bridge->capndx+AGPCTRL, &temp);
831 temp |= (1<<9);
832 pci_write_config_dword(bridge->dev,
833 bridge->capndx+AGPCTRL, temp);
834
Dave Jones8c8b8382005-08-17 23:08:11 -0700835 printk(KERN_INFO PFX "Device is in legacy mode,"
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836 " falling back to 2.x\n");
837 }
838 }
839
840 /* AGP v<3 */
Joe Perchesc7258012008-03-26 14:10:02 -0700841 agp_device_command(bridge_agpstat, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842}
843EXPORT_SYMBOL(agp_generic_enable);
844
845
846int agp_generic_create_gatt_table(struct agp_bridge_data *bridge)
847{
848 char *table;
849 char *table_end;
850 int size;
851 int page_order;
852 int num_entries;
853 int i;
854 void *temp;
855 struct page *page;
856
857 /* The generic routines can't handle 2 level gatt's */
858 if (bridge->driver->size_type == LVL2_APER_SIZE)
859 return -EINVAL;
860
861 table = NULL;
862 i = bridge->aperture_size_idx;
863 temp = bridge->current_size;
864 size = page_order = num_entries = 0;
865
866 if (bridge->driver->size_type != FIXED_APER_SIZE) {
867 do {
868 switch (bridge->driver->size_type) {
869 case U8_APER_SIZE:
870 size = A_SIZE_8(temp)->size;
871 page_order =
872 A_SIZE_8(temp)->page_order;
873 num_entries =
874 A_SIZE_8(temp)->num_entries;
875 break;
876 case U16_APER_SIZE:
877 size = A_SIZE_16(temp)->size;
878 page_order = A_SIZE_16(temp)->page_order;
879 num_entries = A_SIZE_16(temp)->num_entries;
880 break;
881 case U32_APER_SIZE:
882 size = A_SIZE_32(temp)->size;
883 page_order = A_SIZE_32(temp)->page_order;
884 num_entries = A_SIZE_32(temp)->num_entries;
885 break;
886 /* This case will never really happen. */
887 case FIXED_APER_SIZE:
888 case LVL2_APER_SIZE:
889 default:
890 size = page_order = num_entries = 0;
891 break;
892 }
893
Keir Fraser07eee782005-03-30 13:17:04 -0800894 table = alloc_gatt_pages(page_order);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895
896 if (table == NULL) {
897 i++;
898 switch (bridge->driver->size_type) {
899 case U8_APER_SIZE:
900 bridge->current_size = A_IDX8(bridge);
901 break;
902 case U16_APER_SIZE:
903 bridge->current_size = A_IDX16(bridge);
904 break;
905 case U32_APER_SIZE:
906 bridge->current_size = A_IDX32(bridge);
907 break;
Dave Jones89197e32006-05-30 18:19:39 -0400908 /* These cases will never really happen. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909 case FIXED_APER_SIZE:
910 case LVL2_APER_SIZE:
911 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912 break;
913 }
914 temp = bridge->current_size;
915 } else {
916 bridge->aperture_size_idx = i;
917 }
918 } while (!table && (i < bridge->driver->num_aperture_sizes));
919 } else {
920 size = ((struct aper_size_info_fixed *) temp)->size;
921 page_order = ((struct aper_size_info_fixed *) temp)->page_order;
922 num_entries = ((struct aper_size_info_fixed *) temp)->num_entries;
Keir Fraser07eee782005-03-30 13:17:04 -0800923 table = alloc_gatt_pages(page_order);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 }
925
926 if (table == NULL)
927 return -ENOMEM;
928
929 table_end = table + ((PAGE_SIZE * (1 << page_order)) - 1);
930
931 for (page = virt_to_page(table); page <= virt_to_page(table_end); page++)
932 SetPageReserved(page);
933
934 bridge->gatt_table_real = (u32 *) table;
935 agp_gatt_table = (void *)table;
936
937 bridge->driver->cache_flush();
Arjan van dev Venfcea4242008-02-06 05:16:00 +0100938#ifdef CONFIG_X86
939 set_memory_uc((unsigned long)table, 1 << page_order);
940 bridge->gatt_table = (void *)table;
941#else
Keir Fraser07eee782005-03-30 13:17:04 -0800942 bridge->gatt_table = ioremap_nocache(virt_to_gart(table),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943 (PAGE_SIZE * (1 << page_order)));
944 bridge->driver->cache_flush();
Arjan van dev Venfcea4242008-02-06 05:16:00 +0100945#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946
947 if (bridge->gatt_table == NULL) {
948 for (page = virt_to_page(table); page <= virt_to_page(table_end); page++)
949 ClearPageReserved(page);
950
Keir Fraser07eee782005-03-30 13:17:04 -0800951 free_gatt_pages(table, page_order);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952
953 return -ENOMEM;
954 }
Keir Fraser07eee782005-03-30 13:17:04 -0800955 bridge->gatt_bus_addr = virt_to_gart(bridge->gatt_table_real);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956
957 /* AK: bogus, should encode addresses > 4GB */
958 for (i = 0; i < num_entries; i++) {
959 writel(bridge->scratch_page, bridge->gatt_table+i);
960 readl(bridge->gatt_table+i); /* PCI Posting. */
961 }
962
963 return 0;
964}
965EXPORT_SYMBOL(agp_generic_create_gatt_table);
966
967int agp_generic_free_gatt_table(struct agp_bridge_data *bridge)
968{
969 int page_order;
970 char *table, *table_end;
971 void *temp;
972 struct page *page;
973
974 temp = bridge->current_size;
975
976 switch (bridge->driver->size_type) {
977 case U8_APER_SIZE:
978 page_order = A_SIZE_8(temp)->page_order;
979 break;
980 case U16_APER_SIZE:
981 page_order = A_SIZE_16(temp)->page_order;
982 break;
983 case U32_APER_SIZE:
984 page_order = A_SIZE_32(temp)->page_order;
985 break;
986 case FIXED_APER_SIZE:
987 page_order = A_SIZE_FIX(temp)->page_order;
988 break;
989 case LVL2_APER_SIZE:
990 /* The generic routines can't deal with 2 level gatt's */
991 return -EINVAL;
992 break;
993 default:
994 page_order = 0;
995 break;
996 }
997
998 /* Do not worry about freeing memory, because if this is
999 * called, then all agp memory is deallocated and removed
1000 * from the table. */
1001
Arjan van dev Venfcea4242008-02-06 05:16:00 +01001002#ifdef CONFIG_X86
1003 set_memory_wb((unsigned long)bridge->gatt_table, 1 << page_order);
1004#else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005 iounmap(bridge->gatt_table);
Arjan van dev Venfcea4242008-02-06 05:16:00 +01001006#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007 table = (char *) bridge->gatt_table_real;
1008 table_end = table + ((PAGE_SIZE * (1 << page_order)) - 1);
1009
1010 for (page = virt_to_page(table); page <= virt_to_page(table_end); page++)
1011 ClearPageReserved(page);
1012
Keir Fraser07eee782005-03-30 13:17:04 -08001013 free_gatt_pages(bridge->gatt_table_real, page_order);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014
1015 agp_gatt_table = NULL;
1016 bridge->gatt_table = NULL;
1017 bridge->gatt_table_real = NULL;
1018 bridge->gatt_bus_addr = 0;
1019
1020 return 0;
1021}
1022EXPORT_SYMBOL(agp_generic_free_gatt_table);
1023
1024
1025int agp_generic_insert_memory(struct agp_memory * mem, off_t pg_start, int type)
1026{
1027 int num_entries;
1028 size_t i;
1029 off_t j;
1030 void *temp;
1031 struct agp_bridge_data *bridge;
Thomas Hellstroma030ce42007-01-23 10:33:43 +01001032 int mask_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033
1034 bridge = mem->bridge;
1035 if (!bridge)
1036 return -EINVAL;
1037
Thomas Hellstrom5aa80c72006-12-20 16:33:41 +01001038 if (mem->page_count == 0)
1039 return 0;
1040
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041 temp = bridge->current_size;
1042
1043 switch (bridge->driver->size_type) {
1044 case U8_APER_SIZE:
1045 num_entries = A_SIZE_8(temp)->num_entries;
1046 break;
1047 case U16_APER_SIZE:
1048 num_entries = A_SIZE_16(temp)->num_entries;
1049 break;
1050 case U32_APER_SIZE:
1051 num_entries = A_SIZE_32(temp)->num_entries;
1052 break;
1053 case FIXED_APER_SIZE:
1054 num_entries = A_SIZE_FIX(temp)->num_entries;
1055 break;
1056 case LVL2_APER_SIZE:
1057 /* The generic routines can't deal with 2 level gatt's */
1058 return -EINVAL;
1059 break;
1060 default:
1061 num_entries = 0;
1062 break;
1063 }
1064
1065 num_entries -= agp_memory_reserved/PAGE_SIZE;
1066 if (num_entries < 0) num_entries = 0;
1067
Andrew Morton1c14cfb2007-02-05 16:09:35 -08001068 if (type != mem->type)
Thomas Hellstroma030ce42007-01-23 10:33:43 +01001069 return -EINVAL;
Thomas Hellstroma030ce42007-01-23 10:33:43 +01001070
1071 mask_type = bridge->driver->agp_type_to_mask_type(bridge, type);
1072 if (mask_type != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073 /* The generic routines know nothing of memory types */
1074 return -EINVAL;
1075 }
1076
1077 /* AK: could wrap */
1078 if ((pg_start + mem->page_count) > num_entries)
1079 return -EINVAL;
1080
1081 j = pg_start;
1082
1083 while (j < (pg_start + mem->page_count)) {
1084 if (!PGE_EMPTY(bridge, readl(bridge->gatt_table+j)))
1085 return -EBUSY;
1086 j++;
1087 }
1088
Joe Perchesc7258012008-03-26 14:10:02 -07001089 if (!mem->is_flushed) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001090 bridge->driver->cache_flush();
Joe Perchesc7258012008-03-26 14:10:02 -07001091 mem->is_flushed = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092 }
1093
1094 for (i = 0, j = pg_start; i < mem->page_count; i++, j++) {
Thomas Hellstroma030ce42007-01-23 10:33:43 +01001095 writel(bridge->driver->mask_memory(bridge, mem->memory[i], mask_type),
1096 bridge->gatt_table+j);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097 }
Thomas Hellstrom5aa80c72006-12-20 16:33:41 +01001098 readl(bridge->gatt_table+j-1); /* PCI Posting. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099
1100 bridge->driver->tlb_flush(mem);
1101 return 0;
1102}
1103EXPORT_SYMBOL(agp_generic_insert_memory);
1104
1105
1106int agp_generic_remove_memory(struct agp_memory *mem, off_t pg_start, int type)
1107{
1108 size_t i;
1109 struct agp_bridge_data *bridge;
Thomas Hellstroma030ce42007-01-23 10:33:43 +01001110 int mask_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111
1112 bridge = mem->bridge;
1113 if (!bridge)
1114 return -EINVAL;
1115
Thomas Hellstrom5aa80c72006-12-20 16:33:41 +01001116 if (mem->page_count == 0)
1117 return 0;
1118
Thomas Hellstroma030ce42007-01-23 10:33:43 +01001119 if (type != mem->type)
1120 return -EINVAL;
1121
1122 mask_type = bridge->driver->agp_type_to_mask_type(bridge, type);
1123 if (mask_type != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124 /* The generic routines know nothing of memory types */
1125 return -EINVAL;
1126 }
1127
1128 /* AK: bogus, should encode addresses > 4GB */
1129 for (i = pg_start; i < (mem->page_count + pg_start); i++) {
1130 writel(bridge->scratch_page, bridge->gatt_table+i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001131 }
Thomas Hellstrom5aa80c72006-12-20 16:33:41 +01001132 readl(bridge->gatt_table+i-1); /* PCI Posting. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134 bridge->driver->tlb_flush(mem);
1135 return 0;
1136}
1137EXPORT_SYMBOL(agp_generic_remove_memory);
1138
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139struct agp_memory *agp_generic_alloc_by_type(size_t page_count, int type)
1140{
1141 return NULL;
1142}
1143EXPORT_SYMBOL(agp_generic_alloc_by_type);
1144
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145void agp_generic_free_by_type(struct agp_memory *curr)
1146{
Thomas Hellstroma030ce42007-01-23 10:33:43 +01001147 agp_free_page_array(curr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148 agp_free_key(curr->key);
1149 kfree(curr);
1150}
1151EXPORT_SYMBOL(agp_generic_free_by_type);
1152
Thomas Hellstroma030ce42007-01-23 10:33:43 +01001153struct agp_memory *agp_generic_alloc_user(size_t page_count, int type)
1154{
1155 struct agp_memory *new;
1156 int i;
1157 int pages;
1158
1159 pages = (page_count + ENTRIES_PER_PAGE - 1) / ENTRIES_PER_PAGE;
1160 new = agp_create_user_memory(page_count);
1161 if (new == NULL)
1162 return NULL;
1163
Andrew Morton1c14cfb2007-02-05 16:09:35 -08001164 for (i = 0; i < page_count; i++)
Thomas Hellstroma030ce42007-01-23 10:33:43 +01001165 new->memory[i] = 0;
Thomas Hellstroma030ce42007-01-23 10:33:43 +01001166 new->page_count = 0;
1167 new->type = type;
1168 new->num_scratch_pages = pages;
1169
1170 return new;
1171}
1172EXPORT_SYMBOL(agp_generic_alloc_user);
1173
Linus Torvalds1da177e2005-04-16 15:20:36 -07001174/*
1175 * Basic Page Allocation Routines -
1176 * These routines handle page allocation and by default they reserve the allocated
1177 * memory. They also handle incrementing the current_memory_agp value, Which is checked
1178 * against a maximum value.
1179 */
1180
1181void *agp_generic_alloc_page(struct agp_bridge_data *bridge)
1182{
1183 struct page * page;
1184
Linus Torvalds66c669b2006-11-22 14:55:29 -08001185 page = alloc_page(GFP_KERNEL | GFP_DMA32);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186 if (page == NULL)
1187 return NULL;
1188
1189 map_page_into_agp(page);
1190
1191 get_page(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192 atomic_inc(&agp_bridge->current_memory_agp);
1193 return page_address(page);
1194}
1195EXPORT_SYMBOL(agp_generic_alloc_page);
1196
1197
Dave Airliea2721e92007-10-15 10:19:16 +10001198void agp_generic_destroy_page(void *addr, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199{
1200 struct page *page;
1201
1202 if (addr == NULL)
1203 return;
1204
1205 page = virt_to_page(addr);
Dave Airliea2721e92007-10-15 10:19:16 +10001206 if (flags & AGP_PAGE_DESTROY_UNMAP)
1207 unmap_page_from_agp(page);
1208
1209 if (flags & AGP_PAGE_DESTROY_FREE) {
1210 put_page(page);
1211 free_page((unsigned long)addr);
1212 atomic_dec(&agp_bridge->current_memory_agp);
1213 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214}
1215EXPORT_SYMBOL(agp_generic_destroy_page);
1216
1217/* End Basic Page Allocation Routines */
1218
1219
1220/**
1221 * agp_enable - initialise the agp point-to-point connection.
1222 *
1223 * @mode: agp mode register value to configure with.
1224 */
1225void agp_enable(struct agp_bridge_data *bridge, u32 mode)
1226{
1227 if (!bridge)
1228 return;
1229 bridge->driver->agp_enable(bridge, mode);
1230}
1231EXPORT_SYMBOL(agp_enable);
1232
1233/* When we remove the global variable agp_bridge from all drivers
1234 * then agp_alloc_bridge and agp_generic_find_bridge need to be updated
1235 */
1236
1237struct agp_bridge_data *agp_generic_find_bridge(struct pci_dev *pdev)
1238{
1239 if (list_empty(&agp_bridges))
1240 return NULL;
1241
1242 return agp_bridge;
1243}
1244
1245static void ipi_handler(void *null)
1246{
1247 flush_agp_cache();
1248}
1249
1250void global_cache_flush(void)
1251{
Jens Axboe15c8b6c2008-05-09 09:39:44 +02001252 if (on_each_cpu(ipi_handler, NULL, 1) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253 panic(PFX "timed out waiting for the other CPUs!\n");
1254}
1255EXPORT_SYMBOL(global_cache_flush);
1256
1257unsigned long agp_generic_mask_memory(struct agp_bridge_data *bridge,
1258 unsigned long addr, int type)
1259{
1260 /* memory type is ignored in the generic routine */
1261 if (bridge->driver->masks)
1262 return addr | bridge->driver->masks[0].mask;
1263 else
1264 return addr;
1265}
1266EXPORT_SYMBOL(agp_generic_mask_memory);
1267
Thomas Hellstroma030ce42007-01-23 10:33:43 +01001268int agp_generic_type_to_mask_type(struct agp_bridge_data *bridge,
1269 int type)
1270{
1271 if (type >= AGP_USER_TYPES)
1272 return 0;
1273 return type;
1274}
1275EXPORT_SYMBOL(agp_generic_type_to_mask_type);
1276
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277/*
1278 * These functions are implemented according to the AGPv3 spec,
1279 * which covers implementation details that had previously been
1280 * left open.
1281 */
1282
1283int agp3_generic_fetch_size(void)
1284{
1285 u16 temp_size;
1286 int i;
1287 struct aper_size_info_16 *values;
1288
1289 pci_read_config_word(agp_bridge->dev, agp_bridge->capndx+AGPAPSIZE, &temp_size);
1290 values = A_SIZE_16(agp_bridge->driver->aperture_sizes);
1291
1292 for (i = 0; i < agp_bridge->driver->num_aperture_sizes; i++) {
1293 if (temp_size == values[i].size_value) {
1294 agp_bridge->previous_size =
1295 agp_bridge->current_size = (void *) (values + i);
1296
1297 agp_bridge->aperture_size_idx = i;
1298 return values[i].size;
1299 }
1300 }
1301 return 0;
1302}
1303EXPORT_SYMBOL(agp3_generic_fetch_size);
1304
1305void agp3_generic_tlbflush(struct agp_memory *mem)
1306{
1307 u32 ctrl;
1308 pci_read_config_dword(agp_bridge->dev, agp_bridge->capndx+AGPCTRL, &ctrl);
1309 pci_write_config_dword(agp_bridge->dev, agp_bridge->capndx+AGPCTRL, ctrl & ~AGPCTRL_GTLBEN);
1310 pci_write_config_dword(agp_bridge->dev, agp_bridge->capndx+AGPCTRL, ctrl);
1311}
1312EXPORT_SYMBOL(agp3_generic_tlbflush);
1313
1314int agp3_generic_configure(void)
1315{
1316 u32 temp;
1317 struct aper_size_info_16 *current_size;
1318
1319 current_size = A_SIZE_16(agp_bridge->current_size);
1320
1321 pci_read_config_dword(agp_bridge->dev, AGP_APBASE, &temp);
1322 agp_bridge->gart_bus_addr = (temp & PCI_BASE_ADDRESS_MEM_MASK);
1323
1324 /* set aperture size */
1325 pci_write_config_word(agp_bridge->dev, agp_bridge->capndx+AGPAPSIZE, current_size->size_value);
1326 /* set gart pointer */
1327 pci_write_config_dword(agp_bridge->dev, agp_bridge->capndx+AGPGARTLO, agp_bridge->gatt_bus_addr);
1328 /* enable aperture and GTLB */
1329 pci_read_config_dword(agp_bridge->dev, agp_bridge->capndx+AGPCTRL, &temp);
1330 pci_write_config_dword(agp_bridge->dev, agp_bridge->capndx+AGPCTRL, temp | AGPCTRL_APERENB | AGPCTRL_GTLBEN);
1331 return 0;
1332}
1333EXPORT_SYMBOL(agp3_generic_configure);
1334
1335void agp3_generic_cleanup(void)
1336{
1337 u32 ctrl;
1338 pci_read_config_dword(agp_bridge->dev, agp_bridge->capndx+AGPCTRL, &ctrl);
1339 pci_write_config_dword(agp_bridge->dev, agp_bridge->capndx+AGPCTRL, ctrl & ~AGPCTRL_APERENB);
1340}
1341EXPORT_SYMBOL(agp3_generic_cleanup);
1342
Dave Jonese5524f32007-02-22 18:41:28 -05001343const struct aper_size_info_16 agp3_generic_sizes[AGP_GENERIC_SIZES_ENTRIES] =
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344{
1345 {4096, 1048576, 10,0x000},
1346 {2048, 524288, 9, 0x800},
1347 {1024, 262144, 8, 0xc00},
1348 { 512, 131072, 7, 0xe00},
1349 { 256, 65536, 6, 0xf00},
1350 { 128, 32768, 5, 0xf20},
1351 { 64, 16384, 4, 0xf30},
1352 { 32, 8192, 3, 0xf38},
1353 { 16, 4096, 2, 0xf3c},
1354 { 8, 2048, 1, 0xf3e},
1355 { 4, 1024, 0, 0xf3f}
1356};
1357EXPORT_SYMBOL(agp3_generic_sizes);
1358