drm: device minor fixups and /proc fixups

This patch fixes up the DRM to do better minor number accounting
and /proc directory creation, the old code was buggy in a number
of situations with multiple cards, and rather ugly. It is also 
a step on the way to the drm_core module.

From: Jon Smirl and Dave Airlie
Signed-off-by: Dave Airlie <airlied@linux.ie>

drivers/char/drm/drmP.h

@@ -57,6 +57,7 @@
 #include <linux/jiffies.h>
 #include <linux/smp_lock.h>	/* For (un)lock_kernel */
 #include <linux/mm.h>
+#include <linux/cdev.h>
 #if defined(__alpha__) || defined(__powerpc__)
 #include <asm/pgtable.h> /* For pte_wrprotect */
 #endif
@@ -695,12 +696,31 @@ typedef struct drm_device {
 	drm_sigdata_t     sigdata; /**< For block_all_signals */
 	sigset_t          sigmask;
 
+	struct file_operations *fops;	/**< file operations */
+	struct proc_dir_entry  *dev_root; /**< proc directory entry */
+
 	struct            drm_driver_fn fn_tbl;
 	drm_local_map_t   *agp_buffer_map;
 	int               dev_priv_size;
 	u32               driver_features;
 } drm_device_t;
 
+typedef struct drm_minor {
+	enum {
+		DRM_MINOR_FREE = 0,
+		DRM_MINOR_PRIMARY,
+	} type;
+	drm_device_t *dev;
+	struct proc_dir_entry  *dev_root; /**< proc directory entry */
+} drm_minor_t;
+
+typedef struct drm_global {
+	unsigned int cards_limit;
+	drm_minor_t *minors;
+	struct class_simple *drm_class;
+	struct proc_dir_entry *proc_root;
+} drm_global_t;
+
 static __inline__ int drm_core_check_feature(struct drm_device *dev, int feature)
 {
 	return ((dev->driver_features & feature) ? 1 : 0);
@@ -921,13 +941,12 @@ extern int            DRM(agp_bind_memory)(DRM_AGP_MEM *handle, off_t start);
 extern int            DRM(agp_unbind_memory)(DRM_AGP_MEM *handle);
 
 				/* Stub support (drm_stub.h) */
-int                   DRM(stub_register)(const char *name,
-					 struct file_operations *fops,
-					 drm_device_t *dev);
-int                   DRM(stub_unregister)(int minor);
+extern int 	      DRM(probe)(struct pci_dev *pdev, const struct pci_device_id *ent);
+extern int 	      DRM(put_minor)(drm_device_t *dev);
+extern drm_global_t   *DRM(global);
 
 				/* Proc support (drm_proc.h) */
-extern struct proc_dir_entry *DRM(proc_init)(drm_device_t *dev,
+extern int            DRM(proc_init)(drm_device_t *dev,
 					     int minor,
 					     struct proc_dir_entry *root,
 					     struct proc_dir_entry **dev_root);

drivers/char/drm/drm_drv.h

@@ -74,10 +74,6 @@ __setup( DRIVER_NAME "=", DRM_OPTIONS_FUNC );
 #undef DRM_OPTIONS_FUNC
 #endif
 
-#define MAX_DEVICES 4
-static drm_device_t	DRM(device)[MAX_DEVICES];
-static int		DRM(numdevs) = 0;
-
 struct file_operations	DRM(fops) = {
 	.owner   = THIS_MODULE,
 	.open	 = DRM(open),
@@ -158,15 +154,6 @@ drm_ioctl_desc_t		  DRM(ioctls)[] = {
 
 #define DRIVER_IOCTL_COUNT	DRM_ARRAY_SIZE( DRM(ioctls) )
 
-#ifdef MODULE
-static char *drm_opts = NULL;
-#endif
-
-MODULE_AUTHOR( DRIVER_AUTHOR );
-MODULE_DESCRIPTION( DRIVER_DESC );
-MODULE_PARM( drm_opts, "s" );
-MODULE_LICENSE("GPL and additional rights");
-
 static int DRM(setup)( drm_device_t *dev )
 {
 	int i;
@@ -420,44 +407,19 @@ static struct pci_device_id DRM(pciidlist)[] = {
 	DRM(PCI_IDS)
 };
 
-static int DRM(probe)(struct pci_dev *pdev)
+int DRM(fill_in_dev)(drm_device_t *dev, struct pci_dev *pdev, const struct pci_device_id *ent)
 {
-	drm_device_t *dev;
 	int retcode;
-	int i;
-	int is_compat = 0;
-
-	DRM_DEBUG( "\n" );
-
-	for (i = 0; DRM(pciidlist)[i].vendor != 0; i++) {
-		if ((DRM(pciidlist)[i].vendor == pdev->vendor) &&
-		    (DRM(pciidlist)[i].device == pdev->device)) {
-			is_compat = 1;
-		}
-	}
-	if (is_compat == 0)
-		return -ENODEV;
-
-	if (DRM(numdevs) >= MAX_DEVICES)
-		return -ENODEV;
-
-	if ((retcode=pci_enable_device(pdev)))
-		return retcode;
-
-	dev = &(DRM(device)[DRM(numdevs)]);
 
-	memset( (void *)dev, 0, sizeof(*dev) );
 	dev->count_lock = SPIN_LOCK_UNLOCKED;
 	init_timer( &dev->timer );
 	sema_init( &dev->struct_sem, 1 );
 	sema_init( &dev->ctxlist_sem, 1 );
 
-	if ((dev->minor = DRM(stub_register)(DRIVER_NAME, &DRM(fops),dev)) < 0)
-		return -EPERM;
-	dev->device = MKDEV(DRM_MAJOR, dev->minor );
 	dev->name   = DRIVER_NAME;
-
+	dev->fops   = &DRM(fops);
 	dev->pdev   = pdev;
+
 #ifdef __alpha__
 	dev->hose   = pdev->sysdata;
 	dev->pci_domain = dev->hose->bus->number;
@@ -486,16 +448,15 @@ static int DRM(probe)(struct pci_dev *pdev)
 	DRM(driver_register_fns)(dev);
 
 	if (dev->fn_tbl.preinit)
-	  dev->fn_tbl.preinit(dev);
+		if ((retcode = dev->fn_tbl.preinit(dev)))
+			goto error_out_unreg;
 
-	if (drm_core_has_AGP(dev))
-	{
+	if (drm_core_has_AGP(dev)) {
 		dev->agp = DRM(agp_init)();
 		if (drm_core_check_feature(dev, DRIVER_REQUIRE_AGP) && (dev->agp == NULL)) {
 			DRM_ERROR( "Cannot initialize the agpgart module.\n" );
-			DRM(stub_unregister)(dev->minor);
-			DRM(takedown)( dev );
-			return -EINVAL;
+			retcode = -EINVAL;
+			goto error_out_unreg;
 		}
 		if (drm_core_has_MTRR(dev)) {
 			if (dev->agp)
@@ -509,13 +470,11 @@ static int DRM(probe)(struct pci_dev *pdev)
 	retcode = DRM(ctxbitmap_init)( dev );
 	if( retcode ) {
 		DRM_ERROR( "Cannot allocate memory for context bitmap.\n" );
-		DRM(stub_unregister)(dev->minor);
-		DRM(takedown)( dev );
-		return retcode;
+		goto error_out_unreg;
 	}
 
-	DRM(numdevs)++; /* no errors, mark it reserved */
-	
+	dev->device = MKDEV(DRM_MAJOR, dev->minor );
+
 	DRM_INFO( "Initialized %s %d.%d.%d %s on minor %d: %s\n",
 		DRIVER_NAME,
 		DRIVER_MAJOR,
@@ -526,11 +485,21 @@ static int DRM(probe)(struct pci_dev *pdev)
 		pci_pretty_name(pdev));
 
 	if (dev->fn_tbl.postinit)
-	  dev->fn_tbl.postinit(dev);
+		if ((retcode = dev->fn_tbl.postinit(dev)))
+			goto error_out_unreg;
 
 	return 0;
+	
+error_out_unreg:
+	DRM(takedown)(dev);
+	return retcode;
 }
 
+#ifdef MODULE
+static char *drm_opts = NULL;
+#endif
+MODULE_PARM( drm_opts, "s" );
+
 /**
  * Module initialization. Called via init_module at module load time, or via
  * linux/init/main.c (this is not currently supported).
@@ -547,6 +516,8 @@ static int DRM(probe)(struct pci_dev *pdev)
 static int __init drm_init( void )
 {
 	struct pci_dev *pdev = NULL;
+	struct pci_device_id *pid;
+	int i;
 
 	DRM_DEBUG( "\n" );
 
@@ -556,8 +527,16 @@ static int __init drm_init( void )
 
 	DRM(mem_init)();
 
-	while ((pdev = pci_find_device(PCI_ANY_ID, PCI_ANY_ID, pdev)) != NULL) {
-		DRM(probe)(pdev);
+	for (i=0; DRM(pciidlist)[i].vendor != 0; i++) {
+		pid = &DRM(pciidlist[i]);
+		
+		pdev=NULL;
+		/* pass back in pdev to account for multiple identical cards */		
+		while ((pdev = pci_get_subsys(pid->vendor, pid->device, pid->subvendor, pid->subdevice, pdev)) != NULL) {
+			/* stealth mode requires a manual probe */
+			pci_dev_get(pdev);
+			DRM(probe)(pdev, pid);
+		}
 	}
 	return 0;
 }
@@ -569,52 +548,68 @@ static int __init drm_init( void )
  * 
  * \sa drm_init().
  */
-static void __exit drm_cleanup( void )
+static void __exit drm_cleanup( drm_device_t *dev )
 {
-	drm_device_t *dev;
-	int i;
-
 	DRM_DEBUG( "\n" );
 
-	for (i = DRM(numdevs) - 1; i >= 0; i--) {
-		dev = &(DRM(device)[i]);
-		if ( DRM(stub_unregister)(dev->minor) ) {
-			DRM_ERROR( "Cannot unload module\n" );
-		} else {
-			DRM_DEBUG("minor %d unregistered\n", dev->minor);
-			if (i == 0) {
-				DRM_INFO( "Module unloaded\n" );
-			}
-		}
+	if (!dev) {
+		DRM_ERROR("cleanup called no dev\n");
+		return;
+	}
 
-		DRM(ctxbitmap_cleanup)( dev );
+	DRM(takedown)( dev );	
 
-		if (drm_core_has_MTRR(dev) && drm_core_has_AGP(dev) &&
-		    dev->agp && dev->agp->agp_mtrr >= 0) {
-			int retval;
-			retval = mtrr_del( dev->agp->agp_mtrr,
+	DRM(ctxbitmap_cleanup)( dev );
+	
+	if (drm_core_has_MTRR(dev) && drm_core_has_AGP(dev) &&
+	    dev->agp && dev->agp->agp_mtrr >= 0) {
+		int retval;
+		retval = mtrr_del( dev->agp->agp_mtrr,
 				   dev->agp->agp_info.aper_base,
 				   dev->agp->agp_info.aper_size*1024*1024 );
-			DRM_DEBUG( "mtrr_del=%d\n", retval );
-		}
+		DRM_DEBUG( "mtrr_del=%d\n", retval );
+	}
+	
+	if (drm_core_has_AGP(dev) && dev->agp ) {
+		DRM(agp_uninit)();
+		DRM(free)( dev->agp, sizeof(*dev->agp), DRM_MEM_AGPLISTS );
+		dev->agp = NULL;
+	}
 
-		DRM(takedown)( dev );
+	if (dev->fn_tbl.postcleanup)
+		dev->fn_tbl.postcleanup(dev);
+	
+	if ( DRM(put_minor)(dev) )
+		DRM_ERROR( "Cannot unload module\n" );
+}
 
-		if (drm_core_has_AGP(dev) && dev->agp ) {
-			DRM(agp_uninit)();
-			DRM(free)( dev->agp, sizeof(*dev->agp), DRM_MEM_AGPLISTS );
-			dev->agp = NULL;
-		}
 
-		if (dev->fn_tbl.postcleanup)
-		  dev->fn_tbl.postcleanup(dev);
+static void __exit drm_exit (void)
+{
+	int i;
+	drm_device_t *dev;
+	drm_minor_t *minor;
+	
+	DRM_DEBUG( "\n" );
+
+	if (DRM(global)) {
+		for (i = 0; DRM(global) && (i < DRM(global)->cards_limit); i++) {
+			minor = &DRM(global)->minors[i];
+			dev = minor->dev;
 
-	}
-	DRM(numdevs) = 0;
+			if ((minor->type == DRM_MINOR_PRIMARY) && (dev->fops == &DRM(fops))) {
+				/* release the pci driver */
+				if (dev->pdev)
+					pci_dev_put(dev->pdev);
+				drm_cleanup(dev);
+			}
+		}
+	} 
+	DRM_INFO( "Module unloaded\n" );
 }
 
 module_init( drm_init );
-module_exit( drm_cleanup );
+module_exit( drm_exit );
 
 
 /**
@@ -674,19 +669,16 @@ int DRM(version)( struct inode *inode, struct file *filp,
 int DRM(open)( struct inode *inode, struct file *filp )
 {
 	drm_device_t *dev = NULL;
+	int minor = iminor(inode);
 	int retcode = 0;
-	int i;
 
-	for (i = 0; i < DRM(numdevs); i++) {
-		if (iminor(inode) == DRM(device)[i].minor) {
-			dev = &(DRM(device)[i]);
-			break;
-		}
-	}
-	if (!dev) {
+	if (!((minor >= 0) && (minor < DRM(global)->cards_limit)))
 		return -ENODEV;
-	}
-
+		
+	dev = DRM(global)->minors[minor].dev;
+	if (!dev)
+		return -ENODEV;
+	
 	retcode = DRM(open_helper)( inode, filp, dev );
 	if ( !retcode ) {
 		atomic_inc( &dev->counts[_DRM_STAT_OPENS] );

drivers/char/drm/drm_proc.h

@@ -86,25 +86,19 @@ struct drm_proc_list {
  * "/proc/dri/%minor%/", and each entry in proc_list as
  * "/proc/dri/%minor%/%name%".
  */
-struct proc_dir_entry *DRM(proc_init)(drm_device_t *dev, int minor,
-				      struct proc_dir_entry *root,
-				      struct proc_dir_entry **dev_root)
+int DRM(proc_init)(drm_device_t *dev, int minor,
+		    struct proc_dir_entry *root,
+		    struct proc_dir_entry **dev_root)
 {
 	struct proc_dir_entry *ent;
 	int		      i, j;
 	char                  name[64];
 
-	if (!minor) root = create_proc_entry("dri", S_IFDIR, NULL);
-	if (!root) {
-		DRM_ERROR("Cannot create /proc/dri\n");
-		return NULL;
-	}
-
 	sprintf(name, "%d", minor);
 	*dev_root = create_proc_entry(name, S_IFDIR, root);
 	if (!*dev_root) {
 		DRM_ERROR("Cannot create /proc/dri/%s\n", name);
-		return NULL;
+		return -1;
 	}
 
 	for (i = 0; i < DRM_PROC_ENTRIES; i++) {
@@ -117,14 +111,13 @@ struct proc_dir_entry *DRM(proc_init)(drm_device_t *dev, int minor,
 				remove_proc_entry(DRM(proc_list)[i].name,
 						  *dev_root);
 			remove_proc_entry(name, root);
-			if (!minor) remove_proc_entry("dri", NULL);
-			return NULL;
+			return -1;
 		}
 		ent->read_proc = DRM(proc_list)[i].f;
 		ent->data      = dev;
 	}
 
-	return root;
+	return 0;
 }
 
 
@@ -150,7 +143,6 @@ int DRM(proc_cleanup)(int minor, struct proc_dir_entry *root,
 		remove_proc_entry(DRM(proc_list)[i].name, dev_root);
 	sprintf(name, "%d", minor);
 	remove_proc_entry(name, root);
-	if (!minor) remove_proc_entry("dri", NULL);
 
 	return 0;
 }