drm: Remove memory debugging infrastructure.

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>

2 files changed, 16 insertions, 22 deletions

diff --git a/drivers/gpu/drm/savage/savage_bci.c b/drivers/gpu/drm/savage/savage_bci.c
index 456cd040f31a..bff6fc2524c8 100644
--- a/drivers/gpu/drm/savage/savage_bci.c
+++ b/drivers/gpu/drm/savage/savage_bci.c
@@ -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;
 }
diff --git a/drivers/gpu/drm/savage/savage_state.c b/drivers/gpu/drm/savage/savage_state.c
index 5f6238fdf1fa..8a3e31599c94 100644
--- a/drivers/gpu/drm/savage/savage_state.c
+++ b/drivers/gpu/drm/savage/savage_state.c
@@ -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;
 }