Update the DRM to latest from DRI CVS. This is approximately the version

included in XFree86 4.3, but includes some fixes.  Notable changes include
Radeon 8500-9100 support, PCI Radeon/Rage 128 support, transform & lighting
support for Radeons, and vblank syncing support for r128, radeon, and mga.
The gamma driver was removed due to lack of any users.

1 files changed, 44 insertions, 126 deletions

diff --git a/sys/dev/drm/drm_ioctl.h b/sys/dev/drm/drm_ioctl.h
index 3989a31..4826faf 100644
--- a/sys/dev/drm/drm_ioctl.h
+++ b/sys/dev/drm/drm_ioctl.h
@@ -31,34 +31,19 @@
  * $FreeBSD$
  */
 
-#define __NO_VERSION__
 #include "dev/drm/drmP.h"
-#ifdef __FreeBSD__
-#include <sys/bus.h>
-#include <pci/pcivar.h>
-#endif /* __FreeBSD__ */
 
-int DRM(irq_busid)( DRM_OS_IOCTL )
+int DRM(irq_busid)( DRM_IOCTL_ARGS )
 {
-	drm_irq_busid_t id;
-#ifdef __linux__
-	struct pci_dev	*dev;
-#endif /* __linux__ */
 #ifdef __FreeBSD__
+	drm_irq_busid_t id;
 	devclass_t pci;
 	device_t bus, dev;
 	device_t *kids;
 	int error, i, num_kids;
-#endif /* __FreeBSD__ */
 
-	DRM_OS_KRNFROMUSR( id, (drm_irq_busid_t *)data, sizeof(id) );
+	DRM_COPY_FROM_USER_IOCTL( id, (drm_irq_busid_t *)data, sizeof(id) );
 
-#ifdef __linux__
-	dev = pci_find_slot(id.busnum, PCI_DEVFN(id.devnum, id.funcnum));
-	if (dev) id.irq = dev->irq;
-	else	 id.irq = 0;
-#endif /* __linux__ */
-#ifdef __FreeBSD__
 	pci = devclass_find("pci");
 	if (!pci)
 		return ENOENT;
@@ -83,53 +68,56 @@ int DRM(irq_busid)( DRM_OS_IOCTL )
 		id.irq = pci_get_irq(dev);
 	else
 		id.irq = 0;
-#endif /* __FreeBSD__ */
 	DRM_DEBUG("%d:%d:%d => IRQ %d\n",
 		  id.busnum, id.devnum, id.funcnum, id.irq);
 	
-	DRM_OS_KRNTOUSR( (drm_irq_busid_t *)data, id, sizeof(id) );
+	DRM_COPY_TO_USER_IOCTL( (drm_irq_busid_t *)data, id, sizeof(id) );
 
 	return 0;
+#else
+	/* don't support interrupt-driven drivers on Net yet */
+	return ENOENT;
+#endif
 }
 
-int DRM(getunique)( DRM_OS_IOCTL )
+int DRM(getunique)( DRM_IOCTL_ARGS )
 {
-	DRM_OS_DEVICE;
+	DRM_DEVICE;
 	drm_unique_t	 u;
 
-	DRM_OS_KRNFROMUSR( u, (drm_unique_t *)data, sizeof(u) );
+	DRM_COPY_FROM_USER_IOCTL( u, (drm_unique_t *)data, sizeof(u) );
 
 	if (u.unique_len >= dev->unique_len) {
-		if (DRM_OS_COPYTOUSR(u.unique, dev->unique, dev->unique_len))
-			return DRM_OS_ERR(EFAULT);
+		if (DRM_COPY_TO_USER(u.unique, dev->unique, dev->unique_len))
+			return DRM_ERR(EFAULT);
 	}
 	u.unique_len = dev->unique_len;
 
-	DRM_OS_KRNTOUSR( (drm_unique_t *)data, u, sizeof(u) );
+	DRM_COPY_TO_USER_IOCTL( (drm_unique_t *)data, u, sizeof(u) );
 
 	return 0;
 }
 
-int DRM(setunique)( DRM_OS_IOCTL )
+int DRM(setunique)( DRM_IOCTL_ARGS )
 {
-	DRM_OS_DEVICE;
+	DRM_DEVICE;
 	drm_unique_t	 u;
 
 	if (dev->unique_len || dev->unique)
-		return DRM_OS_ERR(EBUSY);
+		return DRM_ERR(EBUSY);
 
-	DRM_OS_KRNFROMUSR( u, (drm_unique_t *)data, sizeof(u) );
+	DRM_COPY_FROM_USER_IOCTL( u, (drm_unique_t *)data, sizeof(u) );
 
 	if (!u.unique_len || u.unique_len > 1024)
-		return DRM_OS_ERR(EINVAL);
+		return DRM_ERR(EINVAL);
 
 	dev->unique_len = u.unique_len;
 	dev->unique	= DRM(alloc)(u.unique_len + 1, DRM_MEM_DRIVER);
 
-	if(!dev->unique) return DRM_OS_ERR(ENOMEM);
+	if(!dev->unique) return DRM_ERR(ENOMEM);
 
-	if (DRM_OS_COPYFROMUSR(dev->unique, u.unique, dev->unique_len))
-		return DRM_OS_ERR(EFAULT);
+	if (DRM_COPY_FROM_USER(dev->unique, u.unique, dev->unique_len))
+		return DRM_ERR(EFAULT);
 
 	dev->unique[dev->unique_len] = '\0';
 
@@ -137,85 +125,34 @@ int DRM(setunique)( DRM_OS_IOCTL )
 				  DRM_MEM_DRIVER);
 	if(!dev->devname) {
 		DRM(free)(dev->devname, sizeof(*dev->devname), DRM_MEM_DRIVER);
-		return DRM_OS_ERR(ENOMEM);
+		return DRM_ERR(ENOMEM);
 	}
 	sprintf(dev->devname, "%s@%s", dev->name, dev->unique);
 
-#ifdef __linux__
-	do {
-		struct pci_dev *pci_dev;
-                int b, d, f;
-                char *p;
- 
-                for(p = dev->unique; p && *p && *p != ':'; p++);
-                if (!p || !*p) break;
-                b = (int)simple_strtoul(p+1, &p, 10);
-                if (*p != ':') break;
-                d = (int)simple_strtoul(p+1, &p, 10);
-                if (*p != ':') break;
-                f = (int)simple_strtoul(p+1, &p, 10);
-                if (*p) break;
- 
-                pci_dev = pci_find_slot(b, PCI_DEVFN(d,f));
-                if (pci_dev) {
-			dev->pdev = pci_dev;
-#ifdef __alpha__
-			dev->hose = pci_dev->sysdata;
-#endif
-		}
-        } while(0);
-#endif /* __linux__ */
 
 	return 0;
 }
 
 
-int DRM(getmap)( DRM_OS_IOCTL )
+int DRM(getmap)( DRM_IOCTL_ARGS )
 {
-	DRM_OS_DEVICE;
+	DRM_DEVICE;
 	drm_map_t    map;
-#ifdef __linux__
-	drm_map_list_t *r_list = NULL;
-	struct list_head *list;
-#endif /* __linux__ */
-#ifdef __FreeBSD__
-	drm_map_t    *mapinlist;
+	drm_local_map_t    *mapinlist;
 	drm_map_list_entry_t *list;
-#endif /* __FreeBSD__ */
 	int          idx;
 	int	     i = 0;
 
-	DRM_OS_KRNFROMUSR( map, (drm_map_t *)data, sizeof(map) );
+	DRM_COPY_FROM_USER_IOCTL( map, (drm_map_t *)data, sizeof(map) );
 
 	idx = map.offset;
 
-	DRM_OS_LOCK;
+	DRM_LOCK;
 	if (idx < 0 || idx >= dev->map_count) {
-		DRM_OS_UNLOCK;
-		return DRM_OS_ERR(EINVAL);
-	}
-
-#ifdef __linux__
-	list_for_each(list, &dev->maplist->head) {
-		if(i == idx) {
-			r_list = (drm_map_list_t *)list;
-			break;
-		}
-		i++;
-	}
-	if(!r_list || !r_list->map) {
-		DRM_OS_UNLOCK;
-		return DRM_OS_ERR(EINVAL);
+		DRM_UNLOCK;
+		return DRM_ERR(EINVAL);
 	}
 
-	map.offset = r_list->map->offset;
-	map.size   = r_list->map->size;
-	map.type   = r_list->map->type;
-	map.flags  = r_list->map->flags;
-	map.handle = r_list->map->handle;
-	map.mtrr   = r_list->map->mtrr;
-#endif /* __linux__ */
-#ifdef __FreeBSD__
 	TAILQ_FOREACH(list, dev->maplist, link) {
 		mapinlist = list->map;
 		if (i==idx) {
@@ -229,47 +166,29 @@ int DRM(getmap)( DRM_OS_IOCTL )
 		}
 		i++;
 	}
-#endif /* __FreeBSD__ */
 
-	DRM_OS_UNLOCK;
+	DRM_UNLOCK;
 
-#ifdef __FreeBSD__
  	if (!list)
 		return EINVAL;
-#endif /* __FreeBSD__ */
 
-	DRM_OS_KRNTOUSR( (drm_map_t *)data, map, sizeof(map) );
+	DRM_COPY_TO_USER_IOCTL( (drm_map_t *)data, map, sizeof(map) );
 
 	return 0;
 }
 
-int DRM(getclient)( DRM_OS_IOCTL )
+int DRM(getclient)( DRM_IOCTL_ARGS )
 {
-	DRM_OS_DEVICE;
+	DRM_DEVICE;
 	drm_client_t client;
 	drm_file_t   *pt;
 	int          idx;
 	int          i = 0;
 
-	DRM_OS_KRNFROMUSR( client, (drm_client_t *)data, sizeof(client) );
+	DRM_COPY_FROM_USER_IOCTL( client, (drm_client_t *)data, sizeof(client) );
 
 	idx = client.idx;
-	DRM_OS_LOCK;
-#ifdef __linux__
-	for (i = 0, pt = dev->file_first; i < idx && pt; i++, pt = pt->next)
-		;
-
-	if (!pt) {
-		DRM_OS_UNLOCK;
-		return DRM_OS_ERR(EINVAL);
-	}
-	client.auth  = pt->authenticated;
-	client.pid   = pt->pid;
-	client.uid   = pt->uid;
-	client.magic = pt->magic;
-	client.iocs  = pt->ioctl_count;
-#endif /* __linux__ */
-#ifdef __FreeBSD__
+	DRM_LOCK;
 	TAILQ_FOREACH(pt, &dev->files, link) {
 		if (i==idx)
 		{
@@ -278,30 +197,29 @@ int DRM(getclient)( DRM_OS_IOCTL )
 			client.uid   = pt->uid;
 			client.magic = pt->magic;
 			client.iocs  = pt->ioctl_count;
-			DRM_OS_UNLOCK;
+			DRM_UNLOCK;
 
 			*(drm_client_t *)data = client;
 			return 0;
 		}
 		i++;
 	}
-#endif /* __FreeBSD__ */
-	DRM_OS_UNLOCK;
+	DRM_UNLOCK;
 
-	DRM_OS_KRNTOUSR( (drm_client_t *)data, client, sizeof(client) );
+	DRM_COPY_TO_USER_IOCTL( (drm_client_t *)data, client, sizeof(client) );
 
 	return 0;
 }
 
-int DRM(getstats)( DRM_OS_IOCTL )
+int DRM(getstats)( DRM_IOCTL_ARGS )
 {
-	DRM_OS_DEVICE;
+	DRM_DEVICE;
 	drm_stats_t  stats;
 	int          i;
 
 	memset(&stats, 0, sizeof(stats));
 	
-	DRM_OS_LOCK;
+	DRM_LOCK;
 
 	for (i = 0; i < dev->counters; i++) {
 		if (dev->types[i] == _DRM_STAT_LOCK)
@@ -315,9 +233,9 @@ int DRM(getstats)( DRM_OS_IOCTL )
 	
 	stats.count = dev->counters;
 
-	DRM_OS_UNLOCK;
+	DRM_UNLOCK;
 
-	DRM_OS_KRNTOUSR( (drm_stats_t *)data, stats, sizeof(stats) );
+	DRM_COPY_TO_USER_IOCTL( (drm_stats_t *)data, stats, sizeof(stats) );
 
 	return 0;
 }