blob: 13a5577ee434a631de2f50a9f032720e1b2fdbfd [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
Shaohua Li37acee12008-08-21 10:46:11 +0800267 if (bridge->driver->agp_alloc_pages) {
268 if (bridge->driver->agp_alloc_pages(bridge, new, page_count)) {
269 agp_free_memory(new);
270 return NULL;
271 }
272 new->bridge = bridge;
273 return new;
274 }
275
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 for (i = 0; i < page_count; i++) {
277 void *addr = bridge->driver->agp_alloc_page(bridge);
278
279 if (addr == NULL) {
280 agp_free_memory(new);
281 return NULL;
282 }
Keir Fraser07eee782005-03-30 13:17:04 -0800283 new->memory[i] = virt_to_gart(addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 new->page_count++;
285 }
Alan Hourihane88d51962005-11-06 23:35:34 -0800286 new->bridge = bridge;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 return new;
289}
290EXPORT_SYMBOL(agp_allocate_memory);
291
292
293/* End - Generic routines for handling agp_memory structures */
294
295
296static int agp_return_size(void)
297{
298 int current_size;
299 void *temp;
300
301 temp = agp_bridge->current_size;
302
303 switch (agp_bridge->driver->size_type) {
304 case U8_APER_SIZE:
305 current_size = A_SIZE_8(temp)->size;
306 break;
307 case U16_APER_SIZE:
308 current_size = A_SIZE_16(temp)->size;
309 break;
310 case U32_APER_SIZE:
311 current_size = A_SIZE_32(temp)->size;
312 break;
313 case LVL2_APER_SIZE:
314 current_size = A_SIZE_LVL2(temp)->size;
315 break;
316 case FIXED_APER_SIZE:
317 current_size = A_SIZE_FIX(temp)->size;
318 break;
319 default:
320 current_size = 0;
321 break;
322 }
323
324 current_size -= (agp_memory_reserved / (1024*1024));
325 if (current_size <0)
326 current_size = 0;
327 return current_size;
328}
329
330
331int agp_num_entries(void)
332{
333 int num_entries;
334 void *temp;
335
336 temp = agp_bridge->current_size;
337
338 switch (agp_bridge->driver->size_type) {
339 case U8_APER_SIZE:
340 num_entries = A_SIZE_8(temp)->num_entries;
341 break;
342 case U16_APER_SIZE:
343 num_entries = A_SIZE_16(temp)->num_entries;
344 break;
345 case U32_APER_SIZE:
346 num_entries = A_SIZE_32(temp)->num_entries;
347 break;
348 case LVL2_APER_SIZE:
349 num_entries = A_SIZE_LVL2(temp)->num_entries;
350 break;
351 case FIXED_APER_SIZE:
352 num_entries = A_SIZE_FIX(temp)->num_entries;
353 break;
354 default:
355 num_entries = 0;
356 break;
357 }
358
359 num_entries -= agp_memory_reserved>>PAGE_SHIFT;
360 if (num_entries<0)
361 num_entries = 0;
362 return num_entries;
363}
364EXPORT_SYMBOL_GPL(agp_num_entries);
365
366
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367/**
368 * agp_copy_info - copy bridge state information
369 *
Dave Jones6a92a4e2006-02-28 00:54:25 -0500370 * @info: agp_kern_info pointer. The caller should insure that this pointer is valid.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 *
372 * This function copies information about the agp bridge device and the state of
373 * the agp backend into an agp_kern_info pointer.
374 */
375int agp_copy_info(struct agp_bridge_data *bridge, struct agp_kern_info *info)
376{
377 memset(info, 0, sizeof(struct agp_kern_info));
378 if (!bridge) {
379 info->chipset = NOT_SUPPORTED;
380 return -EIO;
381 }
382
383 info->version.major = bridge->version->major;
384 info->version.minor = bridge->version->minor;
385 info->chipset = SUPPORTED;
386 info->device = bridge->dev;
David Mosberger66bb8bf2005-04-04 13:29:43 -0700387 if (bridge->mode & AGPSTAT_MODE_3_0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 info->mode = bridge->mode & ~AGP3_RESERVED_MASK;
389 else
390 info->mode = bridge->mode & ~AGP2_RESERVED_MASK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 info->aper_base = bridge->gart_bus_addr;
392 info->aper_size = agp_return_size();
393 info->max_memory = bridge->max_memory_agp;
394 info->current_memory = atomic_read(&bridge->current_memory_agp);
395 info->cant_use_aperture = bridge->driver->cant_use_aperture;
396 info->vm_ops = bridge->vm_ops;
397 info->page_mask = ~0UL;
398 return 0;
399}
400EXPORT_SYMBOL(agp_copy_info);
401
402/* End - Routine to copy over information structure */
403
404/*
405 * Routines for handling swapping of agp_memory into the GATT -
406 * These routines take agp_memory and insert them into the GATT.
407 * They call device specific routines to actually write to the GATT.
408 */
409
410/**
411 * agp_bind_memory - Bind an agp_memory structure into the GATT.
412 *
413 * @curr: agp_memory pointer
414 * @pg_start: an offset into the graphics aperture translation table
415 *
416 * It returns -EINVAL if the pointer == NULL.
417 * It returns -EBUSY if the area of the table requested is already in use.
418 */
419int agp_bind_memory(struct agp_memory *curr, off_t pg_start)
420{
421 int ret_val;
422
423 if (curr == NULL)
424 return -EINVAL;
425
Joe Perchesc7258012008-03-26 14:10:02 -0700426 if (curr->is_bound) {
Dave Jones8c8b8382005-08-17 23:08:11 -0700427 printk(KERN_INFO PFX "memory %p is already bound!\n", curr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 return -EINVAL;
429 }
Joe Perchesc7258012008-03-26 14:10:02 -0700430 if (!curr->is_flushed) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 curr->bridge->driver->cache_flush();
Joe Perchesc7258012008-03-26 14:10:02 -0700432 curr->is_flushed = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 }
434 ret_val = curr->bridge->driver->insert_memory(curr, pg_start, curr->type);
435
436 if (ret_val != 0)
437 return ret_val;
438
Joe Perchesc7258012008-03-26 14:10:02 -0700439 curr->is_bound = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 curr->pg_start = pg_start;
441 return 0;
442}
443EXPORT_SYMBOL(agp_bind_memory);
444
445
446/**
447 * agp_unbind_memory - Removes an agp_memory structure from the GATT
448 *
449 * @curr: agp_memory pointer to be removed from the GATT.
450 *
451 * It returns -EINVAL if this piece of agp_memory is not currently bound to
452 * the graphics aperture translation table or if the agp_memory pointer == NULL
453 */
454int agp_unbind_memory(struct agp_memory *curr)
455{
456 int ret_val;
457
458 if (curr == NULL)
459 return -EINVAL;
460
Joe Perchesc7258012008-03-26 14:10:02 -0700461 if (!curr->is_bound) {
Dave Jones8c8b8382005-08-17 23:08:11 -0700462 printk(KERN_INFO PFX "memory %p was not bound!\n", curr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 return -EINVAL;
464 }
465
466 ret_val = curr->bridge->driver->remove_memory(curr, curr->pg_start, curr->type);
467
468 if (ret_val != 0)
469 return ret_val;
470
Joe Perchesc7258012008-03-26 14:10:02 -0700471 curr->is_bound = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 curr->pg_start = 0;
473 return 0;
474}
475EXPORT_SYMBOL(agp_unbind_memory);
476
477/* End - Routines for handling swapping of agp_memory into the GATT */
478
479
480/* Generic Agp routines - Start */
481static void agp_v2_parse_one(u32 *requested_mode, u32 *bridge_agpstat, u32 *vga_agpstat)
482{
483 u32 tmp;
484
485 if (*requested_mode & AGP2_RESERVED_MASK) {
Dave Jonesc4dd4582005-11-04 15:18:56 -0800486 printk(KERN_INFO PFX "reserved bits set (%x) in mode 0x%x. Fixed.\n",
487 *requested_mode & AGP2_RESERVED_MASK, *requested_mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 *requested_mode &= ~AGP2_RESERVED_MASK;
489 }
490
Dave Jones28af24b2006-11-03 15:13:27 -0500491 /*
492 * Some dumb bridges are programmed to disobey the AGP2 spec.
493 * This is likely a BIOS misprogramming rather than poweron default, or
494 * it would be a lot more common.
495 * https://bugs.freedesktop.org/show_bug.cgi?id=8816
496 * AGPv2 spec 6.1.9 states:
497 * The RATE field indicates the data transfer rates supported by this
498 * device. A.G.P. devices must report all that apply.
499 * Fix them up as best we can.
500 */
501 switch (*bridge_agpstat & 7) {
502 case 4:
503 *bridge_agpstat |= (AGPSTAT2_2X | AGPSTAT2_1X);
504 printk(KERN_INFO PFX "BIOS bug. AGP bridge claims to only support x4 rate"
505 "Fixing up support for x2 & x1\n");
506 break;
507 case 2:
508 *bridge_agpstat |= AGPSTAT2_1X;
509 printk(KERN_INFO PFX "BIOS bug. AGP bridge claims to only support x2 rate"
510 "Fixing up support for x1\n");
511 break;
512 default:
513 break;
514 }
515
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 /* Check the speed bits make sense. Only one should be set. */
517 tmp = *requested_mode & 7;
518 switch (tmp) {
519 case 0:
Dave Jones8c8b8382005-08-17 23:08:11 -0700520 printk(KERN_INFO PFX "%s tried to set rate=x0. Setting to x1 mode.\n", current->comm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 *requested_mode |= AGPSTAT2_1X;
522 break;
523 case 1:
524 case 2:
525 break;
526 case 3:
527 *requested_mode &= ~(AGPSTAT2_1X); /* rate=2 */
528 break;
529 case 4:
530 break;
531 case 5:
532 case 6:
533 case 7:
534 *requested_mode &= ~(AGPSTAT2_1X|AGPSTAT2_2X); /* rate=4*/
535 break;
536 }
537
538 /* disable SBA if it's not supported */
539 if (!((*bridge_agpstat & AGPSTAT_SBA) && (*vga_agpstat & AGPSTAT_SBA) && (*requested_mode & AGPSTAT_SBA)))
540 *bridge_agpstat &= ~AGPSTAT_SBA;
541
542 /* Set rate */
543 if (!((*bridge_agpstat & AGPSTAT2_4X) && (*vga_agpstat & AGPSTAT2_4X) && (*requested_mode & AGPSTAT2_4X)))
544 *bridge_agpstat &= ~AGPSTAT2_4X;
545
546 if (!((*bridge_agpstat & AGPSTAT2_2X) && (*vga_agpstat & AGPSTAT2_2X) && (*requested_mode & AGPSTAT2_2X)))
547 *bridge_agpstat &= ~AGPSTAT2_2X;
548
549 if (!((*bridge_agpstat & AGPSTAT2_1X) && (*vga_agpstat & AGPSTAT2_1X) && (*requested_mode & AGPSTAT2_1X)))
550 *bridge_agpstat &= ~AGPSTAT2_1X;
551
552 /* Now we know what mode it should be, clear out the unwanted bits. */
553 if (*bridge_agpstat & AGPSTAT2_4X)
554 *bridge_agpstat &= ~(AGPSTAT2_1X | AGPSTAT2_2X); /* 4X */
555
556 if (*bridge_agpstat & AGPSTAT2_2X)
557 *bridge_agpstat &= ~(AGPSTAT2_1X | AGPSTAT2_4X); /* 2X */
558
559 if (*bridge_agpstat & AGPSTAT2_1X)
560 *bridge_agpstat &= ~(AGPSTAT2_2X | AGPSTAT2_4X); /* 1X */
561
562 /* Apply any errata. */
563 if (agp_bridge->flags & AGP_ERRATA_FASTWRITES)
564 *bridge_agpstat &= ~AGPSTAT_FW;
565
566 if (agp_bridge->flags & AGP_ERRATA_SBA)
567 *bridge_agpstat &= ~AGPSTAT_SBA;
568
569 if (agp_bridge->flags & AGP_ERRATA_1X) {
570 *bridge_agpstat &= ~(AGPSTAT2_2X | AGPSTAT2_4X);
571 *bridge_agpstat |= AGPSTAT2_1X;
572 }
573
574 /* If we've dropped down to 1X, disable fast writes. */
575 if (*bridge_agpstat & AGPSTAT2_1X)
576 *bridge_agpstat &= ~AGPSTAT_FW;
577}
578
579/*
580 * requested_mode = Mode requested by (typically) X.
581 * bridge_agpstat = PCI_AGP_STATUS from agp bridge.
582 * vga_agpstat = PCI_AGP_STATUS from graphic card.
583 */
584static void agp_v3_parse_one(u32 *requested_mode, u32 *bridge_agpstat, u32 *vga_agpstat)
585{
586 u32 origbridge=*bridge_agpstat, origvga=*vga_agpstat;
587 u32 tmp;
588
589 if (*requested_mode & AGP3_RESERVED_MASK) {
Dave Jonesc4dd4582005-11-04 15:18:56 -0800590 printk(KERN_INFO PFX "reserved bits set (%x) in mode 0x%x. Fixed.\n",
591 *requested_mode & AGP3_RESERVED_MASK, *requested_mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 *requested_mode &= ~AGP3_RESERVED_MASK;
593 }
594
595 /* Check the speed bits make sense. */
596 tmp = *requested_mode & 7;
597 if (tmp == 0) {
Dave Jones8c8b8382005-08-17 23:08:11 -0700598 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 -0700599 *requested_mode |= AGPSTAT3_4X;
600 }
601 if (tmp >= 3) {
Dave Jones8c8b8382005-08-17 23:08:11 -0700602 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 -0700603 *requested_mode = (*requested_mode & ~7) | AGPSTAT3_8X;
604 }
605
606 /* ARQSZ - Set the value to the maximum one.
607 * Don't allow the mode register to override values. */
608 *bridge_agpstat = ((*bridge_agpstat & ~AGPSTAT_ARQSZ) |
609 max_t(u32,(*bridge_agpstat & AGPSTAT_ARQSZ),(*vga_agpstat & AGPSTAT_ARQSZ)));
610
611 /* Calibration cycle.
612 * Don't allow the mode register to override values. */
613 *bridge_agpstat = ((*bridge_agpstat & ~AGPSTAT_CAL_MASK) |
614 min_t(u32,(*bridge_agpstat & AGPSTAT_CAL_MASK),(*vga_agpstat & AGPSTAT_CAL_MASK)));
615
616 /* SBA *must* be supported for AGP v3 */
617 *bridge_agpstat |= AGPSTAT_SBA;
618
619 /*
620 * Set speed.
621 * Check for invalid speeds. This can happen when applications
622 * written before the AGP 3.0 standard pass AGP2.x modes to AGP3 hardware
623 */
624 if (*requested_mode & AGPSTAT_MODE_3_0) {
625 /*
626 * Caller hasn't a clue what it is doing. Bridge is in 3.0 mode,
627 * have been passed a 3.0 mode, but with 2.x speed bits set.
628 * AGP2.x 4x -> AGP3.0 4x.
629 */
630 if (*requested_mode & AGPSTAT2_4X) {
Dave Jones8c8b8382005-08-17 23:08:11 -0700631 printk(KERN_INFO PFX "%s passes broken AGP3 flags (%x). Fixed.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 current->comm, *requested_mode);
633 *requested_mode &= ~AGPSTAT2_4X;
634 *requested_mode |= AGPSTAT3_4X;
635 }
636 } else {
637 /*
638 * The caller doesn't know what they are doing. We are in 3.0 mode,
639 * but have been passed an AGP 2.x mode.
640 * Convert AGP 1x,2x,4x -> AGP 3.0 4x.
641 */
Dave Jones8c8b8382005-08-17 23:08:11 -0700642 printk(KERN_INFO PFX "%s passes broken AGP2 flags (%x) in AGP3 mode. Fixed.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 current->comm, *requested_mode);
644 *requested_mode &= ~(AGPSTAT2_4X | AGPSTAT2_2X | AGPSTAT2_1X);
645 *requested_mode |= AGPSTAT3_4X;
646 }
647
648 if (*requested_mode & AGPSTAT3_8X) {
649 if (!(*bridge_agpstat & AGPSTAT3_8X)) {
650 *bridge_agpstat &= ~(AGPSTAT3_8X | AGPSTAT3_RSVD);
651 *bridge_agpstat |= AGPSTAT3_4X;
Dave Jones8c8b8382005-08-17 23:08:11 -0700652 printk(KERN_INFO PFX "%s requested AGPx8 but bridge not capable.\n", current->comm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 return;
654 }
655 if (!(*vga_agpstat & AGPSTAT3_8X)) {
656 *bridge_agpstat &= ~(AGPSTAT3_8X | AGPSTAT3_RSVD);
657 *bridge_agpstat |= AGPSTAT3_4X;
Dave Jones8c8b8382005-08-17 23:08:11 -0700658 printk(KERN_INFO PFX "%s requested AGPx8 but graphic card not capable.\n", current->comm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659 return;
660 }
661 /* All set, bridge & device can do AGP x8*/
662 *bridge_agpstat &= ~(AGPSTAT3_4X | AGPSTAT3_RSVD);
663 goto done;
664
Dave Jonesedf03fb2006-09-10 21:12:20 -0400665 } else if (*requested_mode & AGPSTAT3_4X) {
666 *bridge_agpstat &= ~(AGPSTAT3_8X | AGPSTAT3_RSVD);
667 *bridge_agpstat |= AGPSTAT3_4X;
668 goto done;
669
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670 } else {
671
672 /*
Dave Jonesedf03fb2006-09-10 21:12:20 -0400673 * If we didn't specify an AGP mode, we see if both
674 * the graphics card, and the bridge can do x8, and use if so.
675 * If not, we fall back to x4 mode.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 */
Dave Jonesedf03fb2006-09-10 21:12:20 -0400677 if ((*bridge_agpstat & AGPSTAT3_8X) && (*vga_agpstat & AGPSTAT3_8X)) {
Dave Jones2cc1a412006-09-28 19:50:07 -0400678 printk(KERN_INFO PFX "No AGP mode specified. Setting to highest mode "
679 "supported by bridge & card (x8).\n");
Dave Jonesedf03fb2006-09-10 21:12:20 -0400680 *bridge_agpstat &= ~(AGPSTAT3_4X | AGPSTAT3_RSVD);
681 *vga_agpstat &= ~(AGPSTAT3_4X | AGPSTAT3_RSVD);
682 } else {
683 printk(KERN_INFO PFX "Fell back to AGPx4 mode because");
684 if (!(*bridge_agpstat & AGPSTAT3_8X)) {
Dave Jones2cc1a412006-09-28 19:50:07 -0400685 printk(KERN_INFO PFX "bridge couldn't do x8. bridge_agpstat:%x (orig=%x)\n",
686 *bridge_agpstat, origbridge);
Dave Jonesedf03fb2006-09-10 21:12:20 -0400687 *bridge_agpstat &= ~(AGPSTAT3_8X | AGPSTAT3_RSVD);
688 *bridge_agpstat |= AGPSTAT3_4X;
689 }
690 if (!(*vga_agpstat & AGPSTAT3_8X)) {
Dave Jones2cc1a412006-09-28 19:50:07 -0400691 printk(KERN_INFO PFX "graphics card couldn't do x8. vga_agpstat:%x (orig=%x)\n",
692 *vga_agpstat, origvga);
Dave Jonesedf03fb2006-09-10 21:12:20 -0400693 *vga_agpstat &= ~(AGPSTAT3_8X | AGPSTAT3_RSVD);
694 *vga_agpstat |= AGPSTAT3_4X;
695 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696 }
697 }
698
699done:
700 /* Apply any errata. */
701 if (agp_bridge->flags & AGP_ERRATA_FASTWRITES)
702 *bridge_agpstat &= ~AGPSTAT_FW;
703
704 if (agp_bridge->flags & AGP_ERRATA_SBA)
705 *bridge_agpstat &= ~AGPSTAT_SBA;
706
707 if (agp_bridge->flags & AGP_ERRATA_1X) {
708 *bridge_agpstat &= ~(AGPSTAT2_2X | AGPSTAT2_4X);
709 *bridge_agpstat |= AGPSTAT2_1X;
710 }
711}
712
713
714/**
715 * agp_collect_device_status - determine correct agp_cmd from various agp_stat's
716 * @bridge: an agp_bridge_data struct allocated for the AGP host bridge.
717 * @requested_mode: requested agp_stat from userspace (Typically from X)
718 * @bridge_agpstat: current agp_stat from AGP bridge.
719 *
720 * This function will hunt for an AGP graphics card, and try to match
721 * the requested mode to the capabilities of both the bridge and the card.
722 */
723u32 agp_collect_device_status(struct agp_bridge_data *bridge, u32 requested_mode, u32 bridge_agpstat)
724{
725 struct pci_dev *device = NULL;
726 u32 vga_agpstat;
727 u8 cap_ptr;
728
729 for (;;) {
730 device = pci_get_class(PCI_CLASS_DISPLAY_VGA << 8, device);
731 if (!device) {
Dave Jones8c8b8382005-08-17 23:08:11 -0700732 printk(KERN_INFO PFX "Couldn't find an AGP VGA controller.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 return 0;
734 }
735 cap_ptr = pci_find_capability(device, PCI_CAP_ID_AGP);
736 if (cap_ptr)
737 break;
738 }
739
740 /*
741 * Ok, here we have a AGP device. Disable impossible
742 * settings, and adjust the readqueue to the minimum.
743 */
744 pci_read_config_dword(device, cap_ptr+PCI_AGP_STATUS, &vga_agpstat);
745
746 /* adjust RQ depth */
747 bridge_agpstat = ((bridge_agpstat & ~AGPSTAT_RQ_DEPTH) |
748 min_t(u32, (requested_mode & AGPSTAT_RQ_DEPTH),
749 min_t(u32, (bridge_agpstat & AGPSTAT_RQ_DEPTH), (vga_agpstat & AGPSTAT_RQ_DEPTH))));
750
751 /* disable FW if it's not supported */
752 if (!((bridge_agpstat & AGPSTAT_FW) &&
753 (vga_agpstat & AGPSTAT_FW) &&
754 (requested_mode & AGPSTAT_FW)))
755 bridge_agpstat &= ~AGPSTAT_FW;
756
757 /* Check to see if we are operating in 3.0 mode */
David Mosberger66bb8bf2005-04-04 13:29:43 -0700758 if (agp_bridge->mode & AGPSTAT_MODE_3_0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 agp_v3_parse_one(&requested_mode, &bridge_agpstat, &vga_agpstat);
760 else
761 agp_v2_parse_one(&requested_mode, &bridge_agpstat, &vga_agpstat);
762
763 pci_dev_put(device);
764 return bridge_agpstat;
765}
766EXPORT_SYMBOL(agp_collect_device_status);
767
768
Joe Perchesc7258012008-03-26 14:10:02 -0700769void agp_device_command(u32 bridge_agpstat, bool agp_v3)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770{
771 struct pci_dev *device = NULL;
772 int mode;
773
774 mode = bridge_agpstat & 0x7;
775 if (agp_v3)
776 mode *= 4;
777
778 for_each_pci_dev(device) {
779 u8 agp = pci_find_capability(device, PCI_CAP_ID_AGP);
780 if (!agp)
781 continue;
782
783 printk(KERN_INFO PFX "Putting AGP V%d device at %s into %dx mode\n",
784 agp_v3 ? 3 : 2, pci_name(device), mode);
785 pci_write_config_dword(device, agp + PCI_AGP_COMMAND, bridge_agpstat);
786 }
787}
788EXPORT_SYMBOL(agp_device_command);
789
790
791void get_agp_version(struct agp_bridge_data *bridge)
792{
793 u32 ncapid;
794
795 /* Exit early if already set by errata workarounds. */
796 if (bridge->major_version != 0)
797 return;
798
799 pci_read_config_dword(bridge->dev, bridge->capndx, &ncapid);
800 bridge->major_version = (ncapid >> AGP_MAJOR_VERSION_SHIFT) & 0xf;
801 bridge->minor_version = (ncapid >> AGP_MINOR_VERSION_SHIFT) & 0xf;
802}
803EXPORT_SYMBOL(get_agp_version);
804
805
806void agp_generic_enable(struct agp_bridge_data *bridge, u32 requested_mode)
807{
808 u32 bridge_agpstat, temp;
809
810 get_agp_version(agp_bridge);
811
812 printk(KERN_INFO PFX "Found an AGP %d.%d compliant device at %s.\n",
813 agp_bridge->major_version,
814 agp_bridge->minor_version,
815 pci_name(agp_bridge->dev));
816
817 pci_read_config_dword(agp_bridge->dev,
818 agp_bridge->capndx + PCI_AGP_STATUS, &bridge_agpstat);
819
820 bridge_agpstat = agp_collect_device_status(agp_bridge, requested_mode, bridge_agpstat);
821 if (bridge_agpstat == 0)
822 /* Something bad happened. FIXME: Return error code? */
823 return;
824
825 bridge_agpstat |= AGPSTAT_AGP_ENABLE;
826
827 /* Do AGP version specific frobbing. */
828 if (bridge->major_version >= 3) {
David Mosberger66bb8bf2005-04-04 13:29:43 -0700829 if (bridge->mode & AGPSTAT_MODE_3_0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 /* If we have 3.5, we can do the isoch stuff. */
831 if (bridge->minor_version >= 5)
832 agp_3_5_enable(bridge);
Joe Perchesc7258012008-03-26 14:10:02 -0700833 agp_device_command(bridge_agpstat, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 return;
835 } else {
836 /* Disable calibration cycle in RX91<1> when not in AGP3.0 mode of operation.*/
837 bridge_agpstat &= ~(7<<10) ;
838 pci_read_config_dword(bridge->dev,
839 bridge->capndx+AGPCTRL, &temp);
840 temp |= (1<<9);
841 pci_write_config_dword(bridge->dev,
842 bridge->capndx+AGPCTRL, temp);
843
Dave Jones8c8b8382005-08-17 23:08:11 -0700844 printk(KERN_INFO PFX "Device is in legacy mode,"
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845 " falling back to 2.x\n");
846 }
847 }
848
849 /* AGP v<3 */
Joe Perchesc7258012008-03-26 14:10:02 -0700850 agp_device_command(bridge_agpstat, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851}
852EXPORT_SYMBOL(agp_generic_enable);
853
854
855int agp_generic_create_gatt_table(struct agp_bridge_data *bridge)
856{
857 char *table;
858 char *table_end;
859 int size;
860 int page_order;
861 int num_entries;
862 int i;
863 void *temp;
864 struct page *page;
865
866 /* The generic routines can't handle 2 level gatt's */
867 if (bridge->driver->size_type == LVL2_APER_SIZE)
868 return -EINVAL;
869
870 table = NULL;
871 i = bridge->aperture_size_idx;
872 temp = bridge->current_size;
873 size = page_order = num_entries = 0;
874
875 if (bridge->driver->size_type != FIXED_APER_SIZE) {
876 do {
877 switch (bridge->driver->size_type) {
878 case U8_APER_SIZE:
879 size = A_SIZE_8(temp)->size;
880 page_order =
881 A_SIZE_8(temp)->page_order;
882 num_entries =
883 A_SIZE_8(temp)->num_entries;
884 break;
885 case U16_APER_SIZE:
886 size = A_SIZE_16(temp)->size;
887 page_order = A_SIZE_16(temp)->page_order;
888 num_entries = A_SIZE_16(temp)->num_entries;
889 break;
890 case U32_APER_SIZE:
891 size = A_SIZE_32(temp)->size;
892 page_order = A_SIZE_32(temp)->page_order;
893 num_entries = A_SIZE_32(temp)->num_entries;
894 break;
895 /* This case will never really happen. */
896 case FIXED_APER_SIZE:
897 case LVL2_APER_SIZE:
898 default:
899 size = page_order = num_entries = 0;
900 break;
901 }
902
Keir Fraser07eee782005-03-30 13:17:04 -0800903 table = alloc_gatt_pages(page_order);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904
905 if (table == NULL) {
906 i++;
907 switch (bridge->driver->size_type) {
908 case U8_APER_SIZE:
909 bridge->current_size = A_IDX8(bridge);
910 break;
911 case U16_APER_SIZE:
912 bridge->current_size = A_IDX16(bridge);
913 break;
914 case U32_APER_SIZE:
915 bridge->current_size = A_IDX32(bridge);
916 break;
Dave Jones89197e32006-05-30 18:19:39 -0400917 /* These cases will never really happen. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918 case FIXED_APER_SIZE:
919 case LVL2_APER_SIZE:
920 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921 break;
922 }
923 temp = bridge->current_size;
924 } else {
925 bridge->aperture_size_idx = i;
926 }
927 } while (!table && (i < bridge->driver->num_aperture_sizes));
928 } else {
929 size = ((struct aper_size_info_fixed *) temp)->size;
930 page_order = ((struct aper_size_info_fixed *) temp)->page_order;
931 num_entries = ((struct aper_size_info_fixed *) temp)->num_entries;
Keir Fraser07eee782005-03-30 13:17:04 -0800932 table = alloc_gatt_pages(page_order);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933 }
934
935 if (table == NULL)
936 return -ENOMEM;
937
938 table_end = table + ((PAGE_SIZE * (1 << page_order)) - 1);
939
940 for (page = virt_to_page(table); page <= virt_to_page(table_end); page++)
941 SetPageReserved(page);
942
943 bridge->gatt_table_real = (u32 *) table;
944 agp_gatt_table = (void *)table;
945
946 bridge->driver->cache_flush();
Arjan van dev Venfcea4242008-02-06 05:16:00 +0100947#ifdef CONFIG_X86
948 set_memory_uc((unsigned long)table, 1 << page_order);
949 bridge->gatt_table = (void *)table;
950#else
Keir Fraser07eee782005-03-30 13:17:04 -0800951 bridge->gatt_table = ioremap_nocache(virt_to_gart(table),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952 (PAGE_SIZE * (1 << page_order)));
953 bridge->driver->cache_flush();
Arjan van dev Venfcea4242008-02-06 05:16:00 +0100954#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955
956 if (bridge->gatt_table == NULL) {
957 for (page = virt_to_page(table); page <= virt_to_page(table_end); page++)
958 ClearPageReserved(page);
959
Keir Fraser07eee782005-03-30 13:17:04 -0800960 free_gatt_pages(table, page_order);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961
962 return -ENOMEM;
963 }
Keir Fraser07eee782005-03-30 13:17:04 -0800964 bridge->gatt_bus_addr = virt_to_gart(bridge->gatt_table_real);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965
966 /* AK: bogus, should encode addresses > 4GB */
967 for (i = 0; i < num_entries; i++) {
968 writel(bridge->scratch_page, bridge->gatt_table+i);
969 readl(bridge->gatt_table+i); /* PCI Posting. */
970 }
971
972 return 0;
973}
974EXPORT_SYMBOL(agp_generic_create_gatt_table);
975
976int agp_generic_free_gatt_table(struct agp_bridge_data *bridge)
977{
978 int page_order;
979 char *table, *table_end;
980 void *temp;
981 struct page *page;
982
983 temp = bridge->current_size;
984
985 switch (bridge->driver->size_type) {
986 case U8_APER_SIZE:
987 page_order = A_SIZE_8(temp)->page_order;
988 break;
989 case U16_APER_SIZE:
990 page_order = A_SIZE_16(temp)->page_order;
991 break;
992 case U32_APER_SIZE:
993 page_order = A_SIZE_32(temp)->page_order;
994 break;
995 case FIXED_APER_SIZE:
996 page_order = A_SIZE_FIX(temp)->page_order;
997 break;
998 case LVL2_APER_SIZE:
999 /* The generic routines can't deal with 2 level gatt's */
1000 return -EINVAL;
1001 break;
1002 default:
1003 page_order = 0;
1004 break;
1005 }
1006
1007 /* Do not worry about freeing memory, because if this is
1008 * called, then all agp memory is deallocated and removed
1009 * from the table. */
1010
Arjan van dev Venfcea4242008-02-06 05:16:00 +01001011#ifdef CONFIG_X86
1012 set_memory_wb((unsigned long)bridge->gatt_table, 1 << page_order);
1013#else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014 iounmap(bridge->gatt_table);
Arjan van dev Venfcea4242008-02-06 05:16:00 +01001015#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016 table = (char *) bridge->gatt_table_real;
1017 table_end = table + ((PAGE_SIZE * (1 << page_order)) - 1);
1018
1019 for (page = virt_to_page(table); page <= virt_to_page(table_end); page++)
1020 ClearPageReserved(page);
1021
Keir Fraser07eee782005-03-30 13:17:04 -08001022 free_gatt_pages(bridge->gatt_table_real, page_order);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023
1024 agp_gatt_table = NULL;
1025 bridge->gatt_table = NULL;
1026 bridge->gatt_table_real = NULL;
1027 bridge->gatt_bus_addr = 0;
1028
1029 return 0;
1030}
1031EXPORT_SYMBOL(agp_generic_free_gatt_table);
1032
1033
1034int agp_generic_insert_memory(struct agp_memory * mem, off_t pg_start, int type)
1035{
1036 int num_entries;
1037 size_t i;
1038 off_t j;
1039 void *temp;
1040 struct agp_bridge_data *bridge;
Thomas Hellstroma030ce42007-01-23 10:33:43 +01001041 int mask_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042
1043 bridge = mem->bridge;
1044 if (!bridge)
1045 return -EINVAL;
1046
Thomas Hellstrom5aa80c72006-12-20 16:33:41 +01001047 if (mem->page_count == 0)
1048 return 0;
1049
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050 temp = bridge->current_size;
1051
1052 switch (bridge->driver->size_type) {
1053 case U8_APER_SIZE:
1054 num_entries = A_SIZE_8(temp)->num_entries;
1055 break;
1056 case U16_APER_SIZE:
1057 num_entries = A_SIZE_16(temp)->num_entries;
1058 break;
1059 case U32_APER_SIZE:
1060 num_entries = A_SIZE_32(temp)->num_entries;
1061 break;
1062 case FIXED_APER_SIZE:
1063 num_entries = A_SIZE_FIX(temp)->num_entries;
1064 break;
1065 case LVL2_APER_SIZE:
1066 /* The generic routines can't deal with 2 level gatt's */
1067 return -EINVAL;
1068 break;
1069 default:
1070 num_entries = 0;
1071 break;
1072 }
1073
1074 num_entries -= agp_memory_reserved/PAGE_SIZE;
1075 if (num_entries < 0) num_entries = 0;
1076
Andrew Morton1c14cfb2007-02-05 16:09:35 -08001077 if (type != mem->type)
Thomas Hellstroma030ce42007-01-23 10:33:43 +01001078 return -EINVAL;
Thomas Hellstroma030ce42007-01-23 10:33:43 +01001079
1080 mask_type = bridge->driver->agp_type_to_mask_type(bridge, type);
1081 if (mask_type != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082 /* The generic routines know nothing of memory types */
1083 return -EINVAL;
1084 }
1085
1086 /* AK: could wrap */
1087 if ((pg_start + mem->page_count) > num_entries)
1088 return -EINVAL;
1089
1090 j = pg_start;
1091
1092 while (j < (pg_start + mem->page_count)) {
1093 if (!PGE_EMPTY(bridge, readl(bridge->gatt_table+j)))
1094 return -EBUSY;
1095 j++;
1096 }
1097
Joe Perchesc7258012008-03-26 14:10:02 -07001098 if (!mem->is_flushed) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099 bridge->driver->cache_flush();
Joe Perchesc7258012008-03-26 14:10:02 -07001100 mem->is_flushed = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101 }
1102
1103 for (i = 0, j = pg_start; i < mem->page_count; i++, j++) {
Thomas Hellstroma030ce42007-01-23 10:33:43 +01001104 writel(bridge->driver->mask_memory(bridge, mem->memory[i], mask_type),
1105 bridge->gatt_table+j);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106 }
Thomas Hellstrom5aa80c72006-12-20 16:33:41 +01001107 readl(bridge->gatt_table+j-1); /* PCI Posting. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108
1109 bridge->driver->tlb_flush(mem);
1110 return 0;
1111}
1112EXPORT_SYMBOL(agp_generic_insert_memory);
1113
1114
1115int agp_generic_remove_memory(struct agp_memory *mem, off_t pg_start, int type)
1116{
1117 size_t i;
1118 struct agp_bridge_data *bridge;
Thomas Hellstroma030ce42007-01-23 10:33:43 +01001119 int mask_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120
1121 bridge = mem->bridge;
1122 if (!bridge)
1123 return -EINVAL;
1124
Thomas Hellstrom5aa80c72006-12-20 16:33:41 +01001125 if (mem->page_count == 0)
1126 return 0;
1127
Thomas Hellstroma030ce42007-01-23 10:33:43 +01001128 if (type != mem->type)
1129 return -EINVAL;
1130
1131 mask_type = bridge->driver->agp_type_to_mask_type(bridge, type);
1132 if (mask_type != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133 /* The generic routines know nothing of memory types */
1134 return -EINVAL;
1135 }
1136
1137 /* AK: bogus, should encode addresses > 4GB */
1138 for (i = pg_start; i < (mem->page_count + pg_start); i++) {
1139 writel(bridge->scratch_page, bridge->gatt_table+i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140 }
Thomas Hellstrom5aa80c72006-12-20 16:33:41 +01001141 readl(bridge->gatt_table+i-1); /* PCI Posting. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143 bridge->driver->tlb_flush(mem);
1144 return 0;
1145}
1146EXPORT_SYMBOL(agp_generic_remove_memory);
1147
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148struct agp_memory *agp_generic_alloc_by_type(size_t page_count, int type)
1149{
1150 return NULL;
1151}
1152EXPORT_SYMBOL(agp_generic_alloc_by_type);
1153
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154void agp_generic_free_by_type(struct agp_memory *curr)
1155{
Thomas Hellstroma030ce42007-01-23 10:33:43 +01001156 agp_free_page_array(curr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157 agp_free_key(curr->key);
1158 kfree(curr);
1159}
1160EXPORT_SYMBOL(agp_generic_free_by_type);
1161
Thomas Hellstroma030ce42007-01-23 10:33:43 +01001162struct agp_memory *agp_generic_alloc_user(size_t page_count, int type)
1163{
1164 struct agp_memory *new;
1165 int i;
1166 int pages;
1167
1168 pages = (page_count + ENTRIES_PER_PAGE - 1) / ENTRIES_PER_PAGE;
1169 new = agp_create_user_memory(page_count);
1170 if (new == NULL)
1171 return NULL;
1172
Andrew Morton1c14cfb2007-02-05 16:09:35 -08001173 for (i = 0; i < page_count; i++)
Thomas Hellstroma030ce42007-01-23 10:33:43 +01001174 new->memory[i] = 0;
Thomas Hellstroma030ce42007-01-23 10:33:43 +01001175 new->page_count = 0;
1176 new->type = type;
1177 new->num_scratch_pages = pages;
1178
1179 return new;
1180}
1181EXPORT_SYMBOL(agp_generic_alloc_user);
1182
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183/*
1184 * Basic Page Allocation Routines -
1185 * These routines handle page allocation and by default they reserve the allocated
1186 * memory. They also handle incrementing the current_memory_agp value, Which is checked
1187 * against a maximum value.
1188 */
1189
Shaohua Li37acee12008-08-21 10:46:11 +08001190int agp_generic_alloc_pages(struct agp_bridge_data *bridge, struct agp_memory *mem, size_t num_pages)
1191{
1192 struct page * page;
1193 int i, ret = -ENOMEM;
1194
1195 for (i = 0; i < num_pages; i++) {
1196 page = alloc_page(GFP_KERNEL | GFP_DMA32);
1197 /* agp_free_memory() needs gart address */
1198 if (page == NULL)
1199 goto out;
1200
1201#ifndef CONFIG_X86
1202 map_page_into_agp(page);
1203#endif
1204 get_page(page);
1205 atomic_inc(&agp_bridge->current_memory_agp);
1206
1207 /* set_memory_array_uc() needs virtual address */
1208 mem->memory[i] = (unsigned long)page_address(page);
1209 mem->page_count++;
1210 }
1211
1212#ifdef CONFIG_X86
1213 set_memory_array_uc(mem->memory, num_pages);
1214#endif
1215 ret = 0;
1216out:
1217 for (i = 0; i < mem->page_count; i++)
1218 mem->memory[i] = virt_to_gart((void *)mem->memory[i]);
1219 return ret;
1220}
1221EXPORT_SYMBOL(agp_generic_alloc_pages);
1222
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223void *agp_generic_alloc_page(struct agp_bridge_data *bridge)
1224{
1225 struct page * page;
1226
Linus Torvalds66c669b2006-11-22 14:55:29 -08001227 page = alloc_page(GFP_KERNEL | GFP_DMA32);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228 if (page == NULL)
1229 return NULL;
1230
Ingo Molnar9326d612008-08-21 13:46:25 +02001231 map_page_into_agp(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232
1233 get_page(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001234 atomic_inc(&agp_bridge->current_memory_agp);
1235 return page_address(page);
1236}
1237EXPORT_SYMBOL(agp_generic_alloc_page);
1238
1239
Dave Airliea2721e92007-10-15 10:19:16 +10001240void agp_generic_destroy_page(void *addr, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241{
1242 struct page *page;
1243
1244 if (addr == NULL)
1245 return;
1246
1247 page = virt_to_page(addr);
Dave Airliea2721e92007-10-15 10:19:16 +10001248 if (flags & AGP_PAGE_DESTROY_UNMAP)
1249 unmap_page_from_agp(page);
1250
1251 if (flags & AGP_PAGE_DESTROY_FREE) {
1252 put_page(page);
1253 free_page((unsigned long)addr);
1254 atomic_dec(&agp_bridge->current_memory_agp);
1255 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256}
1257EXPORT_SYMBOL(agp_generic_destroy_page);
1258
1259/* End Basic Page Allocation Routines */
1260
1261
1262/**
1263 * agp_enable - initialise the agp point-to-point connection.
1264 *
1265 * @mode: agp mode register value to configure with.
1266 */
1267void agp_enable(struct agp_bridge_data *bridge, u32 mode)
1268{
1269 if (!bridge)
1270 return;
1271 bridge->driver->agp_enable(bridge, mode);
1272}
1273EXPORT_SYMBOL(agp_enable);
1274
1275/* When we remove the global variable agp_bridge from all drivers
1276 * then agp_alloc_bridge and agp_generic_find_bridge need to be updated
1277 */
1278
1279struct agp_bridge_data *agp_generic_find_bridge(struct pci_dev *pdev)
1280{
1281 if (list_empty(&agp_bridges))
1282 return NULL;
1283
1284 return agp_bridge;
1285}
1286
1287static void ipi_handler(void *null)
1288{
1289 flush_agp_cache();
1290}
1291
1292void global_cache_flush(void)
1293{
Jens Axboe15c8b6c2008-05-09 09:39:44 +02001294 if (on_each_cpu(ipi_handler, NULL, 1) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295 panic(PFX "timed out waiting for the other CPUs!\n");
1296}
1297EXPORT_SYMBOL(global_cache_flush);
1298
1299unsigned long agp_generic_mask_memory(struct agp_bridge_data *bridge,
1300 unsigned long addr, int type)
1301{
1302 /* memory type is ignored in the generic routine */
1303 if (bridge->driver->masks)
1304 return addr | bridge->driver->masks[0].mask;
1305 else
1306 return addr;
1307}
1308EXPORT_SYMBOL(agp_generic_mask_memory);
1309
Thomas Hellstroma030ce42007-01-23 10:33:43 +01001310int agp_generic_type_to_mask_type(struct agp_bridge_data *bridge,
1311 int type)
1312{
1313 if (type >= AGP_USER_TYPES)
1314 return 0;
1315 return type;
1316}
1317EXPORT_SYMBOL(agp_generic_type_to_mask_type);
1318
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319/*
1320 * These functions are implemented according to the AGPv3 spec,
1321 * which covers implementation details that had previously been
1322 * left open.
1323 */
1324
1325int agp3_generic_fetch_size(void)
1326{
1327 u16 temp_size;
1328 int i;
1329 struct aper_size_info_16 *values;
1330
1331 pci_read_config_word(agp_bridge->dev, agp_bridge->capndx+AGPAPSIZE, &temp_size);
1332 values = A_SIZE_16(agp_bridge->driver->aperture_sizes);
1333
1334 for (i = 0; i < agp_bridge->driver->num_aperture_sizes; i++) {
1335 if (temp_size == values[i].size_value) {
1336 agp_bridge->previous_size =
1337 agp_bridge->current_size = (void *) (values + i);
1338
1339 agp_bridge->aperture_size_idx = i;
1340 return values[i].size;
1341 }
1342 }
1343 return 0;
1344}
1345EXPORT_SYMBOL(agp3_generic_fetch_size);
1346
1347void agp3_generic_tlbflush(struct agp_memory *mem)
1348{
1349 u32 ctrl;
1350 pci_read_config_dword(agp_bridge->dev, agp_bridge->capndx+AGPCTRL, &ctrl);
1351 pci_write_config_dword(agp_bridge->dev, agp_bridge->capndx+AGPCTRL, ctrl & ~AGPCTRL_GTLBEN);
1352 pci_write_config_dword(agp_bridge->dev, agp_bridge->capndx+AGPCTRL, ctrl);
1353}
1354EXPORT_SYMBOL(agp3_generic_tlbflush);
1355
1356int agp3_generic_configure(void)
1357{
1358 u32 temp;
1359 struct aper_size_info_16 *current_size;
1360
1361 current_size = A_SIZE_16(agp_bridge->current_size);
1362
1363 pci_read_config_dword(agp_bridge->dev, AGP_APBASE, &temp);
1364 agp_bridge->gart_bus_addr = (temp & PCI_BASE_ADDRESS_MEM_MASK);
1365
1366 /* set aperture size */
1367 pci_write_config_word(agp_bridge->dev, agp_bridge->capndx+AGPAPSIZE, current_size->size_value);
1368 /* set gart pointer */
1369 pci_write_config_dword(agp_bridge->dev, agp_bridge->capndx+AGPGARTLO, agp_bridge->gatt_bus_addr);
1370 /* enable aperture and GTLB */
1371 pci_read_config_dword(agp_bridge->dev, agp_bridge->capndx+AGPCTRL, &temp);
1372 pci_write_config_dword(agp_bridge->dev, agp_bridge->capndx+AGPCTRL, temp | AGPCTRL_APERENB | AGPCTRL_GTLBEN);
1373 return 0;
1374}
1375EXPORT_SYMBOL(agp3_generic_configure);
1376
1377void agp3_generic_cleanup(void)
1378{
1379 u32 ctrl;
1380 pci_read_config_dword(agp_bridge->dev, agp_bridge->capndx+AGPCTRL, &ctrl);
1381 pci_write_config_dword(agp_bridge->dev, agp_bridge->capndx+AGPCTRL, ctrl & ~AGPCTRL_APERENB);
1382}
1383EXPORT_SYMBOL(agp3_generic_cleanup);
1384
Dave Jonese5524f32007-02-22 18:41:28 -05001385const struct aper_size_info_16 agp3_generic_sizes[AGP_GENERIC_SIZES_ENTRIES] =
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386{
1387 {4096, 1048576, 10,0x000},
1388 {2048, 524288, 9, 0x800},
1389 {1024, 262144, 8, 0xc00},
1390 { 512, 131072, 7, 0xe00},
1391 { 256, 65536, 6, 0xf00},
1392 { 128, 32768, 5, 0xf20},
1393 { 64, 16384, 4, 0xf30},
1394 { 32, 8192, 3, 0xf38},
1395 { 16, 4096, 2, 0xf3c},
1396 { 8, 2048, 1, 0xf3e},
1397 { 4, 1024, 0, 0xf3f}
1398};
1399EXPORT_SYMBOL(agp3_generic_sizes);
1400