Merge bkbits.net:/repos/l/linux/linux-2.5

into bkbits.net:/repos/d/drm/drm-2.6

drivers/char/drm/Kconfig

@@ -5,7 +5,8 @@
 # Direct Rendering Infrastructure (DRI) in XFree86 4.1.0 and higher.
 #
 config DRM
-	bool "Direct Rendering Manager (XFree86 4.1.0 and higher DRI support)"
+	tristate "Direct Rendering Manager (XFree86 4.1.0 and higher DRI support)"
+	depends on AGP || AGP=n
 	help
 	  Kernel-level support for the Direct Rendering Infrastructure (DRI)
 	  introduced in XFree86 4.0. If you say Y here, you need to select

drivers/char/drm/Makefile

@@ -2,6 +2,11 @@
 # Makefile for the drm device driver.  This driver provides support for the
 # Direct Rendering Infrastructure (DRI) in XFree86 4.1.0 and higher.
 
+drm-objs    :=	drm_auth.o drm_bufs.o drm_context.o drm_dma.o drm_drawable.o \
+		drm_drv.o drm_fops.o drm_init.o drm_ioctl.o drm_irq.o \
+		drm_lock.o drm_memory.o drm_proc.o drm_stub.o drm_vm.o \
+		drm_agpsupport.o drm_scatter.o ati_pcigart.o
+
 gamma-objs  := gamma_drv.o gamma_dma.o
 tdfx-objs   := tdfx_drv.o
 r128-objs   := r128_drv.o r128_cce.o r128_state.o r128_irq.o
@@ -13,6 +18,7 @@ radeon-objs := radeon_drv.o radeon_cp.o radeon_state.o radeon_mem.o radeon_irq.o
 ffb-objs    := ffb_drv.o ffb_context.o
 sis-objs    := sis_drv.o sis_ds.o sis_mm.o
 
+obj-$(CONFIG_DRM)	+= drm.o
 obj-$(CONFIG_DRM_GAMMA) += gamma.o
 obj-$(CONFIG_DRM_TDFX)	+= tdfx.o
 obj-$(CONFIG_DRM_R128)	+= r128.o

drivers/char/drm/ati_pcigart.h → drivers/char/drm/ati_pcigart.c

@@ -52,7 +52,7 @@
 # define ATI_MAX_PCIGART_PAGES		8192	/**< 32 MB aperture, 4K pages */
 # define ATI_PCIGART_PAGE_SIZE		4096	/**< PCI GART page size */
 
-static unsigned long DRM(ati_alloc_pcigart_table)( void )
+unsigned long drm_ati_alloc_pcigart_table( void )
 {
 	unsigned long address;
 	struct page *page;
@@ -75,7 +75,7 @@ static unsigned long DRM(ati_alloc_pcigart_table)( void )
 	return address;
 }
 
-static void DRM(ati_free_pcigart_table)( unsigned long address )
+static void drm_ati_free_pcigart_table( unsigned long address )
 {
 	struct page *page;
 	int i;
@@ -91,7 +91,44 @@ static void DRM(ati_free_pcigart_table)( unsigned long address )
 	free_pages( address, ATI_PCIGART_TABLE_ORDER );
 }
 
-int DRM(ati_pcigart_init)( drm_device_t *dev,
+int drm_ati_pcigart_cleanup( drm_device_t *dev,
+			      unsigned long addr,
+			      dma_addr_t bus_addr)
+{
+	drm_sg_mem_t *entry = dev->sg;
+	unsigned long pages;
+	int i;
+
+	/* we need to support large memory configurations */
+	if ( !entry ) {
+		DRM_ERROR( "no scatter/gather memory!\n" );
+		return 0;
+	}
+
+	if ( bus_addr ) {
+		pci_unmap_single(dev->pdev, bus_addr,
+				 ATI_PCIGART_TABLE_PAGES * PAGE_SIZE,
+				 PCI_DMA_TODEVICE);
+
+		pages = ( entry->pages <= ATI_MAX_PCIGART_PAGES )
+		        ? entry->pages : ATI_MAX_PCIGART_PAGES;
+
+		for ( i = 0 ; i < pages ; i++ ) {
+			if ( !entry->busaddr[i] ) break;
+			pci_unmap_single(dev->pdev, entry->busaddr[i],
+					 PAGE_SIZE, PCI_DMA_TODEVICE);
+		}
+	}
+
+	if ( addr ) {
+		drm_ati_free_pcigart_table( addr );
+	}
+
+	return 1;
+}
+EXPORT_SYMBOL(drm_ati_pcigart_cleanup);
+
+int drm_ati_pcigart_init( drm_device_t *dev,
 			   unsigned long *addr,
 			   dma_addr_t *bus_addr)
 {
@@ -106,7 +143,7 @@ int DRM(ati_pcigart_init)( drm_device_t *dev,
 		goto done;
 	}
 
-	address = DRM(ati_alloc_pcigart_table)();
+	address = drm_ati_alloc_pcigart_table();
 	if ( !address ) {
 		DRM_ERROR( "cannot allocate PCI GART page!\n" );
 		goto done;
@@ -122,7 +159,7 @@ int DRM(ati_pcigart_init)( drm_device_t *dev,
 				  PCI_DMA_TODEVICE);
 	if (bus_address == 0) {
 		DRM_ERROR( "unable to map PCIGART pages!\n" );
-		DRM(ati_free_pcigart_table)( address );
+		drm_ati_free_pcigart_table( address );
 		address = 0;
 		goto done;
 	}
@@ -142,7 +179,7 @@ int DRM(ati_pcigart_init)( drm_device_t *dev,
 					   PCI_DMA_TODEVICE);
 		if (entry->busaddr[i] == 0) {
 			DRM_ERROR( "unable to map PCIGART pages!\n" );
-			DRM(ati_pcigart_cleanup)( dev, address, bus_address );
+			drm_ati_pcigart_cleanup( dev, address, bus_address );
 			address = 0;
 			bus_address = 0;
 			goto done;
@@ -168,39 +205,4 @@ int DRM(ati_pcigart_init)( drm_device_t *dev,
 	*bus_addr = bus_address;
 	return ret;
 }
-
-int DRM(ati_pcigart_cleanup)( drm_device_t *dev,
-			      unsigned long addr,
-			      dma_addr_t bus_addr)
-{
-	drm_sg_mem_t *entry = dev->sg;
-	unsigned long pages;
-	int i;
-
-	/* we need to support large memory configurations */
-	if ( !entry ) {
-		DRM_ERROR( "no scatter/gather memory!\n" );
-		return 0;
-	}
-
-	if ( bus_addr ) {
-		pci_unmap_single(dev->pdev, bus_addr,
-				 ATI_PCIGART_TABLE_PAGES * PAGE_SIZE,
-				 PCI_DMA_TODEVICE);
-
-		pages = ( entry->pages <= ATI_MAX_PCIGART_PAGES )
-		        ? entry->pages : ATI_MAX_PCIGART_PAGES;
-
-		for ( i = 0 ; i < pages ; i++ ) {
-			if ( !entry->busaddr[i] ) break;
-			pci_unmap_single(dev->pdev, entry->busaddr[i],
-					 PAGE_SIZE, PCI_DMA_TODEVICE);
-		}
-	}
-
-	if ( addr ) {
-		DRM(ati_free_pcigart_table)( addr );
-	}
-
-	return 1;
-}
+EXPORT_SYMBOL(drm_ati_pcigart_init);

drivers/char/drm/drm_auth.h → drivers/char/drm/drm_auth.c

@@ -44,7 +44,7 @@
  * The key is the modulus of the hash table size, #DRM_HASH_SIZE, which must be
  * a power of 2.
  */
-static int DRM(hash_magic)(drm_magic_t magic)
+static int drm_hash_magic(drm_magic_t magic)
 {
 	return magic & (DRM_HASH_SIZE-1);
 }
@@ -59,11 +59,11 @@ static int DRM(hash_magic)(drm_magic_t magic)
  * the one with matching magic number, while holding the drm_device::struct_sem
  * lock.
  */
-static drm_file_t *DRM(find_file)(drm_device_t *dev, drm_magic_t magic)
+static drm_file_t *drm_find_file(drm_device_t *dev, drm_magic_t magic)
 {
 	drm_file_t	  *retval = NULL;
 	drm_magic_entry_t *pt;
-	int		  hash	  = DRM(hash_magic)(magic);
+	int		  hash	  = drm_hash_magic(magic);
 
 	down(&dev->struct_sem);
 	for (pt = dev->magiclist[hash].head; pt; pt = pt->next) {
@@ -87,15 +87,15 @@ static drm_file_t *DRM(find_file)(drm_device_t *dev, drm_magic_t magic)
  * associated the magic number hash key in drm_device::magiclist, while holding
  * the drm_device::struct_sem lock.
  */
-int DRM(add_magic)(drm_device_t *dev, drm_file_t *priv, drm_magic_t magic)
+int drm_add_magic(drm_device_t *dev, drm_file_t *priv, drm_magic_t magic)
 {
 	int		  hash;
 	drm_magic_entry_t *entry;
 
 	DRM_DEBUG("%d\n", magic);
 
-	hash	     = DRM(hash_magic)(magic);
-	entry	     = DRM(alloc)(sizeof(*entry), DRM_MEM_MAGIC);
+	hash	     = drm_hash_magic(magic);
+	entry	     = drm_alloc(sizeof(*entry), DRM_MEM_MAGIC);
 	if (!entry) return -ENOMEM;
 	memset(entry, 0, sizeof(*entry));
 	entry->magic = magic;
@@ -124,7 +124,7 @@ int DRM(add_magic)(drm_device_t *dev, drm_file_t *priv, drm_magic_t magic)
  * Searches and unlinks the entry in drm_device::magiclist with the magic
  * number hash key, while holding the drm_device::struct_sem lock.
  */
-int DRM(remove_magic)(drm_device_t *dev, drm_magic_t magic)
+int drm_remove_magic(drm_device_t *dev, drm_magic_t magic)
 {
 	drm_magic_entry_t *prev = NULL;
 	drm_magic_entry_t *pt;
@@ -132,7 +132,7 @@ int DRM(remove_magic)(drm_device_t *dev, drm_magic_t magic)
 
 
 	DRM_DEBUG("%d\n", magic);
-	hash = DRM(hash_magic)(magic);
+	hash = drm_hash_magic(magic);
 
 	down(&dev->struct_sem);
 	for (pt = dev->magiclist[hash].head; pt; prev = pt, pt = pt->next) {
@@ -152,7 +152,7 @@ int DRM(remove_magic)(drm_device_t *dev, drm_magic_t magic)
 	}
 	up(&dev->struct_sem);
 
-	DRM(free)(pt, sizeof(*pt), DRM_MEM_MAGIC);
+	drm_free(pt, sizeof(*pt), DRM_MEM_MAGIC);
 
 	return -EINVAL;
 }
@@ -170,7 +170,7 @@ int DRM(remove_magic)(drm_device_t *dev, drm_magic_t magic)
  * searches an unique non-zero magic number and add it associating it with \p
  * filp.
  */
-int DRM(getmagic)(struct inode *inode, struct file *filp,
+int drm_getmagic(struct inode *inode, struct file *filp,
 		  unsigned int cmd, unsigned long arg)
 {
 	static drm_magic_t sequence = 0;
@@ -188,9 +188,9 @@ int DRM(getmagic)(struct inode *inode, struct file *filp,
 			if (!sequence) ++sequence; /* reserve 0 */
 			auth.magic = sequence++;
 			spin_unlock(&lock);
-		} while (DRM(find_file)(dev, auth.magic));
+		} while (drm_find_file(dev, auth.magic));
 		priv->magic = auth.magic;
-		DRM(add_magic)(dev, priv, auth.magic);
+		drm_add_magic(dev, priv, auth.magic);
 	}
 
 	DRM_DEBUG("%u\n", auth.magic);
@@ -210,7 +210,7 @@ int DRM(getmagic)(struct inode *inode, struct file *filp,
  *
  * Checks if \p filp is associated with the magic number passed in \arg.
  */
-int DRM(authmagic)(struct inode *inode, struct file *filp,
+int drm_authmagic(struct inode *inode, struct file *filp,
 		   unsigned int cmd, unsigned long arg)
 {
 	drm_file_t	   *priv    = filp->private_data;
@@ -221,9 +221,9 @@ int DRM(authmagic)(struct inode *inode, struct file *filp,
 	if (copy_from_user(&auth, (drm_auth_t __user *)arg, sizeof(auth)))
 		return -EFAULT;
 	DRM_DEBUG("%u\n", auth.magic);
-	if ((file = DRM(find_file)(dev, auth.magic))) {
+	if ((file = drm_find_file(dev, auth.magic))) {
 		file->authenticated = 1;
-		DRM(remove_magic)(dev, auth.magic);
+		drm_remove_magic(dev, auth.magic);
 		return 0;
 	}
 	return -EINVAL;

drivers/char/drm/drm_context.h → drivers/char/drm/drm_context.c

@@ -56,7 +56,7 @@
  * in drm_device::context_sareas, while holding the drm_device::struct_sem
  * lock.
  */
-void DRM(ctxbitmap_free)( drm_device_t *dev, int ctx_handle )
+void drm_ctxbitmap_free( drm_device_t *dev, int ctx_handle )
 {
 	if ( ctx_handle < 0 ) goto failed;
 	if ( !dev->ctx_bitmap ) goto failed;
@@ -84,7 +84,7 @@ void DRM(ctxbitmap_free)( drm_device_t *dev, int ctx_handle )
  * drm_device::context_sareas to accommodate the new entry while holding the
  * drm_device::struct_sem lock.
  */
-int DRM(ctxbitmap_next)( drm_device_t *dev )
+int drm_ctxbitmap_next( drm_device_t *dev )
 {
 	int bit;
 
@@ -100,7 +100,7 @@ int DRM(ctxbitmap_next)( drm_device_t *dev )
 			if(dev->context_sareas) {
 				drm_map_t **ctx_sareas;
 
-				ctx_sareas = DRM(realloc)(dev->context_sareas,
+				ctx_sareas = drm_realloc(dev->context_sareas,
 						(dev->max_context - 1) * 
 						sizeof(*dev->context_sareas),
 						dev->max_context * 
@@ -115,7 +115,7 @@ int DRM(ctxbitmap_next)( drm_device_t *dev )
 				dev->context_sareas[bit] = NULL;
 			} else {
 				/* max_context == 1 at this point */
-				dev->context_sareas = DRM(alloc)(
+				dev->context_sareas = drm_alloc(
 						dev->max_context * 
 						sizeof(*dev->context_sareas),
 						DRM_MEM_MAPS);
@@ -142,13 +142,13 @@ int DRM(ctxbitmap_next)( drm_device_t *dev )
  * Allocates and initialize drm_device::ctx_bitmap and drm_device::context_sareas, while holding
  * the drm_device::struct_sem lock.
  */
-int DRM(ctxbitmap_init)( drm_device_t *dev )
+int drm_ctxbitmap_init( drm_device_t *dev )
 {
 	int i;
    	int temp;
 
 	down(&dev->struct_sem);
-	dev->ctx_bitmap = (unsigned long *) DRM(alloc)( PAGE_SIZE,
+	dev->ctx_bitmap = (unsigned long *) drm_alloc( PAGE_SIZE,
 							DRM_MEM_CTXBITMAP );
 	if ( dev->ctx_bitmap == NULL ) {
 		up(&dev->struct_sem);
@@ -160,7 +160,7 @@ int DRM(ctxbitmap_init)( drm_device_t *dev )
 	up(&dev->struct_sem);
 
 	for ( i = 0 ; i < DRM_RESERVED_CONTEXTS ; i++ ) {
-		temp = DRM(ctxbitmap_next)( dev );
+		temp = drm_ctxbitmap_next( dev );
 	   	DRM_DEBUG( "drm_ctxbitmap_init : %d\n", temp );
 	}
 
@@ -175,14 +175,14 @@ int DRM(ctxbitmap_init)( drm_device_t *dev )
  * Frees drm_device::ctx_bitmap and drm_device::context_sareas, while holding
  * the drm_device::struct_sem lock.
  */
-void DRM(ctxbitmap_cleanup)( drm_device_t *dev )
+void drm_ctxbitmap_cleanup( drm_device_t *dev )
 {
 	down(&dev->struct_sem);
-	if( dev->context_sareas ) DRM(free)( dev->context_sareas,
+	if( dev->context_sareas ) drm_free( dev->context_sareas,
 					     sizeof(*dev->context_sareas) * 
 					     dev->max_context,
 					     DRM_MEM_MAPS );
-	DRM(free)( (void *)dev->ctx_bitmap, PAGE_SIZE, DRM_MEM_CTXBITMAP );
+	drm_free( (void *)dev->ctx_bitmap, PAGE_SIZE, DRM_MEM_CTXBITMAP );
 	up(&dev->struct_sem);
 }
 
@@ -204,7 +204,7 @@ void DRM(ctxbitmap_cleanup)( drm_device_t *dev )
  * Gets the map from drm_device::context_sareas with the handle specified and
  * returns its handle.
  */
-int DRM(getsareactx)(struct inode *inode, struct file *filp,
+int drm_getsareactx(struct inode *inode, struct file *filp,
 		     unsigned int cmd, unsigned long arg)
 {
 	drm_file_t	*priv	= filp->private_data;
@@ -243,7 +243,7 @@ int DRM(getsareactx)(struct inode *inode, struct file *filp,
  * Searches the mapping specified in \p arg and update the entry in
  * drm_device::context_sareas with it.
  */
-int DRM(setsareactx)(struct inode *inode, struct file *filp,
+int drm_setsareactx(struct inode *inode, struct file *filp,
 		     unsigned int cmd, unsigned long arg)
 {
 	drm_file_t	*priv	= filp->private_data;
@@ -297,7 +297,7 @@ int DRM(setsareactx)(struct inode *inode, struct file *filp,
  *
  * Attempt to set drm_device::context_flag.
  */
-int DRM(context_switch)( drm_device_t *dev, int old, int new )
+int drm_context_switch( drm_device_t *dev, int old, int new )
 {
         if ( test_and_set_bit( 0, &dev->context_flag ) ) {
                 DRM_ERROR( "Reentering -- FIXME\n" );
@@ -326,7 +326,7 @@ int DRM(context_switch)( drm_device_t *dev, int old, int new )
  * hardware lock is held, clears the drm_device::context_flag and wakes up
  * drm_device::context_wait.
  */
-int DRM(context_switch_complete)( drm_device_t *dev, int new )
+int drm_context_switch_complete( drm_device_t *dev, int new )
 {
         dev->last_context = new;  /* PRE/POST: This is the _only_ writer. */
         dev->last_switch  = jiffies;
@@ -353,7 +353,7 @@ int DRM(context_switch_complete)( drm_device_t *dev, int new )
  * \param arg user argument pointing to a drm_ctx_res structure.
  * \return zero on success or a negative number on failure.
  */
-int DRM(resctx)( struct inode *inode, struct file *filp,
+int drm_resctx( struct inode *inode, struct file *filp,
 		 unsigned int cmd, unsigned long arg )
 {
 	drm_ctx_res_t res;
@@ -391,7 +391,7 @@ int DRM(resctx)( struct inode *inode, struct file *filp,
  *
  * Get a new handle for the context and copy to userspace.
  */
-int DRM(addctx)( struct inode *inode, struct file *filp,
+int drm_addctx( struct inode *inode, struct file *filp,
 		 unsigned int cmd, unsigned long arg )
 {
 	drm_file_t *priv = filp->private_data;
@@ -403,10 +403,10 @@ int DRM(addctx)( struct inode *inode, struct file *filp,
 	if ( copy_from_user( &ctx, argp, sizeof(ctx) ) )
 		return -EFAULT;
 
-	ctx.handle = DRM(ctxbitmap_next)( dev );
+	ctx.handle = drm_ctxbitmap_next( dev );
 	if ( ctx.handle == DRM_KERNEL_CONTEXT ) {
 				/* Skip kernel's context and get a new one. */
-		ctx.handle = DRM(ctxbitmap_next)( dev );
+		ctx.handle = drm_ctxbitmap_next( dev );
 	}
 	DRM_DEBUG( "%d\n", ctx.handle );
 	if ( ctx.handle == -1 ) {
@@ -417,11 +417,11 @@ int DRM(addctx)( struct inode *inode, struct file *filp,
 
 	if ( ctx.handle != DRM_KERNEL_CONTEXT )
 	{
-		if (dev->fn_tbl.context_ctor)
-			dev->fn_tbl.context_ctor(dev, ctx.handle);
+		if (dev->driver->context_ctor)
+			dev->driver->context_ctor(dev, ctx.handle);
 	}
 
-	ctx_entry = DRM(alloc)( sizeof(*ctx_entry), DRM_MEM_CTXLIST );
+	ctx_entry = drm_alloc( sizeof(*ctx_entry), DRM_MEM_CTXLIST );
 	if ( !ctx_entry ) {
 		DRM_DEBUG("out of memory\n");
 		return -ENOMEM;
@@ -441,7 +441,7 @@ int DRM(addctx)( struct inode *inode, struct file *filp,
 	return 0;
 }
 
-int DRM(modctx)( struct inode *inode, struct file *filp,
+int drm_modctx( struct inode *inode, struct file *filp,
 		 unsigned int cmd, unsigned long arg )
 {
 	/* This does nothing */
@@ -457,7 +457,7 @@ int DRM(modctx)( struct inode *inode, struct file *filp,
  * \param arg user argument pointing to a drm_ctx structure.
  * \return zero on success or a negative number on failure.
  */
-int DRM(getctx)( struct inode *inode, struct file *filp,
+int drm_getctx( struct inode *inode, struct file *filp,
 		 unsigned int cmd, unsigned long arg )
 {
 	drm_ctx_t __user *argp = (void __user *)arg;
@@ -485,7 +485,7 @@ int DRM(getctx)( struct inode *inode, struct file *filp,
  *
  * Calls context_switch().
  */
-int DRM(switchctx)( struct inode *inode, struct file *filp,
+int drm_switchctx( struct inode *inode, struct file *filp,
 		    unsigned int cmd, unsigned long arg )
 {
 	drm_file_t *priv = filp->private_data;
@@ -496,7 +496,7 @@ int DRM(switchctx)( struct inode *inode, struct file *filp,
 		return -EFAULT;
 
 	DRM_DEBUG( "%d\n", ctx.handle );
-	return DRM(context_switch)( dev, dev->last_context, ctx.handle );
+	return drm_context_switch( dev, dev->last_context, ctx.handle );
 }
 
 /**
@@ -510,7 +510,7 @@ int DRM(switchctx)( struct inode *inode, struct file *filp,
  *
  * Calls context_switch_complete().
  */
-int DRM(newctx)( struct inode *inode, struct file *filp,
+int drm_newctx( struct inode *inode, struct file *filp,
 		 unsigned int cmd, unsigned long arg )
 {
 	drm_file_t *priv = filp->private_data;
@@ -521,7 +521,7 @@ int DRM(newctx)( struct inode *inode, struct file *filp,
 		return -EFAULT;
 
 	DRM_DEBUG( "%d\n", ctx.handle );
-	DRM(context_switch_complete)( dev, ctx.handle );
+	drm_context_switch_complete( dev, ctx.handle );
 
 	return 0;
 }
@@ -537,7 +537,7 @@ int DRM(newctx)( struct inode *inode, struct file *filp,
  *
  * If not the special kernel context, calls ctxbitmap_free() to free the specified context.
  */
-int DRM(rmctx)( struct inode *inode, struct file *filp,
+int drm_rmctx( struct inode *inode, struct file *filp,
 		unsigned int cmd, unsigned long arg )
 {
 	drm_file_t *priv = filp->private_data;
@@ -552,9 +552,9 @@ int DRM(rmctx)( struct inode *inode, struct file *filp,
 		priv->remove_auth_on_close = 1;
 	}
 	if ( ctx.handle != DRM_KERNEL_CONTEXT ) {
-		if (dev->fn_tbl.context_dtor)
-			dev->fn_tbl.context_dtor(dev, ctx.handle);
-		DRM(ctxbitmap_free)( dev, ctx.handle );
+		if (dev->driver->context_dtor)
+			dev->driver->context_dtor(dev, ctx.handle);
+		drm_ctxbitmap_free( dev, ctx.handle );
 	}
 
 	down( &dev->ctxlist_sem );
@@ -564,7 +564,7 @@ int DRM(rmctx)( struct inode *inode, struct file *filp,
 		list_for_each_entry_safe( pos, n, &dev->ctxlist->head, head ) {
 			if ( pos->handle == ctx.handle ) {
 				list_del( &pos->head );
-				DRM(free)( pos, sizeof(*pos), DRM_MEM_CTXLIST );
+				drm_free( pos, sizeof(*pos), DRM_MEM_CTXLIST );
 				--dev->ctx_count;
 			}
 		}

drivers/char/drm/drm_core.h

@@ -20,21 +20,15 @@
  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  * DEALINGS IN THE SOFTWARE.
  */
+#define DRIVER_AUTHOR		"Gareth Hughes, Leif Delgass, José Fonseca, Jon Smirl"
 
-#include "drm_auth.h"
-#include "drm_agpsupport.h"
-#include "drm_bufs.h"
-#include "drm_context.h"
-#include "drm_dma.h"
-#include "drm_irq.h"
-#include "drm_drawable.h"
-#include "drm_drv.h"
-#include "drm_fops.h"
-#include "drm_init.h"
-#include "drm_ioctl.h"
-#include "drm_lock.h"
-#include "drm_memory.h"
-#include "drm_proc.h"
-#include "drm_vm.h"
-#include "drm_stub.h"
-#include "drm_scatter.h"
+#define DRIVER_NAME		"drm"
+#define DRIVER_DESC		"DRM shared core routines"
+#define DRIVER_DATE		"20040925"
+
+#define DRM_IF_MAJOR	1
+#define DRM_IF_MINOR	2
+
+#define DRIVER_MAJOR	1
+#define DRIVER_MINOR	0
+#define DRIVER_PATCHLEVEL 0

drivers/char/drm/drm_dma.h → drivers/char/drm/drm_dma.c

@@ -43,11 +43,11 @@
  *
  * Allocate and initialize a drm_device_dma structure.
  */
-int DRM(dma_setup)( drm_device_t *dev )
+int drm_dma_setup( drm_device_t *dev )
 {
 	int i;
 
-	dev->dma = DRM(alloc)( sizeof(*dev->dma), DRM_MEM_DRIVER );
+	dev->dma = drm_alloc( sizeof(*dev->dma), DRM_MEM_DRIVER );
 	if ( !dev->dma )
 		return -ENOMEM;
 
@@ -67,7 +67,7 @@ int DRM(dma_setup)( drm_device_t *dev )
  * Free all pages associated with DMA buffers, the buffers and pages lists, and
  * finally the the drm_device::dma structure itself.
  */
-void DRM(dma_takedown)(drm_device_t *dev)
+void drm_dma_takedown(drm_device_t *dev)
 {
 	drm_device_dma_t  *dma = dev->dma;
 	int		  i, j;
@@ -84,12 +84,12 @@ void DRM(dma_takedown)(drm_device_t *dev)
 				  dma->bufs[i].seg_count);
 			for (j = 0; j < dma->bufs[i].seg_count; j++) {
 				if (dma->bufs[i].seglist[j]) {
-					DRM(free_pages)(dma->bufs[i].seglist[j],
+					drm_free_pages(dma->bufs[i].seglist[j],
 							dma->bufs[i].page_order,
 							DRM_MEM_DMA);
 				}
 			}
-			DRM(free)(dma->bufs[i].seglist,
+			drm_free(dma->bufs[i].seglist,
 				  dma->bufs[i].seg_count
 				  * sizeof(*dma->bufs[0].seglist),
 				  DRM_MEM_SEGS);
@@ -97,12 +97,12 @@ void DRM(dma_takedown)(drm_device_t *dev)
 	   	if (dma->bufs[i].buf_count) {
 		   	for (j = 0; j < dma->bufs[i].buf_count; j++) {
 				if (dma->bufs[i].buflist[j].dev_private) {
-					DRM(free)(dma->bufs[i].buflist[j].dev_private,
+					drm_free(dma->bufs[i].buflist[j].dev_private,
 						  dma->bufs[i].buflist[j].dev_priv_size,
 						  DRM_MEM_BUFS);
 				}
 			}
-		   	DRM(free)(dma->bufs[i].buflist,
+		   	drm_free(dma->bufs[i].buflist,
 				  dma->bufs[i].buf_count *
 				  sizeof(*dma->bufs[0].buflist),
 				  DRM_MEM_BUFS);
@@ -110,17 +110,17 @@ void DRM(dma_takedown)(drm_device_t *dev)
 	}
 
 	if (dma->buflist) {
-		DRM(free)(dma->buflist,
+		drm_free(dma->buflist,
 			  dma->buf_count * sizeof(*dma->buflist),
 			  DRM_MEM_BUFS);
 	}
 
 	if (dma->pagelist) {
-		DRM(free)(dma->pagelist,
+		drm_free(dma->pagelist,
 			  dma->page_count * sizeof(*dma->pagelist),
 			  DRM_MEM_PAGES);
 	}
-	DRM(free)(dev->dma, sizeof(*dev->dma), DRM_MEM_DRIVER);
+	drm_free(dev->dma, sizeof(*dev->dma), DRM_MEM_DRIVER);
 	dev->dma = NULL;
 }
 
@@ -133,7 +133,7 @@ void DRM(dma_takedown)(drm_device_t *dev)
  * 
  * Resets the fields of \p buf.
  */
-void DRM(free_buffer)(drm_device_t *dev, drm_buf_t *buf)
+void drm_free_buffer(drm_device_t *dev, drm_buf_t *buf)
 {
 	if (!buf) return;
 
@@ -154,7 +154,7 @@ void DRM(free_buffer)(drm_device_t *dev, drm_buf_t *buf)
  *
  * Frees each buffer associated with \p filp not already on the hardware.
  */
-void DRM(core_reclaim_buffers)( struct file *filp )
+void drm_core_reclaim_buffers( struct file *filp )
 {
 	drm_file_t    *priv   = filp->private_data;
 	drm_device_t  *dev    = priv->dev;
@@ -166,7 +166,7 @@ void DRM(core_reclaim_buffers)( struct file *filp )
 		if (dma->buflist[i]->filp == filp) {
 			switch (dma->buflist[i]->list) {
 			case DRM_LIST_NONE:
-				DRM(free_buffer)(dev, dma->buflist[i]);
+				drm_free_buffer(dev, dma->buflist[i]);
 				break;
 			case DRM_LIST_WAIT:
 				dma->buflist[i]->list = DRM_LIST_RECLAIM;
@@ -178,4 +178,5 @@ void DRM(core_reclaim_buffers)( struct file *filp )
 		}
 	}
 }
+EXPORT_SYMBOL(drm_core_reclaim_buffers);
 

drivers/char/drm/drm_drawable.h → drivers/char/drm/drm_drawable.c

@@ -36,7 +36,7 @@
 #include "drmP.h"
 
 /** No-op. */
-int DRM(adddraw)(struct inode *inode, struct file *filp,
+int drm_adddraw(struct inode *inode, struct file *filp,
 		 unsigned int cmd, unsigned long arg)
 {
 	drm_draw_t draw;
@@ -49,7 +49,7 @@ int DRM(adddraw)(struct inode *inode, struct file *filp,
 }
 
 /** No-op. */
-int DRM(rmdraw)(struct inode *inode, struct file *filp,
+int drm_rmdraw(struct inode *inode, struct file *filp,
 		unsigned int cmd, unsigned long arg)
 {
 	return 0;		/* NOOP */

drivers/char/drm/drm_init.h → drivers/char/drm/drm_init.c

@@ -35,88 +35,12 @@
 
 #include "drmP.h"
 
-/** Debug flags.  Set by parse_option(). */
-#if 0
-int DRM(flags) = DRM_FLAG_DEBUG;
-#else
-int DRM(flags) = 0;
-#endif
-
-/**
- * Parse a single option.
- *
- * \param s option string.
- *
- * \sa See parse_options() for details.
- */
-static void DRM(parse_option)(char *s)
-{
-	char *c, *r;
-
-	DRM_DEBUG("\"%s\"\n", s);
-	if (!s || !*s) return;
-	for (c = s; *c && *c != ':'; c++); /* find : or \0 */
-	if (*c) r = c + 1; else r = NULL;  /* remember remainder */
-	*c = '\0';			   /* terminate */
-	if (!strcmp(s, "debug")) {
-		DRM(flags) |= DRM_FLAG_DEBUG;
-		DRM_INFO("Debug messages ON\n");
-		return;
-	}
-	DRM_ERROR("\"%s\" is not a valid option\n", s);
-	return;
-}
-
-/**
- * Parse the insmod "drm_opts=" options, or the command-line
- * options passed to the kernel via LILO.  
- *
- * \param s contains option_list without the 'drm_opts=' part.
- *
- * The grammar of the format is as
- * follows:
- *
- * \code
- * drm		::= 'drm_opts=' option_list
- * option_list	::= option [ ';' option_list ]
- * option	::= 'device:' major
- *		|   'debug'
- *		|   'noctx'
- * major	::= INTEGER
- * \endcode
- *
- * - device=major,minor specifies the device number used for /dev/drm
- *   - if major == 0 then the misc device is used
- *   - if major == 0 and minor == 0 then dynamic misc allocation is used
- * - debug=on specifies that debugging messages will be printk'd
- * - debug=trace specifies that each function call will be logged via printk
- * - debug=off turns off all debugging options
- *
- * \todo Actually only the \e presence of the 'debug' option is currently
- * checked.
- */
-
-void DRM(parse_options)(char *s)
-{
-	char *h, *t, *n;
-
-	DRM_DEBUG("\"%s\"\n", s ?: "");
-	if (!s || !*s) return;
-
-	for (h = t = n = s; h && *h; h = n) {
-		for (; *t && *t != ';'; t++);	       /* find ; or \0 */
-		if (*t) n = t + 1; else n = NULL;      /* remember next */
-		*t = '\0';			       /* terminate */
-		DRM(parse_option)(h);		       /* parse */
-	}
-}
-
 /**
  * Check whether DRI will run on this CPU.
  *
  * \return non-zero if the DRI will run on this CPU, or zero otherwise.
  */
-int DRM(cpu_valid)(void)
+int drm_cpu_valid(void)
 {
 #if defined(__i386__)
 	if (boot_cpu_data.x86 == 3) return 0; /* No cmpxchg on a 386 */

drivers/char/drm/drm_ioctl.h → drivers/char/drm/drm_ioctl.c

@@ -34,6 +34,7 @@
  */
 
 #include "drmP.h"
+#include "drm_core.h"
 
 #include "linux/pci.h"
 
@@ -48,7 +49,7 @@
  *
  * Copies the bus id from drm_device::unique into user space.
  */
-int DRM(getunique)(struct inode *inode, struct file *filp,
+int drm_getunique(struct inode *inode, struct file *filp,
 		   unsigned int cmd, unsigned long arg)
 {
 	drm_file_t	 *priv	 = filp->private_data;
@@ -82,7 +83,7 @@ int DRM(getunique)(struct inode *inode, struct file *filp,
  * in interface version 1.1 and will return EBUSY when setversion has requested
  * version 1.1 or greater.
  */
-int DRM(setunique)(struct inode *inode, struct file *filp,
+int drm_setunique(struct inode *inode, struct file *filp,
 		   unsigned int cmd, unsigned long arg)
 {
 	drm_file_t	 *priv	 = filp->private_data;
@@ -98,19 +99,19 @@ int DRM(setunique)(struct inode *inode, struct file *filp,
 	if (!u.unique_len || u.unique_len > 1024) return -EINVAL;
 
 	dev->unique_len = u.unique_len;
-	dev->unique	= DRM(alloc)(u.unique_len + 1, DRM_MEM_DRIVER);
+	dev->unique	= drm_alloc(u.unique_len + 1, DRM_MEM_DRIVER);
 	if(!dev->unique) return -ENOMEM;
 	if (copy_from_user(dev->unique, u.unique, dev->unique_len))
 		return -EFAULT;
 
 	dev->unique[dev->unique_len] = '\0';
 
-	dev->devname = DRM(alloc)(strlen(dev->name) + strlen(dev->unique) + 2,
+	dev->devname = drm_alloc(strlen(dev->driver->pci_driver.name) + strlen(dev->unique) + 2,
 				  DRM_MEM_DRIVER);
 	if (!dev->devname)
 		return -ENOMEM;
 
-	sprintf(dev->devname, "%s@%s", dev->name, dev->unique);
+	sprintf(dev->devname, "%s@%s", dev->driver->pci_driver.name, dev->unique);
 
 	/* Return error if the busid submitted doesn't match the device's actual
 	 * busid.
@@ -131,25 +132,25 @@ int DRM(setunique)(struct inode *inode, struct file *filp,
 }
 
 static int
-DRM(set_busid)(drm_device_t *dev)
+drm_set_busid(drm_device_t *dev)
 {
 	if (dev->unique != NULL)
 		return EBUSY;
 
 	dev->unique_len = 20;
-	dev->unique = DRM(alloc)(dev->unique_len + 1, DRM_MEM_DRIVER);
+	dev->unique = drm_alloc(dev->unique_len + 1, DRM_MEM_DRIVER);
 	if (dev->unique == NULL)
 		return ENOMEM;
 
 	snprintf(dev->unique, dev->unique_len, "pci:%04x:%02x:%02x.%d",
 		dev->pci_domain, dev->pci_bus, dev->pci_slot, dev->pci_func);
 
-	dev->devname = DRM(alloc)(strlen(dev->name) + dev->unique_len + 2,
+	dev->devname = drm_alloc(strlen(dev->driver->pci_driver.name) + dev->unique_len + 2,
 				DRM_MEM_DRIVER);
 	if (dev->devname == NULL)
 		return ENOMEM;
 
-	sprintf(dev->devname, "%s@%s", dev->name, dev->unique);
+	sprintf(dev->devname, "%s@%s", dev->driver->pci_driver.name, dev->unique);
 
 	return 0;
 }
@@ -168,7 +169,7 @@ DRM(set_busid)(drm_device_t *dev)
  * Searches for the mapping with the specified offset and copies its information
  * into userspace
  */
-int DRM(getmap)( struct inode *inode, struct file *filp,
+int drm_getmap( struct inode *inode, struct file *filp,
 		 unsigned int cmd, unsigned long arg )
 {
 	drm_file_t   *priv = filp->private_data;
@@ -228,7 +229,7 @@ int DRM(getmap)( struct inode *inode, struct file *filp,
  * Searches for the client with the specified index and copies its information
  * into userspace
  */
-int DRM(getclient)( struct inode *inode, struct file *filp,
+int drm_getclient( struct inode *inode, struct file *filp,
 		    unsigned int cmd, unsigned long arg )
 {
 	drm_file_t   *priv = filp->private_data;
@@ -272,7 +273,7 @@ int DRM(getclient)( struct inode *inode, struct file *filp,
  * 
  * \return zero on success or a negative number on failure.
  */
-int DRM(getstats)( struct inode *inode, struct file *filp,
+int drm_getstats( struct inode *inode, struct file *filp,
 		   unsigned int cmd, unsigned long arg )
 {
 	drm_file_t   *priv = filp->private_data;
@@ -303,10 +304,7 @@ int DRM(getstats)( struct inode *inode, struct file *filp,
 	return 0;
 }
 
-#define DRM_IF_MAJOR	1
-#define DRM_IF_MINOR	2
-
-int DRM(setversion)(DRM_IOCTL_ARGS)
+int drm_setversion(DRM_IOCTL_ARGS)
 {
 	DRM_DEVICE;
 	drm_set_version_t sv;
@@ -333,7 +331,7 @@ int DRM(setversion)(DRM_IOCTL_ARGS)
 			/*
 			 * Version 1.1 includes tying of DRM to specific device
 			 */
-			DRM(set_busid)(dev);
+			drm_set_busid(dev);
 		}
 	}
 
@@ -342,8 +340,16 @@ int DRM(setversion)(DRM_IOCTL_ARGS)
 		    sv.drm_dd_minor < 0 || sv.drm_dd_minor > DRIVER_MINOR)
 			return EINVAL;
 
-		if (dev->fn_tbl.set_version)
-			dev->fn_tbl.set_version(dev, &sv);
+		if (dev->driver->set_version)
+			dev->driver->set_version(dev, &sv);
 	}
 	return 0;
 }
+
+/** No-op ioctl. */
+int drm_noop(struct inode *inode, struct file *filp, unsigned int cmd,
+	       unsigned long arg)
+{
+	DRM_DEBUG("\n");
+	return 0;
+}

drivers/char/drm/drm_irq.h → drivers/char/drm/drm_irq.c

@@ -50,7 +50,7 @@
  * This IOCTL is deprecated, and will now return EINVAL for any busid not equal
  * to that of the device that this DRM instance attached to.
  */
-int DRM(irq_by_busid)(struct inode *inode, struct file *filp,
+int drm_irq_by_busid(struct inode *inode, struct file *filp,
 		   unsigned int cmd, unsigned long arg)
 {
 	drm_file_t *priv = filp->private_data;
@@ -86,10 +86,10 @@ int DRM(irq_by_busid)(struct inode *inode, struct file *filp,
  * \param irq IRQ number.
  *
  * Initializes the IRQ related data, and setups drm_device::vbl_queue. Installs the handler, calling the driver
- * \c DRM(driver_irq_preinstall)() and \c DRM(driver_irq_postinstall)() functions
+ * \c drm_driver_irq_preinstall() and \c drm_driver_irq_postinstall() functions
  * before and after the installation.
  */
-int DRM(irq_install)( drm_device_t *dev )
+int drm_irq_install( drm_device_t *dev )
 {
 	int ret;
 	unsigned long sh_flags=0;
@@ -128,13 +128,13 @@ int DRM(irq_install)( drm_device_t *dev )
 	}
 
 				/* Before installing handler */
-	dev->fn_tbl.irq_preinstall(dev);
+	dev->driver->irq_preinstall(dev);
 
 				/* Install handler */
 	if (drm_core_check_feature(dev, DRIVER_IRQ_SHARED))
 		sh_flags = SA_SHIRQ;
 	
-	ret = request_irq( dev->irq, dev->fn_tbl.irq_handler,
+	ret = request_irq( dev->irq, dev->driver->irq_handler,
 			   sh_flags, dev->devname, dev );
 	if ( ret < 0 ) {
 		down( &dev->struct_sem );
@@ -144,7 +144,7 @@ int DRM(irq_install)( drm_device_t *dev )
 	}
 
 				/* After installing handler */
-	dev->fn_tbl.irq_postinstall(dev);
+	dev->driver->irq_postinstall(dev);
 
 	return 0;
 }
@@ -154,9 +154,9 @@ int DRM(irq_install)( drm_device_t *dev )
  *
  * \param dev DRM device.
  *
- * Calls the driver's \c DRM(driver_irq_uninstall)() function, and stops the irq.
+ * Calls the driver's \c drm_driver_irq_uninstall() function, and stops the irq.
  */
-int DRM(irq_uninstall)( drm_device_t *dev )
+int drm_irq_uninstall( drm_device_t *dev )
 {
 	int irq_enabled;
 
@@ -173,12 +173,13 @@ int DRM(irq_uninstall)( drm_device_t *dev )
 
 	DRM_DEBUG( "%s: irq=%d\n", __FUNCTION__, dev->irq );
 
-	dev->fn_tbl.irq_uninstall(dev);
+	dev->driver->irq_uninstall(dev);
 
 	free_irq( dev->irq, dev );
 
 	return 0;
 }
+EXPORT_SYMBOL(drm_irq_uninstall);
 
 /**
  * IRQ control ioctl.
@@ -191,7 +192,7 @@ int DRM(irq_uninstall)( drm_device_t *dev )
  *
  * Calls irq_install() or irq_uninstall() according to \p arg.
  */
-int DRM(control)( struct inode *inode, struct file *filp,
+int drm_control( struct inode *inode, struct file *filp,
 		  unsigned int cmd, unsigned long arg )
 {
 	drm_file_t *priv = filp->private_data;
@@ -210,11 +211,11 @@ int DRM(control)( struct inode *inode, struct file *filp,
 		if (dev->if_version < DRM_IF_VERSION(1, 2) &&
 		    ctl.irq != dev->irq)
 			return -EINVAL;
-		return DRM(irq_install)( dev );
+		return drm_irq_install( dev );
 	case DRM_UNINST_HANDLER:
 		if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
 			return 0;
-		return DRM(irq_uninstall)( dev );
+		return drm_irq_uninstall( dev );
 	default:
 		return -EINVAL;
 	}
@@ -239,7 +240,7 @@ int DRM(control)( struct inode *inode, struct file *filp,
  *
  * If a signal is not requested, then calls vblank_wait().
  */
-int DRM(wait_vblank)( DRM_IOCTL_ARGS )
+int drm_wait_vblank( DRM_IOCTL_ARGS )
 {
 	drm_file_t *priv = filp->private_data;
 	drm_device_t *dev = priv->dev;
@@ -300,7 +301,7 @@ int DRM(wait_vblank)( DRM_IOCTL_ARGS )
 
 		spin_unlock_irqrestore( &dev->vbl_lock, irqflags );
 
-		if ( !( vbl_sig = DRM_MALLOC( sizeof( drm_vbl_sig_t ) ) ) ) {
+		if ( !( vbl_sig = drm_alloc( sizeof( drm_vbl_sig_t ), DRM_MEM_DRIVER ) ) ) {
 			return -ENOMEM;
 		}
 
@@ -316,8 +317,8 @@ int DRM(wait_vblank)( DRM_IOCTL_ARGS )
 
 		spin_unlock_irqrestore( &dev->vbl_lock, irqflags );
 	} else {
-		if (dev->fn_tbl.vblank_wait)
-			ret = dev->fn_tbl.vblank_wait( dev, &vblwait.request.sequence );
+		if (dev->driver->vblank_wait)
+			ret = dev->driver->vblank_wait( dev, &vblwait.request.sequence );
 
 		do_gettimeofday( &now );
 		vblwait.reply.tval_sec = now.tv_sec;
@@ -339,7 +340,7 @@ int DRM(wait_vblank)( DRM_IOCTL_ARGS )
  *
  * If a signal is not requested, then calls vblank_wait().
  */
-void DRM(vbl_send_signals)( drm_device_t *dev )
+void drm_vbl_send_signals( drm_device_t *dev )
 {
 	struct list_head *list, *tmp;
 	drm_vbl_sig_t *vbl_sig;
@@ -356,7 +357,7 @@ void DRM(vbl_send_signals)( drm_device_t *dev )
 
 			list_del( list );
 
-			DRM_FREE( vbl_sig, sizeof(*vbl_sig) );
+			drm_free( vbl_sig, sizeof(*vbl_sig), DRM_MEM_DRIVER );
 
 			dev->vbl_pending--;
 		}
@@ -364,5 +365,6 @@ void DRM(vbl_send_signals)( drm_device_t *dev )
 
 	spin_unlock_irqrestore( &dev->vbl_lock, flags );
 }
+EXPORT_SYMBOL(drm_vbl_send_signals);
 
 

drivers/char/drm/drm_lock.h → drivers/char/drm/drm_lock.c

@@ -35,11 +35,146 @@
 
 #include "drmP.h"
 
-/** No-op ioctl. */
-int DRM(noop)(struct inode *inode, struct file *filp, unsigned int cmd,
-	       unsigned long arg)
+/** 
+ * Lock ioctl.
+ *
+ * \param inode device inode.
+ * \param filp file pointer.
+ * \param cmd command.
+ * \param arg user argument, pointing to a drm_lock structure.
+ * \return zero on success or negative number on failure.
+ *
+ * Add the current task to the lock wait queue, and attempt to take to lock.
+ */
+int drm_lock( struct inode *inode, struct file *filp,
+	       unsigned int cmd, unsigned long arg )
+{
+        drm_file_t *priv = filp->private_data;
+        drm_device_t *dev = priv->dev;
+        DECLARE_WAITQUEUE( entry, current );
+        drm_lock_t lock;
+        int ret = 0;
+
+	++priv->lock_count;
+
+        if ( copy_from_user( &lock, (drm_lock_t __user *)arg, sizeof(lock) ) )
+		return -EFAULT;
+
+        if ( lock.context == DRM_KERNEL_CONTEXT ) {
+                DRM_ERROR( "Process %d using kernel context %d\n",
+			   current->pid, lock.context );
+                return -EINVAL;
+        }
+
+        DRM_DEBUG( "%d (pid %d) requests lock (0x%08x), flags = 0x%08x\n",
+		   lock.context, current->pid,
+		   dev->lock.hw_lock->lock, lock.flags );
+
+	if (drm_core_check_feature(dev, DRIVER_DMA_QUEUE))
+		if ( lock.context < 0 )
+			return -EINVAL;
+
+	add_wait_queue( &dev->lock.lock_queue, &entry );
+	for (;;) {
+		__set_current_state(TASK_INTERRUPTIBLE);
+		if ( !dev->lock.hw_lock ) {
+			/* Device has been unregistered */
+			ret = -EINTR;
+			break;
+		}
+		if ( drm_lock_take( &dev->lock.hw_lock->lock,
+				     lock.context ) ) {
+			dev->lock.filp      = filp;
+			dev->lock.lock_time = jiffies;
+			atomic_inc( &dev->counts[_DRM_STAT_LOCKS] );
+			break;  /* Got lock */
+		}
+		
+		/* Contention */
+		schedule();
+		if ( signal_pending( current ) ) {
+			ret = -ERESTARTSYS;
+			break;
+		}
+	}
+	__set_current_state(TASK_RUNNING);
+	remove_wait_queue( &dev->lock.lock_queue, &entry );
+
+	sigemptyset( &dev->sigmask );
+	sigaddset( &dev->sigmask, SIGSTOP );
+	sigaddset( &dev->sigmask, SIGTSTP );
+	sigaddset( &dev->sigmask, SIGTTIN );
+	sigaddset( &dev->sigmask, SIGTTOU );
+	dev->sigdata.context = lock.context;
+	dev->sigdata.lock    = dev->lock.hw_lock;
+	block_all_signals( drm_notifier,
+			   &dev->sigdata, &dev->sigmask );
+	
+	if (dev->driver->dma_ready && (lock.flags & _DRM_LOCK_READY))
+		dev->driver->dma_ready(dev);
+	
+	if ( dev->driver->dma_quiescent && (lock.flags & _DRM_LOCK_QUIESCENT ))
+		return dev->driver->dma_quiescent(dev);
+	
+	/* dev->driver->kernel_context_switch isn't used by any of the x86 
+	 *  drivers but is used by the Sparc driver.
+	 */
+	
+	if (dev->driver->kernel_context_switch && 
+	    dev->last_context != lock.context) {
+	  dev->driver->kernel_context_switch(dev, dev->last_context, 
+					    lock.context);
+	}
+        DRM_DEBUG( "%d %s\n", lock.context, ret ? "interrupted" : "has lock" );
+
+        return ret;
+}
+
+/** 
+ * Unlock ioctl.
+ *
+ * \param inode device inode.
+ * \param filp file pointer.
+ * \param cmd command.
+ * \param arg user argument, pointing to a drm_lock structure.
+ * \return zero on success or negative number on failure.
+ *
+ * Transfer and free the lock.
+ */
+int drm_unlock( struct inode *inode, struct file *filp,
+		 unsigned int cmd, unsigned long arg )
 {
-	DRM_DEBUG("\n");
+	drm_file_t *priv = filp->private_data;
+	drm_device_t *dev = priv->dev;
+	drm_lock_t lock;
+
+	if ( copy_from_user( &lock, (drm_lock_t __user *)arg, sizeof(lock) ) )
+		return -EFAULT;
+
+	if ( lock.context == DRM_KERNEL_CONTEXT ) {
+		DRM_ERROR( "Process %d using kernel context %d\n",
+			   current->pid, lock.context );
+		return -EINVAL;
+	}
+
+	atomic_inc( &dev->counts[_DRM_STAT_UNLOCKS] );
+
+	/* kernel_context_switch isn't used by any of the x86 drm
+	 * modules but is required by the Sparc driver.
+	 */
+	if (dev->driver->kernel_context_switch_unlock)
+		dev->driver->kernel_context_switch_unlock(dev, &lock);
+	else {
+		drm_lock_transfer( dev, &dev->lock.hw_lock->lock, 
+				    DRM_KERNEL_CONTEXT );
+		
+		if ( drm_lock_free( dev, &dev->lock.hw_lock->lock,
+				     DRM_KERNEL_CONTEXT ) ) {
+			DRM_ERROR( "\n" );
+		}
+	}
+
+	unblock_all_signals();
 	return 0;
 }
 
@@ -52,7 +187,7 @@ int DRM(noop)(struct inode *inode, struct file *filp, unsigned int cmd,
  *
  * Attempt to mark the lock as held by the given context, via the \p cmpxchg instruction.
  */
-int DRM(lock_take)(__volatile__ unsigned int *lock, unsigned int context)
+int drm_lock_take(__volatile__ unsigned int *lock, unsigned int context)
 {
 	unsigned int old, new, prev;
 
@@ -90,7 +225,7 @@ int DRM(lock_take)(__volatile__ unsigned int *lock, unsigned int context)
  * Resets the lock file pointer.
  * Marks the lock as held by the given context, via the \p cmpxchg instruction.
  */
-int DRM(lock_transfer)(drm_device_t *dev,
+int drm_lock_transfer(drm_device_t *dev,
 		       __volatile__ unsigned int *lock, unsigned int context)
 {
 	unsigned int old, new, prev;
@@ -115,7 +250,7 @@ int DRM(lock_transfer)(drm_device_t *dev,
  * Marks the lock as not held, via the \p cmpxchg instruction. Wakes any task
  * waiting on the lock queue.
  */
-int DRM(lock_free)(drm_device_t *dev,
+int drm_lock_free(drm_device_t *dev,
 		   __volatile__ unsigned int *lock, unsigned int context)
 {
 	unsigned int old, new, prev;
@@ -147,7 +282,7 @@ int DRM(lock_free)(drm_device_t *dev,
  * \return one if the signal should be delivered normally, or zero if the
  * signal should be blocked.
  */
-int DRM(notifier)(void *priv)
+int drm_notifier(void *priv)
 {
 	drm_sigdata_t *s = (drm_sigdata_t *)priv;
 	unsigned int  old, new, prev;

drivers/char/drm/drm_fops.h → drivers/char/drm/drm_memory.c

-/**
- * \file drm_fops.h 
- * File operations for DRM
- * 
+/** 
+ * \file drm_memory.h 
+ * Memory management wrappers for DRM
+ *
  * \author Rickard E. (Rik) Faith <faith@valinux.com>
- * \author Daryll Strauss <daryll@valinux.com>
  * \author Gareth Hughes <gareth@valinux.com>
  */
 
-/*
- * Created: Mon Jan  4 08:58:31 1999 by faith@valinux.com
+/* 
+ * Created: Thu Feb  4 14:00:34 1999 by faith@valinux.com
  *
  * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
  * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
@@ -34,123 +33,149 @@
  * OTHER DEALINGS IN THE SOFTWARE.
  */
 
+#include <linux/config.h>
+#include <linux/highmem.h>
 #include "drmP.h"
-#include <linux/poll.h>
 
+#ifdef DEBUG_MEMORY
+#include "drm_memory_debug.h"
+#else
+
+/** No-op. */
+void drm_mem_init(void)
+{
+}
 
 /**
- * Called whenever a process opens /dev/drm. 
- *
- * \param inode device inode.
- * \param filp file pointer.
- * \param dev device.
- * \return zero on success or a negative number on failure.
+ * Called when "/proc/dri/%dev%/mem" is read.
  * 
- * Creates and initializes a drm_file structure for the file private data in \p
- * filp and add it into the double linked list in \p dev.
+ * \param buf output buffer.
+ * \param start start of output data.
+ * \param offset requested start offset.
+ * \param len requested number of bytes.
+ * \param eof whether there is no more data to return.
+ * \param data private data.
+ * \return number of written bytes.
+ *
+ * No-op. 
  */
-int DRM(open_helper)(struct inode *inode, struct file *filp, drm_device_t *dev)
+int drm_mem_info(char *buf, char **start, off_t offset,
+		  int len, int *eof, void *data)
 {
-	int	     minor = iminor(inode);
-	drm_file_t   *priv;
-	int ret;
-
-	if (filp->f_flags & O_EXCL)   return -EBUSY; /* No exclusive opens */
-	if (!DRM(cpu_valid)())        return -EINVAL;
-
-	DRM_DEBUG("pid = %d, minor = %d\n", current->pid, minor);
-
-	priv		    = DRM(alloc)(sizeof(*priv), DRM_MEM_FILES);
-	if(!priv) return -ENOMEM;
-
-	memset(priv, 0, sizeof(*priv));
-	filp->private_data  = priv;
-	priv->uid	    = current->euid;
-	priv->pid	    = current->pid;
-	priv->minor	    = minor;
-	priv->dev	    = dev;
-	priv->ioctl_count   = 0;
-	priv->authenticated = capable(CAP_SYS_ADMIN);
-	priv->lock_count    = 0;
-
-	if (dev->fn_tbl.open_helper) {
-		ret=dev->fn_tbl.open_helper(dev, priv);
-		if (ret < 0)
-			goto out_free;
-	}
+	return 0;
+}
+
+/** Wrapper around kmalloc() */
+void *drm_calloc(size_t nmemb, size_t size, int area)
+{
+	void *addr;
+
+	addr = kmalloc(size * nmemb, GFP_KERNEL);
+	if (addr != NULL)
+		memset((void *)addr, 0, size * nmemb);
+
+	return addr;
+}
+EXPORT_SYMBOL(drm_calloc);
 
-	down(&dev->struct_sem);
-	if (!dev->file_last) {
-		priv->next	= NULL;
-		priv->prev	= NULL;
-		dev->file_first = priv;
-		dev->file_last	= priv;
-	} else {
-		priv->next	     = NULL;
-		priv->prev	     = dev->file_last;
-		dev->file_last->next = priv;
-		dev->file_last	     = priv;
+/** Wrapper around kmalloc() and kfree() */
+void *drm_realloc(void *oldpt, size_t oldsize, size_t size, int area)
+{
+	void *pt;
+
+	if (!(pt = kmalloc(size, GFP_KERNEL))) return NULL;
+	if (oldpt && oldsize) {
+		memcpy(pt, oldpt, oldsize);
+		kfree(oldpt);
 	}
-	up(&dev->struct_sem);
-
-#ifdef __alpha__
-	/*
-	 * Default the hose
-	 */
-	if (!dev->hose) {
-		struct pci_dev *pci_dev;
-		pci_dev = pci_get_class(PCI_CLASS_DISPLAY_VGA << 8, NULL);
-		if (pci_dev) {
-			dev->hose = pci_dev->sysdata;
-			pci_dev_put(pci_dev);
-		}
-		if (!dev->hose) {
-			struct pci_bus *b = pci_bus_b(pci_root_buses.next);
-			if (b) dev->hose = b->sysdata;
-		}
+	return pt;
+}
+
+/**
+ * Allocate pages.
+ *
+ * \param order size order.
+ * \param area memory area. (Not used.)
+ * \return page address on success, or zero on failure.
+ *
+ * Allocate and reserve free pages.
+ */
+unsigned long drm_alloc_pages(int order, int area)
+{
+	unsigned long address;
+	unsigned long bytes	  = PAGE_SIZE << order;
+	unsigned long addr;
+	unsigned int  sz;
+
+	address = __get_free_pages(GFP_KERNEL, order);
+	if (!address) 
+		return 0;
+
+				/* Zero */
+	memset((void *)address, 0, bytes);
+
+				/* Reserve */
+	for (addr = address, sz = bytes;
+	     sz > 0;
+	     addr += PAGE_SIZE, sz -= PAGE_SIZE) {
+		SetPageReserved(virt_to_page(addr));
 	}
-#endif
 
-	return 0;
-out_free:
-	DRM(free)(priv, sizeof(*priv), DRM_MEM_FILES);
-	filp->private_data=NULL;
-	return ret;
+	return address;
 }
 
-/** No-op. */
-int DRM(flush)(struct file *filp)
+/**
+ * Free pages.
+ * 
+ * \param address address of the pages to free.
+ * \param order size order.
+ * \param area memory area. (Not used.)
+ *
+ * Unreserve and free pages allocated by alloc_pages().
+ */
+void drm_free_pages(unsigned long address, int order, int area)
 {
-	drm_file_t    *priv   = filp->private_data;
-	drm_device_t  *dev    = priv->dev;
+	unsigned long bytes = PAGE_SIZE << order;
+	unsigned long addr;
+	unsigned int  sz;
+
+	if (!address) 
+		return;
+
+	/* Unreserve */
+	for (addr = address, sz = bytes;
+	     sz > 0;
+	     addr += PAGE_SIZE, sz -= PAGE_SIZE) {
+		ClearPageReserved(virt_to_page(addr));
+	}
 
-	DRM_DEBUG("pid = %d, device = 0x%lx, open_count = %d\n",
-		  current->pid, (long)old_encode_dev(dev->device), dev->open_count);
-	return 0;
+	free_pages(address, order);
 }
 
-/** No-op. */
-int DRM(fasync)(int fd, struct file *filp, int on)
-{
-	drm_file_t    *priv   = filp->private_data;
-	drm_device_t  *dev    = priv->dev;
-	int	      retcode;
 
-	DRM_DEBUG("fd = %d, device = 0x%lx\n", fd, (long)old_encode_dev(dev->device));
-	retcode = fasync_helper(fd, filp, on, &dev->buf_async);
-	if (retcode < 0) return retcode;
-	return 0;
+#if __OS_HAS_AGP
+/** Wrapper around agp_allocate_memory() */
+DRM_AGP_MEM *drm_alloc_agp(int pages, u32 type)
+{
+	return drm_agp_allocate_memory(pages, type);
 }
 
-/** No-op. */
-unsigned int DRM(poll)(struct file *filp, struct poll_table_struct *wait)
+/** Wrapper around agp_free_memory() */
+int drm_free_agp(DRM_AGP_MEM *handle, int pages)
 {
-	return 0;
+	return drm_agp_free_memory(handle) ? 0 : -EINVAL;
 }
 
+/** Wrapper around agp_bind_memory() */
+int drm_bind_agp(DRM_AGP_MEM *handle, unsigned int start)
+{
+	return drm_agp_bind_memory(handle, start);
+}
 
-/** No-op. */
-ssize_t DRM(read)(struct file *filp, char __user *buf, size_t count, loff_t *off)
+/** Wrapper around agp_unbind_memory() */
+int drm_unbind_agp(DRM_AGP_MEM *handle)
 {
-	return 0;
+	return drm_agp_unbind_memory(handle);
 }
+#endif /* agp */
+#endif /* debug_memory */

drivers/char/drm/drm_memory_debug.h

@@ -167,7 +167,7 @@ void *DRM(alloc)(size_t size, int area)
 	return pt;
 }
 
-void *DRM(calloc)(size_t size, size_t nmemb, int area)
+void *DRM(calloc)(size_t nmemb, size_t size, int area)
 {
 	void *addr;
 

drivers/char/drm/drm_os_linux.h

@@ -100,11 +100,6 @@ static __inline__ int mtrr_del (int reg, unsigned long base,
 	__put_user(val, uaddr)
 
 
-/** 'malloc' without the overhead of DRM(alloc)() */
-#define DRM_MALLOC(x) kmalloc(x, GFP_KERNEL)
-/** 'free' without the overhead of DRM(free)() */
-#define DRM_FREE(x,size) kfree(x)
-
 #define DRM_GET_PRIV_WITH_RETURN(_priv, _filp) _priv = _filp->private_data
 
 /** 

drivers/char/drm/drm_scatter.h → drivers/char/drm/drm_scatter.c

@@ -37,7 +37,7 @@
 
 #define DEBUG_SCATTER 0
 
-void DRM(sg_cleanup)( drm_sg_mem_t *entry )
+void drm_sg_cleanup( drm_sg_mem_t *entry )
 {
 	struct page *page;
 	int i;
@@ -50,18 +50,18 @@ void DRM(sg_cleanup)( drm_sg_mem_t *entry )
 
 	vfree( entry->virtual );
 
-	DRM(free)( entry->busaddr,
+	drm_free( entry->busaddr,
 		   entry->pages * sizeof(*entry->busaddr),
 		   DRM_MEM_PAGES );
-	DRM(free)( entry->pagelist,
+	drm_free( entry->pagelist,
 		   entry->pages * sizeof(*entry->pagelist),
 		   DRM_MEM_PAGES );
-	DRM(free)( entry,
+	drm_free( entry,
 		   sizeof(*entry),
 		   DRM_MEM_SGLISTS );
 }
 
-int DRM(sg_alloc)( struct inode *inode, struct file *filp,
+int drm_sg_alloc( struct inode *inode, struct file *filp,
 		   unsigned int cmd, unsigned long arg )
 {
 	drm_file_t *priv = filp->private_data;
@@ -82,7 +82,7 @@ int DRM(sg_alloc)( struct inode *inode, struct file *filp,
 	if ( copy_from_user( &request, argp, sizeof(request) ) )
 		return -EFAULT;
 
-	entry = DRM(alloc)( sizeof(*entry), DRM_MEM_SGLISTS );
+	entry = drm_alloc( sizeof(*entry), DRM_MEM_SGLISTS );
 	if ( !entry )
 		return -ENOMEM;
 
@@ -92,22 +92,22 @@ int DRM(sg_alloc)( struct inode *inode, struct file *filp,
 	DRM_DEBUG( "sg size=%ld pages=%ld\n", request.size, pages );
 
 	entry->pages = pages;
-	entry->pagelist = DRM(alloc)( pages * sizeof(*entry->pagelist),
+	entry->pagelist = drm_alloc( pages * sizeof(*entry->pagelist),
 				     DRM_MEM_PAGES );
 	if ( !entry->pagelist ) {
-		DRM(free)( entry, sizeof(*entry), DRM_MEM_SGLISTS );
+		drm_free( entry, sizeof(*entry), DRM_MEM_SGLISTS );
 		return -ENOMEM;
 	}
 
 	memset(entry->pagelist, 0, pages * sizeof(*entry->pagelist));
 
-	entry->busaddr = DRM(alloc)( pages * sizeof(*entry->busaddr),
+	entry->busaddr = drm_alloc( pages * sizeof(*entry->busaddr),
 				     DRM_MEM_PAGES );
 	if ( !entry->busaddr ) {
-		DRM(free)( entry->pagelist,
+		drm_free( entry->pagelist,
 			   entry->pages * sizeof(*entry->pagelist),
 			   DRM_MEM_PAGES );
-		DRM(free)( entry,
+		drm_free( entry,
 			   sizeof(*entry),
 			   DRM_MEM_SGLISTS );
 		return -ENOMEM;
@@ -116,13 +116,13 @@ int DRM(sg_alloc)( struct inode *inode, struct file *filp,
 
 	entry->virtual = vmalloc_32( pages << PAGE_SHIFT );
 	if ( !entry->virtual ) {
-		DRM(free)( entry->busaddr,
+		drm_free( entry->busaddr,
 			   entry->pages * sizeof(*entry->busaddr),
 			   DRM_MEM_PAGES );
-		DRM(free)( entry->pagelist,
+		drm_free( entry->pagelist,
 			   entry->pages * sizeof(*entry->pagelist),
 			   DRM_MEM_PAGES );
-		DRM(free)( entry,
+		drm_free( entry,
 			   sizeof(*entry),
 			   DRM_MEM_SGLISTS );
 		return -ENOMEM;
@@ -148,7 +148,7 @@ int DRM(sg_alloc)( struct inode *inode, struct file *filp,
 	request.handle = entry->handle;
 
 	if ( copy_to_user( argp, &request, sizeof(request) ) ) {
-		DRM(sg_cleanup)( entry );
+		drm_sg_cleanup( entry );
 		return -EFAULT;
 	}
 
@@ -197,11 +197,11 @@ int DRM(sg_alloc)( struct inode *inode, struct file *filp,
 	return 0;
 
  failed:
-	DRM(sg_cleanup)( entry );
+	drm_sg_cleanup( entry );
 	return -ENOMEM;
 }
 
-int DRM(sg_free)( struct inode *inode, struct file *filp,
+int drm_sg_free( struct inode *inode, struct file *filp,
 		 unsigned int cmd, unsigned long arg )
 {
 	drm_file_t *priv = filp->private_data;
@@ -225,7 +225,7 @@ int DRM(sg_free)( struct inode *inode, struct file *filp,
 
 	DRM_DEBUG( "sg free virtual  = %p\n", entry->virtual );
 
-	DRM(sg_cleanup)( entry );
+	drm_sg_cleanup( entry );
 
 	return 0;
 }

drivers/char/drm/gamma_dma.c

@@ -937,10 +937,10 @@ void gamma_driver_register_fns(drm_device_t *dev)
 	dev->driver_features = DRIVER_USE_AGP | DRIVER_USE_MTRR | DRIVER_PCI_DMA | DRIVER_HAVE_DMA | DRIVER_HAVE_IRQ;
 	DRM(fops).read = gamma_fops_read;
 	DRM(fops).poll = gamma_fops_poll;
-	dev->fn_tbl.preinit = gamma_driver_preinit;
-	dev->fn_tbl.pretakedown = gamma_driver_pretakedown;
-	dev->fn_tbl.dma_ready = gamma_driver_dma_ready;
-	dev->fn_tbl.dma_quiescent = gamma_driver_dma_quiescent;
-	dev->fn_tbl.dma_flush_block_and_flush = gamma_flush_block_and_flush;
-	dev->fn_tbl.dma_flush_unblock = gamma_flush_unblock;
+	dev->driver.preinit = gamma_driver_preinit;
+	dev->driver.pretakedown = gamma_driver_pretakedown;
+	dev->driver.dma_ready = gamma_driver_dma_ready;
+	dev->driver.dma_quiescent = gamma_driver_dma_quiescent;
+	dev->driver.dma_flush_block_and_flush = gamma_flush_block_and_flush;
+	dev->driver.dma_flush_unblock = gamma_flush_unblock;
 }

drivers/char/drm/mga_state.c

@@ -32,7 +32,6 @@
  *    Gareth Hughes <gareth@valinux.com>
  */
 
-#include "mga.h"
 #include "drmP.h"
 #include "drm.h"
 #include "mga_drm.h"