drm: Remove memory debugging infrastructure.
Eric Anholt [Tue, 24 Mar 2009 19:23:04 +0000 (12:23 -0700)]
It hasn't been used in ages, and having the user tell your how much
memory is being freed at free time is a recipe for disaster even if it
was ever used.

Signed-off-by: Eric Anholt <eric@anholt.net>

41 files changed:
drivers/gpu/drm/drm_agpsupport.c
drivers/gpu/drm/drm_auth.c
drivers/gpu/drm/drm_bufs.c
drivers/gpu/drm/drm_context.c
drivers/gpu/drm/drm_debugfs.c
drivers/gpu/drm/drm_dma.c
drivers/gpu/drm/drm_drawable.c
drivers/gpu/drm/drm_drv.c
drivers/gpu/drm/drm_fops.c
drivers/gpu/drm/drm_gem.c
drivers/gpu/drm/drm_hashtab.c
drivers/gpu/drm/drm_ioctl.c
drivers/gpu/drm/drm_irq.c
drivers/gpu/drm/drm_memory.c
drivers/gpu/drm/drm_pci.c
drivers/gpu/drm/drm_proc.c
drivers/gpu/drm/drm_scatter.c
drivers/gpu/drm/drm_sman.c
drivers/gpu/drm/drm_stub.c
drivers/gpu/drm/drm_vm.c
drivers/gpu/drm/i810/i810_dma.c
drivers/gpu/drm/i830/i830_dma.c
drivers/gpu/drm/i915/i915_dma.c
drivers/gpu/drm/i915/i915_gem.c
drivers/gpu/drm/i915/i915_mem.c
drivers/gpu/drm/i915/intel_bios.c
drivers/gpu/drm/i915/intel_tv.c
drivers/gpu/drm/mga/mga_dma.c
drivers/gpu/drm/r128/r128_cce.c
drivers/gpu/drm/r128/r128_state.c
drivers/gpu/drm/radeon/radeon_cp.c
drivers/gpu/drm/radeon/radeon_i2c.c
drivers/gpu/drm/radeon/radeon_kms.c
drivers/gpu/drm/radeon/radeon_mem.c
drivers/gpu/drm/radeon/radeon_state.c
drivers/gpu/drm/savage/savage_bci.c
drivers/gpu/drm/savage/savage_state.c
drivers/gpu/drm/sis/sis_drv.c
drivers/gpu/drm/via/via_map.c
include/drm/drmP.h
include/drm/drm_memory_debug.h [deleted file]

index 1479659..7a0d042 100644 (file)
@@ -203,7 +203,7 @@ int drm_agp_alloc(struct drm_device *dev, struct drm_agp_buffer *request)
 
        if (!dev->agp || !dev->agp->acquired)
                return -EINVAL;
-       if (!(entry = drm_alloc(sizeof(*entry), DRM_MEM_AGPLISTS)))
+       if (!(entry = kmalloc(sizeof(*entry), GFP_KERNEL)))
                return -ENOMEM;
 
        memset(entry, 0, sizeof(*entry));
@@ -211,7 +211,7 @@ int drm_agp_alloc(struct drm_device *dev, struct drm_agp_buffer *request)
        pages = (request->size + PAGE_SIZE - 1) / PAGE_SIZE;
        type = (u32) request->type;
        if (!(memory = drm_alloc_agp(dev, pages, type))) {
-               drm_free(entry, sizeof(*entry), DRM_MEM_AGPLISTS);
+               kfree(entry);
                return -ENOMEM;
        }
 
@@ -369,7 +369,7 @@ int drm_agp_free(struct drm_device *dev, struct drm_agp_buffer *request)
        list_del(&entry->head);
 
        drm_free_agp(entry->memory, entry->pages);
-       drm_free(entry, sizeof(*entry), DRM_MEM_AGPLISTS);
+       kfree(entry);
        return 0;
 }
 EXPORT_SYMBOL(drm_agp_free);
@@ -397,13 +397,13 @@ struct drm_agp_head *drm_agp_init(struct drm_device *dev)
 {
        struct drm_agp_head *head = NULL;
 
-       if (!(head = drm_alloc(sizeof(*head), DRM_MEM_AGPLISTS)))
+       if (!(head = kmalloc(sizeof(*head), GFP_KERNEL)))
                return NULL;
        memset((void *)head, 0, sizeof(*head));
        head->bridge = agp_find_bridge(dev->pdev);
        if (!head->bridge) {
                if (!(head->bridge = agp_backend_acquire(dev->pdev))) {
-                       drm_free(head, sizeof(*head), DRM_MEM_AGPLISTS);
+                       kfree(head);
                        return NULL;
                }
                agp_copy_info(head->bridge, &head->agp_info);
@@ -412,7 +412,7 @@ struct drm_agp_head *drm_agp_init(struct drm_device *dev)
                agp_copy_info(head->bridge, &head->agp_info);
        }
        if (head->agp_info.chipset == NOT_SUPPORTED) {
-               drm_free(head, sizeof(*head), DRM_MEM_AGPLISTS);
+               kfree(head);
                return NULL;
        }
        INIT_LIST_HEAD(&head->memory);
index ca7a9ef..932b5aa 100644 (file)
@@ -79,7 +79,7 @@ static int drm_add_magic(struct drm_master *master, struct drm_file *priv,
        struct drm_device *dev = master->minor->dev;
        DRM_DEBUG("%d\n", magic);
 
-       entry = drm_alloc(sizeof(*entry), DRM_MEM_MAGIC);
+       entry = kmalloc(sizeof(*entry), GFP_KERNEL);
        if (!entry)
                return -ENOMEM;
        memset(entry, 0, sizeof(*entry));
@@ -120,7 +120,7 @@ static int drm_remove_magic(struct drm_master *master, drm_magic_t magic)
        list_del(&pt->head);
        mutex_unlock(&dev->struct_mutex);
 
-       drm_free(pt, sizeof(*pt), DRM_MEM_MAGIC);
+       kfree(pt);
 
        return 0;
 }
index 80a2575..6246e3f 100644 (file)
@@ -151,7 +151,7 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset,
        unsigned long user_token;
        int ret;
 
-       map = drm_alloc(sizeof(*map), DRM_MEM_MAPS);
+       map = kmalloc(sizeof(*map), GFP_KERNEL);
        if (!map)
                return -ENOMEM;
 
@@ -165,7 +165,7 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset,
         * when processes fork.
         */
        if ((map->flags & _DRM_REMOVABLE) && map->type != _DRM_SHM) {
-               drm_free(map, sizeof(*map), DRM_MEM_MAPS);
+               kfree(map);
                return -EINVAL;
        }
        DRM_DEBUG("offset = 0x%08llx, size = 0x%08lx, type = %d\n",
@@ -179,7 +179,7 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset,
                map->size = PAGE_ALIGN(map->size);
 
        if ((map->offset & (~(resource_size_t)PAGE_MASK)) || (map->size & (~PAGE_MASK))) {
-               drm_free(map, sizeof(*map), DRM_MEM_MAPS);
+               kfree(map);
                return -EINVAL;
        }
        map->mtrr = -1;
@@ -191,7 +191,7 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset,
 #if !defined(__sparc__) && !defined(__alpha__) && !defined(__ia64__) && !defined(__powerpc64__) && !defined(__x86_64__)
                if (map->offset + (map->size-1) < map->offset ||
                    map->offset < virt_to_phys(high_memory)) {
-                       drm_free(map, sizeof(*map), DRM_MEM_MAPS);
+                       kfree(map);
                        return -EINVAL;
                }
 #endif
@@ -212,7 +212,7 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset,
                                list->map->size = map->size;
                        }
 
-                       drm_free(map, sizeof(*map), DRM_MEM_MAPS);
+                       kfree(map);
                        *maplist = list;
                        return 0;
                }
@@ -227,7 +227,7 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset,
                if (map->type == _DRM_REGISTERS) {
                        map->handle = ioremap(map->offset, map->size);
                        if (!map->handle) {
-                               drm_free(map, sizeof(*map), DRM_MEM_MAPS);
+                               kfree(map);
                                return -ENOMEM;
                        }
                }
@@ -243,7 +243,7 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset,
                                list->map->size = map->size;
                        }
 
-                       drm_free(map, sizeof(*map), DRM_MEM_MAPS);
+                       kfree(map);
                        *maplist = list;
                        return 0;
                }
@@ -251,7 +251,7 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset,
                DRM_DEBUG("%lu %d %p\n",
                          map->size, drm_order(map->size), map->handle);
                if (!map->handle) {
-                       drm_free(map, sizeof(*map), DRM_MEM_MAPS);
+                       kfree(map);
                        return -ENOMEM;
                }
                map->offset = (unsigned long)map->handle;
@@ -259,7 +259,7 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset,
                        /* Prevent a 2nd X Server from creating a 2nd lock */
                        if (dev->primary->master->lock.hw_lock != NULL) {
                                vfree(map->handle);
-                               drm_free(map, sizeof(*map), DRM_MEM_MAPS);
+                               kfree(map);
                                return -EBUSY;
                        }
                        dev->sigdata.lock = dev->primary->master->lock.hw_lock = map->handle;   /* Pointer to lock */
@@ -270,7 +270,7 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset,
                int valid = 0;
 
                if (!drm_core_has_AGP(dev)) {
-                       drm_free(map, sizeof(*map), DRM_MEM_MAPS);
+                       kfree(map);
                        return -EINVAL;
                }
 #ifdef __alpha__
@@ -303,7 +303,7 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset,
                        }
                }
                if (!list_empty(&dev->agp->memory) && !valid) {
-                       drm_free(map, sizeof(*map), DRM_MEM_MAPS);
+                       kfree(map);
                        return -EPERM;
                }
                DRM_DEBUG("AGP offset = 0x%08llx, size = 0x%08lx\n",
@@ -316,7 +316,7 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset,
        }
        case _DRM_SCATTER_GATHER:
                if (!dev->sg) {
-                       drm_free(map, sizeof(*map), DRM_MEM_MAPS);
+                       kfree(map);
                        return -EINVAL;
                }
                map->offset += (unsigned long)dev->sg->virtual;
@@ -328,7 +328,7 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset,
                 * need to point to a 64bit variable first. */
                dmah = drm_pci_alloc(dev, map->size, map->size, 0xffffffffUL);
                if (!dmah) {
-                       drm_free(map, sizeof(*map), DRM_MEM_MAPS);
+                       kfree(map);
                        return -ENOMEM;
                }
                map->handle = dmah->vaddr;
@@ -336,15 +336,15 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset,
                kfree(dmah);
                break;
        default:
-               drm_free(map, sizeof(*map), DRM_MEM_MAPS);
+               kfree(map);
                return -EINVAL;
        }
 
-       list = drm_alloc(sizeof(*list), DRM_MEM_MAPS);
+       list = kmalloc(sizeof(*list), GFP_KERNEL);
        if (!list) {
                if (map->type == _DRM_REGISTERS)
                        iounmap(map->handle);
-               drm_free(map, sizeof(*map), DRM_MEM_MAPS);
+               kfree(map);
                return -EINVAL;
        }
        memset(list, 0, sizeof(*list));
@@ -362,8 +362,8 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset,
        if (ret) {
                if (map->type == _DRM_REGISTERS)
                        iounmap(map->handle);
-               drm_free(map, sizeof(*map), DRM_MEM_MAPS);
-               drm_free(list, sizeof(*list), DRM_MEM_MAPS);
+               kfree(map);
+               kfree(list);
                mutex_unlock(&dev->struct_mutex);
                return ret;
        }
@@ -448,7 +448,7 @@ int drm_rmmap_locked(struct drm_device *dev, struct drm_local_map *map)
                        list_del(&r_list->head);
                        drm_ht_remove_key(&dev->map_hash,
                                          r_list->user_token >> PAGE_SHIFT);
-                       drm_free(r_list, sizeof(*r_list), DRM_MEM_MAPS);
+                       kfree(r_list);
                        found = 1;
                        break;
                }
@@ -491,7 +491,7 @@ int drm_rmmap_locked(struct drm_device *dev, struct drm_local_map *map)
                DRM_ERROR("tried to rmmap GEM object\n");
                break;
        }
-       drm_free(map, sizeof(*map), DRM_MEM_MAPS);
+       kfree(map);
 
        return 0;
 }
@@ -582,24 +582,16 @@ static void drm_cleanup_buf_error(struct drm_device * dev,
                                drm_pci_free(dev, entry->seglist[i]);
                        }
                }
-               drm_free(entry->seglist,
-                        entry->seg_count *
-                        sizeof(*entry->seglist), DRM_MEM_SEGS);
+               kfree(entry->seglist);
 
                entry->seg_count = 0;
        }
 
        if (entry->buf_count) {
                for (i = 0; i < entry->buf_count; i++) {
-                       if (entry->buflist[i].dev_private) {
-                               drm_free(entry->buflist[i].dev_private,
-                                        entry->buflist[i].dev_priv_size,
-                                        DRM_MEM_BUFS);
-                       }
+                       kfree(entry->buflist[i].dev_private);
                }
-               drm_free(entry->buflist,
-                        entry->buf_count *
-                        sizeof(*entry->buflist), DRM_MEM_BUFS);
+               kfree(entry->buflist);
 
                entry->buf_count = 0;
        }
@@ -698,8 +690,7 @@ int drm_addbufs_agp(struct drm_device * dev, struct drm_buf_desc * request)
                return -EINVAL;
        }
 
-       entry->buflist = drm_alloc(count * sizeof(*entry->buflist),
-                                  DRM_MEM_BUFS);
+       entry->buflist = kmalloc(count * sizeof(*entry->buflist), GFP_KERNEL);
        if (!entry->buflist) {
                mutex_unlock(&dev->struct_mutex);
                atomic_dec(&dev->buf_alloc);
@@ -729,7 +720,7 @@ int drm_addbufs_agp(struct drm_device * dev, struct drm_buf_desc * request)
                buf->file_priv = NULL;
 
                buf->dev_priv_size = dev->driver->dev_priv_size;
-               buf->dev_private = drm_alloc(buf->dev_priv_size, DRM_MEM_BUFS);
+               buf->dev_private = kmalloc(buf->dev_priv_size, GFP_KERNEL);
                if (!buf->dev_private) {
                        /* Set count correctly so we free the proper amount. */
                        entry->buf_count = count;
@@ -749,10 +740,9 @@ int drm_addbufs_agp(struct drm_device * dev, struct drm_buf_desc * request)
 
        DRM_DEBUG("byte_count: %d\n", byte_count);
 
-       temp_buflist = drm_realloc(dma->buflist,
-                                  dma->buf_count * sizeof(*dma->buflist),
-                                  (dma->buf_count + entry->buf_count)
-                                  * sizeof(*dma->buflist), DRM_MEM_BUFS);
+       temp_buflist = krealloc(dma->buflist,
+                               (dma->buf_count + entry->buf_count) *
+                               sizeof(*dma->buflist), GFP_KERNEL);
        if (!temp_buflist) {
                /* Free the entry because it isn't valid */
                drm_cleanup_buf_error(dev, entry);
@@ -854,8 +844,7 @@ int drm_addbufs_pci(struct drm_device * dev, struct drm_buf_desc * request)
                return -EINVAL;
        }
 
-       entry->buflist = drm_alloc(count * sizeof(*entry->buflist),
-                                  DRM_MEM_BUFS);
+       entry->buflist = kmalloc(count * sizeof(*entry->buflist), GFP_KERNEL);
        if (!entry->buflist) {
                mutex_unlock(&dev->struct_mutex);
                atomic_dec(&dev->buf_alloc);
@@ -863,11 +852,9 @@ int drm_addbufs_pci(struct drm_device * dev, struct drm_buf_desc * request)
        }
        memset(entry->buflist, 0, count * sizeof(*entry->buflist));
 
-       entry->seglist = drm_alloc(count * sizeof(*entry->seglist),
-                                  DRM_MEM_SEGS);
+       entry->seglist = kmalloc(count * sizeof(*entry->seglist), GFP_KERNEL);
        if (!entry->seglist) {
-               drm_free(entry->buflist,
-                        count * sizeof(*entry->buflist), DRM_MEM_BUFS);
+               kfree(entry->buflist);
                mutex_unlock(&dev->struct_mutex);
                atomic_dec(&dev->buf_alloc);
                return -ENOMEM;
@@ -877,13 +864,11 @@ int drm_addbufs_pci(struct drm_device * dev, struct drm_buf_desc * request)
        /* Keep the original pagelist until we know all the allocations
         * have succeeded
         */
-       temp_pagelist = drm_alloc((dma->page_count + (count << page_order))
-                                 * sizeof(*dma->pagelist), DRM_MEM_PAGES);
+       temp_pagelist = kmalloc((dma->page_count + (count << page_order)) *
+                              sizeof(*dma->pagelist), GFP_KERNEL);
        if (!temp_pagelist) {
-               drm_free(entry->buflist,
-                        count * sizeof(*entry->buflist), DRM_MEM_BUFS);
-               drm_free(entry->seglist,
-                        count * sizeof(*entry->seglist), DRM_MEM_SEGS);
+               kfree(entry->buflist);
+               kfree(entry->seglist);
                mutex_unlock(&dev->struct_mutex);
                atomic_dec(&dev->buf_alloc);
                return -ENOMEM;
@@ -907,9 +892,7 @@ int drm_addbufs_pci(struct drm_device * dev, struct drm_buf_desc * request)
                        entry->buf_count = count;
                        entry->seg_count = count;
                        drm_cleanup_buf_error(dev, entry);
-                       drm_free(temp_pagelist,
-                                (dma->page_count + (count << page_order))
-                                * sizeof(*dma->pagelist), DRM_MEM_PAGES);
+                       kfree(temp_pagelist);
                        mutex_unlock(&dev->struct_mutex);
                        atomic_dec(&dev->buf_alloc);
                        return -ENOMEM;
@@ -940,18 +923,14 @@ int drm_addbufs_pci(struct drm_device * dev, struct drm_buf_desc * request)
                        buf->file_priv = NULL;
 
                        buf->dev_priv_size = dev->driver->dev_priv_size;
-                       buf->dev_private = drm_alloc(buf->dev_priv_size,
-                                                    DRM_MEM_BUFS);
+                       buf->dev_private = kmalloc(buf->dev_priv_size,
+                                                 GFP_KERNEL);
                        if (!buf->dev_private) {
                                /* Set count correctly so we free the proper amount. */
                                entry->buf_count = count;
                                entry->seg_count = count;
                                drm_cleanup_buf_error(dev, entry);
-                               drm_free(temp_pagelist,
-                                        (dma->page_count +
-                                         (count << page_order))
-                                        * sizeof(*dma->pagelist),
-                                        DRM_MEM_PAGES);
+                               kfree(temp_pagelist);
                                mutex_unlock(&dev->struct_mutex);
                                atomic_dec(&dev->buf_alloc);
                                return -ENOMEM;
@@ -964,16 +943,13 @@ int drm_addbufs_pci(struct drm_device * dev, struct drm_buf_desc * request)
                byte_count += PAGE_SIZE << page_order;
        }
 
-       temp_buflist = drm_realloc(dma->buflist,
-                                  dma->buf_count * sizeof(*dma->buflist),
-                                  (dma->buf_count + entry->buf_count)
-                                  * sizeof(*dma->buflist), DRM_MEM_BUFS);
+       temp_buflist = krealloc(dma->buflist,
+                               (dma->buf_count + entry->buf_count) *
+                               sizeof(*dma->buflist), GFP_KERNEL);
        if (!temp_buflist) {
                /* Free the entry because it isn't valid */
                drm_cleanup_buf_error(dev, entry);
-               drm_free(temp_pagelist,
-                        (dma->page_count + (count << page_order))
-                        * sizeof(*dma->pagelist), DRM_MEM_PAGES);
+               kfree(temp_pagelist);
                mutex_unlock(&dev->struct_mutex);
                atomic_dec(&dev->buf_alloc);
                return -ENOMEM;
@@ -988,9 +964,7 @@ int drm_addbufs_pci(struct drm_device * dev, struct drm_buf_desc * request)
         * with the new one.
         */
        if (dma->page_count) {
-               drm_free(dma->pagelist,
-                        dma->page_count * sizeof(*dma->pagelist),
-                        DRM_MEM_PAGES);
+               kfree(dma->pagelist);
        }
        dma->pagelist = temp_pagelist;
 
@@ -1086,8 +1060,8 @@ static int drm_addbufs_sg(struct drm_device * dev, struct drm_buf_desc * request
                return -EINVAL;
        }
 
-       entry->buflist = drm_alloc(count * sizeof(*entry->buflist),
-                                  DRM_MEM_BUFS);
+       entry->buflist = kmalloc(count * sizeof(*entry->buflist),
+                               GFP_KERNEL);
        if (!entry->buflist) {
                mutex_unlock(&dev->struct_mutex);
                atomic_dec(&dev->buf_alloc);
@@ -1118,7 +1092,7 @@ static int drm_addbufs_sg(struct drm_device * dev, struct drm_buf_desc * request
                buf->file_priv = NULL;
 
                buf->dev_priv_size = dev->driver->dev_priv_size;
-               buf->dev_private = drm_alloc(buf->dev_priv_size, DRM_MEM_BUFS);
+               buf->dev_private = kmalloc(buf->dev_priv_size, GFP_KERNEL);
                if (!buf->dev_private) {
                        /* Set count correctly so we free the proper amount. */
                        entry->buf_count = count;
@@ -1139,10 +1113,9 @@ static int drm_addbufs_sg(struct drm_device * dev, struct drm_buf_desc * request
 
        DRM_DEBUG("byte_count: %d\n", byte_count);
 
-       temp_buflist = drm_realloc(dma->buflist,
-                                  dma->buf_count * sizeof(*dma->buflist),
-                                  (dma->buf_count + entry->buf_count)
-                                  * sizeof(*dma->buflist), DRM_MEM_BUFS);
+       temp_buflist = krealloc(dma->buflist,
+                               (dma->buf_count + entry->buf_count) *
+                               sizeof(*dma->buflist), GFP_KERNEL);
        if (!temp_buflist) {
                /* Free the entry because it isn't valid */
                drm_cleanup_buf_error(dev, entry);
@@ -1248,8 +1221,8 @@ static int drm_addbufs_fb(struct drm_device * dev, struct drm_buf_desc * request
                return -EINVAL;
        }
 
-       entry->buflist = drm_alloc(count * sizeof(*entry->buflist),
-                                  DRM_MEM_BUFS);
+       entry->buflist = kmalloc(count * sizeof(*entry->buflist),
+                               GFP_KERNEL);
        if (!entry->buflist) {
                mutex_unlock(&dev->struct_mutex);
                atomic_dec(&dev->buf_alloc);
@@ -1279,7 +1252,7 @@ static int drm_addbufs_fb(struct drm_device * dev, struct drm_buf_desc * request
                buf->file_priv = NULL;
 
                buf->dev_priv_size = dev->driver->dev_priv_size;
-               buf->dev_private = drm_alloc(buf->dev_priv_size, DRM_MEM_BUFS);
+               buf->dev_private = kmalloc(buf->dev_priv_size, GFP_KERNEL);
                if (!buf->dev_private) {
                        /* Set count correctly so we free the proper amount. */
                        entry->buf_count = count;
@@ -1299,10 +1272,9 @@ static int drm_addbufs_fb(struct drm_device * dev, struct drm_buf_desc * request
 
        DRM_DEBUG("byte_count: %d\n", byte_count);
 
-       temp_buflist = drm_realloc(dma->buflist,
-                                  dma->buf_count * sizeof(*dma->buflist),
-                                  (dma->buf_count + entry->buf_count)
-                                  * sizeof(*dma->buflist), DRM_MEM_BUFS);
+       temp_buflist = krealloc(dma->buflist,
+                               (dma->buf_count + entry->buf_count) *
+                               sizeof(*dma->buflist), GFP_KERNEL);
        if (!temp_buflist) {
                /* Free the entry because it isn't valid */
                drm_cleanup_buf_error(dev, entry);
index 7d1e53c..2607753 100644 (file)
@@ -341,7 +341,7 @@ int drm_addctx(struct drm_device *dev, void *data,
                        }
        }
 
-       ctx_entry = drm_alloc(sizeof(*ctx_entry), DRM_MEM_CTXLIST);
+       ctx_entry = kmalloc(sizeof(*ctx_entry), GFP_KERNEL);
        if (!ctx_entry) {
                DRM_DEBUG("out of memory\n");
                return -ENOMEM;
@@ -456,7 +456,7 @@ int drm_rmctx(struct drm_device *dev, void *data,
                list_for_each_entry_safe(pos, n, &dev->ctxlist, head) {
                        if (pos->handle == ctx->handle) {
                                list_del(&pos->head);
-                               drm_free(pos, sizeof(*pos), DRM_MEM_CTXLIST);
+                               kfree(pos);
                                --dev->ctx_count;
                        }
                }
index 6ce0e26..2960b6d 100644 (file)
@@ -100,15 +100,13 @@ int drm_debugfs_create_files(struct drm_info_list *files, int count,
                    (dev->driver->driver_features & features) != features)
                        continue;
 
-               tmp = drm_alloc(sizeof(struct drm_info_node),
-                               _DRM_DRIVER);
+               tmp = kmalloc(sizeof(struct drm_info_node), GFP_KERNEL);
                ent = debugfs_create_file(files[i].name, S_IFREG | S_IRUGO,
                                          root, tmp, &drm_debugfs_fops);
                if (!ent) {
                        DRM_ERROR("Cannot create /sys/kernel/debug/dri/%s/%s\n",
                                  name, files[i].name);
-                       drm_free(tmp, sizeof(struct drm_info_node),
-                                _DRM_DRIVER);
+                       kfree(tmp);
                        ret = -1;
                        goto fail;
                }
@@ -196,8 +194,7 @@ int drm_debugfs_remove_files(struct drm_info_list *files, int count,
                        if (tmp->info_ent == &files[i]) {
                                debugfs_remove(tmp->dent);
                                list_del(pos);
-                               drm_free(tmp, sizeof(struct drm_info_node),
-                                        _DRM_DRIVER);
+                               kfree(tmp);
                        }
                }
        }
index 7a8e2fb..13f1537 100644 (file)
@@ -47,7 +47,7 @@ int drm_dma_setup(struct drm_device *dev)
 {
        int i;
 
-       dev->dma = drm_alloc(sizeof(*dev->dma), DRM_MEM_DRIVER);
+       dev->dma = kmalloc(sizeof(*dev->dma), GFP_KERNEL);
        if (!dev->dma)
                return -ENOMEM;
 
@@ -88,36 +88,19 @@ void drm_dma_takedown(struct drm_device *dev)
                                        drm_pci_free(dev, dma->bufs[i].seglist[j]);
                                }
                        }
-                       drm_free(dma->bufs[i].seglist,
-                                dma->bufs[i].seg_count
-                                * sizeof(*dma->bufs[0].seglist), DRM_MEM_SEGS);
+                       kfree(dma->bufs[i].seglist);
                }
                if (dma->bufs[i].buf_count) {
                        for (j = 0; j < dma->bufs[i].buf_count; j++) {
-                               if (dma->bufs[i].buflist[j].dev_private) {
-                                       drm_free(dma->bufs[i].buflist[j].
-                                                dev_private,
-                                                dma->bufs[i].buflist[j].
-                                                dev_priv_size, DRM_MEM_BUFS);
-                               }
+                               kfree(dma->bufs[i].buflist[j].dev_private);
                        }
-                       drm_free(dma->bufs[i].buflist,
-                                dma->bufs[i].buf_count *
-                                sizeof(*dma->bufs[0].buflist), DRM_MEM_BUFS);
+                       kfree(dma->bufs[i].buflist);
                }
        }
 
-       if (dma->buflist) {
-               drm_free(dma->buflist,
-                        dma->buf_count * sizeof(*dma->buflist), DRM_MEM_BUFS);
-       }
-
-       if (dma->pagelist) {
-               drm_free(dma->pagelist,
-                        dma->page_count * sizeof(*dma->pagelist),
-                        DRM_MEM_PAGES);
-       }
-       drm_free(dev->dma, sizeof(*dev->dma), DRM_MEM_DRIVER);
+       kfree(dma->buflist);
+       kfree(dma->pagelist);
+       kfree(dev->dma);
        dev->dma = NULL;
 }
 
index 80be1ca..c53c976 100644 (file)
@@ -85,9 +85,8 @@ int drm_rmdraw(struct drm_device *dev, void *data, struct drm_file *file_priv)
                spin_unlock_irqrestore(&dev->drw_lock, irqflags);
                return -EINVAL;
        }
-       drm_free(info->rects, info->num_rects * sizeof(struct drm_clip_rect),
-                       DRM_MEM_BUFS);
-       drm_free(info, sizeof(struct drm_drawable_info), DRM_MEM_BUFS);
+       kfree(info->rects);
+       kfree(info);
 
        idr_remove(&dev->drw_idr, draw->handle);
 
@@ -106,12 +105,12 @@ int drm_update_drawable_info(struct drm_device *dev, void *data, struct drm_file
 
        info = idr_find(&dev->drw_idr, update->handle);
        if (!info) {
-               info = drm_calloc(1, sizeof(*info), DRM_MEM_BUFS);
+               info = kzalloc(sizeof(*info), GFP_KERNEL);
                if (!info)
                        return -ENOMEM;
                if (IS_ERR(idr_replace(&dev->drw_idr, info, update->handle))) {
                        DRM_ERROR("No such drawable %d\n", update->handle);
-                       drm_free(info, sizeof(*info), DRM_MEM_BUFS);
+                       kfree(info);
                        return -EINVAL;
                }
        }
@@ -121,8 +120,9 @@ int drm_update_drawable_info(struct drm_device *dev, void *data, struct drm_file
                if (update->num == 0)
                        rects = NULL;
                else if (update->num != info->num_rects) {
-                       rects = drm_alloc(update->num * sizeof(struct drm_clip_rect),
-                                        DRM_MEM_BUFS);
+                       rects = kmalloc(update->num *
+                                       sizeof(struct drm_clip_rect),
+                                       GFP_KERNEL);
                } else
                        rects = info->rects;
 
@@ -145,8 +145,7 @@ int drm_update_drawable_info(struct drm_device *dev, void *data, struct drm_file
                spin_lock_irqsave(&dev->drw_lock, irqflags);
 
                if (rects != info->rects) {
-                       drm_free(info->rects, info->num_rects *
-                                sizeof(struct drm_clip_rect), DRM_MEM_BUFS);
+                       kfree(info->rects);
                }
 
                info->rects = rects;
@@ -166,8 +165,7 @@ int drm_update_drawable_info(struct drm_device *dev, void *data, struct drm_file
 
 error:
        if (rects != info->rects)
-               drm_free(rects, update->num * sizeof(struct drm_clip_rect),
-                        DRM_MEM_BUFS);
+               kfree(rects);
 
        return err;
 }
@@ -186,9 +184,8 @@ static int drm_drawable_free(int idr, void *p, void *data)
        struct drm_drawable_info *info = p;
 
        if (info) {
-               drm_free(info->rects, info->num_rects *
-                        sizeof(struct drm_clip_rect), DRM_MEM_BUFS);
-               drm_free(info, sizeof(*info), DRM_MEM_BUFS);
+               kfree(info->rects);
+               kfree(info);
        }
 
        return 0;
index 1bf7efd..b39d7bf 100644 (file)
@@ -189,7 +189,7 @@ int drm_lastclose(struct drm_device * dev)
                        if (entry->bound)
                                drm_unbind_agp(entry->memory);
                        drm_free_agp(entry->memory, entry->pages);
-                       drm_free(entry, sizeof(*entry), DRM_MEM_AGPLISTS);
+                       kfree(entry);
                }
                INIT_LIST_HEAD(&dev->agp->memory);
 
@@ -208,21 +208,15 @@ int drm_lastclose(struct drm_device * dev)
        /* Clear vma list (only built for debugging) */
        list_for_each_entry_safe(vma, vma_temp, &dev->vmalist, head) {
                list_del(&vma->head);
-               drm_free(vma, sizeof(*vma), DRM_MEM_VMAS);
+               kfree(vma);
        }
 
        if (drm_core_check_feature(dev, DRIVER_DMA_QUEUE) && dev->queuelist) {
                for (i = 0; i < dev->queue_count; i++) {
-                       if (dev->queuelist[i]) {
-                               drm_free(dev->queuelist[i],
-                                        sizeof(*dev->queuelist[0]),
-                                        DRM_MEM_QUEUES);
-                               dev->queuelist[i] = NULL;
-                       }
+                       kfree(dev->queuelist[i]);
+                       dev->queuelist[i] = NULL;
                }
-               drm_free(dev->queuelist,
-                        dev->queue_slots * sizeof(*dev->queuelist),
-                        DRM_MEM_QUEUES);
+               kfree(dev->queuelist);
                dev->queuelist = NULL;
        }
        dev->queue_count = 0;
@@ -344,8 +338,6 @@ static int __init drm_core_init(void)
                goto err_p3;
        }
 
-       drm_mem_init();
-
        DRM_INFO("Initialized %s %d.%d.%d %s\n",
                 CORE_NAME, CORE_MAJOR, CORE_MINOR, CORE_PATCHLEVEL, CORE_DATE);
        return 0;
index 09a3571..251bc0e 100644 (file)
@@ -240,7 +240,7 @@ static int drm_open_helper(struct inode *inode, struct file *filp,
 
        DRM_DEBUG("pid = %d, minor = %d\n", task_pid_nr(current), minor_id);
 
-       priv = drm_alloc(sizeof(*priv), DRM_MEM_FILES);
+       priv = kmalloc(sizeof(*priv), GFP_KERNEL);
        if (!priv)
                return -ENOMEM;
 
@@ -328,7 +328,7 @@ static int drm_open_helper(struct inode *inode, struct file *filp,
 
        return 0;
       out_free:
-       drm_free(priv, sizeof(*priv), DRM_MEM_FILES);
+       kfree(priv);
        filp->private_data = NULL;
        return ret;
 }
@@ -471,7 +471,7 @@ int drm_release(struct inode *inode, struct file *filp)
                                drm_ctxbitmap_free(dev, pos->handle);
 
                                list_del(&pos->head);
-                               drm_free(pos, sizeof(*pos), DRM_MEM_CTXLIST);
+                               kfree(pos);
                                --dev->ctx_count;
                        }
                }
@@ -516,7 +516,7 @@ int drm_release(struct inode *inode, struct file *filp)
 
        if (dev->driver->postclose)
                dev->driver->postclose(dev, file_priv);
-       drm_free(file_priv, sizeof(*file_priv), DRM_MEM_FILES);
+       kfree(file_priv);
 
        /* ========================================================
         * End inline drm_release
index ec43005..8104eca 100644 (file)
@@ -89,7 +89,7 @@ drm_gem_init(struct drm_device *dev)
        atomic_set(&dev->gtt_count, 0);
        atomic_set(&dev->gtt_memory, 0);
 
-       mm = drm_calloc(1, sizeof(struct drm_gem_mm), DRM_MEM_MM);
+       mm = kzalloc(sizeof(struct drm_gem_mm), GFP_KERNEL);
        if (!mm) {
                DRM_ERROR("out of memory\n");
                return -ENOMEM;
@@ -98,14 +98,14 @@ drm_gem_init(struct drm_device *dev)
        dev->mm_private = mm;
 
        if (drm_ht_create(&mm->offset_hash, 19)) {
-               drm_free(mm, sizeof(struct drm_gem_mm), DRM_MEM_MM);
+               kfree(mm);
                return -ENOMEM;
        }
 
        if (drm_mm_init(&mm->offset_manager, DRM_FILE_PAGE_OFFSET_START,
                        DRM_FILE_PAGE_OFFSET_SIZE)) {
                drm_ht_remove(&mm->offset_hash);
-               drm_free(mm, sizeof(struct drm_gem_mm), DRM_MEM_MM);
+               kfree(mm);
                return -ENOMEM;
        }
 
@@ -119,7 +119,7 @@ drm_gem_destroy(struct drm_device *dev)
 
        drm_mm_takedown(&mm->offset_manager);
        drm_ht_remove(&mm->offset_hash);
-       drm_free(mm, sizeof(struct drm_gem_mm), DRM_MEM_MM);
+       kfree(mm);
        dev->mm_private = NULL;
 }
 
index ac35145..f36b21c 100644 (file)
@@ -46,8 +46,7 @@ int drm_ht_create(struct drm_open_hash *ht, unsigned int order)
        ht->table = NULL;
        ht->use_vmalloc = ((ht->size * sizeof(*ht->table)) > PAGE_SIZE);
        if (!ht->use_vmalloc) {
-               ht->table = drm_calloc(ht->size, sizeof(*ht->table),
-                                      DRM_MEM_HASHTAB);
+               ht->table = kcalloc(ht->size, sizeof(*ht->table), GFP_KERNEL);
        }
        if (!ht->table) {
                ht->use_vmalloc = 1;
@@ -200,8 +199,7 @@ void drm_ht_remove(struct drm_open_hash *ht)
                if (ht->use_vmalloc)
                        vfree(ht->table);
                else
-                       drm_free(ht->table, ht->size * sizeof(*ht->table),
-                                DRM_MEM_HASHTAB);
+                       kfree(ht->table);
                ht->table = NULL;
        }
 }
index 1fad762..9b9ff46 100644 (file)
@@ -93,7 +93,7 @@ int drm_setunique(struct drm_device *dev, void *data,
 
        master->unique_len = u->unique_len;
        master->unique_size = u->unique_len + 1;
-       master->unique = drm_alloc(master->unique_size, DRM_MEM_DRIVER);
+       master->unique = kmalloc(master->unique_size, GFP_KERNEL);
        if (!master->unique)
                return -ENOMEM;
        if (copy_from_user(master->unique, u->unique, master->unique_len))
@@ -101,9 +101,8 @@ int drm_setunique(struct drm_device *dev, void *data,
 
        master->unique[master->unique_len] = '\0';
 
-       dev->devname =
-           drm_alloc(strlen(dev->driver->pci_driver.name) +
-                     strlen(master->unique) + 2, DRM_MEM_DRIVER);
+       dev->devname = kmalloc(strlen(dev->driver->pci_driver.name) +
+                              strlen(master->unique) + 2, GFP_KERNEL);
        if (!dev->devname)
                return -ENOMEM;
 
@@ -138,7 +137,7 @@ static int drm_set_busid(struct drm_device *dev, struct drm_file *file_priv)
 
        master->unique_len = 40;
        master->unique_size = master->unique_len;
-       master->unique = drm_alloc(master->unique_size, DRM_MEM_DRIVER);
+       master->unique = kmalloc(master->unique_size, GFP_KERNEL);
        if (master->unique == NULL)
                return -ENOMEM;
 
@@ -152,9 +151,8 @@ static int drm_set_busid(struct drm_device *dev, struct drm_file *file_priv)
        else
                master->unique_len = len;
 
-       dev->devname =
-           drm_alloc(strlen(dev->driver->pci_driver.name) + master->unique_len +
-                     2, DRM_MEM_DRIVER);
+       dev->devname = kmalloc(strlen(dev->driver->pci_driver.name) +
+                              master->unique_len + 2, GFP_KERNEL);
        if (dev->devname == NULL)
                return -ENOMEM;
 
index fc8e5ac..b4a3dbc 100644 (file)
@@ -104,21 +104,13 @@ void drm_vblank_cleanup(struct drm_device *dev)
 
        vblank_disable_fn((unsigned long)dev);
 
-       drm_free(dev->vbl_queue, sizeof(*dev->vbl_queue) * dev->num_crtcs,
-                DRM_MEM_DRIVER);
-       drm_free(dev->_vblank_count, sizeof(*dev->_vblank_count) *
-                dev->num_crtcs, DRM_MEM_DRIVER);
-       drm_free(dev->vblank_refcount, sizeof(*dev->vblank_refcount) *
-                dev->num_crtcs, DRM_MEM_DRIVER);
-       drm_free(dev->vblank_enabled, sizeof(*dev->vblank_enabled) *
-                dev->num_crtcs, DRM_MEM_DRIVER);
-       drm_free(dev->last_vblank, sizeof(*dev->last_vblank) * dev->num_crtcs,
-                DRM_MEM_DRIVER);
-       drm_free(dev->last_vblank_wait,
-                sizeof(*dev->last_vblank_wait) * dev->num_crtcs,
-                DRM_MEM_DRIVER);
-       drm_free(dev->vblank_inmodeset, sizeof(*dev->vblank_inmodeset) *
-                dev->num_crtcs, DRM_MEM_DRIVER);
+       kfree(dev->vbl_queue);
+       kfree(dev->_vblank_count);
+       kfree(dev->vblank_refcount);
+       kfree(dev->vblank_enabled);
+       kfree(dev->last_vblank);
+       kfree(dev->last_vblank_wait);
+       kfree(dev->vblank_inmodeset);
 
        dev->num_crtcs = 0;
 }
@@ -132,37 +124,33 @@ int drm_vblank_init(struct drm_device *dev, int num_crtcs)
        spin_lock_init(&dev->vbl_lock);
        dev->num_crtcs = num_crtcs;
 
-       dev->vbl_queue = drm_alloc(sizeof(wait_queue_head_t) * num_crtcs,
-                                  DRM_MEM_DRIVER);
+       dev->vbl_queue = kmalloc(sizeof(wait_queue_head_t) * num_crtcs,
+                                GFP_KERNEL);
        if (!dev->vbl_queue)
                goto err;
 
-       dev->_vblank_count = drm_alloc(sizeof(atomic_t) * num_crtcs,
-                                     DRM_MEM_DRIVER);
+       dev->_vblank_count = kmalloc(sizeof(atomic_t) * num_crtcs, GFP_KERNEL);
        if (!dev->_vblank_count)
                goto err;
 
-       dev->vblank_refcount = drm_alloc(sizeof(atomic_t) * num_crtcs,
-                                        DRM_MEM_DRIVER);
+       dev->vblank_refcount = kmalloc(sizeof(atomic_t) * num_crtcs,
+                                      GFP_KERNEL);
        if (!dev->vblank_refcount)
                goto err;
 
-       dev->vblank_enabled = drm_calloc(num_crtcs, sizeof(int),
-                                        DRM_MEM_DRIVER);
+       dev->vblank_enabled = kcalloc(num_crtcs, sizeof(int), GFP_KERNEL);
        if (!dev->vblank_enabled)
                goto err;
 
-       dev->last_vblank = drm_calloc(num_crtcs, sizeof(u32), DRM_MEM_DRIVER);
+       dev->last_vblank = kcalloc(num_crtcs, sizeof(u32), GFP_KERNEL);
        if (!dev->last_vblank)
                goto err;
 
-       dev->last_vblank_wait = drm_calloc(num_crtcs, sizeof(u32),
-                                          DRM_MEM_DRIVER);
+       dev->last_vblank_wait = kcalloc(num_crtcs, sizeof(u32), GFP_KERNEL);
        if (!dev->last_vblank_wait)
                goto err;
 
-       dev->vblank_inmodeset = drm_calloc(num_crtcs, sizeof(int),
-                                        DRM_MEM_DRIVER);
+       dev->vblank_inmodeset = kcalloc(num_crtcs, sizeof(int), GFP_KERNEL);
        if (!dev->vblank_inmodeset)
                goto err;
 
index 0c707f5..0a43618 100644 (file)
 #include <linux/highmem.h>
 #include "drmP.h"
 
-#ifdef DEBUG_MEMORY
-#include "drm_memory_debug.h"
-#else
-
-/** No-op. */
-void drm_mem_init(void)
-{
-}
-
 /**
  * Called when "/proc/dri/%dev%/mem" is read.
  *
@@ -64,20 +55,6 @@ int drm_mem_info(char *buf, char **start, off_t offset,
        return 0;
 }
 
-/** Wrapper around kmalloc() and kfree() */
-void *drm_realloc(void *oldpt, size_t oldsize, size_t size, int area)
-{
-       void *pt;
-
-       if (!(pt = kmalloc(size, GFP_KERNEL)))
-               return NULL;
-       if (oldpt && oldsize) {
-               memcpy(pt, oldpt, oldsize);
-               kfree(oldpt);
-       }
-       return pt;
-}
-
 #if __OS_HAS_AGP
 static void *agp_remap(unsigned long offset, unsigned long size,
                       struct drm_device * dev)
@@ -157,8 +134,6 @@ static inline void *agp_remap(unsigned long offset, unsigned long size,
 
 #endif                         /* agp */
 
-#endif                         /* debug_memory */
-
 void drm_core_ioremap(struct drm_local_map *map, struct drm_device *dev)
 {
        if (drm_core_has_AGP(dev) &&
index b55d5bc..577094f 100644 (file)
@@ -55,17 +55,6 @@ drm_dma_handle_t *drm_pci_alloc(struct drm_device * dev, size_t size, size_t ali
        unsigned long addr;
        size_t sz;
 #endif
-#ifdef DRM_DEBUG_MEMORY
-       int area = DRM_MEM_DMA;
-
-       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);
-#endif
 
        /* pci_alloc_consistent only guarantees alignment to the smallest
         * PAGE_SIZE order which is greater than or equal to the requested size.
@@ -86,26 +75,10 @@ drm_dma_handle_t *drm_pci_alloc(struct drm_device * dev, size_t size, size_t ali
        dmah->size = size;
        dmah->vaddr = dma_alloc_coherent(&dev->pdev->dev, size, &dmah->busaddr, GFP_KERNEL | __GFP_COMP);
 
-#ifdef DRM_DEBUG_MEMORY
-       if (dmah->vaddr == NULL) {
-               spin_lock(&drm_mem_lock);
-               ++drm_mem_stats[area].fail_count;
-               spin_unlock(&drm_mem_lock);
-               kfree(dmah);
-               return NULL;
-       }
-
-       spin_lock(&drm_mem_lock);
-       ++drm_mem_stats[area].succeed_count;
-       drm_mem_stats[area].bytes_allocated += size;
-       drm_ram_used += size;
-       spin_unlock(&drm_mem_lock);
-#else
        if (dmah->vaddr == NULL) {
                kfree(dmah);
                return NULL;
        }
-#endif
 
        memset(dmah->vaddr, 0, size);
 
@@ -132,17 +105,8 @@ void __drm_pci_free(struct drm_device * dev, drm_dma_handle_t * dmah)
        unsigned long addr;
        size_t sz;
 #endif
-#ifdef DRM_DEBUG_MEMORY
-       int area = DRM_MEM_DMA;
-       int alloc_count;
-       int free_count;
-#endif
 
-       if (!dmah->vaddr) {
-#ifdef DRM_DEBUG_MEMORY
-               DRM_MEM_ERROR(area, "Attempt to free address 0\n");
-#endif
-       } else {
+       if (dmah->vaddr) {
                /* XXX - Is virt_to_page() legal for consistent mem? */
                /* Unreserve */
                for (addr = (unsigned long)dmah->vaddr, sz = dmah->size;
@@ -152,21 +116,6 @@ void __drm_pci_free(struct drm_device * dev, drm_dma_handle_t * dmah)
                dma_free_coherent(&dev->pdev->dev, dmah->size, dmah->vaddr,
                                  dmah->busaddr);
        }
-
-#ifdef DRM_DEBUG_MEMORY
-       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 += size;
-       drm_ram_used -= size;
-       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);
-       }
-#endif
-
 }
 
 /**
index bae5391..bbd4b3d 100644 (file)
@@ -105,13 +105,12 @@ int drm_proc_create_files(struct drm_info_list *files, int count,
                    (dev->driver->driver_features & features) != features)
                        continue;
 
-               tmp = drm_alloc(sizeof(struct drm_info_node), _DRM_DRIVER);
+               tmp = kmalloc(sizeof(struct drm_info_node), GFP_KERNEL);
                ent = create_proc_entry(files[i].name, S_IFREG | S_IRUGO, root);
                if (!ent) {
                        DRM_ERROR("Cannot create /proc/dri/%s/%s\n",
                                  name, files[i].name);
-                       drm_free(tmp, sizeof(struct drm_info_node),
-                                _DRM_DRIVER);
+                       kfree(tmp);
                        ret = -1;
                        goto fail;
                }
@@ -192,8 +191,7 @@ int drm_proc_remove_files(struct drm_info_list *files, int count,
                                remove_proc_entry(files[i].name,
                                                  minor->proc_root);
                                list_del(pos);
-                               drm_free(tmp, sizeof(struct drm_info_node),
-                                        _DRM_DRIVER);
+                               kfree(tmp);
                        }
                }
        }
index b2b0f3d..c7823c8 100644 (file)
@@ -58,11 +58,9 @@ void drm_sg_cleanup(struct drm_sg_mem * entry)
 
        vfree(entry->virtual);
 
-       drm_free(entry->busaddr,
-                entry->pages * sizeof(*entry->busaddr), DRM_MEM_PAGES);
-       drm_free(entry->pagelist,
-                entry->pages * sizeof(*entry->pagelist), DRM_MEM_PAGES);
-       drm_free(entry, sizeof(*entry), DRM_MEM_SGLISTS);
+       kfree(entry->busaddr);
+       kfree(entry->pagelist);
+       kfree(entry);
 }
 
 #ifdef _LP64
@@ -84,7 +82,7 @@ int drm_sg_alloc(struct drm_device *dev, struct drm_scatter_gather * request)
        if (dev->sg)
                return -EINVAL;
 
-       entry = drm_alloc(sizeof(*entry), DRM_MEM_SGLISTS);
+       entry = kmalloc(sizeof(*entry), GFP_KERNEL);
        if (!entry)
                return -ENOMEM;
 
@@ -93,34 +91,27 @@ int drm_sg_alloc(struct drm_device *dev, struct drm_scatter_gather * request)
        DRM_DEBUG("size=%ld pages=%ld\n", request->size, pages);
 
        entry->pages = pages;
-       entry->pagelist = drm_alloc(pages * sizeof(*entry->pagelist),
-                                   DRM_MEM_PAGES);
+       entry->pagelist = kmalloc(pages * sizeof(*entry->pagelist), GFP_KERNEL);
        if (!entry->pagelist) {
-               drm_free(entry, sizeof(*entry), DRM_MEM_SGLISTS);
+               kfree(entry);
                return -ENOMEM;
        }
 
        memset(entry->pagelist, 0, pages * sizeof(*entry->pagelist));
 
-       entry->busaddr = drm_alloc(pages * sizeof(*entry->busaddr),
-                                  DRM_MEM_PAGES);
+       entry->busaddr = kmalloc(pages * sizeof(*entry->busaddr), GFP_KERNEL);
        if (!entry->busaddr) {
-               drm_free(entry->pagelist,
-                        entry->pages * sizeof(*entry->pagelist),
-                        DRM_MEM_PAGES);
-               drm_free(entry, sizeof(*entry), DRM_MEM_SGLISTS);
+               kfree(entry->pagelist);
+               kfree(entry);
                return -ENOMEM;
        }
        memset((void *)entry->busaddr, 0, pages * sizeof(*entry->busaddr));
 
        entry->virtual = drm_vmalloc_dma(pages << PAGE_SHIFT);
        if (!entry->virtual) {
-               drm_free(entry->busaddr,
-                        entry->pages * sizeof(*entry->busaddr), DRM_MEM_PAGES);
-               drm_free(entry->pagelist,
-                        entry->pages * sizeof(*entry->pagelist),
-                        DRM_MEM_PAGES);
-               drm_free(entry, sizeof(*entry), DRM_MEM_SGLISTS);
+               kfree(entry->busaddr);
+               kfree(entry->pagelist);
+               kfree(entry);
                return -ENOMEM;
        }
 
index 926f146..463aed9 100644 (file)
@@ -48,9 +48,7 @@ void drm_sman_takedown(struct drm_sman * sman)
 {
        drm_ht_remove(&sman->user_hash_tab);
        drm_ht_remove(&sman->owner_hash_tab);
-       if (sman->mm)
-               drm_free(sman->mm, sman->num_managers * sizeof(*sman->mm),
-                        DRM_MEM_MM);
+       kfree(sman->mm);
 }
 
 EXPORT_SYMBOL(drm_sman_takedown);
@@ -61,8 +59,9 @@ drm_sman_init(struct drm_sman * sman, unsigned int num_managers,
 {
        int ret = 0;
 
-       sman->mm = (struct drm_sman_mm *) drm_calloc(num_managers, sizeof(*sman->mm),
-                                               DRM_MEM_MM);
+       sman->mm = (struct drm_sman_mm *) kcalloc(num_managers,
+                                                 sizeof(*sman->mm),
+                                                 GFP_KERNEL);
        if (!sman->mm) {
                ret = -ENOMEM;
                goto out;
@@ -78,7 +77,7 @@ drm_sman_init(struct drm_sman * sman, unsigned int num_managers,
 
        drm_ht_remove(&sman->owner_hash_tab);
 out1:
-       drm_free(sman->mm, num_managers * sizeof(*sman->mm), DRM_MEM_MM);
+       kfree(sman->mm);
 out:
        return ret;
 }
@@ -110,7 +109,7 @@ static void drm_sman_mm_destroy(void *private)
 {
        struct drm_mm *mm = (struct drm_mm *) private;
        drm_mm_takedown(mm);
-       drm_free(mm, sizeof(*mm), DRM_MEM_MM);
+       kfree(mm);
 }
 
 static unsigned long drm_sman_mm_offset(void *private, void *ref)
@@ -130,7 +129,7 @@ drm_sman_set_range(struct drm_sman * sman, unsigned int manager,
        BUG_ON(manager >= sman->num_managers);
 
        sman_mm = &sman->mm[manager];
-       mm = drm_calloc(1, sizeof(*mm), DRM_MEM_MM);
+       mm = kzalloc(sizeof(*mm), GFP_KERNEL);
        if (!mm) {
                return -ENOMEM;
        }
@@ -138,7 +137,7 @@ drm_sman_set_range(struct drm_sman * sman, unsigned int manager,
        ret = drm_mm_init(mm, start, size);
 
        if (ret) {
-               drm_free(mm, sizeof(*mm), DRM_MEM_MM);
+               kfree(mm);
                return ret;
        }
 
@@ -176,7 +175,7 @@ static struct drm_owner_item *drm_sman_get_owner_item(struct drm_sman * sman,
                                      owner_hash);
        }
 
-       owner_item = drm_calloc(1, sizeof(*owner_item), DRM_MEM_MM);
+       owner_item = kzalloc(sizeof(*owner_item), GFP_KERNEL);
        if (!owner_item)
                goto out;
 
@@ -189,7 +188,7 @@ static struct drm_owner_item *drm_sman_get_owner_item(struct drm_sman * sman,
        return owner_item;
 
 out1:
-       drm_free(owner_item, sizeof(*owner_item), DRM_MEM_MM);
+       kfree(owner_item);
 out:
        return NULL;
 }
@@ -212,7 +211,7 @@ struct drm_memblock_item *drm_sman_alloc(struct drm_sman *sman, unsigned int man
                return NULL;
        }
 
-       memblock = drm_calloc(1, sizeof(*memblock), DRM_MEM_MM);
+       memblock = kzalloc(sizeof(*memblock), GFP_KERNEL);
 
        if (!memblock)
                goto out;
@@ -237,7 +236,7 @@ struct drm_memblock_item *drm_sman_alloc(struct drm_sman *sman, unsigned int man
 out2:
        drm_ht_remove_item(&sman->user_hash_tab, &memblock->user_hash);
 out1:
-       drm_free(memblock, sizeof(*memblock), DRM_MEM_MM);
+       kfree(memblock);
 out:
        sman_mm->free(sman_mm->private, tmp);
 
@@ -253,7 +252,7 @@ static void drm_sman_free(struct drm_memblock_item *item)
        list_del(&item->owner_list);
        drm_ht_remove_item(&sman->user_hash_tab, &item->user_hash);
        item->mm->free(item->mm->private, item->mm_info);
-       drm_free(item, sizeof(*item), DRM_MEM_MM);
+       kfree(item);
 }
 
 int drm_sman_free_key(struct drm_sman *sman, unsigned int key)
@@ -277,7 +276,7 @@ static void drm_sman_remove_owner(struct drm_sman *sman,
 {
        list_del(&owner_item->sman_list);
        drm_ht_remove_item(&sman->owner_hash_tab, &owner_item->owner_hash);
-       drm_free(owner_item, sizeof(*owner_item), DRM_MEM_MM);
+       kfree(owner_item);
 }
 
 int drm_sman_owner_clean(struct drm_sman *sman, unsigned long owner)
index 387a8de..155a5bb 100644 (file)
@@ -107,7 +107,7 @@ struct drm_master *drm_master_create(struct drm_minor *minor)
 {
        struct drm_master *master;
 
-       master = drm_calloc(1, sizeof(*master), DRM_MEM_DRIVER);
+       master = kzalloc(sizeof(*master), GFP_KERNEL);
        if (!master)
                return NULL;
 
@@ -149,7 +149,7 @@ static void drm_master_destroy(struct kref *kref)
        }
 
        if (master->unique) {
-               drm_free(master->unique, master->unique_size, DRM_MEM_DRIVER);
+               kfree(master->unique);
                master->unique = NULL;
                master->unique_len = 0;
        }
@@ -157,12 +157,12 @@ static void drm_master_destroy(struct kref *kref)
        list_for_each_entry_safe(pt, next, &master->magicfree, head) {
                list_del(&pt->head);
                drm_ht_remove_item(&master->magiclist, &pt->hash_item);
-               drm_free(pt, sizeof(*pt), DRM_MEM_MAGIC);
+               kfree(pt);
        }
 
        drm_ht_remove(&master->magiclist);
 
-       drm_free(master, sizeof(*master), DRM_MEM_DRIVER);
+       kfree(master);
 }
 
 void drm_master_put(struct drm_master **master)
@@ -390,7 +390,7 @@ int drm_get_dev(struct pci_dev *pdev, const struct pci_device_id *ent,
 
        DRM_DEBUG("\n");
 
-       dev = drm_calloc(1, sizeof(*dev), DRM_MEM_STUB);
+       dev = kzalloc(sizeof(*dev), GFP_KERNEL);
        if (!dev)
                return -ENOMEM;
 
@@ -443,7 +443,7 @@ err_g3:
 err_g2:
        pci_disable_device(pdev);
 err_g1:
-       drm_free(dev, sizeof(*dev), DRM_MEM_STUB);
+       kfree(dev);
        return ret;
 }
 EXPORT_SYMBOL(drm_get_dev);
@@ -516,7 +516,7 @@ void drm_put_dev(struct drm_device *dev)
                dev->driver->unload(dev);
 
        if (drm_core_has_AGP(dev) && dev->agp) {
-               drm_free(dev->agp, sizeof(*dev->agp), DRM_MEM_AGPLISTS);
+               kfree(dev->agp);
                dev->agp = NULL;
        }
 
@@ -535,10 +535,9 @@ void drm_put_dev(struct drm_device *dev)
        drm_put_minor(&dev->primary);
 
        if (dev->devname) {
-               drm_free(dev->devname, strlen(dev->devname) + 1,
-                        DRM_MEM_DRIVER);
+               kfree(dev->devname);
                dev->devname = NULL;
        }
-       drm_free(dev, sizeof(*dev), DRM_MEM_STUB);
+       kfree(dev);
 }
 EXPORT_SYMBOL(drm_put_dev);
index 22f7656..f95d03a 100644 (file)
@@ -227,7 +227,7 @@ static void drm_vm_shm_close(struct vm_area_struct *vma)
                        found_maps++;
                if (pt->vma == vma) {
                        list_del(&pt->head);
-                       drm_free(pt, sizeof(*pt), DRM_MEM_VMAS);
+                       kfree(pt);
                }
        }
 
@@ -273,7 +273,7 @@ static void drm_vm_shm_close(struct vm_area_struct *vma)
                                DRM_ERROR("tried to rmmap GEM object\n");
                                break;
                        }
-                       drm_free(map, sizeof(*map), DRM_MEM_MAPS);
+                       kfree(map);
                }
        }
        mutex_unlock(&dev->struct_mutex);
@@ -414,7 +414,7 @@ void drm_vm_open_locked(struct vm_area_struct *vma)
                  vma->vm_start, vma->vm_end - vma->vm_start);
        atomic_inc(&dev->vma_count);
 
-       vma_entry = drm_alloc(sizeof(*vma_entry), DRM_MEM_VMAS);
+       vma_entry = kmalloc(sizeof(*vma_entry), GFP_KERNEL);
        if (vma_entry) {
                vma_entry->vma = vma;
                vma_entry->pid = current->pid;
@@ -454,7 +454,7 @@ static void drm_vm_close(struct vm_area_struct *vma)
        list_for_each_entry_safe(pt, temp, &dev->vmalist, head) {
                if (pt->vma == vma) {
                        list_del(&pt->head);
-                       drm_free(pt, sizeof(*pt), DRM_MEM_VMAS);
+                       kfree(pt);
                        break;
                }
        }
index e5de8ea..7d1d88c 100644 (file)
@@ -227,8 +227,7 @@ static int i810_dma_cleanup(struct drm_device * dev)
                        /* Need to rewrite hardware status page */
                        I810_WRITE(0x02080, 0x1ffff000);
                }
-               drm_free(dev->dev_private, sizeof(drm_i810_private_t),
-                        DRM_MEM_DRIVER);
+               kfree(dev->dev_private);
                dev->dev_private = NULL;
 
                for (i = 0; i < dma->buf_count; i++) {
@@ -439,8 +438,7 @@ static int i810_dma_init(struct drm_device *dev, void *data,
        switch (init->func) {
        case I810_INIT_DMA_1_4:
                DRM_INFO("Using v1.4 init.\n");
-               dev_priv = drm_alloc(sizeof(drm_i810_private_t),
-                                    DRM_MEM_DRIVER);
+               dev_priv = kmalloc(sizeof(drm_i810_private_t), GFP_KERNEL);
                if (dev_priv == NULL)
                        return -ENOMEM;
                retcode = i810_dma_initialize(dev, dev_priv, init);
index a86ab30..877bf6c 100644 (file)
@@ -232,8 +232,7 @@ static int i830_dma_cleanup(struct drm_device * dev)
                        I830_WRITE(0x02080, 0x1ffff000);
                }
 
-               drm_free(dev->dev_private, sizeof(drm_i830_private_t),
-                        DRM_MEM_DRIVER);
+               kfree(dev->dev_private);
                dev->dev_private = NULL;
 
                for (i = 0; i < dma->buf_count; i++) {
@@ -459,8 +458,7 @@ static int i830_dma_init(struct drm_device *dev, void *data,
 
        switch (init->func) {
        case I830_INIT_DMA:
-               dev_priv = drm_alloc(sizeof(drm_i830_private_t),
-                                    DRM_MEM_DRIVER);
+               dev_priv = kmalloc(sizeof(drm_i830_private_t), GFP_KERNEL);
                if (dev_priv == NULL)
                        return -ENOMEM;
                retcode = i830_dma_initialize(dev, dev_priv, init);
index 1a60626..9b28c55 100644 (file)
@@ -643,9 +643,9 @@ static int i915_batchbuffer(struct drm_device *dev, void *data,
                return -EINVAL;
 
        if (batch->num_cliprects) {
-               cliprects = drm_calloc(batch->num_cliprects,
-                                      sizeof(struct drm_clip_rect),
-                                      DRM_MEM_DRIVER);
+               cliprects = kcalloc(batch->num_cliprects,
+                                   sizeof(struct drm_clip_rect),
+                                   GFP_KERNEL);
                if (cliprects == NULL)
                        return -ENOMEM;
 
@@ -664,9 +664,7 @@ static int i915_batchbuffer(struct drm_device *dev, void *data,
                sarea_priv->last_dispatch = READ_BREADCRUMB(dev_priv);
 
 fail_free:
-       drm_free(cliprects,
-                batch->num_cliprects * sizeof(struct drm_clip_rect),
-                DRM_MEM_DRIVER);
+       kfree(cliprects);
 
        return ret;
 }
@@ -692,7 +690,7 @@ static int i915_cmdbuffer(struct drm_device *dev, void *data,
        if (cmdbuf->num_cliprects < 0)
                return -EINVAL;
 
-       batch_data = drm_alloc(cmdbuf->sz, DRM_MEM_DRIVER);
+       batch_data = kmalloc(cmdbuf->sz, GFP_KERNEL);
        if (batch_data == NULL)
                return -ENOMEM;
 
@@ -701,9 +699,8 @@ static int i915_cmdbuffer(struct drm_device *dev, void *data,
                goto fail_batch_free;
 
        if (cmdbuf->num_cliprects) {
-               cliprects = drm_calloc(cmdbuf->num_cliprects,
-                                      sizeof(struct drm_clip_rect),
-                                      DRM_MEM_DRIVER);
+               cliprects = kcalloc(cmdbuf->num_cliprects,
+                                   sizeof(struct drm_clip_rect), GFP_KERNEL);
                if (cliprects == NULL)
                        goto fail_batch_free;
 
@@ -726,11 +723,9 @@ static int i915_cmdbuffer(struct drm_device *dev, void *data,
                sarea_priv->last_dispatch = READ_BREADCRUMB(dev_priv);
 
 fail_clip_free:
-       drm_free(cliprects,
-                cmdbuf->num_cliprects * sizeof(struct drm_clip_rect),
-                DRM_MEM_DRIVER);
+       kfree(cliprects);
 fail_batch_free:
-       drm_free(batch_data, cmdbuf->sz, DRM_MEM_DRIVER);
+       kfree(batch_data);
 
        return ret;
 }
@@ -1067,7 +1062,7 @@ int i915_master_create(struct drm_device *dev, struct drm_master *master)
 {
        struct drm_i915_master_private *master_priv;
 
-       master_priv = drm_calloc(1, sizeof(*master_priv), DRM_MEM_DRIVER);
+       master_priv = kzalloc(sizeof(*master_priv), GFP_KERNEL);
        if (!master_priv)
                return -ENOMEM;
 
@@ -1082,7 +1077,7 @@ void i915_master_destroy(struct drm_device *dev, struct drm_master *master)
        if (!master_priv)
                return;
 
-       drm_free(master_priv, sizeof(*master_priv), DRM_MEM_DRIVER);
+       kfree(master_priv);
 
        master->driver_priv = NULL;
 }
@@ -1111,12 +1106,10 @@ int i915_driver_load(struct drm_device *dev, unsigned long flags)
        dev->types[8] = _DRM_STAT_SECONDARY;
        dev->types[9] = _DRM_STAT_DMA;
 
-       dev_priv = drm_alloc(sizeof(drm_i915_private_t), DRM_MEM_DRIVER);
+       dev_priv = kzalloc(sizeof(drm_i915_private_t), GFP_KERNEL);
        if (dev_priv == NULL)
                return -ENOMEM;
 
-       memset(dev_priv, 0, sizeof(drm_i915_private_t));
-
        dev->dev_private = (void *)dev_priv;
        dev_priv->dev = dev;
 
@@ -1221,7 +1214,7 @@ out_iomapfree:
 out_rmmap:
        iounmap(dev_priv->regs);
 free_priv:
-       drm_free(dev_priv, sizeof(struct drm_i915_private), DRM_MEM_DRIVER);
+       kfree(dev_priv);
        return ret;
 }
 
@@ -1261,8 +1254,7 @@ int i915_driver_unload(struct drm_device *dev)
                i915_gem_lastclose(dev);
        }
 
-       drm_free(dev->dev_private, sizeof(drm_i915_private_t),
-                DRM_MEM_DRIVER);
+       kfree(dev->dev_private);
 
        return 0;
 }
@@ -1273,7 +1265,7 @@ int i915_driver_open(struct drm_device *dev, struct drm_file *file_priv)
 
        DRM_DEBUG_DRIVER(I915_DRV, "\n");
        i915_file_priv = (struct drm_i915_file_private *)
-           drm_alloc(sizeof(*i915_file_priv), DRM_MEM_FILES);
+           kmalloc(sizeof(*i915_file_priv), GFP_KERNEL);
 
        if (!i915_file_priv)
                return -ENOMEM;
@@ -1326,7 +1318,7 @@ void i915_driver_postclose(struct drm_device *dev, struct drm_file *file_priv)
 {
        struct drm_i915_file_private *i915_file_priv = file_priv->driver_priv;
 
-       drm_free(i915_file_priv, sizeof(*i915_file_priv), DRM_MEM_FILES);
+       kfree(i915_file_priv);
 }
 
 struct drm_ioctl_desc i915_ioctls[] = {
index 174aef2..fd2b8bd 100644 (file)
@@ -1207,8 +1207,7 @@ i915_gem_create_mmap_offset(struct drm_gem_object *obj)
 
        /* Set the object up for mmap'ing */
        list = &obj->map_list;
-       list->map = drm_calloc(1, sizeof(struct drm_map_list),
-                              DRM_MEM_DRIVER);
+       list->map = kzalloc(sizeof(struct drm_map_list), GFP_KERNEL);
        if (!list->map)
                return -ENOMEM;
 
@@ -1248,7 +1247,7 @@ i915_gem_create_mmap_offset(struct drm_gem_object *obj)
 out_free_mm:
        drm_mm_put_block(list->file_offset_node);
 out_free_list:
-       drm_free(list->map, sizeof(struct drm_map_list), DRM_MEM_DRIVER);
+       kfree(list->map);
 
        return ret;
 }
@@ -1270,7 +1269,7 @@ i915_gem_free_mmap_offset(struct drm_gem_object *obj)
        }
 
        if (list->map) {
-               drm_free(list->map, sizeof(struct drm_map), DRM_MEM_DRIVER);
+               kfree(list->map);
                list->map = NULL;
        }
 
@@ -1493,7 +1492,7 @@ i915_add_request(struct drm_device *dev, struct drm_file *file_priv,
        if (file_priv != NULL)
                i915_file_priv = file_priv->driver_priv;
 
-       request = drm_calloc(1, sizeof(*request), DRM_MEM_DRIVER);
+       request = kzalloc(sizeof(*request), GFP_KERNEL);
        if (request == NULL)
                return 0;
 
@@ -1675,7 +1674,7 @@ i915_gem_retire_requests(struct drm_device *dev)
 
                        list_del(&request->list);
                        list_del(&request->client_list);
-                       drm_free(request, sizeof(*request), DRM_MEM_DRIVER);
+                       kfree(request);
                } else
                        break;
        }
@@ -2833,8 +2832,7 @@ i915_gem_object_set_to_full_cpu_read_domain(struct drm_gem_object *obj)
        /* Free the page_cpu_valid mappings which are now stale, whether
         * or not we've got I915_GEM_DOMAIN_CPU.
         */
-       drm_free(obj_priv->page_cpu_valid, obj->size / PAGE_SIZE,
-                DRM_MEM_DRIVER);
+       kfree(obj_priv->page_cpu_valid);
        obj_priv->page_cpu_valid = NULL;
 }
 
@@ -2876,8 +2874,8 @@ i915_gem_object_set_cpu_read_domain_range(struct drm_gem_object *obj,
         * newly adding I915_GEM_DOMAIN_CPU
         */
        if (obj_priv->page_cpu_valid == NULL) {
-               obj_priv->page_cpu_valid = drm_calloc(1, obj->size / PAGE_SIZE,
-                                                     DRM_MEM_DRIVER);
+               obj_priv->page_cpu_valid = kzalloc(obj->size / PAGE_SIZE,
+                                                  GFP_KERNEL);
                if (obj_priv->page_cpu_valid == NULL)
                        return -ENOMEM;
        } else if ((obj->read_domains & I915_GEM_DOMAIN_CPU) == 0)
@@ -3300,8 +3298,8 @@ i915_gem_execbuffer(struct drm_device *dev, void *data,
        }
 
        if (args->num_cliprects != 0) {
-               cliprects = drm_calloc(args->num_cliprects, sizeof(*cliprects),
-                                      DRM_MEM_DRIVER);
+               cliprects = kcalloc(args->num_cliprects, sizeof(*cliprects),
+                                   GFP_KERNEL);
                if (cliprects == NULL)
                        goto pre_mutex_err;
 
@@ -3554,8 +3552,7 @@ err:
 pre_mutex_err:
        drm_free_large(object_list);
        drm_free_large(exec_list);
-       drm_free(cliprects, sizeof(*cliprects) * args->num_cliprects,
-                DRM_MEM_DRIVER);
+       kfree(cliprects);
 
        return ret;
 }
@@ -3772,7 +3769,7 @@ int i915_gem_init_object(struct drm_gem_object *obj)
 {
        struct drm_i915_gem_object *obj_priv;
 
-       obj_priv = drm_calloc(1, sizeof(*obj_priv), DRM_MEM_DRIVER);
+       obj_priv = kzalloc(sizeof(*obj_priv), GFP_KERNEL);
        if (obj_priv == NULL)
                return -ENOMEM;
 
@@ -3810,9 +3807,9 @@ void i915_gem_free_object(struct drm_gem_object *obj)
 
        i915_gem_free_mmap_offset(obj);
 
-       drm_free(obj_priv->page_cpu_valid, 1, DRM_MEM_DRIVER);
+       kfree(obj_priv->page_cpu_valid);
        kfree(obj_priv->bit_17);
-       drm_free(obj->driver_private, 1, DRM_MEM_DRIVER);
+       kfree(obj->driver_private);
 }
 
 /** Unbinds all objects that are on the given buffer list. */
@@ -4266,7 +4263,7 @@ int i915_gem_init_phys_object(struct drm_device *dev,
        if (dev_priv->mm.phys_objs[id - 1] || !size)
                return 0;
 
-       phys_obj = drm_calloc(1, sizeof(struct drm_i915_gem_phys_object), DRM_MEM_DRIVER);
+       phys_obj = kzalloc(sizeof(struct drm_i915_gem_phys_object), GFP_KERNEL);
        if (!phys_obj)
                return -ENOMEM;
 
@@ -4285,7 +4282,7 @@ int i915_gem_init_phys_object(struct drm_device *dev,
 
        return 0;
 kfree_obj:
-       drm_free(phys_obj, sizeof(struct drm_i915_gem_phys_object), DRM_MEM_DRIVER);
+       kfree(phys_obj);
        return ret;
 }
 
index 96e2719..83b7b81 100644 (file)
@@ -94,8 +94,8 @@ static struct mem_block *split_block(struct mem_block *p, int start, int size,
 {
        /* Maybe cut off the start of an existing block */
        if (start > p->start) {
-               struct mem_block *newblock =
-                   drm_alloc(sizeof(*newblock), DRM_MEM_BUFLISTS);
+               struct mem_block *newblock = kmalloc(sizeof(*newblock),
+                                                    GFP_KERNEL);
                if (!newblock)
                        goto out;
                newblock->start = start;
@@ -111,8 +111,8 @@ static struct mem_block *split_block(struct mem_block *p, int start, int size,
 
        /* Maybe cut off the end of an existing block */
        if (size < p->size) {
-               struct mem_block *newblock =
-                   drm_alloc(sizeof(*newblock), DRM_MEM_BUFLISTS);
+               struct mem_block *newblock = kmalloc(sizeof(*newblock),
+                                                    GFP_KERNEL);
                if (!newblock)
                        goto out;
                newblock->start = start + size;
@@ -169,7 +169,7 @@ static void free_block(struct mem_block *p)
                p->size += q->size;
                p->next = q->next;
                p->next->prev = p;
-               drm_free(q, sizeof(*q), DRM_MEM_BUFLISTS);
+               kfree(q);
        }
 
        if (p->prev->file_priv == NULL) {
@@ -177,7 +177,7 @@ static void free_block(struct mem_block *p)
                q->size += p->size;
                q->next = p->next;
                q->next->prev = q;
-               drm_free(p, sizeof(*q), DRM_MEM_BUFLISTS);
+               kfree(p);
        }
 }
 
@@ -185,14 +185,14 @@ static void free_block(struct mem_block *p)
  */
 static int init_heap(struct mem_block **heap, int start, int size)
 {
-       struct mem_block *blocks = drm_alloc(sizeof(*blocks), DRM_MEM_BUFLISTS);
+       struct mem_block *blocks = kmalloc(sizeof(*blocks), GFP_KERNEL);
 
        if (!blocks)
                return -ENOMEM;
 
-       *heap = drm_alloc(sizeof(**heap), DRM_MEM_BUFLISTS);
+       *heap = kmalloc(sizeof(**heap), GFP_KERNEL);
        if (!*heap) {
-               drm_free(blocks, sizeof(*blocks), DRM_MEM_BUFLISTS);
+               kfree(blocks);
                return -ENOMEM;
        }
 
@@ -233,7 +233,7 @@ void i915_mem_release(struct drm_device * dev, struct drm_file *file_priv,
                        p->size += q->size;
                        p->next = q->next;
                        p->next->prev = p;
-                       drm_free(q, sizeof(*q), DRM_MEM_BUFLISTS);
+                       kfree(q);
                }
        }
 }
@@ -250,10 +250,10 @@ void i915_mem_takedown(struct mem_block **heap)
        for (p = (*heap)->next; p != *heap;) {
                struct mem_block *q = p;
                p = p->next;
-               drm_free(q, sizeof(*q), DRM_MEM_BUFLISTS);
+               kfree(q);
        }
 
-       drm_free(*heap, sizeof(**heap), DRM_MEM_BUFLISTS);
+       kfree(*heap);
        *heap = NULL;
 }
 
index 754dd22..cdd126d 100644 (file)
@@ -124,8 +124,7 @@ parse_lfp_panel_data(struct drm_i915_private *dev_priv,
        entry = &lvds_lfp_data->data[lvds_options->panel_type];
        dvo_timing = &entry->dvo_timing;
 
-       panel_fixed_mode = drm_calloc(1, sizeof(*panel_fixed_mode),
-                                     DRM_MEM_DRIVER);
+       panel_fixed_mode = kzalloc(sizeof(*panel_fixed_mode), GFP_KERNEL);
 
        fill_detail_timing_data(panel_fixed_mode, dvo_timing);
 
@@ -156,8 +155,7 @@ parse_sdvo_panel_data(struct drm_i915_private *dev_priv,
        if (!dvo_timing)
                return;
 
-       panel_fixed_mode = drm_calloc(1, sizeof(*panel_fixed_mode),
-                                     DRM_MEM_DRIVER);
+       panel_fixed_mode = kzalloc(sizeof(*panel_fixed_mode), GFP_KERNEL);
 
        if (!panel_fixed_mode)
                return;
index 50d7ed7..ea68992 100644 (file)
@@ -1561,8 +1561,7 @@ intel_tv_destroy (struct drm_connector *connector)
 
        drm_sysfs_connector_remove(connector);
        drm_connector_cleanup(connector);
-       drm_free(intel_output, sizeof(struct intel_output) + sizeof(struct intel_tv_priv),
-                DRM_MEM_DRIVER);
+       kfree(intel_output);
 }
 
 
@@ -1695,8 +1694,8 @@ intel_tv_init(struct drm_device *dev)
            (tv_dac_off & TVDAC_STATE_CHG_EN) != 0)
                return;
 
-       intel_output = drm_calloc(1, sizeof(struct intel_output) +
-                                 sizeof(struct intel_tv_priv), DRM_MEM_DRIVER);
+       intel_output = kzalloc(sizeof(struct intel_output) +
+                              sizeof(struct intel_tv_priv), GFP_KERNEL);
        if (!intel_output) {
                return;
        }
@@ -1730,8 +1729,8 @@ intel_tv_init(struct drm_device *dev)
        connector->doublescan_allowed = false;
 
        /* Create TV properties then attach current values */
-       tv_format_names = drm_alloc(sizeof(char *) * NUM_TV_MODES,
-                                   DRM_MEM_DRIVER);
+       tv_format_names = kmalloc(sizeof(char *) * NUM_TV_MODES,
+                                 GFP_KERNEL);
        if (!tv_format_names)
                goto out;
        for (i = 0; i < NUM_TV_MODES; i++)
index 7a6bf9f..6c67a02 100644 (file)
@@ -254,23 +254,20 @@ static int mga_freelist_init(struct drm_device * dev, drm_mga_private_t * dev_pr
        int i;
        DRM_DEBUG("count=%d\n", dma->buf_count);
 
-       dev_priv->head = drm_alloc(sizeof(drm_mga_freelist_t), DRM_MEM_DRIVER);
+       dev_priv->head = kzalloc(sizeof(drm_mga_freelist_t), GFP_KERNEL);
        if (dev_priv->head == NULL)
                return -ENOMEM;
 
-       memset(dev_priv->head, 0, sizeof(drm_mga_freelist_t));
        SET_AGE(&dev_priv->head->age, MGA_BUFFER_USED, 0);
 
        for (i = 0; i < dma->buf_count; i++) {
                buf = dma->buflist[i];
                buf_priv = buf->dev_private;
 
-               entry = drm_alloc(sizeof(drm_mga_freelist_t), DRM_MEM_DRIVER);
+               entry = kzalloc(sizeof(drm_mga_freelist_t), GFP_KERNEL);
                if (entry == NULL)
                        return -ENOMEM;
 
-               memset(entry, 0, sizeof(drm_mga_freelist_t));
-
                entry->next = dev_priv->head->next;
                entry->prev = dev_priv->head;
                SET_AGE(&entry->age, MGA_BUFFER_FREE, 0);
@@ -301,7 +298,7 @@ static void mga_freelist_cleanup(struct drm_device * dev)
        entry = dev_priv->head;
        while (entry) {
                next = entry->next;
-               drm_free(entry, sizeof(drm_mga_freelist_t), DRM_MEM_DRIVER);
+               kfree(entry);
                entry = next;
        }
 
@@ -399,12 +396,11 @@ int mga_driver_load(struct drm_device * dev, unsigned long flags)
        drm_mga_private_t *dev_priv;
        int ret;
 
-       dev_priv = drm_alloc(sizeof(drm_mga_private_t), DRM_MEM_DRIVER);
+       dev_priv = kzalloc(sizeof(drm_mga_private_t), GFP_KERNEL);
        if (!dev_priv)
                return -ENOMEM;
 
        dev->dev_private = (void *)dev_priv;
-       memset(dev_priv, 0, sizeof(drm_mga_private_t));
 
        dev_priv->usec_timeout = MGA_DEFAULT_USEC_TIMEOUT;
        dev_priv->chipset = flags;
@@ -1150,7 +1146,7 @@ int mga_dma_buffers(struct drm_device *dev, void *data,
  */
 int mga_driver_unload(struct drm_device * dev)
 {
-       drm_free(dev->dev_private, sizeof(drm_mga_private_t), DRM_MEM_DRIVER);
+       kfree(dev->dev_private);
        dev->dev_private = NULL;
 
        return 0;
index 077c045..c75fd35 100644 (file)
@@ -353,12 +353,10 @@ static int r128_do_init_cce(struct drm_device * dev, drm_r128_init_t * init)
 
        DRM_DEBUG("\n");
 
-       dev_priv = drm_alloc(sizeof(drm_r128_private_t), DRM_MEM_DRIVER);
+       dev_priv = kzalloc(sizeof(drm_r128_private_t), GFP_KERNEL);
        if (dev_priv == NULL)
                return -ENOMEM;
 
-       memset(dev_priv, 0, sizeof(drm_r128_private_t));
-
        dev_priv->is_pci = init->is_pci;
 
        if (dev_priv->is_pci && !dev->sg) {
@@ -619,8 +617,7 @@ int r128_do_cleanup_cce(struct drm_device * dev)
                                            ("failed to cleanup PCI GART!\n");
                }
 
-               drm_free(dev->dev_private, sizeof(drm_r128_private_t),
-                        DRM_MEM_DRIVER);
+               kfree(dev->dev_private);
                dev->dev_private = NULL;
        }
 
@@ -768,18 +765,17 @@ static int r128_freelist_init(struct drm_device * dev)
        drm_r128_freelist_t *entry;
        int i;
 
-       dev_priv->head = drm_alloc(sizeof(drm_r128_freelist_t), DRM_MEM_DRIVER);
+       dev_priv->head = kzalloc(sizeof(drm_r128_freelist_t), GFP_KERNEL);
        if (dev_priv->head == NULL)
                return -ENOMEM;
 
-       memset(dev_priv->head, 0, sizeof(drm_r128_freelist_t));
        dev_priv->head->age = R128_BUFFER_USED;
 
        for (i = 0; i < dma->buf_count; i++) {
                buf = dma->buflist[i];
                buf_priv = buf->dev_private;
 
-               entry = drm_alloc(sizeof(drm_r128_freelist_t), DRM_MEM_DRIVER);
+               entry = kmalloc(sizeof(drm_r128_freelist_t), GFP_KERNEL);
                if (!entry)
                        return -ENOMEM;
 
index f7a5b57..026a48c 100644 (file)
@@ -910,24 +910,24 @@ static int r128_cce_dispatch_write_span(struct drm_device * dev,
        }
 
        buffer_size = depth->n * sizeof(u32);
-       buffer = drm_alloc(buffer_size, DRM_MEM_BUFS);
+       buffer = kmalloc(buffer_size, GFP_KERNEL);
        if (buffer == NULL)
                return -ENOMEM;
        if (DRM_COPY_FROM_USER(buffer, depth->buffer, buffer_size)) {
-               drm_free(buffer, buffer_size, DRM_MEM_BUFS);
+               kfree(buffer);
                return -EFAULT;
        }
 
        mask_size = depth->n * sizeof(u8);
        if (depth->mask) {
-               mask = drm_alloc(mask_size, DRM_MEM_BUFS);
+               mask = kmalloc(mask_size, GFP_KERNEL);
                if (mask == NULL) {
-                       drm_free(buffer, buffer_size, DRM_MEM_BUFS);
+                       kfree(buffer);
                        return -ENOMEM;
                }
                if (DRM_COPY_FROM_USER(mask, depth->mask, mask_size)) {
-                       drm_free(buffer, buffer_size, DRM_MEM_BUFS);
-                       drm_free(mask, mask_size, DRM_MEM_BUFS);
+                       kfree(buffer);
+                       kfree(mask);
                        return -EFAULT;
                }
 
@@ -954,7 +954,7 @@ static int r128_cce_dispatch_write_span(struct drm_device * dev,
                        }
                }
 
-               drm_free(mask, mask_size, DRM_MEM_BUFS);
+               kfree(mask);
        } else {
                for (i = 0; i < count; i++, x++) {
                        BEGIN_RING(6);
@@ -978,7 +978,7 @@ static int r128_cce_dispatch_write_span(struct drm_device * dev,
                }
        }
 
-       drm_free(buffer, buffer_size, DRM_MEM_BUFS);
+       kfree(buffer);
 
        return 0;
 }
@@ -1000,54 +1000,54 @@ static int r128_cce_dispatch_write_pixels(struct drm_device * dev,
 
        xbuf_size = count * sizeof(*x);
        ybuf_size = count * sizeof(*y);
-       x = drm_alloc(xbuf_size, DRM_MEM_BUFS);
+       x = kmalloc(xbuf_size, GFP_KERNEL);
        if (x == NULL) {
                return -ENOMEM;
        }
-       y = drm_alloc(ybuf_size, DRM_MEM_BUFS);
+       y = kmalloc(ybuf_size, GFP_KERNEL);
        if (y == NULL) {
-               drm_free(x, xbuf_size, DRM_MEM_BUFS);
+               kfree(x);
                return -ENOMEM;
        }
        if (DRM_COPY_FROM_USER(x, depth->x, xbuf_size)) {
-               drm_free(x, xbuf_size, DRM_MEM_BUFS);
-               drm_free(y, ybuf_size, DRM_MEM_BUFS);
+               kfree(x);
+               kfree(y);
                return -EFAULT;
        }
        if (DRM_COPY_FROM_USER(y, depth->y, xbuf_size)) {
-               drm_free(x, xbuf_size, DRM_MEM_BUFS);
-               drm_free(y, ybuf_size, DRM_MEM_BUFS);
+               kfree(x);
+               kfree(y);
                return -EFAULT;
        }
 
        buffer_size = depth->n * sizeof(u32);
-       buffer = drm_alloc(buffer_size, DRM_MEM_BUFS);
+       buffer = kmalloc(buffer_size, GFP_KERNEL);
        if (buffer == NULL) {
-               drm_free(x, xbuf_size, DRM_MEM_BUFS);
-               drm_free(y, ybuf_size, DRM_MEM_BUFS);
+               kfree(x);
+               kfree(y);
                return -ENOMEM;
        }
        if (DRM_COPY_FROM_USER(buffer, depth->buffer, buffer_size)) {
-               drm_free(x, xbuf_size, DRM_MEM_BUFS);
-               drm_free(y, ybuf_size, DRM_MEM_BUFS);
-               drm_free(buffer, buffer_size, DRM_MEM_BUFS);
+               kfree(x);
+               kfree(y);
+               kfree(buffer);
                return -EFAULT;
        }
 
        if (depth->mask) {
                mask_size = depth->n * sizeof(u8);
-               mask = drm_alloc(mask_size, DRM_MEM_BUFS);
+               mask = kmalloc(mask_size, GFP_KERNEL);
                if (mask == NULL) {
-                       drm_free(x, xbuf_size, DRM_MEM_BUFS);
-                       drm_free(y, ybuf_size, DRM_MEM_BUFS);
-                       drm_free(buffer, buffer_size, DRM_MEM_BUFS);
+                       kfree(x);
+                       kfree(y);
+                       kfree(buffer);
                        return -ENOMEM;
                }
                if (DRM_COPY_FROM_USER(mask, depth->mask, mask_size)) {
-                       drm_free(x, xbuf_size, DRM_MEM_BUFS);
-                       drm_free(y, ybuf_size, DRM_MEM_BUFS);
-                       drm_free(buffer, buffer_size, DRM_MEM_BUFS);
-                       drm_free(mask, mask_size, DRM_MEM_BUFS);
+                       kfree(x);
+                       kfree(y);
+                       kfree(buffer);
+                       kfree(mask);
                        return -EFAULT;
                }
 
@@ -1074,7 +1074,7 @@ static int r128_cce_dispatch_write_pixels(struct drm_device * dev,
                        }
                }
 
-               drm_free(mask, mask_size, DRM_MEM_BUFS);
+               kfree(mask);
        } else {
                for (i = 0; i < count; i++) {
                        BEGIN_RING(6);
@@ -1098,9 +1098,9 @@ static int r128_cce_dispatch_write_pixels(struct drm_device * dev,
                }
        }
 
-       drm_free(x, xbuf_size, DRM_MEM_BUFS);
-       drm_free(y, ybuf_size, DRM_MEM_BUFS);
-       drm_free(buffer, buffer_size, DRM_MEM_BUFS);
+       kfree(x);
+       kfree(y);
+       kfree(buffer);
 
        return 0;
 }
@@ -1167,23 +1167,23 @@ static int r128_cce_dispatch_read_pixels(struct drm_device * dev,
 
        xbuf_size = count * sizeof(*x);
        ybuf_size = count * sizeof(*y);
-       x = drm_alloc(xbuf_size, DRM_MEM_BUFS);
+       x = kmalloc(xbuf_size, GFP_KERNEL);
        if (x == NULL) {
                return -ENOMEM;
        }
-       y = drm_alloc(ybuf_size, DRM_MEM_BUFS);
+       y = kmalloc(ybuf_size, GFP_KERNEL);
        if (y == NULL) {
-               drm_free(x, xbuf_size, DRM_MEM_BUFS);
+               kfree(x);
                return -ENOMEM;
        }
        if (DRM_COPY_FROM_USER(x, depth->x, xbuf_size)) {
-               drm_free(x, xbuf_size, DRM_MEM_BUFS);
-               drm_free(y, ybuf_size, DRM_MEM_BUFS);
+               kfree(x);
+               kfree(y);
                return -EFAULT;
        }
        if (DRM_COPY_FROM_USER(y, depth->y, ybuf_size)) {
-               drm_free(x, xbuf_size, DRM_MEM_BUFS);
-               drm_free(y, ybuf_size, DRM_MEM_BUFS);
+               kfree(x);
+               kfree(y);
                return -EFAULT;
        }
 
@@ -1210,8 +1210,8 @@ static int r128_cce_dispatch_read_pixels(struct drm_device * dev,
                ADVANCE_RING();
        }
 
-       drm_free(x, xbuf_size, DRM_MEM_BUFS);
-       drm_free(y, ybuf_size, DRM_MEM_BUFS);
+       kfree(x);
+       kfree(y);
 
        return 0;
 }
index 89c4c44..d835682 100644 (file)
@@ -2045,11 +2045,10 @@ int radeon_driver_load(struct drm_device *dev, unsigned long flags)
        drm_radeon_private_t *dev_priv;
        int ret = 0;
 
-       dev_priv = drm_alloc(sizeof(drm_radeon_private_t), DRM_MEM_DRIVER);
+       dev_priv = kzalloc(sizeof(drm_radeon_private_t), GFP_KERNEL);
        if (dev_priv == NULL)
                return -ENOMEM;
 
-       memset(dev_priv, 0, sizeof(drm_radeon_private_t));
        dev->dev_private = (void *)dev_priv;
        dev_priv->flags = flags;
 
@@ -2103,7 +2102,7 @@ int radeon_master_create(struct drm_device *dev, struct drm_master *master)
        unsigned long sareapage;
        int ret;
 
-       master_priv = drm_calloc(1, sizeof(*master_priv), DRM_MEM_DRIVER);
+       master_priv = kzalloc(sizeof(*master_priv), GFP_KERNEL);
        if (!master_priv)
                return -ENOMEM;
 
@@ -2137,7 +2136,7 @@ void radeon_master_destroy(struct drm_device *dev, struct drm_master *master)
        if (master_priv->sarea)
                drm_rmmap_locked(dev, master_priv->sarea);
 
-       drm_free(master_priv, sizeof(*master_priv), DRM_MEM_DRIVER);
+       kfree(master_priv);
 
        master->driver_priv = NULL;
 }
@@ -2171,7 +2170,7 @@ int radeon_driver_unload(struct drm_device *dev)
 
        drm_rmmap(dev, dev_priv->mmio);
 
-       drm_free(dev_priv, sizeof(*dev_priv), DRM_MEM_DRIVER);
+       kfree(dev_priv);
 
        dev->dev_private = NULL;
        return 0;
index 71465ed..dd438d3 100644 (file)
@@ -162,7 +162,7 @@ struct radeon_i2c_chan *radeon_i2c_create(struct drm_device *dev,
        struct radeon_i2c_chan *i2c;
        int ret;
 
-       i2c = drm_calloc(1, sizeof(struct radeon_i2c_chan), DRM_MEM_DRIVER);
+       i2c = kzalloc(sizeof(struct radeon_i2c_chan), GFP_KERNEL);
        if (i2c == NULL)
                return NULL;
 
@@ -189,7 +189,7 @@ struct radeon_i2c_chan *radeon_i2c_create(struct drm_device *dev,
 
        return i2c;
 out_free:
-       drm_free(i2c, sizeof(struct radeon_i2c_chan), DRM_MEM_DRIVER);
+       kfree(i2c);
        return NULL;
 
 }
@@ -200,7 +200,7 @@ void radeon_i2c_destroy(struct radeon_i2c_chan *i2c)
                return;
 
        i2c_del_adapter(&i2c->adapter);
-       drm_free(i2c, sizeof(struct radeon_i2c_chan), DRM_MEM_DRIVER);
+       kfree(i2c);
 }
 
 struct drm_encoder *radeon_best_encoder(struct drm_connector *connector)
index 64f42b1..4612a7c 100644 (file)
@@ -169,7 +169,7 @@ int radeon_master_create_kms(struct drm_device *dev, struct drm_master *master)
        unsigned long sareapage;
        int ret;
 
-       master_priv = drm_calloc(1, sizeof(*master_priv), DRM_MEM_DRIVER);
+       master_priv = kzalloc(sizeof(*master_priv), GFP_KERNEL);
        if (master_priv == NULL) {
                return -ENOMEM;
        }
@@ -199,7 +199,7 @@ void radeon_master_destroy_kms(struct drm_device *dev,
        if (master_priv->sarea) {
                drm_rmmap_locked(dev, master_priv->sarea);
        }
-       drm_free(master_priv, sizeof(*master_priv), DRM_MEM_DRIVER);
+       kfree(master_priv);
        master->driver_priv = NULL;
 }
 
index 4af5286..ed95155 100644 (file)
@@ -43,8 +43,8 @@ static struct mem_block *split_block(struct mem_block *p, int start, int size,
 {
        /* Maybe cut off the start of an existing block */
        if (start > p->start) {
-               struct mem_block *newblock =
-                   drm_alloc(sizeof(*newblock), DRM_MEM_BUFS);
+               struct mem_block *newblock = kmalloc(sizeof(*newblock),
+                                                    GFP_KERNEL);
                if (!newblock)
                        goto out;
                newblock->start = start;
@@ -60,8 +60,8 @@ static struct mem_block *split_block(struct mem_block *p, int start, int size,
 
        /* Maybe cut off the end of an existing block */
        if (size < p->size) {
-               struct mem_block *newblock =
-                   drm_alloc(sizeof(*newblock), DRM_MEM_BUFS);
+               struct mem_block *newblock = kmalloc(sizeof(*newblock),
+                                                    GFP_KERNEL);
                if (!newblock)
                        goto out;
                newblock->start = start + size;
@@ -118,7 +118,7 @@ static void free_block(struct mem_block *p)
                p->size += q->size;
                p->next = q->next;
                p->next->prev = p;
-               drm_free(q, sizeof(*q), DRM_MEM_BUFS);
+               kfree(q);
        }
 
        if (p->prev->file_priv == NULL) {
@@ -126,7 +126,7 @@ static void free_block(struct mem_block *p)
                q->size += p->size;
                q->next = p->next;
                q->next->prev = q;
-               drm_free(p, sizeof(*q), DRM_MEM_BUFS);
+               kfree(p);
        }
 }
 
@@ -134,14 +134,14 @@ static void free_block(struct mem_block *p)
  */
 static int init_heap(struct mem_block **heap, int start, int size)
 {
-       struct mem_block *blocks = drm_alloc(sizeof(*blocks), DRM_MEM_BUFS);
+       struct mem_block *blocks = kmalloc(sizeof(*blocks), GFP_KERNEL);
 
        if (!blocks)
                return -ENOMEM;
 
-       *heap = drm_alloc(sizeof(**heap), DRM_MEM_BUFS);
+       *heap = kmalloc(sizeof(**heap), GFP_KERNEL);
        if (!*heap) {
-               drm_free(blocks, sizeof(*blocks), DRM_MEM_BUFS);
+               kfree(blocks);
                return -ENOMEM;
        }
 
@@ -179,7 +179,7 @@ void radeon_mem_release(struct drm_file *file_priv, struct mem_block *heap)
                        p->size += q->size;
                        p->next = q->next;
                        p->next->prev = p;
-                       drm_free(q, sizeof(*q), DRM_MEM_DRIVER);
+                       kfree(q);
                }
        }
 }
@@ -196,10 +196,10 @@ void radeon_mem_takedown(struct mem_block **heap)
        for (p = (*heap)->next; p != *heap;) {
                struct mem_block *q = p;
                p = p->next;
-               drm_free(q, sizeof(*q), DRM_MEM_DRIVER);
+               kfree(q);
        }
 
-       drm_free(*heap, sizeof(**heap), DRM_MEM_DRIVER);
+       kfree(*heap);
        *heap = NULL;
 }
 
index fa728ec..46645f3 100644 (file)
@@ -2866,12 +2866,12 @@ static int radeon_cp_cmdbuf(struct drm_device *dev, void *data, struct drm_file
         */
        orig_bufsz = cmdbuf->bufsz;
        if (orig_bufsz != 0) {
-               kbuf = drm_alloc(cmdbuf->bufsz, DRM_MEM_DRIVER);
+               kbuf = kmalloc(cmdbuf->bufsz, GFP_KERNEL);
                if (kbuf == NULL)
                        return -ENOMEM;
                if (DRM_COPY_FROM_USER(kbuf, (void __user *)cmdbuf->buf,
                                       cmdbuf->bufsz)) {
-                       drm_free(kbuf, orig_bufsz, DRM_MEM_DRIVER);
+                       kfree(kbuf);
                        return -EFAULT;
                }
                cmdbuf->buf = kbuf;
@@ -2884,7 +2884,7 @@ static int radeon_cp_cmdbuf(struct drm_device *dev, void *data, struct drm_file
                temp = r300_do_cp_cmdbuf(dev, file_priv, cmdbuf);
 
                if (orig_bufsz != 0)
-                       drm_free(kbuf, orig_bufsz, DRM_MEM_DRIVER);
+                       kfree(kbuf);
 
                return temp;
        }
@@ -2991,7 +2991,7 @@ static int radeon_cp_cmdbuf(struct drm_device *dev, void *data, struct drm_file
        }
 
        if (orig_bufsz != 0)
-               drm_free(kbuf, orig_bufsz, DRM_MEM_DRIVER);
+               kfree(kbuf);
 
        DRM_DEBUG("DONE\n");
        COMMIT_RING();
@@ -2999,7 +2999,7 @@ static int radeon_cp_cmdbuf(struct drm_device *dev, void *data, struct drm_file
 
       err:
        if (orig_bufsz != 0)
-               drm_free(kbuf, orig_bufsz, DRM_MEM_DRIVER);
+               kfree(kbuf);
        return -EINVAL;
 }
 
@@ -3175,9 +3175,7 @@ int radeon_driver_open(struct drm_device *dev, struct drm_file *file_priv)
        struct drm_radeon_driver_file_fields *radeon_priv;
 
        DRM_DEBUG("\n");
-       radeon_priv =
-           (struct drm_radeon_driver_file_fields *)
-           drm_alloc(sizeof(*radeon_priv), DRM_MEM_FILES);
+       radeon_priv = kmalloc(sizeof(*radeon_priv), GFP_KERNEL);
 
        if (!radeon_priv)
                return -ENOMEM;
@@ -3196,7 +3194,7 @@ void radeon_driver_postclose(struct drm_device *dev, struct drm_file *file_priv)
        struct drm_radeon_driver_file_fields *radeon_priv =
            file_priv->driver_priv;
 
-       drm_free(radeon_priv, sizeof(*radeon_priv), DRM_MEM_FILES);
+       kfree(radeon_priv);
 }
 
 struct drm_ioctl_desc radeon_ioctls[] = {
index 456cd04..bff6fc2 100644 (file)
@@ -298,8 +298,8 @@ static int savage_dma_init(drm_savage_private_t * dev_priv)
 
        dev_priv->nr_dma_pages = dev_priv->cmd_dma->size /
            (SAVAGE_DMA_PAGE_SIZE * 4);
-       dev_priv->dma_pages = drm_alloc(sizeof(drm_savage_dma_page_t) *
-                                       dev_priv->nr_dma_pages, DRM_MEM_DRIVER);
+       dev_priv->dma_pages = kmalloc(sizeof(drm_savage_dma_page_t) *
+                                     dev_priv->nr_dma_pages, GFP_KERNEL);
        if (dev_priv->dma_pages == NULL)
                return -ENOMEM;
 
@@ -539,7 +539,7 @@ int savage_driver_load(struct drm_device *dev, unsigned long chipset)
 {
        drm_savage_private_t *dev_priv;
 
-       dev_priv = drm_alloc(sizeof(drm_savage_private_t), DRM_MEM_DRIVER);
+       dev_priv = kmalloc(sizeof(drm_savage_private_t), GFP_KERNEL);
        if (dev_priv == NULL)
                return -ENOMEM;
 
@@ -671,7 +671,7 @@ int savage_driver_unload(struct drm_device *dev)
 {
        drm_savage_private_t *dev_priv = dev->dev_private;
 
-       drm_free(dev_priv, sizeof(drm_savage_private_t), DRM_MEM_DRIVER);
+       kfree(dev_priv);
 
        return 0;
 }
@@ -804,8 +804,8 @@ static int savage_do_init_bci(struct drm_device * dev, drm_savage_init_t * init)
                dev_priv->fake_dma.offset = 0;
                dev_priv->fake_dma.size = SAVAGE_FAKE_DMA_SIZE;
                dev_priv->fake_dma.type = _DRM_SHM;
-               dev_priv->fake_dma.handle = drm_alloc(SAVAGE_FAKE_DMA_SIZE,
-                                                     DRM_MEM_DRIVER);
+               dev_priv->fake_dma.handle = kmalloc(SAVAGE_FAKE_DMA_SIZE,
+                                                   GFP_KERNEL);
                if (!dev_priv->fake_dma.handle) {
                        DRM_ERROR("could not allocate faked DMA buffer!\n");
                        savage_do_cleanup_bci(dev);
@@ -903,9 +903,7 @@ static int savage_do_cleanup_bci(struct drm_device * dev)
        drm_savage_private_t *dev_priv = dev->dev_private;
 
        if (dev_priv->cmd_dma == &dev_priv->fake_dma) {
-               if (dev_priv->fake_dma.handle)
-                       drm_free(dev_priv->fake_dma.handle,
-                                SAVAGE_FAKE_DMA_SIZE, DRM_MEM_DRIVER);
+               kfree(dev_priv->fake_dma.handle);
        } else if (dev_priv->cmd_dma && dev_priv->cmd_dma->handle &&
                   dev_priv->cmd_dma->type == _DRM_AGP &&
                   dev_priv->dma_type == SAVAGE_DMA_AGP)
@@ -920,10 +918,7 @@ static int savage_do_cleanup_bci(struct drm_device * dev)
                dev->agp_buffer_map = NULL;
        }
 
-       if (dev_priv->dma_pages)
-               drm_free(dev_priv->dma_pages,
-                        sizeof(drm_savage_dma_page_t) * dev_priv->nr_dma_pages,
-                        DRM_MEM_DRIVER);
+       kfree(dev_priv->dma_pages);
 
        return 0;
 }
index 5f6238f..8a3e315 100644 (file)
@@ -988,20 +988,20 @@ int savage_bci_cmdbuf(struct drm_device *dev, void *data, struct drm_file *file_
         * for locking on FreeBSD.
         */
        if (cmdbuf->size) {
-               kcmd_addr = drm_alloc(cmdbuf->size * 8, DRM_MEM_DRIVER);
+               kcmd_addr = kmalloc(cmdbuf->size * 8, GFP_KERNEL);
                if (kcmd_addr == NULL)
                        return -ENOMEM;
 
                if (DRM_COPY_FROM_USER(kcmd_addr, cmdbuf->cmd_addr,
                                       cmdbuf->size * 8))
                {
-                       drm_free(kcmd_addr, cmdbuf->size * 8, DRM_MEM_DRIVER);
+                       kfree(kcmd_addr);
                        return -EFAULT;
                }
                cmdbuf->cmd_addr = kcmd_addr;
        }
        if (cmdbuf->vb_size) {
-               kvb_addr = drm_alloc(cmdbuf->vb_size, DRM_MEM_DRIVER);
+               kvb_addr = kmalloc(cmdbuf->vb_size, GFP_KERNEL);
                if (kvb_addr == NULL) {
                        ret = -ENOMEM;
                        goto done;
@@ -1015,8 +1015,8 @@ int savage_bci_cmdbuf(struct drm_device *dev, void *data, struct drm_file *file_
                cmdbuf->vb_addr = kvb_addr;
        }
        if (cmdbuf->nbox) {
-               kbox_addr = drm_alloc(cmdbuf->nbox * sizeof(struct drm_clip_rect),
-                                      DRM_MEM_DRIVER);
+               kbox_addr = kmalloc(cmdbuf->nbox * sizeof(struct drm_clip_rect),
+                                   GFP_KERNEL);
                if (kbox_addr == NULL) {
                        ret = -ENOMEM;
                        goto done;
@@ -1154,10 +1154,9 @@ int savage_bci_cmdbuf(struct drm_device *dev, void *data, struct drm_file *file_
 
 done:
        /* If we didn't need to allocate them, these'll be NULL */
-       drm_free(kcmd_addr, cmdbuf->size * 8, DRM_MEM_DRIVER);
-       drm_free(kvb_addr, cmdbuf->vb_size, DRM_MEM_DRIVER);
-       drm_free(kbox_addr, cmdbuf->nbox * sizeof(struct drm_clip_rect),
-                DRM_MEM_DRIVER);
+       kfree(kcmd_addr);
+       kfree(kvb_addr);
+       kfree(kbox_addr);
 
        return ret;
 }
index 7dacc64..e725cc0 100644 (file)
@@ -40,7 +40,7 @@ static int sis_driver_load(struct drm_device *dev, unsigned long chipset)
        drm_sis_private_t *dev_priv;
        int ret;
 
-       dev_priv = drm_calloc(1, sizeof(drm_sis_private_t), DRM_MEM_DRIVER);
+       dev_priv = kzalloc(sizeof(drm_sis_private_t), GFP_KERNEL);
        if (dev_priv == NULL)
                return -ENOMEM;
 
@@ -48,7 +48,7 @@ static int sis_driver_load(struct drm_device *dev, unsigned long chipset)
        dev_priv->chipset = chipset;
        ret = drm_sman_init(&dev_priv->sman, 2, 12, 8);
        if (ret) {
-               drm_free(dev_priv, sizeof(dev_priv), DRM_MEM_DRIVER);
+               kfree(dev_priv);
        }
 
        return ret;
@@ -59,7 +59,7 @@ static int sis_driver_unload(struct drm_device *dev)
        drm_sis_private_t *dev_priv = dev->dev_private;
 
        drm_sman_takedown(&dev_priv->sman);
-       drm_free(dev_priv, sizeof(*dev_priv), DRM_MEM_DRIVER);
+       kfree(dev_priv);
 
        return 0;
 }
index 2c4f0b4..6e6f915 100644 (file)
@@ -96,7 +96,7 @@ int via_driver_load(struct drm_device *dev, unsigned long chipset)
        drm_via_private_t *dev_priv;
        int ret = 0;
 
-       dev_priv = drm_calloc(1, sizeof(drm_via_private_t), DRM_MEM_DRIVER);
+       dev_priv = kzalloc(sizeof(drm_via_private_t), GFP_KERNEL);
        if (dev_priv == NULL)
                return -ENOMEM;
 
@@ -106,14 +106,14 @@ int via_driver_load(struct drm_device *dev, unsigned long chipset)
 
        ret = drm_sman_init(&dev_priv->sman, 2, 12, 8);
        if (ret) {
-               drm_free(dev_priv, sizeof(*dev_priv), DRM_MEM_DRIVER);
+               kfree(dev_priv);
                return ret;
        }
 
        ret = drm_vblank_init(dev, 1);
        if (ret) {
                drm_sman_takedown(&dev_priv->sman);
-               drm_free(dev_priv, sizeof(drm_via_private_t), DRM_MEM_DRIVER);
+               kfree(dev_priv);
                return ret;
        }
 
@@ -126,7 +126,7 @@ int via_driver_unload(struct drm_device *dev)
 
        drm_sman_takedown(&dev_priv->sman);
 
-       drm_free(dev_priv, sizeof(drm_via_private_t), DRM_MEM_DRIVER);
+       kfree(dev_priv);
 
        return 0;
 }
index d4ddc22..45b67d9 100644 (file)
@@ -34,9 +34,6 @@
 #ifndef _DRM_P_H_
 #define _DRM_P_H_
 
-/* If you want the memory alloc debug functionality, change define below */
-/* #define DEBUG_MEMORY */
-
 #ifdef __KERNEL__
 #ifdef __alpha__
 /* add include of current.h so that "current" is defined
@@ -133,31 +130,6 @@ extern void drm_ut_debug_printk(unsigned int request_level,
 
 #define DRM_FLAG_DEBUG   0x01
 
-#define DRM_MEM_DMA       0
-#define DRM_MEM_SAREA     1
-#define DRM_MEM_DRIVER    2
-#define DRM_MEM_MAGIC     3
-#define DRM_MEM_IOCTLS    4
-#define DRM_MEM_MAPS      5
-#define DRM_MEM_VMAS      6
-#define DRM_MEM_BUFS      7
-#define DRM_MEM_SEGS      8
-#define DRM_MEM_PAGES     9
-#define DRM_MEM_FILES    10
-#define DRM_MEM_QUEUES   11
-#define DRM_MEM_CMDS     12
-#define DRM_MEM_MAPPINGS  13
-#define DRM_MEM_BUFLISTS  14
-#define DRM_MEM_AGPLISTS  15
-#define DRM_MEM_TOTALAGP  16
-#define DRM_MEM_BOUNDAGP  17
-#define DRM_MEM_CTXBITMAP 18
-#define DRM_MEM_STUB      19
-#define DRM_MEM_SGLISTS   20
-#define DRM_MEM_CTXLIST   21
-#define DRM_MEM_MM        22
-#define DRM_MEM_HASHTAB   23
-
 #define DRM_MAX_CTXBITMAP (PAGE_SIZE * 8)
 #define DRM_MAP_HASH_OFFSET 0x10000000
 
@@ -1517,24 +1489,6 @@ static __inline__ void drm_core_dropmap(struct drm_local_map *map)
 {
 }
 
-#ifndef DEBUG_MEMORY
-/** Wrapper around kmalloc() */
-static __inline__ void *drm_alloc(size_t size, int area)
-{
-       return kmalloc(size, GFP_KERNEL);
-}
-
-/** Wrapper around kfree() */
-static __inline__ void drm_free(void *pt, size_t size, int area)
-{
-       kfree(pt);
-}
-
-/** Wrapper around kcalloc() */
-static __inline__ void *drm_calloc(size_t nmemb, size_t size, int area)
-{
-       return kcalloc(nmemb, size, GFP_KERNEL);
-}
 
 static __inline__ void *drm_calloc_large(size_t nmemb, size_t size)
 {
@@ -1555,12 +1509,6 @@ static __inline void drm_free_large(void *ptr)
 
        vfree(ptr);
 }
-#else
-extern void *drm_alloc(size_t size, int area);
-extern void drm_free(void *pt, size_t size, int area);
-extern void *drm_calloc(size_t nmemb, size_t size, int area);
-#endif
-
 /*@}*/
 
 #endif                         /* __KERNEL__ */
diff --git a/include/drm/drm_memory_debug.h b/include/drm/drm_memory_debug.h
deleted file mode 100644 (file)
index 6463271..0000000
+++ /dev/null
@@ -1,309 +0,0 @@
-/**
- * \file drm_memory_debug.h
- * Memory management wrappers for DRM.
- *
- * \author Rickard E. (Rik) Faith <faith@valinux.com>
- * \author Gareth Hughes <gareth@valinux.com>
- */
-
-/*
- * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
- * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- * OTHER DEALINGS IN THE SOFTWARE.
- */
-
-#include "drmP.h"
-
-typedef struct drm_mem_stats {
-       const char *name;
-       int succeed_count;
-       int free_count;
-       int fail_count;
-       unsigned long bytes_allocated;
-       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[] =
-{
-       [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) {
-       drm_mem_stats_t *mem;
-       struct sysinfo si;
-
-       for (mem = drm_mem_stats; mem->name; ++mem) {
-               mem->succeed_count = 0;
-               mem->free_count = 0;
-               mem->fail_count = 0;
-               mem->bytes_allocated = 0;
-               mem->bytes_freed = 0;
-       }
-
-       si_meminfo(&si);
-       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,
-                          int request, int *eof, void *data) {
-       drm_mem_stats_t *pt;
-       int len = 0;
-
-       if (offset > DRM_PROC_LIMIT) {
-               *eof = 1;
-               return 0;
-       }
-
-       *eof = 0;
-       *start = &buf[offset];
-
-       DRM_PROC_PRINT("                  total counts                  "
-                      " |    outstanding  \n");
-       DRM_PROC_PRINT("type       alloc freed fail     bytes      freed"
-                      " | 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_PROC_PRINT("%-9.9s %5d %5d %4d %10lu kB         |\n",
-                      "locked", 0, 0, 0, drm_ram_used >> 10);
-       DRM_PROC_PRINT("\n");
-       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,
-                              pt->free_count,
-                              pt->fail_count,
-                              pt->bytes_allocated,
-                              pt->bytes_freed,
-                              pt->succeed_count - pt->free_count,
-                              (long)pt->bytes_allocated
-                              - (long)pt->bytes_freed);
-       }
-
-       if (len > request + offset)
-               return request;
-       *eof = 1;
-       return len - 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);
-       return ret;
-}
-
-void *drm_alloc (size_t size, int area) {
-       void *pt;
-
-       if (!size) {
-               DRM_MEM_ERROR(area, "Allocating 0 bytes\n");
-               return NULL;
-       }
-
-       if (!(pt = kmalloc(size, GFP_KERNEL))) {
-               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);
-       return pt;
-}
-
-void *drm_calloc (size_t nmemb, size_t size, int area) {
-       void *addr;
-
-       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 *pt;
-
-       if (!(pt = drm_alloc (size, area)))
-               return NULL;
-       if (oldpt && oldsize) {
-               memcpy(pt, oldpt, oldsize);
-               drm_free (oldpt, oldsize, area);
-       }
-       return pt;
-}
-
-void drm_free (void *pt, size_t size, int area) {
-       int alloc_count;
-       int free_count;
-
-       if (!pt)
-               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);
-       if (free_count > alloc_count) {
-               DRM_MEM_ERROR(area, "Excess frees: %d frees, %d allocs\n",
-                             free_count, alloc_count);
-       }
-}
-
-#if __OS_HAS_AGP
-
-DRM_AGP_MEM *drm_alloc_agp (drm_device_t *dev, int pages, u32 type) {
-       DRM_AGP_MEM *handle;
-
-       if (!pages) {
-               DRM_MEM_ERROR(DRM_MEM_TOTALAGP, "Allocating 0 pages\n");
-               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
-                   += pages << PAGE_SHIFT;
-               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);
-       return NULL;
-}
-
-int drm_free_agp (DRM_AGP_MEM * handle, int pages) {
-       int alloc_count;
-       int free_count;
-       int retval = -EINVAL;
-
-       if (!handle) {
-               DRM_MEM_ERROR(DRM_MEM_TOTALAGP,
-                             "Attempt to free NULL AGP handle\n");
-               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
-                   += pages << PAGE_SHIFT;
-               spin_unlock(&drm_mem_lock);
-               if (free_count > alloc_count) {
-                       DRM_MEM_ERROR(DRM_MEM_TOTALAGP,
-                                     "Excess frees: %d frees, %d allocs\n",
-                                     free_count, alloc_count);
-               }
-               return 0;
-       }
-       return retval;
-}
-
-int drm_bind_agp (DRM_AGP_MEM * handle, unsigned int start) {
-       int retcode = -EINVAL;
-
-       if (!handle) {
-               DRM_MEM_ERROR(DRM_MEM_BOUNDAGP,
-                             "Attempt to bind NULL AGP handle\n");
-               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
-                   += handle->page_count << PAGE_SHIFT;
-               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);
-       return retcode;
-}
-
-int drm_unbind_agp (DRM_AGP_MEM * handle) {
-       int alloc_count;
-       int free_count;
-       int retcode = -EINVAL;
-
-       if (!handle) {
-               DRM_MEM_ERROR(DRM_MEM_BOUNDAGP,
-                             "Attempt to unbind NULL AGP handle\n");
-               return retcode;
-       }
-
-       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
-           += handle->page_count << PAGE_SHIFT;
-       spin_unlock(&drm_mem_lock);
-       if (free_count > alloc_count) {
-               DRM_MEM_ERROR(DRM_MEM_BOUNDAGP,
-                             "Excess frees: %d frees, %d allocs\n",
-                             free_count, alloc_count);
-       }
-       return retcode;
-}
-#endif