Converts the remaining drm_agp_foo functions to be a drm_agp_foo and

    drm_agp_foo_ioctl pair. Modifies the MGA DRM to use the drm_agp_foo
    functions instead of the drm_foo_agp functions. The drm_foo_agp
    functions are no longer exported by drm.ko.
Ensures that dma->seg_count and dma->page_count are properly set in
    drm_addbufs_{agp,sg,fb}. drm_addbufs_pci was already correct.
Ensures that mga_do_agp_dma_bootstrap correctly sets agp_buffer_token.
At this point PCI DMA is still broken.
Xorg bug: #4797 Reviewed by: Dave Airlie, Eric Anholt Signed-off-by: Ian
    Romanick <idr@us.ibm.com>

diff --git a/linux-core/drmP.h b/linux-core/drmP.h
index 2836713..c0ac922 100644 (file)
--- a/linux-core/drmP.h
+++ b/linux-core/drmP.h
@@ -938,13 +938,17 @@ extern int drm_agp_enable_ioctl(struct inode *inode, struct file *filp,
 extern int drm_agp_info(drm_device_t * dev, drm_agp_info_t *info);
 extern int drm_agp_info_ioctl(struct inode *inode, struct file *filp,
                        unsigned int cmd, unsigned long arg);
-extern int drm_agp_alloc(struct inode *inode, struct file *filp,
+extern int drm_agp_alloc(drm_device_t *dev, drm_agp_buffer_t *request);
+extern int drm_agp_alloc_ioctl(struct inode *inode, struct file *filp,
                         unsigned int cmd, unsigned long arg);
-extern int drm_agp_free(struct inode *inode, struct file *filp,
+extern int drm_agp_free(drm_device_t *dev, drm_agp_buffer_t *request);
+extern int drm_agp_free_ioctl(struct inode *inode, struct file *filp,
                        unsigned int cmd, unsigned long arg);
-extern int drm_agp_unbind(struct inode *inode, struct file *filp,
+extern int drm_agp_unbind(drm_device_t *dev, drm_agp_binding_t *request);
+extern int drm_agp_unbind_ioctl(struct inode *inode, struct file *filp,
                          unsigned int cmd, unsigned long arg);
-extern int drm_agp_bind(struct inode *inode, struct file *filp,
+extern int drm_agp_bind(drm_device_t *dev, drm_agp_binding_t *request);
+extern int drm_agp_bind_ioctl(struct inode *inode, struct file *filp,
                        unsigned int cmd, unsigned long arg);
 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,11)
 extern DRM_AGP_MEM *drm_agp_allocate_memory(size_t pages, u32 type);

diff --git a/linux-core/drm_agpsupport.c b/linux-core/drm_agpsupport.c
index 078c912..572d7a0 100644 (file)
--- a/linux-core/drm_agpsupport.c
+++ b/linux-core/drm_agpsupport.c
@@ -228,29 +228,22 @@ int drm_agp_enable_ioctl(struct inode *inode, struct file *filp,
  * Verifies the AGP device is present and has been acquired, allocates the
  * memory via alloc_agp() and creates a drm_agp_mem entry for it.
  */
-int drm_agp_alloc(struct inode *inode, struct file *filp,
-                 unsigned int cmd, unsigned long arg)
+int drm_agp_alloc(drm_device_t *dev, drm_agp_buffer_t *request)
 {
-       drm_file_t *priv = filp->private_data;
-       drm_device_t *dev = priv->head->dev;
-       drm_agp_buffer_t request;
        drm_agp_mem_t *entry;
        DRM_AGP_MEM *memory;
        unsigned long pages;
        u32 type;
-       drm_agp_buffer_t __user *argp = (void __user *)arg;
 
        if (!dev->agp || !dev->agp->acquired)
                return -EINVAL;
-       if (copy_from_user(&request, argp, sizeof(request)))
-               return -EFAULT;
        if (!(entry = drm_alloc(sizeof(*entry), DRM_MEM_AGPLISTS)))
                return -ENOMEM;
 
        memset(entry, 0, sizeof(*entry));
 
-       pages = (request.size + PAGE_SIZE - 1) / PAGE_SIZE;
-       type = (u32) request.type;
+       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);
                return -ENOMEM;
@@ -266,16 +259,40 @@ int drm_agp_alloc(struct inode *inode, struct file *filp,
                dev->agp->memory->prev = entry;
        dev->agp->memory = entry;
 
-       request.handle = entry->handle;
-       request.physical = memory->physical;
+       request->handle = entry->handle;
+       request->physical = memory->physical;
+
+       return 0;
+}
+EXPORT_SYMBOL(drm_agp_alloc);
+
+
+int drm_agp_alloc_ioctl(struct inode *inode, struct file *filp,
+                       unsigned int cmd, unsigned long arg)
+{
+       drm_file_t *priv = filp->private_data;
+       drm_device_t *dev = priv->head->dev;
+       drm_agp_buffer_t request;
+       drm_agp_buffer_t __user *argp = (void __user *)arg;
+       int err;
+
+       if (copy_from_user(&request, argp, sizeof(request)))
+               return -EFAULT;
+
+       err = drm_agp_alloc(dev, &request);
+       if (err)
+               return err;
 
        if (copy_to_user(argp, &request, sizeof(request))) {
+               drm_agp_mem_t *entry = dev->agp->memory;
+
                dev->agp->memory = entry->next;
                dev->agp->memory->prev = NULL;
-               drm_free_agp(memory, pages);
+               drm_free_agp(entry->memory, entry->pages);
                drm_free(entry, sizeof(*entry), DRM_MEM_AGPLISTS);
                return -EFAULT;
        }
+
        return 0;
 }
 
@@ -312,21 +329,14 @@ static drm_agp_mem_t *drm_agp_lookup_entry(drm_device_t * dev,
  * Verifies the AGP device is present and acquired, looks-up the AGP memory
  * entry and passes it to the unbind_agp() function.
  */
-int drm_agp_unbind(struct inode *inode, struct file *filp,
-                  unsigned int cmd, unsigned long arg)
+int drm_agp_unbind(drm_device_t *dev, drm_agp_binding_t *request)
 {
-       drm_file_t *priv = filp->private_data;
-       drm_device_t *dev = priv->head->dev;
-       drm_agp_binding_t request;
        drm_agp_mem_t *entry;
        int ret;
 
        if (!dev->agp || !dev->agp->acquired)
                return -EINVAL;
-       if (copy_from_user
-           (&request, (drm_agp_binding_t __user *) arg, sizeof(request)))
-               return -EFAULT;
-       if (!(entry = drm_agp_lookup_entry(dev, request.handle)))
+       if (!(entry = drm_agp_lookup_entry(dev, request->handle)))
                return -EINVAL;
        if (!entry->bound)
                return -EINVAL;
@@ -335,6 +345,23 @@ int drm_agp_unbind(struct inode *inode, struct file *filp,
                entry->bound = 0;
        return ret;
 }
+EXPORT_SYMBOL(drm_agp_unbind);
+
+
+int drm_agp_unbind_ioctl(struct inode *inode, struct file *filp,
+                        unsigned int cmd, unsigned long arg)
+{
+       drm_file_t *priv = filp->private_data;
+       drm_device_t *dev = priv->head->dev;
+       drm_agp_binding_t request;
+
+       if (copy_from_user
+           (&request, (drm_agp_binding_t __user *) arg, sizeof(request)))
+               return -EFAULT;
+
+       return drm_agp_unbind(dev, &request);
+}
+
 
 /**
  * Bind AGP memory into the GATT (ioctl)
@@ -349,26 +376,19 @@ int drm_agp_unbind(struct inode *inode, struct file *filp,
  * is currently bound into the GATT. Looks-up the AGP memory entry and passes
  * it to bind_agp() function.
  */
-int drm_agp_bind(struct inode *inode, struct file *filp,
-                unsigned int cmd, unsigned long arg)
+int drm_agp_bind(drm_device_t *dev, drm_agp_binding_t *request)
 {
-       drm_file_t *priv = filp->private_data;
-       drm_device_t *dev = priv->head->dev;
-       drm_agp_binding_t request;
        drm_agp_mem_t *entry;
        int retcode;
        int page;
 
        if (!dev->agp || !dev->agp->acquired)
                return -EINVAL;
-       if (copy_from_user
-           (&request, (drm_agp_binding_t __user *) arg, sizeof(request)))
-               return -EFAULT;
-       if (!(entry = drm_agp_lookup_entry(dev, request.handle)))
+       if (!(entry = drm_agp_lookup_entry(dev, request->handle)))
                return -EINVAL;
        if (entry->bound)
                return -EINVAL;
-       page = (request.offset + PAGE_SIZE - 1) / PAGE_SIZE;
+       page = (request->offset + PAGE_SIZE - 1) / PAGE_SIZE;
        if ((retcode = drm_bind_agp(entry->memory, page)))
                return retcode;
        entry->bound = dev->agp->base + (page << PAGE_SHIFT);
@@ -376,6 +396,23 @@ int drm_agp_bind(struct inode *inode, struct file *filp,
                  dev->agp->base, entry->bound);
        return 0;
 }
+EXPORT_SYMBOL(drm_agp_bind);
+
+
+int drm_agp_bind_ioctl(struct inode *inode, struct file *filp,
+                      unsigned int cmd, unsigned long arg)
+{
+       drm_file_t *priv = filp->private_data;
+       drm_device_t *dev = priv->head->dev;
+       drm_agp_binding_t request;
+
+       if (copy_from_user
+           (&request, (drm_agp_binding_t __user *) arg, sizeof(request)))
+               return -EFAULT;
+
+       return drm_agp_bind(dev, &request);
+}
+
 
 /**
  * Free AGP memory (ioctl).
@@ -391,20 +428,13 @@ int drm_agp_bind(struct inode *inode, struct file *filp,
  * unbind_agp(). Frees it via free_agp() as well as the entry itself
  * and unlinks from the doubly linked list it's inserted in.
  */
-int drm_agp_free(struct inode *inode, struct file *filp,
-                unsigned int cmd, unsigned long arg)
+int drm_agp_free(drm_device_t *dev, drm_agp_buffer_t *request)
 {
-       drm_file_t *priv = filp->private_data;
-       drm_device_t *dev = priv->head->dev;
-       drm_agp_buffer_t request;
        drm_agp_mem_t *entry;
 
        if (!dev->agp || !dev->agp->acquired)
                return -EINVAL;
-       if (copy_from_user
-           (&request, (drm_agp_buffer_t __user *) arg, sizeof(request)))
-               return -EFAULT;
-       if (!(entry = drm_agp_lookup_entry(dev, request.handle)))
+       if (!(entry = drm_agp_lookup_entry(dev, request->handle)))
                return -EINVAL;
        if (entry->bound)
                drm_unbind_agp(entry->memory);
@@ -421,6 +451,24 @@ int drm_agp_free(struct inode *inode, struct file *filp,
        drm_free(entry, sizeof(*entry), DRM_MEM_AGPLISTS);
        return 0;
 }
+EXPORT_SYMBOL(drm_agp_free);
+
+
+
+int drm_agp_free_ioctl(struct inode *inode, struct file *filp,
+                      unsigned int cmd, unsigned long arg)
+{
+       drm_file_t *priv = filp->private_data;
+       drm_device_t *dev = priv->head->dev;
+       drm_agp_buffer_t request;
+
+       if (copy_from_user
+           (&request, (drm_agp_buffer_t __user *) arg, sizeof(request)))
+               return -EFAULT;
+
+       return drm_agp_free(dev, &request);
+}
+
 
 /**
  * Initialize the AGP resources.

diff --git a/linux-core/drm_bufs.c b/linux-core/drm_bufs.c
index e9e4a35..5e1fca1 100644 (file)
--- a/linux-core/drm_bufs.c
+++ b/linux-core/drm_bufs.c
@@ -694,6 +694,8 @@ int drm_addbufs_agp(drm_device_t * dev, drm_buf_desc_t * request)
        }
 
        dma->buf_count += entry->buf_count;
+       dma->seg_count += entry->seg_count;
+       dma->page_count += byte_count >> PAGE_SHIFT;
        dma->byte_count += byte_count;
 
        DRM_DEBUG("dma->buf_count : %d\n", dma->buf_count);
@@ -1077,6 +1079,8 @@ static int drm_addbufs_sg(drm_device_t * dev, drm_buf_desc_t * request)
        }
 
        dma->buf_count += entry->buf_count;
+       dma->seg_count += entry->seg_count;
+       dma->page_count += byte_count >> PAGE_SHIFT;
        dma->byte_count += byte_count;
 
        DRM_DEBUG("dma->buf_count : %d\n", dma->buf_count);
@@ -1236,6 +1240,8 @@ int drm_addbufs_fb(drm_device_t * dev, drm_buf_desc_t * request)
        }
 
        dma->buf_count += entry->buf_count;
+       dma->seg_count += entry->seg_count;
+       dma->page_count += byte_count >> PAGE_SHIFT;
        dma->byte_count += byte_count;
 
        DRM_DEBUG("dma->buf_count : %d\n", dma->buf_count);

diff --git a/linux-core/drm_core.h b/linux-core/drm_core.h
index ff76497..a9a851b 100644 (file)
--- a/linux-core/drm_core.h
+++ b/linux-core/drm_core.h
@@ -27,11 +27,11 @@
 
 #define CORE_NAME              "drm"
 #define CORE_DESC              "DRM shared core routines"
-#define CORE_DATE              "20040925"
+#define CORE_DATE              "20051102"
 
 #define DRM_IF_MAJOR   1
 #define DRM_IF_MINOR   2
 
 #define CORE_MAJOR     1
 #define CORE_MINOR     0
-#define CORE_PATCHLEVEL 0
+#define CORE_PATCHLEVEL 1

diff --git a/linux-core/drm_drv.c b/linux-core/drm_drv.c
index a845ae7..1e711c0 100644 (file)
--- a/linux-core/drm_drv.c
+++ b/linux-core/drm_drv.c
@@ -109,10 +109,10 @@ drm_ioctl_desc_t drm_ioctls[] = {
        [DRM_IOCTL_NR(DRM_IOCTL_AGP_RELEASE)] = {drm_agp_release_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
        [DRM_IOCTL_NR(DRM_IOCTL_AGP_ENABLE)] = {drm_agp_enable_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
        [DRM_IOCTL_NR(DRM_IOCTL_AGP_INFO)] = {drm_agp_info_ioctl, DRM_AUTH},
-       [DRM_IOCTL_NR(DRM_IOCTL_AGP_ALLOC)] = {drm_agp_alloc, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
-       [DRM_IOCTL_NR(DRM_IOCTL_AGP_FREE)] = {drm_agp_free, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
-       [DRM_IOCTL_NR(DRM_IOCTL_AGP_BIND)] = {drm_agp_bind, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
-       [DRM_IOCTL_NR(DRM_IOCTL_AGP_UNBIND)] = {drm_agp_unbind, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
+       [DRM_IOCTL_NR(DRM_IOCTL_AGP_ALLOC)] = {drm_agp_alloc_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
+       [DRM_IOCTL_NR(DRM_IOCTL_AGP_FREE)] = {drm_agp_free_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
+       [DRM_IOCTL_NR(DRM_IOCTL_AGP_BIND)] = {drm_agp_bind_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
+       [DRM_IOCTL_NR(DRM_IOCTL_AGP_UNBIND)] = {drm_agp_unbind_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
 #endif
 
        [DRM_IOCTL_NR(DRM_IOCTL_SG_ALLOC)] = {drm_sg_alloc, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},

diff --git a/linux-core/drm_memory.c b/linux-core/drm_memory.c
index 6961004..9125cd4 100644 (file)
--- a/linux-core/drm_memory.c
+++ b/linux-core/drm_memory.c
@@ -162,27 +162,23 @@ DRM_AGP_MEM *drm_alloc_agp(drm_device_t *dev, int pages, u32 type)
        return drm_agp_allocate_memory(dev->agp->bridge, pages, type);
 }
 #endif
-EXPORT_SYMBOL(drm_alloc_agp);
 
 /** Wrapper around agp_free_memory() */
 int drm_free_agp(DRM_AGP_MEM * handle, int pages)
 {
        return drm_agp_free_memory(handle) ? 0 : -EINVAL;
 }
-EXPORT_SYMBOL(drm_free_agp);
 
 /** Wrapper around agp_bind_memory() */
 int drm_bind_agp(DRM_AGP_MEM * handle, unsigned int start)
 {
        return drm_agp_bind_memory(handle, start);
 }
-EXPORT_SYMBOL(drm_bind_agp);
 
 /** Wrapper around agp_unbind_memory() */
 int drm_unbind_agp(DRM_AGP_MEM * handle)
 {
        return drm_agp_unbind_memory(handle);
 }
-EXPORT_SYMBOL(drm_unbind_agp);
 #endif                         /* agp */
 #endif                         /* debug_memory */

diff --git a/linux-core/drm_memory_debug.c b/linux-core/drm_memory_debug.c
index 2ce2abc..2fe7aea 100644 (file)
--- a/linux-core/drm_memory_debug.c
+++ b/linux-core/drm_memory_debug.c
@@ -391,7 +391,6 @@ DRM_AGP_MEM *drm_alloc_agp(drm_device_t *dev, int pages, u32 type)
        spin_unlock(&drm_mem_lock);
        return NULL;
 }
-EXPORT_SYMBOL(drm_alloc_agp);
 
 int drm_free_agp(DRM_AGP_MEM * handle, int pages)
 {
@@ -421,7 +420,6 @@ int drm_free_agp(DRM_AGP_MEM * handle, int pages)
        }
        return retval;
 }
-EXPORT_SYMBOL(drm_free_agp);
 
 int drm_bind_agp(DRM_AGP_MEM * handle, unsigned int start)
 {
@@ -446,7 +444,6 @@ int drm_bind_agp(DRM_AGP_MEM * handle, unsigned int start)
        spin_unlock(&drm_mem_lock);
        return retcode;
 }
-EXPORT_SYMBOL(drm_bind_agp);
 
 int drm_unbind_agp(DRM_AGP_MEM * handle)
 {
@@ -475,7 +472,6 @@ int drm_unbind_agp(DRM_AGP_MEM * handle)
        }
        return retcode;
 }
-EXPORT_SYMBOL(drm_unbind_agp);
 
 #endif
 #endif

diff --git a/shared-core/mga_dma.c b/shared-core/mga_dma.c
index c6df510..fa3dd39 100644 (file)
--- a/shared-core/mga_dma.c
+++ b/shared-core/mga_dma.c
@@ -446,6 +446,8 @@ static int mga_do_agp_dma_bootstrap(drm_device_t * dev,
        drm_buf_desc_t req;
        drm_agp_mode_t mode;
        drm_agp_info_t info;
+       drm_agp_buffer_t agp_req;
+       drm_agp_binding_t bind_req;
 
        /* Acquire AGP. */
        err = drm_agp_acquire(dev);
@@ -481,16 +483,22 @@ static int mga_do_agp_dma_bootstrap(drm_device_t * dev,
 
 
        /* Allocate and bind AGP memory. */
-       dev_priv->agp_pages = agp_size / PAGE_SIZE;
-       dev_priv->agp_mem = drm_alloc_agp( dev, dev_priv->agp_pages, 0 );
-       if (dev_priv->agp_mem == NULL) {
-               dev_priv->agp_pages = 0;
+       agp_req.size = agp_size;
+       agp_req.type = 0;
+       err = drm_agp_alloc( dev, & agp_req );
+       if (err) {
+               dev_priv->agp_size = 0;
                DRM_ERROR("Unable to allocate %uMB AGP memory\n",
                          dma_bs->agp_size);
-               return DRM_ERR(ENOMEM);
+               return err;
        }
-               
-       err = drm_bind_agp( dev_priv->agp_mem, 0 );
+
+       dev_priv->agp_size = agp_size;
+       dev_priv->agp_handle = agp_req.handle;
+
+       bind_req.handle = agp_req.handle;
+       bind_req.offset = 0;
+       err = drm_agp_bind( dev, &bind_req );
        if (err) {
                DRM_ERROR("Unable to bind AGP memory: %d\n", err);
                return err;
@@ -538,6 +546,20 @@ static int mga_do_agp_dma_bootstrap(drm_device_t * dev,
                return err;
        }
 
+       {
+               drm_map_list_t *_entry;
+               unsigned long agp_token = 0;
+
+               list_for_each_entry(_entry, &dev->maplist->head, head) {
+                       if (_entry->map == dev->agp_buffer_map)
+                               agp_token = _entry->user_token;
+               }
+               if (!agp_token)
+                       return -EFAULT;
+
+               dev->agp_buffer_token = agp_token;
+       }
+
        offset += secondary_size;
        err = drm_addmap( dev, offset, agp_size - offset,
                          _DRM_AGP, 0, & dev_priv->agp_textures );
@@ -943,13 +965,19 @@ static int mga_do_cleanup_dma(drm_device_t * dev, int full_cleanup)
                        drm_core_ioremapfree(dev->agp_buffer_map, dev);
 
                if (dev_priv->used_new_dma_init) {
-                       if (dev_priv->agp_mem != NULL) {
-                               dev_priv->agp_textures = NULL;
-                               drm_unbind_agp(dev_priv->agp_mem);
+                       if (dev_priv->agp_handle != 0) {
+                               drm_agp_binding_t unbind_req;
+                               drm_agp_buffer_t free_req;
 
-                               drm_free_agp(dev_priv->agp_mem, dev_priv->agp_pages);
-                               dev_priv->agp_pages = 0;
-                               dev_priv->agp_mem = NULL;
+                               unbind_req.handle = dev_priv->agp_handle;
+                               drm_agp_unbind(dev, &unbind_req);
+
+                               free_req.handle = dev_priv->agp_handle;
+                               drm_agp_free(dev, &free_req);
+
+                               dev_priv->agp_textures = NULL;
+                               dev_priv->agp_size = 0;
+                               dev_priv->agp_handle = 0;
                        }
 
                        if ((dev->agp != NULL) && dev->agp->acquired) {

diff --git a/shared-core/mga_drv.h b/shared-core/mga_drv.h
index 9454987..526dc4c 100644 (file)
--- a/shared-core/mga_drv.h
+++ b/shared-core/mga_drv.h
@@ -38,11 +38,11 @@
 
 #define DRIVER_NAME            "mga"
 #define DRIVER_DESC            "Matrox G200/G400"
-#define DRIVER_DATE            "20050607"
+#define DRIVER_DATE            "20051102"
 
 #define DRIVER_MAJOR           3
 #define DRIVER_MINOR           2
-#define DRIVER_PATCHLEVEL      0
+#define DRIVER_PATCHLEVEL      1
 
 typedef struct drm_mga_primary_buffer {
        u8 *start;
@@ -144,8 +144,8 @@ typedef struct drm_mga_private {
        drm_local_map_t *primary;
        drm_local_map_t *agp_textures;
        
-       DRM_AGP_MEM *agp_mem;
-       unsigned int agp_pages;
+       unsigned long agp_handle;
+       unsigned int agp_size;
 } drm_mga_private_t;
 
                                /* mga_dma.c */