Convert BSD code to mostly use bus_dma, the dma abstraction for dealing

    with IOMMUs and such. There is one usage of the forbidden vtophys()
    left in drm_scatter.c which will be fixed up soon. This required a KPI
    change for drm_pci_alloc/free() to return/use a drm_dma_handle_t that
    keeps track of os-specific bits, rather than just passing around the
    vaddr/busaddr/size.
Submitted by: Tonnerre Lombard (partially) Tested on: FreeBSD: Rage128
    AGP/PCI Linux: Savage4 AGP/PCI

4 files changed, 29 insertions, 29 deletions

diff --git a/shared-core/i915_dma.c b/shared-core/i915_dma.c
index ac96f37d..9c27706b 100644
--- a/shared-core/i915_dma.c
+++ b/shared-core/i915_dma.c
@@ -75,9 +75,8 @@ static int i915_dma_cleanup(drm_device_t * dev)
 			drm_core_ioremapfree(&dev_priv->ring.map, dev);
 		}
 
-		if (dev_priv->hw_status_page) {
-			drm_pci_free(dev, PAGE_SIZE, dev_priv->hw_status_page,
-				     dev_priv->dma_status_page);
+		if (dev_priv->status_page_dmah) {
+			drm_pci_free(dev, dev_priv->status_page_dmah);
 			/* Need to rewrite hardware status page */
 			I915_WRITE(0x02080, 0x1ffff000);
 		}
@@ -154,15 +153,18 @@ static int i915_initialize(drm_device_t * dev,
 	dev_priv->allow_batchbuffer = 1;
 
 	/* Program Hardware Status Page */
-	dev_priv->hw_status_page = drm_pci_alloc(dev, PAGE_SIZE, PAGE_SIZE, 
-	    0xffffffff, &dev_priv->dma_status_page);
+	dev_priv->status_page_dmah = drm_pci_alloc(dev, PAGE_SIZE, PAGE_SIZE, 
+	    0xffffffff);
 
-	if (!dev_priv->hw_status_page) {
+	if (!dev_priv->status_page_dmah) {
 		dev->dev_private = (void *)dev_priv;
 		i915_dma_cleanup(dev);
 		DRM_ERROR("Can not allocate hardware status page\n");
 		return DRM_ERR(ENOMEM);
 	}
+	dev_priv->hw_status_page = dev_priv->status_page_dmah->vaddr;
+	dev_priv->dma_status_page = dev_priv->status_page_dmah->busaddr;
+	
 	memset(dev_priv->hw_status_page, 0, PAGE_SIZE);
 	DRM_DEBUG("hw status page @ %p\n", dev_priv->hw_status_page);
 
diff --git a/shared-core/i915_drv.h b/shared-core/i915_drv.h
index a4294159..b9615341 100644
--- a/shared-core/i915_drv.h
+++ b/shared-core/i915_drv.h
@@ -55,9 +55,10 @@ typedef struct drm_i915_private {
 	drm_i915_sarea_t *sarea_priv;
 	drm_i915_ring_buffer_t ring;
 
+	drm_dma_handle_t *status_page_dmah;
 	void *hw_status_page;
-	unsigned long counter;
 	dma_addr_t dma_status_page;
+	unsigned long counter;
 
 	int back_offset;
 	int front_offset;
diff --git a/shared-core/mach64_dma.c b/shared-core/mach64_dma.c
index b32dde2b..d7e97a99 100644
--- a/shared-core/mach64_dma.c
+++ b/shared-core/mach64_dma.c
@@ -575,8 +575,7 @@ void mach64_dump_ring_info(drm_mach64_private_t * dev_priv)
 static int mach64_bm_dma_test(drm_device_t * dev)
 {
 	drm_mach64_private_t *dev_priv = dev->dev_private;
-	dma_addr_t data_handle;
-	void *cpu_addr_data;
+	drm_dma_handle_t *cpu_addr_dmah;
 	u32 data_addr;
 	u32 *table, *data;
 	u32 expected[2];
@@ -589,14 +588,14 @@ static int mach64_bm_dma_test(drm_device_t * dev)
 
 	/* FIXME: get a dma buffer from the freelist here */
 	DRM_DEBUG("Allocating data memory ...\n");
-	cpu_addr_data =
-	    drm_pci_alloc(dev, 0x1000, 0x1000, 0xfffffffful, &data_handle);
-	if (!cpu_addr_data || !data_handle) {
+	cpu_addr_dmah =
+	    drm_pci_alloc(dev, 0x1000, 0x1000, 0xfffffffful);
+	if (!cpu_addr_dmah) {
 		DRM_INFO("data-memory allocation failed!\n");
 		return DRM_ERR(ENOMEM);
 	} else {
-		data = (u32 *) cpu_addr_data;
-		data_addr = (u32) data_handle;
+		data = (u32 *) cpu_addr_dmah->vaddr;
+		data_addr = (u32) cpu_addr_dmah->busaddr;
 	}
 
 	/* Save the X server's value for SRC_CNTL and restore it
@@ -624,7 +623,7 @@ static int mach64_bm_dma_test(drm_device_t * dev)
 			DRM_INFO("resetting engine ...\n");
 			mach64_do_engine_reset(dev_priv);
 			DRM_INFO("freeing data buffer memory.\n");
-			drm_pci_free(dev, 0x1000, cpu_addr_data, data_handle);
+			drm_pci_free(dev, cpu_addr_dmah);
 			return DRM_ERR(EIO);
 		}
 	}
@@ -679,7 +678,7 @@ static int mach64_bm_dma_test(drm_device_t * dev)
 		MACH64_WRITE(MACH64_PAT_REG0, pat_reg0);
 		MACH64_WRITE(MACH64_PAT_REG1, pat_reg1);
 		DRM_INFO("freeing data buffer memory.\n");
-		drm_pci_free(dev, 0x1000, cpu_addr_data, data_handle);
+		drm_pci_free(dev, cpu_addr_dmah);
 		return i;
 	}
 	DRM_DEBUG("waiting for idle...done\n");
@@ -715,7 +714,7 @@ static int mach64_bm_dma_test(drm_device_t * dev)
 		MACH64_WRITE(MACH64_PAT_REG0, pat_reg0);
 		MACH64_WRITE(MACH64_PAT_REG1, pat_reg1);
 		DRM_INFO("freeing data buffer memory.\n");
-		drm_pci_free(dev, 0x1000, cpu_addr_data, data_handle);
+		drm_pci_free(dev, cpu_addr_dmah);
 		return i;
 	}
 
@@ -743,7 +742,7 @@ static int mach64_bm_dma_test(drm_device_t * dev)
 	MACH64_WRITE(MACH64_PAT_REG1, pat_reg1);
 
 	DRM_DEBUG("freeing data buffer memory.\n");
-	drm_pci_free(dev, 0x1000, cpu_addr_data, data_handle);
+	drm_pci_free(dev, cpu_addr_dmah);
 	DRM_DEBUG("returning ...\n");
 
 	return failed;
@@ -896,16 +895,17 @@ static int mach64_do_dma_init(drm_device_t * dev, drm_mach64_init_t * init)
 	dev_priv->ring.size = 0x4000;	/* 16KB */
 
 	if (dev_priv->is_pci) {
-		dev_priv->ring.start = drm_pci_alloc(dev, dev_priv->ring.size,
+		dev_priv->ring.dmah = drm_pci_alloc(dev, dev_priv->ring.size,
 						     dev_priv->ring.size,
-						     0xfffffffful,
-						     &dev_priv->ring.handle);
+						     0xfffffffful);
 
-		if (!dev_priv->ring.start || !dev_priv->ring.handle) {
+		if (!dev_priv->ring.dmah) {
 			DRM_ERROR("Allocating dma descriptor ring failed\n");
 			return DRM_ERR(ENOMEM);
 		} else {
-			dev_priv->ring.start_addr = (u32) dev_priv->ring.handle;
+			dev_priv->ring.start = dev_priv->ring.dmah->vaddr;
+			dev_priv->ring.start_addr =
+			    (u32) dev_priv->ring.dmah->busaddr;
 		}
 	} else {
 		dev_priv->ring.start = dev_priv->ring_map->handle;
@@ -1149,11 +1149,8 @@ int mach64_do_cleanup_dma(drm_device_t * dev)
 		drm_mach64_private_t *dev_priv = dev->dev_private;
 
 		if (dev_priv->is_pci) {
-			if ((dev_priv->ring.start != NULL)
-			    && dev_priv->ring.handle) {
-				drm_pci_free(dev, dev_priv->ring.size,
-					     dev_priv->ring.start,
-					     dev_priv->ring.handle);
+			if (dev_priv->ring.dmah) {
+				drm_pci_free(dev, dev_priv->ring.dmah);
 			}
 		} else {
 			if (dev_priv->ring_map)
diff --git a/shared-core/mach64_drv.h b/shared-core/mach64_drv.h
index 698a6a51..fb3deb2f 100644
--- a/shared-core/mach64_drv.h
+++ b/shared-core/mach64_drv.h
@@ -60,7 +60,7 @@ typedef struct drm_mach64_freelist {
 } drm_mach64_freelist_t;
 
 typedef struct drm_mach64_descriptor_ring {
-	dma_addr_t handle;	/* handle (bus address) of ring returned by pci_alloc_consistent() */
+	drm_dma_handle_t *dmah;	/* Handle to pci dma memory */
 	void *start;		/* write pointer (cpu address) to start of descriptor ring */
 	u32 start_addr;		/* bus address of beginning of descriptor ring */
 	int size;		/* size of ring in bytes */