drm: merge in Linus mainline

diff --combined drivers/char/drm/drm_lock.c
index f970dc36c18f84011dfe97fba6dfadb71448e713,b48a595d54eca0e9c13b0cb269b88fba6dc49f56..f9e45303498dd66164106d7af210200b7b6c86ba
--- 1/drivers/char/drm/drm_lock.c
--- 2/drivers/char/drm/drm_lock.c
+++ b/drivers/char/drm/drm_lock.c
@@@ -104,8 -104,9 +104,9 @@@ int drm_lock(struct inode *inode, struc
        __set_current_state(TASK_RUNNING);
        remove_wait_queue(&dev->lock.lock_queue, &entry);
  
-       DRM_DEBUG( "%d %s\n", lock.context, ret ? "interrupted" : "has lock" );
-       if (ret) return ret;
+       DRM_DEBUG("%d %s\n", lock.context, ret ? "interrupted" : "has lock");
+       if (ret)
+               return ret;
  
        sigemptyset(&dev->sigmask);
        sigaddset(&dev->sigmask, SIGSTOP);
@@@ -121,17 -122,20 +122,19 @@@
  
        if (dev->driver->dma_quiescent && (lock.flags & _DRM_LOCK_QUIESCENT)) {
                if (dev->driver->dma_quiescent(dev)) {
-                       DRM_DEBUG( "%d waiting for DMA quiescent\n", lock.context);
+                       DRM_DEBUG("%d waiting for DMA quiescent\n", lock.context);
                        return DRM_ERR(EBUSY);
                }
        }
  
 -
+       /* dev->driver->kernel_context_switch isn't used by any of the x86
+        *  drivers but is used by the Sparc driver.
+        */
        if (dev->driver->kernel_context_switch &&
            dev->last_context != lock.context) {
                dev->driver->kernel_context_switch(dev, dev->last_context,
                                                   lock.context);
        }
- 
        return 0;
  }
  

diff --combined drivers/char/drm/drm_memory.c
index 7438741c29e9b1151df5cf657ef2aba0286a4d21,abef2acf99f596d67d34b29031c85cfadcd3afc3..8074771e348fd384598b259c748a67b23c99650b
--- 1/drivers/char/drm/drm_memory.c
--- 2/drivers/char/drm/drm_memory.c
+++ b/drivers/char/drm/drm_memory.c
@@@ -95,7 -95,7 +95,7 @@@ unsigned long drm_alloc_pages(int order
        unsigned long addr;
        unsigned int sz;
  
-       address = __get_free_pages(GFP_KERNEL, order);
+       address = __get_free_pages(GFP_KERNEL|__GFP_COMP, order);
        if (!address)
                return 0;
  
@@@ -145,22 -145,30 +145,22 @@@ DRM_AGP_MEM *drm_alloc_agp(drm_device_
        return drm_agp_allocate_memory(dev->agp->bridge, pages, type);
  }
  
 -EXPORT_SYMBOL(drm_alloc_agp);
 -
  /** Wrapper around agp_free_memory() */
  int drm_free_agp(DRM_AGP_MEM * handle, int pages)
  {
        return drm_agp_free_memory(handle) ? 0 : -EINVAL;
  }
  
 -EXPORT_SYMBOL(drm_free_agp);
 -
  /** Wrapper around agp_bind_memory() */
  int drm_bind_agp(DRM_AGP_MEM * handle, unsigned int start)
  {
        return drm_agp_bind_memory(handle, start);
  }
  
 -EXPORT_SYMBOL(drm_bind_agp);
 -
  /** Wrapper around agp_unbind_memory() */
  int drm_unbind_agp(DRM_AGP_MEM * handle)
  {
        return drm_agp_unbind_memory(handle);
  }
 -
 -EXPORT_SYMBOL(drm_unbind_agp);
  #endif                                /* agp */
  #endif                                /* debug_memory */

diff --combined drivers/char/drm/drm_memory_debug.h
index 706b75251ea102dc8d1e8cf5c1e87a3d1b7dd6d0,b370aca718d278602217bbbcb58fb5812218c96d..e84605fc54af09e8073cd3a99c399fc658b1cfd4
--- 1/drivers/char/drm/drm_memory_debug.h
--- 2/drivers/char/drm/drm_memory_debug.h
+++ b/drivers/char/drm/drm_memory_debug.h
@@@ -1,5 -1,5 +1,5 @@@
  /**
 - * \file drm_memory.h
 + * \file drm_memory_debug.h
   * Memory management wrappers for DRM.
   *
   * \author Rickard E. (Rik) Faith <faith@valinux.com>
@@@ -43,41 -43,42 +43,41 @@@ typedef struct drm_mem_stats 
        unsigned long bytes_freed;
  } drm_mem_stats_t;
  
 -static DEFINE_SPINLOCK(DRM(mem_lock));
 -static unsigned long DRM(ram_available) = 0;  /* In pages */
 -static unsigned long DRM(ram_used) = 0;
 -static drm_mem_stats_t DRM(mem_stats)[] =
 +static spinlock_t drm_mem_lock = SPIN_LOCK_UNLOCKED;
 +static unsigned long drm_ram_available = 0;   /* In pages */
 +static unsigned long drm_ram_used = 0;
 +static drm_mem_stats_t drm_mem_stats[] =
  {
 -      [DRM_MEM_DMA] = {
 -      "dmabufs"},[DRM_MEM_SAREA] = {
 -      "sareas"},[DRM_MEM_DRIVER] = {
 -      "driver"},[DRM_MEM_MAGIC] = {
 -      "magic"},[DRM_MEM_IOCTLS] = {
 -      "ioctltab"},[DRM_MEM_MAPS] = {
 -      "maplist"},[DRM_MEM_VMAS] = {
 -      "vmalist"},[DRM_MEM_BUFS] = {
 -      "buflist"},[DRM_MEM_SEGS] = {
 -      "seglist"},[DRM_MEM_PAGES] = {
 -      "pagelist"},[DRM_MEM_FILES] = {
 -      "files"},[DRM_MEM_QUEUES] = {
 -      "queues"},[DRM_MEM_CMDS] = {
 -      "commands"},[DRM_MEM_MAPPINGS] = {
 -      "mappings"},[DRM_MEM_BUFLISTS] = {
 -      "buflists"},[DRM_MEM_AGPLISTS] = {
 -      "agplist"},[DRM_MEM_SGLISTS] = {
 -      "sglist"},[DRM_MEM_TOTALAGP] = {
 -      "totalagp"},[DRM_MEM_BOUNDAGP] = {
 -      "boundagp"},[DRM_MEM_CTXBITMAP] = {
 -      "ctxbitmap"},[DRM_MEM_CTXLIST] = {
 -      "ctxlist"},[DRM_MEM_STUB] = {
 -      "stub"}, {
 -      NULL, 0,}               /* Last entry must be null */
 +      [DRM_MEM_DMA] = {"dmabufs"},
 +      [DRM_MEM_SAREA] = {"sareas"},
 +      [DRM_MEM_DRIVER] = {"driver"},
 +      [DRM_MEM_MAGIC] = {"magic"},
 +      [DRM_MEM_IOCTLS] = {"ioctltab"},
 +      [DRM_MEM_MAPS] = {"maplist"},
 +      [DRM_MEM_VMAS] = {"vmalist"},
 +      [DRM_MEM_BUFS] = {"buflist"},
 +      [DRM_MEM_SEGS] = {"seglist"},
 +      [DRM_MEM_PAGES] = {"pagelist"},
 +      [DRM_MEM_FILES] = {"files"},
 +      [DRM_MEM_QUEUES] = {"queues"},
 +      [DRM_MEM_CMDS] = {"commands"},
 +      [DRM_MEM_MAPPINGS] = {"mappings"},
 +      [DRM_MEM_BUFLISTS] = {"buflists"},
 +      [DRM_MEM_AGPLISTS] = {"agplist"},
 +      [DRM_MEM_SGLISTS] = {"sglist"},
 +      [DRM_MEM_TOTALAGP] = {"totalagp"},
 +      [DRM_MEM_BOUNDAGP] = {"boundagp"},
 +      [DRM_MEM_CTXBITMAP] = {"ctxbitmap"},
 +      [DRM_MEM_CTXLIST] = {"ctxlist"},
 +      [DRM_MEM_STUB] = {"stub"},
 +      {NULL, 0,}              /* Last entry must be null */
  };
  
 -void DRM(mem_init) (void) {
 +void drm_mem_init (void) {
        drm_mem_stats_t *mem;
        struct sysinfo si;
  
 -      for (mem = DRM(mem_stats); mem->name; ++mem) {
 +      for (mem = drm_mem_stats; mem->name; ++mem) {
                mem->succeed_count = 0;
                mem->free_count = 0;
                mem->fail_count = 0;
@@@ -86,13 -87,13 +86,13 @@@
        }
  
        si_meminfo(&si);
 -      DRM(ram_available) = si.totalram;
 -      DRM(ram_used) = 0;
 +      drm_ram_available = si.totalram;
 +      drm_ram_used = 0;
  }
  
  /* drm_mem_info is called whenever a process reads /dev/drm/mem. */
  
 -static int DRM(_mem_info) (char *buf, char **start, off_t offset,
 +static int drm__mem_info (char *buf, char **start, off_t offset,
                           int request, int *eof, void *data) {
        drm_mem_stats_t *pt;
        int len = 0;
@@@ -111,11 -112,11 +111,11 @@@
                       " | allocs      bytes\n\n");
        DRM_PROC_PRINT("%-9.9s %5d %5d %4d %10lu kB         |\n",
                       "system", 0, 0, 0,
 -                     DRM(ram_available) << (PAGE_SHIFT - 10));
 +                     drm_ram_available << (PAGE_SHIFT - 10));
        DRM_PROC_PRINT("%-9.9s %5d %5d %4d %10lu kB         |\n",
 -                     "locked", 0, 0, 0, DRM(ram_used) >> 10);
 +                     "locked", 0, 0, 0, drm_ram_used >> 10);
        DRM_PROC_PRINT("\n");
 -      for (pt = DRM(mem_stats); pt->name; pt++) {
 +      for (pt = drm_mem_stats; pt->name; pt++) {
                DRM_PROC_PRINT("%-9.9s %5d %5d %4d %10lu %10lu | %6d %10ld\n",
                               pt->name,
                               pt->succeed_count,
@@@ -134,17 -135,17 +134,17 @@@
        return len - offset;
  }
  
 -int DRM(mem_info) (char *buf, char **start, off_t offset,
 +int drm_mem_info (char *buf, char **start, off_t offset,
                   int len, int *eof, void *data) {
        int ret;
  
 -      spin_lock(&DRM(mem_lock));
 -      ret = DRM(_mem_info) (buf, start, offset, len, eof, data);
 -      spin_unlock(&DRM(mem_lock));
 +      spin_lock(&drm_mem_lock);
 +      ret = drm__mem_info (buf, start, offset, len, eof, data);
 +      spin_unlock(&drm_mem_lock);
        return ret;
  }
  
 -void *DRM(alloc) (size_t size, int area) {
 +void *drm_alloc (size_t size, int area) {
        void *pt;
  
        if (!size) {
@@@ -153,41 -154,41 +153,41 @@@
        }
  
        if (!(pt = kmalloc(size, GFP_KERNEL))) {
 -              spin_lock(&DRM(mem_lock));
 -              ++DRM(mem_stats)[area].fail_count;
 -              spin_unlock(&DRM(mem_lock));
 +              spin_lock(&drm_mem_lock);
 +              ++drm_mem_stats[area].fail_count;
 +              spin_unlock(&drm_mem_lock);
                return NULL;
        }
 -      spin_lock(&DRM(mem_lock));
 -      ++DRM(mem_stats)[area].succeed_count;
 -      DRM(mem_stats)[area].bytes_allocated += size;
 -      spin_unlock(&DRM(mem_lock));
 +      spin_lock(&drm_mem_lock);
 +      ++drm_mem_stats[area].succeed_count;
 +      drm_mem_stats[area].bytes_allocated += size;
 +      spin_unlock(&drm_mem_lock);
        return pt;
  }
  
 -void *DRM(calloc) (size_t nmemb, size_t size, int area) {
 +void *drm_calloc (size_t nmemb, size_t size, int area) {
        void *addr;
  
 -      addr = DRM(alloc) (nmemb * size, area);
 +      addr = drm_alloc (nmemb * size, area);
        if (addr != NULL)
                memset((void *)addr, 0, size * nmemb);
  
        return addr;
  }
  
 -void *DRM(realloc) (void *oldpt, size_t oldsize, size_t size, int area) {
 +void *drm_realloc (void *oldpt, size_t oldsize, size_t size, int area) {
        void *pt;
  
 -      if (!(pt = DRM(alloc) (size, area)))
 +      if (!(pt = drm_alloc (size, area)))
                return NULL;
        if (oldpt && oldsize) {
                memcpy(pt, oldpt, oldsize);
 -              DRM(free) (oldpt, oldsize, area);
 +              drm_free (oldpt, oldsize, area);
        }
        return pt;
  }
  
 -void DRM(free) (void *pt, size_t size, int area) {
 +void drm_free (void *pt, size_t size, int area) {
        int alloc_count;
        int free_count;
  
@@@ -195,43 -196,43 +195,43 @@@
                DRM_MEM_ERROR(area, "Attempt to free NULL pointer\n");
        else
                kfree(pt);
 -      spin_lock(&DRM(mem_lock));
 -      DRM(mem_stats)[area].bytes_freed += size;
 -      free_count = ++DRM(mem_stats)[area].free_count;
 -      alloc_count = DRM(mem_stats)[area].succeed_count;
 -      spin_unlock(&DRM(mem_lock));
 +      spin_lock(&drm_mem_lock);
 +      drm_mem_stats[area].bytes_freed += size;
 +      free_count = ++drm_mem_stats[area].free_count;
 +      alloc_count = drm_mem_stats[area].succeed_count;
 +      spin_unlock(&drm_mem_lock);
        if (free_count > alloc_count) {
                DRM_MEM_ERROR(area, "Excess frees: %d frees, %d allocs\n",
                              free_count, alloc_count);
        }
  }
  
 -unsigned long DRM(alloc_pages) (int order, int area) {
 +unsigned long drm_alloc_pages (int order, int area) {
        unsigned long address;
        unsigned long bytes = PAGE_SIZE << order;
        unsigned long addr;
        unsigned int sz;
  
 -      spin_lock(&DRM(mem_lock));
 -      if ((DRM(ram_used) >> PAGE_SHIFT)
 -          > (DRM_RAM_PERCENT * DRM(ram_available)) / 100) {
 -              spin_unlock(&DRM(mem_lock));
 +      spin_lock(&drm_mem_lock);
 +      if ((drm_ram_used >> PAGE_SHIFT)
 +          > (DRM_RAM_PERCENT * drm_ram_available) / 100) {
 +              spin_unlock(&drm_mem_lock);
                return 0;
        }
 -      spin_unlock(&DRM(mem_lock));
 +      spin_unlock(&drm_mem_lock);
  
-       address = __get_free_pages(GFP_KERNEL, order);
+       address = __get_free_pages(GFP_KERNEL|__GFP_COMP, order);
        if (!address) {
 -              spin_lock(&DRM(mem_lock));
 -              ++DRM(mem_stats)[area].fail_count;
 -              spin_unlock(&DRM(mem_lock));
 +              spin_lock(&drm_mem_lock);
 +              ++drm_mem_stats[area].fail_count;
 +              spin_unlock(&drm_mem_lock);
                return 0;
        }
 -      spin_lock(&DRM(mem_lock));
 -      ++DRM(mem_stats)[area].succeed_count;
 -      DRM(mem_stats)[area].bytes_allocated += bytes;
 -      DRM(ram_used) += bytes;
 -      spin_unlock(&DRM(mem_lock));
 +      spin_lock(&drm_mem_lock);
 +      ++drm_mem_stats[area].succeed_count;
 +      drm_mem_stats[area].bytes_allocated += bytes;
 +      drm_ram_used += bytes;
 +      spin_unlock(&drm_mem_lock);
  
        /* Zero outside the lock */
        memset((void *)address, 0, bytes);
@@@ -245,7 -246,7 +245,7 @@@
        return address;
  }
  
 -void DRM(free_pages) (unsigned long address, int order, int area) {
 +void drm_free_pages (unsigned long address, int order, int area) {
        unsigned long bytes = PAGE_SIZE << order;
        int alloc_count;
        int free_count;
@@@ -263,12 -264,12 +263,12 @@@
                free_pages(address, order);
        }
  
 -      spin_lock(&DRM(mem_lock));
 -      free_count = ++DRM(mem_stats)[area].free_count;
 -      alloc_count = DRM(mem_stats)[area].succeed_count;
 -      DRM(mem_stats)[area].bytes_freed += bytes;
 -      DRM(ram_used) -= bytes;
 -      spin_unlock(&DRM(mem_lock));
 +      spin_lock(&drm_mem_lock);
 +      free_count = ++drm_mem_stats[area].free_count;
 +      alloc_count = drm_mem_stats[area].succeed_count;
 +      drm_mem_stats[area].bytes_freed += bytes;
 +      drm_ram_used -= bytes;
 +      spin_unlock(&drm_mem_lock);
        if (free_count > alloc_count) {
                DRM_MEM_ERROR(area,
                              "Excess frees: %d frees, %d allocs\n",
@@@ -276,7 -277,7 +276,7 @@@
        }
  }
  
 -void *DRM(ioremap) (unsigned long offset, unsigned long size,
 +void *drm_ioremap (unsigned long offset, unsigned long size,
                    drm_device_t * dev) {
        void *pt;
  
@@@ -287,19 -288,19 +287,19 @@@
        }
  
        if (!(pt = drm_ioremap(offset, size, dev))) {
 -              spin_lock(&DRM(mem_lock));
 -              ++DRM(mem_stats)[DRM_MEM_MAPPINGS].fail_count;
 -              spin_unlock(&DRM(mem_lock));
 +              spin_lock(&drm_mem_lock);
 +              ++drm_mem_stats[DRM_MEM_MAPPINGS].fail_count;
 +              spin_unlock(&drm_mem_lock);
                return NULL;
        }
 -      spin_lock(&DRM(mem_lock));
 -      ++DRM(mem_stats)[DRM_MEM_MAPPINGS].succeed_count;
 -      DRM(mem_stats)[DRM_MEM_MAPPINGS].bytes_allocated += size;
 -      spin_unlock(&DRM(mem_lock));
 +      spin_lock(&drm_mem_lock);
 +      ++drm_mem_stats[DRM_MEM_MAPPINGS].succeed_count;
 +      drm_mem_stats[DRM_MEM_MAPPINGS].bytes_allocated += size;
 +      spin_unlock(&drm_mem_lock);
        return pt;
  }
  
 -void *DRM(ioremap_nocache) (unsigned long offset, unsigned long size,
 +void *drm_ioremap_nocache (unsigned long offset, unsigned long size,
                            drm_device_t * dev) {
        void *pt;
  
@@@ -310,19 -311,19 +310,19 @@@
        }
  
        if (!(pt = drm_ioremap_nocache(offset, size, dev))) {
 -              spin_lock(&DRM(mem_lock));
 -              ++DRM(mem_stats)[DRM_MEM_MAPPINGS].fail_count;
 -              spin_unlock(&DRM(mem_lock));
 +              spin_lock(&drm_mem_lock);
 +              ++drm_mem_stats[DRM_MEM_MAPPINGS].fail_count;
 +              spin_unlock(&drm_mem_lock);
                return NULL;
        }
 -      spin_lock(&DRM(mem_lock));
 -      ++DRM(mem_stats)[DRM_MEM_MAPPINGS].succeed_count;
 -      DRM(mem_stats)[DRM_MEM_MAPPINGS].bytes_allocated += size;
 -      spin_unlock(&DRM(mem_lock));
 +      spin_lock(&drm_mem_lock);
 +      ++drm_mem_stats[DRM_MEM_MAPPINGS].succeed_count;
 +      drm_mem_stats[DRM_MEM_MAPPINGS].bytes_allocated += size;
 +      spin_unlock(&drm_mem_lock);
        return pt;
  }
  
 -void DRM(ioremapfree) (void *pt, unsigned long size, drm_device_t * dev) {
 +void drm_ioremapfree (void *pt, unsigned long size, drm_device_t * dev) {
        int alloc_count;
        int free_count;
  
@@@ -332,11 -333,11 +332,11 @@@
        else
                drm_ioremapfree(pt, size, dev);
  
 -      spin_lock(&DRM(mem_lock));
 -      DRM(mem_stats)[DRM_MEM_MAPPINGS].bytes_freed += size;
 -      free_count = ++DRM(mem_stats)[DRM_MEM_MAPPINGS].free_count;
 -      alloc_count = DRM(mem_stats)[DRM_MEM_MAPPINGS].succeed_count;
 -      spin_unlock(&DRM(mem_lock));
 +      spin_lock(&drm_mem_lock);
 +      drm_mem_stats[DRM_MEM_MAPPINGS].bytes_freed += size;
 +      free_count = ++drm_mem_stats[DRM_MEM_MAPPINGS].free_count;
 +      alloc_count = drm_mem_stats[DRM_MEM_MAPPINGS].succeed_count;
 +      spin_unlock(&drm_mem_lock);
        if (free_count > alloc_count) {
                DRM_MEM_ERROR(DRM_MEM_MAPPINGS,
                              "Excess frees: %d frees, %d allocs\n",
@@@ -346,7 -347,7 +346,7 @@@
  
  #if __OS_HAS_AGP
  
 -DRM_AGP_MEM *DRM(alloc_agp) (int pages, u32 type) {
 +DRM_AGP_MEM *drm_alloc_agp (drm_device_t *dev, int pages, u32 type) {
        DRM_AGP_MEM *handle;
  
        if (!pages) {
@@@ -354,21 -355,21 +354,21 @@@
                return NULL;
        }
  
 -      if ((handle = DRM(agp_allocate_memory) (pages, type))) {
 -              spin_lock(&DRM(mem_lock));
 -              ++DRM(mem_stats)[DRM_MEM_TOTALAGP].succeed_count;
 -              DRM(mem_stats)[DRM_MEM_TOTALAGP].bytes_allocated
 +      if ((handle = drm_agp_allocate_memory (pages, type))) {
 +              spin_lock(&drm_mem_lock);
 +              ++drm_mem_stats[DRM_MEM_TOTALAGP].succeed_count;
 +              drm_mem_stats[DRM_MEM_TOTALAGP].bytes_allocated
                    += pages << PAGE_SHIFT;
 -              spin_unlock(&DRM(mem_lock));
 +              spin_unlock(&drm_mem_lock);
                return handle;
        }
 -      spin_lock(&DRM(mem_lock));
 -      ++DRM(mem_stats)[DRM_MEM_TOTALAGP].fail_count;
 -      spin_unlock(&DRM(mem_lock));
 +      spin_lock(&drm_mem_lock);
 +      ++drm_mem_stats[DRM_MEM_TOTALAGP].fail_count;
 +      spin_unlock(&drm_mem_lock);
        return NULL;
  }
  
 -int DRM(free_agp) (DRM_AGP_MEM * handle, int pages) {
 +int drm_free_agp (DRM_AGP_MEM * handle, int pages) {
        int alloc_count;
        int free_count;
        int retval = -EINVAL;
@@@ -379,13 -380,13 +379,13 @@@
                return retval;
        }
  
 -      if (DRM(agp_free_memory) (handle)) {
 -              spin_lock(&DRM(mem_lock));
 -              free_count = ++DRM(mem_stats)[DRM_MEM_TOTALAGP].free_count;
 -              alloc_count = DRM(mem_stats)[DRM_MEM_TOTALAGP].succeed_count;
 -              DRM(mem_stats)[DRM_MEM_TOTALAGP].bytes_freed
 +      if (drm_agp_free_memory (handle)) {
 +              spin_lock(&drm_mem_lock);
 +              free_count = ++drm_mem_stats[DRM_MEM_TOTALAGP].free_count;
 +              alloc_count = drm_mem_stats[DRM_MEM_TOTALAGP].succeed_count;
 +              drm_mem_stats[DRM_MEM_TOTALAGP].bytes_freed
                    += pages << PAGE_SHIFT;
 -              spin_unlock(&DRM(mem_lock));
 +              spin_unlock(&drm_mem_lock);
                if (free_count > alloc_count) {
                        DRM_MEM_ERROR(DRM_MEM_TOTALAGP,
                                      "Excess frees: %d frees, %d allocs\n",
@@@ -396,7 -397,7 +396,7 @@@
        return retval;
  }
  
 -int DRM(bind_agp) (DRM_AGP_MEM * handle, unsigned int start) {
 +int drm_bind_agp (DRM_AGP_MEM * handle, unsigned int start) {
        int retcode = -EINVAL;
  
        if (!handle) {
@@@ -405,21 -406,21 +405,21 @@@
                return retcode;
        }
  
 -      if (!(retcode = DRM(agp_bind_memory) (handle, start))) {
 -              spin_lock(&DRM(mem_lock));
 -              ++DRM(mem_stats)[DRM_MEM_BOUNDAGP].succeed_count;
 -              DRM(mem_stats)[DRM_MEM_BOUNDAGP].bytes_allocated
 +      if (!(retcode = drm_agp_bind_memory (handle, start))) {
 +              spin_lock(&drm_mem_lock);
 +              ++drm_mem_stats[DRM_MEM_BOUNDAGP].succeed_count;
 +              drm_mem_stats[DRM_MEM_BOUNDAGP].bytes_allocated
                    += handle->page_count << PAGE_SHIFT;
 -              spin_unlock(&DRM(mem_lock));
 +              spin_unlock(&drm_mem_lock);
                return retcode;
        }
 -      spin_lock(&DRM(mem_lock));
 -      ++DRM(mem_stats)[DRM_MEM_BOUNDAGP].fail_count;
 -      spin_unlock(&DRM(mem_lock));
 +      spin_lock(&drm_mem_lock);
 +      ++drm_mem_stats[DRM_MEM_BOUNDAGP].fail_count;
 +      spin_unlock(&drm_mem_lock);
        return retcode;
  }
  
 -int DRM(unbind_agp) (DRM_AGP_MEM * handle) {
 +int drm_unbind_agp (DRM_AGP_MEM * handle) {
        int alloc_count;
        int free_count;
        int retcode = -EINVAL;
@@@ -430,14 -431,14 +430,14 @@@
                return retcode;
        }
  
 -      if ((retcode = DRM(agp_unbind_memory) (handle)))
 +      if ((retcode = drm_agp_unbind_memory (handle)))
                return retcode;
 -      spin_lock(&DRM(mem_lock));
 -      free_count = ++DRM(mem_stats)[DRM_MEM_BOUNDAGP].free_count;
 -      alloc_count = DRM(mem_stats)[DRM_MEM_BOUNDAGP].succeed_count;
 -      DRM(mem_stats)[DRM_MEM_BOUNDAGP].bytes_freed
 +      spin_lock(&drm_mem_lock);
 +      free_count = ++drm_mem_stats[DRM_MEM_BOUNDAGP].free_count;
 +      alloc_count = drm_mem_stats[DRM_MEM_BOUNDAGP].succeed_count;
 +      drm_mem_stats[DRM_MEM_BOUNDAGP].bytes_freed
            += handle->page_count << PAGE_SHIFT;
 -      spin_unlock(&DRM(mem_lock));
 +      spin_unlock(&drm_mem_lock);
        if (free_count > alloc_count) {
                DRM_MEM_ERROR(DRM_MEM_BOUNDAGP,
                              "Excess frees: %d frees, %d allocs\n",

diff --combined drivers/char/drm/mga_drv.c
index 93f171e634c06c123f29e9ad1b2b55c4700b23a3,1713451a5cc658ba0ca1c8ef291076010c78c7d6..9f7ed0e0351b0c39cab6751c97df2b5694b5a872
--- 1/drivers/char/drm/mga_drv.c
--- 2/drivers/char/drm/mga_drv.c
+++ b/drivers/char/drm/mga_drv.c
@@@ -38,6 -38,41 +38,6 @@@
  #include "drm_pciids.h"
  
  static int mga_driver_device_is_agp(drm_device_t * dev);
 -static int postinit(struct drm_device *dev, unsigned long flags)
 -{
 -      drm_mga_private_t *const dev_priv =
 -          (drm_mga_private_t *) dev->dev_private;
 -
 -      dev_priv->mmio_base = pci_resource_start(dev->pdev, 1);
 -      dev_priv->mmio_size = pci_resource_len(dev->pdev, 1);
 -
 -      dev->counters += 3;
 -      dev->types[6] = _DRM_STAT_IRQ;
 -      dev->types[7] = _DRM_STAT_PRIMARY;
 -      dev->types[8] = _DRM_STAT_SECONDARY;
 -
 -      DRM_INFO("Initialized %s %d.%d.%d %s on minor %d: %s\n",
 -               DRIVER_NAME,
 -               DRIVER_MAJOR,
 -               DRIVER_MINOR,
 -               DRIVER_PATCHLEVEL,
 -               DRIVER_DATE, dev->primary.minor, pci_pretty_name(dev->pdev)
 -          );
 -      return 0;
 -}
 -
 -static int version(drm_version_t * version)
 -{
 -      int len;
 -
 -      version->version_major = DRIVER_MAJOR;
 -      version->version_minor = DRIVER_MINOR;
 -      version->version_patchlevel = DRIVER_PATCHLEVEL;
 -      DRM_COPY(version->name, DRIVER_NAME);
 -      DRM_COPY(version->date, DRIVER_DATE);
 -      DRM_COPY(version->desc, DRIVER_DESC);
 -      return 0;
 -}
  
  static struct pci_device_id pciidlist[] = {
        mga_PCI_IDS
@@@ -45,12 -80,12 +45,12 @@@
  
  static struct drm_driver driver = {
        .driver_features =
 -          DRIVER_USE_AGP | DRIVER_REQUIRE_AGP | DRIVER_USE_MTRR |
 +          DRIVER_USE_AGP | DRIVER_USE_MTRR | DRIVER_PCI_DMA |
            DRIVER_HAVE_DMA | DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED |
            DRIVER_IRQ_VBL,
 -      .preinit = mga_driver_preinit,
 -      .postcleanup = mga_driver_postcleanup,
 -      .pretakedown = mga_driver_pretakedown,
 +      .load = mga_driver_load,
 +      .unload = mga_driver_unload,
 +      .lastclose = mga_driver_lastclose,
        .dma_quiescent = mga_driver_dma_quiescent,
        .device_is_agp = mga_driver_device_is_agp,
        .vblank_wait = mga_driver_vblank_wait,
@@@ -61,6 -96,8 +61,6 @@@
        .reclaim_buffers = drm_core_reclaim_buffers,
        .get_map_ofs = drm_core_get_map_ofs,
        .get_reg_ofs = drm_core_get_reg_ofs,
 -      .postinit = postinit,
 -      .version = version,
        .ioctls = mga_ioctls,
        .dma_ioctl = mga_dma_buffers,
        .fops = {
@@@ -76,16 -113,9 +76,16 @@@
  #endif
                 },
        .pci_driver = {
 -                     .name = DRIVER_NAME,
 -                     .id_table = pciidlist,
 -                     }
 +               .name = DRIVER_NAME,
 +               .id_table = pciidlist,
 +      },
 +
 +      .name = DRIVER_NAME,
 +      .desc = DRIVER_DESC,
 +      .date = DRIVER_DATE,
 +      .major = DRIVER_MAJOR,
 +      .minor = DRIVER_MINOR,
 +      .patchlevel = DRIVER_PATCHLEVEL,
  };
  
  static int __init mga_init(void)
@@@ -131,7 -161,7 +131,7 @@@ static int mga_driver_device_is_agp(drm
         * device.
         */
  
-       if ((pdev->device == 0x0525)
+       if ((pdev->device == 0x0525) && pdev->bus->self
            && (pdev->bus->self->vendor == 0x3388)
            && (pdev->bus->self->device == 0x0021)) {
                return 0;

diff --combined drivers/char/drm/radeon_drv.h
index 498b19b1d641aeae0ac6ca52228c38f2925f10fa,d92ccee3e54c64b29c9bbc7fcc4b1973386d3644..fac0d5196ce380aec173a48cd015b8b6969ef446
--- 1/drivers/char/drm/radeon_drv.h
--- 2/drivers/char/drm/radeon_drv.h
+++ b/drivers/char/drm/radeon_drv.h
@@@ -38,7 -38,7 +38,7 @@@
  
  #define DRIVER_NAME           "radeon"
  #define DRIVER_DESC           "ATI Radeon"
 -#define DRIVER_DATE           "20050911"
 +#define DRIVER_DATE           "20051229"
  
  /* Interface history:
   *
@@@ -73,7 -73,7 +73,7 @@@
   * 1.11- Add packet R200_EMIT_RB3D_BLENDCOLOR to support GL_EXT_blend_color
   *       and GL_EXT_blend_[func|equation]_separate on r200
   * 1.12- Add R300 CP microcode support - this just loads the CP on r300
 - *       (No 3D support yet - just microcode loading)
 + *       (No 3D support yet - just microcode loading).
   * 1.13- Add packet R200_EMIT_TCL_POINT_SPRITE_CNTL for ARB_point_parameters
   *     - Add hyperz support, add hyperz flags to clear ioctl.
   * 1.14- Add support for color tiling
@@@ -88,13 -88,14 +88,13 @@@
   *       R200_EMIT_PP_TXFILTER_0-5, 2 more regs) and R200_EMIT_ATF_TFACTOR
   *       (replaces R200_EMIT_TFACTOR_0 (8 consts instead of 6)
   * 1.19- Add support for gart table in FB memory and PCIE r300
 + * 1.20- Add support for r300 texrect
 + * 1.21- Add support for card type getparam
   */
  #define DRIVER_MAJOR          1
 -#define DRIVER_MINOR          19
 +#define DRIVER_MINOR          21
  #define DRIVER_PATCHLEVEL     0
  
 -#define GET_RING_HEAD(dev_priv)               DRM_READ32(  (dev_priv)->ring_rptr, 0 )
 -#define SET_RING_HEAD(dev_priv,val)   DRM_WRITE32( (dev_priv)->ring_rptr, 0, (val) )
 -
  /*
   * Radeon chip families
   */
@@@ -102,8 -103,8 +102,8 @@@ enum radeon_family 
        CHIP_R100,
        CHIP_RS100,
        CHIP_RV100,
 -      CHIP_R200,
        CHIP_RV200,
 +      CHIP_R200,
        CHIP_RS200,
        CHIP_R250,
        CHIP_RS250,
@@@ -137,9 -138,6 +137,9 @@@ enum radeon_chip_flags 
        CHIP_IS_PCIE = 0x00200000UL,
  };
  
 +#define GET_RING_HEAD(dev_priv)               DRM_READ32(  (dev_priv)->ring_rptr, 0 )
 +#define SET_RING_HEAD(dev_priv,val)   DRM_WRITE32( (dev_priv)->ring_rptr, 0, (val) )
 +
  typedef struct drm_radeon_freelist {
        unsigned int age;
        drm_buf_t *buf;
@@@ -247,6 -245,8 +247,6 @@@ typedef struct drm_radeon_private 
  
        drm_radeon_depth_clear_t depth_clear;
  
 -      unsigned long fb_offset;
 -      unsigned long mmio_offset;
        unsigned long ring_offset;
        unsigned long ring_rptr_offset;
        unsigned long buffers_offset;
@@@ -273,6 -273,7 +273,7 @@@
  
        /* starting from here on, data is preserved accross an open */
        uint32_t flags;         /* see radeon_chip_flags */
+       int is_pci;
  } drm_radeon_private_t;
  
  typedef struct drm_radeon_buf_priv {
@@@ -329,14 -330,17 +330,14 @@@ extern irqreturn_t radeon_driver_irq_ha
  extern void radeon_driver_irq_preinstall(drm_device_t * dev);
  extern void radeon_driver_irq_postinstall(drm_device_t * dev);
  extern void radeon_driver_irq_uninstall(drm_device_t * dev);
 -extern void radeon_driver_prerelease(drm_device_t * dev, DRMFILE filp);
 -extern void radeon_driver_pretakedown(drm_device_t * dev);
 -extern int radeon_driver_open_helper(drm_device_t * dev,
 -                                   drm_file_t * filp_priv);
 -extern void radeon_driver_free_filp_priv(drm_device_t * dev,
 -                                       drm_file_t * filp_priv);
 -
 -extern int radeon_preinit(struct drm_device *dev, unsigned long flags);
 -extern int radeon_postinit(struct drm_device *dev, unsigned long flags);
 -extern int radeon_postcleanup(struct drm_device *dev);
  
 +extern int radeon_driver_load(struct drm_device *dev, unsigned long flags);
 +extern int radeon_driver_unload(struct drm_device *dev);
 +extern int radeon_driver_firstopen(struct drm_device *dev);
 +extern void radeon_driver_preclose(drm_device_t * dev, DRMFILE filp);
 +extern void radeon_driver_postclose(drm_device_t * dev, drm_file_t * filp);
 +extern void radeon_driver_lastclose(drm_device_t * dev);
 +extern int radeon_driver_open(drm_device_t * dev, drm_file_t * filp_priv);
  extern long radeon_compat_ioctl(struct file *filp, unsigned int cmd,
                                unsigned long arg);
  
@@@ -360,8 -364,6 +361,8 @@@ extern int r300_do_cp_cmdbuf(drm_device
   */
  
  #define RADEON_AGP_COMMAND            0x0f60
 +#define RADEON_AGP_COMMAND_PCI_CONFIG   0x0060        /* offset in PCI config */
 +#     define RADEON_AGP_ENABLE        (1<<8)
  #define RADEON_AUX_SCISSOR_CNTL               0x26f0
  #     define RADEON_EXCLUSIVE_SCISSOR_0       (1 << 24)
  #     define RADEON_EXCLUSIVE_SCISSOR_1       (1 << 25)
@@@ -649,8 -651,6 +650,8 @@@
  
  #define RADEON_WAIT_UNTIL             0x1720
  #     define RADEON_WAIT_CRTC_PFLIP           (1 << 0)
 +#     define RADEON_WAIT_2D_IDLE              (1 << 14)
 +#     define RADEON_WAIT_3D_IDLE              (1 << 15)
  #     define RADEON_WAIT_2D_IDLECLEAN         (1 << 16)
  #     define RADEON_WAIT_3D_IDLECLEAN         (1 << 17)
  #     define RADEON_WAIT_HOST_IDLECLEAN       (1 << 18)
@@@ -1105,6 -1105,7 +1106,6 @@@ do {                                                                    
                write = 0;                                      \
                _tab += _i;                                     \
        }                                                       \
 -                                                              \
        while (_size > 0) {                                     \
                *(ring + write) = *_tab++;                      \
                write++;                                        \