drivers/char/agp/generic.c

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