Attachment 3573 Details for Bug 4797 – Almost fix AGP problems in MGA DRM.

[patch] Almost fix AGP problems in MGA DRM.

mga_DRM_AGP_breakage-01.patch (text/plain), 14.10 KB, created by Ian Romanick on 2005-10-17 23:01:16 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Ian Romanick

Created: 2005-10-17 23:01:16 UTC

Size: 14.10 KB

patch

obsolete

>Index: linux-core/drmP.h
>===================================================================
>RCS file: /cvs/dri/drm/linux-core/drmP.h,v
>retrieving revision 1.167
>diff -u -d -r1.167 drmP.h
>--- linux-core/drmP.h	6 Oct 2005 23:08:58 -0000	1.167
>+++ linux-core/drmP.h	18 Oct 2005 05:53:48 -0000
>@@ -943,13 +943,17 @@
> 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);
>Index: linux-core/drm_agpsupport.c
>===================================================================
>RCS file: /cvs/dri/drm/linux-core/drm_agpsupport.c,v
>retrieving revision 1.32
>diff -u -d -r1.32 drm_agpsupport.c
>--- linux-core/drm_agpsupport.c	17 Jun 2005 09:09:17 -0000	1.32
>+++ linux-core/drm_agpsupport.c	18 Oct 2005 05:53:48 -0000
>@@ -228,29 +228,22 @@
>  * 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 @@
> 		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 @@
>  * 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 @@
> 		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 @@
>  * 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 @@
> 		  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 @@
>  * 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 @@
> 	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.
>Index: linux-core/drm_drv.c
>===================================================================
>RCS file: /cvs/dri/drm/linux-core/drm_drv.c,v
>retrieving revision 1.126
>diff -u -d -r1.126 drm_drv.c
>--- linux-core/drm_drv.c	3 Sep 2005 03:27:14 -0000	1.126
>+++ linux-core/drm_drv.c	18 Oct 2005 05:53:48 -0000
>@@ -109,10 +109,10 @@
> 	[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},
>Index: linux-core/drm_memory.c
>===================================================================
>RCS file: /cvs/dri/drm/linux-core/drm_memory.c,v
>retrieving revision 1.7
>diff -u -d -r1.7 drm_memory.c
>--- linux-core/drm_memory.c	17 Jun 2005 09:09:17 -0000	1.7
>+++ linux-core/drm_memory.c	18 Oct 2005 05:53:48 -0000
>@@ -162,27 +162,23 @@
> 	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 */
>Index: linux-core/drm_memory_debug.c
>===================================================================
>RCS file: /cvs/dri/drm/linux-core/drm_memory_debug.c,v
>retrieving revision 1.6
>diff -u -d -r1.6 drm_memory_debug.c
>--- linux-core/drm_memory_debug.c	23 Jun 2005 05:29:16 -0000	1.6
>+++ linux-core/drm_memory_debug.c	18 Oct 2005 05:53:48 -0000
>@@ -391,7 +391,6 @@
> 	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 @@
> 	}
> 	return retval;
> }
>-EXPORT_SYMBOL(drm_free_agp);
> 
> int drm_bind_agp(DRM_AGP_MEM * handle, unsigned int start)
> {
>@@ -446,7 +444,6 @@
> 	spin_unlock(&drm_mem_lock);
> 	return retcode;
> }
>-EXPORT_SYMBOL(drm_bind_agp);
> 
> int drm_unbind_agp(DRM_AGP_MEM * handle)
> {
>@@ -475,7 +472,6 @@
> 	}
> 	return retcode;
> }
>-EXPORT_SYMBOL(drm_unbind_agp);
> 
> #endif
> #endif
>Index: shared-core/mga_dma.c
>===================================================================
>RCS file: /cvs/dri/drm/shared-core/mga_dma.c,v
>retrieving revision 1.34
>diff -u -d -r1.34 mga_dma.c
>--- shared-core/mga_dma.c	14 Oct 2005 05:01:19 -0000	1.34
>+++ shared-core/mga_dma.c	18 Oct 2005 05:53:49 -0000
>@@ -446,6 +446,8 @@
> 	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 @@
> 
> 
> 	/* 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;
>@@ -939,13 +947,19 @@
> 			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) {
>Index: shared-core/mga_drv.h
>===================================================================
>RCS file: /cvs/dri/drm/shared-core/mga_drv.h,v
>retrieving revision 1.23
>diff -u -d -r1.23 mga_drv.h
>--- shared-core/mga_drv.h	5 Aug 2005 03:50:23 -0000	1.23
>+++ shared-core/mga_drv.h	18 Oct 2005 05:53:49 -0000
>@@ -144,8 +144,8 @@
> 	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 */

Actions: View | Splinter Review

Attachments on bug 4797: 3573 | 3586 | 3587 | 3685

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.