Merge http://linus.bkbits.net/linux-2.5

into maxwell.earthlink.net:/tmp/linus-2.5

37 files changed, 791 insertions, 1410 deletions

diff --git a/drivers/block/DAC960.c b/drivers/block/DAC960.c
index 210449ad1715..dc372aa4dbb1 100644
--- a/drivers/block/DAC960.c
+++ b/drivers/block/DAC960.c
@@ -2055,29 +2055,20 @@ static void DAC960_ComputeGenericDiskInfo(DAC960_Controller_T *Controller)
 static void DAC960_RegisterDisk(DAC960_Controller_T *Controller,
 				int LogicalDriveNumber)
 {
-  if (Controller->FirmwareType == DAC960_V1_Controller)
-    {
+  long size;
+  if (Controller->FirmwareType == DAC960_V1_Controller) {
       if (LogicalDriveNumber > Controller->LogicalDriveCount - 1) return;
-      register_disk(&Controller->GenericDiskInfo,
-		    DAC960_KernelDevice(Controller->ControllerNumber,
-					LogicalDriveNumber, 0),
-		    DAC960_MaxPartitions,
-		    &DAC960_BlockDeviceOperations,
-		    Controller->V1.LogicalDriveInformation
-				   [LogicalDriveNumber].LogicalDriveSize);
-    }
-  else
-    {
+      size = Controller->V1.LogicalDriveInformation
+				   [LogicalDriveNumber].LogicalDriveSize;
+  } else {
       DAC960_V2_LogicalDeviceInfo_T *LogicalDeviceInfo =
 	Controller->V2.LogicalDeviceInformation[LogicalDriveNumber];
       if (LogicalDeviceInfo == NULL) return;
-      register_disk(&Controller->GenericDiskInfo,
-		    DAC960_KernelDevice(Controller->ControllerNumber,
-					LogicalDriveNumber, 0),
-		    DAC960_MaxPartitions,
-		    &DAC960_BlockDeviceOperations,
-		    LogicalDeviceInfo->ConfigurableDeviceSize);
-    }
+      size = LogicalDeviceInfo->ConfigurableDeviceSize;
+  }
+  register_disk(&Controller->GenericDiskInfo,
+    DAC960_KernelDevice(Controller->ControllerNumber, LogicalDriveNumber, 0),
+    DAC960_MaxPartitions, &DAC960_BlockDeviceOperations, size);
 }
 
 
@@ -5399,15 +5390,9 @@ static int DAC960_IOCTL(Inode_T *Inode, File_T *File,
 	    LogicalDeviceInfo->ConfigurableDeviceSize
 	    / (Geometry.heads * Geometry.sectors);
 	}
-      Geometry.start = get_start_sect(Inode->i_rdev);
+      Geometry.start = get_start_sect(Inode->i_bdev);
       return (copy_to_user(UserGeometry, &Geometry,
 			   sizeof(DiskGeometry_T)) ? -EFAULT : 0);
-    case BLKGETSIZE:
-    case BLKGETSIZE64:
-    case BLKFLSBUF:
-    case BLKBSZGET:
-    case BLKBSZSET:
-      return blk_ioctl(Inode->i_bdev, Request, Argument);
 
     case BLKRRPART:
       /* Re-Read Partition Table. */
diff --git a/drivers/block/acsi.c b/drivers/block/acsi.c
index c35ef7f77e40..f616f01847b7 100644
--- a/drivers/block/acsi.c
+++ b/drivers/block/acsi.c
@@ -248,8 +248,6 @@ static int				NDevices = 0;
 static int				acsi_sizes[MAX_DEV<<4] = { 0, };
 static struct hd_struct	acsi_part[MAX_DEV<<4] = { {0,0}, };
 static int 				access_count[MAX_DEV] = { 0, };
-static char 			busy[MAX_DEV] = { 0, };
-static DECLARE_WAIT_QUEUE_HEAD(busy_wait);
 
 static int				CurrentNReq;
 static int				CurrentNSect;
@@ -1107,7 +1105,7 @@ static int acsi_ioctl( struct inode *inode, struct file *file,
 	    put_user( 64, &geo->heads );
 	    put_user( 32, &geo->sectors );
 	    put_user( acsi_info[dev].size >> 11, &geo->cylinders );
-		put_user(get_start_sect(inode->i_rdev), &geo->start);
+		put_user(get_start_sect(inode->i_bdev), &geo->start);
 		return 0;
 	  }
 		
@@ -1118,14 +1116,6 @@ static int acsi_ioctl( struct inode *inode, struct file *file,
 		put_user( 0, &((Scsi_Idlun *) arg)->host_unique_id );
 		return 0;
 		
-	  case BLKGETSIZE:
-	  case BLKGETSIZE64:
-	  case BLKROSET:
-	  case BLKROGET:
-	  case BLKFLSBUF:
-	  case BLKPG:
-		return blk_ioctl(inode->i_bdev, cmd, arg);
-
 	  case BLKRRPART: /* Re-read partition tables */
 	        if (!capable(CAP_SYS_ADMIN)) 
 			return -EACCES;
@@ -1161,8 +1151,6 @@ static int acsi_open( struct inode * inode, struct file * filp )
 	if (device >= NDevices)
 		return -ENXIO;
 	aip = &acsi_info[device];
-	while (busy[device])
-		sleep_on(&busy_wait);
 
 	if (access_count[device] == 0 && aip->removable) {
 #if 0
@@ -1803,10 +1791,6 @@ void cleanup_module(void)
 }
 #endif
 
-#define DEVICE_BUSY busy[device]
-#define USAGE access_count[device]
-#define GENDISK_STRUCT acsi_gendisk
-
 /*
  * This routine is called to flush all partitions and partition tables
  * for a changed scsi disk, and then re-read the new partition table.
@@ -1828,24 +1812,15 @@ void cleanup_module(void)
 
 static int revalidate_acsidisk( int dev, int maxusage )
 {
-	int device;
-	struct gendisk * gdev;
-	int res;
-	struct acsi_info_struct *aip;
-	
-	device = DEVICE_NR(minor(dev));
-	aip = &acsi_info[device];
-	gdev = &GENDISK_STRUCT;
+	int unit = DEVICE_NR(minor(dev));
+	struct acsi_info_struct *aip = &acsi_info[unit];
+	kdev_t device = mk_kdev(MAJOR_NR, unit<<4);
+	int res = dev_lock_part(device);
 
-	cli();
-	if (DEVICE_BUSY || USAGE > maxusage) {
-		sti();
-		return -EBUSY;
-	};
-	DEVICE_BUSY = 1;
-	sti();
+	if (res < 0)
+		return res;
 
-	res = wipe_partitions(dev);
+	res = wipe_partitions(device);
 
 	stdma_lock( NULL, NULL );
 
@@ -1862,10 +1837,9 @@ static int revalidate_acsidisk( int dev, int maxusage )
 	stdma_release();
 
 	if (!res)
-		grok_partitions(dev, aip->size);
+		grok_partitions(device, aip->size);
 
-	DEVICE_BUSY = 0;
-	wake_up(&busy_wait);
+	dev_unlock_part(device);
 	return res;
 }
 
diff --git a/drivers/block/ataflop.c b/drivers/block/ataflop.c
index af8f966f4eb3..04a8ce00c6a7 100644
--- a/drivers/block/ataflop.c
+++ b/drivers/block/ataflop.c
@@ -1559,12 +1559,6 @@ static int fd_ioctl(struct inode *inode, struct file *filp,
 	struct floppy_struct setprm;
 
 	device = inode->i_rdev;
-	switch (cmd) {
-		case BLKROSET:
-		case BLKROGET:
-		case BLKFLSBUF:
-			return blk_ioctl(inode->i_bdev, cmd, param);
-	}
 	drive = minor (device);
 	type  = drive >> 2;
 	drive &= 3;
diff --git a/drivers/block/blkpg.c b/drivers/block/blkpg.c
index 37e244777963..83826af84b6a 100644
--- a/drivers/block/blkpg.c
+++ b/drivers/block/blkpg.c
@@ -69,8 +69,9 @@ int add_partition(struct block_device *bdev, struct blkpg_partition *p)
 	struct gendisk *g;
 	long long ppstart, pplength;
 	long pstart, plength;
-	int i, drive, first_minor, end_minor, minor;
+	int i;
 	kdev_t dev = to_kdev_t(bdev->bd_dev);
+	struct hd_struct *part;
 
 	/* convert bytes to sectors, check for fit in a hd_struct */
 	ppstart = (p->start >> 9);
@@ -85,37 +86,32 @@ int add_partition(struct block_device *bdev, struct blkpg_partition *p)
 	g = get_gendisk(dev);
 	if (!g)
 		return -ENXIO;
+	part = g->part + minor(dev);
 
 	/* existing drive? */
-	drive = (minor(dev) >> g->minor_shift);
-	first_minor = (drive << g->minor_shift);
-	end_minor   = first_minor + (1 << g->minor_shift);
-	if (drive >= g->nr_real)
-		return -ENXIO;
 
 	/* drive and partition number OK? */
-	if (first_minor != minor(dev))
+	if (bdev != bdev->bd_contains)
 		return -EINVAL;
 	if (p->pno <= 0 || p->pno >= (1 << g->minor_shift))
 		return -EINVAL;
 
 	/* partition number in use? */
-	minor = first_minor + p->pno;
-	if (g->part[minor].nr_sects != 0)
+	if (part[p->pno].nr_sects != 0)
 		return -EBUSY;
 
 	/* overlap? */
-	for (i=first_minor+1; i<end_minor; i++)
-		if (!(pstart+plength <= g->part[i].start_sect ||
-		      pstart >= g->part[i].start_sect + g->part[i].nr_sects))
+	for (i = 1; i < (1<<g->minor_shift); i++)
+		if (!(pstart+plength <= part[i].start_sect ||
+		      pstart >= part[i].start_sect + part[i].nr_sects))
 			return -EBUSY;
 
 	/* all seems OK */
-	g->part[minor].start_sect = pstart;
-	g->part[minor].nr_sects = plength;
+	part[p->pno].start_sect = pstart;
+	part[p->pno].nr_sects = plength;
 	if (g->sizes)
-		g->sizes[minor] = (plength >> (BLOCK_SIZE_BITS - 9));
-	devfs_register_partitions (g, first_minor, 0);
+		g->sizes[minor(dev)+p->pno] = (plength >> (BLOCK_SIZE_BITS-9));
+	devfs_register_partitions (g, minor(dev), 0);
 	return 0;
 }
 
@@ -133,33 +129,27 @@ int del_partition(struct block_device *bdev, struct blkpg_partition *p)
 {
 	kdev_t dev = to_kdev_t(bdev->bd_dev);
 	struct gendisk *g;
-	kdev_t devp;
 	struct block_device *bdevp;
-	int drive, first_minor, minor;
+	struct hd_struct *part;
 	int holder;
 
 	/* find the drive major */
 	g = get_gendisk(dev);
 	if (!g)
 		return -ENXIO;
+	part = g->part + minor(dev);
 
-	/* drive and partition number OK? */
-	drive = (minor(dev) >> g->minor_shift);
-	first_minor = (drive << g->minor_shift);
-
-	if (first_minor != minor(dev))
+	if (bdev != bdev->bd_contains)
 		return -EINVAL;
 	if (p->pno <= 0 || p->pno >= (1 << g->minor_shift))
   		return -EINVAL;
 
 	/* existing drive and partition? */
-	minor = first_minor + p->pno;
-	if (drive >= g->nr_real || g->part[minor].nr_sects == 0)
+	if (part[p->pno].nr_sects == 0)
 		return -ENXIO;
 
 	/* partition in use? Incomplete check for now. */
-	devp = mk_kdev(major(dev), minor);
-	bdevp = bdget(kdev_t_to_nr(devp));
+	bdevp = bdget(MKDEV(major(dev), minor(dev) + p->pno));
 	if (!bdevp)
 		return -ENOMEM;
 	if (bd_claim(bdevp, &holder) < 0) {
@@ -171,11 +161,11 @@ int del_partition(struct block_device *bdev, struct blkpg_partition *p)
 	fsync_bdev(bdevp);
 	invalidate_bdev(bdevp, 0);
 
-	g->part[minor].start_sect = 0;
-	g->part[minor].nr_sects = 0;
+	part[p->pno].start_sect = 0;
+	part[p->pno].nr_sects = 0;
 	if (g->sizes)
-		g->sizes[minor] = 0;
-	devfs_register_partitions (g, first_minor, 0);
+		g->sizes[minor(dev) + p->pno] = 0;
+	devfs_register_partitions (g, minor(dev), 0);
 	bd_release(bdevp);
 	bdput(bdevp);
 
@@ -223,10 +213,6 @@ int blk_ioctl(struct block_device *bdev, unsigned int cmd, unsigned long arg)
 	int holder;
 	struct backing_dev_info *bdi;
 
-	intval = block_ioctl(bdev, cmd, arg);
-	if (intval != -ENOTTY)
-		return intval;
-
 	switch (cmd) {
 		case BLKROSET:
 			if (!capable(CAP_SYS_ADMIN))
@@ -296,14 +282,6 @@ int blk_ioctl(struct block_device *bdev, unsigned int cmd, unsigned long arg)
 
 		case BLKPG:
 			return blkpg_ioctl(bdev, (struct blkpg_ioctl_arg *) arg);
-			
-		/*
-		 * deprecated, use the /proc/iosched interface instead
-		 */
-		case BLKELVGET:
-		case BLKELVSET:
-			return -ENOTTY;
-
 		case BLKBSZGET:
 			/* get the logical block size (cf. BLKSSZGET) */
 			intval = block_size(bdev);
@@ -330,5 +308,3 @@ int blk_ioctl(struct block_device *bdev, unsigned int cmd, unsigned long arg)
 			return -EINVAL;
 	}
 }
-
-EXPORT_SYMBOL(blk_ioctl);
diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index e06fd274b653..939d70269415 100644
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -440,15 +440,6 @@ static int cciss_ioctl(struct inode *inode, struct file *filep,
 
 	case BLKRRPART:
 		return revalidate_logvol(inode->i_rdev, 1);
-	case BLKGETSIZE:
-	case BLKGETSIZE64:
-	case BLKFLSBUF:
-	case BLKBSZSET:
-	case BLKBSZGET:
-	case BLKROSET:
-	case BLKROGET:
-	case BLKPG:
-		return blk_ioctl(inode->i_bdev, cmd, arg);
 	case CCISS_GETPCIINFO:
 	{
 		cciss_pci_info_struct pciinfo;
@@ -735,6 +726,10 @@ static int cciss_ioctl(struct inode *inode, struct file *filep,
 }
 
 /* Borrowed and adapted from sd.c */
+/*
+ * FIXME: we are missing the exclusion with ->open() here - it can happen
+ * just as we are rereading partition tables.
+ */
 static int revalidate_logvol(kdev_t dev, int maxusage)
 {
         int ctlr, target;
@@ -860,18 +855,9 @@ static int deregister_disk(int ctlr, int logvol)
 	/* invalidate the devices and deregister the disk */ 
 	max_p = 1 << gdev->minor_shift;
 	start = logvol << gdev->minor_shift;
+	wipe_partitions(mk_kdev(MAJOR_NR+ctlr, start));
 	for (i=max_p-1; i>=0; i--)
-	{
-		int minor = start+i;
-		kdev_t kdev = mk_kdev(MAJOR_NR+ctlr, minor);
-		// printk("invalidating( %d %d)\n", ctlr, minor);
-		invalidate_device(kdev, 1);
-		/* so open will now fail */
-		h->sizes[minor] = 0;
-		/* so it will no longer appear in /proc/partitions */ 
-		gdev->part[minor].start_sect = 0;
-		gdev->part[minor].nr_sects = 0;	
-	}
+		h->sizes[start + i] = 0;
 	/* check to see if it was the last disk */
 	if (logvol == h->highest_lun)
 	{
@@ -1313,19 +1299,12 @@ static int register_new_disk(kdev_t dev, int ctlr)
 	hba[ctlr]->drv[logvol].usage_count = 0;
 	max_p = 1 << gdev->minor_shift;
         start = logvol<< gdev->minor_shift;
+	kdev = mk_kdev(MAJOR_NR + ctlr, logvol<< gdev->minor_shift);
 
-        for(i=max_p-1; i>=0; i--) {
-                int minor = start+i;
-		kdev = mk_kdev(MAJOR_NR + ctlr, minor);
-                invalidate_device(kdev, 1);
-                gdev->part[minor].start_sect = 0;
-                gdev->part[minor].nr_sects = 0;
-        }
-
+	wipe_partitions(kdev);
 	++hba[ctlr]->num_luns;
 	gdev->nr_real = hba[ctlr]->highest_lun + 1;
 	/* setup partitions per disk */
-	kdev = mk_kdev(MAJOR_NR + ctlr, logvol<< gdev->minor_shift);
 	grok_partitions(kdev, hba[ctlr]->drv[logvol].nr_blocks);
 	
 	kfree(ld_buff);
diff --git a/drivers/block/cpqarray.c b/drivers/block/cpqarray.c
index fccef1bb792c..31276ef0e87c 100644
--- a/drivers/block/cpqarray.c
+++ b/drivers/block/cpqarray.c
@@ -1116,7 +1116,7 @@ static int ida_ioctl(struct inode *inode, struct file *filep, unsigned int cmd,
 		put_user(diskinfo[0], &geo->heads);
 		put_user(diskinfo[1], &geo->sectors);
 		put_user(diskinfo[2], &geo->cylinders);
-		put_user(get_start_sect(inode->i_rdev), &geo->start);
+		put_user(get_start_sect(inode->i_bdev), &geo->start);
 		return 0;
 	case IDAGETDRVINFO:
 		if (copy_to_user(&io->c.drv, &hba[ctlr]->drv[dsk],
@@ -1157,16 +1157,6 @@ static int ida_ioctl(struct inode *inode, struct file *filep, unsigned int cmd,
 		return(0);
 	}	
 
-	case BLKGETSIZE:
-	case BLKGETSIZE64:
-	case BLKFLSBUF:
-	case BLKBSZSET:
-	case BLKBSZGET:
-	case BLKROSET:
-	case BLKROGET:
-	case BLKPG:
-		return blk_ioctl(inode->i_bdev, cmd, arg);
-
 	default:
 		return -EINVAL;
 	}
@@ -1533,6 +1523,9 @@ static int revalidate_allvol(kdev_t dev)
 }
 
 /* Borrowed and adapted from sd.c */
+/*
+ * FIXME: exclusion with ->open()
+ */
 static int revalidate_logvol(kdev_t dev, int maxusage)
 {
 	int ctlr, target;
diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index aff8acff0ef3..fdc6e904464a 100644
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -3468,12 +3468,6 @@ static int fd_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
 	const char *outparam; /* parameters passed back to user space */
 
 	device = inode->i_rdev;
-	switch (cmd) {
-		case BLKROSET:
-		case BLKROGET:
-		case BLKFLSBUF:
-			return blk_ioctl(inode->i_bdev, cmd, param);
-	}
 	type = TYPE(device);
 	drive = DRIVE(device);
 
diff --git a/drivers/block/genhd.c b/drivers/block/genhd.c
index 7c30fbe37c16..0fc011f610d1 100644
--- a/drivers/block/genhd.c
+++ b/drivers/block/genhd.c
@@ -117,31 +117,6 @@ get_gendisk(kdev_t dev)
 
 EXPORT_SYMBOL(get_gendisk);
 
-
-unsigned long
-get_start_sect(kdev_t dev)
-{
-	struct gendisk *gp;
-
-	gp = get_gendisk(dev);
-	if (gp)
-		return gp->part[minor(dev)].start_sect;
-	return 0;
-}
-
-EXPORT_SYMBOL(get_start_sect);
-
-unsigned long
-get_nr_sects(kdev_t dev)
-{
-	struct gendisk *gp;
-
-	gp = get_gendisk(dev);
-	if (gp)
-		return gp->part[minor(dev)].nr_sects;
-	return 0;
-}
-
 #ifdef CONFIG_PROC_FS
 /* iterator */
 static void *part_start(struct seq_file *part, loff_t *pos)
@@ -209,7 +184,6 @@ int __init device_init(void)
 {
 	rwlock_init(&gendisk_lock);
 	blk_dev_init();
-	sti();
 #ifdef CONFIG_I2O
 	i2o_init();
 #endif
diff --git a/drivers/block/ll_rw_blk.c b/drivers/block/ll_rw_blk.c
index 48616f94f5ee..c23f57a0ed16 100644
--- a/drivers/block/ll_rw_blk.c
+++ b/drivers/block/ll_rw_blk.c
@@ -1573,16 +1573,10 @@ end_io:
 static inline void blk_partition_remap(struct bio *bio)
 {
 	struct block_device *bdev = bio->bi_bdev;
-	struct gendisk *g;
-
 	if (bdev == bdev->bd_contains)
 		return;
 
-	g = get_gendisk(to_kdev_t(bdev->bd_dev));
-	if (!g)
-		BUG();
-
-	bio->bi_sector += g->part[minor(to_kdev_t((bdev->bd_dev)))].start_sect;
+	bio->bi_sector += bdev->bd_offset;
 	bio->bi_bdev = bdev->bd_contains;
 	/* lots of checks are possible */
 }
@@ -2047,9 +2041,6 @@ int __init blk_dev_init(void)
 #if defined(CONFIG_IDE) && defined(CONFIG_BLK_DEV_HD)
 	hd_init();
 #endif
-#if defined(__i386__)	/* Do we even need this? */
-	outb_p(0xc, 0x3f2);
-#endif
 
 	return 0;
 };
diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index 982604ff6bfd..50c1052cae74 100644
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -912,10 +912,6 @@ static int lo_ioctl(struct inode * inode, struct file * file,
 		}
 		err = put_user((u64)loop_sizes[lo->lo_number] << 10, (u64*)arg);
 		break;
-	case BLKBSZGET:
-	case BLKBSZSET:
-		err = blk_ioctl(inode->i_bdev, cmd, arg);
-		break;
 	default:
 		err = lo->ioctl ? lo->ioctl(lo, cmd, arg) : -EINVAL;
 	}
diff --git a/drivers/block/paride/Makefile b/drivers/block/paride/Makefile
index d62c39cb9b55..b1294e64f414 100644
--- a/drivers/block/paride/Makefile
+++ b/drivers/block/paride/Makefile
@@ -5,14 +5,9 @@
 # Rewritten to use lists instead of if-statements.
 #
 
-export-objs := paride.o bpck6.o
+export-objs := paride.o
 
 obj-$(CONFIG_PARIDE)		+= paride.o
-obj-$(CONFIG_PARIDE_PD)		+= pd.o
-obj-$(CONFIG_PARIDE_PCD)	+= pcd.o
-obj-$(CONFIG_PARIDE_PF)		+= pf.o
-obj-$(CONFIG_PARIDE_PT)		+= pt.o
-obj-$(CONFIG_PARIDE_PG)		+= pg.o
 obj-$(CONFIG_PARIDE_ATEN)	+= aten.o
 obj-$(CONFIG_PARIDE_BPCK)	+= bpck.o
 obj-$(CONFIG_PARIDE_COMM)	+= comm.o
@@ -20,13 +15,18 @@ obj-$(CONFIG_PARIDE_DSTR)	+= dstr.o
 obj-$(CONFIG_PARIDE_KBIC)	+= kbic.o
 obj-$(CONFIG_PARIDE_EPAT)	+= epat.o
 obj-$(CONFIG_PARIDE_EPIA)	+= epia.o
-obj-$(CONFIG_PARIDE_FIT2)	+= fit2.o
-obj-$(CONFIG_PARIDE_FIT3)	+= fit3.o
 obj-$(CONFIG_PARIDE_FRPW)	+= frpw.o
 obj-$(CONFIG_PARIDE_FRIQ)	+= friq.o
+obj-$(CONFIG_PARIDE_FIT2)	+= fit2.o
+obj-$(CONFIG_PARIDE_FIT3)	+= fit3.o
 obj-$(CONFIG_PARIDE_ON20)	+= on20.o
 obj-$(CONFIG_PARIDE_ON26)	+= on26.o
 obj-$(CONFIG_PARIDE_KTTI)	+= ktti.o
 obj-$(CONFIG_PARIDE_BPCK6)	+= bpck6.o
+obj-$(CONFIG_PARIDE_PD)		+= pd.o
+obj-$(CONFIG_PARIDE_PCD)	+= pcd.o
+obj-$(CONFIG_PARIDE_PF)		+= pf.o
+obj-$(CONFIG_PARIDE_PT)		+= pt.o
+obj-$(CONFIG_PARIDE_PG)		+= pg.o
 
 include $(TOPDIR)/Rules.make
diff --git a/drivers/block/paride/aten.c b/drivers/block/paride/aten.c
index b22d34da348a..763fc50d7f76 100644
--- a/drivers/block/paride/aten.c
+++ b/drivers/block/paride/aten.c
@@ -18,6 +18,7 @@
 #define ATEN_VERSION      "1.01"
 
 #include <linux/module.h>
+#include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/kernel.h>
 #include <linux/wait.h>
@@ -140,35 +141,33 @@ static void aten_release_proto( PIA *pi )
 {       MOD_DEC_USE_COUNT;
 }
 
-struct pi_protocol aten = {"aten",0,2,2,1,1,
-                           aten_write_regr,
-                           aten_read_regr,
-                           aten_write_block,
-                           aten_read_block,
-                           aten_connect,
-                           aten_disconnect,
-                           0,
-                           0,
-                           0,
-                           aten_log_adapter,
-                           aten_init_proto,
-                           aten_release_proto
-                          };
-
-
-#ifdef MODULE
-
-int     init_module(void)
-
-{       return pi_register( &aten ) - 1;
+static struct pi_protocol aten = {
+	.name		= "aten",
+	.max_mode	= 2,
+	.epp_first	= 2,
+	.default_delay	= 1,
+	.max_units	= 1,
+	.write_regr	= aten_write_regr,
+	.read_regr	= aten_read_regr,
+	.write_block	= aten_write_block,
+	.read_block	= aten_read_block,
+	.connect	= aten_connect,
+	.disconnect	= aten_disconnect,
+	.log_adapter	= aten_log_adapter,
+	.init_proto	= aten_init_proto,
+	.release_proto	= aten_release_proto,
+};
+
+static int __init aten_init(void)
+{
+	return pi_register(&aten)-1;
 }
 
-void    cleanup_module(void)
-
-{       pi_unregister( &aten );
+static void __exit aten_exit(void)
+{
+	pi_unregister( &aten );
 }
 
-#endif
-
-/* end of aten.c */
 MODULE_LICENSE("GPL");
+module_init(aten_init)
+module_exit(aten_exit)
diff --git a/drivers/block/paride/bpck.c b/drivers/block/paride/bpck.c
index 3e20e6b7054a..b15ff97fe7af 100644
--- a/drivers/block/paride/bpck.c
+++ b/drivers/block/paride/bpck.c
@@ -17,6 +17,7 @@
 #define	BPCK_VERSION	"1.02" 
 
 #include <linux/module.h>
+#include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/kernel.h>
 #include <linux/types.h>
@@ -452,34 +453,36 @@ static void bpck_release_proto( PIA *pi)
 {       MOD_DEC_USE_COUNT;
 }
 
-struct pi_protocol bpck = { "bpck",0,5,2,4,256,
-			  bpck_write_regr,
-			  bpck_read_regr,
-			  bpck_write_block,
-			  bpck_read_block,
-			  bpck_connect,
-			  bpck_disconnect,
-			  bpck_test_port,
-			  bpck_probe_unit,
-		          bpck_test_proto,
-			  bpck_log_adapter,
-			  bpck_init_proto,
-			  bpck_release_proto
-			};
-
-#ifdef MODULE
-
-int	init_module(void)
-
-{	return pi_register(&bpck) - 1;
+static struct pi_protocol bpck = {
+	.name		= "bpck",
+	.max_mode	= 5,
+	.epp_first	= 2,
+	.default_delay	= 4,
+	.max_units	= 255,
+	.write_regr	= bpck_write_regr,
+	.read_regr	= bpck_read_regr,
+	.write_block	= bpck_write_block,
+	.read_block	= bpck_read_block,
+	.connect	= bpck_connect,
+	.disconnect	= bpck_disconnect,
+	.test_port	= bpck_test_port,
+	.probe_unit	= bpck_probe_unit,
+	.test_proto	= bpck_test_proto,
+	.log_adapter	= bpck_log_adapter,
+	.init_proto	= bpck_init_proto,
+	.release_proto	= bpck_release_proto,
+};
+
+static int __init bpck_init(void)
+{
+	return pi_register(&bpck)-1;
 }
 
-void	cleanup_module(void)
-
-{	pi_unregister(&bpck);
+static void __exit bpck_exit(void)
+{
+	pi_unregister(&bpck);
 }
 
-#endif
-
-/* end of bpck.c */
 MODULE_LICENSE("GPL");
+module_init(bpck_init)
+module_exit(bpck_exit)
diff --git a/drivers/block/paride/bpck6.c b/drivers/block/paride/bpck6.c
index f2febfcfd268..c1fcdd9f4e94 100644
--- a/drivers/block/paride/bpck6.c
+++ b/drivers/block/paride/bpck6.c
@@ -26,6 +26,7 @@ int verbose=0; /* set this to 1 to see debugging messages and whatnot */
 #define BACKPACK_VERSION "2.0.2"
 
 #include <linux/module.h>
+#include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/slab.h>
 #include <linux/types.h>
@@ -252,65 +253,41 @@ static void bpck6_release_proto(PIA *pi)
 	kfree((void *)(pi->private)); 
 }
 
-struct pi_protocol bpck6 = { "bpck6", /* name for proto*/
-				0, /* index into proto table */
-				5, /* max mode =5 */
-				2, /* 2-5 use epp (need 8 ports) */
-				0, /* no delay (not used anyway) */
-				255, /* we can have units  up to 255 */
-				bpck6_write_regr,
-				bpck6_read_regr,
-				bpck6_write_block,
-				bpck6_read_block,
-				bpck6_connect,
-				bpck6_disconnect,
-				bpck6_test_port,
- 				bpck6_probe_unit,
-				0,
-				bpck6_log_adapter,
-				bpck6_init_proto,
-				bpck6_release_proto
-                        };
-
-
-EXPORT_SYMBOL(bpck6_write_regr);
-EXPORT_SYMBOL(bpck6_read_regr);
-EXPORT_SYMBOL(bpck6_write_block);
-EXPORT_SYMBOL(bpck6_read_block);
-EXPORT_SYMBOL(bpck6_connect);
-EXPORT_SYMBOL(bpck6_disconnect);
-EXPORT_SYMBOL(bpck6_test_port);
-EXPORT_SYMBOL(bpck6_probe_unit);
-EXPORT_SYMBOL(bpck6_log_adapter);
-EXPORT_SYMBOL(bpck6_init_proto);
-EXPORT_SYMBOL(bpck6_release_proto);
-
-/*---------------------------MODULE STUFF-----------------------*/
-
-#ifdef MODULE
-/*module information*/
-
-static int init_module(void)
+static struct pi_protocol bpck6 = {
+	.name		= "bpck6",
+	.max_mode	= 5,
+	.epp_first	= 2, /* 2-5 use epp (need 8 ports) */
+	.max_units	= 255,
+	.write_regr	= bpck6_write_regr,
+	.read_regr	= bpck6_read_regr,
+	.write_block	= bpck6_write_block,
+	.read_block	= bpck6_read_block,
+	.connect	= bpck6_connect,
+	.disconnect	= bpck6_disconnect,
+	.test_port	= bpck6_test_port,
+	.probe_unit	= bpck6_probe_unit,
+	.log_adapter	= bpck6_log_adapter,
+	.init_proto	= bpck6_init_proto,
+	.release_proto	= bpck6_release_proto,
+};
+
+static int __init bpck6_init(void)
 {
 	printk(KERN_INFO "bpck6: BACKPACK Protocol Driver V"BACKPACK_VERSION"\n");
 	printk(KERN_INFO "bpck6: Copyright 2001 by Micro Solutions, Inc., DeKalb IL. USA\n");
-
 	if(verbose)
-	{
 		printk(KERN_DEBUG "bpck6: verbose debug enabled.\n");
-	}
-
 	return pi_register(&bpck6) - 1;  
 }
 
-void    cleanup_module(void)
+static void __exit bpck6_exit(void)
 {
 	pi_unregister(&bpck6);
 }
 
+MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Micro Solutions Inc.");
 MODULE_DESCRIPTION("BACKPACK Protocol module, compatible with PARIDE");
 MODULE_PARM(verbose,"i");
-
-#endif
-
+module_init(bpck6_init)
+module_exit(bpck6_exit)
diff --git a/drivers/block/paride/comm.c b/drivers/block/paride/comm.c
index 058a7d68572c..f3010d6fc73b 100644
--- a/drivers/block/paride/comm.c
+++ b/drivers/block/paride/comm.c
@@ -17,6 +17,7 @@
 #define COMM_VERSION      "1.01"
 
 #include <linux/module.h>
+#include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/kernel.h>
 #include <linux/types.h>
@@ -196,35 +197,33 @@ static void comm_release_proto(PIA *pi)
 {       MOD_DEC_USE_COUNT;
 }
 
-struct pi_protocol comm = {"comm",0,5,2,1,1,
-                           comm_write_regr,
-                           comm_read_regr,
-                           comm_write_block,
-                           comm_read_block,
-                           comm_connect,
-                           comm_disconnect,
-                           0,
-                           0,
-                           0,
-                           comm_log_adapter,
-                           comm_init_proto,
-                           comm_release_proto
-                          };
-
-
-#ifdef MODULE
-
-int     init_module(void)
-
-{       return pi_register( &comm ) - 1;
+static struct pi_protocol comm = {
+	.name		= "comm",
+	.max_mode	= 5,
+	.epp_first	= 2,
+	.default_delay	= 1,
+	.max_units	= 1,
+	.write_regr	= comm_write_regr,
+	.read_regr	= comm_read_regr,
+	.write_block	= comm_write_block,
+	.read_block	= comm_read_block,
+	.connect	= comm_connect,
+	.disconnect	= comm_disconnect,
+	.log_adapter	= comm_log_adapter,
+	.init_proto	= comm_init_proto,
+	.release_proto	= comm_release_proto,
+};
+
+static int __init comm_init(void)
+{
+	return pi_register(&comm)-1;
 }
 
-void    cleanup_module(void)
-
-{       pi_unregister( &comm );
+static void __exit comm_exit(void)
+{
+	pi_unregister(&comm);
 }
 
-#endif
-
-/* end of comm.c */
 MODULE_LICENSE("GPL");
+module_init(comm_init)
+module_exit(comm_exit)
diff --git a/drivers/block/paride/dstr.c b/drivers/block/paride/dstr.c
index 438735b6ce10..204fe75df233 100644
--- a/drivers/block/paride/dstr.c
+++ b/drivers/block/paride/dstr.c
@@ -16,6 +16,7 @@
 #define DSTR_VERSION      "1.01"
 
 #include <linux/module.h>
+#include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/kernel.h>
 #include <linux/types.h>
@@ -211,35 +212,33 @@ static void dstr_release_proto( PIA *pi)
 {       MOD_DEC_USE_COUNT;
 }
 
-struct pi_protocol dstr = {"dstr",0,5,2,1,1,
-                           dstr_write_regr,
-                           dstr_read_regr,
-                           dstr_write_block,
-                           dstr_read_block,
-                           dstr_connect,
-                           dstr_disconnect,
-                           0,
-                           0,
-                           0,
-                           dstr_log_adapter,
-                           dstr_init_proto,
-                           dstr_release_proto
-                          };
-
-
-#ifdef MODULE
-
-int     init_module(void)
-
-{       return pi_register( &dstr ) - 1;
+static struct pi_protocol dstr = {
+	.name		= "dstr",
+	.max_mode	= 5,
+	.epp_first	= 2,
+	.default_delay	= 1,
+	.max_units	= 1,
+	.write_regr	= dstr_write_regr,
+	.read_regr	= dstr_read_regr,
+	.write_block	= dstr_write_block,
+	.read_block	= dstr_read_block,
+	.connect	= dstr_connect,
+	.disconnect	= dstr_disconnect,
+	.log_adapter	= dstr_log_adapter,
+	.init_proto	= dstr_init_proto,
+	.release_proto	= dstr_release_proto,
+};
+
+static int __init dstr_init(void)
+{
+	return pi_register(&dstr)-1;
 }
 
-void    cleanup_module(void)
-
-{       pi_unregister( &dstr );
+static void __exit dstr_exit(void)
+{
+	pi_unregister(&dstr);
 }
 
-#endif
-
-/* end of dstr.c */
 MODULE_LICENSE("GPL");
+module_init(dstr_init)
+module_exit(dstr_exit)
diff --git a/drivers/block/paride/epat.c b/drivers/block/paride/epat.c
index 624a5ba32cfd..0a7126756371 100644
--- a/drivers/block/paride/epat.c
+++ b/drivers/block/paride/epat.c
@@ -19,6 +19,7 @@
 #define EPAT_VERSION      "1.02"
 
 #include <linux/module.h>
+#include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/kernel.h>
 #include <linux/types.h>
@@ -311,35 +312,34 @@ static void epat_release_proto( PIA *pi)
 {	MOD_DEC_USE_COUNT;
 }
 
-struct pi_protocol epat = {"epat",0,6,3,1,1,
-			   epat_write_regr,
-			   epat_read_regr,
-			   epat_write_block,
-			   epat_read_block,
-			   epat_connect,
-			   epat_disconnect,
-			   0,
-			   0,
-			   epat_test_proto,
-			   epat_log_adapter,
-			   epat_init_proto,
-			   epat_release_proto
-			  };
-
-
-#ifdef MODULE
-
-int	init_module(void)
-
-{	return pi_register( &epat) - 1;
+static struct pi_protocol epat = {
+	.name		= "epat",
+	.max_mode	= 6,
+	.epp_first	= 3,
+	.default_delay	= 1,
+	.max_units	= 1,
+	.write_regr	= epat_write_regr,
+	.read_regr	= epat_read_regr,
+	.write_block	= epat_write_block,
+	.read_block	= epat_read_block,
+	.connect	= epat_connect,
+	.disconnect	= epat_disconnect,
+	.test_proto	= epat_test_proto,
+	.log_adapter	= epat_log_adapter,
+	.init_proto	= epat_init_proto,
+	.release_proto	= epat_release_proto,
+};
+
+static int __init epat_init(void)
+{
+	return pi_register(&epat)-1;
 }
 
-void	cleanup_module(void)
-
-{	pi_unregister( &epat);
+static void __exit epat_exit(void)
+{
+	pi_unregister(&epat);
 }
 
-#endif
-
-/* end of epat.c */
 MODULE_LICENSE("GPL");
+module_init(epat_init)
+module_exit(epat_exit)
diff --git a/drivers/block/paride/epia.c b/drivers/block/paride/epia.c
index c27edd64ecc1..c2728af843dd 100644
--- a/drivers/block/paride/epia.c
+++ b/drivers/block/paride/epia.c
@@ -20,6 +20,7 @@
 #define EPIA_VERSION      "1.02"
 
 #include <linux/module.h>
+#include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/kernel.h>
 #include <linux/types.h>
@@ -293,36 +294,34 @@ static void epia_release_proto( PIA *pi)
 {       MOD_DEC_USE_COUNT;
 }
 
-struct pi_protocol epia = {"epia",0,6,3,1,1,
-                           epia_write_regr,
-                           epia_read_regr,
-                           epia_write_block,
-                           epia_read_block,
-                           epia_connect,
-                           epia_disconnect,
-                           0,
-                           0,
-                           epia_test_proto,
-                           epia_log_adapter,
-                           epia_init_proto,
-                           epia_release_proto
-                          };
-
-
-#ifdef MODULE
-
-int     init_module(void)
-
-{       return pi_register( &epia ) - 1;
+static struct pi_protocol epia = {
+	.name		= "epia",
+	.max_mode	= 6,
+	.epp_first	= 3,
+	.default_delay	= 1,
+	.max_units	= 1,
+	.write_regr	= epia_write_regr,
+	.read_regr	= epia_read_regr,
+	.write_block	= epia_write_block,
+	.read_block	= epia_read_block,
+	.connect	= epia_connect,
+	.disconnect	= epia_disconnect,
+	.test_proto	= epia_test_proto,
+	.log_adapter	= epia_log_adapter,
+	.init_proto	= epia_init_proto,
+	.release_proto	= epia_release_proto,
+};
+
+static int __init epia_init(void)
+{
+	return pi_register(&epia)-1;
 }
 
-void    cleanup_module(void)
-
-{       pi_unregister( &epia );
+static void __exit epia_exit(void)
+{
+	pi_unregister(&epia);
 }
 
-#endif
-
-/* end of epia.c */
-
 MODULE_LICENSE("GPL");
+module_init(epia_init)
+module_exit(epia_exit)
diff --git a/drivers/block/paride/fit2.c b/drivers/block/paride/fit2.c
index 7f45529c80b1..42b2880a82ac 100644
--- a/drivers/block/paride/fit2.c
+++ b/drivers/block/paride/fit2.c
@@ -16,6 +16,7 @@
 #define FIT2_VERSION      "1.0"
 
 #include <linux/module.h>
+#include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/kernel.h>
 #include <linux/types.h>
@@ -129,35 +130,33 @@ static void fit2_release_proto( PIA *pi)
 {       MOD_DEC_USE_COUNT;
 }
 
-struct pi_protocol fit2 = {"fit2",0,1,2,1,1,
-                           fit2_write_regr,
-                           fit2_read_regr,
-                           fit2_write_block,
-                           fit2_read_block,
-                           fit2_connect,
-                           fit2_disconnect,
-                           0,
-                           0,
-                           0,
-                           fit2_log_adapter,
-                           fit2_init_proto,
-                           fit2_release_proto
-                          };
-
-
-#ifdef MODULE
-
-int     init_module(void)
-
-{       return pi_register( &fit2 ) - 1;
+static struct pi_protocol fit2 = {
+	.name		= "fit2",
+	.max_mode	= 1,
+	.epp_first	= 2,
+	.default_delay	= 1,
+	.max_units	= 1,
+	.write_regr	= fit2_write_regr,
+	.read_regr	= fit2_read_regr,
+	.write_block	= fit2_write_block,
+	.read_block	= fit2_read_block,
+	.connect	= fit2_connect,
+	.disconnect	= fit2_disconnect,
+	.log_adapter	= fit2_log_adapter,
+	.init_proto	= fit2_init_proto,
+	.release_proto	= fit2_release_proto,
+};
+
+static int __init fit2_init(void)
+{
+	return pi_register(&fit2)-1;
 }
 
-void    cleanup_module(void)
-
-{       pi_unregister( &fit2 );
+static void __exit fit2_exit(void)
+{
+	pi_unregister(&fit2);
 }
 
-#endif
-
-/* end of fit2.c */
 MODULE_LICENSE("GPL");
+module_init(fit2_init)
+module_exit(fit2_exit)
diff --git a/drivers/block/paride/fit3.c b/drivers/block/paride/fit3.c
index 8b5ad4bd5ad0..4d9286562c3c 100644
--- a/drivers/block/paride/fit3.c
+++ b/drivers/block/paride/fit3.c
@@ -20,6 +20,7 @@
 #define FIT3_VERSION      "1.0"
 
 #include <linux/module.h>
+#include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/kernel.h>
 #include <linux/types.h>
@@ -189,35 +190,33 @@ static void fit3_release_proto(PIA *pi)
 {       MOD_DEC_USE_COUNT;
 }
 
-struct pi_protocol fit3 = {"fit3",0,3,2,1,1,
-                           fit3_write_regr,
-                           fit3_read_regr,
-                           fit3_write_block,
-                           fit3_read_block,
-                           fit3_connect,
-                           fit3_disconnect,
-                           0,
-                           0,
-                           0,
-                           fit3_log_adapter,
-                           fit3_init_proto,
-                           fit3_release_proto
-                          };
-
-
-#ifdef MODULE
-
-int     init_module(void)
-
-{       return pi_register( &fit3 ) - 1;
+static struct pi_protocol fit3 = {
+	.name		= "fit3",
+	.max_mode	= 3,
+	.epp_first	= 2,
+	.default_delay	= 1,
+	.max_units	= 1,
+	.write_regr	= fit3_write_regr,
+	.read_regr	= fit3_read_regr,
+	.write_block	= fit3_write_block,
+	.read_block	= fit3_read_block,
+	.connect	= fit3_connect,
+	.disconnect	= fit3_disconnect,
+	.log_adapter	= fit3_log_adapter,
+	.init_proto	= fit3_init_proto,
+	.release_proto	= fit3_release_proto,
+};
+
+static int __init fit3_init(void)
+{
+	return pi_register(&fit3)-1;
 }
 
-void    cleanup_module(void)
-
-{       pi_unregister( &fit3 );
+static void __exit fit3_exit(void)
+{
+	pi_unregister(&fit3);
 }
 
-#endif
-
-/* end of fit3.c */
 MODULE_LICENSE("GPL");
+module_init(fit3_init)
+module_exit(fit3_exit)
diff --git a/drivers/block/paride/friq.c b/drivers/block/paride/friq.c
index 74b2eaab1c19..10b994a456da 100644
--- a/drivers/block/paride/friq.c
+++ b/drivers/block/paride/friq.c
@@ -28,6 +28,7 @@
 #define	FRIQ_VERSION	"1.01" 
 
 #include <linux/module.h>
+#include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/kernel.h>
 #include <linux/types.h>
@@ -250,35 +251,34 @@ static void friq_release_proto( PIA *pi)
 	MOD_DEC_USE_COUNT;
 }
 
-struct pi_protocol friq = {"friq",0,5,2,1,1,
-                           friq_write_regr,
-                           friq_read_regr,
-                           friq_write_block,
-                           friq_read_block,
-                           friq_connect,
-                           friq_disconnect,
-                           0,
-                           0,
-                           friq_test_proto,
-                           friq_log_adapter,
-                           friq_init_proto,
-                           friq_release_proto
-                          };
-
-
-#ifdef MODULE
-
-int     init_module(void)
-
-{       return pi_register( &friq ) - 1;
+static struct pi_protocol friq = {
+	.name		= "friq",
+	.max_mode	= 5,
+	.epp_first	= 2,
+	.default_delay	= 1,
+	.max_units	= 1,
+	.write_regr	= friq_write_regr,
+	.read_regr	= friq_read_regr,
+	.write_block	= friq_write_block,
+	.read_block	= friq_read_block,
+	.connect	= friq_connect,
+	.disconnect	= friq_disconnect,
+	.test_proto	= friq_test_proto,
+	.log_adapter	= friq_log_adapter,
+	.init_proto	= friq_init_proto,
+	.release_proto	= friq_release_proto,
+};
+
+static int __init friq_init(void)
+{
+	return pi_register(&friq)-1;
 }
 
-void    cleanup_module(void)
-
-{       pi_unregister( &friq );
+static void __exit friq_exit(void)
+{
+	pi_unregister(&friq);
 }
 
-#endif
-
-/* end of friq.c */
 MODULE_LICENSE("GPL");
+module_init(friq_init)
+module_exit(friq_exit)
diff --git a/drivers/block/paride/frpw.c b/drivers/block/paride/frpw.c
index 817004a3f7dc..ee0cad3807a1 100644
--- a/drivers/block/paride/frpw.c
+++ b/drivers/block/paride/frpw.c
@@ -26,6 +26,7 @@
 #define	FRPW_VERSION	"1.03" 
 
 #include <linux/module.h>
+#include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/kernel.h>
 #include <linux/types.h>
@@ -291,35 +292,34 @@ static void frpw_release_proto( PIA *pi)
 {       MOD_DEC_USE_COUNT;
 }
 
-struct pi_protocol frpw = {"frpw",0,6,2,2,1,
-                           frpw_write_regr,
-                           frpw_read_regr,
-                           frpw_write_block,
-                           frpw_read_block,
-                           frpw_connect,
-                           frpw_disconnect,
-                           0,
-                           0,
-                           frpw_test_proto,
-                           frpw_log_adapter,
-                           frpw_init_proto,
-                           frpw_release_proto
-                          };
-
-
-#ifdef MODULE
-
-int     init_module(void)
-
-{       return pi_register( &frpw ) - 1;
+static struct pi_protocol frpw = {
+	.name		= "frpw",
+	.max_mode	= 6,
+	.epp_first	= 2,
+	.default_delay	= 2,
+	.max_units	= 1,
+	.write_regr	= frpw_write_regr,
+	.read_regr	= frpw_read_regr,
+	.write_block	= frpw_write_block,
+	.read_block	= frpw_read_block,
+	.connect	= frpw_connect,
+	.disconnect	= frpw_disconnect,
+	.test_proto	= frpw_test_proto,
+	.log_adapter	= frpw_log_adapter,
+	.init_proto	= frpw_init_proto,
+	.release_proto	= frpw_release_proto,
+};
+
+static int __init frpw_init(void)
+{
+	return pi_register(&frpw)-1;
 }
 
-void    cleanup_module(void)
-
-{       pi_unregister( &frpw );
+static void __exit frpw_exit(void)
+{
+	pi_unregister(&frpw);
 }
 
-#endif
-
-/* end of frpw.c */
 MODULE_LICENSE("GPL");
+module_init(frpw_init)
+module_exit(frpw_exit)
diff --git a/drivers/block/paride/kbic.c b/drivers/block/paride/kbic.c
index 2f20c9b0fa4e..f97233b39b7b 100644
--- a/drivers/block/paride/kbic.c
+++ b/drivers/block/paride/kbic.c
@@ -21,6 +21,7 @@
 #define KBIC_VERSION      "1.01"
 
 #include <linux/module.h>
+#include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/kernel.h>
 #include <linux/types.h>
@@ -258,56 +259,51 @@ static void kbic_release_proto( PIA *pi)
 {       MOD_DEC_USE_COUNT;
 }
 
-struct pi_protocol k951 = {"k951",0,6,3,1,1,
-                           kbic_write_regr,
-                           kbic_read_regr,
-                           kbic_write_block,
-                           kbic_read_block,
-                           k951_connect,
-                           k951_disconnect,
-                           0,
-                           0,
-                           0,
-                           k951_log_adapter,
-                           kbic_init_proto,
-                           kbic_release_proto
-  			  };
-
-
-struct pi_protocol k971 = {"k971",0,6,3,1,1,
-                           kbic_write_regr,
-                           kbic_read_regr,
-                           kbic_write_block,
-                           kbic_read_block,
-                           k971_connect,
-                           k971_disconnect,
-                           0,
-                           0,
-                           0,
-                           k971_log_adapter,
-                           kbic_init_proto,
-                           kbic_release_proto
-                          };
-
-#ifdef MODULE
-
-int     init_module(void)
-
-{       int s5,s7;
-
-	s5 = pi_register(&k951);
-	s7 = pi_register(&k971);
-
-	return (s5 || s7) - 1;
+static struct pi_protocol k951 = {
+	.name		= "k951",
+	.max_mode	= 6,
+	.epp_first	= 3,
+	.default_delay	= 1,
+	.max_units	= 1,
+	.write_regr	= kbic_write_regr,
+	.read_regr	= kbic_read_regr,
+	.write_block	= kbic_write_block,
+	.read_block	= kbic_read_block,
+	.connect	= k951_connect,
+	.disconnect	= k951_disconnect,
+	.log_adapter	= k951_log_adapter,
+	.init_proto	= kbic_init_proto,
+	.release_proto	= kbic_release_proto
+};
+
+static struct pi_protocol k971 = {
+	.name		= "k971",
+	.max_mode	= 6,
+	.epp_first	= 3,
+	.default_delay	= 1,
+	.max_units	= 1,
+	.write_regr	= kbic_write_regr,
+	.read_regr	= kbic_read_regr,
+	.write_block	= kbic_write_block,
+	.read_block	= kbic_read_block,
+	.connect	= k971_connect,
+	.disconnect	= k971_disconnect,
+	.log_adapter	= k971_log_adapter,
+	.init_proto	= kbic_init_proto,
+	.release_proto	= kbic_release_proto
+};
+
+static int __init kbic_init(void)
+{
+	return (pi_register(&k951)||pi_register(&k971))-1;
 }
 
-void    cleanup_module(void)
-
-{       pi_unregister( &k951 );
-	pi_unregister( &k971 );
+static void __exit kbic_exit(void)
+{
+	pi_unregister(&k951);
+	pi_unregister(&k971);
 }
 
-#endif
-
-/* end of kbic.c */
 MODULE_LICENSE("GPL");
+module_init(kbic_init)
+module_exit(kbic_exit)
diff --git a/drivers/block/paride/ktti.c b/drivers/block/paride/ktti.c
index 60778192e0c1..bee083b4da9c 100644
--- a/drivers/block/paride/ktti.c
+++ b/drivers/block/paride/ktti.c
@@ -12,6 +12,7 @@
 #define KTTI_VERSION      "1.0"
 
 #include <linux/module.h>
+#include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/kernel.h>
 #include <linux/types.h>
@@ -106,35 +107,33 @@ static void ktti_release_proto( PIA *pi)
 {       MOD_DEC_USE_COUNT;
 }
 
-struct pi_protocol ktti = {"ktti",0,1,2,1,1,
-                           ktti_write_regr,
-                           ktti_read_regr,
-                           ktti_write_block,
-                           ktti_read_block,
-                           ktti_connect,
-                           ktti_disconnect,
-                           0,
-                           0,
-                           0,
-                           ktti_log_adapter,
-                           ktti_init_proto,
-                           ktti_release_proto
-                          };
-
-
-#ifdef MODULE
-
-int     init_module(void)
-
-{       return pi_register( &ktti ) - 1;
+static struct pi_protocol ktti = {
+	.name		= "ktti",
+	.max_mode	= 1,
+	.epp_first	= 2,
+	.default_delay	= 1,
+	.max_units	= 1,
+	.write_regr	= ktti_write_regr,
+	.read_regr	= ktti_read_regr,
+	.write_block	= ktti_write_block,
+	.read_block	= ktti_read_block,
+	.connect	= ktti_connect,
+	.disconnect	= ktti_disconnect,
+	.log_adapter	= ktti_log_adapter,
+	.init_proto	= ktti_init_proto,
+	.release_proto	= ktti_release_proto,
+};
+
+static int __init ktti_init(void)
+{
+	return pi_register(&ktti)-1;
 }
 
-void    cleanup_module(void)
-
-{       pi_unregister( &ktti );
+static void __exit ktti_exit(void)
+{
+	pi_unregister(&ktti);
 }
 
-#endif
-
-/* end of ktti.c */
 MODULE_LICENSE("GPL");
+module_init(ktti_init)
+module_exit(ktti_exit)
diff --git a/drivers/block/paride/on20.c b/drivers/block/paride/on20.c
index b3c8d3d325e0..8528e0212591 100644
--- a/drivers/block/paride/on20.c
+++ b/drivers/block/paride/on20.c
@@ -15,6 +15,7 @@
 #define	ON20_VERSION	"1.01"
 
 #include <linux/module.h>
+#include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/kernel.h>
 #include <linux/types.h>
@@ -131,35 +132,33 @@ static void on20_release_proto( PIA *pi)
 {       MOD_DEC_USE_COUNT;
 }
 
-struct pi_protocol on20 = {"on20",0,2,2,1,1,
-                           on20_write_regr,
-                           on20_read_regr,
-                           on20_write_block,
-                           on20_read_block,
-                           on20_connect,
-                           on20_disconnect,
-                           0,
-                           0,
-                           0,
-                           on20_log_adapter,
-                           on20_init_proto,
-                           on20_release_proto
-                          };
-
-
-#ifdef MODULE
-
-int     init_module(void)
-
-{       return pi_register( &on20 ) - 1;
+static struct pi_protocol on20 = {
+	.name		= "on20",
+	.max_mode	= 2,
+	.epp_first	= 2,
+	.default_delay	= 1,
+	.max_units	= 1,
+	.write_regr	= on20_write_regr,
+	.read_regr	= on20_read_regr,
+	.write_block	= on20_write_block,
+	.read_block	= on20_read_block,
+	.connect	= on20_connect,
+	.disconnect	= on20_disconnect,
+	.log_adapter	= on20_log_adapter,
+	.init_proto	= on20_init_proto,
+	.release_proto	= on20_release_proto,
+};
+
+static int __init on20_init(void)
+{
+	return pi_register(&on20)-1;
 }
 
-void    cleanup_module(void)
-
-{       pi_unregister( &on20 );
+static void __exit on20_exit(void)
+{
+	pi_unregister(&on20);
 }
 
-#endif
-
-/* end of on20.c */
 MODULE_LICENSE("GPL");
+module_init(on20_init)
+module_exit(on20_exit)
diff --git a/drivers/block/paride/on26.c b/drivers/block/paride/on26.c
index 0688c6317972..c08111db5a21 100644
--- a/drivers/block/paride/on26.c
+++ b/drivers/block/paride/on26.c
@@ -19,6 +19,7 @@
 #define ON26_VERSION      "1.04"
 
 #include <linux/module.h>
+#include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/kernel.h>
 #include <linux/types.h>
@@ -296,36 +297,34 @@ static void on26_release_proto( PIA *pi)
 {       MOD_DEC_USE_COUNT;
 }
 
-struct pi_protocol on26 = {"on26",0,5,2,1,1,
-                           on26_write_regr,
-                           on26_read_regr,
-                           on26_write_block,
-                           on26_read_block,
-                           on26_connect,
-                           on26_disconnect,
-                           on26_test_port,
-                           0,
-                           0,
-                           on26_log_adapter,
-                           on26_init_proto,
-                           on26_release_proto
-                          };
-
-
-#ifdef MODULE
-
-int     init_module(void)
-
-{       return pi_register( &on26 ) - 1;
+static struct pi_protocol on26 = {
+	.name		= "on26",
+	.max_mode	= 5,
+	.epp_first	= 2,
+	.default_delay	= 1,
+	.max_units	= 1,
+	.write_regr	= on26_write_regr,
+	.read_regr	= on26_read_regr,
+	.write_block	= on26_write_block,
+	.read_block	= on26_read_block,
+	.connect	= on26_connect,
+	.disconnect	= on26_disconnect,
+	.test_port	= on26_test_port,
+	.log_adapter	= on26_log_adapter,
+	.init_proto	= on26_init_proto,
+	.release_proto	= on26_release_proto,
+};
+
+static int __init on26_init(void)
+{
+	return pi_register(&on26)-1;
 }
 
-void    cleanup_module(void)
-
-{       pi_unregister( &on26 );
+static void __exit on26_exit(void)
+{
+	pi_unregister(&on26);
 }
 
-#endif
-
-/* end of on26.c */
-
 MODULE_LICENSE("GPL");
+module_init(on26_init)
+module_exit(on26_exit)
diff --git a/drivers/block/paride/paride.c b/drivers/block/paride/paride.c
index e3a6150acff6..18bd7892269c 100644
--- a/drivers/block/paride/paride.c
+++ b/drivers/block/paride/paride.c
@@ -431,136 +431,3 @@ int pi_init(PIA *pi, int autoprobe, int port, int mode,
 }
 
 EXPORT_SYMBOL(pi_init);
-
-#ifdef MODULE
-
-int	init_module(void)
-
-{
-	int k;
-	const char *indicate_pp = "";
-#ifdef CONFIG_PARPORT
-	indicate_pp = " (parport)";
-#endif
-
-	for (k=0;k<MAX_PROTOS;k++) protocols[k] = 0;
-
-	printk("paride: version %s installed%s\n",PI_VERSION,indicate_pp);
-	return 0;
-}
-
-void	cleanup_module(void)
-
-{
-}
-
-#else
-
-void	paride_init( void )
-
-{
-
-#ifdef CONFIG_PARIDE_ATEN
-	{ extern struct pi_protocol aten;
-	  pi_register(&aten);
-	};
-#endif
-#ifdef CONFIG_PARIDE_BPCK
-        { extern struct pi_protocol bpck;
-          pi_register(&bpck);
-        };
-#endif
-#ifdef CONFIG_PARIDE_COMM
-        { extern struct pi_protocol comm;
-          pi_register(&comm);
-        };
-#endif
-#ifdef CONFIG_PARIDE_DSTR
-        { extern struct pi_protocol dstr;
-          pi_register(&dstr);
-        };
-#endif
-#ifdef CONFIG_PARIDE_EPAT
-        { extern struct pi_protocol epat;
-          pi_register(&epat);
-        };
-#endif
-#ifdef CONFIG_PARIDE_EPIA
-        { extern struct pi_protocol epia;
-          pi_register(&epia);
-        };
-#endif
-#ifdef CONFIG_PARIDE_FRPW
-        { extern struct pi_protocol frpw;
-          pi_register(&frpw);
-        };
-#endif
-#ifdef CONFIG_PARIDE_FRIQ
-        { extern struct pi_protocol friq;
-          pi_register(&friq);
-        };
-#endif 
-#ifdef CONFIG_PARIDE_FIT2
-        { extern struct pi_protocol fit2;
-          pi_register(&fit2);
-        };
-#endif
-#ifdef CONFIG_PARIDE_FIT3
-        { extern struct pi_protocol fit3;
-          pi_register(&fit3);
-        };
-#endif
-#ifdef CONFIG_PARIDE_KBIC
-        { extern struct pi_protocol k951;
-          extern struct pi_protocol k971;
-          pi_register(&k951);
-          pi_register(&k971);
-        };
-#endif
-#ifdef CONFIG_PARIDE_KTTI
-        { extern struct pi_protocol ktti;
-          pi_register(&ktti);
-        };
-#endif
-#ifdef CONFIG_PARIDE_ON20
-        { extern struct pi_protocol on20;
-          pi_register(&on20);
-        };
-#endif
-#ifdef CONFIG_PARIDE_ON26
-        { extern struct pi_protocol on26;
-          pi_register(&on26);
-        };
-#endif
-
-#ifdef CONFIG_PARIDE_PD
-	{ extern int pd_init(void);
-	  pd_init();
-	};
-#endif
-#ifdef CONFIG_PARIDE_PCD
-        { extern int pcd_init(void);
-          pcd_init();
-        };
-#endif
-#ifdef CONFIG_PARIDE_PF
-        { extern int pf_init(void);
-          pf_init();
-        };
-#endif
-#ifdef CONFIG_PARIDE_PT
-        { extern int pt_init(void);
-          pt_init();
-        };
-#endif
-#ifdef CONFIG_PARIDE_PG
-        { extern int pg_init(void);
-          pg_init();
-        };
-#endif
-}
-
-#endif
-
-/* end of paride.c */
-MODULE_LICENSE("GPL");
diff --git a/drivers/block/paride/pcd.c b/drivers/block/paride/pcd.c
index e9839726b20e..25273d4ba1b8 100644
--- a/drivers/block/paride/pcd.c
+++ b/drivers/block/paride/pcd.c
@@ -137,6 +137,7 @@ static int pcd_drive_count;
 /* end of parameters */
 
 #include <linux/module.h>
+#include <linux/init.h>
 #include <linux/errno.h>
 #include <linux/fs.h>
 #include <linux/kernel.h>
@@ -200,9 +201,6 @@ MODULE_PARM(drive3,"1-6i");
 #define IDE_READY       0x40
 #define IDE_BUSY        0x80
 
-int pcd_init(void);
-void cleanup_module( void );
-
 static int pcd_open(struct cdrom_device_info *cdi, int purpose);
 static void pcd_release(struct cdrom_device_info *cdi);
 static int pcd_drive_status(struct cdrom_device_info *cdi, int slot_nr);
@@ -327,84 +325,18 @@ static void pcd_init_units( void )
         }
 }
 
-int pcd_init (void)	/* preliminary initialisation */
-{
-	int unit;
-
-	if (disable) return -1;
-
-	pcd_init_units();
-
-	if (pcd_detect()) return -1;
-
-	/* get the atapi capabilities page */
-	pcd_probe_capabilities();
-
-	if (register_blkdev(MAJOR_NR,name,&pcd_bdops)) {
-		printk("pcd: unable to get major number %d\n",MAJOR_NR);
-		return -1;
-	}
-
-	for (unit=0;unit<PCD_UNITS;unit++) {
-		if (PCD.present) {
-			register_cdrom(&PCD.info);
-			devfs_plain_cdrom(&PCD.info, &pcd_bdops);
-		}
-	}
-
-	blk_init_queue(BLK_DEFAULT_QUEUE(MAJOR_NR), do_pcd_request, &pcd_lock);
-
-	return 0;
-}
-
 static int pcd_open(struct cdrom_device_info *cdi, int purpose)
-
-{	int unit = DEVICE_NR(cdi->dev);
-
-	if  ((unit >= PCD_UNITS) || (!PCD.present)) return -ENODEV;
-
+{
+	int unit = DEVICE_NR(cdi->dev);
+	if  ((unit >= PCD_UNITS) || (!PCD.present))
+		return -ENODEV;
 	return 0;
 }
 
 static void pcd_release(struct cdrom_device_info *cdi)
-
 {
 }
 
-#ifdef MODULE
-
-/* Glue for modules ... */
-
-int	init_module(void)
-
-{	int	err;
-
-#ifdef PARIDE_JUMBO
-       { extern paride_init();
-         paride_init();
-       } 
-#endif
-
-	err = pcd_init();
-
-	return err;
-}
-
-void	cleanup_module(void)
-
-{	int unit;
-	
-        for (unit=0;unit<PCD_UNITS;unit++) 
-           if (PCD.present) {
-		pi_release(PI);
-		unregister_cdrom(&PCD.info);
-	   }
-
-	unregister_blkdev(MAJOR_NR,name);
-}
-
-#endif
-
 #define WR(c,r,v)       pi_write_regr(PI,c,r,v)
 #define RR(c,r)         (pi_read_regr(PI,c,r))
 
@@ -950,6 +882,50 @@ static int pcd_get_mcn (struct cdrom_device_info *cdi, struct cdrom_mcn *mcn)
 	return 0;
 }
 
-/* end of pcd.c */
+
+static int __init pcd_init(void)
+{
+	int unit;
+
+	if (disable)
+		return -1;
+
+	pcd_init_units();
+
+	if (pcd_detect())
+		return -1;
+
+	/* get the atapi capabilities page */
+	pcd_probe_capabilities();
+
+	if (register_blkdev(MAJOR_NR,name,&pcd_bdops)) {
+		printk("pcd: unable to get major number %d\n",MAJOR_NR);
+		return -1;
+	}
+
+	for (unit=0;unit<PCD_UNITS;unit++) {
+		if (PCD.present) {
+			register_cdrom(&PCD.info);
+			devfs_plain_cdrom(&PCD.info, &pcd_bdops);
+		}
+	}
+
+	blk_init_queue(BLK_DEFAULT_QUEUE(MAJOR_NR), do_pcd_request, &pcd_lock);
+
+	return 0;
+}
+
+static void __exit pcd_exit(void)
+{
+	int unit;
+	for (unit=0;unit<PCD_UNITS;unit++) 
+		if (PCD.present) {
+			pi_release(PI);
+			unregister_cdrom(&PCD.info);
+		}
+	unregister_blkdev(MAJOR_NR,name);
+}
 
 MODULE_LICENSE("GPL");
+module_init(pcd_init)
+module_exit(pcd_exit)
diff --git a/drivers/block/paride/pd.c b/drivers/block/paride/pd.c
index cb10da16d136..f9b681ac6b86 100644
--- a/drivers/block/paride/pd.c
+++ b/drivers/block/paride/pd.c
@@ -153,16 +153,12 @@ static int pd_drive_count;
 
 /* end of parameters */
 
+#include <linux/init.h>
 #include <linux/module.h>
-#include <linux/errno.h>
 #include <linux/fs.h>
-#include <linux/devfs_fs_kernel.h>
-#include <linux/kernel.h>
 #include <linux/delay.h>
-#include <linux/genhd.h>
 #include <linux/hdreg.h>
 #include <linux/cdrom.h>	/* for the eject ioctl */
-#include <linux/spinlock.h>
 
 #include <asm/uaccess.h>
 
@@ -181,8 +177,8 @@ static STT pd_stt[7] = {{"drive0",8,drive0},
 		        {"nice",1,&nice}};
 
 void pd_setup( char *str, int *ints)
-
-{	generic_setup(pd_stt,7,str);
+{
+	generic_setup(pd_stt,7,str);
 }
 
 #endif
@@ -199,19 +195,15 @@ MODULE_PARM(drive3,"1-8i");
 
 #include "paride.h"
 
-#define PD_BITS    4
-
-/* set up defines for blk.h,  why don't all drivers do it this way ? */
-
 #define MAJOR_NR   major
-#define DEVICE_NR(device) (minor(device)>>PD_BITS)
-#define DEVICE_OFF(device)
 
 #include <linux/blk.h>
 #include <linux/blkpg.h>
 
 #include "pseudo.h"
 
+#define PD_BITS    4
+#define DEVICE_NR(device) (minor(device)>>PD_BITS)
 #define PD_PARTNS  	(1<<PD_BITS)
 #define PD_DEVS		PD_PARTNS*PD_UNITS
 
@@ -258,11 +250,7 @@ MODULE_PARM(drive3,"1-8i");
 #define IDE_IDENTIFY    	0xec
 #define IDE_EJECT		0xed
 
-int pd_init(void);
 void pd_setup(char * str, int * ints);
-#ifdef MODULE
-void cleanup_module( void );
-#endif
 static int pd_open(struct inode *inode, struct file *file);
 static void do_pd_request(request_queue_t * q);
 static int pd_ioctl(struct inode *inode,struct file *file,
@@ -296,6 +284,7 @@ struct pd_unit {
 	int heads;                	/* physical geometry */
 	int sectors;
 	int cylinders;
+	int can_lba;
 	int drive;			/* master=0 slave=1 */
 	int changed;			/* Have we seen a disk change ? */
 	int removable;			/* removable media device  ?  */
@@ -303,7 +292,7 @@ struct pd_unit {
 	int alt_geom;
 	int present;
 	char name[PD_NAMELEN];		/* pda, pdb, etc ... */
-	};
+};
 
 struct pd_unit pd[PD_UNITS];
 
@@ -312,7 +301,6 @@ struct pd_unit pd[PD_UNITS];
 #define PD pd[unit]
 #define PI PD.pi
 
-static int pd_valid = 1;		/* serialise partition checks */
 static char pd_scratch[512];            /* scratch block buffer */
 
 /* the variables below are used mainly in the I/O request engine, which
@@ -379,47 +367,12 @@ void pd_init_units( void )
 	}
 }
 
-int pd_init (void)
-{
-	request_queue_t * q;
-
-	if (disable) return -1;
-        if (devfs_register_blkdev(MAJOR_NR,name,&pd_fops)) {
-                printk("%s: unable to get major number %d\n",
-                        name,major);
-                return -1;
-        }
-	q = BLK_DEFAULT_QUEUE(MAJOR_NR);
-	blk_init_queue(q, do_pd_request, &pd_lock);
-	blk_queue_max_sectors(q, cluster);
-
-	pd_gendisk.major = major;
-	pd_gendisk.major_name = name;
-	add_gendisk(&pd_gendisk);
-
-	printk("%s: %s version %s, major %d, cluster %d, nice %d\n",
-		name,name,PD_VERSION,major,cluster,nice);
-	pd_init_units();
-	pd_valid = 0;
-	pd_gendisk.nr_real = pd_detect();
-	pd_valid = 1;
-
-#ifdef MODULE
-        if (!pd_gendisk.nr_real) {
-		cleanup_module();
-		return -1;
-	}
-#endif
-        return 0;
-}
-
 static int pd_open (struct inode *inode, struct file *file)
+{
+	int unit = DEVICE_NR(inode->i_rdev);
 
-{       int unit = DEVICE_NR(inode->i_rdev);
-
-        if ((unit >= PD_UNITS) || (!PD.present)) return -ENODEV;
-
-	wait_event (pd_wait_open, pd_valid);
+        if ((unit >= PD_UNITS) || (!PD.present))
+		return -ENODEV;
 
         PD.access++;
 
@@ -434,11 +387,8 @@ static int pd_ioctl(struct inode *inode,struct file *file,
                     unsigned int cmd, unsigned long arg)
 {
 	struct hd_geometry *geo = (struct hd_geometry *) arg;
-	int err, unit;
+	int err, unit = DEVICE_NR(inode->i_rdev);
 
-	if (!inode || kdev_none(inode->i_rdev))
-		return -EINVAL;
-	unit = DEVICE_NR(inode->i_rdev);
 	if (!PD.present)
 		return -ENODEV;
 
@@ -461,50 +411,34 @@ static int pd_ioctl(struct inode *inode,struct file *file,
 		    put_user(PD.heads, (char *) &geo->heads);
 		    put_user(PD.sectors, (char *) &geo->sectors);
 		}
-		put_user(get_start_sect(inode->i_rdev), (long *)&geo->start);
+		put_user(get_start_sect(inode->i_bdev), (long *)&geo->start);
 		return 0;
 	    case BLKRRPART:
 		if (!capable(CAP_SYS_ADMIN))
 			return -EACCES;
 		return pd_revalidate(inode->i_rdev);
-	    case BLKGETSIZE:
-	    case BLKGETSIZE64:
-	    case BLKROSET:
-	    case BLKROGET:
-	    case BLKFLSBUF:
-	    case BLKPG:
-		return blk_ioctl(inode->i_bdev, cmd, arg);
 	    default:
 		return -EINVAL;
 	}
 }
 
 static int pd_release (struct inode *inode, struct file *file)
+{
+	int	unit = DEVICE_NR(inode->i_rdev);
 
-{       kdev_t devp;
-	int	unit;
-
-        devp = inode->i_rdev;
-	unit = DEVICE_NR(devp);
-
-	if ((unit >= PD_UNITS) || (PD.access <= 0)) 
-		return -EINVAL;
-
-	PD.access--;
-
-        if (!PD.access && PD.removable)
+        if (!--PD.access && PD.removable)
 		pd_doorlock(unit,IDE_DOORUNLOCK);
 
 	return 0;
 }
 
 static int pd_check_media( kdev_t dev)
-
-{       int r, unit;
-
-	unit = DEVICE_NR(dev);
-	if ((unit >= PD_UNITS) || (!PD.present)) return -ENODEV;
-        if (!PD.removable) return 0;
+{
+	int r, unit = DEVICE_NR(dev);
+	if ((unit >= PD_UNITS) || (!PD.present))
+		return -ENODEV;
+        if (!PD.removable)
+		return 0;
 	pd_media_check(unit);
 	r = PD.changed;
 	PD.changed = 0;
@@ -513,64 +447,26 @@ static int pd_check_media( kdev_t dev)
 
 static int pd_revalidate(kdev_t dev)
 {
-	int unit, res;
-	long flags;
+	int unit = DEVICE_NR(dev);
+	kdev_t device = mk_kdev(MAJOR_NR, unit << PD_BITS);
+	int res;
 
-	unit = DEVICE_NR(dev);
 	if ((unit >= PD_UNITS) || !PD.present)
 		return -ENODEV;
 
-	save_flags(flags);
-	cli(); 
-	if (PD.access > 1) {
-		restore_flags(flags);
-		return -EBUSY;
-	}
-	pd_valid = 0;
-	restore_flags(flags);   
-
-	res = wipe_partitions(dev);
+	res = dev_lock_part(device);
+	if (res < 0)
+		return res;
+	res = wipe_partitions(device);
 
 	if (res == 0 && pd_identify(unit))
-		grok_partitions(dev, PD.capacity);
+		grok_partitions(device, PD.capacity);
 
-	pd_valid = 1;
-	wake_up(&pd_wait_open);
+	dev_unlock_part(device);
  
         return res;
 }
 
-#ifdef MODULE
-
-/* Glue for modules ... */
-
-void    cleanup_module(void);
-
-int     init_module(void)
-
-{
-
-#ifdef PARIDE_JUMBO
-       { extern paride_init();
-         paride_init();
-       } 
-#endif
-        return pd_init();
-}
-
-void    cleanup_module(void)
-{
-	int unit;
-
-	devfs_unregister_blkdev(MAJOR_NR, name);
-	del_gendisk(&pd_gendisk);
-
-	for (unit=0; unit<PD_UNITS; unit++) 
-		if (PD.present)
-			pi_release(PI);
-}
-#endif
-
 #define	WR(c,r,v)	pi_write_regr(PI,c,r,v)
 #define	RR(c,r)		(pi_read_regr(PI,c,r))
 
@@ -619,7 +515,6 @@ static int pd_wait_for( int unit, int w, char * msg )    /* polled wait */
 
 static void pd_send_command( int unit, int n, int s, int h, 
 			     int c0, int c1, int func )
-
 {
         WR(0,6,DRIVE+h);
         WR(0,1,0);                /* the IDE task file */
@@ -633,16 +528,20 @@ static void pd_send_command( int unit, int n, int s, int h,
 }
 
 static void pd_ide_command( int unit, int func, int block, int count )
-
-/* Don't use this call if the capacity is zero. */
-
-{       int c1, c0, h, s;
-
-        s  = ( block % PD.sectors) + 1;
-        h  = ( block / PD.sectors) % PD.heads;
-        c0 = ( block / (PD.sectors*PD.heads)) % 256;
-        c1 = ( block / (PD.sectors*PD.heads*256));
-
+{
+	int c1, c0, h, s;
+
+	if (PD.can_lba) {
+		s = block & 255;
+		c0 = (block >>= 8) & 255;
+		c1 = (block >>= 8) & 255;
+		h = ((block >>= 8) & 15) + 0x40;
+	} else {
+		s  = ( block % PD.sectors) + 1;
+		h  = ( block /= PD.sectors) % PD.heads;
+		c0 = ( block /= PD.heads) % 256;
+		c1 = (block >>= 8);
+	}
         pd_send_command(unit,count,s,h,c0,c1,func);
 }
 
@@ -742,10 +641,14 @@ static int pd_identify( int unit )
         }
         pi_read_block(PI,pd_scratch,512);
         pi_disconnect(PI);
-        PD.sectors = word_val(6);
-        PD.heads = word_val(3);
-        PD.cylinders  = word_val(1);
-        PD.capacity = PD.sectors*PD.heads*PD.cylinders;
+	PD.can_lba = pd_scratch[99] & 2;
+	PD.sectors = le16_to_cpu(*(u16*)(pd_scratch+12));
+	PD.heads = le16_to_cpu(*(u16*)(pd_scratch+6));
+	PD.cylinders  = le16_to_cpu(*(u16*)(pd_scratch+2));
+	if (PD.can_lba)
+		PD.capacity = le32_to_cpu(*(u32*)(pd_scratch + 120));
+	else
+		PD.capacity = PD.sectors*PD.heads*PD.cylinders;
 
         for(j=0;j<PD_ID_LEN;j++) id[j^1] = pd_scratch[j+PD_ID_OFF];
         j = PD_ID_LEN-1;
@@ -763,7 +666,7 @@ static int pd_identify( int unit )
 
         if (PD.capacity) pd_init_dev_parms(unit);
         if (!PD.standby) pd_standby_off(unit);
-	
+
         return 1;
 }
 
@@ -1031,6 +934,50 @@ static void do_pd_write_done( void )
 	spin_unlock_irqrestore(&pd_lock,saved_flags);
 }
 
-/* end of pd.c */
+static int __init pd_init(void)
+{
+	request_queue_t * q;
+	int unit;
+
+	if (disable) return -1;
+        if (devfs_register_blkdev(MAJOR_NR,name,&pd_fops)) {
+                printk("%s: unable to get major number %d\n",
+                        name,major);
+                return -1;
+        }
+	q = BLK_DEFAULT_QUEUE(MAJOR_NR);
+	blk_init_queue(q, do_pd_request, &pd_lock);
+	blk_queue_max_sectors(q, cluster);
+
+	pd_gendisk.major = major;
+	pd_gendisk.major_name = name;
+	add_gendisk(&pd_gendisk);
+
+	printk("%s: %s version %s, major %d, cluster %d, nice %d\n",
+		name,name,PD_VERSION,major,cluster,nice);
+	pd_init_units();
+	pd_gendisk.nr_real = pd_detect();
+        if (!pd_gendisk.nr_real) {
+		devfs_unregister_blkdev(MAJOR_NR, name);
+		del_gendisk(&pd_gendisk);
+		for (unit=0; unit<PD_UNITS; unit++) 
+			if (PD.present)
+				pi_release(PI);
+		return -1;
+	}
+        return 0;
+}
+
+static void __exit pd_exit(void)
+{
+	int unit;
+	devfs_unregister_blkdev(MAJOR_NR, name);
+	del_gendisk(&pd_gendisk);
+	for (unit=0; unit<PD_UNITS; unit++) 
+		if (PD.present)
+			pi_release(PI);
+}
 
 MODULE_LICENSE("GPL");
+module_init(pd_init)
+module_exit(pd_exit)
diff --git a/drivers/block/paride/pf.c b/drivers/block/paride/pf.c
index 578feaadbb38..a117aa6df61a 100644
--- a/drivers/block/paride/pf.c
+++ b/drivers/block/paride/pf.c
@@ -153,11 +153,9 @@ static int pf_drive_count;
 
 
 #include <linux/module.h>
-#include <linux/errno.h>
+#include <linux/init.h>
 #include <linux/fs.h>
-#include <linux/kernel.h>
 #include <linux/delay.h>
-#include <linux/genhd.h>
 #include <linux/hdreg.h>
 #include <linux/cdrom.h>
 #include <linux/spinlock.h>
@@ -240,7 +238,6 @@ MODULE_PARM(drive3,"1-7i");
 #define ATAPI_READ_10		0x28
 #define ATAPI_WRITE_10		0x2a
 
-int pf_init(void);
 #ifdef MODULE
 void cleanup_module( void );
 #endif
@@ -337,34 +334,6 @@ void pf_init_units( void )
         }
 } 
 
-int pf_init (void)      /* preliminary initialisation */
-
-{       int i;
-	request_queue_t * q; 
-
-	if (disable) return -1;
-
-	pf_init_units();
-
-	if (pf_detect()) return -1;
-	pf_busy = 0;
-
-        if (register_blkdev(MAJOR_NR,name,&pf_fops)) {
-                printk("pf_init: unable to get major number %d\n",
-                        major);
-                return -1;
-        }
-	q = BLK_DEFAULT_QUEUE(MAJOR_NR);
-	blk_init_queue(q, do_pf_request, &pf_spin_lock);
-	blk_queue_max_phys_segments(q, cluster);
-	blk_queue_max_hw_segments(q, cluster);
-
-	for (i=0;i<PF_UNITS;i++)
-		register_disk(NULL, mk_kdev(MAJOR_NR, i), 1, &pf_fops, 0);
-
-        return 0;
-}
-
 static int pf_open (struct inode *inode, struct file *file)
 
 {       int	unit = DEVICE_NR(inode->i_rdev);
@@ -423,10 +392,6 @@ static int pf_ioctl(struct inode *inode,struct file *file,
                 return put_user(PF.capacity,(long *) arg);
             case BLKGETSIZE64:
                 return put_user((u64)PF.capacity << 9,(u64 *)arg);
-	    case BLKROSET:
-	    case BLKROGET:
-	    case BLKFLSBUF:
-		return blk_ioctl(inode->i_bdev, cmd, arg);
             default:
                 return -EINVAL;
         }
@@ -458,39 +423,6 @@ static int pf_check_media( kdev_t dev)
 {       return 1;
 }
 
-#ifdef MODULE
-
-/* Glue for modules ... */
-
-void    cleanup_module(void);
-
-int     init_module(void)
-
-{       int     err;
-
-#ifdef PARIDE_JUMBO
-       { extern paride_init();
-         paride_init();
-       } 
-#endif
-
-        err = pf_init();
-
-        return err;
-}
-
-void    cleanup_module(void)
-
-{       int unit;
-
-        unregister_blkdev(MAJOR_NR,name);
-
-	for (unit=0;unit<PF_UNITS;unit++)
-	  if (PF.present) pi_release(PI);
-}
-
-#endif
-
 #define	WR(c,r,v)	pi_write_regr(PI,c,r,v)
 #define	RR(c,r)		(pi_read_regr(PI,c,r))
 
@@ -1040,6 +972,44 @@ static void do_pf_write_done( void )
 	spin_unlock_irqrestore(&pf_spin_lock,saved_flags);
 }
 
-/* end of pf.c */
+static int __init pf_init(void)      /* preliminary initialisation */
+{
+	int i;
+	request_queue_t * q; 
+
+	if (disable)
+		return -1;
+
+	pf_init_units();
+
+	if (pf_detect())
+		return -1;
+	pf_busy = 0;
+
+	if (register_blkdev(MAJOR_NR,name,&pf_fops)) {
+		printk("pf_init: unable to get major number %d\n", major);
+		return -1;
+	}
+	q = BLK_DEFAULT_QUEUE(MAJOR_NR);
+	blk_init_queue(q, do_pf_request, &pf_spin_lock);
+	blk_queue_max_phys_segments(q, cluster);
+	blk_queue_max_hw_segments(q, cluster);
+
+	for (i=0;i<PF_UNITS;i++)
+		register_disk(NULL, mk_kdev(MAJOR_NR, i), 1, &pf_fops, 0);
 
+	return 0;
+}
+
+static void __exit pf_exit(void)
+{
+	int unit;
+	unregister_blkdev(MAJOR_NR,name);
+	for (unit=0;unit<PF_UNITS;unit++)
+		if (PF.present)
+			pi_release(PI);
+}
+ 
 MODULE_LICENSE("GPL");
+module_init(pf_init)
+module_exit(pf_exit)
diff --git a/drivers/block/paride/pg.c b/drivers/block/paride/pg.c
index 5f5af68fc86c..0a43b4a5d61b 100644
--- a/drivers/block/paride/pg.c
+++ b/drivers/block/paride/pg.c
@@ -162,16 +162,13 @@ static int pg_drive_count;
 
 
 #include <linux/module.h>
-#include <linux/errno.h>
+#include <linux/init.h>
 #include <linux/fs.h>
 #include <linux/devfs_fs_kernel.h>
-#include <linux/kernel.h>
 #include <linux/delay.h>
 #include <linux/slab.h>
 #include <linux/mtio.h>
 #include <linux/pg.h>
-#include <linux/wait.h>
-#include <linux/smp_lock.h>
 
 #include <asm/uaccess.h>
 
@@ -218,11 +215,6 @@ MODULE_PARM(drive3,"1-6i");
 
 #define ATAPI_IDENTIFY		0x12
 
-int pg_init(void);
-#ifdef MODULE
-void cleanup_module( void );
-#endif
-
 static int pg_open(struct inode *inode, struct file *file);
 static int pg_release (struct inode *inode, struct file *file);
 static ssize_t pg_read(struct file * filp, char * buf, 
@@ -291,64 +283,6 @@ void pg_init_units( void )
 
 static devfs_handle_t devfs_handle;
 
-int pg_init (void)      /* preliminary initialisation */
-
-{       int unit;
-
-	if (disable) return -1;
-
-	pg_init_units();
-
-	if (pg_detect()) return -1;
-
-	if (devfs_register_chrdev(major,name,&pg_fops)) {
-		printk("pg_init: unable to get major number %d\n",
-			major);
-		for (unit=0;unit<PG_UNITS;unit++)
-		  if (PG.present) pi_release(PI);
-		return -1;
-	}
-	devfs_handle = devfs_mk_dir (NULL, "pg", NULL);
-	devfs_register_series (devfs_handle, "%u", 4, DEVFS_FL_DEFAULT,
-			       major, 0, S_IFCHR | S_IRUSR | S_IWUSR,
-			       &pg_fops, NULL);
-	return 0;
-}
-
-#ifdef MODULE
-
-/* Glue for modules ... */
-
-void    cleanup_module(void);
-
-int     init_module(void)
-
-{       int     err;
-
-#ifdef PARIDE_JUMBO
-       { extern paride_init();
-         paride_init();
-       } 
-#endif
-
-	err = pg_init();
-
-	return err;
-}
-
-void    cleanup_module(void)
-
-{       int unit;
-
-	devfs_unregister (devfs_handle);
-	devfs_unregister_chrdev(major,name);
-
-	for (unit=0;unit<PG_UNITS;unit++)
-	  if (PG.present) pi_release(PI);
-}
-
-#endif
-
 #define	WR(c,r,v)	pi_write_regr(PI,c,r,v)
 #define	RR(c,r)		(pi_read_regr(PI,c,r))
 
@@ -691,6 +625,43 @@ static ssize_t pg_read(struct file * filp, char * buf,
 	return copy+hs;
 }
 
-/* end of pg.c */
+static int __init pg_init(void)
+{
+	int unit;
+
+	if (disable)
+		return -1;
+
+	pg_init_units();
+
+	if (pg_detect())
+		return -1;
+
+	if (devfs_register_chrdev(major,name,&pg_fops)) {
+		printk("pg_init: unable to get major number %d\n",
+			major);
+		for (unit=0;unit<PG_UNITS;unit++)
+		  if (PG.present) pi_release(PI);
+		return -1;
+	}
+	devfs_handle = devfs_mk_dir (NULL, "pg", NULL);
+	devfs_register_series (devfs_handle, "%u", 4, DEVFS_FL_DEFAULT,
+			       major, 0, S_IFCHR | S_IRUSR | S_IWUSR,
+			       &pg_fops, NULL);
+	return 0;
+}
+
+static void __exit pg_exit(void)
+{
+	int unit;
+
+	devfs_unregister (devfs_handle);
+	devfs_unregister_chrdev(major,name);
+
+	for (unit=0;unit<PG_UNITS;unit++)
+		if (PG.present) pi_release(PI);
+}
 
 MODULE_LICENSE("GPL");
+module_init(pg_init)
+module_exit(pg_exit)
diff --git a/drivers/block/paride/pt.c b/drivers/block/paride/pt.c
index ccf3db7b1463..bc987791fd32 100644
--- a/drivers/block/paride/pt.c
+++ b/drivers/block/paride/pt.c
@@ -141,15 +141,12 @@ static int pt_drive_count;
 
 
 #include <linux/module.h>
-#include <linux/errno.h>
+#include <linux/init.h>
 #include <linux/fs.h>
 #include <linux/devfs_fs_kernel.h>
-#include <linux/kernel.h>
 #include <linux/delay.h>
 #include <linux/slab.h>
 #include <linux/mtio.h>
-#include <linux/wait.h>
-#include <linux/smp_lock.h>
 
 #include <asm/uaccess.h>
 
@@ -209,11 +206,6 @@ MODULE_PARM(drive3,"1-6i");
 #define ATAPI_MODE_SENSE	0x1a
 #define ATAPI_LOG_SENSE		0x4d
 
-int pt_init(void);
-#ifdef MODULE
-void cleanup_module( void );
-#endif
-
 static int pt_open(struct inode *inode, struct file *file);
 static int pt_ioctl(struct inode *inode,struct file *file,
                     unsigned int cmd, unsigned long arg);
@@ -291,71 +283,9 @@ void pt_init_units( void )
                 PT.name[j] = 0;
                 if (DU[D_PRT]) pt_drive_count++;
         }
-} 
-
-static devfs_handle_t devfs_handle;
-
-int pt_init (void)      /* preliminary initialisation */
-
-{       int unit;
-
-	if (disable) return -1;
-
-	pt_init_units();
-
-	if (pt_detect()) return -1;
-
-	if (devfs_register_chrdev(major,name,&pt_fops)) {
-                printk("pt_init: unable to get major number %d\n",
-                        major);
-	        for (unit=0;unit<PT_UNITS;unit++)
-        	  if (PT.present) pi_release(PI);
-                return -1;
-        }
-
-	devfs_handle = devfs_mk_dir (NULL, "pt", NULL);
-	devfs_register_series (devfs_handle, "%u", 4, DEVFS_FL_DEFAULT,
-			       major, 0, S_IFCHR | S_IRUSR | S_IWUSR,
-			       &pt_fops, NULL);
-	devfs_register_series (devfs_handle, "%un", 4, DEVFS_FL_DEFAULT,
-			       major, 128, S_IFCHR | S_IRUSR | S_IWUSR,
-			       &pt_fops, NULL);
-        return 0;
 }
 
-#ifdef MODULE
-
-/* Glue for modules ... */
-
-void    cleanup_module(void);
-
-int     init_module(void)
-
-{       int     err;
-
-#ifdef PARIDE_JUMBO
-       { extern paride_init();
-         paride_init();
-       } 
-#endif
-
-        err = pt_init();
-
-        return err;
-}
-
-void    cleanup_module(void)
-
-{	int unit;
-
-	devfs_unregister (devfs_handle);
-	devfs_unregister_chrdev(major,name);
-
-	for (unit=0;unit<PT_UNITS;unit++)
-	  if (PT.present) pi_release(PI);
-}
-
-#endif
+static devfs_handle_t devfs_handle;
 
 #define	WR(c,r,v)	pi_write_regr(PI,c,r,v)
 #define	RR(c,r)		(pi_read_regr(PI,c,r))
@@ -965,6 +895,46 @@ static ssize_t pt_write(struct file * filp, const char * buf,
 	return t;
 }
 
-/* end of pt.c */
+static int __init pt_init(void)
+{
+	int unit;
+
+	if (disable)
+		return -1;
+
+	pt_init_units();
+
+	if (pt_detect())
+		return -1;
+
+	if (devfs_register_chrdev(major,name,&pt_fops)) {
+		printk("pt_init: unable to get major number %d\n",
+			major);
+		for (unit=0;unit<PT_UNITS;unit++)
+			if (PT.present) pi_release(PI);
+		return -1;
+	}
+
+	devfs_handle = devfs_mk_dir (NULL, "pt", NULL);
+	devfs_register_series (devfs_handle, "%u", 4, DEVFS_FL_DEFAULT,
+			       major, 0, S_IFCHR | S_IRUSR | S_IWUSR,
+			       &pt_fops, NULL);
+	devfs_register_series (devfs_handle, "%un", 4, DEVFS_FL_DEFAULT,
+			       major, 128, S_IFCHR | S_IRUSR | S_IWUSR,
+			       &pt_fops, NULL);
+	return 0;
+}
+
+static void __exit pt_exit(void)
+{
+	int unit;
+	devfs_unregister (devfs_handle);
+	devfs_unregister_chrdev(major,name);
+	for (unit=0;unit<PT_UNITS;unit++)
+		if (PT.present)
+			pi_release(PI);
+}
 
 MODULE_LICENSE("GPL");
+module_init(pt_init)
+module_exit(pt_exit)
diff --git a/drivers/block/ps2esdi.c b/drivers/block/ps2esdi.c
index bd604cee4663..1d734f15cab2 100644
--- a/drivers/block/ps2esdi.c
+++ b/drivers/block/ps2esdi.c
@@ -93,8 +93,6 @@ static void ps2esdi_geometry_int_handler(u_int);
 
 static int ps2esdi_open(struct inode *inode, struct file *file);
 
-static int ps2esdi_release(struct inode *inode, struct file *file);
-
 static int ps2esdi_ioctl(struct inode *inode, struct file *file,
 			 u_int cmd, u_long arg);
 
@@ -111,11 +109,8 @@ static void ps2esdi_reset_timer(unsigned long unused);
 static u_int dma_arb_level;		/* DMA arbitration level */
 
 static DECLARE_WAIT_QUEUE_HEAD(ps2esdi_int);
-static DECLARE_WAIT_QUEUE_HEAD(ps2esdi_wait_open);
 
 static int no_int_yet;
-static int access_count[MAX_HD];
-static char ps2esdi_valid[MAX_HD];
 static int ps2esdi_sizes[MAX_HD << 6];
 static int ps2esdi_drives;
 static struct hd_struct ps2esdi[MAX_HD << 6];
@@ -152,7 +147,6 @@ static struct block_device_operations ps2esdi_fops =
 {
 	owner:		THIS_MODULE,
 	open:		ps2esdi_open,
-	release:	ps2esdi_release,
 	ioctl:		ps2esdi_ioctl,
 };
 
@@ -441,13 +435,11 @@ static int __init ps2esdi_geninit(void)
 	}
 	blk_queue_max_sectors(BLK_DEFAULT_QUEUE(MAJOR_NR), 128);
 
-	for (i = 0; i < ps2esdi_drives; i++) {
+	for (i = 0; i < ps2esdi_drives; i++)
 		register_disk(&ps2esdi_gendisk,mk_kdev(MAJOR_NR,i<<6),1<<6,
 				&ps2esdi_fops,
 				ps2esdi_info[i].head * ps2esdi_info[i].sect *
 				ps2esdi_info[i].cyl);
-		ps2esdi_valid[i] = 1;
-	}
 	return 0;
 
 err_out3:
@@ -1083,32 +1075,11 @@ static void dump_cmd_complete_status(u_int int_ret_code)
 static int ps2esdi_open(struct inode *inode, struct file *file)
 {
 	int dev = DEVICE_NR(inode->i_rdev);
-
-	if (dev < ps2esdi_drives) {
-		while (!ps2esdi_valid[dev])
-			sleep_on(&ps2esdi_wait_open);
-
-		access_count[dev]++;
-
-		return (0);
-	} else
-		return (-ENODEV);
-}
-
-
-
-static int ps2esdi_release(struct inode *inode, struct file *file)
-{
-	int dev = DEVICE_NR(inode->i_rdev);
-
-	if (dev < ps2esdi_drives) {
-		access_count[dev]--;
-	}
+	if (dev >= ps2esdi_drives)
+		return -ENODEV;
 	return 0;
 }
 
-
-
 static int ps2esdi_ioctl(struct inode *inode,
 			 struct file *file, u_int cmd, u_long arg)
 {
@@ -1125,7 +1096,7 @@ static int ps2esdi_ioctl(struct inode *inode,
 				put_user(ps2esdi_info[dev].head, (char *) &geometry->heads);
 				put_user(ps2esdi_info[dev].sect, (char *) &geometry->sectors);
 				put_user(ps2esdi_info[dev].cyl, (short *) &geometry->cylinders);
-				put_user(get_start_sect(inode->i_rdev),
+				put_user(get_start_sect(inode->b_rdev),
 					    (long *) &geometry->start);
 
 				return 0;
@@ -1136,16 +1107,6 @@ static int ps2esdi_ioctl(struct inode *inode,
                         if (!capable(CAP_SYS_ADMIN)) 
 				return -EACCES;
 			return (ps2esdi_reread_partitions(inode->i_rdev));
-
-		case BLKGETSIZE:
-		case BLKGETSIZE64:
-		case BLKROSET:
-		case BLKROGET:
-		case BLKFLSBUF:
-		case BLKBSZGET:
-		case BLKBSZSET:
-		case BLKPG:
-			return blk_ioctl(inode->i_bdev, cmd, arg);
 		}
 	return (-EINVAL);
 }
@@ -1155,24 +1116,20 @@ static int ps2esdi_ioctl(struct inode *inode,
 static int ps2esdi_reread_partitions(kdev_t dev)
 {
 	int target = DEVICE_NR(dev);
-	int res;
+	kdev_t device = mk_kdev(MAJOR_NR, target << 6);
+	int res = dev_lock_part(device);
 
-	cli();
-	ps2esdi_valid[target] = (access_count[target] != 1);
-	sti();
-	if (ps2esdi_valid[target])
-		return (-EBUSY);
+	if (res < 0)
+		return res;
 
-	res = wipe_partitions(dev);
+	res = wipe_partitions(device);
 	if (res == 0)
-		grok_partitions(dev, ps2esdi_info[target].head
+		grok_partitions(device, ps2esdi_info[target].head
 				* ps2esdi_info[target].cyl
 				* ps2esdi_info[target].sect);
  
-	ps2esdi_valid[target] = 1;
-	wake_up(&ps2esdi_wait_open);
-
-	return (res);
+	dev_unlock_part(device);
+	return res;
 }
 
 static void ps2esdi_reset_timer(unsigned long unused)
diff --git a/drivers/block/rd.c b/drivers/block/rd.c
index 7b60e75d5584..662020429ba6 100644
--- a/drivers/block/rd.c
+++ b/drivers/block/rd.c
@@ -303,12 +303,6 @@ static int rd_ioctl(struct inode *inode, struct file *file, unsigned int cmd, un
 			}
 			up(&inode->i_bdev->bd_sem);
 			break;
-         	case BLKGETSIZE:
-         	case BLKGETSIZE64:
-		case BLKROSET:
-		case BLKROGET:
-		case BLKSSZGET:
-			error = blk_ioctl(inode->i_bdev, cmd, arg);
 	}
 out:
 	return error;
diff --git a/drivers/block/umem.c b/drivers/block/umem.c
index e046885bb67b..a1575eb830b0 100644
--- a/drivers/block/umem.c
+++ b/drivers/block/umem.c
@@ -65,7 +65,7 @@
 #define MM_BLKSIZE 1024  /* 1k blocks */
 #define MM_HARDSECT 512  /* 512-byte hardware sectors */
 #define MM_SHIFT 6       /* max 64 partitions on 4 cards  */
-#define DEVICE_NR(device) (MINOR(device)>>MM_SHIFT)
+#define DEVICE_NR(device) (minor(device)>>MM_SHIFT)
 
 /*
  * Version Information
@@ -150,7 +150,6 @@ struct cardinfo {
 		unsigned long	last_change;
 	} battery[2];
 
-	atomic_t	 usage;
 	spinlock_t 	lock;
 	int		check_batteries;
 
@@ -813,31 +812,21 @@ static void del_battery_timer(void)
  * Note no locks taken out here.  In a worst case scenario, we could drop
  * a chunk of system memory.  But that should never happen, since validation
  * happens at open or mount time, when locks are held.
+ *
+ *	That's crap, since doing that while some partitions are opened
+ * or mounted will give you really nasty results.
  */
 static int mm_revalidate(kdev_t i_rdev)
 {
-	int i;
-
-	int card_number = DEVICE_NR(kdev_val(i_rdev));
-	/* first partition, # of partitions */
-	int part1 = (card_number << MM_SHIFT) + 1;
-	int npart = (1 << MM_SHIFT) -1;
-
-	/* first clear old partition information */
-	for (i=0; i<npart ;i++) {
-		mm_gendisk.sizes[part1+i]=0;
-		mm_gendisk.part[part1+i].start_sect = 0;
-		mm_gendisk.part[part1+i].nr_sects = 0;
-	}
-
-	mm_gendisk.part[card_number << MM_SHIFT].nr_sects =
-		cards[card_number].mm_size << 1;
-
-
-	/* then fill new info */
+	int card_number = DEVICE_NR(i_rdev);
+	kdev_t device = mk_mdev(MAJOR_NR, card_number << MM_SHIFT);
+	int res = dev_lock_part(device);
+	if (res < 0)
+		return res;
+	wipe_partitions(device);
 	printk(KERN_INFO "mm partition check: (%d)\n", card_number);
-	grok_partitions(mk_kdev(major_nr,part1-1),
-			mm_gendisk.sizes[card_number<<MM_SHIFT]);
+	grok_partitions(device, cards[card_number].mm_size << 1);
+	dev_unlock_part(device);
 	return 0;
 }
 /*
@@ -859,16 +848,6 @@ static int mm_ioctl(struct inode *i, struct file *f, unsigned int cmd, unsigned
 
 
 	switch(cmd) {
-
-	case BLKGETSIZE:
-		/* Return the device size, expressed in sectors */
-		err = ! access_ok (VERIFY_WRITE, arg, sizeof(long));
-		if (err) return -EFAULT;
-		size = mm_gendisk.part[minor].nr_sects;
-		if (copy_to_user((long *) arg, &size, sizeof (long)))
-			return -EFAULT;
-		return 0;
-
 	case BLKRRPART:
 		return (mm_revalidate(i->i_rdev));
 
@@ -883,16 +862,15 @@ static int mm_ioctl(struct inode *i, struct file *f, unsigned int cmd, unsigned
 		size = cards[card_number].mm_size * (1024 / MM_HARDSECT);
 		geo.heads     = 64;
 		geo.sectors   = 32;
-		geo.start     = mm_gendisk.part[minor].start_sect;
+		geo.start     = get_start_sect(inode->i_bdev);
 		geo.cylinders = size / (geo.heads * geo.sectors);
 
 		if (copy_to_user((void *) arg, &geo, sizeof(geo)))
 			return -EFAULT;
 		return 0;
 
-
 	default:
-		return blk_ioctl(i->i_bdev, cmd, arg);
+		return -EINVAL;
 	}
 
 	return -ENOTTY; /* unknown command */
@@ -905,7 +883,7 @@ static int mm_ioctl(struct inode *i, struct file *f, unsigned int cmd, unsigned
 */
 static int mm_check_change(kdev_t i_rdev)
 {
-	int card_number = DEVICE_NR(kdev_val(i_rdev));
+	int card_number = DEVICE_NR(i_rdev);
 /*  struct cardinfo *dev = cards + card_number; */
 	if (card_number >= num_cards) /* paranoid */
 		return 0;
@@ -920,38 +898,8 @@ static int mm_check_change(kdev_t i_rdev)
 */
 static int mm_open(struct inode *i, struct file *filp)
 {
-	int num;
-	struct cardinfo *card;
-
-	num = DEVICE_NR(kdev_val(i->i_rdev));
-	if (num >= num_cards)
+	if (DEVICE_NR(i->i_rdev) >= num_cards)
 		return -ENXIO;
-
-	card = cards + num;
-
-	atomic_inc(&card->usage);
-	MOD_INC_USE_COUNT;
-
-	return 0;
-}
-/*
------------------------------------------------------------------------------------
---                              mm_do_release
------------------------------------------------------------------------------------
-*/
-static int mm_do_release(struct inode *i, struct file *filp)
-{
-	int num;
-	struct cardinfo *card;
-
-	num = DEVICE_NR(kdev_val(i->i_rdev));
-
-	card = cards + num;
-
-	if (atomic_dec_and_test(&card->usage))
-		invalidate_device(i->i_rdev, 1);
-
-	MOD_DEC_USE_COUNT;
 	return 0;
 }
 /*
@@ -962,7 +910,6 @@ static int mm_do_release(struct inode *i, struct file *filp)
 static struct block_device_operations mm_fops = {
 	owner:		THIS_MODULE,
 	open:		mm_open,
-	release:	mm_do_release,
 	ioctl:		mm_ioctl,
 	revalidate:	mm_revalidate,
 	check_media_change: mm_check_change,
@@ -1243,7 +1190,7 @@ static struct pci_driver mm_pci_driver = {
 
 static request_queue_t * mm_queue_proc(kdev_t dev)
 {
-	int c = DEVICE_NR(kdev_val(dev));
+	int c = DEVICE_NR(dev);
 
 	if (c < MM_MAXCARDS)
 		return &cards[c].queue;
@@ -1293,7 +1240,6 @@ int __init mm_init(void)
 	blk_dev[MAJOR_NR].queue = mm_queue_proc;
 	add_gendisk(&mm_gendisk);
 
-        blk_size[MAJOR_NR]      = mm_gendisk.sizes;
         for (i = 0; i < num_cards; i++) {
 		register_disk(&mm_gendisk, mk_kdev(MAJOR_NR, i<<MM_SHIFT), MM_SHIFT,
 			      &mm_fops, cards[i].mm_size << 1);
@@ -1325,9 +1271,6 @@ void __exit mm_cleanup(void)
 
 	unregister_blkdev(MAJOR_NR, "umem");
 
-        for (i = 0; i < (num_cards << MM_SHIFT); i++)
-		invalidate_device (mk_kdev(MAJOR_NR,i), 1);
-
 	blk_size     [MAJOR_NR] = NULL;
 
 	/*
diff --git a/drivers/block/xd.c b/drivers/block/xd.c
index bca8cd457e0e..a1166a4e1394 100644
--- a/drivers/block/xd.c
+++ b/drivers/block/xd.c
@@ -122,7 +122,7 @@ static unsigned int xd_bases[] __initdata =
 };
 
 static struct hd_struct xd_struct[XD_MAXDRIVES << 6];
-static int xd_sizes[XD_MAXDRIVES << 6], xd_access[XD_MAXDRIVES];
+static int xd_sizes[XD_MAXDRIVES << 6];
 
 static spinlock_t xd_lock = SPIN_LOCK_UNLOCKED;
 
@@ -140,12 +140,9 @@ static struct gendisk xd_gendisk = {
 static struct block_device_operations xd_fops = {
 	owner:		THIS_MODULE,
 	open:		xd_open,
-	release:	xd_release,
 	ioctl:		xd_ioctl,
 };
 static DECLARE_WAIT_QUEUE_HEAD(xd_wait_int);
-static DECLARE_WAIT_QUEUE_HEAD(xd_wait_open);
-static u_char xd_valid[XD_MAXDRIVES] = { 0,0 };
 static u_char xd_drives, xd_irq = 5, xd_dma = 3, xd_maxsectors;
 static u_char xd_override __initdata = 0, xd_type __initdata = 0;
 static u_short xd_iobase = 0x320;
@@ -244,14 +241,11 @@ static void __init xd_geninit (void)
 	/* xd_maxsectors depends on controller - so set after detection */
 	blk_queue_max_sectors(BLK_DEFAULT_QUEUE(MAJOR_NR), xd_maxsectors);
 
-	for (i = 0; i < xd_drives; i++) {
-		xd_valid[i] = 1;
+	for (i = 0; i < xd_drives; i++)
 		register_disk(&xd_gendisk, mk_kdev(MAJOR_NR,i<<6), 1<<6,
 				&xd_fops,
 				xd_info[i].heads * xd_info[i].cylinders *
 				xd_info[i].sectors);
-	}
-
 	xd_gendisk.nr_real = xd_drives;
 }
 
@@ -259,17 +253,9 @@ static void __init xd_geninit (void)
 static int xd_open (struct inode *inode,struct file *file)
 {
 	int dev = DEVICE_NR(inode->i_rdev);
-
-	if (dev < xd_drives) {
-		while (!xd_valid[dev])
-			sleep_on(&xd_wait_open);
-
-		xd_access[dev]++;
-
-		return (0);
-	}
-
-	return -ENXIO;
+	if (dev >= xd_drives)
+		return -ENXIO;
+	return 0;
 }
 
 /* do_xd_request: handle an incoming request */
@@ -329,7 +315,7 @@ static int xd_ioctl (struct inode *inode,struct file *file,u_int cmd,u_long arg)
 			g.heads = xd_info[dev].heads;
 			g.sectors = xd_info[dev].sectors;
 			g.cylinders = xd_info[dev].cylinders;
-			g.start = get_start_sect(inode->i_rdev);
+			g.start = get_start_sect(inode->i_bdev);
 			return copy_to_user(geometry, &g, sizeof g) ? -EFAULT : 0;
 		}
 		case HDIO_SET_DMA:
@@ -351,50 +337,28 @@ static int xd_ioctl (struct inode *inode,struct file *file,u_int cmd,u_long arg)
 				return -EACCES;
 			return xd_reread_partitions(inode->i_rdev);
 
-		case BLKGETSIZE:
-		case BLKGETSIZE64:
-		case BLKFLSBUF:
-		case BLKROSET:
-		case BLKROGET:
-		case BLKPG:
-			return blk_ioctl(inode->i_bdev, cmd, arg);
-
 		default:
 			return -EINVAL;
 	}
 }
 
-/* xd_release: release the device */
-static int xd_release (struct inode *inode, struct file *file)
-{
-	int target = DEVICE_NR(inode->i_rdev);
-	if (target < xd_drives)
-		xd_access[target]--;
-	return 0;
-}
-
 /* xd_reread_partitions: rereads the partition table from a drive */
 static int xd_reread_partitions(kdev_t dev)
 {
-	int target;
-	int res;
+	int target = DEVICE_NR(dev);
+	kdev_t device = mk_kdev(MAJOR_NR, target << 6);
+	int res = dev_lock_part(device);
 	
-	target = DEVICE_NR(dev);
-
-	cli();
-	xd_valid[target] = (xd_access[target] != 1);
-        sti();
-	if (xd_valid[target])
-		return -EBUSY;
+	if (res < 0)
+		return 0;
 
-	res = wipe_partitions(dev);
+	res = wipe_partitions(device);
 	if (!res)
-		grok_partitions(dev, xd_info[target].heads
+		grok_partitions(device, xd_info[target].heads
 				* xd_info[target].cylinders
 				* xd_info[target].sectors);
 
-	xd_valid[target] = 1;
-	wake_up(&xd_wait_open);
+	dev_unlock_part(device);
 
 	return res;
 }
diff --git a/drivers/block/xd.h b/drivers/block/xd.h
index 7babb59b96d0..3df2d4e98410 100644
--- a/drivers/block/xd.h
+++ b/drivers/block/xd.h
@@ -113,7 +113,6 @@ static void xd_geninit (void);
 static int xd_open (struct inode *inode,struct file *file);
 static void do_xd_request (request_queue_t * q);
 static int xd_ioctl (struct inode *inode,struct file *file,unsigned int cmd,unsigned long arg);
-static int xd_release (struct inode *inode,struct file *file);
 static int xd_reread_partitions (kdev_t dev);
 static int xd_readwrite (u_char operation,u_char drive,char *buffer,u_int block,u_int count);
 static void xd_recalibrate (u_char drive);