Merge branch 'upstream'

Conflicts:

	drivers/scsi/libata-core.c

347 files changed, 13188 insertions, 10957 deletions

diff --git a/drivers/acpi/Kconfig b/drivers/acpi/Kconfig
index 33e2ca847a..82710ae392 100644
--- a/drivers/acpi/Kconfig
+++ b/drivers/acpi/Kconfig
@@ -205,6 +205,18 @@ config ACPI_IBM
 
           If you have an IBM ThinkPad laptop, say Y or M here.
 
+config ACPI_IBM_DOCK
+        bool "Legacy Docking Station Support"
+        depends on ACPI_IBM
+        default n
+        ---help---
+          Allows the ibm_acpi driver to handle docking station events.
+          This support is obsoleted by CONFIG_HOTPLUG_PCI_ACPI.  It will
+          allow locking and removing the laptop from the docking station,
+          but will not properly connect PCI devices.
+
+          If you are not sure, say N here.
+
 config ACPI_TOSHIBA
         tristate "Toshiba Laptop Extras"
         depends on X86
diff --git a/drivers/acpi/ibm_acpi.c b/drivers/acpi/ibm_acpi.c
index 5cc090326d..262b1f4133 100644
--- a/drivers/acpi/ibm_acpi.c
+++ b/drivers/acpi/ibm_acpi.c
@@ -160,13 +160,13 @@ IBM_HANDLE(cmos, root, "\\UCMS",	/* R50, R50e, R50p, R51, T4x, X31, X40 */
            "\\CMOS",            /* A3x, G4x, R32, T23, T30, X22-24, X30 */
            "\\CMS",             /* R40, R40e */
     );                          /* all others */
-
+#ifdef CONFIG_ACPI_IBM_DOCK
 IBM_HANDLE(dock, root, "\\_SB.GDCK",    /* X30, X31, X40 */
            "\\_SB.PCI0.DOCK",   /* 600e/x,770e,770x,A2xm/p,T20-22,X20-21 */
            "\\_SB.PCI0.PCI1.DOCK",      /* all others */
            "\\_SB.PCI.ISA.SLCE",        /* 570 */
     );                          /* A21e,G4x,R30,R31,R32,R40,R40e,R50e */
-
+#endif
 IBM_HANDLE(bay, root, "\\_SB.PCI.IDE.SECN.MAST",        /* 570 */
            "\\_SB.PCI0.IDE0.IDES.IDSM", /* 600e/x, 770e, 770x */
            "\\_SB.PCI0.IDE0.SCND.MSTR", /* all others */
@@ -844,7 +844,7 @@ static int _sta(acpi_handle handle)
 
         return status;
 }
-
+#ifdef CONFIG_ACPI_IBM_DOCK
 #define dock_docked() (_sta(dock_handle) & 1)
 
 static int dock_read(char *p)
@@ -907,6 +907,7 @@ static void dock_notify(struct ibm_struct *ibm, u32 event)
                 acpi_bus_generate_event(ibm->device, event, 0); /* unknown */
         }
 }
+#endif
 
 static int bay_status_supported;
 static int bay_status2_supported;
@@ -1574,6 +1575,7 @@ static struct ibm_struct ibms[] = {
          .read = light_read,
          .write = light_write,
          },
+#ifdef CONFIG_ACPI_IBM_DOCK
         {
          .name = "dock",
          .read = dock_read,
@@ -1589,6 +1591,7 @@ static struct ibm_struct ibms[] = {
          .handle = &pci_handle,
          .type = ACPI_SYSTEM_NOTIFY,
          },
+#endif
         {
          .name = "bay",
          .init = bay_init,
@@ -1880,7 +1883,9 @@ IBM_PARAM(hotkey);
 IBM_PARAM(bluetooth);
 IBM_PARAM(video);
 IBM_PARAM(light);
+#ifdef CONFIG_ACPI_IBM_DOCK
 IBM_PARAM(dock);
+#endif
 IBM_PARAM(bay);
 IBM_PARAM(cmos);
 IBM_PARAM(led);
@@ -1927,7 +1932,9 @@ static int __init acpi_ibm_init(void)
         IBM_HANDLE_INIT(hkey);
         IBM_HANDLE_INIT(lght);
         IBM_HANDLE_INIT(cmos);
+#ifdef CONFIG_ACPI_IBM_DOCK
         IBM_HANDLE_INIT(dock);
+#endif
         IBM_HANDLE_INIT(pci);
         IBM_HANDLE_INIT(bay);
         if (bay_handle)
diff --git a/drivers/acpi/scan.c b/drivers/acpi/scan.c
index 9271e5209a..a0ab828b2c 100644
--- a/drivers/acpi/scan.c
+++ b/drivers/acpi/scan.c
@@ -23,7 +23,6 @@ static LIST_HEAD(acpi_device_list);
 DEFINE_SPINLOCK(acpi_device_lock);
 LIST_HEAD(acpi_wakeup_device_list);
 
-static int acpi_bus_trim(struct acpi_device *start, int rmdevice);
 
 static void acpi_device_release(struct kobject *kobj)
 {
@@ -1284,7 +1283,7 @@ int acpi_bus_start(struct acpi_device *device)
 
 EXPORT_SYMBOL(acpi_bus_start);
 
-static int acpi_bus_trim(struct acpi_device *start, int rmdevice)
+int acpi_bus_trim(struct acpi_device *start, int rmdevice)
 {
         acpi_status status;
         struct acpi_device *parent, *child;
@@ -1337,6 +1336,8 @@ static int acpi_bus_trim(struct acpi_device *start, int rmdevice)
         }
         return err;
 }
+EXPORT_SYMBOL_GPL(acpi_bus_trim);
+
 
 static int acpi_bus_scan_fixed(struct acpi_device *root)
 {
diff --git a/drivers/base/power/suspend.c b/drivers/base/power/suspend.c
index 8660779fb2..bdb60663f2 100644
--- a/drivers/base/power/suspend.c
+++ b/drivers/base/power/suspend.c
@@ -8,6 +8,7 @@
  *
  */
 
+#include <linux/vt_kern.h>
 #include <linux/device.h>
 #include "../base.h"
 #include "power.h"
@@ -62,7 +63,6 @@ int suspend_device(struct device * dev, pm_message_t state)
         return error;
 }
 
-
 /**
  *      device_suspend - Save state and stop all devices in system.
  *      @state:         Power state to put each device in.
@@ -82,6 +82,9 @@ int device_suspend(pm_message_t state)
 {
         int error = 0;
 
+        if (!is_console_suspend_safe())
+                return -EINVAL;
+
         down(&dpm_sem);
         down(&dpm_list_sem);
         while (!list_empty(&dpm_active) && error == 0) {
diff --git a/drivers/block/Makefile b/drivers/block/Makefile
index 3ec1f8df87..410f259a80 100644
--- a/drivers/block/Makefile
+++ b/drivers/block/Makefile
@@ -7,7 +7,6 @@
 
 obj-$(CONFIG_MAC_FLOPPY)        += swim3.o
 obj-$(CONFIG_BLK_DEV_FD)        += floppy.o
-obj-$(CONFIG_BLK_DEV_FD98)      += floppy98.o
 obj-$(CONFIG_AMIGA_FLOPPY)      += amiflop.o
 obj-$(CONFIG_ATARI_FLOPPY)      += ataflop.o
 obj-$(CONFIG_BLK_DEV_SWIM_IOP)  += swim_iop.o
diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index cf39cf9aac..1f2890989b 100644
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -38,6 +38,7 @@
 #include <linux/hdreg.h>
 #include <linux/spinlock.h>
 #include <linux/compat.h>
+#include <linux/blktrace_api.h>
 #include <asm/uaccess.h>
 #include <asm/io.h>
 
@@ -2331,6 +2332,7 @@ static inline void complete_command( ctlr_info_t *h, CommandList_struct *cmd,
 
         cmd->rq->completion_data = cmd;
         cmd->rq->errors = status;
+        blk_add_trace_rq(cmd->rq->q, cmd->rq, BLK_TA_COMPLETE);
         blk_complete_request(cmd->rq);
 }
 
@@ -3268,8 +3270,8 @@ clean2:
         unregister_blkdev(hba[i]->major, hba[i]->devname);
 clean1:
         release_io_mem(hba[i]);
-        free_hba(i);
         hba[i]->busy_initializing = 0;
+        free_hba(i);
         return(-1);
 }
 
diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index d23b54332d..fb2d0be7cd 100644
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -179,6 +179,7 @@ static int print_unex = 1;
 #include <linux/devfs_fs_kernel.h>
 #include <linux/platform_device.h>
 #include <linux/buffer_head.h>  /* for invalidate_buffers() */
+#include <linux/mutex.h>
 
 /*
  * PS/2 floppies have much slower step rates than regular floppies.
@@ -413,7 +414,7 @@ static struct floppy_write_errors write_errors[N_DRIVE];
 static struct timer_list motor_off_timer[N_DRIVE];
 static struct gendisk *disks[N_DRIVE];
 static struct block_device *opened_bdev[N_DRIVE];
-static DECLARE_MUTEX(open_lock);
+static DEFINE_MUTEX(open_lock);
 static struct floppy_raw_cmd *raw_cmd, default_raw_cmd;
 
 /*
@@ -3333,7 +3334,7 @@ static inline int set_geometry(unsigned int cmd, struct floppy_struct *g,
         if (type) {
                 if (!capable(CAP_SYS_ADMIN))
                         return -EPERM;
-                down(&open_lock);
+                mutex_lock(&open_lock);
                 LOCK_FDC(drive, 1);
                 floppy_type[type] = *g;
                 floppy_type[type].name = "user format";
@@ -3347,7 +3348,7 @@ static inline int set_geometry(unsigned int cmd, struct floppy_struct *g,
                                 continue;
                         __invalidate_device(bdev);
                 }
-                up(&open_lock);
+                mutex_unlock(&open_lock);
         } else {
                 int oldStretch;
                 LOCK_FDC(drive, 1);
@@ -3674,7 +3675,7 @@ static int floppy_release(struct inode *inode, struct file *filp)
 {
         int drive = (long)inode->i_bdev->bd_disk->private_data;
 
-        down(&open_lock);
+        mutex_lock(&open_lock);
         if (UDRS->fd_ref < 0)
                 UDRS->fd_ref = 0;
         else if (!UDRS->fd_ref--) {
@@ -3684,7 +3685,7 @@ static int floppy_release(struct inode *inode, struct file *filp)
         if (!UDRS->fd_ref)
                 opened_bdev[drive] = NULL;
         floppy_release_irq_and_dma();
-        up(&open_lock);
+        mutex_unlock(&open_lock);
         return 0;
 }
 
@@ -3702,7 +3703,7 @@ static int floppy_open(struct inode *inode, struct file *filp)
         char *tmp;
 
         filp->private_data = (void *)0;
-        down(&open_lock);
+        mutex_lock(&open_lock);
         old_dev = UDRS->fd_device;
         if (opened_bdev[drive] && opened_bdev[drive] != inode->i_bdev)
                 goto out2;
@@ -3785,7 +3786,7 @@ static int floppy_open(struct inode *inode, struct file *filp)
                 if ((filp->f_mode & 2) && !(UTESTF(FD_DISK_WRITABLE)))
                         goto out;
         }
-        up(&open_lock);
+        mutex_unlock(&open_lock);
         return 0;
 out:
         if (UDRS->fd_ref < 0)
@@ -3796,7 +3797,7 @@ out:
                 opened_bdev[drive] = NULL;
         floppy_release_irq_and_dma();
 out2:
-        up(&open_lock);
+        mutex_unlock(&open_lock);
         return res;
 }
 
diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index 0010704739..74bf0255e9 100644
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -1144,7 +1144,7 @@ static int lo_ioctl(struct inode * inode, struct file * file,
         struct loop_device *lo = inode->i_bdev->bd_disk->private_data;
         int err;
 
-        down(&lo->lo_ctl_mutex);
+        mutex_lock(&lo->lo_ctl_mutex);
         switch (cmd) {
         case LOOP_SET_FD:
                 err = loop_set_fd(lo, file, inode->i_bdev, arg);
@@ -1170,7 +1170,7 @@ static int lo_ioctl(struct inode * inode, struct file * file,
         default:
                 err = lo->ioctl ? lo->ioctl(lo, cmd, arg) : -EINVAL;
         }
-        up(&lo->lo_ctl_mutex);
+        mutex_unlock(&lo->lo_ctl_mutex);
         return err;
 }
 
@@ -1178,9 +1178,9 @@ static int lo_open(struct inode *inode, struct file *file)
 {
         struct loop_device *lo = inode->i_bdev->bd_disk->private_data;
 
-        down(&lo->lo_ctl_mutex);
+        mutex_lock(&lo->lo_ctl_mutex);
         lo->lo_refcnt++;
-        up(&lo->lo_ctl_mutex);
+        mutex_unlock(&lo->lo_ctl_mutex);
 
         return 0;
 }
@@ -1189,9 +1189,9 @@ static int lo_release(struct inode *inode, struct file *file)
 {
         struct loop_device *lo = inode->i_bdev->bd_disk->private_data;
 
-        down(&lo->lo_ctl_mutex);
+        mutex_lock(&lo->lo_ctl_mutex);
         --lo->lo_refcnt;
-        up(&lo->lo_ctl_mutex);
+        mutex_unlock(&lo->lo_ctl_mutex);
 
         return 0;
 }
@@ -1233,12 +1233,12 @@ int loop_unregister_transfer(int number)
         xfer_funcs[n] = NULL;
 
         for (lo = &loop_dev[0]; lo < &loop_dev[max_loop]; lo++) {
-                down(&lo->lo_ctl_mutex);
+                mutex_lock(&lo->lo_ctl_mutex);
 
                 if (lo->lo_encryption == xfer)
                         loop_release_xfer(lo);
 
-                up(&lo->lo_ctl_mutex);
+                mutex_unlock(&lo->lo_ctl_mutex);
         }
 
         return 0;
@@ -1285,7 +1285,7 @@ static int __init loop_init(void)
                 lo->lo_queue = blk_alloc_queue(GFP_KERNEL);
                 if (!lo->lo_queue)
                         goto out_mem4;
-                init_MUTEX(&lo->lo_ctl_mutex);
+                mutex_init(&lo->lo_ctl_mutex);
                 init_completion(&lo->lo_done);
                 init_completion(&lo->lo_bh_done);
                 lo->lo_number = i;
diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c
index 6997d8e6bf..a9bde30dad 100644
--- a/drivers/block/nbd.c
+++ b/drivers/block/nbd.c
@@ -459,9 +459,9 @@ static void do_nbd_request(request_queue_t * q)
                 req->errors = 0;
                 spin_unlock_irq(q->queue_lock);
 
-                down(&lo->tx_lock);
+                mutex_lock(&lo->tx_lock);
                 if (unlikely(!lo->sock)) {
-                        up(&lo->tx_lock);
+                        mutex_unlock(&lo->tx_lock);
                         printk(KERN_ERR "%s: Attempted send on closed socket\n",
                                lo->disk->disk_name);
                         req->errors++;
@@ -484,7 +484,7 @@ static void do_nbd_request(request_queue_t * q)
                 }
 
                 lo->active_req = NULL;
-                up(&lo->tx_lock);
+                mutex_unlock(&lo->tx_lock);
                 wake_up_all(&lo->active_wq);
 
                 spin_lock_irq(q->queue_lock);
@@ -534,9 +534,9 @@ static int nbd_ioctl(struct inode *inode, struct file *file,
  
         case NBD_CLEAR_SOCK:
                 error = 0;
-                down(&lo->tx_lock);
+                mutex_lock(&lo->tx_lock);
                 lo->sock = NULL;
-                up(&lo->tx_lock);
+                mutex_unlock(&lo->tx_lock);
                 file = lo->file;
                 lo->file = NULL;
                 nbd_clear_que(lo);
@@ -590,7 +590,7 @@ static int nbd_ioctl(struct inode *inode, struct file *file,
                  * FIXME: This code is duplicated from sys_shutdown, but
                  * there should be a more generic interface rather than
                  * calling socket ops directly here */
-                down(&lo->tx_lock);
+                mutex_lock(&lo->tx_lock);
                 if (lo->sock) {
                         printk(KERN_WARNING "%s: shutting down socket\n",
                                 lo->disk->disk_name);
@@ -598,7 +598,7 @@ static int nbd_ioctl(struct inode *inode, struct file *file,
                                 SEND_SHUTDOWN|RCV_SHUTDOWN);
                         lo->sock = NULL;
                 }
-                up(&lo->tx_lock);
+                mutex_unlock(&lo->tx_lock);
                 file = lo->file;
                 lo->file = NULL;
                 nbd_clear_que(lo);
@@ -683,7 +683,7 @@ static int __init nbd_init(void)
                 nbd_dev[i].flags = 0;
                 spin_lock_init(&nbd_dev[i].queue_lock);
                 INIT_LIST_HEAD(&nbd_dev[i].queue_head);
-                init_MUTEX(&nbd_dev[i].tx_lock);
+                mutex_init(&nbd_dev[i].tx_lock);
                 init_waitqueue_head(&nbd_dev[i].active_wq);
                 nbd_dev[i].blksize = 1024;
                 nbd_dev[i].bytesize = 0x7ffffc00ULL << 10; /* 2TB */
diff --git a/drivers/block/paride/comm.c b/drivers/block/paride/comm.c
index d842956edf..43d61359d8 100644
--- a/drivers/block/paride/comm.c
+++ b/drivers/block/paride/comm.c
@@ -60,7 +60,7 @@ static int comm_read_regr( PIA *pi, int cont, int regr )
 
         case 2:
         case 3:
-        case 4: w3(r+0x20); r1(); 
+        case 4: w3(r+0x20); (void)r1();
                 w2(0x24); h = r4(); w2(4);
                 return h;
 
@@ -82,7 +82,7 @@ static void comm_write_regr( PIA *pi, int cont, int regr, int val )
 
         case 2:
         case 3:
-        case 4: w3(r); r1(); w4(val); 
+        case 4: w3(r); (void)r1(); w4(val);
                 break;
         }
 }
@@ -126,17 +126,17 @@ static void comm_read_block( PIA *pi, char * buf, int count )
                 w2(4);
                 break;
                 
-        case 2: w3(0x68); r1(); w2(0x24);
+        case 2: w3(0x68); (void)r1(); w2(0x24);
                 for (i=0;i<count;i++) buf[i] = r4();
                 w2(4);
                 break;
 
-        case 3: w3(0x68); r1(); w2(0x24);
+        case 3: w3(0x68); (void)r1(); w2(0x24);
                 for (i=0;i<count/2;i++) ((u16 *)buf)[i] = r4w();
                 w2(4);
                 break;
 
-        case 4: w3(0x68); r1(); w2(0x24);
+        case 4: w3(0x68); (void)r1(); w2(0x24);
                 for (i=0;i<count/4;i++) ((u32 *)buf)[i] = r4l();
                 w2(4);
                 break;
@@ -160,15 +160,15 @@ static void comm_write_block( PIA *pi, char * buf, int count )
                 w2(5); w2(4);
                 break;
 
-        case 2: w3(0x48); r1();
+        case 2: w3(0x48); (void)r1();
                 for (k=0;k<count;k++) w4(buf[k^1]);
                 break;
 
-        case 3: w3(0x48); r1();
+        case 3: w3(0x48); (void)r1();
                 for (k=0;k<count/2;k++) w4w(pi_swab16(buf,k));
                 break;
 
-        case 4: w3(0x48); r1();
+        case 4: w3(0x48); (void)r1();
                 for (k=0;k<count/4;k++) w4l(pi_swab32(buf,k));
                 break;
 
diff --git a/drivers/block/paride/on26.c b/drivers/block/paride/on26.c
index 9f837d9a36..0f833caa21 100644
--- a/drivers/block/paride/on26.c
+++ b/drivers/block/paride/on26.c
@@ -66,7 +66,7 @@ static int on26_read_regr( PIA *pi, int cont, int regr )
         case 3:
         case 4: w3(1); w3(1); w2(5); w4(r); w2(4);
                 w3(0); w3(0); w2(0x24); a = r4(); w2(4);
-                w2(0x24); r4(); w2(4);
+                w2(0x24); (void)r4(); w2(4);
                 return a;
 
         }
diff --git a/drivers/block/pktcdvd.c b/drivers/block/pktcdvd.c
index 476a5b553f..1d261f985f 100644
--- a/drivers/block/pktcdvd.c
+++ b/drivers/block/pktcdvd.c
@@ -56,6 +56,7 @@
 #include <linux/seq_file.h>
 #include <linux/miscdevice.h>
 #include <linux/suspend.h>
+#include <linux/mutex.h>
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_ioctl.h>
 #include <scsi/scsi.h>
@@ -81,7 +82,7 @@
 static struct pktcdvd_device *pkt_devs[MAX_WRITERS];
 static struct proc_dir_entry *pkt_proc;
 static int pkt_major;
-static struct semaphore ctl_mutex;      /* Serialize open/close/setup/teardown */
+static struct mutex ctl_mutex;  /* Serialize open/close/setup/teardown */
 static mempool_t *psd_pool;
 
 
@@ -2018,7 +2019,7 @@ static int pkt_open(struct inode *inode, struct file *file)
 
         VPRINTK("pktcdvd: entering open\n");
 
-        down(&ctl_mutex);
+        mutex_lock(&ctl_mutex);
         pd = pkt_find_dev_from_minor(iminor(inode));
         if (!pd) {
                 ret = -ENODEV;
@@ -2044,14 +2045,14 @@ static int pkt_open(struct inode *inode, struct file *file)
                 set_blocksize(inode->i_bdev, CD_FRAMESIZE);
         }
 
-        up(&ctl_mutex);
+        mutex_unlock(&ctl_mutex);
         return 0;
 
 out_dec:
         pd->refcnt--;
 out:
         VPRINTK("pktcdvd: failed open (%d)\n", ret);
-        up(&ctl_mutex);
+        mutex_unlock(&ctl_mutex);
         return ret;
 }
 
@@ -2060,14 +2061,14 @@ static int pkt_close(struct inode *inode, struct file *file)
         struct pktcdvd_device *pd = inode->i_bdev->bd_disk->private_data;
         int ret = 0;
 
-        down(&ctl_mutex);
+        mutex_lock(&ctl_mutex);
         pd->refcnt--;
         BUG_ON(pd->refcnt < 0);
         if (pd->refcnt == 0) {
                 int flush = test_bit(PACKET_WRITABLE, &pd->flags);
                 pkt_release_dev(pd, flush);
         }
-        up(&ctl_mutex);
+        mutex_unlock(&ctl_mutex);
         return ret;
 }
 
@@ -2596,21 +2597,21 @@ static int pkt_ctl_ioctl(struct inode *inode, struct file *file, unsigned int cm
         case PKT_CTRL_CMD_SETUP:
                 if (!capable(CAP_SYS_ADMIN))
                         return -EPERM;
-                down(&ctl_mutex);
+                mutex_lock(&ctl_mutex);
                 ret = pkt_setup_dev(&ctrl_cmd);
-                up(&ctl_mutex);
+                mutex_unlock(&ctl_mutex);
                 break;
         case PKT_CTRL_CMD_TEARDOWN:
                 if (!capable(CAP_SYS_ADMIN))
                         return -EPERM;
-                down(&ctl_mutex);
+                mutex_lock(&ctl_mutex);
                 ret = pkt_remove_dev(&ctrl_cmd);
-                up(&ctl_mutex);
+                mutex_unlock(&ctl_mutex);
                 break;
         case PKT_CTRL_CMD_STATUS:
-                down(&ctl_mutex);
+                mutex_lock(&ctl_mutex);
                 pkt_get_status(&ctrl_cmd);
-                up(&ctl_mutex);
+                mutex_unlock(&ctl_mutex);
                 break;
         default:
                 return -ENOTTY;
@@ -2656,7 +2657,7 @@ static int __init pkt_init(void)
                 goto out;
         }
 
-        init_MUTEX(&ctl_mutex);
+        mutex_init(&ctl_mutex);
 
         pkt_proc = proc_mkdir("pktcdvd", proc_root_driver);
 
diff --git a/drivers/block/rd.c b/drivers/block/rd.c
index ffd6abd6d5..940bfd7951 100644
--- a/drivers/block/rd.c
+++ b/drivers/block/rd.c
@@ -186,7 +186,8 @@ static int ramdisk_writepages(struct address_space *mapping,
  */
 static int ramdisk_set_page_dirty(struct page *page)
 {
-        SetPageDirty(page);
+        if (!TestSetPageDirty(page))
+                return 1;
         return 0;
 }
 
@@ -310,12 +311,12 @@ static int rd_ioctl(struct inode *inode, struct file *file,
          * cache
          */
         error = -EBUSY;
-        down(&bdev->bd_sem);
+        mutex_lock(&bdev->bd_mutex);
         if (bdev->bd_openers <= 2) {
                 truncate_inode_pages(bdev->bd_inode->i_mapping, 0);
                 error = 0;
         }
-        up(&bdev->bd_sem);
+        mutex_unlock(&bdev->bd_mutex);
         return error;
 }
 
diff --git a/drivers/cdrom/cdrom.c b/drivers/cdrom/cdrom.c
index 879bbc26ce..a59876a0bf 100644
--- a/drivers/cdrom/cdrom.c
+++ b/drivers/cdrom/cdrom.c
@@ -407,7 +407,6 @@ int register_cdrom(struct cdrom_device_info *cdi)
         ENSURE(get_mcn, CDC_MCN);
         ENSURE(reset, CDC_RESET);
         ENSURE(audio_ioctl, CDC_PLAY_AUDIO);
-        ENSURE(dev_ioctl, CDC_IOCTLS);
         ENSURE(generic_packet, CDC_GENERIC_PACKET);
         cdi->mc_flags = 0;
         cdo->n_minors = 0;
@@ -2196,395 +2195,586 @@ retry:
         return cdrom_read_cdda_old(cdi, ubuf, lba, nframes);    
 }
 
-/* Just about every imaginable ioctl is supported in the Uniform layer
- * these days. ATAPI / SCSI specific code now mainly resides in
- * mmc_ioct().
- */
-int cdrom_ioctl(struct file * file, struct cdrom_device_info *cdi,
-                struct inode *ip, unsigned int cmd, unsigned long arg)
+static int cdrom_ioctl_multisession(struct cdrom_device_info *cdi,
+                void __user *argp)
 {
-        struct cdrom_device_ops *cdo = cdi->ops;
+        struct cdrom_multisession ms_info;
+        u8 requested_format;
         int ret;
 
-        /* Try the generic SCSI command ioctl's first.. */
-        ret = scsi_cmd_ioctl(file, ip->i_bdev->bd_disk, cmd, (void __user *)arg);
-        if (ret != -ENOTTY)
+        cdinfo(CD_DO_IOCTL, "entering CDROMMULTISESSION\n");
+
+        if (!(cdi->ops->capability & CDC_MULTI_SESSION))
+                return -ENOSYS;
+
+        if (copy_from_user(&ms_info, argp, sizeof(ms_info)))
+                return -EFAULT;
+
+        requested_format = ms_info.addr_format;
+        if (requested_format != CDROM_MSF && requested_format != CDROM_LBA)
+                return -EINVAL;
+        ms_info.addr_format = CDROM_LBA;
+
+        ret = cdi->ops->get_last_session(cdi, &ms_info);
+        if (ret)
                 return ret;
 
-        /* the first few commands do not deal with audio drive_info, but
-           only with routines in cdrom device operations. */
-        switch (cmd) {
-        case CDROMMULTISESSION: {
-                struct cdrom_multisession ms_info;
-                u_char requested_format;
-                cdinfo(CD_DO_IOCTL, "entering CDROMMULTISESSION\n"); 
-                if (!(cdo->capability & CDC_MULTI_SESSION))
-                        return -ENOSYS;
-                IOCTL_IN(arg, struct cdrom_multisession, ms_info);
-                requested_format = ms_info.addr_format;
-                if (!((requested_format == CDROM_MSF) ||
-                        (requested_format == CDROM_LBA)))
-                                return -EINVAL;
-                ms_info.addr_format = CDROM_LBA;
-                if ((ret=cdo->get_last_session(cdi, &ms_info)))
+        sanitize_format(&ms_info.addr, &ms_info.addr_format, requested_format);
+
+        if (copy_to_user(argp, &ms_info, sizeof(ms_info)))
+                return -EFAULT;
+
+        cdinfo(CD_DO_IOCTL, "CDROMMULTISESSION successful\n");
+        return 0;
+}
+
+static int cdrom_ioctl_eject(struct cdrom_device_info *cdi)
+{
+        cdinfo(CD_DO_IOCTL, "entering CDROMEJECT\n");
+
+        if (!CDROM_CAN(CDC_OPEN_TRAY))
+                return -ENOSYS;
+        if (cdi->use_count != 1 || keeplocked)
+                return -EBUSY;
+        if (CDROM_CAN(CDC_LOCK)) {
+                int ret = cdi->ops->lock_door(cdi, 0);
+                if (ret)
                         return ret;
-                sanitize_format(&ms_info.addr, &ms_info.addr_format,
-                                requested_format);
-                IOCTL_OUT(arg, struct cdrom_multisession, ms_info);
-                cdinfo(CD_DO_IOCTL, "CDROMMULTISESSION successful\n"); 
-                return 0;
-                }
+        }
 
-        case CDROMEJECT: {
-                cdinfo(CD_DO_IOCTL, "entering CDROMEJECT\n"); 
-                if (!CDROM_CAN(CDC_OPEN_TRAY))
-                        return -ENOSYS;
-                if (cdi->use_count != 1 || keeplocked)
-                        return -EBUSY;
-                if (CDROM_CAN(CDC_LOCK))
-                        if ((ret=cdo->lock_door(cdi, 0)))
-                                return ret;
+        return cdi->ops->tray_move(cdi, 1);
+}
 
-                return cdo->tray_move(cdi, 1);
-                }
+static int cdrom_ioctl_closetray(struct cdrom_device_info *cdi)
+{
+        cdinfo(CD_DO_IOCTL, "entering CDROMCLOSETRAY\n");
 
-        case CDROMCLOSETRAY: {
-                cdinfo(CD_DO_IOCTL, "entering CDROMCLOSETRAY\n"); 
-                if (!CDROM_CAN(CDC_CLOSE_TRAY))
-                        return -ENOSYS;
-                return cdo->tray_move(cdi, 0);
-                }
+        if (!CDROM_CAN(CDC_CLOSE_TRAY))
+                return -ENOSYS;
+        return cdi->ops->tray_move(cdi, 0);
+}
 
-        case CDROMEJECT_SW: {
-                cdinfo(CD_DO_IOCTL, "entering CDROMEJECT_SW\n"); 
-                if (!CDROM_CAN(CDC_OPEN_TRAY))
-                        return -ENOSYS;
-                if (keeplocked)
-                        return -EBUSY;
-                cdi->options &= ~(CDO_AUTO_CLOSE | CDO_AUTO_EJECT);
-                if (arg)
-                        cdi->options |= CDO_AUTO_CLOSE | CDO_AUTO_EJECT;
-                return 0;
-                }
+static int cdrom_ioctl_eject_sw(struct cdrom_device_info *cdi,
+                unsigned long arg)
+{
+        cdinfo(CD_DO_IOCTL, "entering CDROMEJECT_SW\n");
 
-        case CDROM_MEDIA_CHANGED: {
-                struct cdrom_changer_info *info;
-                int changed;
+        if (!CDROM_CAN(CDC_OPEN_TRAY))
+                return -ENOSYS;
+        if (keeplocked)
+                return -EBUSY;
 
-                cdinfo(CD_DO_IOCTL, "entering CDROM_MEDIA_CHANGED\n"); 
-                if (!CDROM_CAN(CDC_MEDIA_CHANGED))
-                        return -ENOSYS;
+        cdi->options &= ~(CDO_AUTO_CLOSE | CDO_AUTO_EJECT);
+        if (arg)
+                cdi->options |= CDO_AUTO_CLOSE | CDO_AUTO_EJECT;
+        return 0;
+}
 
-                /* cannot select disc or select current disc */
-                if (!CDROM_CAN(CDC_SELECT_DISC) || arg == CDSL_CURRENT)
-                        return media_changed(cdi, 1);
+static int cdrom_ioctl_media_changed(struct cdrom_device_info *cdi,
+                unsigned long arg)
+{
+        struct cdrom_changer_info *info;
+        int ret;
 
-                if ((unsigned int)arg >= cdi->capacity)
-                        return -EINVAL;
+        cdinfo(CD_DO_IOCTL, "entering CDROM_MEDIA_CHANGED\n");
 
-                info = kmalloc(sizeof(*info), GFP_KERNEL);
-                if (!info)
-                        return -ENOMEM;
+        if (!CDROM_CAN(CDC_MEDIA_CHANGED))
+                return -ENOSYS;
 
-                if ((ret = cdrom_read_mech_status(cdi, info))) {
-                        kfree(info);
-                        return ret;
-                }
+        /* cannot select disc or select current disc */
+        if (!CDROM_CAN(CDC_SELECT_DISC) || arg == CDSL_CURRENT)
+                return media_changed(cdi, 1);
 
-                changed = info->slots[arg].change;
-                kfree(info);
-                return changed;
-                }
+        if ((unsigned int)arg >= cdi->capacity)
+                return -EINVAL;
 
-        case CDROM_SET_OPTIONS: {
-                cdinfo(CD_DO_IOCTL, "entering CDROM_SET_OPTIONS\n"); 
-                /* options need to be in sync with capability. too late for
-                   that, so we have to check each one separately... */
-                switch (arg) {
-                case CDO_USE_FFLAGS:
-                case CDO_CHECK_TYPE:
-                        break;
-                case CDO_LOCK:
-                        if (!CDROM_CAN(CDC_LOCK))
-                                return -ENOSYS;
-                        break;
-                case 0:
-                        return cdi->options;
-                /* default is basically CDO_[AUTO_CLOSE|AUTO_EJECT] */
-                default:
-                        if (!CDROM_CAN(arg))
-                                return -ENOSYS;
-                }
-                cdi->options |= (int) arg;
-                return cdi->options;
-                }
+        info = kmalloc(sizeof(*info), GFP_KERNEL);
+        if (!info)
+                return -ENOMEM;
 
-        case CDROM_CLEAR_OPTIONS: {
-                cdinfo(CD_DO_IOCTL, "entering CDROM_CLEAR_OPTIONS\n"); 
-                cdi->options &= ~(int) arg;
-                return cdi->options;
-                }
+        ret = cdrom_read_mech_status(cdi, info);
+        if (!ret)
+                ret = info->slots[arg].change;
+        kfree(info);
+        return ret;
+}
 
-        case CDROM_SELECT_SPEED: {
-                cdinfo(CD_DO_IOCTL, "entering CDROM_SELECT_SPEED\n"); 
-                if (!CDROM_CAN(CDC_SELECT_SPEED))
-                        return -ENOSYS;
-                return cdo->select_speed(cdi, arg);
-                }
+static int cdrom_ioctl_set_options(struct cdrom_device_info *cdi,
+                unsigned long arg)
+{
+        cdinfo(CD_DO_IOCTL, "entering CDROM_SET_OPTIONS\n");
 
-        case CDROM_SELECT_DISC: {
-                cdinfo(CD_DO_IOCTL, "entering CDROM_SELECT_DISC\n"); 
-                if (!CDROM_CAN(CDC_SELECT_DISC))
+        /*
+         * Options need to be in sync with capability.
+         * Too late for that, so we have to check each one separately.
+         */
+        switch (arg) {
+        case CDO_USE_FFLAGS:
+        case CDO_CHECK_TYPE:
+                break;
+        case CDO_LOCK:
+                if (!CDROM_CAN(CDC_LOCK))
+                        return -ENOSYS;
+                break;
+        case 0:
+                return cdi->options;
+        /* default is basically CDO_[AUTO_CLOSE|AUTO_EJECT] */
+        default:
+                if (!CDROM_CAN(arg))
                         return -ENOSYS;
+        }
+        cdi->options |= (int) arg;
+        return cdi->options;
+}
 
-                if ((arg != CDSL_CURRENT) && (arg != CDSL_NONE))
-                        if ((int)arg >= cdi->capacity)
-                                return -EINVAL;
-
-                /* cdo->select_disc is a hook to allow a driver-specific
-                 * way of seleting disc.  However, since there is no
-                 * equiv hook for cdrom_slot_status this may not 
-                 * actually be useful...
-                 */
-                if (cdo->select_disc != NULL)
-                        return cdo->select_disc(cdi, arg);
-
-                /* no driver specific select_disc(), call our own */
-                cdinfo(CD_CHANGER, "Using generic cdrom_select_disc()\n"); 
-                return cdrom_select_disc(cdi, arg);
-                }
+static int cdrom_ioctl_clear_options(struct cdrom_device_info *cdi,
+                unsigned long arg)
+{
+        cdinfo(CD_DO_IOCTL, "entering CDROM_CLEAR_OPTIONS\n");
 
-        case CDROMRESET: {
-                if (!capable(CAP_SYS_ADMIN))
-                        return -EACCES;
-                cdinfo(CD_DO_IOCTL, "entering CDROM_RESET\n");
-                if (!CDROM_CAN(CDC_RESET))
-                        return -ENOSYS;
-                invalidate_bdev(ip->i_bdev, 0);
-                return cdo->reset(cdi);
-                }
+        cdi->options &= ~(int) arg;
+        return cdi->options;
+}
 
-        case CDROM_LOCKDOOR: {
-                cdinfo(CD_DO_IOCTL, "%socking door.\n", arg ? "L" : "Unl");
-                if (!CDROM_CAN(CDC_LOCK))
-                        return -EDRIVE_CANT_DO_THIS;
-                keeplocked = arg ? 1 : 0;
-                /* don't unlock the door on multiple opens,but allow root
-                 * to do so */
-                if ((cdi->use_count != 1) && !arg && !capable(CAP_SYS_ADMIN))
-                        return -EBUSY;
-                return cdo->lock_door(cdi, arg);
-                }
+static int cdrom_ioctl_select_speed(struct cdrom_device_info *cdi,
+                unsigned long arg)
+{
+        cdinfo(CD_DO_IOCTL, "entering CDROM_SELECT_SPEED\n");
 
-        case CDROM_DEBUG: {
-                if (!capable(CAP_SYS_ADMIN))
-                        return -EACCES;
-                cdinfo(CD_DO_IOCTL, "%sabling debug.\n", arg ? "En" : "Dis");
-                debug = arg ? 1 : 0;
-                return debug;
-                }
+        if (!CDROM_CAN(CDC_SELECT_SPEED))
+                return -ENOSYS;
+        return cdi->ops->select_speed(cdi, arg);
+}
 
-        case CDROM_GET_CAPABILITY: {
-                cdinfo(CD_DO_IOCTL, "entering CDROM_GET_CAPABILITY\n");
-                return (cdo->capability & ~cdi->mask);
-                }
+static int cdrom_ioctl_select_disc(struct cdrom_device_info *cdi,
+                unsigned long arg)
+{
+        cdinfo(CD_DO_IOCTL, "entering CDROM_SELECT_DISC\n");
+
+        if (!CDROM_CAN(CDC_SELECT_DISC))
+                return -ENOSYS;
+
+        if (arg != CDSL_CURRENT && arg != CDSL_NONE) {
+                if ((int)arg >= cdi->capacity)
+                        return -EINVAL;
+        }
+
+        /*
+         * ->select_disc is a hook to allow a driver-specific way of
+         * seleting disc.  However, since there is no equivalent hook for
+         * cdrom_slot_status this may not actually be useful...
+         */
+        if (cdi->ops->select_disc)
+                return cdi->ops->select_disc(cdi, arg);
+
+        cdinfo(CD_CHANGER, "Using generic cdrom_select_disc()\n");
+        return cdrom_select_disc(cdi, arg);
+}
+
+static int cdrom_ioctl_reset(struct cdrom_device_info *cdi,
+                struct block_device *bdev)
+{
+        cdinfo(CD_DO_IOCTL, "entering CDROM_RESET\n");
+
+        if (!capable(CAP_SYS_ADMIN))
+                return -EACCES;
+        if (!CDROM_CAN(CDC_RESET))
+                return -ENOSYS;
+        invalidate_bdev(bdev, 0);
+        return cdi->ops->reset(cdi);
+}
+
+static int cdrom_ioctl_lock_door(struct cdrom_device_info *cdi,
+                unsigned long arg)
+{
+        cdinfo(CD_DO_IOCTL, "%socking door.\n", arg ? "L" : "Unl");
+
+        if (!CDROM_CAN(CDC_LOCK))
+                return -EDRIVE_CANT_DO_THIS;
+
+        keeplocked = arg ? 1 : 0;
+
+        /*
+         * Don't unlock the door on multiple opens by default, but allow
+         * root to do so.
+         */
+        if (cdi->use_count != 1 && !arg && !capable(CAP_SYS_ADMIN))
+                return -EBUSY;
+        return cdi->ops->lock_door(cdi, arg);
+}
+
+static int cdrom_ioctl_debug(struct cdrom_device_info *cdi,
+                unsigned long arg)
+{
+        cdinfo(CD_DO_IOCTL, "%sabling debug.\n", arg ? "En" : "Dis");
+
+        if (!capable(CAP_SYS_ADMIN))
+                return -EACCES;
+        debug = arg ? 1 : 0;
+        return debug;
+}
 
-/* The following function is implemented, although very few audio
+static int cdrom_ioctl_get_capability(struct cdrom_device_info *cdi)
+{
+        cdinfo(CD_DO_IOCTL, "entering CDROM_GET_CAPABILITY\n");
+        return (cdi->ops->capability & ~cdi->mask);
+}
+
+/*
+ * The following function is implemented, although very few audio
  * discs give Universal Product Code information, which should just be
  * the Medium Catalog Number on the box.  Note, that the way the code
  * is written on the CD is /not/ uniform across all discs!
  */
-        case CDROM_GET_MCN: {
-                struct cdrom_mcn mcn;
-                cdinfo(CD_DO_IOCTL, "entering CDROM_GET_MCN\n"); 
-                if (!(cdo->capability & CDC_MCN))
-                        return -ENOSYS;
-                if ((ret=cdo->get_mcn(cdi, &mcn)))
-                        return ret;
-                IOCTL_OUT(arg, struct cdrom_mcn, mcn);
-                cdinfo(CD_DO_IOCTL, "CDROM_GET_MCN successful\n"); 
-                return 0;
-                }
+static int cdrom_ioctl_get_mcn(struct cdrom_device_info *cdi,
+                void __user *argp)
+{
+        struct cdrom_mcn mcn;
+        int ret;
 
-        case CDROM_DRIVE_STATUS: {
-                cdinfo(CD_DO_IOCTL, "entering CDROM_DRIVE_STATUS\n"); 
-                if (!(cdo->capability & CDC_DRIVE_STATUS))
-                        return -ENOSYS;
-                if (!CDROM_CAN(CDC_SELECT_DISC))
-                        return cdo->drive_status(cdi, CDSL_CURRENT);
-                if ((arg == CDSL_CURRENT) || (arg == CDSL_NONE)) 
-                        return cdo->drive_status(cdi, CDSL_CURRENT);
-                if (((int)arg >= cdi->capacity))
-                        return -EINVAL;
-                return cdrom_slot_status(cdi, arg);
-                }
+        cdinfo(CD_DO_IOCTL, "entering CDROM_GET_MCN\n");
 
-        /* Ok, this is where problems start.  The current interface for the
-           CDROM_DISC_STATUS ioctl is flawed.  It makes the false assumption
-           that CDs are all CDS_DATA_1 or all CDS_AUDIO, etc.  Unfortunatly,
-           while this is often the case, it is also very common for CDs to
-           have some tracks with data, and some tracks with audio.  Just 
-           because I feel like it, I declare the following to be the best
-           way to cope.  If the CD has ANY data tracks on it, it will be
-           returned as a data CD.  If it has any XA tracks, I will return
-           it as that.  Now I could simplify this interface by combining these 
-           returns with the above, but this more clearly demonstrates
-           the problem with the current interface.  Too bad this wasn't 
-           designed to use bitmasks...         -Erik 
-
-           Well, now we have the option CDS_MIXED: a mixed-type CD. 
-           User level programmers might feel the ioctl is not very useful.
-                                                ---david
-        */
-        case CDROM_DISC_STATUS: {
-                tracktype tracks;
-                cdinfo(CD_DO_IOCTL, "entering CDROM_DISC_STATUS\n"); 
-                cdrom_count_tracks(cdi, &tracks);
-                if (tracks.error) 
-                        return(tracks.error);
-
-                /* Policy mode on */
-                if (tracks.audio > 0) {
-                        if (tracks.data==0 && tracks.cdi==0 && tracks.xa==0) 
-                                return CDS_AUDIO;
-                        else
-                                return CDS_MIXED;
-                }
-                if (tracks.cdi > 0) return CDS_XA_2_2;
-                if (tracks.xa > 0) return CDS_XA_2_1;
-                if (tracks.data > 0) return CDS_DATA_1;
-                /* Policy mode off */
+        if (!(cdi->ops->capability & CDC_MCN))
+                return -ENOSYS;
+        ret = cdi->ops->get_mcn(cdi, &mcn);
+        if (ret)
+                return ret;
 
-                cdinfo(CD_WARNING,"This disc doesn't have any tracks I recognize!\n");
-                return CDS_NO_INFO;
-                }
+        if (copy_to_user(argp, &mcn, sizeof(mcn)))
+                return -EFAULT;
+        cdinfo(CD_DO_IOCTL, "CDROM_GET_MCN successful\n");
+        return 0;
+}
 
-        case CDROM_CHANGER_NSLOTS: {
-                cdinfo(CD_DO_IOCTL, "entering CDROM_CHANGER_NSLOTS\n"); 
-                return cdi->capacity;
-                }
+static int cdrom_ioctl_drive_status(struct cdrom_device_info *cdi,
+                unsigned long arg)
+{
+        cdinfo(CD_DO_IOCTL, "entering CDROM_DRIVE_STATUS\n");
+
+        if (!(cdi->ops->capability & CDC_DRIVE_STATUS))
+                return -ENOSYS;
+        if (!CDROM_CAN(CDC_SELECT_DISC) ||
+            (arg == CDSL_CURRENT || arg == CDSL_NONE))
+                return cdi->ops->drive_status(cdi, CDSL_CURRENT);
+        if (((int)arg >= cdi->capacity))
+                return -EINVAL;
+        return cdrom_slot_status(cdi, arg);
+}
+
+/*
+ * Ok, this is where problems start.  The current interface for the
+ * CDROM_DISC_STATUS ioctl is flawed.  It makes the false assumption that
+ * CDs are all CDS_DATA_1 or all CDS_AUDIO, etc.  Unfortunatly, while this
+ * is often the case, it is also very common for CDs to have some tracks
+ * with data, and some tracks with audio.  Just because I feel like it,
+ * I declare the following to be the best way to cope.  If the CD has ANY
+ * data tracks on it, it will be returned as a data CD.  If it has any XA
+ * tracks, I will return it as that.  Now I could simplify this interface
+ * by combining these  returns with the above, but this more clearly
+ * demonstrates the problem with the current interface.  Too bad this
+ * wasn't designed to use bitmasks...         -Erik
+ *
+ * Well, now we have the option CDS_MIXED: a mixed-type CD.
+ * User level programmers might feel the ioctl is not very useful.
+ *                                      ---david
+ */
+static int cdrom_ioctl_disc_status(struct cdrom_device_info *cdi)
+{
+        tracktype tracks;
+
+        cdinfo(CD_DO_IOCTL, "entering CDROM_DISC_STATUS\n");
+
+        cdrom_count_tracks(cdi, &tracks);
+        if (tracks.error)
+                return tracks.error;
+
+        /* Policy mode on */
+        if (tracks.audio > 0) {
+                if (!tracks.data && !tracks.cdi && !tracks.xa)
+                        return CDS_AUDIO;
+                else
+                        return CDS_MIXED;
         }
 
-        /* use the ioctls that are implemented through the generic_packet()
-           interface. this may look at bit funny, but if -ENOTTY is
-           returned that particular ioctl is not implemented and we
-           let it go through the device specific ones. */
+        if (tracks.cdi > 0)
+                return CDS_XA_2_2;
+        if (tracks.xa > 0)
+                return CDS_XA_2_1;
+        if (tracks.data > 0)
+                return CDS_DATA_1;
+        /* Policy mode off */
+
+        cdinfo(CD_WARNING,"This disc doesn't have any tracks I recognize!\n");
+        return CDS_NO_INFO;
+}
+
+static int cdrom_ioctl_changer_nslots(struct cdrom_device_info *cdi)
+{
+        cdinfo(CD_DO_IOCTL, "entering CDROM_CHANGER_NSLOTS\n");
+        return cdi->capacity;
+}
+
+static int cdrom_ioctl_get_subchnl(struct cdrom_device_info *cdi,
+                void __user *argp)
+{
+        struct cdrom_subchnl q;
+        u8 requested, back;
+        int ret;
+
+        /* cdinfo(CD_DO_IOCTL,"entering CDROMSUBCHNL\n");*/
+
+        if (!CDROM_CAN(CDC_PLAY_AUDIO))
+                return -ENOSYS;
+        if (copy_from_user(&q, argp, sizeof(q)))
+                return -EFAULT;
+
+        requested = q.cdsc_format;
+        if (requested != CDROM_MSF && requested != CDROM_LBA)
+                return -EINVAL;
+        q.cdsc_format = CDROM_MSF;
+
+        ret = cdi->ops->audio_ioctl(cdi, CDROMSUBCHNL, &q);
+        if (ret)
+                return ret;
+
+        back = q.cdsc_format; /* local copy */
+        sanitize_format(&q.cdsc_absaddr, &back, requested);
+        sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
+
+        if (copy_to_user(argp, &q, sizeof(q)))
+                return -EFAULT;
+        /* cdinfo(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */
+        return 0;
+}
+
+static int cdrom_ioctl_read_tochdr(struct cdrom_device_info *cdi,
+                void __user *argp)
+{
+        struct cdrom_tochdr header;
+        int ret;
+
+        /* cdinfo(CD_DO_IOCTL, "entering CDROMREADTOCHDR\n"); */
+
+        if (!CDROM_CAN(CDC_PLAY_AUDIO))
+                return -ENOSYS;
+        if (copy_from_user(&header, argp, sizeof(header)))
+                return -EFAULT;
+
+        ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCHDR, &header);
+        if (ret)
+                return ret;
+
+        if (copy_to_user(argp, &header, sizeof(header)))
+                return -EFAULT;
+        /* cdinfo(CD_DO_IOCTL, "CDROMREADTOCHDR successful\n"); */
+        return 0;
+}
+
+static int cdrom_ioctl_read_tocentry(struct cdrom_device_info *cdi,
+                void __user *argp)
+{
+        struct cdrom_tocentry entry;
+        u8 requested_format;
+        int ret;
+
+        /* cdinfo(CD_DO_IOCTL, "entering CDROMREADTOCENTRY\n"); */
+
+        if (!CDROM_CAN(CDC_PLAY_AUDIO))
+                return -ENOSYS;
+        if (copy_from_user(&entry, argp, sizeof(entry)))
+                return -EFAULT;
+
+        requested_format = entry.cdte_format;
+        if (requested_format != CDROM_MSF && requested_format != CDROM_LBA)
+                return -EINVAL;
+        /* make interface to low-level uniform */
+        entry.cdte_format = CDROM_MSF;
+        ret = cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &entry);
+        if (ret)
+                return ret;
+        sanitize_format(&entry.cdte_addr, &entry.cdte_format, requested_format);
+
+        if (copy_to_user(argp, &entry, sizeof(entry)))
+                return -EFAULT;
+        /* cdinfo(CD_DO_IOCTL, "CDROMREADTOCENTRY successful\n"); */
+        return 0;
+}
+
+static int cdrom_ioctl_play_msf(struct cdrom_device_info *cdi,
+                void __user *argp)
+{
+        struct cdrom_msf msf;
+
+        cdinfo(CD_DO_IOCTL, "entering CDROMPLAYMSF\n");
+
+        if (!CDROM_CAN(CDC_PLAY_AUDIO))
+                return -ENOSYS;
+        if (copy_from_user(&msf, argp, sizeof(msf)))
+                return -EFAULT;
+        return cdi->ops->audio_ioctl(cdi, CDROMPLAYMSF, &msf);
+}
+
+static int cdrom_ioctl_play_trkind(struct cdrom_device_info *cdi,
+                void __user *argp)
+{
+        struct cdrom_ti ti;
+        int ret;
+
+        cdinfo(CD_DO_IOCTL, "entering CDROMPLAYTRKIND\n");
+
+        if (!CDROM_CAN(CDC_PLAY_AUDIO))
+                return -ENOSYS;
+        if (copy_from_user(&ti, argp, sizeof(ti)))
+                return -EFAULT;
+
+        ret = check_for_audio_disc(cdi, cdi->ops);
+        if (ret)
+                return ret;
+        return cdi->ops->audio_ioctl(cdi, CDROMPLAYTRKIND, &ti);
+}
+static int cdrom_ioctl_volctrl(struct cdrom_device_info *cdi,
+                void __user *argp)
+{
+        struct cdrom_volctrl volume;
+
+        cdinfo(CD_DO_IOCTL, "entering CDROMVOLCTRL\n");
+
+        if (!CDROM_CAN(CDC_PLAY_AUDIO))
+                return -ENOSYS;
+        if (copy_from_user(&volume, argp, sizeof(volume)))
+                return -EFAULT;
+        return cdi->ops->audio_ioctl(cdi, CDROMVOLCTRL, &volume);
+}
+
+static int cdrom_ioctl_volread(struct cdrom_device_info *cdi,
+                void __user *argp)
+{
+        struct cdrom_volctrl volume;
+        int ret;
+
+        cdinfo(CD_DO_IOCTL, "entering CDROMVOLREAD\n");
+
+        if (!CDROM_CAN(CDC_PLAY_AUDIO))
+                return -ENOSYS;
+
+        ret = cdi->ops->audio_ioctl(cdi, CDROMVOLREAD, &volume);
+        if (ret)
+                return ret;
+
+        if (copy_to_user(argp, &volume, sizeof(volume)))
+                return -EFAULT;
+        return 0;
+}
+
+static int cdrom_ioctl_audioctl(struct cdrom_device_info *cdi,
+                unsigned int cmd)
+{
+        int ret;
+
+        cdinfo(CD_DO_IOCTL, "doing audio ioctl (start/stop/pause/resume)\n");
+
+        if (!CDROM_CAN(CDC_PLAY_AUDIO))
+                return -ENOSYS;
+        ret = check_for_audio_disc(cdi, cdi->ops);
+        if (ret)
+                return ret;
+        return cdi->ops->audio_ioctl(cdi, cmd, NULL);
+}
+
+/*
+ * Just about every imaginable ioctl is supported in the Uniform layer
+ * these days.
+ * ATAPI / SCSI specific code now mainly resides in mmc_ioctl().
+ */
+int cdrom_ioctl(struct file * file, struct cdrom_device_info *cdi,
+                struct inode *ip, unsigned int cmd, unsigned long arg)
+{
+        void __user *argp = (void __user *)arg;
+        int ret;
+
+        /*
+         * Try the generic SCSI command ioctl's first.
+         */
+        ret = scsi_cmd_ioctl(file, ip->i_bdev->bd_disk, cmd, argp);
+        if (ret != -ENOTTY)
+                return ret;
+
+        switch (cmd) {
+        case CDROMMULTISESSION:
+                return cdrom_ioctl_multisession(cdi, argp);
+        case CDROMEJECT:
+                return cdrom_ioctl_eject(cdi);
+        case CDROMCLOSETRAY:
+                return cdrom_ioctl_closetray(cdi);
+        case CDROMEJECT_SW:
+                return cdrom_ioctl_eject_sw(cdi, arg);
+        case CDROM_MEDIA_CHANGED:
+                return cdrom_ioctl_media_changed(cdi, arg);
+        case CDROM_SET_OPTIONS:
+                return cdrom_ioctl_set_options(cdi, arg);
+        case CDROM_CLEAR_OPTIONS:
+                return cdrom_ioctl_clear_options(cdi, arg);
+        case CDROM_SELECT_SPEED:
+                return cdrom_ioctl_select_speed(cdi, arg);
+        case CDROM_SELECT_DISC:
+                return cdrom_ioctl_select_disc(cdi, arg);
+        case CDROMRESET:
+                return cdrom_ioctl_reset(cdi, ip->i_bdev);
+        case CDROM_LOCKDOOR:
+                return cdrom_ioctl_lock_door(cdi, arg);
+        case CDROM_DEBUG:
+                return cdrom_ioctl_debug(cdi, arg);
+        case CDROM_GET_CAPABILITY:
+                return cdrom_ioctl_get_capability(cdi);
+        case CDROM_GET_MCN:
+                return cdrom_ioctl_get_mcn(cdi, argp);
+        case CDROM_DRIVE_STATUS:
+                return cdrom_ioctl_drive_status(cdi, arg);
+        case CDROM_DISC_STATUS:
+                return cdrom_ioctl_disc_status(cdi);
+        case CDROM_CHANGER_NSLOTS:
+                return cdrom_ioctl_changer_nslots(cdi);
+        }
+
+        /*
+         * Use the ioctls that are implemented through the generic_packet()
+         * interface. this may look at bit funny, but if -ENOTTY is
+         * returned that particular ioctl is not implemented and we
+         * let it go through the device specific ones.
+         */
         if (CDROM_CAN(CDC_GENERIC_PACKET)) {
                 ret = mmc_ioctl(cdi, cmd, arg);
-                if (ret != -ENOTTY) {
+                if (ret != -ENOTTY)
                         return ret;
-                }
         }
 
-        /* note: most of the cdinfo() calls are commented out here,
-           because they fill up the sys log when CD players poll
-           the drive. */
+        /*
+         * Note: most of the cdinfo() calls are commented out here,
+         * because they fill up the sys log when CD players poll
+         * the drive.
+         */
         switch (cmd) {
-        case CDROMSUBCHNL: {
-                struct cdrom_subchnl q;
-                u_char requested, back;
-                if (!CDROM_CAN(CDC_PLAY_AUDIO))
-                        return -ENOSYS;
-                /* cdinfo(CD_DO_IOCTL,"entering CDROMSUBCHNL\n");*/ 
-                IOCTL_IN(arg, struct cdrom_subchnl, q);
-                requested = q.cdsc_format;
-                if (!((requested == CDROM_MSF) ||
-                      (requested == CDROM_LBA)))
-                        return -EINVAL;
-                q.cdsc_format = CDROM_MSF;
-                if ((ret=cdo->audio_ioctl(cdi, cmd, &q)))
-                        return ret;
-                back = q.cdsc_format; /* local copy */
-                sanitize_format(&q.cdsc_absaddr, &back, requested);
-                sanitize_format(&q.cdsc_reladdr, &q.cdsc_format, requested);
-                IOCTL_OUT(arg, struct cdrom_subchnl, q);
-                /* cdinfo(CD_DO_IOCTL, "CDROMSUBCHNL successful\n"); */ 
-                return 0;
-                }
-        case CDROMREADTOCHDR: {
-                struct cdrom_tochdr header;
-                if (!CDROM_CAN(CDC_PLAY_AUDIO))
-                        return -ENOSYS;
-                /* cdinfo(CD_DO_IOCTL, "entering CDROMREADTOCHDR\n"); */ 
-                IOCTL_IN(arg, struct cdrom_tochdr, header);
-                if ((ret=cdo->audio_ioctl(cdi, cmd, &header)))
-                        return ret;
-                IOCTL_OUT(arg, struct cdrom_tochdr, header);
-                /* cdinfo(CD_DO_IOCTL, "CDROMREADTOCHDR successful\n"); */ 
-                return 0;
-                }
-        case CDROMREADTOCENTRY: {
-                struct cdrom_tocentry entry;
-                u_char requested_format;
-                if (!CDROM_CAN(CDC_PLAY_AUDIO))
-                        return -ENOSYS;
-                /* cdinfo(CD_DO_IOCTL, "entering CDROMREADTOCENTRY\n"); */ 
-                IOCTL_IN(arg, struct cdrom_tocentry, entry);
-                requested_format = entry.cdte_format;
-                if (!((requested_format == CDROM_MSF) || 
-                        (requested_format == CDROM_LBA)))
-                                return -EINVAL;
-                /* make interface to low-level uniform */
-                entry.cdte_format = CDROM_MSF;
-                if ((ret=cdo->audio_ioctl(cdi, cmd, &entry)))
-                        return ret;
-                sanitize_format(&entry.cdte_addr,
-                &entry.cdte_format, requested_format);
-                IOCTL_OUT(arg, struct cdrom_tocentry, entry);
-                /* cdinfo(CD_DO_IOCTL, "CDROMREADTOCENTRY successful\n"); */ 
-                return 0;
-                }
-        case CDROMPLAYMSF: {
-                struct cdrom_msf msf;
-                if (!CDROM_CAN(CDC_PLAY_AUDIO))
-                        return -ENOSYS;
-                cdinfo(CD_DO_IOCTL, "entering CDROMPLAYMSF\n"); 
-                IOCTL_IN(arg, struct cdrom_msf, msf);
-                return cdo->audio_ioctl(cdi, cmd, &msf);
-                }
-        case CDROMPLAYTRKIND: {
-                struct cdrom_ti ti;
-                if (!CDROM_CAN(CDC_PLAY_AUDIO))
-                        return -ENOSYS;
-                cdinfo(CD_DO_IOCTL, "entering CDROMPLAYTRKIND\n"); 
-                IOCTL_IN(arg, struct cdrom_ti, ti);
-                CHECKAUDIO;
-                return cdo->audio_ioctl(cdi, cmd, &ti);
-                }
-        case CDROMVOLCTRL: {
-                struct cdrom_volctrl volume;
-                if (!CDROM_CAN(CDC_PLAY_AUDIO))
-                        return -ENOSYS;
-                cdinfo(CD_DO_IOCTL, "entering CDROMVOLCTRL\n"); 
-                IOCTL_IN(arg, struct cdrom_volctrl, volume);
-                return cdo->audio_ioctl(cdi, cmd, &volume);
-                }
-        case CDROMVOLREAD: {
-                struct cdrom_volctrl volume;
-                if (!CDROM_CAN(CDC_PLAY_AUDIO))
-                        return -ENOSYS;
-                cdinfo(CD_DO_IOCTL, "entering CDROMVOLREAD\n"); 
-                if ((ret=cdo->audio_ioctl(cdi, cmd, &volume)))
-                        return ret;
-                IOCTL_OUT(arg, struct cdrom_volctrl, volume);
-                return 0;
-                }
+        case CDROMSUBCHNL:
+                return cdrom_ioctl_get_subchnl(cdi, argp);
+        case CDROMREADTOCHDR:
+                return cdrom_ioctl_read_tochdr(cdi, argp);
+        case CDROMREADTOCENTRY:
+                return cdrom_ioctl_read_tocentry(cdi, argp);
+        case CDROMPLAYMSF:
+                return cdrom_ioctl_play_msf(cdi, argp);
+        case CDROMPLAYTRKIND:
+                return cdrom_ioctl_play_trkind(cdi, argp);
+        case CDROMVOLCTRL:
+                return cdrom_ioctl_volctrl(cdi, argp);
+        case CDROMVOLREAD:
+                return cdrom_ioctl_volread(cdi, argp);
         case CDROMSTART:
         case CDROMSTOP:
         case CDROMPAUSE:
-        case CDROMRESUME: {
-                if (!CDROM_CAN(CDC_PLAY_AUDIO))
-                        return -ENOSYS;
-                cdinfo(CD_DO_IOCTL, "doing audio ioctl (start/stop/pause/resume)\n"); 
-                CHECKAUDIO;
-                return cdo->audio_ioctl(cdi, cmd, NULL);
-                }
-        } /* switch */
+        case CDROMRESUME:
+                return cdrom_ioctl_audioctl(cdi, cmd);
+        }
 
-        /* do the device specific ioctls */
-        if (CDROM_CAN(CDC_IOCTLS))
-                return cdo->dev_ioctl(cdi, cmd, arg);
-        
         return -ENOSYS;
 }
 
diff --git a/drivers/cdrom/cdu31a.c b/drivers/cdrom/cdu31a.c
index 378e88d207..72ffd64e8b 100644
--- a/drivers/cdrom/cdu31a.c
+++ b/drivers/cdrom/cdu31a.c
@@ -2668,7 +2668,7 @@ static int scd_audio_ioctl(struct cdrom_device_info *cdi,
         return retval;
 }
 
-static int scd_dev_ioctl(struct cdrom_device_info *cdi,
+static int scd_read_audio(struct cdrom_device_info *cdi,
                          unsigned int cmd, unsigned long arg)
 {
         void __user *argp = (void __user *)arg;
@@ -2894,11 +2894,10 @@ static struct cdrom_device_ops scd_dops = {
         .get_mcn                = scd_get_mcn,
         .reset                  = scd_reset,
         .audio_ioctl            = scd_audio_ioctl,
-        .dev_ioctl              = scd_dev_ioctl,
         .capability             = CDC_OPEN_TRAY | CDC_CLOSE_TRAY | CDC_LOCK |
                                   CDC_SELECT_SPEED | CDC_MULTI_SESSION |
                                   CDC_MCN | CDC_MEDIA_CHANGED | CDC_PLAY_AUDIO |
-                                  CDC_RESET | CDC_IOCTLS | CDC_DRIVE_STATUS,
+                                  CDC_RESET | CDC_DRIVE_STATUS,
         .n_minors               = 1,
 };
 
@@ -2936,6 +2935,9 @@ static int scd_block_ioctl(struct inode *inode, struct file *file,
                 case CDROMCLOSETRAY:
                         retval = scd_tray_move(&scd_info, 0);
                         break;
+                case CDROMREADAUDIO:
+                        retval = scd_read_audio(&scd_info, CDROMREADAUDIO, arg);
+                        break;
                 default:
                         retval = cdrom_ioctl(file, &scd_info, inode, cmd, arg);
         }
diff --git a/drivers/cdrom/cm206.c b/drivers/cdrom/cm206.c
index ce127f7ec0..fad27a87ce 100644
--- a/drivers/cdrom/cm206.c
+++ b/drivers/cdrom/cm206.c
@@ -1157,32 +1157,6 @@ static int cm206_audio_ioctl(struct cdrom_device_info *cdi, unsigned int cmd,
         }
 }
 
-/* Ioctl. These ioctls are specific to the cm206 driver. I have made
-   some driver statistics accessible through ioctl calls.
- */
-
-static int cm206_ioctl(struct cdrom_device_info *cdi, unsigned int cmd,
-                       unsigned long arg)
-{
-        switch (cmd) {
-#ifdef STATISTICS
-        case CM206CTL_GET_STAT:
-                if (arg >= NR_STATS)
-                        return -EINVAL;
-                else
-                        return cd->stats[arg];
-        case CM206CTL_GET_LAST_STAT:
-                if (arg >= NR_STATS)
-                        return -EINVAL;
-                else
-                        return cd->last_stat[arg];
-#endif
-        default:
-                debug(("Unknown ioctl call 0x%x\n", cmd));
-                return -EINVAL;
-        }
-}
-
 static int cm206_media_changed(struct cdrom_device_info *cdi, int disc_nr)
 {
         if (cd != NULL) {
@@ -1321,11 +1295,10 @@ static struct cdrom_device_ops cm206_dops = {
         .get_mcn                = cm206_get_upc,
         .reset                  = cm206_reset,
         .audio_ioctl            = cm206_audio_ioctl,
-        .dev_ioctl              = cm206_ioctl,
         .capability             = CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK |
                                   CDC_MULTI_SESSION | CDC_MEDIA_CHANGED |
                                   CDC_MCN | CDC_PLAY_AUDIO | CDC_SELECT_SPEED |
-                                  CDC_IOCTLS | CDC_DRIVE_STATUS,
+                                  CDC_DRIVE_STATUS,
         .n_minors               = 1,
 };
 
@@ -1350,6 +1323,21 @@ static int cm206_block_release(struct inode *inode, struct file *file)
 static int cm206_block_ioctl(struct inode *inode, struct file *file,
                                 unsigned cmd, unsigned long arg)
 {
+        switch (cmd) {
+#ifdef STATISTICS
+        case CM206CTL_GET_STAT:
+                if (arg >= NR_STATS)
+                        return -EINVAL;
+                return cd->stats[arg];
+        case CM206CTL_GET_LAST_STAT:
+                if (arg >= NR_STATS)
+                        return -EINVAL;
+                return cd->last_stat[arg];
+#endif
+        default:
+                break;
+        }
+
         return cdrom_ioctl(file, &cm206_info, inode, cmd, arg);
 }
 
diff --git a/drivers/cdrom/sbpcd.c b/drivers/cdrom/sbpcd.c
index 466e9c2974..4760f515f5 100644
--- a/drivers/cdrom/sbpcd.c
+++ b/drivers/cdrom/sbpcd.c
@@ -4160,332 +4160,6 @@ static int sbpcd_get_last_session(struct cdrom_device_info *cdi, struct cdrom_mu
         return  0;
 }
 
-/*==========================================================================*/
-/*==========================================================================*/
-/*
- * ioctl support
- */
-static int sbpcd_dev_ioctl(struct cdrom_device_info *cdi, u_int cmd,
-                      u_long arg)
-{
-        struct sbpcd_drive *p = cdi->handle;
-        int i;
-        
-        msg(DBG_IO2,"ioctl(%s, 0x%08lX, 0x%08lX)\n", cdi->name, cmd, arg);
-        if (p->drv_id==-1) {
-                msg(DBG_INF, "ioctl: bad device: %s\n", cdi->name);
-                return (-ENXIO);             /* no such drive */
-        }
-        down(&ioctl_read_sem);
-        if (p != current_drive)
-                switch_drive(p);
-        
-        msg(DBG_IO2,"ioctl: device %s, request %04X\n",cdi->name,cmd);
-        switch (cmd)            /* Sun-compatible */
-        {
-        case DDIOCSDBG:         /* DDI Debug */
-                if (!capable(CAP_SYS_ADMIN)) RETURN_UP(-EPERM);
-                i=sbpcd_dbg_ioctl(arg,1);
-                RETURN_UP(i);
-        case CDROMRESET:      /* hard reset the drive */
-                msg(DBG_IOC,"ioctl: CDROMRESET entered.\n");
-                i=DriveReset();
-                current_drive->audio_state=0;
-                RETURN_UP(i);
-                
-        case CDROMREADMODE1:
-                msg(DBG_IOC,"ioctl: CDROMREADMODE1 requested.\n");
-#ifdef SAFE_MIXED
-                if (current_drive->has_data>1) RETURN_UP(-EBUSY);
-#endif /* SAFE_MIXED */
-                cc_ModeSelect(CD_FRAMESIZE);
-                cc_ModeSense();
-                current_drive->mode=READ_M1;
-                RETURN_UP(0);
-                
-        case CDROMREADMODE2: /* not usable at the moment */
-                msg(DBG_IOC,"ioctl: CDROMREADMODE2 requested.\n");
-#ifdef SAFE_MIXED
-                if (current_drive->has_data>1) RETURN_UP(-EBUSY);
-#endif /* SAFE_MIXED */
-                cc_ModeSelect(CD_FRAMESIZE_RAW1);
-                cc_ModeSense();
-                current_drive->mode=READ_M2;
-                RETURN_UP(0);
-                
-        case CDROMAUDIOBUFSIZ: /* configure the audio buffer size */
-                msg(DBG_IOC,"ioctl: CDROMAUDIOBUFSIZ entered.\n");
-                if (current_drive->sbp_audsiz>0)
-                        vfree(current_drive->aud_buf);
-                current_drive->aud_buf=NULL;
-                current_drive->sbp_audsiz=arg;
-                
-                if (current_drive->sbp_audsiz>16)
-                {
-                        current_drive->sbp_audsiz = 0;
-                        RETURN_UP(current_drive->sbp_audsiz);
-                }
-        
-                if (current_drive->sbp_audsiz>0)
-                {
-                        current_drive->aud_buf=(u_char *) vmalloc(current_drive->sbp_audsiz*CD_FRAMESIZE_RAW);
-                        if (current_drive->aud_buf==NULL)
-                        {
-                                msg(DBG_INF,"audio buffer (%d frames) not available.\n",current_drive->sbp_audsiz);
-                                current_drive->sbp_audsiz=0;
-                        }
-                        else msg(DBG_INF,"audio buffer size: %d frames.\n",current_drive->sbp_audsiz);
-                }
-                RETURN_UP(current_drive->sbp_audsiz);
-
-        case CDROMREADAUDIO:
-        { /* start of CDROMREADAUDIO */
-                int i=0, j=0, frame, block=0;
-                u_int try=0;
-                u_long timeout;
-                u_char *p;
-                u_int data_tries = 0;
-                u_int data_waits = 0;
-                u_int data_retrying = 0;
-                int status_tries;
-                int error_flag;
-                
-                msg(DBG_IOC,"ioctl: CDROMREADAUDIO entered.\n");
-                if (fam0_drive) RETURN_UP(-EINVAL);
-                if (famL_drive) RETURN_UP(-EINVAL);
-                if (famV_drive) RETURN_UP(-EINVAL);
-                if (famT_drive) RETURN_UP(-EINVAL);
-#ifdef SAFE_MIXED
-                if (current_drive->has_data>1) RETURN_UP(-EBUSY);
-#endif /* SAFE_MIXED */ 
-                if (current_drive->aud_buf==NULL) RETURN_UP(-EINVAL);
-                if (copy_from_user(&read_audio, (void __user *)arg,
-                                   sizeof(struct cdrom_read_audio)))
-                        RETURN_UP(-EFAULT);
-                if (read_audio.nframes < 0 || read_audio.nframes>current_drive->sbp_audsiz) RETURN_UP(-EINVAL);
-                if (!access_ok(VERIFY_WRITE, read_audio.buf,
-                              read_audio.nframes*CD_FRAMESIZE_RAW))
-                        RETURN_UP(-EFAULT);
-                
-                if (read_audio.addr_format==CDROM_MSF) /* MSF-bin specification of where to start */
-                        block=msf2lba(&read_audio.addr.msf.minute);
-                else if (read_audio.addr_format==CDROM_LBA) /* lba specification of where to start */
-                        block=read_audio.addr.lba;
-                else RETURN_UP(-EINVAL);
-#if 000
-                i=cc_SetSpeed(speed_150,0,0);
-                if (i) msg(DBG_AUD,"read_audio: SetSpeed error %d\n", i);
-#endif
-                msg(DBG_AUD,"read_audio: lba: %d, msf: %06X\n",
-                    block, blk2msf(block));
-                msg(DBG_AUD,"read_audio: before cc_ReadStatus.\n");
-#if OLD_BUSY
-                while (busy_data) sbp_sleep(HZ/10); /* wait a bit */
-                busy_audio=1;
-#endif /* OLD_BUSY */ 
-                error_flag=0;
-                for (data_tries=5; data_tries>0; data_tries--)
-                {
-                        msg(DBG_AUD,"data_tries=%d ...\n", data_tries);
-                        current_drive->mode=READ_AU;
-                        cc_ModeSelect(CD_FRAMESIZE_RAW);
-                        cc_ModeSense();
-                        for (status_tries=3; status_tries > 0; status_tries--)
-                        {
-                                flags_cmd_out |= f_respo3;
-                                cc_ReadStatus();
-                                if (sbp_status() != 0) break;
-                                if (st_check) cc_ReadError();
-                                sbp_sleep(1);    /* wait a bit, try again */
-                        }
-                        if (status_tries == 0)
-                        {
-                                msg(DBG_AUD,"read_audio: sbp_status: failed after 3 tries in line %d.\n", __LINE__);
-                                continue;
-                        }
-                        msg(DBG_AUD,"read_audio: sbp_status: ok.\n");
-                        
-                        flags_cmd_out = f_putcmd | f_respo2 | f_ResponseStatus | f_obey_p_check;
-                        if (fam0L_drive)
-                        {
-                                flags_cmd_out |= f_lopsta | f_getsta | f_bit1;
-                                cmd_type=READ_M2;
-                                drvcmd[0]=CMD0_READ_XA; /* "read XA frames", old drives */
-                                drvcmd[1]=(block>>16)&0x000000ff;
-                                drvcmd[2]=(block>>8)&0x000000ff;
-                                drvcmd[3]=block&0x000000ff;
-                                drvcmd[4]=0;
-                                drvcmd[5]=read_audio.nframes; /* # of frames */
-                                drvcmd[6]=0;
-                        }
-                        else if (fam1_drive)
-                        {
-                                drvcmd[0]=CMD1_READ; /* "read frames", new drives */
-                                lba2msf(block,&drvcmd[1]); /* msf-bin format required */
-                                drvcmd[4]=0;
-                                drvcmd[5]=0;
-                                drvcmd[6]=read_audio.nframes; /* # of frames */
-                        }
-                        else if (fam2_drive)
-                        {
-                                drvcmd[0]=CMD2_READ_XA2;
-                                lba2msf(block,&drvcmd[1]); /* msf-bin format required */
-                                drvcmd[4]=0;
-                                drvcmd[5]=read_audio.nframes; /* # of frames */
-                                drvcmd[6]=0x11; /* raw mode */
-                        }
-                        else if (famT_drive) /* CD-55A: not tested yet */
-                        {
-                        }
-                        msg(DBG_AUD,"read_audio: before giving \"read\" command.\n");
-                        flags_cmd_out=f_putcmd;
-                        response_count=0;
-                        i=cmd_out();
-                        if (i<0) msg(DBG_INF,"error giving READ AUDIO command: %0d\n", i);
-                        sbp_sleep(0);
-                        msg(DBG_AUD,"read_audio: after giving \"read\" command.\n");
-                        for (frame=1;frame<2 && !error_flag; frame++)
-                        {
-                                try=maxtim_data;
-                                for (timeout=jiffies+9*HZ; ; )
-                                {
-                                        for ( ; try!=0;try--)
-                                        {
-                                                j=inb(CDi_status);
-                                                if (!(j&s_not_data_ready)) break;
-                                                if (!(j&s_not_result_ready)) break;
-                                                if (fam0L_drive) if (j&s_attention) break;
-                                        }
-                                        if (try != 0 || time_after_eq(jiffies, timeout)) break;
-                                        if (data_retrying == 0) data_waits++;
-                                        data_retrying = 1;
-                                        sbp_sleep(1);
-                                        try = 1;
-                                }
-                                if (try==0)
-                                {
-                                        msg(DBG_INF,"read_audio: sbp_data: CDi_status timeout.\n");
-                                        error_flag++;
-                                        break;
-                                }
-                                msg(DBG_AUD,"read_audio: sbp_data: CDi_status ok.\n");
-                                if (j&s_not_data_ready)
-                                {
-                                        msg(DBG_INF, "read_audio: sbp_data: DATA_READY timeout.\n");
-                                        error_flag++;
-                                        break;
-                                }
-                                msg(DBG_AUD,"read_audio: before reading data.\n");
-                                error_flag=0;
-                                p = current_drive->aud_buf;
-                                if (sbpro_type==1) OUT(CDo_sel_i_d,1);
-                                if (do_16bit)
-                                {
-                                        u_short *p2 = (u_short *) p;
-
-                                        for (; (u_char *) p2 < current_drive->aud_buf + read_audio.nframes*CD_FRAMESIZE_RAW;)
-                                        {
-                                                if ((inb_p(CDi_status)&s_not_data_ready)) continue;
-
-                                                /* get one sample */
-                                                *p2++ = inw_p(CDi_data);
-                                                *p2++ = inw_p(CDi_data);
-                                        }
-                                } else {
-                                        for (; p < current_drive->aud_buf + read_audio.nframes*CD_FRAMESIZE_RAW;)
-                                        {
-                                                if ((inb_p(CDi_status)&s_not_data_ready)) continue;
-
-                                                /* get one sample */
-                                                *p++ = inb_p(CDi_data);
-                                                *p++ = inb_p(CDi_data);
-                                                *p++ = inb_p(CDi_data);
-                                                *p++ = inb_p(CDi_data);
-                                        }
-                                }
-                                if (sbpro_type==1) OUT(CDo_sel_i_d,0);
-                                data_retrying = 0;
-                        }
-                        msg(DBG_AUD,"read_audio: after reading data.\n");
-                        if (error_flag)    /* must have been spurious D_RDY or (ATTN&&!D_RDY) */
-                        {
-                                msg(DBG_AUD,"read_audio: read aborted by drive\n");
-#if 0000
-                                i=cc_DriveReset();                /* ugly fix to prevent a hang */
-#else
-                                i=cc_ReadError();
-#endif
-                                continue;
-                        }
-                        if (fam0L_drive)
-                        {
-                                i=maxtim_data;
-                                for (timeout=jiffies+9*HZ; time_before(jiffies, timeout); timeout--)
-                                {
-                                        for ( ;i!=0;i--)
-                                        {
-                                                j=inb(CDi_status);
-                                                if (!(j&s_not_data_ready)) break;
-                                                if (!(j&s_not_result_ready)) break;
-                                                if (j&s_attention) break;
-                                        }
-                                        if (i != 0 || time_after_eq(jiffies, timeout)) break;
-                                        sbp_sleep(0);
-                                        i = 1;
-                                }
-                                if (i==0) msg(DBG_AUD,"read_audio: STATUS TIMEOUT AFTER READ");
-                                if (!(j&s_attention))
-                                {
-                                        msg(DBG_AUD,"read_audio: sbp_data: timeout waiting DRV_ATTN - retrying\n");
-                                        i=cc_DriveReset();  /* ugly fix to prevent a hang */
-                                        continue;
-                                }
-                        }
-                        do
-                        {
-                                if (fam0L_drive) cc_ReadStatus();
-                                i=ResponseStatus();  /* builds status_bits, returns orig. status (old) or faked p_success (new) */
-                                if (i<0) { msg(DBG_AUD,
-                                               "read_audio: cc_ReadStatus error after read: %02X\n",
-                                               current_drive->status_bits);
-                                           continue; /* FIXME */
-                                   }
-                        }
-                        while ((fam0L_drive)&&(!st_check)&&(!(i&p_success)));
-                        if (st_check)
-                        {
-                                i=cc_ReadError();
-                                msg(DBG_AUD,"read_audio: cc_ReadError was necessary after read: %02X\n",i);
-                                continue;
-                        }
-                        if (copy_to_user(read_audio.buf,
-                                         current_drive->aud_buf,
-                                         read_audio.nframes * CD_FRAMESIZE_RAW))
-                                RETURN_UP(-EFAULT);
-                        msg(DBG_AUD,"read_audio: copy_to_user done.\n");
-                        break;
-                }
-                cc_ModeSelect(CD_FRAMESIZE);
-                cc_ModeSense();
-                current_drive->mode=READ_M1;
-#if OLD_BUSY
-                busy_audio=0;
-#endif /* OLD_BUSY */ 
-                if (data_tries == 0)
-                {
-                        msg(DBG_AUD,"read_audio: failed after 5 tries in line %d.\n", __LINE__);
-                        RETURN_UP(-EIO);
-                }
-                msg(DBG_AUD,"read_audio: successful return.\n");
-                RETURN_UP(0);
-        } /* end of CDROMREADAUDIO */
-                
-        default:
-                msg(DBG_IOC,"ioctl: unknown function request %04X\n", cmd);
-                RETURN_UP(-EINVAL);
-        } /* end switch(cmd) */
-}
-
 static int sbpcd_audio_ioctl(struct cdrom_device_info *cdi, u_int cmd,
                        void * arg)
 {
@@ -4530,7 +4204,7 @@ static int sbpcd_audio_ioctl(struct cdrom_device_info *cdi, u_int cmd,
                 default:
                         RETURN_UP(-EINVAL);
                 }
-                
+
         case CDROMRESUME: /* resume paused audio play */
                 msg(DBG_IOC,"ioctl: CDROMRESUME entered.\n");
                 /* resume playing audio tracks when a previous PLAY AUDIO call has  */
@@ -4544,12 +4218,12 @@ static int sbpcd_audio_ioctl(struct cdrom_device_info *cdi, u_int cmd,
                 if (i<0) RETURN_UP(-EIO);
                 current_drive->audio_state=audio_playing;
                 RETURN_UP(0);
-                
+
         case CDROMPLAYMSF:
                 msg(DBG_IOC,"ioctl: CDROMPLAYMSF entered.\n");
 #ifdef SAFE_MIXED
                 if (current_drive->has_data>1) RETURN_UP(-EBUSY);
-#endif /* SAFE_MIXED */ 
+#endif /* SAFE_MIXED */
                 if (current_drive->audio_state==audio_playing)
                 {
                         i=cc_Pause_Resume(1);
@@ -4584,7 +4258,7 @@ static int sbpcd_audio_ioctl(struct cdrom_device_info *cdi, u_int cmd,
                 msg(DBG_IOC,"ioctl: CDROMPLAYTRKIND entered.\n");
 #ifdef SAFE_MIXED
                 if (current_drive->has_data>1) RETURN_UP(-EBUSY);
-#endif /* SAFE_MIXED */ 
+#endif /* SAFE_MIXED */
                 if (current_drive->audio_state==audio_playing)
                 {
                         msg(DBG_IOX,"CDROMPLAYTRKIND: already audio_playing.\n");
@@ -4654,13 +4328,13 @@ static int sbpcd_audio_ioctl(struct cdrom_device_info *cdi, u_int cmd,
                 cc_DriveReset();
 #endif
                 RETURN_UP(i);
-                
+
         case CDROMSTART:  /* Spin up the drive */
                 msg(DBG_IOC,"ioctl: CDROMSTART entered.\n");
                 cc_SpinUp();
                 current_drive->audio_state=0;
                 RETURN_UP(0);
-                
+
         case CDROMVOLCTRL:   /* Volume control */
                 msg(DBG_IOC,"ioctl: CDROMVOLCTRL entered.\n");
                 memcpy(&volctrl,(char *) arg,sizeof(volctrl));
@@ -4670,7 +4344,7 @@ static int sbpcd_audio_ioctl(struct cdrom_device_info *cdi, u_int cmd,
                 current_drive->vol_ctrl1=volctrl.channel1;
                 i=cc_SetVolume();
                 RETURN_UP(0);
-                
+
         case CDROMVOLREAD:   /* read Volume settings from drive */
                 msg(DBG_IOC,"ioctl: CDROMVOLREAD entered.\n");
                 st=cc_GetVolume();
@@ -4694,7 +4368,7 @@ static int sbpcd_audio_ioctl(struct cdrom_device_info *cdi, u_int cmd,
                 if (i<0) {
                         j=cc_ReadError(); /* clear out error status from drive */
                         current_drive->audio_state=CDROM_AUDIO_NO_STATUS;
-                        /* get and set the disk state here, 
+                        /* get and set the disk state here,
                         probably not the right place, but who cares!
                         It makes it work properly! --AJK */
                         if (current_drive->CD_changed==0xFF) {
@@ -4715,8 +4389,8 @@ static int sbpcd_audio_ioctl(struct cdrom_device_info *cdi, u_int cmd,
                         }
                 }
                 memcpy(&SC, (void *) arg, sizeof(struct cdrom_subchnl));
-                /* 
-                        This virtual crap is very bogus! 
+                /*
+                        This virtual crap is very bogus!
                         It doesn't detect when the cd is done playing audio!
                         Lets do this right with proper hardware register reading!
                 */
@@ -4775,7 +4449,7 @@ static int sbpcd_audio_ioctl(struct cdrom_device_info *cdi, u_int cmd,
                     SC.cdsc_trk,SC.cdsc_ind,
                     SC.cdsc_absaddr,SC.cdsc_reladdr);
                 RETURN_UP(0);
-                
+
         default:
                 msg(DBG_IOC,"ioctl: unknown function request %04X\n", cmd);
                 RETURN_UP(-EINVAL);
@@ -4788,7 +4462,7 @@ static int sbpcd_audio_ioctl(struct cdrom_device_info *cdi, u_int cmd,
 static void sbp_transfer(struct request *req)
 {
         long offs;
-        
+
         while ( (req->nr_sectors > 0) &&
                (req->sector/4 >= current_drive->sbp_first_frame) &&
                (req->sector/4 <= current_drive->sbp_last_frame) )
@@ -4807,11 +4481,11 @@ static void sbp_transfer(struct request *req)
  *
  *  This is a kludge so we don't need to modify end_request.
  *  We put the req we take out after INIT_REQUEST in the requests list,
- *  so that end_request will discard it. 
+ *  so that end_request will discard it.
  *
  *  The bug could be present in other block devices, perhaps we
  *  should modify INIT_REQUEST and end_request instead, and
- *  change every block device.. 
+ *  change every block device..
  *
  *  Could be a race here?? Could e.g. a timer interrupt schedule() us?
  *  If so, we should copy end_request here, and do it right.. (or
@@ -4883,19 +4557,19 @@ static void do_sbpcd_request(request_queue_t * q)
         while (busy_audio) sbp_sleep(HZ); /* wait a bit */
         busy_data=1;
 #endif /* OLD_BUSY */
-        
+
         if (p->audio_state==audio_playing) goto err_done;
         if (p != current_drive)
                 switch_drive(p);
 
         block = req->sector; /* always numbered as 512-byte-pieces */
         nsect = req->nr_sectors; /* always counted as 512-byte-pieces */
-        
+
         msg(DBG_BSZ,"read sector %d (%d sectors)\n", block, nsect);
 #if 0
         msg(DBG_MUL,"read LBA %d\n", block/4);
 #endif
-        
+
         sbp_transfer(req);
         /* if we satisfied the request from the buffer, we're done. */
         if (req->nr_sectors == 0)
@@ -4914,10 +4588,10 @@ static void do_sbpcd_request(request_queue_t * q)
         i=prepare(0,0); /* at moment not really a hassle check, but ... */
         if (i!=0)
                 msg(DBG_INF,"\"prepare\" tells error %d -- ignored\n", i);
-#endif /* FUTURE */ 
-        
+#endif /* FUTURE */
+
         if (!st_spinning) cc_SpinUp();
-        
+
         for (data_tries=n_retries; data_tries > 0; data_tries--)
         {
                 for (status_tries=3; status_tries > 0; status_tries--)
@@ -4940,7 +4614,7 @@ static void do_sbpcd_request(request_queue_t * q)
                 {
 #ifdef SAFE_MIXED
                         current_drive->has_data=2; /* is really a data disk */
-#endif /* SAFE_MIXED */ 
+#endif /* SAFE_MIXED */
 #ifdef DEBUG_GTL
                         printk(" do_sbpcd_request[%do](%p:%ld+%ld) end 3, Time:%li\n",
                                 xnr, req, req->sector, req->nr_sectors, jiffies);
@@ -4951,7 +4625,7 @@ static void do_sbpcd_request(request_queue_t * q)
                         goto request_loop;
                 }
         }
-        
+
  err_done:
 #if OLD_BUSY
         busy_data=0;
@@ -4976,7 +4650,7 @@ static void sbp_read_cmd(struct request *req)
 
         int i;
         int block;
-        
+
         current_drive->sbp_first_frame=current_drive->sbp_last_frame=-1;      /* purge buffer */
         current_drive->sbp_current = 0;
         block=req->sector/4;
@@ -4993,7 +4667,7 @@ static void sbp_read_cmd(struct request *req)
                         current_drive->sbp_read_frames=1;
                 }
         }
-        
+
         flags_cmd_out = f_putcmd | f_respo2 | f_ResponseStatus | f_obey_p_check;
         clr_cmdbuf();
         if (famV_drive)
@@ -5092,7 +4766,7 @@ static int sbp_data(struct request *req)
         int success;
         int wait;
         int duration;
-        
+
         error_flag=0;
         success=0;
 #if LONG_TIMING
@@ -5105,12 +4779,12 @@ static int sbp_data(struct request *req)
         for (frame=0;frame<current_drive->sbp_read_frames&&!error_flag; frame++)
         {
                 SBPCD_CLI;
-                
+
                 del_timer(&data_timer);
                 data_timer.expires=jiffies+max_latency;
                 timed_out_data=0;
                 add_timer(&data_timer);
-                while (!timed_out_data) 
+                while (!timed_out_data)
                 {
                         if (current_drive->f_multisession) try=maxtim_data*4;
                         else try=maxtim_data;
@@ -5207,9 +4881,9 @@ static int sbp_data(struct request *req)
                         else
                           {
                             sbp_sleep(1);
-                            OUT(CDo_sel_i_d,0); 
+                            OUT(CDo_sel_i_d,0);
                             i=inb(CDi_status);
-                          } 
+                          }
                         if (!(i&s_not_data_ready))
                         {
                                 OUT(CDo_sel_i_d,1);
@@ -5311,7 +4985,7 @@ static int sbp_data(struct request *req)
                 }
                 SBPCD_STI;
         }
-        
+
 #if 0
         if (!success)
 #endif
@@ -5370,7 +5044,326 @@ static int sbpcd_block_ioctl(struct inode *inode, struct file *file,
                                 unsigned cmd, unsigned long arg)
 {
         struct sbpcd_drive *p = inode->i_bdev->bd_disk->private_data;
-        return cdrom_ioctl(file, p->sbpcd_infop, inode, cmd, arg);
+        struct cdrom_device_info *cdi = p->sbpcd_infop;
+        int ret, i;
+
+        ret = cdrom_ioctl(file, p->sbpcd_infop, inode, cmd, arg);
+        if (ret != -ENOSYS)
+                return ret;
+
+        msg(DBG_IO2,"ioctl(%s, 0x%08lX, 0x%08lX)\n", cdi->name, cmd, arg);
+        if (p->drv_id==-1) {
+                msg(DBG_INF, "ioctl: bad device: %s\n", cdi->name);
+                return (-ENXIO);             /* no such drive */
+        }
+        down(&ioctl_read_sem);
+        if (p != current_drive)
+                switch_drive(p);
+        
+        msg(DBG_IO2,"ioctl: device %s, request %04X\n",cdi->name,cmd);
+        switch (cmd)            /* Sun-compatible */
+        {
+        case DDIOCSDBG:         /* DDI Debug */
+                if (!capable(CAP_SYS_ADMIN)) RETURN_UP(-EPERM);
+                i=sbpcd_dbg_ioctl(arg,1);
+                RETURN_UP(i);
+        case CDROMRESET:      /* hard reset the drive */
+                msg(DBG_IOC,"ioctl: CDROMRESET entered.\n");
+                i=DriveReset();
+                current_drive->audio_state=0;
+                RETURN_UP(i);
+
+        case CDROMREADMODE1:
+                msg(DBG_IOC,"ioctl: CDROMREADMODE1 requested.\n");
+#ifdef SAFE_MIXED
+                if (current_drive->has_data>1) RETURN_UP(-EBUSY);
+#endif /* SAFE_MIXED */
+                cc_ModeSelect(CD_FRAMESIZE);
+                cc_ModeSense();
+                current_drive->mode=READ_M1;
+                RETURN_UP(0);
+
+        case CDROMREADMODE2: /* not usable at the moment */
+                msg(DBG_IOC,"ioctl: CDROMREADMODE2 requested.\n");
+#ifdef SAFE_MIXED
+                if (current_drive->has_data>1) RETURN_UP(-EBUSY);
+#endif /* SAFE_MIXED */
+                cc_ModeSelect(CD_FRAMESIZE_RAW1);
+                cc_ModeSense();
+                current_drive->mode=READ_M2;
+                RETURN_UP(0);
+
+        case CDROMAUDIOBUFSIZ: /* configure the audio buffer size */
+                msg(DBG_IOC,"ioctl: CDROMAUDIOBUFSIZ entered.\n");
+                if (current_drive->sbp_audsiz>0)
+                        vfree(current_drive->aud_buf);
+                current_drive->aud_buf=NULL;
+                current_drive->sbp_audsiz=arg;
+
+                if (current_drive->sbp_audsiz>16)
+                {
+                        current_drive->sbp_audsiz = 0;
+                        RETURN_UP(current_drive->sbp_audsiz);
+                }
+        
+                if (current_drive->sbp_audsiz>0)
+                {
+                        current_drive->aud_buf=(u_char *) vmalloc(current_drive->sbp_audsiz*CD_FRAMESIZE_RAW);
+                        if (current_drive->aud_buf==NULL)
+                        {
+                                msg(DBG_INF,"audio buffer (%d frames) not available.\n",current_drive->sbp_audsiz);
+                                current_drive->sbp_audsiz=0;
+                        }
+                        else msg(DBG_INF,"audio buffer size: %d frames.\n",current_drive->sbp_audsiz);
+                }
+                RETURN_UP(current_drive->sbp_audsiz);
+
+        case CDROMREADAUDIO:
+        { /* start of CDROMREADAUDIO */
+                int i=0, j=0, frame, block=0;
+                u_int try=0;
+                u_long timeout;
+                u_char *p;
+                u_int data_tries = 0;
+                u_int data_waits = 0;
+                u_int data_retrying = 0;
+                int status_tries;
+                int error_flag;
+
+                msg(DBG_IOC,"ioctl: CDROMREADAUDIO entered.\n");
+                if (fam0_drive) RETURN_UP(-EINVAL);
+                if (famL_drive) RETURN_UP(-EINVAL);
+                if (famV_drive) RETURN_UP(-EINVAL);
+                if (famT_drive) RETURN_UP(-EINVAL);
+#ifdef SAFE_MIXED
+                if (current_drive->has_data>1) RETURN_UP(-EBUSY);
+#endif /* SAFE_MIXED */
+                if (current_drive->aud_buf==NULL) RETURN_UP(-EINVAL);
+                if (copy_from_user(&read_audio, (void __user *)arg,
+                                   sizeof(struct cdrom_read_audio)))
+                        RETURN_UP(-EFAULT);
+                if (read_audio.nframes < 0 || read_audio.nframes>current_drive->sbp_audsiz) RETURN_UP(-EINVAL);
+                if (!access_ok(VERIFY_WRITE, read_audio.buf,
+                              read_audio.nframes*CD_FRAMESIZE_RAW))
+                        RETURN_UP(-EFAULT);
+
+                if (read_audio.addr_format==CDROM_MSF) /* MSF-bin specification of where to start */
+                        block=msf2lba(&read_audio.addr.msf.minute);
+                else if (read_audio.addr_format==CDROM_LBA) /* lba specification of where to start */
+                        block=read_audio.addr.lba;
+                else RETURN_UP(-EINVAL);
+#if 000
+                i=cc_SetSpeed(speed_150,0,0);
+                if (i) msg(DBG_AUD,"read_audio: SetSpeed error %d\n", i);
+#endif
+                msg(DBG_AUD,"read_audio: lba: %d, msf: %06X\n",
+                    block, blk2msf(block));
+                msg(DBG_AUD,"read_audio: before cc_ReadStatus.\n");
+#if OLD_BUSY
+                while (busy_data) sbp_sleep(HZ/10); /* wait a bit */
+                busy_audio=1;
+#endif /* OLD_BUSY */
+                error_flag=0;
+                for (data_tries=5; data_tries>0; data_tries--)
+                {
+                        msg(DBG_AUD,"data_tries=%d ...\n", data_tries);
+                        current_drive->mode=READ_AU;
+                        cc_ModeSelect(CD_FRAMESIZE_RAW);
+                        cc_ModeSense();
+                        for (status_tries=3; status_tries > 0; status_tries--)
+                        {
+                                flags_cmd_out |= f_respo3;
+                                cc_ReadStatus();
+                                if (sbp_status() != 0) break;
+                                if (st_check) cc_ReadError();
+                                sbp_sleep(1);    /* wait a bit, try again */
+                        }
+                        if (status_tries == 0)
+                        {
+                                msg(DBG_AUD,"read_audio: sbp_status: failed after 3 tries in line %d.\n", __LINE__);
+                                continue;
+                        }
+                        msg(DBG_AUD,"read_audio: sbp_status: ok.\n");
+
+                        flags_cmd_out = f_putcmd | f_respo2 | f_ResponseStatus | f_obey_p_check;
+                        if (fam0L_drive)
+                        {
+                                flags_cmd_out |= f_lopsta | f_getsta | f_bit1;
+                                cmd_type=READ_M2;
+                                drvcmd[0]=CMD0_READ_XA; /* "read XA frames", old drives */
+                                drvcmd[1]=(block>>16)&0x000000ff;
+                                drvcmd[2]=(block>>8)&0x000000ff;
+                                drvcmd[3]=block&0x000000ff;
+                                drvcmd[4]=0;
+                                drvcmd[5]=read_audio.nframes; /* # of frames */
+                                drvcmd[6]=0;
+                        }
+                        else if (fam1_drive)
+                        {
+                                drvcmd[0]=CMD1_READ; /* "read frames", new drives */
+                                lba2msf(block,&drvcmd[1]); /* msf-bin format required */
+                                drvcmd[4]=0;
+                                drvcmd[5]=0;
+                                drvcmd[6]=read_audio.nframes; /* # of frames */
+                        }
+                        else if (fam2_drive)
+                        {
+                                drvcmd[0]=CMD2_READ_XA2;
+                                lba2msf(block,&drvcmd[1]); /* msf-bin format required */
+                                drvcmd[4]=0;
+                                drvcmd[5]=read_audio.nframes; /* # of frames */
+                                drvcmd[6]=0x11; /* raw mode */
+                        }
+                        else if (famT_drive) /* CD-55A: not tested yet */
+                        {
+                        }
+                        msg(DBG_AUD,"read_audio: before giving \"read\" command.\n");
+                        flags_cmd_out=f_putcmd;
+                        response_count=0;
+                        i=cmd_out();
+                        if (i<0) msg(DBG_INF,"error giving READ AUDIO command: %0d\n", i);
+                        sbp_sleep(0);
+                        msg(DBG_AUD,"read_audio: after giving \"read\" command.\n");
+                        for (frame=1;frame<2 && !error_flag; frame++)
+                        {
+                                try=maxtim_data;
+                                for (timeout=jiffies+9*HZ; ; )
+                                {
+                                        for ( ; try!=0;try--)
+                                        {
+                                                j=inb(CDi_status);
+                                                if (!(j&s_not_data_ready)) break;
+                                                if (!(j&s_not_result_ready)) break;
+                                                if (fam0L_drive) if (j&s_attention) break;
+                                        }
+                                        if (try != 0 || time_after_eq(jiffies, timeout)) break;
+                                        if (data_retrying == 0) data_waits++;
+                                        data_retrying = 1;
+                                        sbp_sleep(1);
+                                        try = 1;
+                                }
+                                if (try==0)
+                                {
+                                        msg(DBG_INF,"read_audio: sbp_data: CDi_status timeout.\n");
+                                        error_flag++;
+                                        break;
+                                }
+                                msg(DBG_AUD,"read_audio: sbp_data: CDi_status ok.\n");
+                                if (j&s_not_data_ready)
+                                {
+                                        msg(DBG_INF, "read_audio: sbp_data: DATA_READY timeout.\n");
+                                        error_flag++;
+                                        break;
+                                }
+                                msg(DBG_AUD,"read_audio: before reading data.\n");
+                                error_flag=0;
+                                p = current_drive->aud_buf;
+                                if (sbpro_type==1) OUT(CDo_sel_i_d,1);
+                                if (do_16bit)
+                                {
+                                        u_short *p2 = (u_short *) p;
+
+                                        for (; (u_char *) p2 < current_drive->aud_buf + read_audio.nframes*CD_FRAMESIZE_RAW;)
+                                        {
+                                                if ((inb_p(CDi_status)&s_not_data_ready)) continue;
+
+                                                /* get one sample */
+                                                *p2++ = inw_p(CDi_data);
+                                                *p2++ = inw_p(CDi_data);
+                                        }
+                                } else {
+                                        for (; p < current_drive->aud_buf + read_audio.nframes*CD_FRAMESIZE_RAW;)
+                                        {
+                                                if ((inb_p(CDi_status)&s_not_data_ready)) continue;
+
+                                                /* get one sample */
+                                                *p++ = inb_p(CDi_data);
+                                                *p++ = inb_p(CDi_data);
+                                                *p++ = inb_p(CDi_data);
+                                                *p++ = inb_p(CDi_data);
+                                        }
+                                }
+                                if (sbpro_type==1) OUT(CDo_sel_i_d,0);
+                                data_retrying = 0;
+                        }
+                        msg(DBG_AUD,"read_audio: after reading data.\n");
+                        if (error_flag)    /* must have been spurious D_RDY or (ATTN&&!D_RDY) */
+                        {
+                                msg(DBG_AUD,"read_audio: read aborted by drive\n");
+#if 0000
+                                i=cc_DriveReset();                /* ugly fix to prevent a hang */
+#else
+                                i=cc_ReadError();
+#endif
+                                continue;
+                        }
+                        if (fam0L_drive)
+                        {
+                                i=maxtim_data;
+                                for (timeout=jiffies+9*HZ; time_before(jiffies, timeout); timeout--)
+                                {
+                                        for ( ;i!=0;i--)
+                                        {
+                                                j=inb(CDi_status);
+                                                if (!(j&s_not_data_ready)) break;
+                                                if (!(j&s_not_result_ready)) break;
+                                                if (j&s_attention) break;
+                                        }
+                                        if (i != 0 || time_after_eq(jiffies, timeout)) break;
+                                        sbp_sleep(0);
+                                        i = 1;
+                                }
+                                if (i==0) msg(DBG_AUD,"read_audio: STATUS TIMEOUT AFTER READ");
+                                if (!(j&s_attention))
+                                {
+                                        msg(DBG_AUD,"read_audio: sbp_data: timeout waiting DRV_ATTN - retrying\n");
+                                        i=cc_DriveReset();  /* ugly fix to prevent a hang */
+                                        continue;
+                                }
+                        }
+                        do
+                        {
+                                if (fam0L_drive) cc_ReadStatus();
+                                i=ResponseStatus();  /* builds status_bits, returns orig. status (old) or faked p_success (new) */
+                                if (i<0) { msg(DBG_AUD,
+                                               "read_audio: cc_ReadStatus error after read: %02X\n",
+                                               current_drive->status_bits);
+                                           continue; /* FIXME */
+                                   }
+                        }
+                        while ((fam0L_drive)&&(!st_check)&&(!(i&p_success)));
+                        if (st_check)
+                        {
+                                i=cc_ReadError();
+                                msg(DBG_AUD,"read_audio: cc_ReadError was necessary after read: %02X\n",i);
+                                continue;
+                        }
+                        if (copy_to_user(read_audio.buf,
+                                         current_drive->aud_buf,
+                                         read_audio.nframes * CD_FRAMESIZE_RAW))
+                                RETURN_UP(-EFAULT);
+                        msg(DBG_AUD,"read_audio: copy_to_user done.\n");
+                        break;
+                }
+                cc_ModeSelect(CD_FRAMESIZE);
+                cc_ModeSense();
+                current_drive->mode=READ_M1;
+#if OLD_BUSY
+                busy_audio=0;
+#endif /* OLD_BUSY */
+                if (data_tries == 0)
+                {
+                        msg(DBG_AUD,"read_audio: failed after 5 tries in line %d.\n", __LINE__);
+                        RETURN_UP(-EIO);
+                }
+                msg(DBG_AUD,"read_audio: successful return.\n");
+                RETURN_UP(0);
+        } /* end of CDROMREADAUDIO */
+
+        default:
+                msg(DBG_IOC,"ioctl: unknown function request %04X\n", cmd);
+                RETURN_UP(-EINVAL);
+        } /* end switch(cmd) */
 }
 
 static int sbpcd_block_media_changed(struct gendisk *disk)
@@ -5478,10 +5471,9 @@ static struct cdrom_device_ops sbpcd_dops = {
         .get_mcn                = sbpcd_get_mcn,
         .reset                  = sbpcd_reset,
         .audio_ioctl            = sbpcd_audio_ioctl,
-        .dev_ioctl              = sbpcd_dev_ioctl,
         .capability             = CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK |
                                 CDC_MULTI_SESSION | CDC_MEDIA_CHANGED |
-                                CDC_MCN | CDC_PLAY_AUDIO | CDC_IOCTLS,
+                                CDC_MCN | CDC_PLAY_AUDIO,
         .n_minors               = 1,
 };
 
diff --git a/drivers/cdrom/viocd.c b/drivers/cdrom/viocd.c
index e276172595..c0f817ba7a 100644
--- a/drivers/cdrom/viocd.c
+++ b/drivers/cdrom/viocd.c
@@ -627,7 +627,7 @@ static struct cdrom_device_ops viocd_dops = {
         .media_changed = viocd_media_changed,
         .lock_door = viocd_lock_door,
         .generic_packet = viocd_packet,
-        .capability = CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK | CDC_SELECT_SPEED | CDC_SELECT_DISC | CDC_MULTI_SESSION | CDC_MCN | CDC_MEDIA_CHANGED | CDC_PLAY_AUDIO | CDC_RESET | CDC_IOCTLS | CDC_DRIVE_STATUS | CDC_GENERIC_PACKET | CDC_CD_R | CDC_CD_RW | CDC_DVD | CDC_DVD_R | CDC_DVD_RAM | CDC_RAM
+        .capability = CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK | CDC_SELECT_SPEED | CDC_SELECT_DISC | CDC_MULTI_SESSION | CDC_MCN | CDC_MEDIA_CHANGED | CDC_PLAY_AUDIO | CDC_RESET | CDC_DRIVE_STATUS | CDC_GENERIC_PACKET | CDC_CD_R | CDC_CD_RW | CDC_DVD | CDC_DVD_R | CDC_DVD_RAM | CDC_RAM
 };
 
 static int __init find_capability(const char *type)
diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index 05ba410682..5980f3e886 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -290,7 +290,7 @@ config SX
 
 config RIO
         tristate "Specialix RIO system support"
-        depends on SERIAL_NONSTANDARD && BROKEN_ON_SMP && !64BIT
+        depends on SERIAL_NONSTANDARD && !64BIT
         help
           This is a driver for the Specialix RIO, a smart serial card which
           drives an outboard box that can support up to 128 ports.  Product
@@ -695,7 +695,7 @@ config NVRAM
 
 config RTC
         tristate "Enhanced Real Time Clock Support"
-        depends on !PPC32 && !PARISC && !IA64 && !M68K && (!SPARC || PCI) && !FRV
+        depends on !PPC && !PARISC && !IA64 && !M68K && (!SPARC || PCI) && !FRV
         ---help---
           If you say Y here and create a character special file /dev/rtc with
           major number 10 and minor number 135 using mknod ("man mknod"), you
diff --git a/drivers/char/amiserial.c b/drivers/char/amiserial.c
index 7ac365b5d9..6602b3156d 100644
--- a/drivers/char/amiserial.c
+++ b/drivers/char/amiserial.c
@@ -46,8 +46,6 @@
 
 /* Sanity checks */
 
-#define SERIAL_INLINE
-  
 #if defined(MODULE) && defined(SERIAL_DEBUG_MCOUNT)
 #define DBG_CNT(s) printk("(%s): [%x] refc=%d, serc=%d, ttyc=%d -> %s\n", \
  tty->name, (info->flags), serial_driver->refcount,info->count,tty->count,s)
@@ -95,10 +93,6 @@ static char *serial_version = "4.30";
 #include <asm/amigahw.h>
 #include <asm/amigaints.h>
 
-#ifdef SERIAL_INLINE
-#define _INLINE_ inline
-#endif
-
 #define custom amiga_custom
 static char *serial_name = "Amiga-builtin serial driver";
 
@@ -253,14 +247,14 @@ static void rs_start(struct tty_struct *tty)
  * This routine is used by the interrupt handler to schedule
  * processing in the software interrupt portion of the driver.
  */
-static _INLINE_ void rs_sched_event(struct async_struct *info,
-                                  int event)
+static void rs_sched_event(struct async_struct *info,
+                           int event)
 {
         info->event |= 1 << event;
         tasklet_schedule(&info->tlet);
 }
 
-static _INLINE_ void receive_chars(struct async_struct *info)
+static void receive_chars(struct async_struct *info)
 {
         int status;
         int serdatr;
@@ -349,7 +343,7 @@ out:
         return;
 }
 
-static _INLINE_ void transmit_chars(struct async_struct *info)
+static void transmit_chars(struct async_struct *info)
 {
         custom.intreq = IF_TBE;
         mb();
@@ -389,7 +383,7 @@ static _INLINE_ void transmit_chars(struct async_struct *info)
         }
 }
 
-static _INLINE_ void check_modem_status(struct async_struct *info)
+static void check_modem_status(struct async_struct *info)
 {
         unsigned char status = ciab.pra & (SER_DCD | SER_CTS | SER_DSR);
         unsigned char dstatus;
@@ -1959,7 +1953,7 @@ done:
  * number, and identifies which options were configured into this
  * driver.
  */
-static _INLINE_ void show_serial_version(void)
+static void show_serial_version(void)
 {
         printk(KERN_INFO "%s version %s\n", serial_name, serial_version);
 }
diff --git a/drivers/char/generic_serial.c b/drivers/char/generic_serial.c
index e38a5f0e07..5e59c0b427 100644
--- a/drivers/char/generic_serial.c
+++ b/drivers/char/generic_serial.c
@@ -48,8 +48,8 @@ static int gs_debug;
 #define NEW_WRITE_LOCKING 1
 #if NEW_WRITE_LOCKING
 #define DECL      /* Nothing */
-#define LOCKIT    down (& port->port_write_sem);
-#define RELEASEIT up (&port->port_write_sem);
+#define LOCKIT    mutex_lock(& port->port_write_mutex);
+#define RELEASEIT mutex_unlock(&port->port_write_mutex);
 #else
 #define DECL      unsigned long flags;
 #define LOCKIT    save_flags (flags);cli ()
@@ -124,14 +124,14 @@ int gs_write(struct tty_struct * tty,
         /* get exclusive "write" access to this port (problem 3) */
         /* This is not a spinlock because we can have a disk access (page 
                  fault) in copy_from_user */
-        down (& port->port_write_sem);
+        mutex_lock(& port->port_write_mutex);
 
         while (1) {
 
                 c = count;
  
                 /* This is safe because we "OWN" the "head". Noone else can 
-                   change the "head": we own the port_write_sem. */
+                   change the "head": we own the port_write_mutex. */
                 /* Don't overrun the end of the buffer */
                 t = SERIAL_XMIT_SIZE - port->xmit_head;
                 if (t < c) c = t;
@@ -153,7 +153,7 @@ int gs_write(struct tty_struct * tty,
                 count -= c;
                 total += c;
         }
-        up (& port->port_write_sem);
+        mutex_unlock(& port->port_write_mutex);
 
         gs_dprintk (GS_DEBUG_WRITE, "write: interrupts are %s\n", 
                     (port->flags & GS_TX_INTEN)?"enabled": "disabled"); 
@@ -214,7 +214,7 @@ int gs_write(struct tty_struct * tty,
                 c = count;
 
                 /* This is safe because we "OWN" the "head". Noone else can 
-                   change the "head": we own the port_write_sem. */
+                   change the "head": we own the port_write_mutex. */
                 /* Don't overrun the end of the buffer */
                 t = SERIAL_XMIT_SIZE - port->xmit_head;
                 if (t < c) c = t;
@@ -888,7 +888,7 @@ int gs_init_port(struct gs_port *port)
         spin_lock_irqsave (&port->driver_lock, flags);
         if (port->tty) 
                 clear_bit(TTY_IO_ERROR, &port->tty->flags);
-        init_MUTEX(&port->port_write_sem);
+        mutex_init(&port->port_write_mutex);
         port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
         spin_unlock_irqrestore(&port->driver_lock, flags);
         gs_set_termios(port->tty, NULL);
diff --git a/drivers/char/hvcs.c b/drivers/char/hvcs.c
index 831eb4e8d9..f7ac318565 100644
--- a/drivers/char/hvcs.c
+++ b/drivers/char/hvcs.c
@@ -118,7 +118,7 @@
  * the hvcs_final_close() function in order to get it out of the spinlock.
  * Rearranged hvcs_close().  Cleaned up some printks and did some housekeeping
  * on the changelog.  Removed local CLC_LENGTH and used HVCS_CLC_LENGTH from
- * arch/ppc64/hvcserver.h.
+ * include/asm-powerpc/hvcserver.h 
  *
  * 1.3.2 -> 1.3.3 Replaced yield() in hvcs_close() with tty_wait_until_sent() to
  * prevent possible lockup with realtime scheduling as similarily pointed out by
@@ -168,9 +168,10 @@ MODULE_VERSION(HVCS_DRIVER_VERSION);
 
 /*
  * The hcall interface involves putting 8 chars into each of two registers.
- * We load up those 2 registers (in arch/ppc64/hvconsole.c) by casting char[16]
- * to long[2].  It would work without __ALIGNED__, but a little (tiny) bit
- * slower because an unaligned load is slower than aligned load.
+ * We load up those 2 registers (in arch/powerpc/platforms/pseries/hvconsole.c)
+ * by casting char[16] to long[2].  It would work without __ALIGNED__, but a 
+ * little (tiny) bit slower because an unaligned load is slower than aligned 
+ * load.
  */
 #define __ALIGNED__     __attribute__((__aligned__(8)))
 
diff --git a/drivers/char/ipmi/ipmi_poweroff.c b/drivers/char/ipmi/ipmi_poweroff.c
index 49c09ae004..e8ed26b77d 100644
--- a/drivers/char/ipmi/ipmi_poweroff.c
+++ b/drivers/char/ipmi/ipmi_poweroff.c
@@ -37,15 +37,13 @@
 #include <linux/proc_fs.h>
 #include <linux/string.h>
 #include <linux/completion.h>
+#include <linux/pm.h>
 #include <linux/kdev_t.h>
 #include <linux/ipmi.h>
 #include <linux/ipmi_smi.h>
 
 #define PFX "IPMI poweroff: "
 
-/* Where to we insert our poweroff function? */
-extern void (*pm_power_off)(void);
-
 /* Definitions for controlling power off (if the system supports it).  It
  * conveniently matches the IPMI chassis control values. */
 #define IPMI_CHASSIS_POWER_DOWN         0       /* power down, the default. */
diff --git a/drivers/char/istallion.c b/drivers/char/istallion.c
index 28c5a3193b..ede128356a 100644
--- a/drivers/char/istallion.c
+++ b/drivers/char/istallion.c
@@ -181,7 +181,6 @@ static struct tty_driver	*stli_serial;
  *      is already swapping a shared buffer won't make things any worse.
  */
 static char                     *stli_tmpwritebuf;
-static DECLARE_MUTEX(stli_tmpwritesem);
 
 #define STLI_TXBUFSIZE          4096
 
diff --git a/drivers/char/n_tty.c b/drivers/char/n_tty.c
index ccad7ae945..ede365d053 100644
--- a/drivers/char/n_tty.c
+++ b/drivers/char/n_tty.c
@@ -132,7 +132,7 @@ static void put_tty_queue(unsigned char c, struct tty_struct *tty)
  *      We test the TTY_THROTTLED bit first so that it always
  *      indicates the current state. The decision about whether
  *      it is worth allowing more input has been taken by the caller.
- *      Can sleep, may be called under the atomic_read semaphore but
+ *      Can sleep, may be called under the atomic_read_lock mutex but
  *      this is not guaranteed.
  */
  
@@ -1132,7 +1132,7 @@ static inline int input_available_p(struct tty_struct *tty, int amt)
  *      buffer, and once to drain the space from the (physical) beginning of
  *      the buffer to head pointer.
  *
- *      Called under the tty->atomic_read sem and with TTY_DONT_FLIP set
+ *      Called under the tty->atomic_read_lock sem and with TTY_DONT_FLIP set
  *
  */
  
@@ -1262,11 +1262,11 @@ do_it_again:
          *      Internal serialization of reads.
          */
         if (file->f_flags & O_NONBLOCK) {
-                if (down_trylock(&tty->atomic_read))
+                if (!mutex_trylock(&tty->atomic_read_lock))
                         return -EAGAIN;
         }
         else {
-                if (down_interruptible(&tty->atomic_read))
+                if (mutex_lock_interruptible(&tty->atomic_read_lock))
                         return -ERESTARTSYS;
         }
 
@@ -1393,7 +1393,7 @@ do_it_again:
                         timeout = time;
         }
         clear_bit(TTY_DONT_FLIP, &tty->flags);
-        up(&tty->atomic_read);
+        mutex_unlock(&tty->atomic_read_lock);
         remove_wait_queue(&tty->read_wait, &wait);
 
         if (!waitqueue_active(&tty->read_wait))
diff --git a/drivers/char/nwflash.c b/drivers/char/nwflash.c
index ca41d62b1d..8865387d34 100644
--- a/drivers/char/nwflash.c
+++ b/drivers/char/nwflash.c
@@ -27,6 +27,7 @@
 #include <linux/rwsem.h>
 #include <linux/init.h>
 #include <linux/smp_lock.h>
+#include <linux/mutex.h>
 
 #include <asm/hardware/dec21285.h>
 #include <asm/io.h>
@@ -56,7 +57,7 @@ static int gbWriteEnable;
 static int gbWriteBase64Enable;
 static volatile unsigned char *FLASH_BASE;
 static int gbFlashSize = KFLASH_SIZE;
-static DECLARE_MUTEX(nwflash_sem);
+static DEFINE_MUTEX(nwflash_mutex);
 
 extern spinlock_t gpio_lock;
 
@@ -140,7 +141,7 @@ static ssize_t flash_read(struct file *file, char __user *buf, size_t size,
                 /*
                  * We now lock against reads and writes. --rmk
                  */
-                if (down_interruptible(&nwflash_sem))
+                if (mutex_lock_interruptible(&nwflash_mutex))
                         return -ERESTARTSYS;
 
                 ret = copy_to_user(buf, (void *)(FLASH_BASE + p), count);
@@ -149,7 +150,7 @@ static ssize_t flash_read(struct file *file, char __user *buf, size_t size,
                         *ppos += count;
                 } else
                         ret = -EFAULT;
-                up(&nwflash_sem);
+                mutex_unlock(&nwflash_mutex);
         }
         return ret;
 }
@@ -188,7 +189,7 @@ static ssize_t flash_write(struct file *file, const char __user *buf,
         /*
          * We now lock against reads and writes. --rmk
          */
-        if (down_interruptible(&nwflash_sem))
+        if (mutex_lock_interruptible(&nwflash_mutex))
                 return -ERESTARTSYS;
 
         written = 0;
@@ -277,7 +278,7 @@ static ssize_t flash_write(struct file *file, const char __user *buf,
          */
         leds_event(led_release);
 
-        up(&nwflash_sem);
+        mutex_unlock(&nwflash_mutex);
 
         return written;
 }
diff --git a/drivers/char/pcmcia/synclink_cs.c b/drivers/char/pcmcia/synclink_cs.c
index 8a8ca32822..e6b714b639 100644
--- a/drivers/char/pcmcia/synclink_cs.c
+++ b/drivers/char/pcmcia/synclink_cs.c
@@ -4181,7 +4181,7 @@ static int hdlcdev_attach(struct net_device *dev, unsigned short encoding,
         }
 
         info->params.encoding = new_encoding;
-        info->params.crc_type = new_crctype;;
+        info->params.crc_type = new_crctype;
 
         /* if network interface up, reprogram hardware */
         if (info->netcount)
diff --git a/drivers/char/raw.c b/drivers/char/raw.c
index 30e4cbe16b..15a7b40865 100644
--- a/drivers/char/raw.c
+++ b/drivers/char/raw.c
@@ -19,6 +19,7 @@
 #include <linux/uio.h>
 #include <linux/cdev.h>
 #include <linux/device.h>
+#include <linux/mutex.h>
 
 #include <asm/uaccess.h>
 
@@ -29,7 +30,7 @@ struct raw_device_data {
 
 static struct class *raw_class;
 static struct raw_device_data raw_devices[MAX_RAW_MINORS];
-static DECLARE_MUTEX(raw_mutex);
+static DEFINE_MUTEX(raw_mutex);
 static struct file_operations raw_ctl_fops;          /* forward declaration */
 
 /*
@@ -53,7 +54,7 @@ static int raw_open(struct inode *inode, struct file *filp)
                 return 0;
         }
 
-        down(&raw_mutex);
+        mutex_lock(&raw_mutex);
 
         /*
          * All we need to do on open is check that the device is bound.
@@ -78,7 +79,7 @@ static int raw_open(struct inode *inode, struct file *filp)
                 filp->f_dentry->d_inode->i_mapping =
                         bdev->bd_inode->i_mapping;
         filp->private_data = bdev;
-        up(&raw_mutex);
+        mutex_unlock(&raw_mutex);
         return 0;
 
 out2:
@@ -86,7 +87,7 @@ out2:
 out1:
         blkdev_put(bdev);
 out:
-        up(&raw_mutex);
+        mutex_unlock(&raw_mutex);
         return err;
 }
 
@@ -99,14 +100,14 @@ static int raw_release(struct inode *inode, struct file *filp)
         const int minor= iminor(inode);
         struct block_device *bdev;
 
-        down(&raw_mutex);
+        mutex_lock(&raw_mutex);
         bdev = raw_devices[minor].binding;
         if (--raw_devices[minor].inuse == 0) {
                 /* Here  inode->i_mapping == bdev->bd_inode->i_mapping  */
                 inode->i_mapping = &inode->i_data;
                 inode->i_mapping->backing_dev_info = &default_backing_dev_info;
         }
-        up(&raw_mutex);
+        mutex_unlock(&raw_mutex);
 
         bd_release(bdev);
         blkdev_put(bdev);
@@ -187,9 +188,9 @@ static int raw_ctl_ioctl(struct inode *inode, struct file *filp,
                                 goto out;
                         }
 
-                        down(&raw_mutex);
+                        mutex_lock(&raw_mutex);
                         if (rawdev->inuse) {
-                                up(&raw_mutex);
+                                mutex_unlock(&raw_mutex);
                                 err = -EBUSY;
                                 goto out;
                         }
@@ -211,11 +212,11 @@ static int raw_ctl_ioctl(struct inode *inode, struct file *filp,
                                         bind_device(&rq);
                                 }
                         }
-                        up(&raw_mutex);
+                        mutex_unlock(&raw_mutex);
                 } else {
                         struct block_device *bdev;
 
-                        down(&raw_mutex);
+                        mutex_lock(&raw_mutex);
                         bdev = rawdev->binding;
                         if (bdev) {
                                 rq.block_major = MAJOR(bdev->bd_dev);
@@ -223,7 +224,7 @@ static int raw_ctl_ioctl(struct inode *inode, struct file *filp,
                         } else {
                                 rq.block_major = rq.block_minor = 0;
                         }
-                        up(&raw_mutex);
+                        mutex_unlock(&raw_mutex);
                         if (copy_to_user((void __user *)arg, &rq, sizeof(rq))) {
                                 err = -EFAULT;
                                 goto out;
diff --git a/drivers/char/rio/Makefile b/drivers/char/rio/Makefile
index bce2bd1204..2d1c5a7cba 100644
--- a/drivers/char/rio/Makefile
+++ b/drivers/char/rio/Makefile
@@ -9,4 +9,4 @@
 obj-$(CONFIG_RIO) += rio.o
 
 rio-objs := rio_linux.o rioinit.o rioboot.o riocmd.o rioctrl.o riointr.o \
-            rioparam.o riopcicopy.o rioroute.o riotable.o riotty.o
+            rioparam.o rioroute.o riotable.o riotty.o
diff --git a/drivers/char/rio/board.h b/drivers/char/rio/board.h
index 29c9802040..bdea633a90 100644
--- a/drivers/char/rio/board.h
+++ b/drivers/char/rio/board.h
@@ -33,10 +33,6 @@
 #ifndef __rio_board_h__
 #define __rio_board_h__
 
-#ifdef SCCS_LABELS
-static char *_board_h_sccs_ = "@(#)board.h      1.2";
-#endif
-
 /*
 ** board.h contains the definitions for the *hardware* of the host cards.
 ** It describes the memory overlay for the dual port RAM area.
@@ -53,29 +49,29 @@ static char *_board_h_sccs_ = "@(#)board.h	1.2";
 **      The shape of the Host Control area, at offset 0x7C00, Write Only
 */
 struct s_Ctrl {
-        BYTE DpCtl;             /* 7C00 */
-        BYTE Dp_Unused2_[127];
-        BYTE DpIntSet;          /* 7C80 */
-        BYTE Dp_Unused3_[127];
-        BYTE DpTpuReset;        /* 7D00 */
-        BYTE Dp_Unused4_[127];
-        BYTE DpIntReset;        /* 7D80 */
-        BYTE Dp_Unused5_[127];
+        u8 DpCtl;               /* 7C00 */
+        u8 Dp_Unused2_[127];
+        u8 DpIntSet;            /* 7C80 */
+        u8 Dp_Unused3_[127];
+        u8 DpTpuReset;  /* 7D00 */
+        u8 Dp_Unused4_[127];
+        u8 DpIntReset;  /* 7D80 */
+        u8 Dp_Unused5_[127];
 };
 
 /*
 ** The PROM data area on the host (0x7C00), Read Only
 */
 struct s_Prom {
-        WORD DpSlxCode[2];
-        WORD DpRev;
-        WORD Dp_Unused6_;
-        WORD DpUniq[4];
-        WORD DpJahre;
-        WORD DpWoche;
-        WORD DpHwFeature[5];
-        WORD DpOemId;
-        WORD DpSiggy[16];
+        u16 DpSlxCode[2];
+        u16 DpRev;
+        u16 Dp_Unused6_;
+        u16 DpUniq[4];
+        u16 DpJahre;
+        u16 DpWoche;
+        u16 DpHwFeature[5];
+        u16 DpOemId;
+        u16 DpSiggy[16];
 };
 
 /*
@@ -90,19 +86,19 @@ union u_CtrlProm {		/* This is the control/PROM area (0x7C00) */
 ** The top end of memory!
 */
 struct s_ParmMapS {             /* Area containing Parm Map Pointer */
-        BYTE Dp_Unused8_[DP_PARMMAP_ADDR];
-        WORD DpParmMapAd;
+        u8 Dp_Unused8_[DP_PARMMAP_ADDR];
+        u16 DpParmMapAd;
 };
 
 struct s_StartUpS {
-        BYTE Dp_Unused9_[DP_STARTUP_ADDR];
-        BYTE Dp_LongJump[0x4];
-        BYTE Dp_Unused10_[2];
-        BYTE Dp_ShortJump[0x2];
+        u8 Dp_Unused9_[DP_STARTUP_ADDR];
+        u8 Dp_LongJump[0x4];
+        u8 Dp_Unused10_[2];
+        u8 Dp_ShortJump[0x2];
 };
 
 union u_Sram2ParmMap {          /* This is the top of memory (0x7E00-0x7FFF) */
-        BYTE DpSramMem[DP_SRAM2_SIZE];
+        u8 DpSramMem[DP_SRAM2_SIZE];
         struct s_ParmMapS DpParmMapS;
         struct s_StartUpS DpStartUpS;
 };
@@ -111,11 +107,11 @@ union u_Sram2ParmMap {		/* This is the top of memory (0x7E00-0x7FFF) */
 **      This is the DP RAM overlay.
 */
 struct DpRam {
-        BYTE DpSram1[DP_SRAM1_SIZE];    /* 0000 - 7BFF */
+        u8 DpSram1[DP_SRAM1_SIZE];      /* 0000 - 7BFF */
         union u_CtrlProm DpCtrlProm;    /* 7C00 - 7DFF */
         union u_Sram2ParmMap DpSram2ParmMap;    /* 7E00 - 7FFF */
-        BYTE DpScratch[DP_SCRATCH_SIZE];        /* 8000 - 8FFF */
-        BYTE DpSram3[DP_SRAM3_SIZE];    /* 9000 - FFFF */
+        u8 DpScratch[DP_SCRATCH_SIZE];  /* 8000 - 8FFF */
+        u8 DpSram3[DP_SRAM3_SIZE];      /* 9000 - FFFF */
 };
 
 #define DpControl       DpCtrlProm.DpCtrl.DpCtl
diff --git a/drivers/char/rio/bootpkt.h b/drivers/char/rio/bootpkt.h
deleted file mode 100644
index 602266e0c0..0000000000
--- a/drivers/char/rio/bootpkt.h
+++ /dev/null
@@ -1,61 +0,0 @@
-
-
-/****************************************************************************
- *******                                                              *******
- *******        B O O T    P A C K E T   H E A D E R   F I L E
- *******                                                              *******
- ****************************************************************************
-
- Author  : Ian Nandhra
- Date    :
-
- *
- *  (C) 1990 - 2000 Specialix International Ltd., Byfleet, Surrey, UK.
- *
- *      This program is free software; you can redistribute it and/or modify
- *      it under the terms of the GNU General Public License as published by
- *      the Free Software Foundation; either version 2 of the License, or
- *      (at your option) any later version.
- *
- *      This program is distributed in the hope that it will be useful,
- *      but WITHOUT ANY WARRANTY; without even the implied warranty of
- *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *      GNU General Public License for more details.
- *
- *      You should have received a copy of the GNU General Public License
- *      along with this program; if not, write to the Free Software
- *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
- Version : 0.01
-
-
-                            Mods
- ----------------------------------------------------------------------------
-  Date     By                Description
- ----------------------------------------------------------------------------
-
- ***************************************************************************/
-
-#ifndef _pkt_h
-#define _pkt_h 1
-
-#ifndef lint
-#ifdef SCCS
-static char *_rio_bootpkt_h_sccs = "@(#)bootpkt.h       1.1";
-#endif
-#endif
-
-    /*************************************************
-     * Overlayed onto the Data fields of a regular
-     * Packet
-     ************************************************/
-typedef struct BOOT_PKT BOOT_PKT;
-struct BOOT_PKT {
-        short seq_num;
-        char data[10];
-};
-
-
-#endif
-
-/*********** end of file ***********/
diff --git a/drivers/char/rio/cirrus.h b/drivers/char/rio/cirrus.h
index 89bd94eb45..f4f837f868 100644
--- a/drivers/char/rio/cirrus.h
+++ b/drivers/char/rio/cirrus.h
@@ -40,73 +40,7 @@
 #endif
 #define _cirrus_h 1
 
-
-
-/* Bit fields for particular registers */
-
-/* GCR */
-#define GCR_SERIAL      0x00    /* Configure as serial channel */
-#define GCR_PARALLEL    0x80    /* Configure as parallel channel */
-
-/* RDSR - when status read from FIFO */
-#define RDSR_BREAK              0x08    /* Break received */
-#define RDSR_TIMEOUT            0x80    /* No new data timeout */
-#define RDSR_SC1                0x10    /* Special char 1 (tx XON) matched */
-#define RDSR_SC2                0x20    /* Special char 2 (tx XOFF) matched */
-#define RDSR_SC12_MASK          0x30    /* Mask for special chars 1 and 2 */
-
-/* PPR */
-#define PPR_DEFAULT     0x31    /* Default value - for a 25Mhz clock gives
-                                   a timeout period of 1ms */
-
-/* LIVR */
-#define LIVR_EXCEPTION  0x07    /* Receive exception interrupt */
-
-/* CCR */
-#define CCR_RESET       0x80    /* Reset channel */
-#define CCR_CHANGE      0x4e    /* COR's have changed - NB always change all
-                                   COR's */
-#define CCR_WFLUSH      0x82    /* Flush transmit FIFO and TSR / THR */
-
-#define CCR_SENDSC1     0x21    /* Send special character one */
-#define CCR_SENDSC2     0x22    /* Send special character two */
-#define CCR_SENDSC3     0x23    /* Send special character three */
-#define CCR_SENDSC4     0x24    /* Send special character four */
-
-#define CCR_TENABLE     0x18    /* Enable transmitter */
-#define CCR_TDISABLE    0x14    /* Disable transmitter */
-#define CCR_RENABLE     0x12    /* Enable receiver */
-#define CCR_RDISABLE    0x11    /* Disable receiver */
-
-#define CCR_READY       0x00    /* CCR is ready for another command */
-
-/* CCSR */
-#define CCSR_TXENABLE   0x08    /* Transmitter enable */
-#define CCSR_RXENABLE   0x80    /* Receiver enable */
-#define CCSR_TXFLOWOFF  0x04    /* Transmit flow off */
-#define CCSR_TXFLOWON   0x02    /* Transmit flow on */
-
-/* SVRR */
-#define SVRR_RECEIVE    0x01    /* Receive interrupt pending */
-#define SVRR_TRANSMIT   0x02    /* Transmit interrupt pending */
-#define SVRR_MODEM      0x04    /* Modem interrupt pending */
-
-/* CAR */
-#define CAR_PORTS       0x03    /* Bit fields for ports */
-
-/* IER */
-#define IER_MODEM       0x80    /* Change in modem status */
-#define IER_RECEIVE     0x10    /* Good data / data exception */
-#define IER_TRANSMITR   0x04    /* Transmit ready (FIFO empty) */
-#define IER_TRANSMITE   0x02    /* Transmit empty */
-#define IER_TIMEOUT     0x01    /* Timeout on no data */
-
-#define IER_DEFAULT     0x94    /* Default values */
-#define IER_PARALLEL    0x84    /* Default for Parallel */
-#define IER_EMPTY       0x92    /* Transmitter empty rather than ready */
-
-/* COR1 - Driver only */
-#define COR1_INPCK      0x10    /* Check parity of received characters */
+/* Bit fields for particular registers shared with driver */
 
 /* COR1 - driver and RTA */
 #define COR1_ODD        0x80    /* Odd parity */
@@ -222,35 +156,6 @@
 
 #define MSVR1_HOST      0xf3    /* The bits the host wants */
 
-/* MSVR2 */
-#define MSVR2_DSR       0x02    /* DSR output pin (DTR on Cirrus) */
-
-/* MCOR */
-#define MCOR_CD         0x80    /* CD (DSR on Cirrus) */
-#define MCOR_RTS        0x40    /* RTS (CTS on Cirrus) */
-#define MCOR_RI         0x20    /* RI */
-#define MCOR_DTR        0x10    /* DTR (CD on Cirrus) */
-
-#define MCOR_DEFAULT    (MCOR_CD | MCOR_RTS | MCOR_RI | MCOR_DTR)
-#define MCOR_FULLMODEM  MCOR_DEFAULT
-#define MCOR_RJ45       (MCOR_CD | MCOR_RTS | MCOR_DTR)
-#define MCOR_RESTRICTED (MCOR_CD | MCOR_RTS)
-
-/* More MCOR - H/W Handshake (flowcontrol) stuff */
-#define MCOR_THRESH8    0x08    /* eight characters then we stop */
-#define MCOR_THRESH9    0x09    /* nine characters then we stop */
-#define MCOR_THRESH10   0x0A    /* ten characters then we stop */
-#define MCOR_THRESH11   0x0B    /* eleven characters then we stop */
-
-#define MCOR_THRESHBITS 0x0F    /* mask for ANDing out the above */
-
-#define MCOR_THRESHOLD  MCOR_THRESH9    /* MUST BE GREATER THAN COR3_THRESHOLD */
-
-
-/* RTPR */
-#define RTPR_DEFAULT    0x02    /* Default */
-
-
 /* Defines for the subscripts of a CONFIG packet */
 #define CONFIG_COR1     1       /* Option register 1 */
 #define CONFIG_COR2     2       /* Option register 2 */
@@ -264,19 +169,6 @@
 #define CONFIG_TXBAUD   10      /* Tx baud rate */
 #define CONFIG_RXBAUD   11      /* Rx baud rate */
 
-/* Port status stuff */
-#define IDLE_CLOSED     0       /* Closed */
-#define IDLE_OPEN       1       /* Idle open */
-#define IDLE_BREAK      2       /* Idle on break */
-
-/* Subscript of MODEM STATUS packet */
-#define MODEM_VALUE     3       /* Current values of handshake pins */
-/* Subscript of SBREAK packet */
-#define BREAK_LENGTH    1       /* Length of a break in slices of 0.01 seconds
-                                   0 = stay on break until an EBREAK command
-                                   is sent */
-
-
 #define PRE_EMPTIVE     0x80    /* Pre-emptive bit in command field */
 
 /* Packet types going from Host to remote - with the exception of OPEN, MOPEN,
diff --git a/drivers/char/rio/cmdblk.h b/drivers/char/rio/cmdblk.h
index a9a8c45631..c46b2fdb66 100644
--- a/drivers/char/rio/cmdblk.h
+++ b/drivers/char/rio/cmdblk.h
@@ -48,10 +48,10 @@ struct CmdBlk {
         struct CmdBlk *NextP;   /* Pointer to next command block */
         struct PKT Packet;      /* A packet, to copy to the rup */
         /* The func to call to check if OK */
-        int (*PreFuncP) (int, struct CmdBlk *);
+        int (*PreFuncP) (unsigned long, struct CmdBlk *);
         int PreArg;             /* The arg for the func */
         /* The func to call when completed */
-        int (*PostFuncP) (int, struct CmdBlk *);
+        int (*PostFuncP) (unsigned long, struct CmdBlk *);
         int PostArg;            /* The arg for the func */
 };
 
diff --git a/drivers/char/rio/cmdpkt.h b/drivers/char/rio/cmdpkt.h
index 77cee8df68..357ae57224 100644
--- a/drivers/char/rio/cmdpkt.h
+++ b/drivers/char/rio/cmdpkt.h
@@ -55,24 +55,24 @@ static char *_cmdpkt_h_sccs_ = "@(#)cmdpkt.h	1.2";
 ** at Data[2] in the actual pkt!
 */
 struct BootSequence {
-        WORD NumPackets;
-        WORD LoadBase;
-        WORD CodeSize;
+        u16 NumPackets;
+        u16 LoadBase;
+        u16 CodeSize;
 };
 
 #define BOOT_SEQUENCE_LEN       8
 
 struct SamTop {
-        BYTE Unit;
-        BYTE Link;
+        u8 Unit;
+        u8 Link;
 };
 
 struct CmdHdr {
-        BYTE PcCommand;
+        u8 PcCommand;
         union {
-                BYTE PcPhbNum;
-                BYTE PcLinkNum;
-                BYTE PcIDNum;
+                u8 PcPhbNum;
+                u8 PcLinkNum;
+                u8 PcIDNum;
         } U0;
 };
 
@@ -84,28 +84,28 @@ struct PktCmd {
                         struct BootSequence PcBootSequence;
                 } S1;
                 struct {
-                        WORD PcSequence;
-                        BYTE PcBootData[RTA_BOOT_DATA_SIZE];
+                        u16 PcSequence;
+                        u8 PcBootData[RTA_BOOT_DATA_SIZE];
                 } S2;
                 struct {
-                        WORD __crud__;
-                        BYTE PcUniqNum[4];      /* this is really a uint. */
-                        BYTE PcModuleTypes;     /* what modules are fitted */
+                        u16 __crud__;
+                        u8 PcUniqNum[4];        /* this is really a uint. */
+                        u8 PcModuleTypes;       /* what modules are fitted */
                 } S3;
                 struct {
                         struct CmdHdr CmdHdr;
-                        BYTE __undefined__;
-                        BYTE PcModemStatus;
-                        BYTE PcPortStatus;
-                        BYTE PcSubCommand;      /* commands like mem or register dump */
-                        WORD PcSubAddr; /* Address for command */
-                        BYTE PcSubData[64];     /* Date area for command */
+                        u8 __undefined__;
+                        u8 PcModemStatus;
+                        u8 PcPortStatus;
+                        u8 PcSubCommand;        /* commands like mem or register dump */
+                        u16 PcSubAddr;  /* Address for command */
+                        u8 PcSubData[64];       /* Date area for command */
                 } S4;
                 struct {
                         struct CmdHdr CmdHdr;
-                        BYTE PcCommandText[1];
-                        BYTE __crud__[20];
-                        BYTE PcIDNum2;  /* It had to go somewhere! */
+                        u8 PcCommandText[1];
+                        u8 __crud__[20];
+                        u8 PcIDNum2;    /* It had to go somewhere! */
                 } S5;
                 struct {
                         struct CmdHdr CmdHdr;
@@ -118,45 +118,45 @@ struct PktCmd_M {
         union {
                 struct {
                         struct {
-                                uchar PcCommand;
+                                u8 PcCommand;
                                 union {
-                                        uchar PcPhbNum;
-                                        uchar PcLinkNum;
-                                        uchar PcIDNum;
+                                        u8 PcPhbNum;
+                                        u8 PcLinkNum;
+                                        u8 PcIDNum;
                                 } U0;
                         } CmdHdr;
                         struct {
-                                ushort NumPackets;
-                                ushort LoadBase;
-                                ushort CodeSize;
+                                u16 NumPackets;
+                                u16 LoadBase;
+                                u16 CodeSize;
                         } PcBootSequence;
                 } S1;
                 struct {
-                        ushort PcSequence;
-                        uchar PcBootData[RTA_BOOT_DATA_SIZE];
+                        u16 PcSequence;
+                        u8 PcBootData[RTA_BOOT_DATA_SIZE];
                 } S2;
                 struct {
-                        ushort __crud__;
-                        uchar PcUniqNum[4];     /* this is really a uint. */
-                        uchar PcModuleTypes;    /* what modules are fitted */
+                        u16 __crud__;
+                        u8 PcUniqNum[4];        /* this is really a uint. */
+                        u8 PcModuleTypes;       /* what modules are fitted */
                 } S3;
                 struct {
-                        ushort __cmd_hdr__;
-                        uchar __undefined__;
-                        uchar PcModemStatus;
-                        uchar PcPortStatus;
-                        uchar PcSubCommand;
-                        ushort PcSubAddr;
-                        uchar PcSubData[64];
+                        u16 __cmd_hdr__;
+                        u8 __undefined__;
+                        u8 PcModemStatus;
+                        u8 PcPortStatus;
+                        u8 PcSubCommand;
+                        u16 PcSubAddr;
+                        u8 PcSubData[64];
                 } S4;
                 struct {
-                        ushort __cmd_hdr__;
-                        uchar PcCommandText[1];
-                        uchar __crud__[20];
-                        uchar PcIDNum2; /* Tacked on end */
+                        u16 __cmd_hdr__;
+                        u8 PcCommandText[1];
+                        u8 __crud__[20];
+                        u8 PcIDNum2;    /* Tacked on end */
                 } S5;
                 struct {
-                        ushort __cmd_hdr__;
+                        u16 __cmd_hdr__;
                         struct Top Topology[LINKS_PER_UNIT];
                 } S6;
         } U1;
diff --git a/drivers/char/rio/control.h b/drivers/char/rio/control.h
deleted file mode 100644
index 6853d03304..0000000000
--- a/drivers/char/rio/control.h
+++ /dev/null
@@ -1,61 +0,0 @@
-
-
-/****************************************************************************
- *******                                                              *******
- *******           C O N T R O L   P A C K E T   H E A D E R S
- *******                                                              *******
- ****************************************************************************
-
- Author  : Jon Brawn
- Date    :
-
- *
- *  (C) 1990 - 2000 Specialix International Ltd., Byfleet, Surrey, UK.
- *
- *      This program is free software; you can redistribute it and/or modify
- *      it under the terms of the GNU General Public License as published by
- *      the Free Software Foundation; either version 2 of the License, or
- *      (at your option) any later version.
- *
- *      This program is distributed in the hope that it will be useful,
- *      but WITHOUT ANY WARRANTY; without even the implied warranty of
- *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *      GNU General Public License for more details.
- *
- *      You should have received a copy of the GNU General Public License
- *      along with this program; if not, write to the Free Software
- *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
- Version : 0.01
-
-
-                            Mods
- ----------------------------------------------------------------------------
-  Date     By                Description
- ----------------------------------------------------------------------------
-
- ***************************************************************************/
-
-
-#ifndef _control_h
-#define _control_h
-
-#ifndef lint
-/* static char *_rio_control_h_sccs = "@(#)control.h    1.4"; */
-#endif
-
-#define CONTROL         '^'
-#define IFOAD           ( CONTROL + 1 )
-#define IDENTIFY        ( CONTROL + 2 )
-#define ZOMBIE          ( CONTROL + 3 )
-#define UFOAD           ( CONTROL + 4 )
-#define IWAIT           ( CONTROL + 5 )
-
-#define IFOAD_MAGIC     0xF0AD  /* of course */
-#define ZOMBIE_MAGIC    (~0xDEAD)       /* not dead -> zombie */
-#define UFOAD_MAGIC     0xD1E   /* kill-your-neighbour */
-#define IWAIT_MAGIC     0xB1DE  /* Bide your time */
-
-#endif
-
-/*********** end of file ***********/
diff --git a/drivers/char/rio/daemon.h b/drivers/char/rio/daemon.h
index 28a991bd4f..5818a8aa46 100644
--- a/drivers/char/rio/daemon.h
+++ b/drivers/char/rio/daemon.h
@@ -45,15 +45,15 @@ static char *_daemon_h_sccs_ = "@(#)daemon.h	1.3";
 */
 
 struct Error {
-        uint Error;
-        uint Entry;
-        uint Other;
+        unsigned int Error;
+        unsigned int Entry;
+        unsigned int Other;
 };
 
 struct DownLoad {
         char *DataP;
-        uint Count;
-        uint ProductCode;
+        unsigned int Count;
+        unsigned int ProductCode;
 };
 
 /*
@@ -68,69 +68,64 @@ struct DownLoad {
 #endif
 
 struct PortSetup {
-        uint From;              /* Set/Clear XP & IXANY Control from this port.... */
-        uint To;                /* .... to this port */
-        uint XpCps;             /* at this speed */
+        unsigned int From;              /* Set/Clear XP & IXANY Control from this port.... */
+        unsigned int To;                /* .... to this port */
+        unsigned int XpCps;             /* at this speed */
         char XpOn[MAX_XP_CTRL_LEN];     /* this is the start string */
         char XpOff[MAX_XP_CTRL_LEN];    /* this is the stop string */
-        uchar IxAny;            /* enable/disable IXANY */
-        uchar IxOn;             /* enable/disable IXON */
-        uchar Lock;             /* lock port params */
-        uchar Store;            /* store params across closes */
-        uchar Drain;            /* close only when drained */
+        u8 IxAny;                       /* enable/disable IXANY */
+        u8 IxOn;                        /* enable/disable IXON */
+        u8 Lock;                        /* lock port params */
+        u8 Store;                       /* store params across closes */
+        u8 Drain;                       /* close only when drained */
 };
 
 struct LpbReq {
-        uint Host;
-        uint Link;
+        unsigned int Host;
+        unsigned int Link;
         struct LPB *LpbP;
 };
 
 struct RupReq {
-        uint HostNum;
-        uint RupNum;
+        unsigned int HostNum;
+        unsigned int RupNum;
         struct RUP *RupP;
 };
 
 struct PortReq {
-        uint SysPort;
+        unsigned int SysPort;
         struct Port *PortP;
 };
 
 struct StreamInfo {
-        uint SysPort;
-#if 0
-        queue_t RQueue;
-        queue_t WQueue;
-#else
+        unsigned int SysPort;
         int RQueue;
         int WQueue;
-#endif
 };
 
 struct HostReq {
-        uint HostNum;
+        unsigned int HostNum;
         struct Host *HostP;
 };
 
 struct HostDpRam {
-        uint HostNum;
+        unsigned int HostNum;
         struct DpRam *DpRamP;
 };
 
 struct DebugCtrl {
-        uint SysPort;
-        uint Debug;
-        uint Wait;
+        unsigned int SysPort;
+        unsigned int Debug;
+        unsigned int Wait;
 };
 
 struct MapInfo {
-        uint FirstPort;         /* 8 ports, starting from this (tty) number */
-        uint RtaUnique;         /* reside on this RTA (unique number) */
+        unsigned int FirstPort;         /* 8 ports, starting from this (tty) number */
+        unsigned int RtaUnique;         /* reside on this RTA (unique number) */
 };
 
 struct MapIn {
-        uint NumEntries;        /* How many port sets are we mapping? */
+        unsigned int NumEntries;        /* How many port sets are we mapping? */
         struct MapInfo *MapInfoP;       /* Pointer to (user space) info */
 };
 
@@ -147,13 +142,13 @@ struct SpecialRupCmd {
 };
 
 struct IdentifyRta {
-        ulong RtaUnique;
-        uchar ID;
+        unsigned long RtaUnique;
+        u8 ID;
 };
 
 struct KillNeighbour {
-        ulong UniqueNum;
-        uchar Link;
+        unsigned long UniqueNum;
+        u8 Link;
 };
 
 struct rioVersion {
diff --git a/drivers/char/rio/defaults.h b/drivers/char/rio/defaults.h
deleted file mode 100644
index d55c2f6a98..0000000000
--- a/drivers/char/rio/defaults.h
+++ /dev/null
@@ -1,51 +0,0 @@
-
-/****************************************************************************
- *******                                                              *******
- *******                     D E F A U L T S
- *******                                                              *******
- ****************************************************************************
-
- Author  : Ian Nandhra
- Date    :
-
- *
- *  (C) 1990 - 2000 Specialix International Ltd., Byfleet, Surrey, UK.
- *
- *      This program is free software; you can redistribute it and/or modify
- *      it under the terms of the GNU General Public License as published by
- *      the Free Software Foundation; either version 2 of the License, or
- *      (at your option) any later version.
- *
- *      This program is distributed in the hope that it will be useful,
- *      but WITHOUT ANY WARRANTY; without even the implied warranty of
- *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *      GNU General Public License for more details.
- *
- *      You should have received a copy of the GNU General Public License
- *      along with this program; if not, write to the Free Software
- *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
- Version : 0.01
-
-
-                            Mods
- ----------------------------------------------------------------------------
-  Date     By                Description
- ----------------------------------------------------------------------------
-
- ***************************************************************************/
-
-#ifndef lint
-#ifdef SCCS
-static char *_rio_defaults_h_sccs = "@(#)defaults.h     1.1";
-#endif
-#endif
-
-
-#define MILLISECOND           (int) (1000/64)   /* 15.625 low ticks */
-#define SECOND                (int) 15625       /* Low priority ticks */
-
-#define LINK_TIMEOUT          (int) (POLL_PERIOD / 2)
-
-
-/*********** end of file ***********/
diff --git a/drivers/char/rio/error.h b/drivers/char/rio/error.h
deleted file mode 100644
index f20f0789db..0000000000
--- a/drivers/char/rio/error.h
+++ /dev/null
@@ -1,82 +0,0 @@
-
-/****************************************************************************
- *******                                                              *******
- *******     E R R O R  H E A D E R   F I L E
- *******                                                              *******
- ****************************************************************************
-
- Author  : Ian Nandhra
- Date    :
-
- *
- *  (C) 1990 - 2000 Specialix International Ltd., Byfleet, Surrey, UK.
- *
- *      This program is free software; you can redistribute it and/or modify
- *      it under the terms of the GNU General Public License as published by
- *      the Free Software Foundation; either version 2 of the License, or
- *      (at your option) any later version.
- *
- *      This program is distributed in the hope that it will be useful,
- *      but WITHOUT ANY WARRANTY; without even the implied warranty of
- *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *      GNU General Public License for more details.
- *
- *      You should have received a copy of the GNU General Public License
- *      along with this program; if not, write to the Free Software
- *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
- Version : 0.01
-
-
-                            Mods
- ----------------------------------------------------------------------------
-  Date     By                Description
- ----------------------------------------------------------------------------
-
- ***************************************************************************/
-
-#ifndef lint
-/* static char *_rio_error_h_sccs = "@(#)error.h        1.3"; */
-#endif
-
-#define E_NO_ERROR                       ((ushort) 0)
-#define E_PROCESS_NOT_INIT               ((ushort) 1)
-#define E_LINK_TIMEOUT                   ((ushort) 2)
-#define E_NO_ROUTE                       ((ushort) 3)
-#define E_CONFUSED                       ((ushort) 4)
-#define E_HOME                           ((ushort) 5)
-#define E_CSUM_FAIL                      ((ushort) 6)
-#define E_DISCONNECTED                   ((ushort) 7)
-#define E_BAD_RUP                        ((ushort) 8)
-#define E_NO_VIRGIN                      ((ushort) 9)
-#define E_BOOT_RUP_BUSY                  ((ushort) 10)
-
-
-
-    /*************************************************
-     * Parsed to mem_halt()
-     ************************************************/
-#define E_CHANALLOC                      ((ushort) 0x80)
-#define E_POLL_ALLOC                     ((ushort) 0x81)
-#define E_LTTWAKE                        ((ushort) 0x82)
-#define E_LTT_ALLOC                      ((ushort) 0x83)
-#define E_LRT_ALLOC                      ((ushort) 0x84)
-#define E_CIRRUS                         ((ushort) 0x85)
-#define E_MONITOR                        ((ushort) 0x86)
-#define E_PHB_ALLOC                      ((ushort) 0x87)
-#define E_ARRAY_ALLOC                    ((ushort) 0x88)
-#define E_QBUF_ALLOC                     ((ushort) 0x89)
-#define E_PKT_ALLOC                      ((ushort) 0x8a)
-#define E_GET_TX_Q_BUF                   ((ushort) 0x8b)
-#define E_GET_RX_Q_BUF                   ((ushort) 0x8c)
-#define E_MEM_OUT                        ((ushort) 0x8d)
-#define E_MMU_INIT                       ((ushort) 0x8e)
-#define E_LTT_INIT                       ((ushort) 0x8f)
-#define E_LRT_INIT                       ((ushort) 0x90)
-#define E_LINK_RUN                       ((ushort) 0x91)
-#define E_MONITOR_ALLOC                  ((ushort) 0x92)
-#define E_MONITOR_INIT                   ((ushort) 0x93)
-#define E_POLL_INIT                      ((ushort) 0x94)
-
-
-/*********** end of file ***********/
diff --git a/drivers/char/rio/func.h b/drivers/char/rio/func.h
index b4778410ec..e64fe99123 100644
--- a/drivers/char/rio/func.h
+++ b/drivers/char/rio/func.h
@@ -43,35 +43,33 @@ static char *_func_h_sccs_ = "@(#)func.h	1.3";
 
 /* rioboot.c */
 int RIOBootCodeRTA(struct rio_info *, struct DownLoad *);
-int RIOBootCodeHOST(struct rio_info *, register struct DownLoad *);
+int RIOBootCodeHOST(struct rio_info *, struct DownLoad *);
 int RIOBootCodeUNKNOWN(struct rio_info *, struct DownLoad *);
 void msec_timeout(struct Host *);
-int RIOBootRup(struct rio_info *, uint, struct Host *, struct PKT *);
-int RIOBootOk(struct rio_info *, struct Host *, ulong);
-int RIORtaBound(struct rio_info *, uint);
-void FillSlot(int, int, uint, struct Host *);
+int RIOBootRup(struct rio_info *, unsigned int, struct Host *, struct PKT *);
+int RIOBootOk(struct rio_info *, struct Host *, unsigned long);
+int RIORtaBound(struct rio_info *, unsigned int);
+void rio_fill_host_slot(int, int, unsigned int, struct Host *);
 
 /* riocmd.c */
 int RIOFoadRta(struct Host *, struct Map *);
 int RIOZombieRta(struct Host *, struct Map *);
-int RIOCommandRta(struct rio_info *, uint, int (*func) (struct Host *, struct Map *));
-int RIOIdentifyRta(struct rio_info *, caddr_t);
-int RIOKillNeighbour(struct rio_info *, caddr_t);
+int RIOCommandRta(struct rio_info *, unsigned long, int (*func) (struct Host *, struct Map *));
+int RIOIdentifyRta(struct rio_info *, void *);
+int RIOKillNeighbour(struct rio_info *, void *);
 int RIOSuspendBootRta(struct Host *, int, int);
 int RIOFoadWakeup(struct rio_info *);
 struct CmdBlk *RIOGetCmdBlk(void);
 void RIOFreeCmdBlk(struct CmdBlk *);
-int RIOQueueCmdBlk(struct Host *, uint, struct CmdBlk *);
+int RIOQueueCmdBlk(struct Host *, unsigned int, struct CmdBlk *);
 void RIOPollHostCommands(struct rio_info *, struct Host *);
-int RIOWFlushMark(int, struct CmdBlk *);
-int RIORFlushEnable(int, struct CmdBlk *);
-int RIOUnUse(int, struct CmdBlk *);
-void ShowPacket(uint, struct PKT *);
+int RIOWFlushMark(unsigned long, struct CmdBlk *);
+int RIORFlushEnable(unsigned long, struct CmdBlk *);
+int RIOUnUse(unsigned long, struct CmdBlk *);
 
 /* rioctrl.c */
-int copyin(int, caddr_t, int);
 int riocontrol(struct rio_info *, dev_t, int, caddr_t, int);
-int RIOPreemptiveCmd(struct rio_info *, struct Port *, uchar);
+int RIOPreemptiveCmd(struct rio_info *, struct Port *, unsigned char);
 
 /* rioinit.c */
 void rioinit(struct rio_info *, struct RioHostInfo *);
@@ -80,19 +78,17 @@ void RIOISAinit(struct rio_info *, int);
 int RIODoAT(struct rio_info *, int, int);
 caddr_t RIOCheckForATCard(int);
 int RIOAssignAT(struct rio_info *, int, caddr_t, int);
-int RIOBoardTest(paddr_t, caddr_t, uchar, int);
+int RIOBoardTest(unsigned long, caddr_t, unsigned char, int);
 void RIOAllocDataStructs(struct rio_info *);
 void RIOSetupDataStructs(struct rio_info *);
-int RIODefaultName(struct rio_info *, struct Host *, uint);
+int RIODefaultName(struct rio_info *, struct Host *, unsigned int);
 struct rioVersion *RIOVersid(void);
-int RIOMapin(paddr_t, int, caddr_t *);
-void RIOMapout(paddr_t, long, caddr_t);
-void RIOHostReset(uint, volatile struct DpRam *, uint);
+void RIOHostReset(unsigned int, struct DpRam *, unsigned int);
 
 /* riointr.c */
 void RIOTxEnable(char *);
 void RIOServiceHost(struct rio_info *, struct Host *, int);
-int riotproc(struct rio_info *, register struct ttystatics *, int, int);
+int riotproc(struct rio_info *, struct ttystatics *, int, int);
 
 /* rioparam.c */
 int RIOParam(struct Port *, int, int, int);
@@ -106,18 +102,18 @@ int can_remove_receive(struct PKT **, struct Port *);
 void remove_receive(struct Port *);
 
 /* rioroute.c */
-int RIORouteRup(struct rio_info *, uint, struct Host *, struct PKT *);
-void RIOFixPhbs(struct rio_info *, struct Host *, uint);
-uint GetUnitType(uint);
+int RIORouteRup(struct rio_info *, unsigned int, struct Host *, struct PKT *);
+void RIOFixPhbs(struct rio_info *, struct Host *, unsigned int);
+unsigned int GetUnitType(unsigned int);
 int RIOSetChange(struct rio_info *);
-int RIOFindFreeID(struct rio_info *, struct Host *, uint *, uint *);
+int RIOFindFreeID(struct rio_info *, struct Host *, unsigned int *, unsigned int *);
 
 
 /* riotty.c */
 
 int riotopen(struct tty_struct *tty, struct file *filp);
 int riotclose(void *ptr);
-int riotioctl(struct rio_info *, struct tty_struct *, register int, register caddr_t);
+int riotioctl(struct rio_info *, struct tty_struct *, int, caddr_t);
 void ttyseth(struct Port *, struct ttystatics *, struct old_sgttyb *sg);
 
 /* riotable.c */
@@ -131,7 +127,7 @@ int RIOChangeName(struct rio_info *, struct Map *);
 #if 0
 /* riodrvr.c */
 struct rio_info *rio_install(struct RioHostInfo *);
-int rio_uninstall(register struct rio_info *);
+int rio_uninstall(struct rio_info *);
 int rio_open(struct rio_info *, int, struct file *);
 int rio_close(struct rio_info *, struct file *);
 int rio_read(struct rio_info *, struct file *, char *, int);
@@ -143,7 +139,7 @@ int rio_isr_thread(char *);
 struct rio_info *rio_info_store(int cmd, struct rio_info *p);
 #endif
 
-extern int rio_pcicopy(char *src, char *dst, int n);
+extern void rio_copy_to_card(void *to, void *from, int len);
 extern int rio_minor(struct tty_struct *tty);
 extern int rio_ismodem(struct tty_struct *tty);
 
diff --git a/drivers/char/rio/host.h b/drivers/char/rio/host.h
index f7dfcedf7d..3ec73d1a27 100644
--- a/drivers/char/rio/host.h
+++ b/drivers/char/rio/host.h
@@ -50,22 +50,20 @@ static char *_host_h_sccs_ = "@(#)host.h	1.2";
 **    the host.
 */
 struct Host {
-        uchar Type;             /* RIO_EISA, RIO_MCA, ... */
-        uchar Ivec;             /* POLLED or ivec number */
-        uchar Mode;             /* Control stuff */
-        uchar Slot;             /* Slot */
-        volatile caddr_t Caddr; /* KV address of DPRAM */
-        volatile struct DpRam *CardP;   /* KV address of DPRAM, with overlay */
-        paddr_t PaddrP;         /* Phys. address of DPRAM */
+        unsigned char Type;             /* RIO_EISA, RIO_MCA, ... */
+        unsigned char Ivec;             /* POLLED or ivec number */
+        unsigned char Mode;             /* Control stuff */
+        unsigned char Slot;             /* Slot */
+        caddr_t Caddr;                  /* KV address of DPRAM */
+        struct DpRam *CardP;            /* KV address of DPRAM, with overlay */
+        unsigned long PaddrP;           /* Phys. address of DPRAM */
         char Name[MAX_NAME_LEN];        /* The name of the host */
-        uint UniqueNum;         /* host unique number */
+        unsigned int UniqueNum;         /* host unique number */
         spinlock_t HostLock;    /* Lock structure for MPX */
-        /*struct pci_devinfo    PciDevInfo; *//* PCI Bus/Device/Function stuff */
-        /*struct lockb          HostLock;  *//* Lock structure for MPX */
-        uint WorkToBeDone;      /* set to true each interrupt */
-        uint InIntr;            /* Being serviced? */
-        uint IntSrvDone;        /* host's interrupt has been serviced */
-        int (*Copy) (caddr_t, caddr_t, int);    /* copy func */
+        unsigned int WorkToBeDone;      /* set to true each interrupt */
+        unsigned int InIntr;            /* Being serviced? */
+        unsigned int IntSrvDone;        /* host's interrupt has been serviced */
+        void (*Copy) (void *, void *, int);     /* copy func */
         struct timer_list timer;
         /*
          **               I M P O R T A N T !
@@ -74,7 +72,7 @@ struct Host {
          ** a RIO_HOST_FOAD command.
          */
 
-        ulong Flags;            /* Whats going down */
+        unsigned long Flags;                    /* Whats going down */
 #define RC_WAITING            0
 #define RC_STARTUP            1
 #define RC_RUNNING            2
@@ -88,28 +86,28 @@ struct Host {
 ** Boot mode applies to the way in which hosts in this system will
 ** boot RTAs
 */
-#define RC_BOOT_ALL           0x8       /* Boot all RTAs attached */
-#define RC_BOOT_OWN           0x10      /* Only boot RTAs bound to this system */
-#define RC_BOOT_NONE          0x20      /* Don't boot any RTAs (slave mode) */
+#define RC_BOOT_ALL           0x8               /* Boot all RTAs attached */
+#define RC_BOOT_OWN           0x10              /* Only boot RTAs bound to this system */
+#define RC_BOOT_NONE          0x20              /* Don't boot any RTAs (slave mode) */
 
         struct Top Topology[LINKS_PER_UNIT];    /* one per link */
-        struct Map Mapping[MAX_RUP];    /* Mappings for host */
-        struct PHB *PhbP;       /* Pointer to the PHB array */
-        ushort *PhbNumP;        /* Ptr to Number of PHB's */
-        struct LPB *LinkStrP;   /* Link Structure Array */
-        struct RUP *RupP;       /* Sixteen real rups here */
-        struct PARM_MAP *ParmMapP;      /* points to the parmmap */
-        uint ExtraUnits[MAX_EXTRA_UNITS];       /* unknown things */
-        uint NumExtraBooted;    /* how many of the above */
+        struct Map Mapping[MAX_RUP];            /* Mappings for host */
+        struct PHB *PhbP;                       /* Pointer to the PHB array */
+        unsigned short *PhbNumP;                /* Ptr to Number of PHB's */
+        struct LPB *LinkStrP;                   /* Link Structure Array */
+        struct RUP *RupP;                       /* Sixteen real rups here */
+        struct PARM_MAP *ParmMapP;              /* points to the parmmap */
+        unsigned int ExtraUnits[MAX_EXTRA_UNITS];       /* unknown things */
+        unsigned int NumExtraBooted;            /* how many of the above */
         /*
          ** Twenty logical rups.
          ** The first sixteen are the real Rup entries (above), the last four
          ** are the link RUPs.
          */
         struct UnixRup UnixRups[MAX_RUP + LINKS_PER_UNIT];
-        int timeout_id;         /* For calling 100 ms delays */
-        int timeout_sem;        /* For calling 100 ms delays */
-        long locks;             /* long req'd for set_bit --RR */
+        int timeout_id;                         /* For calling 100 ms delays */
+        int timeout_sem;                        /* For calling 100 ms delays */
+        long locks;                             /* long req'd for set_bit --RR */
         char ____end_marker____;
 };
 #define Control      CardP->DpControl
diff --git a/drivers/char/rio/link.h b/drivers/char/rio/link.h
index 48d68ca7f8..f3bf11a04d 100644
--- a/drivers/char/rio/link.h
+++ b/drivers/char/rio/link.h
@@ -37,38 +37,9 @@
 #ifndef _link_h
 #define _link_h 1
 
-#ifndef lint
-#ifdef SCCS_LABELS
-/* static char *_rio_link_h_sccs = "@(#)link.h  1.15"; */
-#endif
-#endif
-
-
-
 /*************************************************
  * Define the Link Status stuff
  ************************************************/
-#define LRT_ACTIVE         ((ushort) 0x01)
-#define LRT_SPARE1         ((ushort) 0x02)
-#define INTRO_RCVD         ((ushort) 0x04)
-#define FORCED_DISCONNECT  ((ushort) 0x08)
-#define LRT_SPARE2         ((ushort) 0x80)
-
-#define TOP_OF_RTA_RAM     ((ushort) 0x7000)
-#define HOST_SERIAL_POINTER (unsigned char **) (TOP_OF_RTA_RAM - 2 * sizeof (ushort))
-
-/* Flags for ltt_status */
-#define  WAITING_ACK            (ushort) 0x0001
-#define  DATA_SENT              (ushort) 0x0002
-#define  WAITING_RUP            (ushort) 0x0004
-#define  WAITING_RETRY          (ushort) 0x0008
-#define  WAITING_TOPOLOGY       (ushort) 0x0010
-#define  SEND_SYNC              (ushort) 0x0020
-#define  FOAD_THIS_LINK         (ushort) 0x0040
-#define  REQUEST_SYNC           (ushort) 0x0080
-#define  REMOTE_DYING           (ushort) 0x0100
-#define  DIE_NOW                (ushort) 0x0200
-
 /* Boot request stuff */
 #define BOOT_REQUEST       ((ushort) 0) /* Request for a boot */
 #define BOOT_ABORT         ((ushort) 1) /* Abort a boot */
@@ -76,77 +47,48 @@
                                            and load address */
 #define BOOT_COMPLETED     ((ushort) 3) /* Boot completed */
 
-/* States that a link can be in */
-#define LINK_DISCONNECTED  ((ushort) 0) /* Disconnected */
-#define LINK_BOOT1         ((ushort) 1) /* Trying to send 1st stage boot */
-#define LINK_BOOT2         ((ushort) 2) /* Trying to send 2nd stage boot */
-#define LINK_BOOT2WAIT     ((ushort) 3) /* Waiting for selftest results */
-#define LINK_BOOT3         ((ushort) 4) /* Trying to send 3rd stage boots */
-#define LINK_SYNC          ((ushort) 5) /* Syncing */
-
-#define LINK_INTRO         ((ushort) 10)        /* Introductory packet */
-#define LINK_SUPPLYID      ((ushort) 11)        /* Trying to supply an ID */
-#define LINK_TOPOLOGY      ((ushort) 12)        /* Send a topology update */
-#define LINK_REQUESTID     ((ushort) 13)        /* Waiting for an ID */
-#define LINK_CONNECTED     ((ushort) 14)        /* Connected */
-
-#define LINK_INTERCONNECT  ((ushort) 20)        /* Subnets interconnected */
-
-#define LINK_SPARE         ((ushort) 40)
-
-/*
-** Set the default timeout for link communications.
-*/
-#define LINKTIMEOUT             (400 * MILLISECOND)
-
-/*
-** LED stuff
-*/
-#define LED_SET_COLOUR(colour)
-#define LED_OR_COLOUR(colour)
-#define LED_TIMEOUT(time)
 
 struct LPB {
-        WORD link_number;       /* Link Number */
-        Channel_ptr in_ch;      /* Link In Channel */
-        Channel_ptr out_ch;     /* Link Out Channel */
-        BYTE attached_serial[4];        /* Attached serial number */
-        BYTE attached_host_serial[4];
+        u16 link_number;        /* Link Number */
+        u16 in_ch;      /* Link In Channel */
+        u16 out_ch;     /* Link Out Channel */
+        u8 attached_serial[4];  /* Attached serial number */
+        u8 attached_host_serial[4];
         /* Serial number of Host who
            booted the other end */
-        WORD descheduled;       /* Currently Descheduled */
-        WORD state;             /* Current state */
-        WORD send_poll;         /* Send a Poll Packet */
-        Process_ptr ltt_p;      /* Process Descriptor */
-        Process_ptr lrt_p;      /* Process Descriptor */
-        WORD lrt_status;        /* Current lrt status */
-        WORD ltt_status;        /* Current ltt status */
-        WORD timeout;           /* Timeout value */
-        WORD topology;          /* Topology bits */
-        WORD mon_ltt;
-        WORD mon_lrt;
-        WORD WaitNoBoot;        /* Secs to hold off booting */
-        PKT_ptr add_packet_list;        /* Add packets to here */
-        PKT_ptr remove_packet_list;     /* Send packets from here */
-
-        Channel_ptr lrt_fail_chan;      /* Lrt's failure channel */
-        Channel_ptr ltt_fail_chan;      /* Ltt's failure channel */
+        u16 descheduled;        /* Currently Descheduled */
+        u16 state;              /* Current state */
+        u16 send_poll;          /* Send a Poll Packet */
+        u16 ltt_p;      /* Process Descriptor */
+        u16 lrt_p;      /* Process Descriptor */
+        u16 lrt_status;         /* Current lrt status */
+        u16 ltt_status;         /* Current ltt status */
+        u16 timeout;            /* Timeout value */
+        u16 topology;           /* Topology bits */
+        u16 mon_ltt;
+        u16 mon_lrt;
+        u16 WaitNoBoot; /* Secs to hold off booting */
+        u16 add_packet_list;    /* Add packets to here */
+        u16 remove_packet_list; /* Send packets from here */
+
+        u16 lrt_fail_chan;      /* Lrt's failure channel */
+        u16 ltt_fail_chan;      /* Ltt's failure channel */
 
         /* RUP structure for HOST to driver communications */
         struct RUP rup;
         struct RUP link_rup;    /* RUP for the link (POLL,
                                    topology etc.) */
-        WORD attached_link;     /* Number of attached link */
-        WORD csum_errors;       /* csum errors */
-        WORD num_disconnects;   /* number of disconnects */
-        WORD num_sync_rcvd;     /* # sync's received */
-        WORD num_sync_rqst;     /* # sync requests */
-        WORD num_tx;            /* Num pkts sent */
-        WORD num_rx;            /* Num pkts received */
-        WORD module_attached;   /* Module tpyes of attached */
-        WORD led_timeout;       /* LED timeout */
-        WORD first_port;        /* First port to service */
-        WORD last_port;         /* Last port to service */
+        u16 attached_link;      /* Number of attached link */
+        u16 csum_errors;        /* csum errors */
+        u16 num_disconnects;    /* number of disconnects */
+        u16 num_sync_rcvd;      /* # sync's received */
+        u16 num_sync_rqst;      /* # sync requests */
+        u16 num_tx;             /* Num pkts sent */
+        u16 num_rx;             /* Num pkts received */
+        u16 module_attached;    /* Module tpyes of attached */
+        u16 led_timeout;        /* LED timeout */
+        u16 first_port;         /* First port to service */
+        u16 last_port;          /* Last port to service */
 };
 
 #endif
diff --git a/drivers/char/rio/linux_compat.h b/drivers/char/rio/linux_compat.h
index 17a14c4a34..34c0d2899e 100644
--- a/drivers/char/rio/linux_compat.h
+++ b/drivers/char/rio/linux_compat.h
@@ -19,56 +19,12 @@
 #include <linux/interrupt.h>
 
 
-#define disable(oldspl) save_flags (oldspl)
-#define restore(oldspl) restore_flags (oldspl)
-
-#define sysbrk(x) kmalloc ((x),in_interrupt()? GFP_ATOMIC : GFP_KERNEL)
-#define sysfree(p,size) kfree ((p))
-
-#define WBYTE(p,v) writeb(v, &p)
-#define RBYTE(p)   readb (&p)
-#define WWORD(p,v) writew(v, &p)
-#define RWORD(p)   readw(&p)
-#define WINDW(p,v) writew(v, p)
-#define RINDW(p)   readw(p)
-
 #define DEBUG_ALL
 
-#define cprintf printk
-
-#ifdef __KERNEL__
-#define INKERNEL
-#endif
-
 struct ttystatics {
         struct termios tm;
 };
 
-#define bzero(d, n)         memset((d), 0, (n))
-#define bcopy(src, dest, n) memcpy ((dest), (src), (n))
-
-#define SEM_SIGIGNORE 0x1234
-
-#ifdef DEBUG_SEM
-#define swait(a,b)      printk ("waiting:    " __FILE__ " line %d\n", __LINE__)
-#define ssignal(sem)    printk ("signalling: " __FILE__ " line %d\n", __LINE__)
-
-#define sreset(sem)     printk ("sreset:     " __FILE__ "\n")
-#define sem_init(sem,v) printk ("sreset:     " __FILE__ "\n")
-#endif
-
-
-#define getpid()    (current->pid)
-
-#define QSIZE SERIAL_XMIT_SIZE
-
-#define pseterr(errno) return (- errno)
-
-#define V_CBAUD CBAUD
-
-/* For one reason or another rioboot.c uses delay instead of RIODelay. */
-#define delay(x,y) RIODelay(NULL, y)
-
 extern int rio_debug;
 
 #define RIO_DEBUG_INIT         0x000001
@@ -91,6 +47,7 @@ extern int rio_debug;
 #define RIO_DEBUG_DELAY        0x020000
 #define RIO_DEBUG_MOD_COUNT    0x040000
 
+
 /* Copied over from riowinif.h . This is ugly. The winif file declares
 also much other stuff which is incompatible with the headers from
 the older driver. The older driver includes "brates.h" which shadows
diff --git a/drivers/char/rio/list.h b/drivers/char/rio/list.h
deleted file mode 100644
index 79b853140a..0000000000
--- a/drivers/char/rio/list.h
+++ /dev/null
@@ -1,56 +0,0 @@
-/****************************************************************************
- *******                                                              *******
- *******                      L I S T                                 *******
- *******                                                              *******
- ****************************************************************************
-
- Author  : Jeremy Rolls.
- Date    : 04-Nov-1990
-
- *
- *  (C) 1990 - 2000 Specialix International Ltd., Byfleet, Surrey, UK.
- *
- *      This program is free software; you can redistribute it and/or modify
- *      it under the terms of the GNU General Public License as published by
- *      the Free Software Foundation; either version 2 of the License, or
- *      (at your option) any later version.
- *
- *      This program is distributed in the hope that it will be useful,
- *      but WITHOUT ANY WARRANTY; without even the implied warranty of
- *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *      GNU General Public License for more details.
- *
- *      You should have received a copy of the GNU General Public License
- *      along with this program; if not, write to the Free Software
- *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
- Version : 0.01
-
-
-                            Mods
- ----------------------------------------------------------------------------
-  Date     By                Description
- ----------------------------------------------------------------------------
- ***************************************************************************/
-
-#ifndef _list_h
-#define _list_h 1
-
-#ifdef SCCS_LABELS
-#ifndef lint
-static char *_rio_list_h_sccs = "@(#)list.h     1.9";
-#endif
-#endif
-
-#define PKT_IN_USE    0x1
-
-#define ZERO_PTR (ushort) 0x8000
-#define CaD     PortP->Caddr
-
-/*
-** We can add another packet to a transmit queue if the packet pointer pointed
-** to by the TxAdd pointer has PKT_IN_USE clear in its address.
-*/
-
-#endif                          /* ifndef _list.h */
-/*********** end of file ***********/
diff --git a/drivers/char/rio/map.h b/drivers/char/rio/map.h
index 97fe287aab..bdbcd09c8b 100644
--- a/drivers/char/rio/map.h
+++ b/drivers/char/rio/map.h
@@ -47,17 +47,17 @@ static char *_map_h_sccs_ = "@(#)map.h	1.2";
 #define MAX_NAME_LEN 32
 
 struct Map {
-        uint HostUniqueNum;     /* Supporting hosts unique number */
-        uint RtaUniqueNum;      /* Unique number */
+        unsigned int HostUniqueNum;     /* Supporting hosts unique number */
+        unsigned int RtaUniqueNum;      /* Unique number */
         /*
          ** The next two IDs must be swapped on big-endian architectures
          ** when using a v2.04 /etc/rio/config with a v3.00 driver (when
          ** upgrading for example).
          */
-        ushort ID;              /* ID used in the subnet */
-        ushort ID2;             /* ID of 2nd block of 8 for 16 port */
-        ulong Flags;            /* Booted, ID Given, Disconnected */
-        ulong SysPort;          /* First tty mapped to this port */
+        unsigned short ID;              /* ID used in the subnet */
+        unsigned short ID2;             /* ID of 2nd block of 8 for 16 port */
+        unsigned long Flags;            /* Booted, ID Given, Disconnected */
+        unsigned long SysPort;          /* First tty mapped to this port */
         struct Top Topology[LINKS_PER_UNIT];    /* ID connected to each link */
         char Name[MAX_NAME_LEN];        /* Cute name by which RTA is known */
 };
diff --git a/drivers/char/rio/param.h b/drivers/char/rio/param.h
index de7e57180c..675c200b24 100644
--- a/drivers/char/rio/param.h
+++ b/drivers/char/rio/param.h
@@ -43,18 +43,18 @@ static char *_param_h_sccs_ = "@(#)param.h	1.2";
 */
 
 struct phb_param {
-        BYTE Cmd;               /* It is very important that these line up */
-        BYTE Cor1;              /* with what is expected at the other end. */
-        BYTE Cor2;              /* to confirm that you've got it right,    */
-        BYTE Cor4;              /* check with cirrus/cirrus.h              */
-        BYTE Cor5;
-        BYTE TxXon;             /* Transmit X-On character */
-        BYTE TxXoff;            /* Transmit X-Off character */
-        BYTE RxXon;             /* Receive X-On character */
-        BYTE RxXoff;            /* Receive X-Off character */
-        BYTE LNext;             /* Literal-next character */
-        BYTE TxBaud;            /* Transmit baudrate */
-        BYTE RxBaud;            /* Receive baudrate */
+        u8 Cmd;                 /* It is very important that these line up */
+        u8 Cor1;                /* with what is expected at the other end. */
+        u8 Cor2;                /* to confirm that you've got it right,    */
+        u8 Cor4;                /* check with cirrus/cirrus.h              */
+        u8 Cor5;
+        u8 TxXon;               /* Transmit X-On character */
+        u8 TxXoff;              /* Transmit X-Off character */
+        u8 RxXon;               /* Receive X-On character */
+        u8 RxXoff;              /* Receive X-Off character */
+        u8 LNext;               /* Literal-next character */
+        u8 TxBaud;              /* Transmit baudrate */
+        u8 RxBaud;              /* Receive baudrate */
 };
 
 #endif
diff --git a/drivers/char/rio/parmmap.h b/drivers/char/rio/parmmap.h
index e24acc1d18..9764ef85c5 100644
--- a/drivers/char/rio/parmmap.h
+++ b/drivers/char/rio/parmmap.h
@@ -47,40 +47,40 @@
 typedef struct PARM_MAP PARM_MAP;
 
 struct PARM_MAP {
-        PHB_ptr phb_ptr;        /* Pointer to the PHB array */
-        WORD_ptr phb_num_ptr;   /* Ptr to Number of PHB's */
-        FREE_LIST_ptr free_list;        /* Free List pointer */
-        FREE_LIST_ptr free_list_end;    /* Free List End pointer */
-        Q_BUF_ptr_ptr q_free_list_ptr;  /* Ptr to Q_BUF variable */
-        BYTE_ptr unit_id_ptr;   /* Unit Id */
-        LPB_ptr link_str_ptr;   /* Link Structure Array */
-        BYTE_ptr bootloader_1;  /* 1st Stage Boot Loader */
-        BYTE_ptr bootloader_2;  /* 2nd Stage Boot Loader */
-        WORD_ptr port_route_map_ptr;    /* Port Route Map */
-        ROUTE_STR_ptr route_ptr;        /* Unit Route Map */
-        NUMBER_ptr map_present; /* Route Map present */
-        NUMBER pkt_num;         /* Total number of packets */
-        NUMBER q_num;           /* Total number of Q packets */
-        WORD buffers_per_port;  /* Number of buffers per port */
-        WORD heap_size;         /* Initial size of heap */
-        WORD heap_left;         /* Current Heap left */
-        WORD error;             /* Error code */
-        WORD tx_max;            /* Max number of tx pkts per phb */
-        WORD rx_max;            /* Max number of rx pkts per phb */
-        WORD rx_limit;          /* For high / low watermarks */
-        NUMBER links;           /* Links to use */
-        NUMBER timer;           /* Interrupts per second */
-        RUP_ptr rups;           /* Pointer to the RUPs */
-        WORD max_phb;           /* Mostly for debugging */
-        WORD living;            /* Just increments!! */
-        WORD init_done;         /* Initialisation over */
-        WORD booting_link;
-        WORD idle_count;        /* Idle time counter */
-        WORD busy_count;        /* Busy counter */
-        WORD idle_control;      /* Control Idle Process */
-        WORD tx_intr;           /* TX interrupt pending */
-        WORD rx_intr;           /* RX interrupt pending */
-        WORD rup_intr;          /* RUP interrupt pending */
+        u16 phb_ptr;    /* Pointer to the PHB array */
+        u16 phb_num_ptr;        /* Ptr to Number of PHB's */
+        u16 free_list;  /* Free List pointer */
+        u16 free_list_end;      /* Free List End pointer */
+        u16 q_free_list_ptr;    /* Ptr to Q_BUF variable */
+        u16 unit_id_ptr;        /* Unit Id */
+        u16 link_str_ptr;       /* Link Structure Array */
+        u16 bootloader_1;       /* 1st Stage Boot Loader */
+        u16 bootloader_2;       /* 2nd Stage Boot Loader */
+        u16 port_route_map_ptr; /* Port Route Map */
+        u16 route_ptr;          /* Unit Route Map */
+        u16 map_present;        /* Route Map present */
+        s16 pkt_num;            /* Total number of packets */
+        s16 q_num;              /* Total number of Q packets */
+        u16 buffers_per_port;   /* Number of buffers per port */
+        u16 heap_size;          /* Initial size of heap */
+        u16 heap_left;          /* Current Heap left */
+        u16 error;              /* Error code */
+        u16 tx_max;             /* Max number of tx pkts per phb */
+        u16 rx_max;             /* Max number of rx pkts per phb */
+        u16 rx_limit;           /* For high / low watermarks */
+        s16 links;              /* Links to use */
+        s16 timer;              /* Interrupts per second */
+        u16 rups;               /* Pointer to the RUPs */
+        u16 max_phb;            /* Mostly for debugging */
+        u16 living;             /* Just increments!! */
+        u16 init_done;          /* Initialisation over */
+        u16 booting_link;
+        u16 idle_count;         /* Idle time counter */
+        u16 busy_count;         /* Busy counter */
+        u16 idle_control;       /* Control Idle Process */
+        u16 tx_intr;            /* TX interrupt pending */
+        u16 rx_intr;            /* RX interrupt pending */
+        u16 rup_intr;           /* RUP interrupt pending */
 };
 
 #endif
diff --git a/drivers/char/rio/phb.h b/drivers/char/rio/phb.h
index 2663ca0306..a4c48ae4e3 100644
--- a/drivers/char/rio/phb.h
+++ b/drivers/char/rio/phb.h
@@ -37,13 +37,6 @@
 #ifndef _phb_h
 #define _phb_h 1
 
-#ifdef SCCS_LABELS
-#ifndef lint
-/* static char *_rio_phb_h_sccs = "@(#)phb.h    1.12"; */
-#endif
-#endif
-
-
 /*************************************************
  * Handshake asserted. Deasserted by the LTT(s)
  ************************************************/
@@ -124,23 +117,23 @@
  * the start. The pointer tx_add points to a SPACE to put a Packet.
  * The pointer tx_remove points to the next Packet to remove
  *************************************************************************/
-typedef struct PHB PHB;
+
 struct PHB {
-        WORD source;
-        WORD handshake;
-        WORD status;
-        NUMBER timeout;         /* Maximum of 1.9 seconds */
-        WORD link;              /* Send down this link */
-        WORD destination;
-        PKT_ptr_ptr tx_start;
-        PKT_ptr_ptr tx_end;
-        PKT_ptr_ptr tx_add;
-        PKT_ptr_ptr tx_remove;
-
-        PKT_ptr_ptr rx_start;
-        PKT_ptr_ptr rx_end;
-        PKT_ptr_ptr rx_add;
-        PKT_ptr_ptr rx_remove;
+        u8 source;
+        u8 handshake;
+        u8 status;
+        u16 timeout;            /* Maximum of 1.9 seconds */
+        u8 link;                /* Send down this link */
+        u8 destination;
+        u16 tx_start;
+        u16 tx_end;
+        u16 tx_add;
+        u16 tx_remove;
+
+        u16 rx_start;
+        u16 rx_end;
+        u16 rx_add;
+        u16 rx_remove;
 
 };
 
diff --git a/drivers/char/rio/pkt.h b/drivers/char/rio/pkt.h
index 7011e52e82..a9458164f0 100644
--- a/drivers/char/rio/pkt.h
+++ b/drivers/char/rio/pkt.h
@@ -37,14 +37,6 @@
 #ifndef _pkt_h
 #define _pkt_h 1
 
-
-#ifdef SCCS_LABELS
-#ifndef lint
-/* static char *_rio_pkt_h_sccs = "@(#)pkt.h    1.8"; */
-#endif
-#endif
-
-#define MAX_TTL         0xf
 #define PKT_CMD_BIT     ((ushort) 0x080)
 #define PKT_CMD_DATA    ((ushort) 0x080)
 
@@ -70,15 +62,15 @@
 #define CONTROL_DATA_WNDW  (DATA_WNDW << 8)
 
 struct PKT {
-        BYTE dest_unit;         /* Destination Unit Id */
-        BYTE dest_port;         /* Destination POrt */
-        BYTE src_unit;          /* Source Unit Id */
-        BYTE src_port;          /* Source POrt */
-        BYTE len;
-        BYTE control;
-        BYTE data[PKT_MAX_DATA_LEN];
+        u8 dest_unit;           /* Destination Unit Id */
+        u8 dest_port;           /* Destination POrt */
+        u8 src_unit;            /* Source Unit Id */
+        u8 src_port;            /* Source POrt */
+        u8 len;
+        u8 control;
+        u8 data[PKT_MAX_DATA_LEN];
         /* Actual data :-) */
-        WORD csum;              /* C-SUM */
+        u16 csum;               /* C-SUM */
 };
 #endif
 
diff --git a/drivers/char/rio/port.h b/drivers/char/rio/port.h
index c99b1e70fd..9b5fa3eb04 100644
--- a/drivers/char/rio/port.h
+++ b/drivers/char/rio/port.h
@@ -33,91 +33,37 @@
 #ifndef __rio_port_h__
 #define __rio_port_h__
 
-#ifdef SCCS_LABELS
-static char *_port_h_sccs_ = "@(#)port.h        1.3";
-#endif
-
-
-#undef VPIX
-
-
-/*
-** the port data structure - one per port in the system
-*/
-
-#ifdef STATS
-struct RIOStats {
-        /*
-         ** interrupt statistics
-         */
-        uint BreakIntCnt;
-        uint ModemOffCnt;
-        uint ModemOnCnt;
-        uint RxIntCnt;
-        uint TxIntCnt;
-        /*
-         ** throughput statistics
-         */
-        uint RxCharCnt;
-        uint RxPktCnt;
-        uint RxSaveCnt;
-        uint TxCharCnt;
-        uint TxPktCnt;
-        /*
-         ** driver entry statistics
-         */
-        uint CloseCnt;
-        uint IoctlCnt;
-        uint OpenCnt;
-        uint ReadCnt;
-        uint WriteCnt;
-        /*
-         ** proc statistics
-         */
-        uint BlockCnt;
-        uint OutputCnt;
-        uint ResumeCnt;
-        uint RflushCnt;
-        uint SuspendCnt;
-        uint TbreakCnt;
-        uint TimeoutCnt;
-        uint UnblockCnt;
-        uint WflushCnt;
-        uint WFBodgeCnt;
-};
-#endif
-
 /*
 **      Port data structure
 */
 struct Port {
         struct gs_port gs;
-        int PortNum;            /* RIO port no., 0-511 */
+        int PortNum;                    /* RIO port no., 0-511 */
         struct Host *HostP;
-        volatile caddr_t Caddr;
-        ushort HostPort;        /* Port number on host card */
-        uchar RupNum;           /* Number of RUP for port */
-        uchar ID2;              /* Second ID of RTA for port */
-        ulong State;            /* FLAGS for open & xopen */
-#define RIO_LOPEN       0x00001 /* Local open */
-#define RIO_MOPEN       0x00002 /* Modem open */
-#define RIO_WOPEN       0x00004 /* Waiting for open */
-#define RIO_CLOSING     0x00008 /* The port is being close */
-#define RIO_XPBUSY      0x00010 /* Transparent printer busy */
-#define RIO_BREAKING    0x00020 /* Break in progress */
-#define RIO_DIRECT      0x00040 /* Doing Direct output */
-#define RIO_EXCLUSIVE   0x00080 /* Stream open for exclusive use */
-#define RIO_NDELAY      0x00100 /* Stream is open FNDELAY */
-#define RIO_CARR_ON     0x00200 /* Stream has carrier present */
-#define RIO_XPWANTR     0x00400 /* Stream wanted by Xprint */
-#define RIO_RBLK        0x00800 /* Stream is read-blocked */
-#define RIO_BUSY        0x01000 /* Stream is BUSY for write */
-#define RIO_TIMEOUT     0x02000 /* Stream timeout in progress */
-#define RIO_TXSTOP      0x04000 /* Stream output is stopped */
-#define RIO_WAITFLUSH   0x08000 /* Stream waiting for flush */
-#define RIO_DYNOROD     0x10000 /* Drain failed */
-#define RIO_DELETED     0x20000 /* RTA has been deleted */
-#define RIO_ISSCANCODE  0x40000 /* This line is in scancode mode */
+        caddr_t Caddr;
+        unsigned short HostPort;        /* Port number on host card */
+        unsigned char RupNum;           /* Number of RUP for port */
+        unsigned char ID2;              /* Second ID of RTA for port */
+        unsigned long State;            /* FLAGS for open & xopen */
+#define RIO_LOPEN       0x00001         /* Local open */
+#define RIO_MOPEN       0x00002         /* Modem open */
+#define RIO_WOPEN       0x00004         /* Waiting for open */
+#define RIO_CLOSING     0x00008         /* The port is being close */
+#define RIO_XPBUSY      0x00010         /* Transparent printer busy */
+#define RIO_BREAKING    0x00020         /* Break in progress */
+#define RIO_DIRECT      0x00040         /* Doing Direct output */
+#define RIO_EXCLUSIVE   0x00080         /* Stream open for exclusive use */
+#define RIO_NDELAY      0x00100         /* Stream is open FNDELAY */
+#define RIO_CARR_ON     0x00200         /* Stream has carrier present */
+#define RIO_XPWANTR     0x00400         /* Stream wanted by Xprint */
+#define RIO_RBLK        0x00800         /* Stream is read-blocked */
+#define RIO_BUSY        0x01000         /* Stream is BUSY for write */
+#define RIO_TIMEOUT     0x02000         /* Stream timeout in progress */
+#define RIO_TXSTOP      0x04000         /* Stream output is stopped */
+#define RIO_WAITFLUSH   0x08000         /* Stream waiting for flush */
+#define RIO_DYNOROD     0x10000         /* Drain failed */
+#define RIO_DELETED     0x20000         /* RTA has been deleted */
+#define RIO_ISSCANCODE  0x40000         /* This line is in scancode mode */
 #define RIO_USING_EUC   0x100000        /* Using extended Unix chars */
 #define RIO_CAN_COOK    0x200000        /* This line can do cooking */
 #define RIO_TRIAD_MODE  0x400000        /* Enable TRIAD special ops. */
@@ -125,15 +71,15 @@ struct Port {
 #define RIO_TRIAD_FUNC  0x1000000       /* Seen a function key coming in */
 #define RIO_THROTTLE_RX 0x2000000       /* RX needs to be throttled. */
 
-        ulong Config;           /* FLAGS for NOREAD.... */
-#define RIO_NOREAD      0x0001  /* Are not allowed to read port */
-#define RIO_NOWRITE     0x0002  /* Are not allowed to write port */
-#define RIO_NOXPRINT    0x0004  /* Are not allowed to xprint port */
-#define RIO_NOMASK      0x0007  /* All not allowed things */
-#define RIO_IXANY       0x0008  /* Port is allowed ixany */
-#define RIO_MODEM       0x0010  /* Stream is a modem device */
-#define RIO_IXON        0x0020  /* Port is allowed ixon */
-#define RIO_WAITDRAIN   0x0040  /* Wait for port to completely drain */
+        unsigned long Config;           /* FLAGS for NOREAD.... */
+#define RIO_NOREAD      0x0001          /* Are not allowed to read port */
+#define RIO_NOWRITE     0x0002          /* Are not allowed to write port */
+#define RIO_NOXPRINT    0x0004          /* Are not allowed to xprint port */
+#define RIO_NOMASK      0x0007          /* All not allowed things */
+#define RIO_IXANY       0x0008          /* Port is allowed ixany */
+#define RIO_MODEM       0x0010          /* Stream is a modem device */
+#define RIO_IXON        0x0020          /* Port is allowed ixon */
+#define RIO_WAITDRAIN   0x0040          /* Wait for port to completely drain */
 #define RIO_MAP_50_TO_50        0x0080  /* Map 50 baud to 50 baud */
 #define RIO_MAP_110_TO_110      0x0100  /* Map 110 baud to 110 baud */
 
@@ -142,36 +88,36 @@ struct Port {
 ** As LynxOS does not appear to support Hardware Flow Control .....
 ** Define our own flow control flags in 'Config'.
 */
-#define RIO_CTSFLOW     0x0200  /* RIO's own CTSFLOW flag */
-#define RIO_RTSFLOW     0x0400  /* RIO's own RTSFLOW flag */
+#define RIO_CTSFLOW     0x0200          /* RIO's own CTSFLOW flag */
+#define RIO_RTSFLOW     0x0400          /* RIO's own RTSFLOW flag */
 
 
-        struct PHB *PhbP;       /* pointer to PHB for port */
-        WORD *TxAdd;            /* Add packets here */
-        WORD *TxStart;          /* Start of add array */
-        WORD *TxEnd;            /* End of add array */
-        WORD *RxRemove;         /* Remove packets here */
-        WORD *RxStart;          /* Start of remove array */
-        WORD *RxEnd;            /* End of remove array */
-        uint RtaUniqueNum;      /* Unique number of RTA */
-        ushort PortState;       /* status of port */
-        ushort ModemState;      /* status of modem lines */
-        ulong ModemLines;       /* Modem bits sent to RTA */
-        uchar CookMode;         /* who expands CR/LF? */
-        uchar ParamSem;         /* Prevent write during param */
-        uchar Mapped;           /* if port mapped onto host */
-        uchar SecondBlock;      /* if port belongs to 2nd block
-                                   of 16 port RTA */
-        uchar InUse;            /* how many pre-emptive cmds */
-        uchar Lock;             /* if params locked */
-        uchar Store;            /* if params stored across closes */
-        uchar FirstOpen;        /* TRUE if first time port opened */
-        uchar FlushCmdBodge;    /* if doing a (non)flush */
-        uchar MagicFlags;       /* require intr processing */
-#define MAGIC_FLUSH     0x01    /* mirror of WflushFlag */
-#define MAGIC_REBOOT    0x02    /* RTA re-booted, re-open ports */
-#define MORE_OUTPUT_EYGOR 0x04  /* riotproc failed to empty clists */
-        uchar WflushFlag;       /* 1 How many WFLUSHs active */
+        struct PHB *PhbP;               /* pointer to PHB for port */
+        u16 *TxAdd;                     /* Add packets here */
+        u16 *TxStart;                   /* Start of add array */
+        u16 *TxEnd;                     /* End of add array */
+        u16 *RxRemove;                  /* Remove packets here */
+        u16 *RxStart;                   /* Start of remove array */
+        u16 *RxEnd;                     /* End of remove array */
+        unsigned int RtaUniqueNum;      /* Unique number of RTA */
+        unsigned short PortState;       /* status of port */
+        unsigned short ModemState;      /* status of modem lines */
+        unsigned long ModemLines;       /* Modem bits sent to RTA */
+        unsigned char CookMode;         /* who expands CR/LF? */
+        unsigned char ParamSem;         /* Prevent write during param */
+        unsigned char Mapped;           /* if port mapped onto host */
+        unsigned char SecondBlock;      /* if port belongs to 2nd block
+                                                of 16 port RTA */
+        unsigned char InUse;            /* how many pre-emptive cmds */
+        unsigned char Lock;             /* if params locked */
+        unsigned char Store;            /* if params stored across closes */
+        unsigned char FirstOpen;        /* TRUE if first time port opened */
+        unsigned char FlushCmdBodge;    /* if doing a (non)flush */
+        unsigned char MagicFlags;       /* require intr processing */
+#define MAGIC_FLUSH     0x01            /* mirror of WflushFlag */
+#define MAGIC_REBOOT    0x02            /* RTA re-booted, re-open ports */
+#define MORE_OUTPUT_EYGOR 0x04          /* riotproc failed to empty clists */
+        unsigned char WflushFlag;       /* 1 How many WFLUSHs active */
 /*
 ** Transparent print stuff
 */
@@ -179,63 +125,55 @@ struct Port {
 #ifndef MAX_XP_CTRL_LEN
 #define MAX_XP_CTRL_LEN         16      /* ALSO IN DAEMON.H */
 #endif
-                uint XpCps;
+                unsigned int XpCps;
                 char XpOn[MAX_XP_CTRL_LEN];
                 char XpOff[MAX_XP_CTRL_LEN];
-                ushort XpLen;   /* strlen(XpOn)+strlen(XpOff) */
-                uchar XpActive;
-                uchar XpLastTickOk;     /* TRUE if we can process */
+                unsigned short XpLen;   /* strlen(XpOn)+strlen(XpOff) */
+                unsigned char XpActive;
+                unsigned char XpLastTickOk;     /* TRUE if we can process */
 #define XP_OPEN         00001
 #define XP_RUNABLE      00002
                 struct ttystatics *XttyP;
         } Xprint;
-#ifdef VPIX
-        v86_t *StashP;
-        uint IntMask;
-        struct termss VpixSs;
-        uchar ModemStatusReg;   /* Modem status register */
-#endif
-        uchar RxDataStart;
-        uchar Cor2Copy;         /* copy of COR2 */
-        char *Name;             /* points to the Rta's name */
-#ifdef STATS
-        struct RIOStats Stat;   /* ports statistics */
-#endif
+        unsigned char RxDataStart;
+        unsigned char Cor2Copy;         /* copy of COR2 */
+        char *Name;                     /* points to the Rta's name */
         char *TxRingBuffer;
-        ushort TxBufferIn;      /* New data arrives here */
-        ushort TxBufferOut;     /* Intr removes data here */
-        ushort OldTxBufferOut;  /* Indicates if draining */
-        int TimeoutId;          /* Timeout ID */
-        uint Debug;
-        uchar WaitUntilBooted;  /* True if open should block */
-        uint statsGather;       /* True if gathering stats */
-        ulong txchars;          /* Chars transmitted */
-        ulong rxchars;          /* Chars received */
-        ulong opens;            /* port open count */
-        ulong closes;           /* port close count */
-        ulong ioctls;           /* ioctl count */
-        uchar LastRxTgl;        /* Last state of rx toggle bit */
-        spinlock_t portSem;     /* Lock using this sem */
-        int MonitorTstate;      /* Monitoring ? */
-        int timeout_id;         /* For calling 100 ms delays */
-        int timeout_sem;        /* For calling 100 ms delays */
-        int firstOpen;          /* First time open ? */
-        char *p;                /* save the global struc here .. */
+        unsigned short TxBufferIn;      /* New data arrives here */
+        unsigned short TxBufferOut;     /* Intr removes data here */
+        unsigned short OldTxBufferOut;  /* Indicates if draining */
+        int TimeoutId;                  /* Timeout ID */
+        unsigned int Debug;
+        unsigned char WaitUntilBooted;  /* True if open should block */
+        unsigned int statsGather;       /* True if gathering stats */
+        unsigned long txchars;          /* Chars transmitted */
+        unsigned long rxchars;          /* Chars received */
+        unsigned long opens;            /* port open count */
+        unsigned long closes;           /* port close count */
+        unsigned long ioctls;           /* ioctl count */
+        unsigned char LastRxTgl;        /* Last state of rx toggle bit */
+        spinlock_t portSem;             /* Lock using this sem */
+        int MonitorTstate;              /* Monitoring ? */
+        int timeout_id;                 /* For calling 100 ms delays */
+        int timeout_sem;                /* For calling 100 ms delays */
+        int firstOpen;                  /* First time open ? */
+        char *p;                        /* save the global struc here .. */
 };
 
 struct ModuleInfo {
         char *Name;
-        uint Flags[4];          /* one per port on a module */
+        unsigned int Flags[4];          /* one per port on a module */
 };
-#endif
 
 /*
 ** This struct is required because trying to grab an entire Port structure
 ** runs into problems with differing struct sizes between driver and config.
 */
 struct PortParams {
-        uint Port;
-        ulong Config;
-        ulong State;
+        unsigned int Port;
+        unsigned long Config;
+        unsigned long State;
         struct ttystatics *TtyP;
 };
+
+#endif
diff --git a/drivers/char/rio/qbuf.h b/drivers/char/rio/qbuf.h
deleted file mode 100644
index 391ffc3355..0000000000
--- a/drivers/char/rio/qbuf.h
+++ /dev/null
@@ -1,62 +0,0 @@
-
-/****************************************************************************
- *******                                                              *******
- *******       Q U E U E    B U F F E R   S T R U C T U R E S
- *******                                                              *******
- ****************************************************************************
-
- Author  : Ian Nandhra / Jeremy Rolls
- Date    :
-
- *
- *  (C) 1990 - 2000 Specialix International Ltd., Byfleet, Surrey, UK.
- *
- *      This program is free software; you can redistribute it and/or modify
- *      it under the terms of the GNU General Public License as published by
- *      the Free Software Foundation; either version 2 of the License, or
- *      (at your option) any later version.
- *
- *      This program is distributed in the hope that it will be useful,
- *      but WITHOUT ANY WARRANTY; without even the implied warranty of
- *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *      GNU General Public License for more details.
- *
- *      You should have received a copy of the GNU General Public License
- *      along with this program; if not, write to the Free Software
- *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
- Version : 0.01
-
-
-                            Mods
- ----------------------------------------------------------------------------
-  Date     By                Description
- ----------------------------------------------------------------------------
-
- ***************************************************************************/
-
-#ifndef _qbuf_h
-#define _qbuf_h 1
-
-#ifndef lint
-#ifdef SCCS_LABELS
-static char *_rio_qbuf_h_sccs = "@(#)qbuf.h     1.1";
-#endif
-#endif
-
-
-
-#define PKTS_PER_BUFFER    (220 / PKT_LENGTH)
-
-typedef struct Q_BUF Q_BUF;
-struct Q_BUF {
-        Q_BUF_ptr next;
-        Q_BUF_ptr prev;
-        PKT_ptr buf[PKTS_PER_BUFFER];
-};
-
-
-#endif
-
-
-/*********** end of file ***********/
diff --git a/drivers/char/rio/rio.h b/drivers/char/rio/rio.h
index 7f45e1ab53..b4c91871ba 100644
--- a/drivers/char/rio/rio.h
+++ b/drivers/char/rio/rio.h
@@ -33,38 +33,6 @@
 #ifndef __rio_rio_h__
 #define __rio_rio_h__
 
-#ifdef SCCS_LABELS
-static char *_rio_h_sccs_ = "@(#)rio.h  1.3";
-#endif
-
-/*
-** 30.09.1998 ARG -
-** Introduced driver version and host card type strings
-*/
-#define RIO_DRV_STR "Specialix RIO Driver"
-#define RIO_AT_HOST_STR "ISA"
-#define RIO_PCI_HOST_STR "PCI"
-
-
-/*
-** rio_info_store() commands (arbitary values) :
-*/
-#define RIO_INFO_PUT    0xA4B3C2D1
-#define RIO_INFO_GET    0xF1E2D3C4
-
-
-/*
-** anything that I couldn't cram in somewhere else
-*/
-/*
-#ifndef RIODEBUG
-#define debug
-#else
-#define debug rioprint
-#endif
-*/
-
-
 /*
 **      Maximum numbers of things
 */
@@ -101,9 +69,8 @@ static char *_rio_h_sccs_ = "@(#)rio.h	1.3";
 /*
 **      Flag values returned by functions
 */
+
 #define RIO_FAIL        -1
-#define RIO_SUCCESS     0
-#define COPYFAIL        -1      /* copy[in|out] failed */
 
 /*
 ** SysPort value for something that hasn't any ports
@@ -142,30 +109,8 @@ static char *_rio_h_sccs_ = "@(#)rio.h	1.3";
 /*
 **      Generally useful constants
 */
-#define HALF_A_SECOND           ((HZ)>>1)
-#define A_SECOND                (HZ)
-#define HUNDRED_HZ              ((HZ/100)?(HZ/100):1)
-#define FIFTY_HZ                ((HZ/50)?(HZ/50):1)
-#define TWENTY_HZ               ((HZ/20)?(HZ/20):1)
-#define TEN_HZ                  ((HZ/10)?(HZ/10):1)
-#define FIVE_HZ                 ((HZ/5)?(HZ/5):1)
-#define HUNDRED_MS              TEN_HZ
-#define FIFTY_MS                TWENTY_HZ
-#define TWENTY_MS               FIFTY_HZ
-#define TEN_MS                  HUNDRED_HZ
-#define TWO_SECONDS             ((A_SECOND)*2)
-#define FIVE_SECONDS            ((A_SECOND)*5)
-#define TEN_SECONDS             ((A_SECOND)*10)
-#define FIFTEEN_SECONDS         ((A_SECOND)*15)
-#define TWENTY_SECONDS          ((A_SECOND)*20)
-#define HALF_A_MINUTE           (A_MINUTE>>1)
-#define A_MINUTE                (A_SECOND*60)
-#define FIVE_MINUTES            (A_MINUTE*5)
-#define QUARTER_HOUR            (A_MINUTE*15)
-#define HALF_HOUR               (A_MINUTE*30)
-#define HOUR                    (A_MINUTE*60)
-
-#define SIXTEEN_MEG             0x1000000
+
+#define HUNDRED_MS              ((HZ/10)?(HZ/10):1)
 #define ONE_MEG                 0x100000
 #define SIXTY_FOUR_K            0x10000
 
@@ -173,8 +118,6 @@ static char *_rio_h_sccs_ = "@(#)rio.h	1.3";
 #define RIO_EISA_MEM_SIZE       SIXTY_FOUR_K
 #define RIO_MCA_MEM_SIZE        SIXTY_FOUR_K
 
-#define POLL_VECTOR             0x100
-
 #define COOK_WELL               0
 #define COOK_MEDIUM             1
 #define COOK_RAW                2
@@ -186,69 +129,26 @@ static char *_rio_h_sccs_ = "@(#)rio.h	1.3";
 **      RIO_OBJ takes hostp->Caddr and a UNIX pointer to an object and
 **      returns the offset into the DP RAM area.
 */
-#define RIO_PTR(C,O) (((caddr_t)(C))+(0xFFFF&(O)))
-#define RIO_OFF(C,O) ((int)(O)-(int)(C))
+#define RIO_PTR(C,O) (((unsigned char *)(C))+(0xFFFF&(O)))
+#define RIO_OFF(C,O) ((long)(O)-(long)(C))
 
 /*
 **      How to convert from various different device number formats:
 **      DEV is a dev number, as passed to open, close etc - NOT a minor
 **      number!
-**
-**      Note:   LynxOS only gives us 8 bits for the device minor number,
-**              so all this crap here to deal with 'modem' bits etc. is
-**              just a load of irrelevant old bunkum!
-**              This however does not stop us needing to define a value
-**              for RIO_MODEMOFFSET which is required by the 'riomkdev'
-**              utility in the New Config Utilities suite.
-*/
-/* 0-511: direct 512-1023: modem */
-#define RIO_MODEMOFFSET         0x200   /* doesn't mean anything */
+**/
+
 #define RIO_MODEM_MASK          0x1FF
 #define RIO_MODEM_BIT           0x200
 #define RIO_UNMODEM(DEV)        (MINOR(DEV) & RIO_MODEM_MASK)
 #define RIO_ISMODEM(DEV)        (MINOR(DEV) & RIO_MODEM_BIT)
 #define RIO_PORT(DEV,FIRST_MAJ) ( (MAJOR(DEV) - FIRST_MAJ) * PORTS_PER_HOST) \
                                         + MINOR(DEV)
-
-#define splrio  spltty
-
-#define RIO_IPL 5
-#define RIO_PRI (PZERO+10)
-#define RIO_CLOSE_PRI   PZERO-1 /* uninterruptible sleeps for close */
-
-typedef struct DbInf {
-        uint Flag;
-        char Name[8];
-} DbInf;
-
-#ifndef TRUE
-#define TRUE (1==1)
-#endif
-#ifndef FALSE
-#define FALSE   (!TRUE)
-#endif
-
-#define CSUM(pkt_ptr)  (((ushort *)(pkt_ptr))[0] + ((ushort *)(pkt_ptr))[1] + \
-                        ((ushort *)(pkt_ptr))[2] + ((ushort *)(pkt_ptr))[3] + \
-                        ((ushort *)(pkt_ptr))[4] + ((ushort *)(pkt_ptr))[5] + \
-                        ((ushort *)(pkt_ptr))[6] + ((ushort *)(pkt_ptr))[7] + \
-                        ((ushort *)(pkt_ptr))[8] + ((ushort *)(pkt_ptr))[9] )
-
-/*
-** This happy little macro copies SIZE bytes of data from FROM to TO
-** quite well. SIZE must be a constant.
-*/
-#define CCOPY( FROM, TO, SIZE ) { *(struct s { char data[SIZE]; } *)(TO) = *(struct s *)(FROM); }
-
-/*
-** increment a buffer pointer modulo the size of the buffer...
-*/
-#define BUMP( P, I )    ((P) = (((P)+(I)) & RIOBufferMask))
-
-#define INIT_PACKET( PK, PP ) \
-{ \
-        *((uint *)PK)    = PP->PacketInfo; \
-}
+#define CSUM(pkt_ptr)  (((u16 *)(pkt_ptr))[0] + ((u16 *)(pkt_ptr))[1] + \
+                        ((u16 *)(pkt_ptr))[2] + ((u16 *)(pkt_ptr))[3] + \
+                        ((u16 *)(pkt_ptr))[4] + ((u16 *)(pkt_ptr))[5] + \
+                        ((u16 *)(pkt_ptr))[6] + ((u16 *)(pkt_ptr))[7] + \
+                        ((u16 *)(pkt_ptr))[8] + ((u16 *)(pkt_ptr))[9] )
 
 #define RIO_LINK_ENABLE 0x80FF  /* FF is a hack, mainly for Mips, to        */
                                /* prevent a really stupid race condition.  */
@@ -267,27 +167,42 @@ typedef struct DbInf {
 #define DISCONNECT      0
 #define CONNECT         1
 
+/* ------ Control Codes ------ */
 
-/*
-** Machine types - these must NOT overlap with product codes 0-15
-*/
-#define RIO_MIPS_R3230  31
-#define RIO_MIPS_R4030  32
+#define CONTROL         '^'
+#define IFOAD           ( CONTROL + 1 )
+#define IDENTIFY        ( CONTROL + 2 )
+#define ZOMBIE          ( CONTROL + 3 )
+#define UFOAD           ( CONTROL + 4 )
+#define IWAIT           ( CONTROL + 5 )
+
+#define IFOAD_MAGIC     0xF0AD  /* of course */
+#define ZOMBIE_MAGIC    (~0xDEAD)       /* not dead -> zombie */
+#define UFOAD_MAGIC     0xD1E   /* kill-your-neighbour */
+#define IWAIT_MAGIC     0xB1DE  /* Bide your time */
+
+/* ------ Error Codes ------ */
+
+#define E_NO_ERROR                       ((ushort) 0)
+
+/* ------ Free Lists ------ */
 
-#define RIO_IO_UNKNOWN  -2
+struct rio_free_list {
+        u16 next;
+        u16 prev;
+};
 
-#undef  MODERN
-#define ERROR( E )      do { u.u_error = E; return OPENFAIL } while ( 0 )
+/* NULL for card side linked lists */
+#define TPNULL  ((ushort)(0x8000))
+/* We can add another packet to a transmit queue if the packet pointer pointed
+ * to by the TxAdd pointer has PKT_IN_USE clear in its address. */
+#define PKT_IN_USE    0x1
 
-/* Defines for MPX line discipline routines */
+/* ------ Topology ------ */
 
-#define DIST_LINESW_OPEN        0x01
-#define DIST_LINESW_CLOSE       0x02
-#define DIST_LINESW_READ        0x04
-#define DIST_LINESW_WRITE       0x08
-#define DIST_LINESW_IOCTL       0x10
-#define DIST_LINESW_INPUT       0x20
-#define DIST_LINESW_OUTPUT      0x40
-#define DIST_LINESW_MDMINT      0x80
+struct Top {
+        u8 Unit;
+        u8 Link;
+};
 
 #endif                          /* __rio_h__ */
diff --git a/drivers/char/rio/rio_linux.c b/drivers/char/rio/rio_linux.c
index c9af283a81..78dd856534 100644
--- a/drivers/char/rio/rio_linux.c
+++ b/drivers/char/rio/rio_linux.c
@@ -57,15 +57,12 @@
 #include <asm/uaccess.h>
 
 #include "linux_compat.h"
-#include "typdef.h"
 #include "pkt.h"
 #include "daemon.h"
 #include "rio.h"
 #include "riospace.h"
-#include "top.h"
 #include "cmdpkt.h"
 #include "map.h"
-#include "riotypes.h"
 #include "rup.h"
 #include "port.h"
 #include "riodrvr.h"
@@ -78,17 +75,13 @@
 #include "unixrup.h"
 #include "board.h"
 #include "host.h"
-#include "error.h"
 #include "phb.h"
 #include "link.h"
 #include "cmdblk.h"
 #include "route.h"
-#include "control.h"
 #include "cirrus.h"
 #include "rioioctl.h"
 #include "param.h"
-#include "list.h"
-#include "sam.h"
 #include "protsts.h"
 #include "rioboard.h"
 
@@ -297,7 +290,7 @@ static void my_hd(void *ad, int len)
         unsigned char *addr = ad;
 
         for (i = 0; i < len; i += 16) {
-                rio_dprintk(RIO_DEBUG_PARAM, "%08x ", (int) addr + i);
+                rio_dprintk(RIO_DEBUG_PARAM, "%08lx ", (unsigned long) addr + i);
                 for (j = 0; j < 16; j++) {
                         rio_dprintk(RIO_DEBUG_PARAM, "%02x %s", addr[j + i], (j == 7) ? " " : "");
                 }
@@ -340,34 +333,19 @@ int RIODelay_ni(struct Port *PortP, int njiffies)
         return !RIO_FAIL;
 }
 
-
-int rio_minor(struct tty_struct *tty)
+void rio_copy_to_card(void *to, void *from, int len)
 {
-        return tty->index + (tty->driver == rio_driver) ? 0 : 256;
+        rio_memcpy_toio(NULL, to, from, len);
 }
 
-
-int rio_ismodem(struct tty_struct *tty)
+int rio_minor(struct tty_struct *tty)
 {
-        return 1;
+        return tty->index + (tty->driver == rio_driver) ? 0 : 256;
 }
 
-
 static int rio_set_real_termios(void *ptr)
 {
-        int rv, modem;
-        struct tty_struct *tty;
-        func_enter();
-
-        tty = ((struct Port *) ptr)->gs.tty;
-
-        modem = rio_ismodem(tty);
-
-        rv = RIOParam((struct Port *) ptr, CONFIG, modem, 1);
-
-        func_exit();
-
-        return rv;
+        return RIOParam((struct Port *) ptr, CONFIG, 1, 1);
 }
 
 
@@ -379,7 +357,7 @@ static void rio_reset_interrupt(struct Host *HostP)
         case RIO_AT:
         case RIO_MCA:
         case RIO_PCI:
-                WBYTE(HostP->ResetInt, 0xff);
+                writeb(0xFF, &HostP->ResetInt);
         }
 
         func_exit();
@@ -397,9 +375,6 @@ static irqreturn_t rio_interrupt(int irq, void *ptr, struct pt_regs *regs)
         /* AAargh! The order in which to do these things is essential and
            not trivial.
 
-           - Rate limit goes before "recursive". Otherwise a series of
-           recursive calls will hang the machine in the interrupt routine.
-
            - hardware twiddling goes before "recursive". Otherwise when we
            poll the card, and a recursive interrupt happens, we won't
            ack the card, so it might keep on interrupting us. (especially
@@ -414,26 +389,6 @@ static irqreturn_t rio_interrupt(int irq, void *ptr, struct pt_regs *regs)
            - The initialized test goes before recursive.
          */
 
-
-
-#ifdef IRQ_RATE_LIMIT
-        /* Aaargh! I'm ashamed. This costs more lines-of-code than the
-           actual interrupt routine!. (Well, used to when I wrote that comment) */
-        {
-                static int lastjif;
-                static int nintr = 0;
-
-                if (lastjif == jiffies) {
-                        if (++nintr > IRQ_RATE_LIMIT) {
-                                free_irq(HostP->Ivec, ptr);
-                                printk(KERN_ERR "rio: Too many interrupts. Turning off interrupt %d.\n", HostP->Ivec);
-                        }
-                } else {
-                        lastjif = jiffies;
-                        nintr = 0;
-                }
-        }
-#endif
         rio_dprintk(RIO_DEBUG_IFLOW, "rio: We've have noticed the interrupt\n");
         if (HostP->Ivec == irq) {
                 /* Tell the card we've noticed the interrupt. */
@@ -444,13 +399,13 @@ static irqreturn_t rio_interrupt(int irq, void *ptr, struct pt_regs *regs)
                 return IRQ_HANDLED;
 
         if (test_and_set_bit(RIO_BOARD_INTR_LOCK, &HostP->locks)) {
-                printk(KERN_ERR "Recursive interrupt! (host %d/irq%d)\n", (int) ptr, HostP->Ivec);
+                printk(KERN_ERR "Recursive interrupt! (host %p/irq%d)\n", ptr, HostP->Ivec);
                 return IRQ_HANDLED;
         }
 
         RIOServiceHost(p, HostP, irq);
 
-        rio_dprintk(RIO_DEBUG_IFLOW, "riointr() doing host %d type %d\n", (int) ptr, HostP->Type);
+        rio_dprintk(RIO_DEBUG_IFLOW, "riointr() doing host %p type %d\n", ptr, HostP->Type);
 
         clear_bit(RIO_BOARD_INTR_LOCK, &HostP->locks);
         rio_dprintk(RIO_DEBUG_IFLOW, "rio: exit rio_interrupt (%d/%d)\n", irq, HostP->Ivec);
@@ -873,7 +828,7 @@ static int rio_init_datastructures(void)
 #define HOST_SZ sizeof(struct Host)
 #define PORT_SZ sizeof(struct Port *)
 #define TMIO_SZ sizeof(struct termios *)
-        rio_dprintk(RIO_DEBUG_INIT, "getting : %d %d %d %d %d bytes\n", RI_SZ, RIO_HOSTS * HOST_SZ, RIO_PORTS * PORT_SZ, RIO_PORTS * TMIO_SZ, RIO_PORTS * TMIO_SZ);
+        rio_dprintk(RIO_DEBUG_INIT, "getting : %Zd %Zd %Zd %Zd %Zd bytes\n", RI_SZ, RIO_HOSTS * HOST_SZ, RIO_PORTS * PORT_SZ, RIO_PORTS * TMIO_SZ, RIO_PORTS * TMIO_SZ);
 
         if (!(p = ckmalloc(RI_SZ)))
                 goto free0;
@@ -963,22 +918,21 @@ static void __exit rio_release_drivers(void)
 
 static void fix_rio_pci(struct pci_dev *pdev)
 {
-        unsigned int hwbase;
-        unsigned long rebase;
+        unsigned long hwbase;
+        unsigned char *rebase;
         unsigned int t;
 
 #define CNTRL_REG_OFFSET        0x50
 #define CNTRL_REG_GOODVALUE     0x18260000
 
-        pci_read_config_dword(pdev, PCI_BASE_ADDRESS_0, &hwbase);
-        hwbase &= PCI_BASE_ADDRESS_MEM_MASK;
-        rebase = (ulong) ioremap(hwbase, 0x80);
+        hwbase = pci_resource_start(pdev, 0);
+        rebase = ioremap(hwbase, 0x80);
         t = readl(rebase + CNTRL_REG_OFFSET);
         if (t != CNTRL_REG_GOODVALUE) {
                 printk(KERN_DEBUG "rio: performing cntrl reg fix: %08x -> %08x\n", t, CNTRL_REG_GOODVALUE);
                 writel(CNTRL_REG_GOODVALUE, rebase + CNTRL_REG_OFFSET);
         }
-        iounmap((char *) rebase);
+        iounmap(rebase);
 }
 #endif
 
@@ -994,7 +948,6 @@ static int __init rio_init(void)
 
 #ifdef CONFIG_PCI
         struct pci_dev *pdev = NULL;
-        unsigned int tint;
         unsigned short tshort;
 #endif
 
@@ -1019,6 +972,8 @@ static int __init rio_init(void)
 #ifdef CONFIG_PCI
         /* First look for the JET devices: */
         while ((pdev = pci_get_device(PCI_VENDOR_ID_SPECIALIX, PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8, pdev))) {
+                u32 tint;
+
                 if (pci_enable_device(pdev))
                         continue;
 
@@ -1029,7 +984,6 @@ static int __init rio_init(void)
                    Also, reading a non-aligned dword doesn't work. So we read the
                    whole dword at 0x2c and extract the word at 0x2e (SUBSYSTEM_ID)
                    ourselves */
-                /* I don't know why the define doesn't work, constant 0x2c does --REW */
                 pci_read_config_dword(pdev, 0x2c, &tint);
                 tshort = (tint >> 16) & 0xffff;
                 rio_dprintk(RIO_DEBUG_PROBE, "Got a specialix card: %x.\n", tint);
@@ -1039,33 +993,31 @@ static int __init rio_init(void)
                 }
                 rio_dprintk(RIO_DEBUG_PROBE, "cp1\n");
 
-                pci_read_config_dword(pdev, PCI_BASE_ADDRESS_2, &tint);
-
                 hp = &p->RIOHosts[p->RIONumHosts];
-                hp->PaddrP = tint & PCI_BASE_ADDRESS_MEM_MASK;
+                hp->PaddrP = pci_resource_start(pdev, 2);
                 hp->Ivec = pdev->irq;
                 if (((1 << hp->Ivec) & rio_irqmask) == 0)
                         hp->Ivec = 0;
                 hp->Caddr = ioremap(p->RIOHosts[p->RIONumHosts].PaddrP, RIO_WINDOW_LEN);
                 hp->CardP = (struct DpRam *) hp->Caddr;
                 hp->Type = RIO_PCI;
-                hp->Copy = rio_pcicopy;
+                hp->Copy = rio_copy_to_card;
                 hp->Mode = RIO_PCI_BOOT_FROM_RAM;
                 spin_lock_init(&hp->HostLock);
                 rio_reset_interrupt(hp);
                 rio_start_card_running(hp);
 
                 rio_dprintk(RIO_DEBUG_PROBE, "Going to test it (%p/%p).\n", (void *) p->RIOHosts[p->RIONumHosts].PaddrP, p->RIOHosts[p->RIONumHosts].Caddr);
-                if (RIOBoardTest(p->RIOHosts[p->RIONumHosts].PaddrP, p->RIOHosts[p->RIONumHosts].Caddr, RIO_PCI, 0) == RIO_SUCCESS) {
+                if (RIOBoardTest(p->RIOHosts[p->RIONumHosts].PaddrP, p->RIOHosts[p->RIONumHosts].Caddr, RIO_PCI, 0) == 0) {
                         rio_dprintk(RIO_DEBUG_INIT, "Done RIOBoardTest\n");
-                        WBYTE(p->RIOHosts[p->RIONumHosts].ResetInt, 0xff);
+                        writeb(0xFF, &p->RIOHosts[p->RIONumHosts].ResetInt);
                         p->RIOHosts[p->RIONumHosts].UniqueNum =
-                            ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[0]) & 0xFF) << 0) |
-                            ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[1]) & 0xFF) << 8) | ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[2]) & 0xFF) << 16) | ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[3]) & 0xFF) << 24);
+                            ((readb(&p->RIOHosts[p->RIONumHosts].Unique[0]) & 0xFF) << 0) |
+                            ((readb(&p->RIOHosts[p->RIONumHosts].Unique[1]) & 0xFF) << 8) | ((readb(&p->RIOHosts[p->RIONumHosts].Unique[2]) & 0xFF) << 16) | ((readb(&p->RIOHosts[p->RIONumHosts].Unique[3]) & 0xFF) << 24);
                         rio_dprintk(RIO_DEBUG_PROBE, "Hmm Tested ok, uniqid = %x.\n", p->RIOHosts[p->RIONumHosts].UniqueNum);
 
                         fix_rio_pci(pdev);
-                        p->RIOLastPCISearch = RIO_SUCCESS;
+                        p->RIOLastPCISearch = 0;
                         p->RIONumHosts++;
                         found++;
                 } else {
@@ -1088,10 +1040,8 @@ static int __init rio_init(void)
                         continue;
 
 #ifdef CONFIG_RIO_OLDPCI
-                pci_read_config_dword(pdev, PCI_BASE_ADDRESS_0, &tint);
-
                 hp = &p->RIOHosts[p->RIONumHosts];
-                hp->PaddrP = tint & PCI_BASE_ADDRESS_MEM_MASK;
+                hp->PaddrP = pci_resource_start(pdev, 0);
                 hp->Ivec = pdev->irq;
                 if (((1 << hp->Ivec) & rio_irqmask) == 0)
                         hp->Ivec = 0;
@@ -1099,7 +1049,7 @@ static int __init rio_init(void)
                 hp->Caddr = ioremap(p->RIOHosts[p->RIONumHosts].PaddrP, RIO_WINDOW_LEN);
                 hp->CardP = (struct DpRam *) hp->Caddr;
                 hp->Type = RIO_PCI;
-                hp->Copy = rio_pcicopy;
+                hp->Copy = rio_copy_to_card;
                 hp->Mode = RIO_PCI_BOOT_FROM_RAM;
                 spin_lock_init(&hp->HostLock);
 
@@ -1109,14 +1059,14 @@ static int __init rio_init(void)
                 rio_reset_interrupt(hp);
                 rio_start_card_running(hp);
                 rio_dprintk(RIO_DEBUG_PROBE, "Going to test it (%p/%p).\n", (void *) p->RIOHosts[p->RIONumHosts].PaddrP, p->RIOHosts[p->RIONumHosts].Caddr);
-                if (RIOBoardTest(p->RIOHosts[p->RIONumHosts].PaddrP, p->RIOHosts[p->RIONumHosts].Caddr, RIO_PCI, 0) == RIO_SUCCESS) {
-                        WBYTE(p->RIOHosts[p->RIONumHosts].ResetInt, 0xff);
+                if (RIOBoardTest(p->RIOHosts[p->RIONumHosts].PaddrP, p->RIOHosts[p->RIONumHosts].Caddr, RIO_PCI, 0) == 0) {
+                        writeb(0xFF, &p->RIOHosts[p->RIONumHosts].ResetInt);
                         p->RIOHosts[p->RIONumHosts].UniqueNum =
-                            ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[0]) & 0xFF) << 0) |
-                            ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[1]) & 0xFF) << 8) | ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[2]) & 0xFF) << 16) | ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[3]) & 0xFF) << 24);
+                            ((readb(&p->RIOHosts[p->RIONumHosts].Unique[0]) & 0xFF) << 0) |
+                            ((readb(&p->RIOHosts[p->RIONumHosts].Unique[1]) & 0xFF) << 8) | ((readb(&p->RIOHosts[p->RIONumHosts].Unique[2]) & 0xFF) << 16) | ((readb(&p->RIOHosts[p->RIONumHosts].Unique[3]) & 0xFF) << 24);
                         rio_dprintk(RIO_DEBUG_PROBE, "Hmm Tested ok, uniqid = %x.\n", p->RIOHosts[p->RIONumHosts].UniqueNum);
 
-                        p->RIOLastPCISearch = RIO_SUCCESS;
+                        p->RIOLastPCISearch = 0;
                         p->RIONumHosts++;
                         found++;
                 } else {
@@ -1137,8 +1087,8 @@ static int __init rio_init(void)
                 hp->Caddr = ioremap(p->RIOHosts[p->RIONumHosts].PaddrP, RIO_WINDOW_LEN);
                 hp->CardP = (struct DpRam *) hp->Caddr;
                 hp->Type = RIO_AT;
-                hp->Copy = rio_pcicopy; /* AT card PCI???? - PVDL
-                                         * -- YES! this is now a normal copy. Only the
+                hp->Copy = rio_copy_to_card;    /* AT card PCI???? - PVDL
+                                         * -- YES! this is now a normal copy. Only the
                                          * old PCI card uses the special PCI copy.
                                          * Moreover, the ISA card will work with the
                                          * special PCI copy anyway. -- REW */
@@ -1150,7 +1100,7 @@ static int __init rio_init(void)
                 okboard = 0;
                 if ((strncmp(vpdp->identifier, RIO_ISA_IDENT, 16) == 0) || (strncmp(vpdp->identifier, RIO_ISA2_IDENT, 16) == 0) || (strncmp(vpdp->identifier, RIO_ISA3_IDENT, 16) == 0)) {
                         /* Board is present... */
-                        if (RIOBoardTest(hp->PaddrP, hp->Caddr, RIO_AT, 0) == RIO_SUCCESS) {
+                        if (RIOBoardTest(hp->PaddrP, hp->Caddr, RIO_AT, 0) == 0) {
                                 /* ... and feeling fine!!!! */
                                 rio_dprintk(RIO_DEBUG_PROBE, "Hmm Tested ok, uniqid = %x.\n", p->RIOHosts[p->RIONumHosts].UniqueNum);
                                 if (RIOAssignAT(p, hp->PaddrP, hp->Caddr, 0)) {
@@ -1252,24 +1202,3 @@ static void __exit rio_exit(void)
 
 module_init(rio_init);
 module_exit(rio_exit);
-
-/*
- * Anybody who knows why this doesn't work for me, please tell me -- REW.
- * Snatched from scsi.c (fixed one spelling error):
- * Overrides for Emacs so that we follow Linus' tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local Variables:
- * c-indent-level: 4
- * c-brace-imaginary-offset: 0
- * c-brace-offset: -4
- * c-argdecl-indent: 4
- * c-label-offset: -4
- * c-continued-statement-offset: 4
- * c-continued-brace-offset: 0
- * indent-tabs-mode: nil
- * tab-width: 8
- * End:
- */
diff --git a/drivers/char/rio/rioboot.c b/drivers/char/rio/rioboot.c
index 92df43552f..acda9326c2 100644
--- a/drivers/char/rio/rioboot.c
+++ b/drivers/char/rio/rioboot.c
@@ -30,38 +30,29 @@
 ** -----------------------------------------------------------------------------
 */
 
-#ifdef SCCS_LABELS
-static char *_rioboot_c_sccs_ = "@(#)rioboot.c  1.3";
-#endif
-
 #include <linux/module.h>
 #include <linux/slab.h>
+#include <linux/termios.h>
+#include <linux/serial.h>
+#include <asm/semaphore.h>
+#include <linux/generic_serial.h>
 #include <linux/errno.h>
 #include <linux/interrupt.h>
+#include <linux/delay.h>
 #include <asm/io.h>
 #include <asm/system.h>
 #include <asm/string.h>
-#include <asm/semaphore.h>
-
-
-#include <linux/termios.h>
-#include <linux/serial.h>
-
-#include <linux/generic_serial.h>
-
+#include <asm/uaccess.h>
 
 
 #include "linux_compat.h"
 #include "rio_linux.h"
-#include "typdef.h"
 #include "pkt.h"
 #include "daemon.h"
 #include "rio.h"
 #include "riospace.h"
-#include "top.h"
 #include "cmdpkt.h"
 #include "map.h"
-#include "riotypes.h"
 #include "rup.h"
 #include "port.h"
 #include "riodrvr.h"
@@ -74,161 +65,130 @@ static char *_rioboot_c_sccs_ = "@(#)rioboot.c	1.3";
 #include "unixrup.h"
 #include "board.h"
 #include "host.h"
-#include "error.h"
 #include "phb.h"
 #include "link.h"
 #include "cmdblk.h"
 #include "route.h"
 
-static int RIOBootComplete( struct rio_info *p, struct Host *HostP, uint Rup, struct PktCmd *PktCmdP );
-
-static uchar
-RIOAtVec2Ctrl[] =
-{
-        /* 0 */  INTERRUPT_DISABLE,
-        /* 1 */  INTERRUPT_DISABLE,
-        /* 2 */  INTERRUPT_DISABLE,
-        /* 3 */  INTERRUPT_DISABLE,
-        /* 4 */  INTERRUPT_DISABLE,
-        /* 5 */  INTERRUPT_DISABLE,
-        /* 6 */  INTERRUPT_DISABLE,
-        /* 7 */  INTERRUPT_DISABLE,
-        /* 8 */  INTERRUPT_DISABLE,
-        /* 9 */  IRQ_9|INTERRUPT_ENABLE,
+static int RIOBootComplete(struct rio_info *p, struct Host *HostP, unsigned int Rup, struct PktCmd *PktCmdP);
+
+static const unsigned char RIOAtVec2Ctrl[] = {
+        /* 0 */ INTERRUPT_DISABLE,
+        /* 1 */ INTERRUPT_DISABLE,
+        /* 2 */ INTERRUPT_DISABLE,
+        /* 3 */ INTERRUPT_DISABLE,
+        /* 4 */ INTERRUPT_DISABLE,
+        /* 5 */ INTERRUPT_DISABLE,
+        /* 6 */ INTERRUPT_DISABLE,
+        /* 7 */ INTERRUPT_DISABLE,
+        /* 8 */ INTERRUPT_DISABLE,
+        /* 9 */ IRQ_9 | INTERRUPT_ENABLE,
         /* 10 */ INTERRUPT_DISABLE,
-        /* 11 */ IRQ_11|INTERRUPT_ENABLE,
-        /* 12 */ IRQ_12|INTERRUPT_ENABLE,
+        /* 11 */ IRQ_11 | INTERRUPT_ENABLE,
+        /* 12 */ IRQ_12 | INTERRUPT_ENABLE,
         /* 13 */ INTERRUPT_DISABLE,
         /* 14 */ INTERRUPT_DISABLE,
-        /* 15 */ IRQ_15|INTERRUPT_ENABLE
+        /* 15 */ IRQ_15 | INTERRUPT_ENABLE
 };
 
-/*
-** Load in the RTA boot code.
-*/
-int
-RIOBootCodeRTA(p, rbp)
-struct rio_info *       p;
-struct DownLoad *       rbp; 
+/**
+ *      RIOBootCodeRTA          -       Load RTA boot code
+ *      @p: RIO to load
+ *      @rbp: Download descriptor
+ *
+ *      Called when the user process initiates booting of the card firmware.
+ *      Lads the firmware
+ */
+
+int RIOBootCodeRTA(struct rio_info *p, struct DownLoad * rbp)
 {
         int offset;
 
-        func_enter ();
+        func_enter();
 
-        /* Linux doesn't allow you to disable interrupts during a
-           "copyin". (Crash when a pagefault occurs). */
-        /* disable(oldspl); */
-        
-        rio_dprintk (RIO_DEBUG_BOOT, "Data at user address 0x%x\n",(int)rbp->DataP);
+        rio_dprintk(RIO_DEBUG_BOOT, "Data at user address %p\n", rbp->DataP);
 
         /*
-        ** Check that we have set asside enough memory for this
-        */
-        if ( rbp->Count > SIXTY_FOUR_K ) {
-                rio_dprintk (RIO_DEBUG_BOOT, "RTA Boot Code Too Large!\n");
+         ** Check that we have set asside enough memory for this
+         */
+        if (rbp->Count > SIXTY_FOUR_K) {
+                rio_dprintk(RIO_DEBUG_BOOT, "RTA Boot Code Too Large!\n");
                 p->RIOError.Error = HOST_FILE_TOO_LARGE;
-                /* restore(oldspl); */
-                func_exit ();
+                func_exit();
                 return -ENOMEM;
         }
 
-        if ( p->RIOBooting ) {
-                rio_dprintk (RIO_DEBUG_BOOT, "RTA Boot Code : BUSY BUSY BUSY!\n");
+        if (p->RIOBooting) {
+                rio_dprintk(RIO_DEBUG_BOOT, "RTA Boot Code : BUSY BUSY BUSY!\n");
                 p->RIOError.Error = BOOT_IN_PROGRESS;
-                /* restore(oldspl); */
-                func_exit ();
+                func_exit();
                 return -EBUSY;
         }
 
         /*
-        ** The data we load in must end on a (RTA_BOOT_DATA_SIZE) byte boundary,
-        ** so calculate how far we have to move the data up the buffer
-        ** to achieve this.
-        */
-        offset = (RTA_BOOT_DATA_SIZE - (rbp->Count % RTA_BOOT_DATA_SIZE)) % 
-                                                        RTA_BOOT_DATA_SIZE;
+         ** The data we load in must end on a (RTA_BOOT_DATA_SIZE) byte boundary,
+         ** so calculate how far we have to move the data up the buffer
+         ** to achieve this.
+         */
+        offset = (RTA_BOOT_DATA_SIZE - (rbp->Count % RTA_BOOT_DATA_SIZE)) % RTA_BOOT_DATA_SIZE;
 
         /*
-        ** Be clean, and clear the 'unused' portion of the boot buffer,
-        ** because it will (eventually) be part of the Rta run time environment
-        ** and so should be zeroed.
-        */
-        bzero( (caddr_t)p->RIOBootPackets, offset );
+         ** Be clean, and clear the 'unused' portion of the boot buffer,
+         ** because it will (eventually) be part of the Rta run time environment
+         ** and so should be zeroed.
+         */
+        memset(p->RIOBootPackets, 0, offset);
 
         /*
-        ** Copy the data from user space.
-        */
+         ** Copy the data from user space into the array
+         */
 
-        if ( copyin((int)rbp->DataP,((caddr_t)(p->RIOBootPackets))+offset,
-                                rbp->Count) ==COPYFAIL ) {
-                rio_dprintk (RIO_DEBUG_BOOT, "Bad data copy from user space\n");
+        if (copy_from_user(((u8 *)p->RIOBootPackets) + offset, rbp->DataP, rbp->Count)) {
+                rio_dprintk(RIO_DEBUG_BOOT, "Bad data copy from user space\n");
                 p->RIOError.Error = COPYIN_FAILED;
-                /* restore(oldspl); */
-                func_exit ();
+                func_exit();
                 return -EFAULT;
         }
 
         /*
-        ** Make sure that our copy of the size includes that offset we discussed
-        ** earlier.
-        */
-        p->RIONumBootPkts = (rbp->Count+offset)/RTA_BOOT_DATA_SIZE;
-        p->RIOBootCount   = rbp->Count;
+         ** Make sure that our copy of the size includes that offset we discussed
+         ** earlier.
+         */
+        p->RIONumBootPkts = (rbp->Count + offset) / RTA_BOOT_DATA_SIZE;
+        p->RIOBootCount = rbp->Count;
 
-        /* restore(oldspl); */
         func_exit();
         return 0;
 }
 
-void rio_start_card_running (struct Host * HostP)
-{
-        func_enter ();
+/**
+ *      rio_start_card_running          -       host card start
+ *      @HostP: The RIO to kick off
+ *
+ *      Start a RIO processor unit running. Encapsulates the knowledge
+ *      of the card type.
+ */
 
-        switch ( HostP->Type ) {
+void rio_start_card_running(struct Host *HostP)
+{
+        switch (HostP->Type) {
         case RIO_AT:
-                rio_dprintk (RIO_DEBUG_BOOT, "Start ISA card running\n");
-                WBYTE(HostP->Control, 
-                      BOOT_FROM_RAM | EXTERNAL_BUS_ON
-                      | HostP->Mode
-                      | RIOAtVec2Ctrl[HostP->Ivec & 0xF] );
-                break;
-                
-#ifdef FUTURE_RELEASE
-        case RIO_MCA:
-                                /*
-                                ** MCA handles IRQ vectors differently, so we don't write 
-                                ** them to this register.
-                                */
-                rio_dprintk (RIO_DEBUG_BOOT, "Start MCA card running\n");
-                WBYTE(HostP->Control, McaTpBootFromRam | McaTpBusEnable | HostP->Mode);
+                rio_dprintk(RIO_DEBUG_BOOT, "Start ISA card running\n");
+                writeb(BOOT_FROM_RAM | EXTERNAL_BUS_ON | HostP->Mode | RIOAtVec2Ctrl[HostP->Ivec & 0xF], &HostP->Control);
                 break;
-
-        case RIO_EISA:
-                                /*
-                                ** EISA is totally different and expects OUTBZs to turn it on.
-                                */
-                rio_dprintk (RIO_DEBUG_BOOT, "Start EISA card running\n");
-                OUTBZ( HostP->Slot, EISA_CONTROL_PORT, HostP->Mode | RIOEisaVec2Ctrl[HostP->Ivec] | EISA_TP_RUN | EISA_TP_BUS_ENABLE | EISA_TP_BOOT_FROM_RAM );
-                break;
-#endif
-
         case RIO_PCI:
-                                /*
-                                ** PCI is much the same as MCA. Everything is once again memory
-                                ** mapped, so we are writing to memory registers instead of io
-                                ** ports.
-                                */
-                rio_dprintk (RIO_DEBUG_BOOT, "Start PCI card running\n");
-                WBYTE(HostP->Control, PCITpBootFromRam | PCITpBusEnable | HostP->Mode);
+                /*
+                 ** PCI is much the same as MCA. Everything is once again memory
+                 ** mapped, so we are writing to memory registers instead of io
+                 ** ports.
+                 */
+                rio_dprintk(RIO_DEBUG_BOOT, "Start PCI card running\n");
+                writeb(PCITpBootFromRam | PCITpBusEnable | HostP->Mode, &HostP->Control);
                 break;
         default:
-                rio_dprintk (RIO_DEBUG_BOOT, "Unknown host type %d\n", HostP->Type);
+                rio_dprintk(RIO_DEBUG_BOOT, "Unknown host type %d\n", HostP->Type);
                 break;
         }
-/* 
-        printk (KERN_INFO "Done with starting the card\n");
-        func_exit ();
-*/
         return;
 }
 
@@ -239,370 +199,350 @@ void rio_start_card_running (struct Host * HostP)
 ** Put your rubber pants on before messing with this code - even the magic
 ** numbers have trouble understanding what they are doing here.
 */
-int
-RIOBootCodeHOST(p, rbp)
-struct rio_info *       p;
-register struct DownLoad *rbp;
+
+int RIOBootCodeHOST(struct rio_info *p, struct DownLoad *rbp)
 {
-        register struct Host *HostP;
-        register caddr_t Cad;
-        register PARM_MAP *ParmMapP;
-        register int RupN;
+        struct Host *HostP;
+        u8 *Cad;
+        PARM_MAP *ParmMapP;
+        int RupN;
         int PortN;
-        uint host;
-        caddr_t StartP;
-        BYTE *DestP;
+        unsigned int host;
+        u8 *StartP;
+        u8 *DestP;
         int wait_count;
-        ushort OldParmMap;
-        ushort offset;  /* It is very important that this is a ushort */
-        /* uint byte; */
-        caddr_t DownCode = NULL;
+        u16 OldParmMap;
+        u16 offset;             /* It is very important that this is a u16 */
+        u8 *DownCode = NULL;
         unsigned long flags;
 
-        HostP = NULL; /* Assure the compiler we've initialized it */
-        for ( host=0; host<p->RIONumHosts; host++ ) {
-                rio_dprintk (RIO_DEBUG_BOOT, "Attempt to boot host %d\n",host);
+        HostP = NULL;           /* Assure the compiler we've initialized it */
+
+
+        /* Walk the hosts */
+        for (host = 0; host < p->RIONumHosts; host++) {
+                rio_dprintk(RIO_DEBUG_BOOT, "Attempt to boot host %d\n", host);
                 HostP = &p->RIOHosts[host];
-                
-                rio_dprintk (RIO_DEBUG_BOOT,  "Host Type = 0x%x, Mode = 0x%x, IVec = 0x%x\n",
-                    HostP->Type, HostP->Mode, HostP->Ivec);
 
+                rio_dprintk(RIO_DEBUG_BOOT, "Host Type = 0x%x, Mode = 0x%x, IVec = 0x%x\n", HostP->Type, HostP->Mode, HostP->Ivec);
 
-                if ( (HostP->Flags & RUN_STATE) != RC_WAITING ) {
-                        rio_dprintk (RIO_DEBUG_BOOT, "%s %d already running\n","Host",host);
+                /* Don't boot hosts already running */
+                if ((HostP->Flags & RUN_STATE) != RC_WAITING) {
+                        rio_dprintk(RIO_DEBUG_BOOT, "%s %d already running\n", "Host", host);
                         continue;
                 }
 
                 /*
-                ** Grab a 32 bit pointer to the card.
-                */
+                 ** Grab a pointer to the card (ioremapped)
+                 */
                 Cad = HostP->Caddr;
 
                 /*
-                ** We are going to (try) and load in rbp->Count bytes.
-                ** The last byte will reside at p->RIOConf.HostLoadBase-1;
-                ** Therefore, we need to start copying at address
-                ** (caddr+p->RIOConf.HostLoadBase-rbp->Count)
-                */
-                StartP = (caddr_t)&Cad[p->RIOConf.HostLoadBase-rbp->Count];
-
-                rio_dprintk (RIO_DEBUG_BOOT, "kernel virtual address for host is 0x%x\n", (int)Cad );
-                rio_dprintk (RIO_DEBUG_BOOT, "kernel virtual address for download is 0x%x\n", (int)StartP);
-                rio_dprintk (RIO_DEBUG_BOOT, "host loadbase is 0x%x\n",p->RIOConf.HostLoadBase);
-                rio_dprintk (RIO_DEBUG_BOOT, "size of download is 0x%x\n", rbp->Count);
-
-                if ( p->RIOConf.HostLoadBase < rbp->Count ) {
-                        rio_dprintk (RIO_DEBUG_BOOT, "Bin too large\n");
+                 ** We are going to (try) and load in rbp->Count bytes.
+                 ** The last byte will reside at p->RIOConf.HostLoadBase-1;
+                 ** Therefore, we need to start copying at address
+                 ** (caddr+p->RIOConf.HostLoadBase-rbp->Count)
+                 */
+                StartP = &Cad[p->RIOConf.HostLoadBase - rbp->Count];
+
+                rio_dprintk(RIO_DEBUG_BOOT, "kernel virtual address for host is %p\n", Cad);
+                rio_dprintk(RIO_DEBUG_BOOT, "kernel virtual address for download is %p\n", StartP);
+                rio_dprintk(RIO_DEBUG_BOOT, "host loadbase is 0x%x\n", p->RIOConf.HostLoadBase);
+                rio_dprintk(RIO_DEBUG_BOOT, "size of download is 0x%x\n", rbp->Count);
+
+                /* Make sure it fits */
+                if (p->RIOConf.HostLoadBase < rbp->Count) {
+                        rio_dprintk(RIO_DEBUG_BOOT, "Bin too large\n");
                         p->RIOError.Error = HOST_FILE_TOO_LARGE;
-                        func_exit ();
+                        func_exit();
                         return -EFBIG;
                 }
                 /*
-                ** Ensure that the host really is stopped.
-                ** Disable it's external bus & twang its reset line.
-                */
-                RIOHostReset( HostP->Type, (struct DpRam *)HostP->CardP, HostP->Slot );
-
-                /*
-                ** Copy the data directly from user space to the SRAM.
-                ** This ain't going to be none too clever if the download
-                ** code is bigger than this segment.
-                */
-                rio_dprintk (RIO_DEBUG_BOOT, "Copy in code\n");
+                 ** Ensure that the host really is stopped.
+                 ** Disable it's external bus & twang its reset line.
+                 */
+                RIOHostReset(HostP->Type, (struct DpRam *) HostP->CardP, HostP->Slot);
 
                 /*
-                ** PCI hostcard can't cope with 32 bit accesses and so need to copy 
-                ** data to a local buffer, and then dripfeed the card.
-                */
-                if ( HostP->Type == RIO_PCI ) {
-                  /* int offset; */
-
-                        DownCode = sysbrk(rbp->Count);
-                        if ( !DownCode ) {
-                                rio_dprintk (RIO_DEBUG_BOOT, "No system memory available\n");
-                                p->RIOError.Error = NOT_ENOUGH_CORE_FOR_PCI_COPY;
-                                func_exit ();
-                                return -ENOMEM;
-                        }
-                        bzero(DownCode, rbp->Count);
-
-                        if ( copyin((int)rbp->DataP,DownCode,rbp->Count)==COPYFAIL ) {
-                                rio_dprintk (RIO_DEBUG_BOOT, "Bad copyin of host data\n");
-                                sysfree( DownCode, rbp->Count );
-                                p->RIOError.Error = COPYIN_FAILED;
-                                func_exit ();
-                                return -EFAULT;
-                        }
-
-                        HostP->Copy( DownCode, StartP, rbp->Count );
-
-                        sysfree( DownCode, rbp->Count );
+                 ** Copy the data directly from user space to the SRAM.
+                 ** This ain't going to be none too clever if the download
+                 ** code is bigger than this segment.
+                 */
+                rio_dprintk(RIO_DEBUG_BOOT, "Copy in code\n");
+
+                /* Buffer to local memory as we want to use I/O space and
+                   some cards only do 8 or 16 bit I/O */
+
+                DownCode = vmalloc(rbp->Count);
+                if (!DownCode) {
+                        p->RIOError.Error = NOT_ENOUGH_CORE_FOR_PCI_COPY;
+                        func_exit();
+                        return -ENOMEM;
                 }
-                else if ( copyin((int)rbp->DataP,StartP,rbp->Count)==COPYFAIL ) {
-                        rio_dprintk (RIO_DEBUG_BOOT, "Bad copyin of host data\n");
+                if (copy_from_user(rbp->DataP, DownCode, rbp->Count)) {
+                        kfree(DownCode);
                         p->RIOError.Error = COPYIN_FAILED;
-                        func_exit ();
+                        func_exit();
                         return -EFAULT;
                 }
+                HostP->Copy(DownCode, StartP, rbp->Count);
+                vfree(DownCode);
 
-                rio_dprintk (RIO_DEBUG_BOOT, "Copy completed\n");
+                rio_dprintk(RIO_DEBUG_BOOT, "Copy completed\n");
 
                 /*
-                **                      S T O P !
-                **
-                ** Upto this point the code has been fairly rational, and possibly
-                ** even straight forward. What follows is a pile of crud that will
-                ** magically turn into six bytes of transputer assembler. Normally
-                ** you would expect an array or something, but, being me, I have
-                ** chosen [been told] to use a technique whereby the startup code
-                ** will be correct if we change the loadbase for the code. Which
-                ** brings us onto another issue - the loadbase is the *end* of the
-                ** code, not the start.
-                **
-                ** If I were you I wouldn't start from here.
-                */
+                 **                     S T O P !
+                 **
+                 ** Upto this point the code has been fairly rational, and possibly
+                 ** even straight forward. What follows is a pile of crud that will
+                 ** magically turn into six bytes of transputer assembler. Normally
+                 ** you would expect an array or something, but, being me, I have
+                 ** chosen [been told] to use a technique whereby the startup code
+                 ** will be correct if we change the loadbase for the code. Which
+                 ** brings us onto another issue - the loadbase is the *end* of the
+                 ** code, not the start.
+                 **
+                 ** If I were you I wouldn't start from here.
+                 */
 
                 /*
-                ** We now need to insert a short boot section into
-                ** the memory at the end of Sram2. This is normally (de)composed
-                ** of the last eight bytes of the download code. The
-                ** download has been assembled/compiled to expect to be
-                ** loaded from 0x7FFF downwards. We have loaded it
-                ** at some other address. The startup code goes into the small
-                ** ram window at Sram2, in the last 8 bytes, which are really
-                ** at addresses 0x7FF8-0x7FFF.
-                **
-                ** If the loadbase is, say, 0x7C00, then we need to branch to
-                ** address 0x7BFE to run the host.bin startup code. We assemble
-                ** this jump manually.
-                **
-                ** The two byte sequence 60 08 is loaded into memory at address
-                ** 0x7FFE,F. This is a local branch to location 0x7FF8 (60 is nfix 0,
-                ** which adds '0' to the .O register, complements .O, and then shifts
-                ** it left by 4 bit positions, 08 is a jump .O+8 instruction. This will
-                ** add 8 to .O (which was 0xFFF0), and will branch RELATIVE to the new
-                ** location. Now, the branch starts from the value of .PC (or .IP or
-                ** whatever the bloody register is called on this chip), and the .PC
-                ** will be pointing to the location AFTER the branch, in this case
-                ** .PC == 0x8000, so the branch will be to 0x8000+0xFFF8 = 0x7FF8.
-                **
-                ** A long branch is coded at 0x7FF8. This consists of loading a four
-                ** byte offset into .O using nfix (as above) and pfix operators. The
-                ** pfix operates in exactly the same way as the nfix operator, but
-                ** without the complement operation. The offset, of course, must be
-                ** relative to the address of the byte AFTER the branch instruction,
-                ** which will be (urm) 0x7FFC, so, our final destination of the branch
-                ** (loadbase-2), has to be reached from here. Imagine that the loadbase
-                ** is 0x7C00 (which it is), then we will need to branch to 0x7BFE (which
-                ** is the first byte of the initial two byte short local branch of the
-                ** download code).
-                **
-                ** To code a jump from 0x7FFC (which is where the branch will start
-                ** from) to 0x7BFE, we will need to branch 0xFC02 bytes (0x7FFC+0xFC02)=
-                ** 0x7BFE.
-                ** This will be coded as four bytes:
-                ** 60 2C 20 02
-                ** being nfix .O+0
-                **         pfix .O+C
-                **         pfix .O+0
-                **         jump .O+2
-                **
-                ** The nfix operator is used, so that the startup code will be
-                ** compatible with the whole Tp family. (lies, damn lies, it'll never
-                ** work in a month of Sundays).
-                **
-                ** The nfix nyble is the 1s complement of the nyble value you
-                ** want to load - in this case we wanted 'F' so we nfix loaded '0'.
-                */
+                 ** We now need to insert a short boot section into
+                 ** the memory at the end of Sram2. This is normally (de)composed
+                 ** of the last eight bytes of the download code. The
+                 ** download has been assembled/compiled to expect to be
+                 ** loaded from 0x7FFF downwards. We have loaded it
+                 ** at some other address. The startup code goes into the small
+                 ** ram window at Sram2, in the last 8 bytes, which are really
+                 ** at addresses 0x7FF8-0x7FFF.
+                 **
+                 ** If the loadbase is, say, 0x7C00, then we need to branch to
+                 ** address 0x7BFE to run the host.bin startup code. We assemble
+                 ** this jump manually.
+                 **
+                 ** The two byte sequence 60 08 is loaded into memory at address
+                 ** 0x7FFE,F. This is a local branch to location 0x7FF8 (60 is nfix 0,
+                 ** which adds '0' to the .O register, complements .O, and then shifts
+                 ** it left by 4 bit positions, 08 is a jump .O+8 instruction. This will
+                 ** add 8 to .O (which was 0xFFF0), and will branch RELATIVE to the new
+                 ** location. Now, the branch starts from the value of .PC (or .IP or
+                 ** whatever the bloody register is called on this chip), and the .PC
+                 ** will be pointing to the location AFTER the branch, in this case
+                 ** .PC == 0x8000, so the branch will be to 0x8000+0xFFF8 = 0x7FF8.
+                 **
+                 ** A long branch is coded at 0x7FF8. This consists of loading a four
+                 ** byte offset into .O using nfix (as above) and pfix operators. The
+                 ** pfix operates in exactly the same way as the nfix operator, but
+                 ** without the complement operation. The offset, of course, must be
+                 ** relative to the address of the byte AFTER the branch instruction,
+                 ** which will be (urm) 0x7FFC, so, our final destination of the branch
+                 ** (loadbase-2), has to be reached from here. Imagine that the loadbase
+                 ** is 0x7C00 (which it is), then we will need to branch to 0x7BFE (which
+                 ** is the first byte of the initial two byte short local branch of the
+                 ** download code).
+                 **
+                 ** To code a jump from 0x7FFC (which is where the branch will start
+                 ** from) to 0x7BFE, we will need to branch 0xFC02 bytes (0x7FFC+0xFC02)=
+                 ** 0x7BFE.
+                 ** This will be coded as four bytes:
+                 ** 60 2C 20 02
+                 ** being nfix .O+0
+                 **        pfix .O+C
+                 **        pfix .O+0
+                 **        jump .O+2
+                 **
+                 ** The nfix operator is used, so that the startup code will be
+                 ** compatible with the whole Tp family. (lies, damn lies, it'll never
+                 ** work in a month of Sundays).
+                 **
+                 ** The nfix nyble is the 1s complement of the nyble value you
+                 ** want to load - in this case we wanted 'F' so we nfix loaded '0'.
+                 */
 
 
                 /*
-                ** Dest points to the top 8 bytes of Sram2. The Tp jumps
-                ** to 0x7FFE at reset time, and starts executing. This is
-                ** a short branch to 0x7FF8, where a long branch is coded.
-                */
+                 ** Dest points to the top 8 bytes of Sram2. The Tp jumps
+                 ** to 0x7FFE at reset time, and starts executing. This is
+                 ** a short branch to 0x7FF8, where a long branch is coded.
+                 */
 
-                DestP = (BYTE *)&Cad[0x7FF8];   /* <<<---- READ THE ABOVE COMMENTS */
+                DestP = (u8 *) &Cad[0x7FF8];    /* <<<---- READ THE ABOVE COMMENTS */
 
 #define NFIX(N) (0x60 | (N))    /* .O  = (~(.O + N))<<4 */
 #define PFIX(N) (0x20 | (N))    /* .O  =   (.O + N)<<4  */
-#define JUMP(N) (0x00 | (N))    /* .PC =   .PC + .O      */
+#define JUMP(N) (0x00 | (N))    /* .PC =   .PC + .O      */
 
                 /*
-                ** 0x7FFC is the address of the location following the last byte of
-                ** the four byte jump instruction.
-                ** READ THE ABOVE COMMENTS
-                **
-                ** offset is (TO-FROM) % MEMSIZE, but with compound buggering about.
-                ** Memsize is 64K for this range of Tp, so offset is a short (unsigned,
-                ** cos I don't understand 2's complement).
-                */
-                offset = (p->RIOConf.HostLoadBase-2)-0x7FFC;
-                WBYTE( DestP[0] , NFIX(((ushort)(~offset) >> (ushort)12) & 0xF) );
-                WBYTE( DestP[1] , PFIX(( offset >> 8) & 0xF) );
-                WBYTE( DestP[2] , PFIX(( offset >> 4) & 0xF) );
-                WBYTE( DestP[3] , JUMP( offset & 0xF) );
-
-                WBYTE( DestP[6] , NFIX(0) );
-                WBYTE( DestP[7] , JUMP(8) );
-
-                rio_dprintk (RIO_DEBUG_BOOT, "host loadbase is 0x%x\n",p->RIOConf.HostLoadBase);
-                rio_dprintk (RIO_DEBUG_BOOT, "startup offset is 0x%x\n",offset);
+                 ** 0x7FFC is the address of the location following the last byte of
+                 ** the four byte jump instruction.
+                 ** READ THE ABOVE COMMENTS
+                 **
+                 ** offset is (TO-FROM) % MEMSIZE, but with compound buggering about.
+                 ** Memsize is 64K for this range of Tp, so offset is a short (unsigned,
+                 ** cos I don't understand 2's complement).
+                 */
+                offset = (p->RIOConf.HostLoadBase - 2) - 0x7FFC;
+
+                writeb(NFIX(((unsigned short) (~offset) >> (unsigned short) 12) & 0xF), DestP);
+                writeb(PFIX((offset >> 8) & 0xF), DestP + 1);
+                writeb(PFIX((offset >> 4) & 0xF), DestP + 2);
+                writeb(JUMP(offset & 0xF), DestP + 3);
+
+                writeb(NFIX(0), DestP + 6);
+                writeb(JUMP(8), DestP + 7);
+
+                rio_dprintk(RIO_DEBUG_BOOT, "host loadbase is 0x%x\n", p->RIOConf.HostLoadBase);
+                rio_dprintk(RIO_DEBUG_BOOT, "startup offset is 0x%x\n", offset);
 
                 /*
-                ** Flag what is going on
-                */
+                 ** Flag what is going on
+                 */
                 HostP->Flags &= ~RUN_STATE;
                 HostP->Flags |= RC_STARTUP;
 
                 /*
-                ** Grab a copy of the current ParmMap pointer, so we
-                ** can tell when it has changed.
-                */
-                OldParmMap = RWORD(HostP->__ParmMapR);
+                 ** Grab a copy of the current ParmMap pointer, so we
+                 ** can tell when it has changed.
+                 */
+                OldParmMap = readw(&HostP->__ParmMapR);
 
-                rio_dprintk (RIO_DEBUG_BOOT, "Original parmmap is 0x%x\n",OldParmMap);
+                rio_dprintk(RIO_DEBUG_BOOT, "Original parmmap is 0x%x\n", OldParmMap);
 
                 /*
-                ** And start it running (I hope).
-                ** As there is nothing dodgy or obscure about the
-                ** above code, this is guaranteed to work every time.
-                */
-                rio_dprintk (RIO_DEBUG_BOOT,  "Host Type = 0x%x, Mode = 0x%x, IVec = 0x%x\n",
-                    HostP->Type, HostP->Mode, HostP->Ivec);
+                 ** And start it running (I hope).
+                 ** As there is nothing dodgy or obscure about the
+                 ** above code, this is guaranteed to work every time.
+                 */
+                rio_dprintk(RIO_DEBUG_BOOT, "Host Type = 0x%x, Mode = 0x%x, IVec = 0x%x\n", HostP->Type, HostP->Mode, HostP->Ivec);
 
                 rio_start_card_running(HostP);
 
-                rio_dprintk (RIO_DEBUG_BOOT, "Set control port\n");
+                rio_dprintk(RIO_DEBUG_BOOT, "Set control port\n");
 
                 /*
-                ** Now, wait for upto five seconds for the Tp to setup the parmmap
-                ** pointer:
-                */
-                for ( wait_count=0; (wait_count<p->RIOConf.StartupTime)&&
-                        (RWORD(HostP->__ParmMapR)==OldParmMap); wait_count++ ) {
-                        rio_dprintk (RIO_DEBUG_BOOT, "Checkout %d, 0x%x\n",wait_count,RWORD(HostP->__ParmMapR));
-                        delay(HostP, HUNDRED_MS);
+                 ** Now, wait for upto five seconds for the Tp to setup the parmmap
+                 ** pointer:
+                 */
+                for (wait_count = 0; (wait_count < p->RIOConf.StartupTime) && (readw(&HostP->__ParmMapR) == OldParmMap); wait_count++) {
+                        rio_dprintk(RIO_DEBUG_BOOT, "Checkout %d, 0x%x\n", wait_count, readw(&HostP->__ParmMapR));
+                        mdelay(100);
 
                 }
 
                 /*
-                ** If the parmmap pointer is unchanged, then the host code
-                ** has crashed & burned in a really spectacular way
-                */
-                if ( RWORD(HostP->__ParmMapR) == OldParmMap ) {
-                        rio_dprintk (RIO_DEBUG_BOOT, "parmmap 0x%x\n", RWORD(HostP->__ParmMapR));
-                        rio_dprintk (RIO_DEBUG_BOOT, "RIO Mesg Run Fail\n");
-
-#define HOST_DISABLE \
-                HostP->Flags &= ~RUN_STATE; \
-                HostP->Flags |= RC_STUFFED; \
-                RIOHostReset( HostP->Type, (struct DpRam *)HostP->CardP, HostP->Slot );\
-                continue
-
-                        HOST_DISABLE;
+                 ** If the parmmap pointer is unchanged, then the host code
+                 ** has crashed & burned in a really spectacular way
+                 */
+                if (readw(&HostP->__ParmMapR) == OldParmMap) {
+                        rio_dprintk(RIO_DEBUG_BOOT, "parmmap 0x%x\n", readw(&HostP->__ParmMapR));
+                        rio_dprintk(RIO_DEBUG_BOOT, "RIO Mesg Run Fail\n");
+                        HostP->Flags &= ~RUN_STATE;
+                        HostP->Flags |= RC_STUFFED;
+                        RIOHostReset( HostP->Type, (struct DpRam *)HostP->CardP, HostP->Slot );
+                        continue;
                 }
 
-                rio_dprintk (RIO_DEBUG_BOOT, "Running 0x%x\n", RWORD(HostP->__ParmMapR));
+                rio_dprintk(RIO_DEBUG_BOOT, "Running 0x%x\n", readw(&HostP->__ParmMapR));
 
                 /*
-                ** Well, the board thought it was OK, and setup its parmmap
-                ** pointer. For the time being, we will pretend that this
-                ** board is running, and check out what the error flag says.
-                */
+                 ** Well, the board thought it was OK, and setup its parmmap
+                 ** pointer. For the time being, we will pretend that this
+                 ** board is running, and check out what the error flag says.
+                 */
 
                 /*
-                ** Grab a 32 bit pointer to the parmmap structure
-                */
-                ParmMapP = (PARM_MAP *)RIO_PTR(Cad,RWORD(HostP->__ParmMapR));
-                rio_dprintk (RIO_DEBUG_BOOT, "ParmMapP : %x\n", (int)ParmMapP);
-                ParmMapP = (PARM_MAP *)((unsigned long)Cad + 
-                                                (unsigned long)((RWORD((HostP->__ParmMapR))) & 0xFFFF)); 
-                rio_dprintk (RIO_DEBUG_BOOT, "ParmMapP : %x\n", (int)ParmMapP);
+                 ** Grab a 32 bit pointer to the parmmap structure
+                 */
+                ParmMapP = (PARM_MAP *) RIO_PTR(Cad, readw(&HostP->__ParmMapR));
+                rio_dprintk(RIO_DEBUG_BOOT, "ParmMapP : %p\n", ParmMapP);
+                ParmMapP = (PARM_MAP *) ((unsigned long) Cad + readw(&HostP->__ParmMapR));
+                rio_dprintk(RIO_DEBUG_BOOT, "ParmMapP : %p\n", ParmMapP);
 
                 /*
-                ** The links entry should be 0xFFFF; we set it up
-                ** with a mask to say how many PHBs to use, and 
-                ** which links to use.
-                */
-                if ( (RWORD(ParmMapP->links) & 0xFFFF) != 0xFFFF ) {
-                        rio_dprintk (RIO_DEBUG_BOOT, "RIO Mesg Run Fail %s\n", HostP->Name);
-                        rio_dprintk (RIO_DEBUG_BOOT, "Links = 0x%x\n",RWORD(ParmMapP->links));
-                        HOST_DISABLE;
+                 ** The links entry should be 0xFFFF; we set it up
+                 ** with a mask to say how many PHBs to use, and
+                 ** which links to use.
+                 */
+                if (readw(&ParmMapP->links) != 0xFFFF) {
+                        rio_dprintk(RIO_DEBUG_BOOT, "RIO Mesg Run Fail %s\n", HostP->Name);
+                        rio_dprintk(RIO_DEBUG_BOOT, "Links = 0x%x\n", readw(&ParmMapP->links));
+                        HostP->Flags &= ~RUN_STATE;
+                        HostP->Flags |= RC_STUFFED;
+                        RIOHostReset( HostP->Type, (struct DpRam *)HostP->CardP, HostP->Slot );
+                        continue;
                 }
 
-                WWORD(ParmMapP->links , RIO_LINK_ENABLE);
+                writew(RIO_LINK_ENABLE, &ParmMapP->links);
 
                 /*
-                ** now wait for the card to set all the parmmap->XXX stuff
-                ** this is a wait of upto two seconds....
-                */
-                rio_dprintk (RIO_DEBUG_BOOT, "Looking for init_done - %d ticks\n",p->RIOConf.StartupTime);
+                 ** now wait for the card to set all the parmmap->XXX stuff
+                 ** this is a wait of upto two seconds....
+                 */
+                rio_dprintk(RIO_DEBUG_BOOT, "Looking for init_done - %d ticks\n", p->RIOConf.StartupTime);
                 HostP->timeout_id = 0;
-                for ( wait_count=0; (wait_count<p->RIOConf.StartupTime) && 
-                                                !RWORD(ParmMapP->init_done); wait_count++ ) {
-                        rio_dprintk (RIO_DEBUG_BOOT, "Waiting for init_done\n");
-                        delay(HostP, HUNDRED_MS);
+                for (wait_count = 0; (wait_count < p->RIOConf.StartupTime) && !readw(&ParmMapP->init_done); wait_count++) {
+                        rio_dprintk(RIO_DEBUG_BOOT, "Waiting for init_done\n");
+                        mdelay(100);
                 }
-                rio_dprintk (RIO_DEBUG_BOOT, "OK! init_done!\n");
-
-                if (RWORD(ParmMapP->error) != E_NO_ERROR || 
-                                                        !RWORD(ParmMapP->init_done) ) {
-                        rio_dprintk (RIO_DEBUG_BOOT, "RIO Mesg Run Fail %s\n", HostP->Name);
-                        rio_dprintk (RIO_DEBUG_BOOT, "Timedout waiting for init_done\n");
-                        HOST_DISABLE;
+                rio_dprintk(RIO_DEBUG_BOOT, "OK! init_done!\n");
+
+                if (readw(&ParmMapP->error) != E_NO_ERROR || !readw(&ParmMapP->init_done)) {
+                        rio_dprintk(RIO_DEBUG_BOOT, "RIO Mesg Run Fail %s\n", HostP->Name);
+                        rio_dprintk(RIO_DEBUG_BOOT, "Timedout waiting for init_done\n");
+                        HostP->Flags &= ~RUN_STATE;
+                        HostP->Flags |= RC_STUFFED;
+                        RIOHostReset( HostP->Type, (struct DpRam *)HostP->CardP, HostP->Slot );
+                        continue;
                 }
 
-                rio_dprintk (RIO_DEBUG_BOOT, "Got init_done\n");
+                rio_dprintk(RIO_DEBUG_BOOT, "Got init_done\n");
 
                 /*
-                ** It runs! It runs!
-                */
-                rio_dprintk (RIO_DEBUG_BOOT, "Host ID %x Running\n",HostP->UniqueNum);
+                 ** It runs! It runs!
+                 */
+                rio_dprintk(RIO_DEBUG_BOOT, "Host ID %x Running\n", HostP->UniqueNum);
 
                 /*
-                ** set the time period between interrupts.
-                */
-                WWORD(ParmMapP->timer, (short)p->RIOConf.Timer );
+                 ** set the time period between interrupts.
+                 */
+                writew(p->RIOConf.Timer, &ParmMapP->timer);
 
                 /*
-                ** Translate all the 16 bit pointers in the __ParmMapR into
-                ** 32 bit pointers for the driver.
-                */
-                HostP->ParmMapP  =      ParmMapP;
-                HostP->PhbP              =      (PHB*)RIO_PTR(Cad,RWORD(ParmMapP->phb_ptr));
-                HostP->RupP              =      (RUP*)RIO_PTR(Cad,RWORD(ParmMapP->rups));
-                HostP->PhbNumP    = (ushort*)RIO_PTR(Cad,RWORD(ParmMapP->phb_num_ptr));
-                HostP->LinkStrP  =      (LPB*)RIO_PTR(Cad,RWORD(ParmMapP->link_str_ptr));
+                 ** Translate all the 16 bit pointers in the __ParmMapR into
+                 ** 32 bit pointers for the driver in ioremap space.
+                 */
+                HostP->ParmMapP = ParmMapP;
+                HostP->PhbP = (struct PHB *) RIO_PTR(Cad, readw(&ParmMapP->phb_ptr));
+                HostP->RupP = (struct RUP *) RIO_PTR(Cad, readw(&ParmMapP->rups));
+                HostP->PhbNumP = (unsigned short *) RIO_PTR(Cad, readw(&ParmMapP->phb_num_ptr));
+                HostP->LinkStrP = (struct LPB *) RIO_PTR(Cad, readw(&ParmMapP->link_str_ptr));
 
                 /*
-                ** point the UnixRups at the real Rups
-                */
-                for ( RupN = 0; RupN<MAX_RUP; RupN++ ) {
-                        HostP->UnixRups[RupN].RupP              = &HostP->RupP[RupN];
-                        HostP->UnixRups[RupN].Id                  = RupN+1;
+                 ** point the UnixRups at the real Rups
+                 */
+                for (RupN = 0; RupN < MAX_RUP; RupN++) {
+                        HostP->UnixRups[RupN].RupP = &HostP->RupP[RupN];
+                        HostP->UnixRups[RupN].Id = RupN + 1;
                         HostP->UnixRups[RupN].BaseSysPort = NO_PORT;
                         spin_lock_init(&HostP->UnixRups[RupN].RupLock);
                 }
 
-                for ( RupN = 0; RupN<LINKS_PER_UNIT; RupN++ ) {
-                        HostP->UnixRups[RupN+MAX_RUP].RupP      = &HostP->LinkStrP[RupN].rup;
-                        HostP->UnixRups[RupN+MAX_RUP].Id  = 0;
-                        HostP->UnixRups[RupN+MAX_RUP].BaseSysPort = NO_PORT;
-                        spin_lock_init(&HostP->UnixRups[RupN+MAX_RUP].RupLock);
+                for (RupN = 0; RupN < LINKS_PER_UNIT; RupN++) {
+                        HostP->UnixRups[RupN + MAX_RUP].RupP = &HostP->LinkStrP[RupN].rup;
+                        HostP->UnixRups[RupN + MAX_RUP].Id = 0;
+                        HostP->UnixRups[RupN + MAX_RUP].BaseSysPort = NO_PORT;
+                        spin_lock_init(&HostP->UnixRups[RupN + MAX_RUP].RupLock);
                 }
 
                 /*
-                ** point the PortP->Phbs at the real Phbs
-                */
-                for ( PortN=p->RIOFirstPortsMapped; 
-                                PortN<p->RIOLastPortsMapped+PORTS_PER_RTA; PortN++ ) {
-                        if ( p->RIOPortp[PortN]->HostP == HostP ) {
+                 ** point the PortP->Phbs at the real Phbs
+                 */
+                for (PortN = p->RIOFirstPortsMapped; PortN < p->RIOLastPortsMapped + PORTS_PER_RTA; PortN++) {
+                        if (p->RIOPortp[PortN]->HostP == HostP) {
                                 struct Port *PortP = p->RIOPortp[PortN];
                                 struct PHB *PhbP;
                                 /* int oldspl; */
 
-                                if ( !PortP->Mapped )
+                                if (!PortP->Mapped)
                                         continue;
 
                                 PhbP = &HostP->PhbP[PortP->HostPort];
@@ -610,641 +550,522 @@ register struct DownLoad *rbp;
 
                                 PortP->PhbP = PhbP;
 
-                                PortP->TxAdd    = (WORD *)RIO_PTR(Cad,RWORD(PhbP->tx_add));
-                                PortP->TxStart  = (WORD *)RIO_PTR(Cad,RWORD(PhbP->tx_start));
-                                PortP->TxEnd    = (WORD *)RIO_PTR(Cad,RWORD(PhbP->tx_end));
-                                PortP->RxRemove = (WORD *)RIO_PTR(Cad,RWORD(PhbP->rx_remove));
-                                PortP->RxStart  = (WORD *)RIO_PTR(Cad,RWORD(PhbP->rx_start));
-                                PortP->RxEnd    = (WORD *)RIO_PTR(Cad,RWORD(PhbP->rx_end));
+                                PortP->TxAdd = (u16 *) RIO_PTR(Cad, readw(&PhbP->tx_add));
+                                PortP->TxStart = (u16 *) RIO_PTR(Cad, readw(&PhbP->tx_start));
+                                PortP->TxEnd = (u16 *) RIO_PTR(Cad, readw(&PhbP->tx_end));
+                                PortP->RxRemove = (u16 *) RIO_PTR(Cad, readw(&PhbP->rx_remove));
+                                PortP->RxStart = (u16 *) RIO_PTR(Cad, readw(&PhbP->rx_start));
+                                PortP->RxEnd = (u16 *) RIO_PTR(Cad, readw(&PhbP->rx_end));
 
                                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
                                 /*
-                                ** point the UnixRup at the base SysPort
-                                */
-                                if ( !(PortN % PORTS_PER_RTA) )
+                                 ** point the UnixRup at the base SysPort
+                                 */
+                                if (!(PortN % PORTS_PER_RTA))
                                         HostP->UnixRups[PortP->RupNum].BaseSysPort = PortN;
                         }
                 }
 
-                rio_dprintk (RIO_DEBUG_BOOT, "Set the card running... \n");
+                rio_dprintk(RIO_DEBUG_BOOT, "Set the card running... \n");
                 /*
-                ** last thing - show the world that everything is in place
-                */
+                 ** last thing - show the world that everything is in place
+                 */
                 HostP->Flags &= ~RUN_STATE;
                 HostP->Flags |= RC_RUNNING;
         }
         /*
-        ** MPX always uses a poller. This is actually patched into the system
-        ** configuration and called directly from each clock tick.
-        **
-        */
+         ** MPX always uses a poller. This is actually patched into the system
+         ** configuration and called directly from each clock tick.
+         **
+         */
         p->RIOPolling = 1;
 
         p->RIOSystemUp++;
-        
-        rio_dprintk (RIO_DEBUG_BOOT, "Done everything %x\n", HostP->Ivec);
-        func_exit ();
+
+        rio_dprintk(RIO_DEBUG_BOOT, "Done everything %x\n", HostP->Ivec);
+        func_exit();
         return 0;
 }
 
 
 
-/*
-** Boot an RTA. If we have successfully processed this boot, then
-** return 1. If we havent, then return 0.
-*/
-int
-RIOBootRup( p, Rup, HostP, PacketP)
-struct rio_info *       p;
-uint Rup;
-struct Host *HostP;
-struct PKT *PacketP; 
+/**
+ *      RIOBootRup              -       Boot an RTA
+ *      @p: rio we are working with
+ *      @Rup: Rup number
+ *      @HostP: host object
+ *      @PacketP: packet to use
+ *
+ *      If we have successfully processed this boot, then
+ *      return 1. If we havent, then return 0.
+ */
+
+int RIOBootRup(struct rio_info *p, unsigned int Rup, struct Host *HostP, struct PKT *PacketP)
 {
-        struct PktCmd *PktCmdP = (struct PktCmd *)PacketP->data;
+        struct PktCmd *PktCmdP = (struct PktCmd *) PacketP->data;
         struct PktCmd_M *PktReplyP;
         struct CmdBlk *CmdBlkP;
-        uint sequence;
+        unsigned int sequence;
 
         /*
-        ** If we haven't been told what to boot, we can't boot it.
-        */
-        if ( p->RIONumBootPkts == 0 ) {
-                rio_dprintk (RIO_DEBUG_BOOT, "No RTA code to download yet\n");
+         ** If we haven't been told what to boot, we can't boot it.
+         */
+        if (p->RIONumBootPkts == 0) {
+                rio_dprintk(RIO_DEBUG_BOOT, "No RTA code to download yet\n");
                 return 0;
         }
 
-        /* rio_dprint(RIO_DEBUG_BOOT, NULL,DBG_BOOT,"Incoming command packet\n"); */
-        /* ShowPacket( DBG_BOOT, PacketP ); */
-
         /*
-        ** Special case of boot completed - if we get one of these then we
-        ** don't need a command block. For all other cases we do, so handle
-        ** this first and then get a command block, then handle every other
-        ** case, relinquishing the command block if disaster strikes!
-        */
-        if ( (RBYTE(PacketP->len) & PKT_CMD_BIT) && 
-                        (RBYTE(PktCmdP->Command)==BOOT_COMPLETED) )
-                return RIOBootComplete(p, HostP, Rup, PktCmdP );
+         ** Special case of boot completed - if we get one of these then we
+         ** don't need a command block. For all other cases we do, so handle
+         ** this first and then get a command block, then handle every other
+         ** case, relinquishing the command block if disaster strikes!
+         */
+        if ((readb(&PacketP->len) & PKT_CMD_BIT) && (readb(&PktCmdP->Command) == BOOT_COMPLETED))
+                return RIOBootComplete(p, HostP, Rup, PktCmdP);
 
         /*
-        ** try to unhook a command block from the command free list.
-        */
-        if ( !(CmdBlkP = RIOGetCmdBlk()) ) {
-                rio_dprintk (RIO_DEBUG_BOOT, "No command blocks to boot RTA! come back later.\n");
+         ** Try to allocate a command block. This is in kernel space
+         */
+        if (!(CmdBlkP = RIOGetCmdBlk())) {
+                rio_dprintk(RIO_DEBUG_BOOT, "No command blocks to boot RTA! come back later.\n");
                 return 0;
         }
 
         /*
-        ** Fill in the default info on the command block
-        */
-        CmdBlkP->Packet.dest_unit = Rup < (ushort)MAX_RUP ? Rup : 0;
+         ** Fill in the default info on the command block
+         */
+        CmdBlkP->Packet.dest_unit = Rup < (unsigned short) MAX_RUP ? Rup : 0;
         CmdBlkP->Packet.dest_port = BOOT_RUP;
-        CmdBlkP->Packet.src_unit  = 0;
-        CmdBlkP->Packet.src_port  = BOOT_RUP;
+        CmdBlkP->Packet.src_unit = 0;
+        CmdBlkP->Packet.src_port = BOOT_RUP;
 
         CmdBlkP->PreFuncP = CmdBlkP->PostFuncP = NULL;
-        PktReplyP = (struct PktCmd_M *)CmdBlkP->Packet.data;
+        PktReplyP = (struct PktCmd_M *) CmdBlkP->Packet.data;
 
         /*
-        ** process COMMANDS on the boot rup!
-        */
-        if ( RBYTE(PacketP->len) & PKT_CMD_BIT ) {
+         ** process COMMANDS on the boot rup!
+         */
+        if (readb(&PacketP->len) & PKT_CMD_BIT) {
                 /*
-                ** We only expect one type of command - a BOOT_REQUEST!
-                */
-                if ( RBYTE(PktCmdP->Command) != BOOT_REQUEST ) {
-                        rio_dprintk (RIO_DEBUG_BOOT, "Unexpected command %d on BOOT RUP %d of host %d\n", 
-                                                PktCmdP->Command,Rup,HostP-p->RIOHosts);
-                        ShowPacket( DBG_BOOT, PacketP );
-                        RIOFreeCmdBlk( CmdBlkP );
+                 ** We only expect one type of command - a BOOT_REQUEST!
+                 */
+                if (readb(&PktCmdP->Command) != BOOT_REQUEST) {
+                        rio_dprintk(RIO_DEBUG_BOOT, "Unexpected command %d on BOOT RUP %d of host %Zd\n", readb(&PktCmdP->Command), Rup, HostP - p->RIOHosts);
+                        RIOFreeCmdBlk(CmdBlkP);
                         return 1;
                 }
 
                 /*
-                ** Build a Boot Sequence command block
-                **
-                ** 02.03.1999 ARG - ESIL 0820 fix
-                ** We no longer need to use "Boot Mode", we'll always allow
-                ** boot requests - the boot will not complete if the device
-                ** appears in the bindings table.
-                ** So, this conditional is not required ...
-                **
-                if (p->RIOBootMode == RC_BOOT_NONE)
-                        **
-                        ** If the system is in slave mode, and a boot request is
-                        ** received, set command to BOOT_ABORT so that the boot
-                        ** will not complete.
-                        **
-                        PktReplyP->Command                       = BOOT_ABORT;
-                else
-                **
-                ** We'll just (always) set the command field in packet reply
-                ** to allow an attempted boot sequence :
-                */
+                 ** Build a Boot Sequence command block
+                 **
+                 ** We no longer need to use "Boot Mode", we'll always allow
+                 ** boot requests - the boot will not complete if the device
+                 ** appears in the bindings table.
+                 **
+                 ** We'll just (always) set the command field in packet reply
+                 ** to allow an attempted boot sequence :
+                 */
                 PktReplyP->Command = BOOT_SEQUENCE;
 
                 PktReplyP->BootSequence.NumPackets = p->RIONumBootPkts;
-                PktReplyP->BootSequence.LoadBase   = p->RIOConf.RtaLoadBase;
-                PktReplyP->BootSequence.CodeSize   = p->RIOBootCount;
+                PktReplyP->BootSequence.LoadBase = p->RIOConf.RtaLoadBase;
+                PktReplyP->BootSequence.CodeSize = p->RIOBootCount;
 
-                CmdBlkP->Packet.len                             = BOOT_SEQUENCE_LEN | PKT_CMD_BIT;
+                CmdBlkP->Packet.len = BOOT_SEQUENCE_LEN | PKT_CMD_BIT;
 
-                bcopy("BOOT",(void *)&CmdBlkP->Packet.data[BOOT_SEQUENCE_LEN],4);
+                memcpy((void *) &CmdBlkP->Packet.data[BOOT_SEQUENCE_LEN], "BOOT", 4);
 
-                rio_dprintk (RIO_DEBUG_BOOT, "Boot RTA on Host %d Rup %d - %d (0x%x) packets to 0x%x\n",
-                        HostP-p->RIOHosts, Rup, p->RIONumBootPkts, p->RIONumBootPkts, 
-                                                                p->RIOConf.RtaLoadBase);
+                rio_dprintk(RIO_DEBUG_BOOT, "Boot RTA on Host %Zd Rup %d - %d (0x%x) packets to 0x%x\n", HostP - p->RIOHosts, Rup, p->RIONumBootPkts, p->RIONumBootPkts, p->RIOConf.RtaLoadBase);
 
                 /*
-                ** If this host is in slave mode, send the RTA an invalid boot
-                ** sequence command block to force it to kill the boot. We wait
-                ** for half a second before sending this packet to prevent the RTA
-                ** attempting to boot too often. The master host should then grab
-                ** the RTA and make it its own.
-                */
+                 ** If this host is in slave mode, send the RTA an invalid boot
+                 ** sequence command block to force it to kill the boot. We wait
+                 ** for half a second before sending this packet to prevent the RTA
+                 ** attempting to boot too often. The master host should then grab
+                 ** the RTA and make it its own.
+                 */
                 p->RIOBooting++;
-                RIOQueueCmdBlk( HostP, Rup, CmdBlkP );
+                RIOQueueCmdBlk(HostP, Rup, CmdBlkP);
                 return 1;
         }
 
         /*
-        ** It is a request for boot data.
-        */
-        sequence = RWORD(PktCmdP->Sequence);
+         ** It is a request for boot data.
+         */
+        sequence = readw(&PktCmdP->Sequence);
 
-        rio_dprintk (RIO_DEBUG_BOOT, "Boot block %d on Host %d Rup%d\n",sequence,HostP-p->RIOHosts,Rup);
+        rio_dprintk(RIO_DEBUG_BOOT, "Boot block %d on Host %Zd Rup%d\n", sequence, HostP - p->RIOHosts, Rup);
 
-        if ( sequence >= p->RIONumBootPkts ) {
-                rio_dprintk (RIO_DEBUG_BOOT, "Got a request for packet %d, max is %d\n", sequence, 
-                                        p->RIONumBootPkts);
-                ShowPacket( DBG_BOOT, PacketP );
+        if (sequence >= p->RIONumBootPkts) {
+                rio_dprintk(RIO_DEBUG_BOOT, "Got a request for packet %d, max is %d\n", sequence, p->RIONumBootPkts);
         }
 
         PktReplyP->Sequence = sequence;
-
-        bcopy( p->RIOBootPackets[ p->RIONumBootPkts - sequence - 1 ], 
-                                PktReplyP->BootData, RTA_BOOT_DATA_SIZE );
-
+        memcpy(PktReplyP->BootData, p->RIOBootPackets[p->RIONumBootPkts - sequence - 1], RTA_BOOT_DATA_SIZE);
         CmdBlkP->Packet.len = PKT_MAX_DATA_LEN;
-        ShowPacket( DBG_BOOT, &CmdBlkP->Packet );
-        RIOQueueCmdBlk( HostP, Rup, CmdBlkP );
+        RIOQueueCmdBlk(HostP, Rup, CmdBlkP);
         return 1;
 }
 
-/*
-** This function is called when an RTA been booted.
-** If booted by a host, HostP->HostUniqueNum is the booting host.
-** If booted by an RTA, HostP->Mapping[Rup].RtaUniqueNum is the booting RTA.
-** RtaUniq is the booted RTA.
-*/
-static int RIOBootComplete( struct rio_info *p, struct Host *HostP, uint Rup, struct PktCmd *PktCmdP )
+/**
+ *      RIOBootComplete         -       RTA boot is done
+ *      @p: RIO we are working with
+ *      @HostP: Host structure
+ *      @Rup: RUP being used
+ *      @PktCmdP: Packet command that was used
+ *
+ *      This function is called when an RTA been booted.
+ *      If booted by a host, HostP->HostUniqueNum is the booting host.
+ *      If booted by an RTA, HostP->Mapping[Rup].RtaUniqueNum is the booting RTA.
+ *      RtaUniq is the booted RTA.
+ */
+
+static int RIOBootComplete(struct rio_info *p, struct Host *HostP, unsigned int Rup, struct PktCmd *PktCmdP)
 {
-        struct Map      *MapP = NULL;
-        struct Map      *MapP2 = NULL;
-        int     Flag;
-        int     found;
-        int     host, rta;
-        int     EmptySlot = -1;
-        int     entry, entry2;
-        char    *MyType, *MyName;
-        uint    MyLink;
-        ushort  RtaType;
-        uint    RtaUniq = (RBYTE(PktCmdP->UniqNum[0])) +
-                          (RBYTE(PktCmdP->UniqNum[1]) << 8) +
-                          (RBYTE(PktCmdP->UniqNum[2]) << 16) +
-                          (RBYTE(PktCmdP->UniqNum[3]) << 24);
-
-        /* Was RIOBooting-- . That's bad. If an RTA sends two of them, the
-           driver will never think that the RTA has booted... -- REW */
+        struct Map *MapP = NULL;
+        struct Map *MapP2 = NULL;
+        int Flag;
+        int found;
+        int host, rta;
+        int EmptySlot = -1;
+        int entry, entry2;
+        char *MyType, *MyName;
+        unsigned int MyLink;
+        unsigned short RtaType;
+        u32 RtaUniq = (readb(&PktCmdP->UniqNum[0])) + (readb(&PktCmdP->UniqNum[1]) << 8) + (readb(&PktCmdP->UniqNum[2]) << 16) + (readb(&PktCmdP->UniqNum[3]) << 24);
+
         p->RIOBooting = 0;
 
-        rio_dprintk (RIO_DEBUG_BOOT, "RTA Boot completed - BootInProgress now %d\n", p->RIOBooting);
+        rio_dprintk(RIO_DEBUG_BOOT, "RTA Boot completed - BootInProgress now %d\n", p->RIOBooting);
 
         /*
-        ** Determine type of unit (16/8 port RTA).
-        */
+         ** Determine type of unit (16/8 port RTA).
+         */
+
         RtaType = GetUnitType(RtaUniq);
-        if ( Rup >= (ushort)MAX_RUP ) {
-            rio_dprintk (RIO_DEBUG_BOOT, "RIO: Host %s has booted an RTA(%d) on link %c\n",
-             HostP->Name, 8 * RtaType, RBYTE(PktCmdP->LinkNum)+'A');
-        } else {
-            rio_dprintk (RIO_DEBUG_BOOT, "RIO: RTA %s has booted an RTA(%d) on link %c\n",
-             HostP->Mapping[Rup].Name, 8 * RtaType,
-             RBYTE(PktCmdP->LinkNum)+'A');
-        }
+        if (Rup >= (unsigned short) MAX_RUP)
+                rio_dprintk(RIO_DEBUG_BOOT, "RIO: Host %s has booted an RTA(%d) on link %c\n", HostP->Name, 8 * RtaType, readb(&PktCmdP->LinkNum) + 'A');
+        else
+                rio_dprintk(RIO_DEBUG_BOOT, "RIO: RTA %s has booted an RTA(%d) on link %c\n", HostP->Mapping[Rup].Name, 8 * RtaType, readb(&PktCmdP->LinkNum) + 'A');
 
-        rio_dprintk (RIO_DEBUG_BOOT, "UniqNum is 0x%x\n",RtaUniq);
+        rio_dprintk(RIO_DEBUG_BOOT, "UniqNum is 0x%x\n", RtaUniq);
 
-        if ( ( RtaUniq == 0x00000000 ) || ( RtaUniq == 0xffffffff ) )
-        {
-            rio_dprintk (RIO_DEBUG_BOOT, "Illegal RTA Uniq Number\n");
-            return TRUE;
+        if (RtaUniq == 0x00000000 || RtaUniq == 0xffffffff) {
+                rio_dprintk(RIO_DEBUG_BOOT, "Illegal RTA Uniq Number\n");
+                return 1;
         }
 
         /*
-        ** If this RTA has just booted an RTA which doesn't belong to this
-        ** system, or the system is in slave mode, do not attempt to create
-        ** a new table entry for it.
-        */
-        if (!RIOBootOk(p, HostP, RtaUniq))
-        {
-            MyLink = RBYTE(PktCmdP->LinkNum);
-            if (Rup < (ushort) MAX_RUP)
-            {
-                /*
-                ** RtaUniq was clone booted (by this RTA). Instruct this RTA
-                ** to hold off further attempts to boot on this link for 30
-                ** seconds.
-                */
-                if (RIOSuspendBootRta(HostP, HostP->Mapping[Rup].ID, MyLink))
-                {
-                    rio_dprintk (RIO_DEBUG_BOOT, "RTA failed to suspend booting on link %c\n",
-                     'A' + MyLink);
-                }
-            }
-            else
-            {
-                /*
-                ** RtaUniq was booted by this host. Set the booting link
-                ** to hold off for 30 seconds to give another unit a
-                ** chance to boot it.
-                */
-                WWORD(HostP->LinkStrP[MyLink].WaitNoBoot, 30);
-            }
-            rio_dprintk (RIO_DEBUG_BOOT, "RTA %x not owned - suspend booting down link %c on unit %x\n",
-              RtaUniq, 'A' + MyLink, HostP->Mapping[Rup].RtaUniqueNum);
-            return TRUE;
+         ** If this RTA has just booted an RTA which doesn't belong to this
+         ** system, or the system is in slave mode, do not attempt to create
+         ** a new table entry for it.
+         */
+
+        if (!RIOBootOk(p, HostP, RtaUniq)) {
+                MyLink = readb(&PktCmdP->LinkNum);
+                if (Rup < (unsigned short) MAX_RUP) {
+                        /*
+                         ** RtaUniq was clone booted (by this RTA). Instruct this RTA
+                         ** to hold off further attempts to boot on this link for 30
+                         ** seconds.
+                         */
+                        if (RIOSuspendBootRta(HostP, HostP->Mapping[Rup].ID, MyLink)) {
+                                rio_dprintk(RIO_DEBUG_BOOT, "RTA failed to suspend booting on link %c\n", 'A' + MyLink);
+                        }
+                } else
+                        /*
+                         ** RtaUniq was booted by this host. Set the booting link
+                         ** to hold off for 30 seconds to give another unit a
+                         ** chance to boot it.
+                         */
+                        writew(30, &HostP->LinkStrP[MyLink].WaitNoBoot);
+                rio_dprintk(RIO_DEBUG_BOOT, "RTA %x not owned - suspend booting down link %c on unit %x\n", RtaUniq, 'A' + MyLink, HostP->Mapping[Rup].RtaUniqueNum);
+                return 1;
         }
 
         /*
-        ** Check for a SLOT_IN_USE entry for this RTA attached to the
-        ** current host card in the driver table.
-        **
-        ** If it exists, make a note that we have booted it. Other parts of
-        ** the driver are interested in this information at a later date,
-        ** in particular when the booting RTA asks for an ID for this unit,
-        ** we must have set the BOOTED flag, and the NEWBOOT flag is used
-        ** to force an open on any ports that where previously open on this
-        ** unit.
-        */
-        for ( entry=0; entry<MAX_RUP; entry++ )
-        {
-            uint sysport;
-
-            if ((HostP->Mapping[entry].Flags & SLOT_IN_USE) && 
-               (HostP->Mapping[entry].RtaUniqueNum==RtaUniq))
-            {
-                HostP->Mapping[entry].Flags |= RTA_BOOTED|RTA_NEWBOOT;
-#ifdef NEED_TO_FIX
-                RIO_SV_BROADCAST(HostP->svFlags[entry]);
-#endif
-                if ( (sysport=HostP->Mapping[entry].SysPort) != NO_PORT )
-                {
-                   if ( sysport < p->RIOFirstPortsBooted )
-                        p->RIOFirstPortsBooted = sysport;
-                   if ( sysport > p->RIOLastPortsBooted )
-                        p->RIOLastPortsBooted = sysport;
-                   /*
-                   ** For a 16 port RTA, check the second bank of 8 ports
-                   */
-                   if (RtaType == TYPE_RTA16)
-                   {
-                        entry2 = HostP->Mapping[entry].ID2 - 1;
-                        HostP->Mapping[entry2].Flags |= RTA_BOOTED|RTA_NEWBOOT;
-#ifdef NEED_TO_FIX
-                        RIO_SV_BROADCAST(HostP->svFlags[entry2]);
-#endif
-                        sysport = HostP->Mapping[entry2].SysPort;
-                        if ( sysport < p->RIOFirstPortsBooted )
-                            p->RIOFirstPortsBooted = sysport;
-                        if ( sysport > p->RIOLastPortsBooted )
-                            p->RIOLastPortsBooted = sysport;
-                   }
-                }
-                if (RtaType == TYPE_RTA16) {
-                   rio_dprintk (RIO_DEBUG_BOOT, "RTA will be given IDs %d+%d\n",
-                    entry+1, entry2+1);
-                } else {
-                   rio_dprintk (RIO_DEBUG_BOOT, "RTA will be given ID %d\n",entry+1);
+         ** Check for a SLOT_IN_USE entry for this RTA attached to the
+         ** current host card in the driver table.
+         **
+         ** If it exists, make a note that we have booted it. Other parts of
+         ** the driver are interested in this information at a later date,
+         ** in particular when the booting RTA asks for an ID for this unit,
+         ** we must have set the BOOTED flag, and the NEWBOOT flag is used
+         ** to force an open on any ports that where previously open on this
+         ** unit.
+         */
+        for (entry = 0; entry < MAX_RUP; entry++) {
+                unsigned int sysport;
+
+                if ((HostP->Mapping[entry].Flags & SLOT_IN_USE) && (HostP->Mapping[entry].RtaUniqueNum == RtaUniq)) {
+                        HostP->Mapping[entry].Flags |= RTA_BOOTED | RTA_NEWBOOT;
+                        if ((sysport = HostP->Mapping[entry].SysPort) != NO_PORT) {
+                                if (sysport < p->RIOFirstPortsBooted)
+                                        p->RIOFirstPortsBooted = sysport;
+                                if (sysport > p->RIOLastPortsBooted)
+                                        p->RIOLastPortsBooted = sysport;
+                                /*
+                                 ** For a 16 port RTA, check the second bank of 8 ports
+                                 */
+                                if (RtaType == TYPE_RTA16) {
+                                        entry2 = HostP->Mapping[entry].ID2 - 1;
+                                        HostP->Mapping[entry2].Flags |= RTA_BOOTED | RTA_NEWBOOT;
+                                        sysport = HostP->Mapping[entry2].SysPort;
+                                        if (sysport < p->RIOFirstPortsBooted)
+                                                p->RIOFirstPortsBooted = sysport;
+                                        if (sysport > p->RIOLastPortsBooted)
+                                                p->RIOLastPortsBooted = sysport;
+                                }
+                        }
+                        if (RtaType == TYPE_RTA16)
+                                rio_dprintk(RIO_DEBUG_BOOT, "RTA will be given IDs %d+%d\n", entry + 1, entry2 + 1);
+                        else
+                                rio_dprintk(RIO_DEBUG_BOOT, "RTA will be given ID %d\n", entry + 1);
+                        return 1;
                 }
-                return TRUE;
-            }
         }
 
-        rio_dprintk (RIO_DEBUG_BOOT, "RTA not configured for this host\n");
+        rio_dprintk(RIO_DEBUG_BOOT, "RTA not configured for this host\n");
 
-        if ( Rup >= (ushort)MAX_RUP )
-        {
-            /*
-            ** It was a host that did the booting
-            */
-            MyType = "Host";
-            MyName = HostP->Name;
-        }
-        else
-        {
-            /*
-            ** It was an RTA that did the booting
-            */
-            MyType = "RTA";
-            MyName = HostP->Mapping[Rup].Name;
+        if (Rup >= (unsigned short) MAX_RUP) {
+                /*
+                 ** It was a host that did the booting
+                 */
+                MyType = "Host";
+                MyName = HostP->Name;
+        } else {
+                /*
+                 ** It was an RTA that did the booting
+                 */
+                MyType = "RTA";
+                MyName = HostP->Mapping[Rup].Name;
         }
-        MyLink = RBYTE(PktCmdP->LinkNum);
+        MyLink = readb(&PktCmdP->LinkNum);
 
         /*
-        ** There is no SLOT_IN_USE entry for this RTA attached to the current
-        ** host card in the driver table.
-        **
-        ** Check for a SLOT_TENTATIVE entry for this RTA attached to the
-        ** current host card in the driver table.
-        **
-        ** If we find one, then we re-use that slot.
-        */
-        for ( entry=0; entry<MAX_RUP; entry++ )
-        {
-            if ( (HostP->Mapping[entry].Flags & SLOT_TENTATIVE) &&
-                 (HostP->Mapping[entry].RtaUniqueNum == RtaUniq) )
-            {
-                if (RtaType == TYPE_RTA16)
-                {
-                    entry2 = HostP->Mapping[entry].ID2 - 1;
-                    if ( (HostP->Mapping[entry2].Flags & SLOT_TENTATIVE) &&
-                         (HostP->Mapping[entry2].RtaUniqueNum == RtaUniq) )
-                        rio_dprintk (RIO_DEBUG_BOOT, "Found previous tentative slots (%d+%d)\n",
-                         entry, entry2);
-                    else
-                        continue;
+         ** There is no SLOT_IN_USE entry for this RTA attached to the current
+         ** host card in the driver table.
+         **
+         ** Check for a SLOT_TENTATIVE entry for this RTA attached to the
+         ** current host card in the driver table.
+         **
+         ** If we find one, then we re-use that slot.
+         */
+        for (entry = 0; entry < MAX_RUP; entry++) {
+                if ((HostP->Mapping[entry].Flags & SLOT_TENTATIVE) && (HostP->Mapping[entry].RtaUniqueNum == RtaUniq)) {
+                        if (RtaType == TYPE_RTA16) {
+                                entry2 = HostP->Mapping[entry].ID2 - 1;
+                                if ((HostP->Mapping[entry2].Flags & SLOT_TENTATIVE) && (HostP->Mapping[entry2].RtaUniqueNum == RtaUniq))
+                                        rio_dprintk(RIO_DEBUG_BOOT, "Found previous tentative slots (%d+%d)\n", entry, entry2);
+                                else
+                                        continue;
+                        } else
+                                rio_dprintk(RIO_DEBUG_BOOT, "Found previous tentative slot (%d)\n", entry);
+                        if (!p->RIONoMessage)
+                                printk("RTA connected to %s '%s' (%c) not configured.\n", MyType, MyName, MyLink + 'A');
+                        return 1;
                 }
-                else
-                        rio_dprintk (RIO_DEBUG_BOOT, "Found previous tentative slot (%d)\n",entry);
-                if (! p->RIONoMessage)
-                    cprintf("RTA connected to %s '%s' (%c) not configured.\n",MyType,MyName,MyLink+'A');
-                return TRUE;
-            }
         }
 
         /*
-        ** There is no SLOT_IN_USE or SLOT_TENTATIVE entry for this RTA
-        ** attached to the current host card in the driver table.
-        **
-        ** Check if there is a SLOT_IN_USE or SLOT_TENTATIVE entry on another
-        ** host for this RTA in the driver table.
-        **
-        ** For a SLOT_IN_USE entry on another host, we need to delete the RTA
-        ** entry from the other host and add it to this host (using some of
-        ** the functions from table.c which do this).
-        ** For a SLOT_TENTATIVE entry on another host, we must cope with the
-        ** following scenario:
-        **
-        ** + Plug 8 port RTA into host A. (This creates SLOT_TENTATIVE entry
-        **   in table)
-        ** + Unplug RTA and plug into host B. (We now have 2 SLOT_TENTATIVE
-        **   entries)
-        ** + Configure RTA on host B. (This slot now becomes SLOT_IN_USE)
-        ** + Unplug RTA and plug back into host A.
-        ** + Configure RTA on host A. We now have the same RTA configured
-        **   with different ports on two different hosts.
-        */
-        rio_dprintk (RIO_DEBUG_BOOT, "Have we seen RTA %x before?\n", RtaUniq );
+         ** There is no SLOT_IN_USE or SLOT_TENTATIVE entry for this RTA
+         ** attached to the current host card in the driver table.
+         **
+         ** Check if there is a SLOT_IN_USE or SLOT_TENTATIVE entry on another
+         ** host for this RTA in the driver table.
+         **
+         ** For a SLOT_IN_USE entry on another host, we need to delete the RTA
+         ** entry from the other host and add it to this host (using some of
+         ** the functions from table.c which do this).
+         ** For a SLOT_TENTATIVE entry on another host, we must cope with the
+         ** following scenario:
+         **
+         ** + Plug 8 port RTA into host A. (This creates SLOT_TENTATIVE entry
+         **   in table)
+         ** + Unplug RTA and plug into host B. (We now have 2 SLOT_TENTATIVE
+         **   entries)
+         ** + Configure RTA on host B. (This slot now becomes SLOT_IN_USE)
+         ** + Unplug RTA and plug back into host A.
+         ** + Configure RTA on host A. We now have the same RTA configured
+         **   with different ports on two different hosts.
+         */
+        rio_dprintk(RIO_DEBUG_BOOT, "Have we seen RTA %x before?\n", RtaUniq);
         found = 0;
-        Flag = 0; /* Convince the compiler this variable is initialized */
-        for ( host = 0; !found && (host < p->RIONumHosts); host++ )
-        {
-            for ( rta=0; rta<MAX_RUP; rta++ )
-            {
-                if ((p->RIOHosts[host].Mapping[rta].Flags &
-                 (SLOT_IN_USE | SLOT_TENTATIVE)) &&
-                 (p->RIOHosts[host].Mapping[rta].RtaUniqueNum==RtaUniq))
-                {
-                    Flag = p->RIOHosts[host].Mapping[rta].Flags;
-                    MapP = &p->RIOHosts[host].Mapping[rta];
-                    if (RtaType == TYPE_RTA16)
-                    {
-                        MapP2 = &p->RIOHosts[host].Mapping[MapP->ID2 - 1];
-                        rio_dprintk (RIO_DEBUG_BOOT, "This RTA is units %d+%d from host %s\n",
-                         rta+1, MapP->ID2, p->RIOHosts[host].Name);
-                    }
-                    else
-                        rio_dprintk (RIO_DEBUG_BOOT, "This RTA is unit %d from host %s\n",
-                         rta+1, p->RIOHosts[host].Name);
-                    found = 1;
-                    break;
+        Flag = 0;               /* Convince the compiler this variable is initialized */
+        for (host = 0; !found && (host < p->RIONumHosts); host++) {
+                for (rta = 0; rta < MAX_RUP; rta++) {
+                        if ((p->RIOHosts[host].Mapping[rta].Flags & (SLOT_IN_USE | SLOT_TENTATIVE)) && (p->RIOHosts[host].Mapping[rta].RtaUniqueNum == RtaUniq)) {
+                                Flag = p->RIOHosts[host].Mapping[rta].Flags;
+                                MapP = &p->RIOHosts[host].Mapping[rta];
+                                if (RtaType == TYPE_RTA16) {
+                                        MapP2 = &p->RIOHosts[host].Mapping[MapP->ID2 - 1];
+                                        rio_dprintk(RIO_DEBUG_BOOT, "This RTA is units %d+%d from host %s\n", rta + 1, MapP->ID2, p->RIOHosts[host].Name);
+                                } else
+                                        rio_dprintk(RIO_DEBUG_BOOT, "This RTA is unit %d from host %s\n", rta + 1, p->RIOHosts[host].Name);
+                                found = 1;
+                                break;
+                        }
                 }
-            }
         }
 
         /*
-        ** There is no SLOT_IN_USE or SLOT_TENTATIVE entry for this RTA
-        ** attached to the current host card in the driver table.
-        **
-        ** If we have not found a SLOT_IN_USE or SLOT_TENTATIVE entry on
-        ** another host for this RTA in the driver table...
-        **
-        ** Check for a SLOT_IN_USE entry for this RTA in the config table.
-        */
-        if ( !MapP )
-        {
-            rio_dprintk (RIO_DEBUG_BOOT, "Look for RTA %x in RIOSavedTable\n",RtaUniq);
-            for ( rta=0; rta < TOTAL_MAP_ENTRIES; rta++ )
-            {
-                rio_dprintk (RIO_DEBUG_BOOT, "Check table entry %d (%x)",
-                      rta,
-                      p->RIOSavedTable[rta].RtaUniqueNum);
-
-                if ( (p->RIOSavedTable[rta].Flags & SLOT_IN_USE) &&
-                 (p->RIOSavedTable[rta].RtaUniqueNum == RtaUniq) )
-                {
-                    MapP = &p->RIOSavedTable[rta];
-                    Flag = p->RIOSavedTable[rta].Flags;
-                    if (RtaType == TYPE_RTA16)
-                    {
-                        for (entry2 = rta + 1; entry2 < TOTAL_MAP_ENTRIES;
-                         entry2++)
-                        {
-                            if (p->RIOSavedTable[entry2].RtaUniqueNum == RtaUniq)
-                                break;
-                        }
-                        MapP2 = &p->RIOSavedTable[entry2];
-                        rio_dprintk (RIO_DEBUG_BOOT, "This RTA is from table entries %d+%d\n",
-                              rta, entry2);
-                    }
-                    else
-                        rio_dprintk (RIO_DEBUG_BOOT, "This RTA is from table entry %d\n", rta);
-                    break;
+         ** There is no SLOT_IN_USE or SLOT_TENTATIVE entry for this RTA
+         ** attached to the current host card in the driver table.
+         **
+         ** If we have not found a SLOT_IN_USE or SLOT_TENTATIVE entry on
+         ** another host for this RTA in the driver table...
+         **
+         ** Check for a SLOT_IN_USE entry for this RTA in the config table.
+         */
+        if (!MapP) {
+                rio_dprintk(RIO_DEBUG_BOOT, "Look for RTA %x in RIOSavedTable\n", RtaUniq);
+                for (rta = 0; rta < TOTAL_MAP_ENTRIES; rta++) {
+                        rio_dprintk(RIO_DEBUG_BOOT, "Check table entry %d (%x)", rta, p->RIOSavedTable[rta].RtaUniqueNum);
+
+                        if ((p->RIOSavedTable[rta].Flags & SLOT_IN_USE) && (p->RIOSavedTable[rta].RtaUniqueNum == RtaUniq)) {
+                                MapP = &p->RIOSavedTable[rta];
+                                Flag = p->RIOSavedTable[rta].Flags;
+                                if (RtaType == TYPE_RTA16) {
+                                        for (entry2 = rta + 1; entry2 < TOTAL_MAP_ENTRIES; entry2++) {
+                                                if (p->RIOSavedTable[entry2].RtaUniqueNum == RtaUniq)
+                                                        break;
+                                        }
+                                        MapP2 = &p->RIOSavedTable[entry2];
+                                        rio_dprintk(RIO_DEBUG_BOOT, "This RTA is from table entries %d+%d\n", rta, entry2);
+                                } else
+                                        rio_dprintk(RIO_DEBUG_BOOT, "This RTA is from table entry %d\n", rta);
+                                break;
+                        }
                 }
-            }
         }
 
         /*
-        ** There is no SLOT_IN_USE or SLOT_TENTATIVE entry for this RTA
-        ** attached to the current host card in the driver table.
-        **
-        ** We may have found a SLOT_IN_USE entry on another host for this
-        ** RTA in the config table, or a SLOT_IN_USE or SLOT_TENTATIVE entry
-        ** on another host for this RTA in the driver table.
-        **
-        ** Check the driver table for room to fit this newly discovered RTA.
-        ** RIOFindFreeID() first looks for free slots and if it does not
-        ** find any free slots it will then attempt to oust any
-        ** tentative entry in the table.
-        */
+         ** There is no SLOT_IN_USE or SLOT_TENTATIVE entry for this RTA
+         ** attached to the current host card in the driver table.
+         **
+         ** We may have found a SLOT_IN_USE entry on another host for this
+         ** RTA in the config table, or a SLOT_IN_USE or SLOT_TENTATIVE entry
+         ** on another host for this RTA in the driver table.
+         **
+         ** Check the driver table for room to fit this newly discovered RTA.
+         ** RIOFindFreeID() first looks for free slots and if it does not
+         ** find any free slots it will then attempt to oust any
+         ** tentative entry in the table.
+         */
         EmptySlot = 1;
-        if (RtaType == TYPE_RTA16)
-        {
-            if (RIOFindFreeID(p, HostP, &entry, &entry2) == 0)
-            {
-                RIODefaultName(p, HostP, entry);
-                FillSlot(entry, entry2, RtaUniq, HostP);
-                EmptySlot = 0;
-            }
-        }
-        else
-        {
-            if (RIOFindFreeID(p, HostP, &entry, NULL) == 0)
-            {
-                RIODefaultName(p, HostP, entry);
-                FillSlot(entry, 0, RtaUniq, HostP);
-                EmptySlot = 0;
-            }
+        if (RtaType == TYPE_RTA16) {
+                if (RIOFindFreeID(p, HostP, &entry, &entry2) == 0) {
+                        RIODefaultName(p, HostP, entry);
+                        rio_fill_host_slot(entry, entry2, RtaUniq, HostP);
+                        EmptySlot = 0;
+                }
+        } else {
+                if (RIOFindFreeID(p, HostP, &entry, NULL) == 0) {
+                        RIODefaultName(p, HostP, entry);
+                        rio_fill_host_slot(entry, 0, RtaUniq, HostP);
+                        EmptySlot = 0;
+                }
         }
 
         /*
-        ** There is no SLOT_IN_USE or SLOT_TENTATIVE entry for this RTA
-        ** attached to the current host card in the driver table.
-        **
-        ** If we found a SLOT_IN_USE entry on another host for this
-        ** RTA in the config or driver table, and there are enough free
-        ** slots in the driver table, then we need to move it over and
-        ** delete it from the other host.
-        ** If we found a SLOT_TENTATIVE entry on another host for this
-        ** RTA in the driver table, just delete the other host entry.
-        */
-        if (EmptySlot == 0)
-        {
-            if ( MapP )
-            {
-                if (Flag & SLOT_IN_USE)
-                {
-                    rio_dprintk (RIO_DEBUG_BOOT, 
-    "This RTA configured on another host - move entry to current host (1)\n");
-                    HostP->Mapping[entry].SysPort = MapP->SysPort;
-                    CCOPY( MapP->Name, HostP->Mapping[entry].Name, MAX_NAME_LEN );
-                    HostP->Mapping[entry].Flags =
-                     SLOT_IN_USE | RTA_BOOTED | RTA_NEWBOOT;
-#ifdef NEED_TO_FIX
-                    RIO_SV_BROADCAST(HostP->svFlags[entry]);
-#endif
-                    RIOReMapPorts( p, HostP, &HostP->Mapping[entry] );
-                    if ( HostP->Mapping[entry].SysPort < p->RIOFirstPortsBooted )
-                        p->RIOFirstPortsBooted = HostP->Mapping[entry].SysPort;
-                    if ( HostP->Mapping[entry].SysPort > p->RIOLastPortsBooted )
-                        p->RIOLastPortsBooted = HostP->Mapping[entry].SysPort;
-                    rio_dprintk (RIO_DEBUG_BOOT, "SysPort %d, Name %s\n",(int)MapP->SysPort,MapP->Name);
-                }
-                else
-                {
-                    rio_dprintk (RIO_DEBUG_BOOT, 
-   "This RTA has a tentative entry on another host - delete that entry (1)\n");
-                    HostP->Mapping[entry].Flags =
-                     SLOT_TENTATIVE | RTA_BOOTED | RTA_NEWBOOT;
-#ifdef NEED_TO_FIX
-                    RIO_SV_BROADCAST(HostP->svFlags[entry]);
-#endif
-                }
-                if (RtaType == TYPE_RTA16)
-                {
-                    if (Flag & SLOT_IN_USE)
-                    {
-                        HostP->Mapping[entry2].Flags = SLOT_IN_USE |
-                         RTA_BOOTED | RTA_NEWBOOT | RTA16_SECOND_SLOT;
-#ifdef NEED_TO_FIX
-                        RIO_SV_BROADCAST(HostP->svFlags[entry2]);
-#endif
-                        HostP->Mapping[entry2].SysPort = MapP2->SysPort;
-                        /*
-                        ** Map second block of ttys for 16 port RTA
-                        */
-                        RIOReMapPorts( p, HostP, &HostP->Mapping[entry2] );
-                       if (HostP->Mapping[entry2].SysPort < p->RIOFirstPortsBooted)
-                         p->RIOFirstPortsBooted = HostP->Mapping[entry2].SysPort;
-                       if (HostP->Mapping[entry2].SysPort > p->RIOLastPortsBooted)
-                         p->RIOLastPortsBooted = HostP->Mapping[entry2].SysPort;
-                        rio_dprintk (RIO_DEBUG_BOOT, "SysPort %d, Name %s\n",
-                               (int)HostP->Mapping[entry2].SysPort,
-                               HostP->Mapping[entry].Name);
-                    }
-                    else
-                        HostP->Mapping[entry2].Flags = SLOT_TENTATIVE |
-                         RTA_BOOTED | RTA_NEWBOOT | RTA16_SECOND_SLOT;
-#ifdef NEED_TO_FIX
-                        RIO_SV_BROADCAST(HostP->svFlags[entry2]);
-#endif
-                    bzero( (caddr_t)MapP2, sizeof(struct Map) );
-                }
-                bzero( (caddr_t)MapP, sizeof(struct Map) );
-                if (! p->RIONoMessage)
-                    cprintf("An orphaned RTA has been adopted by %s '%s' (%c).\n",MyType,MyName,MyLink+'A');
-            }
-            else if (! p->RIONoMessage)
-                cprintf("RTA connected to %s '%s' (%c) not configured.\n",MyType,MyName,MyLink+'A');
-            RIOSetChange(p);
-            return TRUE;
+         ** There is no SLOT_IN_USE or SLOT_TENTATIVE entry for this RTA
+         ** attached to the current host card in the driver table.
+         **
+         ** If we found a SLOT_IN_USE entry on another host for this
+         ** RTA in the config or driver table, and there are enough free
+         ** slots in the driver table, then we need to move it over and
+         ** delete it from the other host.
+         ** If we found a SLOT_TENTATIVE entry on another host for this
+         ** RTA in the driver table, just delete the other host entry.
+         */
+        if (EmptySlot == 0) {
+                if (MapP) {
+                        if (Flag & SLOT_IN_USE) {
+                                rio_dprintk(RIO_DEBUG_BOOT, "This RTA configured on another host - move entry to current host (1)\n");
+                                HostP->Mapping[entry].SysPort = MapP->SysPort;
+                                memcpy(HostP->Mapping[entry].Name, MapP->Name, MAX_NAME_LEN);
+                                HostP->Mapping[entry].Flags = SLOT_IN_USE | RTA_BOOTED | RTA_NEWBOOT;
+                                RIOReMapPorts(p, HostP, &HostP->Mapping[entry]);
+                                if (HostP->Mapping[entry].SysPort < p->RIOFirstPortsBooted)
+                                        p->RIOFirstPortsBooted = HostP->Mapping[entry].SysPort;
+                                if (HostP->Mapping[entry].SysPort > p->RIOLastPortsBooted)
+                                        p->RIOLastPortsBooted = HostP->Mapping[entry].SysPort;
+                                rio_dprintk(RIO_DEBUG_BOOT, "SysPort %d, Name %s\n", (int) MapP->SysPort, MapP->Name);
+                        } else {
+                                rio_dprintk(RIO_DEBUG_BOOT, "This RTA has a tentative entry on another host - delete that entry (1)\n");
+                                HostP->Mapping[entry].Flags = SLOT_TENTATIVE | RTA_BOOTED | RTA_NEWBOOT;
+                        }
+                        if (RtaType == TYPE_RTA16) {
+                                if (Flag & SLOT_IN_USE) {
+                                        HostP->Mapping[entry2].Flags = SLOT_IN_USE | RTA_BOOTED | RTA_NEWBOOT | RTA16_SECOND_SLOT;
+                                        HostP->Mapping[entry2].SysPort = MapP2->SysPort;
+                                        /*
+                                         ** Map second block of ttys for 16 port RTA
+                                         */
+                                        RIOReMapPorts(p, HostP, &HostP->Mapping[entry2]);
+                                        if (HostP->Mapping[entry2].SysPort < p->RIOFirstPortsBooted)
+                                                p->RIOFirstPortsBooted = HostP->Mapping[entry2].SysPort;
+                                        if (HostP->Mapping[entry2].SysPort > p->RIOLastPortsBooted)
+                                                p->RIOLastPortsBooted = HostP->Mapping[entry2].SysPort;
+                                        rio_dprintk(RIO_DEBUG_BOOT, "SysPort %d, Name %s\n", (int) HostP->Mapping[entry2].SysPort, HostP->Mapping[entry].Name);
+                                } else
+                                        HostP->Mapping[entry2].Flags = SLOT_TENTATIVE | RTA_BOOTED | RTA_NEWBOOT | RTA16_SECOND_SLOT;
+                                memset(MapP2, 0, sizeof(struct Map));
+                        }
+                        memset(MapP, 0, sizeof(struct Map));
+                        if (!p->RIONoMessage)
+                                printk("An orphaned RTA has been adopted by %s '%s' (%c).\n", MyType, MyName, MyLink + 'A');
+                } else if (!p->RIONoMessage)
+                        printk("RTA connected to %s '%s' (%c) not configured.\n", MyType, MyName, MyLink + 'A');
+                RIOSetChange(p);
+                return 1;
         }
 
         /*
-        ** There is no room in the driver table to make an entry for the
-        ** booted RTA. Keep a note of its Uniq Num in the overflow table,
-        ** so we can ignore it's ID requests.
-        */
-        if (! p->RIONoMessage)
-            cprintf("The RTA connected to %s '%s' (%c) cannot be configured.  You cannot configure more than 128 ports to one host card.\n",MyType,MyName,MyLink+'A');
-        for ( entry=0; entry<HostP->NumExtraBooted; entry++ )
-        {
-            if ( HostP->ExtraUnits[entry] == RtaUniq )
-            {
-                /*
-                ** already got it!
-                */
-                return TRUE;
-            }
+         ** There is no room in the driver table to make an entry for the
+         ** booted RTA. Keep a note of its Uniq Num in the overflow table,
+         ** so we can ignore it's ID requests.
+         */
+        if (!p->RIONoMessage)
+                printk("The RTA connected to %s '%s' (%c) cannot be configured.  You cannot configure more than 128 ports to one host card.\n", MyType, MyName, MyLink + 'A');
+        for (entry = 0; entry < HostP->NumExtraBooted; entry++) {
+                if (HostP->ExtraUnits[entry] == RtaUniq) {
+                        /*
+                         ** already got it!
+                         */
+                        return 1;
+                }
         }
         /*
-        ** If there is room, add the unit to the list of extras
-        */
-        if ( HostP->NumExtraBooted < MAX_EXTRA_UNITS )
-            HostP->ExtraUnits[HostP->NumExtraBooted++] = RtaUniq;
-        return TRUE;
+         ** If there is room, add the unit to the list of extras
+         */
+        if (HostP->NumExtraBooted < MAX_EXTRA_UNITS)
+                HostP->ExtraUnits[HostP->NumExtraBooted++] = RtaUniq;
+        return 1;
 }
 
 
 /*
 ** If the RTA or its host appears in the RIOBindTab[] structure then
-** we mustn't boot the RTA and should return FALSE.
+** we mustn't boot the RTA and should return 0.
 ** This operation is slightly different from the other drivers for RIO
 ** in that this is designed to work with the new utilities
 ** not config.rio and is FAR SIMPLER.
 ** We no longer support the RIOBootMode variable. It is all done from the
 ** "boot/noboot" field in the rio.cf file.
 */
-int
-RIOBootOk(p, HostP, RtaUniq)
-struct rio_info *       p;
-struct Host *           HostP;
-ulong RtaUniq;
+int RIOBootOk(struct rio_info *p, struct Host *HostP, unsigned long RtaUniq)
 {
-    int         Entry;
-    uint HostUniq = HostP->UniqueNum;
+        int Entry;
+        unsigned int HostUniq = HostP->UniqueNum;
 
         /*
-        ** Search bindings table for RTA or its parent.
-        ** If it exists, return 0, else 1.
-        */
-        for (Entry = 0;
-            ( Entry < MAX_RTA_BINDINGS ) && ( p->RIOBindTab[Entry] != 0 );
-            Entry++)
-        {
-                if ( (p->RIOBindTab[Entry] == HostUniq) ||
-                     (p->RIOBindTab[Entry] == RtaUniq) )
+         ** Search bindings table for RTA or its parent.
+         ** If it exists, return 0, else 1.
+         */
+        for (Entry = 0; (Entry < MAX_RTA_BINDINGS) && (p->RIOBindTab[Entry] != 0); Entry++) {
+                if ((p->RIOBindTab[Entry] == HostUniq) || (p->RIOBindTab[Entry] == RtaUniq))
                         return 0;
         }
         return 1;
@@ -1255,45 +1076,38 @@ ulong RtaUniq;
 ** slots tentative, and the second one RTA_SECOND_SLOT as well.
 */
 
-void
-FillSlot(entry, entry2, RtaUniq, HostP)
-int entry;
-int entry2;
-uint RtaUniq;
-struct Host *HostP;
+void rio_fill_host_slot(int entry, int entry2, unsigned int rta_uniq, struct Host *host)
 {
-        int             link;
+        int link;
 
-        rio_dprintk (RIO_DEBUG_BOOT, "FillSlot(%d, %d, 0x%x...)\n", entry, entry2, RtaUniq);
+        rio_dprintk(RIO_DEBUG_BOOT, "rio_fill_host_slot(%d, %d, 0x%x...)\n", entry, entry2, rta_uniq);
 
-        HostP->Mapping[entry].Flags = (RTA_BOOTED | RTA_NEWBOOT | SLOT_TENTATIVE);
-        HostP->Mapping[entry].SysPort = NO_PORT;
-        HostP->Mapping[entry].RtaUniqueNum = RtaUniq;
-        HostP->Mapping[entry].HostUniqueNum = HostP->UniqueNum;
-        HostP->Mapping[entry].ID = entry + 1;
-        HostP->Mapping[entry].ID2 = 0;
+        host->Mapping[entry].Flags = (RTA_BOOTED | RTA_NEWBOOT | SLOT_TENTATIVE);
+        host->Mapping[entry].SysPort = NO_PORT;
+        host->Mapping[entry].RtaUniqueNum = rta_uniq;
+        host->Mapping[entry].HostUniqueNum = host->UniqueNum;
+        host->Mapping[entry].ID = entry + 1;
+        host->Mapping[entry].ID2 = 0;
         if (entry2) {
-                HostP->Mapping[entry2].Flags = (RTA_BOOTED | RTA_NEWBOOT | 
-                                                                SLOT_TENTATIVE | RTA16_SECOND_SLOT);
-                HostP->Mapping[entry2].SysPort = NO_PORT;
-                HostP->Mapping[entry2].RtaUniqueNum = RtaUniq;
-                HostP->Mapping[entry2].HostUniqueNum = HostP->UniqueNum;
-                HostP->Mapping[entry2].Name[0] = '\0';
-                HostP->Mapping[entry2].ID = entry2 + 1;
-                HostP->Mapping[entry2].ID2 = entry + 1;
-                HostP->Mapping[entry].ID2 = entry2 + 1;
+                host->Mapping[entry2].Flags = (RTA_BOOTED | RTA_NEWBOOT | SLOT_TENTATIVE | RTA16_SECOND_SLOT);
+                host->Mapping[entry2].SysPort = NO_PORT;
+                host->Mapping[entry2].RtaUniqueNum = rta_uniq;
+                host->Mapping[entry2].HostUniqueNum = host->UniqueNum;
+                host->Mapping[entry2].Name[0] = '\0';
+                host->Mapping[entry2].ID = entry2 + 1;
+                host->Mapping[entry2].ID2 = entry + 1;
+                host->Mapping[entry].ID2 = entry2 + 1;
         }
         /*
-        ** Must set these up, so that utilities show
-        ** topology of 16 port RTAs correctly
-        */
-        for ( link=0; link<LINKS_PER_UNIT; link++ ) {
-                HostP->Mapping[entry].Topology[link].Unit = ROUTE_DISCONNECT;
-                HostP->Mapping[entry].Topology[link].Link = NO_LINK;
+         ** Must set these up, so that utilities show
+         ** topology of 16 port RTAs correctly
+         */
+        for (link = 0; link < LINKS_PER_UNIT; link++) {
+                host->Mapping[entry].Topology[link].Unit = ROUTE_DISCONNECT;
+                host->Mapping[entry].Topology[link].Link = NO_LINK;
                 if (entry2) {
-                        HostP->Mapping[entry2].Topology[link].Unit = ROUTE_DISCONNECT;
-                        HostP->Mapping[entry2].Topology[link].Link = NO_LINK;
+                        host->Mapping[entry2].Topology[link].Unit = ROUTE_DISCONNECT;
+                        host->Mapping[entry2].Topology[link].Link = NO_LINK;
                 }
         }
 }
-
diff --git a/drivers/char/rio/riocmd.c b/drivers/char/rio/riocmd.c
index 694bfb9d93..e6d2b14b5e 100644
--- a/drivers/char/rio/riocmd.c
+++ b/drivers/char/rio/riocmd.c
@@ -42,6 +42,7 @@ static char *_riocmd_c_sccs_ = "@(#)riocmd.c	1.2";
 #include <asm/system.h>
 #include <asm/string.h>
 #include <asm/semaphore.h>
+#include <asm/uaccess.h>
 
 #include <linux/termios.h>
 #include <linux/serial.h>
@@ -50,15 +51,12 @@ static char *_riocmd_c_sccs_ = "@(#)riocmd.c	1.2";
 
 #include "linux_compat.h"
 #include "rio_linux.h"
-#include "typdef.h"
 #include "pkt.h"
 #include "daemon.h"
 #include "rio.h"
 #include "riospace.h"
-#include "top.h"
 #include "cmdpkt.h"
 #include "map.h"
-#include "riotypes.h"
 #include "rup.h"
 #include "port.h"
 #include "riodrvr.h"
@@ -71,12 +69,10 @@ static char *_riocmd_c_sccs_ = "@(#)riocmd.c	1.2";
 #include "unixrup.h"
 #include "board.h"
 #include "host.h"
-#include "error.h"
 #include "phb.h"
 #include "link.h"
 #include "cmdblk.h"
 #include "route.h"
-#include "control.h"
 #include "cirrus.h"
 
 
@@ -143,17 +139,17 @@ int RIOZombieRta(struct Host *HostP, struct Map *MapP)
         return 0;
 }
 
-int RIOCommandRta(struct rio_info *p, uint RtaUnique, int (*func) (struct Host * HostP, struct Map * MapP))
+int RIOCommandRta(struct rio_info *p, unsigned long RtaUnique, int (*func) (struct Host * HostP, struct Map * MapP))
 {
-        uint Host;
+        unsigned int Host;
 
-        rio_dprintk(RIO_DEBUG_CMD, "Command RTA 0x%x func 0x%x\n", RtaUnique, (int) func);
+        rio_dprintk(RIO_DEBUG_CMD, "Command RTA 0x%lx func %p\n", RtaUnique, func);
 
         if (!RtaUnique)
                 return (0);
 
         for (Host = 0; Host < p->RIONumHosts; Host++) {
-                uint Rta;
+                unsigned int Rta;
                 struct Host *HostP = &p->RIOHosts[Host];
 
                 for (Rta = 0; Rta < RTAS_PER_HOST; Rta++) {
@@ -170,7 +166,7 @@ int RIOCommandRta(struct rio_info *p, uint RtaUnique, int (*func) (struct Host *
                                  ** any connections, we can get to it.
                                  */
                                 for (Link = 0; Link < LINKS_PER_UNIT; Link++) {
-                                        if (MapP->Topology[Link].Unit <= (uchar) MAX_RUP) {
+                                        if (MapP->Topology[Link].Unit <= (u8) MAX_RUP) {
                                                 /*
                                                  ** Its worth trying the operation...
                                                  */
@@ -184,18 +180,18 @@ int RIOCommandRta(struct rio_info *p, uint RtaUnique, int (*func) (struct Host *
 }
 
 
-int RIOIdentifyRta(struct rio_info *p, caddr_t arg)
+int RIOIdentifyRta(struct rio_info *p, void * arg)
 {
-        uint Host;
+        unsigned int Host;
 
-        if (copyin((int) arg, (caddr_t) & IdRta, sizeof(IdRta)) == COPYFAIL) {
+        if (copy_from_user(&IdRta, arg, sizeof(IdRta))) {
                 rio_dprintk(RIO_DEBUG_CMD, "RIO_IDENTIFY_RTA copy failed\n");
                 p->RIOError.Error = COPYIN_FAILED;
                 return -EFAULT;
         }
 
         for (Host = 0; Host < p->RIONumHosts; Host++) {
-                uint Rta;
+                unsigned int Rta;
                 struct Host *HostP = &p->RIOHosts[Host];
 
                 for (Rta = 0; Rta < RTAS_PER_HOST; Rta++) {
@@ -211,7 +207,7 @@ int RIOIdentifyRta(struct rio_info *p, caddr_t arg)
                                  ** any connections, we can get to it.
                                  */
                                 for (Link = 0; Link < LINKS_PER_UNIT; Link++) {
-                                        if (MapP->Topology[Link].Unit <= (uchar) MAX_RUP) {
+                                        if (MapP->Topology[Link].Unit <= (u8) MAX_RUP) {
                                                 /*
                                                  ** Its worth trying the operation...
                                                  */
@@ -249,7 +245,7 @@ int RIOIdentifyRta(struct rio_info *p, caddr_t arg)
 }
 
 
-int RIOKillNeighbour(struct rio_info *p, caddr_t arg)
+int RIOKillNeighbour(struct rio_info *p, void * arg)
 {
         uint Host;
         uint ID;
@@ -258,7 +254,7 @@ int RIOKillNeighbour(struct rio_info *p, caddr_t arg)
 
         rio_dprintk(RIO_DEBUG_CMD, "KILL HOST NEIGHBOUR\n");
 
-        if (copyin((int) arg, (caddr_t) & KillUnit, sizeof(KillUnit)) == COPYFAIL) {
+        if (copy_from_user(&KillUnit, arg, sizeof(KillUnit))) {
                 rio_dprintk(RIO_DEBUG_CMD, "RIO_KILL_NEIGHBOUR copy failed\n");
                 p->RIOError.Error = COPYIN_FAILED;
                 return -EFAULT;
@@ -344,7 +340,7 @@ int RIOSuspendBootRta(struct Host *HostP, int ID, int Link)
 int RIOFoadWakeup(struct rio_info *p)
 {
         int port;
-        register struct Port *PortP;
+        struct Port *PortP;
         unsigned long flags;
 
         for (port = 0; port < RIO_PORTS; port++) {
@@ -374,15 +370,15 @@ int RIOFoadWakeup(struct rio_info *p)
 /*
 ** Incoming command on the COMMAND_RUP to be processed.
 */
-static int RIOCommandRup(struct rio_info *p, uint Rup, struct Host *HostP, PKT * PacketP)
+static int RIOCommandRup(struct rio_info *p, uint Rup, struct Host *HostP, struct PKT * PacketP)
 {
         struct PktCmd *PktCmdP = (struct PktCmd *) PacketP->data;
         struct Port *PortP;
         struct UnixRup *UnixRupP;
-        ushort SysPort;
-        ushort ReportedModemStatus;
-        ushort rup;
-        ushort subCommand;
+        unsigned short SysPort;
+        unsigned short ReportedModemStatus;
+        unsigned short rup;
+        unsigned short subCommand;
         unsigned long flags;
 
         func_enter();
@@ -395,18 +391,18 @@ static int RIOCommandRup(struct rio_info *p, uint Rup, struct Host *HostP, PKT *
          ** we can use PhbNum to get the rup number for the appropriate 8 port
          ** block (for the first block, this should be equal to 'Rup').
          */
-        rup = RBYTE(PktCmdP->PhbNum) / (ushort) PORTS_PER_RTA;
+        rup = readb(&PktCmdP->PhbNum) / (unsigned short) PORTS_PER_RTA;
         UnixRupP = &HostP->UnixRups[rup];
-        SysPort = UnixRupP->BaseSysPort + (RBYTE(PktCmdP->PhbNum) % (ushort) PORTS_PER_RTA);
+        SysPort = UnixRupP->BaseSysPort + (readb(&PktCmdP->PhbNum) % (unsigned short) PORTS_PER_RTA);
         rio_dprintk(RIO_DEBUG_CMD, "Command on rup %d, port %d\n", rup, SysPort);
 
         if (UnixRupP->BaseSysPort == NO_PORT) {
                 rio_dprintk(RIO_DEBUG_CMD, "OBSCURE ERROR!\n");
                 rio_dprintk(RIO_DEBUG_CMD, "Diagnostics follow. Please WRITE THESE DOWN and report them to Specialix Technical Support\n");
-                rio_dprintk(RIO_DEBUG_CMD, "CONTROL information: Host number %d, name ``%s''\n", HostP - p->RIOHosts, HostP->Name);
+                rio_dprintk(RIO_DEBUG_CMD, "CONTROL information: Host number %Zd, name ``%s''\n", HostP - p->RIOHosts, HostP->Name);
                 rio_dprintk(RIO_DEBUG_CMD, "CONTROL information: Rup number  0x%x\n", rup);
 
-                if (Rup >= (ushort) MAX_RUP) {
+                if (Rup >= (unsigned short) MAX_RUP) {
                         rio_dprintk(RIO_DEBUG_CMD, "CONTROL information: This is the RUP for RTA ``%s''\n", HostP->Mapping[Rup].Name);
                 } else
                         rio_dprintk(RIO_DEBUG_CMD, "CONTROL information: This is the RUP for link ``%c'' of host ``%s''\n", ('A' + Rup - MAX_RUP), HostP->Name);
@@ -417,16 +413,16 @@ static int RIOCommandRup(struct rio_info *p, uint Rup, struct Host *HostP, PKT *
                 rio_dprintk(RIO_DEBUG_CMD, "PACKET information: Control  0x%x (%d)\n", PacketP->control, PacketP->control);
                 rio_dprintk(RIO_DEBUG_CMD, "PACKET information: Check      0x%x (%d)\n", PacketP->csum, PacketP->csum);
                 rio_dprintk(RIO_DEBUG_CMD, "COMMAND information: Host Port Number 0x%x, " "Command Code 0x%x\n", PktCmdP->PhbNum, PktCmdP->Command);
-                return TRUE;
+                return 1;
         }
         PortP = p->RIOPortp[SysPort];
         rio_spin_lock_irqsave(&PortP->portSem, flags);
-        switch (RBYTE(PktCmdP->Command)) {
+        switch (readb(&PktCmdP->Command)) {
         case BREAK_RECEIVED:
                 rio_dprintk(RIO_DEBUG_CMD, "Received a break!\n");
                 /* If the current line disc. is not multi-threading and
                    the current processor is not the default, reset rup_intr
-                   and return FALSE to ensure that the command packet is
+                   and return 0 to ensure that the command packet is
                    not freed. */
                 /* Call tmgr HANGUP HERE */
                 /* Fix this later when every thing works !!!! RAMRAJ */
@@ -434,15 +430,15 @@ static int RIOCommandRup(struct rio_info *p, uint Rup, struct Host *HostP, PKT *
                 break;
 
         case COMPLETE:
-                rio_dprintk(RIO_DEBUG_CMD, "Command complete on phb %d host %d\n", RBYTE(PktCmdP->PhbNum), HostP - p->RIOHosts);
+                rio_dprintk(RIO_DEBUG_CMD, "Command complete on phb %d host %Zd\n", readb(&PktCmdP->PhbNum), HostP - p->RIOHosts);
                 subCommand = 1;
-                switch (RBYTE(PktCmdP->SubCommand)) {
+                switch (readb(&PktCmdP->SubCommand)) {
                 case MEMDUMP:
-                        rio_dprintk(RIO_DEBUG_CMD, "Memory dump cmd (0x%x) from addr 0x%x\n", RBYTE(PktCmdP->SubCommand), RWORD(PktCmdP->SubAddr));
+                        rio_dprintk(RIO_DEBUG_CMD, "Memory dump cmd (0x%x) from addr 0x%x\n", readb(&PktCmdP->SubCommand), readw(&PktCmdP->SubAddr));
                         break;
                 case READ_REGISTER:
-                        rio_dprintk(RIO_DEBUG_CMD, "Read register (0x%x)\n", RWORD(PktCmdP->SubAddr));
-                        p->CdRegister = (RBYTE(PktCmdP->ModemStatus) & MSVR1_HOST);
+                        rio_dprintk(RIO_DEBUG_CMD, "Read register (0x%x)\n", readw(&PktCmdP->SubAddr));
+                        p->CdRegister = (readb(&PktCmdP->ModemStatus) & MSVR1_HOST);
                         break;
                 default:
                         subCommand = 0;
@@ -450,10 +446,10 @@ static int RIOCommandRup(struct rio_info *p, uint Rup, struct Host *HostP, PKT *
                 }
                 if (subCommand)
                         break;
-                rio_dprintk(RIO_DEBUG_CMD, "New status is 0x%x was 0x%x\n", RBYTE(PktCmdP->PortStatus), PortP->PortState);
-                if (PortP->PortState != RBYTE(PktCmdP->PortStatus)) {
+                rio_dprintk(RIO_DEBUG_CMD, "New status is 0x%x was 0x%x\n", readb(&PktCmdP->PortStatus), PortP->PortState);
+                if (PortP->PortState != readb(&PktCmdP->PortStatus)) {
                         rio_dprintk(RIO_DEBUG_CMD, "Mark status & wakeup\n");
-                        PortP->PortState = RBYTE(PktCmdP->PortStatus);
+                        PortP->PortState = readb(&PktCmdP->PortStatus);
                         /* What should we do here ...
                            wakeup( &PortP->PortState );
                          */
@@ -467,7 +463,7 @@ static int RIOCommandRup(struct rio_info *p, uint Rup, struct Host *HostP, PKT *
                  ** to the check for modem status change (they're just there because
                  ** it's a convenient place to put them!).
                  */
-                ReportedModemStatus = RBYTE(PktCmdP->ModemStatus);
+                ReportedModemStatus = readb(&PktCmdP->ModemStatus);
                 if ((PortP->ModemState & MSVR1_HOST) == (ReportedModemStatus & MSVR1_HOST)) {
                         rio_dprintk(RIO_DEBUG_CMD, "Modem status unchanged 0x%x\n", PortP->ModemState);
                         /*
@@ -514,9 +510,6 @@ static int RIOCommandRup(struct rio_info *p, uint Rup, struct Host *HostP, PKT *
                                                          */
                                                         if (PortP->State & (PORT_ISOPEN | RIO_WOPEN))
                                                                 wake_up_interruptible(&PortP->gs.open_wait);
-#ifdef STATS
-                                                        PortP->Stat.ModemOnCnt++;
-#endif
                                                 }
                                         } else {
                                                 /*
@@ -527,9 +520,6 @@ static int RIOCommandRup(struct rio_info *p, uint Rup, struct Host *HostP, PKT *
                                                                 tty_hangup(PortP->gs.tty);
                                                         PortP->State &= ~RIO_CARR_ON;
                                                         rio_dprintk(RIO_DEBUG_CMD, "Carrirer just went down\n");
-#ifdef STATS
-                                                        PortP->Stat.ModemOffCnt++;
-#endif
                                                 }
                                         }
                                 }
@@ -539,14 +529,14 @@ static int RIOCommandRup(struct rio_info *p, uint Rup, struct Host *HostP, PKT *
                 break;
 
         default:
-                rio_dprintk(RIO_DEBUG_CMD, "Unknown command %d on CMD_RUP of host %d\n", RBYTE(PktCmdP->Command), HostP - p->RIOHosts);
+                rio_dprintk(RIO_DEBUG_CMD, "Unknown command %d on CMD_RUP of host %Zd\n", readb(&PktCmdP->Command), HostP - p->RIOHosts);
                 break;
         }
         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 
         func_exit();
 
-        return TRUE;
+        return 1;
 }
 
 /*
@@ -566,10 +556,9 @@ struct CmdBlk *RIOGetCmdBlk(void)
 {
         struct CmdBlk *CmdBlkP;
 
-        CmdBlkP = (struct CmdBlk *) sysbrk(sizeof(struct CmdBlk));
+        CmdBlkP = (struct CmdBlk *)kmalloc(sizeof(struct CmdBlk), GFP_ATOMIC);
         if (CmdBlkP)
-                bzero(CmdBlkP, sizeof(struct CmdBlk));
-
+                memset(CmdBlkP, 0, sizeof(struct CmdBlk));
         return CmdBlkP;
 }
 
@@ -578,7 +567,7 @@ struct CmdBlk *RIOGetCmdBlk(void)
 */
 void RIOFreeCmdBlk(struct CmdBlk *CmdBlkP)
 {
-        sysfree((void *) CmdBlkP, sizeof(struct CmdBlk));
+        kfree(CmdBlkP);
 }
 
 /*
@@ -591,7 +580,7 @@ int RIOQueueCmdBlk(struct Host *HostP, uint Rup, struct CmdBlk *CmdBlkP)
         struct UnixRup *UnixRupP;
         unsigned long flags;
 
-        if (Rup >= (ushort) (MAX_RUP + LINKS_PER_UNIT)) {
+        if (Rup >= (unsigned short) (MAX_RUP + LINKS_PER_UNIT)) {
                 rio_dprintk(RIO_DEBUG_CMD, "Illegal rup number %d in RIOQueueCmdBlk\n", Rup);
                 RIOFreeCmdBlk(CmdBlkP);
                 return RIO_FAIL;
@@ -605,14 +594,14 @@ int RIOQueueCmdBlk(struct Host *HostP, uint Rup, struct CmdBlk *CmdBlkP)
          ** If the RUP is currently inactive, then put the request
          ** straight on the RUP....
          */
-        if ((UnixRupP->CmdsWaitingP == NULL) && (UnixRupP->CmdPendingP == NULL) && (RWORD(UnixRupP->RupP->txcontrol) == TX_RUP_INACTIVE) && (CmdBlkP->PreFuncP ? (*CmdBlkP->PreFuncP) (CmdBlkP->PreArg, CmdBlkP)
-                                                                                                                                             : TRUE)) {
+        if ((UnixRupP->CmdsWaitingP == NULL) && (UnixRupP->CmdPendingP == NULL) && (readw(&UnixRupP->RupP->txcontrol) == TX_RUP_INACTIVE) && (CmdBlkP->PreFuncP ? (*CmdBlkP->PreFuncP) (CmdBlkP->PreArg, CmdBlkP)
+                                                                                                                                             : 1)) {
                 rio_dprintk(RIO_DEBUG_CMD, "RUP inactive-placing command straight on. Cmd byte is 0x%x\n", CmdBlkP->Packet.data[0]);
 
                 /*
                  ** Whammy! blat that pack!
                  */
-                HostP->Copy((caddr_t) & CmdBlkP->Packet, RIO_PTR(HostP->Caddr, UnixRupP->RupP->txpkt), sizeof(PKT));
+                HostP->Copy((caddr_t) & CmdBlkP->Packet, RIO_PTR(HostP->Caddr, UnixRupP->RupP->txpkt), sizeof(struct PKT));
 
                 /*
                  ** place command packet on the pending position.
@@ -622,11 +611,11 @@ int RIOQueueCmdBlk(struct Host *HostP, uint Rup, struct CmdBlk *CmdBlkP)
                 /*
                  ** set the command register
                  */
-                WWORD(UnixRupP->RupP->txcontrol, TX_PACKET_READY);
+                writew(TX_PACKET_READY, &UnixRupP->RupP->txcontrol);
 
                 rio_spin_unlock_irqrestore(&UnixRupP->RupLock, flags);
 
-                return RIO_SUCCESS;
+                return 0;
         }
         rio_dprintk(RIO_DEBUG_CMD, "RUP active - en-queing\n");
 
@@ -634,20 +623,20 @@ int RIOQueueCmdBlk(struct Host *HostP, uint Rup, struct CmdBlk *CmdBlkP)
                 rio_dprintk(RIO_DEBUG_CMD, "Rup active - command waiting\n");
         if (UnixRupP->CmdPendingP != NULL)
                 rio_dprintk(RIO_DEBUG_CMD, "Rup active - command pending\n");
-        if (RWORD(UnixRupP->RupP->txcontrol) != TX_RUP_INACTIVE)
+        if (readw(&UnixRupP->RupP->txcontrol) != TX_RUP_INACTIVE)
                 rio_dprintk(RIO_DEBUG_CMD, "Rup active - command rup not ready\n");
 
         Base = &UnixRupP->CmdsWaitingP;
 
-        rio_dprintk(RIO_DEBUG_CMD, "First try to queue cmdblk 0x%x at 0x%x\n", (int) CmdBlkP, (int) Base);
+        rio_dprintk(RIO_DEBUG_CMD, "First try to queue cmdblk %p at %p\n", CmdBlkP, Base);
 
         while (*Base) {
-                rio_dprintk(RIO_DEBUG_CMD, "Command cmdblk 0x%x here\n", (int) (*Base));
+                rio_dprintk(RIO_DEBUG_CMD, "Command cmdblk %p here\n", *Base);
                 Base = &((*Base)->NextP);
-                rio_dprintk(RIO_DEBUG_CMD, "Now try to queue cmd cmdblk 0x%x at 0x%x\n", (int) CmdBlkP, (int) Base);
+                rio_dprintk(RIO_DEBUG_CMD, "Now try to queue cmd cmdblk %p at %p\n", CmdBlkP, Base);
         }
 
-        rio_dprintk(RIO_DEBUG_CMD, "Will queue cmdblk 0x%x at 0x%x\n", (int) CmdBlkP, (int) Base);
+        rio_dprintk(RIO_DEBUG_CMD, "Will queue cmdblk %p at %p\n", CmdBlkP, Base);
 
         *Base = CmdBlkP;
 
@@ -655,7 +644,7 @@ int RIOQueueCmdBlk(struct Host *HostP, uint Rup, struct CmdBlk *CmdBlkP)
 
         rio_spin_unlock_irqrestore(&UnixRupP->RupLock, flags);
 
-        return RIO_SUCCESS;
+        return 0;
 }
 
 /*
@@ -664,10 +653,10 @@ int RIOQueueCmdBlk(struct Host *HostP, uint Rup, struct CmdBlk *CmdBlkP)
 */
 void RIOPollHostCommands(struct rio_info *p, struct Host *HostP)
 {
-        register struct CmdBlk *CmdBlkP;
-        register struct UnixRup *UnixRupP;
+        struct CmdBlk *CmdBlkP;
+        struct UnixRup *UnixRupP;
         struct PKT *PacketP;
-        ushort Rup;
+        unsigned short Rup;
         unsigned long flags;
 
 
@@ -684,16 +673,14 @@ void RIOPollHostCommands(struct rio_info *p, struct Host *HostP)
                 /*
                  ** First check for incoming commands:
                  */
-                if (RWORD(UnixRupP->RupP->rxcontrol) != RX_RUP_INACTIVE) {
+                if (readw(&UnixRupP->RupP->rxcontrol) != RX_RUP_INACTIVE) {
                         int FreeMe;
 
-                        PacketP = (PKT *) RIO_PTR(HostP->Caddr, RWORD(UnixRupP->RupP->rxpkt));
+                        PacketP = (struct PKT *) RIO_PTR(HostP->Caddr, readw(&UnixRupP->RupP->rxpkt));
 
-                        ShowPacket(DBG_CMD, PacketP);
-
-                        switch (RBYTE(PacketP->dest_port)) {
+                        switch (readb(&PacketP->dest_port)) {
                         case BOOT_RUP:
-                                rio_dprintk(RIO_DEBUG_CMD, "Incoming Boot %s packet '%x'\n", RBYTE(PacketP->len) & 0x80 ? "Command" : "Data", RBYTE(PacketP->data[0]));
+                                rio_dprintk(RIO_DEBUG_CMD, "Incoming Boot %s packet '%x'\n", readb(&PacketP->len) & 0x80 ? "Command" : "Data", readb(&PacketP->data[0]));
                                 rio_spin_unlock_irqrestore(&UnixRupP->RupLock, flags);
                                 FreeMe = RIOBootRup(p, Rup, HostP, PacketP);
                                 rio_spin_lock_irqsave(&UnixRupP->RupLock, flags);
@@ -708,7 +695,7 @@ void RIOPollHostCommands(struct rio_info *p, struct Host *HostP)
                                 rio_spin_unlock_irqrestore(&UnixRupP->RupLock, flags);
                                 FreeMe = RIOCommandRup(p, Rup, HostP, PacketP);
                                 if (PacketP->data[5] == MEMDUMP) {
-                                        rio_dprintk(RIO_DEBUG_CMD, "Memdump from 0x%x complete\n", *(ushort *) & (PacketP->data[6]));
+                                        rio_dprintk(RIO_DEBUG_CMD, "Memdump from 0x%x complete\n", *(unsigned short *) & (PacketP->data[6]));
                                         HostP->Copy((caddr_t) & (PacketP->data[8]), (caddr_t) p->RIOMemDump, 32);
                                 }
                                 rio_spin_lock_irqsave(&UnixRupP->RupLock, flags);
@@ -721,7 +708,7 @@ void RIOPollHostCommands(struct rio_info *p, struct Host *HostP)
                                 break;
 
                         default:
-                                rio_dprintk(RIO_DEBUG_CMD, "Unknown RUP %d\n", RBYTE(PacketP->dest_port));
+                                rio_dprintk(RIO_DEBUG_CMD, "Unknown RUP %d\n", readb(&PacketP->dest_port));
                                 FreeMe = 1;
                                 break;
                         }
@@ -730,11 +717,11 @@ void RIOPollHostCommands(struct rio_info *p, struct Host *HostP)
                                 rio_dprintk(RIO_DEBUG_CMD, "Free processed incoming command packet\n");
                                 put_free_end(HostP, PacketP);
 
-                                WWORD(UnixRupP->RupP->rxcontrol, RX_RUP_INACTIVE);
+                                writew(RX_RUP_INACTIVE, &UnixRupP->RupP->rxcontrol);
 
-                                if (RWORD(UnixRupP->RupP->handshake) == PHB_HANDSHAKE_SET) {
+                                if (readw(&UnixRupP->RupP->handshake) == PHB_HANDSHAKE_SET) {
                                         rio_dprintk(RIO_DEBUG_CMD, "Handshake rup %d\n", Rup);
-                                        WWORD(UnixRupP->RupP->handshake, PHB_HANDSHAKE_SET | PHB_HANDSHAKE_RESET);
+                                        writew(PHB_HANDSHAKE_SET | PHB_HANDSHAKE_RESET, &UnixRupP->RupP->handshake);
                                 }
                         }
                 }
@@ -744,7 +731,7 @@ void RIOPollHostCommands(struct rio_info *p, struct Host *HostP)
                  ** and it has completed, then tidy it up.
                  */
                 if ((CmdBlkP = UnixRupP->CmdPendingP) &&        /* ASSIGN! */
-                    (RWORD(UnixRupP->RupP->txcontrol) == TX_RUP_INACTIVE)) {
+                    (readw(&UnixRupP->RupP->txcontrol) == TX_RUP_INACTIVE)) {
                         /*
                          ** we are idle.
                          ** there is a command in pending.
@@ -755,7 +742,7 @@ void RIOPollHostCommands(struct rio_info *p, struct Host *HostP)
                         if (CmdBlkP->Packet.dest_port == BOOT_RUP)
                                 rio_dprintk(RIO_DEBUG_CMD, "Free Boot %s Command Block '%x'\n", CmdBlkP->Packet.len & 0x80 ? "Command" : "Data", CmdBlkP->Packet.data[0]);
 
-                        rio_dprintk(RIO_DEBUG_CMD, "Command 0x%x completed\n", (int) CmdBlkP);
+                        rio_dprintk(RIO_DEBUG_CMD, "Command %p completed\n", CmdBlkP);
 
                         /*
                          ** Clear the Rup lock to prevent mutual exclusion.
@@ -782,20 +769,20 @@ void RIOPollHostCommands(struct rio_info *p, struct Host *HostP)
                  ** is idle, then process the command
                  */
                 if ((CmdBlkP = UnixRupP->CmdsWaitingP) &&       /* ASSIGN! */
-                    (UnixRupP->CmdPendingP == NULL) && (RWORD(UnixRupP->RupP->txcontrol) == TX_RUP_INACTIVE)) {
+                    (UnixRupP->CmdPendingP == NULL) && (readw(&UnixRupP->RupP->txcontrol) == TX_RUP_INACTIVE)) {
                         /*
                          ** if the pre-function is non-zero, call it.
                          ** If it returns RIO_FAIL then don't
                          ** send this command yet!
                          */
-                        if (!(CmdBlkP->PreFuncP ? (*CmdBlkP->PreFuncP) (CmdBlkP->PreArg, CmdBlkP) : TRUE)) {
-                                rio_dprintk(RIO_DEBUG_CMD, "Not ready to start command 0x%x\n", (int) CmdBlkP);
+                        if (!(CmdBlkP->PreFuncP ? (*CmdBlkP->PreFuncP) (CmdBlkP->PreArg, CmdBlkP) : 1)) {
+                                rio_dprintk(RIO_DEBUG_CMD, "Not ready to start command %p\n", CmdBlkP);
                         } else {
-                                rio_dprintk(RIO_DEBUG_CMD, "Start new command 0x%x Cmd byte is 0x%x\n", (int) CmdBlkP, CmdBlkP->Packet.data[0]);
+                                rio_dprintk(RIO_DEBUG_CMD, "Start new command %p Cmd byte is 0x%x\n", CmdBlkP, CmdBlkP->Packet.data[0]);
                                 /*
                                  ** Whammy! blat that pack!
                                  */
-                                HostP->Copy((caddr_t) & CmdBlkP->Packet, RIO_PTR(HostP->Caddr, UnixRupP->RupP->txpkt), sizeof(PKT));
+                                HostP->Copy((caddr_t) & CmdBlkP->Packet, RIO_PTR(HostP->Caddr, UnixRupP->RupP->txpkt), sizeof(struct PKT));
 
                                 /*
                                  ** remove the command from the rup command queue...
@@ -810,7 +797,7 @@ void RIOPollHostCommands(struct rio_info *p, struct Host *HostP)
                                 /*
                                  ** set the command register
                                  */
-                                WWORD(UnixRupP->RupP->txcontrol, TX_PACKET_READY);
+                                writew(TX_PACKET_READY, &UnixRupP->RupP->txcontrol);
 
                                 /*
                                  ** the command block will be freed
@@ -822,7 +809,7 @@ void RIOPollHostCommands(struct rio_info *p, struct Host *HostP)
         } while (Rup);
 }
 
-int RIOWFlushMark(int iPortP, struct CmdBlk *CmdBlkP)
+int RIOWFlushMark(unsigned long iPortP, struct CmdBlk *CmdBlkP)
 {
         struct Port *PortP = (struct Port *) iPortP;
         unsigned long flags;
@@ -834,33 +821,32 @@ int RIOWFlushMark(int iPortP, struct CmdBlk *CmdBlkP)
         return RIOUnUse(iPortP, CmdBlkP);
 }
 
-int RIORFlushEnable(int iPortP, struct CmdBlk *CmdBlkP)
+int RIORFlushEnable(unsigned long iPortP, struct CmdBlk *CmdBlkP)
 {
         struct Port *PortP = (struct Port *) iPortP;
-        PKT *PacketP;
+        struct PKT *PacketP;
         unsigned long flags;
 
         rio_spin_lock_irqsave(&PortP->portSem, flags);
 
         while (can_remove_receive(&PacketP, PortP)) {
                 remove_receive(PortP);
-                ShowPacket(DBG_PROC, PacketP);
                 put_free_end(PortP->HostP, PacketP);
         }
 
-        if (RWORD(PortP->PhbP->handshake) == PHB_HANDSHAKE_SET) {
+        if (readw(&PortP->PhbP->handshake) == PHB_HANDSHAKE_SET) {
                 /*
                  ** MAGIC! (Basically, handshake the RX buffer, so that
                  ** the RTAs upstream can be re-enabled.)
                  */
                 rio_dprintk(RIO_DEBUG_CMD, "Util: Set RX handshake bit\n");
-                WWORD(PortP->PhbP->handshake, PHB_HANDSHAKE_SET | PHB_HANDSHAKE_RESET);
+                writew(PHB_HANDSHAKE_SET | PHB_HANDSHAKE_RESET, &PortP->PhbP->handshake);
         }
         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
         return RIOUnUse(iPortP, CmdBlkP);
 }
 
-int RIOUnUse(int iPortP, struct CmdBlk *CmdBlkP)
+int RIOUnUse(unsigned long iPortP, struct CmdBlk *CmdBlkP)
 {
         struct Port *PortP = (struct Port *) iPortP;
         unsigned long flags;
@@ -890,7 +876,7 @@ int RIOUnUse(int iPortP, struct CmdBlk *CmdBlkP)
          ** When PortP->InUse becomes NOT_INUSE, we must ensure that any data
          ** hanging around in the transmit buffer is sent immediately.
          */
-        WWORD(PortP->HostP->ParmMapP->tx_intr, 1);
+        writew(1, &PortP->HostP->ParmMapP->tx_intr);
         /* What to do here ..
            wakeup( (caddr_t)&(PortP->InUse) );
          */
@@ -898,10 +884,6 @@ int RIOUnUse(int iPortP, struct CmdBlk *CmdBlkP)
         return 0;
 }
 
-void ShowPacket(uint Flags, struct PKT *PacketP)
-{
-}
-
 /*
 ** 
 ** How to use this file:
diff --git a/drivers/char/rio/rioctrl.c b/drivers/char/rio/rioctrl.c
index fcf18a0612..d31aba62bb 100644
--- a/drivers/char/rio/rioctrl.c
+++ b/drivers/char/rio/rioctrl.c
@@ -51,15 +51,12 @@ static char *_rioctrl_c_sccs_ = "@(#)rioctrl.c	1.3";
 
 #include "linux_compat.h"
 #include "rio_linux.h"
-#include "typdef.h"
 #include "pkt.h"
 #include "daemon.h"
 #include "rio.h"
 #include "riospace.h"
-#include "top.h"
 #include "cmdpkt.h"
 #include "map.h"
-#include "riotypes.h"
 #include "rup.h"
 #include "port.h"
 #include "riodrvr.h"
@@ -72,12 +69,10 @@ static char *_rioctrl_c_sccs_ = "@(#)rioctrl.c	1.3";
 #include "unixrup.h"
 #include "board.h"
 #include "host.h"
-#include "error.h"
 #include "phb.h"
 #include "link.h"
 #include "cmdblk.h"
 #include "route.h"
-#include "control.h"
 #include "cirrus.h"
 #include "rioioctl.h"
 
@@ -131,30 +126,6 @@ static int
 
 #define drv_makedev(maj, min) ((((uint) maj & 0xff) << 8) | ((uint) min & 0xff))
 
-int copyin(int arg, caddr_t dp, int siz)
-{
-        int rv;
-
-        rio_dprintk(RIO_DEBUG_CTRL, "Copying %d bytes from user %p to %p.\n", siz, (void *) arg, dp);
-        rv = copy_from_user(dp, (void *) arg, siz);
-        if (rv)
-                return COPYFAIL;
-        else
-                return rv;
-}
-
-static int copyout(caddr_t dp, int arg, int siz)
-{
-        int rv;
-
-        rio_dprintk(RIO_DEBUG_CTRL, "Copying %d bytes to user %p from %p.\n", siz, (void *) arg, dp);
-        rv = copy_to_user((void *) arg, dp, siz);
-        if (rv)
-                return COPYFAIL;
-        else
-                return rv;
-}
-
 int riocontrol(p, dev, cmd, arg, su)
 struct rio_info *p;
 dev_t dev;
@@ -168,7 +139,7 @@ int su;
         ushort loop;
         int Entry;
         struct Port *PortP;
-        PKT *PacketP;
+        struct PKT *PacketP;
         int retval = 0;
         unsigned long flags;
 
@@ -178,7 +149,7 @@ int su;
         Host = 0;
         PortP = NULL;
 
-        rio_dprintk(RIO_DEBUG_CTRL, "control ioctl cmd: 0x%x arg: 0x%x\n", cmd, (int) arg);
+        rio_dprintk(RIO_DEBUG_CTRL, "control ioctl cmd: 0x%x arg: %p\n", cmd, arg);
 
         switch (cmd) {
                 /*
@@ -189,90 +160,34 @@ int su;
                  ** otherwise just the specified host card will be changed.
                  */
         case RIO_SET_TIMER:
-                rio_dprintk(RIO_DEBUG_CTRL, "RIO_SET_TIMER to %dms\n", (uint) arg);
+                rio_dprintk(RIO_DEBUG_CTRL, "RIO_SET_TIMER to %ldms\n", (unsigned long)arg);
                 {
                         int host, value;
-                        host = (uint) arg >> 16;
-                        value = (uint) arg & 0x0000ffff;
+                        host = ((unsigned long) arg >> 16) & 0x0000FFFF;
+                        value = (unsigned long) arg & 0x0000ffff;
                         if (host == -1) {
                                 for (host = 0; host < p->RIONumHosts; host++) {
                                         if (p->RIOHosts[host].Flags == RC_RUNNING) {
-                                                WWORD(p->RIOHosts[host].ParmMapP->timer, value);
+                                                writew(value, &p->RIOHosts[host].ParmMapP->timer);
                                         }
                                 }
                         } else if (host >= p->RIONumHosts) {
                                 return -EINVAL;
                         } else {
                                 if (p->RIOHosts[host].Flags == RC_RUNNING) {
-                                        WWORD(p->RIOHosts[host].ParmMapP->timer, value);
+                                        writew(value, &p->RIOHosts[host].ParmMapP->timer);
                                 }
                         }
                 }
                 return 0;
 
-        case RIO_IDENTIFY_DRIVER:
-                /*
-                 ** 15.10.1998 ARG - ESIL 0760 part fix
-                 ** Added driver ident string output.
-                 **
-                 #ifndef __THIS_RELEASE__
-                 #warning Driver Version string not defined !
-                 #endif
-                 cprintf("%s %s %s %s\n",
-                 RIO_DRV_STR,
-                 __THIS_RELEASE__,
-                 __DATE__, __TIME__ );
-
-                 return 0;
-
-                 case RIO_DISPLAY_HOST_CFG:
-                 **
-                 ** 15.10.1998 ARG - ESIL 0760 part fix
-                 ** Added driver host card ident string output.
-                 **
-                 ** Note that the only types currently supported
-                 ** are ISA and PCI. Also this driver does not
-                 ** (yet) distinguish between the Old PCI card
-                 ** and the Jet PCI card. In fact I think this
-                 ** driver only supports JET PCI !
-                 **
-
-                 for (Host = 0; Host < p->RIONumHosts; Host++)
-                 {
-                 HostP = &(p->RIOHosts[Host]);
-
-                 switch ( HostP->Type )
-                 {
-                 case RIO_AT :
-                 strcpy( host_type, RIO_AT_HOST_STR );
-                 break;
-
-                 case RIO_PCI :
-                 strcpy( host_type, RIO_PCI_HOST_STR );
-                 break;
-
-                 default :
-                 strcpy( host_type, "Unknown" );
-                 break;
-                 }
-
-                 cprintf(
-                 "RIO Host %d - Type:%s Addr:%X IRQ:%d\n",
-                 Host, host_type,
-                 (uint)HostP->PaddrP,
-                 (int)HostP->Ivec - 32  );
-                 }
-                 return 0;
-                 **
-                 */
-
         case RIO_FOAD_RTA:
                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_FOAD_RTA\n");
-                return RIOCommandRta(p, (uint) arg, RIOFoadRta);
+                return RIOCommandRta(p, (unsigned long)arg, RIOFoadRta);
 
         case RIO_ZOMBIE_RTA:
                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_ZOMBIE_RTA\n");
-                return RIOCommandRta(p, (uint) arg, RIOZombieRta);
+                return RIOCommandRta(p, (unsigned long)arg, RIOZombieRta);
 
         case RIO_IDENTIFY_RTA:
                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_IDENTIFY_RTA\n");
@@ -287,7 +202,7 @@ int su;
                         struct CmdBlk *CmdBlkP;
 
                         rio_dprintk(RIO_DEBUG_CTRL, "SPECIAL_RUP_CMD\n");
-                        if (copyin((int) arg, (caddr_t) & SpecialRupCmd, sizeof(SpecialRupCmd)) == COPYFAIL) {
+                        if (copy_from_user(&SpecialRupCmd, arg, sizeof(SpecialRupCmd))) {
                                 rio_dprintk(RIO_DEBUG_CTRL, "SPECIAL_RUP_CMD copy failed\n");
                                 p->RIOError.Error = COPYIN_FAILED;
                                 return -EFAULT;
@@ -302,7 +217,7 @@ int su;
                                 SpecialRupCmd.Host = 0;
                         rio_dprintk(RIO_DEBUG_CTRL, "Queue special rup command for host %d rup %d\n", SpecialRupCmd.Host, SpecialRupCmd.RupNum);
                         if (RIOQueueCmdBlk(&p->RIOHosts[SpecialRupCmd.Host], SpecialRupCmd.RupNum, CmdBlkP) == RIO_FAIL) {
-                                cprintf("FAILED TO QUEUE SPECIAL RUP COMMAND\n");
+                                printk(KERN_WARNING "rio: FAILED TO QUEUE SPECIAL RUP COMMAND\n");
                         }
                         return 0;
                 }
@@ -324,7 +239,7 @@ int su;
                 if ((retval = RIOApel(p)) != 0)
                         return retval;
 
-                if (copyout((caddr_t) p->RIOConnectTable, (int) arg, TOTAL_MAP_ENTRIES * sizeof(struct Map)) == COPYFAIL) {
+                if (copy_to_user(arg, p->RIOConnectTable, TOTAL_MAP_ENTRIES * sizeof(struct Map))) {
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_GET_TABLE copy failed\n");
                         p->RIOError.Error = COPYOUT_FAILED;
                         return -EFAULT;
@@ -369,7 +284,7 @@ int su;
                         p->RIOError.Error = NOT_SUPER_USER;
                         return -EPERM;
                 }
-                if (copyin((int) arg, (caddr_t) & p->RIOConnectTable[0], TOTAL_MAP_ENTRIES * sizeof(struct Map)) == COPYFAIL) {
+                if (copy_from_user(&p->RIOConnectTable[0], arg, TOTAL_MAP_ENTRIES * sizeof(struct Map))) {
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_PUT_TABLE copy failed\n");
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
@@ -415,7 +330,7 @@ int su;
                         p->RIOError.Error = NOT_SUPER_USER;
                         return -EPERM;
                 }
-                if (copyout((caddr_t) p->RIOBindTab, (int) arg, (sizeof(ulong) * MAX_RTA_BINDINGS)) == COPYFAIL) {
+                if (copy_to_user(arg, p->RIOBindTab, (sizeof(ulong) * MAX_RTA_BINDINGS))) {
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_GET_BINDINGS copy failed\n");
                         p->RIOError.Error = COPYOUT_FAILED;
                         return -EFAULT;
@@ -434,7 +349,7 @@ int su;
                         p->RIOError.Error = NOT_SUPER_USER;
                         return -EPERM;
                 }
-                if (copyin((int) arg, (caddr_t) & p->RIOBindTab[0], (sizeof(ulong) * MAX_RTA_BINDINGS)) == COPYFAIL) {
+                if (copy_from_user(&p->RIOBindTab[0], arg, (sizeof(ulong) * MAX_RTA_BINDINGS))) {
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_PUT_BINDINGS copy failed\n");
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
@@ -458,12 +373,12 @@ int su;
                         for (Entry = 0; Entry < MAX_RTA_BINDINGS; Entry++) {
                                 if ((EmptySlot == -1) && (p->RIOBindTab[Entry] == 0L))
                                         EmptySlot = Entry;
-                                else if (p->RIOBindTab[Entry] == (int) arg) {
+                                else if (p->RIOBindTab[Entry] == (long)arg) {
                                         /*
                                          ** Already exists - delete
                                          */
                                         p->RIOBindTab[Entry] = 0L;
-                                        rio_dprintk(RIO_DEBUG_CTRL, "Removing Rta %x from p->RIOBindTab\n", (int) arg);
+                                        rio_dprintk(RIO_DEBUG_CTRL, "Removing Rta %ld from p->RIOBindTab\n", (unsigned long)arg);
                                         return 0;
                                 }
                         }
@@ -471,10 +386,10 @@ int su;
                          ** Dosen't exist - add
                          */
                         if (EmptySlot != -1) {
-                                p->RIOBindTab[EmptySlot] = (int) arg;
-                                rio_dprintk(RIO_DEBUG_CTRL, "Adding Rta %x to p->RIOBindTab\n", (int) arg);
+                                p->RIOBindTab[EmptySlot] = (unsigned long)arg;
+                                rio_dprintk(RIO_DEBUG_CTRL, "Adding Rta %lx to p->RIOBindTab\n", (unsigned long) arg);
                         } else {
-                                rio_dprintk(RIO_DEBUG_CTRL, "p->RIOBindTab full! - Rta %x not added\n", (int) arg);
+                                rio_dprintk(RIO_DEBUG_CTRL, "p->RIOBindTab full! - Rta %lx not added\n", (unsigned long) arg);
                                 return -ENOMEM;
                         }
                         return 0;
@@ -482,7 +397,7 @@ int su;
 
         case RIO_RESUME:
                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_RESUME\n");
-                port = (uint) arg;
+                port = (unsigned long) arg;
                 if ((port < 0) || (port > 511)) {
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_RESUME: Bad port number %d\n", port);
                         p->RIOError.Error = PORT_NUMBER_OUT_OF_RANGE;
@@ -518,8 +433,7 @@ int su;
                         p->RIOError.Error = NOT_SUPER_USER;
                         return -EPERM;
                 }
-                if (copyin((int) arg, (caddr_t) & MapEnt, sizeof(MapEnt))
-                    == COPYFAIL) {
+                if (copy_from_user(&MapEnt, arg, sizeof(MapEnt))) {
                         rio_dprintk(RIO_DEBUG_CTRL, "Copy from user space failed\n");
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
@@ -533,8 +447,7 @@ int su;
                         p->RIOError.Error = NOT_SUPER_USER;
                         return -EPERM;
                 }
-                if (copyin((int) arg, (caddr_t) & MapEnt, sizeof(MapEnt))
-                    == COPYFAIL) {
+                if (copy_from_user(&MapEnt, arg, sizeof(MapEnt))) {
                         rio_dprintk(RIO_DEBUG_CTRL, "Copy from user space failed\n");
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
@@ -548,8 +461,7 @@ int su;
                         p->RIOError.Error = NOT_SUPER_USER;
                         return -EPERM;
                 }
-                if (copyin((int) arg, (caddr_t) & MapEnt, sizeof(MapEnt))
-                    == COPYFAIL) {
+                if (copy_from_user(&MapEnt, arg, sizeof(MapEnt))) {
                         rio_dprintk(RIO_DEBUG_CTRL, "Copy from data space failed\n");
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
@@ -557,30 +469,14 @@ int su;
                 return RIODeleteRta(p, &MapEnt);
 
         case RIO_QUICK_CHECK:
-                /*
-                 ** 09.12.1998 ARG - ESIL 0776 part fix
-                 ** A customer was using this to get the RTAs
-                 ** connect/disconnect status.
-                 ** RIOConCon() had been botched use RIOHalted
-                 ** to keep track of RTA connections and
-                 ** disconnections. That has been changed and
-                 ** RIORtaDisCons in the rio_info struct now
-                 ** does the job. So we need to return the value
-                 ** of RIORtaCons instead of RIOHalted.
-                 **
-                 if (copyout((caddr_t)&p->RIOHalted,(int)arg,
-                 sizeof(uint))==COPYFAIL) {
-                 **
-                 */
-
-                if (copyout((caddr_t) & p->RIORtaDisCons, (int) arg, sizeof(uint)) == COPYFAIL) {
+                if (copy_to_user(arg, &p->RIORtaDisCons, sizeof(unsigned int))) {
                         p->RIOError.Error = COPYOUT_FAILED;
                         return -EFAULT;
                 }
                 return 0;
 
         case RIO_LAST_ERROR:
-                if (copyout((caddr_t) & p->RIOError, (int) arg, sizeof(struct Error)) == COPYFAIL)
+                if (copy_to_user(arg, &p->RIOError, sizeof(struct Error)))
                         return -EFAULT;
                 return 0;
 
@@ -589,7 +485,7 @@ int su;
                 return -EINVAL;
 
         case RIO_GET_MODTYPE:
-                if (copyin((int) arg, (caddr_t) & port, sizeof(uint)) == COPYFAIL) {
+                if (copy_from_user(&port, arg, sizeof(unsigned int))) {
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
                 }
@@ -609,36 +505,11 @@ int su;
                  ** Return module type of port
                  */
                 port = PortP->HostP->UnixRups[PortP->RupNum].ModTypes;
-                if (copyout((caddr_t) & port, (int) arg, sizeof(uint)) == COPYFAIL) {
+                if (copy_to_user(arg, &port, sizeof(unsigned int))) {
                         p->RIOError.Error = COPYOUT_FAILED;
                         return -EFAULT;
                 }
                 return (0);
-                /*
-                 ** 02.03.1999 ARG - ESIL 0820 fix
-                 ** We are no longer using "Boot Mode", so these ioctls
-                 ** are not required :
-                 **
-                 case RIO_GET_BOOT_MODE :
-                 rio_dprint(RIO_DEBUG_CTRL, ("Get boot mode - %x\n", p->RIOBootMode));
-                 **
-                 ** Return boot state of system - BOOT_ALL, BOOT_OWN or BOOT_NONE
-                 **
-                 if (copyout((caddr_t)&p->RIOBootMode, (int)arg,
-                 sizeof(p->RIOBootMode)) == COPYFAIL) {
-                 p->RIOError.Error = COPYOUT_FAILED;
-                 return -EFAULT;
-                 }
-                 return(0);
-
-                 case RIO_SET_BOOT_MODE :
-                 p->RIOBootMode = (uint) arg;
-                 rio_dprint(RIO_DEBUG_CTRL, ("Set boot mode to 0x%x\n", p->RIOBootMode));
-                 return(0);
-                 **
-                 ** End ESIL 0820 fix
-                 */
-
         case RIO_BLOCK_OPENS:
                 rio_dprintk(RIO_DEBUG_CTRL, "Opens block until booted\n");
                 for (Entry = 0; Entry < RIO_PORTS; Entry++) {
@@ -650,8 +521,7 @@ int su;
 
         case RIO_SETUP_PORTS:
                 rio_dprintk(RIO_DEBUG_CTRL, "Setup ports\n");
-                if (copyin((int) arg, (caddr_t) & PortSetup, sizeof(PortSetup))
-                    == COPYFAIL) {
+                if (copy_from_user(&PortSetup, arg, sizeof(PortSetup))) {
                         p->RIOError.Error = COPYIN_FAILED;
                         rio_dprintk(RIO_DEBUG_CTRL, "EFAULT");
                         return -EFAULT;
@@ -667,7 +537,7 @@ int su;
                         return -EINVAL;
                 }
                 if (!p->RIOPortp) {
-                        cprintf("No p->RIOPortp array!\n");
+                        printk(KERN_ERR "rio: No p->RIOPortp array!\n");
                         rio_dprintk(RIO_DEBUG_CTRL, "No p->RIOPortp array!\n");
                         return -EIO;
                 }
@@ -681,8 +551,7 @@ int su;
 
         case RIO_GET_PORT_SETUP:
                 rio_dprintk(RIO_DEBUG_CTRL, "Get port setup\n");
-                if (copyin((int) arg, (caddr_t) & PortSetup, sizeof(PortSetup))
-                    == COPYFAIL) {
+                if (copy_from_user(&PortSetup, arg, sizeof(PortSetup))) {
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
                 }
@@ -698,13 +567,12 @@ int su;
                 PortSetup.Store = p->RIOPortp[port]->Store;
                 PortSetup.Lock = p->RIOPortp[port]->Lock;
                 PortSetup.XpCps = p->RIOPortp[port]->Xprint.XpCps;
-                bcopy(p->RIOPortp[port]->Xprint.XpOn, PortSetup.XpOn, MAX_XP_CTRL_LEN);
-                bcopy(p->RIOPortp[port]->Xprint.XpOff, PortSetup.XpOff, MAX_XP_CTRL_LEN);
+                memcpy(PortSetup.XpOn, p->RIOPortp[port]->Xprint.XpOn, MAX_XP_CTRL_LEN);
+                memcpy(PortSetup.XpOff, p->RIOPortp[port]->Xprint.XpOff, MAX_XP_CTRL_LEN);
                 PortSetup.XpOn[MAX_XP_CTRL_LEN - 1] = '\0';
                 PortSetup.XpOff[MAX_XP_CTRL_LEN - 1] = '\0';
 
-                if (copyout((caddr_t) & PortSetup, (int) arg, sizeof(PortSetup))
-                    == COPYFAIL) {
+                if (copy_to_user(arg, &PortSetup, sizeof(PortSetup))) {
                         p->RIOError.Error = COPYOUT_FAILED;
                         return -EFAULT;
                 }
@@ -712,7 +580,7 @@ int su;
 
         case RIO_GET_PORT_PARAMS:
                 rio_dprintk(RIO_DEBUG_CTRL, "Get port params\n");
-                if (copyin((int) arg, (caddr_t) & PortParams, sizeof(struct PortParams)) == COPYFAIL) {
+                if (copy_from_user(&PortParams, arg, sizeof(struct PortParams))) {
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
                 }
@@ -725,7 +593,7 @@ int su;
                 PortParams.State = PortP->State;
                 rio_dprintk(RIO_DEBUG_CTRL, "Port %d\n", PortParams.Port);
 
-                if (copyout((caddr_t) & PortParams, (int) arg, sizeof(struct PortParams)) == COPYFAIL) {
+                if (copy_to_user(arg, &PortParams, sizeof(struct PortParams))) {
                         p->RIOError.Error = COPYOUT_FAILED;
                         return -EFAULT;
                 }
@@ -733,8 +601,7 @@ int su;
 
         case RIO_GET_PORT_TTY:
                 rio_dprintk(RIO_DEBUG_CTRL, "Get port tty\n");
-                if (copyin((int) arg, (caddr_t) & PortTty, sizeof(struct PortTty))
-                    == COPYFAIL) {
+                if (copy_from_user(&PortTty, arg, sizeof(struct PortTty))) {
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
                 }
@@ -745,14 +612,14 @@ int su;
 
                 rio_dprintk(RIO_DEBUG_CTRL, "Port %d\n", PortTty.port);
                 PortP = (p->RIOPortp[PortTty.port]);
-                if (copyout((caddr_t) & PortTty, (int) arg, sizeof(struct PortTty)) == COPYFAIL) {
+                if (copy_to_user(arg, &PortTty, sizeof(struct PortTty))) {
                         p->RIOError.Error = COPYOUT_FAILED;
                         return -EFAULT;
                 }
                 return retval;
 
         case RIO_SET_PORT_TTY:
-                if (copyin((int) arg, (caddr_t) & PortTty, sizeof(struct PortTty)) == COPYFAIL) {
+                if (copy_from_user(&PortTty, arg, sizeof(struct PortTty))) {
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
                 }
@@ -767,8 +634,7 @@ int su;
 
         case RIO_SET_PORT_PARAMS:
                 rio_dprintk(RIO_DEBUG_CTRL, "Set port params\n");
-                if (copyin((int) arg, (caddr_t) & PortParams, sizeof(PortParams))
-                    == COPYFAIL) {
+                if (copy_from_user(&PortParams, arg, sizeof(PortParams))) {
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
                 }
@@ -784,7 +650,7 @@ int su;
 
         case RIO_GET_PORT_STATS:
                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_GET_PORT_STATS\n");
-                if (copyin((int) arg, (caddr_t) & portStats, sizeof(struct portStats)) == COPYFAIL) {
+                if (copy_from_user(&portStats, arg, sizeof(struct portStats))) {
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
                 }
@@ -799,14 +665,14 @@ int su;
                 portStats.opens = PortP->opens;
                 portStats.closes = PortP->closes;
                 portStats.ioctls = PortP->ioctls;
-                if (copyout((caddr_t) & portStats, (int) arg, sizeof(struct portStats)) == COPYFAIL) {
+                if (copy_to_user(arg, &portStats, sizeof(struct portStats))) {
                         p->RIOError.Error = COPYOUT_FAILED;
                         return -EFAULT;
                 }
                 return retval;
 
         case RIO_RESET_PORT_STATS:
-                port = (uint) arg;
+                port = (unsigned long) arg;
                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_RESET_PORT_STATS\n");
                 if (port >= RIO_PORTS) {
                         p->RIOError.Error = PORT_NUMBER_OUT_OF_RANGE;
@@ -824,7 +690,7 @@ int su;
 
         case RIO_GATHER_PORT_STATS:
                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_GATHER_PORT_STATS\n");
-                if (copyin((int) arg, (caddr_t) & portStats, sizeof(struct portStats)) == COPYFAIL) {
+                if (copy_from_user(&portStats, arg, sizeof(struct portStats))) {
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
                 }
@@ -840,7 +706,7 @@ int su;
 
         case RIO_READ_CONFIG:
                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_READ_CONFIG\n");
-                if (copyout((caddr_t) & p->RIOConf, (int) arg, sizeof(struct Conf)) == COPYFAIL) {
+                if (copy_to_user(arg, &p->RIOConf, sizeof(struct Conf))) {
                         p->RIOError.Error = COPYOUT_FAILED;
                         return -EFAULT;
                 }
@@ -852,8 +718,7 @@ int su;
                         p->RIOError.Error = NOT_SUPER_USER;
                         return -EPERM;
                 }
-                if (copyin((int) arg, (caddr_t) & p->RIOConf, sizeof(struct Conf))
-                    == COPYFAIL) {
+                if (copy_from_user(&p->RIOConf, arg, sizeof(struct Conf))) {
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
                 }
@@ -862,7 +727,7 @@ int su;
                  */
                 for (Host = 0; Host < p->RIONumHosts; Host++)
                         if ((p->RIOHosts[Host].Flags & RUN_STATE) == RC_RUNNING)
-                                WWORD(p->RIOHosts[Host].ParmMapP->timer, p->RIOConf.Timer);
+                                writew(p->RIOConf.Timer, &p->RIOHosts[Host].ParmMapP->timer);
                 return retval;
 
         case RIO_START_POLLER:
@@ -881,8 +746,7 @@ int su;
         case RIO_SETDEBUG:
         case RIO_GETDEBUG:
                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_SETDEBUG/RIO_GETDEBUG\n");
-                if (copyin((int) arg, (caddr_t) & DebugCtrl, sizeof(DebugCtrl))
-                    == COPYFAIL) {
+                if (copy_from_user(&DebugCtrl, arg, sizeof(DebugCtrl))) {
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
                 }
@@ -899,7 +763,7 @@ int su;
                                 rio_dprintk(RIO_DEBUG_CTRL, "Get global debug 0x%x wait 0x%x\n", p->rio_debug, p->RIODebugWait);
                                 DebugCtrl.Debug = p->rio_debug;
                                 DebugCtrl.Wait = p->RIODebugWait;
-                                if (copyout((caddr_t) & DebugCtrl, (int) arg, sizeof(DebugCtrl)) == COPYFAIL) {
+                                if (copy_to_user(arg, &DebugCtrl, sizeof(DebugCtrl))) {
                                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_SET/GET DEBUG: bad port number %d\n", DebugCtrl.SysPort);
                                         p->RIOError.Error = COPYOUT_FAILED;
                                         return -EFAULT;
@@ -921,7 +785,7 @@ int su;
                 } else {
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_GETDEBUG 0x%x\n", p->RIOPortp[DebugCtrl.SysPort]->Debug);
                         DebugCtrl.Debug = p->RIOPortp[DebugCtrl.SysPort]->Debug;
-                        if (copyout((caddr_t) & DebugCtrl, (int) arg, sizeof(DebugCtrl)) == COPYFAIL) {
+                        if (copy_to_user(arg, &DebugCtrl, sizeof(DebugCtrl))) {
                                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_GETDEBUG: Bad copy to user space\n");
                                 p->RIOError.Error = COPYOUT_FAILED;
                                 return -EFAULT;
@@ -936,43 +800,20 @@ int su;
                  ** textual null terminated string.
                  */
                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_VERSID\n");
-                if (copyout((caddr_t) RIOVersid(), (int) arg, sizeof(struct rioVersion)) == COPYFAIL) {
+                if (copy_to_user(arg, RIOVersid(), sizeof(struct rioVersion))) {
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_VERSID: Bad copy to user space (host=%d)\n", Host);
                         p->RIOError.Error = COPYOUT_FAILED;
                         return -EFAULT;
                 }
                 return retval;
 
-                /*
-                 ** !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-                 ** !! commented out previous 'RIO_VERSID' functionality !!
-                 ** !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-                 **
-                 case RIO_VERSID:
-                 **
-                 ** Enquire about the release and version.
-                 ** We return MAX_VERSION_LEN bytes, being a textual null
-                 ** terminated string.
-                 **
-                 rio_dprint(RIO_DEBUG_CTRL, ("RIO_VERSID\n"));
-                 if (copyout((caddr_t)RIOVersid(),
-                 (int)arg, MAX_VERSION_LEN ) == COPYFAIL ) {
-                 rio_dprint(RIO_DEBUG_CTRL, ("RIO_VERSID: Bad copy to user space\n",Host));
-                 p->RIOError.Error = COPYOUT_FAILED;
-                 return -EFAULT;
-                 }
-                 return retval;
-                 **
-                 ** !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-                 */
-
         case RIO_NUM_HOSTS:
                 /*
                  ** Enquire as to the number of hosts located
                  ** at init time.
                  */
                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_NUM_HOSTS\n");
-                if (copyout((caddr_t) & p->RIONumHosts, (int) arg, sizeof(p->RIONumHosts)) == COPYFAIL) {
+                if (copy_to_user(arg, &p->RIONumHosts, sizeof(p->RIONumHosts))) {
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_NUM_HOSTS: Bad copy to user space\n");
                         p->RIOError.Error = COPYOUT_FAILED;
                         return -EFAULT;
@@ -983,7 +824,7 @@ int su;
                 /*
                  ** Kill host. This may not be in the final version...
                  */
-                rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_FOAD %d\n", (int) arg);
+                rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_FOAD %ld\n", (unsigned long) arg);
                 if (!su) {
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_FOAD: Not super user\n");
                         p->RIOError.Error = NOT_SUPER_USER;
@@ -994,7 +835,7 @@ int su;
 
                 for (Host = 0; Host < p->RIONumHosts; Host++) {
                         (void) RIOBoardTest(p->RIOHosts[Host].PaddrP, p->RIOHosts[Host].Caddr, p->RIOHosts[Host].Type, p->RIOHosts[Host].Slot);
-                        bzero((caddr_t) & p->RIOHosts[Host].Flags, ((int) &p->RIOHosts[Host].____end_marker____) - ((int) &p->RIOHosts[Host].Flags));
+                        memset(&p->RIOHosts[Host].Flags, 0, ((char *) &p->RIOHosts[Host].____end_marker____) - ((char *) &p->RIOHosts[Host].Flags));
                         p->RIOHosts[Host].Flags = RC_WAITING;
                 }
                 RIOFoadWakeup(p);
@@ -1017,7 +858,7 @@ int su;
                         p->RIOError.Error = NOT_SUPER_USER;
                         return -EPERM;
                 }
-                if (copyin((int) arg, (caddr_t) & DownLoad, sizeof(DownLoad)) == COPYFAIL) {
+                if (copy_from_user(&DownLoad, arg, sizeof(DownLoad))) {
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_DOWNLOAD: Copy in from user space failed\n");
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
@@ -1045,9 +886,9 @@ int su;
 
         case RIO_PARMS:
                 {
-                        uint host;
+                        unsigned int host;
 
-                        if (copyin((int) arg, (caddr_t) & host, sizeof(host)) == COPYFAIL) {
+                        if (copy_from_user(&host, arg, sizeof(host))) {
                                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_REQ: Copy in from user space failed\n");
                                 p->RIOError.Error = COPYIN_FAILED;
                                 return -EFAULT;
@@ -1056,7 +897,7 @@ int su;
                          ** Fetch the parmmap
                          */
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_PARMS\n");
-                        if (copyout((caddr_t) p->RIOHosts[host].ParmMapP, (int) arg, sizeof(PARM_MAP)) == COPYFAIL) {
+                        if (copy_to_user(arg, p->RIOHosts[host].ParmMapP, sizeof(PARM_MAP))) {
                                 p->RIOError.Error = COPYOUT_FAILED;
                                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_PARMS: Copy out to user space failed\n");
                                 return -EFAULT;
@@ -1066,7 +907,7 @@ int su;
 
         case RIO_HOST_REQ:
                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_REQ\n");
-                if (copyin((int) arg, (caddr_t) & HostReq, sizeof(HostReq)) == COPYFAIL) {
+                if (copy_from_user(&HostReq, arg, sizeof(HostReq))) {
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_REQ: Copy in from user space failed\n");
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
@@ -1078,7 +919,7 @@ int su;
                 }
                 rio_dprintk(RIO_DEBUG_CTRL, "Request for host %d\n", HostReq.HostNum);
 
-                if (copyout((caddr_t) & p->RIOHosts[HostReq.HostNum], (int) HostReq.HostP, sizeof(struct Host)) == COPYFAIL) {
+                if (copy_to_user(HostReq.HostP, &p->RIOHosts[HostReq.HostNum], sizeof(struct Host))) {
                         p->RIOError.Error = COPYOUT_FAILED;
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_REQ: Bad copy to user space\n");
                         return -EFAULT;
@@ -1087,7 +928,7 @@ int su;
 
         case RIO_HOST_DPRAM:
                 rio_dprintk(RIO_DEBUG_CTRL, "Request for DPRAM\n");
-                if (copyin((int) arg, (caddr_t) & HostDpRam, sizeof(HostDpRam)) == COPYFAIL) {
+                if (copy_from_user(&HostDpRam, arg, sizeof(HostDpRam))) {
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_DPRAM: Copy in from user space failed\n");
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
@@ -1104,13 +945,13 @@ int su;
                         /* It's hardware like this that really gets on my tits. */
                         static unsigned char copy[sizeof(struct DpRam)];
                         for (off = 0; off < sizeof(struct DpRam); off++)
-                                copy[off] = p->RIOHosts[HostDpRam.HostNum].Caddr[off];
-                        if (copyout((caddr_t) copy, (int) HostDpRam.DpRamP, sizeof(struct DpRam)) == COPYFAIL) {
+                                copy[off] = readb(&p->RIOHosts[HostDpRam.HostNum].Caddr[off]);
+                        if (copy_to_user(HostDpRam.DpRamP, copy, sizeof(struct DpRam))) {
                                 p->RIOError.Error = COPYOUT_FAILED;
                                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_DPRAM: Bad copy to user space\n");
                                 return -EFAULT;
                         }
-                } else if (copyout((caddr_t) p->RIOHosts[HostDpRam.HostNum].Caddr, (int) HostDpRam.DpRamP, sizeof(struct DpRam)) == COPYFAIL) {
+                } else if (copy_to_user(HostDpRam.DpRamP, p->RIOHosts[HostDpRam.HostNum].Caddr, sizeof(struct DpRam))) {
                         p->RIOError.Error = COPYOUT_FAILED;
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_DPRAM: Bad copy to user space\n");
                         return -EFAULT;
@@ -1119,13 +960,13 @@ int su;
 
         case RIO_SET_BUSY:
                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_SET_BUSY\n");
-                if ((int) arg < 0 || (int) arg > 511) {
-                        rio_dprintk(RIO_DEBUG_CTRL, "RIO_SET_BUSY: Bad port number %d\n", (int) arg);
+                if ((unsigned long) arg > 511) {
+                        rio_dprintk(RIO_DEBUG_CTRL, "RIO_SET_BUSY: Bad port number %ld\n", (unsigned long) arg);
                         p->RIOError.Error = PORT_NUMBER_OUT_OF_RANGE;
                         return -EINVAL;
                 }
                 rio_spin_lock_irqsave(&PortP->portSem, flags);
-                p->RIOPortp[(int) arg]->State |= RIO_BUSY;
+                p->RIOPortp[(unsigned long) arg]->State |= RIO_BUSY;
                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
                 return retval;
 
@@ -1135,7 +976,7 @@ int su;
                  ** (probably for debug reasons)
                  */
                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_PORT\n");
-                if (copyin((int) arg, (caddr_t) & PortReq, sizeof(PortReq)) == COPYFAIL) {
+                if (copy_from_user(&PortReq, arg, sizeof(PortReq))) {
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_PORT: Copy in from user space failed\n");
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
@@ -1147,7 +988,7 @@ int su;
                         return -ENXIO;
                 }
                 rio_dprintk(RIO_DEBUG_CTRL, "Request for port %d\n", PortReq.SysPort);
-                if (copyout((caddr_t) p->RIOPortp[PortReq.SysPort], (int) PortReq.PortP, sizeof(struct Port)) == COPYFAIL) {
+                if (copy_to_user(PortReq.PortP, p->RIOPortp[PortReq.SysPort], sizeof(struct Port))) {
                         p->RIOError.Error = COPYOUT_FAILED;
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_PORT: Bad copy to user space\n");
                         return -EFAULT;
@@ -1160,7 +1001,7 @@ int su;
                  ** (probably for debug reasons)
                  */
                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_RUP\n");
-                if (copyin((int) arg, (caddr_t) & RupReq, sizeof(RupReq)) == COPYFAIL) {
+                if (copy_from_user(&RupReq, arg, sizeof(RupReq))) {
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_RUP: Copy in from user space failed\n");
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
@@ -1184,7 +1025,7 @@ int su;
                 }
                 rio_dprintk(RIO_DEBUG_CTRL, "Request for rup %d from host %d\n", RupReq.RupNum, RupReq.HostNum);
 
-                if (copyout((caddr_t) HostP->UnixRups[RupReq.RupNum].RupP, (int) RupReq.RupP, sizeof(struct RUP)) == COPYFAIL) {
+                if (copy_to_user(HostP->UnixRups[RupReq.RupNum].RupP, RupReq.RupP, sizeof(struct RUP))) {
                         p->RIOError.Error = COPYOUT_FAILED;
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_RUP: Bad copy to user space\n");
                         return -EFAULT;
@@ -1197,7 +1038,7 @@ int su;
                  ** (probably for debug reasons)
                  */
                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_LPB\n");
-                if (copyin((int) arg, (caddr_t) & LpbReq, sizeof(LpbReq)) == COPYFAIL) {
+                if (copy_from_user(&LpbReq, arg, sizeof(LpbReq))) {
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_LPB: Bad copy from user space\n");
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
@@ -1221,7 +1062,7 @@ int su;
                 }
                 rio_dprintk(RIO_DEBUG_CTRL, "Request for lpb %d from host %d\n", LpbReq.Link, LpbReq.Host);
 
-                if (copyout((caddr_t) & HostP->LinkStrP[LpbReq.Link], (int) LpbReq.LpbP, sizeof(struct LPB)) == COPYFAIL) {
+                if (copy_to_user(LpbReq.LpbP, &HostP->LinkStrP[LpbReq.Link], sizeof(struct LPB))) {
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_HOST_LPB: Bad copy to user space\n");
                         p->RIOError.Error = COPYOUT_FAILED;
                         return -EFAULT;
@@ -1252,12 +1093,13 @@ int su;
                         p->RIOError.Error = SIGNALS_ALREADY_SET;
                         return -EBUSY;
                 }
-                p->RIOSignalProcess = getpid();
+                /* FIXME: PID tracking */
+                p->RIOSignalProcess = current->pid;
                 p->RIOPrintDisabled = DONT_PRINT;
                 return retval;
 
         case RIO_SIGNALS_OFF:
-                if (p->RIOSignalProcess != getpid()) {
+                if (p->RIOSignalProcess != current->pid) {
                         p->RIOError.Error = NOT_RECEIVING_PROCESS;
                         return -EPERM;
                 }
@@ -1294,7 +1136,7 @@ int su;
         case RIO_MAP_B110_TO_110:
         case RIO_MAP_B110_TO_115200:
                 rio_dprintk(RIO_DEBUG_CTRL, "Baud rate mapping\n");
-                port = (uint) arg;
+                port = (unsigned long) arg;
                 if (port < 0 || port > 511) {
                         rio_dprintk(RIO_DEBUG_CTRL, "Baud rate mapping: Bad port number %d\n", port);
                         p->RIOError.Error = PORT_NUMBER_OUT_OF_RANGE;
@@ -1324,7 +1166,7 @@ int su;
 
         case RIO_SEND_PACKET:
                 rio_dprintk(RIO_DEBUG_CTRL, "RIO_SEND_PACKET\n");
-                if (copyin((int) arg, (caddr_t) & SendPack, sizeof(SendPack)) == COPYFAIL) {
+                if (copy_from_user(&SendPack, arg, sizeof(SendPack))) {
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_SEND_PACKET: Bad copy from user space\n");
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
@@ -1344,9 +1186,9 @@ int su;
                 }
 
                 for (loop = 0; loop < (ushort) (SendPack.Len & 127); loop++)
-                        WBYTE(PacketP->data[loop], SendPack.Data[loop]);
+                        writeb(SendPack.Data[loop], &PacketP->data[loop]);
 
-                WBYTE(PacketP->len, SendPack.Len);
+                writeb(SendPack.Len, &PacketP->len);
 
                 add_transmit(PortP);
                 /*
@@ -1368,7 +1210,7 @@ int su;
                 return su ? 0 : -EPERM;
 
         case RIO_WHAT_MESG:
-                if (copyout((caddr_t) & p->RIONoMessage, (int) arg, sizeof(p->RIONoMessage)) == COPYFAIL) {
+                if (copy_to_user(arg, &p->RIONoMessage, sizeof(p->RIONoMessage))) {
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_WHAT_MESG: Bad copy to user space\n");
                         p->RIOError.Error = COPYOUT_FAILED;
                         return -EFAULT;
@@ -1376,7 +1218,7 @@ int su;
                 return 0;
 
         case RIO_MEM_DUMP:
-                if (copyin((int) arg, (caddr_t) & SubCmd, sizeof(struct SubCmdStruct)) == COPYFAIL) {
+                if (copy_from_user(&SubCmd, arg, sizeof(struct SubCmdStruct))) {
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
                 }
@@ -1406,7 +1248,7 @@ int su;
                         PortP->State |= RIO_BUSY;
 
                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-                if (copyout((caddr_t) p->RIOMemDump, (int) arg, MEMDUMP_SIZE) == COPYFAIL) {
+                if (copy_to_user(arg, p->RIOMemDump, MEMDUMP_SIZE)) {
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_MEM_DUMP copy failed\n");
                         p->RIOError.Error = COPYOUT_FAILED;
                         return -EFAULT;
@@ -1414,30 +1256,30 @@ int su;
                 return 0;
 
         case RIO_TICK:
-                if ((int) arg < 0 || (int) arg >= p->RIONumHosts)
+                if ((unsigned long) arg >= p->RIONumHosts)
                         return -EINVAL;
-                rio_dprintk(RIO_DEBUG_CTRL, "Set interrupt for host %d\n", (int) arg);
-                WBYTE(p->RIOHosts[(int) arg].SetInt, 0xff);
+                rio_dprintk(RIO_DEBUG_CTRL, "Set interrupt for host %ld\n", (unsigned long) arg);
+                writeb(0xFF, &p->RIOHosts[(unsigned long) arg].SetInt);
                 return 0;
 
         case RIO_TOCK:
-                if ((int) arg < 0 || (int) arg >= p->RIONumHosts)
+                if ((unsigned long) arg >= p->RIONumHosts)
                         return -EINVAL;
-                rio_dprintk(RIO_DEBUG_CTRL, "Clear interrupt for host %d\n", (int) arg);
-                WBYTE((p->RIOHosts[(int) arg].ResetInt), 0xff);
+                rio_dprintk(RIO_DEBUG_CTRL, "Clear interrupt for host %ld\n", (unsigned long) arg);
+                writeb(0xFF, &p->RIOHosts[(unsigned long) arg].ResetInt);
                 return 0;
 
         case RIO_READ_CHECK:
                 /* Check reads for pkts with data[0] the same */
                 p->RIOReadCheck = !p->RIOReadCheck;
-                if (copyout((caddr_t) & p->RIOReadCheck, (int) arg, sizeof(uint)) == COPYFAIL) {
+                if (copy_to_user(arg, &p->RIOReadCheck, sizeof(unsigned int))) {
                         p->RIOError.Error = COPYOUT_FAILED;
                         return -EFAULT;
                 }
                 return 0;
 
         case RIO_READ_REGISTER:
-                if (copyin((int) arg, (caddr_t) & SubCmd, sizeof(struct SubCmdStruct)) == COPYFAIL) {
+                if (copy_from_user(&SubCmd, arg, sizeof(struct SubCmdStruct))) {
                         p->RIOError.Error = COPYIN_FAILED;
                         return -EFAULT;
                 }
@@ -1472,7 +1314,7 @@ int su;
                         PortP->State |= RIO_BUSY;
 
                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-                if (copyout((caddr_t) & p->CdRegister, (int) arg, sizeof(uint)) == COPYFAIL) {
+                if (copy_to_user(arg, &p->CdRegister, sizeof(unsigned int))) {
                         rio_dprintk(RIO_DEBUG_CTRL, "RIO_READ_REGISTER copy failed\n");
                         p->RIOError.Error = COPYOUT_FAILED;
                         return -EFAULT;
@@ -1485,21 +1327,22 @@ int su;
                  */
         case RIO_MAKE_DEV:
                 {
-                        uint port = (uint) arg & RIO_MODEM_MASK;
+                        unsigned int port = (unsigned long) arg & RIO_MODEM_MASK;
+                        unsigned int ret;
 
-                        switch ((uint) arg & RIO_DEV_MASK) {
+                        switch ((unsigned long) arg & RIO_DEV_MASK) {
                         case RIO_DEV_DIRECT:
-                                arg = (caddr_t) drv_makedev(MAJOR(dev), port);
-                                rio_dprintk(RIO_DEBUG_CTRL, "Makedev direct 0x%x is 0x%x\n", port, (int) arg);
-                                return (int) arg;
+                                ret = drv_makedev(MAJOR(dev), port);
+                                rio_dprintk(RIO_DEBUG_CTRL, "Makedev direct 0x%x is 0x%x\n", port, ret);
+                                return ret;
                         case RIO_DEV_MODEM:
-                                arg = (caddr_t) drv_makedev(MAJOR(dev), (port | RIO_MODEM_BIT));
-                                rio_dprintk(RIO_DEBUG_CTRL, "Makedev modem 0x%x is 0x%x\n", port, (int) arg);
-                                return (int) arg;
+                                ret = drv_makedev(MAJOR(dev), (port | RIO_MODEM_BIT));
+                                rio_dprintk(RIO_DEBUG_CTRL, "Makedev modem 0x%x is 0x%x\n", port, ret);
+                                return ret;
                         case RIO_DEV_XPRINT:
-                                arg = (caddr_t) drv_makedev(MAJOR(dev), port);
-                                rio_dprintk(RIO_DEBUG_CTRL, "Makedev printer 0x%x is 0x%x\n", port, (int) arg);
-                                return (int) arg;
+                                ret = drv_makedev(MAJOR(dev), port);
+                                rio_dprintk(RIO_DEBUG_CTRL, "Makedev printer 0x%x is 0x%x\n", port, ret);
+                                return ret;
                         }
                         rio_dprintk(RIO_DEBUG_CTRL, "MAKE Device is called\n");
                         return -EINVAL;
@@ -1513,18 +1356,19 @@ int su;
                 {
                         dev_t dv;
                         int mino;
+                        unsigned long ret;
 
-                        dv = (dev_t) ((int) arg);
+                        dv = (dev_t) ((unsigned long) arg);
                         mino = RIO_UNMODEM(dv);
 
                         if (RIO_ISMODEM(dv)) {
                                 rio_dprintk(RIO_DEBUG_CTRL, "Minor for device 0x%x: modem %d\n", dv, mino);
-                                arg = (caddr_t) (mino | RIO_DEV_MODEM);
+                                ret = mino | RIO_DEV_MODEM;
                         } else {
                                 rio_dprintk(RIO_DEBUG_CTRL, "Minor for device 0x%x: direct %d\n", dv, mino);
-                                arg = (caddr_t) (mino | RIO_DEV_DIRECT);
+                                ret = mino | RIO_DEV_DIRECT;
                         }
-                        return (int) arg;
+                        return ret;
                 }
         }
         rio_dprintk(RIO_DEBUG_CTRL, "INVALID DAEMON IOCTL 0x%x\n", cmd);
@@ -1537,10 +1381,7 @@ int su;
 /*
 ** Pre-emptive commands go on RUPs and are only one byte long.
 */
-int RIOPreemptiveCmd(p, PortP, Cmd)
-struct rio_info *p;
-struct Port *PortP;
-uchar Cmd;
+int RIOPreemptiveCmd(struct rio_info *p, struct Port *PortP, u8 Cmd)
 {
         struct CmdBlk *CmdBlkP;
         struct PktCmd_M *PktCmdP;
@@ -1558,7 +1399,7 @@ uchar Cmd;
                 return RIO_FAIL;
         }
 
-        rio_dprintk(RIO_DEBUG_CTRL, "Command blk 0x%x - InUse now %d\n", (int) CmdBlkP, PortP->InUse);
+        rio_dprintk(RIO_DEBUG_CTRL, "Command blk %p - InUse now %d\n", CmdBlkP, PortP->InUse);
 
         PktCmdP = (struct PktCmd_M *) &CmdBlkP->Packet.data[0];
 
@@ -1572,7 +1413,7 @@ uchar Cmd;
         CmdBlkP->Packet.dest_port = COMMAND_RUP;
         CmdBlkP->Packet.len = PKT_CMD_BIT | 2;
         CmdBlkP->PostFuncP = RIOUnUse;
-        CmdBlkP->PostArg = (int) PortP;
+        CmdBlkP->PostArg = (unsigned long) PortP;
         PktCmdP->Command = Cmd;
         port = PortP->HostPort % (ushort) PORTS_PER_RTA;
         /*
@@ -1584,38 +1425,38 @@ uchar Cmd;
 
         switch (Cmd) {
         case MEMDUMP:
-                rio_dprintk(RIO_DEBUG_CTRL, "Queue MEMDUMP command blk 0x%x (addr 0x%x)\n", (int) CmdBlkP, (int) SubCmd.Addr);
+                rio_dprintk(RIO_DEBUG_CTRL, "Queue MEMDUMP command blk %p (addr 0x%x)\n", CmdBlkP, (int) SubCmd.Addr);
                 PktCmdP->SubCommand = MEMDUMP;
                 PktCmdP->SubAddr = SubCmd.Addr;
                 break;
         case FCLOSE:
-                rio_dprintk(RIO_DEBUG_CTRL, "Queue FCLOSE command blk 0x%x\n", (int) CmdBlkP);
+                rio_dprintk(RIO_DEBUG_CTRL, "Queue FCLOSE command blk %p\n", CmdBlkP);
                 break;
         case READ_REGISTER:
-                rio_dprintk(RIO_DEBUG_CTRL, "Queue READ_REGISTER (0x%x) command blk 0x%x\n", (int) SubCmd.Addr, (int) CmdBlkP);
+                rio_dprintk(RIO_DEBUG_CTRL, "Queue READ_REGISTER (0x%x) command blk %p\n", (int) SubCmd.Addr, CmdBlkP);
                 PktCmdP->SubCommand = READ_REGISTER;
                 PktCmdP->SubAddr = SubCmd.Addr;
                 break;
         case RESUME:
-                rio_dprintk(RIO_DEBUG_CTRL, "Queue RESUME command blk 0x%x\n", (int) CmdBlkP);
+                rio_dprintk(RIO_DEBUG_CTRL, "Queue RESUME command blk %p\n", CmdBlkP);
                 break;
         case RFLUSH:
-                rio_dprintk(RIO_DEBUG_CTRL, "Queue RFLUSH command blk 0x%x\n", (int) CmdBlkP);
+                rio_dprintk(RIO_DEBUG_CTRL, "Queue RFLUSH command blk %p\n", CmdBlkP);
                 CmdBlkP->PostFuncP = RIORFlushEnable;
                 break;
         case SUSPEND:
-                rio_dprintk(RIO_DEBUG_CTRL, "Queue SUSPEND command blk 0x%x\n", (int) CmdBlkP);
+                rio_dprintk(RIO_DEBUG_CTRL, "Queue SUSPEND command blk %p\n", CmdBlkP);
                 break;
 
         case MGET:
-                rio_dprintk(RIO_DEBUG_CTRL, "Queue MGET command blk 0x%x\n", (int) CmdBlkP);
+                rio_dprintk(RIO_DEBUG_CTRL, "Queue MGET command blk %p\n", CmdBlkP);
                 break;
 
         case MSET:
         case MBIC:
         case MBIS:
                 CmdBlkP->Packet.data[4] = (char) PortP->ModemLines;
-                rio_dprintk(RIO_DEBUG_CTRL, "Queue MSET/MBIC/MBIS command blk 0x%x\n", (int) CmdBlkP);
+                rio_dprintk(RIO_DEBUG_CTRL, "Queue MSET/MBIC/MBIS command blk %p\n", CmdBlkP);
                 break;
 
         case WFLUSH:
@@ -1629,7 +1470,7 @@ uchar Cmd;
                         RIOFreeCmdBlk(CmdBlkP);
                         return (RIO_FAIL);
                 } else {
-                        rio_dprintk(RIO_DEBUG_CTRL, "Queue WFLUSH command blk 0x%x\n", (int) CmdBlkP);
+                        rio_dprintk(RIO_DEBUG_CTRL, "Queue WFLUSH command blk %p\n", CmdBlkP);
                         CmdBlkP->PostFuncP = RIOWFlushMark;
                 }
                 break;
diff --git a/drivers/char/rio/riodrvr.h b/drivers/char/rio/riodrvr.h
index 663ee0914e..3cffe275f2 100644
--- a/drivers/char/rio/riodrvr.h
+++ b/drivers/char/rio/riodrvr.h
@@ -72,42 +72,42 @@ struct rio_info {
 */
         int RIOHalted;          /* halted ? */
         int RIORtaDisCons;      /* RTA connections/disconnections */
-        uint RIOReadCheck;      /* Rio read check */
-        uint RIONoMessage;      /* To display message or not */
-        uint RIONumBootPkts;    /* how many packets for an RTA */
-        uint RIOBootCount;      /* size of RTA code */
-        uint RIOBooting;        /* count of outstanding boots */
-        uint RIOSystemUp;       /* Booted ?? */
-        uint RIOCounting;       /* for counting interrupts */
-        uint RIOIntCount;       /* # of intr since last check */
-        uint RIOTxCount;        /* number of xmit intrs  */
-        uint RIORxCount;        /* number of rx intrs */
-        uint RIORupCount;       /* number of rup intrs */
+        unsigned int RIOReadCheck;      /* Rio read check */
+        unsigned int RIONoMessage;      /* To display message or not */
+        unsigned int RIONumBootPkts;    /* how many packets for an RTA */
+        unsigned int RIOBootCount;      /* size of RTA code */
+        unsigned int RIOBooting;        /* count of outstanding boots */
+        unsigned int RIOSystemUp;       /* Booted ?? */
+        unsigned int RIOCounting;       /* for counting interrupts */
+        unsigned int RIOIntCount;       /* # of intr since last check */
+        unsigned int RIOTxCount;        /* number of xmit intrs  */
+        unsigned int RIORxCount;        /* number of rx intrs */
+        unsigned int RIORupCount;       /* number of rup intrs */
         int RIXTimer;
         int RIOBufferSize;      /* Buffersize */
         int RIOBufferMask;      /* Buffersize */
 
         int RIOFirstMajor;      /* First host card's major no */
 
-        uint RIOLastPortsMapped;        /* highest port number known */
-        uint RIOFirstPortsMapped;       /* lowest port number known */
+        unsigned int RIOLastPortsMapped;        /* highest port number known */
+        unsigned int RIOFirstPortsMapped;       /* lowest port number known */
 
-        uint RIOLastPortsBooted;        /* highest port number running */
-        uint RIOFirstPortsBooted;       /* lowest port number running */
+        unsigned int RIOLastPortsBooted;        /* highest port number running */
+        unsigned int RIOFirstPortsBooted;       /* lowest port number running */
 
-        uint RIOLastPortsOpened;        /* highest port number running */
-        uint RIOFirstPortsOpened;       /* lowest port number running */
+        unsigned int RIOLastPortsOpened;        /* highest port number running */
+        unsigned int RIOFirstPortsOpened;       /* lowest port number running */
 
         /* Flag to say that the topology information has been changed. */
-        uint RIOQuickCheck;
-        uint CdRegister;        /* ??? */
+        unsigned int RIOQuickCheck;
+        unsigned int CdRegister;        /* ??? */
         int RIOSignalProcess;   /* Signalling process */
         int rio_debug;          /* To debug ... */
         int RIODebugWait;       /* For what ??? */
         int tpri;               /* Thread prio */
         int tid;                /* Thread id */
-        uint _RIO_Polled;       /* Counter for polling */
-        uint _RIO_Interrupted;  /* Counter for interrupt */
+        unsigned int _RIO_Polled;       /* Counter for polling */
+        unsigned int _RIO_Interrupted;  /* Counter for interrupt */
         int intr_tid;           /* iointset return value */
         int TxEnSem;            /* TxEnable Semaphore */
 
@@ -121,9 +121,9 @@ struct rio_info {
         struct Map RIOSavedTable[TOTAL_MAP_ENTRIES];
 
         /* RTA to host binding table for master/slave operation */
-        ulong RIOBindTab[MAX_RTA_BINDINGS];
+        unsigned long RIOBindTab[MAX_RTA_BINDINGS];
         /* RTA memory dump variable */
-        uchar RIOMemDump[MEMDUMP_SIZE];
+        unsigned char RIOMemDump[MEMDUMP_SIZE];
         struct ModuleInfo RIOModuleTypes[MAX_MODULE_TYPES];
 
 };
@@ -138,7 +138,5 @@ struct rio_info {
 
 
 #define RIO_RESET_INT   0x7d80
-#define WRBYTE(x,y)             *(volatile unsigned char *)((x)) = \
-                                        (unsigned char)(y)
 
 #endif                          /* __riodrvr.h */
diff --git a/drivers/char/rio/rioinit.c b/drivers/char/rio/rioinit.c
index 0d44ef464e..24d2992154 100644
--- a/drivers/char/rio/rioinit.c
+++ b/drivers/char/rio/rioinit.c
@@ -51,15 +51,12 @@ static char *_rioinit_c_sccs_ = "@(#)rioinit.c	1.3";
 
 
 #include "linux_compat.h"
-#include "typdef.h"
 #include "pkt.h"
 #include "daemon.h"
 #include "rio.h"
 #include "riospace.h"
-#include "top.h"
 #include "cmdpkt.h"
 #include "map.h"
-#include "riotypes.h"
 #include "rup.h"
 #include "port.h"
 #include "riodrvr.h"
@@ -72,22 +69,17 @@ static char *_rioinit_c_sccs_ = "@(#)rioinit.c	1.3";
 #include "unixrup.h"
 #include "board.h"
 #include "host.h"
-#include "error.h"
 #include "phb.h"
 #include "link.h"
 #include "cmdblk.h"
 #include "route.h"
-#include "control.h"
 #include "cirrus.h"
 #include "rioioctl.h"
 #include "rio_linux.h"
 
-#undef bcopy
-#define bcopy rio_pcicopy
-
 int RIOPCIinit(struct rio_info *p, int Mode);
 
-static int RIOScrub(int, BYTE *, int);
+static int RIOScrub(int, u8 *, int);
 
 
 /**
@@ -99,12 +91,8 @@ static int RIOScrub(int, BYTE *, int);
 ** bits < 0 indicates 8 bit operation requested,
 ** bits > 0 indicates 16 bit operation.
 */
-int
-RIOAssignAT(p, Base, virtAddr, mode)
-struct rio_info *       p;
-int             Base;
-caddr_t virtAddr;
-int             mode;
+
+int RIOAssignAT(struct rio_info *p, int Base, caddr_t   virtAddr, int mode)
 {
         int             bits;
         struct DpRam *cardp = (struct DpRam *)virtAddr;
@@ -124,29 +112,25 @@ int		mode;
         /*
         ** Revision 01 AT host cards don't support WORD operations,
         */
-        if ( RBYTE(cardp->DpRevision) == 01 )
+        if (readb(&cardp->DpRevision) == 01)
                 bits = BYTE_OPERATION;
 
         p->RIOHosts[p->RIONumHosts].Type = RIO_AT;
-        p->RIOHosts[p->RIONumHosts].Copy = bcopy;
+        p->RIOHosts[p->RIONumHosts].Copy = rio_copy_to_card;
                                                                                         /* set this later */
         p->RIOHosts[p->RIONumHosts].Slot = -1;
         p->RIOHosts[p->RIONumHosts].Mode = SLOW_LINKS | SLOW_AT_BUS | bits;
-        WBYTE(p->RIOHosts[p->RIONumHosts].Control, 
-                        BOOT_FROM_RAM | EXTERNAL_BUS_OFF | 
-                        p->RIOHosts[p->RIONumHosts].Mode | 
-                        INTERRUPT_DISABLE );
-        WBYTE(p->RIOHosts[p->RIONumHosts].ResetInt,0xff);
-        WBYTE(p->RIOHosts[p->RIONumHosts].Control,
-                        BOOT_FROM_RAM | EXTERNAL_BUS_OFF | 
-                        p->RIOHosts[p->RIONumHosts].Mode |
-                        INTERRUPT_DISABLE );
-        WBYTE(p->RIOHosts[p->RIONumHosts].ResetInt,0xff);
+        writeb(BOOT_FROM_RAM | EXTERNAL_BUS_OFF | p->RIOHosts[p->RIONumHosts].Mode | INTERRUPT_DISABLE ,
+                &p->RIOHosts[p->RIONumHosts].Control);
+        writeb(0xFF, &p->RIOHosts[p->RIONumHosts].ResetInt);
+        writeb(BOOT_FROM_RAM | EXTERNAL_BUS_OFF | p->RIOHosts[p->RIONumHosts].Mode | INTERRUPT_DISABLE,
+                &p->RIOHosts[p->RIONumHosts].Control);
+        writeb(0xFF, &p->RIOHosts[p->RIONumHosts].ResetInt);
         p->RIOHosts[p->RIONumHosts].UniqueNum =
-                ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[0])&0xFF)<<0)|
-                ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[1])&0xFF)<<8)|
-                ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[2])&0xFF)<<16)|
-                ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[3])&0xFF)<<24);
+                ((readb(&p->RIOHosts[p->RIONumHosts].Unique[0])&0xFF)<<0)|
+                ((readb(&p->RIOHosts[p->RIONumHosts].Unique[1])&0xFF)<<8)|
+                ((readb(&p->RIOHosts[p->RIONumHosts].Unique[2])&0xFF)<<16)|
+                ((readb(&p->RIOHosts[p->RIONumHosts].Unique[3])&0xFF)<<24);
         rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Uniquenum 0x%x\n",p->RIOHosts[p->RIONumHosts].UniqueNum);
 
         p->RIONumHosts++;
@@ -154,7 +138,7 @@ int		mode;
         return(1);
 }
 
-static  uchar   val[] = {
+static  u8      val[] = {
 #ifdef VERY_LONG_TEST
           0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
           0xa5, 0xff, 0x5a, 0x00, 0xff, 0xc9, 0x36, 
@@ -167,12 +151,7 @@ static	uchar	val[] = {
 ** RAM test a board. 
 ** Nothing too complicated, just enough to check it out.
 */
-int
-RIOBoardTest(paddr, caddr, type, slot)
-paddr_t paddr;
-caddr_t caddr;
-uchar   type;
-int             slot;
+int RIOBoardTest(unsigned long paddr, caddr_t   caddr, unsigned char type, int slot)
 {
         struct DpRam *DpRam = (struct DpRam *)caddr;
         char *ram[4];
@@ -180,8 +159,8 @@ int		slot;
         int  op, bank;
         int  nbanks;
 
-        rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Reset host type=%d, DpRam=0x%x, slot=%d\n",
-                        type,(int)DpRam, slot);
+        rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Reset host type=%d, DpRam=%p, slot=%d\n",
+                        type, DpRam, slot);
 
         RIOHostReset(type, DpRam, slot);
 
@@ -209,12 +188,11 @@ int		slot;
 
 
         if (nbanks == 3) {
-                rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Memory: 0x%x(0x%x), 0x%x(0x%x), 0x%x(0x%x)\n",
-                                (int)ram[0], size[0], (int)ram[1], size[1], (int)ram[2], size[2]);
+                rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Memory: %p(0x%x), %p(0x%x), %p(0x%x)\n",
+                                ram[0], size[0], ram[1], size[1], ram[2], size[2]);
         } else {
-                rio_dprintk (RIO_DEBUG_INIT, "RIO-init: 0x%x(0x%x), 0x%x(0x%x), 0x%x(0x%x), 0x%x(0x%x)\n",
-                        (int)ram[0], size[0], (int)ram[1], size[1], (int)ram[2], size[2], (int)ram[3], 
-                                        size[3]);
+                rio_dprintk (RIO_DEBUG_INIT, "RIO-init: %p(0x%x), %p(0x%x), %p(0x%x), %p(0x%x)\n",
+                                ram[0], size[0], ram[1], size[1], ram[2], size[2], ram[3], size[3]);
         }
 
         /*
@@ -224,7 +202,7 @@ int		slot;
         */
         for (op=0; op<TEST_END; op++) {
                 for (bank=0; bank<nbanks; bank++) {
-                        if (RIOScrub(op, (BYTE *)ram[bank], size[bank]) == RIO_FAIL) {
+                        if (RIOScrub(op, (u8 *)ram[bank], size[bank]) == RIO_FAIL) {
                                 rio_dprintk (RIO_DEBUG_INIT, "RIO-init: RIOScrub band %d, op %d failed\n", 
                                                         bank, op);
                                 return RIO_FAIL;
@@ -233,7 +211,7 @@ int		slot;
         }
 
         rio_dprintk (RIO_DEBUG_INIT, "Test completed\n");
-        return RIO_SUCCESS;
+        return 0;
 }
 
 
@@ -248,13 +226,10 @@ int		slot;
 ** Call with op not zero, and the RAM will be read and compated with val[op-1]
 ** to check that the data from the previous phase was retained.
 */
-static int
-RIOScrub(op, ram, size)
-int             op;
-BYTE *  ram;
-int             size; 
+
+static int RIOScrub(int op, u8 *ram, int size)
 {
-        int                             off;
+        int off;
         unsigned char   oldbyte;
         unsigned char   newbyte;
         unsigned char   invbyte;
@@ -279,15 +254,15 @@ int		size;
         */
         if (op) {
                 for (off=0; off<size; off++) {
-                        if (RBYTE(ram[off]) != oldbyte) {
-                                rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Byte Pre Check 1: BYTE at offset 0x%x should have been=%x, was=%x\n", off, oldbyte, RBYTE(ram[off]));
+                        if (readb(ram + off) != oldbyte) {
+                                rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Byte Pre Check 1: BYTE at offset 0x%x should have been=%x, was=%x\n", off, oldbyte, readb(ram + off));
                                 return RIO_FAIL;
                         }
                 }
                 for (off=0; off<size; off+=2) {
-                        if (*(ushort *)&ram[off] != oldword) {
-                                rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Word Pre Check: WORD at offset 0x%x should have been=%x, was=%x\n",off,oldword,*(ushort *)&ram[off]);
-                                rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Word Pre Check: BYTE at offset 0x%x is %x BYTE at offset 0x%x is %x\n", off, RBYTE(ram[off]), off+1, RBYTE(ram[off+1]));
+                        if (readw(ram + off) != oldword) {
+                                rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Word Pre Check: WORD at offset 0x%x should have been=%x, was=%x\n",off,oldword, readw(ram + off));
+                                rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Word Pre Check: BYTE at offset 0x%x is %x BYTE at offset 0x%x is %x\n", off, readb(ram + off), off+1, readb(ram+off+1));
                                 return RIO_FAIL;
                         }
                 }
@@ -301,13 +276,13 @@ int		size;
         ** the BYTE read/write test.
         */
         for (off=0; off<size; off++) {
-                if (op && (RBYTE(ram[off]) != oldbyte)) {
-                        rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Byte Pre Check 2: BYTE at offset 0x%x should have been=%x, was=%x\n", off, oldbyte, RBYTE(ram[off]));
+                if (op && (readb(ram + off) != oldbyte)) {
+                        rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Byte Pre Check 2: BYTE at offset 0x%x should have been=%x, was=%x\n", off, oldbyte, readb(ram + off));
                         return RIO_FAIL;
                 }
-                WBYTE(ram[off],invbyte);
-                if (RBYTE(ram[off]) != invbyte) {
-                        rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Byte Inv Check: BYTE at offset 0x%x should have been=%x, was=%x\n", off, invbyte, RBYTE(ram[off]));
+                writeb(invbyte, ram + off);
+                if (readb(ram + off) != invbyte) {
+                        rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Byte Inv Check: BYTE at offset 0x%x should have been=%x, was=%x\n", off, invbyte, readb(ram + off));
                         return RIO_FAIL;
                 }
         }
@@ -320,16 +295,16 @@ int		size;
         ** This is the WORD operation test.
         */
         for (off=0; off<size; off+=2) {
-                if (*(ushort *)&ram[off] != invword) {
-                        rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Word Inv Check: WORD at offset 0x%x should have been=%x, was=%x\n", off, invword, *(ushort *)&ram[off]);
-                rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Word Inv Check: BYTE at offset 0x%x is %x BYTE at offset 0x%x is %x\n", off, RBYTE(ram[off]), off+1, RBYTE(ram[off+1]));
+                if (readw(ram + off) != invword) {
+                        rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Word Inv Check: WORD at offset 0x%x should have been=%x, was=%x\n", off, invword, readw(ram + off));
+                        rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Word Inv Check: BYTE at offset 0x%x is %x BYTE at offset 0x%x is %x\n", off, readb(ram + off), off+1, readb(ram+off+1));
                         return RIO_FAIL;
                 }
 
-                *(ushort *)&ram[off] = newword;
-                if ( *(ushort *)&ram[off] != newword ) {
-                        rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Post Word Check 1: WORD at offset 0x%x should have been=%x, was=%x\n", off, newword, *(ushort *)&ram[off]);
-                        rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Post Word Check 1: BYTE at offset 0x%x is %x BYTE at offset 0x%x is %x\n", off, RBYTE(ram[off]), off+1, RBYTE(ram[off+1]));
+                writew(newword, ram + off);
+                if ( readw(ram + off) != newword ) {
+                        rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Post Word Check 1: WORD at offset 0x%x should have been=%x, was=%x\n", off, newword, readw(ram + off));
+                        rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Post Word Check 1: BYTE at offset 0x%x is %x BYTE at offset 0x%x is %x\n", off, readb(ram + off), off+1, readb(ram + off + 1));
                         return RIO_FAIL;
                 }
         }
@@ -340,16 +315,16 @@ int		size;
         ** required test data.
         */
         for (off=0; off<size; off++) {
-                if (RBYTE(ram[off]) != newbyte) {
-                        rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Post Byte Check: BYTE at offset 0x%x should have been=%x, was=%x\n", off, newbyte, RBYTE(ram[off]));
+                if (readb(ram + off) != newbyte) {
+                        rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Post Byte Check: BYTE at offset 0x%x should have been=%x, was=%x\n", off, newbyte, readb(ram + off));
                         return RIO_FAIL;
                 }
         }
 
         for (off=0; off<size; off+=2) {
-                if ( *(ushort *)&ram[off] != newword ) {
-                        rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Post Word Check 2: WORD at offset 0x%x should have been=%x, was=%x\n", off, newword, *(ushort *)&ram[off]);
-                        rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Post Word Check 2: BYTE at offset 0x%x is %x BYTE at offset 0x%x is %x\n", off, RBYTE(ram[off]), off+1, RBYTE(ram[off+1]));
+                if (readw(ram + off) != newword ) {
+                        rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Post Word Check 2: WORD at offset 0x%x should have been=%x, was=%x\n", off, newword, readw(ram + off));
+                        rio_dprintk (RIO_DEBUG_INIT, "RIO-init: Post Word Check 2: BYTE at offset 0x%x is %x BYTE at offset 0x%x is %x\n", off, readb(ram + off), off+1, readb(ram + off + 1));
                         return RIO_FAIL;
                 }
         }
@@ -360,41 +335,37 @@ int		size;
         swapword = invbyte | (newbyte << 8);
 
         for (off=0; off<size; off+=2) {
-                WBYTE(ram[off],invbyte);
-                WBYTE(ram[off+1],newbyte);
+                writeb(invbyte, &ram[off]);
+                writeb(newbyte, &ram[off+1]);
         }
 
         for ( off=0; off<size; off+=2 ) {
-                if (*(ushort *)&ram[off] != swapword) {
-                        rio_dprintk (RIO_DEBUG_INIT, "RIO-init: SwapWord Check 1: WORD at offset 0x%x should have been=%x, was=%x\n", off, swapword, *((ushort *)&ram[off]));
-                        rio_dprintk (RIO_DEBUG_INIT, "RIO-init: SwapWord Check 1: BYTE at offset 0x%x is %x BYTE at offset 0x%x is %x\n", off, RBYTE(ram[off]), off+1, RBYTE(ram[off+1]));
+                if (readw(ram + off) != swapword) {
+                        rio_dprintk (RIO_DEBUG_INIT, "RIO-init: SwapWord Check 1: WORD at offset 0x%x should have been=%x, was=%x\n", off, swapword, readw(ram + off));
+                        rio_dprintk (RIO_DEBUG_INIT, "RIO-init: SwapWord Check 1: BYTE at offset 0x%x is %x BYTE at offset 0x%x is %x\n", off, readb(ram + off), off+1, readb(ram + off + 1));
                         return RIO_FAIL;
                 }
-                *((ushort *)&ram[off]) = ~swapword;
+                writew(~swapword, ram + off);
         }
 
         for (off=0; off<size; off+=2) {
-                if (RBYTE(ram[off]) != newbyte) {
-                        rio_dprintk (RIO_DEBUG_INIT, "RIO-init: SwapWord Check 2: BYTE at offset 0x%x should have been=%x, was=%x\n", off, newbyte, RBYTE(ram[off]));
+                if (readb(ram + off) != newbyte) {
+                        rio_dprintk (RIO_DEBUG_INIT, "RIO-init: SwapWord Check 2: BYTE at offset 0x%x should have been=%x, was=%x\n", off, newbyte, readb(ram + off));
                         return RIO_FAIL;
                 }
-                if (RBYTE(ram[off+1]) != invbyte) {
-                        rio_dprintk (RIO_DEBUG_INIT, "RIO-init: SwapWord Check 2: BYTE at offset 0x%x should have been=%x, was=%x\n", off+1, invbyte, RBYTE(ram[off+1]));
+                if (readb(ram + off + 1) != invbyte) {
+                        rio_dprintk (RIO_DEBUG_INIT, "RIO-init: SwapWord Check 2: BYTE at offset 0x%x should have been=%x, was=%x\n", off+1, invbyte, readb(ram + off + 1));
                         return RIO_FAIL;
                 }
-                *((ushort *)&ram[off]) = newword;
+                writew(newword, ram + off);
         }
-        return RIO_SUCCESS;
+        return 0;
 }
 
 
-int
-RIODefaultName(p, HostP, UnitId)
-struct rio_info *       p;
-struct Host *   HostP;
-uint                    UnitId;
+int RIODefaultName(struct rio_info *p, struct Host *HostP, unsigned int UnitId)
 {
-        bcopy("UNKNOWN RTA X-XX",HostP->Mapping[UnitId].Name,17);
+        memcpy(HostP->Mapping[UnitId].Name, "UNKNOWN RTA X-XX", 17);
         HostP->Mapping[UnitId].Name[12]='1'+(HostP-p->RIOHosts);
         if ((UnitId+1) > 9) {
                 HostP->Mapping[UnitId].Name[14]='0'+((UnitId+1)/10);
@@ -412,8 +383,7 @@ uint			UnitId;
 
 static struct rioVersion        stVersion;
 
-struct rioVersion *
-RIOVersid(void)
+struct rioVersion *RIOVersid(void)
 {
     strlcpy(stVersion.version, "RIO driver for linux V1.0",
             sizeof(stVersion.version));
@@ -423,40 +393,31 @@ RIOVersid(void)
     return &stVersion;
 }
 
-void
-RIOHostReset(Type, DpRamP, Slot)
-uint Type;
-volatile struct DpRam *DpRamP;
-uint Slot; 
+void RIOHostReset(unsigned int Type, struct DpRam *DpRamP, unsigned int Slot)
 {
         /*
         ** Reset the Tpu
         */
         rio_dprintk (RIO_DEBUG_INIT,  "RIOHostReset: type 0x%x", Type);
         switch ( Type ) {
-                case RIO_AT:
-                        rio_dprintk (RIO_DEBUG_INIT, " (RIO_AT)\n");
-                        WBYTE(DpRamP->DpControl,  BOOT_FROM_RAM | EXTERNAL_BUS_OFF | 
-                                          INTERRUPT_DISABLE | BYTE_OPERATION |
-                                          SLOW_LINKS | SLOW_AT_BUS);
-                        WBYTE(DpRamP->DpResetTpu, 0xFF);
-                        udelay(3);
-
+        case RIO_AT:
+                rio_dprintk (RIO_DEBUG_INIT, " (RIO_AT)\n");
+                writeb(BOOT_FROM_RAM | EXTERNAL_BUS_OFF | INTERRUPT_DISABLE | BYTE_OPERATION |
+                        SLOW_LINKS | SLOW_AT_BUS, &DpRamP->DpControl);
+                writeb(0xFF, &DpRamP->DpResetTpu);
+                udelay(3);
                         rio_dprintk (RIO_DEBUG_INIT,  "RIOHostReset: Don't know if it worked. Try reset again\n");
-                        WBYTE(DpRamP->DpControl,  BOOT_FROM_RAM | EXTERNAL_BUS_OFF |
-                                          INTERRUPT_DISABLE | BYTE_OPERATION |
-                                          SLOW_LINKS | SLOW_AT_BUS);
-                        WBYTE(DpRamP->DpResetTpu, 0xFF);
-                        udelay(3);
-                        break;
+                writeb(BOOT_FROM_RAM | EXTERNAL_BUS_OFF | INTERRUPT_DISABLE |
+                        BYTE_OPERATION | SLOW_LINKS | SLOW_AT_BUS, &DpRamP->DpControl);
+                writeb(0xFF, &DpRamP->DpResetTpu);
+                udelay(3);
+                break;
         case RIO_PCI:
                 rio_dprintk (RIO_DEBUG_INIT, " (RIO_PCI)\n");
-                DpRamP->DpControl  = RIO_PCI_BOOT_FROM_RAM;
-                DpRamP->DpResetInt = 0xFF;
-                DpRamP->DpResetTpu = 0xFF;
+                writeb(RIO_PCI_BOOT_FROM_RAM, &DpRamP->DpControl);
+                writeb(0xFF, &DpRamP->DpResetInt);
+                writeb(0xFF, &DpRamP->DpResetTpu);
                 udelay(100);
-                /* for (i=0; i<6000; i++);  */
-                /* suspend( 3 ); */
                 break;
         default:
                 rio_dprintk (RIO_DEBUG_INIT, " (UNKNOWN)\n");
diff --git a/drivers/char/rio/riointr.c b/drivers/char/rio/riointr.c
index 34d8787557..97f0fa5506 100644
--- a/drivers/char/rio/riointr.c
+++ b/drivers/char/rio/riointr.c
@@ -54,15 +54,12 @@ static char *_riointr_c_sccs_ = "@(#)riointr.c	1.2";
 
 #include "linux_compat.h"
 #include "rio_linux.h"
-#include "typdef.h"
 #include "pkt.h"
 #include "daemon.h"
 #include "rio.h"
 #include "riospace.h"
-#include "top.h"
 #include "cmdpkt.h"
 #include "map.h"
-#include "riotypes.h"
 #include "rup.h"
 #include "port.h"
 #include "riodrvr.h"
@@ -75,12 +72,10 @@ static char *_riointr_c_sccs_ = "@(#)riointr.c	1.2";
 #include "unixrup.h"
 #include "board.h"
 #include "host.h"
-#include "error.h"
 #include "phb.h"
 #include "link.h"
 #include "cmdblk.h"
 #include "route.h"
-#include "control.h"
 #include "cirrus.h"
 #include "rioioctl.h"
 
@@ -101,8 +96,7 @@ static char *firstchars(char *p, int nch)
 
 #define INCR( P, I )    ((P) = (((P)+(I)) & p->RIOBufferMask))
 /* Enable and start the transmission of packets */
-void RIOTxEnable(en)
-char *en;
+void RIOTxEnable(char *en)
 {
         struct Port *PortP;
         struct rio_info *p;
@@ -186,10 +180,8 @@ char *en;
 static int RupIntr;
 static int RxIntr;
 static int TxIntr;
-void RIOServiceHost(p, HostP, From)
-struct rio_info *p;
-struct Host *HostP;
-int From;
+
+void RIOServiceHost(struct rio_info *p, struct Host *HostP, int From)
 {
         rio_spin_lock(&HostP->HostLock);
         if ((HostP->Flags & RUN_STATE) != RC_RUNNING) {
@@ -201,22 +193,22 @@ int From;
         }
         rio_spin_unlock(&HostP->HostLock);
 
-        if (RWORD(HostP->ParmMapP->rup_intr)) {
-                WWORD(HostP->ParmMapP->rup_intr, 0);
+        if (readw(&HostP->ParmMapP->rup_intr)) {
+                writew(0, &HostP->ParmMapP->rup_intr);
                 p->RIORupCount++;
                 RupIntr++;
-                rio_dprintk(RIO_DEBUG_INTR, "rio: RUP interrupt on host %d\n", HostP - p->RIOHosts);
+                rio_dprintk(RIO_DEBUG_INTR, "rio: RUP interrupt on host %Zd\n", HostP - p->RIOHosts);
                 RIOPollHostCommands(p, HostP);
         }
 
-        if (RWORD(HostP->ParmMapP->rx_intr)) {
+        if (readw(&HostP->ParmMapP->rx_intr)) {
                 int port;
 
-                WWORD(HostP->ParmMapP->rx_intr, 0);
+                writew(0, &HostP->ParmMapP->rx_intr);
                 p->RIORxCount++;
                 RxIntr++;
 
-                rio_dprintk(RIO_DEBUG_INTR, "rio: RX interrupt on host %d\n", HostP - p->RIOHosts);
+                rio_dprintk(RIO_DEBUG_INTR, "rio: RX interrupt on host %Zd\n", HostP - p->RIOHosts);
                 /*
                  ** Loop through every port. If the port is mapped into
                  ** the system ( i.e. has /dev/ttyXXXX associated ) then it is
@@ -277,26 +269,26 @@ int From;
                          ** it's handshake bit is set, then we must clear the handshake,
                          ** so that that downstream RTA is re-enabled.
                          */
-                        if (!can_remove_receive(&PacketP, PortP) && (RWORD(PortP->PhbP->handshake) == PHB_HANDSHAKE_SET)) {
+                        if (!can_remove_receive(&PacketP, PortP) && (readw(&PortP->PhbP->handshake) == PHB_HANDSHAKE_SET)) {
                                 /*
                                  ** MAGIC! ( Basically, handshake the RX buffer, so that
                                  ** the RTAs upstream can be re-enabled. )
                                  */
                                 rio_dprintk(RIO_DEBUG_INTR, "Set RX handshake bit\n");
-                                WWORD(PortP->PhbP->handshake, PHB_HANDSHAKE_SET | PHB_HANDSHAKE_RESET);
+                                writew(PHB_HANDSHAKE_SET | PHB_HANDSHAKE_RESET, &PortP->PhbP->handshake);
                         }
                         rio_spin_unlock(&PortP->portSem);
                 }
         }
 
-        if (RWORD(HostP->ParmMapP->tx_intr)) {
+        if (readw(&HostP->ParmMapP->tx_intr)) {
                 int port;
 
-                WWORD(HostP->ParmMapP->tx_intr, 0);
+                writew(0, &HostP->ParmMapP->tx_intr);
 
                 p->RIOTxCount++;
                 TxIntr++;
-                rio_dprintk(RIO_DEBUG_INTR, "rio: TX interrupt on host %d\n", HostP - p->RIOHosts);
+                rio_dprintk(RIO_DEBUG_INTR, "rio: TX interrupt on host %Zd\n", HostP - p->RIOHosts);
 
                 /*
                  ** Loop through every port.
@@ -399,7 +391,6 @@ int From;
                         /* For now don't handle RTA reboots. -- REW.
                            Reenabled. Otherwise RTA reboots didn't work. Duh. -- REW */
                         if (PortP->MagicFlags) {
-#if 1
                                 if (PortP->MagicFlags & MAGIC_REBOOT) {
                                         /*
                                          ** well, the RTA has been rebooted, and there is room
@@ -416,13 +407,12 @@ int From;
                                         PortP->InUse = NOT_INUSE;
 
                                         rio_spin_unlock(&PortP->portSem);
-                                        if (RIOParam(PortP, OPEN, ((PortP->Cor2Copy & (COR2_RTSFLOW | COR2_CTSFLOW)) == (COR2_RTSFLOW | COR2_CTSFLOW)) ? TRUE : FALSE, DONT_SLEEP) == RIO_FAIL) {
+                                        if (RIOParam(PortP, OPEN, ((PortP->Cor2Copy & (COR2_RTSFLOW | COR2_CTSFLOW)) == (COR2_RTSFLOW | COR2_CTSFLOW)) ? 1 : 0, DONT_SLEEP) == RIO_FAIL) {
                                                 continue;       /* with next port */
                                         }
                                         rio_spin_lock(&PortP->portSem);
                                         PortP->MagicFlags &= ~MAGIC_REBOOT;
                                 }
-#endif
 
                                 /*
                                  ** As mentioned above, this is a tacky hack to cope
@@ -445,9 +435,9 @@ int From;
                                          */
                                         PktCmdP = (struct PktCmd *) &PacketP->data[0];
 
-                                        WBYTE(PktCmdP->Command, WFLUSH);
+                                        writeb(WFLUSH, &PktCmdP->Command);
 
-                                        p = PortP->HostPort % (ushort) PORTS_PER_RTA;
+                                        p = PortP->HostPort % (u16) PORTS_PER_RTA;
 
                                         /*
                                          ** If second block of ports for 16 port RTA, add 8
@@ -456,27 +446,27 @@ int From;
                                         if (PortP->SecondBlock)
                                                 p += PORTS_PER_RTA;
 
-                                        WBYTE(PktCmdP->PhbNum, p);
+                                        writeb(p, &PktCmdP->PhbNum);
 
                                         /*
                                          ** to make debuggery easier
                                          */
-                                        WBYTE(PacketP->data[2], 'W');
-                                        WBYTE(PacketP->data[3], 'F');
-                                        WBYTE(PacketP->data[4], 'L');
-                                        WBYTE(PacketP->data[5], 'U');
-                                        WBYTE(PacketP->data[6], 'S');
-                                        WBYTE(PacketP->data[7], 'H');
-                                        WBYTE(PacketP->data[8], ' ');
-                                        WBYTE(PacketP->data[9], '0' + PortP->WflushFlag);
-                                        WBYTE(PacketP->data[10], ' ');
-                                        WBYTE(PacketP->data[11], ' ');
-                                        WBYTE(PacketP->data[12], '\0');
+                                        writeb('W', &PacketP->data[2]);
+                                        writeb('F', &PacketP->data[3]);
+                                        writeb('L', &PacketP->data[4]);
+                                        writeb('U', &PacketP->data[5]);
+                                        writeb('S', &PacketP->data[6]);
+                                        writeb('H', &PacketP->data[7]);
+                                        writeb(' ', &PacketP->data[8]);
+                                        writeb('0' + PortP->WflushFlag, &PacketP->data[9]);
+                                        writeb(' ', &PacketP->data[10]);
+                                        writeb(' ', &PacketP->data[11]);
+                                        writeb('\0', &PacketP->data[12]);
 
                                         /*
                                          ** its two bytes long!
                                          */
-                                        WBYTE(PacketP->len, PKT_CMD_BIT | 2);
+                                        writeb(PKT_CMD_BIT | 2, &PacketP->len);
 
                                         /*
                                          ** queue it!
@@ -529,19 +519,15 @@ int From;
 }
 
 /*
-** Routine for handling received data for clist drivers.
-** NB: Called with the tty locked. The spl from the lockb( ) is passed.
-** we return the ttySpl level that we re-locked at.
+** Routine for handling received data for tty drivers
 */
-static void RIOReceive(p, PortP)
-struct rio_info *p;
-struct Port *PortP;
+static void RIOReceive(struct rio_info *p, struct Port *PortP)
 {
         struct tty_struct *TtyP;
-        register ushort transCount;
+        unsigned short transCount;
         struct PKT *PacketP;
-        register uint DataCnt;
-        uchar *ptr;
+        register unsigned int DataCnt;
+        unsigned char *ptr;
         unsigned char *buf;
         int copied = 0;
 
@@ -594,9 +580,6 @@ struct Port *PortP;
                 transCount = 1;
                 while (can_remove_receive(&PacketP, PortP)
                        && transCount) {
-#ifdef STATS
-                        PortP->Stat.RxIntCnt++;
-#endif                          /* STATS */
                         RxIntCnt++;
 
                         /*
@@ -642,28 +625,15 @@ struct Port *PortP;
                          ** to '#define', (this is the only place ___DEBUG_IT___ occurs in the
                          ** driver).
                          */
-#undef ___DEBUG_IT___
-#ifdef ___DEBUG_IT___
-                        kkprintf("I:%d R:%d P:%d Q:%d C:%d F:%x ", intCount, RxIntCnt, PortP->PortNum, TtyP->rxqueue.count, transCount, TtyP->flags);
-#endif
-                        ptr = (uchar *) PacketP->data + PortP->RxDataStart;
+                        ptr = (unsigned char *) PacketP->data + PortP->RxDataStart;
 
                         tty_prepare_flip_string(TtyP, &buf, transCount);
                         rio_memcpy_fromio(buf, ptr, transCount);
-#ifdef STATS
-                        /*
-                         ** keep a count for statistical purposes
-                         */
-                        PortP->Stat.RxCharCnt += transCount;
-#endif
                         PortP->RxDataStart += transCount;
                         PacketP->len -= transCount;
                         copied += transCount;
 
 
-#ifdef ___DEBUG_IT___
-                        kkprintf("T:%d L:%d\n", DataCnt, PacketP->len);
-#endif
 
                         if (PacketP->len == 0) {
                                 /*
@@ -674,12 +644,6 @@ struct Port *PortP;
                                 remove_receive(PortP);
                                 put_free_end(PortP->HostP, PacketP);
                                 PortP->RxDataStart = 0;
-#ifdef STATS
-                                /*
-                                 ** more lies ( oops, I mean statistics )
-                                 */
-                                PortP->Stat.RxPktCnt++;
-#endif                          /* STATS */
                         }
                 }
         }
@@ -691,215 +655,3 @@ struct Port *PortP;
         return;
 }
 
-#ifdef FUTURE_RELEASE
-/*
-** The proc routine called by the line discipline to do the work for it.
-** The proc routine works hand in hand with the interrupt routine.
-*/
-int riotproc(p, tp, cmd, port)
-struct rio_info *p;
-register struct ttystatics *tp;
-int cmd;
-int port;
-{
-        register struct Port *PortP;
-        int SysPort;
-        struct PKT *PacketP;
-
-        SysPort = port;         /* Believe me, it works. */
-
-        if (SysPort < 0 || SysPort >= RIO_PORTS) {
-                rio_dprintk(RIO_DEBUG_INTR, "Illegal port %d derived from TTY in riotproc()\n", SysPort);
-                return 0;
-        }
-        PortP = p->RIOPortp[SysPort];
-
-        if ((uint) PortP->PhbP < (uint) PortP->Caddr || (uint) PortP->PhbP >= (uint) PortP->Caddr + SIXTY_FOUR_K) {
-                rio_dprintk(RIO_DEBUG_INTR, "RIO: NULL or BAD PhbP on sys port %d in proc routine\n", SysPort);
-                rio_dprintk(RIO_DEBUG_INTR, "    PortP = 0x%x\n", PortP);
-                rio_dprintk(RIO_DEBUG_INTR, "    PortP->PhbP = 0x%x\n", PortP->PhbP);
-                rio_dprintk(RIO_DEBUG_INTR, "    PortP->Caddr = 0x%x\n", PortP->PhbP);
-                rio_dprintk(RIO_DEBUG_INTR, "    PortP->HostPort = 0x%x\n", PortP->HostPort);
-                return 0;
-        }
-
-        switch (cmd) {
-        case T_WFLUSH:
-                rio_dprintk(RIO_DEBUG_INTR, "T_WFLUSH\n");
-                /*
-                 ** Because of the spooky way the RIO works, we don't need
-                 ** to issue a flush command on any of the SET*F commands,
-                 ** as that causes trouble with getty and login, which issue
-                 ** these commands to incur a READ flush, and rely on the fact
-                 ** that the line discipline does a wait for drain for them.
-                 ** As the rio doesn't wait for drain, the write flush would
-                 ** destroy the Password: prompt. This isn't very friendly, so
-                 ** here we only issue a WFLUSH command if we are in the interrupt
-                 ** routine, or we aren't executing a SET*F command.
-                 */
-                if (PortP->HostP->InIntr || !PortP->FlushCmdBodge) {
-                        /*
-                         ** form a wflush packet - 1 byte long, no data
-                         */
-                        if (PortP->State & RIO_DELETED) {
-                                rio_dprintk(RIO_DEBUG_INTR, "WFLUSH on deleted RTA\n");
-                        } else {
-                                if (RIOPreemptiveCmd(p, PortP, WFLUSH) == RIO_FAIL) {
-                                        rio_dprintk(RIO_DEBUG_INTR, "T_WFLUSH Command failed\n");
-                                } else
-                                        rio_dprintk(RIO_DEBUG_INTR, "T_WFLUSH Command\n");
-                        }
-                        /*
-                         ** WFLUSH operation - flush the data!
-                         */
-                        PortP->TxBufferIn = PortP->TxBufferOut = 0;
-                } else {
-                        rio_dprintk(RIO_DEBUG_INTR, "T_WFLUSH Command ignored\n");
-                }
-                /*
-                 ** sort out the line discipline
-                 */
-                if (PortP->CookMode == COOK_WELL)
-                        goto start;
-                break;
-
-        case T_RESUME:
-                rio_dprintk(RIO_DEBUG_INTR, "T_RESUME\n");
-                /*
-                 ** send pre-emptive resume packet
-                 */
-                if (PortP->State & RIO_DELETED) {
-                        rio_dprintk(RIO_DEBUG_INTR, "RESUME on deleted RTA\n");
-                } else {
-                        if (RIOPreemptiveCmd(p, PortP, RESUME) == RIO_FAIL) {
-                                rio_dprintk(RIO_DEBUG_INTR, "T_RESUME Command failed\n");
-                        }
-                }
-                /*
-                 ** and re-start the sender software!
-                 */
-                if (PortP->CookMode == COOK_WELL)
-                        goto start;
-                break;
-
-        case T_TIME:
-                rio_dprintk(RIO_DEBUG_INTR, "T_TIME\n");
-                /*
-                 ** T_TIME is called when xDLY is set in oflags and
-                 ** the line discipline timeout has expired. It's
-                 ** function in life is to clear the TIMEOUT flag
-                 ** and to re-start output to the port.
-                 */
-                /*
-                 ** Fall through and re-start output
-                 */
-        case T_OUTPUT:
-              start:
-                if (PortP->MagicFlags & MAGIC_FLUSH) {
-                        PortP->MagicFlags |= MORE_OUTPUT_EYGOR;
-                        return 0;
-                }
-                RIOTxEnable((char *) PortP);
-                PortP->MagicFlags &= ~MORE_OUTPUT_EYGOR;
-                /*rio_dprint(RIO_DEBUG_INTR, PortP,DBG_PROC,"T_OUTPUT finished\n"); */
-                break;
-
-        case T_SUSPEND:
-                rio_dprintk(RIO_DEBUG_INTR, "T_SUSPEND\n");
-                /*
-                 ** send a suspend pre-emptive packet.
-                 */
-                if (PortP->State & RIO_DELETED) {
-                        rio_dprintk(RIO_DEBUG_INTR, "SUSPEND deleted RTA\n");
-                } else {
-                        if (RIOPreemptiveCmd(p, PortP, SUSPEND) == RIO_FAIL) {
-                                rio_dprintk(RIO_DEBUG_INTR, "T_SUSPEND Command failed\n");
-                        }
-                }
-                /*
-                 ** done!
-                 */
-                break;
-
-        case T_BLOCK:
-                rio_dprintk(RIO_DEBUG_INTR, "T_BLOCK\n");
-                break;
-
-        case T_RFLUSH:
-                rio_dprintk(RIO_DEBUG_INTR, "T_RFLUSH\n");
-                if (PortP->State & RIO_DELETED) {
-                        rio_dprintk(RIO_DEBUG_INTR, "RFLUSH on deleted RTA\n");
-                        PortP->RxDataStart = 0;
-                } else {
-                        if (RIOPreemptiveCmd(p, PortP, RFLUSH) == RIO_FAIL) {
-                                rio_dprintk(RIO_DEBUG_INTR, "T_RFLUSH Command failed\n");
-                                return 0;
-                        }
-                        PortP->RxDataStart = 0;
-                        while (can_remove_receive(&PacketP, PortP)) {
-                                remove_receive(PortP);
-                                ShowPacket(DBG_PROC, PacketP);
-                                put_free_end(PortP->HostP, PacketP);
-                        }
-                        if (PortP->PhbP->handshake == PHB_HANDSHAKE_SET) {
-                                /*
-                                 ** MAGIC!
-                                 */
-                                rio_dprintk(RIO_DEBUG_INTR, "Set receive handshake bit\n");
-                                PortP->PhbP->handshake |= PHB_HANDSHAKE_RESET;
-                        }
-                }
-                break;
-                /* FALLTHROUGH */
-        case T_UNBLOCK:
-                rio_dprintk(RIO_DEBUG_INTR, "T_UNBLOCK\n");
-                /*
-                 ** If there is any data to receive set a timeout to service it.
-                 */
-                RIOReceive(p, PortP);
-                break;
-
-        case T_BREAK:
-                rio_dprintk(RIO_DEBUG_INTR, "T_BREAK\n");
-                /*
-                 ** Send a break command. For Sys V
-                 ** this is a timed break, so we
-                 ** send a SBREAK[time] packet
-                 */
-                /*
-                 ** Build a BREAK command
-                 */
-                if (PortP->State & RIO_DELETED) {
-                        rio_dprintk(RIO_DEBUG_INTR, "BREAK on deleted RTA\n");
-                } else {
-                        if (RIOShortCommand(PortP, SBREAK, 2, p->RIOConf.BreakInterval) == RIO_FAIL) {
-                                rio_dprintk(RIO_DEBUG_INTR, "SBREAK RIOShortCommand failed\n");
-                        }
-                }
-
-                /*
-                 ** done!
-                 */
-                break;
-
-        case T_INPUT:
-                rio_dprintk(RIO_DEBUG_INTR, "Proc T_INPUT called - I don't know what to do!\n");
-                break;
-        case T_PARM:
-                rio_dprintk(RIO_DEBUG_INTR, "Proc T_PARM called - I don't know what to do!\n");
-                break;
-
-        case T_SWTCH:
-                rio_dprintk(RIO_DEBUG_INTR, "Proc T_SWTCH called - I don't know what to do!\n");
-                break;
-
-        default:
-                rio_dprintk(RIO_DEBUG_INTR, "Proc UNKNOWN command %d\n", cmd);
-        }
-        /*
-         ** T_OUTPUT returns without passing through this point!
-         */
-        /*rio_dprint(RIO_DEBUG_INTR, PortP,DBG_PROC,"riotproc done\n"); */
-        return (0);
-}
-#endif
diff --git a/drivers/char/rio/rioparam.c b/drivers/char/rio/rioparam.c
index c622f46d6d..d2e8092cdb 100644
--- a/drivers/char/rio/rioparam.c
+++ b/drivers/char/rio/rioparam.c
@@ -52,15 +52,12 @@ static char *_rioparam_c_sccs_ = "@(#)rioparam.c	1.3";
 
 #include "linux_compat.h"
 #include "rio_linux.h"
-#include "typdef.h"
 #include "pkt.h"
 #include "daemon.h"
 #include "rio.h"
 #include "riospace.h"
-#include "top.h"
 #include "cmdpkt.h"
 #include "map.h"
-#include "riotypes.h"
 #include "rup.h"
 #include "port.h"
 #include "riodrvr.h"
@@ -73,17 +70,13 @@ static char *_rioparam_c_sccs_ = "@(#)rioparam.c	1.3";
 #include "unixrup.h"
 #include "board.h"
 #include "host.h"
-#include "error.h"
 #include "phb.h"
 #include "link.h"
 #include "cmdblk.h"
 #include "route.h"
-#include "control.h"
 #include "cirrus.h"
 #include "rioioctl.h"
 #include "param.h"
-#include "list.h"
-#include "sam.h"
 
 
 
@@ -157,20 +150,16 @@ static char *_rioparam_c_sccs_ = "@(#)rioparam.c	1.3";
 ** NB. for MPX
 **      tty lock must NOT have been previously acquired.
 */
-int RIOParam(PortP, cmd, Modem, SleepFlag)
-struct Port *PortP;
-int cmd;
-int Modem;
-int SleepFlag;
+int RIOParam(struct Port *PortP, int cmd, int Modem, int SleepFlag)
 {
-        register struct tty_struct *TtyP;
+        struct tty_struct *TtyP;
         int retval;
-        register struct phb_param *phb_param_ptr;
-        PKT *PacketP;
+        struct phb_param *phb_param_ptr;
+        struct PKT *PacketP;
         int res;
-        uchar Cor1 = 0, Cor2 = 0, Cor4 = 0, Cor5 = 0;
-        uchar TxXon = 0, TxXoff = 0, RxXon = 0, RxXoff = 0;
-        uchar LNext = 0, TxBaud = 0, RxBaud = 0;
+        u8 Cor1 = 0, Cor2 = 0, Cor4 = 0, Cor5 = 0;
+        u8 TxXon = 0, TxXoff = 0, RxXon = 0, RxXoff = 0;
+        u8 LNext = 0, TxBaud = 0, RxBaud = 0;
         int retries = 0xff;
         unsigned long flags;
 
@@ -226,16 +215,13 @@ int SleepFlag;
                 if (retval == RIO_FAIL) {
                         rio_dprintk(RIO_DEBUG_PARAM, "wait for can_add_transmit broken by signal\n");
                         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-                        pseterr(EINTR);
                         func_exit();
-
-                        return RIO_FAIL;
+                        return -EINTR;
                 }
                 if (PortP->State & RIO_DELETED) {
                         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
                         func_exit();
-
-                        return RIO_SUCCESS;
+                        return 0;
                 }
         }
 
@@ -247,7 +233,7 @@ int SleepFlag;
         }
 
         rio_dprintk(RIO_DEBUG_PARAM, "can_add_transmit() returns %x\n", res);
-        rio_dprintk(RIO_DEBUG_PARAM, "Packet is 0x%x\n", (int) PacketP);
+        rio_dprintk(RIO_DEBUG_PARAM, "Packet is %p\n", PacketP);
 
         phb_param_ptr = (struct phb_param *) PacketP->data;
 
@@ -474,9 +460,6 @@ int SleepFlag;
                 e(115200);      /* e(230400);e(460800); e(921600);  */
         }
 
-        /* XXX MIssing conversion table. XXX */
-        /*       (TtyP->termios->c_cflag & V_CBAUD); */
-
         rio_dprintk(RIO_DEBUG_PARAM, "tx baud 0x%x, rx baud 0x%x\n", TxBaud, RxBaud);
 
 
@@ -552,23 +535,23 @@ int SleepFlag;
         /*
          ** Actually write the info into the packet to be sent
          */
-        WBYTE(phb_param_ptr->Cmd, cmd);
-        WBYTE(phb_param_ptr->Cor1, Cor1);
-        WBYTE(phb_param_ptr->Cor2, Cor2);
-        WBYTE(phb_param_ptr->Cor4, Cor4);
-        WBYTE(phb_param_ptr->Cor5, Cor5);
-        WBYTE(phb_param_ptr->TxXon, TxXon);
-        WBYTE(phb_param_ptr->RxXon, RxXon);
-        WBYTE(phb_param_ptr->TxXoff, TxXoff);
-        WBYTE(phb_param_ptr->RxXoff, RxXoff);
-        WBYTE(phb_param_ptr->LNext, LNext);
-        WBYTE(phb_param_ptr->TxBaud, TxBaud);
-        WBYTE(phb_param_ptr->RxBaud, RxBaud);
+        writeb(cmd, &phb_param_ptr->Cmd);
+        writeb(Cor1, &phb_param_ptr->Cor1);
+        writeb(Cor2, &phb_param_ptr->Cor2);
+        writeb(Cor4, &phb_param_ptr->Cor4);
+        writeb(Cor5, &phb_param_ptr->Cor5);
+        writeb(TxXon, &phb_param_ptr->TxXon);
+        writeb(RxXon, &phb_param_ptr->RxXon);
+        writeb(TxXoff, &phb_param_ptr->TxXoff);
+        writeb(RxXoff, &phb_param_ptr->RxXoff);
+        writeb(LNext, &phb_param_ptr->LNext);
+        writeb(TxBaud, &phb_param_ptr->TxBaud);
+        writeb(RxBaud, &phb_param_ptr->RxBaud);
 
         /*
          ** Set the length/command field
          */
-        WBYTE(PacketP->len, 12 | PKT_CMD_BIT);
+        writeb(12 | PKT_CMD_BIT, &PacketP->len);
 
         /*
          ** The packet is formed - now, whack it off
@@ -589,7 +572,7 @@ int SleepFlag;
          */
         func_exit();
 
-        return RIO_SUCCESS;
+        return 0;
 }
 
 
@@ -597,15 +580,13 @@ int SleepFlag;
 ** We can add another packet to a transmit queue if the packet pointer pointed
 ** to by the TxAdd pointer has PKT_IN_USE clear in its address.
 */
-int can_add_transmit(PktP, PortP)
-PKT **PktP;
-struct Port *PortP;
+int can_add_transmit(struct PKT **PktP, struct Port *PortP)
 {
-        register PKT *tp;
+        struct PKT *tp;
 
-        *PktP = tp = (PKT *) RIO_PTR(PortP->Caddr, RWORD(*PortP->TxAdd));
+        *PktP = tp = (struct PKT *) RIO_PTR(PortP->Caddr, readw(PortP->TxAdd));
 
-        return !((uint) tp & PKT_IN_USE);
+        return !((unsigned long) tp & PKT_IN_USE);
 }
 
 /*
@@ -613,27 +594,24 @@ struct Port *PortP;
 ** and then move the TxAdd pointer along one position to point to the next
 ** packet pointer. You must wrap the pointer from the end back to the start.
 */
-void add_transmit(PortP)
-struct Port *PortP;
+void add_transmit(struct Port *PortP)
 {
-        if (RWORD(*PortP->TxAdd) & PKT_IN_USE) {
+        if (readw(PortP->TxAdd) & PKT_IN_USE) {
                 rio_dprintk(RIO_DEBUG_PARAM, "add_transmit: Packet has been stolen!");
         }
-        WWORD(*(ushort *) PortP->TxAdd, RWORD(*PortP->TxAdd) | PKT_IN_USE);
+        writew(readw(PortP->TxAdd) | PKT_IN_USE, PortP->TxAdd);
         PortP->TxAdd = (PortP->TxAdd == PortP->TxEnd) ? PortP->TxStart : PortP->TxAdd + 1;
-        WWORD(PortP->PhbP->tx_add, RIO_OFF(PortP->Caddr, PortP->TxAdd));
+        writew(RIO_OFF(PortP->Caddr, PortP->TxAdd), &PortP->PhbP->tx_add);
 }
 
 /****************************************
  * Put a packet onto the end of the
  * free list
  ****************************************/
-void put_free_end(HostP, PktP)
-struct Host *HostP;
-PKT *PktP;
+void put_free_end(struct Host *HostP, struct PKT *PktP)
 {
-        FREE_LIST *tmp_pointer;
-        ushort old_end, new_end;
+        struct rio_free_list *tmp_pointer;
+        unsigned short old_end, new_end;
         unsigned long flags;
 
         rio_spin_lock_irqsave(&HostP->HostLock, flags);
@@ -643,21 +621,21 @@ PKT *PktP;
         *
         ************************************************/
 
-        rio_dprintk(RIO_DEBUG_PFE, "put_free_end(PktP=%x)\n", (int) PktP);
+        rio_dprintk(RIO_DEBUG_PFE, "put_free_end(PktP=%p)\n", PktP);
 
-        if ((old_end = RWORD(HostP->ParmMapP->free_list_end)) != TPNULL) {
+        if ((old_end = readw(&HostP->ParmMapP->free_list_end)) != TPNULL) {
                 new_end = RIO_OFF(HostP->Caddr, PktP);
-                tmp_pointer = (FREE_LIST *) RIO_PTR(HostP->Caddr, old_end);
-                WWORD(tmp_pointer->next, new_end);
-                WWORD(((FREE_LIST *) PktP)->prev, old_end);
-                WWORD(((FREE_LIST *) PktP)->next, TPNULL);
-                WWORD(HostP->ParmMapP->free_list_end, new_end);
+                tmp_pointer = (struct rio_free_list *) RIO_PTR(HostP->Caddr, old_end);
+                writew(new_end, &tmp_pointer->next);
+                writew(old_end, &((struct rio_free_list *) PktP)->prev);
+                writew(TPNULL, &((struct rio_free_list *) PktP)->next);
+                writew(new_end, &HostP->ParmMapP->free_list_end);
         } else {                /* First packet on the free list this should never happen! */
                 rio_dprintk(RIO_DEBUG_PFE, "put_free_end(): This should never happen\n");
-                WWORD(HostP->ParmMapP->free_list_end, RIO_OFF(HostP->Caddr, PktP));
-                tmp_pointer = (FREE_LIST *) PktP;
-                WWORD(tmp_pointer->prev, TPNULL);
-                WWORD(tmp_pointer->next, TPNULL);
+                writew(RIO_OFF(HostP->Caddr, PktP), &HostP->ParmMapP->free_list_end);
+                tmp_pointer = (struct rio_free_list *) PktP;
+                writew(TPNULL, &tmp_pointer->prev);
+                writew(TPNULL, &tmp_pointer->next);
         }
         rio_dprintk(RIO_DEBUG_CMD, "Before unlock: %p\n", &HostP->HostLock);
         rio_spin_unlock_irqrestore(&HostP->HostLock, flags);
@@ -669,12 +647,10 @@ PKT *PktP;
 ** relevant packet, [having cleared the PKT_IN_USE bit]. If PKT_IN_USE is clear,
 ** then can_remove_receive() returns 0.
 */
-int can_remove_receive(PktP, PortP)
-PKT **PktP;
-struct Port *PortP;
+int can_remove_receive(struct PKT **PktP, struct Port *PortP)
 {
-        if (RWORD(*PortP->RxRemove) & PKT_IN_USE) {
-                *PktP = (PKT *) RIO_PTR(PortP->Caddr, RWORD(*PortP->RxRemove) & ~PKT_IN_USE);
+        if (readw(PortP->RxRemove) & PKT_IN_USE) {
+                *PktP = (struct PKT *) RIO_PTR(PortP->Caddr, readw(PortP->RxRemove) & ~PKT_IN_USE);
                 return 1;
         }
         return 0;
@@ -685,10 +661,9 @@ struct Port *PortP;
 ** and then bump the pointers. Once the pointers get to the end, they must
 ** be wrapped back to the start.
 */
-void remove_receive(PortP)
-struct Port *PortP;
+void remove_receive(struct Port *PortP)
 {
-        WWORD(*PortP->RxRemove, RWORD(*PortP->RxRemove) & ~PKT_IN_USE);
+        writew(readw(PortP->RxRemove) & ~PKT_IN_USE, PortP->RxRemove);
         PortP->RxRemove = (PortP->RxRemove == PortP->RxEnd) ? PortP->RxStart : PortP->RxRemove + 1;
-        WWORD(PortP->PhbP->rx_remove, RIO_OFF(PortP->Caddr, PortP->RxRemove));
+        writew(RIO_OFF(PortP->Caddr, PortP->RxRemove), &PortP->PhbP->rx_remove);
 }
diff --git a/drivers/char/rio/riopcicopy.c b/drivers/char/rio/riopcicopy.c
deleted file mode 100644
index 535afaa51c..0000000000
--- a/drivers/char/rio/riopcicopy.c
+++ /dev/null
@@ -1,8 +0,0 @@
-
-/* Yeah. We have copyright on this one. Sure. */
-
-void rio_pcicopy(char *from, char *to, int amount)
-{
-        while (amount--)
-                *to++ = *from++;
-}
diff --git a/drivers/char/rio/rioroute.c b/drivers/char/rio/rioroute.c
index f98888f526..3570853379 100644
--- a/drivers/char/rio/rioroute.c
+++ b/drivers/char/rio/rioroute.c
@@ -50,15 +50,12 @@ static char *_rioroute_c_sccs_ = "@(#)rioroute.c	1.3";
 
 #include "linux_compat.h"
 #include "rio_linux.h"
-#include "typdef.h"
 #include "pkt.h"
 #include "daemon.h"
 #include "rio.h"
 #include "riospace.h"
-#include "top.h"
 #include "cmdpkt.h"
 #include "map.h"
-#include "riotypes.h"
 #include "rup.h"
 #include "port.h"
 #include "riodrvr.h"
@@ -71,29 +68,25 @@ static char *_rioroute_c_sccs_ = "@(#)rioroute.c	1.3";
 #include "unixrup.h"
 #include "board.h"
 #include "host.h"
-#include "error.h"
 #include "phb.h"
 #include "link.h"
 #include "cmdblk.h"
 #include "route.h"
-#include "control.h"
 #include "cirrus.h"
 #include "rioioctl.h"
 #include "param.h"
-#include "list.h"
-#include "sam.h"
 
-static int RIOCheckIsolated(struct rio_info *, struct Host *, uint);
-static int RIOIsolate(struct rio_info *, struct Host *, uint);
-static int RIOCheck(struct Host *, uint);
-static void RIOConCon(struct rio_info *, struct Host *, uint, uint, uint, uint, int);
+static int RIOCheckIsolated(struct rio_info *, struct Host *, unsigned int);
+static int RIOIsolate(struct rio_info *, struct Host *, unsigned int);
+static int RIOCheck(struct Host *, unsigned int);
+static void RIOConCon(struct rio_info *, struct Host *, unsigned int, unsigned int, unsigned int, unsigned int, int);
 
 
 /*
 ** Incoming on the ROUTE_RUP
 ** I wrote this while I was tired. Forgive me.
 */
-int RIORouteRup(struct rio_info *p, uint Rup, struct Host *HostP, PKT * PacketP)
+int RIORouteRup(struct rio_info *p, unsigned int Rup, struct Host *HostP, struct PKT * PacketP)
 {
         struct PktCmd *PktCmdP = (struct PktCmd *) PacketP->data;
         struct PktCmd_M *PktReplyP;
@@ -104,10 +97,10 @@ int RIORouteRup(struct rio_info *p, uint Rup, struct Host *HostP, PKT * PacketP)
         int ThisLink, ThisLinkMin, ThisLinkMax;
         int port;
         int Mod, Mod1, Mod2;
-        ushort RtaType;
-        uint RtaUniq;
-        uint ThisUnit, ThisUnit2;       /* 2 ids to accommodate 16 port RTA */
-        uint OldUnit, NewUnit, OldLink, NewLink;
+        unsigned short RtaType;
+        unsigned int RtaUniq;
+        unsigned int ThisUnit, ThisUnit2;       /* 2 ids to accommodate 16 port RTA */
+        unsigned int OldUnit, NewUnit, OldLink, NewLink;
         char *MyType, *MyName;
         int Lies;
         unsigned long flags;
@@ -115,7 +108,7 @@ int RIORouteRup(struct rio_info *p, uint Rup, struct Host *HostP, PKT * PacketP)
         /*
          ** Is this unit telling us it's current link topology?
          */
-        if (RBYTE(PktCmdP->Command) == ROUTE_TOPOLOGY) {
+        if (readb(&PktCmdP->Command) == ROUTE_TOPOLOGY) {
                 MapP = HostP->Mapping;
 
                 /*
@@ -125,7 +118,7 @@ int RIORouteRup(struct rio_info *p, uint Rup, struct Host *HostP, PKT * PacketP)
                  ** from an RTA then we need to fill in the Mapping structure's
                  ** Topology array for the unit.
                  */
-                if (Rup >= (ushort) MAX_RUP) {
+                if (Rup >= (unsigned short) MAX_RUP) {
                         ThisUnit = HOST_ID;
                         TopP = HostP->Topology;
                         MyType = "Host";
@@ -151,11 +144,11 @@ int RIORouteRup(struct rio_info *p, uint Rup, struct Host *HostP, PKT * PacketP)
                          ** it won't lie about network interconnect, total disconnects
                          ** and no-IDs. (or at least, it doesn't *matter* if it does)
                          */
-                        if (RBYTE(PktCmdP->RouteTopology[ThisLink].Unit) > (ushort) MAX_RUP)
+                        if (readb(&PktCmdP->RouteTopology[ThisLink].Unit) > (unsigned short) MAX_RUP)
                                 continue;
 
                         for (NewLink = ThisLinkMin; NewLink < ThisLink; NewLink++) {
-                                if ((RBYTE(PktCmdP->RouteTopology[ThisLink].Unit) == RBYTE(PktCmdP->RouteTopology[NewLink].Unit)) && (RBYTE(PktCmdP->RouteTopology[ThisLink].Link) == RBYTE(PktCmdP->RouteTopology[NewLink].Link))) {
+                                if ((readb(&PktCmdP->RouteTopology[ThisLink].Unit) == readb(&PktCmdP->RouteTopology[NewLink].Unit)) && (readb(&PktCmdP->RouteTopology[ThisLink].Link) == readb(&PktCmdP->RouteTopology[NewLink].Link))) {
                                         Lies++;
                                 }
                         }
@@ -164,11 +157,11 @@ int RIORouteRup(struct rio_info *p, uint Rup, struct Host *HostP, PKT * PacketP)
                 if (Lies) {
                         rio_dprintk(RIO_DEBUG_ROUTE, "LIES! DAMN LIES! %d LIES!\n", Lies);
                         rio_dprintk(RIO_DEBUG_ROUTE, "%d:%c %d:%c %d:%c %d:%c\n",
-                                    RBYTE(PktCmdP->RouteTopology[0].Unit),
-                                    'A' + RBYTE(PktCmdP->RouteTopology[0].Link),
-                                    RBYTE(PktCmdP->RouteTopology[1].Unit),
-                                    'A' + RBYTE(PktCmdP->RouteTopology[1].Link), RBYTE(PktCmdP->RouteTopology[2].Unit), 'A' + RBYTE(PktCmdP->RouteTopology[2].Link), RBYTE(PktCmdP->RouteTopology[3].Unit), 'A' + RBYTE(PktCmdP->RouteTopology[3].Link));
-                        return TRUE;
+                                    readb(&PktCmdP->RouteTopology[0].Unit),
+                                    'A' + readb(&PktCmdP->RouteTopology[0].Link),
+                                    readb(&PktCmdP->RouteTopology[1].Unit),
+                                    'A' + readb(&PktCmdP->RouteTopology[1].Link), readb(&PktCmdP->RouteTopology[2].Unit), 'A' + readb(&PktCmdP->RouteTopology[2].Link), readb(&PktCmdP->RouteTopology[3].Unit), 'A' + readb(&PktCmdP->RouteTopology[3].Link));
+                        return 1;
                 }
 
                 /*
@@ -184,8 +177,8 @@ int RIORouteRup(struct rio_info *p, uint Rup, struct Host *HostP, PKT * PacketP)
                         /*
                          ** this is what it is now connected to
                          */
-                        NewUnit = RBYTE(PktCmdP->RouteTopology[ThisLink].Unit);
-                        NewLink = RBYTE(PktCmdP->RouteTopology[ThisLink].Link);
+                        NewUnit = readb(&PktCmdP->RouteTopology[ThisLink].Unit);
+                        NewLink = readb(&PktCmdP->RouteTopology[ThisLink].Link);
 
                         if (OldUnit != NewUnit || OldLink != NewLink) {
                                 /*
@@ -219,7 +212,7 @@ int RIORouteRup(struct rio_info *p, uint Rup, struct Host *HostP, PKT * PacketP)
 
                                         if (NewUnit == ROUTE_INTERCONNECT) {
                                                 if (!p->RIONoMessage)
-                                                        cprintf("%s '%s' (%c) is connected to another network.\n", MyType, MyName, 'A' + ThisLink);
+                                                        printk(KERN_DEBUG "rio: %s '%s' (%c) is connected to another network.\n", MyType, MyName, 'A' + ThisLink);
                                         }
 
                                         /*
@@ -258,18 +251,18 @@ int RIORouteRup(struct rio_info *p, uint Rup, struct Host *HostP, PKT * PacketP)
                                 RIOCheckIsolated(p, HostP, OldUnit);
                         }
                 }
-                return TRUE;
+                return 1;
         }
 
         /*
          ** The only other command we recognise is a route_request command
          */
-        if (RBYTE(PktCmdP->Command) != ROUTE_REQUEST) {
-                rio_dprintk(RIO_DEBUG_ROUTE, "Unknown command %d received on rup %d host %d ROUTE_RUP\n", RBYTE(PktCmdP->Command), Rup, (int) HostP);
-                return TRUE;
+        if (readb(&PktCmdP->Command) != ROUTE_REQUEST) {
+                rio_dprintk(RIO_DEBUG_ROUTE, "Unknown command %d received on rup %d host %p ROUTE_RUP\n", readb(&PktCmdP->Command), Rup, HostP);
+                return 1;
         }
 
-        RtaUniq = (RBYTE(PktCmdP->UniqNum[0])) + (RBYTE(PktCmdP->UniqNum[1]) << 8) + (RBYTE(PktCmdP->UniqNum[2]) << 16) + (RBYTE(PktCmdP->UniqNum[3]) << 24);
+        RtaUniq = (readb(&PktCmdP->UniqNum[0])) + (readb(&PktCmdP->UniqNum[1]) << 8) + (readb(&PktCmdP->UniqNum[2]) << 16) + (readb(&PktCmdP->UniqNum[3]) << 24);
 
         /*
          ** Determine if 8 or 16 port RTA
@@ -278,7 +271,7 @@ int RIORouteRup(struct rio_info *p, uint Rup, struct Host *HostP, PKT * PacketP)
 
         rio_dprintk(RIO_DEBUG_ROUTE, "Received a request for an ID for serial number %x\n", RtaUniq);
 
-        Mod = RBYTE(PktCmdP->ModuleTypes);
+        Mod = readb(&PktCmdP->ModuleTypes);
         Mod1 = LONYBLE(Mod);
         if (RtaType == TYPE_RTA16) {
                 /*
@@ -292,10 +285,6 @@ int RIORouteRup(struct rio_info *p, uint Rup, struct Host *HostP, PKT * PacketP)
                 rio_dprintk(RIO_DEBUG_ROUTE, "Module types are %s (ports 0-3) and %s (ports 4-7)\n", p->RIOModuleTypes[Mod1].Name, p->RIOModuleTypes[Mod2].Name);
         }
 
-        if (RtaUniq == 0xffffffff) {
-                ShowPacket(DBG_SPECIAL, PacketP);
-        }
-
         /*
          ** try to unhook a command block from the command free list.
          */
@@ -320,7 +309,7 @@ int RIORouteRup(struct rio_info *p, uint Rup, struct Host *HostP, PKT * PacketP)
                 PktReplyP->Command = ROUTE_FOAD;
                 HostP->Copy("RT_FOAD", PktReplyP->CommandText, 7);
                 RIOQueueCmdBlk(HostP, Rup, CmdBlkP);
-                return TRUE;
+                return 1;
         }
 
         /*
@@ -348,13 +337,13 @@ int RIORouteRup(struct rio_info *p, uint Rup, struct Host *HostP, PKT * PacketP)
                         if ((HostP->Mapping[ThisUnit].Flags & SLOT_IN_USE) && !(HostP->Mapping[ThisUnit].Flags & RTA_BOOTED)) {
                                 if (!(HostP->Mapping[ThisUnit].Flags & MSG_DONE)) {
                                         if (!p->RIONoMessage)
-                                                cprintf("RTA '%s' is being updated.\n", HostP->Mapping[ThisUnit].Name);
+                                                printk(KERN_DEBUG "rio: RTA '%s' is being updated.\n", HostP->Mapping[ThisUnit].Name);
                                         HostP->Mapping[ThisUnit].Flags |= MSG_DONE;
                                 }
                                 PktReplyP->Command = ROUTE_FOAD;
                                 HostP->Copy("RT_FOAD", PktReplyP->CommandText, 7);
                                 RIOQueueCmdBlk(HostP, Rup, CmdBlkP);
-                                return TRUE;
+                                return 1;
                         }
 
                         /*
@@ -447,7 +436,7 @@ int RIORouteRup(struct rio_info *p, uint Rup, struct Host *HostP, PKT * PacketP)
                         /*
                          ** Job done, get on with the interrupts!
                          */
-                        return TRUE;
+                        return 1;
                 }
         }
         /*
@@ -475,7 +464,7 @@ int RIORouteRup(struct rio_info *p, uint Rup, struct Host *HostP, PKT * PacketP)
 
                 if (!UnknownMesgDone) {
                         if (!p->RIONoMessage)
-                                cprintf("One or more unknown RTAs are being updated.\n");
+                                printk(KERN_DEBUG "rio: One or more unknown RTAs are being updated.\n");
                         UnknownMesgDone = 1;
                 }
 
@@ -491,28 +480,25 @@ int RIORouteRup(struct rio_info *p, uint Rup, struct Host *HostP, PKT * PacketP)
                 if (RtaType == TYPE_RTA16) {
                         if (RIOFindFreeID(p, HostP, &ThisUnit, &ThisUnit2) == 0) {
                                 RIODefaultName(p, HostP, ThisUnit);
-                                FillSlot(ThisUnit, ThisUnit2, RtaUniq, HostP);
+                                rio_fill_host_slot(ThisUnit, ThisUnit2, RtaUniq, HostP);
                         }
                 } else {
                         if (RIOFindFreeID(p, HostP, &ThisUnit, NULL) == 0) {
                                 RIODefaultName(p, HostP, ThisUnit);
-                                FillSlot(ThisUnit, 0, RtaUniq, HostP);
+                                rio_fill_host_slot(ThisUnit, 0, RtaUniq, HostP);
                         }
                 }
                 PktReplyP->Command = ROUTE_USED;
                 HostP->Copy("RT_USED", PktReplyP->CommandText, 7);
         }
         RIOQueueCmdBlk(HostP, Rup, CmdBlkP);
-        return TRUE;
+        return 1;
 }
 
 
-void RIOFixPhbs(p, HostP, unit)
-struct rio_info *p;
-struct Host *HostP;
-uint unit;
+void RIOFixPhbs(struct rio_info *p, struct Host *HostP, unsigned int unit)
 {
-        ushort link, port;
+        unsigned short link, port;
         struct Port *PortP;
         unsigned long flags;
         int PortN = HostP->Mapping[unit].SysPort;
@@ -520,19 +506,19 @@ uint unit;
         rio_dprintk(RIO_DEBUG_ROUTE, "RIOFixPhbs unit %d sysport %d\n", unit, PortN);
 
         if (PortN != -1) {
-                ushort dest_unit = HostP->Mapping[unit].ID2;
+                unsigned short dest_unit = HostP->Mapping[unit].ID2;
 
                 /*
                  ** Get the link number used for the 1st 8 phbs on this unit.
                  */
                 PortP = p->RIOPortp[HostP->Mapping[dest_unit - 1].SysPort];
 
-                link = RWORD(PortP->PhbP->link);
+                link = readw(&PortP->PhbP->link);
 
                 for (port = 0; port < PORTS_PER_RTA; port++, PortN++) {
-                        ushort dest_port = port + 8;
-                        WORD *TxPktP;
-                        PKT *Pkt;
+                        unsigned short dest_port = port + 8;
+                        u16 *TxPktP;
+                        struct PKT *Pkt;
 
                         PortP = p->RIOPortp[PortN];
 
@@ -569,18 +555,18 @@ uint unit;
                                  ** card. This needs to be translated into a 32 bit pointer
                                  ** so it can be accessed from the driver.
                                  */
-                                Pkt = (PKT *) RIO_PTR(HostP->Caddr, RINDW(TxPktP));
+                                Pkt = (struct PKT *) RIO_PTR(HostP->Caddr, readw(TxPktP));
 
                                 /*
                                  ** If the packet is used, reset it.
                                  */
-                                Pkt = (PKT *) ((uint) Pkt & ~PKT_IN_USE);
-                                WBYTE(Pkt->dest_unit, dest_unit);
-                                WBYTE(Pkt->dest_port, dest_port);
+                                Pkt = (struct PKT *) ((unsigned long) Pkt & ~PKT_IN_USE);
+                                writeb(dest_unit, &Pkt->dest_unit);
+                                writeb(dest_port, &Pkt->dest_port);
                         }
-                        rio_dprintk(RIO_DEBUG_ROUTE, "phb dest: Old %x:%x New %x:%x\n", RWORD(PortP->PhbP->destination) & 0xff, (RWORD(PortP->PhbP->destination) >> 8) & 0xff, dest_unit, dest_port);
-                        WWORD(PortP->PhbP->destination, dest_unit + (dest_port << 8));
-                        WWORD(PortP->PhbP->link, link);
+                        rio_dprintk(RIO_DEBUG_ROUTE, "phb dest: Old %x:%x New %x:%x\n", readw(&PortP->PhbP->destination) & 0xff, (readw(&PortP->PhbP->destination) >> 8) & 0xff, dest_unit, dest_port);
+                        writew(dest_unit + (dest_port << 8), &PortP->PhbP->destination);
+                        writew(link, &PortP->PhbP->link);
 
                         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
                 }
@@ -590,9 +576,9 @@ uint unit;
                  */
                 if (link > 3)
                         return;
-                if (((unit * 8) + 7) > RWORD(HostP->LinkStrP[link].last_port)) {
+                if (((unit * 8) + 7) > readw(&HostP->LinkStrP[link].last_port)) {
                         rio_dprintk(RIO_DEBUG_ROUTE, "last port on host link %d: %d\n", link, (unit * 8) + 7);
-                        WWORD(HostP->LinkStrP[link].last_port, (unit * 8) + 7);
+                        writew((unit * 8) + 7, &HostP->LinkStrP[link].last_port);
                 }
         }
 }
@@ -603,10 +589,7 @@ uint unit;
 ** the world about it. This is done to ensure that the configurator
 ** only gets up-to-date information about what is going on.
 */
-static int RIOCheckIsolated(p, HostP, UnitId)
-struct rio_info *p;
-struct Host *HostP;
-uint UnitId;
+static int RIOCheckIsolated(struct rio_info *p, struct Host *HostP, unsigned int UnitId)
 {
         unsigned long flags;
         rio_spin_lock_irqsave(&HostP->HostLock, flags);
@@ -628,12 +611,9 @@ uint UnitId;
 ** all the units attached to it. This will mean that the entire
 ** subnet will re-introduce itself.
 */
-static int RIOIsolate(p, HostP, UnitId)
-struct rio_info *p;
-struct Host *HostP;
-uint UnitId;
+static int RIOIsolate(struct rio_info *p, struct Host *HostP, unsigned int UnitId)
 {
-        uint link, unit;
+        unsigned int link, unit;
 
         UnitId--;               /* this trick relies on the Unit Id being UNSIGNED! */
 
@@ -658,9 +638,7 @@ uint UnitId;
         return 1;
 }
 
-static int RIOCheck(HostP, UnitId)
-struct Host *HostP;
-uint UnitId;
+static int RIOCheck(struct Host *HostP, unsigned int UnitId)
 {
         unsigned char link;
 
@@ -714,8 +692,7 @@ uint UnitId;
 ** Returns the type of unit (host, 16/8 port RTA)
 */
 
-uint GetUnitType(Uniq)
-uint Uniq;
+unsigned int GetUnitType(unsigned int Uniq)
 {
         switch ((Uniq >> 28) & 0xf) {
         case RIO_AT:
@@ -736,8 +713,7 @@ uint Uniq;
         }
 }
 
-int RIOSetChange(p)
-struct rio_info *p;
+int RIOSetChange(struct rio_info *p)
 {
         if (p->RIOQuickCheck != NOT_CHANGED)
                 return (0);
@@ -751,14 +727,13 @@ struct rio_info *p;
         return (0);
 }
 
-static void RIOConCon(p, HostP, FromId, FromLink, ToId, ToLink, Change)
-struct rio_info *p;
-struct Host *HostP;
-uint FromId;
-uint FromLink;
-uint ToId;
-uint ToLink;
-int Change;
+static void RIOConCon(struct rio_info *p,
+                      struct Host *HostP,
+                      unsigned int FromId,
+                      unsigned int FromLink,
+                      unsigned int ToId,
+                      unsigned int ToLink,
+                      int Change)
 {
         char *FromName;
         char *FromType;
@@ -818,7 +793,7 @@ int Change;
         ToType = ToId ? "RTA" : "HOST";
 
         rio_dprintk(RIO_DEBUG_ROUTE, "Link between %s '%s' (%c) and %s '%s' (%c) %s.\n", FromType, FromName, 'A' + FromLink, ToType, ToName, 'A' + ToLink, (Change == CONNECT) ? "established" : "disconnected");
-        cprintf("Link between %s '%s' (%c) and %s '%s' (%c) %s.\n", FromType, FromName, 'A' + FromLink, ToType, ToName, 'A' + ToLink, (Change == CONNECT) ? "established" : "disconnected");
+        printk(KERN_DEBUG "rio: Link between %s '%s' (%c) and %s '%s' (%c) %s.\n", FromType, FromName, 'A' + FromLink, ToType, ToName, 'A' + ToLink, (Change == CONNECT) ? "established" : "disconnected");
 }
 
 /*
@@ -838,7 +813,7 @@ static int RIORemoveFromSavedTable(struct rio_info *p, struct Map *pMap)
          */
         for (entry = 0; entry < TOTAL_MAP_ENTRIES; entry++) {
                 if (p->RIOSavedTable[entry].RtaUniqueNum == pMap->RtaUniqueNum) {
-                        bzero((caddr_t) & p->RIOSavedTable[entry], sizeof(struct Map));
+                        memset(&p->RIOSavedTable[entry], 0, sizeof(struct Map));
                 }
         }
         return 0;
@@ -898,7 +873,7 @@ static int RIOFreeDisconnected(struct rio_info *p, struct Host *HostP, int unit)
                 int nOther = (HostP->Mapping[unit].ID2) - 1;
 
                 rio_dprintk(RIO_DEBUG_ROUTE, "RioFreedis second slot %d.\n", nOther);
-                bzero((caddr_t) & HostP->Mapping[nOther], sizeof(struct Map));
+                memset(&HostP->Mapping[nOther], 0, sizeof(struct Map));
         }
         RIORemoveFromSavedTable(p, &HostP->Mapping[unit]);
 
@@ -912,7 +887,8 @@ static int RIOFreeDisconnected(struct rio_info *p, struct Host *HostP, int unit)
 ** This function scans the given host table for either one
 ** or two free unit ID's.
 */
-int RIOFindFreeID(struct rio_info *p, struct Host *HostP, uint * pID1, uint * pID2)
+
+int RIOFindFreeID(struct rio_info *p, struct Host *HostP, unsigned int * pID1, unsigned int * pID2)
 {
         int unit, tempID;
 
@@ -997,7 +973,7 @@ int RIOFindFreeID(struct rio_info *p, struct Host *HostP, uint * pID1, uint * pI
                                 /*
                                  ** Clear out this slot now that we intend to use it.
                                  */
-                                bzero(&HostP->Mapping[unit], sizeof(struct Map));
+                                memset(&HostP->Mapping[unit], 0, sizeof(struct Map));
 
                                 /*
                                  ** If the second ID is not needed then we can return
@@ -1015,7 +991,7 @@ int RIOFindFreeID(struct rio_info *p, struct Host *HostP, uint * pID1, uint * pI
                                 /*
                                  ** Clear out this slot now that we intend to use it.
                                  */
-                                bzero(&HostP->Mapping[unit], sizeof(struct Map));
+                                memset(&HostP->Mapping[unit], 0, sizeof(struct Map));
 
                                 /* At this point under the right(wrong?) conditions
                                  ** we may have a first unit ID being higher than the
diff --git a/drivers/char/rio/riotable.c b/drivers/char/rio/riotable.c
index a86b216ab6..d3abe0d37d 100644
--- a/drivers/char/rio/riotable.c
+++ b/drivers/char/rio/riotable.c
@@ -53,15 +53,12 @@ static char *_riotable_c_sccs_ = "@(#)riotable.c	1.2";
 
 #include "linux_compat.h"
 #include "rio_linux.h"
-#include "typdef.h"
 #include "pkt.h"
 #include "daemon.h"
 #include "rio.h"
 #include "riospace.h"
-#include "top.h"
 #include "cmdpkt.h"
 #include "map.h"
-#include "riotypes.h"
 #include "rup.h"
 #include "port.h"
 #include "riodrvr.h"
@@ -74,25 +71,20 @@ static char *_riotable_c_sccs_ = "@(#)riotable.c	1.2";
 #include "unixrup.h"
 #include "board.h"
 #include "host.h"
-#include "error.h"
 #include "phb.h"
 #include "link.h"
 #include "cmdblk.h"
 #include "route.h"
-#include "control.h"
 #include "cirrus.h"
 #include "rioioctl.h"
 #include "param.h"
-#include "list.h"
-#include "sam.h"
 #include "protsts.h"
 
 /*
 ** A configuration table has been loaded. It is now up to us
 ** to sort it out and use the information contained therein.
 */
-int RIONewTable(p)
-struct rio_info *p;
+int RIONewTable(struct rio_info *p)
 {
         int Host, Host1, Host2, NameIsUnique, Entry, SubEnt;
         struct Map *MapP;
@@ -137,7 +129,7 @@ struct rio_info *p;
                         cptr = MapP->Name;      /* (2) */
                         cptr[MAX_NAME_LEN - 1] = '\0';
                         if (cptr[0] == '\0') {
-                                bcopy(MapP->RtaUniqueNum ? "RTA NN" : "HOST NN", MapP->Name, 8);
+                                memcpy(MapP->Name, MapP->RtaUniqueNum ? "RTA    NN" : "HOST NN", 8);
                                 MapP->Name[5] = '0' + Entry / 10;
                                 MapP->Name[6] = '0' + Entry % 10;
                         }
@@ -298,9 +290,9 @@ struct rio_info *p;
          */
         for (Host = 0; Host < RIO_HOSTS; Host++) {
                 for (Entry = 0; Entry < MAX_RUP; Entry++) {
-                        bzero((caddr_t) & p->RIOHosts[Host].Mapping[Entry], sizeof(struct Map));
+                        memset(&p->RIOHosts[Host].Mapping[Entry], 0, sizeof(struct Map));
                 }
-                bzero((caddr_t) & p->RIOHosts[Host].Name[0], sizeof(p->RIOHosts[Host].Name));
+                memset(&p->RIOHosts[Host].Name[0], 0, sizeof(p->RIOHosts[Host].Name));
         }
 
         /*
@@ -326,7 +318,7 @@ struct rio_info *p;
                  */
                 if (MapP->ID == 0) {
                         rio_dprintk(RIO_DEBUG_TABLE, "Host entry found. Name %s\n", MapP->Name);
-                        bcopy(MapP->Name, HostP->Name, MAX_NAME_LEN);
+                        memcpy(HostP->Name, MapP->Name, MAX_NAME_LEN);
                         continue;
                 }
 
@@ -370,7 +362,7 @@ struct rio_info *p;
                         }
                 }
                 if (!p->RIOHosts[Host].Name[0]) {
-                        bcopy("HOST 1", p->RIOHosts[Host].Name, 7);
+                        memcpy(p->RIOHosts[Host].Name, "HOST 1", 7);
                         p->RIOHosts[Host].Name[5] += Host;
                 }
                 /*
@@ -398,7 +390,7 @@ struct rio_info *p;
                  */
                 if (Host1 != Host) {
                         rio_dprintk(RIO_DEBUG_TABLE, "Default name %s already used\n", p->RIOHosts[Host].Name);
-                        bcopy("HOST 1", p->RIOHosts[Host].Name, 7);
+                        memcpy(p->RIOHosts[Host].Name, "HOST 1", 7);
                         p->RIOHosts[Host].Name[5] += Host1;
                 }
                 rio_dprintk(RIO_DEBUG_TABLE, "Assigning default name %s\n", p->RIOHosts[Host].Name);
@@ -409,9 +401,10 @@ struct rio_info *p;
 /*
 ** User process needs the config table - build it from first
 ** principles.
+**
+*       FIXME: SMP locking
 */
-int RIOApel(p)
-struct rio_info *p;
+int RIOApel(struct rio_info *p)
 {
         int Host;
         int link;
@@ -419,17 +412,17 @@ struct rio_info *p;
         int Next = 0;
         struct Map *MapP;
         struct Host *HostP;
-        long oldspl;
-
-        disable(oldspl);        /* strange but true! */
+        unsigned long flags;
 
         rio_dprintk(RIO_DEBUG_TABLE, "Generating a table to return to config.rio\n");
 
-        bzero((caddr_t) & p->RIOConnectTable[0], sizeof(struct Map) * TOTAL_MAP_ENTRIES);
+        memset(&p->RIOConnectTable[0], 0, sizeof(struct Map) * TOTAL_MAP_ENTRIES);
 
         for (Host = 0; Host < RIO_HOSTS; Host++) {
                 rio_dprintk(RIO_DEBUG_TABLE, "Processing host %d\n", Host);
                 HostP = &p->RIOHosts[Host];
+                rio_spin_lock_irqsave(&HostP->HostLock, flags);
+
                 MapP = &p->RIOConnectTable[Next++];
                 MapP->HostUniqueNum = HostP->UniqueNum;
                 if ((HostP->Flags & RUN_STATE) != RC_RUNNING)
@@ -440,7 +433,7 @@ struct rio_info *p;
                 MapP->SysPort = NO_PORT;
                 for (link = 0; link < LINKS_PER_UNIT; link++)
                         MapP->Topology[link] = HostP->Topology[link];
-                bcopy(HostP->Name, MapP->Name, MAX_NAME_LEN);
+                memcpy(MapP->Name, HostP->Name, MAX_NAME_LEN);
                 for (Rup = 0; Rup < MAX_RUP; Rup++) {
                         if (HostP->Mapping[Rup].Flags & (SLOT_IN_USE | SLOT_TENTATIVE)) {
                                 p->RIOConnectTable[Next] = HostP->Mapping[Rup];
@@ -453,8 +446,8 @@ struct rio_info *p;
                                 Next++;
                         }
                 }
+                rio_spin_unlock_irqrestore(&HostP->HostLock, flags);
         }
-        restore(oldspl);
         return 0;
 }
 
@@ -463,9 +456,7 @@ struct rio_info *p;
 ** if the entry is suitably inactive, then we can gob on it and remove
 ** it from the table.
 */
-int RIODeleteRta(p, MapP)
-struct rio_info *p;
-struct Map *MapP;
+int RIODeleteRta(struct rio_info *p, struct Map *MapP)
 {
         int host, entry, port, link;
         int SysPort;
@@ -541,10 +532,10 @@ struct Map *MapP;
                                                  ** the phb to port mappings in RIORouteRup.
                                                  */
                                                 if (PortP->SecondBlock) {
-                                                        ushort dest_unit = HostMapP->ID;
-                                                        ushort dest_port = port - SysPort;
-                                                        WORD *TxPktP;
-                                                        PKT *Pkt;
+                                                        u16 dest_unit = HostMapP->ID;
+                                                        u16 dest_port = port - SysPort;
+                                                        u16 *TxPktP;
+                                                        struct PKT *Pkt;
 
                                                         for (TxPktP = PortP->TxStart; TxPktP <= PortP->TxEnd; TxPktP++) {
                                                                 /*
@@ -554,19 +545,19 @@ struct Map *MapP;
                                                                  ** a 32 bit pointer so it can be
                                                                  ** accessed from the driver.
                                                                  */
-                                                                Pkt = (PKT *) RIO_PTR(HostP->Caddr, RWORD(*TxPktP));
+                                                                Pkt = (struct PKT *) RIO_PTR(HostP->Caddr, readw(&*TxPktP));
                                                                 rio_dprintk(RIO_DEBUG_TABLE, "Tx packet (%x) destination: Old %x:%x New %x:%x\n", *TxPktP, Pkt->dest_unit, Pkt->dest_port, dest_unit, dest_port);
-                                                                WWORD(Pkt->dest_unit, dest_unit);
-                                                                WWORD(Pkt->dest_port, dest_port);
+                                                                writew(dest_unit, &Pkt->dest_unit);
+                                                                writew(dest_port, &Pkt->dest_port);
                                                         }
                                                         rio_dprintk(RIO_DEBUG_TABLE, "Port %d phb destination: Old %x:%x New %x:%x\n", port, PortP->PhbP->destination & 0xff, (PortP->PhbP->destination >> 8) & 0xff, dest_unit, dest_port);
-                                                        WWORD(PortP->PhbP->destination, dest_unit + (dest_port << 8));
+                                                        writew(dest_unit + (dest_port << 8), &PortP->PhbP->destination);
                                                 }
                                                 rio_spin_unlock_irqrestore(&PortP->portSem, sem_flags);
                                         }
                                 }
                                 rio_dprintk(RIO_DEBUG_TABLE, "Entry nulled.\n");
-                                bzero((char *) HostMapP, sizeof(struct Map));
+                                memset(HostMapP, 0, sizeof(struct Map));
                                 work_done++;
                         }
                 }
@@ -576,11 +567,11 @@ struct Map *MapP;
         /* XXXXX lock me up */
         for (entry = 0; entry < TOTAL_MAP_ENTRIES; entry++) {
                 if (p->RIOSavedTable[entry].RtaUniqueNum == MapP->RtaUniqueNum) {
-                        bzero((char *) &p->RIOSavedTable[entry], sizeof(struct Map));
+                        memset(&p->RIOSavedTable[entry], 0, sizeof(struct Map));
                         work_done++;
                 }
                 if (p->RIOConnectTable[entry].RtaUniqueNum == MapP->RtaUniqueNum) {
-                        bzero((char *) &p->RIOConnectTable[entry], sizeof(struct Map));
+                        memset(&p->RIOConnectTable[entry], 0, sizeof(struct Map));
                         work_done++;
                 }
         }
@@ -602,7 +593,7 @@ int RIOAssignRta(struct rio_info *p, struct Map *MapP)
 
         rio_dprintk(RIO_DEBUG_TABLE, "Assign entry on host %x, rta %x, ID %d, Sysport %d\n", MapP->HostUniqueNum, MapP->RtaUniqueNum, MapP->ID, (int) MapP->SysPort);
 
-        if ((MapP->ID != (ushort) - 1) && ((int) MapP->ID < (int) 1 || (int) MapP->ID > MAX_RUP)) {
+        if ((MapP->ID != (u16) - 1) && ((int) MapP->ID < (int) 1 || (int) MapP->ID > MAX_RUP)) {
                 rio_dprintk(RIO_DEBUG_TABLE, "Bad ID in map entry!\n");
                 p->RIOError.Error = ID_NUMBER_OUT_OF_RANGE;
                 return -EINVAL;
@@ -648,7 +639,7 @@ int RIOAssignRta(struct rio_info *p, struct Map *MapP)
                          ** Now we have a host we need to allocate an ID
                          ** if the entry does not already have one.
                          */
-                        if (MapP->ID == (ushort) - 1) {
+                        if (MapP->ID == (u16) - 1) {
                                 int nNewID;
 
                                 rio_dprintk(RIO_DEBUG_TABLE, "Attempting to get a new ID for rta \"%s\"\n", MapP->Name);
@@ -667,7 +658,7 @@ int RIOAssignRta(struct rio_info *p, struct Map *MapP)
                                         p->RIOError.Error = COULDNT_FIND_ENTRY;
                                         return -EBUSY;
                                 }
-                                MapP->ID = (ushort) nNewID + 1;
+                                MapP->ID = (u16) nNewID + 1;
                                 rio_dprintk(RIO_DEBUG_TABLE, "Allocated ID %d for this new RTA.\n", MapP->ID);
                                 HostMapP = &p->RIOHosts[host].Mapping[nNewID];
                                 HostMapP->RtaUniqueNum = MapP->RtaUniqueNum;
@@ -708,7 +699,7 @@ int RIOAssignRta(struct rio_info *p, struct Map *MapP)
                          */
                         HostMapP->SysPort = MapP->SysPort;
                         if ((MapP->Flags & RTA16_SECOND_SLOT) == 0)
-                                CCOPY(MapP->Name, HostMapP->Name, MAX_NAME_LEN);
+                                memcpy(HostMapP->Name, MapP->Name, MAX_NAME_LEN);
                         HostMapP->Flags = SLOT_IN_USE | RTA_BOOTED;
 #ifdef NEED_TO_FIX
                         RIO_SV_BROADCAST(p->RIOHosts[host].svFlags[MapP->ID - 1]);
@@ -742,16 +733,13 @@ int RIOAssignRta(struct rio_info *p, struct Map *MapP)
 }
 
 
-int RIOReMapPorts(p, HostP, HostMapP)
-struct rio_info *p;
-struct Host *HostP;
-struct Map *HostMapP;
+int RIOReMapPorts(struct rio_info *p, struct Host *HostP, struct Map *HostMapP)
 {
-        register struct Port *PortP;
-        uint SubEnt;
-        uint HostPort;
-        uint SysPort;
-        ushort RtaType;
+        struct Port *PortP;
+        unsigned int SubEnt;
+        unsigned int HostPort;
+        unsigned int SysPort;
+        u16 RtaType;
         unsigned long flags;
 
         rio_dprintk(RIO_DEBUG_TABLE, "Mapping sysport %d to id %d\n", (int) HostMapP->SysPort, HostMapP->ID);
@@ -794,12 +782,12 @@ struct Map *HostMapP;
                  */
                 if ((HostP->Flags & RUN_STATE) == RC_RUNNING) {
                         struct PHB *PhbP = PortP->PhbP = &HostP->PhbP[HostPort];
-                        PortP->TxAdd = (WORD *) RIO_PTR(HostP->Caddr, RWORD(PhbP->tx_add));
-                        PortP->TxStart = (WORD *) RIO_PTR(HostP->Caddr, RWORD(PhbP->tx_start));
-                        PortP->TxEnd = (WORD *) RIO_PTR(HostP->Caddr, RWORD(PhbP->tx_end));
-                        PortP->RxRemove = (WORD *) RIO_PTR(HostP->Caddr, RWORD(PhbP->rx_remove));
-                        PortP->RxStart = (WORD *) RIO_PTR(HostP->Caddr, RWORD(PhbP->rx_start));
-                        PortP->RxEnd = (WORD *) RIO_PTR(HostP->Caddr, RWORD(PhbP->rx_end));
+                        PortP->TxAdd = (u16 *) RIO_PTR(HostP->Caddr, readw(&PhbP->tx_add));
+                        PortP->TxStart = (u16 *) RIO_PTR(HostP->Caddr, readw(&PhbP->tx_start));
+                        PortP->TxEnd = (u16 *) RIO_PTR(HostP->Caddr, readw(&PhbP->tx_end));
+                        PortP->RxRemove = (u16 *) RIO_PTR(HostP->Caddr, readw(&PhbP->rx_remove));
+                        PortP->RxStart = (u16 *) RIO_PTR(HostP->Caddr, readw(&PhbP->rx_start));
+                        PortP->RxEnd = (u16 *) RIO_PTR(HostP->Caddr, readw(&PhbP->rx_end));
                 } else
                         PortP->PhbP = NULL;
 
@@ -813,10 +801,10 @@ struct Map *HostMapP;
                 PortP->RupNum = HostMapP->ID - 1;
                 if (HostMapP->Flags & RTA16_SECOND_SLOT) {
                         PortP->ID2 = HostMapP->ID2 - 1;
-                        PortP->SecondBlock = TRUE;
+                        PortP->SecondBlock = 1;
                 } else {
                         PortP->ID2 = 0;
-                        PortP->SecondBlock = FALSE;
+                        PortP->SecondBlock = 0;
                 }
                 PortP->RtaUniqueNum = HostMapP->RtaUniqueNum;
 
@@ -866,9 +854,6 @@ struct Map *HostMapP;
                 PortP->RxDataStart = 0;
                 PortP->Cor2Copy = 0;
                 PortP->Name = &HostMapP->Name[0];
-#ifdef STATS
-                bzero((caddr_t) & PortP->Stat, sizeof(struct RIOStats));
-#endif
                 PortP->statsGather = 0;
                 PortP->txchars = 0;
                 PortP->rxchars = 0;
@@ -876,10 +861,10 @@ struct Map *HostMapP;
                 PortP->closes = 0;
                 PortP->ioctls = 0;
                 if (PortP->TxRingBuffer)
-                        bzero(PortP->TxRingBuffer, p->RIOBufferSize);
+                        memset(PortP->TxRingBuffer, 0, p->RIOBufferSize);
                 else if (p->RIOBufferSize) {
-                        PortP->TxRingBuffer = sysbrk(p->RIOBufferSize);
-                        bzero(PortP->TxRingBuffer, p->RIOBufferSize);
+                        PortP->TxRingBuffer = kmalloc(p->RIOBufferSize, GFP_KERNEL);
+                        memset(PortP->TxRingBuffer, 0, p->RIOBufferSize);
                 }
                 PortP->TxBufferOut = 0;
                 PortP->TxBufferIn = 0;
@@ -890,7 +875,7 @@ struct Map *HostMapP;
                  ** If the same, we have received the same rx pkt from the RTA
                  ** twice. Initialise to a value not equal to PHB_RX_TGL or 0.
                  */
-                PortP->LastRxTgl = ~(uchar) PHB_RX_TGL;
+                PortP->LastRxTgl = ~(u8) PHB_RX_TGL;
 
                 /*
                  ** and mark the port as usable
@@ -906,9 +891,7 @@ struct Map *HostMapP;
         return 0;
 }
 
-int RIOChangeName(p, MapP)
-struct rio_info *p;
-struct Map *MapP;
+int RIOChangeName(struct rio_info *p, struct Map *MapP)
 {
         int host;
         struct Map *HostMapP;
@@ -941,7 +924,7 @@ struct Map *MapP;
                                 return -ENXIO;
                         }
                         if (MapP->ID == 0) {
-                                CCOPY(MapP->Name, p->RIOHosts[host].Name, MAX_NAME_LEN);
+                                memcpy(p->RIOHosts[host].Name, MapP->Name, MAX_NAME_LEN);
                                 return 0;
                         }
 
@@ -951,7 +934,7 @@ struct Map *MapP;
                                 p->RIOError.Error = RTA_NUMBER_WRONG;
                                 return -ENXIO;
                         }
-                        CCOPY(MapP->Name, HostMapP->Name, MAX_NAME_LEN);
+                        memcpy(HostMapP->Name, MapP->Name, MAX_NAME_LEN);
                         return 0;
                 }
         }
diff --git a/drivers/char/rio/riotty.c b/drivers/char/rio/riotty.c
index 6379816ed1..204267613c 100644
--- a/drivers/char/rio/riotty.c
+++ b/drivers/char/rio/riotty.c
@@ -56,15 +56,12 @@ static char *_riotty_c_sccs_ = "@(#)riotty.c	1.3";
 
 #include "linux_compat.h"
 #include "rio_linux.h"
-#include "typdef.h"
 #include "pkt.h"
 #include "daemon.h"
 #include "rio.h"
 #include "riospace.h"
-#include "top.h"
 #include "cmdpkt.h"
 #include "map.h"
-#include "riotypes.h"
 #include "rup.h"
 #include "port.h"
 #include "riodrvr.h"
@@ -77,58 +74,18 @@ static char *_riotty_c_sccs_ = "@(#)riotty.c	1.3";
 #include "unixrup.h"
 #include "board.h"
 #include "host.h"
-#include "error.h"
 #include "phb.h"
 #include "link.h"
 #include "cmdblk.h"
 #include "route.h"
-#include "control.h"
 #include "cirrus.h"
 #include "rioioctl.h"
 #include "param.h"
-#include "list.h"
-#include "sam.h"
 
 static void RIOClearUp(struct Port *PortP);
-int RIOShortCommand(struct rio_info *p, struct Port *PortP, int command, int len, int arg);
-
-
-extern int conv_vb[];           /* now defined in ttymgr.c */
-extern int conv_bv[];           /* now defined in ttymgr.c */
 
-/*
-** 16.09.1998 ARG - Fix to build riotty.k.o for Modular Kernel Support
-**
-** ep.def.h is necessary for Modular Kernel Support
-** DO NOT place any kernel 'extern's after this line
-** or this source file will not build riotty.k.o
-*/
-#ifdef uLYNX
-#include <ep.def.h>
-#endif
-
-#ifdef NEED_THIS2
-static struct old_sgttyb default_sg = {
-        B19200, B19200,         /* input and output speed */
-        'H' - '@',              /* erase char */
-        -1,                     /* 2nd erase char */
-        'U' - '@',              /* kill char */
-        ECHO | CRMOD,           /* mode */
-        'C' - '@',              /* interrupt character */
-        '\\' - '@',             /* quit char */
-        'Q' - '@',              /* start char */
-        'S' - '@',              /* stop char */
-        'D' - '@',              /* EOF */
-        -1,                     /* brk */
-        (LCRTBS | LCRTERA | LCRTKIL | LCTLECH), /* local mode word */
-        'Z' - '@',              /* process stop */
-        'Y' - '@',              /* delayed stop */
-        'R' - '@',              /* reprint line */
-        'O' - '@',              /* flush output */
-        'W' - '@',              /* word erase */
-        'V' - '@'               /* literal next char */
-};
-#endif
+/* Below belongs in func.h */
+int RIOShortCommand(struct rio_info *p, struct Port *PortP, int command, int len, int arg);
 
 
 extern struct rio_info *p;
@@ -136,8 +93,7 @@ extern struct rio_info *p;
 
 int riotopen(struct tty_struct *tty, struct file *filp)
 {
-        register uint SysPort;
-        int Modem;
+        unsigned int SysPort;
         int repeat_this = 250;
         struct Port *PortP;     /* pointer to the port structure */
         unsigned long flags;
@@ -151,16 +107,14 @@ int riotopen(struct tty_struct *tty, struct file *filp)
         tty->driver_data = NULL;
 
         SysPort = rio_minor(tty);
-        Modem = rio_ismodem(tty);
 
         if (p->RIOFailed) {
                 rio_dprintk(RIO_DEBUG_TTY, "System initialisation failed\n");
-                pseterr(ENXIO);
                 func_exit();
                 return -ENXIO;
         }
 
-        rio_dprintk(RIO_DEBUG_TTY, "port open SysPort %d (%s) (mapped:%d)\n", SysPort, Modem ? "Modem" : "tty", p->RIOPortp[SysPort]->Mapped);
+        rio_dprintk(RIO_DEBUG_TTY, "port open SysPort %d (mapped:%d)\n", SysPort, p->RIOPortp[SysPort]->Mapped);
 
         /*
          ** Validate that we have received a legitimate request.
@@ -170,7 +124,6 @@ int riotopen(struct tty_struct *tty, struct file *filp)
          */
         if (SysPort >= RIO_PORTS) {     /* out of range ? */
                 rio_dprintk(RIO_DEBUG_TTY, "Illegal port number %d\n", SysPort);
-                pseterr(ENXIO);
                 func_exit();
                 return -ENXIO;
         }
@@ -187,7 +140,6 @@ int riotopen(struct tty_struct *tty, struct file *filp)
                  */
                 rio_dprintk(RIO_DEBUG_TTY, "port not mapped into system\n");
                 func_exit();
-                pseterr(ENXIO);
                 return -ENXIO;
         }
 
@@ -209,7 +161,6 @@ int riotopen(struct tty_struct *tty, struct file *filp)
          */
         if ((PortP->HostP->Flags & RUN_STATE) != RC_RUNNING) {
                 rio_dprintk(RIO_DEBUG_TTY, "Host not running\n");
-                pseterr(ENXIO);
                 func_exit();
                 return -ENXIO;
         }
@@ -309,15 +260,12 @@ int riotopen(struct tty_struct *tty, struct file *filp)
                 /* PortP->gs.xmit_cnt = 0; */
 
                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-#ifdef NEED_THIS
-                ttyseth(PortP, tp, (struct old_sgttyb *) &default_sg);
-#endif
 
                 /* Someone explain to me why this delay/config is
                    here. If I read the docs correctly the "open"
                    command piggybacks the parameters immediately.
                    -- REW */
-                RIOParam(PortP, OPEN, Modem, OK_TO_SLEEP);      /* Open the port */
+                RIOParam(PortP, OPEN, 1, OK_TO_SLEEP);  /* Open the port */
                 rio_spin_lock_irqsave(&PortP->portSem, flags);
 
                 /*
@@ -325,20 +273,6 @@ int riotopen(struct tty_struct *tty, struct file *filp)
                  */
                 while (!(PortP->PortState & PORT_ISOPEN) && !p->RIOHalted) {
                         rio_dprintk(RIO_DEBUG_TTY, "Waiting for PORT_ISOPEN-currently %x\n", PortP->PortState);
-/*
-** 15.10.1998 ARG - ESIL 0759
-** (Part) fix for port being trashed when opened whilst RTA "disconnected"
-** Take out the limited wait - now wait for ever or until user
-** bangs us out.
-**
-                        if (repeat_this -- <= 0) {
-                                rio_dprint(RIO_DEBUG_TTY, ("Waiting for open to finish timed out.\n"));
-                                RIOPreemptiveCmd(p, PortP, FCLOSE ); 
-                                rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-                                return -EINTR;
-                        }
-**
-*/
                         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
                         if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) {
                                 rio_dprintk(RIO_DEBUG_TTY, "Waiting for open to finish broken by signal\n");
@@ -358,80 +292,61 @@ int riotopen(struct tty_struct *tty, struct file *filp)
                 }
                 rio_dprintk(RIO_DEBUG_TTY, "PORT_ISOPEN found\n");
         }
-#ifdef MODEM_SUPPORT
-        if (Modem) {
-                rio_dprintk(RIO_DEBUG_TTY, "Modem - test for carrier\n");
+        rio_dprintk(RIO_DEBUG_TTY, "Modem - test for carrier\n");
+        /*
+         ** ACTION
+         ** insert test for carrier here. -- ???
+         ** I already see that test here. What's the deal? -- REW
+         */
+        if ((PortP->gs.tty->termios->c_cflag & CLOCAL) || (PortP->ModemState & MSVR1_CD)) {
+                rio_dprintk(RIO_DEBUG_TTY, "open(%d) Modem carr on\n", SysPort);
                 /*
-                 ** ACTION
-                 ** insert test for carrier here. -- ???
-                 ** I already see that test here. What's the deal? -- REW
+                   tp->tm.c_state |= CARR_ON;
+                   wakeup((caddr_t) &tp->tm.c_canq);
                  */
-                if ((PortP->gs.tty->termios->c_cflag & CLOCAL) || (PortP->ModemState & MSVR1_CD)) {
-                        rio_dprintk(RIO_DEBUG_TTY, "open(%d) Modem carr on\n", SysPort);
+                PortP->State |= RIO_CARR_ON;
+                wake_up_interruptible(&PortP->gs.open_wait);
+        } else {        /* no carrier - wait for DCD */
                         /*
-                           tp->tm.c_state |= CARR_ON;
-                           wakeup((caddr_t) &tp->tm.c_canq);
-                         */
-                        PortP->State |= RIO_CARR_ON;
-                        wake_up_interruptible(&PortP->gs.open_wait);
-                } else {        /* no carrier - wait for DCD */
-
+                   while (!(PortP->gs.tty->termios->c_state & CARR_ON) &&
+                   !(filp->f_flags & O_NONBLOCK) && !p->RIOHalted )
+                 */
+                while (!(PortP->State & RIO_CARR_ON) && !(filp->f_flags & O_NONBLOCK) && !p->RIOHalted) {
+                                rio_dprintk(RIO_DEBUG_TTY, "open(%d) sleeping for carr on\n", SysPort);
                         /*
-                           while (!(PortP->gs.tty->termios->c_state & CARR_ON) &&
-                           !(filp->f_flags & O_NONBLOCK) && !p->RIOHalted )
+                           PortP->gs.tty->termios->c_state |= WOPEN;
                          */
-                        while (!(PortP->State & RIO_CARR_ON) && !(filp->f_flags & O_NONBLOCK) && !p->RIOHalted) {
-
-                                rio_dprintk(RIO_DEBUG_TTY, "open(%d) sleeping for carr on\n", SysPort);
+                        PortP->State |= RIO_WOPEN;
+                        rio_spin_unlock_irqrestore(&PortP->portSem, flags);
+                        if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) {
                                 /*
-                                   PortP->gs.tty->termios->c_state |= WOPEN;
+                                 ** ACTION: verify that this is a good thing
+                                 ** to do here. -- ???
+                                 ** I think it's OK. -- REW
                                  */
-                                PortP->State |= RIO_WOPEN;
+                                rio_dprintk(RIO_DEBUG_TTY, "open(%d) sleeping for carr broken by signal\n", SysPort);
+                                RIOPreemptiveCmd(p, PortP, FCLOSE);
+                                /*
+                                   tp->tm.c_state &= ~WOPEN;
+                                 */
+                                PortP->State &= ~RIO_WOPEN;
                                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-                                if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL)
-                                        {
-                                                /*
-                                                 ** ACTION: verify that this is a good thing
-                                                 ** to do here. -- ???
-                                                 ** I think it's OK. -- REW
-                                                 */
-                                                rio_dprintk(RIO_DEBUG_TTY, "open(%d) sleeping for carr broken by signal\n", SysPort);
-                                                RIOPreemptiveCmd(p, PortP, FCLOSE);
-                                                /*
-                                                   tp->tm.c_state &= ~WOPEN;
-                                                 */
-                                                PortP->State &= ~RIO_WOPEN;
-                                                rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-                                                func_exit();
-                                                return -EINTR;
-                                        }
+                                func_exit();
+                                return -EINTR;
                         }
-                        PortP->State &= ~RIO_WOPEN;
                 }
-                if (p->RIOHalted)
-                        goto bombout;
-                rio_dprintk(RIO_DEBUG_TTY, "Setting RIO_MOPEN\n");
-                PortP->State |= RIO_MOPEN;
-        } else
-#endif
-        {
-                /*
-                 ** ACTION
-                 ** Direct line open - force carrier (will probably mean
-                 ** that sleeping Modem line fubar)
-                 */
-                PortP->State |= RIO_LOPEN;
+                PortP->State &= ~RIO_WOPEN;
         }
+        if (p->RIOHalted)
+                goto bombout;
+        rio_dprintk(RIO_DEBUG_TTY, "Setting RIO_MOPEN\n");
+        PortP->State |= RIO_MOPEN;
 
-        if (p->RIOHalted) {
+        if (p->RIOHalted)
                 goto bombout;
-        }
 
         rio_dprintk(RIO_DEBUG_TTY, "high level open done\n");
 
-#ifdef STATS
-        PortP->Stat.OpenCnt++;
-#endif
         /*
          ** Count opens for port statistics reporting
          */
@@ -460,23 +375,21 @@ int riotclose(void *ptr)
         unsigned long end_time;
         struct tty_struct *tty;
         unsigned long flags;
-        int Modem;
         int rv = 0;
 
         rio_dprintk(RIO_DEBUG_TTY, "port close SysPort %d\n", PortP->PortNum);
 
         /* PortP = p->RIOPortp[SysPort]; */
-        rio_dprintk(RIO_DEBUG_TTY, "Port is at address 0x%x\n", (int) PortP);
+        rio_dprintk(RIO_DEBUG_TTY, "Port is at address %p\n", PortP);
         /* tp = PortP->TtyP; *//* Get tty */
         tty = PortP->gs.tty;
-        rio_dprintk(RIO_DEBUG_TTY, "TTY is at address 0x%x\n", (int) tty);
+        rio_dprintk(RIO_DEBUG_TTY, "TTY is at address %p\n", tty);
 
         if (PortP->gs.closing_wait)
                 end_time = jiffies + PortP->gs.closing_wait;
         else
                 end_time = jiffies + MAX_SCHEDULE_TIMEOUT;
 
-        Modem = rio_ismodem(tty);
         rio_spin_lock_irqsave(&PortP->portSem, flags);
 
         /*
@@ -500,7 +413,7 @@ int riotclose(void *ptr)
         /*
          ** clear the open bits for this device
          */
-        PortP->State &= (Modem ? ~RIO_MOPEN : ~RIO_LOPEN);
+        PortP->State &= ~RIO_MOPEN;
         PortP->State &= ~RIO_CARR_ON;
         PortP->ModemState &= ~MSVR1_CD;
         /*
@@ -536,7 +449,6 @@ int riotclose(void *ptr)
 
         if (!deleted)
                 while ((PortP->InUse != NOT_INUSE) && !p->RIOHalted && (PortP->TxBufferIn != PortP->TxBufferOut)) {
-                        cprintf("Need to flush the ttyport\n");
                         if (repeat_this-- <= 0) {
                                 rv = -EINTR;
                                 rio_dprintk(RIO_DEBUG_TTY, "Waiting for not idle closed broken by signal\n");
@@ -615,16 +527,13 @@ int riotclose(void *ptr)
 */
         PortP->Config &= ~(RIO_CTSFLOW | RIO_RTSFLOW);
 
-#ifdef STATS
-        PortP->Stat.CloseCnt++;
-#endif
         /*
          ** Count opens for port statistics reporting
          */
         if (PortP->statsGather)
                 PortP->closes++;
 
-      close_end:
+close_end:
         /* XXX: Why would a "DELETED" flag be reset here? I'd have
            thought that a "deleted" flag means that the port was
            permanently gone, but here we can make it reappear by it
@@ -640,8 +549,7 @@ int riotclose(void *ptr)
 
 
 
-static void RIOClearUp(PortP)
-struct Port *PortP;
+static void RIOClearUp(struct Port *PortP)
 {
         rio_dprintk(RIO_DEBUG_TTY, "RIOHalted set\n");
         PortP->Config = 0;      /* Direct semaphore */
@@ -668,7 +576,7 @@ struct Port *PortP;
 */
 int RIOShortCommand(struct rio_info *p, struct Port *PortP, int command, int len, int arg)
 {
-        PKT *PacketP;
+        struct PKT *PacketP;
         int retries = 20;       /* at 10 per second -> 2 seconds */
         unsigned long flags;
 
@@ -722,15 +630,15 @@ int RIOShortCommand(struct rio_info *p, struct Port *PortP, int command, int len
         /*
          ** set the command byte and the argument byte
          */
-        WBYTE(PacketP->data[0], command);
+        writeb(command, &PacketP->data[0]);
 
         if (len == 2)
-                WBYTE(PacketP->data[1], arg);
+                writeb(arg, &PacketP->data[1]);
 
         /*
          ** set the length of the packet and set the command bit.
          */
-        WBYTE(PacketP->len, PKT_CMD_BIT | len);
+        writeb(PKT_CMD_BIT | len, &PacketP->len);
 
         add_transmit(PortP);
         /*
diff --git a/drivers/char/rio/riotypes.h b/drivers/char/rio/riotypes.h
deleted file mode 100644
index 46084d5c7e..0000000000
--- a/drivers/char/rio/riotypes.h
+++ /dev/null
@@ -1,68 +0,0 @@
-/****************************************************************************
- *******                                                              *******
- *******                      R I O T Y P E S
- *******                                                              *******
- ****************************************************************************
-
- Author  : Jon Brawn
- Date    :
-
- *
- *  (C) 1990 - 2000 Specialix International Ltd., Byfleet, Surrey, UK.
- *
- *      This program is free software; you can redistribute it and/or modify
- *      it under the terms of the GNU General Public License as published by
- *      the Free Software Foundation; either version 2 of the License, or
- *      (at your option) any later version.
- *
- *      This program is distributed in the hope that it will be useful,
- *      but WITHOUT ANY WARRANTY; without even the implied warranty of
- *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *      GNU General Public License for more details.
- *
- *      You should have received a copy of the GNU General Public License
- *      along with this program; if not, write to the Free Software
- *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
- Version : 0.01
-
-
-                            Mods
- ----------------------------------------------------------------------------
-  Date     By                Description
- ----------------------------------------------------------------------------
-
- ***************************************************************************/
-
-#ifndef _riotypes_h
-#define _riotypes_h 1
-
-#ifdef SCCS_LABELS
-#ifndef lint
-/* static char *_rio_riotypes_h_sccs = "@(#)riotypes.h  1.10"; */
-#endif
-#endif
-
-typedef unsigned short NUMBER_ptr;
-typedef unsigned short WORD_ptr;
-typedef unsigned short BYTE_ptr;
-typedef unsigned short char_ptr;
-typedef unsigned short Channel_ptr;
-typedef unsigned short FREE_LIST_ptr_ptr;
-typedef unsigned short FREE_LIST_ptr;
-typedef unsigned short LPB_ptr;
-typedef unsigned short Process_ptr;
-typedef unsigned short PHB_ptr;
-typedef unsigned short PKT_ptr;
-typedef unsigned short PKT_ptr_ptr;
-typedef unsigned short Q_BUF_ptr;
-typedef unsigned short Q_BUF_ptr_ptr;
-typedef unsigned short ROUTE_STR_ptr;
-typedef unsigned short RUP_ptr;
-typedef unsigned short short_ptr;
-typedef unsigned short u_short_ptr;
-typedef unsigned short ushort_ptr;
-
-#endif                          /* __riotypes__ */
-
-/*********** end of file ***********/
diff --git a/drivers/char/rio/rom.h b/drivers/char/rio/rom.h
deleted file mode 100644
index 58a7843625..0000000000
--- a/drivers/char/rio/rom.h
+++ /dev/null
@@ -1,62 +0,0 @@
-/****************************************************************************
- *******                                                              *******
- *******                      R O M
- *******                                                              *******
- ****************************************************************************
-
- Author  : Ian Nandhra
- Date    :
-
- *
- *  (C) 1990 - 2000 Specialix International Ltd., Byfleet, Surrey, UK.
- *
- *      This program is free software; you can redistribute it and/or modify
- *      it under the terms of the GNU General Public License as published by
- *      the Free Software Foundation; either version 2 of the License, or
- *      (at your option) any later version.
- *
- *      This program is distributed in the hope that it will be useful,
- *      but WITHOUT ANY WARRANTY; without even the implied warranty of
- *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *      GNU General Public License for more details.
- *
- *      You should have received a copy of the GNU General Public License
- *      along with this program; if not, write to the Free Software
- *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
- Version : 0.01
-
-
-                            Mods
- ----------------------------------------------------------------------------
-  Date     By                Description
- ----------------------------------------------------------------------------
-
- ***************************************************************************/
-
-#ifndef _rom_h
-#define _rom_h 1
-
-#ifndef lint
-#ifdef SCCS
-static char *_rio_rom_h_sccs = "@(#)rom.h       1.1";
-#endif
-#endif
-
-typedef struct ROM ROM;
-struct ROM {
-        u_short slx;
-        char pcb_letter_rev;
-        char pcb_number_rev;
-        char serial[4];
-        char year;
-        char week;
-};
-
-#endif
-
-#define HOST_ROM    (ROM *) 0x7c00
-#define RTA_ROM     (ROM *) 0x7801
-#define ROM_LENGTH  0x20
-
-/*********** end of file ***********/
diff --git a/drivers/char/rio/rup.h b/drivers/char/rio/rup.h
index f74f67c6f7..4ae90cb207 100644
--- a/drivers/char/rio/rup.h
+++ b/drivers/char/rio/rup.h
@@ -37,14 +37,7 @@
 #ifndef _rup_h
 #define _rup_h 1
 
-#ifdef SCCS_LABELS
-#ifndef lint
-/* static char *_rio_rup_h_sccs = "@(#)rup.h    1.5"; */
-#endif
-#endif
-
 #define MAX_RUP          ((short) 16)
-
 #define PKTS_PER_RUP     ((short) 2)    /* They are always used in pairs */
 
 /*************************************************
@@ -60,15 +53,15 @@
 #define RUP_NO_OWNER             0xff   /* RUP not owned by any process */
 
 struct RUP {
-        PKT_ptr txpkt;          /* Outgoing packet */
-        PKT_ptr rxpkt;          /* Incoming packet */
-        WORD link;              /* Which link to send down? */
-        BYTE rup_dest_unit[2];  /* Destination unit */
-        WORD handshake;         /* For handshaking */
-        WORD timeout;           /* Timeout */
-        WORD status;            /* Status */
-        WORD txcontrol;         /* Transmit control */
-        WORD rxcontrol;         /* Receive control */
+        u16 txpkt;              /* Outgoing packet */
+        u16 rxpkt;              /* Incoming packet */
+        u16 link;               /* Which link to send down? */
+        u8 rup_dest_unit[2];    /* Destination unit */
+        u16 handshake;          /* For handshaking */
+        u16 timeout;            /* Timeout */
+        u16 status;             /* Status */
+        u16 txcontrol;          /* Transmit control */
+        u16 rxcontrol;          /* Receive control */
 };
 
 #endif
diff --git a/drivers/char/rio/sam.h b/drivers/char/rio/sam.h
deleted file mode 100644
index 6f754e1901..0000000000
--- a/drivers/char/rio/sam.h
+++ /dev/null
@@ -1,67 +0,0 @@
-/****************************************************************************
- *******                                                              *******
- *******                    S A M . H
- *******                                                              *******
- ****************************************************************************
-
- Author  : Ian Nandhra
- Date    :
-
- *
- *  (C) 1990 - 2000 Specialix International Ltd., Byfleet, Surrey, UK.
- *
- *      This program is free software; you can redistribute it and/or modify
- *      it under the terms of the GNU General Public License as published by
- *      the Free Software Foundation; either version 2 of the License, or
- *      (at your option) any later version.
- *
- *      This program is distributed in the hope that it will be useful,
- *      but WITHOUT ANY WARRANTY; without even the implied warranty of
- *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *      GNU General Public License for more details.
- *
- *      You should have received a copy of the GNU General Public License
- *      along with this program; if not, write to the Free Software
- *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
- Version : 0.01
-
-
-                            Mods
- ----------------------------------------------------------------------------
-  Date     By                Description
- ----------------------------------------------------------------------------
-
- ***************************************************************************/
-#ifndef _sam_h
-#define _sam_h 1
-
-#ifdef SCCS_LABELS
-#ifndef lint
-/* static char *_rio_sam_h_sccs = "@(#)sam.h    1.3"; */
-#endif
-#endif
-
-
-#define NUM_FREE_LIST_UNITS     500
-
-#ifndef FALSE
-#define FALSE (short)  0x00
-#endif
-#ifndef TRUE
-#define TRUE  (short)  !FALSE
-#endif
-
-#define TX    TRUE
-#define RX    FALSE
-
-
-typedef struct FREE_LIST FREE_LIST;
-struct FREE_LIST {
-        FREE_LIST_ptr next;
-        FREE_LIST_ptr prev;
-};
-
-
-#endif
-/*********** end of file ***********/
diff --git a/drivers/char/rio/space.h b/drivers/char/rio/space.h
deleted file mode 100644
index 1f12690f9d..0000000000
--- a/drivers/char/rio/space.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
-** -----------------------------------------------------------------------------
-**
-**  Perle Specialix driver for Linux
-**  Ported from existing RIO Driver for SCO sources.
- *
- *  (C) 1990 - 2000 Specialix International Ltd., Byfleet, Surrey, UK.
- *
- *      This program is free software; you can redistribute it and/or modify
- *      it under the terms of the GNU General Public License as published by
- *      the Free Software Foundation; either version 2 of the License, or
- *      (at your option) any later version.
- *
- *      This program is distributed in the hope that it will be useful,
- *      but WITHOUT ANY WARRANTY; without even the implied warranty of
- *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *      GNU General Public License for more details.
- *
- *      You should have received a copy of the GNU General Public License
- *      along with this program; if not, write to the Free Software
- *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-**
-**      Module          : space.h
-**      SID             : 1.2
-**      Last Modified   : 11/6/98 11:34:19
-**      Retrieved       : 11/6/98 11:34:22
-**
-**  ident @(#)space.h   1.2
-**
-** -----------------------------------------------------------------------------
-*/
-
-#ifndef __rio_space_h__
-#define __rio_space_h__
-
-#ifdef SCCS_LABELS
-static char *_space_h_sccs_ = "@(#)space.h      1.2";
-#endif
-
-extern int rio_cntls;
-extern int rio_bases[];
-extern int rio_limits[];
-extern int rio_vects[];
-
-#endif                          /* __rio_space_h__ */
diff --git a/drivers/char/rio/top.h b/drivers/char/rio/top.h
deleted file mode 100644
index d15a11dc4f..0000000000
--- a/drivers/char/rio/top.h
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
-** -----------------------------------------------------------------------------
-**
-**  Perle Specialix driver for Linux
-**  Ported from existing RIO Driver for SCO sources.
- *
- *  (C) 1990 - 2000 Specialix International Ltd., Byfleet, Surrey, UK.
- *
- *      This program is free software; you can redistribute it and/or modify
- *      it under the terms of the GNU General Public License as published by
- *      the Free Software Foundation; either version 2 of the License, or
- *      (at your option) any later version.
- *
- *      This program is distributed in the hope that it will be useful,
- *      but WITHOUT ANY WARRANTY; without even the implied warranty of
- *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *      GNU General Public License for more details.
- *
- *      You should have received a copy of the GNU General Public License
- *      along with this program; if not, write to the Free Software
- *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-**
-**      Module          : top.h
-**      SID             : 1.2
-**      Last Modified   : 11/6/98 11:34:19
-**      Retrieved       : 11/6/98 11:34:22
-**
-**  ident @(#)top.h     1.2
-**
-** -----------------------------------------------------------------------------
-*/
-
-#ifndef __rio_top_h__
-#define __rio_top_h__
-
-#ifdef SCCS_LABELS
-static char *_top_h_sccs_ = "@(#)top.h  1.2";
-#endif
-
-/*
-** Topology information
-*/
-struct Top {
-        uchar Unit;
-        uchar Link;
-};
-
-#endif                          /* __rio_top_h__ */
diff --git a/drivers/char/rio/typdef.h b/drivers/char/rio/typdef.h
deleted file mode 100644
index 185b889e15..0000000000
--- a/drivers/char/rio/typdef.h
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
-** -----------------------------------------------------------------------------
-**
-**  Perle Specialix driver for Linux
-**  Ported from existing RIO Driver for SCO sources.
- *
- *  (C) 1990 - 2000 Specialix International Ltd., Byfleet, Surrey, UK.
- *
- *      This program is free software; you can redistribute it and/or modify
- *      it under the terms of the GNU General Public License as published by
- *      the Free Software Foundation; either version 2 of the License, or
- *      (at your option) any later version.
- *
- *      This program is distributed in the hope that it will be useful,
- *      but WITHOUT ANY WARRANTY; without even the implied warranty of
- *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *      GNU General Public License for more details.
- *
- *      You should have received a copy of the GNU General Public License
- *      along with this program; if not, write to the Free Software
- *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-**
-**      Module          : typdef.h
-**      SID             : 1.2
-**      Last Modified   : 11/6/98 11:34:20
-**      Retrieved       : 11/6/98 11:34:22
-**
-**  ident @(#)typdef.h  1.2
-**
-** -----------------------------------------------------------------------------
-*/
-
-#ifndef __rio_typdef_h__
-#define __rio_typdef_h__
-
-#ifdef SCCS_LABELS
-static char *_typdef_h_sccs_ = "@(#)typdef.h    1.2";
-#endif
-
-#undef VPIX
-
-/*
-** IT IS REALLY, REALLY, IMPORTANT THAT BYTES ARE UNSIGNED!
-**
-** These types are ONLY to be used for refering to data structures
-** on the RIO Host card!
-*/
-typedef volatile unsigned char BYTE;
-typedef volatile unsigned short WORD;
-typedef volatile unsigned int DWORD;
-typedef volatile unsigned short RIOP;
-typedef volatile short NUMBER;
-
-
-/*
-** 27.01.199 ARG - mods to compile 'newutils' on LyxnOS -
-** These #defines are for the benefit of the 'libfuncs' library
-** only. They are not necessarily correct type mappings and
-** are here only to make the source compile.
-*/
-/* typedef unsigned int uint; */
-typedef unsigned long ulong_t;
-typedef unsigned short ushort_t;
-typedef unsigned char uchar_t;
-typedef unsigned char queue_t;
-typedef unsigned char mblk_t;
-typedef unsigned int paddr_t;
-typedef unsigned char uchar;
-
-#define TPNULL  ((ushort)(0x8000))
-
-
-/*
-** RIO structures defined in other include files.
-*/
-typedef struct PKT PKT;
-typedef struct LPB LPB;
-typedef struct RUP RUP;
-typedef struct Port Port;
-typedef struct DpRam DpRam;
-
-#endif                          /* __rio_typdef_h__ */
diff --git a/drivers/char/rio/unixrup.h b/drivers/char/rio/unixrup.h
index a126c7caba..4306e01dbf 100644
--- a/drivers/char/rio/unixrup.h
+++ b/drivers/char/rio/unixrup.h
@@ -45,9 +45,9 @@ struct UnixRup {
         struct CmdBlk *CmdsWaitingP;    /* Commands waiting to be done */
         struct CmdBlk *CmdPendingP;     /* The command currently being sent */
         struct RUP *RupP;       /* the Rup to send it to */
-        uint Id;                /* Id number */
-        uint BaseSysPort;       /* SysPort of first tty on this RTA */
-        uint ModTypes;          /* Modules on this RTA */
+        unsigned int Id;                /* Id number */
+        unsigned int BaseSysPort;       /* SysPort of first tty on this RTA */
+        unsigned int ModTypes;          /* Modules on this RTA */
         spinlock_t RupLock;     /* Lock structure for MPX */
         /*    struct lockb     RupLock; *//* Lock structure for MPX */
 };
diff --git a/drivers/char/ser_a2232.c b/drivers/char/ser_a2232.c
index fee68cc895..510bd3e0e8 100644
--- a/drivers/char/ser_a2232.c
+++ b/drivers/char/ser_a2232.c
@@ -97,7 +97,7 @@
 #include <asm/amigahw.h>
 #include <linux/zorro.h>
 #include <asm/irq.h>
-#include <asm/semaphore.h>
+#include <linux/mutex.h>
 
 #include <linux/delay.h>
 
@@ -654,7 +654,7 @@ static void a2232_init_portstructs(void)
                 port->gs.closing_wait = 30 * HZ;
                 port->gs.rd = &a2232_real_driver;
 #ifdef NEW_WRITE_LOCKING
-                init_MUTEX(&(port->gs.port_write_sem));
+                init_MUTEX(&(port->gs.port_write_mutex));
 #endif
                 init_waitqueue_head(&port->gs.open_wait);
                 init_waitqueue_head(&port->gs.close_wait);
diff --git a/drivers/char/snsc.c b/drivers/char/snsc.c
index 0e7d216e7e..b543821d8c 100644
--- a/drivers/char/snsc.c
+++ b/drivers/char/snsc.c
@@ -5,7 +5,7 @@
  * License.  See the file "COPYING" in the main directory of this archive
  * for more details.
  *
- * Copyright (C) 2004 Silicon Graphics, Inc. All rights reserved.
+ * Copyright (C) 2004, 2006 Silicon Graphics, Inc. All rights reserved.
  */
 
 /*
@@ -77,7 +77,7 @@ scdrv_open(struct inode *inode, struct file *file)
         scd = container_of(inode->i_cdev, struct sysctl_data_s, scd_cdev);
 
         /* allocate memory for subchannel data */
-        sd = kmalloc(sizeof (struct subch_data_s), GFP_KERNEL);
+        sd = kzalloc(sizeof (struct subch_data_s), GFP_KERNEL);
         if (sd == NULL) {
                 printk("%s: couldn't allocate subchannel data\n",
                        __FUNCTION__);
@@ -85,7 +85,6 @@ scdrv_open(struct inode *inode, struct file *file)
         }
 
         /* initialize subch_data_s fields */
-        memset(sd, 0, sizeof (struct subch_data_s));
         sd->sd_nasid = scd->scd_nasid;
         sd->sd_subch = ia64_sn_irtr_open(scd->scd_nasid);
 
@@ -394,7 +393,7 @@ scdrv_init(void)
                         sprintf(devnamep, "#%d", geo_slab(geoid));
 
                         /* allocate sysctl device data */
-                        scd = kmalloc(sizeof (struct sysctl_data_s),
+                        scd = kzalloc(sizeof (struct sysctl_data_s),
                                       GFP_KERNEL);
                         if (!scd) {
                                 printk("%s: failed to allocate device info"
@@ -402,7 +401,6 @@ scdrv_init(void)
                                        SYSCTL_BASENAME, devname);
                                 continue;
                         }
-                        memset(scd, 0, sizeof (struct sysctl_data_s));
 
                         /* initialize sysctl device data fields */
                         scd->scd_nasid = cnodeid_to_nasid(cnode);
diff --git a/drivers/char/snsc_event.c b/drivers/char/snsc_event.c
index a4fa507eed..e234d50e14 100644
--- a/drivers/char/snsc_event.c
+++ b/drivers/char/snsc_event.c
@@ -287,7 +287,7 @@ scdrv_event_init(struct sysctl_data_s *scd)
 {
         int rv;
 
-        event_sd = kmalloc(sizeof (struct subch_data_s), GFP_KERNEL);
+        event_sd = kzalloc(sizeof (struct subch_data_s), GFP_KERNEL);
         if (event_sd == NULL) {
                 printk(KERN_WARNING "%s: couldn't allocate subchannel info"
                        " for event monitoring\n", __FUNCTION__);
@@ -295,7 +295,6 @@ scdrv_event_init(struct sysctl_data_s *scd)
         }
 
         /* initialize subch_data_s fields */
-        memset(event_sd, 0, sizeof (struct subch_data_s));
         event_sd->sd_nasid = scd->scd_nasid;
         spin_lock_init(&event_sd->sd_rlock);
 
@@ -321,5 +320,3 @@ scdrv_event_init(struct sysctl_data_s *scd)
                 return;
         }
 }
-
-
diff --git a/drivers/char/stallion.c b/drivers/char/stallion.c
index bdaab69921..3f5d6077f3 100644
--- a/drivers/char/stallion.c
+++ b/drivers/char/stallion.c
@@ -148,7 +148,6 @@ static struct tty_driver	*stl_serial;
  *      is already swapping a shared buffer won't make things any worse.
  */
 static char                     *stl_tmpwritebuf;
-static DECLARE_MUTEX(stl_tmpwritesem);
 
 /*
  *      Define a local default termios struct. All ports will be created
diff --git a/drivers/char/sx.c b/drivers/char/sx.c
index a6b4f02bdc..3b47472302 100644
--- a/drivers/char/sx.c
+++ b/drivers/char/sx.c
@@ -2318,7 +2318,7 @@ static int sx_init_portstructs (int nboards, int nports)
                         port->board = board;
                         port->gs.rd = &sx_real_driver;
 #ifdef NEW_WRITE_LOCKING
-                        port->gs.port_write_sem = MUTEX;
+                        port->gs.port_write_mutex = MUTEX;
 #endif
                         port->gs.driver_lock = SPIN_LOCK_UNLOCKED;
                         /*
diff --git a/drivers/char/synclink.c b/drivers/char/synclink.c
index ede688a4e1..d68be61f0a 100644
--- a/drivers/char/synclink.c
+++ b/drivers/char/synclink.c
@@ -7770,7 +7770,7 @@ static int hdlcdev_attach(struct net_device *dev, unsigned short encoding,
         }
 
         info->params.encoding = new_encoding;
-        info->params.crc_type = new_crctype;;
+        info->params.crc_type = new_crctype;
 
         /* if network interface up, reprogram hardware */
         if (info->netcount)
diff --git a/drivers/char/synclink_gt.c b/drivers/char/synclink_gt.c
index b046390cd2..738ec2f4e5 100644
--- a/drivers/char/synclink_gt.c
+++ b/drivers/char/synclink_gt.c
@@ -1365,7 +1365,7 @@ static int hdlcdev_attach(struct net_device *dev, unsigned short encoding,
         }
 
         info->params.encoding = new_encoding;
-        info->params.crc_type = new_crctype;;
+        info->params.crc_type = new_crctype;
 
         /* if network interface up, reprogram hardware */
         if (info->netcount)
diff --git a/drivers/char/synclinkmp.c b/drivers/char/synclinkmp.c
index 960adb256f..8587401311 100644
--- a/drivers/char/synclinkmp.c
+++ b/drivers/char/synclinkmp.c
@@ -1650,7 +1650,7 @@ static int hdlcdev_attach(struct net_device *dev, unsigned short encoding,
         }
 
         info->params.encoding = new_encoding;
-        info->params.crc_type = new_crctype;;
+        info->params.crc_type = new_crctype;
 
         /* if network interface up, reprogram hardware */
         if (info->netcount)
diff --git a/drivers/char/toshiba.c b/drivers/char/toshiba.c
index 0c6f521abd..e2fb234dee 100644
--- a/drivers/char/toshiba.c
+++ b/drivers/char/toshiba.c
@@ -355,14 +355,14 @@ static void tosh_set_fn_port(void)
 /*
  * Get the machine identification number of the current model
  */
-static int tosh_get_machine_id(void)
+static int tosh_get_machine_id(void __iomem *bios)
 {
         int id;
         SMMRegisters regs;
         unsigned short bx,cx;
         unsigned long address;
 
-        id = (0x100*(int) isa_readb(0xffffe))+((int) isa_readb(0xffffa));
+        id = (0x100*(int) readb(bios+0xfffe))+((int) readb(bios+0xfffa));
 
         /* do we have a SCTTable machine identication number on our hands */
 
@@ -388,12 +388,12 @@ static int tosh_get_machine_id(void)
 
                 /* now twiddle with our pointer a bit */
 
-                address = 0x000f0000+bx;
-                cx = isa_readw(address);
-                address = 0x000f0009+bx+cx;
-                cx = isa_readw(address);
-                address = 0x000f000a+cx;
-                cx = isa_readw(address);
+                address = bx;
+                cx = readw(bios + address);
+                address = 9+bx+cx;
+                cx = readw(bios + address);
+                address = 0xa+cx;
+                cx = readw(bios + address);
 
                 /* now construct our machine identification number */
 
@@ -416,13 +416,18 @@ static int tosh_probe(void)
         int i,major,minor,day,year,month,flag;
         unsigned char signature[7] = { 0x54,0x4f,0x53,0x48,0x49,0x42,0x41 };
         SMMRegisters regs;
+        void __iomem *bios = ioremap(0xf0000, 0x10000);
+
+        if (!bios)
+                return -ENOMEM;
 
         /* extra sanity check for the string "TOSHIBA" in the BIOS because
            some machines that are not Toshiba's pass the next test */
 
         for (i=0;i<7;i++) {
-                if (isa_readb(0xfe010+i)!=signature[i]) {
+                if (readb(bios+0xe010+i)!=signature[i]) {
                         printk("toshiba: not a supported Toshiba laptop\n");
+                        iounmap(bios);
                         return -ENODEV;
                 }
         }
@@ -438,6 +443,7 @@ static int tosh_probe(void)
 
         if ((flag==1) || ((regs.eax & 0xff00)==0x8600)) {
                 printk("toshiba: not a supported Toshiba laptop\n");
+                iounmap(bios);
                 return -ENODEV;
         }
 
@@ -447,19 +453,19 @@ static int tosh_probe(void)
 
         /* next get the machine ID of the current laptop */
 
-        tosh_id = tosh_get_machine_id();
+        tosh_id = tosh_get_machine_id(bios);
 
         /* get the BIOS version */
 
-        major = isa_readb(0xfe009)-'0';
-        minor = ((isa_readb(0xfe00b)-'0')*10)+(isa_readb(0xfe00c)-'0');
+        major = readb(bios+0xe009)-'0';
+        minor = ((readb(bios+0xe00b)-'0')*10)+(readb(bios+0xe00c)-'0');
         tosh_bios = (major*0x100)+minor;
 
         /* get the BIOS date */
 
-        day = ((isa_readb(0xffff5)-'0')*10)+(isa_readb(0xffff6)-'0');
-        month = ((isa_readb(0xffff8)-'0')*10)+(isa_readb(0xffff9)-'0');
-        year = ((isa_readb(0xffffb)-'0')*10)+(isa_readb(0xffffc)-'0');
+        day = ((readb(bios+0xfff5)-'0')*10)+(readb(bios+0xfff6)-'0');
+        month = ((readb(bios+0xfff8)-'0')*10)+(readb(bios+0xfff9)-'0');
+        year = ((readb(bios+0xfffb)-'0')*10)+(readb(bios+0xfffc)-'0');
         tosh_date = (((year-90) & 0x1f)<<10) | ((month & 0xf)<<6)
                 | ((day & 0x1f)<<1);
 
@@ -476,6 +482,8 @@ static int tosh_probe(void)
         if ((tosh_id==0xfccb) || (tosh_id==0xfccc))
                 tosh_fan = 1;
 
+        iounmap(bios);
+
         return 0;
 }
 
diff --git a/drivers/char/tty_io.c b/drivers/char/tty_io.c
index 53d3d06655..76592ee1fb 100644
--- a/drivers/char/tty_io.c
+++ b/drivers/char/tty_io.c
@@ -130,7 +130,7 @@ LIST_HEAD(tty_drivers);			/* linked list of tty drivers */
 
 /* Semaphore to protect creating and releasing a tty. This is shared with
    vt.c for deeply disgusting hack reasons */
-DECLARE_MUTEX(tty_sem);
+DEFINE_MUTEX(tty_mutex);
 
 #ifdef CONFIG_UNIX98_PTYS
 extern struct tty_driver *ptm_driver;   /* Unix98 pty masters; for /dev/ptmx */
@@ -1188,11 +1188,11 @@ void disassociate_ctty(int on_exit)
 
         lock_kernel();
 
-        down(&tty_sem);
+        mutex_lock(&tty_mutex);
         tty = current->signal->tty;
         if (tty) {
                 tty_pgrp = tty->pgrp;
-                up(&tty_sem);
+                mutex_unlock(&tty_mutex);
                 if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY)
                         tty_vhangup(tty);
         } else {
@@ -1200,7 +1200,7 @@ void disassociate_ctty(int on_exit)
                         kill_pg(current->signal->tty_old_pgrp, SIGHUP, on_exit);
                         kill_pg(current->signal->tty_old_pgrp, SIGCONT, on_exit);
                 }
-                up(&tty_sem);
+                mutex_unlock(&tty_mutex);
                 unlock_kernel();        
                 return;
         }
@@ -1211,7 +1211,7 @@ void disassociate_ctty(int on_exit)
         }
 
         /* Must lock changes to tty_old_pgrp */
-        down(&tty_sem);
+        mutex_lock(&tty_mutex);
         current->signal->tty_old_pgrp = 0;
         tty->session = 0;
         tty->pgrp = -1;
@@ -1222,7 +1222,7 @@ void disassociate_ctty(int on_exit)
                 p->signal->tty = NULL;
         } while_each_task_pid(current->signal->session, PIDTYPE_SID, p);
         read_unlock(&tasklist_lock);
-        up(&tty_sem);
+        mutex_unlock(&tty_mutex);
         unlock_kernel();
 }
 
@@ -1306,7 +1306,7 @@ static inline ssize_t do_tty_write(
         ssize_t ret = 0, written = 0;
         unsigned int chunk;
         
-        if (down_interruptible(&tty->atomic_write)) {
+        if (mutex_lock_interruptible(&tty->atomic_write_lock)) {
                 return -ERESTARTSYS;
         }
 
@@ -1329,7 +1329,7 @@ static inline ssize_t do_tty_write(
         if (count < chunk)
                 chunk = count;
 
-        /* write_buf/write_cnt is protected by the atomic_write semaphore */
+        /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
         if (tty->write_cnt < chunk) {
                 unsigned char *buf;
 
@@ -1338,7 +1338,7 @@ static inline ssize_t do_tty_write(
 
                 buf = kmalloc(chunk, GFP_KERNEL);
                 if (!buf) {
-                        up(&tty->atomic_write);
+                        mutex_unlock(&tty->atomic_write_lock);
                         return -ENOMEM;
                 }
                 kfree(tty->write_buf);
@@ -1374,7 +1374,7 @@ static inline ssize_t do_tty_write(
                 inode->i_mtime = current_fs_time(inode->i_sb);
                 ret = written;
         }
-        up(&tty->atomic_write);
+        mutex_unlock(&tty->atomic_write_lock);
         return ret;
 }
 
@@ -1442,8 +1442,8 @@ static inline void tty_line_name(struct tty_driver *driver, int index, char *p)
 
 /*
  * WSH 06/09/97: Rewritten to remove races and properly clean up after a
- * failed open.  The new code protects the open with a semaphore, so it's
- * really quite straightforward.  The semaphore locking can probably be
+ * failed open.  The new code protects the open with a mutex, so it's
+ * really quite straightforward.  The mutex locking can probably be
  * relaxed for the (most common) case of reopening a tty.
  */
 static int init_dev(struct tty_driver *driver, int idx,
@@ -1640,7 +1640,7 @@ fast_track:
 success:
         *ret_tty = tty;
         
-        /* All paths come through here to release the semaphore */
+        /* All paths come through here to release the mutex */
 end_init:
         return retval;
 
@@ -1837,7 +1837,7 @@ static void release_dev(struct file * filp)
                 /* Guard against races with tty->count changes elsewhere and
                    opens on /dev/tty */
                    
-                down(&tty_sem);
+                mutex_lock(&tty_mutex);
                 tty_closing = tty->count <= 1;
                 o_tty_closing = o_tty &&
                         (o_tty->count <= (pty_master ? 1 : 0));
@@ -1868,7 +1868,7 @@ static void release_dev(struct file * filp)
 
                 printk(KERN_WARNING "release_dev: %s: read/write wait queue "
                                     "active!\n", tty_name(tty, buf));
-                up(&tty_sem);
+                mutex_unlock(&tty_mutex);
                 schedule();
         }       
 
@@ -1934,7 +1934,7 @@ static void release_dev(struct file * filp)
                 read_unlock(&tasklist_lock);
         }
 
-        up(&tty_sem);
+        mutex_unlock(&tty_mutex);
 
         /* check whether both sides are closing ... */
         if (!tty_closing || (o_tty && !o_tty_closing))
@@ -2040,11 +2040,11 @@ retry_open:
         index  = -1;
         retval = 0;
         
-        down(&tty_sem);
+        mutex_lock(&tty_mutex);
 
         if (device == MKDEV(TTYAUX_MAJOR,0)) {
                 if (!current->signal->tty) {
-                        up(&tty_sem);
+                        mutex_unlock(&tty_mutex);
                         return -ENXIO;
                 }
                 driver = current->signal->tty->driver;
@@ -2070,18 +2070,18 @@ retry_open:
                         noctty = 1;
                         goto got_driver;
                 }
-                up(&tty_sem);
+                mutex_unlock(&tty_mutex);
                 return -ENODEV;
         }
 
         driver = get_tty_driver(device, &index);
         if (!driver) {
-                up(&tty_sem);
+                mutex_unlock(&tty_mutex);
                 return -ENODEV;
         }
 got_driver:
         retval = init_dev(driver, index, &tty);
-        up(&tty_sem);
+        mutex_unlock(&tty_mutex);
         if (retval)
                 return retval;
 
@@ -2167,9 +2167,9 @@ static int ptmx_open(struct inode * inode, struct file * filp)
         }
         up(&allocated_ptys_lock);
 
-        down(&tty_sem);
+        mutex_lock(&tty_mutex);
         retval = init_dev(ptm_driver, index, &tty);
-        up(&tty_sem);
+        mutex_unlock(&tty_mutex);
         
         if (retval)
                 goto out;
@@ -2915,8 +2915,8 @@ static void initialize_tty_struct(struct tty_struct *tty)
         init_waitqueue_head(&tty->write_wait);
         init_waitqueue_head(&tty->read_wait);
         INIT_WORK(&tty->hangup_work, do_tty_hangup, tty);
-        sema_init(&tty->atomic_read, 1);
-        sema_init(&tty->atomic_write, 1);
+        mutex_init(&tty->atomic_read_lock);
+        mutex_init(&tty->atomic_write_lock);
         spin_lock_init(&tty->read_lock);
         INIT_LIST_HEAD(&tty->tty_files);
         INIT_WORK(&tty->SAK_work, NULL, NULL);
diff --git a/drivers/char/vme_scc.c b/drivers/char/vme_scc.c
index d9325281e4..fd00822ac1 100644
--- a/drivers/char/vme_scc.c
+++ b/drivers/char/vme_scc.c
@@ -184,7 +184,7 @@ static void scc_init_portstructs(void)
                 port->gs.closing_wait = 30 * HZ;
                 port->gs.rd = &scc_real_driver;
 #ifdef NEW_WRITE_LOCKING
-                port->gs.port_write_sem = MUTEX;
+                port->gs.port_write_mutex = MUTEX;
 #endif
                 init_waitqueue_head(&port->gs.open_wait);
                 init_waitqueue_head(&port->gs.close_wait);
diff --git a/drivers/char/vt.c b/drivers/char/vt.c
index 0900d1dbee..ca4844c527 100644
--- a/drivers/char/vt.c
+++ b/drivers/char/vt.c
@@ -2489,7 +2489,7 @@ static int con_open(struct tty_struct *tty, struct file *filp)
 }
 
 /*
- * We take tty_sem in here to prevent another thread from coming in via init_dev
+ * We take tty_mutex in here to prevent another thread from coming in via init_dev
  * and taking a ref against the tty while we're in the process of forgetting
  * about it and cleaning things up.
  *
@@ -2497,7 +2497,7 @@ static int con_open(struct tty_struct *tty, struct file *filp)
  */
 static void con_close(struct tty_struct *tty, struct file *filp)
 {
-        down(&tty_sem);
+        mutex_lock(&tty_mutex);
         acquire_console_sem();
         if (tty && tty->count == 1) {
                 struct vc_data *vc = tty->driver_data;
@@ -2507,15 +2507,15 @@ static void con_close(struct tty_struct *tty, struct file *filp)
                 tty->driver_data = NULL;
                 release_console_sem();
                 vcs_remove_devfs(tty);
-                up(&tty_sem);
+                mutex_unlock(&tty_mutex);
                 /*
-                 * tty_sem is released, but we still hold BKL, so there is
+                 * tty_mutex is released, but we still hold BKL, so there is
                  * still exclusion against init_dev()
                  */
                 return;
         }
         release_console_sem();
-        up(&tty_sem);
+        mutex_unlock(&tty_mutex);
 }
 
 static void vc_init(struct vc_data *vc, unsigned int rows,
@@ -2869,9 +2869,9 @@ void unblank_screen(void)
 }
 
 /*
- * We defer the timer blanking to work queue so it can take the console semaphore
+ * We defer the timer blanking to work queue so it can take the console mutex
  * (console operations can still happen at irq time, but only from printk which
- * has the console semaphore. Not perfect yet, but better than no locking
+ * has the console mutex. Not perfect yet, but better than no locking
  */
 static void blank_screen_t(unsigned long dummy)
 {
@@ -3234,6 +3234,14 @@ void vcs_scr_writew(struct vc_data *vc, u16 val, u16 *org)
         }
 }
 
+int is_console_suspend_safe(void)
+{
+        /* It is unsafe to suspend devices while X has control of the
+         * hardware. Make sure we are running on a kernel-controlled console.
+         */
+        return vc_cons[fg_console].d->vc_mode == KD_TEXT;
+}
+
 /*
  *      Visible symbols for modules
  */
diff --git a/drivers/char/watchdog/pcwd_usb.c b/drivers/char/watchdog/pcwd_usb.c
index 1533f56baa..2700c5c45b 100644
--- a/drivers/char/watchdog/pcwd_usb.c
+++ b/drivers/char/watchdog/pcwd_usb.c
@@ -42,6 +42,7 @@
 #include <linux/completion.h>
 #include <asm/uaccess.h>
 #include <linux/usb.h>
+#include <linux/mutex.h>
 
 
 #ifdef CONFIG_USB_DEBUG
@@ -143,7 +144,7 @@ struct usb_pcwd_private {
 static struct usb_pcwd_private *usb_pcwd_device;
 
 /* prevent races between open() and disconnect() */
-static DECLARE_MUTEX (disconnect_sem);
+static DEFINE_MUTEX(disconnect_mutex);
 
 /* local function prototypes */
 static int usb_pcwd_probe       (struct usb_interface *interface, const struct usb_device_id *id);
@@ -723,7 +724,7 @@ static void usb_pcwd_disconnect(struct usb_interface *interface)
         struct usb_pcwd_private *usb_pcwd;
 
         /* prevent races with open() */
-        down (&disconnect_sem);
+        mutex_lock(&disconnect_mutex);
 
         usb_pcwd = usb_get_intfdata (interface);
         usb_set_intfdata (interface, NULL);
@@ -749,7 +750,7 @@ static void usb_pcwd_disconnect(struct usb_interface *interface)
 
         cards_found--;
 
-        up (&disconnect_sem);
+        mutex_unlock(&disconnect_mutex);
 
         printk(KERN_INFO PFX "USB PC Watchdog disconnected\n");
 }
diff --git a/drivers/connector/connector.c b/drivers/connector/connector.c
index d7125f4d91..35897079a7 100644
--- a/drivers/connector/connector.c
+++ b/drivers/connector/connector.c
@@ -26,6 +26,7 @@
 #include <linux/netlink.h>
 #include <linux/moduleparam.h>
 #include <linux/connector.h>
+#include <linux/mutex.h>
 
 #include <net/sock.h>
 
@@ -41,7 +42,7 @@ module_param(cn_val, uint, 0);
 MODULE_PARM_DESC(cn_idx, "Connector's main device idx.");
 MODULE_PARM_DESC(cn_val, "Connector's main device val.");
 
-static DECLARE_MUTEX(notify_lock);
+static DEFINE_MUTEX(notify_lock);
 static LIST_HEAD(notify_list);
 
 static struct cn_dev cdev;
@@ -260,7 +261,7 @@ static void cn_notify(struct cb_id *id, u32 notify_event)
 {
         struct cn_ctl_entry *ent;
 
-        down(&notify_lock);
+        mutex_lock(&notify_lock);
         list_for_each_entry(ent, &notify_list, notify_entry) {
                 int i;
                 struct cn_notify_req *req;
@@ -293,7 +294,7 @@ static void cn_notify(struct cb_id *id, u32 notify_event)
                         cn_netlink_send(&m, ctl->group, GFP_KERNEL);
                 }
         }
-        up(&notify_lock);
+        mutex_unlock(&notify_lock);
 }
 
 /*
@@ -407,14 +408,14 @@ static void cn_callback(void *data)
         if (ctl->group == 0) {
                 struct cn_ctl_entry *n;
 
-                down(&notify_lock);
+                mutex_lock(&notify_lock);
                 list_for_each_entry_safe(ent, n, &notify_list, notify_entry) {
                         if (cn_ctl_msg_equals(ent->msg, ctl)) {
                                 list_del(&ent->notify_entry);
                                 kfree(ent);
                         }
                 }
-                up(&notify_lock);
+                mutex_unlock(&notify_lock);
 
                 return;
         }
@@ -429,9 +430,9 @@ static void cn_callback(void *data)
 
         memcpy(ent->msg, ctl, size - sizeof(*ent));
 
-        down(&notify_lock);
+        mutex_lock(&notify_lock);
         list_add(&ent->notify_entry, &notify_list);
-        up(&notify_lock);
+        mutex_unlock(&notify_lock);
 }
 
 static int __init cn_init(void)
diff --git a/drivers/firmware/dcdbas.c b/drivers/firmware/dcdbas.c
index 3a4e5c5b4e..d6543fc4a9 100644
--- a/drivers/firmware/dcdbas.c
+++ b/drivers/firmware/dcdbas.c
@@ -33,6 +33,7 @@
 #include <linux/spinlock.h>
 #include <linux/string.h>
 #include <linux/types.h>
+#include <linux/mutex.h>
 #include <asm/io.h>
 #include <asm/semaphore.h>
 
@@ -48,7 +49,7 @@ static u8 *smi_data_buf;
 static dma_addr_t smi_data_buf_handle;
 static unsigned long smi_data_buf_size;
 static u32 smi_data_buf_phys_addr;
-static DECLARE_MUTEX(smi_data_lock);
+static DEFINE_MUTEX(smi_data_lock);
 
 static unsigned int host_control_action;
 static unsigned int host_control_smi_type;
@@ -139,9 +140,9 @@ static ssize_t smi_data_buf_size_store(struct device *dev,
         buf_size = simple_strtoul(buf, NULL, 10);
 
         /* make sure SMI data buffer is at least buf_size */
-        down(&smi_data_lock);
+        mutex_lock(&smi_data_lock);
         ret = smi_data_buf_realloc(buf_size);
-        up(&smi_data_lock);
+        mutex_unlock(&smi_data_lock);
         if (ret)
                 return ret;
 
@@ -154,7 +155,7 @@ static ssize_t smi_data_read(struct kobject *kobj, char *buf, loff_t pos,
         size_t max_read;
         ssize_t ret;
 
-        down(&smi_data_lock);
+        mutex_lock(&smi_data_lock);
 
         if (pos >= smi_data_buf_size) {
                 ret = 0;
@@ -165,7 +166,7 @@ static ssize_t smi_data_read(struct kobject *kobj, char *buf, loff_t pos,
         ret = min(max_read, count);
         memcpy(buf, smi_data_buf + pos, ret);
 out:
-        up(&smi_data_lock);
+        mutex_unlock(&smi_data_lock);
         return ret;
 }
 
@@ -174,7 +175,7 @@ static ssize_t smi_data_write(struct kobject *kobj, char *buf, loff_t pos,
 {
         ssize_t ret;
 
-        down(&smi_data_lock);
+        mutex_lock(&smi_data_lock);
 
         ret = smi_data_buf_realloc(pos + count);
         if (ret)
@@ -183,7 +184,7 @@ static ssize_t smi_data_write(struct kobject *kobj, char *buf, loff_t pos,
         memcpy(smi_data_buf + pos, buf, count);
         ret = count;
 out:
-        up(&smi_data_lock);
+        mutex_unlock(&smi_data_lock);
         return ret;
 }
 
@@ -201,9 +202,9 @@ static ssize_t host_control_action_store(struct device *dev,
         ssize_t ret;
 
         /* make sure buffer is available for host control command */
-        down(&smi_data_lock);
+        mutex_lock(&smi_data_lock);
         ret = smi_data_buf_realloc(sizeof(struct apm_cmd));
-        up(&smi_data_lock);
+        mutex_unlock(&smi_data_lock);
         if (ret)
                 return ret;
 
@@ -302,7 +303,7 @@ static ssize_t smi_request_store(struct device *dev,
         unsigned long val = simple_strtoul(buf, NULL, 10);
         ssize_t ret;
 
-        down(&smi_data_lock);
+        mutex_lock(&smi_data_lock);
 
         if (smi_data_buf_size < sizeof(struct smi_cmd)) {
                 ret = -ENODEV;
@@ -334,7 +335,7 @@ static ssize_t smi_request_store(struct device *dev,
         }
 
 out:
-        up(&smi_data_lock);
+        mutex_unlock(&smi_data_lock);
         return ret;
 }
 
diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
index 7230d4e081..99cdc612d2 100644
--- a/drivers/hwmon/Kconfig
+++ b/drivers/hwmon/Kconfig
@@ -406,13 +406,14 @@ config SENSORS_W83L785TS
           will be called w83l785ts.
 
 config SENSORS_W83627HF
-        tristate "Winbond W83627HF, W83627THF, W83637HF, W83697HF"
-        depends on HWMON && I2C && EXPERIMENTAL
+        tristate "Winbond W83627HF, W83627THF, W83637HF, W83687THF, W83697HF"
+        depends on HWMON && I2C
         select I2C_ISA
         select HWMON_VID
         help
           If you say yes here you get support for the Winbond W836X7 series
-          of sensor chips: the W83627HF, W83627THF, W83637HF, and the W83697HF
+          of sensor chips: the W83627HF, W83627THF, W83637HF, W83687THF and
+          W83697HF.
 
           This driver can also be built as a module.  If so, the module
           will be called w83627hf.
diff --git a/drivers/hwmon/adm1021.c b/drivers/hwmon/adm1021.c
index 665612729c..2b6e74dd4a 100644
--- a/drivers/hwmon/adm1021.c
+++ b/drivers/hwmon/adm1021.c
@@ -26,6 +26,7 @@
 #include <linux/i2c.h>
 #include <linux/hwmon.h>
 #include <linux/err.h>
+#include <linux/mutex.h>
 
 
 /* Addresses to scan */
@@ -92,7 +93,7 @@ struct adm1021_data {
         struct class_device *class_dev;
         enum chips type;
 
-        struct semaphore update_lock;
+        struct mutex update_lock;
         char valid;             /* !=0 if following fields are valid */
         unsigned long last_updated;     /* In jiffies */
 
@@ -162,10 +163,10 @@ static ssize_t set_##value(struct device *dev, struct device_attribute *attr, co
         struct adm1021_data *data = i2c_get_clientdata(client); \
         int temp = simple_strtoul(buf, NULL, 10);               \
                                                                 \
-        down(&data->update_lock);                               \
+        mutex_lock(&data->update_lock);                         \
         data->value = TEMP_TO_REG(temp);                        \
         adm1021_write_value(client, reg, data->value);          \
-        up(&data->update_lock);                                 \
+        mutex_unlock(&data->update_lock);                       \
         return count;                                           \
 }
 set(temp_max, ADM1021_REG_TOS_W);
@@ -275,7 +276,7 @@ static int adm1021_detect(struct i2c_adapter *adapter, int address, int kind)
         strlcpy(new_client->name, type_name, I2C_NAME_SIZE);
         data->type = kind;
         data->valid = 0;
-        init_MUTEX(&data->update_lock);
+        mutex_init(&data->update_lock);
 
         /* Tell the I2C layer a new client has arrived */
         if ((err = i2c_attach_client(new_client)))
@@ -351,7 +352,7 @@ static struct adm1021_data *adm1021_update_device(struct device *dev)
         struct i2c_client *client = to_i2c_client(dev);
         struct adm1021_data *data = i2c_get_clientdata(client);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
             || !data->valid) {
@@ -375,7 +376,7 @@ static struct adm1021_data *adm1021_update_device(struct device *dev)
                 data->valid = 1;
         }
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return data;
 }
diff --git a/drivers/hwmon/adm1025.c b/drivers/hwmon/adm1025.c
index 9331c56d2b..a4c859c9fb 100644
--- a/drivers/hwmon/adm1025.c
+++ b/drivers/hwmon/adm1025.c
@@ -53,6 +53,7 @@
 #include <linux/hwmon.h>
 #include <linux/hwmon-vid.h>
 #include <linux/err.h>
+#include <linux/mutex.h>
 
 /*
  * Addresses to scan
@@ -133,7 +134,7 @@ static struct i2c_driver adm1025_driver = {
 struct adm1025_data {
         struct i2c_client client;
         struct class_device *class_dev;
-        struct semaphore update_lock;
+        struct mutex update_lock;
         char valid; /* zero until following fields are valid */
         unsigned long last_updated; /* in jiffies */
 
@@ -207,11 +208,11 @@ static ssize_t set_in##offset##_min(struct device *dev, struct device_attribute
         struct adm1025_data *data = i2c_get_clientdata(client); \
         long val = simple_strtol(buf, NULL, 10); \
  \
-        down(&data->update_lock); \
+        mutex_lock(&data->update_lock); \
         data->in_min[offset] = IN_TO_REG(val, in_scale[offset]); \
         i2c_smbus_write_byte_data(client, ADM1025_REG_IN_MIN(offset), \
                                   data->in_min[offset]); \
-        up(&data->update_lock); \
+        mutex_unlock(&data->update_lock); \
         return count; \
 } \
 static ssize_t set_in##offset##_max(struct device *dev, struct device_attribute *attr, const char *buf, \
@@ -221,11 +222,11 @@ static ssize_t set_in##offset##_max(struct device *dev, struct device_attribute
         struct adm1025_data *data = i2c_get_clientdata(client); \
         long val = simple_strtol(buf, NULL, 10); \
  \
-        down(&data->update_lock); \
+        mutex_lock(&data->update_lock); \
         data->in_max[offset] = IN_TO_REG(val, in_scale[offset]); \
         i2c_smbus_write_byte_data(client, ADM1025_REG_IN_MAX(offset), \
                                   data->in_max[offset]); \
-        up(&data->update_lock); \
+        mutex_unlock(&data->update_lock); \
         return count; \
 } \
 static DEVICE_ATTR(in##offset##_min, S_IWUSR | S_IRUGO, \
@@ -247,11 +248,11 @@ static ssize_t set_temp##offset##_min(struct device *dev, struct device_attribut
         struct adm1025_data *data = i2c_get_clientdata(client); \
         long val = simple_strtol(buf, NULL, 10); \
  \
-        down(&data->update_lock); \
+        mutex_lock(&data->update_lock); \
         data->temp_min[offset-1] = TEMP_TO_REG(val); \
         i2c_smbus_write_byte_data(client, ADM1025_REG_TEMP_LOW(offset-1), \
                                   data->temp_min[offset-1]); \
-        up(&data->update_lock); \
+        mutex_unlock(&data->update_lock); \
         return count; \
 } \
 static ssize_t set_temp##offset##_max(struct device *dev, struct device_attribute *attr, const char *buf, \
@@ -261,11 +262,11 @@ static ssize_t set_temp##offset##_max(struct device *dev, struct device_attribut
         struct adm1025_data *data = i2c_get_clientdata(client); \
         long val = simple_strtol(buf, NULL, 10); \
  \
-        down(&data->update_lock); \
+        mutex_lock(&data->update_lock); \
         data->temp_max[offset-1] = TEMP_TO_REG(val); \
         i2c_smbus_write_byte_data(client, ADM1025_REG_TEMP_HIGH(offset-1), \
                                   data->temp_max[offset-1]); \
-        up(&data->update_lock); \
+        mutex_unlock(&data->update_lock); \
         return count; \
 } \
 static DEVICE_ATTR(temp##offset##_min, S_IWUSR | S_IRUGO, \
@@ -404,7 +405,7 @@ static int adm1025_detect(struct i2c_adapter *adapter, int address, int kind)
         /* We can fill in the remaining client fields */
         strlcpy(new_client->name, name, I2C_NAME_SIZE);
         data->valid = 0;
-        init_MUTEX(&data->update_lock);
+        mutex_init(&data->update_lock);
 
         /* Tell the I2C layer a new client has arrived */
         if ((err = i2c_attach_client(new_client)))
@@ -523,7 +524,7 @@ static struct adm1025_data *adm1025_update_device(struct device *dev)
         struct i2c_client *client = to_i2c_client(dev);
         struct adm1025_data *data = i2c_get_clientdata(client);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if (time_after(jiffies, data->last_updated + HZ * 2) || !data->valid) {
                 int i;
@@ -558,7 +559,7 @@ static struct adm1025_data *adm1025_update_device(struct device *dev)
                 data->valid = 1;
         }
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return data;
 }
diff --git a/drivers/hwmon/adm1026.c b/drivers/hwmon/adm1026.c
index fefe6e74fd..6d4f8b8d35 100644
--- a/drivers/hwmon/adm1026.c
+++ b/drivers/hwmon/adm1026.c
@@ -32,6 +32,7 @@
 #include <linux/hwmon-sysfs.h>
 #include <linux/hwmon-vid.h>
 #include <linux/err.h>
+#include <linux/mutex.h>
 
 /* Addresses to scan */
 static unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END };
@@ -260,10 +261,10 @@ struct pwm_data {
 struct adm1026_data {
         struct i2c_client client;
         struct class_device *class_dev;
-        struct semaphore lock;
+        struct mutex lock;
         enum chips type;
 
-        struct semaphore update_lock;
+        struct mutex update_lock;
         int valid;              /* !=0 if following fields are valid */
         unsigned long last_reading;     /* In jiffies */
         unsigned long last_config;      /* In jiffies */
@@ -298,9 +299,8 @@ static int adm1026_attach_adapter(struct i2c_adapter *adapter);
 static int adm1026_detect(struct i2c_adapter *adapter, int address,
         int kind);
 static int adm1026_detach_client(struct i2c_client *client);
-static int adm1026_read_value(struct i2c_client *client, u8 register);
-static int adm1026_write_value(struct i2c_client *client, u8 register,
-        int value); 
+static int adm1026_read_value(struct i2c_client *client, u8 reg);
+static int adm1026_write_value(struct i2c_client *client, u8 reg, int value);
 static void adm1026_print_gpio(struct i2c_client *client);
 static void adm1026_fixup_gpio(struct i2c_client *client); 
 static struct adm1026_data *adm1026_update_device(struct device *dev);
@@ -575,7 +575,7 @@ static struct adm1026_data *adm1026_update_device(struct device *dev)
         int i;
         long value, alarms, gpio;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         if (!data->valid
             || time_after(jiffies, data->last_reading + ADM1026_DATA_INTERVAL)) {
                 /* Things that change quickly */
@@ -710,7 +710,7 @@ static struct adm1026_data *adm1026_update_device(struct device *dev)
         dev_dbg(&client->dev, "Setting VID from GPIO11-15.\n");
         data->vid = (data->gpio >> 11) & 0x1f;
         data->valid = 1;
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return data;
 }
 
@@ -739,10 +739,10 @@ static ssize_t set_in_min(struct device *dev, struct device_attribute *attr,
         struct adm1026_data *data = i2c_get_clientdata(client);
         int val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->in_min[nr] = INS_TO_REG(nr, val);
         adm1026_write_value(client, ADM1026_REG_IN_MIN[nr], data->in_min[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count; 
 }
 static ssize_t show_in_max(struct device *dev, struct device_attribute *attr,
@@ -762,10 +762,10 @@ static ssize_t set_in_max(struct device *dev, struct device_attribute *attr,
         struct adm1026_data *data = i2c_get_clientdata(client);
         int val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->in_max[nr] = INS_TO_REG(nr, val);
         adm1026_write_value(client, ADM1026_REG_IN_MAX[nr], data->in_max[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -813,10 +813,10 @@ static ssize_t set_in16_min(struct device *dev, struct device_attribute *attr, c
         struct adm1026_data *data = i2c_get_clientdata(client);
         int val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->in_min[16] = INS_TO_REG(16, val + NEG12_OFFSET);
         adm1026_write_value(client, ADM1026_REG_IN_MIN[16], data->in_min[16]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count; 
 }
 static ssize_t show_in16_max(struct device *dev, struct device_attribute *attr, char *buf)
@@ -831,10 +831,10 @@ static ssize_t set_in16_max(struct device *dev, struct device_attribute *attr, c
         struct adm1026_data *data = i2c_get_clientdata(client);
         int val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->in_max[16] = INS_TO_REG(16, val+NEG12_OFFSET);
         adm1026_write_value(client, ADM1026_REG_IN_MAX[16], data->in_max[16]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -874,11 +874,11 @@ static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
         struct adm1026_data *data = i2c_get_clientdata(client);
         int val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->fan_min[nr] = FAN_TO_REG(val, data->fan_div[nr]);
         adm1026_write_value(client, ADM1026_REG_FAN_MIN(nr),
                 data->fan_min[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -939,7 +939,7 @@ static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
         if (new_div == 0) {
                 return -EINVAL;
         }
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         orig_div = data->fan_div[nr];
         data->fan_div[nr] = DIV_FROM_REG(new_div);
 
@@ -958,7 +958,7 @@ static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
         if (data->fan_div[nr] != orig_div) {
                 fixup_fan_min(dev,nr,orig_div);
         }
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -1001,11 +1001,11 @@ static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr,
         struct adm1026_data *data = i2c_get_clientdata(client);
         int val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp_min[nr] = TEMP_TO_REG(val);
         adm1026_write_value(client, ADM1026_REG_TEMP_MIN[nr],
                 data->temp_min[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 static ssize_t show_temp_max(struct device *dev, struct device_attribute *attr,
@@ -1025,11 +1025,11 @@ static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
         struct adm1026_data *data = i2c_get_clientdata(client);
         int val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp_max[nr] = TEMP_TO_REG(val);
         adm1026_write_value(client, ADM1026_REG_TEMP_MAX[nr],
                 data->temp_max[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -1064,11 +1064,11 @@ static ssize_t set_temp_offset(struct device *dev,
         struct adm1026_data *data = i2c_get_clientdata(client);
         int val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp_offset[nr] = TEMP_TO_REG(val);
         adm1026_write_value(client, ADM1026_REG_TEMP_OFFSET[nr],
                 data->temp_offset[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -1115,11 +1115,11 @@ static ssize_t set_temp_auto_point1_temp(struct device *dev,
         struct adm1026_data *data = i2c_get_clientdata(client);
         int val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp_tmin[nr] = TEMP_TO_REG(val);
         adm1026_write_value(client, ADM1026_REG_TEMP_TMIN[nr],
                 data->temp_tmin[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -1150,11 +1150,11 @@ static ssize_t set_temp_crit_enable(struct device *dev,
         int val = simple_strtol(buf, NULL, 10);
 
         if ((val == 1) || (val==0)) {
-                down(&data->update_lock);
+                mutex_lock(&data->update_lock);
                 data->config1 = (data->config1 & ~CFG1_THERM_HOT) | (val << 4);
                 adm1026_write_value(client, ADM1026_REG_CONFIG1, 
                         data->config1);
-                up(&data->update_lock);
+                mutex_unlock(&data->update_lock);
         }
         return count;
 }
@@ -1184,11 +1184,11 @@ static ssize_t set_temp_crit(struct device *dev, struct device_attribute *attr,
         struct adm1026_data *data = i2c_get_clientdata(client);
         int val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp_crit[nr] = TEMP_TO_REG(val);
         adm1026_write_value(client, ADM1026_REG_TEMP_THERM[nr],
                 data->temp_crit[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -1212,10 +1212,10 @@ static ssize_t set_analog_out_reg(struct device *dev, struct device_attribute *a
         struct adm1026_data *data = i2c_get_clientdata(client);
         int val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->analog_out = DAC_TO_REG(val);
         adm1026_write_value(client, ADM1026_REG_DAC, data->analog_out);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -1267,7 +1267,7 @@ static ssize_t set_alarm_mask(struct device *dev, struct device_attribute *attr,
         int val = simple_strtol(buf, NULL, 10);
         unsigned long mask;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->alarm_mask = val & 0x7fffffff;
         mask = data->alarm_mask
                 | (data->gpio_mask & 0x10000 ? 0x80000000 : 0);
@@ -1282,7 +1282,7 @@ static ssize_t set_alarm_mask(struct device *dev, struct device_attribute *attr,
         mask >>= 8;
         adm1026_write_value(client, ADM1026_REG_MASK4,
                 mask & 0xff);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -1303,7 +1303,7 @@ static ssize_t set_gpio(struct device *dev, struct device_attribute *attr, const
         int val = simple_strtol(buf, NULL, 10);
         long   gpio;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->gpio = val & 0x1ffff;
         gpio = data->gpio;
         adm1026_write_value(client, ADM1026_REG_GPIO_STATUS_0_7,gpio & 0xff);
@@ -1311,7 +1311,7 @@ static ssize_t set_gpio(struct device *dev, struct device_attribute *attr, const
         adm1026_write_value(client, ADM1026_REG_GPIO_STATUS_8_15,gpio & 0xff);
         gpio = ((gpio >> 1) & 0x80) | (data->alarms >> 24 & 0x7f);
         adm1026_write_value(client, ADM1026_REG_STATUS4,gpio & 0xff);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -1331,7 +1331,7 @@ static ssize_t set_gpio_mask(struct device *dev, struct device_attribute *attr,
         int val = simple_strtol(buf, NULL, 10);
         long   mask;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->gpio_mask = val & 0x1ffff;
         mask = data->gpio_mask;
         adm1026_write_value(client, ADM1026_REG_GPIO_MASK_0_7,mask & 0xff);
@@ -1339,7 +1339,7 @@ static ssize_t set_gpio_mask(struct device *dev, struct device_attribute *attr,
         adm1026_write_value(client, ADM1026_REG_GPIO_MASK_8_15,mask & 0xff);
         mask = ((mask >> 1) & 0x80) | (data->alarm_mask >> 24 & 0x7f);
         adm1026_write_value(client, ADM1026_REG_MASK1,mask & 0xff);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -1359,10 +1359,10 @@ static ssize_t set_pwm_reg(struct device *dev, struct device_attribute *attr, co
         if (data->pwm1.enable == 1) {
                 int val = simple_strtol(buf, NULL, 10);
 
-                down(&data->update_lock);
+                mutex_lock(&data->update_lock);
                 data->pwm1.pwm = PWM_TO_REG(val);
                 adm1026_write_value(client, ADM1026_REG_PWM, data->pwm1.pwm);
-                up(&data->update_lock);
+                mutex_unlock(&data->update_lock);
         }
         return count;
 }
@@ -1378,14 +1378,14 @@ static ssize_t set_auto_pwm_min(struct device *dev, struct device_attribute *att
         struct adm1026_data *data = i2c_get_clientdata(client);
         int val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->pwm1.auto_pwm_min = SENSORS_LIMIT(val,0,255);
         if (data->pwm1.enable == 2) { /* apply immediately */
                 data->pwm1.pwm = PWM_TO_REG((data->pwm1.pwm & 0x0f) |
                         PWM_MIN_TO_REG(data->pwm1.auto_pwm_min)); 
                 adm1026_write_value(client, ADM1026_REG_PWM, data->pwm1.pwm);
         }
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 static ssize_t show_auto_pwm_max(struct device *dev, struct device_attribute *attr, char *buf)
@@ -1406,7 +1406,7 @@ static ssize_t set_pwm_enable(struct device *dev, struct device_attribute *attr,
         int     old_enable;
 
         if ((val >= 0) && (val < 3)) {
-                down(&data->update_lock);
+                mutex_lock(&data->update_lock);
                 old_enable = data->pwm1.enable;
                 data->pwm1.enable = val;
                 data->config1 = (data->config1 & ~CFG1_PWM_AFC)
@@ -1424,7 +1424,7 @@ static ssize_t set_pwm_enable(struct device *dev, struct device_attribute *attr,
                         adm1026_write_value(client, ADM1026_REG_PWM, 
                                 data->pwm1.pwm);
                 }
-                up(&data->update_lock);
+                mutex_unlock(&data->update_lock);
         }
         return count;
 }
@@ -1541,7 +1541,7 @@ static int adm1026_detect(struct i2c_adapter *adapter, int address,
         /* Fill in the remaining client fields */
         data->type = kind;
         data->valid = 0;
-        init_MUTEX(&data->update_lock);
+        mutex_init(&data->update_lock);
 
         /* Tell the I2C layer a new client has arrived */
         if ((err = i2c_attach_client(new_client)))
diff --git a/drivers/hwmon/adm1031.c b/drivers/hwmon/adm1031.c
index d063979660..3bf2da621a 100644
--- a/drivers/hwmon/adm1031.c
+++ b/drivers/hwmon/adm1031.c
@@ -28,6 +28,7 @@
 #include <linux/i2c.h>
 #include <linux/hwmon.h>
 #include <linux/err.h>
+#include <linux/mutex.h>
 
 /* Following macros takes channel parameter starting from 0 to 2 */
 #define ADM1031_REG_FAN_SPEED(nr)       (0x08 + (nr))
@@ -70,7 +71,7 @@ typedef u8 auto_chan_table_t[8][2];
 struct adm1031_data {
         struct i2c_client client;
         struct class_device *class_dev;
-        struct semaphore update_lock;
+        struct mutex update_lock;
         int chip_type;
         char valid;             /* !=0 if following fields are valid */
         unsigned long last_updated;     /* In jiffies */
@@ -262,10 +263,10 @@ set_fan_auto_channel(struct device *dev, const char *buf, size_t count, int nr)
 
         old_fan_mode = data->conf1;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         
         if ((ret = get_fan_auto_nearest(data, nr, val, data->conf1, &reg))) {
-                up(&data->update_lock);
+                mutex_unlock(&data->update_lock);
                 return ret;
         }
         if (((data->conf1 = FAN_CHAN_TO_REG(reg, data->conf1)) & ADM1031_CONF1_AUTO_MODE) ^ 
@@ -288,7 +289,7 @@ set_fan_auto_channel(struct device *dev, const char *buf, size_t count, int nr)
         }
         data->conf1 = FAN_CHAN_TO_REG(reg, data->conf1);
         adm1031_write_value(client, ADM1031_REG_CONF1, data->conf1);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -329,11 +330,11 @@ set_auto_temp_min(struct device *dev, const char *buf, size_t count, int nr)
         struct adm1031_data *data = i2c_get_clientdata(client);
         int val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->auto_temp[nr] = AUTO_TEMP_MIN_TO_REG(val, data->auto_temp[nr]);
         adm1031_write_value(client, ADM1031_REG_AUTO_TEMP(nr),
                             data->auto_temp[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 static ssize_t show_auto_temp_max(struct device *dev, char *buf, int nr)
@@ -349,11 +350,11 @@ set_auto_temp_max(struct device *dev, const char *buf, size_t count, int nr)
         struct adm1031_data *data = i2c_get_clientdata(client);
         int val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp_max[nr] = AUTO_TEMP_MAX_TO_REG(val, data->auto_temp[nr], data->pwm[nr]);
         adm1031_write_value(client, ADM1031_REG_AUTO_TEMP(nr),
                             data->temp_max[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -405,11 +406,11 @@ set_pwm(struct device *dev, const char *buf, size_t count, int nr)
         int val = simple_strtol(buf, NULL, 10);
         int reg;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         if ((data->conf1 & ADM1031_CONF1_AUTO_MODE) && 
             (((val>>4) & 0xf) != 5)) {
                 /* In automatic mode, the only PWM accepted is 33% */
-                up(&data->update_lock);
+                mutex_unlock(&data->update_lock);
                 return -EINVAL;
         }
         data->pwm[nr] = PWM_TO_REG(val);
@@ -417,7 +418,7 @@ set_pwm(struct device *dev, const char *buf, size_t count, int nr)
         adm1031_write_value(client, ADM1031_REG_PWM,
                             nr ? ((data->pwm[nr] << 4) & 0xf0) | (reg & 0xf)
                             : (data->pwm[nr] & 0xf) | (reg & 0xf0));
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -511,7 +512,7 @@ set_fan_min(struct device *dev, const char *buf, size_t count, int nr)
         struct adm1031_data *data = i2c_get_clientdata(client);
         int val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         if (val) {
                 data->fan_min[nr] = 
                         FAN_TO_REG(val, FAN_DIV_FROM_REG(data->fan_div[nr]));
@@ -519,7 +520,7 @@ set_fan_min(struct device *dev, const char *buf, size_t count, int nr)
                 data->fan_min[nr] = 0xff;
         }
         adm1031_write_value(client, ADM1031_REG_FAN_MIN(nr), data->fan_min[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 static ssize_t
@@ -540,7 +541,7 @@ set_fan_div(struct device *dev, const char *buf, size_t count, int nr)
         if (tmp == 0xff)
                 return -EINVAL;
         
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         old_div = FAN_DIV_FROM_REG(data->fan_div[nr]);
         data->fan_div[nr] = (tmp & 0xC0) | (0x3f & data->fan_div[nr]);
         new_min = data->fan_min[nr] * old_div / 
@@ -553,7 +554,7 @@ set_fan_div(struct device *dev, const char *buf, size_t count, int nr)
                             data->fan_div[nr]);
         adm1031_write_value(client, ADM1031_REG_FAN_MIN(nr), 
                             data->fan_min[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -627,11 +628,11 @@ set_temp_min(struct device *dev, const char *buf, size_t count, int nr)
 
         val = simple_strtol(buf, NULL, 10);
         val = SENSORS_LIMIT(val, -55000, nr == 0 ? 127750 : 127875);
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp_min[nr] = TEMP_TO_REG(val);
         adm1031_write_value(client, ADM1031_REG_TEMP_MIN(nr),
                             data->temp_min[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 static ssize_t
@@ -643,11 +644,11 @@ set_temp_max(struct device *dev, const char *buf, size_t count, int nr)
 
         val = simple_strtol(buf, NULL, 10);
         val = SENSORS_LIMIT(val, -55000, nr == 0 ? 127750 : 127875);
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp_max[nr] = TEMP_TO_REG(val);
         adm1031_write_value(client, ADM1031_REG_TEMP_MAX(nr),
                             data->temp_max[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 static ssize_t
@@ -659,11 +660,11 @@ set_temp_crit(struct device *dev, const char *buf, size_t count, int nr)
 
         val = simple_strtol(buf, NULL, 10);
         val = SENSORS_LIMIT(val, -55000, nr == 0 ? 127750 : 127875);
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp_crit[nr] = TEMP_TO_REG(val);
         adm1031_write_value(client, ADM1031_REG_TEMP_CRIT(nr),
                             data->temp_crit[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -778,7 +779,7 @@ static int adm1031_detect(struct i2c_adapter *adapter, int address, int kind)
 
         strlcpy(new_client->name, name, I2C_NAME_SIZE);
         data->valid = 0;
-        init_MUTEX(&data->update_lock);
+        mutex_init(&data->update_lock);
 
         /* Tell the I2C layer a new client has arrived */
         if ((err = i2c_attach_client(new_client)))
@@ -891,7 +892,7 @@ static struct adm1031_data *adm1031_update_device(struct device *dev)
         struct adm1031_data *data = i2c_get_clientdata(client);
         int chan;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
             || !data->valid) {
@@ -965,7 +966,7 @@ static struct adm1031_data *adm1031_update_device(struct device *dev)
                 data->valid = 1;
         }
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return data;
 }
diff --git a/drivers/hwmon/adm9240.c b/drivers/hwmon/adm9240.c
index 5ddc22fea4..43f6991b58 100644
--- a/drivers/hwmon/adm9240.c
+++ b/drivers/hwmon/adm9240.c
@@ -49,6 +49,7 @@
 #include <linux/hwmon.h>
 #include <linux/hwmon-vid.h>
 #include <linux/err.h>
+#include <linux/mutex.h>
 
 /* Addresses to scan */
 static unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, 0x2f,
@@ -150,7 +151,7 @@ struct adm9240_data {
         enum chips type;
         struct i2c_client client;
         struct class_device *class_dev;
-        struct semaphore update_lock;
+        struct mutex update_lock;
         char valid;
         unsigned long last_updated_measure;
         unsigned long last_updated_config;
@@ -195,11 +196,11 @@ static ssize_t set_max(struct device *dev, struct device_attribute *devattr,
         struct adm9240_data *data = i2c_get_clientdata(client);
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp_max[attr->index] = TEMP_TO_REG(val);
         i2c_smbus_write_byte_data(client, ADM9240_REG_TEMP_MAX(attr->index),
                         data->temp_max[attr->index]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -246,11 +247,11 @@ static ssize_t set_in_min(struct device *dev,
         struct adm9240_data *data = i2c_get_clientdata(client);
         unsigned long val = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->in_min[attr->index] = IN_TO_REG(val, attr->index);
         i2c_smbus_write_byte_data(client, ADM9240_REG_IN_MIN(attr->index),
                         data->in_min[attr->index]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -263,11 +264,11 @@ static ssize_t set_in_max(struct device *dev,
         struct adm9240_data *data = i2c_get_clientdata(client);
         unsigned long val = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->in_max[attr->index] = IN_TO_REG(val, attr->index);
         i2c_smbus_write_byte_data(client, ADM9240_REG_IN_MAX(attr->index),
                         data->in_max[attr->index]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -350,7 +351,7 @@ static ssize_t set_fan_min(struct device *dev,
         int nr = attr->index;
         u8 new_div;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if (!val) {
                 data->fan_min[nr] = 255;
@@ -390,7 +391,7 @@ static ssize_t set_fan_min(struct device *dev,
         i2c_smbus_write_byte_data(client, ADM9240_REG_FAN_MIN(nr),
                         data->fan_min[nr]);
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -439,10 +440,10 @@ static ssize_t set_aout(struct device *dev,
         struct adm9240_data *data = i2c_get_clientdata(client);
         unsigned long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->aout = AOUT_TO_REG(val);
         i2c_smbus_write_byte_data(client, ADM9240_REG_ANALOG_OUT, data->aout);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 static DEVICE_ATTR(aout_output, S_IRUGO | S_IWUSR, show_aout, set_aout);
@@ -539,7 +540,7 @@ static int adm9240_detect(struct i2c_adapter *adapter, int address, int kind)
         /* fill in the remaining client fields and attach */
         strlcpy(new_client->name, name, I2C_NAME_SIZE);
         data->type = kind;
-        init_MUTEX(&data->update_lock);
+        mutex_init(&data->update_lock);
 
         if ((err = i2c_attach_client(new_client)))
                 goto exit_free;
@@ -691,7 +692,7 @@ static struct adm9240_data *adm9240_update_device(struct device *dev)
         struct adm9240_data *data = i2c_get_clientdata(client);
         int i;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         /* minimum measurement cycle: 1.75 seconds */
         if (time_after(jiffies, data->last_updated_measure + (HZ * 7 / 4))
@@ -771,7 +772,7 @@ static struct adm9240_data *adm9240_update_device(struct device *dev)
                 data->last_updated_config = jiffies;
                 data->valid = 1;
         }
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return data;
 }
 
diff --git a/drivers/hwmon/asb100.c b/drivers/hwmon/asb100.c
index ae9de63cf2..65b2709f75 100644
--- a/drivers/hwmon/asb100.c
+++ b/drivers/hwmon/asb100.c
@@ -44,6 +44,7 @@
 #include <linux/err.h>
 #include <linux/init.h>
 #include <linux/jiffies.h>
+#include <linux/mutex.h>
 #include "lm75.h"
 
 /*
@@ -182,10 +183,10 @@ static u8 DIV_TO_REG(long val)
 struct asb100_data {
         struct i2c_client client;
         struct class_device *class_dev;
-        struct semaphore lock;
+        struct mutex lock;
         enum chips type;
 
-        struct semaphore update_lock;
+        struct mutex update_lock;
         unsigned long last_updated;     /* In jiffies */
 
         /* array of 2 pointers to subclients */
@@ -245,11 +246,11 @@ static ssize_t set_in_##reg(struct device *dev, const char *buf, \
         struct asb100_data *data = i2c_get_clientdata(client); \
         unsigned long val = simple_strtoul(buf, NULL, 10); \
  \
-        down(&data->update_lock); \
+        mutex_lock(&data->update_lock); \
         data->in_##reg[nr] = IN_TO_REG(val); \
         asb100_write_value(client, ASB100_REG_IN_##REG(nr), \
                 data->in_##reg[nr]); \
-        up(&data->update_lock); \
+        mutex_unlock(&data->update_lock); \
         return count; \
 }
 
@@ -331,10 +332,10 @@ static ssize_t set_fan_min(struct device *dev, const char *buf,
         struct asb100_data *data = i2c_get_clientdata(client);
         u32 val = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
         asb100_write_value(client, ASB100_REG_FAN_MIN(nr), data->fan_min[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -351,7 +352,7 @@ static ssize_t set_fan_div(struct device *dev, const char *buf,
         unsigned long val = simple_strtoul(buf, NULL, 10);
         int reg;
         
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         min = FAN_FROM_REG(data->fan_min[nr],
                         DIV_FROM_REG(data->fan_div[nr]));
@@ -381,7 +382,7 @@ static ssize_t set_fan_div(struct device *dev, const char *buf,
                 FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
         asb100_write_value(client, ASB100_REG_FAN_MIN(nr), data->fan_min[nr]);
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return count;
 }
@@ -461,7 +462,7 @@ static ssize_t set_##reg(struct device *dev, const char *buf, \
         struct asb100_data *data = i2c_get_clientdata(client); \
         unsigned long val = simple_strtoul(buf, NULL, 10); \
  \
-        down(&data->update_lock); \
+        mutex_lock(&data->update_lock); \
         switch (nr) { \
         case 1: case 2: \
                 data->reg[nr] = LM75_TEMP_TO_REG(val); \
@@ -472,7 +473,7 @@ static ssize_t set_##reg(struct device *dev, const char *buf, \
         } \
         asb100_write_value(client, ASB100_REG_TEMP_##REG(nr+1), \
                         data->reg[nr]); \
-        up(&data->update_lock); \
+        mutex_unlock(&data->update_lock); \
         return count; \
 }
 
@@ -574,11 +575,11 @@ static ssize_t set_pwm1(struct device *dev, struct device_attribute *attr, const
         struct asb100_data *data = i2c_get_clientdata(client);
         unsigned long val = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->pwm &= 0x80; /* keep the enable bit */
         data->pwm |= (0x0f & ASB100_PWM_TO_REG(val));
         asb100_write_value(client, ASB100_REG_PWM1, data->pwm);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -595,11 +596,11 @@ static ssize_t set_pwm_enable1(struct device *dev, struct device_attribute *attr
         struct asb100_data *data = i2c_get_clientdata(client);
         unsigned long val = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->pwm &= 0x0f; /* keep the duty cycle bits */
         data->pwm |= (val ? 0x80 : 0x00);
         asb100_write_value(client, ASB100_REG_PWM1, data->pwm);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -729,7 +730,7 @@ static int asb100_detect(struct i2c_adapter *adapter, int address, int kind)
         }
 
         new_client = &data->client;
-        init_MUTEX(&data->lock);
+        mutex_init(&data->lock);
         i2c_set_clientdata(new_client, data);
         new_client->addr = address;
         new_client->adapter = adapter;
@@ -789,7 +790,7 @@ static int asb100_detect(struct i2c_adapter *adapter, int address, int kind)
         data->type = kind;
 
         data->valid = 0;
-        init_MUTEX(&data->update_lock);
+        mutex_init(&data->update_lock);
 
         /* Tell the I2C layer a new client has arrived */
         if ((err = i2c_attach_client(new_client)))
@@ -885,7 +886,7 @@ static int asb100_read_value(struct i2c_client *client, u16 reg)
         struct i2c_client *cl;
         int res, bank;
 
-        down(&data->lock);
+        mutex_lock(&data->lock);
 
         bank = (reg >> 8) & 0x0f;
         if (bank > 2)
@@ -919,7 +920,7 @@ static int asb100_read_value(struct i2c_client *client, u16 reg)
         if (bank > 2)
                 i2c_smbus_write_byte_data(client, ASB100_REG_BANK, 0);
 
-        up(&data->lock);
+        mutex_unlock(&data->lock);
 
         return res;
 }
@@ -930,7 +931,7 @@ static void asb100_write_value(struct i2c_client *client, u16 reg, u16 value)
         struct i2c_client *cl;
         int bank;
 
-        down(&data->lock);
+        mutex_lock(&data->lock);
 
         bank = (reg >> 8) & 0x0f;
         if (bank > 2)
@@ -960,7 +961,7 @@ static void asb100_write_value(struct i2c_client *client, u16 reg, u16 value)
         if (bank > 2)
                 i2c_smbus_write_byte_data(client, ASB100_REG_BANK, 0);
 
-        up(&data->lock);
+        mutex_unlock(&data->lock);
 }
 
 static void asb100_init_client(struct i2c_client *client)
@@ -984,7 +985,7 @@ static struct asb100_data *asb100_update_device(struct device *dev)
         struct asb100_data *data = i2c_get_clientdata(client);
         int i;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
                 || !data->valid) {
@@ -1042,7 +1043,7 @@ static struct asb100_data *asb100_update_device(struct device *dev)
                 dev_dbg(&client->dev, "... device update complete\n");
         }
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return data;
 }
diff --git a/drivers/hwmon/atxp1.c b/drivers/hwmon/atxp1.c
index b0c490073c..728a1e8b91 100644
--- a/drivers/hwmon/atxp1.c
+++ b/drivers/hwmon/atxp1.c
@@ -26,6 +26,7 @@
 #include <linux/hwmon.h>
 #include <linux/hwmon-vid.h>
 #include <linux/err.h>
+#include <linux/mutex.h>
 
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("System voltages control via Attansic ATXP1");
@@ -60,7 +61,7 @@ static struct i2c_driver atxp1_driver = {
 struct atxp1_data {
         struct i2c_client client;
         struct class_device *class_dev;
-        struct semaphore update_lock;
+        struct mutex update_lock;
         unsigned long last_updated;
         u8 valid;
         struct {
@@ -80,7 +81,7 @@ static struct atxp1_data * atxp1_update_device(struct device *dev)
         client = to_i2c_client(dev);
         data = i2c_get_clientdata(client);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {
 
@@ -93,7 +94,7 @@ static struct atxp1_data * atxp1_update_device(struct device *dev)
                 data->valid = 1;
         }
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return(data);
 }
@@ -309,7 +310,7 @@ static int atxp1_detect(struct i2c_adapter *adapter, int address, int kind)
 
         data->valid = 0;
 
-        init_MUTEX(&data->update_lock);
+        mutex_init(&data->update_lock);
 
         err = i2c_attach_client(new_client);
 
diff --git a/drivers/hwmon/ds1621.c b/drivers/hwmon/ds1621.c
index 203f9c7abb..478eb4bb85 100644
--- a/drivers/hwmon/ds1621.c
+++ b/drivers/hwmon/ds1621.c
@@ -28,6 +28,7 @@
 #include <linux/i2c.h>
 #include <linux/hwmon.h>
 #include <linux/err.h>
+#include <linux/mutex.h>
 #include "lm75.h"
 
 /* Addresses to scan */
@@ -72,7 +73,7 @@ MODULE_PARM_DESC(polarity, "Output's polarity: 0 = active high, 1 = active low")
 struct ds1621_data {
         struct i2c_client client;
         struct class_device *class_dev;
-        struct semaphore update_lock;
+        struct mutex update_lock;
         char valid;                     /* !=0 if following fields are valid */
         unsigned long last_updated;     /* In jiffies */
 
@@ -156,10 +157,10 @@ static ssize_t set_temp_##suffix(struct device *dev, struct device_attribute *at
         struct ds1621_data *data = ds1621_update_client(dev);           \
         u16 val = LM75_TEMP_TO_REG(simple_strtoul(buf, NULL, 10));      \
                                                                         \
-        down(&data->update_lock);                                       \
+        mutex_lock(&data->update_lock);                                 \
         data->value = val;                                              \
         ds1621_write_value(client, reg, data->value);                   \
-        up(&data->update_lock);                                         \
+        mutex_unlock(&data->update_lock);                               \
         return count;                                                   \
 }
 
@@ -242,7 +243,7 @@ static int ds1621_detect(struct i2c_adapter *adapter, int address,
         /* Fill in remaining client fields and put it into the global list */
         strlcpy(new_client->name, "ds1621", I2C_NAME_SIZE);
         data->valid = 0;
-        init_MUTEX(&data->update_lock);
+        mutex_init(&data->update_lock);
 
         /* Tell the I2C layer a new client has arrived */
         if ((err = i2c_attach_client(new_client)))
@@ -297,7 +298,7 @@ static struct ds1621_data *ds1621_update_client(struct device *dev)
         struct ds1621_data *data = i2c_get_clientdata(client);
         u8 new_conf;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
             || !data->valid) {
@@ -327,7 +328,7 @@ static struct ds1621_data *ds1621_update_client(struct device *dev)
                 data->valid = 1;
         }
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return data;
 }
diff --git a/drivers/hwmon/f71805f.c b/drivers/hwmon/f71805f.c
index e029e0a94e..885465df6e 100644
--- a/drivers/hwmon/f71805f.c
+++ b/drivers/hwmon/f71805f.c
@@ -30,6 +30,7 @@
 #include <linux/hwmon.h>
 #include <linux/hwmon-sysfs.h>
 #include <linux/err.h>
+#include <linux/mutex.h>
 #include <asm/io.h>
 
 static struct platform_device *pdev;
@@ -131,10 +132,10 @@ static struct resource f71805f_resource __initdata = {
 struct f71805f_data {
         unsigned short addr;
         const char *name;
-        struct semaphore lock;
+        struct mutex lock;
         struct class_device *class_dev;
 
-        struct semaphore update_lock;
+        struct mutex update_lock;
         char valid;             /* !=0 if following fields are valid */
         unsigned long last_updated;     /* In jiffies */
         unsigned long last_limits;      /* In jiffies */
@@ -224,20 +225,20 @@ static u8 f71805f_read8(struct f71805f_data *data, u8 reg)
 {
         u8 val;
 
-        down(&data->lock);
+        mutex_lock(&data->lock);
         outb(reg, data->addr + ADDR_REG_OFFSET);
         val = inb(data->addr + DATA_REG_OFFSET);
-        up(&data->lock);
+        mutex_unlock(&data->lock);
 
         return val;
 }
 
 static void f71805f_write8(struct f71805f_data *data, u8 reg, u8 val)
 {
-        down(&data->lock);
+        mutex_lock(&data->lock);
         outb(reg, data->addr + ADDR_REG_OFFSET);
         outb(val, data->addr + DATA_REG_OFFSET);
-        up(&data->lock);
+        mutex_unlock(&data->lock);
 }
 
 /* It is important to read the MSB first, because doing so latches the
@@ -246,24 +247,24 @@ static u16 f71805f_read16(struct f71805f_data *data, u8 reg)
 {
         u16 val;
 
-        down(&data->lock);
+        mutex_lock(&data->lock);
         outb(reg, data->addr + ADDR_REG_OFFSET);
         val = inb(data->addr + DATA_REG_OFFSET) << 8;
         outb(++reg, data->addr + ADDR_REG_OFFSET);
         val |= inb(data->addr + DATA_REG_OFFSET);
-        up(&data->lock);
+        mutex_unlock(&data->lock);
 
         return val;
 }
 
 static void f71805f_write16(struct f71805f_data *data, u8 reg, u16 val)
 {
-        down(&data->lock);
+        mutex_lock(&data->lock);
         outb(reg, data->addr + ADDR_REG_OFFSET);
         outb(val >> 8, data->addr + DATA_REG_OFFSET);
         outb(++reg, data->addr + ADDR_REG_OFFSET);
         outb(val & 0xff, data->addr + DATA_REG_OFFSET);
-        up(&data->lock);
+        mutex_unlock(&data->lock);
 }
 
 static struct f71805f_data *f71805f_update_device(struct device *dev)
@@ -271,7 +272,7 @@ static struct f71805f_data *f71805f_update_device(struct device *dev)
         struct f71805f_data *data = dev_get_drvdata(dev);
         int nr;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         /* Limit registers cache is refreshed after 60 seconds */
         if (time_after(jiffies, data->last_updated + 60 * HZ)
@@ -323,7 +324,7 @@ static struct f71805f_data *f71805f_update_device(struct device *dev)
                 data->valid = 1;
         }
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return data;
 }
@@ -362,10 +363,10 @@ static ssize_t set_in0_max(struct device *dev, struct device_attribute
         struct f71805f_data *data = dev_get_drvdata(dev);
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->in_high[0] = in0_to_reg(val);
         f71805f_write8(data, F71805F_REG_IN_HIGH(0), data->in_high[0]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return count;
 }
@@ -376,18 +377,14 @@ static ssize_t set_in0_min(struct device *dev, struct device_attribute
         struct f71805f_data *data = dev_get_drvdata(dev);
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->in_low[0] = in0_to_reg(val);
         f71805f_write8(data, F71805F_REG_IN_LOW(0), data->in_low[0]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return count;
 }
 
-static DEVICE_ATTR(in0_input, S_IRUGO, show_in0, NULL);
-static DEVICE_ATTR(in0_max, S_IRUGO| S_IWUSR, show_in0_max, set_in0_max);
-static DEVICE_ATTR(in0_min, S_IRUGO| S_IWUSR, show_in0_min, set_in0_min);
-
 static ssize_t show_in(struct device *dev, struct device_attribute *devattr,
                        char *buf)
 {
@@ -426,10 +423,10 @@ static ssize_t set_in_max(struct device *dev, struct device_attribute
         int nr = attr->index;
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->in_high[nr] = in_to_reg(val);
         f71805f_write8(data, F71805F_REG_IN_HIGH(nr), data->in_high[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return count;
 }
@@ -442,31 +439,14 @@ static ssize_t set_in_min(struct device *dev, struct device_attribute
         int nr = attr->index;
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->in_low[nr] = in_to_reg(val);
         f71805f_write8(data, F71805F_REG_IN_LOW(nr), data->in_low[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return count;
 }
 
-#define sysfs_in(offset)                                        \
-static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO,          \
-                show_in, NULL, offset);                         \
-static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR,  \
-                show_in_max, set_in_max, offset);               \
-static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR,  \
-                show_in_min, set_in_min, offset)
-
-sysfs_in(1);
-sysfs_in(2);
-sysfs_in(3);
-sysfs_in(4);
-sysfs_in(5);
-sysfs_in(6);
-sysfs_in(7);
-sysfs_in(8);
-
 static ssize_t show_fan(struct device *dev, struct device_attribute *devattr,
                         char *buf)
 {
@@ -495,24 +475,14 @@ static ssize_t set_fan_min(struct device *dev, struct device_attribute
         int nr = attr->index;
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->fan_low[nr] = fan_to_reg(val);
         f71805f_write16(data, F71805F_REG_FAN_LOW(nr), data->fan_low[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return count;
 }
 
-#define sysfs_fan(offset)                                       \
-static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO,         \
-                show_fan, NULL, offset - 1);                    \
-static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
-                show_fan_min, set_fan_min, offset - 1)
-
-sysfs_fan(1);
-sysfs_fan(2);
-sysfs_fan(3);
-
 static ssize_t show_temp(struct device *dev, struct device_attribute *devattr,
                          char *buf)
 {
@@ -562,10 +532,10 @@ static ssize_t set_temp_max(struct device *dev, struct device_attribute
         int nr = attr->index;
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp_high[nr] = temp_to_reg(val);
         f71805f_write8(data, F71805F_REG_TEMP_HIGH(nr), data->temp_high[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return count;
 }
@@ -578,28 +548,14 @@ static ssize_t set_temp_hyst(struct device *dev, struct device_attribute
         int nr = attr->index;
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp_hyst[nr] = temp_to_reg(val);
         f71805f_write8(data, F71805F_REG_TEMP_HYST(nr), data->temp_hyst[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return count;
 }
 
-#define sysfs_temp(offset)                                              \
-static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO,                \
-                show_temp, NULL, offset - 1);                           \
-static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR,        \
-                show_temp_max, set_temp_max, offset - 1);               \
-static SENSOR_DEVICE_ATTR(temp##offset##_max_hyst, S_IRUGO | S_IWUSR,   \
-                show_temp_hyst, set_temp_hyst, offset - 1);             \
-static SENSOR_DEVICE_ATTR(temp##offset##_type, S_IRUGO,                 \
-                show_temp_type, NULL, offset - 1)
-
-sysfs_temp(1);
-sysfs_temp(2);
-sysfs_temp(3);
-
 static ssize_t show_alarms_in(struct device *dev, struct device_attribute
                               *devattr, char *buf)
 {
@@ -625,10 +581,6 @@ static ssize_t show_alarms_temp(struct device *dev, struct device_attribute
         return sprintf(buf, "%d\n", (data->alarms[1] >> 3) & 0x07);
 }
 
-static DEVICE_ATTR(alarms_in, S_IRUGO, show_alarms_in, NULL);
-static DEVICE_ATTR(alarms_fan, S_IRUGO, show_alarms_fan, NULL);
-static DEVICE_ATTR(alarms_temp, S_IRUGO, show_alarms_temp, NULL);
-
 static ssize_t show_name(struct device *dev, struct device_attribute
                          *devattr, char *buf)
 {
@@ -637,7 +589,89 @@ static ssize_t show_name(struct device *dev, struct device_attribute
         return sprintf(buf, "%s\n", data->name);
 }
 
-static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
+static struct device_attribute f71805f_dev_attr[] = {
+        __ATTR(in0_input, S_IRUGO, show_in0, NULL),
+        __ATTR(in0_max, S_IRUGO| S_IWUSR, show_in0_max, set_in0_max),
+        __ATTR(in0_min, S_IRUGO| S_IWUSR, show_in0_min, set_in0_min),
+        __ATTR(alarms_in, S_IRUGO, show_alarms_in, NULL),
+        __ATTR(alarms_fan, S_IRUGO, show_alarms_fan, NULL),
+        __ATTR(alarms_temp, S_IRUGO, show_alarms_temp, NULL),
+        __ATTR(name, S_IRUGO, show_name, NULL),
+};
+
+static struct sensor_device_attribute f71805f_sensor_attr[] = {
+        SENSOR_ATTR(in1_input, S_IRUGO, show_in, NULL, 1),
+        SENSOR_ATTR(in1_max, S_IRUGO | S_IWUSR,
+                    show_in_max, set_in_max, 1),
+        SENSOR_ATTR(in1_min, S_IRUGO | S_IWUSR,
+                    show_in_min, set_in_min, 1),
+        SENSOR_ATTR(in2_input, S_IRUGO, show_in, NULL, 2),
+        SENSOR_ATTR(in2_max, S_IRUGO | S_IWUSR,
+                    show_in_max, set_in_max, 2),
+        SENSOR_ATTR(in2_min, S_IRUGO | S_IWUSR,
+                    show_in_min, set_in_min, 2),
+        SENSOR_ATTR(in3_input, S_IRUGO, show_in, NULL, 3),
+        SENSOR_ATTR(in3_max, S_IRUGO | S_IWUSR,
+                    show_in_max, set_in_max, 3),
+        SENSOR_ATTR(in3_min, S_IRUGO | S_IWUSR,
+                    show_in_min, set_in_min, 3),
+        SENSOR_ATTR(in4_input, S_IRUGO, show_in, NULL, 4),
+        SENSOR_ATTR(in4_max, S_IRUGO | S_IWUSR,
+                    show_in_max, set_in_max, 4),
+        SENSOR_ATTR(in4_min, S_IRUGO | S_IWUSR,
+                    show_in_min, set_in_min, 4),
+        SENSOR_ATTR(in5_input, S_IRUGO, show_in, NULL, 5),
+        SENSOR_ATTR(in5_max, S_IRUGO | S_IWUSR,
+                    show_in_max, set_in_max, 5),
+        SENSOR_ATTR(in5_min, S_IRUGO | S_IWUSR,
+                    show_in_min, set_in_min, 5),
+        SENSOR_ATTR(in6_input, S_IRUGO, show_in, NULL, 6),
+        SENSOR_ATTR(in6_max, S_IRUGO | S_IWUSR,
+                    show_in_max, set_in_max, 6),
+        SENSOR_ATTR(in6_min, S_IRUGO | S_IWUSR,
+                    show_in_min, set_in_min, 6),
+        SENSOR_ATTR(in7_input, S_IRUGO, show_in, NULL, 7),
+        SENSOR_ATTR(in7_max, S_IRUGO | S_IWUSR,
+                    show_in_max, set_in_max, 7),
+        SENSOR_ATTR(in7_min, S_IRUGO | S_IWUSR,
+                    show_in_min, set_in_min, 7),
+        SENSOR_ATTR(in8_input, S_IRUGO, show_in, NULL, 8),
+        SENSOR_ATTR(in8_max, S_IRUGO | S_IWUSR,
+                    show_in_max, set_in_max, 8),
+        SENSOR_ATTR(in8_min, S_IRUGO | S_IWUSR,
+                    show_in_min, set_in_min, 8),
+
+        SENSOR_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0),
+        SENSOR_ATTR(temp1_max, S_IRUGO | S_IWUSR,
+                    show_temp_max, set_temp_max, 0),
+        SENSOR_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR,
+                    show_temp_hyst, set_temp_hyst, 0),
+        SENSOR_ATTR(temp1_type, S_IRUGO, show_temp_type, NULL, 0),
+        SENSOR_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1),
+        SENSOR_ATTR(temp2_max, S_IRUGO | S_IWUSR,
+                    show_temp_max, set_temp_max, 1),
+        SENSOR_ATTR(temp2_max_hyst, S_IRUGO | S_IWUSR,
+                    show_temp_hyst, set_temp_hyst, 1),
+        SENSOR_ATTR(temp2_type, S_IRUGO, show_temp_type, NULL, 1),
+        SENSOR_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 2),
+        SENSOR_ATTR(temp3_max, S_IRUGO | S_IWUSR,
+                    show_temp_max, set_temp_max, 2),
+        SENSOR_ATTR(temp3_max_hyst, S_IRUGO | S_IWUSR,
+                    show_temp_hyst, set_temp_hyst, 2),
+        SENSOR_ATTR(temp3_type, S_IRUGO, show_temp_type, NULL, 2),
+};
+
+static struct sensor_device_attribute f71805f_fan_attr[] = {
+        SENSOR_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0),
+        SENSOR_ATTR(fan1_min, S_IRUGO | S_IWUSR,
+                    show_fan_min, set_fan_min, 0),
+        SENSOR_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1),
+        SENSOR_ATTR(fan2_min, S_IRUGO | S_IWUSR,
+                    show_fan_min, set_fan_min, 1),
+        SENSOR_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2),
+        SENSOR_ATTR(fan3_min, S_IRUGO | S_IWUSR,
+                    show_fan_min, set_fan_min, 2),
+};
 
 /*
  * Device registration and initialization
@@ -668,7 +702,7 @@ static int __devinit f71805f_probe(struct platform_device *pdev)
 {
         struct f71805f_data *data;
         struct resource *res;
-        int err;
+        int i, err;
 
         if (!(data = kzalloc(sizeof(struct f71805f_data), GFP_KERNEL))) {
                 err = -ENOMEM;
@@ -678,9 +712,9 @@ static int __devinit f71805f_probe(struct platform_device *pdev)
 
         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
         data->addr = res->start;
-        init_MUTEX(&data->lock);
+        mutex_init(&data->lock);
         data->name = "f71805f";
-        init_MUTEX(&data->update_lock);
+        mutex_init(&data->update_lock);
 
         platform_set_drvdata(pdev, data);
 
@@ -695,76 +729,31 @@ static int __devinit f71805f_probe(struct platform_device *pdev)
         f71805f_init_device(data);
 
         /* Register sysfs interface files */
-        device_create_file(&pdev->dev, &dev_attr_in0_input);
-        device_create_file(&pdev->dev, &dev_attr_in0_max);
-        device_create_file(&pdev->dev, &dev_attr_in0_min);
-        device_create_file(&pdev->dev, &sensor_dev_attr_in1_input.dev_attr);
-        device_create_file(&pdev->dev, &sensor_dev_attr_in2_input.dev_attr);
-        device_create_file(&pdev->dev, &sensor_dev_attr_in3_input.dev_attr);
-        device_create_file(&pdev->dev, &sensor_dev_attr_in4_input.dev_attr);
-        device_create_file(&pdev->dev, &sensor_dev_attr_in5_input.dev_attr);
-        device_create_file(&pdev->dev, &sensor_dev_attr_in6_input.dev_attr);
-        device_create_file(&pdev->dev, &sensor_dev_attr_in7_input.dev_attr);
-        device_create_file(&pdev->dev, &sensor_dev_attr_in8_input.dev_attr);
-        device_create_file(&pdev->dev, &sensor_dev_attr_in1_max.dev_attr);
-        device_create_file(&pdev->dev, &sensor_dev_attr_in2_max.dev_attr);
-        device_create_file(&pdev->dev, &sensor_dev_attr_in3_max.dev_attr);
-        device_create_file(&pdev->dev, &sensor_dev_attr_in4_max.dev_attr);
-        device_create_file(&pdev->dev, &sensor_dev_attr_in5_max.dev_attr);
-        device_create_file(&pdev->dev, &sensor_dev_attr_in6_max.dev_attr);
-        device_create_file(&pdev->dev, &sensor_dev_attr_in7_max.dev_attr);
-        device_create_file(&pdev->dev, &sensor_dev_attr_in8_max.dev_attr);
-        device_create_file(&pdev->dev, &sensor_dev_attr_in1_min.dev_attr);
-        device_create_file(&pdev->dev, &sensor_dev_attr_in2_min.dev_attr);
-        device_create_file(&pdev->dev, &sensor_dev_attr_in3_min.dev_attr);
-        device_create_file(&pdev->dev, &sensor_dev_attr_in4_min.dev_attr);
-        device_create_file(&pdev->dev, &sensor_dev_attr_in5_min.dev_attr);
-        device_create_file(&pdev->dev, &sensor_dev_attr_in6_min.dev_attr);
-        device_create_file(&pdev->dev, &sensor_dev_attr_in7_min.dev_attr);
-        device_create_file(&pdev->dev, &sensor_dev_attr_in8_min.dev_attr);
-        if (data->fan_enabled & (1 << 0)) {
-                device_create_file(&pdev->dev,
-                                   &sensor_dev_attr_fan1_input.dev_attr);
-                device_create_file(&pdev->dev,
-                                   &sensor_dev_attr_fan1_min.dev_attr);
+        for (i = 0; i < ARRAY_SIZE(f71805f_dev_attr); i++) {
+                err = device_create_file(&pdev->dev, &f71805f_dev_attr[i]);
+                if (err)
+                        goto exit_class;
         }
-        if (data->fan_enabled & (1 << 1)) {
-                device_create_file(&pdev->dev,
-                                   &sensor_dev_attr_fan2_input.dev_attr);
-                device_create_file(&pdev->dev,
-                                   &sensor_dev_attr_fan2_min.dev_attr);
+        for (i = 0; i < ARRAY_SIZE(f71805f_sensor_attr); i++) {
+                err = device_create_file(&pdev->dev,
+                                         &f71805f_sensor_attr[i].dev_attr);
+                if (err)
+                        goto exit_class;
         }
-        if (data->fan_enabled & (1 << 2)) {
-                device_create_file(&pdev->dev,
-                                   &sensor_dev_attr_fan3_input.dev_attr);
-                device_create_file(&pdev->dev,
-                                   &sensor_dev_attr_fan3_min.dev_attr);
+        for (i = 0; i < ARRAY_SIZE(f71805f_fan_attr); i++) {
+                if (!(data->fan_enabled & (1 << (i / 2))))
+                        continue;
+                err = device_create_file(&pdev->dev,
+                                         &f71805f_fan_attr[i].dev_attr);
+                if (err)
+                        goto exit_class;
         }
-        device_create_file(&pdev->dev,
-                           &sensor_dev_attr_temp1_input.dev_attr);
-        device_create_file(&pdev->dev,
-                           &sensor_dev_attr_temp2_input.dev_attr);
-        device_create_file(&pdev->dev,
-                           &sensor_dev_attr_temp3_input.dev_attr);
-        device_create_file(&pdev->dev, &sensor_dev_attr_temp1_max.dev_attr);
-        device_create_file(&pdev->dev, &sensor_dev_attr_temp2_max.dev_attr);
-        device_create_file(&pdev->dev, &sensor_dev_attr_temp3_max.dev_attr);
-        device_create_file(&pdev->dev,
-                           &sensor_dev_attr_temp1_max_hyst.dev_attr);
-        device_create_file(&pdev->dev,
-                           &sensor_dev_attr_temp2_max_hyst.dev_attr);
-        device_create_file(&pdev->dev,
-                           &sensor_dev_attr_temp3_max_hyst.dev_attr);
-        device_create_file(&pdev->dev, &sensor_dev_attr_temp1_type.dev_attr);
-        device_create_file(&pdev->dev, &sensor_dev_attr_temp2_type.dev_attr);
-        device_create_file(&pdev->dev, &sensor_dev_attr_temp3_type.dev_attr);
-        device_create_file(&pdev->dev, &dev_attr_alarms_in);
-        device_create_file(&pdev->dev, &dev_attr_alarms_fan);
-        device_create_file(&pdev->dev, &dev_attr_alarms_temp);
-        device_create_file(&pdev->dev, &dev_attr_name);
 
         return 0;
 
+exit_class:
+        dev_err(&pdev->dev, "Sysfs interface creation failed\n");
+        hwmon_device_unregister(data->class_dev);
 exit_free:
         kfree(data);
 exit:
diff --git a/drivers/hwmon/fscher.c b/drivers/hwmon/fscher.c
index 25409181d1..6bc76b4076 100644
--- a/drivers/hwmon/fscher.c
+++ b/drivers/hwmon/fscher.c
@@ -33,6 +33,7 @@
 #include <linux/i2c.h>
 #include <linux/hwmon.h>
 #include <linux/err.h>
+#include <linux/mutex.h>
 
 /*
  * Addresses to scan
@@ -133,7 +134,7 @@ static struct i2c_driver fscher_driver = {
 struct fscher_data {
         struct i2c_client client;
         struct class_device *class_dev;
-        struct semaphore update_lock;
+        struct mutex update_lock;
         char valid; /* zero until following fields are valid */
         unsigned long last_updated; /* in jiffies */
 
@@ -332,7 +333,7 @@ static int fscher_detect(struct i2c_adapter *adapter, int address, int kind)
          * global list */
         strlcpy(new_client->name, "fscher", I2C_NAME_SIZE);
         data->valid = 0;
-        init_MUTEX(&data->update_lock);
+        mutex_init(&data->update_lock);
 
         /* Tell the I2C layer a new client has arrived */
         if ((err = i2c_attach_client(new_client)))
@@ -417,7 +418,7 @@ static struct fscher_data *fscher_update_device(struct device *dev)
         struct i2c_client *client = to_i2c_client(dev);
         struct fscher_data *data = i2c_get_clientdata(client);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) {
 
@@ -457,7 +458,7 @@ static struct fscher_data *fscher_update_device(struct device *dev)
                 data->valid = 1;                 
         }
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return data;
 }
@@ -472,10 +473,10 @@ static ssize_t set_fan_status(struct i2c_client *client, struct fscher_data *dat
         /* bits 0..1, 3..7 reserved => mask with 0x04 */  
         unsigned long v = simple_strtoul(buf, NULL, 10) & 0x04;
         
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->fan_status[FAN_INDEX_FROM_NUM(nr)] &= ~v;
         fscher_write_value(client, reg, v);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -490,10 +491,10 @@ static ssize_t set_pwm(struct i2c_client *client, struct fscher_data *data,
 {
         unsigned long v = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->fan_min[FAN_INDEX_FROM_NUM(nr)] = v > 0xff ? 0xff : v;
         fscher_write_value(client, reg, data->fan_min[FAN_INDEX_FROM_NUM(nr)]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -518,14 +519,14 @@ static ssize_t set_fan_div(struct i2c_client *client, struct fscher_data *data,
                 return -EINVAL;
         }
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         /* bits 2..7 reserved => mask with 0x03 */
         data->fan_ripple[FAN_INDEX_FROM_NUM(nr)] &= ~0x03;
         data->fan_ripple[FAN_INDEX_FROM_NUM(nr)] |= v;
 
         fscher_write_value(client, reg, data->fan_ripple[FAN_INDEX_FROM_NUM(nr)]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -552,10 +553,10 @@ static ssize_t set_temp_status(struct i2c_client *client, struct fscher_data *da
         /* bits 2..7 reserved, 0 read only => mask with 0x02 */  
         unsigned long v = simple_strtoul(buf, NULL, 10) & 0x02;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp_status[TEMP_INDEX_FROM_NUM(nr)] &= ~v;
         fscher_write_value(client, reg, v);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -609,10 +610,10 @@ static ssize_t set_control(struct i2c_client *client, struct fscher_data *data,
         /* bits 1..7 reserved => mask with 0x01 */  
         unsigned long v = simple_strtoul(buf, NULL, 10) & 0x01;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->global_control &= ~v;
         fscher_write_value(client, reg, v);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -631,11 +632,11 @@ static ssize_t set_watchdog_control(struct i2c_client *client, struct
         /* bits 0..3 reserved => mask with 0xf0 */  
         unsigned long v = simple_strtoul(buf, NULL, 10) & 0xf0;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->watchdog[2] &= ~0xf0;
         data->watchdog[2] |= v;
         fscher_write_value(client, reg, data->watchdog[2]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -651,10 +652,10 @@ static ssize_t set_watchdog_status(struct i2c_client *client, struct fscher_data
         /* bits 0, 2..7 reserved => mask with 0x02 */  
         unsigned long v = simple_strtoul(buf, NULL, 10) & 0x02;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->watchdog[1] &= ~v;
         fscher_write_value(client, reg, v);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -669,10 +670,10 @@ static ssize_t set_watchdog_preset(struct i2c_client *client, struct fscher_data
 {
         unsigned long v = simple_strtoul(buf, NULL, 10) & 0xff;
         
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->watchdog[0] = v;
         fscher_write_value(client, reg, data->watchdog[0]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
diff --git a/drivers/hwmon/fscpos.c b/drivers/hwmon/fscpos.c
index 6d0146b570..6dc4846b9e 100644
--- a/drivers/hwmon/fscpos.c
+++ b/drivers/hwmon/fscpos.c
@@ -37,6 +37,7 @@
 #include <linux/init.h>
 #include <linux/hwmon.h>
 #include <linux/err.h>
+#include <linux/mutex.h>
 
 /*
  * Addresses to scan
@@ -89,8 +90,8 @@ static int fscpos_attach_adapter(struct i2c_adapter *adapter);
 static int fscpos_detect(struct i2c_adapter *adapter, int address, int kind);
 static int fscpos_detach_client(struct i2c_client *client);
 
-static int fscpos_read_value(struct i2c_client *client, u8 register);
-static int fscpos_write_value(struct i2c_client *client, u8 register, u8 value);
+static int fscpos_read_value(struct i2c_client *client, u8 reg);
+static int fscpos_write_value(struct i2c_client *client, u8 reg, u8 value);
 static struct fscpos_data *fscpos_update_device(struct device *dev);
 static void fscpos_init_client(struct i2c_client *client);
 
@@ -114,7 +115,7 @@ static struct i2c_driver fscpos_driver = {
 struct fscpos_data {
         struct i2c_client client;
         struct class_device *class_dev;
-        struct semaphore update_lock;
+        struct mutex update_lock;
         char valid;             /* 0 until following fields are valid */
         unsigned long last_updated;     /* In jiffies */
 
@@ -208,13 +209,13 @@ static ssize_t set_fan_ripple(struct i2c_client *client, struct fscpos_data
                 return -EINVAL;
         }
         
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         /* bits 2..7 reserved => mask with 0x03 */
         data->fan_ripple[nr - 1] &= ~0x03;
         data->fan_ripple[nr - 1] |= v;
         
         fscpos_write_value(client, reg, data->fan_ripple[nr - 1]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -232,10 +233,10 @@ static ssize_t set_pwm(struct i2c_client *client, struct fscpos_data *data,
         if (v < 0) v = 0;
         if (v > 255) v = 255;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->pwm[nr - 1] = v;
         fscpos_write_value(client, reg, data->pwm[nr - 1]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -278,11 +279,11 @@ static ssize_t set_wdog_control(struct i2c_client *client, struct fscpos_data
         /* bits 0..3 reserved => mask with 0xf0 */
         unsigned long v = simple_strtoul(buf, NULL, 10) & 0xf0;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->wdog_control &= ~0xf0;
         data->wdog_control |= v;
         fscpos_write_value(client, reg, data->wdog_control);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -304,10 +305,10 @@ static ssize_t set_wdog_state(struct i2c_client *client, struct fscpos_data
                 return -EINVAL;
         }
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->wdog_state &= ~v;
         fscpos_write_value(client, reg, v);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -321,10 +322,10 @@ static ssize_t set_wdog_preset(struct i2c_client *client, struct fscpos_data
 {
         unsigned long v = simple_strtoul(buf, NULL, 10) & 0xff;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->wdog_preset = v;
         fscpos_write_value(client, reg, data->wdog_preset);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -483,7 +484,7 @@ static int fscpos_detect(struct i2c_adapter *adapter, int address, int kind)
         strlcpy(new_client->name, "fscpos", I2C_NAME_SIZE);
 
         data->valid = 0;
-        init_MUTEX(&data->update_lock);
+        mutex_init(&data->update_lock);
 
         /* Tell the I2C layer a new client has arrived */
         if ((err = i2c_attach_client(new_client)))
@@ -579,7 +580,7 @@ static struct fscpos_data *fscpos_update_device(struct device *dev)
         struct i2c_client *client = to_i2c_client(dev);
         struct fscpos_data *data = i2c_get_clientdata(client);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) {
                 int i;
@@ -625,7 +626,7 @@ static struct fscpos_data *fscpos_update_device(struct device *dev)
                 data->last_updated = jiffies;
                 data->valid = 1;
         }
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return data;
 }
 
diff --git a/drivers/hwmon/gl518sm.c b/drivers/hwmon/gl518sm.c
index 9e685e3a3b..6606aabdb4 100644
--- a/drivers/hwmon/gl518sm.c
+++ b/drivers/hwmon/gl518sm.c
@@ -43,6 +43,7 @@
 #include <linux/i2c.h>
 #include <linux/hwmon.h>
 #include <linux/err.h>
+#include <linux/mutex.h>
 
 /* Addresses to scan */
 static unsigned short normal_i2c[] = { 0x2c, 0x2d, I2C_CLIENT_END };
@@ -120,7 +121,7 @@ struct gl518_data {
         struct class_device *class_dev;
         enum chips type;
 
-        struct semaphore update_lock;
+        struct mutex update_lock;
         char valid;             /* !=0 if following fields are valid */
         unsigned long last_updated;     /* In jiffies */
 
@@ -212,10 +213,10 @@ static ssize_t set_##suffix(struct device *dev, struct device_attribute *attr, c
         struct gl518_data *data = i2c_get_clientdata(client);           \
         long val = simple_strtol(buf, NULL, 10);                        \
                                                                         \
-        down(&data->update_lock);                                       \
+        mutex_lock(&data->update_lock);                                 \
         data->value = type##_TO_REG(val);                               \
         gl518_write_value(client, reg, data->value);                    \
-        up(&data->update_lock);                                         \
+        mutex_unlock(&data->update_lock);                               \
         return count;                                                   \
 }
 
@@ -228,12 +229,12 @@ static ssize_t set_##suffix(struct device *dev, struct device_attribute *attr, c
         int regvalue;                                                   \
         unsigned long val = simple_strtoul(buf, NULL, 10);              \
                                                                         \
-        down(&data->update_lock);                                       \
+        mutex_lock(&data->update_lock);                                 \
         regvalue = gl518_read_value(client, reg);                       \
         data->value = type##_TO_REG(val);                               \
         regvalue = (regvalue & ~mask) | (data->value << shift);         \
         gl518_write_value(client, reg, regvalue);                       \
-        up(&data->update_lock);                                         \
+        mutex_unlock(&data->update_lock);                               \
         return count;                                                   \
 }
 
@@ -265,7 +266,7 @@ static ssize_t set_fan_min1(struct device *dev, struct device_attribute *attr, c
         int regvalue;
         unsigned long val = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         regvalue = gl518_read_value(client, GL518_REG_FAN_LIMIT);
         data->fan_min[0] = FAN_TO_REG(val,
                 DIV_FROM_REG(data->fan_div[0]));
@@ -280,7 +281,7 @@ static ssize_t set_fan_min1(struct device *dev, struct device_attribute *attr, c
         data->beep_mask &= data->alarm_mask;
         gl518_write_value(client, GL518_REG_ALARM, data->beep_mask);
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -291,7 +292,7 @@ static ssize_t set_fan_min2(struct device *dev, struct device_attribute *attr, c
         int regvalue;
         unsigned long val = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         regvalue = gl518_read_value(client, GL518_REG_FAN_LIMIT);
         data->fan_min[1] = FAN_TO_REG(val,
                 DIV_FROM_REG(data->fan_div[1]));
@@ -306,7 +307,7 @@ static ssize_t set_fan_min2(struct device *dev, struct device_attribute *attr, c
         data->beep_mask &= data->alarm_mask;
         gl518_write_value(client, GL518_REG_ALARM, data->beep_mask);
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -407,7 +408,7 @@ static int gl518_detect(struct i2c_adapter *adapter, int address, int kind)
         strlcpy(new_client->name, "gl518sm", I2C_NAME_SIZE);
         data->type = kind;
         data->valid = 0;
-        init_MUTEX(&data->update_lock);
+        mutex_init(&data->update_lock);
 
         /* Tell the I2C layer a new client has arrived */
         if ((err = i2c_attach_client(new_client)))
@@ -525,7 +526,7 @@ static struct gl518_data *gl518_update_device(struct device *dev)
         struct gl518_data *data = i2c_get_clientdata(client);
         int val;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
             || !data->valid) {
@@ -586,7 +587,7 @@ static struct gl518_data *gl518_update_device(struct device *dev)
                 data->valid = 1;
         }
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return data;
 }
diff --git a/drivers/hwmon/gl520sm.c b/drivers/hwmon/gl520sm.c
index baee60e44b..14e810f3c2 100644
--- a/drivers/hwmon/gl520sm.c
+++ b/drivers/hwmon/gl520sm.c
@@ -29,6 +29,7 @@
 #include <linux/hwmon.h>
 #include <linux/hwmon-vid.h>
 #include <linux/err.h>
+#include <linux/mutex.h>
 
 /* Type of the extra sensor */
 static unsigned short extra_sensor_type;
@@ -121,7 +122,7 @@ static struct i2c_driver gl520_driver = {
 struct gl520_data {
         struct i2c_client client;
         struct class_device *class_dev;
-        struct semaphore update_lock;
+        struct mutex update_lock;
         char valid;             /* zero until the following fields are valid */
         unsigned long last_updated;     /* in jiffies */
 
@@ -303,7 +304,7 @@ static ssize_t set_in_min(struct i2c_client *client, struct gl520_data *data, co
         long v = simple_strtol(buf, NULL, 10);
         u8 r;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if (n == 0)
                 r = VDD_TO_REG(v);
@@ -317,7 +318,7 @@ static ssize_t set_in_min(struct i2c_client *client, struct gl520_data *data, co
         else
                 gl520_write_value(client, reg, r);
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -331,7 +332,7 @@ static ssize_t set_in_max(struct i2c_client *client, struct gl520_data *data, co
         else
                 r = IN_TO_REG(v);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         data->in_max[n] = r;
 
@@ -340,7 +341,7 @@ static ssize_t set_in_max(struct i2c_client *client, struct gl520_data *data, co
         else
                 gl520_write_value(client, reg, r);
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -373,7 +374,7 @@ static ssize_t set_fan_min(struct i2c_client *client, struct gl520_data *data, c
         unsigned long v = simple_strtoul(buf, NULL, 10);
         u8 r;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         r = FAN_TO_REG(v, data->fan_div[n - 1]);
         data->fan_min[n - 1] = r;
 
@@ -390,7 +391,7 @@ static ssize_t set_fan_min(struct i2c_client *client, struct gl520_data *data, c
         data->beep_mask &= data->alarm_mask;
         gl520_write_value(client, GL520_REG_BEEP_MASK, data->beep_mask);
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -409,7 +410,7 @@ static ssize_t set_fan_div(struct i2c_client *client, struct gl520_data *data, c
                 return -EINVAL;
         }
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->fan_div[n - 1] = r;
 
         if (n == 1)
@@ -417,7 +418,7 @@ static ssize_t set_fan_div(struct i2c_client *client, struct gl520_data *data, c
         else
                 gl520_write_value(client, reg, (gl520_read_value(client, reg) & ~0x30) | (r << 4));
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -425,10 +426,10 @@ static ssize_t set_fan_off(struct i2c_client *client, struct gl520_data *data, c
 {
         u8 r = simple_strtoul(buf, NULL, 10)?1:0;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->fan_off = r;
         gl520_write_value(client, reg, (gl520_read_value(client, reg) & ~0x0c) | (r << 2));
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -454,10 +455,10 @@ static ssize_t set_temp_max(struct i2c_client *client, struct gl520_data *data,
 {
         long v = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
-        data->temp_max[n - 1] = TEMP_TO_REG(v);;
+        mutex_lock(&data->update_lock);
+        data->temp_max[n - 1] = TEMP_TO_REG(v);
         gl520_write_value(client, reg, data->temp_max[n - 1]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -465,10 +466,10 @@ static ssize_t set_temp_max_hyst(struct i2c_client *client, struct gl520_data *d
 {
         long v = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp_max_hyst[n - 1] = TEMP_TO_REG(v);
         gl520_write_value(client, reg, data->temp_max_hyst[n - 1]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -491,10 +492,10 @@ static ssize_t set_beep_enable(struct i2c_client *client, struct gl520_data *dat
 {
         u8 r = simple_strtoul(buf, NULL, 10)?0:1;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->beep_enable = !r;
         gl520_write_value(client, reg, (gl520_read_value(client, reg) & ~0x04) | (r << 2));
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -502,11 +503,11 @@ static ssize_t set_beep_mask(struct i2c_client *client, struct gl520_data *data,
 {
         u8 r = simple_strtoul(buf, NULL, 10);
         
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         r &= data->alarm_mask;
         data->beep_mask = r;
         gl520_write_value(client, reg, r);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -561,7 +562,7 @@ static int gl520_detect(struct i2c_adapter *adapter, int address, int kind)
         /* Fill in the remaining client fields */
         strlcpy(new_client->name, "gl520sm", I2C_NAME_SIZE);
         data->valid = 0;
-        init_MUTEX(&data->update_lock);
+        mutex_init(&data->update_lock);
 
         /* Tell the I2C layer a new client has arrived */
         if ((err = i2c_attach_client(new_client)))
@@ -685,7 +686,7 @@ static struct gl520_data *gl520_update_device(struct device *dev)
         struct gl520_data *data = i2c_get_clientdata(client);
         int val;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) {
 
@@ -750,7 +751,7 @@ static struct gl520_data *gl520_update_device(struct device *dev)
                 data->valid = 1;
         }
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return data;
 }
diff --git a/drivers/hwmon/hdaps.c b/drivers/hwmon/hdaps.c
index 23a9e1ea8e..7636c1a58f 100644
--- a/drivers/hwmon/hdaps.c
+++ b/drivers/hwmon/hdaps.c
@@ -33,6 +33,7 @@
 #include <linux/module.h>
 #include <linux/timer.h>
 #include <linux/dmi.h>
+#include <linux/mutex.h>
 #include <asm/io.h>
 
 #define HDAPS_LOW_PORT          0x1600  /* first port used by hdaps */
@@ -70,10 +71,10 @@ static u8 km_activity;
 static int rest_x;
 static int rest_y;
 
-static DECLARE_MUTEX(hdaps_sem);
+static DEFINE_MUTEX(hdaps_mutex);
 
 /*
- * __get_latch - Get the value from a given port.  Callers must hold hdaps_sem.
+ * __get_latch - Get the value from a given port.  Callers must hold hdaps_mutex.
  */
 static inline u8 __get_latch(u16 port)
 {
@@ -82,7 +83,7 @@ static inline u8 __get_latch(u16 port)
 
 /*
  * __check_latch - Check a port latch for a given value.  Returns zero if the
- * port contains the given value.  Callers must hold hdaps_sem.
+ * port contains the given value.  Callers must hold hdaps_mutex.
  */
 static inline int __check_latch(u16 port, u8 val)
 {
@@ -93,7 +94,7 @@ static inline int __check_latch(u16 port, u8 val)
 
 /*
  * __wait_latch - Wait up to 100us for a port latch to get a certain value,
- * returning zero if the value is obtained.  Callers must hold hdaps_sem.
+ * returning zero if the value is obtained.  Callers must hold hdaps_mutex.
  */
 static int __wait_latch(u16 port, u8 val)
 {
@@ -110,7 +111,7 @@ static int __wait_latch(u16 port, u8 val)
 
 /*
  * __device_refresh - request a refresh from the accelerometer.  Does not wait
- * for refresh to complete.  Callers must hold hdaps_sem.
+ * for refresh to complete.  Callers must hold hdaps_mutex.
  */
 static void __device_refresh(void)
 {
@@ -124,7 +125,7 @@ static void __device_refresh(void)
 /*
  * __device_refresh_sync - request a synchronous refresh from the
  * accelerometer.  We wait for the refresh to complete.  Returns zero if
- * successful and nonzero on error.  Callers must hold hdaps_sem.
+ * successful and nonzero on error.  Callers must hold hdaps_mutex.
  */
 static int __device_refresh_sync(void)
 {
@@ -134,7 +135,7 @@ static int __device_refresh_sync(void)
 
 /*
  * __device_complete - indicate to the accelerometer that we are done reading
- * data, and then initiate an async refresh.  Callers must hold hdaps_sem.
+ * data, and then initiate an async refresh.  Callers must hold hdaps_mutex.
  */
 static inline void __device_complete(void)
 {
@@ -152,7 +153,7 @@ static int hdaps_readb_one(unsigned int port, u8 *val)
 {
         int ret;
 
-        down(&hdaps_sem);
+        mutex_lock(&hdaps_mutex);
 
         /* do a sync refresh -- we need to be sure that we read fresh data */
         ret = __device_refresh_sync();
@@ -163,7 +164,7 @@ static int hdaps_readb_one(unsigned int port, u8 *val)
         __device_complete();
 
 out:
-        up(&hdaps_sem);
+        mutex_unlock(&hdaps_mutex);
         return ret;
 }
 
@@ -198,9 +199,9 @@ static int hdaps_read_pair(unsigned int port1, unsigned int port2,
 {
         int ret;
 
-        down(&hdaps_sem);
+        mutex_lock(&hdaps_mutex);
         ret = __hdaps_read_pair(port1, port2, val1, val2);
-        up(&hdaps_sem);
+        mutex_unlock(&hdaps_mutex);
 
         return ret;
 }
@@ -213,7 +214,7 @@ static int hdaps_device_init(void)
 {
         int total, ret = -ENXIO;
 
-        down(&hdaps_sem);
+        mutex_lock(&hdaps_mutex);
 
         outb(0x13, 0x1610);
         outb(0x01, 0x161f);
@@ -279,7 +280,7 @@ static int hdaps_device_init(void)
         }
 
 out:
-        up(&hdaps_sem);
+        mutex_unlock(&hdaps_mutex);
         return ret;
 }
 
@@ -313,7 +314,7 @@ static struct platform_driver hdaps_driver = {
 };
 
 /*
- * hdaps_calibrate - Set our "resting" values.  Callers must hold hdaps_sem.
+ * hdaps_calibrate - Set our "resting" values.  Callers must hold hdaps_mutex.
  */
 static void hdaps_calibrate(void)
 {
@@ -325,7 +326,7 @@ static void hdaps_mousedev_poll(unsigned long unused)
         int x, y;
 
         /* Cannot sleep.  Try nonblockingly.  If we fail, try again later. */
-        if (down_trylock(&hdaps_sem)) {
+        if (!mutex_trylock(&hdaps_mutex)) {
                 mod_timer(&hdaps_timer,jiffies + HDAPS_POLL_PERIOD);
                 return;
         }
@@ -340,7 +341,7 @@ static void hdaps_mousedev_poll(unsigned long unused)
         mod_timer(&hdaps_timer, jiffies + HDAPS_POLL_PERIOD);
 
 out:
-        up(&hdaps_sem);
+        mutex_unlock(&hdaps_mutex);
 }
 
 
@@ -420,9 +421,9 @@ static ssize_t hdaps_calibrate_store(struct device *dev,
                                      struct device_attribute *attr,
                                      const char *buf, size_t count)
 {
-        down(&hdaps_sem);
+        mutex_lock(&hdaps_mutex);
         hdaps_calibrate();
-        up(&hdaps_sem);
+        mutex_unlock(&hdaps_mutex);
 
         return count;
 }
diff --git a/drivers/hwmon/hwmon-vid.c b/drivers/hwmon/hwmon-vid.c
index e497274916..a74a44f16f 100644
--- a/drivers/hwmon/hwmon-vid.c
+++ b/drivers/hwmon/hwmon-vid.c
@@ -54,6 +54,10 @@
     (IMVP-II). You can find more information in the datasheet of Max1718
     http://www.maxim-ic.com/quick_view2.cfm/qv_pk/2452
 
+    The 13 specification corresponds to the Intel Pentium M series. There
+    doesn't seem to be any named specification for these. The conversion
+    tables are detailed directly in the various Pentium M datasheets:
+    http://www.intel.com/design/intarch/pentiumm/docs_pentiumm.htm
 */
 
 /* vrm is the VRM/VRD document version multiplied by 10.
@@ -100,6 +104,8 @@ int vid_from_reg(int val, u8 vrm)
         case 17:                /* Intel IMVP-II */
                 return(val & 0x10 ? 975 - (val & 0xF) * 25 :
                                     1750 - val * 50);
+        case 13:
+                return(1708 - (val & 0x3f) * 16);
         default:                /* report 0 for unknown */
                 printk(KERN_INFO "hwmon-vid: requested unknown VRM version\n");
                 return 0;
@@ -129,8 +135,9 @@ struct vrm_model {
 static struct vrm_model vrm_models[] = {
         {X86_VENDOR_AMD, 0x6, ANY, ANY, 90},            /* Athlon Duron etc */
         {X86_VENDOR_AMD, 0xF, ANY, ANY, 24},            /* Athlon 64, Opteron and above VRM 24 */
-        {X86_VENDOR_INTEL, 0x6, 0x9, ANY, 85},          /* 0.13um too */
+        {X86_VENDOR_INTEL, 0x6, 0x9, ANY, 13},          /* Pentium M (130 nm) */
         {X86_VENDOR_INTEL, 0x6, 0xB, ANY, 85},          /* Tualatin */
+        {X86_VENDOR_INTEL, 0x6, 0xD, ANY, 13},          /* Pentium M (90 nm) */
         {X86_VENDOR_INTEL, 0x6, ANY, ANY, 82},          /* any P6 */
         {X86_VENDOR_INTEL, 0x7, ANY, ANY, 0},           /* Itanium */
         {X86_VENDOR_INTEL, 0xF, 0x0, ANY, 90},          /* P4 */
diff --git a/drivers/hwmon/hwmon.c b/drivers/hwmon/hwmon.c
index dddd3eb9b3..106fa01cdb 100644
--- a/drivers/hwmon/hwmon.c
+++ b/drivers/hwmon/hwmon.c
@@ -17,6 +17,7 @@
 #include <linux/idr.h>
 #include <linux/hwmon.h>
 #include <linux/gfp.h>
+#include <linux/spinlock.h>
 
 #define HWMON_ID_PREFIX "hwmon"
 #define HWMON_ID_FORMAT HWMON_ID_PREFIX "%d"
@@ -24,6 +25,7 @@
 static struct class *hwmon_class;
 
 static DEFINE_IDR(hwmon_idr);
+static DEFINE_SPINLOCK(idr_lock);
 
 /**
  * hwmon_device_register - register w/ hwmon sysfs class
@@ -37,20 +39,30 @@ static DEFINE_IDR(hwmon_idr);
 struct class_device *hwmon_device_register(struct device *dev)
 {
         struct class_device *cdev;
-        int id;
+        int id, err;
 
-        if (idr_pre_get(&hwmon_idr, GFP_KERNEL) == 0)
+again:
+        if (unlikely(idr_pre_get(&hwmon_idr, GFP_KERNEL) == 0))
                 return ERR_PTR(-ENOMEM);
 
-        if (idr_get_new(&hwmon_idr, NULL, &id) < 0)
-                return ERR_PTR(-ENOMEM);
+        spin_lock(&idr_lock);
+        err = idr_get_new(&hwmon_idr, NULL, &id);
+        spin_unlock(&idr_lock);
+
+        if (unlikely(err == -EAGAIN))
+                goto again;
+        else if (unlikely(err))
+                return ERR_PTR(err);
 
         id = id & MAX_ID_MASK;
         cdev = class_device_create(hwmon_class, NULL, MKDEV(0,0), dev,
                                         HWMON_ID_FORMAT, id);
 
-        if (IS_ERR(cdev))
+        if (IS_ERR(cdev)) {
+                spin_lock(&idr_lock);
                 idr_remove(&hwmon_idr, id);
+                spin_unlock(&idr_lock);
+        }
 
         return cdev;
 }
@@ -64,9 +76,11 @@ void hwmon_device_unregister(struct class_device *cdev)
 {
         int id;
 
-        if (sscanf(cdev->class_id, HWMON_ID_FORMAT, &id) == 1) {
+        if (likely(sscanf(cdev->class_id, HWMON_ID_FORMAT, &id) == 1)) {
                 class_device_unregister(cdev);
+                spin_lock(&idr_lock);
                 idr_remove(&hwmon_idr, id);
+                spin_unlock(&idr_lock);
         } else
                 dev_dbg(cdev->dev,
                         "hwmon_device_unregister() failed: bad class ID!\n");
diff --git a/drivers/hwmon/it87.c b/drivers/hwmon/it87.c
index d7a9401600..06df92b3ee 100644
--- a/drivers/hwmon/it87.c
+++ b/drivers/hwmon/it87.c
@@ -41,6 +41,7 @@
 #include <linux/hwmon-sysfs.h>
 #include <linux/hwmon-vid.h>
 #include <linux/err.h>
+#include <linux/mutex.h>
 #include <asm/io.h>
 
 
@@ -194,10 +195,10 @@ static int DIV_TO_REG(int val)
 struct it87_data {
         struct i2c_client client;
         struct class_device *class_dev;
-        struct semaphore lock;
+        struct mutex lock;
         enum chips type;
 
-        struct semaphore update_lock;
+        struct mutex update_lock;
         char valid;             /* !=0 if following fields are valid */
         unsigned long last_updated;     /* In jiffies */
 
@@ -224,9 +225,8 @@ static int it87_isa_attach_adapter(struct i2c_adapter *adapter);
 static int it87_detect(struct i2c_adapter *adapter, int address, int kind);
 static int it87_detach_client(struct i2c_client *client);
 
-static int it87_read_value(struct i2c_client *client, u8 register);
-static int it87_write_value(struct i2c_client *client, u8 register,
-                        u8 value);
+static int it87_read_value(struct i2c_client *client, u8 reg);
+static int it87_write_value(struct i2c_client *client, u8 reg, u8 value);
 static struct it87_data *it87_update_device(struct device *dev);
 static int it87_check_pwm(struct i2c_client *client);
 static void it87_init_client(struct i2c_client *client, struct it87_data *data);
@@ -290,11 +290,11 @@ static ssize_t set_in_min(struct device *dev, struct device_attribute *attr,
         struct it87_data *data = i2c_get_clientdata(client);
         unsigned long val = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->in_min[nr] = IN_TO_REG(val);
         it87_write_value(client, IT87_REG_VIN_MIN(nr), 
                         data->in_min[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 static ssize_t set_in_max(struct device *dev, struct device_attribute *attr,
@@ -307,11 +307,11 @@ static ssize_t set_in_max(struct device *dev, struct device_attribute *attr,
         struct it87_data *data = i2c_get_clientdata(client);
         unsigned long val = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->in_max[nr] = IN_TO_REG(val);
         it87_write_value(client, IT87_REG_VIN_MAX(nr), 
                         data->in_max[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -381,10 +381,10 @@ static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
         struct it87_data *data = i2c_get_clientdata(client);
         int val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp_high[nr] = TEMP_TO_REG(val);
         it87_write_value(client, IT87_REG_TEMP_HIGH(nr), data->temp_high[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr,
@@ -397,10 +397,10 @@ static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr,
         struct it87_data *data = i2c_get_clientdata(client);
         int val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp_low[nr] = TEMP_TO_REG(val);
         it87_write_value(client, IT87_REG_TEMP_LOW(nr), data->temp_low[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 #define show_temp_offset(offset)                                        \
@@ -440,7 +440,7 @@ static ssize_t set_sensor(struct device *dev, struct device_attribute *attr,
         struct it87_data *data = i2c_get_clientdata(client);
         int val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         data->sensor &= ~(1 << nr);
         data->sensor &= ~(8 << nr);
@@ -450,11 +450,11 @@ static ssize_t set_sensor(struct device *dev, struct device_attribute *attr,
         else if (val == 2)
             data->sensor |= 8 << nr;
         else if (val != 0) {
-                up(&data->update_lock);
+                mutex_unlock(&data->update_lock);
                 return -EINVAL;
         }
         it87_write_value(client, IT87_REG_TEMP_ENABLE, data->sensor);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 #define show_sensor_offset(offset)                                      \
@@ -524,7 +524,7 @@ static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
         int val = simple_strtol(buf, NULL, 10);
         u8 reg = it87_read_value(client, IT87_REG_FAN_DIV);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         switch (nr) {
         case 0: data->fan_div[nr] = reg & 0x07; break;
         case 1: data->fan_div[nr] = (reg >> 3) & 0x07; break;
@@ -533,7 +533,7 @@ static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
 
         data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
         it87_write_value(client, IT87_REG_FAN_MIN(nr), data->fan_min[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
@@ -548,7 +548,7 @@ static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
         int i, min[3];
         u8 old;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         old = it87_read_value(client, IT87_REG_FAN_DIV);
 
         for (i = 0; i < 3; i++)
@@ -576,7 +576,7 @@ static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
                 data->fan_min[i]=FAN_TO_REG(min[i], DIV_FROM_REG(data->fan_div[i]));
                 it87_write_value(client, IT87_REG_FAN_MIN(i), data->fan_min[i]);
         }
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 static ssize_t set_pwm_enable(struct device *dev,
@@ -589,7 +589,7 @@ static ssize_t set_pwm_enable(struct device *dev,
         struct it87_data *data = i2c_get_clientdata(client);
         int val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if (val == 0) {
                 int tmp;
@@ -606,11 +606,11 @@ static ssize_t set_pwm_enable(struct device *dev,
                 /* set saved pwm value, clear FAN_CTLX PWM mode bit */
                 it87_write_value(client, IT87_REG_PWM(nr), PWM_TO_REG(data->manual_pwm_ctl[nr]));
         } else {
-                up(&data->update_lock);
+                mutex_unlock(&data->update_lock);
                 return -EINVAL;
         }
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
@@ -626,11 +626,11 @@ static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
         if (val < 0 || val > 255)
                 return -EINVAL;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->manual_pwm_ctl[nr] = val;
         if (data->fan_main_ctrl & (1 << nr))
                 it87_write_value(client, IT87_REG_PWM(nr), PWM_TO_REG(data->manual_pwm_ctl[nr]));
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -776,7 +776,7 @@ static int it87_detect(struct i2c_adapter *adapter, int address, int kind)
 
         new_client = &data->client;
         if (is_isa)
-                init_MUTEX(&data->lock);
+                mutex_init(&data->lock);
         i2c_set_clientdata(new_client, data);
         new_client->addr = address;
         new_client->adapter = adapter;
@@ -823,7 +823,7 @@ static int it87_detect(struct i2c_adapter *adapter, int address, int kind)
         strlcpy(new_client->name, name, I2C_NAME_SIZE);
         data->type = kind;
         data->valid = 0;
-        init_MUTEX(&data->update_lock);
+        mutex_init(&data->update_lock);
 
         /* Tell the I2C layer a new client has arrived */
         if ((err = i2c_attach_client(new_client)))
@@ -950,10 +950,10 @@ static int it87_read_value(struct i2c_client *client, u8 reg)
 
         int res;
         if (i2c_is_isa_client(client)) {
-                down(&data->lock);
+                mutex_lock(&data->lock);
                 outb_p(reg, client->addr + IT87_ADDR_REG_OFFSET);
                 res = inb_p(client->addr + IT87_DATA_REG_OFFSET);
-                up(&data->lock);
+                mutex_unlock(&data->lock);
                 return res;
         } else
                 return i2c_smbus_read_byte_data(client, reg);
@@ -969,10 +969,10 @@ static int it87_write_value(struct i2c_client *client, u8 reg, u8 value)
         struct it87_data *data = i2c_get_clientdata(client);
 
         if (i2c_is_isa_client(client)) {
-                down(&data->lock);
+                mutex_lock(&data->lock);
                 outb_p(reg, client->addr + IT87_ADDR_REG_OFFSET);
                 outb_p(value, client->addr + IT87_DATA_REG_OFFSET);
-                up(&data->lock);
+                mutex_unlock(&data->lock);
                 return 0;
         } else
                 return i2c_smbus_write_byte_data(client, reg, value);
@@ -1098,7 +1098,7 @@ static struct it87_data *it87_update_device(struct device *dev)
         struct it87_data *data = i2c_get_clientdata(client);
         int i;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
             || !data->valid) {
@@ -1160,7 +1160,7 @@ static struct it87_data *it87_update_device(struct device *dev)
                 data->valid = 1;
         }
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return data;
 }
diff --git a/drivers/hwmon/lm63.c b/drivers/hwmon/lm63.c
index 6b1aa7ef55..071f0fc6ad 100644
--- a/drivers/hwmon/lm63.c
+++ b/drivers/hwmon/lm63.c
@@ -45,6 +45,7 @@
 #include <linux/hwmon-sysfs.h>
 #include <linux/hwmon.h>
 #include <linux/err.h>
+#include <linux/mutex.h>
 
 /*
  * Addresses to scan
@@ -153,7 +154,7 @@ static struct i2c_driver lm63_driver = {
 struct lm63_data {
         struct i2c_client client;
         struct class_device *class_dev;
-        struct semaphore update_lock;
+        struct mutex update_lock;
         char valid; /* zero until following fields are valid */
         unsigned long last_updated; /* in jiffies */
 
@@ -192,13 +193,13 @@ static ssize_t set_fan(struct device *dev, struct device_attribute *dummy,
         struct lm63_data *data = i2c_get_clientdata(client);
         unsigned long val = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->fan[1] = FAN_TO_REG(val);
         i2c_smbus_write_byte_data(client, LM63_REG_TACH_LIMIT_LSB,
                                   data->fan[1] & 0xFF);
         i2c_smbus_write_byte_data(client, LM63_REG_TACH_LIMIT_MSB,
                                   data->fan[1] >> 8);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -222,12 +223,12 @@ static ssize_t set_pwm1(struct device *dev, struct device_attribute *dummy,
                 return -EPERM;
 
         val = simple_strtoul(buf, NULL, 10);
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->pwm1_value = val <= 0 ? 0 :
                            val >= 255 ? 2 * data->pwm1_freq :
                            (val * data->pwm1_freq * 2 + 127) / 255;
         i2c_smbus_write_byte_data(client, LM63_REG_PWM_VALUE, data->pwm1_value);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -253,10 +254,10 @@ static ssize_t set_temp8(struct device *dev, struct device_attribute *dummy,
         struct lm63_data *data = i2c_get_clientdata(client);
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp8[1] = TEMP8_TO_REG(val);
         i2c_smbus_write_byte_data(client, LM63_REG_LOCAL_HIGH, data->temp8[1]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -284,13 +285,13 @@ static ssize_t set_temp11(struct device *dev, struct device_attribute *devattr,
         long val = simple_strtol(buf, NULL, 10);
         int nr = attr->index;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp11[nr] = TEMP11_TO_REG(val);
         i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2],
                                   data->temp11[nr] >> 8);
         i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2 + 1],
                                   data->temp11[nr] & 0xff);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -314,11 +315,11 @@ static ssize_t set_temp2_crit_hyst(struct device *dev, struct device_attribute *
         long val = simple_strtol(buf, NULL, 10);
         long hyst;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         hyst = TEMP8_FROM_REG(data->temp8[2]) - val;
         i2c_smbus_write_byte_data(client, LM63_REG_REMOTE_TCRIT_HYST,
                                   HYST_TO_REG(hyst));
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -427,7 +428,7 @@ static int lm63_detect(struct i2c_adapter *adapter, int address, int kind)
 
         strlcpy(new_client->name, "lm63", I2C_NAME_SIZE);
         data->valid = 0;
-        init_MUTEX(&data->update_lock);
+        mutex_init(&data->update_lock);
 
         /* Tell the I2C layer a new client has arrived */
         if ((err = i2c_attach_client(new_client)))
@@ -530,7 +531,7 @@ static struct lm63_data *lm63_update_device(struct device *dev)
         struct i2c_client *client = to_i2c_client(dev);
         struct lm63_data *data = i2c_get_clientdata(client);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {
                 if (data->config & 0x04) { /* tachometer enabled  */
@@ -582,7 +583,7 @@ static struct lm63_data *lm63_update_device(struct device *dev)
                 data->valid = 1;
         }
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return data;
 }
diff --git a/drivers/hwmon/lm75.c b/drivers/hwmon/lm75.c
index 74ca2c8c61..fc25b90ec2 100644
--- a/drivers/hwmon/lm75.c
+++ b/drivers/hwmon/lm75.c
@@ -25,6 +25,7 @@
 #include <linux/i2c.h>
 #include <linux/hwmon.h>
 #include <linux/err.h>
+#include <linux/mutex.h>
 #include "lm75.h"
 
 
@@ -47,7 +48,7 @@ I2C_CLIENT_INSMOD_1(lm75);
 struct lm75_data {
         struct i2c_client       client;
         struct class_device *class_dev;
-        struct semaphore        update_lock;
+        struct mutex            update_lock;
         char                    valid;          /* !=0 if following fields are valid */
         unsigned long           last_updated;   /* In jiffies */
         u16                     temp_input;     /* Register values */
@@ -91,10 +92,10 @@ static ssize_t set_##value(struct device *dev, struct device_attribute *attr, co
         struct lm75_data *data = i2c_get_clientdata(client);    \
         int temp = simple_strtoul(buf, NULL, 10);               \
                                                                 \
-        down(&data->update_lock);                               \
+        mutex_lock(&data->update_lock);                         \
         data->value = LM75_TEMP_TO_REG(temp);                   \
         lm75_write_value(client, reg, data->value);             \
-        up(&data->update_lock);                                 \
+        mutex_unlock(&data->update_lock);                                       \
         return count;                                           \
 }
 set(temp_max, LM75_REG_TEMP_OS);
@@ -188,7 +189,7 @@ static int lm75_detect(struct i2c_adapter *adapter, int address, int kind)
         /* Fill in the remaining client fields and put it into the global list */
         strlcpy(new_client->name, name, I2C_NAME_SIZE);
         data->valid = 0;
-        init_MUTEX(&data->update_lock);
+        mutex_init(&data->update_lock);
 
         /* Tell the I2C layer a new client has arrived */
         if ((err = i2c_attach_client(new_client)))
@@ -264,7 +265,7 @@ static struct lm75_data *lm75_update_device(struct device *dev)
         struct i2c_client *client = to_i2c_client(dev);
         struct lm75_data *data = i2c_get_clientdata(client);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
             || !data->valid) {
@@ -277,7 +278,7 @@ static struct lm75_data *lm75_update_device(struct device *dev)
                 data->valid = 1;
         }
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return data;
 }
diff --git a/drivers/hwmon/lm77.c b/drivers/hwmon/lm77.c
index df9e02aaa7..459cc97738 100644
--- a/drivers/hwmon/lm77.c
+++ b/drivers/hwmon/lm77.c
@@ -32,6 +32,7 @@
 #include <linux/i2c.h>
 #include <linux/hwmon.h>
 #include <linux/err.h>
+#include <linux/mutex.h>
 
 /* Addresses to scan */
 static unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4b, I2C_CLIENT_END };
@@ -51,7 +52,7 @@ I2C_CLIENT_INSMOD_1(lm77);
 struct lm77_data {
         struct i2c_client       client;
         struct class_device *class_dev;
-        struct semaphore        update_lock;
+        struct mutex            update_lock;
         char                    valid;
         unsigned long           last_updated;   /* In jiffies */
         int                     temp_input;     /* Temperatures */
@@ -139,10 +140,10 @@ static ssize_t set_##value(struct device *dev, struct device_attribute *attr, co
         struct lm77_data *data = i2c_get_clientdata(client);                    \
         long val = simple_strtoul(buf, NULL, 10);                               \
                                                                                 \
-        down(&data->update_lock);                                               \
+        mutex_lock(&data->update_lock);                                         \
         data->value = val;                              \
         lm77_write_value(client, reg, LM77_TEMP_TO_REG(data->value));           \
-        up(&data->update_lock);                                                 \
+        mutex_unlock(&data->update_lock);                                       \
         return count;                                                           \
 }
 
@@ -157,11 +158,11 @@ static ssize_t set_temp_crit_hyst(struct device *dev, struct device_attribute *a
         struct lm77_data *data = i2c_get_clientdata(client);
         unsigned long val = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp_hyst = data->temp_crit - val;
         lm77_write_value(client, LM77_REG_TEMP_HYST,
                          LM77_TEMP_TO_REG(data->temp_hyst));
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -173,7 +174,7 @@ static ssize_t set_temp_crit(struct device *dev, struct device_attribute *attr,
         long val = simple_strtoul(buf, NULL, 10);
         int oldcrithyst;
         
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         oldcrithyst = data->temp_crit - data->temp_hyst;
         data->temp_crit = val;
         data->temp_hyst = data->temp_crit - oldcrithyst;
@@ -181,7 +182,7 @@ static ssize_t set_temp_crit(struct device *dev, struct device_attribute *attr,
                          LM77_TEMP_TO_REG(data->temp_crit));
         lm77_write_value(client, LM77_REG_TEMP_HYST,
                          LM77_TEMP_TO_REG(data->temp_hyst));
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -306,7 +307,7 @@ static int lm77_detect(struct i2c_adapter *adapter, int address, int kind)
         /* Fill in the remaining client fields and put it into the global list */
         strlcpy(new_client->name, name, I2C_NAME_SIZE);
         data->valid = 0;
-        init_MUTEX(&data->update_lock);
+        mutex_init(&data->update_lock);
 
         /* Tell the I2C layer a new client has arrived */
         if ((err = i2c_attach_client(new_client)))
@@ -380,7 +381,7 @@ static struct lm77_data *lm77_update_device(struct device *dev)
         struct i2c_client *client = to_i2c_client(dev);
         struct lm77_data *data = i2c_get_clientdata(client);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
             || !data->valid) {
@@ -406,7 +407,7 @@ static struct lm77_data *lm77_update_device(struct device *dev)
                 data->valid = 1;
         }
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return data;
 }
diff --git a/drivers/hwmon/lm78.c b/drivers/hwmon/lm78.c
index e404001e20..94be3d797e 100644
--- a/drivers/hwmon/lm78.c
+++ b/drivers/hwmon/lm78.c
@@ -27,6 +27,7 @@
 #include <linux/hwmon.h>
 #include <linux/hwmon-vid.h>
 #include <linux/err.h>
+#include <linux/mutex.h>
 #include <asm/io.h>
 
 /* Addresses to scan */
@@ -131,10 +132,10 @@ static inline int TEMP_FROM_REG(s8 val)
 struct lm78_data {
         struct i2c_client client;
         struct class_device *class_dev;
-        struct semaphore lock;
+        struct mutex lock;
         enum chips type;
 
-        struct semaphore update_lock;
+        struct mutex update_lock;
         char valid;             /* !=0 if following fields are valid */
         unsigned long last_updated;     /* In jiffies */
 
@@ -157,8 +158,8 @@ static int lm78_isa_attach_adapter(struct i2c_adapter *adapter);
 static int lm78_detect(struct i2c_adapter *adapter, int address, int kind);
 static int lm78_detach_client(struct i2c_client *client);
 
-static int lm78_read_value(struct i2c_client *client, u8 register);
-static int lm78_write_value(struct i2c_client *client, u8 register, u8 value);
+static int lm78_read_value(struct i2c_client *client, u8 reg);
+static int lm78_write_value(struct i2c_client *client, u8 reg, u8 value);
 static struct lm78_data *lm78_update_device(struct device *dev);
 static void lm78_init_client(struct i2c_client *client);
 
@@ -207,10 +208,10 @@ static ssize_t set_in_min(struct device *dev, const char *buf,
         struct lm78_data *data = i2c_get_clientdata(client);
         unsigned long val = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->in_min[nr] = IN_TO_REG(val);
         lm78_write_value(client, LM78_REG_IN_MIN(nr), data->in_min[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -221,10 +222,10 @@ static ssize_t set_in_max(struct device *dev, const char *buf,
         struct lm78_data *data = i2c_get_clientdata(client);
         unsigned long val = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->in_max[nr] = IN_TO_REG(val);
         lm78_write_value(client, LM78_REG_IN_MAX(nr), data->in_max[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
         
@@ -288,10 +289,10 @@ static ssize_t set_temp_over(struct device *dev, struct device_attribute *attr,
         struct lm78_data *data = i2c_get_clientdata(client);
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp_over = TEMP_TO_REG(val);
         lm78_write_value(client, LM78_REG_TEMP_OVER, data->temp_over);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -307,10 +308,10 @@ static ssize_t set_temp_hyst(struct device *dev, struct device_attribute *attr,
         struct lm78_data *data = i2c_get_clientdata(client);
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp_hyst = TEMP_TO_REG(val);
         lm78_write_value(client, LM78_REG_TEMP_HYST, data->temp_hyst);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -342,10 +343,10 @@ static ssize_t set_fan_min(struct device *dev, const char *buf,
         struct lm78_data *data = i2c_get_clientdata(client);
         unsigned long val = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
         lm78_write_value(client, LM78_REG_FAN_MIN(nr), data->fan_min[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -368,7 +369,7 @@ static ssize_t set_fan_div(struct device *dev, const char *buf,
         unsigned long min;
         u8 reg;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         min = FAN_FROM_REG(data->fan_min[nr],
                            DIV_FROM_REG(data->fan_div[nr]));
 
@@ -380,7 +381,7 @@ static ssize_t set_fan_div(struct device *dev, const char *buf,
         default:
                 dev_err(&client->dev, "fan_div value %ld not "
                         "supported. Choose one of 1, 2, 4 or 8!\n", val);
-                up(&data->update_lock);
+                mutex_unlock(&data->update_lock);
                 return -EINVAL;
         }
 
@@ -398,7 +399,7 @@ static ssize_t set_fan_div(struct device *dev, const char *buf,
         data->fan_min[nr] =
                 FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
         lm78_write_value(client, LM78_REG_FAN_MIN(nr), data->fan_min[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return count;
 }
@@ -548,7 +549,7 @@ static int lm78_detect(struct i2c_adapter *adapter, int address, int kind)
 
         new_client = &data->client;
         if (is_isa)
-                init_MUTEX(&data->lock);
+                mutex_init(&data->lock);
         i2c_set_clientdata(new_client, data);
         new_client->addr = address;
         new_client->adapter = adapter;
@@ -598,7 +599,7 @@ static int lm78_detect(struct i2c_adapter *adapter, int address, int kind)
         data->type = kind;
 
         data->valid = 0;
-        init_MUTEX(&data->update_lock);
+        mutex_init(&data->update_lock);
 
         /* Tell the I2C layer a new client has arrived */
         if ((err = i2c_attach_client(new_client)))
@@ -697,10 +698,10 @@ static int lm78_read_value(struct i2c_client *client, u8 reg)
         int res;
         if (i2c_is_isa_client(client)) {
                 struct lm78_data *data = i2c_get_clientdata(client);
-                down(&data->lock);
+                mutex_lock(&data->lock);
                 outb_p(reg, client->addr + LM78_ADDR_REG_OFFSET);
                 res = inb_p(client->addr + LM78_DATA_REG_OFFSET);
-                up(&data->lock);
+                mutex_unlock(&data->lock);
                 return res;
         } else
                 return i2c_smbus_read_byte_data(client, reg);
@@ -717,10 +718,10 @@ static int lm78_write_value(struct i2c_client *client, u8 reg, u8 value)
 {
         if (i2c_is_isa_client(client)) {
                 struct lm78_data *data = i2c_get_clientdata(client);
-                down(&data->lock);
+                mutex_lock(&data->lock);
                 outb_p(reg, client->addr + LM78_ADDR_REG_OFFSET);
                 outb_p(value, client->addr + LM78_DATA_REG_OFFSET);
-                up(&data->lock);
+                mutex_unlock(&data->lock);
                 return 0;
         } else
                 return i2c_smbus_write_byte_data(client, reg, value);
@@ -742,7 +743,7 @@ static struct lm78_data *lm78_update_device(struct device *dev)
         struct lm78_data *data = i2c_get_clientdata(client);
         int i;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
             || !data->valid) {
@@ -786,7 +787,7 @@ static struct lm78_data *lm78_update_device(struct device *dev)
                 data->fan_div[2] = 1;
         }
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return data;
 }
diff --git a/drivers/hwmon/lm80.c b/drivers/hwmon/lm80.c
index c9a7cdea7b..f72120d08c 100644
--- a/drivers/hwmon/lm80.c
+++ b/drivers/hwmon/lm80.c
@@ -28,6 +28,7 @@
 #include <linux/i2c.h>
 #include <linux/hwmon.h>
 #include <linux/err.h>
+#include <linux/mutex.h>
 
 /* Addresses to scan */
 static unsigned short normal_i2c[] = { 0x28, 0x29, 0x2a, 0x2b, 0x2c,
@@ -108,7 +109,7 @@ static inline long TEMP_FROM_REG(u16 temp)
 struct lm80_data {
         struct i2c_client client;
         struct class_device *class_dev;
-        struct semaphore update_lock;
+        struct mutex update_lock;
         char valid;             /* !=0 if following fields are valid */
         unsigned long last_updated;     /* In jiffies */
 
@@ -191,10 +192,10 @@ static ssize_t set_in_##suffix(struct device *dev, struct device_attribute *attr
         struct lm80_data *data = i2c_get_clientdata(client); \
         long val = simple_strtol(buf, NULL, 10); \
  \
-        down(&data->update_lock);\
+        mutex_lock(&data->update_lock);\
         data->value = IN_TO_REG(val); \
         lm80_write_value(client, reg, data->value); \
-        up(&data->update_lock);\
+        mutex_unlock(&data->update_lock);\
         return count; \
 }
 set_in(min0, in_min[0], LM80_REG_IN_MIN(0));
@@ -241,10 +242,10 @@ static ssize_t set_fan_##suffix(struct device *dev, struct device_attribute *att
         struct lm80_data *data = i2c_get_clientdata(client); \
         long val = simple_strtoul(buf, NULL, 10); \
  \
-        down(&data->update_lock);\
+        mutex_lock(&data->update_lock);\
         data->value = FAN_TO_REG(val, DIV_FROM_REG(data->div)); \
         lm80_write_value(client, reg, data->value); \
-        up(&data->update_lock);\
+        mutex_unlock(&data->update_lock);\
         return count; \
 }
 set_fan(min1, fan_min[0], LM80_REG_FAN_MIN(1), fan_div[0]);
@@ -263,7 +264,7 @@ static ssize_t set_fan_div(struct device *dev, const char *buf,
         u8 reg;
 
         /* Save fan_min */
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         min = FAN_FROM_REG(data->fan_min[nr],
                            DIV_FROM_REG(data->fan_div[nr]));
 
@@ -275,7 +276,7 @@ static ssize_t set_fan_div(struct device *dev, const char *buf,
         default:
                 dev_err(&client->dev, "fan_div value %ld not "
                         "supported. Choose one of 1, 2, 4 or 8!\n", val);
-                up(&data->update_lock);
+                mutex_unlock(&data->update_lock);
                 return -EINVAL;
         }
 
@@ -286,7 +287,7 @@ static ssize_t set_fan_div(struct device *dev, const char *buf,
         /* Restore fan_min */
         data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
         lm80_write_value(client, LM80_REG_FAN_MIN(nr + 1), data->fan_min[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return count;
 }
@@ -325,10 +326,10 @@ static ssize_t set_temp_##suffix(struct device *dev, struct device_attribute *at
         struct lm80_data *data = i2c_get_clientdata(client); \
         long val = simple_strtoul(buf, NULL, 10); \
  \
-        down(&data->update_lock); \
+        mutex_lock(&data->update_lock); \
         data->value = TEMP_LIMIT_TO_REG(val); \
         lm80_write_value(client, reg, data->value); \
-        up(&data->update_lock); \
+        mutex_unlock(&data->update_lock); \
         return count; \
 }
 set_temp(hot_max, temp_hot_max, LM80_REG_TEMP_HOT_MAX);
@@ -437,7 +438,7 @@ static int lm80_detect(struct i2c_adapter *adapter, int address, int kind)
         /* Fill in the remaining client fields and put it into the global list */
         strlcpy(new_client->name, name, I2C_NAME_SIZE);
         data->valid = 0;
-        init_MUTEX(&data->update_lock);
+        mutex_init(&data->update_lock);
 
         /* Tell the I2C layer a new client has arrived */
         if ((err = i2c_attach_client(new_client)))
@@ -545,7 +546,7 @@ static struct lm80_data *lm80_update_device(struct device *dev)
         struct lm80_data *data = i2c_get_clientdata(client);
         int i;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) {
                 dev_dbg(&client->dev, "Starting lm80 update\n");
@@ -585,7 +586,7 @@ static struct lm80_data *lm80_update_device(struct device *dev)
                 data->valid = 1;
         }
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return data;
 }
diff --git a/drivers/hwmon/lm83.c b/drivers/hwmon/lm83.c
index 26dfa9e216..aac4ec2bf6 100644
--- a/drivers/hwmon/lm83.c
+++ b/drivers/hwmon/lm83.c
@@ -35,6 +35,7 @@
 #include <linux/hwmon-sysfs.h>
 #include <linux/hwmon.h>
 #include <linux/err.h>
+#include <linux/mutex.h>
 
 /*
  * Addresses to scan
@@ -139,7 +140,7 @@ static struct i2c_driver lm83_driver = {
 struct lm83_data {
         struct i2c_client client;
         struct class_device *class_dev;
-        struct semaphore update_lock;
+        struct mutex update_lock;
         char valid; /* zero until following fields are valid */
         unsigned long last_updated; /* in jiffies */
 
@@ -171,11 +172,11 @@ static ssize_t set_temp(struct device *dev, struct device_attribute *devattr,
         long val = simple_strtol(buf, NULL, 10);
         int nr = attr->index;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp[nr] = TEMP_TO_REG(val);
         i2c_smbus_write_byte_data(client, LM83_REG_W_HIGH[nr - 4],
                                   data->temp[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -300,7 +301,7 @@ static int lm83_detect(struct i2c_adapter *adapter, int address, int kind)
         /* We can fill in the remaining client fields */
         strlcpy(new_client->name, name, I2C_NAME_SIZE);
         data->valid = 0;
-        init_MUTEX(&data->update_lock);
+        mutex_init(&data->update_lock);
 
         /* Tell the I2C layer a new client has arrived */
         if ((err = i2c_attach_client(new_client)))
@@ -373,7 +374,7 @@ static struct lm83_data *lm83_update_device(struct device *dev)
         struct i2c_client *client = to_i2c_client(dev);
         struct lm83_data *data = i2c_get_clientdata(client);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if (time_after(jiffies, data->last_updated + HZ * 2) || !data->valid) {
                 int nr;
@@ -393,7 +394,7 @@ static struct lm83_data *lm83_update_device(struct device *dev)
                 data->valid = 1;
         }
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return data;
 }
diff --git a/drivers/hwmon/lm85.c b/drivers/hwmon/lm85.c
index 7389a01275..342e966311 100644
--- a/drivers/hwmon/lm85.c
+++ b/drivers/hwmon/lm85.c
@@ -31,6 +31,7 @@
 #include <linux/hwmon.h>
 #include <linux/hwmon-vid.h>
 #include <linux/err.h>
+#include <linux/mutex.h>
 
 /* Addresses to scan */
 static unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END };
@@ -331,10 +332,10 @@ struct lm85_autofan {
 struct lm85_data {
         struct i2c_client client;
         struct class_device *class_dev;
-        struct semaphore lock;
+        struct mutex lock;
         enum chips type;
 
-        struct semaphore update_lock;
+        struct mutex update_lock;
         int valid;              /* !=0 if following fields are valid */
         unsigned long last_reading;     /* In jiffies */
         unsigned long last_config;      /* In jiffies */
@@ -373,8 +374,8 @@ static int lm85_detect(struct i2c_adapter *adapter, int address,
                         int kind);
 static int lm85_detach_client(struct i2c_client *client);
 
-static int lm85_read_value(struct i2c_client *client, u8 register);
-static int lm85_write_value(struct i2c_client *client, u8 register, int value);
+static int lm85_read_value(struct i2c_client *client, u8 reg);
+static int lm85_write_value(struct i2c_client *client, u8 reg, int value);
 static struct lm85_data *lm85_update_device(struct device *dev);
 static void lm85_init_client(struct i2c_client *client);
 
@@ -407,10 +408,10 @@ static ssize_t set_fan_min(struct device *dev, const char *buf,
         struct lm85_data *data = i2c_get_clientdata(client);
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->fan_min[nr] = FAN_TO_REG(val);
         lm85_write_value(client, LM85_REG_FAN_MIN(nr), data->fan_min[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -499,10 +500,10 @@ static ssize_t set_pwm(struct device *dev, const char *buf,
         struct lm85_data *data = i2c_get_clientdata(client);
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->pwm[nr] = PWM_TO_REG(val);
         lm85_write_value(client, LM85_REG_PWM(nr), data->pwm[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 static ssize_t show_pwm_enable(struct device *dev, char *buf, int nr)
@@ -559,10 +560,10 @@ static ssize_t set_in_min(struct device *dev, const char *buf,
         struct lm85_data *data = i2c_get_clientdata(client);
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->in_min[nr] = INS_TO_REG(nr, val);
         lm85_write_value(client, LM85_REG_IN_MIN(nr), data->in_min[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 static ssize_t show_in_max(struct device *dev, char *buf, int nr)
@@ -577,10 +578,10 @@ static ssize_t set_in_max(struct device *dev, const char *buf,
         struct lm85_data *data = i2c_get_clientdata(client);
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->in_max[nr] = INS_TO_REG(nr, val);
         lm85_write_value(client, LM85_REG_IN_MAX(nr), data->in_max[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 #define show_in_reg(offset)                                             \
@@ -640,10 +641,10 @@ static ssize_t set_temp_min(struct device *dev, const char *buf,
         struct lm85_data *data = i2c_get_clientdata(client);
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp_min[nr] = TEMP_TO_REG(val);
         lm85_write_value(client, LM85_REG_TEMP_MIN(nr), data->temp_min[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 static ssize_t show_temp_max(struct device *dev, char *buf, int nr)
@@ -658,10 +659,10 @@ static ssize_t set_temp_max(struct device *dev, const char *buf,
         struct lm85_data *data = i2c_get_clientdata(client);
         long val = simple_strtol(buf, NULL, 10);        
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp_max[nr] = TEMP_TO_REG(val);
         lm85_write_value(client, LM85_REG_TEMP_MAX(nr), data->temp_max[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 #define show_temp_reg(offset)                                           \
@@ -713,12 +714,12 @@ static ssize_t set_pwm_auto_channels(struct device *dev, const char *buf,
         struct lm85_data *data = i2c_get_clientdata(client);
         long val = simple_strtol(buf, NULL, 10);   
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->autofan[nr].config = (data->autofan[nr].config & (~0xe0))
                 | ZONE_TO_REG(val) ;
         lm85_write_value(client, LM85_REG_AFAN_CONFIG(nr),
                 data->autofan[nr].config);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 static ssize_t show_pwm_auto_pwm_min(struct device *dev, char *buf, int nr)
@@ -733,11 +734,11 @@ static ssize_t set_pwm_auto_pwm_min(struct device *dev, const char *buf,
         struct lm85_data *data = i2c_get_clientdata(client);
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->autofan[nr].min_pwm = PWM_TO_REG(val);
         lm85_write_value(client, LM85_REG_AFAN_MINPWM(nr),
                 data->autofan[nr].min_pwm);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 static ssize_t show_pwm_auto_pwm_minctl(struct device *dev, char *buf, int nr)
@@ -752,7 +753,7 @@ static ssize_t set_pwm_auto_pwm_minctl(struct device *dev, const char *buf,
         struct lm85_data *data = i2c_get_clientdata(client);
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->autofan[nr].min_off = val;
         lm85_write_value(client, LM85_REG_AFAN_SPIKE1, data->smooth[0]
                 | data->syncpwm3
@@ -760,7 +761,7 @@ static ssize_t set_pwm_auto_pwm_minctl(struct device *dev, const char *buf,
                 | (data->autofan[1].min_off ? 0x40 : 0)
                 | (data->autofan[2].min_off ? 0x80 : 0)
         );
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 static ssize_t show_pwm_auto_pwm_freq(struct device *dev, char *buf, int nr)
@@ -775,13 +776,13 @@ static ssize_t set_pwm_auto_pwm_freq(struct device *dev, const char *buf,
         struct lm85_data *data = i2c_get_clientdata(client);
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->autofan[nr].freq = FREQ_TO_REG(val);
         lm85_write_value(client, LM85_REG_AFAN_RANGE(nr),
                 (data->zone[nr].range << 4)
                 | data->autofan[nr].freq
         ); 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 #define pwm_auto(offset)                                                \
@@ -857,7 +858,7 @@ static ssize_t set_temp_auto_temp_off(struct device *dev, const char *buf,
         int min;
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         min = TEMP_FROM_REG(data->zone[nr].limit);
         data->zone[nr].off_desired = TEMP_TO_REG(val);
         data->zone[nr].hyst = HYST_TO_REG(min - val);
@@ -871,7 +872,7 @@ static ssize_t set_temp_auto_temp_off(struct device *dev, const char *buf,
                         (data->zone[2].hyst << 4)
                 );
         }
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 static ssize_t show_temp_auto_temp_min(struct device *dev, char *buf, int nr)
@@ -886,7 +887,7 @@ static ssize_t set_temp_auto_temp_min(struct device *dev, const char *buf,
         struct lm85_data *data = i2c_get_clientdata(client);
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->zone[nr].limit = TEMP_TO_REG(val);
         lm85_write_value(client, LM85_REG_AFAN_LIMIT(nr),
                 data->zone[nr].limit);
@@ -913,7 +914,7 @@ static ssize_t set_temp_auto_temp_min(struct device *dev, const char *buf,
                         (data->zone[2].hyst << 4)
                 );
         }
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 static ssize_t show_temp_auto_temp_max(struct device *dev, char *buf, int nr)
@@ -930,7 +931,7 @@ static ssize_t set_temp_auto_temp_max(struct device *dev, const char *buf,
         int min;
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         min = TEMP_FROM_REG(data->zone[nr].limit);
         data->zone[nr].max_desired = TEMP_TO_REG(val);
         data->zone[nr].range = RANGE_TO_REG(
@@ -938,7 +939,7 @@ static ssize_t set_temp_auto_temp_max(struct device *dev, const char *buf,
         lm85_write_value(client, LM85_REG_AFAN_RANGE(nr),
                 ((data->zone[nr].range & 0x0f) << 4)
                 | (data->autofan[nr].freq & 0x07));
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 static ssize_t show_temp_auto_temp_crit(struct device *dev, char *buf, int nr)
@@ -953,11 +954,11 @@ static ssize_t set_temp_auto_temp_crit(struct device *dev, const char *buf,
         struct lm85_data *data = i2c_get_clientdata(client);
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->zone[nr].critical = TEMP_TO_REG(val);
         lm85_write_value(client, LM85_REG_AFAN_CRITICAL(nr),
                 data->zone[nr].critical);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 #define temp_auto(offset)                                               \
@@ -1149,7 +1150,7 @@ static int lm85_detect(struct i2c_adapter *adapter, int address,
         /* Fill in the remaining client fields */
         data->type = kind;
         data->valid = 0;
-        init_MUTEX(&data->update_lock);
+        mutex_init(&data->update_lock);
 
         /* Tell the I2C layer a new client has arrived */
         if ((err = i2c_attach_client(new_client)))
@@ -1368,7 +1369,7 @@ static struct lm85_data *lm85_update_device(struct device *dev)
         struct lm85_data *data = i2c_get_clientdata(client);
         int i;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if ( !data->valid ||
              time_after(jiffies, data->last_reading + LM85_DATA_INTERVAL) ) {
@@ -1571,7 +1572,7 @@ static struct lm85_data *lm85_update_device(struct device *dev)
 
         data->valid = 1;
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return data;
 }
diff --git a/drivers/hwmon/lm87.c b/drivers/hwmon/lm87.c
index 6ba34c302d..e229daf666 100644
--- a/drivers/hwmon/lm87.c
+++ b/drivers/hwmon/lm87.c
@@ -60,6 +60,7 @@
 #include <linux/hwmon.h>
 #include <linux/hwmon-vid.h>
 #include <linux/err.h>
+#include <linux/mutex.h>
 
 /*
  * Addresses to scan
@@ -176,7 +177,7 @@ static struct i2c_driver lm87_driver = {
 struct lm87_data {
         struct i2c_client client;
         struct class_device *class_dev;
-        struct semaphore update_lock;
+        struct mutex update_lock;
         char valid; /* zero until following fields are valid */
         unsigned long last_updated; /* In jiffies */
 
@@ -253,11 +254,11 @@ static void set_in_min(struct device *dev, const char *buf, int nr)
         struct lm87_data *data = i2c_get_clientdata(client);
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->in_min[nr] = IN_TO_REG(val, data->in_scale[nr]);
         lm87_write_value(client, nr<6 ? LM87_REG_IN_MIN(nr) :
                          LM87_REG_AIN_MIN(nr-6), data->in_min[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 }
 
 static void set_in_max(struct device *dev, const char *buf, int nr)
@@ -266,11 +267,11 @@ static void set_in_max(struct device *dev, const char *buf, int nr)
         struct lm87_data *data = i2c_get_clientdata(client);
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->in_max[nr] = IN_TO_REG(val, data->in_scale[nr]);
         lm87_write_value(client, nr<6 ? LM87_REG_IN_MAX(nr) :
                          LM87_REG_AIN_MAX(nr-6), data->in_max[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 }
 
 #define set_in(offset) \
@@ -327,10 +328,10 @@ static void set_temp_low(struct device *dev, const char *buf, int nr)
         struct lm87_data *data = i2c_get_clientdata(client);
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp_low[nr] = TEMP_TO_REG(val);
         lm87_write_value(client, LM87_REG_TEMP_LOW[nr], data->temp_low[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 }
 
 static void set_temp_high(struct device *dev, const char *buf, int nr)
@@ -339,10 +340,10 @@ static void set_temp_high(struct device *dev, const char *buf, int nr)
         struct lm87_data *data = i2c_get_clientdata(client);
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp_high[nr] = TEMP_TO_REG(val);
         lm87_write_value(client, LM87_REG_TEMP_HIGH[nr], data->temp_high[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 }
 
 #define set_temp(offset) \
@@ -411,11 +412,11 @@ static void set_fan_min(struct device *dev, const char *buf, int nr)
         struct lm87_data *data = i2c_get_clientdata(client);
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->fan_min[nr] = FAN_TO_REG(val,
                             FAN_DIV_FROM_REG(data->fan_div[nr]));
         lm87_write_value(client, LM87_REG_FAN_MIN(nr), data->fan_min[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 }
 
 /* Note: we save and restore the fan minimum here, because its value is
@@ -431,7 +432,7 @@ static ssize_t set_fan_div(struct device *dev, const char *buf,
         unsigned long min;
         u8 reg;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         min = FAN_FROM_REG(data->fan_min[nr],
                            FAN_DIV_FROM_REG(data->fan_div[nr]));
 
@@ -441,7 +442,7 @@ static ssize_t set_fan_div(struct device *dev, const char *buf,
         case 4: data->fan_div[nr] = 2; break;
         case 8: data->fan_div[nr] = 3; break;
         default:
-                up(&data->update_lock);
+                mutex_unlock(&data->update_lock);
                 return -EINVAL;
         }
 
@@ -459,7 +460,7 @@ static ssize_t set_fan_div(struct device *dev, const char *buf,
         data->fan_min[nr] = FAN_TO_REG(min, val);
         lm87_write_value(client, LM87_REG_FAN_MIN(nr),
                          data->fan_min[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return count;
 }
@@ -522,10 +523,10 @@ static ssize_t set_aout(struct device *dev, struct device_attribute *attr, const
         struct lm87_data *data = i2c_get_clientdata(client);
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->aout = AOUT_TO_REG(val);
         lm87_write_value(client, LM87_REG_AOUT, data->aout);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 static DEVICE_ATTR(aout_output, S_IRUGO | S_IWUSR, show_aout, set_aout);
@@ -589,7 +590,7 @@ static int lm87_detect(struct i2c_adapter *adapter, int address, int kind)
         /* We can fill in the remaining client fields */
         strlcpy(new_client->name, "lm87", I2C_NAME_SIZE);
         data->valid = 0;
-        init_MUTEX(&data->update_lock);
+        mutex_init(&data->update_lock);
 
         /* Tell the I2C layer a new client has arrived */
         if ((err = i2c_attach_client(new_client)))
@@ -744,7 +745,7 @@ static struct lm87_data *lm87_update_device(struct device *dev)
         struct i2c_client *client = to_i2c_client(dev);
         struct lm87_data *data = i2c_get_clientdata(client);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {
                 int i, j;
@@ -813,7 +814,7 @@ static struct lm87_data *lm87_update_device(struct device *dev)
                 data->valid = 1;
         }
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return data;
 }
diff --git a/drivers/hwmon/lm90.c b/drivers/hwmon/lm90.c
index 5679464447..d9eeaf7585 100644
--- a/drivers/hwmon/lm90.c
+++ b/drivers/hwmon/lm90.c
@@ -78,6 +78,7 @@
 #include <linux/hwmon-sysfs.h>
 #include <linux/hwmon.h>
 #include <linux/err.h>
+#include <linux/mutex.h>
 
 /*
  * Addresses to scan
@@ -201,7 +202,7 @@ static struct i2c_driver lm90_driver = {
 struct lm90_data {
         struct i2c_client client;
         struct class_device *class_dev;
-        struct semaphore update_lock;
+        struct mutex update_lock;
         char valid; /* zero until following fields are valid */
         unsigned long last_updated; /* in jiffies */
         int kind;
@@ -247,13 +248,13 @@ static ssize_t set_temp8(struct device *dev, struct device_attribute *devattr,
         long val = simple_strtol(buf, NULL, 10);
         int nr = attr->index;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         if (data->kind == adt7461)
                 data->temp8[nr] = TEMP1_TO_REG_ADT7461(val);
         else
                 data->temp8[nr] = TEMP1_TO_REG(val);
         i2c_smbus_write_byte_data(client, reg[nr - 1], data->temp8[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -281,7 +282,7 @@ static ssize_t set_temp11(struct device *dev, struct device_attribute *devattr,
         long val = simple_strtol(buf, NULL, 10);
         int nr = attr->index;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         if (data->kind == adt7461)
                 data->temp11[nr] = TEMP2_TO_REG_ADT7461(val);
         else
@@ -290,7 +291,7 @@ static ssize_t set_temp11(struct device *dev, struct device_attribute *devattr,
                                   data->temp11[nr] >> 8);
         i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2 + 1],
                                   data->temp11[nr] & 0xff);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -311,11 +312,11 @@ static ssize_t set_temphyst(struct device *dev, struct device_attribute *dummy,
         long val = simple_strtol(buf, NULL, 10);
         long hyst;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         hyst = TEMP1_FROM_REG(data->temp8[3]) - val;
         i2c_smbus_write_byte_data(client, LM90_REG_W_TCRIT_HYST,
                                   HYST_TO_REG(hyst));
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -558,7 +559,7 @@ static int lm90_detect(struct i2c_adapter *adapter, int address, int kind)
         strlcpy(new_client->name, name, I2C_NAME_SIZE);
         data->valid = 0;
         data->kind = kind;
-        init_MUTEX(&data->update_lock);
+        mutex_init(&data->update_lock);
 
         /* Tell the I2C layer a new client has arrived */
         if ((err = i2c_attach_client(new_client)))
@@ -646,7 +647,7 @@ static struct lm90_data *lm90_update_device(struct device *dev)
         struct i2c_client *client = to_i2c_client(dev);
         struct lm90_data *data = i2c_get_clientdata(client);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if (time_after(jiffies, data->last_updated + HZ * 2) || !data->valid) {
                 u8 oldh, newh, l;
@@ -692,7 +693,7 @@ static struct lm90_data *lm90_update_device(struct device *dev)
                 data->valid = 1;
         }
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return data;
 }
diff --git a/drivers/hwmon/lm92.c b/drivers/hwmon/lm92.c
index b0c4cb730a..197f77226d 100644
--- a/drivers/hwmon/lm92.c
+++ b/drivers/hwmon/lm92.c
@@ -46,6 +46,7 @@
 #include <linux/i2c.h>
 #include <linux/hwmon.h>
 #include <linux/err.h>
+#include <linux/mutex.h>
 
 /* The LM92 and MAX6635 have 2 two-state pins for address selection,
    resulting in 4 possible addresses. */
@@ -96,7 +97,7 @@ static struct i2c_driver lm92_driver;
 struct lm92_data {
         struct i2c_client client;
         struct class_device *class_dev;
-        struct semaphore update_lock;
+        struct mutex update_lock;
         char valid; /* zero until following fields are valid */
         unsigned long last_updated; /* in jiffies */
 
@@ -114,7 +115,7 @@ static struct lm92_data *lm92_update_device(struct device *dev)
         struct i2c_client *client = to_i2c_client(dev);
         struct lm92_data *data = i2c_get_clientdata(client);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if (time_after(jiffies, data->last_updated + HZ)
          || !data->valid) {
@@ -134,7 +135,7 @@ static struct lm92_data *lm92_update_device(struct device *dev)
                 data->valid = 1;
         }
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return data;
 }
@@ -158,10 +159,10 @@ static ssize_t set_##value(struct device *dev, struct device_attribute *attr, co
         struct lm92_data *data = i2c_get_clientdata(client); \
         long val = simple_strtol(buf, NULL, 10); \
  \
-        down(&data->update_lock); \
+        mutex_lock(&data->update_lock); \
         data->value = TEMP_TO_REG(val); \
         i2c_smbus_write_word_data(client, reg, swab16(data->value)); \
-        up(&data->update_lock); \
+        mutex_unlock(&data->update_lock); \
         return count; \
 }
 set_temp(temp1_crit, LM92_REG_TEMP_CRIT);
@@ -194,11 +195,11 @@ static ssize_t set_temp1_crit_hyst(struct device *dev, struct device_attribute *
         struct lm92_data *data = i2c_get_clientdata(client);
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp1_hyst = TEMP_FROM_REG(data->temp1_crit) - val;
         i2c_smbus_write_word_data(client, LM92_REG_TEMP_HYST,
                                   swab16(TEMP_TO_REG(data->temp1_hyst)));
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -348,7 +349,7 @@ static int lm92_detect(struct i2c_adapter *adapter, int address, int kind)
         /* Fill in the remaining client fields */
         strlcpy(new_client->name, name, I2C_NAME_SIZE);
         data->valid = 0;
-        init_MUTEX(&data->update_lock);
+        mutex_init(&data->update_lock);
 
         /* Tell the i2c subsystem a new client has arrived */
         if ((err = i2c_attach_client(new_client)))
diff --git a/drivers/hwmon/max1619.c b/drivers/hwmon/max1619.c
index 3abe330b22..b4135b5971 100644
--- a/drivers/hwmon/max1619.c
+++ b/drivers/hwmon/max1619.c
@@ -33,6 +33,7 @@
 #include <linux/i2c.h>
 #include <linux/hwmon.h>
 #include <linux/err.h>
+#include <linux/mutex.h>
 
 static unsigned short normal_i2c[] = { 0x18, 0x19, 0x1a,
                                         0x29, 0x2a, 0x2b,
@@ -104,7 +105,7 @@ static struct i2c_driver max1619_driver = {
 struct max1619_data {
         struct i2c_client client;
         struct class_device *class_dev;
-        struct semaphore update_lock;
+        struct mutex update_lock;
         char valid; /* zero until following fields are valid */
         unsigned long last_updated; /* in jiffies */
 
@@ -141,10 +142,10 @@ static ssize_t set_##value(struct device *dev, struct device_attribute *attr, co
         struct max1619_data *data = i2c_get_clientdata(client); \
         long val = simple_strtol(buf, NULL, 10); \
  \
-        down(&data->update_lock); \
+        mutex_lock(&data->update_lock); \
         data->value = TEMP_TO_REG(val); \
         i2c_smbus_write_byte_data(client, reg, data->value); \
-        up(&data->update_lock); \
+        mutex_unlock(&data->update_lock); \
         return count; \
 }
 
@@ -262,7 +263,7 @@ static int max1619_detect(struct i2c_adapter *adapter, int address, int kind)
         /* We can fill in the remaining client fields */
         strlcpy(new_client->name, name, I2C_NAME_SIZE);
         data->valid = 0;
-        init_MUTEX(&data->update_lock);
+        mutex_init(&data->update_lock);
 
         /* Tell the I2C layer a new client has arrived */
         if ((err = i2c_attach_client(new_client)))
@@ -330,7 +331,7 @@ static struct max1619_data *max1619_update_device(struct device *dev)
         struct i2c_client *client = to_i2c_client(dev);
         struct max1619_data *data = i2c_get_clientdata(client);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if (time_after(jiffies, data->last_updated + HZ * 2) || !data->valid) {
                 dev_dbg(&client->dev, "Updating max1619 data.\n");
@@ -353,7 +354,7 @@ static struct max1619_data *max1619_update_device(struct device *dev)
                 data->valid = 1;
         }
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return data;
 }
diff --git a/drivers/hwmon/pc87360.c b/drivers/hwmon/pc87360.c
index f161e88e3b..ae05e483a7 100644
--- a/drivers/hwmon/pc87360.c
+++ b/drivers/hwmon/pc87360.c
@@ -43,6 +43,7 @@
 #include <linux/hwmon-sysfs.h>
 #include <linux/hwmon-vid.h>
 #include <linux/err.h>
+#include <linux/mutex.h>
 #include <asm/io.h>
 
 static u8 devid;
@@ -183,8 +184,8 @@ static inline u8 PWM_TO_REG(int val, int inv)
 struct pc87360_data {
         struct i2c_client client;
         struct class_device *class_dev;
-        struct semaphore lock;
-        struct semaphore update_lock;
+        struct mutex lock;
+        struct mutex update_lock;
         char valid;             /* !=0 if following fields are valid */
         unsigned long last_updated;     /* In jiffies */
 
@@ -283,7 +284,7 @@ static ssize_t set_fan_min(struct device *dev, struct device_attribute *devattr,
         struct pc87360_data *data = i2c_get_clientdata(client);
         long fan_min = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         fan_min = FAN_TO_REG(fan_min, FAN_DIV_FROM_REG(data->fan_status[attr->index]));
 
         /* If it wouldn't fit, change clock divisor */
@@ -300,23 +301,31 @@ static ssize_t set_fan_min(struct device *dev, struct device_attribute *devattr,
         /* Write new divider, preserve alarm bits */
         pc87360_write_value(data, LD_FAN, NO_BANK, PC87360_REG_FAN_STATUS(attr->index),
                             data->fan_status[attr->index] & 0xF9);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return count;
 }
 
-#define show_and_set_fan(offset) \
-static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
-        show_fan_input, NULL, offset-1); \
-static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IWUSR | S_IRUGO, \
-        show_fan_min, set_fan_min, offset-1); \
-static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO, \
-        show_fan_div, NULL, offset-1); \
-static SENSOR_DEVICE_ATTR(fan##offset##_status, S_IRUGO, \
-        show_fan_status, NULL, offset-1);
-show_and_set_fan(1)
-show_and_set_fan(2)
-show_and_set_fan(3)
+static struct sensor_device_attribute fan_input[] = {
+        SENSOR_ATTR(fan1_input, S_IRUGO, show_fan_input, NULL, 0),
+        SENSOR_ATTR(fan2_input, S_IRUGO, show_fan_input, NULL, 1),
+        SENSOR_ATTR(fan3_input, S_IRUGO, show_fan_input, NULL, 2),
+};
+static struct sensor_device_attribute fan_status[] = {
+        SENSOR_ATTR(fan1_status, S_IRUGO, show_fan_status, NULL, 0),
+        SENSOR_ATTR(fan2_status, S_IRUGO, show_fan_status, NULL, 1),
+        SENSOR_ATTR(fan3_status, S_IRUGO, show_fan_status, NULL, 2),
+};
+static struct sensor_device_attribute fan_div[] = {
+        SENSOR_ATTR(fan1_div, S_IRUGO, show_fan_div, NULL, 0),
+        SENSOR_ATTR(fan2_div, S_IRUGO, show_fan_div, NULL, 1),
+        SENSOR_ATTR(fan3_div, S_IRUGO, show_fan_div, NULL, 2),
+};
+static struct sensor_device_attribute fan_min[] = {
+        SENSOR_ATTR(fan1_min, S_IWUSR | S_IRUGO, show_fan_min, set_fan_min, 0),
+        SENSOR_ATTR(fan2_min, S_IWUSR | S_IRUGO, show_fan_min, set_fan_min, 1),
+        SENSOR_ATTR(fan3_min, S_IWUSR | S_IRUGO, show_fan_min, set_fan_min, 2),
+};
 
 static ssize_t show_pwm(struct device *dev, struct device_attribute *devattr, char *buf)
 {
@@ -335,21 +344,20 @@ static ssize_t set_pwm(struct device *dev, struct device_attribute *devattr, con
         struct pc87360_data *data = i2c_get_clientdata(client);
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->pwm[attr->index] = PWM_TO_REG(val,
                               FAN_CONFIG_INVERT(data->fan_conf, attr->index));
         pc87360_write_value(data, LD_FAN, NO_BANK, PC87360_REG_PWM(attr->index),
                             data->pwm[attr->index]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
-#define show_and_set_pwm(offset) \
-static SENSOR_DEVICE_ATTR(pwm##offset, S_IWUSR | S_IRUGO, \
-        show_pwm, set_pwm, offset-1);
-show_and_set_pwm(1)
-show_and_set_pwm(2)
-show_and_set_pwm(3)
+static struct sensor_device_attribute pwm[] = {
+        SENSOR_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 0),
+        SENSOR_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 1),
+        SENSOR_ATTR(pwm3, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 2),
+};
 
 static ssize_t show_in_input(struct device *dev, struct device_attribute *devattr, char *buf)
 {
@@ -386,11 +394,11 @@ static ssize_t set_in_min(struct device *dev, struct device_attribute *devattr,
         struct pc87360_data *data = i2c_get_clientdata(client);
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->in_min[attr->index] = IN_TO_REG(val, data->in_vref);
         pc87360_write_value(data, LD_IN, attr->index, PC87365_REG_IN_MIN,
                             data->in_min[attr->index]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 static ssize_t set_in_max(struct device *dev, struct device_attribute *devattr, const char *buf,
@@ -401,35 +409,67 @@ static ssize_t set_in_max(struct device *dev, struct device_attribute *devattr,
         struct pc87360_data *data = i2c_get_clientdata(client);
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->in_max[attr->index] = IN_TO_REG(val,
                                data->in_vref);
         pc87360_write_value(data, LD_IN, attr->index, PC87365_REG_IN_MAX,
                             data->in_max[attr->index]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
-#define show_and_set_in(offset) \
-static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \
-        show_in_input, NULL, offset); \
-static SENSOR_DEVICE_ATTR(in##offset##_min, S_IWUSR | S_IRUGO, \
-        show_in_min, set_in_min, offset); \
-static SENSOR_DEVICE_ATTR(in##offset##_max, S_IWUSR | S_IRUGO, \
-        show_in_max, set_in_max, offset); \
-static SENSOR_DEVICE_ATTR(in##offset##_status, S_IRUGO, \
-        show_in_status, NULL, offset);
-show_and_set_in(0)
-show_and_set_in(1)
-show_and_set_in(2)
-show_and_set_in(3)
-show_and_set_in(4)
-show_and_set_in(5)
-show_and_set_in(6)
-show_and_set_in(7)
-show_and_set_in(8)
-show_and_set_in(9)
-show_and_set_in(10)
+static struct sensor_device_attribute in_input[] = {
+        SENSOR_ATTR(in0_input, S_IRUGO, show_in_input, NULL, 0),
+        SENSOR_ATTR(in1_input, S_IRUGO, show_in_input, NULL, 1),
+        SENSOR_ATTR(in2_input, S_IRUGO, show_in_input, NULL, 2),
+        SENSOR_ATTR(in3_input, S_IRUGO, show_in_input, NULL, 3),
+        SENSOR_ATTR(in4_input, S_IRUGO, show_in_input, NULL, 4),
+        SENSOR_ATTR(in5_input, S_IRUGO, show_in_input, NULL, 5),
+        SENSOR_ATTR(in6_input, S_IRUGO, show_in_input, NULL, 6),
+        SENSOR_ATTR(in7_input, S_IRUGO, show_in_input, NULL, 7),
+        SENSOR_ATTR(in8_input, S_IRUGO, show_in_input, NULL, 8),
+        SENSOR_ATTR(in9_input, S_IRUGO, show_in_input, NULL, 9),
+        SENSOR_ATTR(in10_input, S_IRUGO, show_in_input, NULL, 10),
+};
+static struct sensor_device_attribute in_status[] = {
+        SENSOR_ATTR(in0_status, S_IRUGO, show_in_status, NULL, 0),
+        SENSOR_ATTR(in1_status, S_IRUGO, show_in_status, NULL, 1),
+        SENSOR_ATTR(in2_status, S_IRUGO, show_in_status, NULL, 2),
+        SENSOR_ATTR(in3_status, S_IRUGO, show_in_status, NULL, 3),
+        SENSOR_ATTR(in4_status, S_IRUGO, show_in_status, NULL, 4),
+        SENSOR_ATTR(in5_status, S_IRUGO, show_in_status, NULL, 5),
+        SENSOR_ATTR(in6_status, S_IRUGO, show_in_status, NULL, 6),
+        SENSOR_ATTR(in7_status, S_IRUGO, show_in_status, NULL, 7),
+        SENSOR_ATTR(in8_status, S_IRUGO, show_in_status, NULL, 8),
+        SENSOR_ATTR(in9_status, S_IRUGO, show_in_status, NULL, 9),
+        SENSOR_ATTR(in10_status, S_IRUGO, show_in_status, NULL, 10),
+};
+static struct sensor_device_attribute in_min[] = {
+        SENSOR_ATTR(in0_min, S_IWUSR | S_IRUGO, show_in_min, set_in_min, 0),
+        SENSOR_ATTR(in1_min, S_IWUSR | S_IRUGO, show_in_min, set_in_min, 1),
+        SENSOR_ATTR(in2_min, S_IWUSR | S_IRUGO, show_in_min, set_in_min, 2),
+        SENSOR_ATTR(in3_min, S_IWUSR | S_IRUGO, show_in_min, set_in_min, 3),
+        SENSOR_ATTR(in4_min, S_IWUSR | S_IRUGO, show_in_min, set_in_min, 4),
+        SENSOR_ATTR(in5_min, S_IWUSR | S_IRUGO, show_in_min, set_in_min, 5),
+        SENSOR_ATTR(in6_min, S_IWUSR | S_IRUGO, show_in_min, set_in_min, 6),
+        SENSOR_ATTR(in7_min, S_IWUSR | S_IRUGO, show_in_min, set_in_min, 7),
+        SENSOR_ATTR(in8_min, S_IWUSR | S_IRUGO, show_in_min, set_in_min, 8),
+        SENSOR_ATTR(in9_min, S_IWUSR | S_IRUGO, show_in_min, set_in_min, 9),
+        SENSOR_ATTR(in10_min, S_IWUSR | S_IRUGO, show_in_min, set_in_min, 10),
+};
+static struct sensor_device_attribute in_max[] = {
+        SENSOR_ATTR(in0_max, S_IWUSR | S_IRUGO, show_in_max, set_in_max, 0),
+        SENSOR_ATTR(in1_max, S_IWUSR | S_IRUGO, show_in_max, set_in_max, 1),
+        SENSOR_ATTR(in2_max, S_IWUSR | S_IRUGO, show_in_max, set_in_max, 2),
+        SENSOR_ATTR(in3_max, S_IWUSR | S_IRUGO, show_in_max, set_in_max, 3),
+        SENSOR_ATTR(in4_max, S_IWUSR | S_IRUGO, show_in_max, set_in_max, 4),
+        SENSOR_ATTR(in5_max, S_IWUSR | S_IRUGO, show_in_max, set_in_max, 5),
+        SENSOR_ATTR(in6_max, S_IWUSR | S_IRUGO, show_in_max, set_in_max, 6),
+        SENSOR_ATTR(in7_max, S_IWUSR | S_IRUGO, show_in_max, set_in_max, 7),
+        SENSOR_ATTR(in8_max, S_IWUSR | S_IRUGO, show_in_max, set_in_max, 8),
+        SENSOR_ATTR(in9_max, S_IWUSR | S_IRUGO, show_in_max, set_in_max, 9),
+        SENSOR_ATTR(in10_max, S_IWUSR | S_IRUGO, show_in_max, set_in_max, 10),
+};
 
 static ssize_t show_therm_input(struct device *dev, struct device_attribute *devattr, char *buf)
 {
@@ -473,11 +513,11 @@ static ssize_t set_therm_min(struct device *dev, struct device_attribute *devatt
         struct pc87360_data *data = i2c_get_clientdata(client);
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->in_min[attr->index] = IN_TO_REG(val, data->in_vref);
         pc87360_write_value(data, LD_IN, attr->index, PC87365_REG_TEMP_MIN,
                             data->in_min[attr->index]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 static ssize_t set_therm_max(struct device *dev, struct device_attribute *devattr, const char *buf,
@@ -488,11 +528,11 @@ static ssize_t set_therm_max(struct device *dev, struct device_attribute *devatt
         struct pc87360_data *data = i2c_get_clientdata(client);
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->in_max[attr->index] = IN_TO_REG(val, data->in_vref);
         pc87360_write_value(data, LD_IN, attr->index, PC87365_REG_TEMP_MAX,
                             data->in_max[attr->index]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 static ssize_t set_therm_crit(struct device *dev, struct device_attribute *devattr, const char *buf,
@@ -503,28 +543,51 @@ static ssize_t set_therm_crit(struct device *dev, struct device_attribute *devat
         struct pc87360_data *data = i2c_get_clientdata(client);
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->in_crit[attr->index-11] = IN_TO_REG(val, data->in_vref);
         pc87360_write_value(data, LD_IN, attr->index, PC87365_REG_TEMP_CRIT,
                             data->in_crit[attr->index-11]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
-#define show_and_set_therm(offset) \
-static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, \
-        show_therm_input, NULL, 11+offset-4); \
-static SENSOR_DEVICE_ATTR(temp##offset##_min, S_IWUSR | S_IRUGO, \
-        show_therm_min, set_therm_min, 11+offset-4); \
-static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IWUSR | S_IRUGO, \
-        show_therm_max, set_therm_max, 11+offset-4); \
-static SENSOR_DEVICE_ATTR(temp##offset##_crit, S_IWUSR | S_IRUGO, \
-        show_therm_crit, set_therm_crit, 11+offset-4); \
-static SENSOR_DEVICE_ATTR(temp##offset##_status, S_IRUGO, \
-        show_therm_status, NULL, 11+offset-4);
-show_and_set_therm(4)
-show_and_set_therm(5)
-show_and_set_therm(6)
+/* the +11 term below reflects the fact that VLM units 11,12,13 are
+   used in the chip to measure voltage across the thermistors
+*/
+static struct sensor_device_attribute therm_input[] = {
+        SENSOR_ATTR(temp4_input, S_IRUGO, show_therm_input, NULL, 0+11),
+        SENSOR_ATTR(temp5_input, S_IRUGO, show_therm_input, NULL, 1+11),
+        SENSOR_ATTR(temp6_input, S_IRUGO, show_therm_input, NULL, 2+11),
+};
+static struct sensor_device_attribute therm_status[] = {
+        SENSOR_ATTR(temp4_status, S_IRUGO, show_therm_status, NULL, 0+11),
+        SENSOR_ATTR(temp5_status, S_IRUGO, show_therm_status, NULL, 1+11),
+        SENSOR_ATTR(temp6_status, S_IRUGO, show_therm_status, NULL, 2+11),
+};
+static struct sensor_device_attribute therm_min[] = {
+        SENSOR_ATTR(temp4_min, S_IRUGO | S_IWUSR,
+                    show_therm_min, set_therm_min, 0+11),
+        SENSOR_ATTR(temp5_min, S_IRUGO | S_IWUSR,
+                    show_therm_min, set_therm_min, 1+11),
+        SENSOR_ATTR(temp6_min, S_IRUGO | S_IWUSR,
+                    show_therm_min, set_therm_min, 2+11),
+};
+static struct sensor_device_attribute therm_max[] = {
+        SENSOR_ATTR(temp4_max, S_IRUGO | S_IWUSR,
+                    show_therm_max, set_therm_max, 0+11),
+        SENSOR_ATTR(temp5_max, S_IRUGO | S_IWUSR,
+                    show_therm_max, set_therm_max, 1+11),
+        SENSOR_ATTR(temp6_max, S_IRUGO | S_IWUSR,
+                    show_therm_max, set_therm_max, 2+11),
+};
+static struct sensor_device_attribute therm_crit[] = {
+        SENSOR_ATTR(temp4_crit, S_IRUGO | S_IWUSR,
+                    show_therm_crit, set_therm_crit, 0+11),
+        SENSOR_ATTR(temp5_crit, S_IRUGO | S_IWUSR,
+                    show_therm_crit, set_therm_crit, 1+11),
+        SENSOR_ATTR(temp6_crit, S_IRUGO | S_IWUSR,
+                    show_therm_crit, set_therm_crit, 2+11),
+};
 
 static ssize_t show_vid(struct device *dev, struct device_attribute *attr, char *buf)
 {
@@ -592,11 +655,11 @@ static ssize_t set_temp_min(struct device *dev, struct device_attribute *devattr
         struct pc87360_data *data = i2c_get_clientdata(client);
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp_min[attr->index] = TEMP_TO_REG(val);
         pc87360_write_value(data, LD_TEMP, attr->index, PC87365_REG_TEMP_MIN,
                             data->temp_min[attr->index]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 static ssize_t set_temp_max(struct device *dev, struct device_attribute *devattr, const char *buf,
@@ -607,11 +670,11 @@ static ssize_t set_temp_max(struct device *dev, struct device_attribute *devattr
         struct pc87360_data *data = i2c_get_clientdata(client);
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp_max[attr->index] = TEMP_TO_REG(val);
         pc87360_write_value(data, LD_TEMP, attr->index, PC87365_REG_TEMP_MAX,
                             data->temp_max[attr->index]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 static ssize_t set_temp_crit(struct device *dev, struct device_attribute *devattr, const char *buf,
@@ -622,28 +685,48 @@ static ssize_t set_temp_crit(struct device *dev, struct device_attribute *devatt
         struct pc87360_data *data = i2c_get_clientdata(client);
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp_crit[attr->index] = TEMP_TO_REG(val);
         pc87360_write_value(data, LD_TEMP, attr->index, PC87365_REG_TEMP_CRIT,
                             data->temp_crit[attr->index]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
-#define show_and_set_temp(offset) \
-static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, \
-        show_temp_input, NULL, offset-1); \
-static SENSOR_DEVICE_ATTR(temp##offset##_min, S_IWUSR | S_IRUGO, \
-        show_temp_min, set_temp_min, offset-1); \
-static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IWUSR | S_IRUGO, \
-        show_temp_max, set_temp_max, offset-1); \
-static SENSOR_DEVICE_ATTR(temp##offset##_crit, S_IWUSR | S_IRUGO, \
-        show_temp_crit, set_temp_crit, offset-1); \
-static SENSOR_DEVICE_ATTR(temp##offset##_status, S_IRUGO, \
-        show_temp_status, NULL, offset-1);
-show_and_set_temp(1)
-show_and_set_temp(2)
-show_and_set_temp(3)
+static struct sensor_device_attribute temp_input[] = {
+        SENSOR_ATTR(temp1_input, S_IRUGO, show_temp_input, NULL, 0),
+        SENSOR_ATTR(temp2_input, S_IRUGO, show_temp_input, NULL, 1),
+        SENSOR_ATTR(temp3_input, S_IRUGO, show_temp_input, NULL, 2),
+};
+static struct sensor_device_attribute temp_status[] = {
+        SENSOR_ATTR(temp1_status, S_IRUGO, show_temp_status, NULL, 0),
+        SENSOR_ATTR(temp2_status, S_IRUGO, show_temp_status, NULL, 1),
+        SENSOR_ATTR(temp3_status, S_IRUGO, show_temp_status, NULL, 2),
+};
+static struct sensor_device_attribute temp_min[] = {
+        SENSOR_ATTR(temp1_min, S_IRUGO | S_IWUSR,
+                    show_temp_min, set_temp_min, 0),
+        SENSOR_ATTR(temp2_min, S_IRUGO | S_IWUSR,
+                    show_temp_min, set_temp_min, 1),
+        SENSOR_ATTR(temp3_min, S_IRUGO | S_IWUSR,
+                    show_temp_min, set_temp_min, 2),
+};
+static struct sensor_device_attribute temp_max[] = {
+        SENSOR_ATTR(temp1_max, S_IRUGO | S_IWUSR,
+                    show_temp_max, set_temp_max, 0),
+        SENSOR_ATTR(temp2_max, S_IRUGO | S_IWUSR,
+                    show_temp_max, set_temp_max, 1),
+        SENSOR_ATTR(temp3_max, S_IRUGO | S_IWUSR,
+                    show_temp_max, set_temp_max, 2),
+};
+static struct sensor_device_attribute temp_crit[] = {
+        SENSOR_ATTR(temp1_crit, S_IRUGO | S_IWUSR,
+                    show_temp_crit, set_temp_crit, 0),
+        SENSOR_ATTR(temp2_crit, S_IRUGO | S_IWUSR,
+                    show_temp_crit, set_temp_crit, 1),
+        SENSOR_ATTR(temp3_crit, S_IRUGO | S_IWUSR,
+                    show_temp_crit, set_temp_crit, 2),
+};
 
 static ssize_t show_temp_alarms(struct device *dev, struct device_attribute *attr, char *buf)
 {
@@ -749,22 +832,24 @@ static int __init pc87360_find(int sioaddr, u8 *devid, unsigned short *addresses
 static int pc87360_detect(struct i2c_adapter *adapter)
 {
         int i;
-        struct i2c_client *new_client;
+        struct i2c_client *client;
         struct pc87360_data *data;
         int err = 0;
         const char *name = "pc87360";
         int use_thermistors = 0;
+        struct device *dev;
 
         if (!(data = kzalloc(sizeof(struct pc87360_data), GFP_KERNEL)))
                 return -ENOMEM;
 
-        new_client = &data->client;
-        i2c_set_clientdata(new_client, data);
-        new_client->addr = address;
-        init_MUTEX(&data->lock);
-        new_client->adapter = adapter;
-        new_client->driver = &pc87360_driver;
-        new_client->flags = 0;
+        client = &data->client;
+        dev = &client->dev;
+        i2c_set_clientdata(client, data);
+        client->addr = address;
+        mutex_init(&data->lock);
+        client->adapter = adapter;
+        client->driver = &pc87360_driver;
+        client->flags = 0;
 
         data->fannr = 2;
         data->innr = 0;
@@ -792,15 +877,15 @@ static int pc87360_detect(struct i2c_adapter *adapter)
                 break;
         }
 
-        strcpy(new_client->name, name);
+        strlcpy(client->name, name, sizeof(client->name));
         data->valid = 0;
-        init_MUTEX(&data->update_lock);
+        mutex_init(&data->update_lock);
 
         for (i = 0; i < 3; i++) {
                 if (((data->address[i] = extra_isa[i]))
                  && !request_region(extra_isa[i], PC87360_EXTENT,
                                     pc87360_driver.driver.name)) {
-                        dev_err(&new_client->dev, "Region 0x%x-0x%x already "
+                        dev_err(&client->dev, "Region 0x%x-0x%x already "
                                 "in use!\n", extra_isa[i],
                                 extra_isa[i]+PC87360_EXTENT-1);
                         for (i--; i >= 0; i--)
@@ -814,7 +899,7 @@ static int pc87360_detect(struct i2c_adapter *adapter)
         if (data->fannr)
                 data->fan_conf = confreg[0] | (confreg[1] << 8);
 
-        if ((err = i2c_attach_client(new_client)))
+        if ((err = i2c_attach_client(client)))
                 goto ERROR2;
 
         /* Use the correct reference voltage
@@ -828,7 +913,7 @@ static int pc87360_detect(struct i2c_adapter *adapter)
                                                 PC87365_REG_TEMP_CONFIG);
                 }
                 data->in_vref = (i&0x02) ? 3025 : 2966;
-                dev_dbg(&new_client->dev, "Using %s reference voltage\n",
+                dev_dbg(&client->dev, "Using %s reference voltage\n",
                         (i&0x02) ? "external" : "internal");
 
                 data->vid_conf = confreg[3];
@@ -847,154 +932,64 @@ static int pc87360_detect(struct i2c_adapter *adapter)
                 if (devid == 0xe9 && data->address[1]) /* PC87366 */
                         use_thermistors = confreg[2] & 0x40;
 
-                pc87360_init_client(new_client, use_thermistors);
+                pc87360_init_client(client, use_thermistors);
         }
 
         /* Register sysfs hooks */
-        data->class_dev = hwmon_device_register(&new_client->dev);
+        data->class_dev = hwmon_device_register(&client->dev);
         if (IS_ERR(data->class_dev)) {
                 err = PTR_ERR(data->class_dev);
                 goto ERROR3;
         }
 
         if (data->innr) {
-                device_create_file(&new_client->dev, &sensor_dev_attr_in0_input.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in1_input.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in2_input.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in3_input.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in4_input.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in5_input.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in6_input.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in7_input.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in8_input.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in9_input.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in10_input.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in0_min.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in1_min.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in2_min.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in3_min.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in4_min.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in5_min.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in6_min.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in7_min.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in8_min.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in9_min.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in10_min.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in0_max.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in1_max.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in2_max.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in3_max.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in4_max.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in5_max.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in6_max.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in7_max.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in8_max.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in9_max.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in10_max.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in0_status.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in1_status.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in2_status.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in3_status.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in4_status.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in5_status.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in6_status.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in7_status.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in8_status.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in9_status.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_in10_status.dev_attr);
-
-                device_create_file(&new_client->dev, &dev_attr_cpu0_vid);
-                device_create_file(&new_client->dev, &dev_attr_vrm);
-                device_create_file(&new_client->dev, &dev_attr_alarms_in);
+                for (i = 0; i < 11; i++) {
+                        device_create_file(dev, &in_input[i].dev_attr);
+                        device_create_file(dev, &in_min[i].dev_attr);
+                        device_create_file(dev, &in_max[i].dev_attr);
+                        device_create_file(dev, &in_status[i].dev_attr);
+                }
+                device_create_file(dev, &dev_attr_cpu0_vid);
+                device_create_file(dev, &dev_attr_vrm);
+                device_create_file(dev, &dev_attr_alarms_in);
         }
 
         if (data->tempnr) {
-                device_create_file(&new_client->dev, &sensor_dev_attr_temp1_input.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_temp2_input.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_temp1_min.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_temp2_min.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_temp1_max.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_temp2_max.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_temp1_crit.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_temp2_crit.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_temp1_status.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_temp2_status.dev_attr);
-
-                device_create_file(&new_client->dev, &dev_attr_alarms_temp);
-        }
-        if (data->tempnr == 3) {
-                device_create_file(&new_client->dev, &sensor_dev_attr_temp3_input.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_temp3_min.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_temp3_max.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_temp3_crit.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_temp3_status.dev_attr);
-        }
-        if (data->innr == 14) {
-                device_create_file(&new_client->dev, &sensor_dev_attr_temp4_input.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_temp5_input.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_temp6_input.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_temp4_min.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_temp5_min.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_temp6_min.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_temp4_max.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_temp5_max.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_temp6_max.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_temp4_crit.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_temp5_crit.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_temp6_crit.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_temp4_status.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_temp5_status.dev_attr);
-                device_create_file(&new_client->dev, &sensor_dev_attr_temp6_status.dev_attr);
-        }
-
-        if (data->fannr) {
-                if (FAN_CONFIG_MONITOR(data->fan_conf, 0)) {
-                        device_create_file(&new_client->dev,
-                                           &sensor_dev_attr_fan1_input.dev_attr);
-                        device_create_file(&new_client->dev,
-                                           &sensor_dev_attr_fan1_min.dev_attr);
-                        device_create_file(&new_client->dev,
-                                           &sensor_dev_attr_fan1_div.dev_attr);
-                        device_create_file(&new_client->dev,
-                                           &sensor_dev_attr_fan1_status.dev_attr);
+                for (i = 0; i < data->tempnr; i++) {
+                        device_create_file(dev, &temp_input[i].dev_attr);
+                        device_create_file(dev, &temp_min[i].dev_attr);
+                        device_create_file(dev, &temp_max[i].dev_attr);
+                        device_create_file(dev, &temp_crit[i].dev_attr);
+                        device_create_file(dev, &temp_status[i].dev_attr);
                 }
+                device_create_file(dev, &dev_attr_alarms_temp);
+        }
 
-                if (FAN_CONFIG_MONITOR(data->fan_conf, 1)) {
-                        device_create_file(&new_client->dev,
-                                           &sensor_dev_attr_fan2_input.dev_attr);
-                        device_create_file(&new_client->dev,
-                                           &sensor_dev_attr_fan2_min.dev_attr);
-                        device_create_file(&new_client->dev,
-                                           &sensor_dev_attr_fan2_div.dev_attr);
-                        device_create_file(&new_client->dev,
-                                           &sensor_dev_attr_fan2_status.dev_attr);
+        if (data->innr == 14) {
+                for (i = 0; i < 3; i++) {
+                        device_create_file(dev, &therm_input[i].dev_attr);
+                        device_create_file(dev, &therm_min[i].dev_attr);
+                        device_create_file(dev, &therm_max[i].dev_attr);
+                        device_create_file(dev, &therm_crit[i].dev_attr);
+                        device_create_file(dev, &therm_status[i].dev_attr);
                 }
-
-                if (FAN_CONFIG_CONTROL(data->fan_conf, 0))
-                        device_create_file(&new_client->dev, &sensor_dev_attr_pwm1.dev_attr);
-                if (FAN_CONFIG_CONTROL(data->fan_conf, 1))
-                        device_create_file(&new_client->dev, &sensor_dev_attr_pwm2.dev_attr);
         }
-        if (data->fannr == 3) {
-                if (FAN_CONFIG_MONITOR(data->fan_conf, 2)) {
-                        device_create_file(&new_client->dev,
-                                           &sensor_dev_attr_fan3_input.dev_attr);
-                        device_create_file(&new_client->dev,
-                                           &sensor_dev_attr_fan3_min.dev_attr);
-                        device_create_file(&new_client->dev,
-                                           &sensor_dev_attr_fan3_div.dev_attr);
-                        device_create_file(&new_client->dev,
-                                           &sensor_dev_attr_fan3_status.dev_attr);
-                }
 
-                if (FAN_CONFIG_CONTROL(data->fan_conf, 2))
-                        device_create_file(&new_client->dev, &sensor_dev_attr_pwm3.dev_attr);
+        for (i = 0; i < data->fannr; i++) {
+                if (FAN_CONFIG_MONITOR(data->fan_conf, i)) {
+                        device_create_file(dev, &fan_input[i].dev_attr);
+                        device_create_file(dev, &fan_min[i].dev_attr);
+                        device_create_file(dev, &fan_div[i].dev_attr);
+                        device_create_file(dev, &fan_status[i].dev_attr);
+                }
+                if (FAN_CONFIG_CONTROL(data->fan_conf, i))
+                        device_create_file(dev, &pwm[i].dev_attr);
         }
 
         return 0;
 
 ERROR3:
-        i2c_detach_client(new_client);
+        i2c_detach_client(client);
 ERROR2:
         for (i = 0; i < 3; i++) {
                 if (data->address[i]) {
@@ -1033,11 +1028,11 @@ static int pc87360_read_value(struct pc87360_data *data, u8 ldi, u8 bank,
 {
         int res;
 
-        down(&(data->lock));
+        mutex_lock(&(data->lock));
         if (bank != NO_BANK)
                 outb_p(bank, data->address[ldi] + PC87365_REG_BANK);
         res = inb_p(data->address[ldi] + reg);
-        up(&(data->lock));
+        mutex_unlock(&(data->lock));
 
         return res;
 }
@@ -1045,11 +1040,11 @@ static int pc87360_read_value(struct pc87360_data *data, u8 ldi, u8 bank,
 static void pc87360_write_value(struct pc87360_data *data, u8 ldi, u8 bank,
                                 u8 reg, u8 value)
 {
-        down(&(data->lock));
+        mutex_lock(&(data->lock));
         if (bank != NO_BANK)
                 outb_p(bank, data->address[ldi] + PC87365_REG_BANK);
         outb_p(value, data->address[ldi] + reg);
-        up(&(data->lock));
+        mutex_unlock(&(data->lock));
 }
 
 static void pc87360_init_client(struct i2c_client *client, int use_thermistors)
@@ -1071,7 +1066,7 @@ static void pc87360_init_client(struct i2c_client *client, int use_thermistors)
         }
 
         nr = data->innr < 11 ? data->innr : 11;
-        for (i=0; i<nr; i++) {
+        for (i = 0; i < nr; i++) {
                 if (init >= init_in[i]) {
                         /* Forcibly enable voltage channel */
                         reg = pc87360_read_value(data, LD_IN, i,
@@ -1088,14 +1083,14 @@ static void pc87360_init_client(struct i2c_client *client, int use_thermistors)
 
         /* We can't blindly trust the Super-I/O space configuration bit,
            most BIOS won't set it properly */
-        for (i=11; i<data->innr; i++) {
+        for (i = 11; i < data->innr; i++) {
                 reg = pc87360_read_value(data, LD_IN, i,
                                          PC87365_REG_TEMP_STATUS);
                 use_thermistors = use_thermistors || (reg & 0x01);
         }
 
         i = use_thermistors ? 2 : 0;
-        for (; i<data->tempnr; i++) {
+        for (; i < data->tempnr; i++) {
                 if (init >= init_temp[i]) {
                         /* Forcibly enable temperature channel */
                         reg = pc87360_read_value(data, LD_TEMP, i,
@@ -1111,7 +1106,7 @@ static void pc87360_init_client(struct i2c_client *client, int use_thermistors)
         }
 
         if (use_thermistors) {
-                for (i=11; i<data->innr; i++) {
+                for (i = 11; i < data->innr; i++) {
                         if (init >= init_in[i]) {
                                 /* The pin may already be used by thermal
                                    diodes */
@@ -1221,7 +1216,7 @@ static struct pc87360_data *pc87360_update_device(struct device *dev)
         struct pc87360_data *data = i2c_get_clientdata(client);
         u8 i;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if (time_after(jiffies, data->last_updated + HZ * 2) || !data->valid) {
                 dev_dbg(&client->dev, "Data update\n");
@@ -1321,7 +1316,7 @@ static struct pc87360_data *pc87360_update_device(struct device *dev)
                 data->valid = 1;
         }
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return data;
 }
diff --git a/drivers/hwmon/sis5595.c b/drivers/hwmon/sis5595.c
index 8be5189d9b..6f3fda73f7 100644
--- a/drivers/hwmon/sis5595.c
+++ b/drivers/hwmon/sis5595.c
@@ -60,6 +60,7 @@
 #include <linux/err.h>
 #include <linux/init.h>
 #include <linux/jiffies.h>
+#include <linux/mutex.h>
 #include <asm/io.h>
 
 
@@ -167,9 +168,9 @@ static inline u8 DIV_TO_REG(int val)
 struct sis5595_data {
         struct i2c_client client;
         struct class_device *class_dev;
-        struct semaphore lock;
+        struct mutex lock;
 
-        struct semaphore update_lock;
+        struct mutex update_lock;
         char valid;             /* !=0 if following fields are valid */
         unsigned long last_updated;     /* In jiffies */
         char maxins;            /* == 3 if temp enabled, otherwise == 4 */
@@ -192,8 +193,8 @@ static struct pci_dev *s_bridge;	/* pointer to the (only) sis5595 */
 static int sis5595_detect(struct i2c_adapter *adapter);
 static int sis5595_detach_client(struct i2c_client *client);
 
-static int sis5595_read_value(struct i2c_client *client, u8 register);
-static int sis5595_write_value(struct i2c_client *client, u8 register, u8 value);
+static int sis5595_read_value(struct i2c_client *client, u8 reg);
+static int sis5595_write_value(struct i2c_client *client, u8 reg, u8 value);
 static struct sis5595_data *sis5595_update_device(struct device *dev);
 static void sis5595_init_client(struct i2c_client *client);
 
@@ -231,10 +232,10 @@ static ssize_t set_in_min(struct device *dev, const char *buf,
         struct sis5595_data *data = i2c_get_clientdata(client);
         unsigned long val = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->in_min[nr] = IN_TO_REG(val);
         sis5595_write_value(client, SIS5595_REG_IN_MIN(nr), data->in_min[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -245,10 +246,10 @@ static ssize_t set_in_max(struct device *dev, const char *buf,
         struct sis5595_data *data = i2c_get_clientdata(client);
         unsigned long val = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->in_max[nr] = IN_TO_REG(val);
         sis5595_write_value(client, SIS5595_REG_IN_MAX(nr), data->in_max[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -310,10 +311,10 @@ static ssize_t set_temp_over(struct device *dev, struct device_attribute *attr,
         struct sis5595_data *data = i2c_get_clientdata(client);
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp_over = TEMP_TO_REG(val);
         sis5595_write_value(client, SIS5595_REG_TEMP_OVER, data->temp_over);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -329,10 +330,10 @@ static ssize_t set_temp_hyst(struct device *dev, struct device_attribute *attr,
         struct sis5595_data *data = i2c_get_clientdata(client);
         long val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp_hyst = TEMP_TO_REG(val);
         sis5595_write_value(client, SIS5595_REG_TEMP_HYST, data->temp_hyst);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -364,10 +365,10 @@ static ssize_t set_fan_min(struct device *dev, const char *buf,
         struct sis5595_data *data = i2c_get_clientdata(client);
         unsigned long val = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
         sis5595_write_value(client, SIS5595_REG_FAN_MIN(nr), data->fan_min[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -390,7 +391,7 @@ static ssize_t set_fan_div(struct device *dev, const char *buf,
         unsigned long val = simple_strtoul(buf, NULL, 10);
         int reg;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         min = FAN_FROM_REG(data->fan_min[nr],
                         DIV_FROM_REG(data->fan_div[nr]));
         reg = sis5595_read_value(client, SIS5595_REG_FANDIV);
@@ -403,7 +404,7 @@ static ssize_t set_fan_div(struct device *dev, const char *buf,
         default:
                 dev_err(&client->dev, "fan_div value %ld not "
                         "supported. Choose one of 1, 2, 4 or 8!\n", val);
-                up(&data->update_lock);
+                mutex_unlock(&data->update_lock);
                 return -EINVAL;
         }
         
@@ -419,7 +420,7 @@ static ssize_t set_fan_div(struct device *dev, const char *buf,
         data->fan_min[nr] =
                 FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
         sis5595_write_value(client, SIS5595_REG_FAN_MIN(nr), data->fan_min[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -527,7 +528,7 @@ static int sis5595_detect(struct i2c_adapter *adapter)
 
         new_client = &data->client;
         new_client->addr = address;
-        init_MUTEX(&data->lock);
+        mutex_init(&data->lock);
         i2c_set_clientdata(new_client, data);
         new_client->adapter = adapter;
         new_client->driver = &sis5595_driver;
@@ -548,7 +549,7 @@ static int sis5595_detect(struct i2c_adapter *adapter)
         strlcpy(new_client->name, "sis5595", I2C_NAME_SIZE);
 
         data->valid = 0;
-        init_MUTEX(&data->update_lock);
+        mutex_init(&data->update_lock);
 
         /* Tell the I2C layer a new client has arrived */
         if ((err = i2c_attach_client(new_client)))
@@ -635,20 +636,20 @@ static int sis5595_read_value(struct i2c_client *client, u8 reg)
         int res;
 
         struct sis5595_data *data = i2c_get_clientdata(client);
-        down(&data->lock);
+        mutex_lock(&data->lock);
         outb_p(reg, client->addr + SIS5595_ADDR_REG_OFFSET);
         res = inb_p(client->addr + SIS5595_DATA_REG_OFFSET);
-        up(&data->lock);
+        mutex_unlock(&data->lock);
         return res;
 }
 
 static int sis5595_write_value(struct i2c_client *client, u8 reg, u8 value)
 {
         struct sis5595_data *data = i2c_get_clientdata(client);
-        down(&data->lock);
+        mutex_lock(&data->lock);
         outb_p(reg, client->addr + SIS5595_ADDR_REG_OFFSET);
         outb_p(value, client->addr + SIS5595_DATA_REG_OFFSET);
-        up(&data->lock);
+        mutex_unlock(&data->lock);
         return 0;
 }
 
@@ -667,7 +668,7 @@ static struct sis5595_data *sis5595_update_device(struct device *dev)
         struct sis5595_data *data = i2c_get_clientdata(client);
         int i;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
             || !data->valid) {
@@ -707,7 +708,7 @@ static struct sis5595_data *sis5595_update_device(struct device *dev)
                 data->valid = 1;
         }
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return data;
 }
diff --git a/drivers/hwmon/smsc47b397.c b/drivers/hwmon/smsc47b397.c
index 8663bbbe97..b6086186d2 100644
--- a/drivers/hwmon/smsc47b397.c
+++ b/drivers/hwmon/smsc47b397.c
@@ -35,6 +35,7 @@
 #include <linux/hwmon.h>
 #include <linux/err.h>
 #include <linux/init.h>
+#include <linux/mutex.h>
 #include <asm/io.h>
 
 /* Address is autodetected, there is no default value */
@@ -92,9 +93,9 @@ static u8 smsc47b397_reg_temp[] = {0x25, 0x26, 0x27, 0x80};
 struct smsc47b397_data {
         struct i2c_client client;
         struct class_device *class_dev;
-        struct semaphore lock;
+        struct mutex lock;
 
-        struct semaphore update_lock;
+        struct mutex update_lock;
         unsigned long last_updated; /* in jiffies */
         int valid;
 
@@ -108,10 +109,10 @@ static int smsc47b397_read_value(struct i2c_client *client, u8 reg)
         struct smsc47b397_data *data = i2c_get_clientdata(client);
         int res;
 
-        down(&data->lock);
+        mutex_lock(&data->lock);
         outb(reg, client->addr);
         res = inb_p(client->addr + 1);
-        up(&data->lock);
+        mutex_unlock(&data->lock);
         return res;
 }
 
@@ -121,7 +122,7 @@ static struct smsc47b397_data *smsc47b397_update_device(struct device *dev)
         struct smsc47b397_data *data = i2c_get_clientdata(client);
         int i;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {
                 dev_dbg(&client->dev, "starting device update...\n");
@@ -144,7 +145,7 @@ static struct smsc47b397_data *smsc47b397_update_device(struct device *dev)
                 dev_dbg(&client->dev, "... device update complete\n");
         }
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return data;
 }
@@ -254,14 +255,14 @@ static int smsc47b397_detect(struct i2c_adapter *adapter)
         new_client = &data->client;
         i2c_set_clientdata(new_client, data);
         new_client->addr = address;
-        init_MUTEX(&data->lock);
+        mutex_init(&data->lock);
         new_client->adapter = adapter;
         new_client->driver = &smsc47b397_driver;
         new_client->flags = 0;
 
         strlcpy(new_client->name, "smsc47b397", I2C_NAME_SIZE);
 
-        init_MUTEX(&data->update_lock);
+        mutex_init(&data->update_lock);
 
         if ((err = i2c_attach_client(new_client)))
                 goto error_free;
diff --git a/drivers/hwmon/smsc47m1.c b/drivers/hwmon/smsc47m1.c
index d1e3ec0fe4..7732aec545 100644
--- a/drivers/hwmon/smsc47m1.c
+++ b/drivers/hwmon/smsc47m1.c
@@ -34,6 +34,7 @@
 #include <linux/hwmon.h>
 #include <linux/err.h>
 #include <linux/init.h>
+#include <linux/mutex.h>
 #include <asm/io.h>
 
 /* Address is autodetected, there is no default value */
@@ -102,9 +103,9 @@ superio_exit(void)
 struct smsc47m1_data {
         struct i2c_client client;
         struct class_device *class_dev;
-        struct semaphore lock;
+        struct mutex lock;
 
-        struct semaphore update_lock;
+        struct mutex update_lock;
         unsigned long last_updated;     /* In jiffies */
 
         u8 fan[2];              /* Register value */
@@ -188,18 +189,18 @@ static ssize_t set_fan_min(struct device *dev, const char *buf,
         struct smsc47m1_data *data = i2c_get_clientdata(client);
         long rpmdiv, val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         rpmdiv = val * DIV_FROM_REG(data->fan_div[nr]);
 
         if (983040 > 192 * rpmdiv || 2 * rpmdiv > 983040) {
-                up(&data->update_lock);
+                mutex_unlock(&data->update_lock);
                 return -EINVAL;
         }
 
         data->fan_preload[nr] = 192 - ((983040 + rpmdiv / 2) / rpmdiv);
         smsc47m1_write_value(client, SMSC47M1_REG_FAN_PRELOAD(nr),
                              data->fan_preload[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return count;
 }
@@ -220,14 +221,14 @@ static ssize_t set_fan_div(struct device *dev, const char *buf,
         if (new_div == old_div) /* No change */
                 return count;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         switch (new_div) {
         case 1: data->fan_div[nr] = 0; break;
         case 2: data->fan_div[nr] = 1; break;
         case 4: data->fan_div[nr] = 2; break;
         case 8: data->fan_div[nr] = 3; break;
         default:
-                up(&data->update_lock);
+                mutex_unlock(&data->update_lock);
                 return -EINVAL;
         }
 
@@ -241,7 +242,7 @@ static ssize_t set_fan_div(struct device *dev, const char *buf,
         data->fan_preload[nr] = SENSORS_LIMIT(tmp, 0, 191);
         smsc47m1_write_value(client, SMSC47M1_REG_FAN_PRELOAD(nr),
                              data->fan_preload[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return count;
 }
@@ -257,12 +258,12 @@ static ssize_t set_pwm(struct device *dev, const char *buf,
         if (val < 0 || val > 255)
                 return -EINVAL;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->pwm[nr] &= 0x81; /* Preserve additional bits */
         data->pwm[nr] |= PWM_TO_REG(val);
         smsc47m1_write_value(client, SMSC47M1_REG_PWM(nr),
                              data->pwm[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return count;
 }
@@ -278,12 +279,12 @@ static ssize_t set_pwm_en(struct device *dev, const char *buf,
         if (val != 0 && val != 1)
                 return -EINVAL;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->pwm[nr] &= 0xFE; /* preserve the other bits */
         data->pwm[nr] |= !val;
         smsc47m1_write_value(client, SMSC47M1_REG_PWM(nr),
                              data->pwm[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return count;
 }
@@ -408,13 +409,13 @@ static int smsc47m1_detect(struct i2c_adapter *adapter)
         new_client = &data->client;
         i2c_set_clientdata(new_client, data);
         new_client->addr = address;
-        init_MUTEX(&data->lock);
+        mutex_init(&data->lock);
         new_client->adapter = adapter;
         new_client->driver = &smsc47m1_driver;
         new_client->flags = 0;
 
         strlcpy(new_client->name, "smsc47m1", I2C_NAME_SIZE);
-        init_MUTEX(&data->update_lock);
+        mutex_init(&data->update_lock);
 
         /* If no function is properly configured, there's no point in
            actually registering the chip. */
@@ -512,17 +513,17 @@ static int smsc47m1_read_value(struct i2c_client *client, u8 reg)
 {
         int res;
 
-        down(&((struct smsc47m1_data *) i2c_get_clientdata(client))->lock);
+        mutex_lock(&((struct smsc47m1_data *) i2c_get_clientdata(client))->lock);
         res = inb_p(client->addr + reg);
-        up(&((struct smsc47m1_data *) i2c_get_clientdata(client))->lock);
+        mutex_unlock(&((struct smsc47m1_data *) i2c_get_clientdata(client))->lock);
         return res;
 }
 
 static void smsc47m1_write_value(struct i2c_client *client, u8 reg, u8 value)
 {
-        down(&((struct smsc47m1_data *) i2c_get_clientdata(client))->lock);
+        mutex_lock(&((struct smsc47m1_data *) i2c_get_clientdata(client))->lock);
         outb_p(value, client->addr + reg);
-        up(&((struct smsc47m1_data *) i2c_get_clientdata(client))->lock);
+        mutex_unlock(&((struct smsc47m1_data *) i2c_get_clientdata(client))->lock);
 }
 
 static struct smsc47m1_data *smsc47m1_update_device(struct device *dev,
@@ -531,7 +532,7 @@ static struct smsc47m1_data *smsc47m1_update_device(struct device *dev,
         struct i2c_client *client = to_i2c_client(dev);
         struct smsc47m1_data *data = i2c_get_clientdata(client);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if (time_after(jiffies, data->last_updated + HZ + HZ / 2) || init) {
                 int i;
@@ -558,7 +559,7 @@ static struct smsc47m1_data *smsc47m1_update_device(struct device *dev,
                 data->last_updated = jiffies;
         }
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return data;
 }
 
diff --git a/drivers/hwmon/via686a.c b/drivers/hwmon/via686a.c
index cb01848729..166298f1f1 100644
--- a/drivers/hwmon/via686a.c
+++ b/drivers/hwmon/via686a.c
@@ -39,6 +39,7 @@
 #include <linux/hwmon.h>
 #include <linux/err.h>
 #include <linux/init.h>
+#include <linux/mutex.h>
 #include <asm/io.h>
 
 
@@ -296,7 +297,7 @@ static inline long TEMP_FROM_REG10(u16 val)
 struct via686a_data {
         struct i2c_client client;
         struct class_device *class_dev;
-        struct semaphore update_lock;
+        struct mutex update_lock;
         char valid;             /* !=0 if following fields are valid */
         unsigned long last_updated;     /* In jiffies */
 
@@ -355,11 +356,11 @@ static ssize_t set_in_min(struct device *dev, const char *buf,
         struct via686a_data *data = i2c_get_clientdata(client);
         unsigned long val = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->in_min[nr] = IN_TO_REG(val, nr);
         via686a_write_value(client, VIA686A_REG_IN_MIN(nr),
                         data->in_min[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 static ssize_t set_in_max(struct device *dev, const char *buf,
@@ -368,11 +369,11 @@ static ssize_t set_in_max(struct device *dev, const char *buf,
         struct via686a_data *data = i2c_get_clientdata(client);
         unsigned long val = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->in_max[nr] = IN_TO_REG(val, nr);
         via686a_write_value(client, VIA686A_REG_IN_MAX(nr),
                         data->in_max[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 #define show_in_offset(offset)                                  \
@@ -432,11 +433,11 @@ static ssize_t set_temp_over(struct device *dev, const char *buf,
         struct via686a_data *data = i2c_get_clientdata(client);
         int val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp_over[nr] = TEMP_TO_REG(val);
         via686a_write_value(client, VIA686A_REG_TEMP_OVER[nr],
                             data->temp_over[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 static ssize_t set_temp_hyst(struct device *dev, const char *buf,
@@ -445,11 +446,11 @@ static ssize_t set_temp_hyst(struct device *dev, const char *buf,
         struct via686a_data *data = i2c_get_clientdata(client);
         int val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp_hyst[nr] = TEMP_TO_REG(val);
         via686a_write_value(client, VIA686A_REG_TEMP_HYST[nr],
                             data->temp_hyst[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 #define show_temp_offset(offset)                                        \
@@ -508,10 +509,10 @@ static ssize_t set_fan_min(struct device *dev, const char *buf,
         struct via686a_data *data = i2c_get_clientdata(client);
         int val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
         via686a_write_value(client, VIA686A_REG_FAN_MIN(nr+1), data->fan_min[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 static ssize_t set_fan_div(struct device *dev, const char *buf,
@@ -521,12 +522,12 @@ static ssize_t set_fan_div(struct device *dev, const char *buf,
         int val = simple_strtol(buf, NULL, 10);
         int old;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         old = via686a_read_value(client, VIA686A_REG_FANDIV);
         data->fan_div[nr] = DIV_TO_REG(val);
         old = (old & 0x0f) | (data->fan_div[1] << 6) | (data->fan_div[0] << 4);
         via686a_write_value(client, VIA686A_REG_FANDIV, old);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -639,7 +640,7 @@ static int via686a_detect(struct i2c_adapter *adapter)
         strlcpy(new_client->name, client_name, I2C_NAME_SIZE);
 
         data->valid = 0;
-        init_MUTEX(&data->update_lock);
+        mutex_init(&data->update_lock);
         /* Tell the I2C layer a new client has arrived */
         if ((err = i2c_attach_client(new_client)))
                 goto exit_free;
@@ -733,7 +734,7 @@ static struct via686a_data *via686a_update_device(struct device *dev)
         struct via686a_data *data = i2c_get_clientdata(client);
         int i;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
             || !data->valid) {
@@ -788,7 +789,7 @@ static struct via686a_data *via686a_update_device(struct device *dev)
                 data->valid = 1;
         }
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return data;
 }
diff --git a/drivers/hwmon/vt8231.c b/drivers/hwmon/vt8231.c
index 271e9cb953..686f3deb30 100644
--- a/drivers/hwmon/vt8231.c
+++ b/drivers/hwmon/vt8231.c
@@ -35,6 +35,7 @@
 #include <linux/hwmon-sysfs.h>
 #include <linux/hwmon-vid.h>
 #include <linux/err.h>
+#include <linux/mutex.h>
 #include <asm/io.h>
 
 static int force_addr;
@@ -148,7 +149,7 @@ static inline u8 FAN_TO_REG(long rpm, int div)
 
 struct vt8231_data {
         struct i2c_client client;
-        struct semaphore update_lock;
+        struct mutex update_lock;
         struct class_device *class_dev;
         char valid;             /* !=0 if following fields are valid */
         unsigned long last_updated;     /* In jiffies */
@@ -223,10 +224,10 @@ static ssize_t set_in_min(struct device *dev, struct device_attribute *attr,
         struct vt8231_data *data = i2c_get_clientdata(client);
         unsigned long val = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->in_min[nr] = SENSORS_LIMIT(((val * 958) / 10000) + 3, 0, 255);
         vt8231_write_value(client, regvoltmin[nr], data->in_min[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -239,10 +240,10 @@ static ssize_t set_in_max(struct device *dev, struct device_attribute *attr,
         struct vt8231_data *data = i2c_get_clientdata(client);
         unsigned long val = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->in_max[nr] = SENSORS_LIMIT(((val * 958) / 10000) + 3, 0, 255);
         vt8231_write_value(client, regvoltmax[nr], data->in_max[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -281,11 +282,11 @@ static ssize_t set_in5_min(struct device *dev, struct device_attribute *attr,
         struct vt8231_data *data = i2c_get_clientdata(client);
         unsigned long val = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->in_min[5] = SENSORS_LIMIT(((val * 958 * 34) / (10000 * 54)) + 3,
                                         0, 255);
         vt8231_write_value(client, regvoltmin[5], data->in_min[5]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -296,11 +297,11 @@ static ssize_t set_in5_max(struct device *dev, struct device_attribute *attr,
         struct vt8231_data *data = i2c_get_clientdata(client);
         unsigned long val = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->in_max[5] = SENSORS_LIMIT(((val * 958 * 34) / (10000 * 54)) + 3,
                                         0, 255);
         vt8231_write_value(client, regvoltmax[5], data->in_max[5]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -351,10 +352,10 @@ static ssize_t set_temp0_max(struct device *dev, struct device_attribute *attr,
         struct vt8231_data *data = i2c_get_clientdata(client);
         int val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp_max[0] = SENSORS_LIMIT((val + 500) / 1000, 0, 255);
         vt8231_write_value(client, regtempmax[0], data->temp_max[0]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 static ssize_t set_temp0_min(struct device *dev, struct device_attribute *attr,
@@ -364,10 +365,10 @@ static ssize_t set_temp0_min(struct device *dev, struct device_attribute *attr,
         struct vt8231_data *data = i2c_get_clientdata(client);
         int val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp_min[0] = SENSORS_LIMIT((val + 500) / 1000, 0, 255);
         vt8231_write_value(client, regtempmin[0], data->temp_min[0]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -407,10 +408,10 @@ static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
         struct vt8231_data *data = i2c_get_clientdata(client);
         int val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp_max[nr] = SENSORS_LIMIT(TEMP_MAXMIN_TO_REG(val), 0, 255);
         vt8231_write_value(client, regtempmax[nr], data->temp_max[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr,
@@ -422,10 +423,10 @@ static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr,
         struct vt8231_data *data = i2c_get_clientdata(client);
         int val = simple_strtol(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->temp_min[nr] = SENSORS_LIMIT(TEMP_MAXMIN_TO_REG(val), 0, 255);
         vt8231_write_value(client, regtempmin[nr], data->temp_min[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -520,10 +521,10 @@ static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
         struct vt8231_data *data = i2c_get_clientdata(client);
         int val = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
         vt8231_write_value(client, VT8231_REG_FAN_MIN(nr), data->fan_min[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -539,7 +540,7 @@ static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
         long min = FAN_FROM_REG(data->fan_min[nr],
                                  DIV_FROM_REG(data->fan_div[nr]));
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         switch (val) {
         case 1: data->fan_div[nr] = 0; break;
         case 2: data->fan_div[nr] = 1; break;
@@ -548,7 +549,7 @@ static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
         default:
                 dev_err(&client->dev, "fan_div value %ld not supported."
                         "Choose one of 1, 2, 4 or 8!\n", val);
-                up(&data->update_lock);
+                mutex_unlock(&data->update_lock);
                 return -EINVAL;
         }
 
@@ -558,7 +559,7 @@ static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
 
         old = (old & 0x0f) | (data->fan_div[1] << 6) | (data->fan_div[0] << 4);
         vt8231_write_value(client, VT8231_REG_FANDIV, old);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -660,7 +661,7 @@ int vt8231_detect(struct i2c_adapter *adapter)
         /* Fill in the remaining client fields and put into the global list */
         strlcpy(client->name, "vt8231", I2C_NAME_SIZE);
 
-        init_MUTEX(&data->update_lock);
+        mutex_init(&data->update_lock);
 
         /* Tell the I2C layer a new client has arrived */
         if ((err = i2c_attach_client(client)))
@@ -745,7 +746,7 @@ static struct vt8231_data *vt8231_update_device(struct device *dev)
         int i;
         u16 low;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
             || !data->valid) {
@@ -804,7 +805,7 @@ static struct vt8231_data *vt8231_update_device(struct device *dev)
                 data->valid = 1;
         }
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return data;
 }
diff --git a/drivers/hwmon/w83627ehf.c b/drivers/hwmon/w83627ehf.c
index 12d79f5e49..b6bd5685fd 100644
--- a/drivers/hwmon/w83627ehf.c
+++ b/drivers/hwmon/w83627ehf.c
@@ -42,7 +42,9 @@
 #include <linux/i2c.h>
 #include <linux/i2c-isa.h>
 #include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
 #include <linux/err.h>
+#include <linux/mutex.h>
 #include <asm/io.h>
 #include "lm75.h"
 
@@ -177,9 +179,9 @@ temp1_to_reg(int temp)
 struct w83627ehf_data {
         struct i2c_client client;
         struct class_device *class_dev;
-        struct semaphore lock;
+        struct mutex lock;
 
-        struct semaphore update_lock;
+        struct mutex update_lock;
         char valid;             /* !=0 if following fields are valid */
         unsigned long last_updated;     /* In jiffies */
 
@@ -230,7 +232,7 @@ static u16 w83627ehf_read_value(struct i2c_client *client, u16 reg)
         struct w83627ehf_data *data = i2c_get_clientdata(client);
         int res, word_sized = is_word_sized(reg);
 
-        down(&data->lock);
+        mutex_lock(&data->lock);
 
         w83627ehf_set_bank(client, reg);
         outb_p(reg & 0xff, client->addr + ADDR_REG_OFFSET);
@@ -242,7 +244,7 @@ static u16 w83627ehf_read_value(struct i2c_client *client, u16 reg)
         }
         w83627ehf_reset_bank(client, reg);
 
-        up(&data->lock);
+        mutex_unlock(&data->lock);
 
         return res;
 }
@@ -252,7 +254,7 @@ static int w83627ehf_write_value(struct i2c_client *client, u16 reg, u16 value)
         struct w83627ehf_data *data = i2c_get_clientdata(client);
         int word_sized = is_word_sized(reg);
 
-        down(&data->lock);
+        mutex_lock(&data->lock);
 
         w83627ehf_set_bank(client, reg);
         outb_p(reg & 0xff, client->addr + ADDR_REG_OFFSET);
@@ -264,7 +266,7 @@ static int w83627ehf_write_value(struct i2c_client *client, u16 reg, u16 value)
         outb_p(value & 0xff, client->addr + DATA_REG_OFFSET);
         w83627ehf_reset_bank(client, reg);
 
-        up(&data->lock);
+        mutex_unlock(&data->lock);
         return 0;
 }
 
@@ -322,7 +324,7 @@ static struct w83627ehf_data *w83627ehf_update_device(struct device *dev)
         struct w83627ehf_data *data = i2c_get_clientdata(client);
         int i;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if (time_after(jiffies, data->last_updated + HZ)
          || !data->valid) {
@@ -397,7 +399,7 @@ static struct w83627ehf_data *w83627ehf_update_device(struct device *dev)
                 data->valid = 1;
         }
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return data;
 }
 
@@ -407,9 +409,12 @@ static struct w83627ehf_data *w83627ehf_update_device(struct device *dev)
 
 #define show_fan_reg(reg) \
 static ssize_t \
-show_##reg(struct device *dev, char *buf, int nr) \
+show_##reg(struct device *dev, struct device_attribute *attr, \
+           char *buf) \
 { \
         struct w83627ehf_data *data = w83627ehf_update_device(dev); \
+        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
+        int nr = sensor_attr->index; \
         return sprintf(buf, "%d\n", \
                        fan_from_reg(data->reg[nr], \
                                     div_from_reg(data->fan_div[nr]))); \
@@ -418,23 +423,28 @@ show_fan_reg(fan);
 show_fan_reg(fan_min);
 
 static ssize_t
-show_fan_div(struct device *dev, char *buf, int nr)
+show_fan_div(struct device *dev, struct device_attribute *attr,
+             char *buf)
 {
         struct w83627ehf_data *data = w83627ehf_update_device(dev);
-        return sprintf(buf, "%u\n",
-                       div_from_reg(data->fan_div[nr]));
+        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
+        int nr = sensor_attr->index;
+        return sprintf(buf, "%u\n", div_from_reg(data->fan_div[nr]));
 }
 
 static ssize_t
-store_fan_min(struct device *dev, const char *buf, size_t count, int nr)
+store_fan_min(struct device *dev, struct device_attribute *attr,
+              const char *buf, size_t count)
 {
         struct i2c_client *client = to_i2c_client(dev);
         struct w83627ehf_data *data = i2c_get_clientdata(client);
+        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
+        int nr = sensor_attr->index;
         unsigned int val = simple_strtoul(buf, NULL, 10);
         unsigned int reg;
         u8 new_div;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         if (!val) {
                 /* No min limit, alarm disabled */
                 data->fan_min[nr] = 255;
@@ -482,63 +492,46 @@ store_fan_min(struct device *dev, const char *buf, size_t count, int nr)
         }
         w83627ehf_write_value(client, W83627EHF_REG_FAN_MIN[nr],
                               data->fan_min[nr]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return count;
 }
 
-#define sysfs_fan_offset(offset) \
-static ssize_t \
-show_reg_fan_##offset(struct device *dev, struct device_attribute *attr, \
-                      char *buf) \
-{ \
-        return show_fan(dev, buf, offset-1); \
-} \
-static DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
-                   show_reg_fan_##offset, NULL);
+static struct sensor_device_attribute sda_fan_input[] = {
+        SENSOR_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0),
+        SENSOR_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1),
+        SENSOR_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2),
+        SENSOR_ATTR(fan4_input, S_IRUGO, show_fan, NULL, 3),
+        SENSOR_ATTR(fan5_input, S_IRUGO, show_fan, NULL, 4),
+};
 
-#define sysfs_fan_min_offset(offset) \
-static ssize_t \
-show_reg_fan##offset##_min(struct device *dev, struct device_attribute *attr, \
-                           char *buf) \
-{ \
-        return show_fan_min(dev, buf, offset-1); \
-} \
-static ssize_t \
-store_reg_fan##offset##_min(struct device *dev, struct device_attribute *attr, \
-                            const char *buf, size_t count) \
-{ \
-        return store_fan_min(dev, buf, count, offset-1); \
-} \
-static DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
-                   show_reg_fan##offset##_min, \
-                   store_reg_fan##offset##_min);
+static struct sensor_device_attribute sda_fan_min[] = {
+        SENSOR_ATTR(fan1_min, S_IWUSR | S_IRUGO, show_fan_min,
+                    store_fan_min, 0),
+        SENSOR_ATTR(fan2_min, S_IWUSR | S_IRUGO, show_fan_min,
+                    store_fan_min, 1),
+        SENSOR_ATTR(fan3_min, S_IWUSR | S_IRUGO, show_fan_min,
+                    store_fan_min, 2),
+        SENSOR_ATTR(fan4_min, S_IWUSR | S_IRUGO, show_fan_min,
+                    store_fan_min, 3),
+        SENSOR_ATTR(fan5_min, S_IWUSR | S_IRUGO, show_fan_min,
+                    store_fan_min, 4),
+};
 
-#define sysfs_fan_div_offset(offset) \
-static ssize_t \
-show_reg_fan##offset##_div(struct device *dev, struct device_attribute *attr, \
-                           char *buf) \
-{ \
-        return show_fan_div(dev, buf, offset - 1); \
-} \
-static DEVICE_ATTR(fan##offset##_div, S_IRUGO, \
-                   show_reg_fan##offset##_div, NULL);
-
-sysfs_fan_offset(1);
-sysfs_fan_min_offset(1);
-sysfs_fan_div_offset(1);
-sysfs_fan_offset(2);
-sysfs_fan_min_offset(2);
-sysfs_fan_div_offset(2);
-sysfs_fan_offset(3);
-sysfs_fan_min_offset(3);
-sysfs_fan_div_offset(3);
-sysfs_fan_offset(4);
-sysfs_fan_min_offset(4);
-sysfs_fan_div_offset(4);
-sysfs_fan_offset(5);
-sysfs_fan_min_offset(5);
-sysfs_fan_div_offset(5);
+static struct sensor_device_attribute sda_fan_div[] = {
+        SENSOR_ATTR(fan1_div, S_IRUGO, show_fan_div, NULL, 0),
+        SENSOR_ATTR(fan2_div, S_IRUGO, show_fan_div, NULL, 1),
+        SENSOR_ATTR(fan3_div, S_IRUGO, show_fan_div, NULL, 2),
+        SENSOR_ATTR(fan4_div, S_IRUGO, show_fan_div, NULL, 3),
+        SENSOR_ATTR(fan5_div, S_IRUGO, show_fan_div, NULL, 4),
+};
+
+static void device_create_file_fan(struct device *dev, int i)
+{
+        device_create_file(dev, &sda_fan_input[i].dev_attr);
+        device_create_file(dev, &sda_fan_div[i].dev_attr);
+        device_create_file(dev, &sda_fan_min[i].dev_attr);
+}
 
 #define show_temp1_reg(reg) \
 static ssize_t \
@@ -561,27 +554,24 @@ store_temp1_##reg(struct device *dev, struct device_attribute *attr, \
         struct w83627ehf_data *data = i2c_get_clientdata(client); \
         u32 val = simple_strtoul(buf, NULL, 10); \
  \
-        down(&data->update_lock); \
+        mutex_lock(&data->update_lock); \
         data->temp1_##reg = temp1_to_reg(val); \
         w83627ehf_write_value(client, W83627EHF_REG_TEMP1_##REG, \
                               data->temp1_##reg); \
-        up(&data->update_lock); \
+        mutex_unlock(&data->update_lock); \
         return count; \
 }
 store_temp1_reg(OVER, max);
 store_temp1_reg(HYST, max_hyst);
 
-static DEVICE_ATTR(temp1_input, S_IRUGO, show_temp1, NULL);
-static DEVICE_ATTR(temp1_max, S_IRUGO| S_IWUSR,
-                   show_temp1_max, store_temp1_max);
-static DEVICE_ATTR(temp1_max_hyst, S_IRUGO| S_IWUSR,
-                   show_temp1_max_hyst, store_temp1_max_hyst);
-
 #define show_temp_reg(reg) \
 static ssize_t \
-show_##reg (struct device *dev, char *buf, int nr) \
+show_##reg(struct device *dev, struct device_attribute *attr, \
+           char *buf) \
 { \
         struct w83627ehf_data *data = w83627ehf_update_device(dev); \
+        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
+        int nr = sensor_attr->index; \
         return sprintf(buf, "%d\n", \
                        LM75_TEMP_FROM_REG(data->reg[nr])); \
 }
@@ -591,55 +581,42 @@ show_temp_reg(temp_max_hyst);
 
 #define store_temp_reg(REG, reg) \
 static ssize_t \
-store_##reg (struct device *dev, const char *buf, size_t count, int nr) \
+store_##reg(struct device *dev, struct device_attribute *attr, \
+            const char *buf, size_t count) \
 { \
         struct i2c_client *client = to_i2c_client(dev); \
         struct w83627ehf_data *data = i2c_get_clientdata(client); \
+        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \
+        int nr = sensor_attr->index; \
         u32 val = simple_strtoul(buf, NULL, 10); \
  \
-        down(&data->update_lock); \
+        mutex_lock(&data->update_lock); \
         data->reg[nr] = LM75_TEMP_TO_REG(val); \
         w83627ehf_write_value(client, W83627EHF_REG_TEMP_##REG[nr], \
                               data->reg[nr]); \
-        up(&data->update_lock); \
+        mutex_unlock(&data->update_lock); \
         return count; \
 }
 store_temp_reg(OVER, temp_max);
 store_temp_reg(HYST, temp_max_hyst);
 
-#define sysfs_temp_offset(offset) \
-static ssize_t \
-show_reg_temp##offset (struct device *dev, struct device_attribute *attr, \
-                       char *buf) \
-{ \
-        return show_temp(dev, buf, offset - 2); \
-} \
-static DEVICE_ATTR(temp##offset##_input, S_IRUGO, \
-                   show_reg_temp##offset, NULL);
-
-#define sysfs_temp_reg_offset(reg, offset) \
-static ssize_t \
-show_reg_temp##offset##_##reg(struct device *dev, struct device_attribute *attr, \
-                              char *buf) \
-{ \
-        return show_temp_##reg(dev, buf, offset - 2); \
-} \
-static ssize_t \
-store_reg_temp##offset##_##reg(struct device *dev, struct device_attribute *attr, \
-                               const char *buf, size_t count) \
-{ \
-        return store_temp_##reg(dev, buf, count, offset - 2); \
-} \
-static DEVICE_ATTR(temp##offset##_##reg, S_IRUGO| S_IWUSR, \
-                   show_reg_temp##offset##_##reg, \
-                   store_reg_temp##offset##_##reg);
-
-sysfs_temp_offset(2);
-sysfs_temp_reg_offset(max, 2);
-sysfs_temp_reg_offset(max_hyst, 2);
-sysfs_temp_offset(3);
-sysfs_temp_reg_offset(max, 3);
-sysfs_temp_reg_offset(max_hyst, 3);
+static struct sensor_device_attribute sda_temp[] = {
+        SENSOR_ATTR(temp1_input, S_IRUGO, show_temp1, NULL, 0),
+        SENSOR_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 0),
+        SENSOR_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 1),
+        SENSOR_ATTR(temp1_max, S_IRUGO | S_IWUSR, show_temp1_max,
+                    store_temp1_max, 0),
+        SENSOR_ATTR(temp2_max, S_IRUGO | S_IWUSR, show_temp_max,
+                    store_temp_max, 0),
+        SENSOR_ATTR(temp3_max, S_IRUGO | S_IWUSR, show_temp_max,
+                    store_temp_max, 1),
+        SENSOR_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR, show_temp1_max_hyst,
+                    store_temp1_max_hyst, 0),
+        SENSOR_ATTR(temp2_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
+                    store_temp_max_hyst, 0),
+        SENSOR_ATTR(temp3_max_hyst, S_IRUGO | S_IWUSR, show_temp_max_hyst,
+                    store_temp_max_hyst, 1),
+};
 
 /*
  * Driver and client management
@@ -673,6 +650,7 @@ static int w83627ehf_detect(struct i2c_adapter *adapter)
 {
         struct i2c_client *client;
         struct w83627ehf_data *data;
+        struct device *dev;
         int i, err = 0;
 
         if (!request_region(address + REGION_OFFSET, REGION_LENGTH,
@@ -689,14 +667,15 @@ static int w83627ehf_detect(struct i2c_adapter *adapter)
         client = &data->client;
         i2c_set_clientdata(client, data);
         client->addr = address;
-        init_MUTEX(&data->lock);
+        mutex_init(&data->lock);
         client->adapter = adapter;
         client->driver = &w83627ehf_driver;
         client->flags = 0;
+        dev = &client->dev;
 
         strlcpy(client->name, "w83627ehf", I2C_NAME_SIZE);
         data->valid = 0;
-        init_MUTEX(&data->update_lock);
+        mutex_init(&data->update_lock);
 
         /* Tell the i2c layer a new client has arrived */
         if ((err = i2c_attach_client(client)))
@@ -720,42 +699,18 @@ static int w83627ehf_detect(struct i2c_adapter *adapter)
                 data->has_fan |= (1 << 4);
 
         /* Register sysfs hooks */
-        data->class_dev = hwmon_device_register(&client->dev);
+        data->class_dev = hwmon_device_register(dev);
         if (IS_ERR(data->class_dev)) {
                 err = PTR_ERR(data->class_dev);
                 goto exit_detach;
         }
 
-        device_create_file(&client->dev, &dev_attr_fan1_input);
-        device_create_file(&client->dev, &dev_attr_fan1_min);
-        device_create_file(&client->dev, &dev_attr_fan1_div);
-        device_create_file(&client->dev, &dev_attr_fan2_input);
-        device_create_file(&client->dev, &dev_attr_fan2_min);
-        device_create_file(&client->dev, &dev_attr_fan2_div);
-        device_create_file(&client->dev, &dev_attr_fan3_input);
-        device_create_file(&client->dev, &dev_attr_fan3_min);
-        device_create_file(&client->dev, &dev_attr_fan3_div);
-
-        if (data->has_fan & (1 << 3)) {
-                device_create_file(&client->dev, &dev_attr_fan4_input);
-                device_create_file(&client->dev, &dev_attr_fan4_min);
-                device_create_file(&client->dev, &dev_attr_fan4_div);
-        }
-        if (data->has_fan & (1 << 4)) {
-                device_create_file(&client->dev, &dev_attr_fan5_input);
-                device_create_file(&client->dev, &dev_attr_fan5_min);
-                device_create_file(&client->dev, &dev_attr_fan5_div);
+        for (i = 0; i < 5; i++) {
+                if (data->has_fan & (1 << i))
+                        device_create_file_fan(dev, i);
         }
-
-        device_create_file(&client->dev, &dev_attr_temp1_input);
-        device_create_file(&client->dev, &dev_attr_temp1_max);
-        device_create_file(&client->dev, &dev_attr_temp1_max_hyst);
-        device_create_file(&client->dev, &dev_attr_temp2_input);
-        device_create_file(&client->dev, &dev_attr_temp2_max);
-        device_create_file(&client->dev, &dev_attr_temp2_max_hyst);
-        device_create_file(&client->dev, &dev_attr_temp3_input);
-        device_create_file(&client->dev, &dev_attr_temp3_max);
-        device_create_file(&client->dev, &dev_attr_temp3_max_hyst);
+        for (i = 0; i < ARRAY_SIZE(sda_temp); i++)
+                device_create_file(dev, &sda_temp[i].dev_attr);
 
         return 0;
 
diff --git a/drivers/hwmon/w83627hf.c b/drivers/hwmon/w83627hf.c
index 7ea441d4da..71fb7f1af8 100644
--- a/drivers/hwmon/w83627hf.c
+++ b/drivers/hwmon/w83627hf.c
@@ -28,6 +28,7 @@
     w83627hf    9       3       2       3       0x20    0x5ca3  no      yes(LPC)
     w83627thf   7       3       3       3       0x90    0x5ca3  no      yes(LPC)
     w83637hf    7       3       3       3       0x80    0x5ca3  no      yes(LPC)
+    w83687thf   7       3       3       3       0x90    0x5ca3  no      yes(LPC)
     w83697hf    8       2       2       2       0x60    0x5ca3  no      yes(LPC)
 
     For other winbond chips, and for i2c support in the above chips,
@@ -46,6 +47,7 @@
 #include <linux/hwmon.h>
 #include <linux/hwmon-vid.h>
 #include <linux/err.h>
+#include <linux/mutex.h>
 #include <asm/io.h>
 #include "lm75.h"
 
@@ -62,7 +64,7 @@ MODULE_PARM_DESC(force_i2c,
 static unsigned short address;
 
 /* Insmod parameters */
-enum chips { any_chip, w83627hf, w83627thf, w83697hf, w83637hf };
+enum chips { any_chip, w83627hf, w83627thf, w83697hf, w83637hf, w83687thf };
 
 static int reset;
 module_param(reset, bool, 0);
@@ -100,6 +102,10 @@ static int VAL;		/* The value to read/write */
 #define W83627THF_GPIO5_IOSR    0xf3 /* w83627thf only */
 #define W83627THF_GPIO5_DR      0xf4 /* w83627thf only */
 
+#define W83687THF_VID_EN        0x29 /* w83687thf only */
+#define W83687THF_VID_CFG       0xF0 /* w83687thf only */
+#define W83687THF_VID_DATA      0xF1 /* w83687thf only */
+
 static inline void
 superio_outb(int reg, int val)
 {
@@ -138,6 +144,7 @@ superio_exit(void)
 #define W627THF_DEVID 0x82
 #define W697_DEVID 0x60
 #define W637_DEVID 0x70
+#define W687THF_DEVID 0x85
 #define WINB_ACT_REG 0x30
 #define WINB_BASE_REG 0x60
 /* Constants specified below */
@@ -201,11 +208,11 @@ superio_exit(void)
 #define W83627HF_REG_PWM1 0x5A
 #define W83627HF_REG_PWM2 0x5B
 
-#define W83627THF_REG_PWM1              0x01    /* 697HF and 637HF too */
-#define W83627THF_REG_PWM2              0x03    /* 697HF and 637HF too */
-#define W83627THF_REG_PWM3              0x11    /* 637HF too */
+#define W83627THF_REG_PWM1              0x01    /* 697HF/637HF/687THF too */
+#define W83627THF_REG_PWM2              0x03    /* 697HF/637HF/687THF too */
+#define W83627THF_REG_PWM3              0x11    /* 637HF/687THF too */
 
-#define W83627THF_REG_VRM_OVT_CFG       0x18    /* 637HF too */
+#define W83627THF_REG_VRM_OVT_CFG       0x18    /* 637HF/687THF too */
 
 static const u8 regpwm_627hf[] = { W83627HF_REG_PWM1, W83627HF_REG_PWM2 };
 static const u8 regpwm[] = { W83627THF_REG_PWM1, W83627THF_REG_PWM2,
@@ -285,10 +292,10 @@ static inline u8 DIV_TO_REG(long val)
 struct w83627hf_data {
         struct i2c_client client;
         struct class_device *class_dev;
-        struct semaphore lock;
+        struct mutex lock;
         enum chips type;
 
-        struct semaphore update_lock;
+        struct mutex update_lock;
         char valid;             /* !=0 if following fields are valid */
         unsigned long last_updated;     /* In jiffies */
 
@@ -318,16 +325,15 @@ struct w83627hf_data {
                                    Default = 3435.
                                    Other Betas unimplemented */
         u8 vrm;
-        u8 vrm_ovt;             /* Register value, 627thf & 637hf only */
+        u8 vrm_ovt;             /* Register value, 627THF/637HF/687THF only */
 };
 
 
 static int w83627hf_detect(struct i2c_adapter *adapter);
 static int w83627hf_detach_client(struct i2c_client *client);
 
-static int w83627hf_read_value(struct i2c_client *client, u16 register);
-static int w83627hf_write_value(struct i2c_client *client, u16 register,
-                               u16 value);
+static int w83627hf_read_value(struct i2c_client *client, u16 reg);
+static int w83627hf_write_value(struct i2c_client *client, u16 reg, u16 value);
 static struct w83627hf_data *w83627hf_update_device(struct device *dev);
 static void w83627hf_init_client(struct i2c_client *client);
 
@@ -360,12 +366,12 @@ store_in_##reg (struct device *dev, const char *buf, size_t count, int nr) \
          \
         val = simple_strtoul(buf, NULL, 10); \
          \
-        down(&data->update_lock); \
+        mutex_lock(&data->update_lock); \
         data->in_##reg[nr] = IN_TO_REG(val); \
         w83627hf_write_value(client, W83781D_REG_IN_##REG(nr), \
                             data->in_##reg[nr]); \
          \
-        up(&data->update_lock); \
+        mutex_unlock(&data->update_lock); \
         return count; \
 }
 store_in_reg(MIN, min)
@@ -413,7 +419,8 @@ static ssize_t show_in_0(struct w83627hf_data *data, char *buf, u8 reg)
         long in0;
 
         if ((data->vrm_ovt & 0x01) &&
-                (w83627thf == data->type || w83637hf == data->type))
+                (w83627thf == data->type || w83637hf == data->type
+                 || w83687thf == data->type))
 
                 /* use VRM9 calculation */
                 in0 = (long)((reg * 488 + 70000 + 50) / 100);
@@ -451,10 +458,11 @@ static ssize_t store_regs_in_min0(struct device *dev, struct device_attribute *a
 
         val = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         
         if ((data->vrm_ovt & 0x01) &&
-                (w83627thf == data->type || w83637hf == data->type))
+                (w83627thf == data->type || w83637hf == data->type
+                 || w83687thf == data->type))
 
                 /* use VRM9 calculation */
                 data->in_min[0] =
@@ -465,7 +473,7 @@ static ssize_t store_regs_in_min0(struct device *dev, struct device_attribute *a
                 data->in_min[0] = IN_TO_REG(val);
 
         w83627hf_write_value(client, W83781D_REG_IN_MIN(0), data->in_min[0]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -478,10 +486,11 @@ static ssize_t store_regs_in_max0(struct device *dev, struct device_attribute *a
 
         val = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if ((data->vrm_ovt & 0x01) &&
-                (w83627thf == data->type || w83637hf == data->type))
+                (w83627thf == data->type || w83637hf == data->type
+                 || w83687thf == data->type))
                 
                 /* use VRM9 calculation */
                 data->in_max[0] =
@@ -492,7 +501,7 @@ static ssize_t store_regs_in_max0(struct device *dev, struct device_attribute *a
                 data->in_max[0] = IN_TO_REG(val);
 
         w83627hf_write_value(client, W83781D_REG_IN_MAX(0), data->in_max[0]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -529,13 +538,13 @@ store_fan_min(struct device *dev, const char *buf, size_t count, int nr)
 
         val = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->fan_min[nr - 1] =
             FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr - 1]));
         w83627hf_write_value(client, W83781D_REG_FAN_MIN(nr),
                             data->fan_min[nr - 1]);
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -597,7 +606,7 @@ store_temp_##reg (struct device *dev, const char *buf, size_t count, int nr) \
          \
         val = simple_strtoul(buf, NULL, 10); \
          \
-        down(&data->update_lock); \
+        mutex_lock(&data->update_lock); \
          \
         if (nr >= 2) {  /* TEMP2 and TEMP3 */ \
                 data->temp_##reg##_add[nr-2] = LM75_TEMP_TO_REG(val); \
@@ -609,7 +618,7 @@ store_temp_##reg (struct device *dev, const char *buf, size_t count, int nr) \
                         data->temp_##reg); \
         } \
          \
-        up(&data->update_lock); \
+        mutex_unlock(&data->update_lock); \
         return count; \
 }
 store_temp_reg(OVER, max);
@@ -718,7 +727,7 @@ store_beep_reg(struct device *dev, const char *buf, size_t count,
 
         val = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if (update_mask == BEEP_MASK) { /* We are storing beep_mask */
                 data->beep_mask = BEEP_MASK_TO_REG(val);
@@ -736,7 +745,7 @@ store_beep_reg(struct device *dev, const char *buf, size_t count,
         w83627hf_write_value(client, W83781D_REG_BEEP_INTS2,
                             val2 | data->beep_enable << 7);
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -783,7 +792,7 @@ store_fan_div_reg(struct device *dev, const char *buf, size_t count, int nr)
         u8 reg;
         unsigned long val = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         /* Save fan_min */
         min = FAN_FROM_REG(data->fan_min[nr],
@@ -805,7 +814,7 @@ store_fan_div_reg(struct device *dev, const char *buf, size_t count, int nr)
         data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
         w83627hf_write_value(client, W83781D_REG_FAN_MIN(nr+1), data->fan_min[nr]);
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -848,7 +857,7 @@ store_pwm_reg(struct device *dev, const char *buf, size_t count, int nr)
 
         val = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if (data->type == w83627thf) {
                 /* bits 0-3 are reserved  in 627THF */
@@ -865,7 +874,7 @@ store_pwm_reg(struct device *dev, const char *buf, size_t count, int nr)
                                      data->pwm[nr - 1]);
         }
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -907,7 +916,7 @@ store_sensor_reg(struct device *dev, const char *buf, size_t count, int nr)
 
         val = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         switch (val) {
         case 1:         /* PII/Celeron diode */
@@ -941,7 +950,7 @@ store_sensor_reg(struct device *dev, const char *buf, size_t count, int nr)
                 break;
         }
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -980,7 +989,8 @@ static int __init w83627hf_find(int sioaddr, unsigned short *addr)
         if(val != W627_DEVID &&
            val != W627THF_DEVID &&
            val != W697_DEVID &&
-           val != W637_DEVID) {
+           val != W637_DEVID &&
+           val != W687THF_DEVID) {
                 superio_exit();
                 return -ENODEV;
         }
@@ -1034,6 +1044,8 @@ static int w83627hf_detect(struct i2c_adapter *adapter)
                 kind = w83627thf;
         else if(val == W637_DEVID)
                 kind = w83637hf;
+        else if (val == W687THF_DEVID)
+                kind = w83687thf;
         else {
                 dev_info(&adapter->dev,
                          "Unsupported chip (dev_id=0x%02X).\n", val);
@@ -1057,7 +1069,7 @@ static int w83627hf_detect(struct i2c_adapter *adapter)
         new_client = &data->client;
         i2c_set_clientdata(new_client, data);
         new_client->addr = address;
-        init_MUTEX(&data->lock);
+        mutex_init(&data->lock);
         new_client->adapter = adapter;
         new_client->driver = &w83627hf_driver;
         new_client->flags = 0;
@@ -1071,13 +1083,15 @@ static int w83627hf_detect(struct i2c_adapter *adapter)
                 client_name = "w83697hf";
         } else if (kind == w83637hf) {
                 client_name = "w83637hf";
+        } else if (kind == w83687thf) {
+                client_name = "w83687thf";
         }
 
         /* Fill in the remaining client fields and put into the global list */
         strlcpy(new_client->name, client_name, I2C_NAME_SIZE);
         data->type = kind;
         data->valid = 0;
-        init_MUTEX(&data->update_lock);
+        mutex_init(&data->update_lock);
 
         /* Tell the I2C layer a new client has arrived */
         if ((err = i2c_attach_client(new_client)))
@@ -1106,7 +1120,7 @@ static int w83627hf_detect(struct i2c_adapter *adapter)
         device_create_file_in(new_client, 2);
         device_create_file_in(new_client, 3);
         device_create_file_in(new_client, 4);
-        if (kind != w83627thf && kind != w83637hf) {
+        if (kind == w83627hf || kind == w83697hf) {
                 device_create_file_in(new_client, 5);
                 device_create_file_in(new_client, 6);
         }
@@ -1139,7 +1153,7 @@ static int w83627hf_detect(struct i2c_adapter *adapter)
 
         device_create_file_pwm(new_client, 1);
         device_create_file_pwm(new_client, 2);
-        if (kind == w83627thf || kind == w83637hf)
+        if (kind == w83627thf || kind == w83637hf || kind == w83687thf)
                 device_create_file_pwm(new_client, 3);
 
         device_create_file_sensor(new_client, 1);
@@ -1187,7 +1201,7 @@ static int w83627hf_read_value(struct i2c_client *client, u16 reg)
         struct w83627hf_data *data = i2c_get_clientdata(client);
         int res, word_sized;
 
-        down(&data->lock);
+        mutex_lock(&data->lock);
         word_sized = (((reg & 0xff00) == 0x100)
                    || ((reg & 0xff00) == 0x200))
                   && (((reg & 0x00ff) == 0x50)
@@ -1213,7 +1227,7 @@ static int w83627hf_read_value(struct i2c_client *client, u16 reg)
                        client->addr + W83781D_ADDR_REG_OFFSET);
                 outb_p(0, client->addr + W83781D_DATA_REG_OFFSET);
         }
-        up(&data->lock);
+        mutex_unlock(&data->lock);
         return res;
 }
 
@@ -1247,12 +1261,39 @@ exit:
         return res;
 }
 
+static int w83687thf_read_vid(struct i2c_client *client)
+{
+        int res = 0xff;
+
+        superio_enter();
+        superio_select(W83627HF_LD_HWM);
+
+        /* Make sure these GPIO pins are enabled */
+        if (!(superio_inb(W83687THF_VID_EN) & (1 << 2))) {
+                dev_dbg(&client->dev, "VID disabled, no VID function\n");
+                goto exit;
+        }
+
+        /* Make sure the pins are configured for input */
+        if (!(superio_inb(W83687THF_VID_CFG) & (1 << 4))) {
+                dev_dbg(&client->dev, "VID configured as output, "
+                        "no VID function\n");
+                goto exit;
+        }
+
+        res = superio_inb(W83687THF_VID_DATA) & 0x3f;
+
+exit:
+        superio_exit();
+        return res;
+}
+
 static int w83627hf_write_value(struct i2c_client *client, u16 reg, u16 value)
 {
         struct w83627hf_data *data = i2c_get_clientdata(client);
         int word_sized;
 
-        down(&data->lock);
+        mutex_lock(&data->lock);
         word_sized = (((reg & 0xff00) == 0x100)
                    || ((reg & 0xff00) == 0x200))
                   && (((reg & 0x00ff) == 0x53)
@@ -1277,7 +1318,7 @@ static int w83627hf_write_value(struct i2c_client *client, u16 reg, u16 value)
                        client->addr + W83781D_ADDR_REG_OFFSET);
                 outb_p(0, client->addr + W83781D_DATA_REG_OFFSET);
         }
-        up(&data->lock);
+        mutex_unlock(&data->lock);
         return 0;
 }
 
@@ -1324,10 +1365,13 @@ static void w83627hf_init_client(struct i2c_client *client)
                 data->vid = (lo & 0x0f) | ((hi & 0x01) << 4);
         } else if (w83627thf == data->type) {
                 data->vid = w83627thf_read_gpio5(client);
+        } else if (w83687thf == data->type) {
+                data->vid = w83687thf_read_vid(client);
         }
 
         /* Read VRM & OVT Config only once */
-        if (w83627thf == data->type || w83637hf == data->type) {
+        if (w83627thf == data->type || w83637hf == data->type
+         || w83687thf == data->type) {
                 data->vrm_ovt = 
                         w83627hf_read_value(client, W83627THF_REG_VRM_OVT_CFG);
         }
@@ -1387,14 +1431,14 @@ static struct w83627hf_data *w83627hf_update_device(struct device *dev)
         struct w83627hf_data *data = i2c_get_clientdata(client);
         int i;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
             || !data->valid) {
                 for (i = 0; i <= 8; i++) {
                         /* skip missing sensors */
                         if (((data->type == w83697hf) && (i == 1)) ||
-                            ((data->type == w83627thf || data->type == w83637hf)
+                            ((data->type != w83627hf && data->type != w83697hf)
                             && (i == 5 || i == 6)))
                                 continue;
                         data->in[i] =
@@ -1470,7 +1514,7 @@ static struct w83627hf_data *w83627hf_update_device(struct device *dev)
                 data->valid = 1;
         }
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return data;
 }
diff --git a/drivers/hwmon/w83781d.c b/drivers/hwmon/w83781d.c
index 64c1f8af5b..e4c700356c 100644
--- a/drivers/hwmon/w83781d.c
+++ b/drivers/hwmon/w83781d.c
@@ -42,6 +42,7 @@
 #include <linux/hwmon.h>
 #include <linux/hwmon-vid.h>
 #include <linux/err.h>
+#include <linux/mutex.h>
 #include <asm/io.h>
 #include "lm75.h"
 
@@ -56,6 +57,10 @@ I2C_CLIENT_INSMOD_5(w83781d, w83782d, w83783s, w83627hf, as99127f);
 I2C_CLIENT_MODULE_PARM(force_subclients, "List of subclient addresses: "
                     "{bus, clientaddr, subclientaddr1, subclientaddr2}");
 
+static int reset;
+module_param(reset, bool, 0);
+MODULE_PARM_DESC(reset, "Set to one to reset chip on load");
+
 static int init = 1;
 module_param(init, bool, 0);
 MODULE_PARM_DESC(init, "Set to zero to bypass chip initialization");
@@ -226,10 +231,10 @@ DIV_TO_REG(long val, enum chips type)
 struct w83781d_data {
         struct i2c_client client;
         struct class_device *class_dev;
-        struct semaphore lock;
+        struct mutex lock;
         enum chips type;
 
-        struct semaphore update_lock;
+        struct mutex update_lock;
         char valid;             /* !=0 if following fields are valid */
         unsigned long last_updated;     /* In jiffies */
 
@@ -267,9 +272,8 @@ static int w83781d_isa_attach_adapter(struct i2c_adapter *adapter);
 static int w83781d_detect(struct i2c_adapter *adapter, int address, int kind);
 static int w83781d_detach_client(struct i2c_client *client);
 
-static int w83781d_read_value(struct i2c_client *client, u16 register);
-static int w83781d_write_value(struct i2c_client *client, u16 register,
-                               u16 value);
+static int w83781d_read_value(struct i2c_client *client, u16 reg);
+static int w83781d_write_value(struct i2c_client *client, u16 reg, u16 value);
 static struct w83781d_data *w83781d_update_device(struct device *dev);
 static void w83781d_init_client(struct i2c_client *client);
 
@@ -311,11 +315,11 @@ static ssize_t store_in_##reg (struct device *dev, const char *buf, size_t count
          \
         val = simple_strtoul(buf, NULL, 10) / 10; \
          \
-        down(&data->update_lock); \
+        mutex_lock(&data->update_lock); \
         data->in_##reg[nr] = IN_TO_REG(val); \
         w83781d_write_value(client, W83781D_REG_IN_##REG(nr), data->in_##reg[nr]); \
          \
-        up(&data->update_lock); \
+        mutex_unlock(&data->update_lock); \
         return count; \
 }
 store_in_reg(MIN, min);
@@ -381,13 +385,13 @@ store_fan_min(struct device *dev, const char *buf, size_t count, int nr)
 
         val = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->fan_min[nr - 1] =
             FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr - 1]));
         w83781d_write_value(client, W83781D_REG_FAN_MIN(nr),
                             data->fan_min[nr - 1]);
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -446,7 +450,7 @@ static ssize_t store_temp_##reg (struct device *dev, const char *buf, size_t cou
          \
         val = simple_strtol(buf, NULL, 10); \
          \
-        down(&data->update_lock); \
+        mutex_lock(&data->update_lock); \
          \
         if (nr >= 2) {  /* TEMP2 and TEMP3 */ \
                 data->temp_##reg##_add[nr-2] = LM75_TEMP_TO_REG(val); \
@@ -458,7 +462,7 @@ static ssize_t store_temp_##reg (struct device *dev, const char *buf, size_t cou
                         data->temp_##reg); \
         } \
          \
-        up(&data->update_lock); \
+        mutex_unlock(&data->update_lock); \
         return count; \
 }
 store_temp_reg(OVER, max);
@@ -571,7 +575,7 @@ store_beep_reg(struct device *dev, const char *buf, size_t count,
 
         val = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if (update_mask == BEEP_MASK) { /* We are storing beep_mask */
                 data->beep_mask = BEEP_MASK_TO_REG(val, data->type);
@@ -592,7 +596,7 @@ store_beep_reg(struct device *dev, const char *buf, size_t count,
         w83781d_write_value(client, W83781D_REG_BEEP_INTS2,
                             val2 | data->beep_enable << 7);
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -637,7 +641,7 @@ store_fan_div_reg(struct device *dev, const char *buf, size_t count, int nr)
         u8 reg;
         unsigned long val = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         
         /* Save fan_min */
         min = FAN_FROM_REG(data->fan_min[nr],
@@ -662,7 +666,7 @@ store_fan_div_reg(struct device *dev, const char *buf, size_t count, int nr)
         data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
         w83781d_write_value(client, W83781D_REG_FAN_MIN(nr+1), data->fan_min[nr]);
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -709,10 +713,10 @@ store_pwm_reg(struct device *dev, const char *buf, size_t count, int nr)
 
         val = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         data->pwm[nr - 1] = PWM_TO_REG(val);
         w83781d_write_value(client, W83781D_REG_PWM(nr), data->pwm[nr - 1]);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -725,7 +729,7 @@ store_pwmenable_reg(struct device *dev, const char *buf, size_t count, int nr)
 
         val = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         switch (val) {
         case 0:
@@ -742,11 +746,11 @@ store_pwmenable_reg(struct device *dev, const char *buf, size_t count, int nr)
                 break;
 
         default:
-                up(&data->update_lock);
+                mutex_unlock(&data->update_lock);
                 return -EINVAL;
         }
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -808,7 +812,7 @@ store_sensor_reg(struct device *dev, const char *buf, size_t count, int nr)
 
         val = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         switch (val) {
         case 1:         /* PII/Celeron diode */
@@ -841,7 +845,7 @@ store_sensor_reg(struct device *dev, const char *buf, size_t count, int nr)
                 break;
         }
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -1073,7 +1077,7 @@ w83781d_detect(struct i2c_adapter *adapter, int address, int kind)
         new_client = &data->client;
         i2c_set_clientdata(new_client, data);
         new_client->addr = address;
-        init_MUTEX(&data->lock);
+        mutex_init(&data->lock);
         new_client->adapter = adapter;
         new_client->driver = is_isa ? &w83781d_isa_driver : &w83781d_driver;
         new_client->flags = 0;
@@ -1178,7 +1182,7 @@ w83781d_detect(struct i2c_adapter *adapter, int address, int kind)
         data->type = kind;
 
         data->valid = 0;
-        init_MUTEX(&data->update_lock);
+        mutex_init(&data->update_lock);
 
         /* Tell the I2C layer a new client has arrived */
         if ((err = i2c_attach_client(new_client)))
@@ -1325,7 +1329,7 @@ w83781d_read_value(struct i2c_client *client, u16 reg)
         int res, word_sized, bank;
         struct i2c_client *cl;
 
-        down(&data->lock);
+        mutex_lock(&data->lock);
         if (i2c_is_isa_client(client)) {
                 word_sized = (((reg & 0xff00) == 0x100)
                               || ((reg & 0xff00) == 0x200))
@@ -1383,7 +1387,7 @@ w83781d_read_value(struct i2c_client *client, u16 reg)
                 if (bank > 2)
                         i2c_smbus_write_byte_data(client, W83781D_REG_BANK, 0);
         }
-        up(&data->lock);
+        mutex_unlock(&data->lock);
         return res;
 }
 
@@ -1394,7 +1398,7 @@ w83781d_write_value(struct i2c_client *client, u16 reg, u16 value)
         int word_sized, bank;
         struct i2c_client *cl;
 
-        down(&data->lock);
+        mutex_lock(&data->lock);
         if (i2c_is_isa_client(client)) {
                 word_sized = (((reg & 0xff00) == 0x100)
                               || ((reg & 0xff00) == 0x200))
@@ -1447,7 +1451,7 @@ w83781d_write_value(struct i2c_client *client, u16 reg, u16 value)
                 if (bank > 2)
                         i2c_smbus_write_byte_data(client, W83781D_REG_BANK, 0);
         }
-        up(&data->lock);
+        mutex_unlock(&data->lock);
         return 0;
 }
 
@@ -1459,8 +1463,17 @@ w83781d_init_client(struct i2c_client *client)
         int type = data->type;
         u8 tmp;
 
-        if (init && type != as99127f) { /* this resets registers we don't have
+        if (reset && type != as99127f) { /* this resets registers we don't have
                                            documentation for on the as99127f */
+                /* Resetting the chip has been the default for a long time,
+                   but it causes the BIOS initializations (fan clock dividers,
+                   thermal sensor types...) to be lost, so it is now optional.
+                   It might even go away if nobody reports it as being useful,
+                   as I see very little reason why this would be needed at
+                   all. */
+                dev_info(&client->dev, "If reset=1 solved a problem you were "
+                         "having, please report!\n");
+
                 /* save these registers */
                 i = w83781d_read_value(client, W83781D_REG_BEEP_CONFIG);
                 p = w83781d_read_value(client, W83781D_REG_PWMCLK12);
@@ -1477,6 +1490,13 @@ w83781d_init_client(struct i2c_client *client)
                 w83781d_write_value(client, W83781D_REG_BEEP_INTS2, 0);
         }
 
+        /* Disable power-on abnormal beep, as advised by the datasheet.
+           Already done if reset=1. */
+        if (init && !reset && type != as99127f) {
+                i = w83781d_read_value(client, W83781D_REG_BEEP_CONFIG);
+                w83781d_write_value(client, W83781D_REG_BEEP_CONFIG, i | 0x80);
+        }
+
         data->vrm = vid_which_vrm();
 
         if ((type != w83781d) && (type != as99127f)) {
@@ -1533,7 +1553,7 @@ static struct w83781d_data *w83781d_update_device(struct device *dev)
         struct w83781d_data *data = i2c_get_clientdata(client);
         int i;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
             || !data->valid) {
@@ -1641,7 +1661,7 @@ static struct w83781d_data *w83781d_update_device(struct device *dev)
                 data->valid = 1;
         }
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return data;
 }
diff --git a/drivers/hwmon/w83792d.c b/drivers/hwmon/w83792d.c
index a2f6bb6762..6865c64d8a 100644
--- a/drivers/hwmon/w83792d.c
+++ b/drivers/hwmon/w83792d.c
@@ -43,6 +43,7 @@
 #include <linux/hwmon.h>
 #include <linux/hwmon-sysfs.h>
 #include <linux/err.h>
+#include <linux/mutex.h>
 
 /* Addresses to scan */
 static unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, 0x2f, I2C_CLIENT_END };
@@ -271,7 +272,7 @@ struct w83792d_data {
         struct class_device *class_dev;
         enum chips type;
 
-        struct semaphore update_lock;
+        struct mutex update_lock;
         char valid;             /* !=0 if following fields are valid */
         unsigned long last_updated;     /* In jiffies */
 
@@ -382,30 +383,40 @@ static ssize_t store_in_##reg (struct device *dev, \
 store_in_reg(MIN, min);
 store_in_reg(MAX, max);
 
-#define sysfs_in_reg(offset) \
-static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, show_in, \
-                                NULL, offset); \
-static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
-                                show_in_min, store_in_min, offset); \
-static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
-                                show_in_max, store_in_max, offset);
-
-sysfs_in_reg(0);
-sysfs_in_reg(1);
-sysfs_in_reg(2);
-sysfs_in_reg(3);
-sysfs_in_reg(4);
-sysfs_in_reg(5);
-sysfs_in_reg(6);
-sysfs_in_reg(7);
-sysfs_in_reg(8);
-
-#define device_create_file_in(client, offset) \
-do { \
-device_create_file(&client->dev, &sensor_dev_attr_in##offset##_input.dev_attr); \
-device_create_file(&client->dev, &sensor_dev_attr_in##offset##_max.dev_attr); \
-device_create_file(&client->dev, &sensor_dev_attr_in##offset##_min.dev_attr); \
-} while (0)
+static struct sensor_device_attribute sda_in_input[] = {
+        SENSOR_ATTR(in0_input, S_IRUGO, show_in, NULL, 0),
+        SENSOR_ATTR(in1_input, S_IRUGO, show_in, NULL, 1),
+        SENSOR_ATTR(in2_input, S_IRUGO, show_in, NULL, 2),
+        SENSOR_ATTR(in3_input, S_IRUGO, show_in, NULL, 3),
+        SENSOR_ATTR(in4_input, S_IRUGO, show_in, NULL, 4),
+        SENSOR_ATTR(in5_input, S_IRUGO, show_in, NULL, 5),
+        SENSOR_ATTR(in6_input, S_IRUGO, show_in, NULL, 6),
+        SENSOR_ATTR(in7_input, S_IRUGO, show_in, NULL, 7),
+        SENSOR_ATTR(in8_input, S_IRUGO, show_in, NULL, 8),
+};
+static struct sensor_device_attribute sda_in_min[] = {
+       SENSOR_ATTR(in0_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 0),
+       SENSOR_ATTR(in1_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 1),
+       SENSOR_ATTR(in2_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 2),
+       SENSOR_ATTR(in3_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 3),
+       SENSOR_ATTR(in4_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 4),
+       SENSOR_ATTR(in5_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 5),
+       SENSOR_ATTR(in6_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 6),
+       SENSOR_ATTR(in7_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 7),
+       SENSOR_ATTR(in8_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 8),
+};
+static struct sensor_device_attribute sda_in_max[] = {
+       SENSOR_ATTR(in0_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 0),
+       SENSOR_ATTR(in1_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 1),
+       SENSOR_ATTR(in2_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 2),
+       SENSOR_ATTR(in3_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 3),
+       SENSOR_ATTR(in4_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 4),
+       SENSOR_ATTR(in5_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 5),
+       SENSOR_ATTR(in6_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 6),
+       SENSOR_ATTR(in7_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 7),
+       SENSOR_ATTR(in8_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 8),
+};
+
 
 #define show_fan_reg(reg) \
 static ssize_t show_##reg (struct device *dev, struct device_attribute *attr, \
@@ -486,28 +497,33 @@ store_fan_div(struct device *dev, struct device_attribute *attr,
         return count;
 }
 
-#define sysfs_fan(offset) \
-static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, show_fan, NULL, \
-                                offset); \
-static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
-                                show_fan_div, store_fan_div, offset); \
-static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
-                                show_fan_min, store_fan_min, offset);
-
-sysfs_fan(1);
-sysfs_fan(2);
-sysfs_fan(3);
-sysfs_fan(4);
-sysfs_fan(5);
-sysfs_fan(6);
-sysfs_fan(7);
-
-#define device_create_file_fan(client, offset) \
-do { \
-device_create_file(&client->dev, &sensor_dev_attr_fan##offset##_input.dev_attr); \
-device_create_file(&client->dev, &sensor_dev_attr_fan##offset##_div.dev_attr); \
-device_create_file(&client->dev, &sensor_dev_attr_fan##offset##_min.dev_attr); \
-} while (0)
+static struct sensor_device_attribute sda_fan_input[] = {
+        SENSOR_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 1),
+        SENSOR_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 2),
+        SENSOR_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 3),
+        SENSOR_ATTR(fan4_input, S_IRUGO, show_fan, NULL, 4),
+        SENSOR_ATTR(fan5_input, S_IRUGO, show_fan, NULL, 5),
+        SENSOR_ATTR(fan6_input, S_IRUGO, show_fan, NULL, 6),
+        SENSOR_ATTR(fan7_input, S_IRUGO, show_fan, NULL, 7),
+};
+static struct sensor_device_attribute sda_fan_min[] = {
+        SENSOR_ATTR(fan1_min, S_IWUSR | S_IRUGO, show_fan_min, store_fan_min, 1),
+        SENSOR_ATTR(fan2_min, S_IWUSR | S_IRUGO, show_fan_min, store_fan_min, 2),
+        SENSOR_ATTR(fan3_min, S_IWUSR | S_IRUGO, show_fan_min, store_fan_min, 3),
+        SENSOR_ATTR(fan4_min, S_IWUSR | S_IRUGO, show_fan_min, store_fan_min, 4),
+        SENSOR_ATTR(fan5_min, S_IWUSR | S_IRUGO, show_fan_min, store_fan_min, 5),
+        SENSOR_ATTR(fan6_min, S_IWUSR | S_IRUGO, show_fan_min, store_fan_min, 6),
+        SENSOR_ATTR(fan7_min, S_IWUSR | S_IRUGO, show_fan_min, store_fan_min, 7),
+};
+static struct sensor_device_attribute sda_fan_div[] = {
+        SENSOR_ATTR(fan1_div, S_IWUSR | S_IRUGO, show_fan_div, store_fan_div, 1),
+        SENSOR_ATTR(fan2_div, S_IWUSR | S_IRUGO, show_fan_div, store_fan_div, 2),
+        SENSOR_ATTR(fan3_div, S_IWUSR | S_IRUGO, show_fan_div, store_fan_div, 3),
+        SENSOR_ATTR(fan4_div, S_IWUSR | S_IRUGO, show_fan_div, store_fan_div, 4),
+        SENSOR_ATTR(fan5_div, S_IWUSR | S_IRUGO, show_fan_div, store_fan_div, 5),
+        SENSOR_ATTR(fan6_div, S_IWUSR | S_IRUGO, show_fan_div, store_fan_div, 6),
+        SENSOR_ATTR(fan7_div, S_IWUSR | S_IRUGO, show_fan_div, store_fan_div, 7),
+};
 
 
 /* read/write the temperature1, includes measured value and limits */
@@ -539,21 +555,6 @@ static ssize_t store_temp1(struct device *dev, struct device_attribute *attr,
         return count;
 }
 
-
-static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp1, NULL, 0);
-static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR, show_temp1,
-                                store_temp1, 1);
-static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR, show_temp1,
-                                store_temp1, 2);
-
-#define device_create_file_temp1(client) \
-do { \
-device_create_file(&client->dev, &sensor_dev_attr_temp1_input.dev_attr); \
-device_create_file(&client->dev, &sensor_dev_attr_temp1_max.dev_attr); \
-device_create_file(&client->dev, &sensor_dev_attr_temp1_max_hyst.dev_attr); \
-} while (0)
-
-
 /* read/write the temperature2-3, includes measured value and limits */
 
 static ssize_t show_temp23(struct device *dev, struct device_attribute *attr,
@@ -590,25 +591,23 @@ static ssize_t store_temp23(struct device *dev, struct device_attribute *attr,
         return count;
 }
 
-#define sysfs_temp23(name,idx) \
-static SENSOR_DEVICE_ATTR_2(name##_input, S_IRUGO, show_temp23, NULL, \
-                                idx, 0); \
-static SENSOR_DEVICE_ATTR_2(name##_max, S_IRUGO | S_IWUSR, \
-                                show_temp23, store_temp23, idx, 2); \
-static SENSOR_DEVICE_ATTR_2(name##_max_hyst, S_IRUGO | S_IWUSR, \
-                                show_temp23, store_temp23, idx, 4);
-
-sysfs_temp23(temp2,0)
-sysfs_temp23(temp3,1)
+static struct sensor_device_attribute_2 sda_temp_input[] = {
+        SENSOR_ATTR_2(temp1_input, S_IRUGO, show_temp1, NULL, 0, 0),
+        SENSOR_ATTR_2(temp2_input, S_IRUGO, show_temp23, NULL, 0, 0),
+        SENSOR_ATTR_2(temp3_input, S_IRUGO, show_temp23, NULL, 1, 0),
+};
 
-#define device_create_file_temp_add(client, offset) \
-do { \
-device_create_file(&client->dev, &sensor_dev_attr_temp##offset##_input.dev_attr); \
-device_create_file(&client->dev, &sensor_dev_attr_temp##offset##_max.dev_attr); \
-device_create_file(&client->dev, \
-&sensor_dev_attr_temp##offset##_max_hyst.dev_attr); \
-} while (0)
+static struct sensor_device_attribute_2 sda_temp_max[] = {
+        SENSOR_ATTR_2(temp1_max, S_IRUGO | S_IWUSR, show_temp1, store_temp1, 0, 1),
+        SENSOR_ATTR_2(temp2_max, S_IRUGO | S_IWUSR, show_temp23, store_temp23, 0, 2),
+        SENSOR_ATTR_2(temp3_max, S_IRUGO | S_IWUSR, show_temp23, store_temp23, 1, 2),
+};
 
+static struct sensor_device_attribute_2 sda_temp_max_hyst[] = {
+        SENSOR_ATTR_2(temp1_max_hyst, S_IRUGO | S_IWUSR, show_temp1, store_temp1, 0, 2),
+        SENSOR_ATTR_2(temp2_max_hyst, S_IRUGO | S_IWUSR, show_temp23, store_temp23, 0, 4),
+        SENSOR_ATTR_2(temp3_max_hyst, S_IRUGO | S_IWUSR, show_temp23, store_temp23, 1, 4),
+};
 
 /* get reatime status of all sensors items: voltage, temp, fan */
 static ssize_t
@@ -620,10 +619,6 @@ show_alarms_reg(struct device *dev, struct device_attribute *attr, char *buf)
 
 static
 DEVICE_ATTR(alarms, S_IRUGO, show_alarms_reg, NULL);
-#define device_create_file_alarms(client) \
-device_create_file(&client->dev, &dev_attr_alarms);
-
-
 
 static ssize_t
 show_pwm(struct device *dev, struct device_attribute *attr,
@@ -711,26 +706,19 @@ store_pwmenable(struct device *dev, struct device_attribute *attr,
         return count;
 }
 
-#define sysfs_pwm(offset) \
-static SENSOR_DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR, \
-                                show_pwm, store_pwm, offset); \
-static SENSOR_DEVICE_ATTR(pwm##offset##_enable, S_IRUGO | S_IWUSR, \
-                                show_pwmenable, store_pwmenable, offset); \
-
-sysfs_pwm(1);
-sysfs_pwm(2);
-sysfs_pwm(3);
-
-
-#define device_create_file_pwm(client, offset) \
-do { \
-device_create_file(&client->dev, &sensor_dev_attr_pwm##offset.dev_attr); \
-} while (0)
-
-#define device_create_file_pwmenable(client, offset) \
-do { \
-device_create_file(&client->dev, &sensor_dev_attr_pwm##offset##_enable.dev_attr); \
-} while (0)
+static struct sensor_device_attribute sda_pwm[] = {
+        SENSOR_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 1),
+        SENSOR_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 2),
+        SENSOR_ATTR(pwm3, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 3),
+};
+static struct sensor_device_attribute sda_pwm_enable[] = {
+        SENSOR_ATTR(pwm1_enable, S_IWUSR | S_IRUGO,
+                    show_pwmenable, store_pwmenable, 1),
+        SENSOR_ATTR(pwm2_enable, S_IWUSR | S_IRUGO,
+                    show_pwmenable, store_pwmenable, 2),
+        SENSOR_ATTR(pwm3_enable, S_IWUSR | S_IRUGO,
+                    show_pwmenable, store_pwmenable, 3),
+};
 
 
 static ssize_t
@@ -764,18 +752,14 @@ store_pwm_mode(struct device *dev, struct device_attribute *attr,
         return count;
 }
 
-#define sysfs_pwm_mode(offset) \
-static SENSOR_DEVICE_ATTR(pwm##offset##_mode, S_IRUGO | S_IWUSR, \
-                                show_pwm_mode, store_pwm_mode, offset);
-
-sysfs_pwm_mode(1);
-sysfs_pwm_mode(2);
-sysfs_pwm_mode(3);
-
-#define device_create_file_pwm_mode(client, offset) \
-do { \
-device_create_file(&client->dev, &sensor_dev_attr_pwm##offset##_mode.dev_attr); \
-} while (0)
+static struct sensor_device_attribute sda_pwm_mode[] = {
+        SENSOR_ATTR(pwm1_mode, S_IWUSR | S_IRUGO,
+                    show_pwm_mode, store_pwm_mode, 1),
+        SENSOR_ATTR(pwm2_mode, S_IWUSR | S_IRUGO,
+                    show_pwm_mode, store_pwm_mode, 2),
+        SENSOR_ATTR(pwm3_mode, S_IWUSR | S_IRUGO,
+                    show_pwm_mode, store_pwm_mode, 3),
+};
 
 
 static ssize_t
@@ -788,12 +772,6 @@ show_regs_chassis(struct device *dev, struct device_attribute *attr,
 
 static DEVICE_ATTR(chassis, S_IRUGO, show_regs_chassis, NULL);
 
-#define device_create_file_chassis(client) \
-do { \
-device_create_file(&client->dev, &dev_attr_chassis); \
-} while (0)
-
-
 static ssize_t
 show_chassis_clear(struct device *dev, struct device_attribute *attr, char *buf)
 {
@@ -824,13 +802,6 @@ store_chassis_clear(struct device *dev, struct device_attribute *attr,
 static DEVICE_ATTR(chassis_clear, S_IRUGO | S_IWUSR,
                 show_chassis_clear, store_chassis_clear);
 
-#define device_create_file_chassis_clear(client) \
-do { \
-device_create_file(&client->dev, &dev_attr_chassis_clear); \
-} while (0)
-
-
-
 /* For Smart Fan I / Thermal Cruise */
 static ssize_t
 show_thermal_cruise(struct device *dev, struct device_attribute *attr,
@@ -864,20 +835,14 @@ store_thermal_cruise(struct device *dev, struct device_attribute *attr,
         return count;
 }
 
-#define sysfs_thermal_cruise(offset) \
-static SENSOR_DEVICE_ATTR(thermal_cruise##offset, S_IRUGO | S_IWUSR, \
-                        show_thermal_cruise, store_thermal_cruise, offset);
-
-sysfs_thermal_cruise(1);
-sysfs_thermal_cruise(2);
-sysfs_thermal_cruise(3);
-
-#define device_create_file_thermal_cruise(client, offset) \
-do { \
-device_create_file(&client->dev, \
-&sensor_dev_attr_thermal_cruise##offset.dev_attr); \
-} while (0)
-
+static struct sensor_device_attribute sda_thermal_cruise[] = {
+        SENSOR_ATTR(thermal_cruise1, S_IWUSR | S_IRUGO,
+                    show_thermal_cruise, store_thermal_cruise, 1),
+        SENSOR_ATTR(thermal_cruise2, S_IWUSR | S_IRUGO,
+                    show_thermal_cruise, store_thermal_cruise, 2),
+        SENSOR_ATTR(thermal_cruise3, S_IWUSR | S_IRUGO,
+                    show_thermal_cruise, store_thermal_cruise, 3),
+};
 
 /* For Smart Fan I/Thermal Cruise and Smart Fan II */
 static ssize_t
@@ -916,19 +881,14 @@ store_tolerance(struct device *dev, struct device_attribute *attr,
         return count;
 }
 
-#define sysfs_tolerance(offset) \
-static SENSOR_DEVICE_ATTR(tolerance##offset, S_IRUGO | S_IWUSR, \
-                                show_tolerance, store_tolerance, offset);
-
-sysfs_tolerance(1);
-sysfs_tolerance(2);
-sysfs_tolerance(3);
-
-#define device_create_file_tolerance(client, offset) \
-do { \
-device_create_file(&client->dev, &sensor_dev_attr_tolerance##offset.dev_attr); \
-} while (0)
-
+static struct sensor_device_attribute sda_tolerance[] = {
+        SENSOR_ATTR(tolerance1, S_IWUSR | S_IRUGO,
+                    show_tolerance, store_tolerance, 1),
+        SENSOR_ATTR(tolerance2, S_IWUSR | S_IRUGO,
+                    show_tolerance, store_tolerance, 2),
+        SENSOR_ATTR(tolerance3, S_IWUSR | S_IRUGO,
+                    show_tolerance, store_tolerance, 3),
+};
 
 /* For Smart Fan II */
 static ssize_t
@@ -964,28 +924,34 @@ store_sf2_point(struct device *dev, struct device_attribute *attr,
         return count;
 }
 
-#define sysfs_sf2_point(offset, index) \
-static SENSOR_DEVICE_ATTR_2(sf2_point##offset##_fan##index, S_IRUGO | S_IWUSR, \
-                                show_sf2_point, store_sf2_point, offset, index);
-
-sysfs_sf2_point(1, 1);  /* Fan1 */
-sysfs_sf2_point(2, 1);  /* Fan1 */
-sysfs_sf2_point(3, 1);  /* Fan1 */
-sysfs_sf2_point(4, 1);  /* Fan1 */
-sysfs_sf2_point(1, 2);  /* Fan2 */
-sysfs_sf2_point(2, 2);  /* Fan2 */
-sysfs_sf2_point(3, 2);  /* Fan2 */
-sysfs_sf2_point(4, 2);  /* Fan2 */
-sysfs_sf2_point(1, 3);  /* Fan3 */
-sysfs_sf2_point(2, 3);  /* Fan3 */
-sysfs_sf2_point(3, 3);  /* Fan3 */
-sysfs_sf2_point(4, 3);  /* Fan3 */
-
-#define device_create_file_sf2_point(client, offset, index) \
-do { \
-device_create_file(&client->dev, \
-&sensor_dev_attr_sf2_point##offset##_fan##index.dev_attr); \
-} while (0)
+static struct sensor_device_attribute_2 sda_sf2_point[] = {
+        SENSOR_ATTR_2(sf2_point1_fan1, S_IRUGO | S_IWUSR,
+                      show_sf2_point, store_sf2_point, 1, 1),
+        SENSOR_ATTR_2(sf2_point2_fan1, S_IRUGO | S_IWUSR,
+                      show_sf2_point, store_sf2_point, 2, 1),
+        SENSOR_ATTR_2(sf2_point3_fan1, S_IRUGO | S_IWUSR,
+                      show_sf2_point, store_sf2_point, 3, 1),
+        SENSOR_ATTR_2(sf2_point4_fan1, S_IRUGO | S_IWUSR,
+                      show_sf2_point, store_sf2_point, 4, 1),
+
+        SENSOR_ATTR_2(sf2_point1_fan2, S_IRUGO | S_IWUSR,
+                      show_sf2_point, store_sf2_point, 1, 2),
+        SENSOR_ATTR_2(sf2_point2_fan2, S_IRUGO | S_IWUSR,
+                      show_sf2_point, store_sf2_point, 2, 2),
+        SENSOR_ATTR_2(sf2_point3_fan2, S_IRUGO | S_IWUSR,
+                      show_sf2_point, store_sf2_point, 3, 2),
+        SENSOR_ATTR_2(sf2_point4_fan2, S_IRUGO | S_IWUSR,
+                      show_sf2_point, store_sf2_point, 4, 2),
+
+        SENSOR_ATTR_2(sf2_point1_fan3, S_IRUGO | S_IWUSR,
+                      show_sf2_point, store_sf2_point, 1, 3),
+        SENSOR_ATTR_2(sf2_point2_fan3, S_IRUGO | S_IWUSR,
+                      show_sf2_point, store_sf2_point, 2, 3),
+        SENSOR_ATTR_2(sf2_point3_fan3, S_IRUGO | S_IWUSR,
+                      show_sf2_point, store_sf2_point, 3, 3),
+        SENSOR_ATTR_2(sf2_point4_fan3, S_IRUGO | S_IWUSR,
+                      show_sf2_point, store_sf2_point, 4, 3),
+};
 
 
 static ssize_t
@@ -1026,26 +992,28 @@ store_sf2_level(struct device *dev, struct device_attribute *attr,
         return count;
 }
 
-#define sysfs_sf2_level(offset, index) \
-static SENSOR_DEVICE_ATTR_2(sf2_level##offset##_fan##index, S_IRUGO | S_IWUSR, \
-                                show_sf2_level, store_sf2_level, offset, index);
-
-sysfs_sf2_level(1, 1);  /* Fan1 */
-sysfs_sf2_level(2, 1);  /* Fan1 */
-sysfs_sf2_level(3, 1);  /* Fan1 */
-sysfs_sf2_level(1, 2);  /* Fan2 */
-sysfs_sf2_level(2, 2);  /* Fan2 */
-sysfs_sf2_level(3, 2);  /* Fan2 */
-sysfs_sf2_level(1, 3);  /* Fan3 */
-sysfs_sf2_level(2, 3);  /* Fan3 */
-sysfs_sf2_level(3, 3);  /* Fan3 */
-
-#define device_create_file_sf2_level(client, offset, index) \
-do { \
-device_create_file(&client->dev, \
-&sensor_dev_attr_sf2_level##offset##_fan##index.dev_attr); \
-} while (0)
-
+static struct sensor_device_attribute_2 sda_sf2_level[] = {
+        SENSOR_ATTR_2(sf2_level1_fan1, S_IRUGO | S_IWUSR,
+                      show_sf2_level, store_sf2_level, 1, 1),
+        SENSOR_ATTR_2(sf2_level2_fan1, S_IRUGO | S_IWUSR,
+                      show_sf2_level, store_sf2_level, 2, 1),
+        SENSOR_ATTR_2(sf2_level3_fan1, S_IRUGO | S_IWUSR,
+                      show_sf2_level, store_sf2_level, 3, 1),
+
+        SENSOR_ATTR_2(sf2_level1_fan2, S_IRUGO | S_IWUSR,
+                      show_sf2_level, store_sf2_level, 1, 2),
+        SENSOR_ATTR_2(sf2_level2_fan2, S_IRUGO | S_IWUSR,
+                      show_sf2_level, store_sf2_level, 2, 2),
+        SENSOR_ATTR_2(sf2_level3_fan2, S_IRUGO | S_IWUSR,
+                      show_sf2_level, store_sf2_level, 3, 2),
+
+        SENSOR_ATTR_2(sf2_level1_fan3, S_IRUGO | S_IWUSR,
+                      show_sf2_level, store_sf2_level, 1, 3),
+        SENSOR_ATTR_2(sf2_level2_fan3, S_IRUGO | S_IWUSR,
+                      show_sf2_level, store_sf2_level, 2, 3),
+        SENSOR_ATTR_2(sf2_level3_fan3, S_IRUGO | S_IWUSR,
+                      show_sf2_level, store_sf2_level, 3, 3),
+};
 
 /* This function is called when:
      * w83792d_driver is inserted (when this module is loaded), for each
@@ -1147,12 +1115,19 @@ ERROR_SC_0:
         return err;
 }
 
+static void device_create_file_fan(struct device *dev, int i)
+{
+        device_create_file(dev, &sda_fan_input[i].dev_attr);
+        device_create_file(dev, &sda_fan_div[i].dev_attr);
+        device_create_file(dev, &sda_fan_min[i].dev_attr);
+}
 
 static int
 w83792d_detect(struct i2c_adapter *adapter, int address, int kind)
 {
         int i = 0, val1 = 0, val2;
-        struct i2c_client *new_client;
+        struct i2c_client *client;
+        struct device *dev;
         struct w83792d_data *data;
         int err = 0;
         const char *client_name = "";
@@ -1170,12 +1145,13 @@ w83792d_detect(struct i2c_adapter *adapter, int address, int kind)
                 goto ERROR0;
         }
 
-        new_client = &data->client;
-        i2c_set_clientdata(new_client, data);
-        new_client->addr = address;
-        new_client->adapter = adapter;
-        new_client->driver = &w83792d_driver;
-        new_client->flags = 0;
+        client = &data->client;
+        dev = &client->dev;
+        i2c_set_clientdata(client, data);
+        client->addr = address;
+        client->adapter = adapter;
+        client->driver = &w83792d_driver;
+        client->flags = 0;
 
         /* Now, we do the remaining detection. */
 
@@ -1184,13 +1160,12 @@ w83792d_detect(struct i2c_adapter *adapter, int address, int kind)
            force_*=... parameter, and the Winbond will be reset to the right
            bank. */
         if (kind < 0) {
-                if (w83792d_read_value(new_client, W83792D_REG_CONFIG) & 0x80) {
-                        dev_warn(&new_client->dev, "Detection failed at step "
-                                "3\n");
+                if (w83792d_read_value(client, W83792D_REG_CONFIG) & 0x80) {
+                        dev_warn(dev, "Detection failed at step 3\n");
                         goto ERROR1;
                 }
-                val1 = w83792d_read_value(new_client, W83792D_REG_BANK);
-                val2 = w83792d_read_value(new_client, W83792D_REG_CHIPMAN);
+                val1 = w83792d_read_value(client, W83792D_REG_BANK);
+                val2 = w83792d_read_value(client, W83792D_REG_CHIPMAN);
                 /* Check for Winbond ID if in bank 0 */
                 if (!(val1 & 0x07)) {  /* is Bank0 */
                         if (((!(val1 & 0x80)) && (val2 != 0xa3)) ||
@@ -1200,34 +1175,33 @@ w83792d_detect(struct i2c_adapter *adapter, int address, int kind)
                 }
                 /* If Winbond chip, address of chip and W83792D_REG_I2C_ADDR
                    should match */
-                if (w83792d_read_value(new_client,
+                if (w83792d_read_value(client,
                                         W83792D_REG_I2C_ADDR) != address) {
-                        dev_warn(&new_client->dev, "Detection failed "
-                                "at step 5\n");
+                        dev_warn(dev, "Detection failed at step 5\n");
                         goto ERROR1;
                 }
         }
 
         /* We have either had a force parameter, or we have already detected the
            Winbond. Put it now into bank 0 and Vendor ID High Byte */
-        w83792d_write_value(new_client,
+        w83792d_write_value(client,
                             W83792D_REG_BANK,
-                            (w83792d_read_value(new_client,
+                            (w83792d_read_value(client,
                                 W83792D_REG_BANK) & 0x78) | 0x80);
 
         /* Determine the chip type. */
         if (kind <= 0) {
                 /* get vendor ID */
-                val2 = w83792d_read_value(new_client, W83792D_REG_CHIPMAN);
+                val2 = w83792d_read_value(client, W83792D_REG_CHIPMAN);
                 if (val2 != 0x5c) {  /* the vendor is NOT Winbond */
                         goto ERROR1;
                 }
-                val1 = w83792d_read_value(new_client, W83792D_REG_WCHIPID);
+                val1 = w83792d_read_value(client, W83792D_REG_WCHIPID);
                 if (val1 == 0x7a) {
                         kind = w83792d;
                 } else {
                         if (kind == 0)
-                                        dev_warn(&new_client->dev,
+                                        dev_warn(dev,
                                         "w83792d: Ignoring 'force' parameter for"
                                         " unknown chip at adapter %d, address"
                                         " 0x%02x\n", i2c_adapter_id(adapter),
@@ -1239,120 +1213,86 @@ w83792d_detect(struct i2c_adapter *adapter, int address, int kind)
         if (kind == w83792d) {
                 client_name = "w83792d";
         } else {
-                dev_err(&new_client->dev, "w83792d: Internal error: unknown"
+                dev_err(dev, "w83792d: Internal error: unknown"
                                           " kind (%d)?!?", kind);
                 goto ERROR1;
         }
 
         /* Fill in the remaining client fields and put into the global list */
-        strlcpy(new_client->name, client_name, I2C_NAME_SIZE);
+        strlcpy(client->name, client_name, I2C_NAME_SIZE);
         data->type = kind;
 
         data->valid = 0;
-        init_MUTEX(&data->update_lock);
+        mutex_init(&data->update_lock);
 
         /* Tell the I2C layer a new client has arrived */
-        if ((err = i2c_attach_client(new_client)))
+        if ((err = i2c_attach_client(client)))
                 goto ERROR1;
 
         if ((err = w83792d_detect_subclients(adapter, address,
-                        kind, new_client)))
+                        kind, client)))
                 goto ERROR2;
 
         /* Initialize the chip */
-        w83792d_init_client(new_client);
+        w83792d_init_client(client);
 
         /* A few vars need to be filled upon startup */
         for (i = 0; i < 7; i++) {
-                data->fan_min[i] = w83792d_read_value(new_client,
+                data->fan_min[i] = w83792d_read_value(client,
                                         W83792D_REG_FAN_MIN[i]);
         }
 
         /* Register sysfs hooks */
-        data->class_dev = hwmon_device_register(&new_client->dev);
+        data->class_dev = hwmon_device_register(dev);
         if (IS_ERR(data->class_dev)) {
                 err = PTR_ERR(data->class_dev);
                 goto ERROR3;
         }
-        device_create_file_in(new_client, 0);
-        device_create_file_in(new_client, 1);
-        device_create_file_in(new_client, 2);
-        device_create_file_in(new_client, 3);
-        device_create_file_in(new_client, 4);
-        device_create_file_in(new_client, 5);
-        device_create_file_in(new_client, 6);
-        device_create_file_in(new_client, 7);
-        device_create_file_in(new_client, 8);
-
-        device_create_file_fan(new_client, 1);
-        device_create_file_fan(new_client, 2);
-        device_create_file_fan(new_client, 3);
+        for (i = 0; i < 9; i++) {
+                device_create_file(dev, &sda_in_input[i].dev_attr);
+                device_create_file(dev, &sda_in_max[i].dev_attr);
+                device_create_file(dev, &sda_in_min[i].dev_attr);
+        }
+        for (i = 0; i < 3; i++)
+                device_create_file_fan(dev, i);
 
         /* Read GPIO enable register to check if pins for fan 4,5 are used as
            GPIO */
-        val1 = w83792d_read_value(new_client, W83792D_REG_GPIO_EN);
+        val1 = w83792d_read_value(client, W83792D_REG_GPIO_EN);
         if (!(val1 & 0x40))
-                device_create_file_fan(new_client, 4);
+                device_create_file_fan(dev, 3);
         if (!(val1 & 0x20))
-                device_create_file_fan(new_client, 5);
+                device_create_file_fan(dev, 4);
 
-        val1 = w83792d_read_value(new_client, W83792D_REG_PIN);
+        val1 = w83792d_read_value(client, W83792D_REG_PIN);
         if (val1 & 0x40)
-                device_create_file_fan(new_client, 6);
+                device_create_file_fan(dev, 5);
         if (val1 & 0x04)
-                device_create_file_fan(new_client, 7);
-
-        device_create_file_temp1(new_client);           /* Temp1 */
-        device_create_file_temp_add(new_client, 2);     /* Temp2 */
-        device_create_file_temp_add(new_client, 3);     /* Temp3 */
-
-        device_create_file_alarms(new_client);
-
-        device_create_file_pwm(new_client, 1);
-        device_create_file_pwm(new_client, 2);
-        device_create_file_pwm(new_client, 3);
-
-        device_create_file_pwmenable(new_client, 1);
-        device_create_file_pwmenable(new_client, 2);
-        device_create_file_pwmenable(new_client, 3);
-
-        device_create_file_pwm_mode(new_client, 1);
-        device_create_file_pwm_mode(new_client, 2);
-        device_create_file_pwm_mode(new_client, 3);
-
-        device_create_file_chassis(new_client);
-        device_create_file_chassis_clear(new_client);
-
-        device_create_file_thermal_cruise(new_client, 1);
-        device_create_file_thermal_cruise(new_client, 2);
-        device_create_file_thermal_cruise(new_client, 3);
-
-        device_create_file_tolerance(new_client, 1);
-        device_create_file_tolerance(new_client, 2);
-        device_create_file_tolerance(new_client, 3);
-
-        device_create_file_sf2_point(new_client, 1, 1); /* Fan1 */
-        device_create_file_sf2_point(new_client, 2, 1); /* Fan1 */
-        device_create_file_sf2_point(new_client, 3, 1); /* Fan1 */
-        device_create_file_sf2_point(new_client, 4, 1); /* Fan1 */
-        device_create_file_sf2_point(new_client, 1, 2); /* Fan2 */
-        device_create_file_sf2_point(new_client, 2, 2); /* Fan2 */
-        device_create_file_sf2_point(new_client, 3, 2); /* Fan2 */
-        device_create_file_sf2_point(new_client, 4, 2); /* Fan2 */
-        device_create_file_sf2_point(new_client, 1, 3); /* Fan3 */
-        device_create_file_sf2_point(new_client, 2, 3); /* Fan3 */
-        device_create_file_sf2_point(new_client, 3, 3); /* Fan3 */
-        device_create_file_sf2_point(new_client, 4, 3); /* Fan3 */
-
-        device_create_file_sf2_level(new_client, 1, 1); /* Fan1 */
-        device_create_file_sf2_level(new_client, 2, 1); /* Fan1 */
-        device_create_file_sf2_level(new_client, 3, 1); /* Fan1 */
-        device_create_file_sf2_level(new_client, 1, 2); /* Fan2 */
-        device_create_file_sf2_level(new_client, 2, 2); /* Fan2 */
-        device_create_file_sf2_level(new_client, 3, 2); /* Fan2 */
-        device_create_file_sf2_level(new_client, 1, 3); /* Fan3 */
-        device_create_file_sf2_level(new_client, 2, 3); /* Fan3 */
-        device_create_file_sf2_level(new_client, 3, 3); /* Fan3 */
+                device_create_file_fan(dev, 6);
+
+        for (i = 0; i < 3; i++) {
+                device_create_file(dev, &sda_temp_input[i].dev_attr);
+                device_create_file(dev, &sda_temp_max[i].dev_attr);
+                device_create_file(dev, &sda_temp_max_hyst[i].dev_attr);
+                device_create_file(dev, &sda_thermal_cruise[i].dev_attr);
+                device_create_file(dev, &sda_tolerance[i].dev_attr);
+        }
+
+        for (i = 0; i < ARRAY_SIZE(sda_pwm); i++) {
+                device_create_file(dev, &sda_pwm[i].dev_attr);
+                device_create_file(dev, &sda_pwm_enable[i].dev_attr);
+                device_create_file(dev, &sda_pwm_mode[i].dev_attr);
+        }
+
+        device_create_file(dev, &dev_attr_alarms);
+        device_create_file(dev, &dev_attr_chassis);
+        device_create_file(dev, &dev_attr_chassis_clear);
+
+        for (i = 0; i < ARRAY_SIZE(sda_sf2_point); i++)
+                device_create_file(dev, &sda_sf2_point[i].dev_attr);
+
+        for (i = 0; i < ARRAY_SIZE(sda_sf2_level); i++)
+                device_create_file(dev, &sda_sf2_level[i].dev_attr);
 
         return 0;
 
@@ -1366,7 +1306,7 @@ ERROR3:
                 kfree(data->lm75[1]);
         }
 ERROR2:
-        i2c_detach_client(new_client);
+        i2c_detach_client(client);
 ERROR1:
         kfree(data);
 ERROR0:
@@ -1434,7 +1374,7 @@ static struct w83792d_data *w83792d_update_device(struct device *dev)
         int i, j;
         u8 reg_array_tmp[4], pwm_array_tmp[7], reg_tmp;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if (time_after
             (jiffies - data->last_updated, (unsigned long) (HZ * 3))
@@ -1545,7 +1485,7 @@ static struct w83792d_data *w83792d_update_device(struct device *dev)
                 data->valid = 1;
         }
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
 #ifdef DEBUG
         w83792d_print_debug(data, dev);
diff --git a/drivers/hwmon/w83l785ts.c b/drivers/hwmon/w83l785ts.c
index f66c0cfded..3f2bac125f 100644
--- a/drivers/hwmon/w83l785ts.c
+++ b/drivers/hwmon/w83l785ts.c
@@ -39,6 +39,7 @@
 #include <linux/hwmon.h>
 #include <linux/hwmon-sysfs.h>
 #include <linux/err.h>
+#include <linux/mutex.h>
 
 /* How many retries on register read error */
 #define MAX_RETRIES     5
@@ -107,7 +108,7 @@ static struct i2c_driver w83l785ts_driver = {
 struct w83l785ts_data {
         struct i2c_client client;
         struct class_device *class_dev;
-        struct semaphore update_lock;
+        struct mutex update_lock;
         char valid; /* zero until following fields are valid */
         unsigned long last_updated; /* in jiffies */
 
@@ -221,7 +222,7 @@ static int w83l785ts_detect(struct i2c_adapter *adapter, int address, int kind)
         /* We can fill in the remaining client fields. */
         strlcpy(new_client->name, "w83l785ts", I2C_NAME_SIZE);
         data->valid = 0;
-        init_MUTEX(&data->update_lock);
+        mutex_init(&data->update_lock);
 
         /* Default values in case the first read fails (unlikely). */
         data->temp[1] = data->temp[0] = 0;
@@ -299,7 +300,7 @@ static struct w83l785ts_data *w83l785ts_update_device(struct device *dev)
         struct i2c_client *client = to_i2c_client(dev);
         struct w83l785ts_data *data = i2c_get_clientdata(client);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if (!data->valid || time_after(jiffies, data->last_updated + HZ * 2)) {
                 dev_dbg(&client->dev, "Updating w83l785ts data.\n");
@@ -312,7 +313,7 @@ static struct w83l785ts_data *w83l785ts_update_device(struct device *dev)
                 data->valid = 1;
         }
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         return data;
 }
diff --git a/drivers/i2c/busses/Kconfig b/drivers/i2c/busses/Kconfig
index ff92735c7c..089c6f5b24 100644
--- a/drivers/i2c/busses/Kconfig
+++ b/drivers/i2c/busses/Kconfig
@@ -168,12 +168,14 @@ config I2C_PIIX4
         help
           If you say yes to this option, support will be included for the Intel
           PIIX4 family of mainboard I2C interfaces.  Specifically, the following
-          versions of the chipset are supported:
+          versions of the chipset are supported (note that Serverworks is part
+          of Broadcom):
             Intel PIIX4
             Intel 440MX
             Serverworks OSB4
             Serverworks CSB5
             Serverworks CSB6
+            Serverworks HT-1000
             SMSC Victory66
 
           This driver can also be built as a module.  If so, the module
@@ -389,10 +391,11 @@ config SCx200_I2C_SDA
           also be specified with a module parameter.
 
 config SCx200_ACB
-        tristate "NatSemi SCx200 ACCESS.bus"
-        depends on I2C && PCI
+        tristate "Geode ACCESS.bus support"
+        depends on X86_32 && I2C && PCI
         help
-          Enable the use of the ACCESS.bus controllers of a SCx200 processor.
+          Enable the use of the ACCESS.bus controllers on the Geode SCx200 and
+          SC1100 processors and the CS5535 and CS5536 Geode companion devices.
 
           If you don't know what to do here, say N.
 
diff --git a/drivers/i2c/busses/i2c-ali1535.c b/drivers/i2c/busses/i2c-ali1535.c
index 3eb47890db..d3ef46aeeb 100644
--- a/drivers/i2c/busses/i2c-ali1535.c
+++ b/drivers/i2c/busses/i2c-ali1535.c
@@ -63,7 +63,6 @@
 #include <linux/i2c.h>
 #include <linux/init.h>
 #include <asm/io.h>
-#include <asm/semaphore.h>
 
 
 /* ALI1535 SMBus address offsets */
@@ -136,7 +135,6 @@
 
 static struct pci_driver ali1535_driver;
 static unsigned short ali1535_smba;
-static DECLARE_MUTEX(i2c_ali1535_sem);
 
 /* Detect whether a ALI1535 can be found, and initialize it, where necessary.
    Note the differences between kernels with the old PCI BIOS interface and
@@ -345,7 +343,6 @@ static s32 ali1535_access(struct i2c_adapter *adap, u16 addr,
         int timeout;
         s32 result = 0;
 
-        down(&i2c_ali1535_sem);
         /* make sure SMBus is idle */
         temp = inb_p(SMBHSTSTS);
         for (timeout = 0;
@@ -460,7 +457,6 @@ static s32 ali1535_access(struct i2c_adapter *adap, u16 addr,
                 break;
         }
 EXIT:
-        up(&i2c_ali1535_sem);
         return result;
 }
 
diff --git a/drivers/i2c/busses/i2c-amd756-s4882.c b/drivers/i2c/busses/i2c-amd756-s4882.c
index 56c7d98759..08e915730c 100644
--- a/drivers/i2c/busses/i2c-amd756-s4882.c
+++ b/drivers/i2c/busses/i2c-amd756-s4882.c
@@ -38,6 +38,7 @@
 #include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/i2c.h>
+#include <linux/mutex.h>
 
 extern struct i2c_adapter amd756_smbus;
 
@@ -45,7 +46,7 @@ static struct i2c_adapter *s4882_adapter;
 static struct i2c_algorithm *s4882_algo;
 
 /* Wrapper access functions for multiplexed SMBus */
-static struct semaphore amd756_lock;
+static DEFINE_MUTEX(amd756_lock);
 
 static s32 amd756_access_virt0(struct i2c_adapter * adap, u16 addr,
                                unsigned short flags, char read_write,
@@ -59,12 +60,12 @@ static s32 amd756_access_virt0(struct i2c_adapter * adap, u16 addr,
          || addr == 0x18)
                 return -1;
 
-        down(&amd756_lock);
+        mutex_lock(&amd756_lock);
 
         error = amd756_smbus.algo->smbus_xfer(adap, addr, flags, read_write,
                                               command, size, data);
 
-        up(&amd756_lock);
+        mutex_unlock(&amd756_lock);
 
         return error;
 }
@@ -87,7 +88,7 @@ static inline s32 amd756_access_channel(struct i2c_adapter * adap, u16 addr,
         if (addr != 0x4c && (addr & 0xfc) != 0x50 && (addr & 0xfc) != 0x30)
                 return -1;
 
-        down(&amd756_lock);
+        mutex_lock(&amd756_lock);
 
         if (last_channels != channels) {
                 union i2c_smbus_data mplxdata;
@@ -105,7 +106,7 @@ static inline s32 amd756_access_channel(struct i2c_adapter * adap, u16 addr,
                                               command, size, data);
 
 UNLOCK:
-        up(&amd756_lock);
+        mutex_unlock(&amd756_lock);
         return error;
 }
 
@@ -166,8 +167,6 @@ static int __init amd756_s4882_init(void)
         }
 
         printk(KERN_INFO "Enabling SMBus multiplexing for Tyan S4882\n");
-        init_MUTEX(&amd756_lock);
-
         /* Define the 5 virtual adapters and algorithms structures */
         if (!(s4882_adapter = kzalloc(5 * sizeof(struct i2c_adapter),
                                       GFP_KERNEL))) {
diff --git a/drivers/i2c/busses/i2c-frodo.c b/drivers/i2c/busses/i2c-frodo.c
deleted file mode 100644
index b6f52f5a41..0000000000
--- a/drivers/i2c/busses/i2c-frodo.c
+++ /dev/null
@@ -1,85 +0,0 @@
-
-/*
- * linux/drivers/i2c/i2c-frodo.c
- *
- * Author: Abraham van der Merwe <abraham@2d3d.co.za>
- *
- * An I2C adapter driver for the 2d3D, Inc. StrongARM SA-1110
- * Development board (Frodo).
- *
- * This source code is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- */
-
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/delay.h>
-#include <linux/i2c.h>
-#include <linux/i2c-algo-bit.h>
-#include <asm/hardware.h>
-
-
-static void frodo_setsda (void *data,int state)
-{
-        if (state)
-                FRODO_CPLD_I2C |= FRODO_I2C_SDA_OUT;
-        else
-                FRODO_CPLD_I2C &= ~FRODO_I2C_SDA_OUT;
-}
-
-static void frodo_setscl (void *data,int state)
-{
-        if (state)
-                FRODO_CPLD_I2C |= FRODO_I2C_SCL_OUT;
-        else
-                FRODO_CPLD_I2C &= ~FRODO_I2C_SCL_OUT;
-}
-
-static int frodo_getsda (void *data)
-{
-        return ((FRODO_CPLD_I2C & FRODO_I2C_SDA_IN) != 0);
-}
-
-static int frodo_getscl (void *data)
-{
-        return ((FRODO_CPLD_I2C & FRODO_I2C_SCL_IN) != 0);
-}
-
-static struct i2c_algo_bit_data bit_frodo_data = {
-        .setsda         = frodo_setsda,
-        .setscl         = frodo_setscl,
-        .getsda         = frodo_getsda,
-        .getscl         = frodo_getscl,
-        .udelay         = 80,
-        .mdelay         = 80,
-        .timeout        = HZ
-};
-
-static struct i2c_adapter frodo_ops = {
-        .owner                  = THIS_MODULE,
-        .id                     = I2C_HW_B_FRODO,
-        .algo_data              = &bit_frodo_data,
-        .dev                    = {
-                .name           = "Frodo adapter driver",
-        },
-};
-
-static int __init i2c_frodo_init (void)
-{
-        return i2c_bit_add_bus(&frodo_ops);
-}
-
-static void __exit i2c_frodo_exit (void)
-{
-        i2c_bit_del_bus(&frodo_ops);
-}
-
-MODULE_AUTHOR ("Abraham van der Merwe <abraham@2d3d.co.za>");
-MODULE_DESCRIPTION ("I2C-Bus adapter routines for Frodo");
-MODULE_LICENSE ("GPL");
-
-module_init (i2c_frodo_init);
-module_exit (i2c_frodo_exit);
-
diff --git a/drivers/i2c/busses/i2c-isa.c b/drivers/i2c/busses/i2c-isa.c
index 4344ae6b1f..c3e1d3e888 100644
--- a/drivers/i2c/busses/i2c-isa.c
+++ b/drivers/i2c/busses/i2c-isa.c
@@ -125,7 +125,7 @@ int i2c_isa_del_driver(struct i2c_driver *driver)
 
 static int __init i2c_isa_init(void)
 {
-        init_MUTEX(&isa_adapter.clist_lock);
+        mutex_init(&isa_adapter.clist_lock);
         INIT_LIST_HEAD(&isa_adapter.clients);
 
         isa_adapter.nr = ANY_I2C_ISA_BUS;
diff --git a/drivers/i2c/busses/i2c-ite.c b/drivers/i2c/busses/i2c-ite.c
index 5f5d294480..d82e6dae84 100644
--- a/drivers/i2c/busses/i2c-ite.c
+++ b/drivers/i2c/busses/i2c-ite.c
@@ -200,9 +200,7 @@ static struct i2c_adapter iic_ite_ops = {
         .owner          = THIS_MODULE,
         .id             = I2C_HW_I_IIC,
         .algo_data      = &iic_ite_data,
-        .dev            = {
-                .name   = "ITE IIC adapter",
-        },
+        .name           = "ITE IIC adapter",
 };
 
 /* Called when the module is loaded.  This function starts the
diff --git a/drivers/i2c/busses/i2c-ixp4xx.c b/drivers/i2c/busses/i2c-ixp4xx.c
index e422d8b2d4..2ed07112d6 100644
--- a/drivers/i2c/busses/i2c-ixp4xx.c
+++ b/drivers/i2c/busses/i2c-ixp4xx.c
@@ -126,6 +126,7 @@ static int ixp4xx_i2c_probe(struct platform_device *plat_dev)
         drv_data->algo_data.timeout = 100;
 
         drv_data->adapter.id = I2C_HW_B_IXP4XX;
+        drv_data->adapter.class = I2C_CLASS_HWMON;
         strlcpy(drv_data->adapter.name, plat_dev->dev.driver->name,
                 I2C_NAME_SIZE);
         drv_data->adapter.algo_data = &drv_data->algo_data;
diff --git a/drivers/i2c/busses/i2c-piix4.c b/drivers/i2c/busses/i2c-piix4.c
index 692f473454..d9c7c00e71 100644
--- a/drivers/i2c/busses/i2c-piix4.c
+++ b/drivers/i2c/busses/i2c-piix4.c
@@ -22,7 +22,7 @@
 /*
    Supports:
         Intel PIIX4, 440MX
-        Serverworks OSB4, CSB5, CSB6
+        Serverworks OSB4, CSB5, CSB6, HT-1000
         SMSC Victory66
 
    Note: we assume there can only be one device, with one SMBus interface.
@@ -419,6 +419,8 @@ static struct pci_device_id piix4_ids[] = {
           .driver_data = 0 },
         { PCI_DEVICE(PCI_VENDOR_ID_SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_CSB6),
           .driver_data = 0 },
+        { PCI_DEVICE(PCI_VENDOR_ID_SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_HT1000SB),
+          .driver_data = 0 },
         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82443MX_3),
           .driver_data = 3 },
         { PCI_DEVICE(PCI_VENDOR_ID_EFAR, PCI_DEVICE_ID_EFAR_SLC90E66_3),
diff --git a/drivers/i2c/busses/i2c-pxa.c b/drivers/i2c/busses/i2c-pxa.c
index 7579f4b256..5155010b45 100644
--- a/drivers/i2c/busses/i2c-pxa.c
+++ b/drivers/i2c/busses/i2c-pxa.c
@@ -647,7 +647,7 @@ static inline void i2c_pxa_start_message(struct pxa_i2c *i2c)
 }
 
 /*
- * We are protected by the adapter bus semaphore.
+ * We are protected by the adapter bus mutex.
  */
 static int i2c_pxa_do_xfer(struct pxa_i2c *i2c, struct i2c_msg *msg, int num)
 {
diff --git a/drivers/i2c/busses/scx200_acb.c b/drivers/i2c/busses/scx200_acb.c
index d3478e0845..8bd305e47f 100644
--- a/drivers/i2c/busses/scx200_acb.c
+++ b/drivers/i2c/busses/scx200_acb.c
@@ -1,27 +1,26 @@
-/*  linux/drivers/i2c/scx200_acb.c 
-
+/*
     Copyright (c) 2001,2002 Christer Weinigel <wingel@nano-system.com>
 
     National Semiconductor SCx200 ACCESS.bus support
-    
+    Also supports the AMD CS5535 and AMD CS5536
+
     Based on i2c-keywest.c which is:
         Copyright (c) 2001 Benjamin Herrenschmidt <benh@kernel.crashing.org>
         Copyright (c) 2000 Philip Edelbrock <phil@stimpy.netroedge.com>
-    
+
     This program is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License as
     published by the Free Software Foundation; either version 2 of the
     License, or (at your option) any later version.
-   
+
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.
-   
+
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
 */
 
 #include <linux/module.h>
@@ -32,7 +31,9 @@
 #include <linux/smp_lock.h>
 #include <linux/pci.h>
 #include <linux/delay.h>
+#include <linux/mutex.h>
 #include <asm/io.h>
+#include <asm/msr.h>
 
 #include <linux/scx200.h>
 
@@ -47,16 +48,7 @@ static int base[MAX_DEVICES] = { 0x820, 0x840 };
 module_param_array(base, int, NULL, 0);
 MODULE_PARM_DESC(base, "Base addresses for the ACCESS.bus controllers");
 
-#ifdef DEBUG
-#define DBG(x...) printk(KERN_DEBUG NAME ": " x)
-#else
-#define DBG(x...)
-#endif
-
-/* The hardware supports interrupt driven mode too, but I haven't
-   implemented that. */
-#define POLLED_MODE 1
-#define POLL_TIMEOUT (HZ)
+#define POLL_TIMEOUT    (HZ/5)
 
 enum scx200_acb_state {
         state_idle,
@@ -79,12 +71,11 @@ static const char *scx200_acb_state_name[] = {
 };
 
 /* Physical interface */
-struct scx200_acb_iface
-{
+struct scx200_acb_iface {
         struct scx200_acb_iface *next;
         struct i2c_adapter adapter;
         unsigned base;
-        struct semaphore sem;
+        struct mutex mutex;
 
         /* State machine data */
         enum scx200_acb_state state;
@@ -100,7 +91,7 @@ struct scx200_acb_iface
 #define ACBSDA          (iface->base + 0)
 #define ACBST           (iface->base + 1)
 #define    ACBST_SDAST          0x40 /* SDA Status */
-#define    ACBST_BER            0x20 
+#define    ACBST_BER            0x20
 #define    ACBST_NEGACK         0x10 /* Negative Acknowledge */
 #define    ACBST_STASTR         0x08 /* Stall After Start */
 #define    ACBST_MASTER         0x02
@@ -109,9 +100,9 @@ struct scx200_acb_iface
 #define ACBCTL1         (iface->base + 3)
 #define    ACBCTL1_STASTRE      0x80
 #define    ACBCTL1_NMINTE       0x40
-#define    ACBCTL1_ACK          0x10
-#define    ACBCTL1_STOP         0x02
-#define    ACBCTL1_START        0x01
+#define    ACBCTL1_ACK          0x10
+#define    ACBCTL1_STOP         0x02
+#define    ACBCTL1_START        0x01
 #define ACBADDR         (iface->base + 4)
 #define ACBCTL2         (iface->base + 5)
 #define    ACBCTL2_ENABLE       0x01
@@ -122,8 +113,8 @@ static void scx200_acb_machine(struct scx200_acb_iface *iface, u8 status)
 {
         const char *errmsg;
 
-        DBG("state %s, status = 0x%02x\n", 
-            scx200_acb_state_name[iface->state], status);
+        dev_dbg(&iface->adapter.dev, "state %s, status = 0x%02x\n",
+                scx200_acb_state_name[iface->state], status);
 
         if (status & ACBST_BER) {
                 errmsg = "bus error";
@@ -133,8 +124,17 @@ static void scx200_acb_machine(struct scx200_acb_iface *iface, u8 status)
                 errmsg = "not master";
                 goto error;
         }
-        if (status & ACBST_NEGACK)
-                goto negack;
+        if (status & ACBST_NEGACK) {
+                dev_dbg(&iface->adapter.dev, "negative ack in state %s\n",
+                        scx200_acb_state_name[iface->state]);
+
+                iface->state = state_idle;
+                iface->result = -ENXIO;
+
+                outb(inb(ACBCTL1) | ACBCTL1_STOP, ACBCTL1);
+                outb(ACBST_STASTR | ACBST_NEGACK, ACBST);
+                return;
+        }
 
         switch (iface->state) {
         case state_idle:
@@ -160,10 +160,10 @@ static void scx200_acb_machine(struct scx200_acb_iface *iface, u8 status)
         case state_repeat_start:
                 outb(inb(ACBCTL1) | ACBCTL1_START, ACBCTL1);
                 /* fallthrough */
-                
+
         case state_quick:
                 if (iface->address_byte & 1) {
-                        if (iface->len == 1) 
+                        if (iface->len == 1)
                                 outb(inb(ACBCTL1) | ACBCTL1_ACK, ACBCTL1);
                         else
                                 outb(inb(ACBCTL1) & ~ACBCTL1_ACK, ACBCTL1);
@@ -202,26 +202,15 @@ static void scx200_acb_machine(struct scx200_acb_iface *iface, u8 status)
                         outb(inb(ACBCTL1) | ACBCTL1_STOP, ACBCTL1);
                         break;
                 }
-                
+
                 outb(*iface->ptr++, ACBSDA);
                 --iface->len;
-                
+
                 break;
         }
 
         return;
 
- negack:
-        DBG("negative acknowledge in state %s\n", 
-            scx200_acb_state_name[iface->state]);
-
-        iface->state = state_idle;
-        iface->result = -ENXIO;
-
-        outb(inb(ACBCTL1) | ACBCTL1_STOP, ACBCTL1);
-        outb(ACBST_STASTR | ACBST_NEGACK, ACBST);
-        return;
-
  error:
         dev_err(&iface->adapter.dev, "%s in state %s\n", errmsg,
                 scx200_acb_state_name[iface->state]);
@@ -231,20 +220,9 @@ static void scx200_acb_machine(struct scx200_acb_iface *iface, u8 status)
         iface->needs_reset = 1;
 }
 
-static void scx200_acb_timeout(struct scx200_acb_iface *iface) 
-{
-        dev_err(&iface->adapter.dev, "timeout in state %s\n",
-                scx200_acb_state_name[iface->state]);
-
-        iface->state = state_idle;
-        iface->result = -EIO;
-        iface->needs_reset = 1;
-}
-
-#ifdef POLLED_MODE
 static void scx200_acb_poll(struct scx200_acb_iface *iface)
 {
-        u8 status = 0;
+        u8 status;
         unsigned long timeout;
 
         timeout = jiffies + POLL_TIMEOUT;
@@ -254,17 +232,21 @@ static void scx200_acb_poll(struct scx200_acb_iface *iface)
                         scx200_acb_machine(iface, status);
                         return;
                 }
-                msleep(10);
+                yield();
         }
 
-        scx200_acb_timeout(iface);
+        dev_err(&iface->adapter.dev, "timeout in state %s\n",
+                scx200_acb_state_name[iface->state]);
+
+        iface->state = state_idle;
+        iface->result = -EIO;
+        iface->needs_reset = 1;
 }
-#endif /* POLLED_MODE */
 
 static void scx200_acb_reset(struct scx200_acb_iface *iface)
 {
         /* Disable the ACCESS.bus device and Configure the SCL
-           frequency: 16 clock cycles */
+           frequency: 16 clock cycles */
         outb(0x70, ACBCTL2);
         /* Polling mode */
         outb(0, ACBCTL1);
@@ -283,9 +265,9 @@ static void scx200_acb_reset(struct scx200_acb_iface *iface)
 }
 
 static s32 scx200_acb_smbus_xfer(struct i2c_adapter *adapter,
-                                u16 address, unsigned short flags,      
-                                char rw, u8 command, int size, 
-                                union i2c_smbus_data *data)
+                                 u16 address, unsigned short flags,
+                                 char rw, u8 command, int size,
+                                 union i2c_smbus_data *data)
 {
         struct scx200_acb_iface *iface = i2c_get_adapdata(adapter);
         int len;
@@ -295,53 +277,47 @@ static s32 scx200_acb_smbus_xfer(struct i2c_adapter *adapter,
 
         switch (size) {
         case I2C_SMBUS_QUICK:
-                len = 0;
-                buffer = NULL;
-                break;
+                len = 0;
+                buffer = NULL;
+                break;
+
         case I2C_SMBUS_BYTE:
-                if (rw == I2C_SMBUS_READ) {
-                        len = 1;
-                        buffer = &data->byte;
-                } else {
-                        len = 1;
-                        buffer = &command;
-                }
-                break;
+                len = 1;
+                buffer = rw ? &data->byte : &command;
+                break;
+
         case I2C_SMBUS_BYTE_DATA:
-                len = 1;
-                buffer = &data->byte;
-                break;
+                len = 1;
+                buffer = &data->byte;
+                break;
+
         case I2C_SMBUS_WORD_DATA:
                 len = 2;
-                cur_word = cpu_to_le16(data->word);
-                buffer = (u8 *)&cur_word;
+                cur_word = cpu_to_le16(data->word);
+                buffer = (u8 *)&cur_word;
                 break;
+
         case I2C_SMBUS_BLOCK_DATA:
-                len = data->block[0];
-                buffer = &data->block[1];
+                len = data->block[0];
+                buffer = &data->block[1];
                 break;
+
         default:
-                return -EINVAL;
+                return -EINVAL;
         }
 
-        DBG("size=%d, address=0x%x, command=0x%x, len=%d, read=%d\n",
-            size, address, command, len, rw == I2C_SMBUS_READ);
+        dev_dbg(&adapter->dev,
+                "size=%d, address=0x%x, command=0x%x, len=%d, read=%d\n",
+                size, address, command, len, rw);
 
         if (!len && rw == I2C_SMBUS_READ) {
-                dev_warn(&adapter->dev, "zero length read\n");
+                dev_dbg(&adapter->dev, "zero length read\n");
                 return -EINVAL;
         }
 
-        if (len && !buffer) {
-                dev_warn(&adapter->dev, "nonzero length but no buffer\n");
-                return -EFAULT;
-        }
-
-        down(&iface->sem);
+        mutex_lock(&iface->mutex);
 
-        iface->address_byte = address<<1;
-        if (rw == I2C_SMBUS_READ)
-                iface->address_byte |= 1;
+        iface->address_byte = (address << 1) | rw;
         iface->command = command;
         iface->ptr = buffer;
         iface->len = len;
@@ -355,25 +331,21 @@ static s32 scx200_acb_smbus_xfer(struct i2c_adapter *adapter,
         else
                 iface->state = state_address;
 
-#ifdef POLLED_MODE
         while (iface->state != state_idle)
                 scx200_acb_poll(iface);
-#else /* POLLED_MODE */
-#error Interrupt driven mode not implemented
-#endif /* POLLED_MODE */        
 
         if (iface->needs_reset)
                 scx200_acb_reset(iface);
 
         rc = iface->result;
 
-        up(&iface->sem);
+        mutex_unlock(&iface->mutex);
 
         if (rc == 0 && size == I2C_SMBUS_WORD_DATA && rw == I2C_SMBUS_READ)
-                data->word = le16_to_cpu(cur_word);
+                data->word = le16_to_cpu(cur_word);
 
 #ifdef DEBUG
-        DBG(": transfer done, result: %d", rc);
+        dev_dbg(&adapter->dev, "transfer done, result: %d", rc);
         if (buffer) {
                 int i;
                 printk(" data:");
@@ -400,17 +372,18 @@ static struct i2c_algorithm scx200_acb_algorithm = {
 };
 
 static struct scx200_acb_iface *scx200_acb_list;
+static DECLARE_MUTEX(scx200_acb_list_mutex);
 
 static int scx200_acb_probe(struct scx200_acb_iface *iface)
 {
         u8 val;
 
         /* Disable the ACCESS.bus device and Configure the SCL
-           frequency: 16 clock cycles */
+           frequency: 16 clock cycles */
         outb(0x70, ACBCTL2);
 
         if (inb(ACBCTL2) != 0x70) {
-                DBG("ACBCTL2 readback failed\n");
+                pr_debug(NAME ": ACBCTL2 readback failed\n");
                 return -ENXIO;
         }
 
@@ -418,7 +391,8 @@ static int scx200_acb_probe(struct scx200_acb_iface *iface)
 
         val = inb(ACBCTL1);
         if (val) {
-                DBG("disabled, but ACBCTL1=0x%02x\n", val);
+                pr_debug(NAME ": disabled, but ACBCTL1=0x%02x\n",
+                        val);
                 return -ENXIO;
         }
 
@@ -428,18 +402,19 @@ static int scx200_acb_probe(struct scx200_acb_iface *iface)
 
         val = inb(ACBCTL1);
         if ((val & ACBCTL1_NMINTE) != ACBCTL1_NMINTE) {
-                DBG("enabled, but NMINTE won't be set, ACBCTL1=0x%02x\n", val);
+                pr_debug(NAME ": enabled, but NMINTE won't be set, "
+                         "ACBCTL1=0x%02x\n", val);
                 return -ENXIO;
         }
 
         return 0;
 }
 
-static int  __init scx200_acb_create(int base, int index)
+static int  __init scx200_acb_create(const char *text, int base, int index)
 {
         struct scx200_acb_iface *iface;
         struct i2c_adapter *adapter;
-        int rc = 0;
+        int rc;
         char description[64];
 
         iface = kzalloc(sizeof(*iface), GFP_KERNEL);
@@ -451,50 +426,51 @@ static int  __init scx200_acb_create(int base, int index)
 
         adapter = &iface->adapter;
         i2c_set_adapdata(adapter, iface);
-        snprintf(adapter->name, I2C_NAME_SIZE, "SCx200 ACB%d", index);
+        snprintf(adapter->name, I2C_NAME_SIZE, "%s ACB%d", text, index);
         adapter->owner = THIS_MODULE;
         adapter->id = I2C_HW_SMBUS_SCX200;
         adapter->algo = &scx200_acb_algorithm;
         adapter->class = I2C_CLASS_HWMON;
 
-        init_MUTEX(&iface->sem);
+        mutex_init(&iface->mutex);
+
+        snprintf(description, sizeof(description), "%s ACCESS.bus [%s]",
+                 text, adapter->name);
 
-        snprintf(description, sizeof(description), "NatSemi SCx200 ACCESS.bus [%s]", adapter->name);
         if (request_region(base, 8, description) == 0) {
-                dev_err(&adapter->dev, "can't allocate io 0x%x-0x%x\n",
+                printk(KERN_ERR NAME ": can't allocate io 0x%x-0x%x\n",
                         base, base + 8-1);
                 rc = -EBUSY;
-                goto errout;
+                goto errout_free;
         }
         iface->base = base;
 
         rc = scx200_acb_probe(iface);
         if (rc) {
-                dev_warn(&adapter->dev, "probe failed\n");
-                goto errout;
+                printk(KERN_WARNING NAME ": probe failed\n");
+                goto errout_release;
         }
 
         scx200_acb_reset(iface);
 
         if (i2c_add_adapter(adapter) < 0) {
-                dev_err(&adapter->dev, "failed to register\n");
+                printk(KERN_ERR NAME ": failed to register\n");
                 rc = -ENODEV;
-                goto errout;
+                goto errout_release;
         }
 
-        lock_kernel();
+        down(&scx200_acb_list_mutex);
         iface->next = scx200_acb_list;
         scx200_acb_list = iface;
-        unlock_kernel();
+        up(&scx200_acb_list_mutex);
 
         return 0;
 
+ errout_release:
+        release_region(iface->base, 8);
+ errout_free:
+        kfree(iface);
  errout:
-        if (iface) {
-                if (iface->base)
-                        release_region(iface->base, 8);
-                kfree(iface);
-        }
         return rc;
 }
 
@@ -504,50 +480,69 @@ static struct pci_device_id scx200[] = {
         { },
 };
 
+static struct pci_device_id divil_pci[] = {
+        { PCI_DEVICE(PCI_VENDOR_ID_NS,  PCI_DEVICE_ID_NS_CS5535_ISA) },
+        { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_CS5536_ISA) },
+        { } /* NULL entry */
+};
+
+#define MSR_LBAR_SMB            0x5140000B
+
+static int scx200_add_cs553x(void)
+{
+        u32     low, hi;
+        u32     smb_base;
+
+        /* Grab & reserve the SMB I/O range */
+        rdmsr(MSR_LBAR_SMB, low, hi);
+
+        /* Check the IO mask and whether SMB is enabled */
+        if (hi != 0x0000F001) {
+                printk(KERN_WARNING NAME ": SMBus not enabled\n");
+                return -ENODEV;
+        }
+
+        /* SMBus IO size is 8 bytes */
+        smb_base = low & 0x0000FFF8;
+
+        return scx200_acb_create("CS5535", smb_base, 0);
+}
+
 static int __init scx200_acb_init(void)
 {
         int i;
-        int rc;
+        int     rc = -ENODEV;
 
         pr_debug(NAME ": NatSemi SCx200 ACCESS.bus Driver\n");
 
         /* Verify that this really is a SCx200 processor */
-        if (pci_dev_present(scx200) == 0)
-                return -ENODEV;
+        if (pci_dev_present(scx200)) {
+                for (i = 0; i < MAX_DEVICES; ++i) {
+                        if (base[i] > 0)
+                                rc = scx200_acb_create("SCx200", base[i], i);
+                }
+        } else if (pci_dev_present(divil_pci))
+                rc = scx200_add_cs553x();
 
-        rc = -ENXIO;
-        for (i = 0; i < MAX_DEVICES; ++i) {
-                if (base[i] > 0)
-                        rc = scx200_acb_create(base[i], i);
-        }
-        if (scx200_acb_list)
-                return 0;
         return rc;
 }
 
 static void __exit scx200_acb_cleanup(void)
 {
         struct scx200_acb_iface *iface;
-        lock_kernel();
+
+        down(&scx200_acb_list_mutex);
         while ((iface = scx200_acb_list) != NULL) {
                 scx200_acb_list = iface->next;
-                unlock_kernel();
+                up(&scx200_acb_list_mutex);
 
                 i2c_del_adapter(&iface->adapter);
                 release_region(iface->base, 8);
                 kfree(iface);
-                lock_kernel();
+                down(&scx200_acb_list_mutex);
         }
-        unlock_kernel();
+        up(&scx200_acb_list_mutex);
 }
 
 module_init(scx200_acb_init);
 module_exit(scx200_acb_cleanup);
-
-/*
-    Local variables:
-        compile-command: "make -k -C ../.. SUBDIRS=drivers/i2c modules"
-        c-basic-offset: 8
-    End:
-*/
-
diff --git a/drivers/i2c/chips/ds1374.c b/drivers/i2c/chips/ds1374.c
index 0710b9da9d..03d09ed5ec 100644
--- a/drivers/i2c/chips/ds1374.c
+++ b/drivers/i2c/chips/ds1374.c
@@ -26,6 +26,7 @@
 #include <linux/i2c.h>
 #include <linux/rtc.h>
 #include <linux/bcd.h>
+#include <linux/mutex.h>
 
 #define DS1374_REG_TOD0         0x00
 #define DS1374_REG_TOD1         0x01
@@ -41,7 +42,7 @@
 
 #define DS1374_DRV_NAME         "ds1374"
 
-static DECLARE_MUTEX(ds1374_mutex);
+static DEFINE_MUTEX(ds1374_mutex);
 
 static struct i2c_driver ds1374_driver;
 static struct i2c_client *save_client;
@@ -114,7 +115,7 @@ ulong ds1374_get_rtc_time(void)
         ulong t1, t2;
         int limit = 10;         /* arbitrary retry limit */
 
-        down(&ds1374_mutex);
+        mutex_lock(&ds1374_mutex);
 
         /*
          * Since the reads are being performed one byte at a time using
@@ -127,7 +128,7 @@ ulong ds1374_get_rtc_time(void)
                 t2 = ds1374_read_rtc();
         } while (t1 != t2 && limit--);
 
-        up(&ds1374_mutex);
+        mutex_unlock(&ds1374_mutex);
 
         if (t1 != t2) {
                 dev_warn(&save_client->dev,
@@ -145,7 +146,7 @@ static void ds1374_set_tlet(ulong arg)
 
         t1 = *(ulong *) arg;
 
-        down(&ds1374_mutex);
+        mutex_lock(&ds1374_mutex);
 
         /*
          * Since the writes are being performed one byte at a time using
@@ -158,7 +159,7 @@ static void ds1374_set_tlet(ulong arg)
                 t2 = ds1374_read_rtc();
         } while (t1 != t2 && limit--);
 
-        up(&ds1374_mutex);
+        mutex_unlock(&ds1374_mutex);
 
         if (t1 != t2)
                 dev_warn(&save_client->dev,
diff --git a/drivers/i2c/chips/eeprom.c b/drivers/i2c/chips/eeprom.c
index 41116b7947..13c108269a 100644
--- a/drivers/i2c/chips/eeprom.c
+++ b/drivers/i2c/chips/eeprom.c
@@ -33,6 +33,7 @@
 #include <linux/sched.h>
 #include <linux/jiffies.h>
 #include <linux/i2c.h>
+#include <linux/mutex.h>
 
 /* Addresses to scan */
 static unsigned short normal_i2c[] = { 0x50, 0x51, 0x52, 0x53, 0x54,
@@ -54,7 +55,7 @@ enum eeprom_nature {
 /* Each client has this additional data */
 struct eeprom_data {
         struct i2c_client client;
-        struct semaphore update_lock;
+        struct mutex update_lock;
         u8 valid;                       /* bitfield, bit!=0 if slice is valid */
         unsigned long last_updated[8];  /* In jiffies, 8 slices */
         u8 data[EEPROM_SIZE];           /* Register values */
@@ -81,7 +82,7 @@ static void eeprom_update_client(struct i2c_client *client, u8 slice)
         struct eeprom_data *data = i2c_get_clientdata(client);
         int i, j;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if (!(data->valid & (1 << slice)) ||
             time_after(jiffies, data->last_updated[slice] + 300 * HZ)) {
@@ -107,7 +108,7 @@ static void eeprom_update_client(struct i2c_client *client, u8 slice)
                 data->valid |= (1 << slice);
         }
 exit:
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 }
 
 static ssize_t eeprom_read(struct kobject *kobj, char *buf, loff_t off, size_t count)
@@ -187,7 +188,7 @@ static int eeprom_detect(struct i2c_adapter *adapter, int address, int kind)
         /* Fill in the remaining client fields */
         strlcpy(new_client->name, "eeprom", I2C_NAME_SIZE);
         data->valid = 0;
-        init_MUTEX(&data->update_lock);
+        mutex_init(&data->update_lock);
         data->nature = UNKNOWN;
 
         /* Tell the I2C layer a new client has arrived */
diff --git a/drivers/i2c/chips/isp1301_omap.c b/drivers/i2c/chips/isp1301_omap.c
index 1251c7fc18..e6f1ab7b91 100644
--- a/drivers/i2c/chips/isp1301_omap.c
+++ b/drivers/i2c/chips/isp1301_omap.c
@@ -1635,8 +1635,6 @@ static struct i2c_driver isp1301_driver = {
         .driver = {
                 .name   = "isp1301_omap",
         },
-        .id             = 1301,         /* FIXME "official", i2c-ids.h */
-        .class          = I2C_CLASS_HWMON,
         .attach_adapter = isp1301_scan_bus,
         .detach_client  = isp1301_detach_client,
 };
diff --git a/drivers/i2c/chips/m41t00.c b/drivers/i2c/chips/m41t00.c
index 2dc3d48375..b5aabe7cf7 100644
--- a/drivers/i2c/chips/m41t00.c
+++ b/drivers/i2c/chips/m41t00.c
@@ -24,13 +24,14 @@
 #include <linux/i2c.h>
 #include <linux/rtc.h>
 #include <linux/bcd.h>
+#include <linux/mutex.h>
 
 #include <asm/time.h>
 #include <asm/rtc.h>
 
 #define M41T00_DRV_NAME         "m41t00"
 
-static DECLARE_MUTEX(m41t00_mutex);
+static DEFINE_MUTEX(m41t00_mutex);
 
 static struct i2c_driver m41t00_driver;
 static struct i2c_client *save_client;
@@ -54,7 +55,7 @@ m41t00_get_rtc_time(void)
         sec = min = hour = day = mon = year = 0;
         sec1 = min1 = hour1 = day1 = mon1 = year1 = 0;
 
-        down(&m41t00_mutex);
+        mutex_lock(&m41t00_mutex);
         do {
                 if (((sec = i2c_smbus_read_byte_data(save_client, 0)) >= 0)
                         && ((min = i2c_smbus_read_byte_data(save_client, 1))
@@ -80,7 +81,7 @@ m41t00_get_rtc_time(void)
                 mon1 = mon;
                 year1 = year;
         } while (--limit > 0);
-        up(&m41t00_mutex);
+        mutex_unlock(&m41t00_mutex);
 
         if (limit == 0) {
                 dev_warn(&save_client->dev,
@@ -125,7 +126,7 @@ m41t00_set_tlet(ulong arg)
         BIN_TO_BCD(tm.tm_mday);
         BIN_TO_BCD(tm.tm_year);
 
-        down(&m41t00_mutex);
+        mutex_lock(&m41t00_mutex);
         if ((i2c_smbus_write_byte_data(save_client, 0, tm.tm_sec & 0x7f) < 0)
                 || (i2c_smbus_write_byte_data(save_client, 1, tm.tm_min & 0x7f)
                         < 0)
@@ -140,7 +141,7 @@ m41t00_set_tlet(ulong arg)
 
                 dev_warn(&save_client->dev,"m41t00: can't write to rtc chip\n");
 
-        up(&m41t00_mutex);
+        mutex_unlock(&m41t00_mutex);
         return;
 }
 
diff --git a/drivers/i2c/chips/max6875.c b/drivers/i2c/chips/max6875.c
index 6d3ff58415..88d2ddee44 100644
--- a/drivers/i2c/chips/max6875.c
+++ b/drivers/i2c/chips/max6875.c
@@ -31,7 +31,7 @@
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/i2c.h>
-#include <asm/semaphore.h>
+#include <linux/mutex.h>
 
 /* Do not scan - the MAX6875 access method will write to some EEPROM chips */
 static unsigned short normal_i2c[] = {I2C_CLIENT_END};
@@ -54,7 +54,7 @@ I2C_CLIENT_INSMOD_1(max6875);
 /* Each client has this additional data */
 struct max6875_data {
         struct i2c_client       client;
-        struct semaphore        update_lock;
+        struct mutex            update_lock;
 
         u32                     valid;
         u8                      data[USER_EEPROM_SIZE];
@@ -83,7 +83,7 @@ static void max6875_update_slice(struct i2c_client *client, int slice)
         if (slice >= USER_EEPROM_SLICES)
                 return;
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         buf = &data->data[slice << SLICE_BITS];
 
@@ -122,7 +122,7 @@ static void max6875_update_slice(struct i2c_client *client, int slice)
                 data->valid |= (1 << slice);
         }
 exit_up:
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 }
 
 static ssize_t max6875_read(struct kobject *kobj, char *buf, loff_t off,
@@ -196,7 +196,7 @@ static int max6875_detect(struct i2c_adapter *adapter, int address, int kind)
         real_client->driver = &max6875_driver;
         real_client->flags = 0;
         strlcpy(real_client->name, "max6875", I2C_NAME_SIZE);
-        init_MUTEX(&data->update_lock);
+        mutex_init(&data->update_lock);
 
         /* Init fake client data */
         /* set the client data to the i2c_client so that it will get freed */
diff --git a/drivers/i2c/chips/pcf8591.c b/drivers/i2c/chips/pcf8591.c
index 36cff09c67..925a6b371f 100644
--- a/drivers/i2c/chips/pcf8591.c
+++ b/drivers/i2c/chips/pcf8591.c
@@ -24,6 +24,7 @@
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/i2c.h>
+#include <linux/mutex.h>
 
 /* Addresses to scan */
 static unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4b, 0x4c,
@@ -74,7 +75,7 @@ MODULE_PARM_DESC(input_mode,
 
 struct pcf8591_data {
         struct i2c_client client;
-        struct semaphore update_lock;
+        struct mutex update_lock;
 
         u8 control;
         u8 aout;
@@ -144,13 +145,13 @@ static ssize_t set_out0_enable(struct device *dev, struct device_attribute *attr
         struct pcf8591_data *data = i2c_get_clientdata(client);
         unsigned long val = simple_strtoul(buf, NULL, 10);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
         if (val)
                 data->control |= PCF8591_CONTROL_AOEF;
         else
                 data->control &= ~PCF8591_CONTROL_AOEF;
         i2c_smbus_write_byte(client, data->control);
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
         return count;
 }
 
@@ -200,7 +201,7 @@ static int pcf8591_detect(struct i2c_adapter *adapter, int address, int kind)
         /* Fill in the remaining client fields and put it into the global 
            list */
         strlcpy(new_client->name, "pcf8591", I2C_NAME_SIZE);
-        init_MUTEX(&data->update_lock);
+        mutex_init(&data->update_lock);
 
         /* Tell the I2C layer a new client has arrived */
         if ((err = i2c_attach_client(new_client)))
@@ -265,7 +266,7 @@ static int pcf8591_read_channel(struct device *dev, int channel)
         struct i2c_client *client = to_i2c_client(dev);
         struct pcf8591_data *data = i2c_get_clientdata(client);
 
-        down(&data->update_lock);
+        mutex_lock(&data->update_lock);
 
         if ((data->control & PCF8591_CONTROL_AICH_MASK) != channel) {
                 data->control = (data->control & ~PCF8591_CONTROL_AICH_MASK)
@@ -278,7 +279,7 @@ static int pcf8591_read_channel(struct device *dev, int channel)
         }
         value = i2c_smbus_read_byte(client);
 
-        up(&data->update_lock);
+        mutex_unlock(&data->update_lock);
 
         if ((channel == 2 && input_mode == 2) ||
             (channel != 3 && (input_mode == 1 || input_mode == 3)))
diff --git a/drivers/i2c/chips/rtc8564.c b/drivers/i2c/chips/rtc8564.c
index ceaa6b0bdf..0d8699b3f4 100644
--- a/drivers/i2c/chips/rtc8564.c
+++ b/drivers/i2c/chips/rtc8564.c
@@ -53,7 +53,7 @@ static inline u8 _rtc8564_ctrl2(struct i2c_client *client)
 #define CTRL1(c) _rtc8564_ctrl1(c)
 #define CTRL2(c) _rtc8564_ctrl2(c)
 
-static int debug;;
+static int debug;
 module_param(debug, int, S_IRUGO | S_IWUSR);
 
 static struct i2c_driver rtc8564_driver;
diff --git a/drivers/i2c/chips/tps65010.c b/drivers/i2c/chips/tps65010.c
index 1af3dfbb80..179b1e022d 100644
--- a/drivers/i2c/chips/tps65010.c
+++ b/drivers/i2c/chips/tps65010.c
@@ -32,6 +32,7 @@
 #include <linux/suspend.h>
 #include <linux/debugfs.h>
 #include <linux/seq_file.h>
+#include <linux/mutex.h>
 
 #include <asm/irq.h>
 #include <asm/mach-types.h>
@@ -81,7 +82,7 @@ enum tps_model {
 
 struct tps65010 {
         struct i2c_client       client;
-        struct semaphore        lock;
+        struct mutex            lock;
         int                     irq;
         struct work_struct      work;
         struct dentry           *file;
@@ -218,7 +219,7 @@ static int dbg_show(struct seq_file *s, void *_)
         seq_printf(s, "driver  %s\nversion %s\nchip    %s\n\n",
                         DRIVER_NAME, DRIVER_VERSION, chip);
 
-        down(&tps->lock);
+        mutex_lock(&tps->lock);
 
         /* FIXME how can we tell whether a battery is present?
          * likely involves a charge gauging chip (like BQ26501).
@@ -300,7 +301,7 @@ static int dbg_show(struct seq_file *s, void *_)
                                 (v2 & (1 << (4 + i))) ? "rising" : "falling");
         }
 
-        up(&tps->lock);
+        mutex_unlock(&tps->lock);
         return 0;
 }
 
@@ -416,7 +417,7 @@ static void tps65010_work(void *_tps)
 {
         struct tps65010         *tps = _tps;
 
-        down(&tps->lock);
+        mutex_lock(&tps->lock);
 
         tps65010_interrupt(tps);
 
@@ -444,7 +445,7 @@ static void tps65010_work(void *_tps)
         if (test_and_clear_bit(FLAG_IRQ_ENABLE, &tps->flags))
                 enable_irq(tps->irq);
 
-        up(&tps->lock);
+        mutex_unlock(&tps->lock);
 }
 
 static irqreturn_t tps65010_irq(int irq, void *_tps, struct pt_regs *regs)
@@ -505,7 +506,7 @@ tps65010_probe(struct i2c_adapter *bus, int address, int kind)
         if (!tps)
                 return 0;
 
-        init_MUTEX(&tps->lock);
+        mutex_init(&tps->lock);
         INIT_WORK(&tps->work, tps65010_work, tps);
         tps->irq = -1;
         tps->client.addr = address;
@@ -695,7 +696,7 @@ int tps65010_set_gpio_out_value(unsigned gpio, unsigned value)
         if ((gpio < GPIO1) || (gpio > GPIO4))
                 return -EINVAL;
 
-        down(&the_tps->lock);
+        mutex_lock(&the_tps->lock);
 
         defgpio = i2c_smbus_read_byte_data(&the_tps->client, TPS_DEFGPIO);
 
@@ -720,7 +721,7 @@ int tps65010_set_gpio_out_value(unsigned gpio, unsigned value)
                 gpio, value ? "high" : "low",
                 i2c_smbus_read_byte_data(&the_tps->client, TPS_DEFGPIO));
 
-        up(&the_tps->lock);
+        mutex_unlock(&the_tps->lock);
         return status;
 }
 EXPORT_SYMBOL(tps65010_set_gpio_out_value);
@@ -745,7 +746,7 @@ int tps65010_set_led(unsigned led, unsigned mode)
                 led = LED2;
         }
 
-        down(&the_tps->lock);
+        mutex_lock(&the_tps->lock);
 
         pr_debug("%s: led%i_on   0x%02x\n", DRIVER_NAME, led,
                 i2c_smbus_read_byte_data(&the_tps->client,
@@ -771,7 +772,7 @@ int tps65010_set_led(unsigned led, unsigned mode)
         default:
                 printk(KERN_ERR "%s: Wrong mode parameter for set_led()\n",
                        DRIVER_NAME);
-                up(&the_tps->lock);
+                mutex_unlock(&the_tps->lock);
                 return -EINVAL;
         }
 
@@ -781,7 +782,7 @@ int tps65010_set_led(unsigned led, unsigned mode)
         if (status != 0) {
                 printk(KERN_ERR "%s: Failed to write led%i_on register\n",
                        DRIVER_NAME, led);
-                up(&the_tps->lock);
+                mutex_unlock(&the_tps->lock);
                 return status;
         }
 
@@ -794,7 +795,7 @@ int tps65010_set_led(unsigned led, unsigned mode)
         if (status != 0) {
                 printk(KERN_ERR "%s: Failed to write led%i_per register\n",
                        DRIVER_NAME, led);
-                up(&the_tps->lock);
+                mutex_unlock(&the_tps->lock);
                 return status;
         }
 
@@ -802,7 +803,7 @@ int tps65010_set_led(unsigned led, unsigned mode)
                 i2c_smbus_read_byte_data(&the_tps->client,
                                 TPS_LED1_PER + offs));
 
-        up(&the_tps->lock);
+        mutex_unlock(&the_tps->lock);
 
         return status;
 }
@@ -820,7 +821,7 @@ int tps65010_set_vib(unsigned value)
         if (!the_tps)
                 return -ENODEV;
 
-        down(&the_tps->lock);
+        mutex_lock(&the_tps->lock);
 
         vdcdc2 = i2c_smbus_read_byte_data(&the_tps->client, TPS_VDCDC2);
         vdcdc2 &= ~(1 << 1);
@@ -831,7 +832,7 @@ int tps65010_set_vib(unsigned value)
 
         pr_debug("%s: vibrator %s\n", DRIVER_NAME, value ? "on" : "off");
 
-        up(&the_tps->lock);
+        mutex_unlock(&the_tps->lock);
         return status;
 }
 EXPORT_SYMBOL(tps65010_set_vib);
@@ -848,7 +849,7 @@ int tps65010_set_low_pwr(unsigned mode)
         if (!the_tps)
                 return -ENODEV;
 
-        down(&the_tps->lock);
+        mutex_lock(&the_tps->lock);
 
         pr_debug("%s: %s low_pwr, vdcdc1 0x%02x\n", DRIVER_NAME,
                 mode ? "enable" : "disable",
@@ -876,7 +877,7 @@ int tps65010_set_low_pwr(unsigned mode)
                 pr_debug("%s: vdcdc1 0x%02x\n", DRIVER_NAME,
                         i2c_smbus_read_byte_data(&the_tps->client, TPS_VDCDC1));
 
-        up(&the_tps->lock);
+        mutex_unlock(&the_tps->lock);
 
         return status;
 }
@@ -894,7 +895,7 @@ int tps65010_config_vregs1(unsigned value)
         if (!the_tps)
                 return -ENODEV;
 
-        down(&the_tps->lock);
+        mutex_lock(&the_tps->lock);
 
         pr_debug("%s: vregs1 0x%02x\n", DRIVER_NAME,
                         i2c_smbus_read_byte_data(&the_tps->client, TPS_VREGS1));
@@ -909,7 +910,7 @@ int tps65010_config_vregs1(unsigned value)
                 pr_debug("%s: vregs1 0x%02x\n", DRIVER_NAME,
                         i2c_smbus_read_byte_data(&the_tps->client, TPS_VREGS1));
 
-        up(&the_tps->lock);
+        mutex_unlock(&the_tps->lock);
 
         return status;
 }
@@ -931,7 +932,7 @@ int tps65013_set_low_pwr(unsigned mode)
         if (!the_tps || the_tps->por)
                 return -ENODEV;
 
-        down(&the_tps->lock);
+        mutex_lock(&the_tps->lock);
 
         pr_debug("%s: %s low_pwr, chgconfig 0x%02x vdcdc1 0x%02x\n",
                 DRIVER_NAME,
@@ -959,7 +960,7 @@ int tps65013_set_low_pwr(unsigned mode)
         if (status != 0) {
                 printk(KERN_ERR "%s: Failed to write chconfig register\n",
          DRIVER_NAME);
-                up(&the_tps->lock);
+                mutex_unlock(&the_tps->lock);
                 return status;
         }
 
@@ -977,7 +978,7 @@ int tps65013_set_low_pwr(unsigned mode)
                 pr_debug("%s: vdcdc1 0x%02x\n", DRIVER_NAME,
                         i2c_smbus_read_byte_data(&the_tps->client, TPS_VDCDC1));
 
-        up(&the_tps->lock);
+        mutex_unlock(&the_tps->lock);
 
         return status;
 }
diff --git a/drivers/i2c/i2c-core.c b/drivers/i2c/i2c-core.c
index 1a2c9ab5d9..45e2cdf547 100644
--- a/drivers/i2c/i2c-core.c
+++ b/drivers/i2c/i2c-core.c
@@ -31,12 +31,13 @@
 #include <linux/idr.h>
 #include <linux/seq_file.h>
 #include <linux/platform_device.h>
+#include <linux/mutex.h>
 #include <asm/uaccess.h>
 
 
 static LIST_HEAD(adapters);
 static LIST_HEAD(drivers);
-static DECLARE_MUTEX(core_lists);
+static DEFINE_MUTEX(core_lists);
 static DEFINE_IDR(i2c_adapter_idr);
 
 /* match always succeeds, as we want the probe() to tell if we really accept this match */
@@ -153,7 +154,7 @@ int i2c_add_adapter(struct i2c_adapter *adap)
         struct list_head   *item;
         struct i2c_driver  *driver;
 
-        down(&core_lists);
+        mutex_lock(&core_lists);
 
         if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0) {
                 res = -ENOMEM;
@@ -168,8 +169,8 @@ int i2c_add_adapter(struct i2c_adapter *adap)
         }
 
         adap->nr =  id & MAX_ID_MASK;
-        init_MUTEX(&adap->bus_lock);
-        init_MUTEX(&adap->clist_lock);
+        mutex_init(&adap->bus_lock);
+        mutex_init(&adap->clist_lock);
         list_add_tail(&adap->list,&adapters);
         INIT_LIST_HEAD(&adap->clients);
 
@@ -203,7 +204,7 @@ int i2c_add_adapter(struct i2c_adapter *adap)
         }
 
 out_unlock:
-        up(&core_lists);
+        mutex_unlock(&core_lists);
         return res;
 }
 
@@ -216,7 +217,7 @@ int i2c_del_adapter(struct i2c_adapter *adap)
         struct i2c_client *client;
         int res = 0;
 
-        down(&core_lists);
+        mutex_lock(&core_lists);
 
         /* First make sure that this adapter was ever added */
         list_for_each_entry(adap_from_list, &adapters, list) {
@@ -272,7 +273,7 @@ int i2c_del_adapter(struct i2c_adapter *adap)
         dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
 
  out_unlock:
-        up(&core_lists);
+        mutex_unlock(&core_lists);
         return res;
 }
 
@@ -287,9 +288,7 @@ int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
 {
         struct list_head   *item;
         struct i2c_adapter *adapter;
-        int res = 0;
-
-        down(&core_lists);
+        int res;
 
         /* add the driver to the list of i2c drivers in the driver core */
         driver->driver.owner = owner;
@@ -297,8 +296,10 @@ int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
 
         res = driver_register(&driver->driver);
         if (res)
-                goto out_unlock;
+                return res;
         
+        mutex_lock(&core_lists);
+
         list_add_tail(&driver->list,&drivers);
         pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
 
@@ -310,9 +311,8 @@ int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
                 }
         }
 
- out_unlock:
-        up(&core_lists);
-        return res;
+        mutex_unlock(&core_lists);
+        return 0;
 }
 EXPORT_SYMBOL(i2c_register_driver);
 
@@ -324,7 +324,7 @@ int i2c_del_driver(struct i2c_driver *driver)
         
         int res = 0;
 
-        down(&core_lists);
+        mutex_lock(&core_lists);
 
         /* Have a look at each adapter, if clients of this driver are still
          * attached. If so, detach them to be able to kill the driver 
@@ -363,7 +363,7 @@ int i2c_del_driver(struct i2c_driver *driver)
         pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);
 
  out_unlock:
-        up(&core_lists);
+        mutex_unlock(&core_lists);
         return 0;
 }
 
@@ -384,9 +384,9 @@ int i2c_check_addr(struct i2c_adapter *adapter, int addr)
 {
         int rval;
 
-        down(&adapter->clist_lock);
+        mutex_lock(&adapter->clist_lock);
         rval = __i2c_check_addr(adapter, addr);
-        up(&adapter->clist_lock);
+        mutex_unlock(&adapter->clist_lock);
 
         return rval;
 }
@@ -395,13 +395,13 @@ int i2c_attach_client(struct i2c_client *client)
 {
         struct i2c_adapter *adapter = client->adapter;
 
-        down(&adapter->clist_lock);
+        mutex_lock(&adapter->clist_lock);
         if (__i2c_check_addr(client->adapter, client->addr)) {
-                up(&adapter->clist_lock);
+                mutex_unlock(&adapter->clist_lock);
                 return -EBUSY;
         }
         list_add_tail(&client->list,&adapter->clients);
-        up(&adapter->clist_lock);
+        mutex_unlock(&adapter->clist_lock);
         
         if (adapter->client_register)  {
                 if (adapter->client_register(client))  {
@@ -450,12 +450,12 @@ int i2c_detach_client(struct i2c_client *client)
                 }
         }
 
-        down(&adapter->clist_lock);
+        mutex_lock(&adapter->clist_lock);
         list_del(&client->list);
         init_completion(&client->released);
         device_remove_file(&client->dev, &dev_attr_client_name);
         device_unregister(&client->dev);
-        up(&adapter->clist_lock);
+        mutex_unlock(&adapter->clist_lock);
         wait_for_completion(&client->released);
 
  out:
@@ -513,19 +513,19 @@ void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
         struct list_head  *item;
         struct i2c_client *client;
 
-        down(&adap->clist_lock);
+        mutex_lock(&adap->clist_lock);
         list_for_each(item,&adap->clients) {
                 client = list_entry(item, struct i2c_client, list);
                 if (!try_module_get(client->driver->driver.owner))
                         continue;
                 if (NULL != client->driver->command) {
-                        up(&adap->clist_lock);
+                        mutex_unlock(&adap->clist_lock);
                         client->driver->command(client,cmd,arg);
-                        down(&adap->clist_lock);
+                        mutex_lock(&adap->clist_lock);
                 }
                 module_put(client->driver->driver.owner);
        }
-       up(&adap->clist_lock);
+       mutex_unlock(&adap->clist_lock);
 }
 
 static int __init i2c_init(void)
@@ -569,9 +569,9 @@ int i2c_transfer(struct i2c_adapter * adap, struct i2c_msg *msgs, int num)
                 }
 #endif
 
-                down(&adap->bus_lock);
+                mutex_lock(&adap->bus_lock);
                 ret = adap->algo->master_xfer(adap,msgs,num);
-                up(&adap->bus_lock);
+                mutex_unlock(&adap->bus_lock);
 
                 return ret;
         } else {
@@ -779,12 +779,12 @@ struct i2c_adapter* i2c_get_adapter(int id)
 {
         struct i2c_adapter *adapter;
         
-        down(&core_lists);
+        mutex_lock(&core_lists);
         adapter = (struct i2c_adapter *)idr_find(&i2c_adapter_idr, id);
         if (adapter && !try_module_get(adapter->owner))
                 adapter = NULL;
 
-        up(&core_lists);
+        mutex_unlock(&core_lists);
         return adapter;
 }
 
@@ -919,12 +919,11 @@ s32 i2c_smbus_write_block_data(struct i2c_client *client, u8 command,
                                u8 length, u8 *values)
 {
         union i2c_smbus_data data;
-        int i;
+
         if (length > I2C_SMBUS_BLOCK_MAX)
                 length = I2C_SMBUS_BLOCK_MAX;
-        for (i = 1; i <= length; i++)
-                data.block[i] = values[i-1];
         data.block[0] = length;
+        memcpy(&data.block[1], values, length);
         return i2c_smbus_xfer(client->adapter,client->addr,client->flags,
                               I2C_SMBUS_WRITE,command,
                               I2C_SMBUS_BLOCK_DATA,&data);
@@ -934,16 +933,14 @@ s32 i2c_smbus_write_block_data(struct i2c_client *client, u8 command,
 s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client, u8 command, u8 *values)
 {
         union i2c_smbus_data data;
-        int i;
+
         if (i2c_smbus_xfer(client->adapter,client->addr,client->flags,
                               I2C_SMBUS_READ,command,
                               I2C_SMBUS_I2C_BLOCK_DATA,&data))
                 return -1;
-        else {
-                for (i = 1; i <= data.block[0]; i++)
-                        values[i-1] = data.block[i];
-                return data.block[0];
-        }
+
+        memcpy(values, &data.block[1], data.block[0]);
+        return data.block[0];
 }
 
 s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client, u8 command,
@@ -1118,10 +1115,10 @@ s32 i2c_smbus_xfer(struct i2c_adapter * adapter, u16 addr, unsigned short flags,
         flags &= I2C_M_TEN | I2C_CLIENT_PEC;
 
         if (adapter->algo->smbus_xfer) {
-                down(&adapter->bus_lock);
+                mutex_lock(&adapter->bus_lock);
                 res = adapter->algo->smbus_xfer(adapter,addr,flags,read_write,
                                                 command,size,data);
-                up(&adapter->bus_lock);
+                mutex_unlock(&adapter->bus_lock);
         } else
                 res = i2c_smbus_xfer_emulated(adapter,addr,flags,read_write,
                                               command,size,data);
diff --git a/drivers/ide/ide-cd.c b/drivers/ide/ide-cd.c
index 3325660f72..c7671e1880 100644
--- a/drivers/ide/ide-cd.c
+++ b/drivers/ide/ide-cd.c
@@ -313,6 +313,7 @@
 #include <linux/cdrom.h>
 #include <linux/ide.h>
 #include <linux/completion.h>
+#include <linux/mutex.h>
 
 #include <scsi/scsi.h>  /* For SCSI -> ATAPI command conversion */
 
@@ -324,7 +325,7 @@
 
 #include "ide-cd.h"
 
-static DECLARE_MUTEX(idecd_ref_sem);
+static DEFINE_MUTEX(idecd_ref_mutex);
 
 #define to_ide_cd(obj) container_of(obj, struct cdrom_info, kref) 
 
@@ -335,11 +336,11 @@ static struct cdrom_info *ide_cd_get(struct gendisk *disk)
 {
         struct cdrom_info *cd = NULL;
 
-        down(&idecd_ref_sem);
+        mutex_lock(&idecd_ref_mutex);
         cd = ide_cd_g(disk);
         if (cd)
                 kref_get(&cd->kref);
-        up(&idecd_ref_sem);
+        mutex_unlock(&idecd_ref_mutex);
         return cd;
 }
 
@@ -347,9 +348,9 @@ static void ide_cd_release(struct kref *);
 
 static void ide_cd_put(struct cdrom_info *cd)
 {
-        down(&idecd_ref_sem);
+        mutex_lock(&idecd_ref_mutex);
         kref_put(&cd->kref, ide_cd_release);
-        up(&idecd_ref_sem);
+        mutex_unlock(&idecd_ref_mutex);
 }
 
 /****************************************************************************
@@ -2471,52 +2472,6 @@ static int ide_cdrom_packet(struct cdrom_device_info *cdi,
 }
 
 static
-int ide_cdrom_dev_ioctl (struct cdrom_device_info *cdi,
-                         unsigned int cmd, unsigned long arg)
-{
-        struct packet_command cgc;
-        char buffer[16];
-        int stat;
-
-        init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
-
-        /* These will be moved into the Uniform layer shortly... */
-        switch (cmd) {
-        case CDROMSETSPINDOWN: {
-                char spindown;
- 
-                if (copy_from_user(&spindown, (void __user *) arg, sizeof(char)))
-                        return -EFAULT;
- 
-                if ((stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0)))
-                        return stat;
-
-                buffer[11] = (buffer[11] & 0xf0) | (spindown & 0x0f);
-
-                return cdrom_mode_select(cdi, &cgc);
-        } 
- 
-        case CDROMGETSPINDOWN: {
-                char spindown;
- 
-                if ((stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0)))
-                        return stat;
- 
-                spindown = buffer[11] & 0x0f;
- 
-                if (copy_to_user((void __user *) arg, &spindown, sizeof (char)))
-                        return -EFAULT;
- 
-                return 0;
-        }
-  
-        default:
-                return -EINVAL;
-        }
-
-}
-
-static
 int ide_cdrom_audio_ioctl (struct cdrom_device_info *cdi,
                            unsigned int cmd, void *arg)
                            
@@ -2852,12 +2807,11 @@ static struct cdrom_device_ops ide_cdrom_dops = {
         .get_mcn                = ide_cdrom_get_mcn,
         .reset                  = ide_cdrom_reset,
         .audio_ioctl            = ide_cdrom_audio_ioctl,
-        .dev_ioctl              = ide_cdrom_dev_ioctl,
         .capability             = CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK |
                                 CDC_SELECT_SPEED | CDC_SELECT_DISC |
                                 CDC_MULTI_SESSION | CDC_MCN |
                                 CDC_MEDIA_CHANGED | CDC_PLAY_AUDIO | CDC_RESET |
-                                CDC_IOCTLS | CDC_DRIVE_STATUS | CDC_CD_R |
+                                CDC_DRIVE_STATUS | CDC_CD_R |
                                 CDC_CD_RW | CDC_DVD | CDC_DVD_R| CDC_DVD_RAM |
                                 CDC_GENERIC_PACKET | CDC_MO_DRIVE | CDC_MRW |
                                 CDC_MRW_W | CDC_RAM,
@@ -3367,6 +3321,45 @@ static int idecd_release(struct inode * inode, struct file * file)
         return 0;
 }
 
+static int idecd_set_spindown(struct cdrom_device_info *cdi, unsigned long arg)
+{
+        struct packet_command cgc;
+        char buffer[16];
+        int stat;
+        char spindown;
+
+        if (copy_from_user(&spindown, (void __user *)arg, sizeof(char)))
+                return -EFAULT;
+
+        init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
+
+        stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
+        if (stat)
+                return stat;
+
+        buffer[11] = (buffer[11] & 0xf0) | (spindown & 0x0f);
+        return cdrom_mode_select(cdi, &cgc);
+}
+
+static int idecd_get_spindown(struct cdrom_device_info *cdi, unsigned long arg)
+{
+        struct packet_command cgc;
+        char buffer[16];
+        int stat;
+        char spindown;
+
+        init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
+
+        stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
+        if (stat)
+                return stat;
+
+        spindown = buffer[11] & 0x0f;
+        if (copy_to_user((void __user *)arg, &spindown, sizeof (char)))
+                return -EFAULT;
+        return 0;
+}
+
 static int idecd_ioctl (struct inode *inode, struct file *file,
                         unsigned int cmd, unsigned long arg)
 {
@@ -3374,7 +3367,16 @@ static int idecd_ioctl (struct inode *inode, struct file *file,
         struct cdrom_info *info = ide_cd_g(bdev->bd_disk);
         int err;
 
-        err  = generic_ide_ioctl(info->drive, file, bdev, cmd, arg);
+        switch (cmd) {
+        case CDROMSETSPINDOWN:
+                return idecd_set_spindown(&info->devinfo, arg);
+        case CDROMGETSPINDOWN:
+                return idecd_get_spindown(&info->devinfo, arg);
+        default:
+                break;
+        }
+
+        err = generic_ide_ioctl(info->drive, file, bdev, cmd, arg);
         if (err == -EINVAL)
                 err = cdrom_ioctl(file, &info->devinfo, inode, cmd, arg);
 
diff --git a/drivers/ide/ide-disk.c b/drivers/ide/ide-disk.c
index 09086b8b64..ccf528d733 100644
--- a/drivers/ide/ide-disk.c
+++ b/drivers/ide/ide-disk.c
@@ -60,6 +60,7 @@
 #include <linux/genhd.h>
 #include <linux/slab.h>
 #include <linux/delay.h>
+#include <linux/mutex.h>
 
 #define _IDE_DISK
 
@@ -78,7 +79,7 @@ struct ide_disk_obj {
         struct kref     kref;
 };
 
-static DECLARE_MUTEX(idedisk_ref_sem);
+static DEFINE_MUTEX(idedisk_ref_mutex);
 
 #define to_ide_disk(obj) container_of(obj, struct ide_disk_obj, kref)
 
@@ -89,11 +90,11 @@ static struct ide_disk_obj *ide_disk_get(struct gendisk *disk)
 {
         struct ide_disk_obj *idkp = NULL;
 
-        down(&idedisk_ref_sem);
+        mutex_lock(&idedisk_ref_mutex);
         idkp = ide_disk_g(disk);
         if (idkp)
                 kref_get(&idkp->kref);
-        up(&idedisk_ref_sem);
+        mutex_unlock(&idedisk_ref_mutex);
         return idkp;
 }
 
@@ -101,9 +102,9 @@ static void ide_disk_release(struct kref *);
 
 static void ide_disk_put(struct ide_disk_obj *idkp)
 {
-        down(&idedisk_ref_sem);
+        mutex_lock(&idedisk_ref_mutex);
         kref_put(&idkp->kref, ide_disk_release);
-        up(&idedisk_ref_sem);
+        mutex_unlock(&idedisk_ref_mutex);
 }
 
 /*
@@ -977,8 +978,6 @@ static void idedisk_setup (ide_drive_t *drive)
                 ide_dma_verbose(drive);
         printk("\n");
 
-        drive->no_io_32bit = id->dword_io ? 1 : 0;
-
         /* write cache enabled? */
         if ((id->csfo & 1) || (id->cfs_enable_1 & (1 << 5)))
                 drive->wcache = 1;
diff --git a/drivers/ide/ide-dma.c b/drivers/ide/ide-dma.c
index 0523da7742..c481be8b80 100644
--- a/drivers/ide/ide-dma.c
+++ b/drivers/ide/ide-dma.c
@@ -175,7 +175,7 @@ ide_startstop_t ide_dma_intr (ide_drive_t *drive)
                         if (rq->rq_disk) {
                                 ide_driver_t *drv;
 
-                                drv = *(ide_driver_t **)rq->rq_disk->private_data;;
+                                drv = *(ide_driver_t **)rq->rq_disk->private_data;
                                 drv->end_request(drive, 1, rq->nr_sectors);
                         } else
                                 ide_end_request(drive, 1, rq->nr_sectors);
diff --git a/drivers/ide/ide-floppy.c b/drivers/ide/ide-floppy.c
index 1f8db9ac05..a53e3ce4a1 100644
--- a/drivers/ide/ide-floppy.c
+++ b/drivers/ide/ide-floppy.c
@@ -98,6 +98,7 @@
 #include <linux/cdrom.h>
 #include <linux/ide.h>
 #include <linux/bitops.h>
+#include <linux/mutex.h>
 
 #include <asm/byteorder.h>
 #include <asm/irq.h>
@@ -517,7 +518,7 @@ typedef struct {
         u8              reserved[4];
 } idefloppy_mode_parameter_header_t;
 
-static DECLARE_MUTEX(idefloppy_ref_sem);
+static DEFINE_MUTEX(idefloppy_ref_mutex);
 
 #define to_ide_floppy(obj) container_of(obj, struct ide_floppy_obj, kref)
 
@@ -528,11 +529,11 @@ static struct ide_floppy_obj *ide_floppy_get(struct gendisk *disk)
 {
         struct ide_floppy_obj *floppy = NULL;
 
-        down(&idefloppy_ref_sem);
+        mutex_lock(&idefloppy_ref_mutex);
         floppy = ide_floppy_g(disk);
         if (floppy)
                 kref_get(&floppy->kref);
-        up(&idefloppy_ref_sem);
+        mutex_unlock(&idefloppy_ref_mutex);
         return floppy;
 }
 
@@ -540,9 +541,9 @@ static void ide_floppy_release(struct kref *);
 
 static void ide_floppy_put(struct ide_floppy_obj *floppy)
 {
-        down(&idefloppy_ref_sem);
+        mutex_lock(&idefloppy_ref_mutex);
         kref_put(&floppy->kref, ide_floppy_release);
-        up(&idefloppy_ref_sem);
+        mutex_unlock(&idefloppy_ref_mutex);
 }
 
 /*
diff --git a/drivers/ide/ide-probe.c b/drivers/ide/ide-probe.c
index 427d1c2041..1b7b4c531b 100644
--- a/drivers/ide/ide-probe.c
+++ b/drivers/ide/ide-probe.c
@@ -858,6 +858,15 @@ static void probe_hwif(ide_hwif_t *hwif)
                         }
                 }
         }
+
+        for (unit = 0; unit < MAX_DRIVES; ++unit) {
+                ide_drive_t *drive = &hwif->drives[unit];
+
+                if (hwif->no_io_32bit)
+                        drive->no_io_32bit = 1;
+                else
+                        drive->no_io_32bit = drive->id->dword_io ? 1 : 0;
+        }
 }
 
 static int hwif_init(ide_hwif_t *hwif);
diff --git a/drivers/ide/ide-tape.c b/drivers/ide/ide-tape.c
index 0101d0def7..ebc59064b4 100644
--- a/drivers/ide/ide-tape.c
+++ b/drivers/ide/ide-tape.c
@@ -443,6 +443,7 @@
 #include <linux/smp_lock.h>
 #include <linux/completion.h>
 #include <linux/bitops.h>
+#include <linux/mutex.h>
 
 #include <asm/byteorder.h>
 #include <asm/irq.h>
@@ -1011,7 +1012,7 @@ typedef struct ide_tape_obj {
          int debug_level; 
 } idetape_tape_t;
 
-static DECLARE_MUTEX(idetape_ref_sem);
+static DEFINE_MUTEX(idetape_ref_mutex);
 
 static struct class *idetape_sysfs_class;
 
@@ -1024,11 +1025,11 @@ static struct ide_tape_obj *ide_tape_get(struct gendisk *disk)
 {
         struct ide_tape_obj *tape = NULL;
 
-        down(&idetape_ref_sem);
+        mutex_lock(&idetape_ref_mutex);
         tape = ide_tape_g(disk);
         if (tape)
                 kref_get(&tape->kref);
-        up(&idetape_ref_sem);
+        mutex_unlock(&idetape_ref_mutex);
         return tape;
 }
 
@@ -1036,9 +1037,9 @@ static void ide_tape_release(struct kref *);
 
 static void ide_tape_put(struct ide_tape_obj *tape)
 {
-        down(&idetape_ref_sem);
+        mutex_lock(&idetape_ref_mutex);
         kref_put(&tape->kref, ide_tape_release);
-        up(&idetape_ref_sem);
+        mutex_unlock(&idetape_ref_mutex);
 }
 
 /*
@@ -1290,11 +1291,11 @@ static struct ide_tape_obj *ide_tape_chrdev_get(unsigned int i)
 {
         struct ide_tape_obj *tape = NULL;
 
-        down(&idetape_ref_sem);
+        mutex_lock(&idetape_ref_mutex);
         tape = idetape_devs[i];
         if (tape)
                 kref_get(&tape->kref);
-        up(&idetape_ref_sem);
+        mutex_unlock(&idetape_ref_mutex);
         return tape;
 }
 
@@ -4870,11 +4871,11 @@ static int ide_tape_probe(ide_drive_t *drive)
 
         drive->driver_data = tape;
 
-        down(&idetape_ref_sem);
+        mutex_lock(&idetape_ref_mutex);
         for (minor = 0; idetape_devs[minor]; minor++)
                 ;
         idetape_devs[minor] = tape;
-        up(&idetape_ref_sem);
+        mutex_unlock(&idetape_ref_mutex);
 
         idetape_setup(drive, tape, minor);
 
diff --git a/drivers/isdn/capi/kcapi.c b/drivers/isdn/capi/kcapi.c
index feec40cf59..8c4fcb9027 100644
--- a/drivers/isdn/capi/kcapi.c
+++ b/drivers/isdn/capi/kcapi.c
@@ -32,6 +32,7 @@
 #ifdef CONFIG_AVMB1_COMPAT
 #include <linux/b1lli.h>
 #endif
+#include <linux/mutex.h>
 
 static char *revision = "$Revision: 1.1.2.8 $";
 
@@ -66,7 +67,7 @@ LIST_HEAD(capi_drivers);
 DEFINE_RWLOCK(capi_drivers_list_lock);
 
 static DEFINE_RWLOCK(application_lock);
-static DECLARE_MUTEX(controller_sem);
+static DEFINE_MUTEX(controller_mutex);
 
 struct capi20_appl *capi_applications[CAPI_MAXAPPL];
 struct capi_ctr *capi_cards[CAPI_MAXCONTR];
@@ -395,20 +396,20 @@ attach_capi_ctr(struct capi_ctr *card)
 {
         int i;
 
-        down(&controller_sem);
+        mutex_lock(&controller_mutex);
 
         for (i = 0; i < CAPI_MAXCONTR; i++) {
                 if (capi_cards[i] == NULL)
                         break;
         }
         if (i == CAPI_MAXCONTR) {
-                up(&controller_sem);
+                mutex_unlock(&controller_mutex);
                 printk(KERN_ERR "kcapi: out of controller slots\n");
                 return -EBUSY;
         }
         capi_cards[i] = card;
 
-        up(&controller_sem);
+        mutex_unlock(&controller_mutex);
 
         card->nrecvctlpkt = 0;
         card->nrecvdatapkt = 0;
@@ -531,13 +532,13 @@ u16 capi20_register(struct capi20_appl *ap)
 
         write_unlock_irqrestore(&application_lock, flags);
         
-        down(&controller_sem);
+        mutex_lock(&controller_mutex);
         for (i = 0; i < CAPI_MAXCONTR; i++) {
                 if (!capi_cards[i] || capi_cards[i]->cardstate != CARD_RUNNING)
                         continue;
                 register_appl(capi_cards[i], applid, &ap->rparam);
         }
-        up(&controller_sem);
+        mutex_unlock(&controller_mutex);
 
         if (showcapimsgs & 1) {
                 printk(KERN_DEBUG "kcapi: appl %d up\n", applid);
@@ -560,13 +561,13 @@ u16 capi20_release(struct capi20_appl *ap)
         capi_applications[ap->applid - 1] = NULL;
         write_unlock_irqrestore(&application_lock, flags);
 
-        down(&controller_sem);
+        mutex_lock(&controller_mutex);
         for (i = 0; i < CAPI_MAXCONTR; i++) {
                 if (!capi_cards[i] || capi_cards[i]->cardstate != CARD_RUNNING)
                         continue;
                 release_appl(capi_cards[i], ap->applid);
         }
-        up(&controller_sem);
+        mutex_unlock(&controller_mutex);
 
         flush_scheduled_work();
         skb_queue_purge(&ap->recv_queue);
diff --git a/drivers/isdn/hisax/config.c b/drivers/isdn/hisax/config.c
index df9d652018..27332506f9 100644
--- a/drivers/isdn/hisax/config.c
+++ b/drivers/isdn/hisax/config.c
@@ -25,7 +25,6 @@
 #include <linux/workqueue.h>
 #include <linux/interrupt.h>
 #define HISAX_STATUS_BUFSIZE 4096
-#define INCLUDE_INLINE_FUNCS
 
 /*
  * This structure array contains one entry per card. An entry looks
diff --git a/drivers/isdn/hisax/elsa.c b/drivers/isdn/hisax/elsa.c
index 110e9fd669..f8ca4b3233 100644
--- a/drivers/isdn/hisax/elsa.c
+++ b/drivers/isdn/hisax/elsa.c
@@ -108,7 +108,6 @@ static const char *ITACVer[] =
 #define ELSA_ASSIGN      4
 
 #define RS_ISR_PASS_LIMIT 256
-#define _INLINE_ inline
 #define FLG_MODEM_ACTIVE 1
 /* IPAC AUX */
 #define ELSA_IPAC_LINE_LED      0x40    /* Bit 6 Gelbe LED */
diff --git a/drivers/macintosh/macio_asic.c b/drivers/macintosh/macio_asic.c
index 69596f6438..431bd37225 100644
--- a/drivers/macintosh/macio_asic.c
+++ b/drivers/macintosh/macio_asic.c
@@ -550,15 +550,12 @@ static void macio_pci_add_devices(struct macio_chip *chip)
  */
 int macio_register_driver(struct macio_driver *drv)
 {
-        int count = 0;
-
         /* initialize common driver fields */
         drv->driver.name = drv->name;
         drv->driver.bus = &macio_bus_type;
 
         /* register with core */
-        count = driver_register(&drv->driver);
-        return count ? count : 1;
+        return driver_register(&drv->driver);
 }
 
 /**
diff --git a/drivers/macintosh/smu.c b/drivers/macintosh/smu.c
index db2ae71d07..4eb05d7143 100644
--- a/drivers/macintosh/smu.c
+++ b/drivers/macintosh/smu.c
@@ -629,8 +629,6 @@ static struct of_platform_driver smu_of_platform_driver =
 
 static int __init smu_init_sysfs(void)
 {
-        int rc;
-
         /*
          * Due to sysfs bogosity, a sysdev is not a real device, so
          * we should in fact create both if we want sysdev semantics
@@ -639,7 +637,7 @@ static int __init smu_init_sysfs(void)
          * I'm a bit too far from figuring out how that works with those
          * new chipsets, but that will come back and bite us
          */
-        rc = of_register_driver(&smu_of_platform_driver);
+        of_register_driver(&smu_of_platform_driver);
         return 0;
 }
 
diff --git a/drivers/macintosh/therm_pm72.c b/drivers/macintosh/therm_pm72.c
index 4f50ee5767..231146f439 100644
--- a/drivers/macintosh/therm_pm72.c
+++ b/drivers/macintosh/therm_pm72.c
@@ -104,7 +104,6 @@
 #include <linux/kernel.h>
 #include <linux/delay.h>
 #include <linux/sched.h>
-#include <linux/i2c.h>
 #include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/spinlock.h>
@@ -113,7 +112,6 @@
 #include <linux/reboot.h>
 #include <linux/kmod.h>
 #include <linux/i2c.h>
-#include <linux/i2c-dev.h>
 #include <asm/prom.h>
 #include <asm/machdep.h>
 #include <asm/io.h>
diff --git a/drivers/macintosh/via-pmu.c b/drivers/macintosh/via-pmu.c
index 4a478eb0e2..4f5f3abc9c 100644
--- a/drivers/macintosh/via-pmu.c
+++ b/drivers/macintosh/via-pmu.c
@@ -161,7 +161,9 @@ static int drop_interrupts;
 #if defined(CONFIG_PM) && defined(CONFIG_PPC32)
 static int option_lid_wakeup = 1;
 #endif /* CONFIG_PM && CONFIG_PPC32 */
+#if (defined(CONFIG_PM)&&defined(CONFIG_PPC32))||defined(CONFIG_PMAC_BACKLIGHT)
 static int sleep_in_progress;
+#endif
 static unsigned long async_req_locks;
 static unsigned int pmu_irq_stats[11];
 
@@ -2201,8 +2203,7 @@ pmac_wakeup_devices(void)
 #define GRACKLE_NAP     (1<<4)
 #define GRACKLE_SLEEP   (1<<3)
 
-int
-powerbook_sleep_grackle(void)
+static int powerbook_sleep_grackle(void)
 {
         unsigned long save_l2cr;
         unsigned short pmcr1;
diff --git a/drivers/macintosh/windfarm_lm75_sensor.c b/drivers/macintosh/windfarm_lm75_sensor.c
index 423bfa2432..3f7967feaf 100644
--- a/drivers/macintosh/windfarm_lm75_sensor.c
+++ b/drivers/macintosh/windfarm_lm75_sensor.c
@@ -15,7 +15,6 @@
 #include <linux/init.h>
 #include <linux/wait.h>
 #include <linux/i2c.h>
-#include <linux/i2c-dev.h>
 #include <asm/prom.h>
 #include <asm/machdep.h>
 #include <asm/io.h>
diff --git a/drivers/macintosh/windfarm_max6690_sensor.c b/drivers/macintosh/windfarm_max6690_sensor.c
index 8e99d408fd..eae1189d6c 100644
--- a/drivers/macintosh/windfarm_max6690_sensor.c
+++ b/drivers/macintosh/windfarm_max6690_sensor.c
@@ -11,7 +11,6 @@
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/i2c.h>
-#include <linux/i2c-dev.h>
 #include <asm/prom.h>
 #include <asm/pmac_low_i2c.h>
 
diff --git a/drivers/macintosh/windfarm_smu_sat.c b/drivers/macintosh/windfarm_smu_sat.c
index 24e51d5e97..e295a07a1e 100644
--- a/drivers/macintosh/windfarm_smu_sat.c
+++ b/drivers/macintosh/windfarm_smu_sat.c
@@ -13,7 +13,6 @@
 #include <linux/init.h>
 #include <linux/wait.h>
 #include <linux/i2c.h>
-#include <linux/i2c-dev.h>
 #include <asm/semaphore.h>
 #include <asm/prom.h>
 #include <asm/smu.h>
diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index 26b08ee425..8c82373f7f 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -17,6 +17,7 @@
 #include <linux/mempool.h>
 #include <linux/slab.h>
 #include <linux/idr.h>
+#include <linux/blktrace_api.h>
 
 static const char *_name = DM_NAME;
 
@@ -334,6 +335,8 @@ static void dec_pending(struct dm_io *io, int error)
                         /* nudge anyone waiting on suspend queue */
                         wake_up(&io->md->wait);
 
+                blk_add_trace_bio(io->md->queue, io->bio, BLK_TA_COMPLETE);
+
                 bio_endio(io->bio, io->bio->bi_size, io->error);
                 free_io(io->md, io);
         }
@@ -392,6 +395,7 @@ static void __map_bio(struct dm_target *ti, struct bio *clone,
                       struct target_io *tio)
 {
         int r;
+        sector_t sector;
 
         /*
          * Sanity checks.
@@ -407,10 +411,17 @@ static void __map_bio(struct dm_target *ti, struct bio *clone,
          * this io.
          */
         atomic_inc(&tio->io->io_count);
+        sector = clone->bi_sector;
         r = ti->type->map(ti, clone, &tio->info);
-        if (r > 0)
+        if (r > 0) {
                 /* the bio has been remapped so dispatch it */
+
+                blk_add_trace_remap(bdev_get_queue(clone->bi_bdev), clone, 
+                                    tio->io->bio->bi_bdev->bd_dev, sector, 
+                                    clone->bi_sector);
+
                 generic_make_request(clone);
+        }
 
         else if (r < 0) {
                 /* error the io and bail out */
diff --git a/drivers/media/video/adv7170.c b/drivers/media/video/adv7170.c
index 4ce07ae62d..671e36db22 100644
--- a/drivers/media/video/adv7170.c
+++ b/drivers/media/video/adv7170.c
@@ -53,7 +53,6 @@ MODULE_AUTHOR("Maxim Yevtyushkin");
 MODULE_LICENSE("GPL");
 
 #include <linux/i2c.h>
-#include <linux/i2c-dev.h>
 
 #define I2C_NAME(x) (x)->name
 
@@ -125,24 +124,21 @@ adv7170_write_block (struct i2c_client *client,
         if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
                 /* do raw I2C, not smbus compatible */
                 struct adv7170 *encoder = i2c_get_clientdata(client);
-                struct i2c_msg msg;
                 u8 block_data[32];
+                int block_len;
 
-                msg.addr = client->addr;
-                msg.flags = 0;
                 while (len >= 2) {
-                        msg.buf = (char *) block_data;
-                        msg.len = 0;
-                        block_data[msg.len++] = reg = data[0];
+                        block_len = 0;
+                        block_data[block_len++] = reg = data[0];
                         do {
-                                block_data[msg.len++] =
+                                block_data[block_len++] =
                                     encoder->reg[reg++] = data[1];
                                 len -= 2;
                                 data += 2;
                         } while (len >= 2 && data[0] == reg &&
-                                 msg.len < 32);
-                        if ((ret = i2c_transfer(client->adapter,
-                                                &msg, 1)) < 0)
+                                 block_len < 32);
+                        if ((ret = i2c_master_send(client, block_data,
+                                                   block_len)) < 0)
                                 break;
                 }
         } else {
diff --git a/drivers/media/video/adv7175.c b/drivers/media/video/adv7175.c
index 4e218f22b2..085e8863ca 100644
--- a/drivers/media/video/adv7175.c
+++ b/drivers/media/video/adv7175.c
@@ -49,7 +49,6 @@ MODULE_AUTHOR("Dave Perks");
 MODULE_LICENSE("GPL");
 
 #include <linux/i2c.h>
-#include <linux/i2c-dev.h>
 
 #define I2C_NAME(s) (s)->name
 
@@ -68,8 +67,6 @@ MODULE_PARM_DESC(debug, "Debug level (0-1)");
 /* ----------------------------------------------------------------------- */
 
 struct adv7175 {
-        unsigned char reg[128];
-
         int norm;
         int input;
         int enable;
@@ -95,9 +92,6 @@ adv7175_write (struct i2c_client *client,
                u8                 reg,
                u8                 value)
 {
-        struct adv7175 *encoder = i2c_get_clientdata(client);
-
-        encoder->reg[reg] = value;
         return i2c_smbus_write_byte_data(client, reg, value);
 }
 
@@ -120,25 +114,21 @@ adv7175_write_block (struct i2c_client *client,
          * the adapter understands raw I2C */
         if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
                 /* do raw I2C, not smbus compatible */
-                struct adv7175 *encoder = i2c_get_clientdata(client);
-                struct i2c_msg msg;
                 u8 block_data[32];
+                int block_len;
 
-                msg.addr = client->addr;
-                msg.flags = 0;
                 while (len >= 2) {
-                        msg.buf = (char *) block_data;
-                        msg.len = 0;
-                        block_data[msg.len++] = reg = data[0];
+                        block_len = 0;
+                        block_data[block_len++] = reg = data[0];
                         do {
-                                block_data[msg.len++] =
-                                    encoder->reg[reg++] = data[1];
+                                block_data[block_len++] = data[1];
+                                reg++;
                                 len -= 2;
                                 data += 2;
                         } while (len >= 2 && data[0] == reg &&
-                                 msg.len < 32);
-                        if ((ret = i2c_transfer(client->adapter,
-                                                &msg, 1)) < 0)
+                                 block_len < 32);
+                        if ((ret = i2c_master_send(client, block_data,
+                                                   block_len)) < 0)
                                 break;
                 }
         } else {
@@ -171,24 +161,6 @@ set_subcarrier_freq (struct i2c_client *client,
         adv7175_write(client, 0x05, 0x25);
 }
 
-#ifdef ENCODER_DUMP
-static void
-dump (struct i2c_client *client)
-{
-        struct adv7175 *encoder = i2c_get_clientdata(client);
-        int i, j;
-
-        printk(KERN_INFO "%s: registry dump\n", I2C_NAME(client));
-        for (i = 0; i < 182 / 8; i++) {
-                printk("%s: 0x%02x -", I2C_NAME(client), i * 8);
-                for (j = 0; j < 8; j++) {
-                        printk(" 0x%02x", encoder->reg[i * 8 + j]);
-                }
-                printk("\n");
-        }
-}
-#endif
-
 /* ----------------------------------------------------------------------- */
 // Output filter:  S-Video  Composite
 
@@ -407,14 +379,6 @@ adv7175_command (struct i2c_client *client,
         }
                 break;
 
-#ifdef ENCODER_DUMP
-        case ENCODER_DUMP:
-        {
-                dump(client);
-        }
-                break;
-#endif
-
         default:
                 return -EINVAL;
         }
diff --git a/drivers/media/video/bt819.c b/drivers/media/video/bt819.c
index d6447791d0..d8a18a6a5b 100644
--- a/drivers/media/video/bt819.c
+++ b/drivers/media/video/bt819.c
@@ -53,7 +53,6 @@ MODULE_AUTHOR("Mike Bernson & Dave Perks");
 MODULE_LICENSE("GPL");
 
 #include <linux/i2c.h>
-#include <linux/i2c-dev.h>
 
 #define I2C_NAME(s) (s)->name
 
@@ -141,24 +140,21 @@ bt819_write_block (struct i2c_client *client,
         if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
                 /* do raw I2C, not smbus compatible */
                 struct bt819 *decoder = i2c_get_clientdata(client);
-                struct i2c_msg msg;
                 u8 block_data[32];
+                int block_len;
 
-                msg.addr = client->addr;
-                msg.flags = 0;
                 while (len >= 2) {
-                        msg.buf = (char *) block_data;
-                        msg.len = 0;
-                        block_data[msg.len++] = reg = data[0];
+                        block_len = 0;
+                        block_data[block_len++] = reg = data[0];
                         do {
-                                block_data[msg.len++] =
+                                block_data[block_len++] =
                                     decoder->reg[reg++] = data[1];
                                 len -= 2;
                                 data += 2;
                         } while (len >= 2 && data[0] == reg &&
-                                 msg.len < 32);
-                        if ((ret = i2c_transfer(client->adapter,
-                                                &msg, 1)) < 0)
+                                 block_len < 32);
+                        if ((ret = i2c_master_send(client, block_data,
+                                                   block_len)) < 0)
                                 break;
                 }
         } else {
diff --git a/drivers/media/video/bt856.c b/drivers/media/video/bt856.c
index 909b593530..4d47a0a0e9 100644
--- a/drivers/media/video/bt856.c
+++ b/drivers/media/video/bt856.c
@@ -53,7 +53,6 @@ MODULE_AUTHOR("Mike Bernson & Dave Perks");
 MODULE_LICENSE("GPL");
 
 #include <linux/i2c.h>
-#include <linux/i2c-dev.h>
 
 #define I2C_NAME(s) (s)->name
 
@@ -71,17 +70,14 @@ MODULE_PARM_DESC(debug, "Debug level (0-1)");
 
 /* ----------------------------------------------------------------------- */
 
-#define REG_OFFSET  0xCE
+#define REG_OFFSET      0xDA
+#define BT856_NR_REG    6
 
 struct bt856 {
-        unsigned char reg[32];
+        unsigned char reg[BT856_NR_REG];
 
         int norm;
         int enable;
-        int bright;
-        int contrast;
-        int hue;
-        int sat;
 };
 
 #define   I2C_BT856        0x88
@@ -120,8 +116,8 @@ bt856_dump (struct i2c_client *client)
         struct bt856 *encoder = i2c_get_clientdata(client);
 
         printk(KERN_INFO "%s: register dump:", I2C_NAME(client));
-        for (i = 0xd6; i <= 0xde; i += 2)
-                printk(" %02x", encoder->reg[i - REG_OFFSET]);
+        for (i = 0; i < BT856_NR_REG; i += 2)
+                printk(" %02x", encoder->reg[i]);
         printk("\n");
 }
 
diff --git a/drivers/media/video/cpia.c b/drivers/media/video/cpia.c
index d93a561e6b..3cebfa91ca 100644
--- a/drivers/media/video/cpia.c
+++ b/drivers/media/video/cpia.c
@@ -58,7 +58,7 @@ static int video_nr = -1;
 
 #ifdef MODULE
 module_param(video_nr, int, 0);
-MODULE_AUTHOR("Scott J. Bertin <sbertin@securenym.net> & Peter Pregler <Peter_Pregler@email.com> & Johannes Erdfelt <johannes@erdfeld.com>");
+MODULE_AUTHOR("Scott J. Bertin <sbertin@securenym.net> & Peter Pregler <Peter_Pregler@email.com> & Johannes Erdfelt <johannes@erdfelt.com>");
 MODULE_DESCRIPTION("V4L-driver for Vision CPiA based cameras");
 MODULE_LICENSE("GPL");
 MODULE_SUPPORTED_DEVICE("video");
diff --git a/drivers/media/video/saa7110.c b/drivers/media/video/saa7110.c
index 7bb85a7b32..e18ea26838 100644
--- a/drivers/media/video/saa7110.c
+++ b/drivers/media/video/saa7110.c
@@ -39,7 +39,6 @@ MODULE_AUTHOR("Pauline Middelink");
 MODULE_LICENSE("GPL");
 
 #include <linux/i2c.h>
-#include <linux/i2c-dev.h>
 
 #define I2C_NAME(s) (s)->name
 
@@ -108,13 +107,8 @@ saa7110_write_block (struct i2c_client *client,
          * the adapter understands raw I2C */
         if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
                 struct saa7110 *decoder = i2c_get_clientdata(client);
-                struct i2c_msg msg;
 
-                msg.len = len;
-                msg.buf = (char *) data;
-                msg.addr = client->addr;
-                msg.flags = 0;
-                ret = i2c_transfer(client->adapter, &msg, 1);
+                ret = i2c_master_send(client, data, len);
 
                 /* Cache the written data */
                 memcpy(decoder->reg + reg, data + 1, len - 1);
@@ -432,15 +426,13 @@ saa7110_command (struct i2c_client *client,
                 break;
 
         case DECODER_DUMP:
-                for (v = 0; v < 0x34; v += 16) {
+                for (v = 0; v < SAA7110_NR_REG; v += 16) {
                         int j;
-                        dprintk(1, KERN_INFO "%s: %03x\n", I2C_NAME(client),
+                        dprintk(1, KERN_DEBUG "%s: %02x:", I2C_NAME(client),
                                 v);
-                        for (j = 0; j < 16; j++) {
-                                dprintk(1, KERN_INFO " %02x",
-                                        decoder->reg[v + j]);
-                        }
-                        dprintk(1, KERN_INFO "\n");
+                        for (j = 0; j < 16 && v + j < SAA7110_NR_REG; j++)
+                                dprintk(1, " %02x", decoder->reg[v + j]);
+                        dprintk(1, "\n");
                 }
                 break;
 
diff --git a/drivers/media/video/saa7111.c b/drivers/media/video/saa7111.c
index 8c06592b37..f9ba0c943a 100644
--- a/drivers/media/video/saa7111.c
+++ b/drivers/media/video/saa7111.c
@@ -52,7 +52,6 @@ MODULE_AUTHOR("Dave Perks");
 MODULE_LICENSE("GPL");
 
 #include <linux/i2c.h>
-#include <linux/i2c-dev.h>
 
 #define I2C_NAME(s) (s)->name
 
@@ -70,8 +69,10 @@ MODULE_PARM_DESC(debug, "Debug level (0-1)");
 
 /* ----------------------------------------------------------------------- */
 
+#define SAA7111_NR_REG          0x18
+
 struct saa7111 {
-        unsigned char reg[32];
+        unsigned char reg[SAA7111_NR_REG];
 
         int norm;
         int input;
@@ -110,24 +111,21 @@ saa7111_write_block (struct i2c_client *client,
         if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
                 /* do raw I2C, not smbus compatible */
                 struct saa7111 *decoder = i2c_get_clientdata(client);
-                struct i2c_msg msg;
                 u8 block_data[32];
+                int block_len;
 
-                msg.addr = client->addr;
-                msg.flags = 0;
                 while (len >= 2) {
-                        msg.buf = (char *) block_data;
-                        msg.len = 0;
-                        block_data[msg.len++] = reg = data[0];
+                        block_len = 0;
+                        block_data[block_len++] = reg = data[0];
                         do {
-                                block_data[msg.len++] =
+                                block_data[block_len++] =
                                     decoder->reg[reg++] = data[1];
                                 len -= 2;
                                 data += 2;
                         } while (len >= 2 && data[0] == reg &&
-                                 msg.len < 32);
-                        if ((ret = i2c_transfer(client->adapter,
-                                                &msg, 1)) < 0)
+                                 block_len < 32);
+                        if ((ret = i2c_master_send(client, block_data,
+                                                   block_len)) < 0)
                                 break;
                 }
         } else {
@@ -210,6 +208,7 @@ saa7111_command (struct i2c_client *client,
         switch (cmd) {
 
         case 0:
+                break;
         case DECODER_INIT:
         {
                 struct video_decoder_init *init = arg;
@@ -227,11 +226,11 @@ saa7111_command (struct i2c_client *client,
         {
                 int i;
 
-                for (i = 0; i < 32; i += 16) {
+                for (i = 0; i < SAA7111_NR_REG; i += 16) {
                         int j;
 
                         printk(KERN_DEBUG "%s: %03x", I2C_NAME(client), i);
-                        for (j = 0; j < 16; ++j) {
+                        for (j = 0; j < 16 && i + j < SAA7111_NR_REG; ++j) {
                                 printk(" %02x",
                                        saa7111_read(client, i + j));
                         }
diff --git a/drivers/media/video/saa7114.c b/drivers/media/video/saa7114.c
index fd0a4b4ef0..4a1f841d0c 100644
--- a/drivers/media/video/saa7114.c
+++ b/drivers/media/video/saa7114.c
@@ -55,7 +55,6 @@ MODULE_AUTHOR("Maxim Yevtyushkin");
 MODULE_LICENSE("GPL");
 
 #include <linux/i2c.h>
-#include <linux/i2c-dev.h>
 
 #define I2C_NAME(x) (x)->name
 
@@ -139,9 +138,6 @@ saa7114_write (struct i2c_client *client,
                u8                 reg,
                u8                 value)
 {
-        /*struct saa7114 *decoder = i2c_get_clientdata(client);*/
-
-        /*decoder->reg[reg] = value;*/
         return i2c_smbus_write_byte_data(client, reg, value);
 }
 
@@ -157,25 +153,21 @@ saa7114_write_block (struct i2c_client *client,
          * the adapter understands raw I2C */
         if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
                 /* do raw I2C, not smbus compatible */
-                /*struct saa7114 *decoder = i2c_get_clientdata(client);*/
-                struct i2c_msg msg;
                 u8 block_data[32];
+                int block_len;
 
-                msg.addr = client->addr;
-                msg.flags = 0;
                 while (len >= 2) {
-                        msg.buf = (char *) block_data;
-                        msg.len = 0;
-                        block_data[msg.len++] = reg = data[0];
+                        block_len = 0;
+                        block_data[block_len++] = reg = data[0];
                         do {
-                                block_data[msg.len++] =
-                                    /*decoder->reg[reg++] =*/ data[1];
+                                block_data[block_len++] = data[1];
+                                reg++;
                                 len -= 2;
                                 data += 2;
                         } while (len >= 2 && data[0] == reg &&
-                                 msg.len < 32);
-                        if ((ret = i2c_transfer(client->adapter,
-                                                &msg, 1)) < 0)
+                                 block_len < 32);
+                        if ((ret = i2c_master_send(client, block_data,
+                                                   block_len)) < 0)
                                 break;
                 }
         } else {
diff --git a/drivers/media/video/saa711x.c b/drivers/media/video/saa711x.c
index 6c161f2f5e..708fae51e8 100644
--- a/drivers/media/video/saa711x.c
+++ b/drivers/media/video/saa711x.c
@@ -45,7 +45,6 @@ MODULE_AUTHOR("Dave Perks, Jose Ignacio Gijon, Joerg Heckenbach, Mark McClelland
 MODULE_LICENSE("GPL");
 
 #include <linux/i2c.h>
-#include <linux/i2c-dev.h>
 
 #define I2C_NAME(s) (s)->name
 
diff --git a/drivers/media/video/saa7185.c b/drivers/media/video/saa7185.c
index 3ed0edb870..9f99ee1303 100644
--- a/drivers/media/video/saa7185.c
+++ b/drivers/media/video/saa7185.c
@@ -49,7 +49,6 @@ MODULE_AUTHOR("Dave Perks");
 MODULE_LICENSE("GPL");
 
 #include <linux/i2c.h>
-#include <linux/i2c-dev.h>
 
 #define I2C_NAME(s) (s)->name
 
@@ -113,24 +112,21 @@ saa7185_write_block (struct i2c_client *client,
         if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
                 /* do raw I2C, not smbus compatible */
                 struct saa7185 *encoder = i2c_get_clientdata(client);
-                struct i2c_msg msg;
                 u8 block_data[32];
+                int block_len;
 
-                msg.addr = client->addr;
-                msg.flags = 0;
                 while (len >= 2) {
-                        msg.buf = (char *) block_data;
-                        msg.len = 0;
-                        block_data[msg.len++] = reg = data[0];
+                        block_len = 0;
+                        block_data[block_len++] = reg = data[0];
                         do {
-                                block_data[msg.len++] =
+                                block_data[block_len++] =
                                     encoder->reg[reg++] = data[1];
                                 len -= 2;
                                 data += 2;
                         } while (len >= 2 && data[0] == reg &&
-                                 msg.len < 32);
-                        if ((ret = i2c_transfer(client->adapter,
-                                                &msg, 1)) < 0)
+                                 block_len < 32);
+                        if ((ret = i2c_master_send(client, block_data,
+                                                   block_len)) < 0)
                                 break;
                 }
         } else {
diff --git a/drivers/media/video/vpx3220.c b/drivers/media/video/vpx3220.c
index d0a1e72ea8..4cd5799674 100644
--- a/drivers/media/video/vpx3220.c
+++ b/drivers/media/video/vpx3220.c
@@ -30,7 +30,6 @@
 #include <asm/uaccess.h>
 
 #include <linux/i2c.h>
-#include <linux/i2c-dev.h>
 
 #define I2C_NAME(x) (x)->name
 
diff --git a/drivers/media/video/zoran.h b/drivers/media/video/zoran.h
index 9fe6ad3b63..ad04a12949 100644
--- a/drivers/media/video/zoran.h
+++ b/drivers/media/video/zoran.h
@@ -395,7 +395,7 @@ struct zoran {
         struct videocodec *codec;       /* video codec */
         struct videocodec *vfe; /* video front end */
 
-        struct semaphore resource_lock; /* prevent evil stuff */
+        struct mutex resource_lock;     /* prevent evil stuff */
 
         u8 initialized;         /* flag if zoran has been correctly initalized */
         int user;               /* number of current users */
diff --git a/drivers/media/video/zoran_card.c b/drivers/media/video/zoran_card.c
index 246e67cd8b..b22dbb6d18 100644
--- a/drivers/media/video/zoran_card.c
+++ b/drivers/media/video/zoran_card.c
@@ -47,6 +47,7 @@
 #include <linux/interrupt.h>
 #include <linux/video_decoder.h>
 #include <linux/video_encoder.h>
+#include <linux/mutex.h>
 
 #include <asm/io.h>
 
@@ -673,7 +674,7 @@ zoran_i2c_client_register (struct i2c_client *client)
                 KERN_DEBUG "%s: i2c_client_register() - driver id = %d\n",
                 ZR_DEVNAME(zr), client->driver->id);
 
-        down(&zr->resource_lock);
+        mutex_lock(&zr->resource_lock);
 
         if (zr->user > 0) {
                 /* we're already busy, so we keep a reference to
@@ -694,7 +695,7 @@ zoran_i2c_client_register (struct i2c_client *client)
         }
 
 clientreg_unlock_and_return:
-        up(&zr->resource_lock);
+        mutex_unlock(&zr->resource_lock);
 
         return res;
 }
@@ -707,7 +708,7 @@ zoran_i2c_client_unregister (struct i2c_client *client)
 
         dprintk(2, KERN_DEBUG "%s: i2c_client_unregister()\n", ZR_DEVNAME(zr));
 
-        down(&zr->resource_lock);
+        mutex_lock(&zr->resource_lock);
 
         if (zr->user > 0) {
                 res = -EBUSY;
@@ -722,7 +723,7 @@ zoran_i2c_client_unregister (struct i2c_client *client)
                 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)), "MJPEG[%d]", zr->id);
         }
 clientunreg_unlock_and_return:
-        up(&zr->resource_lock);
+        mutex_unlock(&zr->resource_lock);
         return res;
 }
 
@@ -995,10 +996,7 @@ test_interrupts (struct zoran *zr)
 static int __devinit
 zr36057_init (struct zoran *zr)
 {
-        u32 *mem;
-        void *vdev;
-        unsigned mem_needed;
-        int j;
+        int j, err;
         int two = 2;
         int zero = 0;
 
@@ -1049,19 +1047,16 @@ zr36057_init (struct zoran *zr)
 
         /* allocate memory *before* doing anything to the hardware
          * in case allocation fails */
-        mem_needed = BUZ_NUM_STAT_COM * 4;
-        mem = kzalloc(mem_needed, GFP_KERNEL);
-        vdev = (void *) kmalloc(sizeof(struct video_device), GFP_KERNEL);
-        if (!mem || !vdev) {
+        zr->stat_com = kzalloc(BUZ_NUM_STAT_COM * 4, GFP_KERNEL);
+        zr->video_dev = kmalloc(sizeof(struct video_device), GFP_KERNEL);
+        if (!zr->stat_com || !zr->video_dev) {
                 dprintk(1,
                         KERN_ERR
                         "%s: zr36057_init() - kmalloc (STAT_COM) failed\n",
                         ZR_DEVNAME(zr));
-                kfree(vdev);
-                kfree(mem);
-                return -ENOMEM;
+                err = -ENOMEM;
+                goto exit_free;
         }
-        zr->stat_com = mem;
         for (j = 0; j < BUZ_NUM_STAT_COM; j++) {
                 zr->stat_com[j] = 1;    /* mark as unavailable to zr36057 */
         }
@@ -1069,16 +1064,11 @@ zr36057_init (struct zoran *zr)
         /*
          *   Now add the template and register the device unit.
          */
-        zr->video_dev = vdev;
         memcpy(zr->video_dev, &zoran_template, sizeof(zoran_template));
         strcpy(zr->video_dev->name, ZR_DEVNAME(zr));
-        if (video_register_device(zr->video_dev, VFL_TYPE_GRABBER,
-                                  video_nr) < 0) {
-                zoran_unregister_i2c(zr);
-                kfree((void *) zr->stat_com);
-                kfree(vdev);
-                return -1;
-        }
+        err = video_register_device(zr->video_dev, VFL_TYPE_GRABBER, video_nr);
+        if (err < 0)
+                goto exit_unregister;
 
         zoran_init_hardware(zr);
         if (*zr_debug > 2)
@@ -1092,6 +1082,13 @@ zr36057_init (struct zoran *zr)
         zr->zoran_proc = NULL;
         zr->initialized = 1;
         return 0;
+
+exit_unregister:
+        zoran_unregister_i2c(zr);
+exit_free:
+        kfree(zr->stat_com);
+        kfree(zr->video_dev);
+        return err;
 }
 
 static void
@@ -1121,7 +1118,7 @@ zoran_release (struct zoran *zr)
         btwrite(0, ZR36057_SPGPPCR);
         free_irq(zr->pci_dev->irq, zr);
         /* unmap and free memory */
-        kfree((void *) zr->stat_com);
+        kfree(zr->stat_com);
         zoran_proc_cleanup(zr);
         iounmap(zr->zr36057_mem);
         pci_disable_device(zr->pci_dev);
@@ -1206,7 +1203,7 @@ find_zr36057 (void)
                 zr->id = zoran_num;
                 snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)), "MJPEG[%u]", zr->id);
                 spin_lock_init(&zr->spinlock);
-                init_MUTEX(&zr->resource_lock);
+                mutex_init(&zr->resource_lock);
                 if (pci_enable_device(dev))
                         continue;
                 zr->zr36057_adr = pci_resource_start(zr->pci_dev, 0);
diff --git a/drivers/media/video/zoran_driver.c b/drivers/media/video/zoran_driver.c
index 485553be19..b2c6e01e39 100644
--- a/drivers/media/video/zoran_driver.c
+++ b/drivers/media/video/zoran_driver.c
@@ -81,6 +81,7 @@
 
 #include <linux/video_decoder.h>
 #include <linux/video_encoder.h>
+#include <linux/mutex.h>
 #include "zoran.h"
 #include "zoran_device.h"
 #include "zoran_card.h"
@@ -1292,7 +1293,7 @@ zoran_open (struct inode *inode,
 
         /* see fs/device.c - the kernel already locks during open(),
          * so locking ourselves only causes deadlocks */
-        /*down(&zr->resource_lock);*/
+        /*mutex_lock(&zr->resource_lock);*/
 
         if (!zr->decoder) {
                 dprintk(1,
@@ -1371,7 +1372,7 @@ zoran_open (struct inode *inode,
         if (zr->user++ == 0)
                 first_open = 1;
 
-        /*up(&zr->resource_lock);*/
+        /*mutex_unlock(&zr->resource_lock);*/
 
         /* default setup - TODO: look at flags */
         if (first_open) {       /* First device open */
@@ -1401,7 +1402,7 @@ open_unlock_and_return:
 
         /* if there's no device found, we didn't obtain the lock either */
         if (zr) {
-                /*up(&zr->resource_lock);*/
+                /*mutex_unlock(&zr->resource_lock);*/
         }
 
         return res;
@@ -1419,7 +1420,7 @@ zoran_close (struct inode *inode,
 
         /* kernel locks (fs/device.c), so don't do that ourselves
          * (prevents deadlocks) */
-        /*down(&zr->resource_lock);*/
+        /*mutex_lock(&zr->resource_lock);*/
 
         zoran_close_end_session(file);
 
@@ -1466,7 +1467,7 @@ zoran_close (struct inode *inode,
         }
         module_put(THIS_MODULE);
 
-        /*up(&zr->resource_lock);*/
+        /*mutex_unlock(&zr->resource_lock);*/
 
         dprintk(4, KERN_INFO "%s: zoran_close() done\n", ZR_DEVNAME(zr));
 
@@ -2027,14 +2028,14 @@ zoran_do_ioctl (struct inode *inode,
          * but moving the free code outside the munmap() handler fixes
          * all this... If someone knows why, please explain me (Ronald)
          */
-        if (!down_trylock(&zr->resource_lock)) {
+        if (!!mutex_trylock(&zr->resource_lock)) {
                 /* we obtained it! Let's try to free some things */
                 if (fh->jpg_buffers.ready_to_be_freed)
                         jpg_fbuffer_free(file);
                 if (fh->v4l_buffers.ready_to_be_freed)
                         v4l_fbuffer_free(file);
 
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
         }
 
         switch (cmd) {
@@ -2051,12 +2052,12 @@ zoran_do_ioctl (struct inode *inode,
 
                 vcap->channels = zr->card.inputs;
                 vcap->audios = 0;
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
                 vcap->maxwidth = BUZ_MAX_WIDTH;
                 vcap->maxheight = BUZ_MAX_HEIGHT;
                 vcap->minwidth = BUZ_MIN_WIDTH;
                 vcap->minheight = BUZ_MIN_HEIGHT;
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
 
                 return 0;
         }
@@ -2084,9 +2085,9 @@ zoran_do_ioctl (struct inode *inode,
                 vchan->tuners = 0;
                 vchan->flags = 0;
                 vchan->type = VIDEO_TYPE_CAMERA;
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
                 vchan->norm = zr->norm;
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
                 vchan->channel = channel;
 
                 return 0;
@@ -2113,7 +2114,7 @@ zoran_do_ioctl (struct inode *inode,
                         "%s: VIDIOCSCHAN - channel=%d, norm=%d\n",
                         ZR_DEVNAME(zr), vchan->channel, vchan->norm);
 
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
                 if ((res = zoran_set_input(zr, vchan->channel)))
                         goto schan_unlock_and_return;
                 if ((res = zoran_set_norm(zr, vchan->norm)))
@@ -2122,7 +2123,7 @@ zoran_do_ioctl (struct inode *inode,
                 /* Make sure the changes come into effect */
                 res = wait_grab_pending(zr);
         schan_unlock_and_return:
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
                 return res;
         }
                 break;
@@ -2134,7 +2135,7 @@ zoran_do_ioctl (struct inode *inode,
                 dprintk(3, KERN_DEBUG "%s: VIDIOCGPICT\n", ZR_DEVNAME(zr));
 
                 memset(vpict, 0, sizeof(struct video_picture));
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
                 vpict->hue = zr->hue;
                 vpict->brightness = zr->brightness;
                 vpict->contrast = zr->contrast;
@@ -2145,7 +2146,7 @@ zoran_do_ioctl (struct inode *inode,
                 } else {
                         vpict->depth = 0;
                 }
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
 
                 return 0;
         }
@@ -2180,7 +2181,7 @@ zoran_do_ioctl (struct inode *inode,
                         return -EINVAL;
                 }
 
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
 
                 decoder_command(zr, DECODER_SET_PICTURE, vpict);
 
@@ -2191,7 +2192,7 @@ zoran_do_ioctl (struct inode *inode,
 
                 fh->overlay_settings.format = &zoran_formats[i];
 
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
 
                 return 0;
         }
@@ -2204,9 +2205,9 @@ zoran_do_ioctl (struct inode *inode,
                 dprintk(3, KERN_DEBUG "%s: VIDIOCCAPTURE - on=%d\n",
                         ZR_DEVNAME(zr), *on);
 
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
                 res = setup_overlay(file, *on);
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
 
                 return res;
         }
@@ -2219,12 +2220,12 @@ zoran_do_ioctl (struct inode *inode,
                 dprintk(3, KERN_DEBUG "%s: VIDIOCGWIN\n", ZR_DEVNAME(zr));
 
                 memset(vwin, 0, sizeof(struct video_window));
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
                 vwin->x = fh->overlay_settings.x;
                 vwin->y = fh->overlay_settings.y;
                 vwin->width = fh->overlay_settings.width;
                 vwin->height = fh->overlay_settings.height;
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
                 vwin->clipcount = 0;
                 return 0;
         }
@@ -2241,12 +2242,12 @@ zoran_do_ioctl (struct inode *inode,
                         ZR_DEVNAME(zr), vwin->x, vwin->y, vwin->width,
                         vwin->height, vwin->clipcount);
 
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
                 res =
                     setup_window(file, vwin->x, vwin->y, vwin->width,
                                  vwin->height, vwin->clips,
                                  vwin->clipcount, NULL);
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
 
                 return res;
         }
@@ -2258,9 +2259,9 @@ zoran_do_ioctl (struct inode *inode,
 
                 dprintk(3, KERN_DEBUG "%s: VIDIOCGFBUF\n", ZR_DEVNAME(zr));
 
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
                 *vbuf = zr->buffer;
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
                 return 0;
         }
                 break;
@@ -2287,12 +2288,12 @@ zoran_do_ioctl (struct inode *inode,
                         return -EINVAL;
                 }
 
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
                 res =
                     setup_fbuffer(file, vbuf->base, &zoran_formats[i],
                                   vbuf->width, vbuf->height,
                                   vbuf->bytesperline);
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
 
                 return res;
         }
@@ -2305,9 +2306,9 @@ zoran_do_ioctl (struct inode *inode,
                 dprintk(3, KERN_DEBUG "%s: VIDIOCSYNC - frame=%d\n",
                         ZR_DEVNAME(zr), *frame);
 
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
                 res = v4l_sync(file, *frame);
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
                 if (!res)
                         zr->v4l_sync_tail++;
                 return res;
@@ -2325,9 +2326,9 @@ zoran_do_ioctl (struct inode *inode,
                         ZR_DEVNAME(zr), vmap->frame, vmap->width, vmap->height,
                         vmap->format);
 
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
                 res = v4l_grab(file, vmap);
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
                 return res;
         }
                 break;
@@ -2348,7 +2349,7 @@ zoran_do_ioctl (struct inode *inode,
                             i * fh->v4l_buffers.buffer_size;
                 }
 
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
 
                 if (fh->jpg_buffers.allocated || fh->v4l_buffers.allocated) {
                         dprintk(1,
@@ -2367,7 +2368,7 @@ zoran_do_ioctl (struct inode *inode,
                 /* The next mmap will map the V4L buffers */
                 fh->map_mode = ZORAN_MAP_MODE_RAW;
         v4l1reqbuf_unlock_and_return:
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
 
                 return res;
         }
@@ -2421,7 +2422,7 @@ zoran_do_ioctl (struct inode *inode,
                 bparams->major_version = MAJOR_VERSION;
                 bparams->minor_version = MINOR_VERSION;
 
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
 
                 bparams->norm = zr->norm;
                 bparams->input = zr->input;
@@ -2450,7 +2451,7 @@ zoran_do_ioctl (struct inode *inode,
                 bparams->jpeg_markers =
                     fh->jpg_settings.jpg_comp.jpeg_markers;
 
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
 
                 bparams->VFIFO_FB = 0;
 
@@ -2486,7 +2487,7 @@ zoran_do_ioctl (struct inode *inode,
                        sizeof(bparams->COM_data));
                 settings.jpg_comp.jpeg_markers = bparams->jpeg_markers;
 
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
 
                 if (zr->codec_mode != BUZ_MODE_IDLE) {
                         dprintk(1,
@@ -2506,7 +2507,7 @@ zoran_do_ioctl (struct inode *inode,
 
                 fh->jpg_settings = settings;
         sparams_unlock_and_return:
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
 
                 return res;
         }
@@ -2538,7 +2539,7 @@ zoran_do_ioctl (struct inode *inode,
                     breq->size > MAX_KMALLOC_MEM)
                         breq->size = MAX_KMALLOC_MEM;
 
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
 
                 if (fh->jpg_buffers.allocated || fh->v4l_buffers.allocated) {
                         dprintk(1,
@@ -2561,7 +2562,7 @@ zoran_do_ioctl (struct inode *inode,
                  * also be *_PLAY, but it doesn't matter here */
                 fh->map_mode = ZORAN_MAP_MODE_JPG_REC;
         jpgreqbuf_unlock_and_return:
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
 
                 return res;
         }
@@ -2574,9 +2575,9 @@ zoran_do_ioctl (struct inode *inode,
                 dprintk(3, KERN_DEBUG "%s: BUZIOC_QBUF_CAPT - frame=%d\n",
                         ZR_DEVNAME(zr), *frame);
 
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
                 res = jpg_qbuf(file, *frame, BUZ_MODE_MOTION_COMPRESS);
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
 
                 return res;
         }
@@ -2589,9 +2590,9 @@ zoran_do_ioctl (struct inode *inode,
                 dprintk(3, KERN_DEBUG "%s: BUZIOC_QBUF_PLAY - frame=%d\n",
                         ZR_DEVNAME(zr), *frame);
 
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
                 res = jpg_qbuf(file, *frame, BUZ_MODE_MOTION_DECOMPRESS);
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
 
                 return res;
         }
@@ -2604,9 +2605,9 @@ zoran_do_ioctl (struct inode *inode,
 
                 dprintk(3, KERN_DEBUG "%s: BUZIOC_SYNC\n", ZR_DEVNAME(zr));
 
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
                 res = jpg_sync(file, bsync);
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
 
                 return res;
         }
@@ -2630,7 +2631,7 @@ zoran_do_ioctl (struct inode *inode,
                 input = zr->card.input[bstat->input].muxsel;
                 norm = VIDEO_MODE_AUTO;
 
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
 
                 if (zr->codec_mode != BUZ_MODE_IDLE) {
                         dprintk(1,
@@ -2655,7 +2656,7 @@ zoran_do_ioctl (struct inode *inode,
                 decoder_command(zr, DECODER_SET_INPUT, &input);
                 decoder_command(zr, DECODER_SET_NORM, &zr->norm);
         gstat_unlock_and_return:
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
 
                 if (!res) {
                         bstat->signal =
@@ -2763,7 +2764,7 @@ zoran_do_ioctl (struct inode *inode,
                 switch (fmt->type) {
                 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
 
-                        down(&zr->resource_lock);
+                        mutex_lock(&zr->resource_lock);
 
                         fmt->fmt.win.w.left = fh->overlay_settings.x;
                         fmt->fmt.win.w.top = fh->overlay_settings.y;
@@ -2776,14 +2777,14 @@ zoran_do_ioctl (struct inode *inode,
                         else
                                 fmt->fmt.win.field = V4L2_FIELD_TOP;
 
-                        up(&zr->resource_lock);
+                        mutex_unlock(&zr->resource_lock);
 
                         break;
 
                 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
                 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
 
-                        down(&zr->resource_lock);
+                        mutex_lock(&zr->resource_lock);
 
                         if (fmt->type == V4L2_BUF_TYPE_VIDEO_CAPTURE &&
                             fh->map_mode == ZORAN_MAP_MODE_RAW) {
@@ -2837,7 +2838,7 @@ zoran_do_ioctl (struct inode *inode,
                                     V4L2_COLORSPACE_SMPTE170M;
                         }
 
-                        up(&zr->resource_lock);
+                        mutex_unlock(&zr->resource_lock);
 
                         break;
 
@@ -2870,7 +2871,7 @@ zoran_do_ioctl (struct inode *inode,
                                 fmt->fmt.win.w.height,
                                 fmt->fmt.win.clipcount,
                                 fmt->fmt.win.bitmap);
-                        down(&zr->resource_lock);
+                        mutex_lock(&zr->resource_lock);
                         res =
                             setup_window(file, fmt->fmt.win.w.left,
                                          fmt->fmt.win.w.top,
@@ -2880,7 +2881,7 @@ zoran_do_ioctl (struct inode *inode,
                                            fmt->fmt.win.clips,
                                          fmt->fmt.win.clipcount,
                                          fmt->fmt.win.bitmap);
-                        up(&zr->resource_lock);
+                        mutex_unlock(&zr->resource_lock);
                         return res;
                         break;
 
@@ -2917,7 +2918,7 @@ zoran_do_ioctl (struct inode *inode,
                         }
 
                         if (fmt->fmt.pix.pixelformat == V4L2_PIX_FMT_MJPEG) {
-                                down(&zr->resource_lock);
+                                mutex_lock(&zr->resource_lock);
 
                                 settings = fh->jpg_settings;
 
@@ -2995,7 +2996,7 @@ zoran_do_ioctl (struct inode *inode,
                                     ZORAN_MAP_MODE_JPG_REC :
                                     ZORAN_MAP_MODE_JPG_PLAY;
                         sfmtjpg_unlock_and_return:
-                                up(&zr->resource_lock);
+                                mutex_unlock(&zr->resource_lock);
                         } else {
                                 for (i = 0; i < zoran_num_formats; i++)
                                         if (fmt->fmt.pix.pixelformat ==
@@ -3010,7 +3011,7 @@ zoran_do_ioctl (struct inode *inode,
                                                 (char *) &printformat);
                                         return -EINVAL;
                                 }
-                                down(&zr->resource_lock);
+                                mutex_lock(&zr->resource_lock);
                                 if (fh->jpg_buffers.allocated ||
                                     (fh->v4l_buffers.allocated &&
                                      fh->v4l_buffers.active !=
@@ -3052,7 +3053,7 @@ zoran_do_ioctl (struct inode *inode,
 
                                 fh->map_mode = ZORAN_MAP_MODE_RAW;
                         sfmtv4l_unlock_and_return:
-                                up(&zr->resource_lock);
+                                mutex_unlock(&zr->resource_lock);
                         }
 
                         break;
@@ -3077,7 +3078,7 @@ zoran_do_ioctl (struct inode *inode,
                 dprintk(3, KERN_DEBUG "%s: VIDIOC_G_FBUF\n", ZR_DEVNAME(zr));
 
                 memset(fb, 0, sizeof(*fb));
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
                 fb->base = zr->buffer.base;
                 fb->fmt.width = zr->buffer.width;
                 fb->fmt.height = zr->buffer.height;
@@ -3086,7 +3087,7 @@ zoran_do_ioctl (struct inode *inode,
                                 fh->overlay_settings.format->fourcc;
                 }
                 fb->fmt.bytesperline = zr->buffer.bytesperline;
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
                 fb->fmt.colorspace = V4L2_COLORSPACE_SRGB;
                 fb->fmt.field = V4L2_FIELD_INTERLACED;
                 fb->flags = V4L2_FBUF_FLAG_OVERLAY;
@@ -3121,12 +3122,12 @@ zoran_do_ioctl (struct inode *inode,
                         return -EINVAL;
                 }
 
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
                 res =
                     setup_fbuffer(file, fb->base, &zoran_formats[i],
                                   fb->fmt.width, fb->fmt.height,
                                   fb->fmt.bytesperline);
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
 
                 return res;
         }
@@ -3139,9 +3140,9 @@ zoran_do_ioctl (struct inode *inode,
                 dprintk(3, KERN_DEBUG "%s: VIDIOC_PREVIEW - on=%d\n",
                         ZR_DEVNAME(zr), *on);
 
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
                 res = setup_overlay(file, *on);
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
 
                 return res;
         }
@@ -3163,7 +3164,7 @@ zoran_do_ioctl (struct inode *inode,
                         return -EINVAL;
                 }
 
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
 
                 if (fh->v4l_buffers.allocated || fh->jpg_buffers.allocated) {
                         dprintk(1,
@@ -3224,7 +3225,7 @@ zoran_do_ioctl (struct inode *inode,
                         goto v4l2reqbuf_unlock_and_return;
                 }
         v4l2reqbuf_unlock_and_return:
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
 
                 return 0;
         }
@@ -3245,9 +3246,9 @@ zoran_do_ioctl (struct inode *inode,
                 buf->type = type;
                 buf->index = index;
 
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
                 res = zoran_v4l2_buffer_status(file, buf, buf->index);
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
 
                 return res;
         }
@@ -3262,7 +3263,7 @@ zoran_do_ioctl (struct inode *inode,
                         KERN_DEBUG "%s: VIDIOC_QBUF - type=%d, index=%d\n",
                         ZR_DEVNAME(zr), buf->type, buf->index);
 
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
 
                 switch (fh->map_mode) {
                 case ZORAN_MAP_MODE_RAW:
@@ -3322,7 +3323,7 @@ zoran_do_ioctl (struct inode *inode,
                         goto qbuf_unlock_and_return;
                 }
         qbuf_unlock_and_return:
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
 
                 return res;
         }
@@ -3336,7 +3337,7 @@ zoran_do_ioctl (struct inode *inode,
                 dprintk(3, KERN_DEBUG "%s: VIDIOC_DQBUF - type=%d\n",
                         ZR_DEVNAME(zr), buf->type);
 
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
 
                 switch (fh->map_mode) {
                 case ZORAN_MAP_MODE_RAW:
@@ -3410,7 +3411,7 @@ zoran_do_ioctl (struct inode *inode,
                         goto dqbuf_unlock_and_return;
                 }
         dqbuf_unlock_and_return:
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
 
                 return res;
         }
@@ -3422,7 +3423,7 @@ zoran_do_ioctl (struct inode *inode,
 
                 dprintk(3, KERN_DEBUG "%s: VIDIOC_STREAMON\n", ZR_DEVNAME(zr));
 
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
 
                 switch (fh->map_mode) {
                 case ZORAN_MAP_MODE_RAW:        /* raw capture */
@@ -3470,7 +3471,7 @@ zoran_do_ioctl (struct inode *inode,
                         goto strmon_unlock_and_return;
                 }
         strmon_unlock_and_return:
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
 
                 return res;
         }
@@ -3482,7 +3483,7 @@ zoran_do_ioctl (struct inode *inode,
 
                 dprintk(3, KERN_DEBUG "%s: VIDIOC_STREAMOFF\n", ZR_DEVNAME(zr));
 
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
 
                 switch (fh->map_mode) {
                 case ZORAN_MAP_MODE_RAW:        /* raw capture */
@@ -3540,7 +3541,7 @@ zoran_do_ioctl (struct inode *inode,
                         goto strmoff_unlock_and_return;
                 }
         strmoff_unlock_and_return:
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
 
                 return res;
         }
@@ -3600,7 +3601,7 @@ zoran_do_ioctl (struct inode *inode,
                     ctrl->id > V4L2_CID_HUE)
                         return -EINVAL;
 
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
                 switch (ctrl->id) {
                 case V4L2_CID_BRIGHTNESS:
                         ctrl->value = zr->brightness;
@@ -3615,7 +3616,7 @@ zoran_do_ioctl (struct inode *inode,
                         ctrl->value = zr->hue;
                         break;
                 }
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
 
                 return 0;
         }
@@ -3642,7 +3643,7 @@ zoran_do_ioctl (struct inode *inode,
                         return -EINVAL;
                 }
 
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
                 switch (ctrl->id) {
                 case V4L2_CID_BRIGHTNESS:
                         zr->brightness = ctrl->value;
@@ -3664,7 +3665,7 @@ zoran_do_ioctl (struct inode *inode,
 
                 decoder_command(zr, DECODER_SET_PICTURE, &pict);
 
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
 
                 return 0;
         }
@@ -3732,9 +3733,9 @@ zoran_do_ioctl (struct inode *inode,
 
                 dprintk(3, KERN_DEBUG "%s: VIDIOC_G_STD\n", ZR_DEVNAME(zr));
 
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
                 norm = zr->norm;
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
 
                 switch (norm) {
                 case VIDEO_MODE_PAL:
@@ -3776,13 +3777,13 @@ zoran_do_ioctl (struct inode *inode,
                         return -EINVAL;
                 }
 
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
                 if ((res = zoran_set_norm(zr, norm)))
                         goto sstd_unlock_and_return;
 
                 res = wait_grab_pending(zr);
         sstd_unlock_and_return:
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
                 return res;
         }
                 break;
@@ -3809,9 +3810,9 @@ zoran_do_ioctl (struct inode *inode,
                 inp->std = V4L2_STD_ALL;
 
                 /* Get status of video decoder */
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
                 decoder_command(zr, DECODER_GET_STATUS, &status);
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
 
                 if (!(status & DECODER_STATUS_GOOD)) {
                         inp->status |= V4L2_IN_ST_NO_POWER;
@@ -3830,9 +3831,9 @@ zoran_do_ioctl (struct inode *inode,
 
                 dprintk(3, KERN_DEBUG "%s: VIDIOC_G_INPUT\n", ZR_DEVNAME(zr));
 
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
                 *input = zr->input;
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
 
                 return 0;
         }
@@ -3845,14 +3846,14 @@ zoran_do_ioctl (struct inode *inode,
                 dprintk(3, KERN_DEBUG "%s: VIDIOC_S_INPUT - input=%d\n",
                         ZR_DEVNAME(zr), *input);
 
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
                 if ((res = zoran_set_input(zr, *input)))
                         goto sinput_unlock_and_return;
 
                 /* Make sure the changes come into effect */
                 res = wait_grab_pending(zr);
         sinput_unlock_and_return:
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
                 return res;
         }
                 break;
@@ -3914,7 +3915,7 @@ zoran_do_ioctl (struct inode *inode,
                 memset(cropcap, 0, sizeof(*cropcap));
                 cropcap->type = type;
 
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
 
                 if (cropcap->type != V4L2_BUF_TYPE_VIDEO_OUTPUT &&
                     (cropcap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
@@ -3934,7 +3935,7 @@ zoran_do_ioctl (struct inode *inode,
                 cropcap->defrect.width = BUZ_MIN_WIDTH;
                 cropcap->defrect.height = BUZ_MIN_HEIGHT;
         cropcap_unlock_and_return:
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
                 return res;
         }
                 break;
@@ -3950,7 +3951,7 @@ zoran_do_ioctl (struct inode *inode,
                 memset(crop, 0, sizeof(*crop));
                 crop->type = type;
 
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
 
                 if (crop->type != V4L2_BUF_TYPE_VIDEO_OUTPUT &&
                     (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
@@ -3969,7 +3970,7 @@ zoran_do_ioctl (struct inode *inode,
                 crop->c.height = fh->jpg_settings.img_height;
 
         gcrop_unlock_and_return:
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
 
                 return res;
         }
@@ -3988,7 +3989,7 @@ zoran_do_ioctl (struct inode *inode,
                         ZR_DEVNAME(zr), crop->type, crop->c.left, crop->c.top,
                         crop->c.width, crop->c.height);
 
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
 
                 if (fh->jpg_buffers.allocated || fh->v4l_buffers.allocated) {
                         dprintk(1,
@@ -4024,7 +4025,7 @@ zoran_do_ioctl (struct inode *inode,
                 fh->jpg_settings = settings;
 
         scrop_unlock_and_return:
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
                 return res;
         }
                 break;
@@ -4038,7 +4039,7 @@ zoran_do_ioctl (struct inode *inode,
 
                 memset(params, 0, sizeof(*params));
 
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
 
                 params->quality = fh->jpg_settings.jpg_comp.quality;
                 params->APPn = fh->jpg_settings.jpg_comp.APPn;
@@ -4053,7 +4054,7 @@ zoran_do_ioctl (struct inode *inode,
                 params->jpeg_markers =
                     fh->jpg_settings.jpg_comp.jpeg_markers;
 
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
 
                 return 0;
         }
@@ -4074,7 +4075,7 @@ zoran_do_ioctl (struct inode *inode,
 
                 settings.jpg_comp = *params;
 
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
 
                 if (fh->v4l_buffers.active != ZORAN_FREE ||
                     fh->jpg_buffers.active != ZORAN_FREE) {
@@ -4093,7 +4094,7 @@ zoran_do_ioctl (struct inode *inode,
                             zoran_v4l2_calc_bufsize(&fh->jpg_settings);
                 fh->jpg_settings.jpg_comp = *params = settings.jpg_comp;
         sjpegc_unlock_and_return:
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
 
                 return 0;
         }
@@ -4127,7 +4128,7 @@ zoran_do_ioctl (struct inode *inode,
 
                 switch (fmt->type) {
                 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
-                        down(&zr->resource_lock);
+                        mutex_lock(&zr->resource_lock);
 
                         if (fmt->fmt.win.w.width > BUZ_MAX_WIDTH)
                                 fmt->fmt.win.w.width = BUZ_MAX_WIDTH;
@@ -4138,7 +4139,7 @@ zoran_do_ioctl (struct inode *inode,
                         if (fmt->fmt.win.w.height < BUZ_MIN_HEIGHT)
                                 fmt->fmt.win.w.height = BUZ_MIN_HEIGHT;
 
-                        up(&zr->resource_lock);
+                        mutex_unlock(&zr->resource_lock);
                         break;
 
                 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
@@ -4146,7 +4147,7 @@ zoran_do_ioctl (struct inode *inode,
                         if (fmt->fmt.pix.bytesperline > 0)
                                 return -EINVAL;
 
-                        down(&zr->resource_lock);
+                        mutex_lock(&zr->resource_lock);
 
                         if (fmt->fmt.pix.pixelformat == V4L2_PIX_FMT_MJPEG) {
                                 settings = fh->jpg_settings;
@@ -4229,7 +4230,7 @@ zoran_do_ioctl (struct inode *inode,
                                 goto tryfmt_unlock_and_return;
                         }
                 tryfmt_unlock_and_return:
-                        up(&zr->resource_lock);
+                        mutex_unlock(&zr->resource_lock);
 
                         return res;
                         break;
@@ -4280,7 +4281,7 @@ zoran_poll (struct file *file,
          * if no buffers queued or so, return POLLNVAL
          */
 
-        down(&zr->resource_lock);
+        mutex_lock(&zr->resource_lock);
 
         switch (fh->map_mode) {
         case ZORAN_MAP_MODE_RAW:
@@ -4329,7 +4330,7 @@ zoran_poll (struct file *file,
         }
 
 poll_unlock_and_return:
-        up(&zr->resource_lock);
+        mutex_unlock(&zr->resource_lock);
 
         return res;
 }
@@ -4385,7 +4386,7 @@ zoran_vm_close (struct vm_area_struct *vma)
                                 if (fh->jpg_buffers.buffer[i].map)
                                         break;
                         if (i == fh->jpg_buffers.num_buffers) {
-                                down(&zr->resource_lock);
+                                mutex_lock(&zr->resource_lock);
 
                                 if (fh->jpg_buffers.active != ZORAN_FREE) {
                                         jpg_qbuf(file, -1, zr->codec_mode);
@@ -4398,7 +4399,7 @@ zoran_vm_close (struct vm_area_struct *vma)
                                 fh->jpg_buffers.allocated = 0;
                                 fh->jpg_buffers.ready_to_be_freed = 1;
 
-                                up(&zr->resource_lock);
+                                mutex_unlock(&zr->resource_lock);
                         }
 
                         break;
@@ -4421,7 +4422,7 @@ zoran_vm_close (struct vm_area_struct *vma)
                                 if (fh->v4l_buffers.buffer[i].map)
                                         break;
                         if (i == fh->v4l_buffers.num_buffers) {
-                                down(&zr->resource_lock);
+                                mutex_lock(&zr->resource_lock);
 
                                 if (fh->v4l_buffers.active != ZORAN_FREE) {
                                         zr36057_set_memgrab(zr, 0);
@@ -4434,7 +4435,7 @@ zoran_vm_close (struct vm_area_struct *vma)
                                 fh->v4l_buffers.allocated = 0;
                                 fh->v4l_buffers.ready_to_be_freed = 1;
 
-                                up(&zr->resource_lock);
+                                mutex_unlock(&zr->resource_lock);
                         }
 
                         break;
@@ -4489,7 +4490,7 @@ zoran_mmap (struct file           *file,
         case ZORAN_MAP_MODE_JPG_PLAY:
 
                 /* lock */
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
 
                 /* Map the MJPEG buffers */
                 if (!fh->jpg_buffers.allocated) {
@@ -4579,13 +4580,13 @@ zoran_mmap (struct file           *file,
 
                 }
         jpg_mmap_unlock_and_return:
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
 
                 break;
 
         case ZORAN_MAP_MODE_RAW:
 
-                down(&zr->resource_lock);
+                mutex_lock(&zr->resource_lock);
 
                 /* Map the V4L buffers */
                 if (!fh->v4l_buffers.allocated) {
@@ -4657,7 +4658,7 @@ zoran_mmap (struct file           *file,
                                 break;
                 }
         v4l_mmap_unlock_and_return:
-                up(&zr->resource_lock);
+                mutex_unlock(&zr->resource_lock);
 
                 break;
 
diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig
index 550f297448..fc3c8854f4 100644
--- a/drivers/mfd/Kconfig
+++ b/drivers/mfd/Kconfig
@@ -3,6 +3,7 @@
 #
 
 menu "Multimedia Capabilities Port drivers"
+        depends on ARCH_SA1100
 
 config MCP
         tristate
diff --git a/drivers/mmc/Kconfig b/drivers/mmc/Kconfig
index 5d397b7a54..3f5d77f633 100644
--- a/drivers/mmc/Kconfig
+++ b/drivers/mmc/Kconfig
@@ -49,6 +49,17 @@ config MMC_PXA
 
           If unsure, say N.
 
+config MMC_SDHCI
+        tristate "Secure Digital Host Controller Interface support  (EXPERIMENTAL)"
+        depends on PCI && MMC && EXPERIMENTAL
+        help
+          This select the generic Secure Digital Host Controller Interface.
+          It is used by manufacturers such as Texas Instruments(R), Ricoh(R)
+          and Toshiba(R). Most controllers found in laptops are of this type.
+          If you have a controller with this interface, say Y or M here.
+
+          If unsure, say N.
+
 config MMC_WBSD
         tristate "Winbond W83L51xD SD/MMC Card Interface support"
         depends on MMC && ISA_DMA_API
diff --git a/drivers/mmc/Makefile b/drivers/mmc/Makefile
index e351e71146..769d545284 100644
--- a/drivers/mmc/Makefile
+++ b/drivers/mmc/Makefile
@@ -17,6 +17,7 @@ obj-$(CONFIG_MMC_BLOCK)		+= mmc_block.o
 #
 obj-$(CONFIG_MMC_ARMMMCI)       += mmci.o
 obj-$(CONFIG_MMC_PXA)           += pxamci.o
+obj-$(CONFIG_MMC_SDHCI)         += sdhci.o
 obj-$(CONFIG_MMC_WBSD)          += wbsd.o
 obj-$(CONFIG_MMC_AU1X)          += au1xmmc.o
 
diff --git a/drivers/mmc/sdhci.c b/drivers/mmc/sdhci.c
new file mode 100644
index 0000000000..8b811d9437
--- /dev/null
+++ b/drivers/mmc/sdhci.c
@@ -0,0 +1,1265 @@
+/*
+ *  linux/drivers/mmc/sdhci.c - Secure Digital Host Controller Interface driver
+ *
+ *  Copyright (C) 2005-2006 Pierre Ossman, All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+ /*
+  * Note that PIO transfer is rather crappy atm. The buffer full/empty
+  * interrupts aren't reliable so we currently transfer the entire buffer
+  * directly. Patches to solve the problem are welcome.
+  */
+
+#include <linux/delay.h>
+#include <linux/highmem.h>
+#include <linux/pci.h>
+#include <linux/dma-mapping.h>
+
+#include <linux/mmc/host.h>
+#include <linux/mmc/protocol.h>
+
+#include <asm/scatterlist.h>
+
+#include "sdhci.h"
+
+#define DRIVER_NAME "sdhci"
+#define DRIVER_VERSION "0.11"
+
+#define BUGMAIL "<sdhci-devel@list.drzeus.cx>"
+
+#ifdef CONFIG_MMC_DEBUG
+#define DBG(f, x...) \
+        printk(KERN_DEBUG DRIVER_NAME " [%s()]: " f, __func__,## x)
+#else
+#define DBG(f, x...) do { } while (0)
+#endif
+
+static const struct pci_device_id pci_ids[] __devinitdata = {
+        /* handle any SD host controller */
+        {PCI_DEVICE_CLASS((PCI_CLASS_SYSTEM_SDHCI << 8), 0xFFFF00)},
+        { /* end: all zeroes */ },
+};
+
+MODULE_DEVICE_TABLE(pci, pci_ids);
+
+static void sdhci_prepare_data(struct sdhci_host *, struct mmc_data *);
+static void sdhci_finish_data(struct sdhci_host *);
+
+static void sdhci_send_command(struct sdhci_host *, struct mmc_command *);
+static void sdhci_finish_command(struct sdhci_host *);
+
+static void sdhci_dumpregs(struct sdhci_host *host)
+{
+        printk(KERN_DEBUG DRIVER_NAME ": ============== REGISTER DUMP ==============\n");
+
+        printk(KERN_DEBUG DRIVER_NAME ": Sys addr: 0x%08x | Version:  0x%08x\n",
+                readl(host->ioaddr + SDHCI_DMA_ADDRESS),
+                readw(host->ioaddr + SDHCI_HOST_VERSION));
+        printk(KERN_DEBUG DRIVER_NAME ": Blk size: 0x%08x | Blk cnt:  0x%08x\n",
+                readw(host->ioaddr + SDHCI_BLOCK_SIZE),
+                readw(host->ioaddr + SDHCI_BLOCK_COUNT));
+        printk(KERN_DEBUG DRIVER_NAME ": Argument: 0x%08x | Trn mode: 0x%08x\n",
+                readl(host->ioaddr + SDHCI_ARGUMENT),
+                readw(host->ioaddr + SDHCI_TRANSFER_MODE));
+        printk(KERN_DEBUG DRIVER_NAME ": Present:  0x%08x | Host ctl: 0x%08x\n",
+                readl(host->ioaddr + SDHCI_PRESENT_STATE),
+                readb(host->ioaddr + SDHCI_HOST_CONTROL));
+        printk(KERN_DEBUG DRIVER_NAME ": Power:    0x%08x | Blk gap:  0x%08x\n",
+                readb(host->ioaddr + SDHCI_POWER_CONTROL),
+                readb(host->ioaddr + SDHCI_BLOCK_GAP_CONTROL));
+        printk(KERN_DEBUG DRIVER_NAME ": Wake-up:  0x%08x | Clock:    0x%08x\n",
+                readb(host->ioaddr + SDHCI_WALK_UP_CONTROL),
+                readw(host->ioaddr + SDHCI_CLOCK_CONTROL));
+        printk(KERN_DEBUG DRIVER_NAME ": Timeout:  0x%08x | Int stat: 0x%08x\n",
+                readb(host->ioaddr + SDHCI_TIMEOUT_CONTROL),
+                readl(host->ioaddr + SDHCI_INT_STATUS));
+        printk(KERN_DEBUG DRIVER_NAME ": Int enab: 0x%08x | Sig enab: 0x%08x\n",
+                readl(host->ioaddr + SDHCI_INT_ENABLE),
+                readl(host->ioaddr + SDHCI_SIGNAL_ENABLE));
+        printk(KERN_DEBUG DRIVER_NAME ": AC12 err: 0x%08x | Slot int: 0x%08x\n",
+                readw(host->ioaddr + SDHCI_ACMD12_ERR),
+                readw(host->ioaddr + SDHCI_SLOT_INT_STATUS));
+        printk(KERN_DEBUG DRIVER_NAME ": Caps:     0x%08x | Max curr: 0x%08x\n",
+                readl(host->ioaddr + SDHCI_CAPABILITIES),
+                readl(host->ioaddr + SDHCI_MAX_CURRENT));
+
+        printk(KERN_DEBUG DRIVER_NAME ": ===========================================\n");
+}
+
+/*****************************************************************************\
+ *                                                                           *
+ * Low level functions                                                       *
+ *                                                                           *
+\*****************************************************************************/
+
+static void sdhci_reset(struct sdhci_host *host, u8 mask)
+{
+        writeb(mask, host->ioaddr + SDHCI_SOFTWARE_RESET);
+
+        if (mask & SDHCI_RESET_ALL) {
+                host->clock = 0;
+
+                mdelay(50);
+        }
+}
+
+static void sdhci_init(struct sdhci_host *host)
+{
+        u32 intmask;
+
+        sdhci_reset(host, SDHCI_RESET_ALL);
+
+        intmask = ~(SDHCI_INT_CARD_INT | SDHCI_INT_BUF_EMPTY | SDHCI_INT_BUF_FULL);
+
+        writel(intmask, host->ioaddr + SDHCI_INT_ENABLE);
+        writel(intmask, host->ioaddr + SDHCI_SIGNAL_ENABLE);
+
+        /* This is unknown magic. */
+        writeb(0xE, host->ioaddr + SDHCI_TIMEOUT_CONTROL);
+}
+
+static void sdhci_activate_led(struct sdhci_host *host)
+{
+        u8 ctrl;
+
+        ctrl = readb(host->ioaddr + SDHCI_HOST_CONTROL);
+        ctrl |= SDHCI_CTRL_LED;
+        writeb(ctrl, host->ioaddr + SDHCI_HOST_CONTROL);
+}
+
+static void sdhci_deactivate_led(struct sdhci_host *host)
+{
+        u8 ctrl;
+
+        ctrl = readb(host->ioaddr + SDHCI_HOST_CONTROL);
+        ctrl &= ~SDHCI_CTRL_LED;
+        writeb(ctrl, host->ioaddr + SDHCI_HOST_CONTROL);
+}
+
+/*****************************************************************************\
+ *                                                                           *
+ * Core functions                                                            *
+ *                                                                           *
+\*****************************************************************************/
+
+static inline char* sdhci_kmap_sg(struct sdhci_host* host)
+{
+        host->mapped_sg = kmap_atomic(host->cur_sg->page, KM_BIO_SRC_IRQ);
+        return host->mapped_sg + host->cur_sg->offset;
+}
+
+static inline void sdhci_kunmap_sg(struct sdhci_host* host)
+{
+        kunmap_atomic(host->mapped_sg, KM_BIO_SRC_IRQ);
+}
+
+static inline int sdhci_next_sg(struct sdhci_host* host)
+{
+        /*
+         * Skip to next SG entry.
+         */
+        host->cur_sg++;
+        host->num_sg--;
+
+        /*
+         * Any entries left?
+         */
+        if (host->num_sg > 0) {
+                host->offset = 0;
+                host->remain = host->cur_sg->length;
+        }
+
+        return host->num_sg;
+}
+
+static void sdhci_transfer_pio(struct sdhci_host *host)
+{
+        char *buffer;
+        u32 mask;
+        int bytes, size;
+        unsigned long max_jiffies;
+
+        BUG_ON(!host->data);
+
+        if (host->num_sg == 0)
+                return;
+
+        bytes = 0;
+        if (host->data->flags & MMC_DATA_READ)
+                mask = SDHCI_DATA_AVAILABLE;
+        else
+                mask = SDHCI_SPACE_AVAILABLE;
+
+        buffer = sdhci_kmap_sg(host) + host->offset;
+
+        /* Transfer shouldn't take more than 5 s */
+        max_jiffies = jiffies + HZ * 5;
+
+        while (host->size > 0) {
+                if (time_after(jiffies, max_jiffies)) {
+                        printk(KERN_ERR "%s: PIO transfer stalled. "
+                                "Please report this to "
+                                BUGMAIL ".\n", mmc_hostname(host->mmc));
+                        sdhci_dumpregs(host);
+
+                        sdhci_kunmap_sg(host);
+
+                        host->data->error = MMC_ERR_FAILED;
+                        sdhci_finish_data(host);
+                        return;
+                }
+
+                if (!(readl(host->ioaddr + SDHCI_PRESENT_STATE) & mask))
+                        continue;
+
+                size = min(host->size, host->remain);
+
+                if (size >= 4) {
+                        if (host->data->flags & MMC_DATA_READ)
+                                *(u32*)buffer = readl(host->ioaddr + SDHCI_BUFFER);
+                        else
+                                writel(*(u32*)buffer, host->ioaddr + SDHCI_BUFFER);
+                        size = 4;
+                } else if (size >= 2) {
+                        if (host->data->flags & MMC_DATA_READ)
+                                *(u16*)buffer = readw(host->ioaddr + SDHCI_BUFFER);
+                        else
+                                writew(*(u16*)buffer, host->ioaddr + SDHCI_BUFFER);
+                        size = 2;
+                } else {
+                        if (host->data->flags & MMC_DATA_READ)
+                                *(u8*)buffer = readb(host->ioaddr + SDHCI_BUFFER);
+                        else
+                                writeb(*(u8*)buffer, host->ioaddr + SDHCI_BUFFER);
+                        size = 1;
+                }
+
+                buffer += size;
+                host->offset += size;
+                host->remain -= size;
+
+                bytes += size;
+                host->size -= size;
+
+                if (host->remain == 0) {
+                        sdhci_kunmap_sg(host);
+                        if (sdhci_next_sg(host) == 0) {
+                                DBG("PIO transfer: %d bytes\n", bytes);
+                                return;
+                        }
+                        buffer = sdhci_kmap_sg(host);
+                }
+        }
+
+        sdhci_kunmap_sg(host);
+
+        DBG("PIO transfer: %d bytes\n", bytes);
+}
+
+static void sdhci_prepare_data(struct sdhci_host *host, struct mmc_data *data)
+{
+        u16 mode;
+
+        WARN_ON(host->data);
+
+        if (data == NULL) {
+                writew(0, host->ioaddr + SDHCI_TRANSFER_MODE);
+                return;
+        }
+
+        DBG("blksz %04x blks %04x flags %08x\n",
+                1 << data->blksz_bits, data->blocks, data->flags);
+        DBG("tsac %d ms nsac %d clk\n",
+                data->timeout_ns / 1000000, data->timeout_clks);
+
+        mode = SDHCI_TRNS_BLK_CNT_EN;
+        if (data->blocks > 1)
+                mode |= SDHCI_TRNS_MULTI;
+        if (data->flags & MMC_DATA_READ)
+                mode |= SDHCI_TRNS_READ;
+        if (host->flags & SDHCI_USE_DMA)
+                mode |= SDHCI_TRNS_DMA;
+
+        writew(mode, host->ioaddr + SDHCI_TRANSFER_MODE);
+
+        writew(1 << data->blksz_bits, host->ioaddr + SDHCI_BLOCK_SIZE);
+        writew(data->blocks, host->ioaddr + SDHCI_BLOCK_COUNT);
+
+        if (host->flags & SDHCI_USE_DMA) {
+                int count;
+
+                count = pci_map_sg(host->chip->pdev, data->sg, data->sg_len,
+                        (data->flags & MMC_DATA_READ)?PCI_DMA_FROMDEVICE:PCI_DMA_TODEVICE);
+                BUG_ON(count != 1);
+
+                writel(sg_dma_address(data->sg), host->ioaddr + SDHCI_DMA_ADDRESS);
+        } else {
+                host->size = (1 << data->blksz_bits) * data->blocks;
+
+                host->cur_sg = data->sg;
+                host->num_sg = data->sg_len;
+
+                host->offset = 0;
+                host->remain = host->cur_sg->length;
+        }
+}
+
+static void sdhci_finish_data(struct sdhci_host *host)
+{
+        struct mmc_data *data;
+        u32 intmask;
+        u16 blocks;
+
+        BUG_ON(!host->data);
+
+        data = host->data;
+        host->data = NULL;
+
+        if (host->flags & SDHCI_USE_DMA) {
+                pci_unmap_sg(host->chip->pdev, data->sg, data->sg_len,
+                        (data->flags & MMC_DATA_READ)?PCI_DMA_FROMDEVICE:PCI_DMA_TODEVICE);
+        } else {
+                intmask = readl(host->ioaddr + SDHCI_SIGNAL_ENABLE);
+                intmask &= ~(SDHCI_INT_BUF_EMPTY | SDHCI_INT_BUF_FULL);
+                writel(intmask, host->ioaddr + SDHCI_SIGNAL_ENABLE);
+
+                intmask = readl(host->ioaddr + SDHCI_INT_ENABLE);
+                intmask &= ~(SDHCI_INT_BUF_EMPTY | SDHCI_INT_BUF_FULL);
+                writel(intmask, host->ioaddr + SDHCI_INT_ENABLE);
+        }
+
+        /*
+         * Controller doesn't count down when in single block mode.
+         */
+        if ((data->blocks == 1) && (data->error == MMC_ERR_NONE))
+                blocks = 0;
+        else
+                blocks = readw(host->ioaddr + SDHCI_BLOCK_COUNT);
+        data->bytes_xfered = (1 << data->blksz_bits) * (data->blocks - blocks);
+
+        if ((data->error == MMC_ERR_NONE) && blocks) {
+                printk(KERN_ERR "%s: Controller signalled completion even "
+                        "though there were blocks left. Please report this "
+                        "to " BUGMAIL ".\n", mmc_hostname(host->mmc));
+                data->error = MMC_ERR_FAILED;
+        }
+
+        if (host->size != 0) {
+                printk(KERN_ERR "%s: %d bytes were left untransferred. "
+                        "Please report this to " BUGMAIL ".\n",
+                        mmc_hostname(host->mmc), host->size);
+                data->error = MMC_ERR_FAILED;
+        }
+
+        DBG("Ending data transfer (%d bytes)\n", data->bytes_xfered);
+
+        if (data->stop) {
+                /*
+                 * The controller needs a reset of internal state machines
+                 * upon error conditions.
+                 */
+                if (data->error != MMC_ERR_NONE) {
+                        sdhci_reset(host, SDHCI_RESET_CMD);
+                        sdhci_reset(host, SDHCI_RESET_DATA);
+                }
+
+                sdhci_send_command(host, data->stop);
+        } else
+                tasklet_schedule(&host->finish_tasklet);
+}
+
+static void sdhci_send_command(struct sdhci_host *host, struct mmc_command *cmd)
+{
+        int flags;
+        u32 present;
+        unsigned long max_jiffies;
+
+        WARN_ON(host->cmd);
+
+        DBG("Sending cmd (%x)\n", cmd->opcode);
+
+        /* Wait max 10 ms */
+        max_jiffies = jiffies + (HZ + 99)/100;
+        do {
+                if (time_after(jiffies, max_jiffies)) {
+                        printk(KERN_ERR "%s: Controller never released "
+                                "inhibit bits. Please report this to "
+                                BUGMAIL ".\n", mmc_hostname(host->mmc));
+                        sdhci_dumpregs(host);
+                        cmd->error = MMC_ERR_FAILED;
+                        tasklet_schedule(&host->finish_tasklet);
+                        return;
+                }
+                present = readl(host->ioaddr + SDHCI_PRESENT_STATE);
+        } while (present & (SDHCI_CMD_INHIBIT | SDHCI_DATA_INHIBIT));
+
+        mod_timer(&host->timer, jiffies + 10 * HZ);
+
+        host->cmd = cmd;
+
+        sdhci_prepare_data(host, cmd->data);
+
+        writel(cmd->arg, host->ioaddr + SDHCI_ARGUMENT);
+
+        if ((cmd->flags & MMC_RSP_136) && (cmd->flags & MMC_RSP_BUSY)) {
+                printk(KERN_ERR "%s: Unsupported response type! "
+                        "Please report this to " BUGMAIL ".\n",
+                        mmc_hostname(host->mmc));
+                cmd->error = MMC_ERR_INVALID;
+                tasklet_schedule(&host->finish_tasklet);
+                return;
+        }
+
+        if (!(cmd->flags & MMC_RSP_PRESENT))
+                flags = SDHCI_CMD_RESP_NONE;
+        else if (cmd->flags & MMC_RSP_136)
+                flags = SDHCI_CMD_RESP_LONG;
+        else if (cmd->flags & MMC_RSP_BUSY)
+                flags = SDHCI_CMD_RESP_SHORT_BUSY;
+        else
+                flags = SDHCI_CMD_RESP_SHORT;
+
+        if (cmd->flags & MMC_RSP_CRC)
+                flags |= SDHCI_CMD_CRC;
+        if (cmd->flags & MMC_RSP_OPCODE)
+                flags |= SDHCI_CMD_INDEX;
+        if (cmd->data)
+                flags |= SDHCI_CMD_DATA;
+
+        writel(SDHCI_MAKE_CMD(cmd->opcode, flags),
+                host->ioaddr + SDHCI_COMMAND);
+}
+
+static void sdhci_finish_command(struct sdhci_host *host)
+{
+        int i;
+
+        BUG_ON(host->cmd == NULL);
+
+        if (host->cmd->flags & MMC_RSP_PRESENT) {
+                if (host->cmd->flags & MMC_RSP_136) {
+                        /* CRC is stripped so we need to do some shifting. */
+                        for (i = 0;i < 4;i++) {
+                                host->cmd->resp[i] = readl(host->ioaddr +
+                                        SDHCI_RESPONSE + (3-i)*4) << 8;
+                                if (i != 3)
+                                        host->cmd->resp[i] |=
+                                                readb(host->ioaddr +
+                                                SDHCI_RESPONSE + (3-i)*4-1);
+                        }
+                } else {
+                        host->cmd->resp[0] = readl(host->ioaddr + SDHCI_RESPONSE);
+                }
+        }
+
+        host->cmd->error = MMC_ERR_NONE;
+
+        DBG("Ending cmd (%x)\n", host->cmd->opcode);
+
+        if (host->cmd->data) {
+                u32 intmask;
+
+                host->data = host->cmd->data;
+
+                if (!(host->flags & SDHCI_USE_DMA)) {
+                        /*
+                         * Don't enable the interrupts until now to make sure we
+                         * get stable handling of the FIFO.
+                         */
+                        intmask = readl(host->ioaddr + SDHCI_INT_ENABLE);
+                        intmask |= SDHCI_INT_BUF_EMPTY | SDHCI_INT_BUF_FULL;
+                        writel(intmask, host->ioaddr + SDHCI_INT_ENABLE);
+
+                        intmask = readl(host->ioaddr + SDHCI_SIGNAL_ENABLE);
+                        intmask |= SDHCI_INT_BUF_EMPTY | SDHCI_INT_BUF_FULL;
+                        writel(intmask, host->ioaddr + SDHCI_SIGNAL_ENABLE);
+
+                        /*
+                         * The buffer interrupts are to unreliable so we
+                         * start the transfer immediatly.
+                         */
+                        sdhci_transfer_pio(host);
+                }
+        } else
+                tasklet_schedule(&host->finish_tasklet);
+
+        host->cmd = NULL;
+}
+
+static void sdhci_set_clock(struct sdhci_host *host, unsigned int clock)
+{
+        int div;
+        u16 clk;
+        unsigned long max_jiffies;
+
+        if (clock == host->clock)
+                return;
+
+        writew(0, host->ioaddr + SDHCI_CLOCK_CONTROL);
+
+        if (clock == 0)
+                goto out;
+
+        for (div = 1;div < 256;div *= 2) {
+                if ((host->max_clk / div) <= clock)
+                        break;
+        }
+        div >>= 1;
+
+        clk = div << SDHCI_DIVIDER_SHIFT;
+        clk |= SDHCI_CLOCK_INT_EN;
+        writew(clk, host->ioaddr + SDHCI_CLOCK_CONTROL);
+
+        /* Wait max 10 ms */
+        max_jiffies = jiffies + (HZ + 99)/100;
+        do {
+                if (time_after(jiffies, max_jiffies)) {
+                        printk(KERN_ERR "%s: Internal clock never stabilised. "
+                                "Please report this to " BUGMAIL ".\n",
+                                mmc_hostname(host->mmc));
+                        sdhci_dumpregs(host);
+                        return;
+                }
+                clk = readw(host->ioaddr + SDHCI_CLOCK_CONTROL);
+        } while (!(clk & SDHCI_CLOCK_INT_STABLE));
+
+        clk |= SDHCI_CLOCK_CARD_EN;
+        writew(clk, host->ioaddr + SDHCI_CLOCK_CONTROL);
+
+out:
+        host->clock = clock;
+}
+
+/*****************************************************************************\
+ *                                                                           *
+ * MMC callbacks                                                             *
+ *                                                                           *
+\*****************************************************************************/
+
+static void sdhci_request(struct mmc_host *mmc, struct mmc_request *mrq)
+{
+        struct sdhci_host *host;
+        unsigned long flags;
+
+        host = mmc_priv(mmc);
+
+        spin_lock_irqsave(&host->lock, flags);
+
+        WARN_ON(host->mrq != NULL);
+
+        sdhci_activate_led(host);
+
+        host->mrq = mrq;
+
+        if (!(readl(host->ioaddr + SDHCI_PRESENT_STATE) & SDHCI_CARD_PRESENT)) {
+                host->mrq->cmd->error = MMC_ERR_TIMEOUT;
+                tasklet_schedule(&host->finish_tasklet);
+        } else
+                sdhci_send_command(host, mrq->cmd);
+
+        spin_unlock_irqrestore(&host->lock, flags);
+}
+
+static void sdhci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
+{
+        struct sdhci_host *host;
+        unsigned long flags;
+        u8 ctrl;
+
+        host = mmc_priv(mmc);
+
+        spin_lock_irqsave(&host->lock, flags);
+
+        DBG("clock %uHz busmode %u powermode %u cs %u Vdd %u width %u\n",
+             ios->clock, ios->bus_mode, ios->power_mode, ios->chip_select,
+             ios->vdd, ios->bus_width);
+
+        /*
+         * Reset the chip on each power off.
+         * Should clear out any weird states.
+         */
+        if (ios->power_mode == MMC_POWER_OFF) {
+                writel(0, host->ioaddr + SDHCI_SIGNAL_ENABLE);
+                spin_unlock_irqrestore(&host->lock, flags);
+                sdhci_init(host);
+                spin_lock_irqsave(&host->lock, flags);
+        }
+
+        sdhci_set_clock(host, ios->clock);
+
+        if (ios->power_mode == MMC_POWER_OFF)
+                writeb(0, host->ioaddr + SDHCI_POWER_CONTROL);
+        else
+                writeb(0xFF, host->ioaddr + SDHCI_POWER_CONTROL);
+
+        ctrl = readb(host->ioaddr + SDHCI_HOST_CONTROL);
+        if (ios->bus_width == MMC_BUS_WIDTH_4)
+                ctrl |= SDHCI_CTRL_4BITBUS;
+        else
+                ctrl &= ~SDHCI_CTRL_4BITBUS;
+        writeb(ctrl, host->ioaddr + SDHCI_HOST_CONTROL);
+
+        spin_unlock_irqrestore(&host->lock, flags);
+}
+
+static int sdhci_get_ro(struct mmc_host *mmc)
+{
+        struct sdhci_host *host;
+        unsigned long flags;
+        int present;
+
+        host = mmc_priv(mmc);
+
+        spin_lock_irqsave(&host->lock, flags);
+
+        present = readl(host->ioaddr + SDHCI_PRESENT_STATE);
+
+        spin_unlock_irqrestore(&host->lock, flags);
+
+        return !(present & SDHCI_WRITE_PROTECT);
+}
+
+static struct mmc_host_ops sdhci_ops = {
+        .request        = sdhci_request,
+        .set_ios        = sdhci_set_ios,
+        .get_ro         = sdhci_get_ro,
+};
+
+/*****************************************************************************\
+ *                                                                           *
+ * Tasklets                                                                  *
+ *                                                                           *
+\*****************************************************************************/
+
+static void sdhci_tasklet_card(unsigned long param)
+{
+        struct sdhci_host *host;
+        unsigned long flags;
+
+        host = (struct sdhci_host*)param;
+
+        spin_lock_irqsave(&host->lock, flags);
+
+        if (!(readl(host->ioaddr + SDHCI_PRESENT_STATE) & SDHCI_CARD_PRESENT)) {
+                if (host->mrq) {
+                        printk(KERN_ERR "%s: Card removed during transfer!\n",
+                                mmc_hostname(host->mmc));
+                        printk(KERN_ERR "%s: Resetting controller.\n",
+                                mmc_hostname(host->mmc));
+
+                        sdhci_reset(host, SDHCI_RESET_CMD);
+                        sdhci_reset(host, SDHCI_RESET_DATA);
+
+                        host->mrq->cmd->error = MMC_ERR_FAILED;
+                        tasklet_schedule(&host->finish_tasklet);
+                }
+        }
+
+        spin_unlock_irqrestore(&host->lock, flags);
+
+        mmc_detect_change(host->mmc, msecs_to_jiffies(500));
+}
+
+static void sdhci_tasklet_finish(unsigned long param)
+{
+        struct sdhci_host *host;
+        unsigned long flags;
+        struct mmc_request *mrq;
+
+        host = (struct sdhci_host*)param;
+
+        spin_lock_irqsave(&host->lock, flags);
+
+        del_timer(&host->timer);
+
+        mrq = host->mrq;
+
+        DBG("Ending request, cmd (%x)\n", mrq->cmd->opcode);
+
+        /*
+         * The controller needs a reset of internal state machines
+         * upon error conditions.
+         */
+        if ((mrq->cmd->error != MMC_ERR_NONE) ||
+                (mrq->data && ((mrq->data->error != MMC_ERR_NONE) ||
+                (mrq->data->stop && (mrq->data->stop->error != MMC_ERR_NONE))))) {
+                sdhci_reset(host, SDHCI_RESET_CMD);
+                sdhci_reset(host, SDHCI_RESET_DATA);
+        }
+
+        host->mrq = NULL;
+        host->cmd = NULL;
+        host->data = NULL;
+
+        sdhci_deactivate_led(host);
+
+        spin_unlock_irqrestore(&host->lock, flags);
+
+        mmc_request_done(host->mmc, mrq);
+}
+
+static void sdhci_timeout_timer(unsigned long data)
+{
+        struct sdhci_host *host;
+        unsigned long flags;
+
+        host = (struct sdhci_host*)data;
+
+        spin_lock_irqsave(&host->lock, flags);
+
+        if (host->mrq) {
+                printk(KERN_ERR "%s: Timeout waiting for hardware interrupt. "
+                        "Please report this to " BUGMAIL ".\n",
+                        mmc_hostname(host->mmc));
+                sdhci_dumpregs(host);
+
+                if (host->data) {
+                        host->data->error = MMC_ERR_TIMEOUT;
+                        sdhci_finish_data(host);
+                } else {
+                        if (host->cmd)
+                                host->cmd->error = MMC_ERR_TIMEOUT;
+                        else
+                                host->mrq->cmd->error = MMC_ERR_TIMEOUT;
+
+                        tasklet_schedule(&host->finish_tasklet);
+                }
+        }
+
+        spin_unlock_irqrestore(&host->lock, flags);
+}
+
+/*****************************************************************************\
+ *                                                                           *
+ * Interrupt handling                                                        *
+ *                                                                           *
+\*****************************************************************************/
+
+static void sdhci_cmd_irq(struct sdhci_host *host, u32 intmask)
+{
+        BUG_ON(intmask == 0);
+
+        if (!host->cmd) {
+                printk(KERN_ERR "%s: Got command interrupt even though no "
+                        "command operation was in progress.\n",
+                        mmc_hostname(host->mmc));
+                printk(KERN_ERR "%s: Please report this to " BUGMAIL ".\n",
+                        mmc_hostname(host->mmc));
+                sdhci_dumpregs(host);
+                return;
+        }
+
+        if (intmask & SDHCI_INT_RESPONSE)
+                sdhci_finish_command(host);
+        else {
+                if (intmask & SDHCI_INT_TIMEOUT)
+                        host->cmd->error = MMC_ERR_TIMEOUT;
+                else if (intmask & SDHCI_INT_CRC)
+                        host->cmd->error = MMC_ERR_BADCRC;
+                else if (intmask & (SDHCI_INT_END_BIT | SDHCI_INT_INDEX))
+                        host->cmd->error = MMC_ERR_FAILED;
+                else
+                        host->cmd->error = MMC_ERR_INVALID;
+
+                tasklet_schedule(&host->finish_tasklet);
+        }
+}
+
+static void sdhci_data_irq(struct sdhci_host *host, u32 intmask)
+{
+        BUG_ON(intmask == 0);
+
+        if (!host->data) {
+                /*
+                 * A data end interrupt is sent together with the response
+                 * for the stop command.
+                 */
+                if (intmask & SDHCI_INT_DATA_END)
+                        return;
+
+                printk(KERN_ERR "%s: Got data interrupt even though no "
+                        "data operation was in progress.\n",
+                        mmc_hostname(host->mmc));
+                printk(KERN_ERR "%s: Please report this to " BUGMAIL ".\n",
+                        mmc_hostname(host->mmc));
+                sdhci_dumpregs(host);
+
+                return;
+        }
+
+        if (intmask & SDHCI_INT_DATA_TIMEOUT)
+                host->data->error = MMC_ERR_TIMEOUT;
+        else if (intmask & SDHCI_INT_DATA_CRC)
+                host->data->error = MMC_ERR_BADCRC;
+        else if (intmask & SDHCI_INT_DATA_END_BIT)
+                host->data->error = MMC_ERR_FAILED;
+
+        if (host->data->error != MMC_ERR_NONE)
+                sdhci_finish_data(host);
+        else {
+                if (intmask & (SDHCI_INT_BUF_FULL | SDHCI_INT_BUF_EMPTY))
+                        sdhci_transfer_pio(host);
+
+                if (intmask & SDHCI_INT_DATA_END)
+                        sdhci_finish_data(host);
+        }
+}
+
+static irqreturn_t sdhci_irq(int irq, void *dev_id, struct pt_regs *regs)
+{
+        irqreturn_t result;
+        struct sdhci_host* host = dev_id;
+        u32 intmask;
+
+        spin_lock(&host->lock);
+
+        intmask = readl(host->ioaddr + SDHCI_INT_STATUS);
+
+        if (!intmask) {
+                result = IRQ_NONE;
+                goto out;
+        }
+
+        DBG("*** %s got interrupt: 0x%08x\n", host->slot_descr, intmask);
+
+        if (intmask & (SDHCI_INT_CARD_INSERT | SDHCI_INT_CARD_REMOVE))
+                tasklet_schedule(&host->card_tasklet);
+
+        if (intmask & SDHCI_INT_CMD_MASK) {
+                sdhci_cmd_irq(host, intmask & SDHCI_INT_CMD_MASK);
+
+                writel(intmask & SDHCI_INT_CMD_MASK,
+                        host->ioaddr + SDHCI_INT_STATUS);
+        }
+
+        if (intmask & SDHCI_INT_DATA_MASK) {
+                sdhci_data_irq(host, intmask & SDHCI_INT_DATA_MASK);
+
+                writel(intmask & SDHCI_INT_DATA_MASK,
+                        host->ioaddr + SDHCI_INT_STATUS);
+        }
+
+        intmask &= ~(SDHCI_INT_CMD_MASK | SDHCI_INT_DATA_MASK);
+
+        if (intmask & SDHCI_INT_CARD_INT) {
+                printk(KERN_ERR "%s: Unexpected card interrupt. Please "
+                        "report this to " BUGMAIL ".\n",
+                        mmc_hostname(host->mmc));
+                sdhci_dumpregs(host);
+        }
+
+        if (intmask & SDHCI_INT_BUS_POWER) {
+                printk(KERN_ERR "%s: Unexpected bus power interrupt. Please "
+                        "report this to " BUGMAIL ".\n",
+                        mmc_hostname(host->mmc));
+                sdhci_dumpregs(host);
+        }
+
+        if (intmask & SDHCI_INT_ACMD12ERR) {
+                printk(KERN_ERR "%s: Unexpected auto CMD12 error. Please "
+                        "report this to " BUGMAIL ".\n",
+                        mmc_hostname(host->mmc));
+                sdhci_dumpregs(host);
+
+                writew(~0, host->ioaddr + SDHCI_ACMD12_ERR);
+        }
+
+        if (intmask)
+                writel(intmask, host->ioaddr + SDHCI_INT_STATUS);
+
+        result = IRQ_HANDLED;
+
+out:
+        spin_unlock(&host->lock);
+
+        return result;
+}
+
+/*****************************************************************************\
+ *                                                                           *
+ * Suspend/resume                                                            *
+ *                                                                           *
+\*****************************************************************************/
+
+#ifdef CONFIG_PM
+
+static int sdhci_suspend (struct pci_dev *pdev, pm_message_t state)
+{
+        struct sdhci_chip *chip;
+        int i, ret;
+
+        chip = pci_get_drvdata(pdev);
+        if (!chip)
+                return 0;
+
+        DBG("Suspending...\n");
+
+        for (i = 0;i < chip->num_slots;i++) {
+                if (!chip->hosts[i])
+                        continue;
+                ret = mmc_suspend_host(chip->hosts[i]->mmc, state);
+                if (ret) {
+                        for (i--;i >= 0;i--)
+                                mmc_resume_host(chip->hosts[i]->mmc);
+                        return ret;
+                }
+        }
+
+        pci_save_state(pdev);
+        pci_enable_wake(pdev, pci_choose_state(pdev, state), 0);
+        pci_disable_device(pdev);
+        pci_set_power_state(pdev, pci_choose_state(pdev, state));
+
+        return 0;
+}
+
+static int sdhci_resume (struct pci_dev *pdev)
+{
+        struct sdhci_chip *chip;
+        int i, ret;
+
+        chip = pci_get_drvdata(pdev);
+        if (!chip)
+                return 0;
+
+        DBG("Resuming...\n");
+
+        pci_set_power_state(pdev, PCI_D0);
+        pci_restore_state(pdev);
+        pci_enable_device(pdev);
+
+        for (i = 0;i < chip->num_slots;i++) {
+                if (!chip->hosts[i])
+                        continue;
+                if (chip->hosts[i]->flags & SDHCI_USE_DMA)
+                        pci_set_master(pdev);
+                sdhci_init(chip->hosts[i]);
+                ret = mmc_resume_host(chip->hosts[i]->mmc);
+                if (ret)
+                        return ret;
+        }
+
+        return 0;
+}
+
+#else /* CONFIG_PM */
+
+#define sdhci_suspend NULL
+#define sdhci_resume NULL
+
+#endif /* CONFIG_PM */
+
+/*****************************************************************************\
+ *                                                                           *
+ * Device probing/removal                                                    *
+ *                                                                           *
+\*****************************************************************************/
+
+static int __devinit sdhci_probe_slot(struct pci_dev *pdev, int slot)
+{
+        int ret;
+        struct sdhci_chip *chip;
+        struct mmc_host *mmc;
+        struct sdhci_host *host;
+
+        u8 first_bar;
+        unsigned int caps;
+
+        chip = pci_get_drvdata(pdev);
+        BUG_ON(!chip);
+
+        ret = pci_read_config_byte(pdev, PCI_SLOT_INFO, &first_bar);
+        if (ret)
+                return ret;
+
+        first_bar &= PCI_SLOT_INFO_FIRST_BAR_MASK;
+
+        if (first_bar > 5) {
+                printk(KERN_ERR DRIVER_NAME ": Invalid first BAR. Aborting.\n");
+                return -ENODEV;
+        }
+
+        if (!(pci_resource_flags(pdev, first_bar + slot) & IORESOURCE_MEM)) {
+                printk(KERN_ERR DRIVER_NAME ": BAR is not iomem. Aborting.\n");
+                return -ENODEV;
+        }
+
+        if (pci_resource_len(pdev, first_bar + slot) != 0x100) {
+                printk(KERN_ERR DRIVER_NAME ": Invalid iomem size. Aborting.\n");
+                return -ENODEV;
+        }
+
+        mmc = mmc_alloc_host(sizeof(struct sdhci_host), &pdev->dev);
+        if (!mmc)
+                return -ENOMEM;
+
+        host = mmc_priv(mmc);
+        host->mmc = mmc;
+
+        host->bar = first_bar + slot;
+
+        host->addr = pci_resource_start(pdev, host->bar);
+        host->irq = pdev->irq;
+
+        DBG("slot %d at 0x%08lx, irq %d\n", slot, host->addr, host->irq);
+
+        snprintf(host->slot_descr, 20, "sdhci:slot%d", slot);
+
+        ret = pci_request_region(pdev, host->bar, host->slot_descr);
+        if (ret)
+                goto free;
+
+        host->ioaddr = ioremap_nocache(host->addr,
+                pci_resource_len(pdev, host->bar));
+        if (!host->ioaddr) {
+                ret = -ENOMEM;
+                goto release;
+        }
+
+        caps = readl(host->ioaddr + SDHCI_CAPABILITIES);
+
+        if ((caps & SDHCI_CAN_DO_DMA) && ((pdev->class & 0x0000FF) == 0x01))
+                host->flags |= SDHCI_USE_DMA;
+
+        if (host->flags & SDHCI_USE_DMA) {
+                if (pci_set_dma_mask(pdev, DMA_32BIT_MASK)) {
+                        printk(KERN_WARNING "%s: No suitable DMA available. "
+                                "Falling back to PIO.\n", host->slot_descr);
+                        host->flags &= ~SDHCI_USE_DMA;
+                }
+        }
+
+        if (host->flags & SDHCI_USE_DMA)
+                pci_set_master(pdev);
+        else /* XXX: Hack to get MMC layer to avoid highmem */
+                pdev->dma_mask = 0;
+
+        host->max_clk = (caps & SDHCI_CLOCK_BASE_MASK) >> SDHCI_CLOCK_BASE_SHIFT;
+        host->max_clk *= 1000000;
+
+        /*
+         * Set host parameters.
+         */
+        mmc->ops = &sdhci_ops;
+        mmc->f_min = host->max_clk / 256;
+        mmc->f_max = host->max_clk;
+        mmc->ocr_avail = MMC_VDD_32_33|MMC_VDD_33_34;
+        mmc->caps = MMC_CAP_4_BIT_DATA;
+
+        spin_lock_init(&host->lock);
+
+        /*
+         * Maximum number of segments. Hardware cannot do scatter lists.
+         */
+        if (host->flags & SDHCI_USE_DMA)
+                mmc->max_hw_segs = 1;
+        else
+                mmc->max_hw_segs = 16;
+        mmc->max_phys_segs = 16;
+
+        /*
+         * Maximum number of sectors in one transfer. Limited by sector
+         * count register.
+         */
+        mmc->max_sectors = 0x3FFF;
+
+        /*
+         * Maximum segment size. Could be one segment with the maximum number
+         * of sectors.
+         */
+        mmc->max_seg_size = mmc->max_sectors * 512;
+
+        /*
+         * Init tasklets.
+         */
+        tasklet_init(&host->card_tasklet,
+                sdhci_tasklet_card, (unsigned long)host);
+        tasklet_init(&host->finish_tasklet,
+                sdhci_tasklet_finish, (unsigned long)host);
+
+        setup_timer(&host->timer, sdhci_timeout_timer, (int)host);
+
+        ret = request_irq(host->irq, sdhci_irq, SA_SHIRQ,
+                host->slot_descr, host);
+        if (ret)
+                goto unmap;
+
+        sdhci_init(host);
+
+#ifdef CONFIG_MMC_DEBUG
+        sdhci_dumpregs(host);
+#endif
+
+        host->chip = chip;
+        chip->hosts[slot] = host;
+
+        mmc_add_host(mmc);
+
+        printk(KERN_INFO "%s: SDHCI at 0x%08lx irq %d %s\n", mmc_hostname(mmc),
+                host->addr, host->irq,
+                (host->flags & SDHCI_USE_DMA)?"DMA":"PIO");
+
+        return 0;
+
+unmap:
+        tasklet_kill(&host->card_tasklet);
+        tasklet_kill(&host->finish_tasklet);
+
+        iounmap(host->ioaddr);
+release:
+        pci_release_region(pdev, host->bar);
+free:
+        mmc_free_host(mmc);
+
+        return ret;
+}
+
+static void sdhci_remove_slot(struct pci_dev *pdev, int slot)
+{
+        struct sdhci_chip *chip;
+        struct mmc_host *mmc;
+        struct sdhci_host *host;
+
+        chip = pci_get_drvdata(pdev);
+        host = chip->hosts[slot];
+        mmc = host->mmc;
+
+        chip->hosts[slot] = NULL;
+
+        mmc_remove_host(mmc);
+
+        sdhci_reset(host, SDHCI_RESET_ALL);
+
+        free_irq(host->irq, host);
+
+        del_timer_sync(&host->timer);
+
+        tasklet_kill(&host->card_tasklet);
+        tasklet_kill(&host->finish_tasklet);
+
+        iounmap(host->ioaddr);
+
+        pci_release_region(pdev, host->bar);
+
+        mmc_free_host(mmc);
+}
+
+static int __devinit sdhci_probe(struct pci_dev *pdev,
+        const struct pci_device_id *ent)
+{
+        int ret, i;
+        u8 slots;
+        struct sdhci_chip *chip;
+
+        BUG_ON(pdev == NULL);
+        BUG_ON(ent == NULL);
+
+        DBG("found at %s\n", pci_name(pdev));
+
+        ret = pci_read_config_byte(pdev, PCI_SLOT_INFO, &slots);
+        if (ret)
+                return ret;
+
+        slots = PCI_SLOT_INFO_SLOTS(slots) + 1;
+        DBG("found %d slot(s)\n", slots);
+        if (slots == 0)
+                return -ENODEV;
+
+        ret = pci_enable_device(pdev);
+        if (ret)
+                return ret;
+
+        chip = kzalloc(sizeof(struct sdhci_chip) +
+                sizeof(struct sdhci_host*) * slots, GFP_KERNEL);
+        if (!chip) {
+                ret = -ENOMEM;
+                goto err;
+        }
+
+        chip->pdev = pdev;
+
+        chip->num_slots = slots;
+        pci_set_drvdata(pdev, chip);
+
+        for (i = 0;i < slots;i++) {
+                ret = sdhci_probe_slot(pdev, i);
+                if (ret) {
+                        for (i--;i >= 0;i--)
+                                sdhci_remove_slot(pdev, i);
+                        goto free;
+                }
+        }
+
+        return 0;
+
+free:
+        pci_set_drvdata(pdev, NULL);
+        kfree(chip);
+
+err:
+        pci_disable_device(pdev);
+        return ret;
+}
+
+static void __devexit sdhci_remove(struct pci_dev *pdev)
+{
+        int i;
+        struct sdhci_chip *chip;
+
+        chip = pci_get_drvdata(pdev);
+
+        if (chip) {
+                for (i = 0;i < chip->num_slots;i++)
+                        sdhci_remove_slot(pdev, i);
+
+                pci_set_drvdata(pdev, NULL);
+
+                kfree(chip);
+        }
+
+        pci_disable_device(pdev);
+}
+
+static struct pci_driver sdhci_driver = {
+        .name =         DRIVER_NAME,
+        .id_table =     pci_ids,
+        .probe =        sdhci_probe,
+        .remove =       __devexit_p(sdhci_remove),
+        .suspend =      sdhci_suspend,
+        .resume =       sdhci_resume,
+};
+
+/*****************************************************************************\
+ *                                                                           *
+ * Driver init/exit                                                          *
+ *                                                                           *
+\*****************************************************************************/
+
+static int __init sdhci_drv_init(void)
+{
+        printk(KERN_INFO DRIVER_NAME
+                ": Secure Digital Host Controller Interface driver, "
+                DRIVER_VERSION "\n");
+        printk(KERN_INFO DRIVER_NAME ": Copyright(c) Pierre Ossman\n");
+
+        return pci_register_driver(&sdhci_driver);
+}
+
+static void __exit sdhci_drv_exit(void)
+{
+        DBG("Exiting\n");
+
+        pci_unregister_driver(&sdhci_driver);
+}
+
+module_init(sdhci_drv_init);
+module_exit(sdhci_drv_exit);
+
+MODULE_AUTHOR("Pierre Ossman <drzeus@drzeus.cx>");
+MODULE_DESCRIPTION("Secure Digital Host Controller Interface driver");
+MODULE_VERSION(DRIVER_VERSION);
+MODULE_LICENSE("GPL");
diff --git a/drivers/mmc/sdhci.h b/drivers/mmc/sdhci.h
new file mode 100644
index 0000000000..3b270ef486
--- /dev/null
+++ b/drivers/mmc/sdhci.h
@@ -0,0 +1,185 @@
+/*
+ *  linux/drivers/mmc/sdhci.h - Secure Digital Host Controller Interface driver
+ *
+ *  Copyright (C) 2005 Pierre Ossman, All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+/*
+ * PCI registers
+ */
+
+#define PCI_SLOT_INFO                   0x40    /* 8 bits */
+#define  PCI_SLOT_INFO_SLOTS(x)         ((x >> 4) & 7)
+#define  PCI_SLOT_INFO_FIRST_BAR_MASK   0x07
+
+/*
+ * Controller registers
+ */
+
+#define SDHCI_DMA_ADDRESS       0x00
+
+#define SDHCI_BLOCK_SIZE        0x04
+
+#define SDHCI_BLOCK_COUNT       0x06
+
+#define SDHCI_ARGUMENT          0x08
+
+#define SDHCI_TRANSFER_MODE     0x0C
+#define  SDHCI_TRNS_DMA         0x01
+#define  SDHCI_TRNS_BLK_CNT_EN  0x02
+#define  SDHCI_TRNS_ACMD12      0x04
+#define  SDHCI_TRNS_READ        0x10
+#define  SDHCI_TRNS_MULTI       0x20
+
+#define SDHCI_COMMAND           0x0E
+#define  SDHCI_CMD_RESP_MASK    0x03
+#define  SDHCI_CMD_CRC          0x08
+#define  SDHCI_CMD_INDEX        0x10
+#define  SDHCI_CMD_DATA         0x20
+
+#define  SDHCI_CMD_RESP_NONE    0x00
+#define  SDHCI_CMD_RESP_LONG    0x01
+#define  SDHCI_CMD_RESP_SHORT   0x02
+#define  SDHCI_CMD_RESP_SHORT_BUSY 0x03
+
+#define SDHCI_MAKE_CMD(c, f) (((c & 0xff) << 8) | (f & 0xff))
+
+#define SDHCI_RESPONSE          0x10
+
+#define SDHCI_BUFFER            0x20
+
+#define SDHCI_PRESENT_STATE     0x24
+#define  SDHCI_CMD_INHIBIT      0x00000001
+#define  SDHCI_DATA_INHIBIT     0x00000002
+#define  SDHCI_DOING_WRITE      0x00000100
+#define  SDHCI_DOING_READ       0x00000200
+#define  SDHCI_SPACE_AVAILABLE  0x00000400
+#define  SDHCI_DATA_AVAILABLE   0x00000800
+#define  SDHCI_CARD_PRESENT     0x00010000
+#define  SDHCI_WRITE_PROTECT    0x00080000
+
+#define SDHCI_HOST_CONTROL      0x28
+#define  SDHCI_CTRL_LED         0x01
+#define  SDHCI_CTRL_4BITBUS     0x02
+
+#define SDHCI_POWER_CONTROL     0x29
+
+#define SDHCI_BLOCK_GAP_CONTROL 0x2A
+
+#define SDHCI_WALK_UP_CONTROL   0x2B
+
+#define SDHCI_CLOCK_CONTROL     0x2C
+#define  SDHCI_DIVIDER_SHIFT    8
+#define  SDHCI_CLOCK_CARD_EN    0x0004
+#define  SDHCI_CLOCK_INT_STABLE 0x0002
+#define  SDHCI_CLOCK_INT_EN     0x0001
+
+#define SDHCI_TIMEOUT_CONTROL   0x2E
+
+#define SDHCI_SOFTWARE_RESET    0x2F
+#define  SDHCI_RESET_ALL        0x01
+#define  SDHCI_RESET_CMD        0x02
+#define  SDHCI_RESET_DATA       0x04
+
+#define SDHCI_INT_STATUS        0x30
+#define SDHCI_INT_ENABLE        0x34
+#define SDHCI_SIGNAL_ENABLE     0x38
+#define  SDHCI_INT_RESPONSE     0x00000001
+#define  SDHCI_INT_DATA_END     0x00000002
+#define  SDHCI_INT_DMA_END      0x00000008
+#define  SDHCI_INT_BUF_EMPTY    0x00000010
+#define  SDHCI_INT_BUF_FULL     0x00000020
+#define  SDHCI_INT_CARD_INSERT  0x00000040
+#define  SDHCI_INT_CARD_REMOVE  0x00000080
+#define  SDHCI_INT_CARD_INT     0x00000100
+#define  SDHCI_INT_TIMEOUT      0x00010000
+#define  SDHCI_INT_CRC          0x00020000
+#define  SDHCI_INT_END_BIT      0x00040000
+#define  SDHCI_INT_INDEX        0x00080000
+#define  SDHCI_INT_DATA_TIMEOUT 0x00100000
+#define  SDHCI_INT_DATA_CRC     0x00200000
+#define  SDHCI_INT_DATA_END_BIT 0x00400000
+#define  SDHCI_INT_BUS_POWER    0x00800000
+#define  SDHCI_INT_ACMD12ERR    0x01000000
+
+#define  SDHCI_INT_NORMAL_MASK  0x00007FFF
+#define  SDHCI_INT_ERROR_MASK   0xFFFF8000
+
+#define  SDHCI_INT_CMD_MASK     (SDHCI_INT_RESPONSE | SDHCI_INT_TIMEOUT | \
+                SDHCI_INT_CRC | SDHCI_INT_END_BIT | SDHCI_INT_INDEX)
+#define  SDHCI_INT_DATA_MASK    (SDHCI_INT_DATA_END | SDHCI_INT_DMA_END | \
+                SDHCI_INT_BUF_EMPTY | SDHCI_INT_BUF_FULL | \
+                SDHCI_INT_DATA_TIMEOUT | SDHCI_INT_DATA_CRC | \
+                SDHCI_INT_DATA_END_BIT)
+
+#define SDHCI_ACMD12_ERR        0x3C
+
+/* 3E-3F reserved */
+
+#define SDHCI_CAPABILITIES      0x40
+#define  SDHCI_CAN_DO_DMA       0x00400000
+#define  SDHCI_CLOCK_BASE_MASK  0x00003F00
+#define  SDHCI_CLOCK_BASE_SHIFT 8
+
+/* 44-47 reserved for more caps */
+
+#define SDHCI_MAX_CURRENT       0x48
+
+/* 4C-4F reserved for more max current */
+
+/* 50-FB reserved */
+
+#define SDHCI_SLOT_INT_STATUS   0xFC
+
+#define SDHCI_HOST_VERSION      0xFE
+
+struct sdhci_chip;
+
+struct sdhci_host {
+        struct sdhci_chip       *chip;
+        struct mmc_host         *mmc;           /* MMC structure */
+
+        spinlock_t              lock;           /* Mutex */
+
+        int                     flags;          /* Host attributes */
+#define SDHCI_USE_DMA           (1<<0)
+
+        unsigned int            max_clk;        /* Max possible freq (MHz) */
+
+        unsigned int            clock;          /* Current clock (MHz) */
+
+        struct mmc_request      *mrq;           /* Current request */
+        struct mmc_command      *cmd;           /* Current command */
+        struct mmc_data         *data;          /* Current data request */
+
+        struct scatterlist      *cur_sg;        /* We're working on this */
+        char                    *mapped_sg;     /* This is where it's mapped */
+        int                     num_sg;         /* Entries left */
+        int                     offset;         /* Offset into current sg */
+        int                     remain;         /* Bytes left in current */
+
+        int                     size;           /* Remaining bytes in transfer */
+
+        char                    slot_descr[20]; /* Name for reservations */
+
+        int                     irq;            /* Device IRQ */
+        int                     bar;            /* PCI BAR index */
+        unsigned long           addr;           /* Bus address */
+        void __iomem *          ioaddr;         /* Mapped address */
+
+        struct tasklet_struct   card_tasklet;   /* Tasklet structures */
+        struct tasklet_struct   finish_tasklet;
+
+        struct timer_list       timer;          /* Timer for timeouts */
+};
+
+struct sdhci_chip {
+        struct pci_dev          *pdev;
+
+        int                     num_slots;      /* Slots on controller */
+        struct sdhci_host       *hosts[0];      /* Pointers to hosts */
+};
diff --git a/drivers/net/8139too.c b/drivers/net/8139too.c
index f5ee064ab6..feae7832fc 100644
--- a/drivers/net/8139too.c
+++ b/drivers/net/8139too.c
@@ -1131,7 +1131,7 @@ static void __devexit rtl8139_remove_one (struct pci_dev *pdev)
    No extra delay is needed with 33Mhz PCI, but 66Mhz may change this.
  */
 
-#define eeprom_delay()  RTL_R32(Cfg9346)
+#define eeprom_delay()  (void)RTL_R32(Cfg9346)
 
 /* The EEPROM commands include the alway-set leading bit. */
 #define EE_WRITE_CMD    (5)
diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
index 00993e8ba5..e20b849a22 100644
--- a/drivers/net/Kconfig
+++ b/drivers/net/Kconfig
@@ -2172,6 +2172,7 @@ config BNX2
 config SPIDER_NET
         tristate "Spider Gigabit Ethernet driver"
         depends on PCI && PPC_CELL
+        select FW_LOADER
         help
           This driver supports the Gigabit Ethernet chips present on the
           Cell Processor-Based Blades from IBM.
diff --git a/drivers/net/bnx2.c b/drivers/net/bnx2.c
index 7d21370700..2671da20a4 100644
--- a/drivers/net/bnx2.c
+++ b/drivers/net/bnx2.c
@@ -9,13 +9,54 @@
  * Written by: Michael Chan  (mchan@broadcom.com)
  */
 
+#include <linux/config.h>
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+
+#include <linux/kernel.h>
+#include <linux/timer.h>
+#include <linux/errno.h>
+#include <linux/ioport.h>
+#include <linux/slab.h>
+#include <linux/vmalloc.h>
+#include <linux/interrupt.h>
+#include <linux/pci.h>
+#include <linux/init.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/skbuff.h>
+#include <linux/dma-mapping.h>
+#include <asm/bitops.h>
+#include <asm/io.h>
+#include <asm/irq.h>
+#include <linux/delay.h>
+#include <asm/byteorder.h>
+#include <linux/time.h>
+#include <linux/ethtool.h>
+#include <linux/mii.h>
+#ifdef NETIF_F_HW_VLAN_TX
+#include <linux/if_vlan.h>
+#define BCM_VLAN 1
+#endif
+#ifdef NETIF_F_TSO
+#include <net/ip.h>
+#include <net/tcp.h>
+#include <net/checksum.h>
+#define BCM_TSO 1
+#endif
+#include <linux/workqueue.h>
+#include <linux/crc32.h>
+#include <linux/prefetch.h>
+#include <linux/cache.h>
+
 #include "bnx2.h"
 #include "bnx2_fw.h"
 
 #define DRV_MODULE_NAME         "bnx2"
 #define PFX DRV_MODULE_NAME     ": "
-#define DRV_MODULE_VERSION      "1.4.38"
-#define DRV_MODULE_RELDATE      "February 10, 2006"
+#define DRV_MODULE_VERSION      "1.4.39"
+#define DRV_MODULE_RELDATE      "March 22, 2006"
 
 #define RUN_AT(x) (jiffies + (x))
 
@@ -313,8 +354,6 @@ bnx2_disable_int(struct bnx2 *bp)
 static void
 bnx2_enable_int(struct bnx2 *bp)
 {
-        u32 val;
-
         REG_WR(bp, BNX2_PCICFG_INT_ACK_CMD,
                BNX2_PCICFG_INT_ACK_CMD_INDEX_VALID |
                BNX2_PCICFG_INT_ACK_CMD_MASK_INT | bp->last_status_idx);
@@ -322,8 +361,7 @@ bnx2_enable_int(struct bnx2 *bp)
         REG_WR(bp, BNX2_PCICFG_INT_ACK_CMD,
                BNX2_PCICFG_INT_ACK_CMD_INDEX_VALID | bp->last_status_idx);
 
-        val = REG_RD(bp, BNX2_HC_COMMAND);
-        REG_WR(bp, BNX2_HC_COMMAND, val | BNX2_HC_COMMAND_COAL_NOW);
+        REG_WR(bp, BNX2_HC_COMMAND, bp->hc_cmd | BNX2_HC_COMMAND_COAL_NOW);
 }
 
 static void
@@ -362,15 +400,11 @@ bnx2_free_mem(struct bnx2 *bp)
 {
         int i;
 
-        if (bp->stats_blk) {
-                pci_free_consistent(bp->pdev, sizeof(struct statistics_block),
-                                    bp->stats_blk, bp->stats_blk_mapping);
-                bp->stats_blk = NULL;
-        }
         if (bp->status_blk) {
-                pci_free_consistent(bp->pdev, sizeof(struct status_block),
+                pci_free_consistent(bp->pdev, bp->status_stats_size,
                                     bp->status_blk, bp->status_blk_mapping);
                 bp->status_blk = NULL;
+                bp->stats_blk = NULL;
         }
         if (bp->tx_desc_ring) {
                 pci_free_consistent(bp->pdev,
@@ -395,14 +429,13 @@ bnx2_free_mem(struct bnx2 *bp)
 static int
 bnx2_alloc_mem(struct bnx2 *bp)
 {
-        int i;
+        int i, status_blk_size;
 
-        bp->tx_buf_ring = kmalloc(sizeof(struct sw_bd) * TX_DESC_CNT,
-                                     GFP_KERNEL);
+        bp->tx_buf_ring = kzalloc(sizeof(struct sw_bd) * TX_DESC_CNT,
+                                  GFP_KERNEL);
         if (bp->tx_buf_ring == NULL)
                 return -ENOMEM;
 
-        memset(bp->tx_buf_ring, 0, sizeof(struct sw_bd) * TX_DESC_CNT);
         bp->tx_desc_ring = pci_alloc_consistent(bp->pdev,
                                                 sizeof(struct tx_bd) *
                                                 TX_DESC_CNT,
@@ -428,21 +461,22 @@ bnx2_alloc_mem(struct bnx2 *bp)
 
         }
 
-        bp->status_blk = pci_alloc_consistent(bp->pdev,
-                                              sizeof(struct status_block),
+        /* Combine status and statistics blocks into one allocation. */
+        status_blk_size = L1_CACHE_ALIGN(sizeof(struct status_block));
+        bp->status_stats_size = status_blk_size +
+                                sizeof(struct statistics_block);
+
+        bp->status_blk = pci_alloc_consistent(bp->pdev, bp->status_stats_size,
                                               &bp->status_blk_mapping);
         if (bp->status_blk == NULL)
                 goto alloc_mem_err;
 
-        memset(bp->status_blk, 0, sizeof(struct status_block));
+        memset(bp->status_blk, 0, bp->status_stats_size);
 
-        bp->stats_blk = pci_alloc_consistent(bp->pdev,
-                                             sizeof(struct statistics_block),
-                                             &bp->stats_blk_mapping);
-        if (bp->stats_blk == NULL)
-                goto alloc_mem_err;
+        bp->stats_blk = (void *) ((unsigned long) bp->status_blk +
+                                  status_blk_size);
 
-        memset(bp->stats_blk, 0, sizeof(struct statistics_block));
+        bp->stats_blk_mapping = bp->status_blk_mapping + status_blk_size;
 
         return 0;
 
@@ -1926,6 +1960,13 @@ bnx2_poll(struct net_device *dev, int *budget)
                 spin_lock(&bp->phy_lock);
                 bnx2_phy_int(bp);
                 spin_unlock(&bp->phy_lock);
+
+                /* This is needed to take care of transient status
+                 * during link changes.
+                 */
+                REG_WR(bp, BNX2_HC_COMMAND,
+                       bp->hc_cmd | BNX2_HC_COMMAND_COAL_NOW_WO_INT);
+                REG_RD(bp, BNX2_HC_COMMAND);
         }
 
         if (bp->status_blk->status_tx_quick_consumer_index0 != bp->hw_tx_cons)
@@ -3307,6 +3348,8 @@ bnx2_init_chip(struct bnx2 *bp)
 
         udelay(20);
 
+        bp->hc_cmd = REG_RD(bp, BNX2_HC_COMMAND);
+
         return rc;
 }
 
@@ -3746,7 +3789,6 @@ bnx2_run_loopback(struct bnx2 *bp, int loopback_mode)
         struct sk_buff *skb, *rx_skb;
         unsigned char *packet;
         u16 rx_start_idx, rx_idx;
-        u32 val;
         dma_addr_t map;
         struct tx_bd *txbd;
         struct sw_bd *rx_buf;
@@ -3777,8 +3819,9 @@ bnx2_run_loopback(struct bnx2 *bp, int loopback_mode)
         map = pci_map_single(bp->pdev, skb->data, pkt_size,
                 PCI_DMA_TODEVICE);
 
-        val = REG_RD(bp, BNX2_HC_COMMAND);
-        REG_WR(bp, BNX2_HC_COMMAND, val | BNX2_HC_COMMAND_COAL_NOW_WO_INT);
+        REG_WR(bp, BNX2_HC_COMMAND,
+               bp->hc_cmd | BNX2_HC_COMMAND_COAL_NOW_WO_INT);
+
         REG_RD(bp, BNX2_HC_COMMAND);
 
         udelay(5);
@@ -3802,8 +3845,9 @@ bnx2_run_loopback(struct bnx2 *bp, int loopback_mode)
 
         udelay(100);
 
-        val = REG_RD(bp, BNX2_HC_COMMAND);
-        REG_WR(bp, BNX2_HC_COMMAND, val | BNX2_HC_COMMAND_COAL_NOW_WO_INT);
+        REG_WR(bp, BNX2_HC_COMMAND,
+               bp->hc_cmd | BNX2_HC_COMMAND_COAL_NOW_WO_INT);
+
         REG_RD(bp, BNX2_HC_COMMAND);
 
         udelay(5);
@@ -3939,7 +3983,6 @@ static int
 bnx2_test_intr(struct bnx2 *bp)
 {
         int i;
-        u32 val;
         u16 status_idx;
 
         if (!netif_running(bp->dev))
@@ -3948,8 +3991,7 @@ bnx2_test_intr(struct bnx2 *bp)
         status_idx = REG_RD(bp, BNX2_PCICFG_INT_ACK_CMD) & 0xffff;
 
         /* This register is not touched during run-time. */
-        val = REG_RD(bp, BNX2_HC_COMMAND);
-        REG_WR(bp, BNX2_HC_COMMAND, val | BNX2_HC_COMMAND_COAL_NOW);
+        REG_WR(bp, BNX2_HC_COMMAND, bp->hc_cmd | BNX2_HC_COMMAND_COAL_NOW);
         REG_RD(bp, BNX2_HC_COMMAND);
 
         for (i = 0; i < 10; i++) {
diff --git a/drivers/net/bnx2.h b/drivers/net/bnx2.h
index fd4b7f2eb4..b87925f6a2 100644
--- a/drivers/net/bnx2.h
+++ b/drivers/net/bnx2.h
@@ -13,46 +13,6 @@
 #ifndef BNX2_H
 #define BNX2_H
 
-#include <linux/config.h>
-
-#include <linux/module.h>
-#include <linux/moduleparam.h>
-
-#include <linux/kernel.h>
-#include <linux/timer.h>
-#include <linux/errno.h>
-#include <linux/ioport.h>
-#include <linux/slab.h>
-#include <linux/vmalloc.h>
-#include <linux/interrupt.h>
-#include <linux/pci.h>
-#include <linux/init.h>
-#include <linux/netdevice.h>
-#include <linux/etherdevice.h>
-#include <linux/skbuff.h>
-#include <linux/dma-mapping.h>
-#include <asm/bitops.h>
-#include <asm/io.h>
-#include <asm/irq.h>
-#include <linux/delay.h>
-#include <asm/byteorder.h>
-#include <linux/time.h>
-#include <linux/ethtool.h>
-#include <linux/mii.h>
-#ifdef NETIF_F_HW_VLAN_TX
-#include <linux/if_vlan.h>
-#define BCM_VLAN 1
-#endif
-#ifdef NETIF_F_TSO
-#include <net/ip.h>
-#include <net/tcp.h>
-#include <net/checksum.h>
-#define BCM_TSO 1
-#endif
-#include <linux/workqueue.h>
-#include <linux/crc32.h>
-#include <linux/prefetch.h>
-
 /* Hardware data structures and register definitions automatically
  * generated from RTL code. Do not modify.
  */
@@ -3917,15 +3877,17 @@ struct bnx2 {
 #define USING_MSI_FLAG                  0x20
 #define ASF_ENABLE_FLAG                 0x40
 
-        struct tx_bd            *tx_desc_ring;
-        struct sw_bd            *tx_buf_ring;
-        u32                     tx_prod_bseq;
-        u16                     tx_prod;
-        u16                     tx_cons;
-        int                     tx_ring_size;
+        /* Put tx producer and consumer fields in separate cache lines. */
 
-        u16                     hw_tx_cons;
-        u16                     hw_rx_cons;
+        u32             tx_prod_bseq __attribute__((aligned(L1_CACHE_BYTES)));
+        u16             tx_prod;
+
+        struct tx_bd    *tx_desc_ring;
+        struct sw_bd    *tx_buf_ring;
+        int             tx_ring_size;
+
+        u16             tx_cons __attribute__((aligned(L1_CACHE_BYTES)));
+        u16             hw_tx_cons;
 
 #ifdef BCM_VLAN 
         struct                  vlan_group *vlgrp;
@@ -3939,6 +3901,7 @@ struct bnx2 {
         u32                     rx_prod_bseq;
         u16                     rx_prod;
         u16                     rx_cons;
+        u16                     hw_rx_cons;
 
         u32                     rx_csum;
 
@@ -4038,6 +4001,7 @@ struct bnx2 {
         struct statistics_block *stats_blk;
         dma_addr_t              stats_blk_mapping;
 
+        u32                     hc_cmd;
         u32                     rx_mode;
 
         u16                     req_line_speed;
@@ -4082,6 +4046,8 @@ struct bnx2 {
 
         struct flash_spec       *flash_info;
         u32                     flash_size;
+
+        int                     status_stats_size;
 };
 
 static u32 bnx2_reg_rd_ind(struct bnx2 *bp, u32 offset);
diff --git a/drivers/net/hp-plus.c b/drivers/net/hp-plus.c
index 74e167e7de..0d7a6250e3 100644
--- a/drivers/net/hp-plus.c
+++ b/drivers/net/hp-plus.c
@@ -250,6 +250,12 @@ static int __init hpp_probe1(struct net_device *dev, int ioaddr)
                 ei_status.block_output = &hpp_mem_block_output;
                 ei_status.get_8390_hdr = &hpp_mem_get_8390_hdr;
                 dev->mem_start = mem_start;
+                ei_status.mem = ioremap(mem_start,
+                                        (HP_STOP_PG - HP_START_PG)*256);
+                if (!ei_status.mem) {
+                        retval = -ENOMEM;
+                        goto out;
+                }
                 ei_status.rmem_start = dev->mem_start + TX_PAGES/2*256;
                 dev->mem_end = ei_status.rmem_end
                         = dev->mem_start + (HP_STOP_PG - HP_START_PG)*256;
@@ -262,8 +268,10 @@ static int __init hpp_probe1(struct net_device *dev, int ioaddr)
 
         retval = register_netdev(dev);
         if (retval)
-                goto out;
+                goto out1;
         return 0;
+out1:
+        iounmap(ei_status.mem);
 out:
         release_region(ioaddr, HP_IO_EXTENT);
         return retval;
@@ -372,7 +380,7 @@ hpp_mem_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring
 
         outw((ring_page<<8), ioaddr + HPP_IN_ADDR);
         outw(option_reg & ~(MemDisable + BootROMEnb), ioaddr + HPP_OPTION);
-        isa_memcpy_fromio(hdr, dev->mem_start, sizeof(struct e8390_pkt_hdr));
+        memcpy_fromio(hdr, ei_status.mem, sizeof(struct e8390_pkt_hdr));
         outw(option_reg, ioaddr + HPP_OPTION);
         hdr->count = (le16_to_cpu(hdr->count) + 3) & ~3;        /* Round up allocation. */
 }
@@ -391,7 +399,7 @@ hpp_mem_block_input(struct net_device *dev, int count, struct sk_buff *skb, int
            Also note that we *can't* use eth_io_copy_and_sum() because
            it will not always copy "count" bytes (e.g. padded IP).  */
 
-        isa_memcpy_fromio(skb->data, dev->mem_start, count);
+        memcpy_fromio(skb->data, ei_status.mem, count);
         outw(option_reg, ioaddr + HPP_OPTION);
 }
 
@@ -416,7 +424,7 @@ hpp_mem_block_output(struct net_device *dev, int count,
 
         outw(start_page << 8, ioaddr + HPP_OUT_ADDR);
         outw(option_reg & ~(MemDisable + BootROMEnb), ioaddr + HPP_OPTION);
-        isa_memcpy_toio(dev->mem_start, buf, (count + 3) & ~3);
+        memcpy_toio(ei_status.mem, buf, (count + 3) & ~3);
         outw(option_reg, ioaddr + HPP_OPTION);
 
         return;
@@ -470,6 +478,7 @@ init_module(void)
 static void cleanup_card(struct net_device *dev)
 {
         /* NB: hpp_close() handles free_irq */
+        iounmap(ei_status.mem);
         release_region(dev->base_addr - NIC_OFFSET, HP_IO_EXTENT);
 }
 
diff --git a/drivers/net/lance.c b/drivers/net/lance.c
index d1d714faa6..bb5ad47921 100644
--- a/drivers/net/lance.c
+++ b/drivers/net/lance.c
@@ -464,20 +464,25 @@ static int __init lance_probe1(struct net_device *dev, int ioaddr, int irq, int
         static int did_version;                 /* Already printed version info. */
         unsigned long flags;
         int err = -ENOMEM;
+        void __iomem *bios;
 
         /* First we look for special cases.
            Check for HP's on-board ethernet by looking for 'HP' in the BIOS.
            There are two HP versions, check the BIOS for the configuration port.
            This method provided by L. Julliard, Laurent_Julliard@grenoble.hp.com.
            */
-        if (isa_readw(0x000f0102) == 0x5048)  {
+        bios = ioremap(0xf00f0, 0x14);
+        if (!bios)
+                return -ENOMEM;
+        if (readw(bios + 0x12) == 0x5048)  {
                 static const short ioaddr_table[] = { 0x300, 0x320, 0x340, 0x360};
-                int hp_port = (isa_readl(0x000f00f1) & 1)  ? 0x499 : 0x99;
+                int hp_port = (readl(bios + 1) & 1)  ? 0x499 : 0x99;
                 /* We can have boards other than the built-in!  Verify this is on-board. */
                 if ((inb(hp_port) & 0xc0) == 0x80
                         && ioaddr_table[inb(hp_port) & 3] == ioaddr)
                         hp_builtin = hp_port;
         }
+        iounmap(bios);
         /* We also recognize the HP Vectra on-board here, but check below. */
         hpJ2405A = (inb(ioaddr) == 0x08 && inb(ioaddr+1) == 0x00
                                 && inb(ioaddr+2) == 0x09);
diff --git a/drivers/net/loopback.c b/drivers/net/loopback.c
index 690a1aae0b..0c13795dca 100644
--- a/drivers/net/loopback.c
+++ b/drivers/net/loopback.c
@@ -172,11 +172,9 @@ static struct net_device_stats *get_stats(struct net_device *dev)
 
         memset(stats, 0, sizeof(struct net_device_stats));
 
-        for (i=0; i < NR_CPUS; i++) {
+        for_each_cpu(i) {
                 struct net_device_stats *lb_stats;
 
-                if (!cpu_possible(i)) 
-                        continue;
                 lb_stats = &per_cpu(loopback_stats, i);
                 stats->rx_bytes   += lb_stats->rx_bytes;
                 stats->tx_bytes   += lb_stats->tx_bytes;
diff --git a/drivers/net/ppp_generic.c b/drivers/net/ppp_generic.c
index f608c12e3e..b2073fce82 100644
--- a/drivers/net/ppp_generic.c
+++ b/drivers/net/ppp_generic.c
@@ -46,6 +46,7 @@
 #include <linux/rwsem.h>
 #include <linux/stddef.h>
 #include <linux/device.h>
+#include <linux/mutex.h>
 #include <net/slhc_vj.h>
 #include <asm/atomic.h>
 
@@ -198,11 +199,11 @@ static unsigned int cardmap_find_first_free(struct cardmap *map);
 static void cardmap_destroy(struct cardmap **map);
 
 /*
- * all_ppp_sem protects the all_ppp_units mapping.
+ * all_ppp_mutex protects the all_ppp_units mapping.
  * It also ensures that finding a ppp unit in the all_ppp_units map
  * and updating its file.refcnt field is atomic.
  */
-static DECLARE_MUTEX(all_ppp_sem);
+static DEFINE_MUTEX(all_ppp_mutex);
 static struct cardmap *all_ppp_units;
 static atomic_t ppp_unit_count = ATOMIC_INIT(0);
 
@@ -804,7 +805,7 @@ static int ppp_unattached_ioctl(struct ppp_file *pf, struct file *file,
                 /* Attach to an existing ppp unit */
                 if (get_user(unit, p))
                         break;
-                down(&all_ppp_sem);
+                mutex_lock(&all_ppp_mutex);
                 err = -ENXIO;
                 ppp = ppp_find_unit(unit);
                 if (ppp != 0) {
@@ -812,7 +813,7 @@ static int ppp_unattached_ioctl(struct ppp_file *pf, struct file *file,
                         file->private_data = &ppp->file;
                         err = 0;
                 }
-                up(&all_ppp_sem);
+                mutex_unlock(&all_ppp_mutex);
                 break;
 
         case PPPIOCATTCHAN:
@@ -2446,7 +2447,7 @@ ppp_create_interface(int unit, int *retp)
         dev->do_ioctl = ppp_net_ioctl;
 
         ret = -EEXIST;
-        down(&all_ppp_sem);
+        mutex_lock(&all_ppp_mutex);
         if (unit < 0)
                 unit = cardmap_find_first_free(all_ppp_units);
         else if (cardmap_get(all_ppp_units, unit) != NULL)
@@ -2465,12 +2466,12 @@ ppp_create_interface(int unit, int *retp)
 
         atomic_inc(&ppp_unit_count);
         cardmap_set(&all_ppp_units, unit, ppp);
-        up(&all_ppp_sem);
+        mutex_unlock(&all_ppp_mutex);
         *retp = 0;
         return ppp;
 
 out2:
-        up(&all_ppp_sem);
+        mutex_unlock(&all_ppp_mutex);
         free_netdev(dev);
 out1:
         kfree(ppp);
@@ -2500,7 +2501,7 @@ static void ppp_shutdown_interface(struct ppp *ppp)
 {
         struct net_device *dev;
 
-        down(&all_ppp_sem);
+        mutex_lock(&all_ppp_mutex);
         ppp_lock(ppp);
         dev = ppp->dev;
         ppp->dev = NULL;
@@ -2514,7 +2515,7 @@ static void ppp_shutdown_interface(struct ppp *ppp)
         ppp->file.dead = 1;
         ppp->owner = NULL;
         wake_up_interruptible(&ppp->file.rwait);
-        up(&all_ppp_sem);
+        mutex_unlock(&all_ppp_mutex);
 }
 
 /*
@@ -2556,7 +2557,7 @@ static void ppp_destroy_interface(struct ppp *ppp)
 
 /*
  * Locate an existing ppp unit.
- * The caller should have locked the all_ppp_sem.
+ * The caller should have locked the all_ppp_mutex.
  */
 static struct ppp *
 ppp_find_unit(int unit)
@@ -2601,7 +2602,7 @@ ppp_connect_channel(struct channel *pch, int unit)
         int ret = -ENXIO;
         int hdrlen;
 
-        down(&all_ppp_sem);
+        mutex_lock(&all_ppp_mutex);
         ppp = ppp_find_unit(unit);
         if (ppp == 0)
                 goto out;
@@ -2626,7 +2627,7 @@ ppp_connect_channel(struct channel *pch, int unit)
  outl:
         write_unlock_bh(&pch->upl);
  out:
-        up(&all_ppp_sem);
+        mutex_unlock(&all_ppp_mutex);
         return ret;
 }
 
diff --git a/drivers/net/sk98lin/skge.c b/drivers/net/sk98lin/skge.c
index a5f2b1ee07..38a26df409 100644
--- a/drivers/net/sk98lin/skge.c
+++ b/drivers/net/sk98lin/skge.c
@@ -1727,7 +1727,7 @@ struct sk_buff	*pMessage)	/* pointer to send-message              */
                 pTxd->VDataHigh = (SK_U32) (PhysAddr >> 32);
                 pTxd->pMBuf     = pMessage;
                 
-                pTxd->TBControl = Control | BMU_OWN | sk_frag->size;;
+                pTxd->TBControl = Control | BMU_OWN | sk_frag->size;
 
                 /* 
                 ** Do we have the last fragment? 
diff --git a/drivers/net/skge.c b/drivers/net/skge.c
index 4eda81d41b..35dbf05c7f 100644
--- a/drivers/net/skge.c
+++ b/drivers/net/skge.c
@@ -44,7 +44,7 @@
 #include "skge.h"
 
 #define DRV_NAME                "skge"
-#define DRV_VERSION             "1.4"
+#define DRV_VERSION             "1.5"
 #define PFX                     DRV_NAME " "
 
 #define DEFAULT_TX_RING_SIZE    128
@@ -357,7 +357,7 @@ static struct net_device_stats *skge_get_stats(struct net_device *dev)
         skge->net_stats.rx_bytes = data[1];
         skge->net_stats.tx_packets = data[2] + data[4] + data[6];
         skge->net_stats.rx_packets = data[3] + data[5] + data[7];
-        skge->net_stats.multicast = data[5] + data[7];
+        skge->net_stats.multicast = data[3] + data[5];
         skge->net_stats.collisions = data[10];
         skge->net_stats.tx_aborted_errors = data[12];
 
@@ -781,7 +781,7 @@ static void skge_rx_setup(struct skge_port *skge, struct skge_element *e,
  * Note: DMA address is not changed by chip.
  *       MTU not changed while receiver active.
  */
-static void skge_rx_reuse(struct skge_element *e, unsigned int size)
+static inline void skge_rx_reuse(struct skge_element *e, unsigned int size)
 {
         struct skge_rx_desc *rd = e->desc;
 
@@ -829,7 +829,7 @@ static int skge_rx_fill(struct skge_port *skge)
         do {
                 struct sk_buff *skb;
 
-                skb = dev_alloc_skb(skge->rx_buf_size + NET_IP_ALIGN);
+                skb = alloc_skb(skge->rx_buf_size + NET_IP_ALIGN, GFP_KERNEL);
                 if (!skb)
                         return -ENOMEM;
 
@@ -847,8 +847,7 @@ static void skge_link_up(struct skge_port *skge)
                     LED_BLK_OFF|LED_SYNC_OFF|LED_ON);
 
         netif_carrier_on(skge->netdev);
-        if (skge->tx_avail > MAX_SKB_FRAGS + 1)
-                netif_wake_queue(skge->netdev);
+        netif_wake_queue(skge->netdev);
 
         if (netif_msg_link(skge))
                 printk(KERN_INFO PFX
@@ -2155,7 +2154,7 @@ static int skge_up(struct net_device *dev)
                 printk(KERN_INFO PFX "%s: enabling interface\n", dev->name);
 
         if (dev->mtu > RX_BUF_SIZE)
-                skge->rx_buf_size = dev->mtu + ETH_HLEN + NET_IP_ALIGN;
+                skge->rx_buf_size = dev->mtu + ETH_HLEN;
         else
                 skge->rx_buf_size = RX_BUF_SIZE;
 
@@ -2190,8 +2189,6 @@ static int skge_up(struct net_device *dev)
         if (err)
                 goto free_rx_ring;
 
-        skge->tx_avail = skge->tx_ring.count - 1;
-
         /* Initialize MAC */
         spin_lock_bh(&hw->phy_lock);
         if (hw->chip_id == CHIP_ID_GENESIS)
@@ -2294,6 +2291,12 @@ static int skge_down(struct net_device *dev)
         return 0;
 }
 
+static inline int skge_avail(const struct skge_ring *ring)
+{
+        return ((ring->to_clean > ring->to_use) ? 0 : ring->count)
+                + (ring->to_clean - ring->to_use) - 1;
+}
+
 static int skge_xmit_frame(struct sk_buff *skb, struct net_device *dev)
 {
         struct skge_port *skge = netdev_priv(dev);
@@ -2314,7 +2317,7 @@ static int skge_xmit_frame(struct sk_buff *skb, struct net_device *dev)
                 return NETDEV_TX_LOCKED;
         }
 
-        if (unlikely(skge->tx_avail < skb_shinfo(skb)->nr_frags +1)) {
+        if (unlikely(skge_avail(&skge->tx_ring) < skb_shinfo(skb)->nr_frags + 1)) {
                 if (!netif_queue_stopped(dev)) {
                         netif_stop_queue(dev);
 
@@ -2390,8 +2393,7 @@ static int skge_xmit_frame(struct sk_buff *skb, struct net_device *dev)
                        dev->name, e - ring->start, skb->len);
 
         ring->to_use = e->next;
-        skge->tx_avail -= skb_shinfo(skb)->nr_frags + 1;
-        if (skge->tx_avail <= MAX_SKB_FRAGS + 1) {
+        if (skge_avail(&skge->tx_ring) <= MAX_SKB_FRAGS + 1) {
                 pr_debug("%s: transmit queue full\n", dev->name);
                 netif_stop_queue(dev);
         }
@@ -2404,35 +2406,37 @@ static int skge_xmit_frame(struct sk_buff *skb, struct net_device *dev)
         return NETDEV_TX_OK;
 }
 
-static inline void skge_tx_free(struct skge_hw *hw, struct skge_element *e)
+static void skge_tx_complete(struct skge_port *skge, struct skge_element *last)
 {
-        /* This ring element can be skb or fragment */
-        if (e->skb) {
-                pci_unmap_single(hw->pdev,
-                               pci_unmap_addr(e, mapaddr),
-                               pci_unmap_len(e, maplen),
-                               PCI_DMA_TODEVICE);
-                dev_kfree_skb(e->skb);
+        struct pci_dev *pdev = skge->hw->pdev;
+        struct skge_element *e;
+
+        for (e = skge->tx_ring.to_clean; e != last; e = e->next) {
+                struct sk_buff *skb = e->skb;
+                int i;
+
                 e->skb = NULL;
-        } else {
-                pci_unmap_page(hw->pdev,
-                               pci_unmap_addr(e, mapaddr),
-                               pci_unmap_len(e, maplen),
-                               PCI_DMA_TODEVICE);
+                pci_unmap_single(pdev, pci_unmap_addr(e, mapaddr),
+                                 skb_headlen(skb), PCI_DMA_TODEVICE);
+
+                for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
+                        e = e->next;
+                        pci_unmap_page(pdev, pci_unmap_addr(e, mapaddr),
+                                       skb_shinfo(skb)->frags[i].size,
+                                       PCI_DMA_TODEVICE);
+                }
+
+                dev_kfree_skb(skb);
         }
+        skge->tx_ring.to_clean = e;
 }
 
 static void skge_tx_clean(struct skge_port *skge)
 {
-        struct skge_ring *ring = &skge->tx_ring;
-        struct skge_element *e;
 
         spin_lock_bh(&skge->tx_lock);
-        for (e = ring->to_clean; e != ring->to_use; e = e->next) {
-                ++skge->tx_avail;
-                skge_tx_free(skge->hw, e);
-        }
-        ring->to_clean = e;
+        skge_tx_complete(skge, skge->tx_ring.to_use);
+        netif_wake_queue(skge->netdev);
         spin_unlock_bh(&skge->tx_lock);
 }
 
@@ -2592,7 +2596,7 @@ static inline struct sk_buff *skge_rx_get(struct skge_port *skge,
                 goto error;
 
         if (len < RX_COPY_THRESHOLD) {
-                skb = dev_alloc_skb(len + 2);
+                skb = alloc_skb(len + 2, GFP_ATOMIC);
                 if (!skb)
                         goto resubmit;
 
@@ -2607,10 +2611,11 @@ static inline struct sk_buff *skge_rx_get(struct skge_port *skge,
                 skge_rx_reuse(e, skge->rx_buf_size);
         } else {
                 struct sk_buff *nskb;
-                nskb = dev_alloc_skb(skge->rx_buf_size + NET_IP_ALIGN);
+                nskb = alloc_skb(skge->rx_buf_size + NET_IP_ALIGN, GFP_ATOMIC);
                 if (!nskb)
                         goto resubmit;
 
+                skb_reserve(nskb, NET_IP_ALIGN);
                 pci_unmap_single(skge->hw->pdev,
                                  pci_unmap_addr(e, mapaddr),
                                  pci_unmap_len(e, maplen),
@@ -2661,30 +2666,29 @@ resubmit:
 static void skge_tx_done(struct skge_port *skge)
 {
         struct skge_ring *ring = &skge->tx_ring;
-        struct skge_element *e;
+        struct skge_element *e, *last;
 
         spin_lock(&skge->tx_lock);
-        for (e = ring->to_clean; prefetch(e->next), e != ring->to_use; e = e->next) {
+        last = ring->to_clean;
+        for (e = ring->to_clean; e != ring->to_use; e = e->next) {
                 struct skge_tx_desc *td = e->desc;
-                u32 control;
 
-                rmb();
-                control = td->control;
-                if (control & BMU_OWN)
+                if (td->control & BMU_OWN)
                         break;
 
-                if (unlikely(netif_msg_tx_done(skge)))
-                        printk(KERN_DEBUG PFX "%s: tx done slot %td status 0x%x\n",
-                               skge->netdev->name, e - ring->start, td->status);
-
-                skge_tx_free(skge->hw, e);
-                e->skb = NULL;
-                ++skge->tx_avail;
+                if (td->control & BMU_EOF) {
+                        last = e->next;
+                        if (unlikely(netif_msg_tx_done(skge)))
+                                printk(KERN_DEBUG PFX "%s: tx done slot %td\n",
+                                       skge->netdev->name, e - ring->start);
+                }
         }
-        ring->to_clean = e;
+
+        skge_tx_complete(skge, last);
+
         skge_write8(skge->hw, Q_ADDR(txqaddr[skge->port], Q_CSR), CSR_IRQ_CL_F);
 
-        if (skge->tx_avail > MAX_SKB_FRAGS + 1)
+        if (skge_avail(&skge->tx_ring) > MAX_SKB_FRAGS + 1)
                 netif_wake_queue(skge->netdev);
 
         spin_unlock(&skge->tx_lock);
@@ -2718,8 +2722,7 @@ static int skge_poll(struct net_device *dev, int *budget)
                         netif_receive_skb(skb);
 
                         ++work_done;
-                } else
-                        skge_rx_reuse(e, skge->rx_buf_size);
+                }
         }
         ring->to_clean = e;
 
diff --git a/drivers/net/skge.h b/drivers/net/skge.h
index 2efdacc290..1f1ce88c81 100644
--- a/drivers/net/skge.h
+++ b/drivers/net/skge.h
@@ -2418,7 +2418,6 @@ struct skge_port {
         int                  port;
 
         spinlock_t           tx_lock;
-        u32                  tx_avail;
         struct skge_ring     tx_ring;
         struct skge_ring     rx_ring;
 
diff --git a/drivers/net/sky2.c b/drivers/net/sky2.c
index 36db93811a..68f9c206a6 100644
--- a/drivers/net/sky2.c
+++ b/drivers/net/sky2.c
@@ -1175,7 +1175,7 @@ static int sky2_xmit_frame(struct sk_buff *skb, struct net_device *dev)
                 /* just drop the packet if non-linear expansion fails */
                 if (skb_header_cloned(skb) &&
                     pskb_expand_head(skb, 0, 0, GFP_ATOMIC)) {
-                        dev_kfree_skb_any(skb);
+                        dev_kfree_skb(skb);
                         goto out_unlock;
                 }
 
@@ -1324,7 +1324,7 @@ static void sky2_tx_complete(struct sky2_port *sky2, u16 done)
                                        PCI_DMA_TODEVICE);
                 }
 
-                dev_kfree_skb_any(skb);
+                dev_kfree_skb(skb);
         }
 
         sky2->tx_cons = put;
@@ -2484,7 +2484,7 @@ static const struct sky2_stat {
         { "single_collisions", GM_TXF_SNG_COL },
         { "multi_collisions", GM_TXF_MUL_COL },
 
-        { "rx_short",      GM_RXE_SHT },
+        { "rx_short",      GM_RXF_SHT },
         { "rx_runt",       GM_RXE_FRAG },
         { "rx_64_byte_packets", GM_RXF_64B },
         { "rx_65_to_127_byte_packets", GM_RXF_127B },
@@ -2607,7 +2607,7 @@ static struct net_device_stats *sky2_get_stats(struct net_device *dev)
         sky2->net_stats.rx_bytes = data[1];
         sky2->net_stats.tx_packets = data[2] + data[4] + data[6];
         sky2->net_stats.rx_packets = data[3] + data[5] + data[7];
-        sky2->net_stats.multicast = data[5] + data[7];
+        sky2->net_stats.multicast = data[3] + data[5];
         sky2->net_stats.collisions = data[10];
         sky2->net_stats.tx_aborted_errors = data[12];
 
diff --git a/drivers/net/sky2.h b/drivers/net/sky2.h
index 2838f661b3..62532b4e45 100644
--- a/drivers/net/sky2.h
+++ b/drivers/net/sky2.h
@@ -1804,7 +1804,7 @@ struct sky2_rx_le {
         __le16  length;
         u8      ctrl;
         u8      opcode;
-} __attribute((packed));;
+} __attribute((packed));
 
 struct sky2_status_le {
         __le32  status; /* also checksum */
diff --git a/drivers/net/tg3.c b/drivers/net/tg3.c
index 88829eb956..b5473325bf 100644
--- a/drivers/net/tg3.c
+++ b/drivers/net/tg3.c
@@ -69,8 +69,8 @@
 
 #define DRV_MODULE_NAME         "tg3"
 #define PFX DRV_MODULE_NAME     ": "
-#define DRV_MODULE_VERSION      "3.53"
-#define DRV_MODULE_RELDATE      "Mar 22, 2006"
+#define DRV_MODULE_VERSION      "3.54"
+#define DRV_MODULE_RELDATE      "Mar 23, 2006"
 
 #define TG3_DEF_MAC_MODE        0
 #define TG3_DEF_RX_MODE         0
@@ -225,6 +225,10 @@ static struct pci_device_id tg3_pci_tbl[] = {
           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5754M,
           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
+        { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5755,
+          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
+        { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5755M,
+          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5787,
           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5787M,
@@ -4557,6 +4561,7 @@ static int tg3_chip_reset(struct tg3 *tp)
         }
 
         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5752 ||
+            GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755 ||
             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787)
                 tw32(GRC_FASTBOOT_PC, 0);
 
@@ -6152,6 +6157,9 @@ static int tg3_reset_hw(struct tg3 *tp)
                         gpio_mask |= GRC_LCLCTRL_GPIO_OE3 |
                                      GRC_LCLCTRL_GPIO_OUTPUT3;
 
+                if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755)
+                        gpio_mask |= GRC_LCLCTRL_GPIO_UART_SEL;
+
                 tp->grc_local_ctrl |= tr32(GRC_LOCAL_CTRL) & gpio_mask;
 
                 /* GPIO1 must be driven high for eeprom write protect */
@@ -6191,7 +6199,8 @@ static int tg3_reset_hw(struct tg3 *tp)
         }
 
         /* Enable host coalescing bug fix */
-        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787)
+        if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755) ||
+            (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787))
                 val |= (1 << 29);
 
         tw32_f(WDMAC_MODE, val);
@@ -6249,6 +6258,9 @@ static int tg3_reset_hw(struct tg3 *tp)
         udelay(100);
 
         tp->rx_mode = RX_MODE_ENABLE;
+        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755)
+                tp->rx_mode |= RX_MODE_IPV6_CSUM_ENABLE;
+
         tw32_f(MAC_RX_MODE, tp->rx_mode);
         udelay(10);
 
@@ -7907,7 +7919,8 @@ static int tg3_set_tx_csum(struct net_device *dev, u32 data)
                 return 0;
         }
   
-        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787)
+        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755 ||
+            GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787)
                 ethtool_op_set_tx_hw_csum(dev, data);
         else
                 ethtool_op_set_tx_csum(dev, data);
@@ -8332,7 +8345,8 @@ static int tg3_test_memory(struct tg3 *tp)
         int i;
 
         if (tp->tg3_flags2 & TG3_FLG2_5705_PLUS) {
-                if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787)
+                if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755 ||
+                    GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787)
                         mem_tbl = mem_tbl_5755;
                 else
                         mem_tbl = mem_tbl_5705;
@@ -8924,6 +8938,47 @@ static void __devinit tg3_get_5752_nvram_info(struct tg3 *tp)
         }
 }
 
+static void __devinit tg3_get_5755_nvram_info(struct tg3 *tp)
+{
+        u32 nvcfg1;
+
+        nvcfg1 = tr32(NVRAM_CFG1);
+
+        /* NVRAM protection for TPM */
+        if (nvcfg1 & (1 << 27))
+                tp->tg3_flags2 |= TG3_FLG2_PROTECTED_NVRAM;
+
+        switch (nvcfg1 & NVRAM_CFG1_5752VENDOR_MASK) {
+                case FLASH_5755VENDOR_ATMEL_EEPROM_64KHZ:
+                case FLASH_5755VENDOR_ATMEL_EEPROM_376KHZ:
+                        tp->nvram_jedecnum = JEDEC_ATMEL;
+                        tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
+                        tp->nvram_pagesize = ATMEL_AT24C512_CHIP_SIZE;
+
+                        nvcfg1 &= ~NVRAM_CFG1_COMPAT_BYPASS;
+                        tw32(NVRAM_CFG1, nvcfg1);
+                        break;
+                case FLASH_5752VENDOR_ATMEL_FLASH_BUFFERED:
+                case FLASH_5755VENDOR_ATMEL_FLASH_1:
+                case FLASH_5755VENDOR_ATMEL_FLASH_2:
+                case FLASH_5755VENDOR_ATMEL_FLASH_3:
+                case FLASH_5755VENDOR_ATMEL_FLASH_4:
+                        tp->nvram_jedecnum = JEDEC_ATMEL;
+                        tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
+                        tp->tg3_flags2 |= TG3_FLG2_FLASH;
+                        tp->nvram_pagesize = 264;
+                        break;
+                case FLASH_5752VENDOR_ST_M45PE10:
+                case FLASH_5752VENDOR_ST_M45PE20:
+                case FLASH_5752VENDOR_ST_M45PE40:
+                        tp->nvram_jedecnum = JEDEC_ST;
+                        tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
+                        tp->tg3_flags2 |= TG3_FLG2_FLASH;
+                        tp->nvram_pagesize = 256;
+                        break;
+        }
+}
+
 static void __devinit tg3_get_5787_nvram_info(struct tg3 *tp)
 {
         u32 nvcfg1;
@@ -8997,6 +9052,8 @@ static void __devinit tg3_nvram_init(struct tg3 *tp)
 
                 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5752)
                         tg3_get_5752_nvram_info(tp);
+                else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755)
+                        tg3_get_5755_nvram_info(tp);
                 else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787)
                         tg3_get_5787_nvram_info(tp);
                 else
@@ -9310,6 +9367,7 @@ static int tg3_nvram_write_block_buffered(struct tg3 *tp, u32 offset, u32 len,
                         nvram_cmd |= NVRAM_CMD_LAST;
 
                 if ((GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5752) &&
+                    (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5755) &&
                     (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5787) &&
                     (tp->nvram_jedecnum == JEDEC_ST) &&
                     (nvram_cmd & NVRAM_CMD_FIRST)) {
@@ -10044,6 +10102,7 @@ static int __devinit tg3_get_invariants(struct tg3 *tp)
 
         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5750 ||
             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5752 ||
+            GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755 ||
             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787 ||
             (tp->tg3_flags2 & TG3_FLG2_5780_CLASS))
                 tp->tg3_flags2 |= TG3_FLG2_5750_PLUS;
@@ -10053,7 +10112,8 @@ static int __devinit tg3_get_invariants(struct tg3 *tp)
                 tp->tg3_flags2 |= TG3_FLG2_5705_PLUS;
 
         if (tp->tg3_flags2 & TG3_FLG2_5750_PLUS) {
-                if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787) {
+                if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755 ||
+                    GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787) {
                         tp->tg3_flags2 |= TG3_FLG2_HW_TSO_2;
                         tp->tg3_flags2 |= TG3_FLG2_1SHOT_MSI;
                 } else
@@ -10063,6 +10123,7 @@ static int __devinit tg3_get_invariants(struct tg3 *tp)
         if (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5705 &&
             GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5750 &&
             GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5752 &&
+            GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5755 &&
             GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5787)
                 tp->tg3_flags2 |= TG3_FLG2_JUMBO_CAPABLE;
 
@@ -10219,6 +10280,9 @@ static int __devinit tg3_get_invariants(struct tg3 *tp)
         else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5752)
                 tp->grc_local_ctrl |= GRC_LCLCTRL_GPIO_OE3;
 
+        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755)
+                tp->grc_local_ctrl |= GRC_LCLCTRL_GPIO_UART_SEL;
+
         /* Force the chip into D0. */
         err = tg3_set_power_state(tp, PCI_D0);
         if (err) {
@@ -10274,6 +10338,7 @@ static int __devinit tg3_get_invariants(struct tg3 *tp)
                 tp->tg3_flags2 |= TG3_FLG2_PHY_5704_A0_BUG;
 
         if ((tp->tg3_flags2 & TG3_FLG2_5705_PLUS) &&
+            (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5755) &&
             (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5787))
                 tp->tg3_flags2 |= TG3_FLG2_PHY_BER_BUG;
 
@@ -10413,7 +10478,8 @@ static int __devinit tg3_get_invariants(struct tg3 *tp)
         /* All chips before 5787 can get confused if TX buffers
          * straddle the 4GB address boundary in some cases.
          */
-        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787)
+        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755 ||
+            GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787)
                 tp->dev->hard_start_xmit = tg3_start_xmit;
         else
                 tp->dev->hard_start_xmit = tg3_start_xmit_dma_bug;
@@ -11002,6 +11068,7 @@ static char * __devinit tg3_phy_string(struct tg3 *tp)
         case PHY_ID_BCM5752:    return "5752";
         case PHY_ID_BCM5714:    return "5714";
         case PHY_ID_BCM5780:    return "5780";
+        case PHY_ID_BCM5755:    return "5755";
         case PHY_ID_BCM5787:    return "5787";
         case PHY_ID_BCM8002:    return "8002/serdes";
         case 0:                 return "serdes";
@@ -11350,7 +11417,8 @@ static int __devinit tg3_init_one(struct pci_dev *pdev,
          * checksumming.
          */
         if ((tp->tg3_flags & TG3_FLAG_BROKEN_CHECKSUMS) == 0) {
-                if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787)
+                if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755 ||
+                    GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787)
                         dev->features |= NETIF_F_HW_CSUM;
                 else
                         dev->features |= NETIF_F_IP_CSUM;
diff --git a/drivers/net/tg3.h b/drivers/net/tg3.h
index baa34c4721..c43cc32642 100644
--- a/drivers/net/tg3.h
+++ b/drivers/net/tg3.h
@@ -138,6 +138,7 @@
 #define   ASIC_REV_5752                  0x06
 #define   ASIC_REV_5780                  0x08
 #define   ASIC_REV_5714                  0x09
+#define   ASIC_REV_5755                  0x0a
 #define   ASIC_REV_5787                  0x0b
 #define  GET_CHIP_REV(CHIP_REV_ID)      ((CHIP_REV_ID) >> 8)
 #define   CHIPREV_5700_AX                0x70
@@ -456,6 +457,7 @@
 #define  RX_MODE_PROMISC                 0x00000100
 #define  RX_MODE_NO_CRC_CHECK            0x00000200
 #define  RX_MODE_KEEP_VLAN_TAG           0x00000400
+#define  RX_MODE_IPV6_CSUM_ENABLE        0x01000000
 #define MAC_RX_STATUS                   0x0000046c
 #define  RX_STATUS_REMOTE_TX_XOFFED      0x00000001
 #define  RX_STATUS_XOFF_RCVD             0x00000002
@@ -1340,6 +1342,7 @@
 #define  GRC_LCLCTRL_CLEARINT           0x00000002
 #define  GRC_LCLCTRL_SETINT             0x00000004
 #define  GRC_LCLCTRL_INT_ON_ATTN        0x00000008
+#define  GRC_LCLCTRL_GPIO_UART_SEL      0x00000010      /* 5755 only */
 #define  GRC_LCLCTRL_USE_SIG_DETECT     0x00000010      /* 5714/5780 only */
 #define  GRC_LCLCTRL_USE_EXT_SIG_DETECT 0x00000020      /* 5714/5780 only */
 #define  GRC_LCLCTRL_GPIO_INPUT3        0x00000020
@@ -1441,6 +1444,9 @@
 #define  FLASH_5755VENDOR_ATMEL_FLASH_1  0x03400001
 #define  FLASH_5755VENDOR_ATMEL_FLASH_2  0x03400002
 #define  FLASH_5755VENDOR_ATMEL_FLASH_3  0x03400000
+#define  FLASH_5755VENDOR_ATMEL_FLASH_4  0x00000003
+#define  FLASH_5755VENDOR_ATMEL_EEPROM_64KHZ     0x03c00003
+#define  FLASH_5755VENDOR_ATMEL_EEPROM_376KHZ    0x03c00002
 #define  FLASH_5787VENDOR_ATMEL_EEPROM_64KHZ     0x03000003
 #define  FLASH_5787VENDOR_ATMEL_EEPROM_376KHZ    0x03000002
 #define  FLASH_5787VENDOR_MICRO_EEPROM_64KHZ     0x03000000
@@ -2259,6 +2265,7 @@ struct tg3 {
 #define PHY_ID_BCM5752                  0x60008100
 #define PHY_ID_BCM5714                  0x60008340
 #define PHY_ID_BCM5780                  0x60008350
+#define PHY_ID_BCM5755                  0xbc050cc0
 #define PHY_ID_BCM5787                  0xbc050ce0
 #define PHY_ID_BCM8002                  0x60010140
 #define PHY_ID_INVALID                  0xffffffff
@@ -2286,7 +2293,7 @@ struct tg3 {
          (X) == PHY_ID_BCM5705 || (X) == PHY_ID_BCM5750 || \
          (X) == PHY_ID_BCM5752 || (X) == PHY_ID_BCM5714 || \
          (X) == PHY_ID_BCM5780 || (X) == PHY_ID_BCM5787 || \
-         (X) == PHY_ID_BCM8002)
+         (X) == PHY_ID_BCM5755 || (X) == PHY_ID_BCM8002)
 
         struct tg3_hw_stats             *hw_stats;
         dma_addr_t                      stats_mapping;
diff --git a/drivers/net/wireless/Kconfig b/drivers/net/wireless/Kconfig
index 5b0a19a505..6a1033ec06 100644
--- a/drivers/net/wireless/Kconfig
+++ b/drivers/net/wireless/Kconfig
@@ -25,6 +25,15 @@ config NET_RADIO
           the tools from
           <http://www.hpl.hp.com/personal/Jean_Tourrilhes/Linux/Tools.html>.
 
+config NET_WIRELESS_RTNETLINK
+        bool "Wireless Extension API over RtNetlink"
+        ---help---
+          Support the Wireless Extension API over the RtNetlink socket
+          in addition to the traditional ioctl interface (selected above).
+
+          For now, few tools use this facility, but it might grow in the
+          future. The only downside is that it adds 4.5 kB to your kernel.
+
 # Note : the cards are obsolete (can't buy them anymore), but the drivers
 # are not, as people are still using them...
 comment "Obsolete Wireless cards support (pre-802.11)"
diff --git a/drivers/net/wireless/airo.c b/drivers/net/wireless/airo.c
index 864937a409..108d9fed8f 100644
--- a/drivers/net/wireless/airo.c
+++ b/drivers/net/wireless/airo.c
@@ -770,6 +770,11 @@ typedef struct {
 } BSSListRid;
 
 typedef struct {
+  BSSListRid bss;
+  struct list_head list;
+} BSSListElement;
+
+typedef struct {
   u8 rssipct;
   u8 rssidBm;
 } tdsRssiEntry;
@@ -902,6 +907,7 @@ static char swversion[] = "2.1";
 #define NUM_MODULES       2
 #define MIC_MSGLEN_MAX    2400
 #define EMMH32_MSGLEN_MAX MIC_MSGLEN_MAX
+#define AIRO_DEF_MTU      2312
 
 typedef struct {
         u32   size;            // size
@@ -1119,6 +1125,8 @@ static int decapsulate(struct airo_info *ai, MICBuffer *mic, etherHead *pPacket,
 static u8 airo_rssi_to_dbm (tdsRssiEntry *rssi_rid, u8 rssi);
 static u8 airo_dbm_to_pct (tdsRssiEntry *rssi_rid, u8 dbm);
 
+static void airo_networks_free(struct airo_info *ai);
+
 struct airo_info {
         struct net_device_stats stats;
         struct net_device             *dev;
@@ -1150,7 +1158,7 @@ struct airo_info {
 #define FLAG_COMMIT     13
 #define FLAG_RESET      14
 #define FLAG_FLASHING   15
-#define JOB_MASK        0x1ff0000
+#define JOB_MASK        0x2ff0000
 #define JOB_DIE         16
 #define JOB_XMIT        17
 #define JOB_XMIT11      18
@@ -1160,6 +1168,7 @@ struct airo_info {
 #define JOB_EVENT       22
 #define JOB_AUTOWEP     23
 #define JOB_WSTATS      24
+#define JOB_SCAN_RESULTS  25
         int (*bap_read)(struct airo_info*, u16 *pu16Dst, int bytelen,
                         int whichbap);
         unsigned short *flash;
@@ -1176,7 +1185,7 @@ struct airo_info {
         } xmit, xmit11;
         struct net_device *wifidev;
         struct iw_statistics    wstats;         // wireless stats
-        unsigned long           scan_timestamp; /* Time started to scan */
+        unsigned long           scan_timeout;   /* Time scan should be read */
         struct iw_spy_data      spy_data;
         struct iw_public_data   wireless_data;
         /* MIC stuff */
@@ -1198,6 +1207,10 @@ struct airo_info {
         APListRid               *APList;
 #define PCI_SHARED_LEN          2*MPI_MAX_FIDS*PKTSIZE+RIDSIZE
         char                    proc_name[IFNAMSIZ];
+
+        struct list_head network_list;
+        struct list_head network_free_list;
+        BSSListElement *networks;
 };
 
 static inline int bap_read(struct airo_info *ai, u16 *pu16Dst, int bytelen,
@@ -1216,6 +1229,22 @@ static int flashgchar(struct airo_info *ai,int matchbyte,int dwelltime);
 static int flashputbuf(struct airo_info *ai);
 static int flashrestart(struct airo_info *ai,struct net_device *dev);
 
+#define airo_print(type, name, fmt, args...) \
+        { printk(type "airo(%s): " fmt "\n", name, ##args); }
+
+#define airo_print_info(name, fmt, args...) \
+        airo_print(KERN_INFO, name, fmt, ##args)
+
+#define airo_print_dbg(name, fmt, args...) \
+        airo_print(KERN_DEBUG, name, fmt, ##args)
+
+#define airo_print_warn(name, fmt, args...) \
+        airo_print(KERN_WARNING, name, fmt, ##args)
+
+#define airo_print_err(name, fmt, args...) \
+        airo_print(KERN_ERR, name, fmt, ##args)
+
+
 /***********************************************************************
  *                              MIC ROUTINES                           *
  ***********************************************************************
@@ -1294,7 +1323,7 @@ static int micsetup(struct airo_info *ai) {
                 ai->tfm = crypto_alloc_tfm("aes", CRYPTO_TFM_REQ_MAY_SLEEP);
 
         if (ai->tfm == NULL) {
-                printk(KERN_ERR "airo: failed to load transform for AES\n");
+                airo_print_err(ai->dev->name, "failed to load transform for AES");
                 return ERROR;
         }
 
@@ -1726,11 +1755,11 @@ static int writeWepKeyRid(struct airo_info*ai, WepKeyRid *pwkr, int perm, int lo
         wkr.kindex = cpu_to_le16(wkr.kindex);
         wkr.klen = cpu_to_le16(wkr.klen);
         rc = PC4500_writerid(ai, RID_WEP_TEMP, &wkr, sizeof(wkr), lock);
-        if (rc!=SUCCESS) printk(KERN_ERR "airo:  WEP_TEMP set %x\n", rc);
+        if (rc!=SUCCESS) airo_print_err(ai->dev->name, "WEP_TEMP set %x", rc);
         if (perm) {
                 rc = PC4500_writerid(ai, RID_WEP_PERM, &wkr, sizeof(wkr), lock);
                 if (rc!=SUCCESS) {
-                        printk(KERN_ERR "airo:  WEP_PERM set %x\n", rc);
+                        airo_print_err(ai->dev->name, "WEP_PERM set %x", rc);
                 }
         }
         return rc;
@@ -1909,7 +1938,7 @@ static int mpi_start_xmit(struct sk_buff *skb, struct net_device *dev) {
         struct airo_info *ai = dev->priv;
 
         if (!skb) {
-                printk(KERN_ERR "airo: %s: skb==NULL\n",__FUNCTION__);
+                airo_print_err(dev->name, "%s: skb == NULL!",__FUNCTION__);
                 return 0;
         }
         npacks = skb_queue_len (&ai->txq);
@@ -1955,8 +1984,8 @@ static int mpi_send_packet (struct net_device *dev)
         /* get a packet to send */
 
         if ((skb = skb_dequeue(&ai->txq)) == 0) {
-                printk (KERN_ERR
-                        "airo: %s: Dequeue'd zero in send_packet()\n",
+                airo_print_err(dev->name,
+                        "%s: Dequeue'd zero in send_packet()",
                         __FUNCTION__);
                 return 0;
         }
@@ -2108,7 +2137,7 @@ static int airo_start_xmit(struct sk_buff *skb, struct net_device *dev) {
         u32 *fids = priv->fids;
 
         if ( skb == NULL ) {
-                printk( KERN_ERR "airo:  skb == NULL!!!\n" );
+                airo_print_err(dev->name, "%s: skb == NULL!", __FUNCTION__);
                 return 0;
         }
 
@@ -2179,7 +2208,7 @@ static int airo_start_xmit11(struct sk_buff *skb, struct net_device *dev) {
         }
 
         if ( skb == NULL ) {
-                printk( KERN_ERR "airo:  skb == NULL!!!\n" );
+                airo_print_err(dev->name, "%s: skb == NULL!", __FUNCTION__);
                 return 0;
         }
 
@@ -2364,6 +2393,8 @@ void stop_airo_card( struct net_device *dev, int freeres )
                         dev_kfree_skb(skb);
         }
 
+        airo_networks_free (ai);
+
         kfree(ai->flash);
         kfree(ai->rssi);
         kfree(ai->APList);
@@ -2434,7 +2465,7 @@ static int mpi_init_descriptors (struct airo_info *ai)
         cmd.parm2 = MPI_MAX_FIDS;
         rc=issuecommand(ai, &cmd, &rsp);
         if (rc != SUCCESS) {
-                printk(KERN_ERR "airo:  Couldn't allocate RX FID\n");
+                airo_print_err(ai->dev->name, "Couldn't allocate RX FID");
                 return rc;
         }
 
@@ -2462,7 +2493,7 @@ static int mpi_init_descriptors (struct airo_info *ai)
 
         rc=issuecommand(ai, &cmd, &rsp);
         if (rc != SUCCESS) {
-                printk(KERN_ERR "airo:  Couldn't allocate TX FID\n");
+                airo_print_err(ai->dev->name, "Couldn't allocate TX FID");
                 return rc;
         }
 
@@ -2476,7 +2507,7 @@ static int mpi_init_descriptors (struct airo_info *ai)
         cmd.parm2 = 1; /* Magic number... */
         rc=issuecommand(ai, &cmd, &rsp);
         if (rc != SUCCESS) {
-                printk(KERN_ERR "airo:  Couldn't allocate RID\n");
+                airo_print_err(ai->dev->name, "Couldn't allocate RID");
                 return rc;
         }
 
@@ -2508,25 +2539,25 @@ static int mpi_map_card(struct airo_info *ai, struct pci_dev *pci,
         aux_len = AUXMEMSIZE;
 
         if (!request_mem_region(mem_start, mem_len, name)) {
-                printk(KERN_ERR "airo: Couldn't get region %x[%x] for %s\n",
+                airo_print_err(ai->dev->name, "Couldn't get region %x[%x] for %s",
                        (int)mem_start, (int)mem_len, name);
                 goto out;
         }
         if (!request_mem_region(aux_start, aux_len, name)) {
-                printk(KERN_ERR "airo: Couldn't get region %x[%x] for %s\n",
+                airo_print_err(ai->dev->name, "Couldn't get region %x[%x] for %s",
                        (int)aux_start, (int)aux_len, name);
                 goto free_region1;
         }
 
         ai->pcimem = ioremap(mem_start, mem_len);
         if (!ai->pcimem) {
-                printk(KERN_ERR "airo: Couldn't map region %x[%x] for %s\n",
+                airo_print_err(ai->dev->name, "Couldn't map region %x[%x] for %s",
                        (int)mem_start, (int)mem_len, name);
                 goto free_region2;
         }
         ai->pciaux = ioremap(aux_start, aux_len);
         if (!ai->pciaux) {
-                printk(KERN_ERR "airo: Couldn't map region %x[%x] for %s\n",
+                airo_print_err(ai->dev->name, "Couldn't map region %x[%x] for %s",
                        (int)aux_start, (int)aux_len, name);
                 goto free_memmap;
         }
@@ -2534,7 +2565,7 @@ static int mpi_map_card(struct airo_info *ai, struct pci_dev *pci,
         /* Reserve PKTSIZE for each fid and 2K for the Rids */
         ai->shared = pci_alloc_consistent(pci, PCI_SHARED_LEN, &ai->shared_dma);
         if (!ai->shared) {
-                printk(KERN_ERR "airo: Couldn't alloc_consistent %d\n",
+                airo_print_err(ai->dev->name, "Couldn't alloc_consistent %d",
                        PCI_SHARED_LEN);
                 goto free_auxmap;
         }
@@ -2626,7 +2657,7 @@ static void wifi_setup(struct net_device *dev)
 
         dev->type               = ARPHRD_IEEE80211;
         dev->hard_header_len    = ETH_HLEN;
-        dev->mtu                = 2312;
+        dev->mtu                = AIRO_DEF_MTU;
         dev->addr_len           = ETH_ALEN;
         dev->tx_queue_len       = 100; 
 
@@ -2670,6 +2701,42 @@ static int reset_card( struct net_device *dev , int lock) {
         return 0;
 }
 
+#define MAX_NETWORK_COUNT       64
+static int airo_networks_allocate(struct airo_info *ai)
+{
+        if (ai->networks)
+                return 0;
+
+        ai->networks =
+            kzalloc(MAX_NETWORK_COUNT * sizeof(BSSListElement),
+                    GFP_KERNEL);
+        if (!ai->networks) {
+                airo_print_warn(ai->dev->name, "Out of memory allocating beacons");
+                return -ENOMEM;
+        }
+
+        return 0;
+}
+
+static void airo_networks_free(struct airo_info *ai)
+{
+        if (!ai->networks)
+                return;
+        kfree(ai->networks);
+        ai->networks = NULL;
+}
+
+static void airo_networks_initialize(struct airo_info *ai)
+{
+        int i;
+
+        INIT_LIST_HEAD(&ai->network_free_list);
+        INIT_LIST_HEAD(&ai->network_list);
+        for (i = 0; i < MAX_NETWORK_COUNT; i++)
+                list_add_tail(&ai->networks[i].list,
+                              &ai->network_free_list);
+}
+
 static struct net_device *_init_airo_card( unsigned short irq, int port,
                                            int is_pcmcia, struct pci_dev *pci,
                                            struct device *dmdev )
@@ -2681,22 +2748,22 @@ static struct net_device *_init_airo_card( unsigned short irq, int port,
         /* Create the network device object. */
         dev = alloc_etherdev(sizeof(*ai));
         if (!dev) {
-                printk(KERN_ERR "airo:  Couldn't alloc_etherdev\n");
+                airo_print_err("", "Couldn't alloc_etherdev");
                 return NULL;
         }
         if (dev_alloc_name(dev, dev->name) < 0) {
-                printk(KERN_ERR "airo:  Couldn't get name!\n");
+                airo_print_err("", "Couldn't get name!");
                 goto err_out_free;
         }
 
         ai = dev->priv;
         ai->wifidev = NULL;
         ai->flags = 0;
+        ai->dev = dev;
         if (pci && (pci->device == 0x5000 || pci->device == 0xa504)) {
-                printk(KERN_DEBUG "airo: Found an MPI350 card\n");
+                airo_print_dbg(dev->name, "Found an MPI350 card");
                 set_bit(FLAG_MPI, &ai->flags);
         }
-        ai->dev = dev;
         spin_lock_init(&ai->aux_lock);
         sema_init(&ai->sem, 1);
         ai->config.len = 0;
@@ -2711,6 +2778,10 @@ static struct net_device *_init_airo_card( unsigned short irq, int port,
         if (rc)
                 goto err_out_thr;
 
+        if (airo_networks_allocate (ai))
+                goto err_out_unlink;
+        airo_networks_initialize (ai);
+
         /* The Airo-specific entries in the device structure. */
         if (test_bit(FLAG_MPI,&ai->flags)) {
                 skb_queue_head_init (&ai->txq);
@@ -2732,33 +2803,33 @@ static struct net_device *_init_airo_card( unsigned short irq, int port,
 
         SET_NETDEV_DEV(dev, dmdev);
 
-
         reset_card (dev, 1);
         msleep(400);
 
         rc = request_irq( dev->irq, airo_interrupt, SA_SHIRQ, dev->name, dev );
         if (rc) {
-                printk(KERN_ERR "airo: register interrupt %d failed, rc %d\n", irq, rc );
+                airo_print_err(dev->name, "register interrupt %d failed, rc %d",
+                                irq, rc);
                 goto err_out_unlink;
         }
         if (!is_pcmcia) {
                 if (!request_region( dev->base_addr, 64, dev->name )) {
                         rc = -EBUSY;
-                        printk(KERN_ERR "airo: Couldn't request region\n");
+                        airo_print_err(dev->name, "Couldn't request region");
                         goto err_out_irq;
                 }
         }
 
         if (test_bit(FLAG_MPI,&ai->flags)) {
                 if (mpi_map_card(ai, pci, dev->name)) {
-                        printk(KERN_ERR "airo: Could not map memory\n");
+                        airo_print_err(dev->name, "Could not map memory");
                         goto err_out_res;
                 }
         }
 
         if (probe) {
                 if ( setup_card( ai, dev->dev_addr, 1 ) != SUCCESS ) {
-                        printk( KERN_ERR "airo: MAC could not be enabled\n" );
+                        airo_print_err(dev->name, "MAC could not be enabled" );
                         rc = -EIO;
                         goto err_out_map;
                 }
@@ -2769,21 +2840,20 @@ static struct net_device *_init_airo_card( unsigned short irq, int port,
 
         rc = register_netdev(dev);
         if (rc) {
-                printk(KERN_ERR "airo: Couldn't register_netdev\n");
+                airo_print_err(dev->name, "Couldn't register_netdev");
                 goto err_out_map;
         }
         ai->wifidev = init_wifidev(ai, dev);
 
         set_bit(FLAG_REGISTERED,&ai->flags);
-        printk( KERN_INFO "airo: MAC enabled %s %x:%x:%x:%x:%x:%x\n",
-                dev->name,
+        airo_print_info(dev->name, "MAC enabled %x:%x:%x:%x:%x:%x",
                 dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
                 dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5] );
 
         /* Allocate the transmit buffers */
         if (probe && !test_bit(FLAG_MPI,&ai->flags))
                 for( i = 0; i < MAX_FIDS; i++ )
-                        ai->fids[i] = transmit_allocate(ai,2312,i>=MAX_FIDS/2);
+                        ai->fids[i] = transmit_allocate(ai,AIRO_DEF_MTU,i>=MAX_FIDS/2);
 
         setup_proc_entry( dev, dev->priv ); /* XXX check for failure */
         netif_start_queue(dev);
@@ -2840,16 +2910,16 @@ int reset_airo_card( struct net_device *dev )
                 return -1;
 
         if ( setup_card(ai, dev->dev_addr, 1 ) != SUCCESS ) {
-                printk( KERN_ERR "airo: MAC could not be enabled\n" );
+                airo_print_err(dev->name, "MAC could not be enabled");
                 return -1;
         }
-        printk( KERN_INFO "airo: MAC enabled %s %x:%x:%x:%x:%x:%x\n", dev->name,
+        airo_print_info(dev->name, "MAC enabled %x:%x:%x:%x:%x:%x",
                         dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
                         dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]);
         /* Allocate the transmit buffers if needed */
         if (!test_bit(FLAG_MPI,&ai->flags))
                 for( i = 0; i < MAX_FIDS; i++ )
-                        ai->fids[i] = transmit_allocate (ai,2312,i>=MAX_FIDS/2);
+                        ai->fids[i] = transmit_allocate (ai,AIRO_DEF_MTU,i>=MAX_FIDS/2);
 
         enable_interrupts( ai );
         netif_wake_queue(dev);
@@ -2875,6 +2945,65 @@ static void airo_send_event(struct net_device *dev) {
         wireless_send_event(dev, SIOCGIWAP, &wrqu, NULL);
 }
 
+static void airo_process_scan_results (struct airo_info *ai) {
+        union iwreq_data        wrqu;
+        BSSListRid BSSList;
+        int rc;
+        BSSListElement * loop_net;
+        BSSListElement * tmp_net;
+
+        /* Blow away current list of scan results */
+        list_for_each_entry_safe (loop_net, tmp_net, &ai->network_list, list) {
+                list_move_tail (&loop_net->list, &ai->network_free_list);
+                /* Don't blow away ->list, just BSS data */
+                memset (loop_net, 0, sizeof (loop_net->bss));
+        }
+
+        /* Try to read the first entry of the scan result */
+        rc = PC4500_readrid(ai, RID_BSSLISTFIRST, &BSSList, sizeof(BSSList), 0);
+        if((rc) || (BSSList.index == 0xffff)) {
+                /* No scan results */
+                goto out;
+        }
+
+        /* Read and parse all entries */
+        tmp_net = NULL;
+        while((!rc) && (BSSList.index != 0xffff)) {
+                /* Grab a network off the free list */
+                if (!list_empty(&ai->network_free_list)) {
+                        tmp_net = list_entry(ai->network_free_list.next,
+                                            BSSListElement, list);
+                        list_del(ai->network_free_list.next);
+                }
+
+                if (tmp_net != NULL) {
+                        memcpy(tmp_net, &BSSList, sizeof(tmp_net->bss));
+                        list_add_tail(&tmp_net->list, &ai->network_list);
+                        tmp_net = NULL;
+                }
+
+                /* Read next entry */
+                rc = PC4500_readrid(ai, RID_BSSLISTNEXT,
+                                    &BSSList, sizeof(BSSList), 0);
+        }
+
+out:
+        ai->scan_timeout = 0;
+        clear_bit(JOB_SCAN_RESULTS, &ai->flags);
+        up(&ai->sem);
+
+        /* Send an empty event to user space.
+         * We don't send the received data on
+         * the event because it would require
+         * us to do complex transcoding, and
+         * we want to minimise the work done in
+         * the irq handler. Use a request to
+         * extract the data - Jean II */
+        wrqu.data.length = 0;
+        wrqu.data.flags = 0;
+        wireless_send_event(ai->dev, SIOCGIWSCAN, &wrqu, NULL);
+}
+
 static int airo_thread(void *data) {
         struct net_device *dev = data;
         struct airo_info *ai = dev->priv;
@@ -2904,13 +3033,26 @@ static int airo_thread(void *data) {
                                 set_current_state(TASK_INTERRUPTIBLE);
                                 if (ai->flags & JOB_MASK)
                                         break;
-                                if (ai->expires) {
-                                        if (time_after_eq(jiffies,ai->expires)){
+                                if (ai->expires || ai->scan_timeout) {
+                                        if (ai->scan_timeout &&
+                                                        time_after_eq(jiffies,ai->scan_timeout)){
+                                                set_bit(JOB_SCAN_RESULTS,&ai->flags);
+                                                break;
+                                        } else if (ai->expires &&
+                                                        time_after_eq(jiffies,ai->expires)){
                                                 set_bit(JOB_AUTOWEP,&ai->flags);
                                                 break;
                                         }
                                         if (!signal_pending(current)) {
-                                                schedule_timeout(ai->expires - jiffies);
+                                                unsigned long wake_at;
+                                                if (!ai->expires || !ai->scan_timeout) {
+                                                        wake_at = max(ai->expires,
+                                                                ai->scan_timeout);
+                                                } else {
+                                                        wake_at = min(ai->expires,
+                                                                ai->scan_timeout);
+                                                }
+                                                schedule_timeout(wake_at - jiffies);
                                                 continue;
                                         }
                                 } else if (!signal_pending(current)) {
@@ -2953,6 +3095,10 @@ static int airo_thread(void *data) {
                         airo_send_event(dev);
                 else if (test_bit(JOB_AUTOWEP, &ai->flags))
                         timer_func(dev);
+                else if (test_bit(JOB_SCAN_RESULTS, &ai->flags))
+                        airo_process_scan_results(ai);
+                else  /* Shouldn't get here, but we make sure to unlock */
+                        up(&ai->sem);
         }
         complete_and_exit (&ai->thr_exited, 0);
 }
@@ -3047,19 +3193,15 @@ static irqreturn_t airo_interrupt ( int irq, void* dev_id, struct pt_regs *regs)
                          * and reassociations as valid status
                          * Jean II */
                         if(newStatus == ASSOCIATED) {
-                                if (apriv->scan_timestamp) {
-                                        /* Send an empty event to user space.
-                                         * We don't send the received data on
-                                         * the event because it would require
-                                         * us to do complex transcoding, and
-                                         * we want to minimise the work done in
-                                         * the irq handler. Use a request to
-                                         * extract the data - Jean II */
-                                        wrqu.data.length = 0;
-                                        wrqu.data.flags = 0;
-                                        wireless_send_event(dev, SIOCGIWSCAN, &wrqu, NULL);
-                                        apriv->scan_timestamp = 0;
+#if 0
+                                /* FIXME: Grabbing scan results here
+                                 * seems to be too early???  Just wait for
+                                 * timeout instead. */
+                                if (apriv->scan_timeout > 0) {
+                                        set_bit(JOB_SCAN_RESULTS, &apriv->flags);
+                                        wake_up_interruptible(&apriv->thr_wait);
                                 }
+#endif
                                 if (down_trylock(&apriv->sem) != 0) {
                                         set_bit(JOB_EVENT, &apriv->flags);
                                         wake_up_interruptible(&apriv->thr_wait);
@@ -3117,8 +3259,8 @@ static irqreturn_t airo_interrupt ( int irq, void* dev_id, struct pt_regs *regs)
                         }
                         len = le16_to_cpu(hdr.len);
 
-                        if (len > 2312) {
-                                printk( KERN_ERR "airo: Bad size %d\n", len );
+                        if (len > AIRO_DEF_MTU) {
+                                airo_print_err(apriv->dev->name, "Bad size %d", len);
                                 goto badrx;
                         }
                         if (len == 0)
@@ -3161,10 +3303,12 @@ static irqreturn_t airo_interrupt ( int irq, void* dev_id, struct pt_regs *regs)
                                 bap_read (apriv, &gap, sizeof(gap), BAP0);
                                 gap = le16_to_cpu(gap);
                                 if (gap) {
-                                        if (gap <= 8)
+                                        if (gap <= 8) {
                                                 bap_read (apriv, tmpbuf, gap, BAP0);
-                                        else
-                                                printk(KERN_ERR "airo: gaplen too big. Problems will follow...\n");
+                                        } else {
+                                                airo_print_err(apriv->dev->name, "gaplen too "
+                                                        "big. Problems will follow...");
+                                        }
                                 }
                                 bap_read (apriv, buffer + hdrlen/2, len, BAP0);
                         } else {
@@ -3281,12 +3425,13 @@ exitrx:
                                 }
                         } else {
                                 OUT4500( apriv, EVACK, status & (EV_TX | EV_TXCPY | EV_TXEXC));
-                                printk( KERN_ERR "airo: Unallocated FID was used to xmit\n" );
+                                airo_print_err(apriv->dev->name, "Unallocated FID was "
+                                        "used to xmit" );
                         }
                 }
 exittx:
                 if ( status & ~STATUS_INTS & ~IGNORE_INTS )
-                        printk( KERN_WARNING "airo: Got weird status %x\n",
+                        airo_print_warn(apriv->dev->name, "Got weird status %x",
                                 status & ~STATUS_INTS & ~IGNORE_INTS );
         }
 
@@ -3359,8 +3504,8 @@ static int enable_MAC( struct airo_info *ai, Resp *rsp, int lock ) {
             up(&ai->sem);
 
         if (rc)
-                printk(KERN_ERR "%s: Cannot enable MAC, err=%d\n",
-                        __FUNCTION__,rc);
+                airo_print_err(ai->dev->name, "%s: Cannot enable MAC, err=%d",
+                        __FUNCTION__, rc);
         return rc;
 }
 
@@ -3489,8 +3634,8 @@ void mpi_receive_802_11 (struct airo_info *ai)
         if (ai->wifidev == NULL)
                 hdr.len = 0;
         len = le16_to_cpu(hdr.len);
-        if (len > 2312) {
-                printk( KERN_ERR "airo: Bad size %d\n", len );
+        if (len > AIRO_DEF_MTU) {
+                airo_print_err(ai->dev->name, "Bad size %d", len);
                 goto badrx;
         }
         if (len == 0)
@@ -3531,8 +3676,8 @@ void mpi_receive_802_11 (struct airo_info *ai)
                 if (gap <= 8)
                         ptr += gap;
                 else
-                        printk(KERN_ERR
-                            "airo: gaplen too big. Problems will follow...\n");
+                        airo_print_err(ai->dev->name,
+                            "gaplen too big. Problems will follow...");
         }
         memcpy ((char *)buffer + hdrlen, ptr, len);
         ptr += len;
@@ -3604,15 +3749,15 @@ static u16 setup_card(struct airo_info *ai, u8 *mac, int lock)
                 if (issuecommand(ai, &cmd, &rsp) != SUCCESS) {
                         if (lock)
                                 up(&ai->sem);
-                        printk(KERN_ERR "airo: Error checking for AUX port\n");
+                        airo_print_err(ai->dev->name, "Error checking for AUX port");
                         return ERROR;
                 }
                 if (!aux_bap || rsp.status & 0xff00) {
                         ai->bap_read = fast_bap_read;
-                        printk(KERN_DEBUG "airo: Doing fast bap_reads\n");
+                        airo_print_dbg(ai->dev->name, "Doing fast bap_reads");
                 } else {
                         ai->bap_read = aux_bap_read;
-                        printk(KERN_DEBUG "airo: Doing AUX bap_reads\n");
+                        airo_print_dbg(ai->dev->name, "Doing AUX bap_reads");
                 }
         }
         if (lock)
@@ -3643,7 +3788,8 @@ static u16 setup_card(struct airo_info *ai, u8 *mac, int lock)
                         if (cap_rid.softCap & 8)
                                 ai->config.rmode |= RXMODE_NORMALIZED_RSSI;
                         else
-                                printk(KERN_WARNING "airo: unknown received signal level scale\n");
+                                airo_print_warn(ai->dev->name, "unknown received signal "
+                                                "level scale");
                 }
                 ai->config.opmode = adhoc ? MODE_STA_IBSS : MODE_STA_ESS;
                 ai->config.authType = AUTH_OPEN;
@@ -3706,7 +3852,8 @@ static u16 setup_card(struct airo_info *ai, u8 *mac, int lock)
 
         status = enable_MAC(ai, &rsp, lock);
         if ( status != SUCCESS || (rsp.status & 0xFF00) != 0) {
-                printk( KERN_ERR "airo: Bad MAC enable reason = %x, rid = %x, offset = %d\n", rsp.rsp0, rsp.rsp1, rsp.rsp2 );
+                airo_print_err(ai->dev->name, "Bad MAC enable reason = %x, rid = %x,"
+                        " offset = %d", rsp.rsp0, rsp.rsp1, rsp.rsp2 );
                 return ERROR;
         }
 
@@ -3749,8 +3896,8 @@ static u16 issuecommand(struct airo_info *ai, Cmd *pCmd, Resp *pRsp) {
         }
 
         if ( max_tries == -1 ) {
-                printk( KERN_ERR
-                        "airo: Max tries exceeded when issueing command\n" );
+                airo_print_err(ai->dev->name,
+                        "Max tries exceeded when issueing command");
                 if (IN4500(ai, COMMAND) & COMMAND_BUSY)
                         OUT4500(ai, EVACK, EV_CLEARCOMMANDBUSY);
                 return ERROR;
@@ -3762,11 +3909,11 @@ static u16 issuecommand(struct airo_info *ai, Cmd *pCmd, Resp *pRsp) {
         pRsp->rsp1 = IN4500(ai, RESP1);
         pRsp->rsp2 = IN4500(ai, RESP2);
         if ((pRsp->status & 0xff00)!=0 && pCmd->cmd != CMD_SOFTRESET) {
-                printk (KERN_ERR "airo: cmd= %x\n", pCmd->cmd);
-                printk (KERN_ERR "airo: status= %x\n", pRsp->status);
-                printk (KERN_ERR "airo: Rsp0= %x\n", pRsp->rsp0);
-                printk (KERN_ERR "airo: Rsp1= %x\n", pRsp->rsp1);
-                printk (KERN_ERR "airo: Rsp2= %x\n", pRsp->rsp2);
+                airo_print_err(ai->dev->name, "cmd= %x\n", pCmd->cmd);
+                airo_print_err(ai->dev->name, "status= %x\n", pRsp->status);
+                airo_print_err(ai->dev->name, "Rsp0= %x\n", pRsp->rsp0);
+                airo_print_err(ai->dev->name, "Rsp1= %x\n", pRsp->rsp1);
+                airo_print_err(ai->dev->name, "Rsp2= %x\n", pRsp->rsp2);
         }
 
         // clear stuck command busy if necessary
@@ -3799,15 +3946,15 @@ static int bap_setup(struct airo_info *ai, u16 rid, u16 offset, int whichbap )
                         }
                 } else if ( status & BAP_ERR ) {
                         /* invalid rid or offset */
-                        printk( KERN_ERR "airo: BAP error %x %d\n",
+                        airo_print_err(ai->dev->name, "BAP error %x %d",
                                 status, whichbap );
                         return ERROR;
                 } else if (status & BAP_DONE) { // success
                         return SUCCESS;
                 }
                 if ( !(max_tries--) ) {
-                        printk( KERN_ERR
-                                "airo: BAP setup error too many retries\n" );
+                        airo_print_err(ai->dev->name,
+                                "airo: BAP setup error too many retries\n");
                         return ERROR;
                 }
                 // -- PC4500 missed it, try again
@@ -3962,8 +4109,8 @@ static int PC4500_readrid(struct airo_info *ai, u16 rid, void *pBuf, int len, in
                 len = min(len, (int)le16_to_cpu(*(u16*)pBuf)) - 2;
 
                 if ( len <= 2 ) {
-                        printk( KERN_ERR
-                        "airo: Rid %x has a length of %d which is too short\n",
+                        airo_print_err(ai->dev->name,
+                                "Rid %x has a length of %d which is too short",
                                 (int)rid, (int)len );
                         rc = ERROR;
                         goto done;
@@ -3996,8 +4143,8 @@ static int PC4500_writerid(struct airo_info *ai, u16 rid,
                 Resp rsp;
 
                 if (test_bit(FLAG_ENABLED, &ai->flags) && (RID_WEP_TEMP != rid))
-                        printk(KERN_ERR
-                                "%s: MAC should be disabled (rid=%04x)\n",
+                        airo_print_err(ai->dev->name,
+                                "%s: MAC should be disabled (rid=%04x)",
                                 __FUNCTION__, rid);
                 memset(&cmd, 0, sizeof(cmd));
                 memset(&rsp, 0, sizeof(rsp));
@@ -4013,7 +4160,7 @@ static int PC4500_writerid(struct airo_info *ai, u16 rid,
                         &ai->config_desc.rid_desc, sizeof(Rid));
 
                 if (len < 4 || len > 2047) {
-                        printk(KERN_ERR "%s: len=%d\n",__FUNCTION__,len);
+                        airo_print_err(ai->dev->name, "%s: len=%d", __FUNCTION__, len);
                         rc = -1;
                 } else {
                         memcpy((char *)ai->config_desc.virtual_host_addr,
@@ -4021,10 +4168,10 @@ static int PC4500_writerid(struct airo_info *ai, u16 rid,
 
                         rc = issuecommand(ai, &cmd, &rsp);
                         if ((rc & 0xff00) != 0) {
-                                printk(KERN_ERR "%s: Write rid Error %d\n",
-                                        __FUNCTION__,rc);
-                                printk(KERN_ERR "%s: Cmd=%04x\n",
-                                                __FUNCTION__,cmd.cmd);
+                                airo_print_err(ai->dev->name, "%s: Write rid Error %d",
+                                                __FUNCTION__, rc);
+                                airo_print_err(ai->dev->name, "%s: Cmd=%04x",
+                                                __FUNCTION__, cmd.cmd);
                         }
 
                         if ((rsp.status & 0x7f00))
@@ -4123,7 +4270,7 @@ static int transmit_802_3_packet(struct airo_info *ai, int len, char *pPacket)
         len >>= 16;
 
         if (len <= ETH_ALEN * 2) {
-                printk( KERN_WARNING "Short packet %d\n", len );
+                airo_print_warn(ai->dev->name, "Short packet %d", len);
                 return ERROR;
         }
         len -= ETH_ALEN * 2;
@@ -4187,7 +4334,7 @@ static int transmit_802_11_packet(struct airo_info *ai, int len, char *pPacket)
         }
 
         if (len < hdrlen) {
-                printk( KERN_WARNING "Short packet %d\n", len );
+                airo_print_warn(ai->dev->name, "Short packet %d", len);
                 return ERROR;
         }
 
@@ -4584,15 +4731,14 @@ static int proc_stats_rid_open( struct inode *inode,
                     i*4<stats.len; i++){
                 if (!statsLabels[i]) continue;
                 if (j+strlen(statsLabels[i])+16>4096) {
-                        printk(KERN_WARNING
-                               "airo: Potentially disasterous buffer overflow averted!\n");
+                        airo_print_warn(apriv->dev->name,
+                               "Potentially disasterous buffer overflow averted!");
                         break;
                 }
                 j+=sprintf(data->rbuffer+j, "%s: %u\n", statsLabels[i], vals[i]);
         }
         if (i*4>=stats.len){
-                printk(KERN_WARNING
-                       "airo: Got a short rid\n");
+                airo_print_warn(apriv->dev->name, "Got a short rid");
         }
         data->readlen = j;
         return 0;
@@ -4754,7 +4900,7 @@ static void proc_config_on_close( struct inode *inode, struct file *file ) {
 
                         line += 14;
                         v = get_dec_u16(line, &i, 4);
-                        v = (v<0) ? 0 : ((v>2312) ? 2312 : v);
+                        v = (v<0) ? 0 : ((v>AIRO_DEF_MTU) ? AIRO_DEF_MTU : v);
                         ai->config.rtsThres = (u16)v;
                         set_bit (FLAG_COMMIT, &ai->flags);
                 } else if ( !strncmp( line, "TXMSDULifetime: ", 16 ) ) {
@@ -4788,7 +4934,7 @@ static void proc_config_on_close( struct inode *inode, struct file *file ) {
 
                         line += 15;
                         v = get_dec_u16(line, &i, 4);
-                        v = (v<256) ? 256 : ((v>2312) ? 2312 : v);
+                        v = (v<256) ? 256 : ((v>AIRO_DEF_MTU) ? AIRO_DEF_MTU : v);
                         v = v & 0xfffe; /* Make sure its even */
                         ai->config.fragThresh = (u16)v;
                         set_bit (FLAG_COMMIT, &ai->flags);
@@ -4798,8 +4944,7 @@ static void proc_config_on_close( struct inode *inode, struct file *file ) {
                         case 'd':  ai->config.modulation=MOD_DEFAULT; set_bit(FLAG_COMMIT, &ai->flags); break;
                         case 'c':  ai->config.modulation=MOD_CCK; set_bit(FLAG_COMMIT, &ai->flags); break;
                         case 'm':  ai->config.modulation=MOD_MOK; set_bit(FLAG_COMMIT, &ai->flags); break;
-                        default:
-                                printk( KERN_WARNING "airo: Unknown modulation\n" );
+                        default: airo_print_warn(ai->dev->name, "Unknown modulation");
                         }
                 } else if (!strncmp(line, "Preamble: ", 10)) {
                         line += 10;
@@ -4807,10 +4952,10 @@ static void proc_config_on_close( struct inode *inode, struct file *file ) {
                         case 'a': ai->config.preamble=PREAMBLE_AUTO; set_bit(FLAG_COMMIT, &ai->flags); break;
                         case 'l': ai->config.preamble=PREAMBLE_LONG; set_bit(FLAG_COMMIT, &ai->flags); break;
                         case 's': ai->config.preamble=PREAMBLE_SHORT; set_bit(FLAG_COMMIT, &ai->flags); break;
-                        default: printk(KERN_WARNING "airo: Unknown preamble\n");
+                        default: airo_print_warn(ai->dev->name, "Unknown preamble");
                         }
                 } else {
-                        printk( KERN_WARNING "Couldn't figure out %s\n", line );
+                        airo_print_warn(ai->dev->name, "Couldn't figure out %s", line);
                 }
                 while( line[0] && line[0] != '\n' ) line++;
                 if ( line[0] ) line++;
@@ -5076,7 +5221,7 @@ static void proc_wepkey_on_close( struct inode *inode, struct file *file ) {
                 }
                 j = 2;
         } else {
-                printk(KERN_ERR "airo:  WepKey passed invalid key index\n");
+                airo_print_err(ai->dev->name, "WepKey passed invalid key index");
                 return;
         }
 
@@ -5489,17 +5634,16 @@ static int __init airo_init_module( void )
         airo_entry->gid = proc_gid;
 
         for( i = 0; i < 4 && io[i] && irq[i]; i++ ) {
-                printk( KERN_INFO
-                        "airo:  Trying to configure ISA adapter at irq=%d io=0x%x\n",
-                        irq[i], io[i] );
+                airo_print_info("", "Trying to configure ISA adapter at irq=%d "
+                        "io=0x%x", irq[i], io[i] );
                 if (init_airo_card( irq[i], io[i], 0, NULL ))
                         have_isa_dev = 1;
         }
 
 #ifdef CONFIG_PCI
-        printk( KERN_INFO "airo:  Probing for PCI adapters\n" );
+        airo_print_info("", "Probing for PCI adapters");
         pci_register_driver(&airo_driver);
-        printk( KERN_INFO "airo:  Finished probing for PCI adapters\n" );
+        airo_print_info("", "Finished probing for PCI adapters");
 #endif
 
         /* Always exit with success, as we are a library module
@@ -5511,7 +5655,7 @@ static int __init airo_init_module( void )
 static void __exit airo_cleanup_module( void )
 {
         while( airo_devices ) {
-                printk( KERN_INFO "airo: Unregistering %s\n", airo_devices->dev->name );
+                airo_print_info(airo_devices->dev->name, "Unregistering...\n");
                 stop_airo_card( airo_devices->dev, 1 );
         }
 #ifdef CONFIG_PCI
@@ -5622,7 +5766,8 @@ static int airo_set_freq(struct net_device *dev,
                 /* We should do a better check than that,
                  * based on the card capability !!! */
                 if((channel < 1) || (channel > 14)) {
-                        printk(KERN_DEBUG "%s: New channel value of %d is invalid!\n", dev->name, fwrq->m);
+                        airo_print_dbg(dev->name, "New channel value of %d is invalid!",
+                                fwrq->m);
                         rc = -EINVAL;
                 } else {
                         readConfigRid(local, 1);
@@ -5946,8 +6091,8 @@ static int airo_set_rts(struct net_device *dev,
         int rthr = vwrq->value;
 
         if(vwrq->disabled)
-                rthr = 2312;
-        if((rthr < 0) || (rthr > 2312)) {
+                rthr = AIRO_DEF_MTU;
+        if((rthr < 0) || (rthr > AIRO_DEF_MTU)) {
                 return -EINVAL;
         }
         readConfigRid(local, 1);
@@ -5970,7 +6115,7 @@ static int airo_get_rts(struct net_device *dev,
 
         readConfigRid(local, 1);
         vwrq->value = local->config.rtsThres;
-        vwrq->disabled = (vwrq->value >= 2312);
+        vwrq->disabled = (vwrq->value >= AIRO_DEF_MTU);
         vwrq->fixed = 1;
 
         return 0;
@@ -5989,8 +6134,8 @@ static int airo_set_frag(struct net_device *dev,
         int fthr = vwrq->value;
 
         if(vwrq->disabled)
-                fthr = 2312;
-        if((fthr < 256) || (fthr > 2312)) {
+                fthr = AIRO_DEF_MTU;
+        if((fthr < 256) || (fthr > AIRO_DEF_MTU)) {
                 return -EINVAL;
         }
         fthr &= ~0x1;   /* Get an even value - is it really needed ??? */
@@ -6014,7 +6159,7 @@ static int airo_get_frag(struct net_device *dev,
 
         readConfigRid(local, 1);
         vwrq->value = local->config.fragThresh;
-        vwrq->disabled = (vwrq->value >= 2312);
+        vwrq->disabled = (vwrq->value >= AIRO_DEF_MTU);
         vwrq->fixed = 1;
 
         return 0;
@@ -6709,9 +6854,9 @@ static int airo_get_range(struct net_device *dev,
                 range->throughput = 1500 * 1000;
 
         range->min_rts = 0;
-        range->max_rts = 2312;
+        range->max_rts = AIRO_DEF_MTU;
         range->min_frag = 256;
-        range->max_frag = 2312;
+        range->max_frag = AIRO_DEF_MTU;
 
         if(cap_rid.softCap & 2) {
                 // WEP: RC4 40 bits
@@ -6972,6 +7117,7 @@ static int airo_set_scan(struct net_device *dev,
         struct airo_info *ai = dev->priv;
         Cmd cmd;
         Resp rsp;
+        int wake = 0;
 
         /* Note : you may have realised that, as this is a SET operation,
          * this is privileged and therefore a normal user can't
@@ -6981,17 +7127,25 @@ static int airo_set_scan(struct net_device *dev,
          * Jean II */
         if (ai->flags & FLAG_RADIO_MASK) return -ENETDOWN;
 
+        if (down_interruptible(&ai->sem))
+                return -ERESTARTSYS;
+
+        /* If there's already a scan in progress, don't
+         * trigger another one. */
+        if (ai->scan_timeout > 0)
+                goto out;
+
         /* Initiate a scan command */
         memset(&cmd, 0, sizeof(cmd));
         cmd.cmd=CMD_LISTBSS;
-        if (down_interruptible(&ai->sem))
-                return -ERESTARTSYS;
         issuecommand(ai, &cmd, &rsp);
-        ai->scan_timestamp = jiffies;
-        up(&ai->sem);
-
-        /* At this point, just return to the user. */
+        ai->scan_timeout = RUN_AT(3*HZ);
+        wake = 1;
 
+out:
+        up(&ai->sem);
+        if (wake)
+                wake_up_interruptible(&ai->thr_wait);
         return 0;
 }
 
@@ -7111,59 +7265,38 @@ static int airo_get_scan(struct net_device *dev,
                          char *extra)
 {
         struct airo_info *ai = dev->priv;
-        BSSListRid BSSList;
-        int rc;
+        BSSListElement *net;
+        int err = 0;
         char *current_ev = extra;
 
-        /* When we are associated again, the scan has surely finished.
-         * Just in case, let's make sure enough time has elapsed since
-         * we started the scan. - Javier */
-        if(ai->scan_timestamp && time_before(jiffies,ai->scan_timestamp+3*HZ)) {
-                /* Important note : we don't want to block the caller
-                 * until results are ready for various reasons.
-                 * First, managing wait queues is complex and racy
-                 * (there may be multiple simultaneous callers).
-                 * Second, we grab some rtnetlink lock before comming
-                 * here (in dev_ioctl()).
-                 * Third, the caller can wait on the Wireless Event
-                 * - Jean II */
+        /* If a scan is in-progress, return -EAGAIN */
+        if (ai->scan_timeout > 0)
                 return -EAGAIN;
-        }
-        ai->scan_timestamp = 0;
 
-        /* There's only a race with proc_BSSList_open(), but its
-         * consequences are begnign. So I don't bother fixing it - Javier */
-
-        /* Try to read the first entry of the scan result */
-        rc = PC4500_readrid(ai, RID_BSSLISTFIRST, &BSSList, sizeof(BSSList), 1);
-        if((rc) || (BSSList.index == 0xffff)) {
-                /* Client error, no scan results...
-                 * The caller need to restart the scan. */
-                return -ENODATA;
-        }
+        if (down_interruptible(&ai->sem))
+                return -EAGAIN;
 
-        /* Read and parse all entries */
-        while((!rc) && (BSSList.index != 0xffff)) {
+        list_for_each_entry (net, &ai->network_list, list) {
                 /* Translate to WE format this entry */
                 current_ev = airo_translate_scan(dev, current_ev,
                                                  extra + dwrq->length,
-                                                 &BSSList);
+                                                 &net->bss);
 
                 /* Check if there is space for one more entry */
                 if((extra + dwrq->length - current_ev) <= IW_EV_ADDR_LEN) {
                         /* Ask user space to try again with a bigger buffer */
-                        return -E2BIG;
+                        err = -E2BIG;
+                        goto out;
                 }
-
-                /* Read next entry */
-                rc = PC4500_readrid(ai, RID_BSSLISTNEXT,
-                                    &BSSList, sizeof(BSSList), 1);
         }
+
         /* Length of data */
         dwrq->length = (current_ev - extra);
         dwrq->flags = 0;        /* todo */
 
-        return 0;
+out:
+        up(&ai->sem);
+        return err;
 }
 
 /*------------------------------------------------------------------*/
@@ -7711,7 +7844,7 @@ static int cmdreset(struct airo_info *ai) {
         disable_MAC(ai, 1);
 
         if(!waitbusy (ai)){
-                printk(KERN_INFO "Waitbusy hang before RESET\n");
+                airo_print_info(ai->dev->name, "Waitbusy hang before RESET");
                 return -EBUSY;
         }
 
@@ -7720,7 +7853,7 @@ static int cmdreset(struct airo_info *ai) {
         ssleep(1);                      /* WAS 600 12/7/00 */
 
         if(!waitbusy (ai)){
-                printk(KERN_INFO "Waitbusy hang AFTER RESET\n");
+                airo_print_info(ai->dev->name, "Waitbusy hang AFTER RESET");
                 return -EBUSY;
         }
         return 0;
@@ -7748,7 +7881,7 @@ static int setflashmode (struct airo_info *ai) {
 
         if(!waitbusy(ai)) {
                 clear_bit (FLAG_FLASHING, &ai->flags);
-                printk(KERN_INFO "Waitbusy hang after setflash mode\n");
+                airo_print_info(ai->dev->name, "Waitbusy hang after setflash mode");
                 return -EIO;
         }
         return 0;
@@ -7777,7 +7910,7 @@ static int flashpchar(struct airo_info *ai,int byte,int dwelltime) {
 
         /* timeout for busy clear wait */
         if(waittime <= 0 ){
-                printk(KERN_INFO "flash putchar busywait timeout! \n");
+                airo_print_info(ai->dev->name, "flash putchar busywait timeout!");
                 return -EBUSY;
         }
 
@@ -7866,7 +7999,7 @@ static int flashrestart(struct airo_info *ai,struct net_device *dev){
         if (!test_bit(FLAG_MPI,&ai->flags))
                 for( i = 0; i < MAX_FIDS; i++ ) {
                         ai->fids[i] = transmit_allocate
-                                ( ai, 2312, i >= MAX_FIDS / 2 );
+                                ( ai, AIRO_DEF_MTU, i >= MAX_FIDS / 2 );
                 }
 
         ssleep(1);                      /* Added 12/7/00 */
diff --git a/drivers/net/wireless/hostap/hostap_ap.c b/drivers/net/wireless/hostap/hostap_ap.c
index 753a1de666..06c3fa32b3 100644
--- a/drivers/net/wireless/hostap/hostap_ap.c
+++ b/drivers/net/wireless/hostap/hostap_ap.c
@@ -3141,7 +3141,7 @@ int hostap_add_sta(struct ap_data *ap, u8 *sta_addr)
         if (ret == 1) {
                 sta = ap_add_sta(ap, sta_addr);
                 if (!sta)
-                        ret = -1;
+                        return -1;
                 sta->flags = WLAN_STA_AUTH | WLAN_STA_ASSOC;
                 sta->ap = 1;
                 memset(sta->supported_rates, 0, sizeof(sta->supported_rates));
diff --git a/drivers/net/wireless/hostap/hostap_cs.c b/drivers/net/wireless/hostap/hostap_cs.c
index f8f4503475..d335b25092 100644
--- a/drivers/net/wireless/hostap/hostap_cs.c
+++ b/drivers/net/wireless/hostap/hostap_cs.c
@@ -585,8 +585,6 @@ static int prism2_config(dev_link_t *link)
         parse = kmalloc(sizeof(cisparse_t), GFP_KERNEL);
         hw_priv = kmalloc(sizeof(*hw_priv), GFP_KERNEL);
         if (parse == NULL || hw_priv == NULL) {
-                kfree(parse);
-                kfree(hw_priv);
                 ret = -ENOMEM;
                 goto failed;
         }
diff --git a/drivers/net/wireless/hostap/hostap_hw.c b/drivers/net/wireless/hostap/hostap_hw.c
index b1f142d9e2..328e9a1d13 100644
--- a/drivers/net/wireless/hostap/hostap_hw.c
+++ b/drivers/net/wireless/hostap/hostap_hw.c
@@ -928,15 +928,15 @@ static int hfa384x_set_rid(struct net_device *dev, u16 rid, void *buf, int len)
 
         res = hfa384x_cmd(dev, HFA384X_CMDCODE_ACCESS_WRITE, rid, NULL, NULL);
         up(&local->rid_bap_sem);
+
         if (res) {
                 printk(KERN_DEBUG "%s: hfa384x_set_rid: CMDCODE_ACCESS_WRITE "
                        "failed (res=%d, rid=%04x, len=%d)\n",
                        dev->name, res, rid, len);
-                return res;
-        }
 
-        if (res == -ETIMEDOUT)
-                prism2_hw_reset(dev);
+                if (res == -ETIMEDOUT)
+                        prism2_hw_reset(dev);
+        }
 
         return res;
 }
diff --git a/drivers/net/wireless/hostap/hostap_ioctl.c b/drivers/net/wireless/hostap/hostap_ioctl.c
index f3e0ce1ee0..8b37e824df 100644
--- a/drivers/net/wireless/hostap/hostap_ioctl.c
+++ b/drivers/net/wireless/hostap/hostap_ioctl.c
@@ -3358,10 +3358,6 @@ static int prism2_ioctl_siwencodeext(struct net_device *dev,
         if (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) {
                 if (!sta_ptr)
                         local->tx_keyidx = i;
-                else if (i) {
-                        ret = -EINVAL;
-                        goto done;
-                }
         }
 
 
diff --git a/drivers/net/wireless/hostap/hostap_pci.c b/drivers/net/wireless/hostap/hostap_pci.c
index 2e85bdced2..194f070975 100644
--- a/drivers/net/wireless/hostap/hostap_pci.c
+++ b/drivers/net/wireless/hostap/hostap_pci.c
@@ -307,7 +307,7 @@ static int prism2_pci_probe(struct pci_dev *pdev,
         memset(hw_priv, 0, sizeof(*hw_priv));
 
         if (pci_enable_device(pdev))
-                return -EIO;
+                goto err_out_free;
 
         phymem = pci_resource_start(pdev, 0);
 
@@ -368,6 +368,8 @@ static int prism2_pci_probe(struct pci_dev *pdev,
  err_out_disable:
         pci_disable_device(pdev);
         prism2_free_local_data(dev);
+
+ err_out_free:
         kfree(hw_priv);
 
         return -ENODEV;
diff --git a/drivers/net/wireless/hostap/hostap_plx.c b/drivers/net/wireless/hostap/hostap_plx.c
index 94fe2449f0..edaaa943eb 100644
--- a/drivers/net/wireless/hostap/hostap_plx.c
+++ b/drivers/net/wireless/hostap/hostap_plx.c
@@ -368,7 +368,7 @@ static int prism2_plx_check_cis(void __iomem *attr_mem, int attr_len,
 
                 switch (cis[pos]) {
                 case CISTPL_CONFIG:
-                        if (cis[pos + 1] < 1)
+                        if (cis[pos + 1] < 2)
                                 goto cis_error;
                         rmsz = (cis[pos + 2] & 0x3c) >> 2;
                         rasz = cis[pos + 2] & 0x03;
@@ -390,7 +390,7 @@ static int prism2_plx_check_cis(void __iomem *attr_mem, int attr_len,
                         break;
 
                 case CISTPL_MANFID:
-                        if (cis[pos + 1] < 4)
+                        if (cis[pos + 1] < 5)
                                 goto cis_error;
                         manfid1 = cis[pos + 2] + (cis[pos + 3] << 8);
                         manfid2 = cis[pos + 4] + (cis[pos + 5] << 8);
@@ -452,7 +452,7 @@ static int prism2_plx_probe(struct pci_dev *pdev,
         memset(hw_priv, 0, sizeof(*hw_priv));
 
         if (pci_enable_device(pdev))
-                return -EIO;
+                goto err_out_free;
 
         /* National Datacomm NCP130 based on TMD7160, not PLX9052. */
         tmd7160 = (pdev->vendor == 0x15e8) && (pdev->device == 0x0131);
@@ -567,9 +567,6 @@ static int prism2_plx_probe(struct pci_dev *pdev,
         return hostap_hw_ready(dev);
 
  fail:
-        prism2_free_local_data(dev);
-        kfree(hw_priv);
-
         if (irq_registered && dev)
                 free_irq(dev->irq, dev);
 
@@ -577,6 +574,10 @@ static int prism2_plx_probe(struct pci_dev *pdev,
                 iounmap(attr_mem);
 
         pci_disable_device(pdev);
+        prism2_free_local_data(dev);
+
+ err_out_free:
+        kfree(hw_priv);
 
         return -ENODEV;
 }
diff --git a/drivers/net/wireless/prism54/oid_mgt.c b/drivers/net/wireless/prism54/oid_mgt.c
index eea2f04c8c..ebb2387858 100644
--- a/drivers/net/wireless/prism54/oid_mgt.c
+++ b/drivers/net/wireless/prism54/oid_mgt.c
@@ -332,7 +332,7 @@ mgt_le_to_cpu(int type, void *data)
         case OID_TYPE_ATTACH:{
                         struct obj_attachment *attach = data;
                         attach->id = le16_to_cpu(attach->id);
-                        attach->size = le16_to_cpu(attach->size);; 
+                        attach->size = le16_to_cpu(attach->size);
                         break;
         }
         case OID_TYPE_SSID:
@@ -401,7 +401,7 @@ mgt_cpu_to_le(int type, void *data)
         case OID_TYPE_ATTACH:{
                         struct obj_attachment *attach = data;
                         attach->id = cpu_to_le16(attach->id);
-                        attach->size = cpu_to_le16(attach->size);; 
+                        attach->size = cpu_to_le16(attach->size);
                         break;
         }
         case OID_TYPE_SSID:
diff --git a/drivers/net/wireless/spectrum_cs.c b/drivers/net/wireless/spectrum_cs.c
index fee4be1ce8..5fa6fbe35b 100644
--- a/drivers/net/wireless/spectrum_cs.c
+++ b/drivers/net/wireless/spectrum_cs.c
@@ -147,7 +147,7 @@ struct pdi {
         __le16 _len;            /* length of ID and data, in words */
         __le16 _id;             /* record ID */
         char data[0];           /* plug data */
-} __attribute__ ((packed));;
+} __attribute__ ((packed));
 
 
 /* Functions for access to little-endian data */
diff --git a/drivers/oprofile/cpu_buffer.c b/drivers/oprofile/cpu_buffer.c
index 78193e4bbd..330d3869b4 100644
--- a/drivers/oprofile/cpu_buffer.c
+++ b/drivers/oprofile/cpu_buffer.c
@@ -38,9 +38,8 @@ void free_cpu_buffers(void)
 {
         int i;
  
-        for_each_online_cpu(i) {
+        for_each_online_cpu(i)
                 vfree(cpu_buffer[i].buffer);
-        }
 }
 
 int alloc_cpu_buffers(void)
diff --git a/drivers/pci/Kconfig b/drivers/pci/Kconfig
index f187fd8aee..4d762fc487 100644
--- a/drivers/pci/Kconfig
+++ b/drivers/pci/Kconfig
@@ -11,24 +11,11 @@ config PCI_MSI
            generate an interrupt using an inbound Memory Write on its
            PCI bus instead of asserting a device IRQ pin.
 
-           If you don't know what to do here, say N.
-
-config PCI_LEGACY_PROC
-        bool "Legacy /proc/pci interface"
-        depends on PCI
-        ---help---
-          This feature enables a procfs file -- /proc/pci -- that provides a 
-          summary of PCI devices in the system. 
-
-          This feature has been deprecated as of v2.5.53, in favor of using the 
-          tool lspci(8). This feature may be removed at a future date. 
+           Use of PCI MSI interrupts can be disabled at kernel boot time
+           by using the 'pci=nomsi' option.  This disables MSI for the
+           entire system.
 
-          lspci can provide the same data, as well as much more. lspci is a part of
-          the pci-utils package, which should be installed by your distribution. 
-          See <file:Documentation/Changes> for information on where to get the latest
-          version. 
-
-          When in doubt, say N.
+           If you don't know what to do here, say N.
 
 config PCI_DEBUG
         bool "PCI Debugging"
diff --git a/drivers/pci/hotplug/Makefile b/drivers/pci/hotplug/Makefile
index 3c71e3077f..421cfffb17 100644
--- a/drivers/pci/hotplug/Makefile
+++ b/drivers/pci/hotplug/Makefile
@@ -22,6 +22,9 @@ ifdef CONFIG_HOTPLUG_PCI_CPCI
 pci_hotplug-objs        +=      cpci_hotplug_core.o     \
                                 cpci_hotplug_pci.o
 endif
+ifdef CONFIG_ACPI
+pci_hotplug-objs        +=      acpi_pcihp.o
+endif
 
 cpqphp-objs             :=      cpqphp_core.o   \
                                 cpqphp_ctrl.o   \
@@ -37,7 +40,8 @@ ibmphp-objs		:=	ibmphp_core.o	\
                                 ibmphp_hpc.o
 
 acpiphp-objs            :=      acpiphp_core.o  \
-                                acpiphp_glue.o
+                                acpiphp_glue.o  \
+                                acpiphp_dock.o
 
 rpaphp-objs             :=      rpaphp_core.o   \
                                 rpaphp_pci.o    \
@@ -50,23 +54,9 @@ pciehp-objs		:=	pciehp_core.o	\
                                 pciehp_ctrl.o   \
                                 pciehp_pci.o    \
                                 pciehp_hpc.o
-ifdef CONFIG_ACPI
-        pciehp-objs += pciehprm_acpi.o
-else
-        pciehp-objs += pciehprm_nonacpi.o
-endif
 
 shpchp-objs             :=      shpchp_core.o   \
                                 shpchp_ctrl.o   \
                                 shpchp_pci.o    \
                                 shpchp_sysfs.o  \
                                 shpchp_hpc.o
-ifdef CONFIG_ACPI
-        shpchp-objs += shpchprm_acpi.o
-else
-        ifdef CONFIG_HOTPLUG_PCI_SHPC_PHPRM_LEGACY
-                shpchp-objs += shpchprm_legacy.o
-        else
-                shpchp-objs += shpchprm_nonacpi.o
-        endif
-endif
diff --git a/drivers/pci/hotplug/shpchprm_acpi.c b/drivers/pci/hotplug/acpi_pcihp.c
index 17145e5222..39af9c325f 100644
--- a/drivers/pci/hotplug/shpchprm_acpi.c
+++ b/drivers/pci/hotplug/acpi_pcihp.c
@@ -1,7 +1,7 @@
 /*
- * SHPCHPRM ACPI: PHP Resource Manager for ACPI platform
+ * Common ACPI functions for hot plug platforms
  *
- * Copyright (C) 2003-2004 Intel Corporation
+ * Copyright (C) 2006 Intel Corporation
  *
  * All rights reserved.
  *
@@ -31,26 +31,12 @@
 #include <acpi/acpi.h>
 #include <acpi/acpi_bus.h>
 #include <acpi/actypes.h>
-#include "shpchp.h"
+#include "pci_hotplug.h"
 
 #define METHOD_NAME__SUN        "_SUN"
 #define METHOD_NAME__HPP        "_HPP"
 #define METHOD_NAME_OSHP        "OSHP"
 
-static u8 * acpi_path_name( acpi_handle handle)
-{
-        acpi_status             status;
-        static u8       path_name[ACPI_PATHNAME_MAX];
-        struct acpi_buffer              ret_buf = { ACPI_PATHNAME_MAX, path_name };
-
-        memset(path_name, 0, sizeof (path_name));
-        status = acpi_get_name(handle, ACPI_FULL_PATHNAME, &ret_buf);
-
-        if (ACPI_FAILURE(status))
-                return NULL;
-        else
-                return path_name;       
-}
 
 static acpi_status
 acpi_run_hpp(acpi_handle handle, struct hotplug_params *hpp)
@@ -58,18 +44,21 @@ acpi_run_hpp(acpi_handle handle, struct hotplug_params *hpp)
         acpi_status             status;
         u8                      nui[4];
         struct acpi_buffer      ret_buf = { 0, NULL};
+        struct acpi_buffer      string = { ACPI_ALLOCATE_BUFFER, NULL };
         union acpi_object       *ext_obj, *package;
-        u8                      *path_name = acpi_path_name(handle);
         int                     i, len = 0;
 
+        acpi_get_name(handle, ACPI_FULL_PATHNAME, &string);
+
         /* get _hpp */
         status = acpi_evaluate_object(handle, METHOD_NAME__HPP, NULL, &ret_buf);
         switch (status) {
         case AE_BUFFER_OVERFLOW:
                 ret_buf.pointer = kmalloc (ret_buf.length, GFP_KERNEL);
                 if (!ret_buf.pointer) {
-                        err ("%s:%s alloc for _HPP fail\n", __FUNCTION__,
-                                        path_name);
+                        printk(KERN_ERR "%s:%s alloc for _HPP fail\n",
+                                __FUNCTION__, (char *)string.pointer);
+                        acpi_os_free(string.pointer);
                         return AE_NO_MEMORY;
                 }
                 status = acpi_evaluate_object(handle, METHOD_NAME__HPP,
@@ -78,16 +67,17 @@ acpi_run_hpp(acpi_handle handle, struct hotplug_params *hpp)
                         break;
         default:
                 if (ACPI_FAILURE(status)) {
-                        dbg("%s:%s _HPP fail=0x%x\n", __FUNCTION__,
-                                        path_name, status);
+                        pr_debug("%s:%s _HPP fail=0x%x\n", __FUNCTION__,
+                                (char *)string.pointer, status);
+                        acpi_os_free(string.pointer);
                         return status;
                 }
         }
 
         ext_obj = (union acpi_object *) ret_buf.pointer;
         if (ext_obj->type != ACPI_TYPE_PACKAGE) {
-                err ("%s:%s _HPP obj not a package\n", __FUNCTION__,
-                                path_name);
+                printk(KERN_ERR "%s:%s _HPP obj not a package\n", __FUNCTION__,
+                                (char *)string.pointer);
                 status = AE_ERROR;
                 goto free_and_return;
         }
@@ -101,8 +91,8 @@ acpi_run_hpp(acpi_handle handle, struct hotplug_params *hpp)
                         nui[i] = (u8)ext_obj->integer.value;
                         break;
                 default:
-                        err ("%s:%s _HPP obj type incorrect\n", __FUNCTION__,
-                                        path_name);
+                        printk(KERN_ERR "%s:%s _HPP obj type incorrect\n",
+                                __FUNCTION__, (char *)string.pointer);
                         status = AE_ERROR;
                         goto free_and_return;
                 }
@@ -113,54 +103,52 @@ acpi_run_hpp(acpi_handle handle, struct hotplug_params *hpp)
         hpp->enable_serr = nui[2];
         hpp->enable_perr = nui[3];
 
-        dbg("  _HPP: cache_line_size=0x%x\n", hpp->cache_line_size);
-        dbg("  _HPP: latency timer  =0x%x\n", hpp->latency_timer);
-        dbg("  _HPP: enable SERR    =0x%x\n", hpp->enable_serr);
-        dbg("  _HPP: enable PERR    =0x%x\n", hpp->enable_perr);
+        pr_debug("  _HPP: cache_line_size=0x%x\n", hpp->cache_line_size);
+        pr_debug("  _HPP: latency timer  =0x%x\n", hpp->latency_timer);
+        pr_debug("  _HPP: enable SERR    =0x%x\n", hpp->enable_serr);
+        pr_debug("  _HPP: enable PERR    =0x%x\n", hpp->enable_perr);
 
 free_and_return:
-        kfree(ret_buf.pointer);
+        acpi_os_free(string.pointer);
+        acpi_os_free(ret_buf.pointer);
         return status;
 }
 
-static void acpi_run_oshp(acpi_handle handle)
+
+
+/* acpi_run_oshp - get control of hotplug from the firmware
+ *
+ * @handle - the handle of the hotplug controller.
+ */
+acpi_status acpi_run_oshp(acpi_handle handle)
 {
         acpi_status             status;
-        u8                      *path_name = acpi_path_name(handle);
+        struct acpi_buffer      string = { ACPI_ALLOCATE_BUFFER, NULL };
+
+        acpi_get_name(handle, ACPI_FULL_PATHNAME, &string);
 
         /* run OSHP */
         status = acpi_evaluate_object(handle, METHOD_NAME_OSHP, NULL, NULL);
-        if (ACPI_FAILURE(status)) {
-                err("%s:%s OSHP fails=0x%x\n", __FUNCTION__, path_name,
-                                status);
-        } else {
-                dbg("%s:%s OSHP passes\n", __FUNCTION__, path_name);
-        }
-}
-
-int shpchprm_get_physical_slot_number(struct controller *ctrl, u32 *sun, u8 busnum, u8 devnum)
-{
-        int offset = devnum - ctrl->slot_device_offset;
+        if (ACPI_FAILURE(status))
+                printk(KERN_ERR "%s:%s OSHP fails=0x%x\n", __FUNCTION__,
+                        (char *)string.pointer, status);
+        else
+                pr_debug("%s:%s OSHP passes\n", __FUNCTION__,
+                        (char *)string.pointer);
 
-        dbg("%s: ctrl->slot_num_inc %d, offset %d\n", __FUNCTION__, ctrl->slot_num_inc, offset);
-        *sun = (u8) (ctrl->first_slot + ctrl->slot_num_inc *offset);
-        return 0;
+        acpi_os_free(string.pointer);
+        return status;
 }
+EXPORT_SYMBOL_GPL(acpi_run_oshp);
+
 
-void get_hp_hw_control_from_firmware(struct pci_dev *dev)
-{
-        /*
-         * OSHP is an optional ACPI firmware control method. If present,
-         * we need to run it to inform BIOS that we will control SHPC
-         * hardware from now on.
-         */
-        acpi_handle handle = DEVICE_ACPI_HANDLE(&(dev->dev));
-        if (!handle)
-                return;
-        acpi_run_oshp(handle);
-}
 
-void get_hp_params_from_firmware(struct pci_dev *dev,
+/* acpi_get_hp_params_from_firmware
+ *
+ * @dev - the pci_dev of the newly added device
+ * @hpp - allocated by the caller
+ */
+acpi_status acpi_get_hp_params_from_firmware(struct pci_dev *dev,
                 struct hotplug_params *hpp)
 {
         acpi_status status = AE_NOT_FOUND;
@@ -182,5 +170,42 @@ void get_hp_params_from_firmware(struct pci_dev *dev,
                 /* Check if a parent object supports _HPP */
                 pdev = pdev->bus->parent->self;
         }
+        return status;
 }
+EXPORT_SYMBOL_GPL(acpi_get_hp_params_from_firmware);
 
+
+/* acpi_root_bridge - check to see if this acpi object is a root bridge
+ *
+ * @handle - the acpi object in question.
+ */
+int acpi_root_bridge(acpi_handle handle)
+{
+        acpi_status status;
+        struct acpi_device_info *info;
+        struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
+        int i;
+
+        status = acpi_get_object_info(handle, &buffer);
+        if (ACPI_SUCCESS(status)) {
+                info = buffer.pointer;
+                if ((info->valid & ACPI_VALID_HID) &&
+                        !strcmp(PCI_ROOT_HID_STRING,
+                                        info->hardware_id.value)) {
+                        acpi_os_free(buffer.pointer);
+                        return 1;
+                }
+                if (info->valid & ACPI_VALID_CID) {
+                        for (i=0; i < info->compatibility_id.count; i++) {
+                                if (!strcmp(PCI_ROOT_HID_STRING,
+                                        info->compatibility_id.id[i].value)) {
+                                        acpi_os_free(buffer.pointer);
+                                        return 1;
+                                }
+                        }
+                }
+                acpi_os_free(buffer.pointer);
+        }
+        return 0;
+}
+EXPORT_SYMBOL_GPL(acpi_root_bridge);
diff --git a/drivers/pci/hotplug/acpiphp.h b/drivers/pci/hotplug/acpiphp.h
index 293603e1b7..467ac70a46 100644
--- a/drivers/pci/hotplug/acpiphp.h
+++ b/drivers/pci/hotplug/acpiphp.h
@@ -37,6 +37,7 @@
 
 #include <linux/acpi.h>
 #include <linux/kobject.h>      /* for KOBJ_NAME_LEN */
+#include <linux/mutex.h>
 #include "pci_hotplug.h"
 
 #define dbg(format, arg...)                                     \
@@ -59,26 +60,10 @@ struct acpiphp_slot;
  * struct slot - slot information for each *physical* slot
  */
 struct slot {
-        u8 number;
         struct hotplug_slot     *hotplug_slot;
-        struct list_head        slot_list;
-
         struct acpiphp_slot     *acpi_slot;
 };
 
-/**
- * struct hpp_param - ACPI 2.0 _HPP Hot Plug Parameters
- * @cache_line_size in DWORD
- * @latency_timer in PCI clock
- * @enable_SERR 0 or 1
- * @enable_PERR 0 or 1
- */
-struct hpp_param {
-        u8 cache_line_size;
-        u8 latency_timer;
-        u8 enable_SERR;
-        u8 enable_PERR;
-};
 
 
 /**
@@ -102,7 +87,7 @@ struct acpiphp_bridge {
         struct pci_dev *pci_dev;
 
         /* ACPI 2.0 _HPP parameters */
-        struct hpp_param hpp;
+        struct hotplug_params hpp;
 
         spinlock_t res_lock;
 };
@@ -118,9 +103,9 @@ struct acpiphp_slot {
         struct acpiphp_bridge *bridge;  /* parent */
         struct list_head funcs;         /* one slot may have different
                                            objects (i.e. for each function) */
-        struct semaphore crit_sect;
+        struct slot *slot;
+        struct mutex crit_sect;
 
-        u32             id;             /* slot id (serial #) for hotplug core */
         u8              device;         /* pci device# */
 
         u32             sun;            /* ACPI _SUN (slot unique number) */
@@ -160,6 +145,25 @@ struct acpiphp_attention_info
         struct module *owner;
 };
 
+
+struct dependent_device {
+        struct list_head device_list;
+        struct list_head pci_list;
+        acpi_handle handle;
+        struct acpiphp_func *func;
+};
+
+
+struct acpiphp_dock_station {
+        acpi_handle handle;
+        u32 last_dock_time;
+        u32 flags;
+        struct acpiphp_func *dock_bridge;
+        struct list_head dependent_devices;
+        struct list_head pci_dependent_devices;
+};
+
+
 /* PCI bus bridge HID */
 #define ACPI_PCI_HOST_HID               "PNP0A03"
 
@@ -197,19 +201,27 @@ struct acpiphp_attention_info
 #define FUNC_HAS_PS1            (0x00000020)
 #define FUNC_HAS_PS2            (0x00000040)
 #define FUNC_HAS_PS3            (0x00000080)
+#define FUNC_HAS_DCK            (0x00000100)
+#define FUNC_IS_DD              (0x00000200)
+
+/* dock station flags */
+#define DOCK_DOCKING            (0x00000001)
+#define DOCK_HAS_BRIDGE         (0x00000002)
 
 /* function prototypes */
 
 /* acpiphp_core.c */
 extern int acpiphp_register_attention(struct acpiphp_attention_info*info);
 extern int acpiphp_unregister_attention(struct acpiphp_attention_info *info);
+extern int acpiphp_register_hotplug_slot(struct acpiphp_slot *slot);
+extern void acpiphp_unregister_hotplug_slot(struct acpiphp_slot *slot);
 
 /* acpiphp_glue.c */
 extern int acpiphp_glue_init (void);
 extern void acpiphp_glue_exit (void);
 extern int acpiphp_get_num_slots (void);
-extern struct acpiphp_slot *get_slot_from_id (int id);
 typedef int (*acpiphp_callback)(struct acpiphp_slot *slot, void *data);
+void handle_hotplug_event_func(acpi_handle, u32, void*);
 
 extern int acpiphp_enable_slot (struct acpiphp_slot *slot);
 extern int acpiphp_disable_slot (struct acpiphp_slot *slot);
@@ -219,6 +231,16 @@ extern u8 acpiphp_get_latch_status (struct acpiphp_slot *slot);
 extern u8 acpiphp_get_adapter_status (struct acpiphp_slot *slot);
 extern u32 acpiphp_get_address (struct acpiphp_slot *slot);
 
+/* acpiphp_dock.c */
+extern int find_dock_station(void);
+extern void remove_dock_station(void);
+extern void add_dependent_device(struct dependent_device *new_dd);
+extern void add_pci_dependent_device(struct dependent_device *new_dd);
+extern struct dependent_device *get_dependent_device(acpi_handle handle);
+extern int is_dependent_device(acpi_handle handle);
+extern int detect_dependent_devices(acpi_handle *bridge_handle);
+extern struct dependent_device *alloc_dependent_device(acpi_handle handle);
+
 /* variables */
 extern int acpiphp_debug;
 
diff --git a/drivers/pci/hotplug/acpiphp_core.c b/drivers/pci/hotplug/acpiphp_core.c
index 60c4c38047..4f1b0da8e4 100644
--- a/drivers/pci/hotplug/acpiphp_core.c
+++ b/drivers/pci/hotplug/acpiphp_core.c
@@ -44,8 +44,6 @@
 #include "pci_hotplug.h"
 #include "acpiphp.h"
 
-static LIST_HEAD(slot_list);
-
 #define MY_NAME "acpiphp"
 
 static int debug;
@@ -341,62 +339,53 @@ static void release_slot(struct hotplug_slot *hotplug_slot)
         kfree(slot);
 }
 
-/**
- * init_slots - initialize 'struct slot' structures for each slot
- *
- */
-static int __init init_slots(void)
+/* callback routine to initialize 'struct slot' for each slot */
+int acpiphp_register_hotplug_slot(struct acpiphp_slot *acpiphp_slot)
 {
         struct slot *slot;
+        struct hotplug_slot *hotplug_slot;
+        struct hotplug_slot_info *hotplug_slot_info;
         int retval = -ENOMEM;
-        int i;
-
-        for (i = 0; i < num_slots; ++i) {
-                slot = kmalloc(sizeof(struct slot), GFP_KERNEL);
-                if (!slot)
-                        goto error;
-                memset(slot, 0, sizeof(struct slot));
-
-                slot->hotplug_slot = kmalloc(sizeof(struct hotplug_slot), GFP_KERNEL);
-                if (!slot->hotplug_slot)
-                        goto error_slot;
-                memset(slot->hotplug_slot, 0, sizeof(struct hotplug_slot));
-
-                slot->hotplug_slot->info = kmalloc(sizeof(struct hotplug_slot_info), GFP_KERNEL);
-                if (!slot->hotplug_slot->info)
-                        goto error_hpslot;
-                memset(slot->hotplug_slot->info, 0, sizeof(struct hotplug_slot_info));
-
-                slot->hotplug_slot->name = kmalloc(SLOT_NAME_SIZE, GFP_KERNEL);
-                if (!slot->hotplug_slot->name)
-                        goto error_info;
-
-                slot->number = i;
-
-                slot->hotplug_slot->private = slot;
-                slot->hotplug_slot->release = &release_slot;
-                slot->hotplug_slot->ops = &acpi_hotplug_slot_ops;
-
-                slot->acpi_slot = get_slot_from_id(i);
-                slot->hotplug_slot->info->power_status = acpiphp_get_power_status(slot->acpi_slot);
-                slot->hotplug_slot->info->attention_status = 0;
-                slot->hotplug_slot->info->latch_status = acpiphp_get_latch_status(slot->acpi_slot);
-                slot->hotplug_slot->info->adapter_status = acpiphp_get_adapter_status(slot->acpi_slot);
-                slot->hotplug_slot->info->max_bus_speed = PCI_SPEED_UNKNOWN;
-                slot->hotplug_slot->info->cur_bus_speed = PCI_SPEED_UNKNOWN;
-
-                make_slot_name(slot);
-
-                retval = pci_hp_register(slot->hotplug_slot);
-                if (retval) {
-                        err("pci_hp_register failed with error %d\n", retval);
-                        goto error_name;
-                }
-
-                /* add slot to our internal list */
-                list_add(&slot->slot_list, &slot_list);
-                info("Slot [%s] registered\n", slot->hotplug_slot->name);
-        }
+
+        slot = kzalloc(sizeof(*slot), GFP_KERNEL);
+        if (!slot)
+                goto error;
+
+        slot->hotplug_slot = kzalloc(sizeof(*hotplug_slot), GFP_KERNEL);
+        if (!slot->hotplug_slot)
+                goto error_slot;
+
+        slot->hotplug_slot->info = kzalloc(sizeof(*hotplug_slot_info),
+                                           GFP_KERNEL);
+        if (!slot->hotplug_slot->info)
+                goto error_hpslot;
+
+        slot->hotplug_slot->name = kzalloc(SLOT_NAME_SIZE, GFP_KERNEL);
+        if (!slot->hotplug_slot->name)
+                goto error_info;
+
+        slot->hotplug_slot->private = slot;
+        slot->hotplug_slot->release = &release_slot;
+        slot->hotplug_slot->ops = &acpi_hotplug_slot_ops;
+
+        slot->acpi_slot = acpiphp_slot;
+        slot->hotplug_slot->info->power_status = acpiphp_get_power_status(slot->acpi_slot);
+        slot->hotplug_slot->info->attention_status = 0;
+        slot->hotplug_slot->info->latch_status = acpiphp_get_latch_status(slot->acpi_slot);
+        slot->hotplug_slot->info->adapter_status = acpiphp_get_adapter_status(slot->acpi_slot);
+        slot->hotplug_slot->info->max_bus_speed = PCI_SPEED_UNKNOWN;
+        slot->hotplug_slot->info->cur_bus_speed = PCI_SPEED_UNKNOWN;
+
+        acpiphp_slot->slot = slot;
+        make_slot_name(slot);
+
+        retval = pci_hp_register(slot->hotplug_slot);
+        if (retval) {
+                err("pci_hp_register failed with error %d\n", retval);
+                goto error_name;
+        }
+
+        info("Slot [%s] registered\n", slot->hotplug_slot->name);
 
         return 0;
 error_name:
@@ -412,42 +401,51 @@ error:
 }
 
 
-static void __exit cleanup_slots (void)
+void acpiphp_unregister_hotplug_slot(struct acpiphp_slot *acpiphp_slot)
 {
-        struct list_head *tmp, *n;
-        struct slot *slot;
+        struct slot *slot = acpiphp_slot->slot;
+        int retval = 0;
 
-        list_for_each_safe (tmp, n, &slot_list) {
-                /* memory will be freed in release_slot callback */
-                slot = list_entry(tmp, struct slot, slot_list);
-                list_del(&slot->slot_list);
-                pci_hp_deregister(slot->hotplug_slot);
-        }
+        info ("Slot [%s] unregistered\n", slot->hotplug_slot->name);
+
+        retval = pci_hp_deregister(slot->hotplug_slot);
+        if (retval)
+                err("pci_hp_deregister failed with error %d\n", retval);
 }
 
 
 static int __init acpiphp_init(void)
 {
         int retval;
+        int docking_station;
 
         info(DRIVER_DESC " version: " DRIVER_VERSION "\n");
 
         acpiphp_debug = debug;
 
+        docking_station = find_dock_station();
+
         /* read all the ACPI info from the system */
         retval = init_acpi();
-        if (retval)
-                return retval;
 
-        return init_slots();
+        /* if we have found a docking station, we should
+         * go ahead and load even if init_acpi has found
+         * no slots.  This handles the case when the _DCK
+         * method not defined under the actual dock bridge
+         */
+        if (docking_station)
+                return 0;
+        else
+                return retval;
 }
 
 
 static void __exit acpiphp_exit(void)
 {
-        cleanup_slots();
         /* deallocate internal data structures etc. */
         acpiphp_glue_exit();
+
+        remove_dock_station();
 }
 
 module_init(acpiphp_init);
diff --git a/drivers/pci/hotplug/acpiphp_dock.c b/drivers/pci/hotplug/acpiphp_dock.c
new file mode 100644
index 0000000000..4f1aaf1283
--- /dev/null
+++ b/drivers/pci/hotplug/acpiphp_dock.c
@@ -0,0 +1,438 @@
+/*
+ * ACPI PCI HotPlug dock functions to ACPI CA subsystem
+ *
+ * Copyright (C) 2006 Kristen Carlson Accardi (kristen.c.accardi@intel.com)
+ * Copyright (C) 2006 Intel Corporation
+ *
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
+ * NON INFRINGEMENT.  See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Send feedback to <kristen.c.accardi@intel.com>
+ *
+ */
+#include <linux/init.h>
+#include <linux/module.h>
+
+#include <linux/kernel.h>
+#include <linux/pci.h>
+#include <linux/smp_lock.h>
+#include <linux/mutex.h>
+
+#include "../pci.h"
+#include "pci_hotplug.h"
+#include "acpiphp.h"
+
+static struct acpiphp_dock_station *ds;
+#define MY_NAME "acpiphp_dock"
+
+
+int is_dependent_device(acpi_handle handle)
+{
+        return (get_dependent_device(handle) ? 1 : 0);
+}
+
+
+static acpi_status
+find_dependent_device(acpi_handle handle, u32 lvl, void *context, void **rv)
+{
+        int *count = (int *)context;
+
+        if (is_dependent_device(handle)) {
+                (*count)++;
+                return AE_CTRL_TERMINATE;
+        } else {
+                return AE_OK;
+        }
+}
+
+
+
+
+void add_dependent_device(struct dependent_device *new_dd)
+{
+        list_add_tail(&new_dd->device_list, &ds->dependent_devices);
+}
+
+
+void add_pci_dependent_device(struct dependent_device *new_dd)
+{
+        list_add_tail(&new_dd->pci_list, &ds->pci_dependent_devices);
+}
+
+
+
+struct dependent_device * get_dependent_device(acpi_handle handle)
+{
+        struct dependent_device *dd;
+
+        if (!ds)
+                return NULL;
+
+        list_for_each_entry(dd, &ds->dependent_devices, device_list) {
+                if (handle == dd->handle)
+                        return dd;
+        }
+        return NULL;
+}
+
+
+
+struct dependent_device *alloc_dependent_device(acpi_handle handle)
+{
+        struct dependent_device *dd;
+
+        dd = kzalloc(sizeof(*dd), GFP_KERNEL);
+        if (dd) {
+                INIT_LIST_HEAD(&dd->pci_list);
+                INIT_LIST_HEAD(&dd->device_list);
+                dd->handle = handle;
+        }
+        return dd;
+}
+
+
+
+static int is_dock(acpi_handle handle)
+{
+        acpi_status status;
+        acpi_handle tmp;
+
+        status = acpi_get_handle(handle, "_DCK", &tmp);
+        if (ACPI_FAILURE(status)) {
+                return 0;
+        }
+        return 1;
+}
+
+
+
+static int dock_present(void)
+{
+        unsigned long sta;
+        acpi_status status;
+
+        if (ds) {
+                status = acpi_evaluate_integer(ds->handle, "_STA", NULL, &sta);
+                if (ACPI_SUCCESS(status) && sta)
+                        return 1;
+        }
+        return 0;
+}
+
+
+
+static void eject_dock(void)
+{
+        struct acpi_object_list arg_list;
+        union acpi_object arg;
+
+        arg_list.count = 1;
+        arg_list.pointer = &arg;
+        arg.type = ACPI_TYPE_INTEGER;
+        arg.integer.value = 1;
+
+        if (ACPI_FAILURE(acpi_evaluate_object(ds->handle, "_EJ0",
+                                        &arg_list, NULL)) || dock_present())
+                warn("%s: failed to eject dock!\n", __FUNCTION__);
+
+        return;
+}
+
+
+
+
+static acpi_status handle_dock(int dock)
+{
+        acpi_status status;
+        struct acpi_object_list arg_list;
+        union acpi_object arg;
+        struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
+
+        dbg("%s: %s\n", __FUNCTION__, dock ? "docking" : "undocking");
+
+        /* _DCK method has one argument */
+        arg_list.count = 1;
+        arg_list.pointer = &arg;
+        arg.type = ACPI_TYPE_INTEGER;
+        arg.integer.value = dock;
+        status = acpi_evaluate_object(ds->handle, "_DCK",
+                                        &arg_list, &buffer);
+        if (ACPI_FAILURE(status))
+                err("%s: failed to execute _DCK\n", __FUNCTION__);
+        acpi_os_free(buffer.pointer);
+
+        return status;
+}
+
+
+
+static inline void dock(void)
+{
+        handle_dock(1);
+}
+
+
+
+static inline void undock(void)
+{
+        handle_dock(0);
+}
+
+
+
+/*
+ * the _DCK method can do funny things... and sometimes not
+ * hah-hah funny.
+ *
+ * TBD - figure out a way to only call fixups for
+ * systems that require them.
+ */
+static void post_dock_fixups(void)
+{
+        struct pci_bus *bus;
+        u32 buses;
+        struct dependent_device *dd;
+
+        list_for_each_entry(dd, &ds->pci_dependent_devices, pci_list) {
+                bus = dd->func->slot->bridge->pci_bus;
+
+                /* fixup bad _DCK function that rewrites
+                 * secondary bridge on slot
+                 */
+                pci_read_config_dword(bus->self,
+                                PCI_PRIMARY_BUS,
+                                &buses);
+
+                if (((buses >> 8) & 0xff) != bus->secondary) {
+                        buses = (buses & 0xff000000)
+                                | ((unsigned int)(bus->primary)     <<  0)
+                                | ((unsigned int)(bus->secondary)   <<  8)
+                                | ((unsigned int)(bus->subordinate) << 16);
+                        pci_write_config_dword(bus->self,
+                                        PCI_PRIMARY_BUS,
+                                        buses);
+                }
+        }
+}
+
+
+
+static void hotplug_pci(u32 type)
+{
+        struct dependent_device *dd;
+
+        list_for_each_entry(dd, &ds->pci_dependent_devices, pci_list)
+                handle_hotplug_event_func(dd->handle, type, dd->func);
+}
+
+
+
+static inline void begin_dock(void)
+{
+        ds->flags |= DOCK_DOCKING;
+}
+
+
+static inline void complete_dock(void)
+{
+        ds->flags &= ~(DOCK_DOCKING);
+        ds->last_dock_time = jiffies;
+}
+
+
+static int dock_in_progress(void)
+{
+        if (ds->flags & DOCK_DOCKING ||
+                ds->last_dock_time == jiffies) {
+                dbg("dock in progress\n");
+                return 1;
+        }
+        return 0;
+}
+
+
+
+static void
+handle_hotplug_event_dock(acpi_handle handle, u32 type, void *context)
+{
+        dbg("%s: enter\n", __FUNCTION__);
+
+        switch (type) {
+                case ACPI_NOTIFY_BUS_CHECK:
+                        dbg("BUS Check\n");
+                        if (!dock_in_progress() && dock_present()) {
+                                begin_dock();
+                                dock();
+                                if (!dock_present()) {
+                                        err("Unable to dock!\n");
+                                        break;
+                                }
+                                post_dock_fixups();
+                                hotplug_pci(type);
+                                complete_dock();
+                        }
+                        break;
+                case ACPI_NOTIFY_EJECT_REQUEST:
+                        dbg("EJECT request\n");
+                        if (!dock_in_progress() && dock_present()) {
+                                hotplug_pci(type);
+                                undock();
+                                eject_dock();
+                                if (dock_present())
+                                        err("Unable to undock!\n");
+                        }
+                        break;
+        }
+}
+
+
+
+
+static acpi_status
+find_dock_ejd(acpi_handle handle, u32 lvl, void *context, void **rv)
+{
+        acpi_status status;
+        acpi_handle tmp;
+        acpi_handle dck_handle = (acpi_handle) context;
+        char objname[64];
+        struct acpi_buffer buffer = { .length = sizeof(objname),
+                                      .pointer = objname };
+        struct acpi_buffer ejd_buffer = {ACPI_ALLOCATE_BUFFER, NULL};
+        union acpi_object *ejd_obj;
+
+        status = acpi_get_handle(handle, "_EJD", &tmp);
+        if (ACPI_FAILURE(status))
+                return AE_OK;
+
+        /* make sure we are dependent on the dock device,
+         * by executing the _EJD method, then getting a handle
+         * to the device referenced by that name.  If that
+         * device handle is the same handle as the dock station
+         * handle, then we are a device dependent on the dock station
+         */
+        acpi_get_name(dck_handle, ACPI_FULL_PATHNAME, &buffer);
+        status = acpi_evaluate_object(handle, "_EJD", NULL, &ejd_buffer);
+        if (ACPI_FAILURE(status)) {
+                err("Unable to execute _EJD!\n");
+                goto find_ejd_out;
+        }
+        ejd_obj = ejd_buffer.pointer;
+        status = acpi_get_handle(NULL, ejd_obj->string.pointer, &tmp);
+        if (ACPI_FAILURE(status))
+                goto find_ejd_out;
+
+        if (tmp == dck_handle) {
+                struct dependent_device *dd;
+                dbg("%s: found device dependent on dock\n", __FUNCTION__);
+                dd = alloc_dependent_device(handle);
+                if (!dd) {
+                        err("Can't allocate memory for dependent device!\n");
+                        goto find_ejd_out;
+                }
+                add_dependent_device(dd);
+        }
+
+find_ejd_out:
+        acpi_os_free(ejd_buffer.pointer);
+        return AE_OK;
+}
+
+
+
+int detect_dependent_devices(acpi_handle *bridge_handle)
+{
+        acpi_status status;
+        int count;
+
+        count = 0;
+
+        status = acpi_walk_namespace(ACPI_TYPE_DEVICE, bridge_handle,
+                                        (u32)1, find_dependent_device,
+                                        (void *)&count, NULL);
+
+        return count;
+}
+
+
+
+
+
+static acpi_status
+find_dock(acpi_handle handle, u32 lvl, void *context, void **rv)
+{
+        int *count = (int *)context;
+
+        if (is_dock(handle)) {
+                dbg("%s: found dock\n", __FUNCTION__);
+                ds = kzalloc(sizeof(*ds), GFP_KERNEL);
+                ds->handle = handle;
+                INIT_LIST_HEAD(&ds->dependent_devices);
+                INIT_LIST_HEAD(&ds->pci_dependent_devices);
+
+                /* look for devices dependent on dock station */
+                acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
+                        ACPI_UINT32_MAX, find_dock_ejd, handle, NULL);
+
+                acpi_install_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
+                        handle_hotplug_event_dock, ds);
+                (*count)++;
+        }
+
+        return AE_OK;
+}
+
+
+
+
+int find_dock_station(void)
+{
+        int num = 0;
+
+        ds = NULL;
+
+        /* start from the root object, because some laptops define
+         * _DCK methods outside the scope of PCI (IBM x-series laptop)
+         */
+        acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
+                        ACPI_UINT32_MAX, find_dock, &num, NULL);
+
+        return num;
+}
+
+
+
+void remove_dock_station(void)
+{
+        struct dependent_device *dd, *tmp;
+        if (ds) {
+                if (ACPI_FAILURE(acpi_remove_notify_handler(ds->handle,
+                        ACPI_SYSTEM_NOTIFY, handle_hotplug_event_dock)))
+                        err("failed to remove dock notify handler\n");
+
+                /* free all dependent devices */
+                list_for_each_entry_safe(dd, tmp, &ds->dependent_devices,
+                                device_list)
+                        kfree(dd);
+
+                /* no need to touch the pci_dependent_device list,
+                 * cause all memory was freed above
+                 */
+                kfree(ds);
+        }
+}
+
+
diff --git a/drivers/pci/hotplug/acpiphp_glue.c b/drivers/pci/hotplug/acpiphp_glue.c
index 509a5b3ae9..053ee84386 100644
--- a/drivers/pci/hotplug/acpiphp_glue.c
+++ b/drivers/pci/hotplug/acpiphp_glue.c
@@ -46,7 +46,7 @@
 #include <linux/kernel.h>
 #include <linux/pci.h>
 #include <linux/smp_lock.h>
-#include <asm/semaphore.h>
+#include <linux/mutex.h>
 
 #include "../pci.h"
 #include "pci_hotplug.h"
@@ -57,7 +57,6 @@ static LIST_HEAD(bridge_list);
 #define MY_NAME "acpiphp_glue"
 
 static void handle_hotplug_event_bridge (acpi_handle, u32, void *);
-static void handle_hotplug_event_func (acpi_handle, u32, void *);
 static void acpiphp_sanitize_bus(struct pci_bus *bus);
 static void acpiphp_set_hpp_values(acpi_handle handle, struct pci_bus *bus);
 
@@ -125,11 +124,11 @@ register_slot(acpi_handle handle, u32 lvl, void *context, void **rv)
         struct acpiphp_bridge *bridge = (struct acpiphp_bridge *)context;
         struct acpiphp_slot *slot;
         struct acpiphp_func *newfunc;
+        struct dependent_device *dd;
         acpi_handle tmp;
         acpi_status status = AE_OK;
         unsigned long adr, sun;
-        int device, function;
-        static int num_slots = 0;       /* XXX if we support I/O node hotplug... */
+        int device, function, retval;
 
         status = acpi_evaluate_integer(handle, "_ADR", NULL, &adr);
 
@@ -138,21 +137,21 @@ register_slot(acpi_handle handle, u32 lvl, void *context, void **rv)
 
         status = acpi_get_handle(handle, "_EJ0", &tmp);
 
-        if (ACPI_FAILURE(status))
+        if (ACPI_FAILURE(status) && !(is_dependent_device(handle)))
                 return AE_OK;
 
         device = (adr >> 16) & 0xffff;
         function = adr & 0xffff;
 
-        newfunc = kmalloc(sizeof(struct acpiphp_func), GFP_KERNEL);
+        newfunc = kzalloc(sizeof(struct acpiphp_func), GFP_KERNEL);
         if (!newfunc)
                 return AE_NO_MEMORY;
-        memset(newfunc, 0, sizeof(struct acpiphp_func));
 
         INIT_LIST_HEAD(&newfunc->sibling);
         newfunc->handle = handle;
         newfunc->function = function;
-        newfunc->flags = FUNC_HAS_EJ0;
+        if (ACPI_SUCCESS(status))
+                newfunc->flags = FUNC_HAS_EJ0;
 
         if (ACPI_SUCCESS(acpi_get_handle(handle, "_STA", &tmp)))
                 newfunc->flags |= FUNC_HAS_STA;
@@ -163,6 +162,19 @@ register_slot(acpi_handle handle, u32 lvl, void *context, void **rv)
         if (ACPI_SUCCESS(acpi_get_handle(handle, "_PS3", &tmp)))
                 newfunc->flags |= FUNC_HAS_PS3;
 
+        if (ACPI_SUCCESS(acpi_get_handle(handle, "_DCK", &tmp))) {
+                newfunc->flags |= FUNC_HAS_DCK;
+                /* add to devices dependent on dock station,
+                 * because this may actually be the dock bridge
+                 */
+                dd = alloc_dependent_device(handle);
+                if (!dd)
+                        err("Can't allocate memory for "
+                                "new dependent device!\n");
+                else
+                        add_dependent_device(dd);
+        }
+
         status = acpi_evaluate_integer(handle, "_SUN", NULL, &sun);
         if (ACPI_FAILURE(status))
                 sun = -1;
@@ -176,19 +188,17 @@ register_slot(acpi_handle handle, u32 lvl, void *context, void **rv)
                 }
 
         if (!slot) {
-                slot = kmalloc(sizeof(struct acpiphp_slot), GFP_KERNEL);
+                slot = kzalloc(sizeof(struct acpiphp_slot), GFP_KERNEL);
                 if (!slot) {
                         kfree(newfunc);
                         return AE_NO_MEMORY;
                 }
 
-                memset(slot, 0, sizeof(struct acpiphp_slot));
                 slot->bridge = bridge;
-                slot->id = num_slots++;
                 slot->device = device;
                 slot->sun = sun;
                 INIT_LIST_HEAD(&slot->funcs);
-                init_MUTEX(&slot->crit_sect);
+                mutex_init(&slot->crit_sect);
 
                 slot->next = bridge->slots;
                 bridge->slots = slot;
@@ -198,6 +208,11 @@ register_slot(acpi_handle handle, u32 lvl, void *context, void **rv)
                 dbg("found ACPI PCI Hotplug slot %d at PCI %04x:%02x:%02x\n",
                                 slot->sun, pci_domain_nr(bridge->pci_bus),
                                 bridge->pci_bus->number, slot->device);
+                retval = acpiphp_register_hotplug_slot(slot);
+                if (retval) {
+                        warn("acpiphp_register_hotplug_slot failed(err code = 0x%x)\n", retval);
+                        goto err_exit;
+                }
         }
 
         newfunc->slot = slot;
@@ -210,16 +225,41 @@ register_slot(acpi_handle handle, u32 lvl, void *context, void **rv)
                 slot->flags |= (SLOT_ENABLED | SLOT_POWEREDON);
         }
 
+        /* if this is a device dependent on a dock station,
+         * associate the acpiphp_func to the dependent_device
+         * struct.
+         */
+        if ((dd = get_dependent_device(handle))) {
+                newfunc->flags |= FUNC_IS_DD;
+                /*
+                 * we don't want any devices which is dependent
+                 * on the dock to have it's _EJ0 method executed.
+                 * because we need to run _DCK first.
+                 */
+                newfunc->flags &= ~FUNC_HAS_EJ0;
+                dd->func = newfunc;
+                add_pci_dependent_device(dd);
+        }
+
         /* install notify handler */
-        status = acpi_install_notify_handler(handle,
+        if (!(newfunc->flags & FUNC_HAS_DCK)) {
+                status = acpi_install_notify_handler(handle,
                                              ACPI_SYSTEM_NOTIFY,
                                              handle_hotplug_event_func,
                                              newfunc);
 
-        if (ACPI_FAILURE(status)) {
-                err("failed to register interrupt notify handler\n");
-                return status;
-        }
+                if (ACPI_FAILURE(status))
+                        err("failed to register interrupt notify handler\n");
+        } else
+                status = AE_OK;
+
+        return status;
+
+ err_exit:
+        bridge->nr_slots--;
+        bridge->slots = slot->next;
+        kfree(slot);
+        kfree(newfunc);
 
         return AE_OK;
 }
@@ -245,57 +285,19 @@ static int detect_ejectable_slots(acpi_handle *bridge_handle)
 static void decode_hpp(struct acpiphp_bridge *bridge)
 {
         acpi_status status;
-        struct acpi_buffer buffer = { .length = ACPI_ALLOCATE_BUFFER,
-                                      .pointer = NULL};
-        union acpi_object *package;
-        int i;
-
-        /* default numbers */
-        bridge->hpp.cache_line_size = 0x10;
-        bridge->hpp.latency_timer = 0x40;
-        bridge->hpp.enable_SERR = 0;
-        bridge->hpp.enable_PERR = 0;
-
-        status = acpi_evaluate_object(bridge->handle, "_HPP", NULL, &buffer);
 
+        status = acpi_get_hp_params_from_firmware(bridge->pci_dev, &bridge->hpp);
         if (ACPI_FAILURE(status)) {
-                dbg("_HPP evaluation failed\n");
-                return;
+                /* use default numbers */
+                bridge->hpp.cache_line_size = 0x10;
+                bridge->hpp.latency_timer = 0x40;
+                bridge->hpp.enable_serr = 0;
+                bridge->hpp.enable_perr = 0;
         }
-
-        package = (union acpi_object *) buffer.pointer;
-
-        if (!package || package->type != ACPI_TYPE_PACKAGE ||
-            package->package.count != 4 || !package->package.elements) {
-                err("invalid _HPP object; ignoring\n");
-                goto err_exit;
-        }
-
-        for (i = 0; i < 4; i++) {
-                if (package->package.elements[i].type != ACPI_TYPE_INTEGER) {
-                        err("invalid _HPP parameter type; ignoring\n");
-                        goto err_exit;
-                }
-        }
-
-        bridge->hpp.cache_line_size = package->package.elements[0].integer.value;
-        bridge->hpp.latency_timer = package->package.elements[1].integer.value;
-        bridge->hpp.enable_SERR = package->package.elements[2].integer.value;
-        bridge->hpp.enable_PERR = package->package.elements[3].integer.value;
-
-        dbg("_HPP parameter = (%02x, %02x, %02x, %02x)\n",
-                bridge->hpp.cache_line_size,
-                bridge->hpp.latency_timer,
-                bridge->hpp.enable_SERR,
-                bridge->hpp.enable_PERR);
-
-        bridge->flags |= BRIDGE_HAS_HPP;
-
- err_exit:
-        kfree(buffer.pointer);
 }
 
 
+
 /* initialize miscellaneous stuff for both root and PCI-to-PCI bridge */
 static void init_bridge_misc(struct acpiphp_bridge *bridge)
 {
@@ -304,9 +306,16 @@ static void init_bridge_misc(struct acpiphp_bridge *bridge)
         /* decode ACPI 2.0 _HPP (hot plug parameters) */
         decode_hpp(bridge);
 
+        /* must be added to the list prior to calling register_slot */
+        list_add(&bridge->list, &bridge_list);
+
         /* register all slot objects under this bridge */
         status = acpi_walk_namespace(ACPI_TYPE_DEVICE, bridge->handle, (u32)1,
                                      register_slot, bridge, NULL);
+        if (ACPI_FAILURE(status)) {
+                list_del(&bridge->list);
+                return;
+        }
 
         /* install notify handler */
         if (bridge->type != BRIDGE_TYPE_HOST) {
@@ -319,8 +328,6 @@ static void init_bridge_misc(struct acpiphp_bridge *bridge)
                         err("failed to register interrupt notify handler\n");
                 }
         }
-
-        list_add(&bridge->list, &bridge_list);
 }
 
 
@@ -329,12 +336,10 @@ static void add_host_bridge(acpi_handle *handle, struct pci_bus *pci_bus)
 {
         struct acpiphp_bridge *bridge;
 
-        bridge = kmalloc(sizeof(struct acpiphp_bridge), GFP_KERNEL);
+        bridge = kzalloc(sizeof(struct acpiphp_bridge), GFP_KERNEL);
         if (bridge == NULL)
                 return;
 
-        memset(bridge, 0, sizeof(struct acpiphp_bridge));
-
         bridge->type = BRIDGE_TYPE_HOST;
         bridge->handle = handle;
 
@@ -351,14 +356,12 @@ static void add_p2p_bridge(acpi_handle *handle, struct pci_dev *pci_dev)
 {
         struct acpiphp_bridge *bridge;
 
-        bridge = kmalloc(sizeof(struct acpiphp_bridge), GFP_KERNEL);
+        bridge = kzalloc(sizeof(struct acpiphp_bridge), GFP_KERNEL);
         if (bridge == NULL) {
                 err("out of memory\n");
                 return;
         }
 
-        memset(bridge, 0, sizeof(struct acpiphp_bridge));
-
         bridge->type = BRIDGE_TYPE_P2P;
         bridge->handle = handle;
 
@@ -410,11 +413,18 @@ find_p2p_bridge(acpi_handle handle, u32 lvl, void *context, void **rv)
                 goto out;
 
         /* check if this bridge has ejectable slots */
-        if (detect_ejectable_slots(handle) > 0) {
+        if ((detect_ejectable_slots(handle) > 0) ||
+                (detect_dependent_devices(handle) > 0)) {
                 dbg("found PCI-to-PCI bridge at PCI %s\n", pci_name(dev));
                 add_p2p_bridge(handle, dev);
         }
 
+        /* search P2P bridges under this p2p bridge */
+        status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, (u32)1,
+                                     find_p2p_bridge, dev->subordinate, NULL);
+        if (ACPI_FAILURE(status))
+                warn("find_p2p_bridge faied (error code = 0x%x)\n", status);
+
  out:
         pci_dev_put(dev);
         return AE_OK;
@@ -512,15 +522,19 @@ static void cleanup_bridge(struct acpiphp_bridge *bridge)
                 list_for_each_safe (list, tmp, &slot->funcs) {
                         struct acpiphp_func *func;
                         func = list_entry(list, struct acpiphp_func, sibling);
-                        status = acpi_remove_notify_handler(func->handle,
+                        if (!(func->flags & FUNC_HAS_DCK)) {
+                                status = acpi_remove_notify_handler(func->handle,
                                                 ACPI_SYSTEM_NOTIFY,
                                                 handle_hotplug_event_func);
-                        if (ACPI_FAILURE(status))
-                                err("failed to remove notify handler\n");
+                                if (ACPI_FAILURE(status))
+                                        err("failed to remove notify handler\n");
+                        }
                         pci_dev_put(func->pci_dev);
                         list_del(list);
                         kfree(func);
                 }
+                acpiphp_unregister_hotplug_slot(slot);
+                list_del(&slot->funcs);
                 kfree(slot);
                 slot = next;
         }
@@ -551,7 +565,8 @@ static void remove_bridge(acpi_handle handle)
         } else {
                 /* clean-up p2p bridges under this host bridge */
                 acpi_walk_namespace(ACPI_TYPE_DEVICE, handle,
-                                (u32)1, cleanup_p2p_bridge, NULL, NULL);
+                                    ACPI_UINT32_MAX, cleanup_p2p_bridge,
+                                    NULL, NULL);
         }
 }
 
@@ -751,6 +766,113 @@ static int power_off_slot(struct acpiphp_slot *slot)
 }
 
 
+
+/**
+ * acpiphp_max_busnr - return the highest reserved bus number under
+ * the given bus.
+ * @bus: bus to start search with
+ *
+ */
+static unsigned char acpiphp_max_busnr(struct pci_bus *bus)
+{
+        struct list_head *tmp;
+        unsigned char max, n;
+
+        /*
+         * pci_bus_max_busnr will return the highest
+         * reserved busnr for all these children.
+         * that is equivalent to the bus->subordinate
+         * value.  We don't want to use the parent's
+         * bus->subordinate value because it could have
+         * padding in it.
+         */
+        max = bus->secondary;
+
+        list_for_each(tmp, &bus->children) {
+                n = pci_bus_max_busnr(pci_bus_b(tmp));
+                if (n > max)
+                        max = n;
+        }
+        return max;
+}
+
+
+
+/**
+ *  get_func - get a pointer to acpiphp_func given a slot, device
+ *  @slot: slot to search
+ *  @dev:  pci_dev struct to match.
+ *
+ *  This function will increase the reference count of pci_dev,
+ *  so callers should call pci_dev_put when complete.
+ *
+ */
+static struct acpiphp_func *
+get_func(struct acpiphp_slot *slot, struct pci_dev *dev)
+{
+        struct acpiphp_func *func = NULL;
+        struct pci_bus *bus = slot->bridge->pci_bus;
+        struct pci_dev *pdev;
+
+        list_for_each_entry(func, &slot->funcs, sibling) {
+                pdev = pci_get_slot(bus, PCI_DEVFN(slot->device,
+                                        func->function));
+                if (pdev) {
+                        if (pdev == dev)
+                                break;
+                        pci_dev_put(pdev);
+                }
+        }
+        return func;
+}
+
+
+/**
+ * acpiphp_bus_add - add a new bus to acpi subsystem
+ * @func: acpiphp_func of the bridge
+ *
+ */
+static int acpiphp_bus_add(struct acpiphp_func *func)
+{
+        acpi_handle phandle;
+        struct acpi_device *device, *pdevice;
+        int ret_val;
+
+        acpi_get_parent(func->handle, &phandle);
+        if (acpi_bus_get_device(phandle, &pdevice)) {
+                dbg("no parent device, assuming NULL\n");
+                pdevice = NULL;
+        }
+        if (!acpi_bus_get_device(func->handle, &device)) {
+                dbg("bus exists... trim\n");
+                /* this shouldn't be in here, so remove
+                 * the bus then re-add it...
+                 */
+                ret_val = acpi_bus_trim(device, 1);
+                dbg("acpi_bus_trim return %x\n", ret_val);
+        }
+
+        ret_val = acpi_bus_add(&device, pdevice, func->handle,
+                ACPI_BUS_TYPE_DEVICE);
+        if (ret_val) {
+                dbg("error adding bus, %x\n",
+                        -ret_val);
+                goto acpiphp_bus_add_out;
+        }
+        /*
+         * try to start anyway.  We could have failed to add
+         * simply because this bus had previously been added
+         * on another add.  Don't bother with the return value
+         * we just keep going.
+         */
+        ret_val = acpi_bus_start(device);
+
+acpiphp_bus_add_out:
+        return ret_val;
+}
+
+
+
 /**
  * enable_device - enable, configure a slot
  * @slot: slot to be enabled
@@ -788,7 +910,7 @@ static int enable_device(struct acpiphp_slot *slot)
                 goto err_exit;
         }
 
-        max = bus->secondary;
+        max = acpiphp_max_busnr(bus);
         for (pass = 0; pass < 2; pass++) {
                 list_for_each_entry(dev, &bus->devices, bus_list) {
                         if (PCI_SLOT(dev->devfn) != slot->device)
@@ -796,8 +918,15 @@ static int enable_device(struct acpiphp_slot *slot)
                         if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE ||
                             dev->hdr_type == PCI_HEADER_TYPE_CARDBUS) {
                                 max = pci_scan_bridge(bus, dev, max, pass);
-                                if (pass && dev->subordinate)
+                                if (pass && dev->subordinate) {
                                         pci_bus_size_bridges(dev->subordinate);
+                                        func = get_func(slot, dev);
+                                        if (func) {
+                                                acpiphp_bus_add(func);
+                                                /* side effect of get_func */
+                                                pci_dev_put(dev);
+                                        }
+                                }
                         }
                 }
         }
@@ -806,8 +935,8 @@ static int enable_device(struct acpiphp_slot *slot)
         acpiphp_sanitize_bus(bus);
         pci_enable_bridges(bus);
         pci_bus_add_devices(bus);
-        acpiphp_set_hpp_values(DEVICE_ACPI_HANDLE(&bus->self->dev), bus);
-        acpiphp_configure_ioapics(DEVICE_ACPI_HANDLE(&bus->self->dev));
+        acpiphp_set_hpp_values(slot->bridge->handle, bus);
+        acpiphp_configure_ioapics(slot->bridge->handle);
 
         /* associate pci_dev to our representation */
         list_for_each (l, &slot->funcs) {
@@ -987,11 +1116,11 @@ static void program_hpp(struct pci_dev *dev, struct acpiphp_bridge *bridge)
         pci_write_config_byte(dev, PCI_LATENCY_TIMER,
                         bridge->hpp.latency_timer);
         pci_read_config_word(dev, PCI_COMMAND, &pci_cmd);
-        if (bridge->hpp.enable_SERR)
+        if (bridge->hpp.enable_serr)
                 pci_cmd |= PCI_COMMAND_SERR;
         else
                 pci_cmd &= ~PCI_COMMAND_SERR;
-        if (bridge->hpp.enable_PERR)
+        if (bridge->hpp.enable_perr)
                 pci_cmd |= PCI_COMMAND_PARITY;
         else
                 pci_cmd &= ~PCI_COMMAND_PARITY;
@@ -1002,11 +1131,11 @@ static void program_hpp(struct pci_dev *dev, struct acpiphp_bridge *bridge)
                 pci_write_config_byte(dev, PCI_SEC_LATENCY_TIMER,
                                 bridge->hpp.latency_timer);
                 pci_read_config_word(dev, PCI_BRIDGE_CONTROL, &pci_bctl);
-                if (bridge->hpp.enable_SERR)
+                if (bridge->hpp.enable_serr)
                         pci_bctl |= PCI_BRIDGE_CTL_SERR;
                 else
                         pci_bctl &= ~PCI_BRIDGE_CTL_SERR;
-                if (bridge->hpp.enable_PERR)
+                if (bridge->hpp.enable_perr)
                         pci_bctl |= PCI_BRIDGE_CTL_PARITY;
                 else
                         pci_bctl &= ~PCI_BRIDGE_CTL_PARITY;
@@ -1026,6 +1155,7 @@ static void acpiphp_set_hpp_values(acpi_handle handle, struct pci_bus *bus)
 
         memset(&bridge, 0, sizeof(bridge));
         bridge.handle = handle;
+        bridge.pci_dev = bus->self;
         decode_hpp(&bridge);
         list_for_each_entry(dev, &bus->devices, bus_list)
                 program_hpp(dev, &bridge);
@@ -1200,7 +1330,7 @@ static void handle_hotplug_event_bridge(acpi_handle handle, u32 type, void *cont
  * handles ACPI event notification on slots
  *
  */
-static void handle_hotplug_event_func(acpi_handle handle, u32 type, void *context)
+void handle_hotplug_event_func(acpi_handle handle, u32 type, void *context)
 {
         struct acpiphp_func *func;
         char objname[64];
@@ -1242,41 +1372,13 @@ static void handle_hotplug_event_func(acpi_handle handle, u32 type, void *contex
         }
 }
 
-static int is_root_bridge(acpi_handle handle)
-{
-        acpi_status status;
-        struct acpi_device_info *info;
-        struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
-        int i;
-
-        status = acpi_get_object_info(handle, &buffer);
-        if (ACPI_SUCCESS(status)) {
-                info = buffer.pointer;
-                if ((info->valid & ACPI_VALID_HID) &&
-                        !strcmp(PCI_ROOT_HID_STRING,
-                                        info->hardware_id.value)) {
-                        acpi_os_free(buffer.pointer);
-                        return 1;
-                }
-                if (info->valid & ACPI_VALID_CID) {
-                        for (i=0; i < info->compatibility_id.count; i++) {
-                                if (!strcmp(PCI_ROOT_HID_STRING,
-                                        info->compatibility_id.id[i].value)) {
-                                        acpi_os_free(buffer.pointer);
-                                        return 1;
-                                }
-                        }
-                }
-        }
-        return 0;
-}
 
 static acpi_status
 find_root_bridges(acpi_handle handle, u32 lvl, void *context, void **rv)
 {
         int *count = (int *)context;
 
-        if (is_root_bridge(handle)) {
+        if (acpi_root_bridge(handle)) {
                 acpi_install_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
                                 handle_hotplug_event_bridge, NULL);
                         (*count)++;
@@ -1373,26 +1475,6 @@ static int acpiphp_for_each_slot(acpiphp_callback fn, void *data)
 }
 #endif
 
-/* search matching slot from id  */
-struct acpiphp_slot *get_slot_from_id(int id)
-{
-        struct list_head *node;
-        struct acpiphp_bridge *bridge;
-        struct acpiphp_slot *slot;
-
-        list_for_each (node, &bridge_list) {
-                bridge = (struct acpiphp_bridge *)node;
-                for (slot = bridge->slots; slot; slot = slot->next)
-                        if (slot->id == id)
-                                return slot;
-        }
-
-        /* should never happen! */
-        err("%s: no object for id %d\n", __FUNCTION__, id);
-        WARN_ON(1);
-        return NULL;
-}
-
 
 /**
  * acpiphp_enable_slot - power on slot
@@ -1401,7 +1483,7 @@ int acpiphp_enable_slot(struct acpiphp_slot *slot)
 {
         int retval;
 
-        down(&slot->crit_sect);
+        mutex_lock(&slot->crit_sect);
 
         /* wake up all functions */
         retval = power_on_slot(slot);
@@ -1413,7 +1495,7 @@ int acpiphp_enable_slot(struct acpiphp_slot *slot)
                 retval = enable_device(slot);
 
  err_exit:
-        up(&slot->crit_sect);
+        mutex_unlock(&slot->crit_sect);
         return retval;
 }
 
@@ -1424,7 +1506,7 @@ int acpiphp_disable_slot(struct acpiphp_slot *slot)
 {
         int retval = 0;
 
-        down(&slot->crit_sect);
+        mutex_lock(&slot->crit_sect);
 
         /* unconfigure all functions */
         retval = disable_device(slot);
@@ -1437,7 +1519,7 @@ int acpiphp_disable_slot(struct acpiphp_slot *slot)
                 goto err_exit;
 
  err_exit:
-        up(&slot->crit_sect);
+        mutex_unlock(&slot->crit_sect);
         return retval;
 }
 
diff --git a/drivers/pci/hotplug/cpci_hotplug_core.c b/drivers/pci/hotplug/cpci_hotplug_core.c
index 30af105271..037ce4c916 100644
--- a/drivers/pci/hotplug/cpci_hotplug_core.c
+++ b/drivers/pci/hotplug/cpci_hotplug_core.c
@@ -248,22 +248,19 @@ cpci_hp_register_bus(struct pci_bus *bus, u8 first, u8 last)
          * with the pci_hotplug subsystem.
          */
         for (i = first; i <= last; ++i) {
-                slot = kmalloc(sizeof (struct slot), GFP_KERNEL);
+                slot = kzalloc(sizeof (struct slot), GFP_KERNEL);
                 if (!slot)
                         goto error;
-                memset(slot, 0, sizeof (struct slot));
 
                 hotplug_slot =
-                    kmalloc(sizeof (struct hotplug_slot), GFP_KERNEL);
+                        kzalloc(sizeof (struct hotplug_slot), GFP_KERNEL);
                 if (!hotplug_slot)
                         goto error_slot;
-                memset(hotplug_slot, 0, sizeof (struct hotplug_slot));
                 slot->hotplug_slot = hotplug_slot;
 
-                info = kmalloc(sizeof (struct hotplug_slot_info), GFP_KERNEL);
+                info = kzalloc(sizeof (struct hotplug_slot_info), GFP_KERNEL);
                 if (!info)
                         goto error_hpslot;
-                memset(info, 0, sizeof (struct hotplug_slot_info));
                 hotplug_slot->info = info;
 
                 name = kmalloc(SLOT_NAME_SIZE, GFP_KERNEL);
diff --git a/drivers/pci/hotplug/cpqphp.h b/drivers/pci/hotplug/cpqphp.h
index cb88404c89..c74e9e37e7 100644
--- a/drivers/pci/hotplug/cpqphp.h
+++ b/drivers/pci/hotplug/cpqphp.h
@@ -32,6 +32,7 @@
 #include <linux/interrupt.h>
 #include <asm/io.h>             /* for read? and write? functions */
 #include <linux/delay.h>        /* for delays */
+#include <linux/mutex.h>
 
 #define MY_NAME "cpqphp"
 
@@ -286,7 +287,7 @@ struct event_info {
 struct controller {
         struct controller *next;
         u32 ctrl_int_comp;
-        struct semaphore crit_sect;     /* critical section semaphore */
+        struct mutex crit_sect;         /* critical section mutex */
         void __iomem *hpc_reg;          /* cookie for our pci controller location */
         struct pci_resource *mem_head;
         struct pci_resource *p_mem_head;
diff --git a/drivers/pci/hotplug/cpqphp_core.c b/drivers/pci/hotplug/cpqphp_core.c
index b3659ffcca..9bc1deb8df 100644
--- a/drivers/pci/hotplug/cpqphp_core.c
+++ b/drivers/pci/hotplug/cpqphp_core.c
@@ -347,26 +347,22 @@ static int ctrl_slot_setup(struct controller *ctrl,
         slot_number = ctrl->first_slot;
 
         while (number_of_slots) {
-                slot = kmalloc(sizeof(*slot), GFP_KERNEL);
+                slot = kzalloc(sizeof(*slot), GFP_KERNEL);
                 if (!slot)
                         goto error;
 
-                memset(slot, 0, sizeof(struct slot));
-                slot->hotplug_slot = kmalloc(sizeof(*(slot->hotplug_slot)),
+                slot->hotplug_slot = kzalloc(sizeof(*(slot->hotplug_slot)),
                                                 GFP_KERNEL);
                 if (!slot->hotplug_slot)
                         goto error_slot;
                 hotplug_slot = slot->hotplug_slot;
-                memset(hotplug_slot, 0, sizeof(struct hotplug_slot));
 
                 hotplug_slot->info =
-                                kmalloc(sizeof(*(hotplug_slot->info)),
+                                kzalloc(sizeof(*(hotplug_slot->info)),
                                                         GFP_KERNEL);
                 if (!hotplug_slot->info)
                         goto error_hpslot;
                 hotplug_slot_info = hotplug_slot->info;
-                memset(hotplug_slot_info, 0,
-                                sizeof(struct hotplug_slot_info));
                 hotplug_slot->name = kmalloc(SLOT_NAME_SIZE, GFP_KERNEL);
 
                 if (!hotplug_slot->name)
@@ -599,7 +595,7 @@ cpqhp_set_attention_status(struct controller *ctrl, struct pci_func *func,
         hp_slot = func->device - ctrl->slot_device_offset;
 
         // Wait for exclusive access to hardware
-        down(&ctrl->crit_sect);
+        mutex_lock(&ctrl->crit_sect);
 
         if (status == 1) {
                 amber_LED_on (ctrl, hp_slot);
@@ -607,7 +603,7 @@ cpqhp_set_attention_status(struct controller *ctrl, struct pci_func *func,
                 amber_LED_off (ctrl, hp_slot);
         } else {
                 // Done with exclusive hardware access
-                up(&ctrl->crit_sect);
+                mutex_unlock(&ctrl->crit_sect);
                 return(1);
         }
 
@@ -617,7 +613,7 @@ cpqhp_set_attention_status(struct controller *ctrl, struct pci_func *func,
         wait_for_ctrl_irq (ctrl);
 
         // Done with exclusive hardware access
-        up(&ctrl->crit_sect);
+        mutex_unlock(&ctrl->crit_sect);
 
         return(0);
 }
@@ -854,13 +850,12 @@ static int cpqhpc_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                         goto err_disable_device;
                 }
 
-                ctrl = (struct controller *) kmalloc(sizeof(struct controller), GFP_KERNEL);
+                ctrl = kzalloc(sizeof(struct controller), GFP_KERNEL);
                 if (!ctrl) {
                         err("%s : out of memory\n", __FUNCTION__);
                         rc = -ENOMEM;
                         goto err_disable_device;
                 }
-                memset(ctrl, 0, sizeof(struct controller));
 
                 rc = pci_read_config_word(pdev, PCI_SUBSYSTEM_ID, &subsystem_deviceid);
                 if (rc) {
@@ -1084,7 +1079,7 @@ static int cpqhpc_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         dbg("bus device function rev: %d %d %d %d\n", ctrl->bus,
                 PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn), ctrl->rev);
 
-        init_MUTEX(&ctrl->crit_sect);
+        mutex_init(&ctrl->crit_sect);
         init_waitqueue_head(&ctrl->queue);
 
         /* initialize our threads if they haven't already been started up */
@@ -1223,7 +1218,7 @@ static int cpqhpc_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 
         // turn off empty slots here unless command line option "ON" set
         // Wait for exclusive access to hardware
-        down(&ctrl->crit_sect);
+        mutex_lock(&ctrl->crit_sect);
 
         num_of_slots = readb(ctrl->hpc_reg + SLOT_MASK) & 0x0F;
 
@@ -1270,12 +1265,12 @@ static int cpqhpc_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         rc = init_SERR(ctrl);
         if (rc) {
                 err("init_SERR failed\n");
-                up(&ctrl->crit_sect);
+                mutex_unlock(&ctrl->crit_sect);
                 goto err_free_irq;
         }
 
         // Done with exclusive hardware access
-        up(&ctrl->crit_sect);
+        mutex_unlock(&ctrl->crit_sect);
 
         cpqhp_create_debugfs_files(ctrl);
 
diff --git a/drivers/pci/hotplug/cpqphp_ctrl.c b/drivers/pci/hotplug/cpqphp_ctrl.c
index 771ed34b18..55d2dc7e39 100644
--- a/drivers/pci/hotplug/cpqphp_ctrl.c
+++ b/drivers/pci/hotplug/cpqphp_ctrl.c
@@ -1282,9 +1282,7 @@ static u32 board_replaced(struct pci_func *func, struct controller *ctrl)
         u8 hp_slot;
         u8 temp_byte;
         u8 adapter_speed;
-        u32 index;
         u32 rc = 0;
-        u32 src = 8;
 
         hp_slot = func->device - ctrl->slot_device_offset;
 
@@ -1299,7 +1297,7 @@ static u32 board_replaced(struct pci_func *func, struct controller *ctrl)
                  **********************************/
                 rc = CARD_FUNCTIONING;
         } else {
-                down(&ctrl->crit_sect);
+                mutex_lock(&ctrl->crit_sect);
 
                 /* turn on board without attaching to the bus */
                 enable_slot_power (ctrl, hp_slot);
@@ -1333,12 +1331,12 @@ static u32 board_replaced(struct pci_func *func, struct controller *ctrl)
                 /* Wait for SOBS to be unset */
                 wait_for_ctrl_irq (ctrl);
 
-                up(&ctrl->crit_sect);
+                mutex_unlock(&ctrl->crit_sect);
 
                 if (rc)
                         return rc;
 
-                down(&ctrl->crit_sect);
+                mutex_lock(&ctrl->crit_sect);
 
                 slot_enable (ctrl, hp_slot);
                 green_LED_blink (ctrl, hp_slot);
@@ -1350,7 +1348,7 @@ static u32 board_replaced(struct pci_func *func, struct controller *ctrl)
                 /* Wait for SOBS to be unset */
                 wait_for_ctrl_irq (ctrl);
 
-                up(&ctrl->crit_sect);
+                mutex_unlock(&ctrl->crit_sect);
 
                 /* Wait for ~1 second because of hot plug spec */
                 long_delay(1*HZ);
@@ -1368,76 +1366,30 @@ static u32 board_replaced(struct pci_func *func, struct controller *ctrl)
 
                         rc = cpqhp_configure_board(ctrl, func);
 
-                        if (rc || src) {
-                                /* If configuration fails, turn it off
-                                 * Get slot won't work for devices behind
-                                 * bridges, but in this case it will always be
-                                 * called for the "base" bus/dev/func of an
-                                 * adapter. */
+                        /* If configuration fails, turn it off
+                         * Get slot won't work for devices behind
+                         * bridges, but in this case it will always be
+                         * called for the "base" bus/dev/func of an
+                         * adapter. */
 
-                                down(&ctrl->crit_sect);
+                        mutex_lock(&ctrl->crit_sect);
 
-                                amber_LED_on (ctrl, hp_slot);
-                                green_LED_off (ctrl, hp_slot);
-                                slot_disable (ctrl, hp_slot);
-
-                                set_SOGO(ctrl);
-
-                                /* Wait for SOBS to be unset */
-                                wait_for_ctrl_irq (ctrl);
-
-                                up(&ctrl->crit_sect);
-
-                                if (rc)
-                                        return rc;
-                                else
-                                        return 1;
-                        }
-
-                        func->status = 0;
-                        func->switch_save = 0x10;
-
-                        index = 1;
-                        while (((func = cpqhp_slot_find(func->bus, func->device, index)) != NULL) && !rc) {
-                                rc |= cpqhp_configure_board(ctrl, func);
-                                index++;
-                        }
-
-                        if (rc) {
-                                /* If configuration fails, turn it off
-                                 * Get slot won't work for devices behind
-                                 * bridges, but in this case it will always be
-                                 * called for the "base" bus/dev/func of an
-                                 * adapter. */
-
-                                down(&ctrl->crit_sect);
-
-                                amber_LED_on (ctrl, hp_slot);
-                                green_LED_off (ctrl, hp_slot);
-                                slot_disable (ctrl, hp_slot);
-
-                                set_SOGO(ctrl);
-
-                                /* Wait for SOBS to be unset */
-                                wait_for_ctrl_irq (ctrl);
-
-                                up(&ctrl->crit_sect);
-
-                                return rc;
-                        }
-                        /* Done configuring so turn LED on full time */
-
-                        down(&ctrl->crit_sect);
-
-                        green_LED_on (ctrl, hp_slot);
+                        amber_LED_on (ctrl, hp_slot);
+                        green_LED_off (ctrl, hp_slot);
+                        slot_disable (ctrl, hp_slot);
 
                         set_SOGO(ctrl);
 
                         /* Wait for SOBS to be unset */
                         wait_for_ctrl_irq (ctrl);
 
-                        up(&ctrl->crit_sect);
-                        rc = 0;
+                        mutex_unlock(&ctrl->crit_sect);
+
+                        if (rc)
+                                return rc;
+                        else
+                                return 1;
+
                 } else {
                         /* Something is wrong
 
@@ -1445,7 +1397,7 @@ static u32 board_replaced(struct pci_func *func, struct controller *ctrl)
                          * in this case it will always be called for the "base"
                          * bus/dev/func of an adapter. */
 
-                        down(&ctrl->crit_sect);
+                        mutex_lock(&ctrl->crit_sect);
 
                         amber_LED_on (ctrl, hp_slot);
                         green_LED_off (ctrl, hp_slot);
@@ -1456,7 +1408,7 @@ static u32 board_replaced(struct pci_func *func, struct controller *ctrl)
                         /* Wait for SOBS to be unset */
                         wait_for_ctrl_irq (ctrl);
 
-                        up(&ctrl->crit_sect);
+                        mutex_unlock(&ctrl->crit_sect);
                 }
 
         }
@@ -1488,7 +1440,7 @@ static u32 board_added(struct pci_func *func, struct controller *ctrl)
         dbg("%s: func->device, slot_offset, hp_slot = %d, %d ,%d\n",
             __FUNCTION__, func->device, ctrl->slot_device_offset, hp_slot);
 
-        down(&ctrl->crit_sect);
+        mutex_lock(&ctrl->crit_sect);
 
         /* turn on board without attaching to the bus */
         enable_slot_power(ctrl, hp_slot);
@@ -1522,7 +1474,7 @@ static u32 board_added(struct pci_func *func, struct controller *ctrl)
         /* Wait for SOBS to be unset */
         wait_for_ctrl_irq(ctrl);
 
-        up(&ctrl->crit_sect);
+        mutex_unlock(&ctrl->crit_sect);
 
         if (rc)
                 return rc;
@@ -1532,7 +1484,7 @@ static u32 board_added(struct pci_func *func, struct controller *ctrl)
         /* turn on board and blink green LED */
 
         dbg("%s: before down\n", __FUNCTION__);
-        down(&ctrl->crit_sect);
+        mutex_lock(&ctrl->crit_sect);
         dbg("%s: after down\n", __FUNCTION__);
 
         dbg("%s: before slot_enable\n", __FUNCTION__);
@@ -1553,7 +1505,7 @@ static u32 board_added(struct pci_func *func, struct controller *ctrl)
         dbg("%s: after wait_for_ctrl_irq\n", __FUNCTION__);
 
         dbg("%s: before up\n", __FUNCTION__);
-        up(&ctrl->crit_sect);
+        mutex_unlock(&ctrl->crit_sect);
         dbg("%s: after up\n", __FUNCTION__);
 
         /* Wait for ~1 second because of hot plug spec */
@@ -1607,7 +1559,7 @@ static u32 board_added(struct pci_func *func, struct controller *ctrl)
                 cpqhp_resource_sort_and_combine(&(ctrl->bus_head));
 
                 if (rc) {
-                        down(&ctrl->crit_sect);
+                        mutex_lock(&ctrl->crit_sect);
 
                         amber_LED_on (ctrl, hp_slot);
                         green_LED_off (ctrl, hp_slot);
@@ -1618,7 +1570,7 @@ static u32 board_added(struct pci_func *func, struct controller *ctrl)
                         /* Wait for SOBS to be unset */
                         wait_for_ctrl_irq (ctrl);
 
-                        up(&ctrl->crit_sect);
+                        mutex_unlock(&ctrl->crit_sect);
                         return rc;
                 } else {
                         cpqhp_save_slot_config(ctrl, func);
@@ -1640,7 +1592,7 @@ static u32 board_added(struct pci_func *func, struct controller *ctrl)
                         }
                 } while (new_slot);
 
-                down(&ctrl->crit_sect);
+                mutex_lock(&ctrl->crit_sect);
 
                 green_LED_on (ctrl, hp_slot);
 
@@ -1649,9 +1601,9 @@ static u32 board_added(struct pci_func *func, struct controller *ctrl)
                 /* Wait for SOBS to be unset */
                 wait_for_ctrl_irq (ctrl);
 
-                up(&ctrl->crit_sect);
+                mutex_unlock(&ctrl->crit_sect);
         } else {
-                down(&ctrl->crit_sect);
+                mutex_lock(&ctrl->crit_sect);
 
                 amber_LED_on (ctrl, hp_slot);
                 green_LED_off (ctrl, hp_slot);
@@ -1662,7 +1614,7 @@ static u32 board_added(struct pci_func *func, struct controller *ctrl)
                 /* Wait for SOBS to be unset */
                 wait_for_ctrl_irq (ctrl);
 
-                up(&ctrl->crit_sect);
+                mutex_unlock(&ctrl->crit_sect);
 
                 return rc;
         }
@@ -1721,7 +1673,7 @@ static u32 remove_board(struct pci_func * func, u32 replace_flag, struct control
                 func->status = 0x01;
         func->configured = 0;
 
-        down(&ctrl->crit_sect);
+        mutex_lock(&ctrl->crit_sect);
 
         green_LED_off (ctrl, hp_slot);
         slot_disable (ctrl, hp_slot);
@@ -1736,7 +1688,7 @@ static u32 remove_board(struct pci_func * func, u32 replace_flag, struct control
         /* Wait for SOBS to be unset */
         wait_for_ctrl_irq (ctrl);
 
-        up(&ctrl->crit_sect);
+        mutex_unlock(&ctrl->crit_sect);
 
         if (!replace_flag && ctrl->add_support) {
                 while (func) {
@@ -1899,7 +1851,7 @@ static void interrupt_event_handler(struct controller *ctrl)
                                         dbg("button cancel\n");
                                         del_timer(&p_slot->task_event);
 
-                                        down(&ctrl->crit_sect);
+                                        mutex_lock(&ctrl->crit_sect);
 
                                         if (p_slot->state == BLINKINGOFF_STATE) {
                                                 /* slot is on */
@@ -1922,7 +1874,7 @@ static void interrupt_event_handler(struct controller *ctrl)
                                         /* Wait for SOBS to be unset */
                                         wait_for_ctrl_irq (ctrl);
 
-                                        up(&ctrl->crit_sect);
+                                        mutex_unlock(&ctrl->crit_sect);
                                 }
                                 /*** button Released (No action on press...) */
                                 else if (ctrl->event_queue[loop].event_type == INT_BUTTON_RELEASE) {
@@ -1937,7 +1889,7 @@ static void interrupt_event_handler(struct controller *ctrl)
                                                 p_slot->state = BLINKINGON_STATE;
                                                 info(msg_button_on, p_slot->number);
                                         }
-                                        down(&ctrl->crit_sect);
+                                        mutex_lock(&ctrl->crit_sect);
                                         
                                         dbg("blink green LED and turn off amber\n");
                                         
@@ -1949,7 +1901,7 @@ static void interrupt_event_handler(struct controller *ctrl)
                                         /* Wait for SOBS to be unset */
                                         wait_for_ctrl_irq (ctrl);
 
-                                        up(&ctrl->crit_sect);
+                                        mutex_unlock(&ctrl->crit_sect);
                                         init_timer(&p_slot->task_event);
                                         p_slot->hp_slot = hp_slot;
                                         p_slot->ctrl = ctrl;
diff --git a/drivers/pci/hotplug/fakephp.c b/drivers/pci/hotplug/fakephp.c
index 060d74775d..71b80c23e8 100644
--- a/drivers/pci/hotplug/fakephp.c
+++ b/drivers/pci/hotplug/fakephp.c
@@ -95,15 +95,13 @@ static int add_slot(struct pci_dev *dev)
         struct hotplug_slot *slot;
         int retval = -ENOMEM;
 
-        slot = kmalloc(sizeof(struct hotplug_slot), GFP_KERNEL);
+        slot = kzalloc(sizeof(struct hotplug_slot), GFP_KERNEL);
         if (!slot)
                 goto error;
-        memset(slot, 0, sizeof(*slot));
 
-        slot->info = kmalloc(sizeof(struct hotplug_slot_info), GFP_KERNEL);
+        slot->info = kzalloc(sizeof(struct hotplug_slot_info), GFP_KERNEL);
         if (!slot->info)
                 goto error_slot;
-        memset(slot->info, 0, sizeof(struct hotplug_slot_info));
 
         slot->info->power_status = 1;
         slot->info->max_bus_speed = PCI_SPEED_UNKNOWN;
@@ -227,11 +225,10 @@ static void pci_rescan_bus(const struct pci_bus *bus)
 {
         unsigned int devfn;
         struct pci_dev *dev;
-        dev = kmalloc(sizeof(struct pci_dev), GFP_KERNEL);
+        dev = kzalloc(sizeof(struct pci_dev), GFP_KERNEL);
         if (!dev)
                 return;
 
-        memset(dev, 0, sizeof(dev));
         dev->bus = (struct pci_bus*)bus;
         dev->sysdata = bus->sysdata;
         for (devfn = 0; devfn < 0x100; devfn += 8) {
diff --git a/drivers/pci/hotplug/ibmphp.h b/drivers/pci/hotplug/ibmphp.h
index c22e0284d7..dba6d8ca9b 100644
--- a/drivers/pci/hotplug/ibmphp.h
+++ b/drivers/pci/hotplug/ibmphp.h
@@ -406,8 +406,6 @@ extern void ibmphp_hpc_stop_poll_thread (void);
 //----------------------------------------------------------------------------
 // HPC return codes
 //----------------------------------------------------------------------------
-#define FALSE                           0x00
-#define TRUE                            0x01
 #define HPC_ERROR                       0xFF
 
 //-----------------------------------------------------------------------------
diff --git a/drivers/pci/hotplug/ibmphp_core.c b/drivers/pci/hotplug/ibmphp_core.c
index dc59da675c..e13d5b8724 100644
--- a/drivers/pci/hotplug/ibmphp_core.c
+++ b/drivers/pci/hotplug/ibmphp_core.c
@@ -1141,7 +1141,7 @@ static int enable_slot(struct hotplug_slot *hs)
                 goto error_power;
         }
 
-        slot_cur->func = kmalloc(sizeof(struct pci_func), GFP_KERNEL);
+        slot_cur->func = kzalloc(sizeof(struct pci_func), GFP_KERNEL);
         if (!slot_cur->func) {
                 /* We cannot do update_slot_info here, since no memory for
                  * kmalloc n.e.ways, and update_slot_info allocates some */
@@ -1149,7 +1149,6 @@ static int enable_slot(struct hotplug_slot *hs)
                 rc = -ENOMEM;
                 goto error_power;
         }
-        memset(slot_cur->func, 0, sizeof(struct pci_func));
         slot_cur->func->busno = slot_cur->bus;
         slot_cur->func->device = slot_cur->device;
         for (i = 0; i < 4; i++)
@@ -1240,9 +1239,9 @@ int ibmphp_do_disable_slot(struct slot *slot_cur)
         }
         
         flag = slot_cur->flag;
-        slot_cur->flag = TRUE;
+        slot_cur->flag = 1;
 
-        if (flag == TRUE) {
+        if (flag == 1) {
                 rc = validate(slot_cur, DISABLE);
                         /* checking if powered off already & valid slot # */
                 if (rc)
@@ -1252,13 +1251,12 @@ int ibmphp_do_disable_slot(struct slot *slot_cur)
 
         if (slot_cur->func == NULL) {
                 /* We need this for fncs's that were there on bootup */
-                slot_cur->func = kmalloc(sizeof(struct pci_func), GFP_KERNEL);
+                slot_cur->func = kzalloc(sizeof(struct pci_func), GFP_KERNEL);
                 if (!slot_cur->func) {
                         err("out of system memory\n");
                         rc = -ENOMEM;
                         goto error;
                 }
-                memset(slot_cur->func, 0, sizeof(struct pci_func));
                 slot_cur->func->busno = slot_cur->bus;
                 slot_cur->func->device = slot_cur->device;
         }
diff --git a/drivers/pci/hotplug/ibmphp_ebda.c b/drivers/pci/hotplug/ibmphp_ebda.c
index aea1187c73..05e4f5a192 100644
--- a/drivers/pci/hotplug/ibmphp_ebda.c
+++ b/drivers/pci/hotplug/ibmphp_ebda.c
@@ -72,13 +72,7 @@ static int ebda_rio_table (void);
 
 static struct ebda_hpc_list * __init alloc_ebda_hpc_list (void)
 {
-        struct ebda_hpc_list *list;
-
-        list = kmalloc (sizeof (struct ebda_hpc_list), GFP_KERNEL);
-        if (!list)
-                return NULL;
-        memset (list, 0, sizeof (*list));
-        return list;
+        return kzalloc(sizeof(struct ebda_hpc_list), GFP_KERNEL);
 }
 
 static struct controller *alloc_ebda_hpc (u32 slot_count, u32 bus_count)
@@ -87,21 +81,18 @@ static struct controller *alloc_ebda_hpc (u32 slot_count, u32 bus_count)
         struct ebda_hpc_slot *slots;
         struct ebda_hpc_bus *buses;
 
-        controller = kmalloc (sizeof (struct controller), GFP_KERNEL);
+        controller = kzalloc(sizeof(struct controller), GFP_KERNEL);
         if (!controller)
                 goto error;
-        memset (controller, 0, sizeof (*controller));
 
-        slots = kmalloc (sizeof (struct ebda_hpc_slot) * slot_count, GFP_KERNEL);
+        slots = kcalloc(slot_count, sizeof(struct ebda_hpc_slot), GFP_KERNEL);
         if (!slots)
                 goto error_contr;
-        memset (slots, 0, sizeof (*slots) * slot_count);
         controller->slots = slots;
 
-        buses = kmalloc (sizeof (struct ebda_hpc_bus) * bus_count, GFP_KERNEL);
+        buses = kcalloc(bus_count, sizeof(struct ebda_hpc_bus), GFP_KERNEL);
         if (!buses)
                 goto error_slots;
-        memset (buses, 0, sizeof (*buses) * bus_count);
         controller->buses = buses;
 
         return controller;
@@ -122,24 +113,12 @@ static void free_ebda_hpc (struct controller *controller)
 
 static struct ebda_rsrc_list * __init alloc_ebda_rsrc_list (void)
 {
-        struct ebda_rsrc_list *list;
-
-        list = kmalloc (sizeof (struct ebda_rsrc_list), GFP_KERNEL);
-        if (!list)
-                return NULL;
-        memset (list, 0, sizeof (*list));
-        return list;
+        return kzalloc(sizeof(struct ebda_rsrc_list), GFP_KERNEL);
 }
 
 static struct ebda_pci_rsrc *alloc_ebda_pci_rsrc (void)
 {
-        struct ebda_pci_rsrc *resource;
-
-        resource = kmalloc (sizeof (struct ebda_pci_rsrc), GFP_KERNEL);
-        if (!resource)
-                return NULL;
-        memset (resource, 0, sizeof (*resource));
-        return resource;
+        return kzalloc(sizeof(struct ebda_pci_rsrc), GFP_KERNEL);
 }
 
 static void __init print_bus_info (void)
@@ -390,10 +369,9 @@ int __init ibmphp_access_ebda (void)
                         debug ("now enter io table ---\n");
                         debug ("rio blk id: %x\n", blk_id);
 
-                        rio_table_ptr = kmalloc (sizeof (struct rio_table_hdr), GFP_KERNEL);
+                        rio_table_ptr = kzalloc(sizeof(struct rio_table_hdr), GFP_KERNEL);
                         if (!rio_table_ptr)
                                 return -ENOMEM; 
-                        memset (rio_table_ptr, 0, sizeof (struct rio_table_hdr) );
                         rio_table_ptr->ver_num = readb (io_mem + offset);
                         rio_table_ptr->scal_count = readb (io_mem + offset + 1);
                         rio_table_ptr->riodev_count = readb (io_mem + offset + 2);
@@ -445,10 +423,9 @@ static int __init ebda_rio_table (void)
 
         // we do concern about rio details
         for (i = 0; i < rio_table_ptr->riodev_count; i++) {
-                rio_detail_ptr = kmalloc (sizeof (struct rio_detail), GFP_KERNEL);
+                rio_detail_ptr = kzalloc(sizeof(struct rio_detail), GFP_KERNEL);
                 if (!rio_detail_ptr)
                         return -ENOMEM;
-                memset (rio_detail_ptr, 0, sizeof (struct rio_detail));
                 rio_detail_ptr->rio_node_id = readb (io_mem + offset);
                 rio_detail_ptr->bbar = readl (io_mem + offset + 1);
                 rio_detail_ptr->rio_type = readb (io_mem + offset + 5);
@@ -503,10 +480,9 @@ static int __init combine_wpg_for_chassis (void)
                 rio_detail_ptr = list_entry (list_head_ptr, struct rio_detail, rio_detail_list);
                 opt_rio_ptr = search_opt_vg (rio_detail_ptr->chassis_num);
                 if (!opt_rio_ptr) {
-                        opt_rio_ptr = (struct opt_rio *) kmalloc (sizeof (struct opt_rio), GFP_KERNEL);
+                        opt_rio_ptr = kzalloc(sizeof(struct opt_rio), GFP_KERNEL);
                         if (!opt_rio_ptr)
                                 return -ENOMEM;
-                        memset (opt_rio_ptr, 0, sizeof (struct opt_rio));
                         opt_rio_ptr->rio_type = rio_detail_ptr->rio_type;
                         opt_rio_ptr->chassis_num = rio_detail_ptr->chassis_num;
                         opt_rio_ptr->first_slot_num = rio_detail_ptr->first_slot_num;
@@ -546,10 +522,9 @@ static int combine_wpg_for_expansion (void)
                 rio_detail_ptr = list_entry (list_head_ptr, struct rio_detail, rio_detail_list);
                 opt_rio_lo_ptr = search_opt_lo (rio_detail_ptr->chassis_num);
                 if (!opt_rio_lo_ptr) {
-                        opt_rio_lo_ptr = (struct opt_rio_lo *) kmalloc (sizeof (struct opt_rio_lo), GFP_KERNEL);
+                        opt_rio_lo_ptr = kzalloc(sizeof(struct opt_rio_lo), GFP_KERNEL);
                         if (!opt_rio_lo_ptr)
                                 return -ENOMEM;
-                        memset (opt_rio_lo_ptr, 0, sizeof (struct opt_rio_lo));
                         opt_rio_lo_ptr->rio_type = rio_detail_ptr->rio_type;
                         opt_rio_lo_ptr->chassis_num = rio_detail_ptr->chassis_num;
                         opt_rio_lo_ptr->first_slot_num = rio_detail_ptr->first_slot_num;
@@ -842,12 +817,11 @@ static int __init ebda_rsrc_controller (void)
 
                         bus_info_ptr2 = ibmphp_find_same_bus_num (slot_ptr->slot_bus_num);
                         if (!bus_info_ptr2) {
-                                bus_info_ptr1 = (struct bus_info *) kmalloc (sizeof (struct bus_info), GFP_KERNEL);
+                                bus_info_ptr1 = kzalloc(sizeof(struct bus_info), GFP_KERNEL);
                                 if (!bus_info_ptr1) {
                                         rc = -ENOMEM;
                                         goto error_no_hp_slot;
                                 }
-                                memset (bus_info_ptr1, 0, sizeof (struct bus_info));
                                 bus_info_ptr1->slot_min = slot_ptr->slot_num;
                                 bus_info_ptr1->slot_max = slot_ptr->slot_num;
                                 bus_info_ptr1->slot_count += 1;
@@ -946,19 +920,17 @@ static int __init ebda_rsrc_controller (void)
                 // register slots with hpc core as well as create linked list of ibm slot
                 for (index = 0; index < hpc_ptr->slot_count; index++) {
 
-                        hp_slot_ptr = kmalloc(sizeof(*hp_slot_ptr), GFP_KERNEL);
+                        hp_slot_ptr = kzalloc(sizeof(*hp_slot_ptr), GFP_KERNEL);
                         if (!hp_slot_ptr) {
                                 rc = -ENOMEM;
                                 goto error_no_hp_slot;
                         }
-                        memset(hp_slot_ptr, 0, sizeof(*hp_slot_ptr));
 
-                        hp_slot_ptr->info = kmalloc (sizeof(struct hotplug_slot_info), GFP_KERNEL);
+                        hp_slot_ptr->info = kzalloc(sizeof(struct hotplug_slot_info), GFP_KERNEL);
                         if (!hp_slot_ptr->info) {
                                 rc = -ENOMEM;
                                 goto error_no_hp_info;
                         }
-                        memset(hp_slot_ptr->info, 0, sizeof(struct hotplug_slot_info));
 
                         hp_slot_ptr->name = kmalloc(30, GFP_KERNEL);
                         if (!hp_slot_ptr->name) {
@@ -966,14 +938,13 @@ static int __init ebda_rsrc_controller (void)
                                 goto error_no_hp_name;
                         }
 
-                        tmp_slot = kmalloc(sizeof(*tmp_slot), GFP_KERNEL);
+                        tmp_slot = kzalloc(sizeof(*tmp_slot), GFP_KERNEL);
                         if (!tmp_slot) {
                                 rc = -ENOMEM;
                                 goto error_no_slot;
                         }
-                        memset(tmp_slot, 0, sizeof(*tmp_slot));
 
-                        tmp_slot->flag = TRUE;
+                        tmp_slot->flag = 1;
 
                         tmp_slot->capabilities = hpc_ptr->slots[index].slot_cap;
                         if ((hpc_ptr->slots[index].slot_cap & EBDA_SLOT_133_MAX) == EBDA_SLOT_133_MAX)
diff --git a/drivers/pci/hotplug/ibmphp_hpc.c b/drivers/pci/hotplug/ibmphp_hpc.c
index 1a3eb8d3d4..c3ac98a0a6 100644
--- a/drivers/pci/hotplug/ibmphp_hpc.c
+++ b/drivers/pci/hotplug/ibmphp_hpc.c
@@ -34,9 +34,11 @@
 #include <linux/pci.h>
 #include <linux/smp_lock.h>
 #include <linux/init.h>
+#include <linux/mutex.h>
+
 #include "ibmphp.h"
 
-static int to_debug = FALSE;
+static int to_debug = 0;
 #define debug_polling(fmt, arg...)      do { if (to_debug) debug (fmt, arg); } while (0)
 
 //----------------------------------------------------------------------------
@@ -93,15 +95,15 @@ static int to_debug = FALSE;
 //----------------------------------------------------------------------------
 // macro utilities
 //----------------------------------------------------------------------------
-// if bits 20,22,25,26,27,29,30 are OFF return TRUE
-#define HPC_I2CSTATUS_CHECK(s)  ((u8)((s & 0x00000A76) ? FALSE : TRUE))
+// if bits 20,22,25,26,27,29,30 are OFF return 1
+#define HPC_I2CSTATUS_CHECK(s)  ((u8)((s & 0x00000A76) ? 0 : 1))
 
 //----------------------------------------------------------------------------
 // global variables
 //----------------------------------------------------------------------------
 static int ibmphp_shutdown;
 static int tid_poll;
-static struct semaphore sem_hpcaccess;  // lock access to HPC
+static struct mutex sem_hpcaccess;      // lock access to HPC
 static struct semaphore semOperations;  // lock all operations and
                                         // access to data structures
 static struct semaphore sem_exit;       // make sure polling thread goes away
@@ -131,11 +133,11 @@ void __init ibmphp_hpc_initvars (void)
 {
         debug ("%s - Entry\n", __FUNCTION__);
 
-        init_MUTEX (&sem_hpcaccess);
+        mutex_init(&sem_hpcaccess);
         init_MUTEX (&semOperations);
         init_MUTEX_LOCKED (&sem_exit);
-        to_debug = FALSE;
-        ibmphp_shutdown = FALSE;
+        to_debug = 0;
+        ibmphp_shutdown = 0;
         tid_poll = 0;
 
         debug ("%s - Exit\n", __FUNCTION__);
@@ -737,21 +739,21 @@ int ibmphp_hpc_writeslot (struct slot * pslot, u8 cmd)
                 // check controller is still not working on the command
                 //--------------------------------------------------------------------
                 timeout = CMD_COMPLETE_TOUT_SEC;
-                done = FALSE;
+                done = 0;
                 while (!done) {
                         rc = hpc_wait_ctlr_notworking (HPC_CTLR_WORKING_TOUT, ctlr_ptr, wpg_bbar,
                                                         &status);
                         if (!rc) {
                                 if (NEEDTOCHECK_CMDSTATUS (cmd)) {
                                         if (CTLR_FINISHED (status) == HPC_CTLR_FINISHED_YES)
-                                                done = TRUE;
+                                                done = 1;
                                 } else
-                                        done = TRUE;
+                                        done = 1;
                         }
                         if (!done) {
                                 msleep(1000);
                                 if (timeout < 1) {
-                                        done = TRUE;
+                                        done = 1;
                                         err ("%s - Error command complete timeout\n", __FUNCTION__);
                                         rc = -EFAULT;
                                 } else
@@ -778,7 +780,7 @@ int ibmphp_hpc_writeslot (struct slot * pslot, u8 cmd)
 *---------------------------------------------------------------------*/
 static void get_hpc_access (void)
 {
-        down (&sem_hpcaccess);
+        mutex_lock(&sem_hpcaccess);
 }
 
 /*----------------------------------------------------------------------
@@ -786,7 +788,7 @@ static void get_hpc_access (void)
 *---------------------------------------------------------------------*/
 void free_hpc_access (void)
 {
-        up (&sem_hpcaccess);
+        mutex_unlock(&sem_hpcaccess);
 }
 
 /*----------------------------------------------------------------------
@@ -797,7 +799,7 @@ void free_hpc_access (void)
 void ibmphp_lock_operations (void)
 {
         down (&semOperations);
-        to_debug = TRUE;
+        to_debug = 1;
 }
 
 /*----------------------------------------------------------------------
@@ -807,7 +809,7 @@ void ibmphp_unlock_operations (void)
 {
         debug ("%s - Entry\n", __FUNCTION__);
         up (&semOperations);
-        to_debug = FALSE;
+        to_debug = 0;
         debug ("%s - Exit\n", __FUNCTION__);
 }
 
@@ -935,40 +937,40 @@ static int process_changeinstatus (struct slot *pslot, struct slot *poldslot)
 {
         u8 status;
         int rc = 0;
-        u8 disable = FALSE;
-        u8 update = FALSE;
+        u8 disable = 0;
+        u8 update = 0;
 
         debug ("process_changeinstatus - Entry pslot[%p], poldslot[%p]\n", pslot, poldslot);
 
         // bit 0 - HPC_SLOT_POWER
         if ((pslot->status & 0x01) != (poldslot->status & 0x01))
-                update = TRUE;
+                update = 1;
 
         // bit 1 - HPC_SLOT_CONNECT
         // ignore
 
         // bit 2 - HPC_SLOT_ATTN
         if ((pslot->status & 0x04) != (poldslot->status & 0x04))
-                update = TRUE;
+                update = 1;
 
         // bit 3 - HPC_SLOT_PRSNT2
         // bit 4 - HPC_SLOT_PRSNT1
         if (((pslot->status & 0x08) != (poldslot->status & 0x08))
                 || ((pslot->status & 0x10) != (poldslot->status & 0x10)))
-                update = TRUE;
+                update = 1;
 
         // bit 5 - HPC_SLOT_PWRGD
         if ((pslot->status & 0x20) != (poldslot->status & 0x20))
                 // OFF -> ON: ignore, ON -> OFF: disable slot
                 if ((poldslot->status & 0x20) && (SLOT_CONNECT (poldslot->status) == HPC_SLOT_CONNECTED) && (SLOT_PRESENT (poldslot->status))) 
-                        disable = TRUE;
+                        disable = 1;
 
         // bit 6 - HPC_SLOT_BUS_SPEED
         // ignore
 
         // bit 7 - HPC_SLOT_LATCH
         if ((pslot->status & 0x80) != (poldslot->status & 0x80)) {
-                update = TRUE;
+                update = 1;
                 // OPEN -> CLOSE
                 if (pslot->status & 0x80) {
                         if (SLOT_PWRGD (pslot->status)) {
@@ -977,7 +979,7 @@ static int process_changeinstatus (struct slot *pslot, struct slot *poldslot)
                                 msleep(1000);
                                 rc = ibmphp_hpc_readslot (pslot, READ_SLOTSTATUS, &status);
                                 if (SLOT_PWRGD (status))
-                                        update = TRUE;
+                                        update = 1;
                                 else    // overwrite power in pslot to OFF
                                         pslot->status &= ~HPC_SLOT_POWER;
                         }
@@ -985,17 +987,17 @@ static int process_changeinstatus (struct slot *pslot, struct slot *poldslot)
                 // CLOSE -> OPEN 
                 else if ((SLOT_PWRGD (poldslot->status) == HPC_SLOT_PWRGD_GOOD)
                         && (SLOT_CONNECT (poldslot->status) == HPC_SLOT_CONNECTED) && (SLOT_PRESENT (poldslot->status))) {
-                        disable = TRUE;
+                        disable = 1;
                 }
                 // else - ignore
         }
         // bit 4 - HPC_SLOT_BLINK_ATTN
         if ((pslot->ext_status & 0x08) != (poldslot->ext_status & 0x08))
-                update = TRUE;
+                update = 1;
 
         if (disable) {
                 debug ("process_changeinstatus - disable slot\n");
-                pslot->flag = FALSE;
+                pslot->flag = 0;
                 rc = ibmphp_do_disable_slot (pslot);
         }
 
@@ -1100,7 +1102,7 @@ void __exit ibmphp_hpc_stop_poll_thread (void)
 {
         debug ("%s - Entry\n", __FUNCTION__);
 
-        ibmphp_shutdown = TRUE;
+        ibmphp_shutdown = 1;
         debug ("before locking operations \n");
         ibmphp_lock_operations ();
         debug ("after locking operations \n");
@@ -1134,7 +1136,7 @@ static int hpc_wait_ctlr_notworking (int timeout, struct controller *ctlr_ptr, v
                                     u8 * pstatus)
 {
         int rc = 0;
-        u8 done = FALSE;
+        u8 done = 0;
 
         debug_polling ("hpc_wait_ctlr_notworking - Entry timeout[%d]\n", timeout);
 
@@ -1142,14 +1144,14 @@ static int hpc_wait_ctlr_notworking (int timeout, struct controller *ctlr_ptr, v
                 *pstatus = ctrl_read (ctlr_ptr, wpg_bbar, WPG_CTLR_INDEX);
                 if (*pstatus == HPC_ERROR) {
                         rc = HPC_ERROR;
-                        done = TRUE;
+                        done = 1;
                 }
                 if (CTLR_WORKING (*pstatus) == HPC_CTLR_WORKING_NO)
-                        done = TRUE;
+                        done = 1;
                 if (!done) {
                         msleep(1000);
                         if (timeout < 1) {
-                                done = TRUE;
+                                done = 1;
                                 err ("HPCreadslot - Error ctlr timeout\n");
                                 rc = HPC_ERROR;
                         } else
diff --git a/drivers/pci/hotplug/ibmphp_pci.c b/drivers/pci/hotplug/ibmphp_pci.c
index 155133fe5c..d87a9e3eae 100644
--- a/drivers/pci/hotplug/ibmphp_pci.c
+++ b/drivers/pci/hotplug/ibmphp_pci.c
@@ -164,12 +164,11 @@ int ibmphp_configure_card (struct pci_func *func, u8 slotno)
                                                 cleanup_count = 6;
                                                 goto error;
                                         }
-                                        newfunc = kmalloc(sizeof(*newfunc), GFP_KERNEL);
+                                        newfunc = kzalloc(sizeof(*newfunc), GFP_KERNEL);
                                         if (!newfunc) {
                                                 err ("out of system memory\n");
                                                 return -ENOMEM;
                                         }
-                                        memset (newfunc, 0, sizeof (struct pci_func));
                                         newfunc->busno = cur_func->busno;
                                         newfunc->device = device;
                                         cur_func->next = newfunc;
@@ -200,15 +199,14 @@ int ibmphp_configure_card (struct pci_func *func, u8 slotno)
                                         }
 
                                         pci_bus_read_config_byte (ibmphp_pci_bus, devfn, PCI_SECONDARY_BUS, &sec_number);
-                                        flag = FALSE;
+                                        flag = 0;
                                         for (i = 0; i < 32; i++) {
                                                 if (func->devices[i]) {
-                                                        newfunc = kmalloc(sizeof(*newfunc), GFP_KERNEL);
+                                                        newfunc = kzalloc(sizeof(*newfunc), GFP_KERNEL);
                                                         if (!newfunc) {
                                                                 err ("out of system memory\n");
                                                                 return -ENOMEM;
                                                         }
-                                                        memset (newfunc, 0, sizeof (struct pci_func));
                                                         newfunc->busno = sec_number;
                                                         newfunc->device = (u8) i;
                                                         for (j = 0; j < 4; j++)
@@ -228,16 +226,15 @@ int ibmphp_configure_card (struct pci_func *func, u8 slotno)
                                                                 cleanup_count = 2;
                                                                 goto error;
                                                         }
-                                                        flag = TRUE;
+                                                        flag = 1;
                                                 }
                                         }
 
-                                        newfunc = kmalloc(sizeof(*newfunc), GFP_KERNEL);
+                                        newfunc = kzalloc(sizeof(*newfunc), GFP_KERNEL);
                                         if (!newfunc) {
                                                 err ("out of system memory\n");
                                                 return -ENOMEM;
                                         }
-                                        memset (newfunc, 0, sizeof (struct pci_func));
                                         newfunc->busno = cur_func->busno;
                                         newfunc->device = device;
                                         for (j = 0; j < 4; j++)
@@ -275,16 +272,15 @@ int ibmphp_configure_card (struct pci_func *func, u8 slotno)
                                                 cur_func->busno, device, function);
                                         pci_bus_read_config_byte (ibmphp_pci_bus, devfn, PCI_SECONDARY_BUS, &sec_number);
                                         debug ("after configuring bridge..., sec_number = %x\n", sec_number);
-                                        flag = FALSE;
+                                        flag = 0;
                                         for (i = 0; i < 32; i++) {
                                                 if (func->devices[i]) {
                                                         debug ("inside for loop, device is %x\n", i);
-                                                        newfunc = kmalloc(sizeof(*newfunc), GFP_KERNEL);
+                                                        newfunc = kzalloc(sizeof(*newfunc), GFP_KERNEL);
                                                         if (!newfunc) {
                                                                 err (" out of system memory\n");
                                                                 return -ENOMEM;
                                                         }
-                                                        memset (newfunc, 0, sizeof (struct pci_func));
                                                         newfunc->busno = sec_number;
                                                         newfunc->device = (u8) i;
                                                         for (j = 0; j < 4; j++)
@@ -305,7 +301,7 @@ int ibmphp_configure_card (struct pci_func *func, u8 slotno)
                                                                 cleanup_count = 2;
                                                                 goto error;
                                                         }
-                                                        flag = TRUE;
+                                                        flag = 1;
                                                 }
                                         }
 
@@ -405,13 +401,12 @@ static int configure_device (struct pci_func *func)
 
                         debug ("len[count] in IO %x, count %d\n", len[count], count);
 
-                        io[count] = kmalloc (sizeof (struct resource_node), GFP_KERNEL);
+                        io[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
 
                         if (!io[count]) {
                                 err ("out of system memory\n");
                                 return -ENOMEM;
                         }
-                        memset (io[count], 0, sizeof (struct resource_node));
                         io[count]->type = IO;
                         io[count]->busno = func->busno;
                         io[count]->devfunc = PCI_DEVFN(func->device, func->function);
@@ -444,29 +439,27 @@ static int configure_device (struct pci_func *func)
 
                                 debug ("len[count] in PFMEM %x, count %d\n", len[count], count);
 
-                                pfmem[count] = kmalloc (sizeof (struct resource_node), GFP_KERNEL);
+                                pfmem[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
                                 if (!pfmem[count]) {
                                         err ("out of system memory\n");
                                         return -ENOMEM;
                                 }
-                                memset (pfmem[count], 0, sizeof (struct resource_node));
                                 pfmem[count]->type = PFMEM;
                                 pfmem[count]->busno = func->busno;
                                 pfmem[count]->devfunc = PCI_DEVFN(func->device,
                                                         func->function);
                                 pfmem[count]->len = len[count];
-                                pfmem[count]->fromMem = FALSE;
+                                pfmem[count]->fromMem = 0;
                                 if (ibmphp_check_resource (pfmem[count], 0) == 0) {
                                         ibmphp_add_resource (pfmem[count]);
                                         func->pfmem[count] = pfmem[count];
                                 } else {
-                                        mem_tmp = kmalloc(sizeof(*mem_tmp), GFP_KERNEL);
+                                        mem_tmp = kzalloc(sizeof(*mem_tmp), GFP_KERNEL);
                                         if (!mem_tmp) {
                                                 err ("out of system memory\n");
                                                 kfree (pfmem[count]);
                                                 return -ENOMEM;
                                         }
-                                        memset (mem_tmp, 0, sizeof (struct resource_node));
                                         mem_tmp->type = MEM;
                                         mem_tmp->busno = pfmem[count]->busno;
                                         mem_tmp->devfunc = pfmem[count]->devfunc;
@@ -474,7 +467,7 @@ static int configure_device (struct pci_func *func)
                                         debug ("there's no pfmem... going into mem.\n");
                                         if (ibmphp_check_resource (mem_tmp, 0) == 0) {
                                                 ibmphp_add_resource (mem_tmp);
-                                                pfmem[count]->fromMem = TRUE;
+                                                pfmem[count]->fromMem = 1;
                                                 pfmem[count]->rangeno = mem_tmp->rangeno;
                                                 pfmem[count]->start = mem_tmp->start;
                                                 pfmem[count]->end = mem_tmp->end;
@@ -512,12 +505,11 @@ static int configure_device (struct pci_func *func)
 
                                 debug ("len[count] in Mem %x, count %d\n", len[count], count);
 
-                                mem[count] = kmalloc (sizeof (struct resource_node), GFP_KERNEL);
+                                mem[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
                                 if (!mem[count]) {
                                         err ("out of system memory\n");
                                         return -ENOMEM;
                                 }
-                                memset (mem[count], 0, sizeof (struct resource_node));
                                 mem[count]->type = MEM;
                                 mem[count]->busno = func->busno;
                                 mem[count]->devfunc = PCI_DEVFN(func->device,
@@ -579,11 +571,11 @@ static int configure_bridge (struct pci_func **func_passed, u8 slotno)
         u16 pfmem_base;
         u32 bar[2];
         u32 len[2];
-        u8 flag_io = FALSE;
-        u8 flag_mem = FALSE;
-        u8 flag_pfmem = FALSE;
-        u8 need_io_upper = FALSE;
-        u8 need_pfmem_upper = FALSE;
+        u8 flag_io = 0;
+        u8 flag_mem = 0;
+        u8 flag_pfmem = 0;
+        u8 need_io_upper = 0;
+        u8 need_pfmem_upper = 0;
         struct res_needed *amount_needed = NULL;
         struct resource_node *io = NULL;
         struct resource_node *bus_io[2] = {NULL, NULL};
@@ -677,14 +669,13 @@ static int configure_bridge (struct pci_func **func_passed, u8 slotno)
 
                         debug ("len[count] in IO = %x\n", len[count]);
 
-                        bus_io[count] = kmalloc (sizeof (struct resource_node), GFP_KERNEL);
+                        bus_io[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
                 
                         if (!bus_io[count]) {
                                 err ("out of system memory\n");
                                 retval = -ENOMEM;
                                 goto error;
                         }
-                        memset (bus_io[count], 0, sizeof (struct resource_node));
                         bus_io[count]->type = IO;
                         bus_io[count]->busno = func->busno;
                         bus_io[count]->devfunc = PCI_DEVFN(func->device,
@@ -711,37 +702,35 @@ static int configure_bridge (struct pci_func **func_passed, u8 slotno)
 
                                 debug ("len[count] in PFMEM = %x\n", len[count]);
 
-                                bus_pfmem[count] = kmalloc (sizeof (struct resource_node), GFP_KERNEL);
+                                bus_pfmem[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
                                 if (!bus_pfmem[count]) {
                                         err ("out of system memory\n");
                                         retval = -ENOMEM;
                                         goto error;
                                 }
-                                memset (bus_pfmem[count], 0, sizeof (struct resource_node));
                                 bus_pfmem[count]->type = PFMEM;
                                 bus_pfmem[count]->busno = func->busno;
                                 bus_pfmem[count]->devfunc = PCI_DEVFN(func->device,
                                                         func->function);
                                 bus_pfmem[count]->len = len[count];
-                                bus_pfmem[count]->fromMem = FALSE;
+                                bus_pfmem[count]->fromMem = 0;
                                 if (ibmphp_check_resource (bus_pfmem[count], 0) == 0) {
                                         ibmphp_add_resource (bus_pfmem[count]);
                                         func->pfmem[count] = bus_pfmem[count];
                                 } else {
-                                        mem_tmp = kmalloc(sizeof(*mem_tmp), GFP_KERNEL);
+                                        mem_tmp = kzalloc(sizeof(*mem_tmp), GFP_KERNEL);
                                         if (!mem_tmp) {
                                                 err ("out of system memory\n");
                                                 retval = -ENOMEM;
                                                 goto error;
                                         }
-                                        memset (mem_tmp, 0, sizeof (struct resource_node));
                                         mem_tmp->type = MEM;
                                         mem_tmp->busno = bus_pfmem[count]->busno;
                                         mem_tmp->devfunc = bus_pfmem[count]->devfunc;
                                         mem_tmp->len = bus_pfmem[count]->len;
                                         if (ibmphp_check_resource (mem_tmp, 0) == 0) {
                                                 ibmphp_add_resource (mem_tmp);
-                                                bus_pfmem[count]->fromMem = TRUE;
+                                                bus_pfmem[count]->fromMem = 1;
                                                 bus_pfmem[count]->rangeno = mem_tmp->rangeno;
                                                 ibmphp_add_pfmem_from_mem (bus_pfmem[count]);
                                                 func->pfmem[count] = bus_pfmem[count];
@@ -770,13 +759,12 @@ static int configure_bridge (struct pci_func **func_passed, u8 slotno)
 
                                 debug ("len[count] in Memory is %x\n", len[count]);
 
-                                bus_mem[count] = kmalloc (sizeof (struct resource_node), GFP_KERNEL);
+                                bus_mem[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
                                 if (!bus_mem[count]) {
                                         err ("out of system memory\n");
                                         retval = -ENOMEM;
                                         goto error;
                                 }
-                                memset (bus_mem[count], 0, sizeof (struct resource_node));
                                 bus_mem[count]->type = MEM;
                                 bus_mem[count]->busno = func->busno;
                                 bus_mem[count]->devfunc = PCI_DEVFN(func->device,
@@ -838,17 +826,16 @@ static int configure_bridge (struct pci_func **func_passed, u8 slotno)
 
         if (!amount_needed->io) {
                 debug ("it doesn't want IO?\n");
-                flag_io = TRUE;
+                flag_io = 1;
         } else {
                 debug ("it wants %x IO behind the bridge\n", amount_needed->io);
-                io = kmalloc(sizeof(*io), GFP_KERNEL);
+                io = kzalloc(sizeof(*io), GFP_KERNEL);
                 
                 if (!io) {
                         err ("out of system memory\n");
                         retval = -ENOMEM;
                         goto error;
                 }
-                memset (io, 0, sizeof (struct resource_node));
                 io->type = IO;
                 io->busno = func->busno;
                 io->devfunc = PCI_DEVFN(func->device, func->function);
@@ -856,71 +843,68 @@ static int configure_bridge (struct pci_func **func_passed, u8 slotno)
                 if (ibmphp_check_resource (io, 1) == 0) {
                         debug ("were we able to add io\n");
                         ibmphp_add_resource (io);
-                        flag_io = TRUE;
+                        flag_io = 1;
                 }
         }
 
         if (!amount_needed->mem) {
                 debug ("it doesn't want n.e.memory?\n");
-                flag_mem = TRUE;
+                flag_mem = 1;
         } else {
                 debug ("it wants %x memory behind the bridge\n", amount_needed->mem);
-                mem = kmalloc(sizeof(*mem), GFP_KERNEL);
+                mem = kzalloc(sizeof(*mem), GFP_KERNEL);
                 if (!mem) {
                         err ("out of system memory\n");
                         retval = -ENOMEM;
                         goto error;
                 }
-                memset (mem, 0, sizeof (struct resource_node));
                 mem->type = MEM;
                 mem->busno = func->busno;
                 mem->devfunc = PCI_DEVFN(func->device, func->function);
                 mem->len = amount_needed->mem;
                 if (ibmphp_check_resource (mem, 1) == 0) {
                         ibmphp_add_resource (mem);
-                        flag_mem = TRUE;
+                        flag_mem = 1;
                         debug ("were we able to add mem\n");
                 }
         }
 
         if (!amount_needed->pfmem) {
                 debug ("it doesn't want n.e.pfmem mem?\n");
-                flag_pfmem = TRUE;
+                flag_pfmem = 1;
         } else {
                 debug ("it wants %x pfmemory behind the bridge\n", amount_needed->pfmem);
-                pfmem = kmalloc(sizeof(*pfmem), GFP_KERNEL);
+                pfmem = kzalloc(sizeof(*pfmem), GFP_KERNEL);
                 if (!pfmem) {
                         err ("out of system memory\n");
                         retval = -ENOMEM;
                         goto error;
                 }
-                memset (pfmem, 0, sizeof (struct resource_node));
                 pfmem->type = PFMEM;
                 pfmem->busno = func->busno;
                 pfmem->devfunc = PCI_DEVFN(func->device, func->function);
                 pfmem->len = amount_needed->pfmem;
-                pfmem->fromMem = FALSE;
+                pfmem->fromMem = 0;
                 if (ibmphp_check_resource (pfmem, 1) == 0) {
                         ibmphp_add_resource (pfmem);
-                        flag_pfmem = TRUE;
+                        flag_pfmem = 1;
                 } else {
-                        mem_tmp = kmalloc(sizeof(*mem_tmp), GFP_KERNEL);
+                        mem_tmp = kzalloc(sizeof(*mem_tmp), GFP_KERNEL);
                         if (!mem_tmp) {
                                 err ("out of system memory\n");
                                 retval = -ENOMEM;
                                 goto error;
                         }
-                        memset (mem_tmp, 0, sizeof (struct resource_node));
                         mem_tmp->type = MEM;
                         mem_tmp->busno = pfmem->busno;
                         mem_tmp->devfunc = pfmem->devfunc;
                         mem_tmp->len = pfmem->len;
                         if (ibmphp_check_resource (mem_tmp, 1) == 0) {
                                 ibmphp_add_resource (mem_tmp);
-                                pfmem->fromMem = TRUE;
+                                pfmem->fromMem = 1;
                                 pfmem->rangeno = mem_tmp->rangeno;
                                 ibmphp_add_pfmem_from_mem (pfmem);
-                                flag_pfmem = TRUE;
+                                flag_pfmem = 1;
                         }
                 }
         }
@@ -936,13 +920,12 @@ static int configure_bridge (struct pci_func **func_passed, u8 slotno)
                  */
                 bus = ibmphp_find_res_bus (sec_number);
                 if (!bus) {
-                        bus = kmalloc(sizeof(*bus), GFP_KERNEL);
+                        bus = kzalloc(sizeof(*bus), GFP_KERNEL);
                         if (!bus) {
                                 err ("out of system memory\n");
                                 retval = -ENOMEM;
                                 goto error;
                         }
-                        memset (bus, 0, sizeof (struct bus_node));
                         bus->busno = sec_number;
                         debug ("b4 adding new bus\n");
                         rc = add_new_bus (bus, io, mem, pfmem, func->busno);
@@ -967,11 +950,11 @@ static int configure_bridge (struct pci_func **func_passed, u8 slotno)
 
                 if ((io_base & PCI_IO_RANGE_TYPE_MASK) == PCI_IO_RANGE_TYPE_32) {
                         debug ("io 32\n");
-                        need_io_upper = TRUE;
+                        need_io_upper = 1;
                 }
                 if ((pfmem_base & PCI_PREF_RANGE_TYPE_MASK) == PCI_PREF_RANGE_TYPE_64) {
                         debug ("pfmem 64\n");
-                        need_pfmem_upper = TRUE;
+                        need_pfmem_upper = 1;
                 }
 
                 if (bus->noIORanges) {
@@ -1111,10 +1094,9 @@ static struct res_needed *scan_behind_bridge (struct pci_func * func, u8 busno)
         };
         struct res_needed *amount;
 
-        amount = kmalloc(sizeof(*amount), GFP_KERNEL);
+        amount = kzalloc(sizeof(*amount), GFP_KERNEL);
         if (amount == NULL)
                 return NULL;
-        memset (amount, 0, sizeof (struct res_needed));
 
         ibmphp_pci_bus->number = busno;
 
@@ -1137,7 +1119,7 @@ static struct res_needed *scan_behind_bridge (struct pci_func * func, u8 busno)
                                 debug ("hdr_type behind the bridge is %x\n", hdr_type);
                                 if (hdr_type & PCI_HEADER_TYPE_BRIDGE) {
                                         err ("embedded bridges not supported for hot-plugging.\n");
-                                        amount->not_correct = TRUE;
+                                        amount->not_correct = 1;
                                         return amount;
                                 }
 
@@ -1145,12 +1127,12 @@ static struct res_needed *scan_behind_bridge (struct pci_func * func, u8 busno)
                                 if (class == PCI_CLASS_NOT_DEFINED_VGA) {
                                         err ("The device %x is VGA compatible and as is not supported for hot plugging. "
                                              "Please choose another device.\n", device);
-                                        amount->not_correct = TRUE;
+                                        amount->not_correct = 1;
                                         return amount;
                                 } else if (class == PCI_CLASS_DISPLAY_VGA) {
                                         err ("The device %x is not supported for hot plugging. "
                                              "Please choose another device.\n", device);
-                                        amount->not_correct = TRUE;
+                                        amount->not_correct = 1;
                                         return amount;
                                 }
 
@@ -1210,9 +1192,9 @@ static struct res_needed *scan_behind_bridge (struct pci_func * func, u8 busno)
         }       /* end for */
 
         if (!howmany)
-                amount->not_correct = TRUE;
+                amount->not_correct = 1;
         else
-                amount->not_correct = FALSE;
+                amount->not_correct = 0;
         if ((amount->io) && (amount->io < IOBRIDGE))
                 amount->io = IOBRIDGE;
         if ((amount->mem) && (amount->mem < MEMBRIDGE))
@@ -1672,12 +1654,11 @@ static int add_new_bus (struct bus_node *bus, struct resource_node *io, struct r
                 list_add (&bus->bus_list, &cur_bus->bus_list);
         }
         if (io) {
-                io_range = kmalloc(sizeof(*io_range), GFP_KERNEL);
+                io_range = kzalloc(sizeof(*io_range), GFP_KERNEL);
                 if (!io_range) {
                         err ("out of system memory\n");
                         return -ENOMEM;
                 }
-                memset (io_range, 0, sizeof (struct range_node));
                 io_range->start = io->start;
                 io_range->end = io->end;
                 io_range->rangeno = 1;
@@ -1685,12 +1666,11 @@ static int add_new_bus (struct bus_node *bus, struct resource_node *io, struct r
                 bus->rangeIO = io_range;
         }
         if (mem) {
-                mem_range = kmalloc(sizeof(*mem_range), GFP_KERNEL);
+                mem_range = kzalloc(sizeof(*mem_range), GFP_KERNEL);
                 if (!mem_range) {
                         err ("out of system memory\n");
                         return -ENOMEM;
                 }
-                memset (mem_range, 0, sizeof (struct range_node));
                 mem_range->start = mem->start;
                 mem_range->end = mem->end;
                 mem_range->rangeno = 1;
@@ -1698,12 +1678,11 @@ static int add_new_bus (struct bus_node *bus, struct resource_node *io, struct r
                 bus->rangeMem = mem_range;
         }
         if (pfmem) {
-                pfmem_range = kmalloc(sizeof(*pfmem_range), GFP_KERNEL);
+                pfmem_range = kzalloc(sizeof(*pfmem_range), GFP_KERNEL);
                 if (!pfmem_range) {     
                         err ("out of system memory\n");
                         return -ENOMEM;
                 }
-                memset (pfmem_range, 0, sizeof (struct range_node));
                 pfmem_range->start = pfmem->start;
                 pfmem_range->end = pfmem->end;
                 pfmem_range->rangeno = 1;
diff --git a/drivers/pci/hotplug/ibmphp_res.c b/drivers/pci/hotplug/ibmphp_res.c
index 9c224c94d6..5636b1ac2a 100644
--- a/drivers/pci/hotplug/ibmphp_res.c
+++ b/drivers/pci/hotplug/ibmphp_res.c
@@ -55,13 +55,12 @@ static struct bus_node * __init alloc_error_bus (struct ebda_pci_rsrc * curr, u8
                 return NULL;
         }
 
-        newbus = kmalloc (sizeof (struct bus_node), GFP_KERNEL);
+        newbus = kzalloc(sizeof(struct bus_node), GFP_KERNEL);
         if (!newbus) {
                 err ("out of system memory\n");
                 return NULL;
         }
 
-        memset (newbus, 0, sizeof (struct bus_node));
         if (flag)
                 newbus->busno = busno;
         else
@@ -79,12 +78,11 @@ static struct resource_node * __init alloc_resources (struct ebda_pci_rsrc * cur
                 return NULL;
         }
 
-        rs = kmalloc (sizeof (struct resource_node), GFP_KERNEL);
+        rs = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
         if (!rs) {
                 err ("out of system memory\n");
                 return NULL;
         }
-        memset (rs, 0, sizeof (struct resource_node));
         rs->busno = curr->bus_num;
         rs->devfunc = curr->dev_fun;
         rs->start = curr->start_addr;
@@ -100,12 +98,11 @@ static int __init alloc_bus_range (struct bus_node **new_bus, struct range_node
         u8 num_ranges = 0;
 
         if (first_bus) {
-                newbus = kmalloc (sizeof (struct bus_node), GFP_KERNEL);
+                newbus = kzalloc(sizeof(struct bus_node), GFP_KERNEL);
                 if (!newbus) {
                         err ("out of system memory.\n");
                         return -ENOMEM;
                 }
-                memset (newbus, 0, sizeof (struct bus_node));
                 newbus->busno = curr->bus_num;
         } else {
                 newbus = *new_bus;
@@ -122,14 +119,13 @@ static int __init alloc_bus_range (struct bus_node **new_bus, struct range_node
                 }
         }
 
-        newrange = kmalloc (sizeof (struct range_node), GFP_KERNEL);
+        newrange = kzalloc(sizeof(struct range_node), GFP_KERNEL);
         if (!newrange) {
                 if (first_bus)
                         kfree (newbus);
                 err ("out of system memory\n");
                 return -ENOMEM;
         }
-        memset (newrange, 0, sizeof (struct range_node));
         newrange->start = curr->start_addr;
         newrange->end = curr->end_addr;
                 
@@ -329,7 +325,7 @@ int __init ibmphp_rsrc_init (void)
                                 if (!new_pfmem)
                                         return -ENOMEM;
                                 new_pfmem->type = PFMEM;
-                                new_pfmem->fromMem = FALSE;
+                                new_pfmem->fromMem = 0;
                                 if (ibmphp_add_resource (new_pfmem) < 0) {
                                         newbus = alloc_error_bus (curr, 0, 0);
                                         if (!newbus)
@@ -466,7 +462,7 @@ static int add_range (int type, struct range_node *range, struct bus_node *bus_c
 static void update_resources (struct bus_node *bus_cur, int type, int rangeno)
 {
         struct resource_node *res = NULL;
-        u8 eol = FALSE; /* end of list indicator */
+        u8 eol = 0;     /* end of list indicator */
 
         switch (type) {
                 case MEM:
@@ -492,7 +488,7 @@ static void update_resources (struct bus_node *bus_cur, int type, int rangeno)
                         else if (res->nextRange)
                                 res = res->nextRange;
                         else {
-                                eol = TRUE;
+                                eol = 1;
                                 break;
                         }
                 }
@@ -983,7 +979,7 @@ int ibmphp_check_resource (struct resource_node *res, u8 bridge)
         int noranges = 0;
         u32 tmp_start;          /* this is to make sure start address is divisible by the length needed */
         u32 tmp_divide;
-        u8 flag = FALSE;
+        u8 flag = 0;
 
         if (!res)
                 return -EINVAL;
@@ -1050,17 +1046,17 @@ int ibmphp_check_resource (struct resource_node *res, u8 bridge)
 
                                         if ((range->start % tmp_divide) == 0) {
                                                 /* just perfect, starting address is divisible by length */
-                                                flag = TRUE;
+                                                flag = 1;
                                                 len_cur = len_tmp;
                                                 start_cur = range->start;
                                         } else {
                                                 /* Needs adjusting */
                                                 tmp_start = range->start;
-                                                flag = FALSE;
+                                                flag = 0;
 
                                                 while ((len_tmp = res_cur->start - 1 - tmp_start) >= res->len) {
                                                         if ((tmp_start % tmp_divide) == 0) {
-                                                                flag = TRUE;
+                                                                flag = 1;
                                                                 len_cur = len_tmp;
                                                                 start_cur = tmp_start;
                                                                 break;
@@ -1089,17 +1085,17 @@ int ibmphp_check_resource (struct resource_node *res, u8 bridge)
 
                                         if (((res_cur->end + 1) % tmp_divide) == 0) {
                                                 /* just perfect, starting address is divisible by length */
-                                                flag = TRUE;
+                                                flag = 1;
                                                 len_cur = len_tmp;
                                                 start_cur = res_cur->end + 1;
                                         } else {
                                                 /* Needs adjusting */
                                                 tmp_start = res_cur->end + 1;
-                                                flag = FALSE;
+                                                flag = 0;
 
                                                 while ((len_tmp = range->end - tmp_start) >= res->len) {
                                                         if ((tmp_start % tmp_divide) == 0) {
-                                                                flag = TRUE;
+                                                                flag = 1;
                                                                 len_cur = len_tmp;
                                                                 start_cur = tmp_start;
                                                                 break;
@@ -1127,17 +1123,17 @@ int ibmphp_check_resource (struct resource_node *res, u8 bridge)
                                         if ((len_tmp < len_cur) || (len_cur == 0)) {
                                                 if ((range->start % tmp_divide) == 0) { 
                                                         /* just perfect, starting address is divisible by length */
-                                                        flag = TRUE;
+                                                        flag = 1;
                                                         len_cur = len_tmp;
                                                         start_cur = range->start;
                                                 } else {
                                                         /* Needs adjusting */
                                                         tmp_start = range->start;
-                                                        flag = FALSE;
+                                                        flag = 0;
 
                                                         while ((len_tmp = res_cur->start - 1 - tmp_start) >= res->len) {
                                                                 if ((tmp_start % tmp_divide) == 0) {
-                                                                        flag = TRUE;
+                                                                        flag = 1;
                                                                         len_cur = len_tmp;
                                                                         start_cur = tmp_start;
                                                                         break;
@@ -1162,17 +1158,17 @@ int ibmphp_check_resource (struct resource_node *res, u8 bridge)
                                         if ((len_tmp < len_cur) || (len_cur == 0)) {
                                                 if (((res_prev->end + 1) % tmp_divide) == 0) {
                                                         /* just perfect, starting address's divisible by length */
-                                                        flag = TRUE;
+                                                        flag = 1;
                                                         len_cur = len_tmp;
                                                         start_cur = res_prev->end + 1;
                                                 } else {
                                                         /* Needs adjusting */
                                                         tmp_start = res_prev->end + 1;
-                                                        flag = FALSE;
+                                                        flag = 0;
 
                                                         while ((len_tmp = res_cur->start - 1 - tmp_start) >= res->len) {
                                                                 if ((tmp_start % tmp_divide) == 0) {
-                                                                        flag = TRUE;
+                                                                        flag = 1;
                                                                         len_cur = len_tmp;
                                                                         start_cur = tmp_start;
                                                                         break;
@@ -1221,17 +1217,17 @@ int ibmphp_check_resource (struct resource_node *res, u8 bridge)
                                 if ((len_tmp < len_cur) || (len_cur == 0)) {
                                         if ((range->start % tmp_divide) == 0) {
                                                 /* just perfect, starting address's divisible by length */
-                                                flag = TRUE;
+                                                flag = 1;
                                                 len_cur = len_tmp;
                                                 start_cur = range->start;
                                         } else {
                                                 /* Needs adjusting */
                                                 tmp_start = range->start;
-                                                flag = FALSE;
+                                                flag = 0;
 
                                                 while ((len_tmp = range->end - tmp_start) >= res->len) {
                                                         if ((tmp_start % tmp_divide) == 0) {
-                                                                flag = TRUE;
+                                                                flag = 1;
                                                                 len_cur = len_tmp;
                                                                 start_cur = tmp_start;
                                                                 break;
@@ -1285,17 +1281,17 @@ int ibmphp_check_resource (struct resource_node *res, u8 bridge)
                                         if ((len_tmp < len_cur) || (len_cur == 0)) {
                                                 if ((range->start % tmp_divide) == 0) {
                                                         /* just perfect, starting address's divisible by length */
-                                                        flag = TRUE;
+                                                        flag = 1;
                                                         len_cur = len_tmp;
                                                         start_cur = range->start;
                                                 } else {
                                                         /* Needs adjusting */
                                                         tmp_start = range->start;
-                                                        flag = FALSE;
+                                                        flag = 0;
 
                                                         while ((len_tmp = range->end - tmp_start) >= res->len) {
                                                                 if ((tmp_start % tmp_divide) == 0) {
-                                                                        flag = TRUE;
+                                                                        flag = 1;
                                                                         len_cur = len_tmp;
                                                                         start_cur = tmp_start;
                                                                         break;
@@ -1688,7 +1684,7 @@ static int __init once_over (void)
                 bus_cur = list_entry (tmp, struct bus_node, bus_list);
                 if ((!bus_cur->rangePFMem) && (bus_cur->firstPFMem)) {
                         for (pfmem_cur = bus_cur->firstPFMem, pfmem_prev = NULL; pfmem_cur; pfmem_prev = pfmem_cur, pfmem_cur = pfmem_cur->next) {
-                                pfmem_cur->fromMem = TRUE;
+                                pfmem_cur->fromMem = 1;
                                 if (pfmem_prev)
                                         pfmem_prev->next = pfmem_cur->next;
                                 else
@@ -1705,12 +1701,11 @@ static int __init once_over (void)
 
                                 bus_cur->firstPFMemFromMem = pfmem_cur;
 
-                                mem = kmalloc (sizeof (struct resource_node), GFP_KERNEL);              
+                                mem = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
                                 if (!mem) {
                                         err ("out of system memory\n");
                                         return -ENOMEM;
                                 }
-                                memset (mem, 0, sizeof (struct resource_node));
                                 mem->type = MEM;
                                 mem->busno = pfmem_cur->busno;
                                 mem->devfunc = pfmem_cur->devfunc;
@@ -1994,12 +1989,11 @@ static int __init update_bridge_ranges (struct bus_node **bus)
                                                 end_address |= (upper_io_end << 16);
 
                                                 if ((start_address) && (start_address <= end_address)) {
-                                                        range = kmalloc (sizeof (struct range_node), GFP_KERNEL);
+                                                        range = kzalloc(sizeof(struct range_node), GFP_KERNEL);
                                                         if (!range) {
                                                                 err ("out of system memory\n");
                                                                 return -ENOMEM;
                                                         }
-                                                        memset (range, 0, sizeof (struct range_node));
                                                         range->start = start_address;
                                                         range->end = end_address + 0xfff;
 
@@ -2020,13 +2014,12 @@ static int __init update_bridge_ranges (struct bus_node **bus)
                                                         fix_resources (bus_sec);
 
                                                         if (ibmphp_find_resource (bus_cur, start_address, &io, IO)) {
-                                                                io = kmalloc (sizeof (struct resource_node), GFP_KERNEL);                                                       
+                                                                io = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
                                                                 if (!io) {
                                                                         kfree (range);
                                                                         err ("out of system memory\n");
                                                                         return -ENOMEM;
                                                                 }
-                                                                memset (io, 0, sizeof (struct resource_node));
                                                                 io->type = IO;
                                                                 io->busno = bus_cur->busno;
                                                                 io->devfunc = ((device << 3) | (function & 0x7));
@@ -2045,12 +2038,11 @@ static int __init update_bridge_ranges (struct bus_node **bus)
 
                                                 if ((start_address) && (start_address <= end_address)) {
 
-                                                        range = kmalloc (sizeof (struct range_node), GFP_KERNEL);
+                                                        range = kzalloc(sizeof(struct range_node), GFP_KERNEL);
                                                         if (!range) {
                                                                 err ("out of system memory\n");
                                                                 return -ENOMEM;
                                                         }
-                                                        memset (range, 0, sizeof (struct range_node));
                                                         range->start = start_address;
                                                         range->end = end_address + 0xfffff;
 
@@ -2072,13 +2064,12 @@ static int __init update_bridge_ranges (struct bus_node **bus)
                                                         fix_resources (bus_sec);
 
                                                         if (ibmphp_find_resource (bus_cur, start_address, &mem, MEM)) {
-                                                                mem = kmalloc (sizeof (struct resource_node), GFP_KERNEL);
+                                                                mem = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
                                                                 if (!mem) {
                                                                         kfree (range);
                                                                         err ("out of system memory\n");
                                                                         return -ENOMEM;
                                                                 }
-                                                                memset (mem, 0, sizeof (struct resource_node));
                                                                 mem->type = MEM;
                                                                 mem->busno = bus_cur->busno;
                                                                 mem->devfunc = ((device << 3) | (function & 0x7));
@@ -2101,12 +2092,11 @@ static int __init update_bridge_ranges (struct bus_node **bus)
 
                                                 if ((start_address) && (start_address <= end_address)) {
 
-                                                        range = kmalloc (sizeof (struct range_node), GFP_KERNEL);
+                                                        range = kzalloc(sizeof(struct range_node), GFP_KERNEL);
                                                         if (!range) {
                                                                 err ("out of system memory\n");
                                                                 return -ENOMEM;
                                                         }
-                                                        memset (range, 0, sizeof (struct range_node));
                                                         range->start = start_address;
                                                         range->end = end_address + 0xfffff;
 
@@ -2127,20 +2117,19 @@ static int __init update_bridge_ranges (struct bus_node **bus)
 
                                                         fix_resources (bus_sec);
                                                         if (ibmphp_find_resource (bus_cur, start_address, &pfmem, PFMEM)) {
-                                                                pfmem = kmalloc (sizeof (struct resource_node), GFP_KERNEL);
+                                                                pfmem = kzalloc(sizeof(struct resource_node), GFP_KERNEL);
                                                                 if (!pfmem) {
                                                                         kfree (range);
                                                                         err ("out of system memory\n");
                                                                         return -ENOMEM;
                                                                 }
-                                                                memset (pfmem, 0, sizeof (struct resource_node));
                                                                 pfmem->type = PFMEM;
                                                                 pfmem->busno = bus_cur->busno;
                                                                 pfmem->devfunc = ((device << 3) | (function & 0x7));
                                                                 pfmem->start = start_address;
                                                                 pfmem->end = end_address + 0xfffff;
                                                                 pfmem->len = pfmem->end - pfmem->start + 1;
-                                                                pfmem->fromMem = FALSE;
+                                                                pfmem->fromMem = 0;
 
                                                                 ibmphp_add_resource (pfmem);
                                                         }
diff --git a/drivers/pci/hotplug/pci_hotplug.h b/drivers/pci/hotplug/pci_hotplug.h
index 88d44f7fef..eb0d01d472 100644
--- a/drivers/pci/hotplug/pci_hotplug.h
+++ b/drivers/pci/hotplug/pci_hotplug.h
@@ -176,5 +176,21 @@ extern int pci_hp_change_slot_info	(struct hotplug_slot *slot,
                                          struct hotplug_slot_info *info);
 extern struct subsystem pci_hotplug_slots_subsys;
 
+struct hotplug_params {
+        u8 cache_line_size;
+        u8 latency_timer;
+        u8 enable_serr;
+        u8 enable_perr;
+};
+
+#ifdef CONFIG_ACPI
+#include <acpi/acpi.h>
+#include <acpi/acpi_bus.h>
+#include <acpi/actypes.h>
+extern acpi_status acpi_run_oshp(acpi_handle handle);
+extern acpi_status acpi_get_hp_params_from_firmware(struct pci_dev *dev,
+                                struct hotplug_params *hpp);
+int acpi_root_bridge(acpi_handle handle);
+#endif
 #endif
 
diff --git a/drivers/pci/hotplug/pciehp.h b/drivers/pci/hotplug/pciehp.h
index 0aac6a6133..92c1f0f1e1 100644
--- a/drivers/pci/hotplug/pciehp.h
+++ b/drivers/pci/hotplug/pciehp.h
@@ -34,6 +34,7 @@
 #include <linux/delay.h>
 #include <linux/sched.h>                /* signal_pending() */
 #include <linux/pcieport_if.h>
+#include <linux/mutex.h>
 #include "pci_hotplug.h"
 
 #define MY_NAME "pciehp"
@@ -49,12 +50,6 @@ extern int pciehp_force;
 #define info(format, arg...) printk(KERN_INFO "%s: " format, MY_NAME , ## arg)
 #define warn(format, arg...) printk(KERN_WARNING "%s: " format, MY_NAME , ## arg)
 
-struct hotplug_params {
-        u8 cache_line_size;
-        u8 latency_timer;
-        u8 enable_serr;
-        u8 enable_perr;
-};
 
 struct slot {
         struct slot *next;
@@ -96,7 +91,7 @@ struct php_ctlr_state_s {
 #define MAX_EVENTS              10
 struct controller {
         struct controller *next;
-        struct semaphore crit_sect;     /* critical section semaphore */
+        struct mutex crit_sect;         /* critical section mutex */
         struct php_ctlr_state_s *hpc_ctlr_handle; /* HPC controller handle */
         int num_slots;                  /* Number of slots on ctlr */
         int slot_num_inc;               /* 1 or -1 */
@@ -191,9 +186,6 @@ extern u8	pciehp_handle_power_fault	(u8 hp_slot, void *inst_id);
 /* pci functions */
 extern int      pciehp_configure_device         (struct slot *p_slot);
 extern int      pciehp_unconfigure_device       (struct slot *p_slot);
-extern int      pciehp_get_hp_hw_control_from_firmware(struct pci_dev *dev);
-extern void     pciehp_get_hp_params_from_firmware(struct pci_dev *dev,
-                struct hotplug_params *hpp);
 
 
 
@@ -285,4 +277,19 @@ struct hpc_ops {
         int     (*check_lnk_status)     (struct controller *ctrl);
 };
 
+
+#ifdef CONFIG_ACPI
+#define pciehp_get_hp_hw_control_from_firmware(dev) \
+        pciehp_acpi_get_hp_hw_control_from_firmware(dev)
+static inline int pciehp_get_hp_params_from_firmware(struct pci_dev *dev,
+                        struct hotplug_params *hpp)
+{
+        if (ACPI_FAILURE(acpi_get_hp_params_from_firmware(dev, hpp)))
+                return -ENODEV;
+        return 0;
+}
+#else
+#define pciehp_get_hp_hw_control_from_firmware(dev)     0
+#define pciehp_get_hp_params_from_firmware(dev, hpp)    (-ENODEV)
+#endif                          /* CONFIG_ACPI */
 #endif                          /* _PCIEHP_H */
diff --git a/drivers/pci/hotplug/pciehp_core.c b/drivers/pci/hotplug/pciehp_core.c
index 4fb569018a..601cf9045b 100644
--- a/drivers/pci/hotplug/pciehp_core.c
+++ b/drivers/pci/hotplug/pciehp_core.c
@@ -117,27 +117,23 @@ static int init_slots(struct controller *ctrl)
         slot_number = ctrl->first_slot;
 
         while (number_of_slots) {
-                slot = kmalloc(sizeof(*slot), GFP_KERNEL);
+                slot = kzalloc(sizeof(*slot), GFP_KERNEL);
                 if (!slot)
                         goto error;
 
-                memset(slot, 0, sizeof(struct slot));
                 slot->hotplug_slot =
-                                kmalloc(sizeof(*(slot->hotplug_slot)),
+                                kzalloc(sizeof(*(slot->hotplug_slot)),
                                                 GFP_KERNEL);
                 if (!slot->hotplug_slot)
                         goto error_slot;
                 hotplug_slot = slot->hotplug_slot;
-                memset(hotplug_slot, 0, sizeof(struct hotplug_slot));
 
                 hotplug_slot->info =
-                        kmalloc(sizeof(*(hotplug_slot->info)),
+                        kzalloc(sizeof(*(hotplug_slot->info)),
                                                 GFP_KERNEL);
                 if (!hotplug_slot->info)
                         goto error_hpslot;
                 hotplug_slot_info = hotplug_slot->info;
-                memset(hotplug_slot_info, 0,
-                                        sizeof(struct hotplug_slot_info));
                 hotplug_slot->name = kmalloc(SLOT_NAME_SIZE, GFP_KERNEL);
                 if (!hotplug_slot->name)
                         goto error_info;
@@ -373,12 +369,11 @@ static int pciehp_probe(struct pcie_device *dev, const struct pcie_port_service_
         u8 value;
         struct pci_dev *pdev;
         
-        ctrl = kmalloc(sizeof(*ctrl), GFP_KERNEL);
+        ctrl = kzalloc(sizeof(*ctrl), GFP_KERNEL);
         if (!ctrl) {
                 err("%s : out of memory\n", __FUNCTION__);
                 goto err_out_none;
         }
-        memset(ctrl, 0, sizeof(struct controller));
 
         pdev = dev->port;
         ctrl->pci_dev = pdev;
@@ -439,7 +434,7 @@ static int pciehp_probe(struct pcie_device *dev, const struct pcie_port_service_
         }
 
         /* Wait for exclusive access to hardware */
-        down(&ctrl->crit_sect);
+        mutex_lock(&ctrl->crit_sect);
 
         t_slot->hpc_ops->get_adapter_status(t_slot, &value); /* Check if slot is occupied */
         
@@ -447,7 +442,7 @@ static int pciehp_probe(struct pcie_device *dev, const struct pcie_port_service_
                 rc = t_slot->hpc_ops->power_off_slot(t_slot); /* Power off slot if not occupied*/
                 if (rc) {
                         /* Done with exclusive hardware access */
-                        up(&ctrl->crit_sect);
+                        mutex_unlock(&ctrl->crit_sect);
                         goto err_out_free_ctrl_slot;
                 } else
                         /* Wait for the command to complete */
@@ -455,7 +450,7 @@ static int pciehp_probe(struct pcie_device *dev, const struct pcie_port_service_
         }
 
         /* Done with exclusive hardware access */
-        up(&ctrl->crit_sect);
+        mutex_unlock(&ctrl->crit_sect);
 
         return 0;
 
diff --git a/drivers/pci/hotplug/pciehp_ctrl.c b/drivers/pci/hotplug/pciehp_ctrl.c
index 83c4b86571..33d1987683 100644
--- a/drivers/pci/hotplug/pciehp_ctrl.c
+++ b/drivers/pci/hotplug/pciehp_ctrl.c
@@ -229,13 +229,13 @@ u8 pciehp_handle_power_fault(u8 hp_slot, void *inst_id)
 static void set_slot_off(struct controller *ctrl, struct slot * pslot)
 {
         /* Wait for exclusive access to hardware */
-        down(&ctrl->crit_sect);
+        mutex_lock(&ctrl->crit_sect);
 
         /* turn off slot, turn on Amber LED, turn off Green LED if supported*/
         if (POWER_CTRL(ctrl->ctrlcap)) {
                 if (pslot->hpc_ops->power_off_slot(pslot)) {   
                         err("%s: Issue of Slot Power Off command failed\n", __FUNCTION__);
-                        up(&ctrl->crit_sect);
+                        mutex_unlock(&ctrl->crit_sect);
                         return;
                 }
                 wait_for_ctrl_irq (ctrl);
@@ -249,14 +249,14 @@ static void set_slot_off(struct controller *ctrl, struct slot * pslot)
         if (ATTN_LED(ctrl->ctrlcap)) { 
                 if (pslot->hpc_ops->set_attention_status(pslot, 1)) {   
                         err("%s: Issue of Set Attention Led command failed\n", __FUNCTION__);
-                        up(&ctrl->crit_sect);
+                        mutex_unlock(&ctrl->crit_sect);
                         return;
                 }
                 wait_for_ctrl_irq (ctrl);
         }
 
         /* Done with exclusive hardware access */
-        up(&ctrl->crit_sect);
+        mutex_unlock(&ctrl->crit_sect);
 }
 
 /**
@@ -279,13 +279,13 @@ static int board_added(struct slot *p_slot)
                         ctrl->slot_device_offset, hp_slot);
 
         /* Wait for exclusive access to hardware */
-        down(&ctrl->crit_sect);
+        mutex_lock(&ctrl->crit_sect);
 
         if (POWER_CTRL(ctrl->ctrlcap)) {
                 /* Power on slot */
                 rc = p_slot->hpc_ops->power_on_slot(p_slot);
                 if (rc) {
-                        up(&ctrl->crit_sect);
+                        mutex_unlock(&ctrl->crit_sect);
                         return -1;
                 }
 
@@ -301,7 +301,7 @@ static int board_added(struct slot *p_slot)
         }
 
         /* Done with exclusive hardware access */
-        up(&ctrl->crit_sect);
+        mutex_unlock(&ctrl->crit_sect);
 
         /* Wait for ~1 second */
         wait_for_ctrl_irq (ctrl);
@@ -335,7 +335,7 @@ static int board_added(struct slot *p_slot)
                 pci_fixup_device(pci_fixup_final, ctrl->pci_dev);
         if (PWR_LED(ctrl->ctrlcap)) {
                 /* Wait for exclusive access to hardware */
-                down(&ctrl->crit_sect);
+                mutex_lock(&ctrl->crit_sect);
 
                 p_slot->hpc_ops->green_led_on(p_slot);
   
@@ -343,7 +343,7 @@ static int board_added(struct slot *p_slot)
                 wait_for_ctrl_irq (ctrl);
         
                 /* Done with exclusive hardware access */
-                up(&ctrl->crit_sect);
+                mutex_unlock(&ctrl->crit_sect);
         }
         return 0;
 
@@ -375,14 +375,14 @@ static int remove_board(struct slot *p_slot)
         dbg("In %s, hp_slot = %d\n", __FUNCTION__, hp_slot);
 
         /* Wait for exclusive access to hardware */
-        down(&ctrl->crit_sect);
+        mutex_lock(&ctrl->crit_sect);
 
         if (POWER_CTRL(ctrl->ctrlcap)) {
                 /* power off slot */
                 rc = p_slot->hpc_ops->power_off_slot(p_slot);
                 if (rc) {
                         err("%s: Issue of Slot Disable command failed\n", __FUNCTION__);
-                        up(&ctrl->crit_sect);
+                        mutex_unlock(&ctrl->crit_sect);
                         return rc;
                 }
                 /* Wait for the command to complete */
@@ -398,7 +398,7 @@ static int remove_board(struct slot *p_slot)
         }
 
         /* Done with exclusive hardware access */
-        up(&ctrl->crit_sect);
+        mutex_unlock(&ctrl->crit_sect);
 
         return 0;
 }
@@ -445,7 +445,7 @@ static void pciehp_pushbutton_thread(unsigned long slot)
 
                 if (pciehp_enable_slot(p_slot) && PWR_LED(p_slot->ctrl->ctrlcap)) {
                         /* Wait for exclusive access to hardware */
-                        down(&p_slot->ctrl->crit_sect);
+                        mutex_lock(&p_slot->ctrl->crit_sect);
 
                         p_slot->hpc_ops->green_led_off(p_slot);
 
@@ -453,7 +453,7 @@ static void pciehp_pushbutton_thread(unsigned long slot)
                         wait_for_ctrl_irq (p_slot->ctrl);
 
                         /* Done with exclusive hardware access */
-                        up(&p_slot->ctrl->crit_sect);
+                        mutex_unlock(&p_slot->ctrl->crit_sect);
                 }
                 p_slot->state = STATIC_STATE;
         }
@@ -495,7 +495,7 @@ static void pciehp_surprise_rm_thread(unsigned long slot)
 
                 if (pciehp_enable_slot(p_slot) && PWR_LED(p_slot->ctrl->ctrlcap)) {
                         /* Wait for exclusive access to hardware */
-                        down(&p_slot->ctrl->crit_sect);
+                        mutex_lock(&p_slot->ctrl->crit_sect);
 
                         p_slot->hpc_ops->green_led_off(p_slot);
 
@@ -503,7 +503,7 @@ static void pciehp_surprise_rm_thread(unsigned long slot)
                         wait_for_ctrl_irq (p_slot->ctrl);
 
                         /* Done with exclusive hardware access */
-                        up(&p_slot->ctrl->crit_sect);
+                        mutex_unlock(&p_slot->ctrl->crit_sect);
                 }
                 p_slot->state = STATIC_STATE;
         }
@@ -616,7 +616,7 @@ static void interrupt_event_handler(struct controller *ctrl)
                                         switch (p_slot->state) {
                                         case BLINKINGOFF_STATE:
                                                 /* Wait for exclusive access to hardware */
-                                                down(&ctrl->crit_sect);
+                                                mutex_lock(&ctrl->crit_sect);
                                                 
                                                 if (PWR_LED(ctrl->ctrlcap)) {
                                                         p_slot->hpc_ops->green_led_on(p_slot);
@@ -630,11 +630,11 @@ static void interrupt_event_handler(struct controller *ctrl)
                                                         wait_for_ctrl_irq (ctrl);
                                                 }
                                                 /* Done with exclusive hardware access */
-                                                up(&ctrl->crit_sect);
+                                                mutex_unlock(&ctrl->crit_sect);
                                                 break;
                                         case BLINKINGON_STATE:
                                                 /* Wait for exclusive access to hardware */
-                                                down(&ctrl->crit_sect);
+                                                mutex_lock(&ctrl->crit_sect);
 
                                                 if (PWR_LED(ctrl->ctrlcap)) {
                                                         p_slot->hpc_ops->green_led_off(p_slot);
@@ -647,7 +647,7 @@ static void interrupt_event_handler(struct controller *ctrl)
                                                         wait_for_ctrl_irq (ctrl);
                                                 }
                                                 /* Done with exclusive hardware access */
-                                                up(&ctrl->crit_sect);
+                                                mutex_unlock(&ctrl->crit_sect);
 
                                                 break;
                                         default:
@@ -676,7 +676,7 @@ static void interrupt_event_handler(struct controller *ctrl)
                                                 }
 
                                                 /* Wait for exclusive access to hardware */
-                                                down(&ctrl->crit_sect);
+                                                mutex_lock(&ctrl->crit_sect);
 
                                                 /* blink green LED and turn off amber */
                                                 if (PWR_LED(ctrl->ctrlcap)) {
@@ -693,7 +693,7 @@ static void interrupt_event_handler(struct controller *ctrl)
                                                 }
 
                                                 /* Done with exclusive hardware access */
-                                                up(&ctrl->crit_sect);
+                                                mutex_unlock(&ctrl->crit_sect);
 
                                                 init_timer(&p_slot->task_event);
                                                 p_slot->task_event.expires = jiffies + 5 * HZ;   /* 5 second delay */
@@ -708,7 +708,7 @@ static void interrupt_event_handler(struct controller *ctrl)
                                         if (POWER_CTRL(ctrl->ctrlcap)) {
                                                 dbg("power fault\n");
                                                 /* Wait for exclusive access to hardware */
-                                                down(&ctrl->crit_sect);
+                                                mutex_lock(&ctrl->crit_sect);
 
                                                 if (ATTN_LED(ctrl->ctrlcap)) {
                                                         p_slot->hpc_ops->set_attention_status(p_slot, 1);
@@ -721,7 +721,7 @@ static void interrupt_event_handler(struct controller *ctrl)
                                                 }
 
                                                 /* Done with exclusive hardware access */
-                                                up(&ctrl->crit_sect);
+                                                mutex_unlock(&ctrl->crit_sect);
                                         }
                                 }
                                 /***********SURPRISE REMOVAL********************/
@@ -756,19 +756,19 @@ int pciehp_enable_slot(struct slot *p_slot)
         int rc;
 
         /* Check to see if (latch closed, card present, power off) */
-        down(&p_slot->ctrl->crit_sect);
+        mutex_lock(&p_slot->ctrl->crit_sect);
 
         rc = p_slot->hpc_ops->get_adapter_status(p_slot, &getstatus);
         if (rc || !getstatus) {
                 info("%s: no adapter on slot(%x)\n", __FUNCTION__, p_slot->number);
-                up(&p_slot->ctrl->crit_sect);
+                mutex_unlock(&p_slot->ctrl->crit_sect);
                 return 1;
         }
         if (MRL_SENS(p_slot->ctrl->ctrlcap)) {  
                 rc = p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
                 if (rc || getstatus) {
                         info("%s: latch open on slot(%x)\n", __FUNCTION__, p_slot->number);
-                        up(&p_slot->ctrl->crit_sect);
+                        mutex_unlock(&p_slot->ctrl->crit_sect);
                         return 1;
                 }
         }
@@ -777,11 +777,11 @@ int pciehp_enable_slot(struct slot *p_slot)
                 rc = p_slot->hpc_ops->get_power_status(p_slot, &getstatus);
                 if (rc || getstatus) {
                         info("%s: already enabled on slot(%x)\n", __FUNCTION__, p_slot->number);
-                        up(&p_slot->ctrl->crit_sect);
+                        mutex_unlock(&p_slot->ctrl->crit_sect);
                         return 1;
                 }
         }
-        up(&p_slot->ctrl->crit_sect);
+        mutex_unlock(&p_slot->ctrl->crit_sect);
 
         p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
 
@@ -806,13 +806,13 @@ int pciehp_disable_slot(struct slot *p_slot)
                 return 1;
 
         /* Check to see if (latch closed, card present, power on) */
-        down(&p_slot->ctrl->crit_sect);
+        mutex_lock(&p_slot->ctrl->crit_sect);
 
         if (!HP_SUPR_RM(p_slot->ctrl->ctrlcap)) {       
                 ret = p_slot->hpc_ops->get_adapter_status(p_slot, &getstatus);
                 if (ret || !getstatus) {
                         info("%s: no adapter on slot(%x)\n", __FUNCTION__, p_slot->number);
-                        up(&p_slot->ctrl->crit_sect);
+                        mutex_unlock(&p_slot->ctrl->crit_sect);
                         return 1;
                 }
         }
@@ -821,7 +821,7 @@ int pciehp_disable_slot(struct slot *p_slot)
                 ret = p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
                 if (ret || getstatus) {
                         info("%s: latch open on slot(%x)\n", __FUNCTION__, p_slot->number);
-                        up(&p_slot->ctrl->crit_sect);
+                        mutex_unlock(&p_slot->ctrl->crit_sect);
                         return 1;
                 }
         }
@@ -830,12 +830,12 @@ int pciehp_disable_slot(struct slot *p_slot)
                 ret = p_slot->hpc_ops->get_power_status(p_slot, &getstatus);
                 if (ret || !getstatus) {
                         info("%s: already disabled slot(%x)\n", __FUNCTION__, p_slot->number);
-                        up(&p_slot->ctrl->crit_sect);
+                        mutex_unlock(&p_slot->ctrl->crit_sect);
                         return 1;
                 }
         }
 
-        up(&p_slot->ctrl->crit_sect);
+        mutex_unlock(&p_slot->ctrl->crit_sect);
 
         ret = remove_board(p_slot);
         update_slot_info(p_slot);
diff --git a/drivers/pci/hotplug/pciehp_hpc.c b/drivers/pci/hotplug/pciehp_hpc.c
index 77e530321d..6c14d9e46b 100644
--- a/drivers/pci/hotplug/pciehp_hpc.c
+++ b/drivers/pci/hotplug/pciehp_hpc.c
@@ -38,7 +38,10 @@
 
 #include "../pci.h"
 #include "pciehp.h"
-
+#include <acpi/acpi.h>
+#include <acpi/acpi_bus.h>
+#include <acpi/actypes.h>
+#include <linux/pci-acpi.h>
 #ifdef DEBUG
 #define DBG_K_TRACE_ENTRY      ((unsigned int)0x00000001)       /* On function entry */
 #define DBG_K_TRACE_EXIT       ((unsigned int)0x00000002)       /* On function exit */
@@ -1236,6 +1239,76 @@ static struct hpc_ops pciehp_hpc_ops = {
         .check_lnk_status               = hpc_check_lnk_status,
 };
 
+#ifdef CONFIG_ACPI
+int pciehp_acpi_get_hp_hw_control_from_firmware(struct pci_dev *dev)
+{
+        acpi_status status;
+        acpi_handle chandle, handle = DEVICE_ACPI_HANDLE(&(dev->dev));
+        struct pci_dev *pdev = dev;
+        struct pci_bus *parent;
+        struct acpi_buffer string = { ACPI_ALLOCATE_BUFFER, NULL };
+
+        /*
+         * Per PCI firmware specification, we should run the ACPI _OSC
+         * method to get control of hotplug hardware before using it.
+         * If an _OSC is missing, we look for an OSHP to do the same thing.
+         * To handle different BIOS behavior, we look for _OSC and OSHP
+         * within the scope of the hotplug controller and its parents, upto
+         * the host bridge under which this controller exists.
+         */
+        while (!handle) {
+                /*
+                 * This hotplug controller was not listed in the ACPI name
+                 * space at all. Try to get acpi handle of parent pci bus.
+                 */
+                if (!pdev || !pdev->bus->parent)
+                        break;
+                parent = pdev->bus->parent;
+                dbg("Could not find %s in acpi namespace, trying parent\n",
+                                pci_name(pdev));
+                if (!parent->self)
+                        /* Parent must be a host bridge */
+                        handle = acpi_get_pci_rootbridge_handle(
+                                        pci_domain_nr(parent),
+                                        parent->number);
+                else
+                        handle = DEVICE_ACPI_HANDLE(
+                                        &(parent->self->dev));
+                pdev = parent->self;
+        }
+
+        while (handle) {
+                acpi_get_name(handle, ACPI_FULL_PATHNAME, &string);
+                dbg("Trying to get hotplug control for %s \n",
+                        (char *)string.pointer);
+                status = pci_osc_control_set(handle,
+                                OSC_PCI_EXPRESS_NATIVE_HP_CONTROL);
+                if (status == AE_NOT_FOUND)
+                        status = acpi_run_oshp(handle);
+                if (ACPI_SUCCESS(status)) {
+                        dbg("Gained control for hotplug HW for pci %s (%s)\n",
+                                pci_name(dev), (char *)string.pointer);
+                        acpi_os_free(string.pointer);
+                        return 0;
+                }
+                if (acpi_root_bridge(handle))
+                        break;
+                chandle = handle;
+                status = acpi_get_parent(chandle, &handle);
+                if (ACPI_FAILURE(status))
+                        break;
+        }
+
+        err("Cannot get control of hotplug hardware for pci %s\n",
+                        pci_name(dev));
+
+        acpi_os_free(string.pointer);
+        return -1;
+}
+#endif
+
+
+
 int pcie_init(struct controller * ctrl, struct pcie_device *dev)
 {
         struct php_ctlr_state_s *php_ctlr, *p;
@@ -1334,7 +1407,7 @@ int pcie_init(struct controller * ctrl, struct pcie_device *dev)
         if (pci_enable_device(pdev))
                 goto abort_free_ctlr;
         
-        init_MUTEX(&ctrl->crit_sect);
+        mutex_init(&ctrl->crit_sect);
         /* setup wait queue */
         init_waitqueue_head(&ctrl->queue);
 
diff --git a/drivers/pci/hotplug/pciehprm_acpi.c b/drivers/pci/hotplug/pciehprm_acpi.c
deleted file mode 100644
index 2bdb30f68b..0000000000
--- a/drivers/pci/hotplug/pciehprm_acpi.c
+++ /dev/null
@@ -1,257 +0,0 @@
-/*
- * PCIEHPRM ACPI: PHP Resource Manager for ACPI platform
- *
- * Copyright (C) 2003-2004 Intel Corporation
- *
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
- * NON INFRINGEMENT.  See the GNU General Public License for more
- * details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * Send feedback to <kristen.c.accardi@intel.com>
- *
- */
-
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/types.h>
-#include <linux/pci.h>
-#include <linux/acpi.h>
-#include <linux/pci-acpi.h>
-#include <acpi/acpi_bus.h>
-#include <acpi/actypes.h>
-#include "pciehp.h"
-
-#define METHOD_NAME__SUN        "_SUN"
-#define METHOD_NAME__HPP        "_HPP"
-#define METHOD_NAME_OSHP        "OSHP"
-
-static u8 * acpi_path_name( acpi_handle handle)
-{
-        acpi_status             status;
-        static u8               path_name[ACPI_PATHNAME_MAX];
-        struct acpi_buffer      ret_buf = { ACPI_PATHNAME_MAX, path_name };
-
-        memset(path_name, 0, sizeof (path_name));
-        status = acpi_get_name(handle, ACPI_FULL_PATHNAME, &ret_buf);
-
-        if (ACPI_FAILURE(status))
-                return NULL;
-        else
-                return path_name;       
-}
-
-static acpi_status
-acpi_run_hpp(acpi_handle handle, struct hotplug_params *hpp)
-{
-        acpi_status             status;
-        u8                      nui[4];
-        struct acpi_buffer      ret_buf = { 0, NULL};
-        union acpi_object       *ext_obj, *package;
-        u8                      *path_name = acpi_path_name(handle);
-        int                     i, len = 0;
-
-        /* get _hpp */
-        status = acpi_evaluate_object(handle, METHOD_NAME__HPP, NULL, &ret_buf);
-        switch (status) {
-        case AE_BUFFER_OVERFLOW:
-                ret_buf.pointer = kmalloc (ret_buf.length, GFP_KERNEL);
-                if (!ret_buf.pointer) {
-                        err ("%s:%s alloc for _HPP fail\n", __FUNCTION__,
-                                        path_name);
-                        return AE_NO_MEMORY;
-                }
-                status = acpi_evaluate_object(handle, METHOD_NAME__HPP,
-                                NULL, &ret_buf);
-                if (ACPI_SUCCESS(status))
-                        break;
-        default:
-                if (ACPI_FAILURE(status)) {
-                        dbg("%s:%s _HPP fail=0x%x\n", __FUNCTION__,
-                                        path_name, status);
-                        return status;
-                }
-        }
-
-        ext_obj = (union acpi_object *) ret_buf.pointer;
-        if (ext_obj->type != ACPI_TYPE_PACKAGE) {
-                err ("%s:%s _HPP obj not a package\n", __FUNCTION__,
-                                path_name);
-                status = AE_ERROR;
-                goto free_and_return;
-        }
-
-        len = ext_obj->package.count;
-        package = (union acpi_object *) ret_buf.pointer;
-        for ( i = 0; (i < len) || (i < 4); i++) {
-                ext_obj = (union acpi_object *) &package->package.elements[i];
-                switch (ext_obj->type) {
-                case ACPI_TYPE_INTEGER:
-                        nui[i] = (u8)ext_obj->integer.value;
-                        break;
-                default:
-                        err ("%s:%s _HPP obj type incorrect\n", __FUNCTION__,
-                                        path_name);
-                        status = AE_ERROR;
-                        goto free_and_return;
-                }
-        }
-
-        hpp->cache_line_size = nui[0];
-        hpp->latency_timer = nui[1];
-        hpp->enable_serr = nui[2];
-        hpp->enable_perr = nui[3];
-
-        dbg("  _HPP: cache_line_size=0x%x\n", hpp->cache_line_size);
-        dbg("  _HPP: latency timer  =0x%x\n", hpp->latency_timer);
-        dbg("  _HPP: enable SERR    =0x%x\n", hpp->enable_serr);
-        dbg("  _HPP: enable PERR    =0x%x\n", hpp->enable_perr);
-
-free_and_return:
-        kfree(ret_buf.pointer);
-        return status;
-}
-
-static acpi_status acpi_run_oshp(acpi_handle handle)
-{
-        acpi_status             status;
-        u8                      *path_name = acpi_path_name(handle);
-
-        /* run OSHP */
-        status = acpi_evaluate_object(handle, METHOD_NAME_OSHP, NULL, NULL);
-        if (ACPI_FAILURE(status)) {
-                dbg("%s:%s OSHP fails=0x%x\n", __FUNCTION__, path_name,
-                                status);
-        } else {
-                dbg("%s:%s OSHP passes\n", __FUNCTION__, path_name);
-        }
-        return status;
-}
-
-static int is_root_bridge(acpi_handle handle)
-{
-        acpi_status status;
-        struct acpi_device_info *info;
-        struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
-        int i;
-
-        status = acpi_get_object_info(handle, &buffer);
-        if (ACPI_SUCCESS(status)) {
-                info = buffer.pointer;
-                if ((info->valid & ACPI_VALID_HID) &&
-                        !strcmp(PCI_ROOT_HID_STRING,
-                                        info->hardware_id.value)) {
-                        acpi_os_free(buffer.pointer);
-                        return 1;
-                }
-                if (info->valid & ACPI_VALID_CID) {
-                        for (i=0; i < info->compatibility_id.count; i++) {
-                                if (!strcmp(PCI_ROOT_HID_STRING,
-                                        info->compatibility_id.id[i].value)) {
-                                        acpi_os_free(buffer.pointer);
-                                        return 1;
-                                }
-                        }
-                }
-        }
-        return 0;
-}
-
-int pciehp_get_hp_hw_control_from_firmware(struct pci_dev *dev)
-{
-        acpi_status status;
-        acpi_handle chandle, handle = DEVICE_ACPI_HANDLE(&(dev->dev));
-        struct pci_dev *pdev = dev;
-        struct pci_bus *parent;
-        u8 *path_name;
-
-        /*
-         * Per PCI firmware specification, we should run the ACPI _OSC
-         * method to get control of hotplug hardware before using it.
-         * If an _OSC is missing, we look for an OSHP to do the same thing.
-         * To handle different BIOS behavior, we look for _OSC and OSHP
-         * within the scope of the hotplug controller and its parents, upto
-         * the host bridge under which this controller exists.
-         */
-        while (!handle) {
-                /*
-                 * This hotplug controller was not listed in the ACPI name
-                 * space at all. Try to get acpi handle of parent pci bus.
-                 */
-                if (!pdev || !pdev->bus->parent)
-                        break;
-                parent = pdev->bus->parent;
-                dbg("Could not find %s in acpi namespace, trying parent\n",
-                                pci_name(pdev));
-                if (!parent->self)
-                        /* Parent must be a host bridge */
-                        handle = acpi_get_pci_rootbridge_handle(
-                                        pci_domain_nr(parent),
-                                        parent->number);
-                else
-                        handle = DEVICE_ACPI_HANDLE(
-                                        &(parent->self->dev));
-                pdev = parent->self;
-        }
-
-        while (handle) {
-                path_name = acpi_path_name(handle);
-                dbg("Trying to get hotplug control for %s \n", path_name);
-                status = pci_osc_control_set(handle,
-                                OSC_PCI_EXPRESS_NATIVE_HP_CONTROL);
-                if (status == AE_NOT_FOUND)
-                        status = acpi_run_oshp(handle);
-                if (ACPI_SUCCESS(status)) {
-                        dbg("Gained control for hotplug HW for pci %s (%s)\n",
-                                pci_name(dev), path_name);
-                        return 0;
-                }
-                if (is_root_bridge(handle))
-                        break;
-                chandle = handle;
-                status = acpi_get_parent(chandle, &handle);
-                if (ACPI_FAILURE(status))
-                        break;
-        }
-
-        err("Cannot get control of hotplug hardware for pci %s\n",
-                        pci_name(dev));
-        return -1;
-}
-
-void pciehp_get_hp_params_from_firmware(struct pci_dev *dev,
-                struct hotplug_params *hpp)
-{
-        acpi_status status = AE_NOT_FOUND;
-        struct pci_dev *pdev = dev;
-
-        /*
-         * _HPP settings apply to all child buses, until another _HPP is
-         * encountered. If we don't find an _HPP for the input pci dev,
-         * look for it in the parent device scope since that would apply to
-         * this pci dev. If we don't find any _HPP, use hardcoded defaults
-         */
-        while (pdev && (ACPI_FAILURE(status))) {
-                acpi_handle handle = DEVICE_ACPI_HANDLE(&(pdev->dev));
-                if (!handle)
-                        break;
-                status = acpi_run_hpp(handle, hpp);
-                if (!(pdev->bus->parent))
-                        break;
-                /* Check if a parent object supports _HPP */
-                pdev = pdev->bus->parent->self;
-        }
-}
-
diff --git a/drivers/pci/hotplug/pciehprm_nonacpi.c b/drivers/pci/hotplug/pciehprm_nonacpi.c
deleted file mode 100644
index 29180dfe84..0000000000
--- a/drivers/pci/hotplug/pciehprm_nonacpi.c
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * PCIEHPRM NONACPI: PHP Resource Manager for Non-ACPI/Legacy platform
- *
- * Copyright (C) 1995,2001 Compaq Computer Corporation
- * Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com)
- * Copyright (C) 2001 IBM Corp.
- * Copyright (C) 2003-2004 Intel Corporation
- *
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
- * NON INFRINGEMENT.  See the GNU General Public License for more
- * details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * Send feedback to <greg@kroah.com>, <kristen.c.accardi@intel.com>
- *
- */
-
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/types.h>
-#include <linux/sched.h>
-#include <linux/pci.h>
-#include <linux/slab.h>
-#include "pciehp.h"
-
-void pciehp_get_hp_params_from_firmware(struct pci_dev *dev,
-                struct hotplug_params *hpp)
-{
-        return;
-}
-
-int pciehp_get_hp_hw_control_from_firmware(struct pci_dev *dev)
-{
-        return 0;
-}
diff --git a/drivers/pci/hotplug/pcihp_skeleton.c b/drivers/pci/hotplug/pcihp_skeleton.c
index 3194d51c6e..0a46f54967 100644
--- a/drivers/pci/hotplug/pcihp_skeleton.c
+++ b/drivers/pci/hotplug/pcihp_skeleton.c
@@ -37,10 +37,12 @@
 #include <linux/init.h>
 #include "pci_hotplug.h"
 
+#define SLOT_NAME_SIZE  10
 struct slot {
         u8 number;
         struct hotplug_slot *hotplug_slot;
         struct list_head slot_list;
+        char name[SLOT_NAME_SIZE];
 };
 
 static LIST_HEAD(slot_list);
@@ -233,12 +235,10 @@ static void release_slot(struct hotplug_slot *hotplug_slot)
 
         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
         kfree(slot->hotplug_slot->info);
-        kfree(slot->hotplug_slot->name);
         kfree(slot->hotplug_slot);
         kfree(slot);
 }
 
-#define SLOT_NAME_SIZE  10
 static void make_slot_name(struct slot *slot)
 {
         /*
@@ -257,7 +257,6 @@ static int __init init_slots(void)
         struct slot *slot;
         struct hotplug_slot *hotplug_slot;
         struct hotplug_slot_info *info;
-        char *name;
         int retval = -ENOMEM;
         int i;
 
@@ -266,31 +265,23 @@ static int __init init_slots(void)
          * with the pci_hotplug subsystem.
          */
         for (i = 0; i < num_slots; ++i) {
-                slot = kmalloc(sizeof(struct slot), GFP_KERNEL);
+                slot = kzalloc(sizeof(*slot), GFP_KERNEL);
                 if (!slot)
                         goto error;
-                memset(slot, 0, sizeof(struct slot));
 
-                hotplug_slot = kmalloc(sizeof(struct hotplug_slot),
-                                        GFP_KERNEL);
+                hotplug_slot = kzalloc(sizeof(*hotplug_slot), GFP_KERNEL);
                 if (!hotplug_slot)
                         goto error_slot;
-                memset(hotplug_slot, 0, sizeof (struct hotplug_slot));
                 slot->hotplug_slot = hotplug_slot;
 
-                info = kmalloc(sizeof(struct hotplug_slot_info), GFP_KERNEL);
+                info = kzalloc(sizeof(*info), GFP_KERNEL);
                 if (!info)
                         goto error_hpslot;
-                memset(info, 0, sizeof (struct hotplug_slot_info));
                 hotplug_slot->info = info;
 
-                name = kmalloc(SLOT_NAME_SIZE, GFP_KERNEL);
-                if (!name)
-                        goto error_info;
-                hotplug_slot->name = name;
-
                 slot->number = i;
 
+                hotplug_slot->name = slot->name;
                 hotplug_slot->private = slot;
                 hotplug_slot->release = &release_slot;
                 make_slot_name(slot);
@@ -300,16 +291,16 @@ static int __init init_slots(void)
                  * Initialize the slot info structure with some known
                  * good values.
                  */
-                info->power_status = get_power_status(slot);
-                info->attention_status = get_attention_status(slot);
-                info->latch_status = get_latch_status(slot);
-                info->adapter_status = get_adapter_status(slot);
+                get_power_status(hotplug_slot, &info->power_status);
+                get_attention_status(hotplug_slot, &info->attention_status);
+                get_latch_status(hotplug_slot, &info->latch_status);
+                get_adapter_status(hotplug_slot, &info->adapter_status);
                 
                 dbg("registering slot %d\n", i);
                 retval = pci_hp_register(slot->hotplug_slot);
                 if (retval) {
                         err("pci_hp_register failed with error %d\n", retval);
-                        goto error_name;
+                        goto error_info;
                 }
 
                 /* add slot to our internal list */
@@ -317,8 +308,6 @@ static int __init init_slots(void)
         }
 
         return 0;
-error_name:
-        kfree(name);
 error_info:
         kfree(info);
 error_hpslot:
diff --git a/drivers/pci/hotplug/rpaphp_slot.c b/drivers/pci/hotplug/rpaphp_slot.c
index 78943e064b..b771196a65 100644
--- a/drivers/pci/hotplug/rpaphp_slot.c
+++ b/drivers/pci/hotplug/rpaphp_slot.c
@@ -84,19 +84,16 @@ struct slot *alloc_slot_struct(struct device_node *dn, int drc_index, char *drc_
 {
         struct slot *slot;
         
-        slot = kmalloc(sizeof (struct slot), GFP_KERNEL);
+        slot = kzalloc(sizeof(struct slot), GFP_KERNEL);
         if (!slot)
                 goto error_nomem;
-        memset(slot, 0, sizeof (struct slot));
-        slot->hotplug_slot = kmalloc(sizeof (struct hotplug_slot), GFP_KERNEL);
+        slot->hotplug_slot = kzalloc(sizeof(struct hotplug_slot), GFP_KERNEL);
         if (!slot->hotplug_slot)
                 goto error_slot;        
-        memset(slot->hotplug_slot, 0, sizeof (struct hotplug_slot));
-        slot->hotplug_slot->info = kmalloc(sizeof (struct hotplug_slot_info),
+        slot->hotplug_slot->info = kzalloc(sizeof(struct hotplug_slot_info),
                                            GFP_KERNEL);
         if (!slot->hotplug_slot->info)
                 goto error_hpslot;
-        memset(slot->hotplug_slot->info, 0, sizeof (struct hotplug_slot_info));
         slot->hotplug_slot->name = kmalloc(BUS_ID_SIZE + 1, GFP_KERNEL);
         if (!slot->hotplug_slot->name)
                 goto error_info;        
diff --git a/drivers/pci/hotplug/sgi_hotplug.c b/drivers/pci/hotplug/sgi_hotplug.c
index a32ae82e59..c402da8e78 100644
--- a/drivers/pci/hotplug/sgi_hotplug.c
+++ b/drivers/pci/hotplug/sgi_hotplug.c
@@ -3,7 +3,7 @@
  * License.  See the file "COPYING" in the main directory of this archive
  * for more details.
  *
- * Copyright (C) 2005 Silicon Graphics, Inc. All rights reserved.
+ * Copyright (C) 2005-2006 Silicon Graphics, Inc. All rights reserved.
  *
  * This work was based on the 2.4/2.6 kernel development by Dick Reigner.
  * Work to add BIOS PROM support was completed by Mike Habeck.
@@ -230,6 +230,13 @@ static void sn_bus_free_data(struct pci_dev *dev)
                 list_for_each_entry(child, &subordinate_bus->devices, bus_list)
                         sn_bus_free_data(child);
         }
+        /*
+         * Some drivers may use dma accesses during the
+         * driver remove function. We release the sysdata
+         * areas after the driver remove functions have
+         * been called.
+         */
+        sn_bus_store_sysdata(dev);
         sn_pci_unfixup_slot(dev);
 }
 
@@ -429,13 +436,6 @@ static int disable_slot(struct hotplug_slot *bss_hotplug_slot)
                                    PCI_DEVFN(slot->device_num + 1,
                                              PCI_FUNC(func)));
                 if (dev) {
-                        /*
-                         * Some drivers may use dma accesses during the
-                         * driver remove function. We release the sysdata
-                         * areas after the driver remove functions have
-                         * been called.
-                         */
-                        sn_bus_store_sysdata(dev);
                         sn_bus_free_data(dev);
                         pci_remove_bus_device(dev);
                         pci_dev_put(dev);
diff --git a/drivers/pci/hotplug/shpchp.h b/drivers/pci/hotplug/shpchp.h
index 7d6f521d02..5c70f43908 100644
--- a/drivers/pci/hotplug/shpchp.h
+++ b/drivers/pci/hotplug/shpchp.h
@@ -33,6 +33,7 @@
 #include <linux/pci.h>
 #include <linux/delay.h>
 #include <linux/sched.h>        /* signal_pending(), struct timer_list */
+#include <linux/mutex.h>
 
 #include "pci_hotplug.h"
 
@@ -45,6 +46,7 @@
 extern int shpchp_poll_mode;
 extern int shpchp_poll_time;
 extern int shpchp_debug;
+extern struct workqueue_struct *shpchp_wq;
 
 /*#define dbg(format, arg...) do { if (shpchp_debug) printk(KERN_DEBUG "%s: " format, MY_NAME , ## arg); } while (0)*/
 #define dbg(format, arg...) do { if (shpchp_debug) printk("%s: " format, MY_NAME , ## arg); } while (0)
@@ -52,10 +54,8 @@ extern int shpchp_debug;
 #define info(format, arg...) printk(KERN_INFO "%s: " format, MY_NAME , ## arg)
 #define warn(format, arg...) printk(KERN_WARNING "%s: " format, MY_NAME , ## arg)
 
-#define SLOT_MAGIC      0x67267321
+#define SLOT_NAME_SIZE 10
 struct slot {
-        u32 magic;
-        struct slot *next;
         u8 bus;
         u8 device;
         u16 status;
@@ -70,26 +70,27 @@ struct slot {
         struct hpc_ops *hpc_ops;
         struct hotplug_slot *hotplug_slot;
         struct list_head        slot_list;
+        char name[SLOT_NAME_SIZE];
+        struct work_struct work;        /* work for button event */
+        struct mutex lock;
 };
 
 struct event_info {
         u32 event_type;
-        u8 hp_slot;
+        struct slot *p_slot;
+        struct work_struct work;
 };
 
 struct controller {
-        struct controller *next;
-        struct semaphore crit_sect;     /* critical section semaphore */
+        struct mutex crit_sect;         /* critical section mutex */
+        struct mutex cmd_lock;          /* command lock */
         struct php_ctlr_state_s *hpc_ctlr_handle; /* HPC controller handle */
         int num_slots;                  /* Number of slots on ctlr */
         int slot_num_inc;               /* 1 or -1 */
         struct pci_dev *pci_dev;
-        struct pci_bus *pci_bus;
-        struct event_info event_queue[10];
-        struct slot *slot;
+        struct list_head slot_list;
         struct hpc_ops *hpc_ops;
         wait_queue_head_t queue;        /* sleep & wake process */
-        u8 next_event;
         u8 bus;
         u8 device;
         u8 function;
@@ -105,12 +106,6 @@ struct controller {
         volatile int cmd_busy;
 };
 
-struct hotplug_params {
-        u8      cache_line_size;
-        u8      latency_timer;
-        u8      enable_serr;
-        u8      enable_perr;
-};
 
 /* Define AMD SHPC ID  */
 #define PCI_DEVICE_ID_AMD_GOLAM_7450    0x7450 
@@ -180,11 +175,8 @@ struct hotplug_params {
 /* sysfs functions for the hotplug controller info */
 extern void shpchp_create_ctrl_files    (struct controller *ctrl);
 
-/* controller functions */
-extern int      shpchp_event_start_thread(void);
-extern void     shpchp_event_stop_thread(void);
-extern int      shpchp_enable_slot(struct slot *slot);
-extern int      shpchp_disable_slot(struct slot *slot);
+extern int      shpchp_sysfs_enable_slot(struct slot *slot);
+extern int      shpchp_sysfs_disable_slot(struct slot *slot);
 
 extern u8       shpchp_handle_attention_button(u8 hp_slot, void *inst_id);
 extern u8       shpchp_handle_switch_change(u8 hp_slot, void *inst_id);
@@ -195,16 +187,28 @@ extern u8	shpchp_handle_power_fault(u8 hp_slot, void *inst_id);
 extern int      shpchp_save_config(struct controller *ctrl, int busnumber, int num_ctlr_slots, int first_device_num);
 extern int      shpchp_configure_device(struct slot *p_slot);
 extern int      shpchp_unconfigure_device(struct slot *p_slot);
-extern void     get_hp_hw_control_from_firmware(struct pci_dev *dev);
-extern void     get_hp_params_from_firmware(struct pci_dev *dev,
-                struct hotplug_params *hpp);
-extern int      shpchprm_get_physical_slot_number(struct controller *ctrl,
-                u32 *sun, u8 busnum, u8 devnum);
 extern void     shpchp_remove_ctrl_files(struct controller *ctrl);
+extern void     cleanup_slots(struct controller *ctrl);
+extern void     queue_pushbutton_work(void *data);
 
 
-/* Global variables */
-extern struct controller *shpchp_ctrl_list;
+#ifdef CONFIG_ACPI
+static inline int get_hp_params_from_firmware(struct pci_dev *dev,
+                        struct hotplug_params *hpp)
+{
+        if (ACPI_FAILURE(acpi_get_hp_params_from_firmware(dev, hpp)))
+                        return -ENODEV;
+        return 0;
+}
+#define get_hp_hw_control_from_firmware(pdev) \
+        do { \
+                if (DEVICE_ACPI_HANDLE(&(pdev->dev))) \
+                        acpi_run_oshp(DEVICE_ACPI_HANDLE(&(pdev->dev))); \
+        } while (0)
+#else
+#define get_hp_params_from_firmware(dev, hpp) (-ENODEV)
+#define get_hp_hw_control_from_firmware(dev) do { } while (0)
+#endif
 
 struct ctrl_reg {
         volatile u32 base_offset;
@@ -286,10 +290,6 @@ static inline int slot_paranoia_check (struct slot *slot, const char *function)
                 dbg("%s - slot == NULL", function);
                 return -1;
         }
-        if (slot->magic != SLOT_MAGIC) {
-                dbg("%s - bad magic number for slot", function);
-                return -1;
-        }
         if (!slot->hotplug_slot) {
                 dbg("%s - slot->hotplug_slot == NULL!", function);
                 return -1;
@@ -314,44 +314,19 @@ static inline struct slot *get_slot (struct hotplug_slot *hotplug_slot, const ch
 
 static inline struct slot *shpchp_find_slot (struct controller *ctrl, u8 device)
 {
-        struct slot *p_slot, *tmp_slot = NULL;
+        struct slot *slot;
 
         if (!ctrl)
                 return NULL;
 
-        p_slot = ctrl->slot;
-
-        while (p_slot && (p_slot->device != device)) {
-                tmp_slot = p_slot;
-                p_slot = p_slot->next;
+        list_for_each_entry(slot, &ctrl->slot_list, slot_list) {
+                if (slot->device == device)
+                        return slot;
         }
-        if (p_slot == NULL) {
-                err("ERROR: shpchp_find_slot device=0x%x\n", device);
-                p_slot = tmp_slot;
-        }
-
-        return (p_slot);
-}
-
-static inline int wait_for_ctrl_irq (struct controller *ctrl)
-{
-    DECLARE_WAITQUEUE(wait, current);
-        int retval = 0;
-
-        add_wait_queue(&ctrl->queue, &wait);
 
-        if (!shpchp_poll_mode) {
-                /* Sleep for up to 1 second */
-                msleep_interruptible(1000);
-        } else {
-                /* Sleep for up to 2 seconds */
-                msleep_interruptible(2000);
-        }
-        remove_wait_queue(&ctrl->queue, &wait);
-        if (signal_pending(current))
-                retval =  -EINTR;
+        err("%s: slot (device=0x%x) not found\n", __FUNCTION__, device);
 
-        return retval;
+        return NULL;
 }
 
 static inline void amd_pogo_errata_save_misc_reg(struct slot *p_slot)
@@ -427,13 +402,6 @@ static inline void amd_pogo_errata_restore_misc_reg(struct slot *p_slot)
         pci_write_config_dword(p_slot->ctrl->pci_dev, PCIX_MISCII_OFFSET, pcix_misc2_temp);
 }
 
-#define SLOT_NAME_SIZE 10
-
-static inline void make_slot_name(char *buffer, int buffer_size, struct slot *slot)
-{
-        snprintf(buffer, buffer_size, "%04d_%04d", slot->bus, slot->number);
-}
-
 enum php_ctlr_type {
         PCI,
         ISA,
diff --git a/drivers/pci/hotplug/shpchp_core.c b/drivers/pci/hotplug/shpchp_core.c
index a2b3f0010c..3be4d492cc 100644
--- a/drivers/pci/hotplug/shpchp_core.c
+++ b/drivers/pci/hotplug/shpchp_core.c
@@ -32,13 +32,14 @@
 #include <linux/kernel.h>
 #include <linux/types.h>
 #include <linux/pci.h>
+#include <linux/workqueue.h>
 #include "shpchp.h"
 
 /* Global variables */
 int shpchp_debug;
 int shpchp_poll_mode;
 int shpchp_poll_time;
-struct controller *shpchp_ctrl_list;    /* = NULL */
+struct workqueue_struct *shpchp_wq;
 
 #define DRIVER_VERSION  "0.4"
 #define DRIVER_AUTHOR   "Dan Zink <dan.zink@compaq.com>, Greg Kroah-Hartman <greg@kroah.com>, Dely Sy <dely.l.sy@intel.com>"
@@ -57,7 +58,6 @@ MODULE_PARM_DESC(shpchp_poll_time, "Polling mechanism frequency, in seconds");
 
 #define SHPC_MODULE_NAME "shpchp"
 
-static int shpc_start_thread (void);
 static int set_attention_status (struct hotplug_slot *slot, u8 value);
 static int enable_slot          (struct hotplug_slot *slot);
 static int disable_slot         (struct hotplug_slot *slot);
@@ -94,107 +94,120 @@ static void release_slot(struct hotplug_slot *hotplug_slot)
         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
 
         kfree(slot->hotplug_slot->info);
-        kfree(slot->hotplug_slot->name);
         kfree(slot->hotplug_slot);
         kfree(slot);
 }
 
+static void make_slot_name(struct slot *slot)
+{
+        snprintf(slot->hotplug_slot->name, SLOT_NAME_SIZE, "%04d_%04d",
+                 slot->bus, slot->number);
+}
+
+
+
+
+static int
+shpchprm_get_physical_slot_number(struct controller *ctrl, u32 *sun,
+                                u8 busnum, u8 devnum)
+{
+        int offset = devnum - ctrl->slot_device_offset;
+
+        dbg("%s: ctrl->slot_num_inc %d, offset %d\n", __FUNCTION__,
+                        ctrl->slot_num_inc, offset);
+        *sun = (u8) (ctrl->first_slot + ctrl->slot_num_inc *offset);
+        return 0;
+}
+
+
+
 static int init_slots(struct controller *ctrl)
 {
-        struct slot *new_slot;
-        u8 number_of_slots;
-        u8 slot_device;
-        u32 slot_number, sun;
-        int result = -ENOMEM;
-
-        number_of_slots = ctrl->num_slots;
-        slot_device = ctrl->slot_device_offset;
-        slot_number = ctrl->first_slot;
-
-        while (number_of_slots) {
-                new_slot = (struct slot *) kmalloc(sizeof(struct slot), GFP_KERNEL);
-                if (!new_slot)
+        struct slot *slot;
+        struct hotplug_slot *hotplug_slot;
+        struct hotplug_slot_info *info;
+        int retval = -ENOMEM;
+        int i;
+        u32 sun;
+
+        for (i = 0; i < ctrl->num_slots; i++) {
+                slot = kzalloc(sizeof(*slot), GFP_KERNEL);
+                if (!slot)
                         goto error;
 
-                memset(new_slot, 0, sizeof(struct slot));
-                new_slot->hotplug_slot = kmalloc (sizeof (struct hotplug_slot), GFP_KERNEL);
-                if (!new_slot->hotplug_slot)
+                hotplug_slot = kzalloc(sizeof(*hotplug_slot), GFP_KERNEL);
+                if (!hotplug_slot)
                         goto error_slot;
-                memset(new_slot->hotplug_slot, 0, sizeof (struct hotplug_slot));
+                slot->hotplug_slot = hotplug_slot;
 
-                new_slot->hotplug_slot->info = kmalloc (sizeof (struct hotplug_slot_info), GFP_KERNEL);
-                if (!new_slot->hotplug_slot->info)
+                info = kzalloc(sizeof(*info), GFP_KERNEL);
+                if (!info)
                         goto error_hpslot;
-                memset(new_slot->hotplug_slot->info, 0, sizeof (struct hotplug_slot_info));
-                new_slot->hotplug_slot->name = kmalloc (SLOT_NAME_SIZE, GFP_KERNEL);
-                if (!new_slot->hotplug_slot->name)
-                        goto error_info;
+                hotplug_slot->info = info;
+
+                hotplug_slot->name = slot->name;
 
-                new_slot->magic = SLOT_MAGIC;
-                new_slot->ctrl = ctrl;
-                new_slot->bus = ctrl->slot_bus;
-                new_slot->device = slot_device;
-                new_slot->hpc_ops = ctrl->hpc_ops;
+                slot->hp_slot = i;
+                slot->ctrl = ctrl;
+                slot->bus = ctrl->slot_bus;
+                slot->device = ctrl->slot_device_offset + i;
+                slot->hpc_ops = ctrl->hpc_ops;
+                mutex_init(&slot->lock);
 
                 if (shpchprm_get_physical_slot_number(ctrl, &sun,
-                                        new_slot->bus, new_slot->device))
-                        goto error_name;
+                                                      slot->bus, slot->device))
+                        goto error_info;
 
-                new_slot->number = sun;
-                new_slot->hp_slot = slot_device - ctrl->slot_device_offset;
+                slot->number = sun;
+                INIT_WORK(&slot->work, queue_pushbutton_work, slot);
 
                 /* register this slot with the hotplug pci core */
-                new_slot->hotplug_slot->private = new_slot;
-                new_slot->hotplug_slot->release = &release_slot;
-                make_slot_name(new_slot->hotplug_slot->name, SLOT_NAME_SIZE, new_slot);
-                new_slot->hotplug_slot->ops = &shpchp_hotplug_slot_ops;
-
-                new_slot->hpc_ops->get_power_status(new_slot, &(new_slot->hotplug_slot->info->power_status));
-                new_slot->hpc_ops->get_attention_status(new_slot, &(new_slot->hotplug_slot->info->attention_status));
-                new_slot->hpc_ops->get_latch_status(new_slot, &(new_slot->hotplug_slot->info->latch_status));
-                new_slot->hpc_ops->get_adapter_status(new_slot, &(new_slot->hotplug_slot->info->adapter_status));
-
-                dbg("Registering bus=%x dev=%x hp_slot=%x sun=%x slot_device_offset=%x\n", new_slot->bus, 
-                        new_slot->device, new_slot->hp_slot, new_slot->number, ctrl->slot_device_offset);
-                result = pci_hp_register (new_slot->hotplug_slot);
-                if (result) {
-                        err ("pci_hp_register failed with error %d\n", result);
-                        goto error_name;
+                hotplug_slot->private = slot;
+                hotplug_slot->release = &release_slot;
+                make_slot_name(slot);
+                hotplug_slot->ops = &shpchp_hotplug_slot_ops;
+
+                get_power_status(hotplug_slot, &info->power_status);
+                get_attention_status(hotplug_slot, &info->attention_status);
+                get_latch_status(hotplug_slot, &info->latch_status);
+                get_adapter_status(hotplug_slot, &info->adapter_status);
+
+                dbg("Registering bus=%x dev=%x hp_slot=%x sun=%x "
+                    "slot_device_offset=%x\n", slot->bus, slot->device,
+                    slot->hp_slot, slot->number, ctrl->slot_device_offset);
+                retval = pci_hp_register(slot->hotplug_slot);
+                if (retval) {
+                        err("pci_hp_register failed with error %d\n", retval);
+                        goto error_info;
                 }
 
-                new_slot->next = ctrl->slot;
-                ctrl->slot = new_slot;
-
-                number_of_slots--;
-                slot_device++;
-                slot_number += ctrl->slot_num_inc;
+                list_add(&slot->slot_list, &ctrl->slot_list);
         }
 
         return 0;
-
-error_name:
-        kfree(new_slot->hotplug_slot->name);
 error_info:
-        kfree(new_slot->hotplug_slot->info);
+        kfree(info);
 error_hpslot:
-        kfree(new_slot->hotplug_slot);
+        kfree(hotplug_slot);
 error_slot:
-        kfree(new_slot);
+        kfree(slot);
 error:
-        return result;
+        return retval;
 }
 
-static void cleanup_slots(struct controller *ctrl)
+void cleanup_slots(struct controller *ctrl)
 {
-        struct slot *old_slot, *next_slot;
-
-        old_slot = ctrl->slot;
-        ctrl->slot = NULL;
-
-        while (old_slot) {
-                next_slot = old_slot->next;
-                pci_hp_deregister(old_slot->hotplug_slot);
-                old_slot = next_slot;
+        struct list_head *tmp;
+        struct list_head *next;
+        struct slot *slot;
+
+        list_for_each_safe(tmp, next, &ctrl->slot_list) {
+                slot = list_entry(tmp, struct slot, slot_list);
+                list_del(&slot->slot_list);
+                cancel_delayed_work(&slot->work);
+                flush_scheduled_work();
+                flush_workqueue(shpchp_wq);
+                pci_hp_deregister(slot->hotplug_slot);
         }
 }
 
@@ -207,9 +220,12 @@ static int get_ctlr_slot_config(struct controller *ctrl)
         int rc;
         int flags;
 
-        rc = shpc_get_ctlr_slot_config(ctrl, &num_ctlr_slots, &first_device_num, &physical_slot_num, &updown, &flags);
+        rc = shpc_get_ctlr_slot_config(ctrl, &num_ctlr_slots,
+                                       &first_device_num, &physical_slot_num,
+                                       &updown, &flags);
         if (rc) {
-                err("%s: get_ctlr_slot_config fail for b:d (%x:%x)\n", __FUNCTION__, ctrl->bus, ctrl->device);
+                err("%s: get_ctlr_slot_config fail for b:d (%x:%x)\n",
+                    __FUNCTION__, ctrl->bus, ctrl->device);
                 return -1;
         }
 
@@ -218,19 +234,19 @@ static int get_ctlr_slot_config(struct controller *ctrl)
         ctrl->first_slot = physical_slot_num;
         ctrl->slot_num_inc = updown;            /* either -1 or 1 */
 
-        dbg("%s: num_slot(0x%x) 1st_dev(0x%x) psn(0x%x) updown(%d) for b:d (%x:%x)\n",
-                __FUNCTION__, num_ctlr_slots, first_device_num, physical_slot_num, updown, ctrl->bus, ctrl->device);
+        dbg("%s: num_slot(0x%x) 1st_dev(0x%x) psn(0x%x) updown(%d) for b:d "
+            "(%x:%x)\n", __FUNCTION__, num_ctlr_slots, first_device_num,
+            physical_slot_num, updown, ctrl->bus, ctrl->device);
 
         return 0;
 }
 
-
 /*
  * set_attention_status - Turns the Amber LED for a slot on, off or blink
  */
 static int set_attention_status (struct hotplug_slot *hotplug_slot, u8 status)
 {
-        struct slot *slot = get_slot (hotplug_slot, __FUNCTION__);
+        struct slot *slot = get_slot(hotplug_slot, __FUNCTION__);
 
         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
 
@@ -240,29 +256,27 @@ static int set_attention_status (struct hotplug_slot *hotplug_slot, u8 status)
         return 0;
 }
 
-
 static int enable_slot (struct hotplug_slot *hotplug_slot)
 {
-        struct slot *slot = get_slot (hotplug_slot, __FUNCTION__);
+        struct slot *slot = get_slot(hotplug_slot, __FUNCTION__);
 
         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
 
-        return shpchp_enable_slot(slot);
+        return shpchp_sysfs_enable_slot(slot);
 }
 
-
 static int disable_slot (struct hotplug_slot *hotplug_slot)
 {
-        struct slot *slot = get_slot (hotplug_slot, __FUNCTION__);
+        struct slot *slot = get_slot(hotplug_slot, __FUNCTION__);
 
         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
 
-        return shpchp_disable_slot(slot);
+        return shpchp_sysfs_disable_slot(slot);
 }
 
 static int get_power_status (struct hotplug_slot *hotplug_slot, u8 *value)
 {
-        struct slot *slot = get_slot (hotplug_slot, __FUNCTION__);
+        struct slot *slot = get_slot(hotplug_slot, __FUNCTION__);
         int retval;
 
         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
@@ -276,7 +290,7 @@ static int get_power_status (struct hotplug_slot *hotplug_slot, u8 *value)
 
 static int get_attention_status (struct hotplug_slot *hotplug_slot, u8 *value)
 {
-        struct slot *slot = get_slot (hotplug_slot, __FUNCTION__);
+        struct slot *slot = get_slot(hotplug_slot, __FUNCTION__);
         int retval;
 
         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
@@ -290,7 +304,7 @@ static int get_attention_status (struct hotplug_slot *hotplug_slot, u8 *value)
 
 static int get_latch_status (struct hotplug_slot *hotplug_slot, u8 *value)
 {
-        struct slot *slot = get_slot (hotplug_slot, __FUNCTION__);
+        struct slot *slot = get_slot(hotplug_slot, __FUNCTION__);
         int retval;
 
         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
@@ -304,7 +318,7 @@ static int get_latch_status (struct hotplug_slot *hotplug_slot, u8 *value)
 
 static int get_adapter_status (struct hotplug_slot *hotplug_slot, u8 *value)
 {
-        struct slot *slot = get_slot (hotplug_slot, __FUNCTION__);
+        struct slot *slot = get_slot(hotplug_slot, __FUNCTION__);
         int retval;
 
         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
@@ -318,7 +332,7 @@ static int get_adapter_status (struct hotplug_slot *hotplug_slot, u8 *value)
 
 static int get_address (struct hotplug_slot *hotplug_slot, u32 *value)
 {
-        struct slot *slot = get_slot (hotplug_slot, __FUNCTION__);
+        struct slot *slot = get_slot(hotplug_slot, __FUNCTION__);
         struct pci_bus *bus = slot->ctrl->pci_dev->subordinate;
 
         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
@@ -330,11 +344,11 @@ static int get_address (struct hotplug_slot *hotplug_slot, u32 *value)
 
 static int get_max_bus_speed (struct hotplug_slot *hotplug_slot, enum pci_bus_speed *value)
 {
-        struct slot *slot = get_slot (hotplug_slot, __FUNCTION__);
+        struct slot *slot = get_slot(hotplug_slot, __FUNCTION__);
         int retval;
 
         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
-        
+
         retval = slot->hpc_ops->get_max_bus_speed(slot, value);
         if (retval < 0)
                 *value = PCI_SPEED_UNKNOWN;
@@ -344,11 +358,11 @@ static int get_max_bus_speed (struct hotplug_slot *hotplug_slot, enum pci_bus_sp
 
 static int get_cur_bus_speed (struct hotplug_slot *hotplug_slot, enum pci_bus_speed *value)
 {
-        struct slot *slot = get_slot (hotplug_slot, __FUNCTION__);
+        struct slot *slot = get_slot(hotplug_slot, __FUNCTION__);
         int retval;
 
         dbg("%s - physical_slot = %s\n", __FUNCTION__, hotplug_slot->name);
-        
+
         retval = slot->hpc_ops->get_cur_bus_speed(slot, value);
         if (retval < 0)
                 *value = PCI_SPEED_UNKNOWN;
@@ -372,61 +386,54 @@ static int shpc_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         int rc;
         struct controller *ctrl;
         struct slot *t_slot;
-        int first_device_num;   /* first PCI device number supported by this SHPC */
-        int num_ctlr_slots;     /* number of slots supported by this SHPC */
+        int first_device_num;   /* first PCI device number */
+        int num_ctlr_slots;     /* number of slots implemented */
 
         if (!is_shpc_capable(pdev))
                 return -ENODEV;
 
-        ctrl = (struct controller *) kmalloc(sizeof(struct controller), GFP_KERNEL);
+        ctrl = kzalloc(sizeof(*ctrl), GFP_KERNEL);
         if (!ctrl) {
                 err("%s : out of memory\n", __FUNCTION__);
                 goto err_out_none;
         }
-        memset(ctrl, 0, sizeof(struct controller));
+        INIT_LIST_HEAD(&ctrl->slot_list);
 
         rc = shpc_init(ctrl, pdev);
         if (rc) {
-                dbg("%s: controller initialization failed\n", SHPC_MODULE_NAME);
+                dbg("%s: controller initialization failed\n",
+                    SHPC_MODULE_NAME);
                 goto err_out_free_ctrl;
         }
 
         pci_set_drvdata(pdev, ctrl);
 
-        ctrl->pci_bus = kmalloc (sizeof (*ctrl->pci_bus), GFP_KERNEL);
-        if (!ctrl->pci_bus) {
-                err("out of memory\n");
-                rc = -ENOMEM;
-                goto err_out_unmap_mmio_region;
-        }
-        
-        memcpy (ctrl->pci_bus, pdev->bus, sizeof (*ctrl->pci_bus));
         ctrl->bus = pdev->bus->number;
         ctrl->slot_bus = pdev->subordinate->number;
-
         ctrl->device = PCI_SLOT(pdev->devfn);
         ctrl->function = PCI_FUNC(pdev->devfn);
-        dbg("ctrl bus=0x%x, device=%x, function=%x, irq=%x\n", ctrl->bus, ctrl->device, ctrl->function, pdev->irq);
+
+        dbg("ctrl bus=0x%x, device=%x, function=%x, irq=%x\n",
+            ctrl->bus, ctrl->device, ctrl->function, pdev->irq);
 
         /*
-         *      Save configuration headers for this and subordinate PCI buses
+         * Save configuration headers for this and subordinate PCI buses
          */
-
         rc = get_ctlr_slot_config(ctrl);
         if (rc) {
                 err(msg_initialization_err, rc);
-                goto err_out_free_ctrl_bus;
+                goto err_out_release_ctlr;
         }
         first_device_num = ctrl->slot_device_offset;
         num_ctlr_slots = ctrl->num_slots;
 
         ctrl->add_support = 1;
-        
+
         /* Setup the slot information structures */
         rc = init_slots(ctrl);
         if (rc) {
                 err(msg_initialization_err, 6);
-                goto err_out_free_ctrl_slot;
+                goto err_out_release_ctlr;
         }
 
         /* Now hpc_functions (slot->hpc_ops->functions) are ready  */
@@ -437,30 +444,16 @@ static int shpc_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         dbg("%s: t_slot->hp_slot %x\n", __FUNCTION__,t_slot->hp_slot);
 
         if (rc || ctrl->speed == PCI_SPEED_UNKNOWN) {
-                err(SHPC_MODULE_NAME ": Can't get current bus speed. Set to 33MHz PCI.\n");
+                err(SHPC_MODULE_NAME ": Can't get current bus speed. "
+                    "Set to 33MHz PCI.\n");
                 ctrl->speed = PCI_SPEED_33MHz;
         }
 
-        /* Finish setting up the hot plug ctrl device */
-        ctrl->next_event = 0;
-
-        if (!shpchp_ctrl_list) {
-                shpchp_ctrl_list = ctrl;
-                ctrl->next = NULL;
-        } else {
-                ctrl->next = shpchp_ctrl_list;
-                shpchp_ctrl_list = ctrl;
-        }
-
         shpchp_create_ctrl_files(ctrl);
 
         return 0;
 
-err_out_free_ctrl_slot:
-        cleanup_slots(ctrl);
-err_out_free_ctrl_bus:
-        kfree(ctrl->pci_bus);
-err_out_unmap_mmio_region:
+err_out_release_ctlr:
         ctrl->hpc_ops->release_ctlr(ctrl);
 err_out_free_ctrl:
         kfree(ctrl);
@@ -468,74 +461,28 @@ err_out_none:
         return -ENODEV;
 }
 
-
-static int shpc_start_thread(void)
-{
-        int retval = 0;
-        
-        dbg("Initialize + Start the notification/polling mechanism \n");
-
-        retval = shpchp_event_start_thread();
-        if (retval) {
-                dbg("shpchp_event_start_thread() failed\n");
-                return retval;
-        }
-
-        return retval;
-}
-
-static void __exit unload_shpchpd(void)
+static void shpc_remove(struct pci_dev *dev)
 {
-        struct controller *ctrl;
-        struct controller *tctrl;
-
-        ctrl = shpchp_ctrl_list;
-
-        while (ctrl) {
-                shpchp_remove_ctrl_files(ctrl);
-                cleanup_slots(ctrl);
-
-                kfree (ctrl->pci_bus);
-                ctrl->hpc_ops->release_ctlr(ctrl);
-
-                tctrl = ctrl;
-                ctrl = ctrl->next;
-
-                kfree(tctrl);
-        }
-
-        /* Stop the notification mechanism */
-        shpchp_event_stop_thread();
+        struct controller *ctrl = pci_get_drvdata(dev);
 
+        shpchp_remove_ctrl_files(ctrl);
+        ctrl->hpc_ops->release_ctlr(ctrl);
+        kfree(ctrl);
 }
 
-
 static struct pci_device_id shpcd_pci_tbl[] = {
-        {
-        .class =        ((PCI_CLASS_BRIDGE_PCI << 8) | 0x00),
-        .class_mask =   ~0,
-        .vendor =       PCI_ANY_ID,
-        .device =       PCI_ANY_ID,
-        .subvendor =    PCI_ANY_ID,
-        .subdevice =    PCI_ANY_ID,
-        },
-        
+        {PCI_DEVICE_CLASS(((PCI_CLASS_BRIDGE_PCI << 8) | 0x00), ~0)},
         { /* end: all zeroes */ }
 };
-
 MODULE_DEVICE_TABLE(pci, shpcd_pci_tbl);
 
-
-
 static struct pci_driver shpc_driver = {
         .name =         SHPC_MODULE_NAME,
         .id_table =     shpcd_pci_tbl,
         .probe =        shpc_probe,
-        /* remove:      shpc_remove_one, */
+        .remove =       shpc_remove,
 };
 
-
-
 static int __init shpcd_init(void)
 {
         int retval = 0;
@@ -544,17 +491,15 @@ static int __init shpcd_init(void)
         shpchp_poll_mode = 1;
 #endif
 
-        retval = shpc_start_thread();
-        if (retval)
-                goto error_hpc_init;
+        shpchp_wq = create_singlethread_workqueue("shpchpd");
+        if (!shpchp_wq)
+                return -ENOMEM;
 
         retval = pci_register_driver(&shpc_driver);
         dbg("%s: pci_register_driver = %d\n", __FUNCTION__, retval);
         info(DRIVER_DESC " version: " DRIVER_VERSION "\n");
-
-error_hpc_init:
         if (retval) {
-                shpchp_event_stop_thread();
+                destroy_workqueue(shpchp_wq);
         }
         return retval;
 }
@@ -562,10 +507,8 @@ error_hpc_init:
 static void __exit shpcd_cleanup(void)
 {
         dbg("unload_shpchpd()\n");
-        unload_shpchpd();
-
         pci_unregister_driver(&shpc_driver);
-
+        destroy_workqueue(shpchp_wq);
         info(DRIVER_DESC " version: " DRIVER_VERSION " unloaded\n");
 }
 
diff --git a/drivers/pci/hotplug/shpchp_ctrl.c b/drivers/pci/hotplug/shpchp_ctrl.c
index 643252d9bf..4e6381481c 100644
--- a/drivers/pci/hotplug/shpchp_ctrl.c
+++ b/drivers/pci/hotplug/shpchp_ctrl.c
@@ -32,65 +32,50 @@
 #include <linux/types.h>
 #include <linux/smp_lock.h>
 #include <linux/pci.h>
+#include <linux/workqueue.h>
 #include "../pci.h"
 #include "shpchp.h"
 
-static void interrupt_event_handler(struct controller *ctrl);
+static void interrupt_event_handler(void *data);
+static int shpchp_enable_slot(struct slot *p_slot);
+static int shpchp_disable_slot(struct slot *p_slot);
 
-static struct semaphore event_semaphore;        /* mutex for process loop (up if something to process) */
-static struct semaphore event_exit;             /* guard ensure thread has exited before calling it quits */
-static int event_finished;
-static unsigned long pushbutton_pending;        /* = 0 */
+static int queue_interrupt_event(struct slot *p_slot, u32 event_type)
+{
+        struct event_info *info;
+
+        info = kmalloc(sizeof(*info), GFP_ATOMIC);
+        if (!info)
+                return -ENOMEM;
+
+        info->event_type = event_type;
+        info->p_slot = p_slot;
+        INIT_WORK(&info->work, interrupt_event_handler, info);
+
+        schedule_work(&info->work);
+
+        return 0;
+}
 
 u8 shpchp_handle_attention_button(u8 hp_slot, void *inst_id)
 {
         struct controller *ctrl = (struct controller *) inst_id;
         struct slot *p_slot;
-        u8 rc = 0;
-        u8 getstatus;
-        struct event_info *taskInfo;
+        u32 event_type;
 
         /* Attention Button Change */
         dbg("shpchp:  Attention button interrupt received.\n");
         
-        /* This is the structure that tells the worker thread what to do */
-        taskInfo = &(ctrl->event_queue[ctrl->next_event]);
         p_slot = shpchp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset);
-
         p_slot->hpc_ops->get_adapter_status(p_slot, &(p_slot->presence_save));
-        p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
-        
-        ctrl->next_event = (ctrl->next_event + 1) % 10;
-        taskInfo->hp_slot = hp_slot;
-
-        rc++;
 
         /*
          *  Button pressed - See if need to TAKE ACTION!!!
          */
         info("Button pressed on Slot(%d)\n", ctrl->first_slot + hp_slot);
-        taskInfo->event_type = INT_BUTTON_PRESS;
-
-        if ((p_slot->state == BLINKINGON_STATE)
-            || (p_slot->state == BLINKINGOFF_STATE)) {
-                /* Cancel if we are still blinking; this means that we press the
-                 * attention again before the 5 sec. limit expires to cancel hot-add
-                 * or hot-remove
-                 */
-                taskInfo->event_type = INT_BUTTON_CANCEL;
-                info("Button cancel on Slot(%d)\n", ctrl->first_slot + hp_slot);
-        } else if ((p_slot->state == POWERON_STATE)
-                   || (p_slot->state == POWEROFF_STATE)) {
-                /* Ignore if the slot is on power-on or power-off state; this 
-                 * means that the previous attention button action to hot-add or
-                 * hot-remove is undergoing
-                 */
-                taskInfo->event_type = INT_BUTTON_IGNORE;
-                info("Button ignore on Slot(%d)\n", ctrl->first_slot + hp_slot);
-        }
+        event_type = INT_BUTTON_PRESS;
 
-        if (rc)
-                up(&event_semaphore);   /* signal event thread that new event is posted */
+        queue_interrupt_event(p_slot, event_type);
 
         return 0;
 
@@ -100,21 +85,12 @@ u8 shpchp_handle_switch_change(u8 hp_slot, void *inst_id)
 {
         struct controller *ctrl = (struct controller *) inst_id;
         struct slot *p_slot;
-        u8 rc = 0;
         u8 getstatus;
-        struct event_info *taskInfo;
+        u32 event_type;
 
         /* Switch Change */
         dbg("shpchp:  Switch interrupt received.\n");
 
-        /* This is the structure that tells the worker thread
-         * what to do
-         */
-        taskInfo = &(ctrl->event_queue[ctrl->next_event]);
-        ctrl->next_event = (ctrl->next_event + 1) % 10;
-        taskInfo->hp_slot = hp_slot;
-
-        rc++;
         p_slot = shpchp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset);
         p_slot->hpc_ops->get_adapter_status(p_slot, &(p_slot->presence_save));
         p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
@@ -126,9 +102,9 @@ u8 shpchp_handle_switch_change(u8 hp_slot, void *inst_id)
                  * Switch opened
                  */
                 info("Latch open on Slot(%d)\n", ctrl->first_slot + hp_slot);
-                taskInfo->event_type = INT_SWITCH_OPEN;
+                event_type = INT_SWITCH_OPEN;
                 if (p_slot->pwr_save && p_slot->presence_save) {
-                        taskInfo->event_type = INT_POWER_FAULT;
+                        event_type = INT_POWER_FAULT;
                         err("Surprise Removal of card\n");
                 }
         } else {
@@ -136,34 +112,23 @@ u8 shpchp_handle_switch_change(u8 hp_slot, void *inst_id)
                  *  Switch closed
                  */
                 info("Latch close on Slot(%d)\n", ctrl->first_slot + hp_slot);
-                taskInfo->event_type = INT_SWITCH_CLOSE;
+                event_type = INT_SWITCH_CLOSE;
         }
 
-        if (rc)
-                up(&event_semaphore);   /* signal event thread that new event is posted */
+        queue_interrupt_event(p_slot, event_type);
 
-        return rc;
+        return 1;
 }
 
 u8 shpchp_handle_presence_change(u8 hp_slot, void *inst_id)
 {
         struct controller *ctrl = (struct controller *) inst_id;
         struct slot *p_slot;
-        u8 rc = 0;
-        /*u8 temp_byte;*/
-        struct event_info *taskInfo;
+        u32 event_type;
 
         /* Presence Change */
         dbg("shpchp:  Presence/Notify input change.\n");
 
-        /* This is the structure that tells the worker thread
-         * what to do
-         */
-        taskInfo = &(ctrl->event_queue[ctrl->next_event]);
-        ctrl->next_event = (ctrl->next_event + 1) % 10;
-        taskInfo->hp_slot = hp_slot;
-
-        rc++;
         p_slot = shpchp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset);
 
         /* 
@@ -175,39 +140,29 @@ u8 shpchp_handle_presence_change(u8 hp_slot, void *inst_id)
                  * Card Present
                  */
                 info("Card present on Slot(%d)\n", ctrl->first_slot + hp_slot);
-                taskInfo->event_type = INT_PRESENCE_ON;
+                event_type = INT_PRESENCE_ON;
         } else {
                 /*
                  * Not Present
                  */
                 info("Card not present on Slot(%d)\n", ctrl->first_slot + hp_slot);
-                taskInfo->event_type = INT_PRESENCE_OFF;
+                event_type = INT_PRESENCE_OFF;
         }
 
-        if (rc)
-                up(&event_semaphore);   /* signal event thread that new event is posted */
+        queue_interrupt_event(p_slot, event_type);
 
-        return rc;
+        return 1;
 }
 
 u8 shpchp_handle_power_fault(u8 hp_slot, void *inst_id)
 {
         struct controller *ctrl = (struct controller *) inst_id;
         struct slot *p_slot;
-        u8 rc = 0;
-        struct event_info *taskInfo;
+        u32 event_type;
 
         /* Power fault */
         dbg("shpchp:  Power fault interrupt received.\n");
 
-        /* This is the structure that tells the worker thread
-         * what to do
-         */
-        taskInfo = &(ctrl->event_queue[ctrl->next_event]);
-        ctrl->next_event = (ctrl->next_event + 1) % 10;
-        taskInfo->hp_slot = hp_slot;
-
-        rc++;
         p_slot = shpchp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset);
 
         if ( !(p_slot->hpc_ops->query_power_fault(p_slot))) {
@@ -216,21 +171,21 @@ u8 shpchp_handle_power_fault(u8 hp_slot, void *inst_id)
                  */
                 info("Power fault cleared on Slot(%d)\n", ctrl->first_slot + hp_slot);
                 p_slot->status = 0x00;
-                taskInfo->event_type = INT_POWER_FAULT_CLEAR;
+                event_type = INT_POWER_FAULT_CLEAR;
         } else {
                 /*
                  *   Power fault
                  */
                 info("Power fault on Slot(%d)\n", ctrl->first_slot + hp_slot);
-                taskInfo->event_type = INT_POWER_FAULT;
+                event_type = INT_POWER_FAULT;
                 /* set power fault status for this board */
                 p_slot->status = 0xFF;
                 info("power fault bit %x set\n", hp_slot);
         }
-        if (rc)
-                up(&event_semaphore);   /* signal event thread that new event is posted */
 
-        return rc;
+        queue_interrupt_event(p_slot, event_type);
+
+        return 1;
 }
 
 /* The following routines constitute the bulk of the 
@@ -242,21 +197,11 @@ static int change_bus_speed(struct controller *ctrl, struct slot *p_slot,
         int rc = 0;
 
         dbg("%s: change to speed %d\n", __FUNCTION__, speed);
-        down(&ctrl->crit_sect);
         if ((rc = p_slot->hpc_ops->set_bus_speed_mode(p_slot, speed))) {
-                err("%s: Issue of set bus speed mode command failed\n", __FUNCTION__);
-                up(&ctrl->crit_sect);
+                err("%s: Issue of set bus speed mode command failed\n",
+                    __FUNCTION__);
                 return WRONG_BUS_FREQUENCY;
         }
-                
-        if ((rc = p_slot->hpc_ops->check_cmd_status(ctrl))) {
-                err("%s: Can't set bus speed/mode in the case of adapter & bus mismatch\n",
-                          __FUNCTION__);
-                err("%s: Error code (%d)\n", __FUNCTION__, rc);
-                up(&ctrl->crit_sect);
-                return WRONG_BUS_FREQUENCY;
-        }
-        up(&ctrl->crit_sect);
         return rc;
 }
 
@@ -265,33 +210,26 @@ static int fix_bus_speed(struct controller *ctrl, struct slot *pslot,
                 enum pci_bus_speed msp)
 { 
         int rc = 0;
-        
-        if (flag != 0) { /* Other slots on the same bus are occupied */
-                if ( asp < bsp ) {
-                        err("%s: speed of bus %x and adapter %x mismatch\n", __FUNCTION__, bsp, asp);
-                        return WRONG_BUS_FREQUENCY;
+
+        /*
+         * If other slots on the same bus are occupied, we cannot
+         * change the bus speed.
+         */
+        if (flag) {
+                if (asp < bsp) {
+                        err("%s: speed of bus %x and adapter %x mismatch\n",
+                            __FUNCTION__, bsp, asp);
+                        rc = WRONG_BUS_FREQUENCY;
                 }
+                return rc;
+        }
+
+        if (asp < msp) {
+                if (bsp != asp)
+                        rc = change_bus_speed(ctrl, pslot, asp);
         } else {
-                /* Other slots on the same bus are empty */
-                if (msp == bsp) {
-                /* if adapter_speed >= bus_speed, do nothing */
-                        if (asp < bsp) {
-                                /* 
-                                * Try to lower bus speed to accommodate the adapter if other slots 
-                                * on the same controller are empty
-                                */
-                                if ((rc = change_bus_speed(ctrl, pslot, asp)))
-                                        return rc;
-                        } 
-                } else {
-                        if (asp < msp) {
-                                if ((rc = change_bus_speed(ctrl, pslot, asp)))
-                                        return rc;
-                        } else {
-                                if ((rc = change_bus_speed(ctrl, pslot, msp)))
-                                        return rc;
-                        }
-                }
+                if (bsp != msp)
+                        rc = change_bus_speed(ctrl, pslot, msp);
         }
         return rc;
 }
@@ -308,8 +246,7 @@ static int board_added(struct slot *p_slot)
         u8 hp_slot;
         u8 slots_not_empty = 0;
         int rc = 0;
-        enum pci_bus_speed adapter_speed, bus_speed, max_bus_speed;
-        u8 pi, mode;
+        enum pci_bus_speed asp, bsp, msp;
         struct controller *ctrl = p_slot->ctrl;
 
         hp_slot = p_slot->device - ctrl->slot_device_offset;
@@ -318,187 +255,68 @@ static int board_added(struct slot *p_slot)
                         __FUNCTION__, p_slot->device,
                         ctrl->slot_device_offset, hp_slot);
 
-        /* Wait for exclusive access to hardware */
-        down(&ctrl->crit_sect);
-
         /* Power on slot without connecting to bus */
         rc = p_slot->hpc_ops->power_on_slot(p_slot);
         if (rc) {
                 err("%s: Failed to power on slot\n", __FUNCTION__);
-                /* Done with exclusive hardware access */
-                up(&ctrl->crit_sect);
                 return -1;
         }
         
-        rc = p_slot->hpc_ops->check_cmd_status(ctrl);
-        if (rc) {
-                err("%s: Failed to power on slot, error code(%d)\n", __FUNCTION__, rc);
-                /* Done with exclusive hardware access */
-                up(&ctrl->crit_sect);
-                return -1;
-        }
-
-        
         if ((ctrl->pci_dev->vendor == 0x8086) && (ctrl->pci_dev->device == 0x0332)) {
                 if (slots_not_empty)
                         return WRONG_BUS_FREQUENCY;
                 
                 if ((rc = p_slot->hpc_ops->set_bus_speed_mode(p_slot, PCI_SPEED_33MHz))) {
                         err("%s: Issue of set bus speed mode command failed\n", __FUNCTION__);
-                        up(&ctrl->crit_sect);
                         return WRONG_BUS_FREQUENCY;
                 }
                 
-                if ((rc = p_slot->hpc_ops->check_cmd_status(ctrl))) {
-                        err("%s: Can't set bus speed/mode in the case of adapter & bus mismatch\n",
-                                  __FUNCTION__);
-                        err("%s: Error code (%d)\n", __FUNCTION__, rc);
-                        up(&ctrl->crit_sect);
-                        return WRONG_BUS_FREQUENCY;
-                }
                 /* turn on board, blink green LED, turn off Amber LED */
                 if ((rc = p_slot->hpc_ops->slot_enable(p_slot))) {
                         err("%s: Issue of Slot Enable command failed\n", __FUNCTION__);
-                        up(&ctrl->crit_sect);
                         return rc;
                 }
-
-                if ((rc = p_slot->hpc_ops->check_cmd_status(ctrl))) {
-                        err("%s: Failed to enable slot, error code(%d)\n", __FUNCTION__, rc);
-                        up(&ctrl->crit_sect);
-                        return rc;  
-                }
         }
  
-        rc = p_slot->hpc_ops->get_adapter_speed(p_slot, &adapter_speed);
-        /* 0 = PCI 33Mhz, 1 = PCI 66 Mhz, 2 = PCI-X 66 PA, 4 = PCI-X 66 ECC, */
-        /* 5 = PCI-X 133 PA, 7 = PCI-X 133 ECC,  0xa = PCI-X 133 Mhz 266, */
-        /* 0xd = PCI-X 133 Mhz 533 */
-        /* This encoding is different from the one used in cur_bus_speed & */
-        /* max_bus_speed */
-
-        if (rc  || adapter_speed == PCI_SPEED_UNKNOWN) {
-                err("%s: Can't get adapter speed or bus mode mismatch\n", __FUNCTION__);
-                /* Done with exclusive hardware access */
-                up(&ctrl->crit_sect);
+        rc = p_slot->hpc_ops->get_adapter_speed(p_slot, &asp);
+        if (rc) {
+                err("%s: Can't get adapter speed or bus mode mismatch\n",
+                    __FUNCTION__);
                 return WRONG_BUS_FREQUENCY;
         }
 
-        rc = p_slot->hpc_ops->get_cur_bus_speed(p_slot, &bus_speed);
-        if (rc || bus_speed == PCI_SPEED_UNKNOWN) {
+        rc = p_slot->hpc_ops->get_cur_bus_speed(p_slot, &bsp);
+        if (rc) {
                 err("%s: Can't get bus operation speed\n", __FUNCTION__);
-                /* Done with exclusive hardware access */
-                up(&ctrl->crit_sect);
                 return WRONG_BUS_FREQUENCY;
         }
 
-        rc = p_slot->hpc_ops->get_max_bus_speed(p_slot, &max_bus_speed);
-        if (rc || max_bus_speed == PCI_SPEED_UNKNOWN) {
+        rc = p_slot->hpc_ops->get_max_bus_speed(p_slot, &msp);
+        if (rc) {
                 err("%s: Can't get max bus operation speed\n", __FUNCTION__);
-                max_bus_speed = bus_speed;
-        }
-
-        /* Done with exclusive hardware access */
-        up(&ctrl->crit_sect);
-
-        if ((rc  = p_slot->hpc_ops->get_prog_int(p_slot, &pi))) {
-                err("%s: Can't get controller programming interface, set it to 1\n", __FUNCTION__);
-                pi = 1;
+                msp = bsp;
         }
 
         /* Check if there are other slots or devices on the same bus */
         if (!list_empty(&ctrl->pci_dev->subordinate->devices))
                 slots_not_empty = 1;
 
-        dbg("%s: slots_not_empty %d, pi %d\n", __FUNCTION__, 
-                slots_not_empty, pi);
-        dbg("adapter_speed %d, bus_speed %d, max_bus_speed %d\n", 
-                adapter_speed, bus_speed, max_bus_speed);
-
-        if (pi == 2) {
-                dbg("%s: In PI = %d\n", __FUNCTION__, pi);
-                if ((rc = p_slot->hpc_ops->get_mode1_ECC_cap(p_slot, &mode))) {
-                        err("%s: Can't get Mode1_ECC, set mode to 0\n", __FUNCTION__);
-                        mode = 0;
-                }
+        dbg("%s: slots_not_empty %d, adapter_speed %d, bus_speed %d, "
+            "max_bus_speed %d\n", __FUNCTION__, slots_not_empty, asp,
+            bsp, msp);
 
-                switch (adapter_speed) {
-                case PCI_SPEED_133MHz_PCIX_533:
-                case PCI_SPEED_133MHz_PCIX_266:
-                        if ((bus_speed != adapter_speed) &&
-                           ((rc = fix_bus_speed(ctrl, p_slot, slots_not_empty, adapter_speed, bus_speed, max_bus_speed)))) 
-                                return rc;
-                        break;  
-                case PCI_SPEED_133MHz_PCIX_ECC:
-                case PCI_SPEED_133MHz_PCIX:
-                        if (mode) { /* Bus - Mode 1 ECC */
-                                if ((bus_speed != 0x7) &&
-                                   ((rc = fix_bus_speed(ctrl, p_slot, slots_not_empty, adapter_speed, bus_speed, max_bus_speed)))) 
-                                        return rc;
-                        } else {
-                                if ((bus_speed != 0x4) &&
-                                   ((rc = fix_bus_speed(ctrl, p_slot, slots_not_empty, adapter_speed, bus_speed, max_bus_speed)))) 
-                                        return rc;
-                        }
-                        break;
-                case PCI_SPEED_66MHz_PCIX_ECC:
-                case PCI_SPEED_66MHz_PCIX:
-                        if (mode) { /* Bus - Mode 1 ECC */
-                                if ((bus_speed != 0x5) &&
-                                   ((rc = fix_bus_speed(ctrl, p_slot, slots_not_empty, adapter_speed, bus_speed, max_bus_speed)))) 
-                                        return rc;
-                        } else {
-                                if ((bus_speed != 0x2) &&
-                                   ((rc = fix_bus_speed(ctrl, p_slot, slots_not_empty, adapter_speed, bus_speed, max_bus_speed)))) 
-                                        return rc;
-                        }
-                        break;
-                case PCI_SPEED_66MHz:
-                        if ((bus_speed != 0x1) &&
-                           ((rc = fix_bus_speed(ctrl, p_slot, slots_not_empty, adapter_speed, bus_speed, max_bus_speed)))) 
-                                return rc;
-                        break;  
-                case PCI_SPEED_33MHz:
-                        if (bus_speed > 0x0) {
-                                if (slots_not_empty == 0) {
-                                        if ((rc = change_bus_speed(ctrl, p_slot, adapter_speed)))
-                                                return rc;
-                                } else {
-                                        err("%s: speed of bus %x and adapter %x mismatch\n", __FUNCTION__, bus_speed, adapter_speed);
-                                        return WRONG_BUS_FREQUENCY;
-                                }
-                        }
-                        break;
-                default:
-                        err("%s: speed of bus %x and adapter %x mismatch\n", __FUNCTION__, bus_speed, adapter_speed);
-                        return WRONG_BUS_FREQUENCY;
-                }
-        } else {
-                /* If adpater_speed == bus_speed, nothing to do here */
-                dbg("%s: In PI = %d\n", __FUNCTION__, pi);
-                if ((adapter_speed != bus_speed) &&
-                   ((rc = fix_bus_speed(ctrl, p_slot, slots_not_empty, adapter_speed, bus_speed, max_bus_speed))))
-                                return rc;
-        }
+        rc = fix_bus_speed(ctrl, p_slot, slots_not_empty, asp, bsp, msp);
+        if (rc)
+                return rc;
 
-        down(&ctrl->crit_sect);
         /* turn on board, blink green LED, turn off Amber LED */
         if ((rc = p_slot->hpc_ops->slot_enable(p_slot))) {
                 err("%s: Issue of Slot Enable command failed\n", __FUNCTION__);
-                up(&ctrl->crit_sect);
                 return rc;
         }
 
-        if ((rc = p_slot->hpc_ops->check_cmd_status(ctrl))) {
-                err("%s: Failed to enable slot, error code(%d)\n", __FUNCTION__, rc);
-                up(&ctrl->crit_sect);
-                return rc;  
-        }
-
-        up(&ctrl->crit_sect);
-
         /* Wait for ~1 second */
-        wait_for_ctrl_irq (ctrl);
+        msleep(1000);
 
         dbg("%s: slot status = %x\n", __FUNCTION__, p_slot->status);
         /* Check for a power fault */
@@ -520,40 +338,18 @@ static int board_added(struct slot *p_slot)
         p_slot->is_a_board = 0x01;
         p_slot->pwr_save = 1;
 
-        /* Wait for exclusive access to hardware */
-        down(&ctrl->crit_sect);
-
         p_slot->hpc_ops->green_led_on(p_slot);
 
-        /* Done with exclusive hardware access */
-        up(&ctrl->crit_sect);
-
         return 0;
 
 err_exit:
-        /* Wait for exclusive access to hardware */
-        down(&ctrl->crit_sect);
-
         /* turn off slot, turn on Amber LED, turn off Green LED */
         rc = p_slot->hpc_ops->slot_disable(p_slot);
         if (rc) {
                 err("%s: Issue of Slot Disable command failed\n", __FUNCTION__);
-                /* Done with exclusive hardware access */
-                up(&ctrl->crit_sect);
-                return rc;
-        }
-
-        rc = p_slot->hpc_ops->check_cmd_status(ctrl);
-        if (rc) {
-                err("%s: Failed to disable slot, error code(%d)\n", __FUNCTION__, rc);
-                /* Done with exclusive hardware access */
-                up(&ctrl->crit_sect);
                 return rc;
         }
 
-        /* Done with exclusive hardware access */
-        up(&ctrl->crit_sect);
-
         return(rc);
 }
 
@@ -580,37 +376,19 @@ static int remove_board(struct slot *p_slot)
         if (p_slot->is_a_board)
                 p_slot->status = 0x01;
 
-        /* Wait for exclusive access to hardware */
-        down(&ctrl->crit_sect);
-
         /* turn off slot, turn on Amber LED, turn off Green LED */
         rc = p_slot->hpc_ops->slot_disable(p_slot);
         if (rc) {
                 err("%s: Issue of Slot Disable command failed\n", __FUNCTION__);
-                /* Done with exclusive hardware access */
-                up(&ctrl->crit_sect);
                 return rc;
         }
-
-        rc = p_slot->hpc_ops->check_cmd_status(ctrl);
-        if (rc) {
-                err("%s: Failed to disable slot, error code(%d)\n", __FUNCTION__, rc);
-                /* Done with exclusive hardware access */
-                up(&ctrl->crit_sect);
-                return rc;  
-        }
         
         rc = p_slot->hpc_ops->set_attention_status(p_slot, 0);
         if (rc) {
                 err("%s: Issue of Set Attention command failed\n", __FUNCTION__);
-                /* Done with exclusive hardware access */
-                up(&ctrl->crit_sect);
                 return rc;
         }
 
-        /* Done with exclusive hardware access */
-        up(&ctrl->crit_sect);
-
         p_slot->pwr_save = 0;
         p_slot->is_a_board = 0;
 
@@ -618,13 +396,10 @@ static int remove_board(struct slot *p_slot)
 }
 
 
-static void pushbutton_helper_thread (unsigned long data)
-{
-        pushbutton_pending = data;
-
-        up(&event_semaphore);
-}
-
+struct pushbutton_work_info {
+        struct slot *p_slot;
+        struct work_struct work;
+};
 
 /**
  * shpchp_pushbutton_thread
@@ -633,96 +408,63 @@ static void pushbutton_helper_thread (unsigned long data)
  * Handles all pending events and exits.
  *
  */
-static void shpchp_pushbutton_thread (unsigned long slot)
+static void shpchp_pushbutton_thread(void *data)
 {
-        struct slot *p_slot = (struct slot *) slot;
-        u8 getstatus;
-        
-        pushbutton_pending = 0;
-
-        if (!p_slot) {
-                dbg("%s: Error! slot NULL\n", __FUNCTION__);
-                return;
-        }
-
-        p_slot->hpc_ops->get_power_status(p_slot, &getstatus);
-        if (getstatus) {
-                p_slot->state = POWEROFF_STATE;
+        struct pushbutton_work_info *info = data;
+        struct slot *p_slot = info->p_slot;
 
+        mutex_lock(&p_slot->lock);
+        switch (p_slot->state) {
+        case POWEROFF_STATE:
+                mutex_unlock(&p_slot->lock);
                 shpchp_disable_slot(p_slot);
+                mutex_lock(&p_slot->lock);
                 p_slot->state = STATIC_STATE;
-        } else {
-                p_slot->state = POWERON_STATE;
-
-                if (shpchp_enable_slot(p_slot)) {
-                        /* Wait for exclusive access to hardware */
-                        down(&p_slot->ctrl->crit_sect);
-
+                break;
+        case POWERON_STATE:
+                mutex_unlock(&p_slot->lock);
+                if (shpchp_enable_slot(p_slot))
                         p_slot->hpc_ops->green_led_off(p_slot);
-
-                        /* Done with exclusive hardware access */
-                        up(&p_slot->ctrl->crit_sect);
-                }
+                mutex_lock(&p_slot->lock);
                 p_slot->state = STATIC_STATE;
+                break;
+        default:
+                break;
         }
+        mutex_unlock(&p_slot->lock);
 
-        return;
-}
-
-
-/* this is the main worker thread */
-static int event_thread(void* data)
-{
-        struct controller *ctrl;
-        lock_kernel();
-        daemonize("shpchpd_event");
-        unlock_kernel();
-
-        while (1) {
-                dbg("!!!!event_thread sleeping\n");
-                down_interruptible (&event_semaphore);
-                dbg("event_thread woken finished = %d\n", event_finished);
-                if (event_finished || signal_pending(current))
-                        break;
-                /* Do stuff here */
-                if (pushbutton_pending)
-                        shpchp_pushbutton_thread(pushbutton_pending);
-                else
-                        for (ctrl = shpchp_ctrl_list; ctrl; ctrl=ctrl->next)
-                                interrupt_event_handler(ctrl);
-        }
-        dbg("event_thread signals exit\n");
-        up(&event_exit);
-        return 0;
+        kfree(info);
 }
 
-int shpchp_event_start_thread (void)
+void queue_pushbutton_work(void *data)
 {
-        int pid;
+        struct slot *p_slot = data;
+        struct pushbutton_work_info *info;
 
-        /* initialize our semaphores */
-        init_MUTEX_LOCKED(&event_exit);
-        event_finished=0;
-
-        init_MUTEX_LOCKED(&event_semaphore);
-        pid = kernel_thread(event_thread, NULL, 0);
-
-        if (pid < 0) {
-                err ("Can't start up our event thread\n");
-                return -1;
+        info = kmalloc(sizeof(*info), GFP_KERNEL);
+        if (!info) {
+                err("%s: Cannot allocate memory\n", __FUNCTION__);
+                return;
         }
-        return 0;
-}
-
+        info->p_slot = p_slot;
+        INIT_WORK(&info->work, shpchp_pushbutton_thread, info);
 
-void shpchp_event_stop_thread (void)
-{
-        event_finished = 1;
-        up(&event_semaphore);
-        down(&event_exit);
+        mutex_lock(&p_slot->lock);
+        switch (p_slot->state) {
+        case BLINKINGOFF_STATE:
+                p_slot->state = POWEROFF_STATE;
+                break;
+        case BLINKINGON_STATE:
+                p_slot->state = POWERON_STATE;
+                break;
+        default:
+                goto out;
+        }
+        queue_work(shpchp_wq, &info->work);
+ out:
+        mutex_unlock(&p_slot->lock);
 }
 
-
 static int update_slot_info (struct slot *slot)
 {
         struct hotplug_slot_info *info;
@@ -742,149 +484,110 @@ static int update_slot_info (struct slot *slot)
         return result;
 }
 
-static void interrupt_event_handler(struct controller *ctrl)
+/*
+ * Note: This function must be called with slot->lock held
+ */
+static void handle_button_press_event(struct slot *p_slot)
 {
-        int loop = 0;
-        int change = 1;
-        u8 hp_slot;
         u8 getstatus;
-        struct slot *p_slot;
 
-        while (change) {
-                change = 0;
-
-                for (loop = 0; loop < 10; loop++) {
-                        if (ctrl->event_queue[loop].event_type != 0) {
-                                dbg("%s:loop %x event_type %x\n", __FUNCTION__, loop, 
-                                        ctrl->event_queue[loop].event_type);
-                                hp_slot = ctrl->event_queue[loop].hp_slot;
-
-                                p_slot = shpchp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset);
-
-                                if (ctrl->event_queue[loop].event_type == INT_BUTTON_CANCEL) {
-                                        dbg("%s: button cancel\n", __FUNCTION__);
-                                        del_timer(&p_slot->task_event);
-
-                                        switch (p_slot->state) {
-                                        case BLINKINGOFF_STATE:
-                                                /* Wait for exclusive access to hardware */
-                                                down(&ctrl->crit_sect);
-
-                                                p_slot->hpc_ops->green_led_on(p_slot);
-
-                                                p_slot->hpc_ops->set_attention_status(p_slot, 0);
-
-                                                /* Done with exclusive hardware access */
-                                                up(&ctrl->crit_sect);
-                                                break;
-                                        case BLINKINGON_STATE:
-                                                /* Wait for exclusive access to hardware */
-                                                down(&ctrl->crit_sect);
-
-                                                p_slot->hpc_ops->green_led_off(p_slot);
-
-                                                p_slot->hpc_ops->set_attention_status(p_slot, 0);
-
-                                                /* Done with exclusive hardware access */
-                                                up(&ctrl->crit_sect);
-
-                                                break;
-                                        default:
-                                                warn("Not a valid state\n");
-                                                return;
-                                        }
-                                        info(msg_button_cancel, p_slot->number);
-                                        p_slot->state = STATIC_STATE;
-                                } else if (ctrl->event_queue[loop].event_type == INT_BUTTON_PRESS) {
-                                        /* Button Pressed (No action on 1st press...) */
-                                        dbg("%s: Button pressed\n", __FUNCTION__);
-
-                                        p_slot->hpc_ops->get_power_status(p_slot, &getstatus);
-                                        if (getstatus) {
-                                                /* slot is on */
-                                                dbg("%s: slot is on\n", __FUNCTION__);
-                                                p_slot->state = BLINKINGOFF_STATE;
-                                                info(msg_button_off, p_slot->number);
-                                        } else {
-                                                /* slot is off */
-                                                dbg("%s: slot is off\n", __FUNCTION__);
-                                                p_slot->state = BLINKINGON_STATE;
-                                                info(msg_button_on, p_slot->number);
-                                        }
-
-                                        /* Wait for exclusive access to hardware */
-                                        down(&ctrl->crit_sect);
-
-                                        /* blink green LED and turn off amber */
-                                        p_slot->hpc_ops->green_led_blink(p_slot);
-                                        
-                                        p_slot->hpc_ops->set_attention_status(p_slot, 0);
-
-                                        /* Done with exclusive hardware access */
-                                        up(&ctrl->crit_sect);
-
-                                        init_timer(&p_slot->task_event);
-                                        p_slot->task_event.expires = jiffies + 5 * HZ;   /* 5 second delay */
-                                        p_slot->task_event.function = (void (*)(unsigned long)) pushbutton_helper_thread;
-                                        p_slot->task_event.data = (unsigned long) p_slot;
-
-                                        dbg("%s: add_timer p_slot = %p\n", __FUNCTION__,(void *) p_slot);
-                                        add_timer(&p_slot->task_event);
-                                } else if (ctrl->event_queue[loop].event_type == INT_POWER_FAULT) {
-                                        /***********POWER FAULT********************/
-                                        dbg("%s: power fault\n", __FUNCTION__);
-                                        /* Wait for exclusive access to hardware */
-                                        down(&ctrl->crit_sect);
-
-                                        p_slot->hpc_ops->set_attention_status(p_slot, 1);
-                                        
-                                        p_slot->hpc_ops->green_led_off(p_slot);
-
-                                        /* Done with exclusive hardware access */
-                                        up(&ctrl->crit_sect);
-                                } else {
-                                        /* refresh notification */
-                                        if (p_slot)
-                                                update_slot_info(p_slot);
-                                }
-
-                                ctrl->event_queue[loop].event_type = 0;
-
-                                change = 1;
-                        }
-                }               /* End of FOR loop */
+        switch (p_slot->state) {
+        case STATIC_STATE:
+                p_slot->hpc_ops->get_power_status(p_slot, &getstatus);
+                if (getstatus) {
+                        p_slot->state = BLINKINGOFF_STATE;
+                        info(msg_button_off, p_slot->number);
+                } else {
+                        p_slot->state = BLINKINGON_STATE;
+                        info(msg_button_on, p_slot->number);
+                }
+                /* blink green LED and turn off amber */
+                p_slot->hpc_ops->green_led_blink(p_slot);
+                p_slot->hpc_ops->set_attention_status(p_slot, 0);
+
+                schedule_delayed_work(&p_slot->work, 5*HZ);
+                break;
+        case BLINKINGOFF_STATE:
+        case BLINKINGON_STATE:
+                /*
+                 * Cancel if we are still blinking; this means that we
+                 * press the attention again before the 5 sec. limit
+                 * expires to cancel hot-add or hot-remove
+                 */
+                info("Button cancel on Slot(%s)\n", p_slot->name);
+                dbg("%s: button cancel\n", __FUNCTION__);
+                cancel_delayed_work(&p_slot->work);
+                if (p_slot->state == BLINKINGOFF_STATE)
+                        p_slot->hpc_ops->green_led_on(p_slot);
+                else
+                        p_slot->hpc_ops->green_led_off(p_slot);
+                p_slot->hpc_ops->set_attention_status(p_slot, 0);
+                info(msg_button_cancel, p_slot->number);
+                p_slot->state = STATIC_STATE;
+                break;
+        case POWEROFF_STATE:
+        case POWERON_STATE:
+                /*
+                 * Ignore if the slot is on power-on or power-off state;
+                 * this means that the previous attention button action
+                 * to hot-add or hot-remove is undergoing
+                 */
+                info("Button ignore on Slot(%s)\n", p_slot->name);
+                update_slot_info(p_slot);
+                break;
+        default:
+                warn("Not a valid state\n");
+                break;
         }
+}
+
+static void interrupt_event_handler(void *data)
+{
+        struct event_info *info = data;
+        struct slot *p_slot = info->p_slot;
+
+        mutex_lock(&p_slot->lock);
+        switch (info->event_type) {
+        case INT_BUTTON_PRESS:
+                handle_button_press_event(p_slot);
+                break;
+        case INT_POWER_FAULT:
+                dbg("%s: power fault\n", __FUNCTION__);
+                p_slot->hpc_ops->set_attention_status(p_slot, 1);
+                p_slot->hpc_ops->green_led_off(p_slot);
+                break;
+        default:
+                update_slot_info(p_slot);
+                break;
+        }
+        mutex_unlock(&p_slot->lock);
 
-        return;
+        kfree(info);
 }
 
 
-int shpchp_enable_slot (struct slot *p_slot)
+static int shpchp_enable_slot (struct slot *p_slot)
 {
         u8 getstatus = 0;
-        int rc;
+        int rc, retval = -ENODEV;
 
         /* Check to see if (latch closed, card present, power off) */
-        down(&p_slot->ctrl->crit_sect);
+        mutex_lock(&p_slot->ctrl->crit_sect);
         rc = p_slot->hpc_ops->get_adapter_status(p_slot, &getstatus);
         if (rc || !getstatus) {
                 info("%s: no adapter on slot(%x)\n", __FUNCTION__, p_slot->number);
-                up(&p_slot->ctrl->crit_sect);
-                return -ENODEV;
+                goto out;
         }
         rc = p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
         if (rc || getstatus) {
                 info("%s: latch open on slot(%x)\n", __FUNCTION__, p_slot->number);
-                up(&p_slot->ctrl->crit_sect);
-                return -ENODEV;
+                goto out;
         }
         rc = p_slot->hpc_ops->get_power_status(p_slot, &getstatus);
         if (rc || getstatus) {
                 info("%s: already enabled on slot(%x)\n", __FUNCTION__, p_slot->number);
-                up(&p_slot->ctrl->crit_sect);
-                return -ENODEV;
+                goto out;
         }
-        up(&p_slot->ctrl->crit_sect);
 
         p_slot->is_a_board = 1;
 
@@ -899,56 +602,119 @@ int shpchp_enable_slot (struct slot *p_slot)
              && p_slot->ctrl->num_slots == 1) {
                 /* handle amd pogo errata; this must be done before enable  */
                 amd_pogo_errata_save_misc_reg(p_slot);
-                rc = board_added(p_slot);
+                retval = board_added(p_slot);
                 /* handle amd pogo errata; this must be done after enable  */
                 amd_pogo_errata_restore_misc_reg(p_slot);
         } else
-                rc = board_added(p_slot);
+                retval = board_added(p_slot);
 
-        if (rc) {
+        if (retval) {
                 p_slot->hpc_ops->get_adapter_status(p_slot,
                                 &(p_slot->presence_save));
                 p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
         }
 
         update_slot_info(p_slot);
-        return rc;
+ out:
+        mutex_unlock(&p_slot->ctrl->crit_sect);
+        return retval;
 }
 
 
-int shpchp_disable_slot (struct slot *p_slot)
+static int shpchp_disable_slot (struct slot *p_slot)
 {
         u8 getstatus = 0;
-        int ret = 0;
+        int rc, retval = -ENODEV;
 
         if (!p_slot->ctrl)
                 return -ENODEV;
 
         /* Check to see if (latch closed, card present, power on) */
-        down(&p_slot->ctrl->crit_sect);
+        mutex_lock(&p_slot->ctrl->crit_sect);
 
-        ret = p_slot->hpc_ops->get_adapter_status(p_slot, &getstatus);
-        if (ret || !getstatus) {
+        rc = p_slot->hpc_ops->get_adapter_status(p_slot, &getstatus);
+        if (rc || !getstatus) {
                 info("%s: no adapter on slot(%x)\n", __FUNCTION__, p_slot->number);
-                up(&p_slot->ctrl->crit_sect);
-                return -ENODEV;
+                goto out;
         }
-        ret = p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
-        if (ret || getstatus) {
+        rc = p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
+        if (rc || getstatus) {
                 info("%s: latch open on slot(%x)\n", __FUNCTION__, p_slot->number);
-                up(&p_slot->ctrl->crit_sect);
-                return -ENODEV;
+                goto out;
         }
-        ret = p_slot->hpc_ops->get_power_status(p_slot, &getstatus);
-        if (ret || !getstatus) {
+        rc = p_slot->hpc_ops->get_power_status(p_slot, &getstatus);
+        if (rc || !getstatus) {
                 info("%s: already disabled slot(%x)\n", __FUNCTION__, p_slot->number);
-                up(&p_slot->ctrl->crit_sect);
-                return -ENODEV;
+                goto out;
         }
-        up(&p_slot->ctrl->crit_sect);
 
-        ret = remove_board(p_slot);
+        retval = remove_board(p_slot);
         update_slot_info(p_slot);
-        return ret;
+ out:
+        mutex_unlock(&p_slot->ctrl->crit_sect);
+        return retval;
 }
 
+int shpchp_sysfs_enable_slot(struct slot *p_slot)
+{
+        int retval = -ENODEV;
+
+        mutex_lock(&p_slot->lock);
+        switch (p_slot->state) {
+        case BLINKINGON_STATE:
+                cancel_delayed_work(&p_slot->work);
+        case STATIC_STATE:
+                p_slot->state = POWERON_STATE;
+                mutex_unlock(&p_slot->lock);
+                retval = shpchp_enable_slot(p_slot);
+                mutex_lock(&p_slot->lock);
+                p_slot->state = STATIC_STATE;
+                break;
+        case POWERON_STATE:
+                info("Slot %s is already in powering on state\n",
+                     p_slot->name);
+                break;
+        case BLINKINGOFF_STATE:
+        case POWEROFF_STATE:
+                info("Already enabled on slot %s\n", p_slot->name);
+                break;
+        default:
+                err("Not a valid state on slot %s\n", p_slot->name);
+                break;
+        }
+        mutex_unlock(&p_slot->lock);
+
+        return retval;
+}
+
+int shpchp_sysfs_disable_slot(struct slot *p_slot)
+{
+        int retval = -ENODEV;
+
+        mutex_lock(&p_slot->lock);
+        switch (p_slot->state) {
+        case BLINKINGOFF_STATE:
+                cancel_delayed_work(&p_slot->work);
+        case STATIC_STATE:
+                p_slot->state = POWEROFF_STATE;
+                mutex_unlock(&p_slot->lock);
+                retval = shpchp_disable_slot(p_slot);
+                mutex_lock(&p_slot->lock);
+                p_slot->state = STATIC_STATE;
+                break;
+        case POWEROFF_STATE:
+                info("Slot %s is already in powering off state\n",
+                     p_slot->name);
+                break;
+        case BLINKINGON_STATE:
+        case POWERON_STATE:
+                info("Already disabled on slot %s\n", p_slot->name);
+                break;
+        default:
+                err("Not a valid state on slot %s\n", p_slot->name);
+                break;
+        }
+        mutex_unlock(&p_slot->lock);
+
+        return retval;
+}
diff --git a/drivers/pci/hotplug/shpchp_hpc.c b/drivers/pci/hotplug/shpchp_hpc.c
index b4226ff3a8..66123cf4de 100644
--- a/drivers/pci/hotplug/shpchp_hpc.c
+++ b/drivers/pci/hotplug/shpchp_hpc.c
@@ -82,31 +82,6 @@
 #define SLOT_100MHZ_PCIX_533    0x0f000000
 #define SLOT_133MHZ_PCIX_533    0xf0000000
 
-
-/* Secondary Bus Configuration Register */
-/* For PI = 1, Bits 0 to 2 have been encoded as follows to show current bus speed/mode */
-#define PCI_33MHZ               0x0
-#define PCI_66MHZ               0x1
-#define PCIX_66MHZ              0x2
-#define PCIX_100MHZ             0x3
-#define PCIX_133MHZ             0x4
-
-/* For PI = 2, Bits 0 to 3 have been encoded as follows to show current bus speed/mode */
-#define PCI_33MHZ               0x0
-#define PCI_66MHZ               0x1
-#define PCIX_66MHZ              0x2
-#define PCIX_100MHZ             0x3
-#define PCIX_133MHZ             0x4
-#define PCIX_66MHZ_ECC          0x5
-#define PCIX_100MHZ_ECC         0x6
-#define PCIX_133MHZ_ECC         0x7
-#define PCIX_66MHZ_266          0x9
-#define PCIX_100MHZ_266         0xa
-#define PCIX_133MHZ_266         0xb
-#define PCIX_66MHZ_533          0x11
-#define PCIX_100MHZ_533         0x12
-#define PCIX_133MHZ_533         0x13
-
 /* Slot Configuration */
 #define SLOT_NUM                0x0000001F
 #define FIRST_DEV_NUM           0x00001F00
@@ -231,6 +206,7 @@ static spinlock_t list_lock;
 static irqreturn_t shpc_isr(int IRQ, void *dev_id, struct pt_regs *regs);
 
 static void start_int_poll_timer(struct php_ctlr_state_s *php_ctlr, int seconds);
+static int hpc_check_cmd_status(struct controller *ctrl);
 
 /* This is the interrupt polling timeout function. */
 static void int_poll_timeout(unsigned long lphp_ctlr)
@@ -303,10 +279,13 @@ static int shpc_write_cmd(struct slot *slot, u8 t_slot, u8 cmd)
         int i;
 
         DBG_ENTER_ROUTINE 
-        
+
+        mutex_lock(&slot->ctrl->cmd_lock);
+
         if (!php_ctlr) {
                 err("%s: Invalid HPC controller handle!\n", __FUNCTION__);
-                return -1;
+                retval = -EINVAL;
+                goto out;
         }
 
         for (i = 0; i < 10; i++) {
@@ -323,7 +302,8 @@ static int shpc_write_cmd(struct slot *slot, u8 t_slot, u8 cmd)
         if (cmd_status & 0x1) { 
                 /* After 1 sec and and the controller is still busy */
                 err("%s : Controller is still busy after 1 sec.\n", __FUNCTION__);
-                return -1;
+                retval = -EBUSY;
+                goto out;
         }
 
         ++t_slot;
@@ -340,6 +320,17 @@ static int shpc_write_cmd(struct slot *slot, u8 t_slot, u8 cmd)
          * Wait for command completion.
          */
         retval = shpc_wait_cmd(slot->ctrl);
+        if (retval)
+                goto out;
+
+        cmd_status = hpc_check_cmd_status(slot->ctrl);
+        if (cmd_status) {
+                err("%s: Failed to issued command 0x%x (error code = %d)\n",
+                    __FUNCTION__, cmd, cmd_status);
+                retval = -EIO;
+        }
+ out:
+        mutex_unlock(&slot->ctrl->cmd_lock);
 
         DBG_LEAVE_ROUTINE 
         return retval;
@@ -532,81 +523,41 @@ static int hpc_get_prog_int(struct slot *slot, u8 *prog_int)
 
 static int hpc_get_adapter_speed(struct slot *slot, enum pci_bus_speed *value)
 {
-        struct php_ctlr_state_s *php_ctlr = slot->ctrl->hpc_ctlr_handle;
-        u32 slot_reg;
-        u16 slot_status, sec_bus_status;
-        u8 m66_cap, pcix_cap, pi;
         int retval = 0;
+        struct php_ctlr_state_s *php_ctlr = slot->ctrl->hpc_ctlr_handle;
+        u32 slot_reg = readl(php_ctlr->creg + SLOT1 + 4 * slot->hp_slot);
+        u8 pcix_cap = (slot_reg >> 12) & 7;
+        u8 m66_cap  = (slot_reg >> 9) & 1;
 
         DBG_ENTER_ROUTINE 
 
-        if (!slot->ctrl->hpc_ctlr_handle) {
-                err("%s: Invalid HPC controller handle!\n", __FUNCTION__);
-                return -1;
-        }
-
-        if (slot->hp_slot >= php_ctlr->num_slots) {
-                err("%s: Invalid HPC slot number!\n", __FUNCTION__);
-                return -1;
-        }
-        
-        pi = readb(php_ctlr->creg + PROG_INTERFACE);
-        slot_reg = readl(php_ctlr->creg + SLOT1 + 4*(slot->hp_slot));
-        dbg("%s: pi = %d, slot_reg = %x\n", __FUNCTION__, pi, slot_reg);
-        slot_status = (u16) slot_reg;
-        dbg("%s: slot_status = %x\n", __FUNCTION__, slot_status);
-        sec_bus_status = readw(php_ctlr->creg + SEC_BUS_CONFIG);
-
-        pcix_cap = (u8) ((slot_status & 0x3000) >> 12);
-        dbg("%s:  pcix_cap = %x\n", __FUNCTION__, pcix_cap);
-        m66_cap = (u8) ((slot_status & 0x0200) >> 9);
-        dbg("%s:  m66_cap = %x\n", __FUNCTION__, m66_cap);
-
+        dbg("%s: slot_reg = %x, pcix_cap = %x, m66_cap = %x\n",
+            __FUNCTION__, slot_reg, pcix_cap, m66_cap);
 
-        if (pi == 2) {
-                switch (pcix_cap) {
-                case 0:
-                        *value = m66_cap ? PCI_SPEED_66MHz : PCI_SPEED_33MHz;
-                        break;
-                case 1:
-                        *value = PCI_SPEED_66MHz_PCIX;
-                        break;
-                case 3:
-                        *value = PCI_SPEED_133MHz_PCIX;
-                        break;
-                case 4:
-                        *value = PCI_SPEED_133MHz_PCIX_266;     
-                        break;
-                case 5:
-                        *value = PCI_SPEED_133MHz_PCIX_533;     
-                        break;
-                case 2: /* Reserved */
-                default:
-                        *value = PCI_SPEED_UNKNOWN;
-                        retval = -ENODEV;
-                        break;
-                }
-        } else {
-                switch (pcix_cap) {
-                case 0:
-                        *value = m66_cap ? PCI_SPEED_66MHz : PCI_SPEED_33MHz;
-                        break;
-                case 1:
-                        *value = PCI_SPEED_66MHz_PCIX;
-                        break;
-                case 3:
-                        *value = PCI_SPEED_133MHz_PCIX; 
-                        break;
-                case 2: /* Reserved */
-                default:
-                        *value = PCI_SPEED_UNKNOWN;
-                        retval = -ENODEV;
-                        break;
-                }
+        switch (pcix_cap) {
+        case 0x0:
+                *value = m66_cap ? PCI_SPEED_66MHz : PCI_SPEED_33MHz;
+                break;
+        case 0x1:
+                *value = PCI_SPEED_66MHz_PCIX;
+                break;
+        case 0x3:
+                *value = PCI_SPEED_133MHz_PCIX;
+                break;
+        case 0x4:
+                *value = PCI_SPEED_133MHz_PCIX_266;
+                break;
+        case 0x5:
+                *value = PCI_SPEED_133MHz_PCIX_533;
+                break;
+        case 0x2:
+        default:
+                *value = PCI_SPEED_UNKNOWN;
+                retval = -ENODEV;
+                break;
         }
 
         dbg("Adapter speed = %d\n", *value);
-        
         DBG_LEAVE_ROUTINE 
         return retval;
 }
@@ -797,6 +748,7 @@ static void hpc_release_ctlr(struct controller *ctrl)
 {
         struct php_ctlr_state_s *php_ctlr = ctrl->hpc_ctlr_handle;
         struct php_ctlr_state_s *p, *p_prev;
+        int i;
 
         DBG_ENTER_ROUTINE 
 
@@ -805,6 +757,14 @@ static void hpc_release_ctlr(struct controller *ctrl)
                 return ;
         }
 
+        /*
+         * Mask all slot event interrupts
+         */
+        for (i = 0; i < ctrl->num_slots; i++)
+                writel(0xffff3fff, php_ctlr->creg + SLOT1 + (4 * i));
+
+        cleanup_slots(ctrl);
+
         if (shpchp_poll_mode) {
             del_timer(&php_ctlr->int_poll_timer);
         } else {        
@@ -814,6 +774,7 @@ static void hpc_release_ctlr(struct controller *ctrl)
                         pci_disable_msi(php_ctlr->pci_dev);
                 }
         }
+
         if (php_ctlr->pci_dev) {
                 iounmap(php_ctlr->creg);
                 release_mem_region(ctrl->mmio_base, ctrl->mmio_size);
@@ -939,98 +900,66 @@ static int hpc_slot_disable(struct slot * slot)
 
 static int hpc_set_bus_speed_mode(struct slot * slot, enum pci_bus_speed value)
 {
-        u8 slot_cmd;
-        u8 pi;
-        int retval = 0;
+        int retval;
         struct php_ctlr_state_s *php_ctlr = slot->ctrl->hpc_ctlr_handle;
+        u8 pi, cmd;
 
         DBG_ENTER_ROUTINE 
-        
-        if (!slot->ctrl->hpc_ctlr_handle) {
-                err("%s: Invalid HPC controller handle!\n", __FUNCTION__);
-                return -1;
-        }
 
         pi = readb(php_ctlr->creg + PROG_INTERFACE);
-        
-        if (pi == 1) {
-                switch (value) {
-                case 0:
-                        slot_cmd = SETA_PCI_33MHZ;
-                        break;
-                case 1:
-                        slot_cmd = SETA_PCI_66MHZ;
-                        break;
-                case 2:
-                        slot_cmd = SETA_PCIX_66MHZ;
-                        break;
-                case 3:
-                        slot_cmd = SETA_PCIX_100MHZ;    
-                        break;
-                case 4:
-                        slot_cmd = SETA_PCIX_133MHZ;    
-                        break;
-                default:
-                        slot_cmd = PCI_SPEED_UNKNOWN;
-                        retval = -ENODEV;
-                        return retval;  
-                }
-        } else {
-                switch (value) {
-                case 0:
-                        slot_cmd = SETB_PCI_33MHZ;
-                        break;
-                case 1:
-                        slot_cmd = SETB_PCI_66MHZ;
-                        break;
-                case 2:
-                        slot_cmd = SETB_PCIX_66MHZ_PM;
-                        break;
-                case 3:
-                        slot_cmd = SETB_PCIX_100MHZ_PM; 
-                        break;
-                case 4:
-                        slot_cmd = SETB_PCIX_133MHZ_PM; 
-                        break;
-                case 5:
-                        slot_cmd = SETB_PCIX_66MHZ_EM;  
-                        break;
-                case 6:
-                        slot_cmd = SETB_PCIX_100MHZ_EM; 
-                        break;
-                case 7:
-                        slot_cmd = SETB_PCIX_133MHZ_EM; 
-                        break;
-                case 8:
-                        slot_cmd = SETB_PCIX_66MHZ_266; 
-                        break;
-                case 0x9:
-                        slot_cmd = SETB_PCIX_100MHZ_266;        
-                        break;
-                case 0xa:
-                        slot_cmd = SETB_PCIX_133MHZ_266;        
-                        break;
-                case 0xb:
-                        slot_cmd = SETB_PCIX_66MHZ_533; 
-                        break;
-                case 0xc:
-                        slot_cmd = SETB_PCIX_100MHZ_533;        
-                        break;
-                case 0xd:
-                        slot_cmd = SETB_PCIX_133MHZ_533;        
-                        break;
-                default:
-                        slot_cmd = PCI_SPEED_UNKNOWN;
-                        retval = -ENODEV;
-                        return retval;  
-                }
+        if ((pi == 1) && (value > PCI_SPEED_133MHz_PCIX))
+                return -EINVAL;
 
+        switch (value) {
+        case PCI_SPEED_33MHz:
+                cmd = SETA_PCI_33MHZ;
+                break;
+        case PCI_SPEED_66MHz:
+                cmd = SETA_PCI_66MHZ;
+                break;
+        case PCI_SPEED_66MHz_PCIX:
+                cmd = SETA_PCIX_66MHZ;
+                break;
+        case PCI_SPEED_100MHz_PCIX:
+                cmd = SETA_PCIX_100MHZ;
+                break;
+        case PCI_SPEED_133MHz_PCIX:
+                cmd = SETA_PCIX_133MHZ;
+                break;
+        case PCI_SPEED_66MHz_PCIX_ECC:
+                cmd = SETB_PCIX_66MHZ_EM;
+                break;
+        case PCI_SPEED_100MHz_PCIX_ECC:
+                cmd = SETB_PCIX_100MHZ_EM;
+                break;
+        case PCI_SPEED_133MHz_PCIX_ECC:
+                cmd = SETB_PCIX_133MHZ_EM;
+                break;
+        case PCI_SPEED_66MHz_PCIX_266:
+                cmd = SETB_PCIX_66MHZ_266;
+                break;
+        case PCI_SPEED_100MHz_PCIX_266:
+                cmd = SETB_PCIX_100MHZ_266;
+                break;
+        case PCI_SPEED_133MHz_PCIX_266:
+                cmd = SETB_PCIX_133MHZ_266;
+                break;
+        case PCI_SPEED_66MHz_PCIX_533:
+                cmd = SETB_PCIX_66MHZ_533;
+                break;
+        case PCI_SPEED_100MHz_PCIX_533:
+                cmd = SETB_PCIX_100MHZ_533;
+                break;
+        case PCI_SPEED_133MHz_PCIX_533:
+                cmd = SETB_PCIX_133MHZ_533;
+                break;
+        default:
+                return -EINVAL;
         }
-        retval = shpc_write_cmd(slot, 0, slot_cmd);
-        if (retval) {
+
+        retval = shpc_write_cmd(slot, 0, cmd);
+        if (retval)
                 err("%s: Write command failed!\n", __FUNCTION__);
-                return -1;
-        }
 
         DBG_LEAVE_ROUTINE
         return retval;
@@ -1093,14 +1022,8 @@ static irqreturn_t shpc_isr(int IRQ, void *dev_id, struct pt_regs *regs)
                 wake_up_interruptible(&ctrl->queue);
         }
 
-        if ((intr_loc = (intr_loc >> 1)) == 0) {
-                /* Unmask Global Interrupt Mask */
-                temp_dword = readl(php_ctlr->creg + SERR_INTR_ENABLE);
-                temp_dword &= 0xfffffffe;
-                writel(temp_dword, php_ctlr->creg + SERR_INTR_ENABLE);
-
-                return IRQ_NONE;
-        }
+        if ((intr_loc = (intr_loc >> 1)) == 0)
+                goto out;
 
         for (hp_slot = 0; hp_slot < ctrl->num_slots; hp_slot++) { 
         /* To find out which slot has interrupt pending */
@@ -1130,6 +1053,7 @@ static irqreturn_t shpc_isr(int IRQ, void *dev_id, struct pt_regs *regs)
                         dbg("%s: intr_loc2 = %x\n",__FUNCTION__, intr_loc2); 
                 }
         }
+ out:
         if (!shpchp_poll_mode) {
                 /* Unmask Global Interrupt Mask */
                 temp_dword = readl(php_ctlr->creg + SERR_INTR_ENABLE);
@@ -1142,64 +1066,43 @@ static irqreturn_t shpc_isr(int IRQ, void *dev_id, struct pt_regs *regs)
 
 static int hpc_get_max_bus_speed (struct slot *slot, enum pci_bus_speed *value)
 {
+        int retval = 0;
         struct php_ctlr_state_s *php_ctlr = slot->ctrl->hpc_ctlr_handle;
         enum pci_bus_speed bus_speed = PCI_SPEED_UNKNOWN;
-        int retval = 0;
-        u8 pi;
-        u32 slot_avail1, slot_avail2;
+        u8 pi = readb(php_ctlr->creg + PROG_INTERFACE);
+        u32 slot_avail1 = readl(php_ctlr->creg + SLOT_AVAIL1);
+        u32 slot_avail2 = readl(php_ctlr->creg + SLOT_AVAIL2);
 
         DBG_ENTER_ROUTINE 
 
-        if (!slot->ctrl->hpc_ctlr_handle) {
-                err("%s: Invalid HPC controller handle!\n", __FUNCTION__);
-                return -1;
-        }
-
-        if (slot->hp_slot >= php_ctlr->num_slots) {
-                err("%s: Invalid HPC slot number!\n", __FUNCTION__);
-                return -1;
-        }
-
-        pi = readb(php_ctlr->creg + PROG_INTERFACE);
-        slot_avail1 = readl(php_ctlr->creg + SLOT_AVAIL1);
-        slot_avail2 = readl(php_ctlr->creg + SLOT_AVAIL2);
-
         if (pi == 2) {
                 if (slot_avail2 & SLOT_133MHZ_PCIX_533)
-                        bus_speed = PCIX_133MHZ_533;
+                        bus_speed = PCI_SPEED_133MHz_PCIX_533;
                 else if (slot_avail2 & SLOT_100MHZ_PCIX_533)
-                        bus_speed = PCIX_100MHZ_533;
+                        bus_speed = PCI_SPEED_100MHz_PCIX_533;
                 else if (slot_avail2 & SLOT_66MHZ_PCIX_533)
-                        bus_speed = PCIX_66MHZ_533;
+                        bus_speed = PCI_SPEED_66MHz_PCIX_533;
                 else if (slot_avail2 & SLOT_133MHZ_PCIX_266)
-                        bus_speed = PCIX_133MHZ_266;
+                        bus_speed = PCI_SPEED_133MHz_PCIX_266;
                 else if (slot_avail2 & SLOT_100MHZ_PCIX_266)
-                        bus_speed = PCIX_100MHZ_266;
+                        bus_speed = PCI_SPEED_100MHz_PCIX_266;
                 else if (slot_avail2 & SLOT_66MHZ_PCIX_266)
-                        bus_speed = PCIX_66MHZ_266;
-                else if (slot_avail1 & SLOT_133MHZ_PCIX)
-                        bus_speed = PCIX_133MHZ;
-                else if (slot_avail1 & SLOT_100MHZ_PCIX)
-                        bus_speed = PCIX_100MHZ;
-                else if (slot_avail1 & SLOT_66MHZ_PCIX)
-                        bus_speed = PCIX_66MHZ;
-                else if (slot_avail2 & SLOT_66MHZ)
-                        bus_speed = PCI_66MHZ;
-                else if (slot_avail1 & SLOT_33MHZ)
-                        bus_speed = PCI_33MHZ;
-                else bus_speed = PCI_SPEED_UNKNOWN;
-        } else {
+                        bus_speed = PCI_SPEED_66MHz_PCIX_266;
+        }
+
+        if (bus_speed == PCI_SPEED_UNKNOWN) {
                 if (slot_avail1 & SLOT_133MHZ_PCIX)
-                        bus_speed = PCIX_133MHZ;
+                        bus_speed = PCI_SPEED_133MHz_PCIX;
                 else if (slot_avail1 & SLOT_100MHZ_PCIX)
-                        bus_speed = PCIX_100MHZ;
+                        bus_speed = PCI_SPEED_100MHz_PCIX;
                 else if (slot_avail1 & SLOT_66MHZ_PCIX)
-                        bus_speed = PCIX_66MHZ;
+                        bus_speed = PCI_SPEED_66MHz_PCIX;
                 else if (slot_avail2 & SLOT_66MHZ)
-                        bus_speed = PCI_66MHZ;
+                        bus_speed = PCI_SPEED_66MHz;
                 else if (slot_avail1 & SLOT_33MHZ)
-                        bus_speed = PCI_33MHZ;
-                else bus_speed = PCI_SPEED_UNKNOWN;
+                        bus_speed = PCI_SPEED_33MHz;
+                else
+                        retval = -ENODEV;
         }
 
         *value = bus_speed;
@@ -1210,111 +1113,69 @@ static int hpc_get_max_bus_speed (struct slot *slot, enum pci_bus_speed *value)
 
 static int hpc_get_cur_bus_speed (struct slot *slot, enum pci_bus_speed *value)
 {
+        int retval = 0;
         struct php_ctlr_state_s *php_ctlr = slot->ctrl->hpc_ctlr_handle;
         enum pci_bus_speed bus_speed = PCI_SPEED_UNKNOWN;
-        u16 sec_bus_status;
-        int retval = 0;
-        u8 pi;
+        u16 sec_bus_reg = readw(php_ctlr->creg + SEC_BUS_CONFIG);
+        u8 pi = readb(php_ctlr->creg + PROG_INTERFACE);
+        u8 speed_mode = (pi == 2) ? (sec_bus_reg & 0xF) : (sec_bus_reg & 0x7);
 
         DBG_ENTER_ROUTINE 
 
-        if (!slot->ctrl->hpc_ctlr_handle) {
-                err("%s: Invalid HPC controller handle!\n", __FUNCTION__);
-                return -1;
-        }
-
-        if (slot->hp_slot >= php_ctlr->num_slots) {
-                err("%s: Invalid HPC slot number!\n", __FUNCTION__);
-                return -1;
+        if ((pi == 1) && (speed_mode > 4)) {
+                *value = PCI_SPEED_UNKNOWN;
+                return -ENODEV;
         }
 
-        pi = readb(php_ctlr->creg + PROG_INTERFACE);
-        sec_bus_status = readw(php_ctlr->creg + SEC_BUS_CONFIG);
-
-        if (pi == 2) {
-                switch (sec_bus_status & 0x000f) {
-                case 0:
-                        bus_speed = PCI_SPEED_33MHz;
-                        break;
-                case 1:
-                        bus_speed = PCI_SPEED_66MHz;
-                        break;
-                case 2:
-                        bus_speed = PCI_SPEED_66MHz_PCIX;
-                        break;
-                case 3:
-                        bus_speed = PCI_SPEED_100MHz_PCIX;      
-                        break;
-                case 4:
-                        bus_speed = PCI_SPEED_133MHz_PCIX;      
-                        break;
-                case 5:
-                        bus_speed = PCI_SPEED_66MHz_PCIX_ECC;
-                        break;
-                case 6:
-                        bus_speed = PCI_SPEED_100MHz_PCIX_ECC;
-                        break;
-                case 7:
-                        bus_speed = PCI_SPEED_133MHz_PCIX_ECC;  
-                        break;
-                case 8:
-                        bus_speed = PCI_SPEED_66MHz_PCIX_266;   
-                        break;
-                case 9:
-                        bus_speed = PCI_SPEED_100MHz_PCIX_266;  
-                        break;
-                case 0xa:
-                        bus_speed = PCI_SPEED_133MHz_PCIX_266;  
-                        break;
-                case 0xb:
-                        bus_speed = PCI_SPEED_66MHz_PCIX_533;   
-                        break;
-                case 0xc:
-                        bus_speed = PCI_SPEED_100MHz_PCIX_533;  
-                        break;
-                case 0xd:
-                        bus_speed = PCI_SPEED_133MHz_PCIX_533;  
-                        break;
-                case 0xe:
-                case 0xf:
-                default:
-                        bus_speed = PCI_SPEED_UNKNOWN;
-                        break;
-                }
-        } else {
-                /* In the case where pi is undefined, default it to 1 */ 
-                switch (sec_bus_status & 0x0007) {
-                case 0:
-                        bus_speed = PCI_SPEED_33MHz;
-                        break;
-                case 1:
-                        bus_speed = PCI_SPEED_66MHz;
-                        break;
-                case 2:
-                        bus_speed = PCI_SPEED_66MHz_PCIX;
-                        break;
-                case 3:
-                        bus_speed = PCI_SPEED_100MHz_PCIX;      
-                        break;
-                case 4:
-                        bus_speed = PCI_SPEED_133MHz_PCIX;      
-                        break;
-                case 5:
-                        bus_speed = PCI_SPEED_UNKNOWN;          /*      Reserved */
-                        break;
-                case 6:
-                        bus_speed = PCI_SPEED_UNKNOWN;          /*      Reserved */
-                        break;
-                case 7:
-                        bus_speed = PCI_SPEED_UNKNOWN;          /*      Reserved */     
-                        break;
-                default:
-                        bus_speed = PCI_SPEED_UNKNOWN;
-                        break;
-                }
+        switch (speed_mode) {
+        case 0x0:
+                *value = PCI_SPEED_33MHz;
+                break;
+        case 0x1:
+                *value = PCI_SPEED_66MHz;
+                break;
+        case 0x2:
+                *value = PCI_SPEED_66MHz_PCIX;
+                break;
+        case 0x3:
+                *value = PCI_SPEED_100MHz_PCIX;
+                break;
+        case 0x4:
+                *value = PCI_SPEED_133MHz_PCIX;
+                break;
+        case 0x5:
+                *value = PCI_SPEED_66MHz_PCIX_ECC;
+                break;
+        case 0x6:
+                *value = PCI_SPEED_100MHz_PCIX_ECC;
+                break;
+        case 0x7:
+                *value = PCI_SPEED_133MHz_PCIX_ECC;
+                break;
+        case 0x8:
+                *value = PCI_SPEED_66MHz_PCIX_266;
+                break;
+        case 0x9:
+                *value = PCI_SPEED_100MHz_PCIX_266;
+                break;
+        case 0xa:
+                *value = PCI_SPEED_133MHz_PCIX_266;
+                break;
+        case 0xb:
+                *value = PCI_SPEED_66MHz_PCIX_533;
+                break;
+        case 0xc:
+                *value = PCI_SPEED_100MHz_PCIX_533;
+                break;
+        case 0xd:
+                *value = PCI_SPEED_133MHz_PCIX_533;
+                break;
+        default:
+                *value = PCI_SPEED_UNKNOWN;
+                retval = -ENODEV;
+                break;
         }
 
-        *value = bus_speed;
         dbg("Current bus speed = %d\n", bus_speed);
         DBG_LEAVE_ROUTINE 
         return retval;
@@ -1343,7 +1204,6 @@ static struct hpc_ops shpchp_hpc_ops = {
         .green_led_blink                = hpc_set_green_led_blink,
         
         .release_ctlr                   = hpc_release_ctlr,
-        .check_cmd_status               = hpc_check_cmd_status,
 };
 
 inline static int shpc_indirect_creg_read(struct controller *ctrl, int index,
@@ -1375,15 +1235,13 @@ int shpc_init(struct controller * ctrl, struct pci_dev * pdev)
         ctrl->pci_dev = pdev;  /* pci_dev of the P2P bridge */
 
         spin_lock_init(&list_lock);
-        php_ctlr = (struct php_ctlr_state_s *) kmalloc(sizeof(struct php_ctlr_state_s), GFP_KERNEL);
+        php_ctlr = kzalloc(sizeof(*php_ctlr), GFP_KERNEL);
 
         if (!php_ctlr) {        /* allocate controller state data */
                 err("%s: HPC controller memory allocation error!\n", __FUNCTION__);
                 goto abort;
         }
 
-        memset(php_ctlr, 0, sizeof(struct php_ctlr_state_s));
-
         php_ctlr->pci_dev = pdev;       /* save pci_dev in context */
 
         if ((pdev->vendor == PCI_VENDOR_ID_AMD) || (pdev->device ==
@@ -1454,7 +1312,9 @@ int shpc_init(struct controller * ctrl, struct pci_dev * pdev)
         }
         dbg("%s: php_ctlr->creg %p\n", __FUNCTION__, php_ctlr->creg);
 
-        init_MUTEX(&ctrl->crit_sect);
+        mutex_init(&ctrl->crit_sect);
+        mutex_init(&ctrl->cmd_lock);
+
         /* Setup wait queue */
         init_waitqueue_head(&ctrl->queue);
 
diff --git a/drivers/pci/hotplug/shpchp_pci.c b/drivers/pci/hotplug/shpchp_pci.c
index 19e1a5e1e3..257adc2339 100644
--- a/drivers/pci/hotplug/shpchp_pci.c
+++ b/drivers/pci/hotplug/shpchp_pci.c
@@ -38,7 +38,7 @@ static void program_fw_provided_values(struct pci_dev *dev)
 {
         u16 pci_cmd, pci_bctl;
         struct pci_dev *cdev;
-        struct hotplug_params hpp = {0x8, 0x40, 0, 0}; /* defaults */
+        struct hotplug_params hpp;
 
         /* Program hpp values for this device */
         if (!(dev->hdr_type == PCI_HEADER_TYPE_NORMAL ||
@@ -46,7 +46,13 @@ static void program_fw_provided_values(struct pci_dev *dev)
                         (dev->class >> 8) == PCI_CLASS_BRIDGE_PCI)))
                 return;
 
-        get_hp_params_from_firmware(dev, &hpp);
+        /* use default values if we can't get them from firmware */
+        if (get_hp_params_from_firmware(dev, &hpp)) {
+                hpp.cache_line_size = 8;
+                hpp.latency_timer = 0x40;
+                hpp.enable_serr = 0;
+                hpp.enable_perr = 0;
+        }
 
         pci_write_config_byte(dev, PCI_CACHE_LINE_SIZE, hpp.cache_line_size);
         pci_write_config_byte(dev, PCI_LATENCY_TIMER, hpp.latency_timer);
diff --git a/drivers/pci/hotplug/shpchprm_legacy.c b/drivers/pci/hotplug/shpchprm_legacy.c
deleted file mode 100644
index ed6c1254bf..0000000000
--- a/drivers/pci/hotplug/shpchprm_legacy.c
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * SHPCHPRM Legacy: PHP Resource Manager for Non-ACPI/Legacy platform
- *
- * Copyright (C) 1995,2001 Compaq Computer Corporation
- * Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com)
- * Copyright (C) 2001 IBM Corp.
- * Copyright (C) 2003-2004 Intel Corporation
- *
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
- * NON INFRINGEMENT.  See the GNU General Public License for more
- * details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * Send feedback to <greg@kroah.com>,<kristen.c.accardi@intel.com>
- *
- */
-
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/types.h>
-#include <linux/pci.h>
-#include "shpchp.h"
-
-int shpchprm_get_physical_slot_number(struct controller *ctrl, u32 *sun, u8 busnum, u8 devnum)
-{
-        int     offset = devnum - ctrl->slot_device_offset;
-
-        *sun = (u8) (ctrl->first_slot + ctrl->slot_num_inc * offset);
-        return 0;
-}
-
-void get_hp_params_from_firmware(struct pci_dev *dev,
-                struct hotplug_params *hpp)
-{
-        return;
-}
-
-void get_hp_hw_control_from_firmware(struct pci_dev *dev)
-{
-        return;
-}
-
diff --git a/drivers/pci/hotplug/shpchprm_nonacpi.c b/drivers/pci/hotplug/shpchprm_nonacpi.c
deleted file mode 100644
index c6b40998ee..0000000000
--- a/drivers/pci/hotplug/shpchprm_nonacpi.c
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * SHPCHPRM NONACPI: PHP Resource Manager for Non-ACPI/Legacy platform
- *
- * Copyright (C) 1995,2001 Compaq Computer Corporation
- * Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com)
- * Copyright (C) 2001 IBM Corp.
- * Copyright (C) 2003-2004 Intel Corporation
- *
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
- * NON INFRINGEMENT.  See the GNU General Public License for more
- * details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * Send feedback to <greg@kroah.com>, <kristen.c.accardi@intel.com>
- *
- */
-
-#include <linux/config.h>
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/types.h>
-#include <linux/pci.h>
-#include <linux/slab.h>
-
-#include "shpchp.h"
-
-int shpchprm_get_physical_slot_number(struct controller *ctrl, u32 *sun, u8 busnum, u8 devnum)
-{
-        int     offset = devnum - ctrl->slot_device_offset;
-
-        dbg("%s: ctrl->slot_num_inc %d, offset %d\n", __FUNCTION__, ctrl->slot_num_inc, offset);
-        *sun = (u8) (ctrl->first_slot + ctrl->slot_num_inc * offset);
-        return 0;
-}
-
-void get_hp_params_from_firmware(struct pci_dev *dev,
-                struct hotplug_params *hpp)
-{
-        return;
-}
-
-void get_hp_hw_control_from_firmware(struct pci_dev *dev)
-{
-        return;
-}
diff --git a/drivers/pci/msi.c b/drivers/pci/msi.c
index 48723d6fa6..a77e79c8c8 100644
--- a/drivers/pci/msi.c
+++ b/drivers/pci/msi.c
@@ -103,9 +103,9 @@ static void set_msi_affinity(unsigned int vector, cpumask_t cpu_mask)
         switch (entry->msi_attrib.type) {
         case PCI_CAP_ID_MSI:
         {
-                int pos;
+                int pos = pci_find_capability(entry->dev, PCI_CAP_ID_MSI);
 
-                if (!(pos = pci_find_capability(entry->dev, PCI_CAP_ID_MSI)))
+                if (!pos)
                         return;
 
                 pci_read_config_dword(entry->dev, msi_lower_address_reg(pos),
@@ -347,9 +347,9 @@ static int assign_msi_vector(void)
 
 static int get_new_vector(void)
 {
-        int vector;
+        int vector = assign_msi_vector();
 
-        if ((vector = assign_msi_vector()) > 0)
+        if (vector > 0)
                 set_intr_gate(vector, interrupt[vector]);
 
         return vector;
@@ -369,7 +369,8 @@ static int msi_init(void)
                 return status;
         }
 
-        if ((status = msi_cache_init()) < 0) {
+        status = msi_cache_init();
+        if (status < 0) {
                 pci_msi_enable = 0;
                 printk(KERN_WARNING "PCI: MSI cache init failed\n");
                 return status;
@@ -523,10 +524,12 @@ static int msi_capability_init(struct pci_dev *dev)
         pos = pci_find_capability(dev, PCI_CAP_ID_MSI);
         pci_read_config_word(dev, msi_control_reg(pos), &control);
         /* MSI Entry Initialization */
-        if (!(entry = alloc_msi_entry()))
+        entry = alloc_msi_entry();
+        if (!entry)
                 return -ENOMEM;
 
-        if ((vector = get_msi_vector(dev)) < 0) {
+        vector = get_msi_vector(dev);
+        if (vector < 0) {
                 kmem_cache_free(msi_cachep, entry);
                 return -EBUSY;
         }
@@ -597,7 +600,8 @@ static int msix_capability_init(struct pci_dev *dev,
         struct msg_address address;
         struct msg_data data;
         int vector, pos, i, j, nr_entries, temp = 0;
-        u32 phys_addr, table_offset;
+        unsigned long phys_addr;
+        u32 table_offset;
         u16 control;
         u8 bir;
         void __iomem *base;
@@ -606,11 +610,11 @@ static int msix_capability_init(struct pci_dev *dev,
         /* Request & Map MSI-X table region */
         pci_read_config_word(dev, msi_control_reg(pos), &control);
         nr_entries = multi_msix_capable(control);
-        pci_read_config_dword(dev, msix_table_offset_reg(pos),
-                &table_offset);
+
+        pci_read_config_dword(dev, msix_table_offset_reg(pos), &table_offset);
         bir = (u8)(table_offset & PCI_MSIX_FLAGS_BIRMASK);
-        phys_addr = pci_resource_start (dev, bir);
-        phys_addr += (u32)(table_offset & ~PCI_MSIX_FLAGS_BIRMASK);
+        table_offset &= ~PCI_MSIX_FLAGS_BIRMASK;
+        phys_addr = pci_resource_start (dev, bir) + table_offset;
         base = ioremap_nocache(phys_addr, nr_entries * PCI_MSIX_ENTRY_SIZE);
         if (base == NULL)
                 return -ENOMEM;
@@ -620,7 +624,8 @@ static int msix_capability_init(struct pci_dev *dev,
                 entry = alloc_msi_entry();
                 if (!entry)
                         break;
-                if ((vector = get_msi_vector(dev)) < 0)
+                vector = get_msi_vector(dev);
+                if (vector < 0)
                         break;
 
                 j = entries[i].entry;
@@ -699,12 +704,17 @@ int pci_enable_msi(struct pci_dev* dev)
         if (dev->no_msi)
                 return status;
 
+        if (dev->bus->bus_flags & PCI_BUS_FLAGS_NO_MSI)
+                return -EINVAL;
+
         temp = dev->irq;
 
-        if ((status = msi_init()) < 0)
+        status = msi_init();
+        if (status < 0)
                 return status;
 
-        if (!(pos = pci_find_capability(dev, PCI_CAP_ID_MSI)))
+        pos = pci_find_capability(dev, PCI_CAP_ID_MSI);
+        if (!pos)
                 return -EINVAL;
 
         pci_read_config_word(dev, msi_control_reg(pos), &control);
@@ -728,8 +738,8 @@ int pci_enable_msi(struct pci_dev* dev)
                 dev->irq = temp;
         }
         /* Check whether driver already requested for MSI-X vectors */
-        if ((pos = pci_find_capability(dev, PCI_CAP_ID_MSIX)) > 0 &&
-                !msi_lookup_vector(dev, PCI_CAP_ID_MSIX)) {
+        pos = pci_find_capability(dev, PCI_CAP_ID_MSIX);
+        if (pos > 0 && !msi_lookup_vector(dev, PCI_CAP_ID_MSIX)) {
                         printk(KERN_INFO "PCI: %s: Can't enable MSI.  "
                                "Device already has MSI-X vectors assigned\n",
                                pci_name(dev));
@@ -755,7 +765,13 @@ void pci_disable_msi(struct pci_dev* dev)
         u16 control;
         unsigned long flags;
 
-        if (!dev || !(pos = pci_find_capability(dev, PCI_CAP_ID_MSI)))
+        if (!pci_msi_enable)
+                return;
+        if (!dev)
+                return;
+
+        pos = pci_find_capability(dev, PCI_CAP_ID_MSI);
+        if (!pos)
                 return;
 
         pci_read_config_word(dev, msi_control_reg(pos), &control);
@@ -826,8 +842,10 @@ static int msi_free_vector(struct pci_dev* dev, int vector, int reassign)
                          * Detect last MSI-X vector to be released.
                          * Release the MSI-X memory-mapped table.
                          */
+#if 0
                         int pos, nr_entries;
-                        u32 phys_addr, table_offset;
+                        unsigned long phys_addr;
+                        u32 table_offset;
                         u16 control;
                         u8 bir;
 
@@ -838,9 +856,12 @@ static int msi_free_vector(struct pci_dev* dev, int vector, int reassign)
                         pci_read_config_dword(dev, msix_table_offset_reg(pos),
                                 &table_offset);
                         bir = (u8)(table_offset & PCI_MSIX_FLAGS_BIRMASK);
-                        phys_addr = pci_resource_start (dev, bir);
-                        phys_addr += (u32)(table_offset &
-                                ~PCI_MSIX_FLAGS_BIRMASK);
+                        table_offset &= ~PCI_MSIX_FLAGS_BIRMASK;
+                        phys_addr = pci_resource_start(dev, bir) + table_offset;
+/*
+ * FIXME!  and what did you want to do with phys_addr?
+ */
+#endif
                         iounmap(base);
                 }
         }
@@ -924,10 +945,12 @@ int pci_enable_msix(struct pci_dev* dev, struct msix_entry *entries, int nvec)
         if (!pci_msi_enable || !dev || !entries)
                 return -EINVAL;
 
-        if ((status = msi_init()) < 0)
+        status = msi_init();
+        if (status < 0)
                 return status;
 
-        if (!(pos = pci_find_capability(dev, PCI_CAP_ID_MSIX)))
+        pos = pci_find_capability(dev, PCI_CAP_ID_MSIX);
+        if (!pos)
                 return -EINVAL;
 
         pci_read_config_word(dev, msi_control_reg(pos), &control);
@@ -1006,7 +1029,13 @@ void pci_disable_msix(struct pci_dev* dev)
         int pos, temp;
         u16 control;
 
-        if (!dev || !(pos = pci_find_capability(dev, PCI_CAP_ID_MSIX)))
+        if (!pci_msi_enable)
+                return;
+        if (!dev)
+                return;
+
+        pos = pci_find_capability(dev, PCI_CAP_ID_MSIX);
+        if (!pos)
                 return;
 
         pci_read_config_word(dev, msi_control_reg(pos), &control);
@@ -1066,8 +1095,8 @@ void msi_remove_pci_irq_vectors(struct pci_dev* dev)
                 return;
 
         temp = dev->irq;                /* Save IOAPIC IRQ */
-        if ((pos = pci_find_capability(dev, PCI_CAP_ID_MSI)) > 0 &&
-                !msi_lookup_vector(dev, PCI_CAP_ID_MSI)) {
+        pos = pci_find_capability(dev, PCI_CAP_ID_MSI);
+        if (pos > 0 && !msi_lookup_vector(dev, PCI_CAP_ID_MSI)) {
                 spin_lock_irqsave(&msi_lock, flags);
                 state = msi_desc[dev->irq]->msi_attrib.state;
                 spin_unlock_irqrestore(&msi_lock, flags);
@@ -1080,8 +1109,8 @@ void msi_remove_pci_irq_vectors(struct pci_dev* dev)
                         msi_free_vector(dev, dev->irq, 0);
                 dev->irq = temp;                /* Restore IOAPIC IRQ */
         }
-        if ((pos = pci_find_capability(dev, PCI_CAP_ID_MSIX)) > 0 &&
-                !msi_lookup_vector(dev, PCI_CAP_ID_MSIX)) {
+        pos = pci_find_capability(dev, PCI_CAP_ID_MSIX);
+        if (pos > 0 && !msi_lookup_vector(dev, PCI_CAP_ID_MSIX)) {
                 int vector, head, tail = 0, warning = 0;
                 void __iomem *base = NULL;
 
@@ -1101,7 +1130,9 @@ void msi_remove_pci_irq_vectors(struct pci_dev* dev)
                 msi_free_vector(dev, vector, 0);
                 if (warning) {
                         /* Force to release the MSI-X memory-mapped table */
-                        u32 phys_addr, table_offset;
+#if 0
+                        unsigned long phys_addr;
+                        u32 table_offset;
                         u16 control;
                         u8 bir;
 
@@ -1110,9 +1141,12 @@ void msi_remove_pci_irq_vectors(struct pci_dev* dev)
                         pci_read_config_dword(dev, msix_table_offset_reg(pos),
                                 &table_offset);
                         bir = (u8)(table_offset & PCI_MSIX_FLAGS_BIRMASK);
-                        phys_addr = pci_resource_start (dev, bir);
-                        phys_addr += (u32)(table_offset &
-                                ~PCI_MSIX_FLAGS_BIRMASK);
+                        table_offset &= ~PCI_MSIX_FLAGS_BIRMASK;
+                        phys_addr = pci_resource_start(dev, bir) + table_offset;
+/*
+ * FIXME! and what did you want to do with phys_addr?
+ */
+#endif
                         iounmap(base);
                         printk(KERN_WARNING "PCI: %s: msi_remove_pci_irq_vectors() "
                                "called without free_irq() on all MSI-X vectors\n",
@@ -1123,6 +1157,11 @@ void msi_remove_pci_irq_vectors(struct pci_dev* dev)
         }
 }
 
+void pci_no_msi(void)
+{
+        pci_msi_enable = 0;
+}
+
 EXPORT_SYMBOL(pci_enable_msi);
 EXPORT_SYMBOL(pci_disable_msi);
 EXPORT_SYMBOL(pci_enable_msix);
diff --git a/drivers/pci/pci-driver.c b/drivers/pci/pci-driver.c
index 0aa14c92b5..f22f69ac64 100644
--- a/drivers/pci/pci-driver.c
+++ b/drivers/pci/pci-driver.c
@@ -53,11 +53,10 @@ store_new_id(struct device_driver *driver, const char *buf, size_t count)
         if (fields < 0)
                 return -EINVAL;
 
-        dynid = kmalloc(sizeof(*dynid), GFP_KERNEL);
+        dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
         if (!dynid)
                 return -ENOMEM;
 
-        memset(dynid, 0, sizeof(*dynid));
         INIT_LIST_HEAD(&dynid->node);
         dynid->id.vendor = vendor;
         dynid->id.device = device;
@@ -380,14 +379,6 @@ int __pci_register_driver(struct pci_driver *drv, struct module *owner)
         /* initialize common driver fields */
         drv->driver.name = drv->name;
         drv->driver.bus = &pci_bus_type;
-        /* FIXME, once all of the existing PCI drivers have been fixed to set
-         * the pci shutdown function, this test can go away. */
-        if (!drv->driver.shutdown)
-                drv->driver.shutdown = pci_device_shutdown;
-        else
-                printk(KERN_WARNING "Warning: PCI driver %s has a struct "
-                        "device_driver shutdown method, please update!\n",
-                        drv->name);
         drv->driver.owner = owner;
         drv->driver.kobj.ktype = &pci_driver_kobj_type;
 
@@ -514,6 +505,7 @@ struct bus_type pci_bus_type = {
         .probe          = pci_device_probe,
         .remove         = pci_device_remove,
         .suspend        = pci_device_suspend,
+        .shutdown       = pci_device_shutdown,
         .resume         = pci_device_resume,
         .dev_attrs      = pci_dev_attrs,
 };
diff --git a/drivers/pci/pci-sysfs.c b/drivers/pci/pci-sysfs.c
index 965a593462..56ac2bc003 100644
--- a/drivers/pci/pci-sysfs.c
+++ b/drivers/pci/pci-sysfs.c
@@ -501,9 +501,8 @@ int pci_create_sysfs_dev_files (struct pci_dev *pdev)
         if (pci_resource_len(pdev, PCI_ROM_RESOURCE)) {
                 struct bin_attribute *rom_attr;
                 
-                rom_attr = kmalloc(sizeof(*rom_attr), GFP_ATOMIC);
+                rom_attr = kzalloc(sizeof(*rom_attr), GFP_ATOMIC);
                 if (rom_attr) {
-                        memset(rom_attr, 0x00, sizeof(*rom_attr));
                         pdev->rom_attr = rom_attr;
                         rom_attr->size = pci_resource_len(pdev, PCI_ROM_RESOURCE);
                         rom_attr->attr.name = "rom";
diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
index d2d1879166..bea1ad1ad5 100644
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
@@ -19,7 +19,6 @@
 #include <asm/dma.h>    /* isa_dma_bridge_buggy */
 #include "pci.h"
 
-#if 0
 
 /**
  * pci_bus_max_busnr - returns maximum PCI bus number of given bus' children
@@ -34,7 +33,7 @@ pci_bus_max_busnr(struct pci_bus* bus)
         struct list_head *tmp;
         unsigned char max, n;
 
-        max = bus->number;
+        max = bus->subordinate;
         list_for_each(tmp, &bus->children) {
                 n = pci_bus_max_busnr(pci_bus_b(tmp));
                 if(n > max)
@@ -42,7 +41,9 @@ pci_bus_max_busnr(struct pci_bus* bus)
         }
         return max;
 }
+EXPORT_SYMBOL_GPL(pci_bus_max_busnr);
 
+#if 0
 /**
  * pci_max_busnr - returns maximum PCI bus number
  *
@@ -495,9 +496,8 @@ pci_enable_device_bars(struct pci_dev *dev, int bars)
 int
 pci_enable_device(struct pci_dev *dev)
 {
-        int err;
-
-        if ((err = pci_enable_device_bars(dev, (1 << PCI_NUM_RESOURCES) - 1)))
+        int err = pci_enable_device_bars(dev, (1 << PCI_NUM_RESOURCES) - 1);
+        if (err)
                 return err;
         pci_fixup_device(pci_fixup_enable, dev);
         dev->is_enabled = 1;
@@ -639,7 +639,7 @@ void pci_release_region(struct pci_dev *pdev, int bar)
  *      Returns 0 on success, or %EBUSY on error.  A warning
  *      message is also printed on failure.
  */
-int pci_request_region(struct pci_dev *pdev, int bar, char *res_name)
+int pci_request_region(struct pci_dev *pdev, int bar, const char *res_name)
 {
         if (pci_resource_len(pdev, bar) == 0)
                 return 0;
@@ -697,7 +697,7 @@ void pci_release_regions(struct pci_dev *pdev)
  *      Returns 0 on success, or %EBUSY on error.  A warning
  *      message is also printed on failure.
  */
-int pci_request_regions(struct pci_dev *pdev, char *res_name)
+int pci_request_regions(struct pci_dev *pdev, const char *res_name)
 {
         int i;
         
@@ -900,8 +900,12 @@ static int __devinit pci_setup(char *str)
                 if (k)
                         *k++ = 0;
                 if (*str && (str = pcibios_setup(str)) && *str) {
-                        /* PCI layer options should be handled here */
-                        printk(KERN_ERR "PCI: Unknown option `%s'\n", str);
+                        if (!strcmp(str, "nomsi")) {
+                                pci_no_msi();
+                        } else {
+                                printk(KERN_ERR "PCI: Unknown option `%s'\n",
+                                                str);
+                        }
                 }
                 str = k;
         }
diff --git a/drivers/pci/pci.h b/drivers/pci/pci.h
index a6dfee2f6d..8f3fb47ea6 100644
--- a/drivers/pci/pci.h
+++ b/drivers/pci/pci.h
@@ -50,8 +50,10 @@ extern int pci_msi_quirk;
 
 #ifdef CONFIG_PCI_MSI
 void disable_msi_mode(struct pci_dev *dev, int pos, int type);
+void pci_no_msi(void);
 #else
 static inline void disable_msi_mode(struct pci_dev *dev, int pos, int type) { }
+static inline void pci_no_msi(void) { }
 #endif
 
 extern int pcie_mch_quirk;
diff --git a/drivers/pci/pcie/portdrv.h b/drivers/pci/pcie/portdrv.h
index a63bd8f726..1d317d22ee 100644
--- a/drivers/pci/pcie/portdrv.h
+++ b/drivers/pci/pcie/portdrv.h
@@ -29,7 +29,6 @@
 
 struct pcie_port_device_ext {
         int interrupt_mode;     /* [0:INTx | 1:MSI | 2:MSI-X] */
-        unsigned int saved_msi_config_space[5];
 };
 
 extern struct bus_type pcie_port_bus_type;
diff --git a/drivers/pci/pcie/portdrv_core.c b/drivers/pci/pcie/portdrv_core.c
index e4e5f1e8d8..55c6622678 100644
--- a/drivers/pci/pcie/portdrv_core.c
+++ b/drivers/pci/pcie/portdrv_core.c
@@ -248,11 +248,10 @@ static struct pcie_device* alloc_pcie_device(struct pci_dev *parent,
 {
         struct pcie_device *device;
 
-        device = kmalloc(sizeof(struct pcie_device), GFP_KERNEL);
+        device = kzalloc(sizeof(struct pcie_device), GFP_KERNEL);
         if (!device)
                 return NULL;
 
-        memset(device, 0, sizeof(struct pcie_device));
         pcie_device_init(parent, device, port_type, service_type, irq,irq_mode);
         printk(KERN_DEBUG "Allocate Port Service[%s]\n", device->device.bus_id);
         return device;
diff --git a/drivers/pci/pcie/portdrv_pci.c b/drivers/pci/pcie/portdrv_pci.c
index 02260141dc..50bfc1b2f3 100644
--- a/drivers/pci/pcie/portdrv_pci.c
+++ b/drivers/pci/pcie/portdrv_pci.c
@@ -30,75 +30,16 @@ MODULE_LICENSE("GPL");
 /* global data */
 static const char device_name[] = "pcieport-driver";
 
-static void pci_save_msi_state(struct pci_dev *dev)
+static int pcie_portdrv_save_config(struct pci_dev *dev)
 {
-        struct pcie_port_device_ext *p_ext = pci_get_drvdata(dev);
-        int i = 0, pos;
-        u16 control;
-
-        if ((pos = pci_find_capability(dev, PCI_CAP_ID_MSI)) <= 0)
-                return;
-
-        pci_read_config_dword(dev, pos, &p_ext->saved_msi_config_space[i++]);
-        control = p_ext->saved_msi_config_space[0] >> 16;
-        pci_read_config_dword(dev, pos + PCI_MSI_ADDRESS_LO,
-                &p_ext->saved_msi_config_space[i++]);
-        if (control & PCI_MSI_FLAGS_64BIT) {
-                pci_read_config_dword(dev, pos + PCI_MSI_ADDRESS_HI,
-                        &p_ext->saved_msi_config_space[i++]);
-                pci_read_config_dword(dev, pos + PCI_MSI_DATA_64,
-                        &p_ext->saved_msi_config_space[i++]);
-        } else
-                pci_read_config_dword(dev, pos + PCI_MSI_DATA_32,
-                        &p_ext->saved_msi_config_space[i++]);
-        if (control & PCI_MSI_FLAGS_MASKBIT)
-                pci_read_config_dword(dev, pos + PCI_MSI_MASK_BIT,
-                        &p_ext->saved_msi_config_space[i++]);
-}
-
-static void pci_restore_msi_state(struct pci_dev *dev)
-{
-        struct pcie_port_device_ext *p_ext = pci_get_drvdata(dev);
-        int i = 0, pos;
-        u16 control;
-
-        if ((pos = pci_find_capability(dev, PCI_CAP_ID_MSI)) <= 0)
-                return;
-
-        control = p_ext->saved_msi_config_space[i++] >> 16;
-        pci_write_config_word(dev, pos + PCI_MSI_FLAGS, control);
-        pci_write_config_dword(dev, pos + PCI_MSI_ADDRESS_LO,
-                p_ext->saved_msi_config_space[i++]);
-        if (control & PCI_MSI_FLAGS_64BIT) {
-                pci_write_config_dword(dev, pos + PCI_MSI_ADDRESS_HI,
-                        p_ext->saved_msi_config_space[i++]);
-                pci_write_config_dword(dev, pos + PCI_MSI_DATA_64,
-                        p_ext->saved_msi_config_space[i++]);
-        } else
-                pci_write_config_dword(dev, pos + PCI_MSI_DATA_32,
-                        p_ext->saved_msi_config_space[i++]);
-        if (control & PCI_MSI_FLAGS_MASKBIT)
-                pci_write_config_dword(dev, pos + PCI_MSI_MASK_BIT,
-                        p_ext->saved_msi_config_space[i++]);
-}
-
-static void pcie_portdrv_save_config(struct pci_dev *dev)
-{
-        struct pcie_port_device_ext *p_ext = pci_get_drvdata(dev);
-
-        pci_save_state(dev);
-        if (p_ext->interrupt_mode == PCIE_PORT_MSI_MODE)
-                pci_save_msi_state(dev);
+        return pci_save_state(dev);
 }
 
 static int pcie_portdrv_restore_config(struct pci_dev *dev)
 {
-        struct pcie_port_device_ext *p_ext = pci_get_drvdata(dev);
         int retval;
 
         pci_restore_state(dev);
-        if (p_ext->interrupt_mode == PCIE_PORT_MSI_MODE)
-                pci_restore_msi_state(dev);
         retval = pci_enable_device(dev);
         if (retval)
                 return retval;
@@ -149,7 +90,8 @@ static int pcie_portdrv_suspend (struct pci_dev *dev, pm_message_t state)
 {
         int ret = pcie_port_device_suspend(dev, state);
 
-        pcie_portdrv_save_config(dev);
+        if (!ret)
+                ret = pcie_portdrv_save_config(dev);
         return ret;
 }
 
diff --git a/drivers/pci/probe.c b/drivers/pci/probe.c
index adfad4fd6a..a10ed9dab2 100644
--- a/drivers/pci/probe.c
+++ b/drivers/pci/probe.c
@@ -33,10 +33,9 @@ LIST_HEAD(pci_devices);
  */
 static void pci_create_legacy_files(struct pci_bus *b)
 {
-        b->legacy_io = kmalloc(sizeof(struct bin_attribute) * 2,
+        b->legacy_io = kzalloc(sizeof(struct bin_attribute) * 2,
                                GFP_ATOMIC);
         if (b->legacy_io) {
-                memset(b->legacy_io, 0, sizeof(struct bin_attribute) * 2);
                 b->legacy_io->attr.name = "legacy_io";
                 b->legacy_io->size = 0xffff;
                 b->legacy_io->attr.mode = S_IRUSR | S_IWUSR;
@@ -320,9 +319,8 @@ static struct pci_bus * __devinit pci_alloc_bus(void)
 {
         struct pci_bus *b;
 
-        b = kmalloc(sizeof(*b), GFP_KERNEL);
+        b = kzalloc(sizeof(*b), GFP_KERNEL);
         if (b) {
-                memset(b, 0, sizeof(*b));
                 INIT_LIST_HEAD(&b->node);
                 INIT_LIST_HEAD(&b->children);
                 INIT_LIST_HEAD(&b->devices);
@@ -347,6 +345,7 @@ pci_alloc_child_bus(struct pci_bus *parent, struct pci_dev *bridge, int busnr)
         child->parent = parent;
         child->ops = parent->ops;
         child->sysdata = parent->sysdata;
+        child->bus_flags = parent->bus_flags;
         child->bridge = get_device(&bridge->dev);
 
         child->class_dev.class = &pcibus_class;
@@ -456,7 +455,7 @@ int __devinit pci_scan_bridge(struct pci_bus *bus, struct pci_dev * dev, int max
                  * pass and just note the configuration.
                  */
                 if (pass)
-                        return max;
+                        goto out;
                 busnr = (buses >> 8) & 0xFF;
 
                 /*
@@ -466,12 +465,12 @@ int __devinit pci_scan_bridge(struct pci_bus *bus, struct pci_dev * dev, int max
                 if (pci_find_bus(pci_domain_nr(bus), busnr)) {
                         printk(KERN_INFO "PCI: Bus %04x:%02x already known\n",
                                         pci_domain_nr(bus), busnr);
-                        return max;
+                        goto out;
                 }
 
                 child = pci_add_new_bus(bus, dev, busnr);
                 if (!child)
-                        return max;
+                        goto out;
                 child->primary = buses & 0xFF;
                 child->subordinate = (buses >> 16) & 0xFF;
                 child->bridge_ctl = bctl;
@@ -496,7 +495,7 @@ int __devinit pci_scan_bridge(struct pci_bus *bus, struct pci_dev * dev, int max
                                    bus ranges. */
                                 pci_write_config_dword(dev, PCI_PRIMARY_BUS,
                                                        buses & ~0xffffff);
-                        return max;
+                        goto out;
                 }
 
                 /* Clear errors */
@@ -505,7 +504,7 @@ int __devinit pci_scan_bridge(struct pci_bus *bus, struct pci_dev * dev, int max
                 /* Prevent assigning a bus number that already exists.
                  * This can happen when a bridge is hot-plugged */
                 if (pci_find_bus(pci_domain_nr(bus), max+1))
-                        return max;
+                        goto out;
                 child = pci_add_new_bus(bus, dev, ++max);
                 buses = (buses & 0xff000000)
                       | ((unsigned int)(child->primary)     <<  0)
@@ -537,6 +536,11 @@ int __devinit pci_scan_bridge(struct pci_bus *bus, struct pci_dev * dev, int max
                         pci_fixup_parent_subordinate_busnr(child, max);
                         /* Now we can scan all subordinate buses... */
                         max = pci_scan_child_bus(child);
+                        /*
+                         * now fix it up again since we have found
+                         * the real value of max.
+                         */
+                        pci_fixup_parent_subordinate_busnr(child, max);
                 } else {
                         /*
                          * For CardBus bridges, we leave 4 bus numbers
@@ -576,8 +580,6 @@ int __devinit pci_scan_bridge(struct pci_bus *bus, struct pci_dev * dev, int max
                 pci_write_config_byte(dev, PCI_SUBORDINATE_BUS, max);
         }
 
-        pci_write_config_word(dev, PCI_BRIDGE_CONTROL, bctl);
-
         sprintf(child->name, (is_cardbus ? "PCI CardBus #%02x" : "PCI Bus #%02x"), child->number);
 
         while (bus->parent) {
@@ -585,17 +587,22 @@ int __devinit pci_scan_bridge(struct pci_bus *bus, struct pci_dev * dev, int max
                     (child->number > bus->subordinate) ||
                     (child->number < bus->number) ||
                     (child->subordinate < bus->number)) {
-                        printk(KERN_WARNING "PCI: Bus #%02x (-#%02x) may be "
+                        printk(KERN_WARNING "PCI: Bus #%02x (-#%02x) is "
                                "hidden behind%s bridge #%02x (-#%02x)%s\n",
                                child->number, child->subordinate,
                                bus->self->transparent ? " transparent" : " ",
                                bus->number, bus->subordinate,
                                pcibios_assign_all_busses() ? " " :
                                " (try 'pci=assign-busses')");
+                        printk(KERN_WARNING "Please report the result to "
+                               "linux-kernel to fix this permanently\n");
                 }
                 bus = bus->parent;
         }
 
+out:
+        pci_write_config_word(dev, PCI_BRIDGE_CONTROL, bctl);
+
         return max;
 }
 
@@ -788,11 +795,10 @@ pci_scan_device(struct pci_bus *bus, int devfn)
         if (pci_bus_read_config_byte(bus, devfn, PCI_HEADER_TYPE, &hdr_type))
                 return NULL;
 
-        dev = kmalloc(sizeof(struct pci_dev), GFP_KERNEL);
+        dev = kzalloc(sizeof(struct pci_dev), GFP_KERNEL);
         if (!dev)
                 return NULL;
 
-        memset(dev, 0, sizeof(struct pci_dev));
         dev->bus = bus;
         dev->sysdata = bus->sysdata;
         dev->dev.parent = bus->bridge;
diff --git a/drivers/pci/proc.c b/drivers/pci/proc.c
index 92a8857608..54b2ebc9c9 100644
--- a/drivers/pci/proc.c
+++ b/drivers/pci/proc.c
@@ -458,131 +458,6 @@ int pci_proc_detach_bus(struct pci_bus* bus)
         return 0;
 }
 
-#ifdef CONFIG_PCI_LEGACY_PROC
-
-/*
- *  Backward compatible /proc/pci interface.
- */
-
-/*
- * Convert some of the configuration space registers of the device at
- * address (bus,devfn) into a string (possibly several lines each).
- * The configuration string is stored starting at buf[len].  If the
- * string would exceed the size of the buffer (SIZE), 0 is returned.
- */
-static int show_dev_config(struct seq_file *m, void *v)
-{
-        struct pci_dev *dev = v;
-        struct pci_dev *first_dev;
-        struct pci_driver *drv;
-        u32 class_rev;
-        unsigned char latency, min_gnt, max_lat;
-        int reg;
-
-        first_dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, NULL);
-        if (dev == first_dev)
-                seq_puts(m, "PCI devices found:\n");
-        pci_dev_put(first_dev);
-
-        drv = pci_dev_driver(dev);
-
-        pci_user_read_config_dword(dev, PCI_CLASS_REVISION, &class_rev);
-        pci_user_read_config_byte (dev, PCI_LATENCY_TIMER, &latency);
-        pci_user_read_config_byte (dev, PCI_MIN_GNT, &min_gnt);
-        pci_user_read_config_byte (dev, PCI_MAX_LAT, &max_lat);
-        seq_printf(m, "  Bus %2d, device %3d, function %2d:\n",
-               dev->bus->number, PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn));
-        seq_printf(m, "    Class %04x", class_rev >> 16);
-        seq_printf(m, ": PCI device %04x:%04x", dev->vendor, dev->device);
-        seq_printf(m, " (rev %d).\n", class_rev & 0xff);
-
-        if (dev->irq)
-                seq_printf(m, "      IRQ %d.\n", dev->irq);
-
-        if (latency || min_gnt || max_lat) {
-                seq_printf(m, "      Master Capable.  ");
-                if (latency)
-                        seq_printf(m, "Latency=%d.  ", latency);
-                else
-                        seq_puts(m, "No bursts.  ");
-                if (min_gnt)
-                        seq_printf(m, "Min Gnt=%d.", min_gnt);
-                if (max_lat)
-                        seq_printf(m, "Max Lat=%d.", max_lat);
-                seq_putc(m, '\n');
-        }
-
-        for (reg = 0; reg < 6; reg++) {
-                struct resource *res = dev->resource + reg;
-                unsigned long base, end, flags;
-
-                base = res->start;
-                end = res->end;
-                flags = res->flags;
-                if (!end)
-                        continue;
-
-                if (flags & PCI_BASE_ADDRESS_SPACE_IO) {
-                        seq_printf(m, "      I/O at 0x%lx [0x%lx].\n",
-                                base, end);
-                } else {
-                        const char *pref, *type = "unknown";
-
-                        if (flags & PCI_BASE_ADDRESS_MEM_PREFETCH)
-                                pref = "P";
-                        else
-                                pref = "Non-p";
-                        switch (flags & PCI_BASE_ADDRESS_MEM_TYPE_MASK) {
-                              case PCI_BASE_ADDRESS_MEM_TYPE_32:
-                                type = "32 bit"; break;
-                              case PCI_BASE_ADDRESS_MEM_TYPE_1M:
-                                type = "20 bit"; break;
-                              case PCI_BASE_ADDRESS_MEM_TYPE_64:
-                                type = "64 bit"; break;
-                        }
-                        seq_printf(m, "      %srefetchable %s memory at "
-                                       "0x%lx [0x%lx].\n", pref, type,
-                                       base,
-                                       end);
-                }
-        }
-        return 0;
-}
-
-static struct seq_operations proc_pci_op = {
-        .start  = pci_seq_start,
-        .next   = pci_seq_next,
-        .stop   = pci_seq_stop,
-        .show   = show_dev_config
-};
-
-static int proc_pci_open(struct inode *inode, struct file *file)
-{
-        return seq_open(file, &proc_pci_op);
-}
-static struct file_operations proc_pci_operations = {
-        .open           = proc_pci_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = seq_release,
-};
-
-static void legacy_proc_init(void)
-{
-        struct proc_dir_entry * entry = create_proc_entry("pci", 0, NULL);
-        if (entry)
-                entry->proc_fops = &proc_pci_operations;
-}
-
-#else
-
-static void legacy_proc_init(void)
-{
-
-}
-
-#endif /* CONFIG_PCI_LEGACY_PROC */
-
 static int proc_bus_pci_dev_open(struct inode *inode, struct file *file)
 {
         return seq_open(file, &proc_bus_pci_devices_op);
@@ -606,7 +481,6 @@ static int __init pci_proc_init(void)
         while ((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
                 pci_proc_attach_device(dev);
         }
-        legacy_proc_init();
         return 0;
 }
 
diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c
index dda6099903..4970f47be7 100644
--- a/drivers/pci/quirks.c
+++ b/drivers/pci/quirks.c
@@ -575,8 +575,11 @@ static void __init quirk_amd_8131_ioapic(struct pci_dev *dev)
 { 
         unsigned char revid, tmp;
         
-        pci_msi_quirk = 1;
-        printk(KERN_WARNING "PCI: MSI quirk detected. pci_msi_quirk set.\n");
+        if (dev->subordinate) {
+                printk(KERN_WARNING "PCI: MSI quirk detected. "
+                       "PCI_BUS_FLAGS_NO_MSI set for subordinate bus.\n");
+                dev->subordinate->bus_flags |= PCI_BUS_FLAGS_NO_MSI;
+        }
 
         if (nr_ioapics == 0) 
                 return;
@@ -934,6 +937,12 @@ static void __init asus_hides_smbus_hostbridge(struct pci_dev *dev)
                         case 0x12bd: /* HP D530 */
                                 asus_hides_smbus = 1;
                         }
+                if (dev->device == PCI_DEVICE_ID_INTEL_82915GM_HB) {
+                        switch (dev->subsystem_device) {
+                        case 0x099c: /* HP Compaq nx6110 */
+                                asus_hides_smbus = 1;
+                        }
+                }
         } else if (unlikely(dev->subsystem_vendor == PCI_VENDOR_ID_TOSHIBA)) {
                 if (dev->device == PCI_DEVICE_ID_INTEL_82855GM_HB)
                         switch(dev->subsystem_device) {
@@ -1068,6 +1077,37 @@ DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_SI,	PCI_DEVICE_ID_SI_651,		quirk_sis_96x_
 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_SI,      PCI_DEVICE_ID_SI_735,           quirk_sis_96x_compatible );
 
 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_SI,      PCI_DEVICE_ID_SI_503,           quirk_sis_503 );
+/*
+ * On ASUS A8V and A8V Deluxe boards, the onboard AC97 audio controller
+ * and MC97 modem controller are disabled when a second PCI soundcard is
+ * present. This patch, tweaking the VT8237 ISA bridge, enables them.
+ * -- bjd
+ */
+static void __init asus_hides_ac97_lpc(struct pci_dev *dev)
+{
+        u8 val;
+        int asus_hides_ac97 = 0;
+
+        if (likely(dev->subsystem_vendor == PCI_VENDOR_ID_ASUSTEK)) {
+                if (dev->device == PCI_DEVICE_ID_VIA_8237)
+                        asus_hides_ac97 = 1;
+        }
+
+        if (!asus_hides_ac97)
+                return;
+
+        pci_read_config_byte(dev, 0x50, &val);
+        if (val & 0xc0) {
+                pci_write_config_byte(dev, 0x50, val & (~0xc0));
+                pci_read_config_byte(dev, 0x50, &val);
+                if (val & 0xc0)
+                        printk(KERN_INFO "PCI: onboard AC97/MC97 devices continue to play 'hide and seek'! 0x%x\n", val);
+                else
+                        printk(KERN_INFO "PCI: enabled onboard AC97/MC97 devices\n");
+        }
+}
+DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_VIA,     PCI_DEVICE_ID_VIA_8237, asus_hides_ac97_lpc );
+
 
 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_SI,      PCI_DEVICE_ID_SI_961,           quirk_sis_96x_smbus );
 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_SI,      PCI_DEVICE_ID_SI_962,           quirk_sis_96x_smbus );
@@ -1242,6 +1282,33 @@ DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_INTEL,	PCI_DEVICE_ID_INTEL_PXH_1,	quirk_pc
 DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_INTEL,    PCI_DEVICE_ID_INTEL_PXHV,       quirk_pcie_pxh);
 
 
+/*
+ * Fixup the cardbus bridges on the IBM Dock II docking station
+ */
+static void __devinit quirk_ibm_dock2_cardbus(struct pci_dev *dev)
+{
+        u32 val;
+
+        /*
+         * tie the 2 interrupt pins to INTA, and configure the
+         * multifunction routing register to handle this.
+         */
+        if ((dev->subsystem_vendor == PCI_VENDOR_ID_IBM) &&
+                (dev->subsystem_device == 0x0148)) {
+                printk(KERN_INFO "PCI: Found IBM Dock II Cardbus Bridge "
+                        "applying quirk\n");
+                pci_read_config_dword(dev, 0x8c, &val);
+                val = ((val & 0xffffff00) | 0x1002);
+                pci_write_config_dword(dev, 0x8c, val);
+                pci_read_config_dword(dev, 0x80, &val);
+                val = ((val & 0x00ffff00) | 0x2864c077);
+                pci_write_config_dword(dev, 0x80, val);
+        }
+}
+
+DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1420,
+                                quirk_ibm_dock2_cardbus);
+
 static void __devinit quirk_netmos(struct pci_dev *dev)
 {
         unsigned int num_parallel = (dev->subsystem_device & 0xf0) >> 4;
diff --git a/drivers/pci/search.c b/drivers/pci/search.c
index 05fa91a31c..ce7dd6e7be 100644
--- a/drivers/pci/search.c
+++ b/drivers/pci/search.c
@@ -246,9 +246,9 @@ pci_get_subsys(unsigned int vendor, unsigned int device,
         }
         dev = NULL;
 exit:
-        pci_dev_put(from);
         dev = pci_dev_get(dev);
         spin_unlock(&pci_bus_lock);
+        pci_dev_put(from);
         return dev;
 }
 
@@ -339,9 +339,9 @@ struct pci_dev *pci_get_class(unsigned int class, struct pci_dev *from)
         }
         dev = NULL;
 exit:
-        pci_dev_put(from);
         dev = pci_dev_get(dev);
         spin_unlock(&pci_bus_lock);
+        pci_dev_put(from);
         return dev;
 }
 
diff --git a/drivers/pnp/pnpbios/rsparser.c b/drivers/pnp/pnpbios/rsparser.c
index 5e38cd7335..c89c98a2cc 100644
--- a/drivers/pnp/pnpbios/rsparser.c
+++ b/drivers/pnp/pnpbios/rsparser.c
@@ -448,11 +448,7 @@ pnpbios_parse_resource_option_data(unsigned char * p, unsigned char * end, struc
                         break;
 
                 case SMALL_TAG_END:
-                        if (option_independent != option)
-                                printk(KERN_WARNING "PnPBIOS: Missing SMALL_TAG_ENDDEP tag\n");
-                        p = p + 2;
-                        return (unsigned char *)p;
-                        break;
+                        return p + 2;
 
                 default: /* an unkown tag */
                         len_err:
diff --git a/drivers/s390/Kconfig b/drivers/s390/Kconfig
index 721787cc5a..4d36208ff8 100644
--- a/drivers/s390/Kconfig
+++ b/drivers/s390/Kconfig
@@ -183,7 +183,13 @@ config S390_TAPE_34XX
           tape subsystems and 100% compatibles.
           It is safe to say "Y" here.
 
-
+config S390_TAPE_3590
+        tristate "Support for 3590 tape hardware"
+        depends on S390_TAPE
+        help
+          Select this option if you want to access IBM 3590 magnetic
+          tape subsystems and 100% compatibles.
+          It is safe to say "Y" here.
 
 config VMLOGRDR
         tristate "Support for the z/VM recording system services (VM only)"
diff --git a/drivers/s390/block/Kconfig b/drivers/s390/block/Kconfig
index 6f50cc9323..929d6fff61 100644
--- a/drivers/s390/block/Kconfig
+++ b/drivers/s390/block/Kconfig
@@ -49,20 +49,18 @@ config DASD_FBA
 
 config DASD_DIAG
         tristate "Support for DIAG access to Disks"
-        depends on DASD && ( 64BIT = 'n' || EXPERIMENTAL)
+        depends on DASD
         help
           Select this option if you want to use Diagnose250 command to access
           Disks under VM.  If you are not running under VM or unsure what it is,
           say "N".
 
-config DASD_CMB
-        tristate "Compatibility interface for DASD channel measurement blocks"
+config DASD_EER
+        bool "Extended error reporting (EER)"
         depends on DASD
         help
-          This driver provides an additional interface to the channel measurement
-          facility, which is normally accessed though sysfs, with a set of
-          ioctl functions specific to the dasd driver.
-          This is only needed if you want to use applications written for
-          linux-2.4 dasd channel measurement facility interface.
+          This driver provides a character device interface to the
+          DASD extended error reporting. This is only needed if you want to
+          use applications written for the EER facility.
 
 endif
diff --git a/drivers/s390/block/Makefile b/drivers/s390/block/Makefile
index 58c6780134..be9f22d52f 100644
--- a/drivers/s390/block/Makefile
+++ b/drivers/s390/block/Makefile
@@ -7,11 +7,13 @@ dasd_fba_mod-objs  := dasd_fba.o dasd_3370_erp.o dasd_9336_erp.o
 dasd_diag_mod-objs := dasd_diag.o
 dasd_mod-objs      := dasd.o dasd_ioctl.o dasd_proc.o dasd_devmap.o \
                         dasd_genhd.o dasd_erp.o
+ifdef CONFIG_DASD_EER
+dasd_mod-objs      += dasd_eer.o
+endif
 
 obj-$(CONFIG_DASD) += dasd_mod.o
 obj-$(CONFIG_DASD_DIAG) += dasd_diag_mod.o
 obj-$(CONFIG_DASD_ECKD) += dasd_eckd_mod.o
 obj-$(CONFIG_DASD_FBA)  += dasd_fba_mod.o
-obj-$(CONFIG_DASD_CMB)  += dasd_cmb.o
 obj-$(CONFIG_BLK_DEV_XPRAM) += xpram.o
 obj-$(CONFIG_DCSSBLK) += dcssblk.o
diff --git a/drivers/s390/block/dasd.c b/drivers/s390/block/dasd.c
index 33157c84d1..dfe542b206 100644
--- a/drivers/s390/block/dasd.c
+++ b/drivers/s390/block/dasd.c
@@ -71,10 +71,9 @@ dasd_alloc_device(void)
 {
         struct dasd_device *device;
 
-        device = kmalloc(sizeof (struct dasd_device), GFP_ATOMIC);
+        device = kzalloc(sizeof (struct dasd_device), GFP_ATOMIC);
         if (device == NULL)
                 return ERR_PTR(-ENOMEM);
-        memset(device, 0, sizeof (struct dasd_device));
         /* open_count = 0 means device online but not in use */
         atomic_set(&device->open_count, -1);
 
@@ -151,6 +150,8 @@ dasd_state_new_to_known(struct dasd_device *device)
 static inline void
 dasd_state_known_to_new(struct dasd_device * device)
 {
+        /* Disable extended error reporting for this device. */
+        dasd_eer_disable(device);
         /* Forget the discipline information. */
         if (device->discipline)
                 module_put(device->discipline->owner);
@@ -545,29 +546,26 @@ dasd_kmalloc_request(char *magic, int cplength, int datasize,
              (cplength*sizeof(struct ccw1)) > PAGE_SIZE)
                 BUG();
 
-        cqr = kmalloc(sizeof(struct dasd_ccw_req), GFP_ATOMIC);
+        cqr = kzalloc(sizeof(struct dasd_ccw_req), GFP_ATOMIC);
         if (cqr == NULL)
                 return ERR_PTR(-ENOMEM);
-        memset(cqr, 0, sizeof(struct dasd_ccw_req));
         cqr->cpaddr = NULL;
         if (cplength > 0) {
-                cqr->cpaddr = kmalloc(cplength*sizeof(struct ccw1),
+                cqr->cpaddr = kcalloc(cplength, sizeof(struct ccw1),
                                       GFP_ATOMIC | GFP_DMA);
                 if (cqr->cpaddr == NULL) {
                         kfree(cqr);
                         return ERR_PTR(-ENOMEM);
                 }
-                memset(cqr->cpaddr, 0, cplength*sizeof(struct ccw1));
         }
         cqr->data = NULL;
         if (datasize > 0) {
-                cqr->data = kmalloc(datasize, GFP_ATOMIC | GFP_DMA);
+                cqr->data = kzalloc(datasize, GFP_ATOMIC | GFP_DMA);
                 if (cqr->data == NULL) {
                         kfree(cqr->cpaddr);
                         kfree(cqr);
                         return ERR_PTR(-ENOMEM);
                 }
-                memset(cqr->data, 0, datasize);
         }
         strncpy((char *) &cqr->magic, magic, 4);
         ASCEBC((char *) &cqr->magic, 4);
@@ -892,6 +890,9 @@ dasd_handle_state_change_pending(struct dasd_device *device)
         struct dasd_ccw_req *cqr;
         struct list_head *l, *n;
 
+        /* First of all start sense subsystem status request. */
+        dasd_eer_snss(device);
+
         device->stopped &= ~DASD_STOPPED_PENDING;
 
         /* restart all 'running' IO on queue */
@@ -1111,6 +1112,19 @@ restart:
                         }
                         goto restart;
                 }
+
+                /* First of all call extended error reporting. */
+                if (dasd_eer_enabled(device) &&
+                    cqr->status == DASD_CQR_FAILED) {
+                        dasd_eer_write(device, cqr, DASD_EER_FATALERROR);
+
+                        /* restart request  */
+                        cqr->status = DASD_CQR_QUEUED;
+                        cqr->retries = 255;
+                        device->stopped |= DASD_STOPPED_QUIESCE;
+                        goto restart;
+                }
+
                 /* Process finished ERP request. */
                 if (cqr->refers) {
                         __dasd_process_erp(device, cqr);
@@ -1248,7 +1262,8 @@ __dasd_start_head(struct dasd_device * device)
         cqr = list_entry(device->ccw_queue.next, struct dasd_ccw_req, list);
         /* check FAILFAST */
         if (device->stopped & ~DASD_STOPPED_PENDING &&
-            test_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags)) {
+            test_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags) &&
+            (!dasd_eer_enabled(device))) {
                 cqr->status = DASD_CQR_FAILED;
                 dasd_schedule_bh(device);
         }
@@ -1807,7 +1822,7 @@ dasd_exit(void)
 #ifdef CONFIG_PROC_FS
         dasd_proc_exit();
 #endif
-        dasd_ioctl_exit();
+        dasd_eer_exit();
         if (dasd_page_cache != NULL) {
                 kmem_cache_destroy(dasd_page_cache);
                 dasd_page_cache = NULL;
@@ -2004,6 +2019,9 @@ dasd_generic_notify(struct ccw_device *cdev, int event)
         switch (event) {
         case CIO_GONE:
         case CIO_NO_PATH:
+                /* First of all call extended error reporting. */
+                dasd_eer_write(device, NULL, DASD_EER_NOPATH);
+
                 if (device->state < DASD_STATE_BASIC)
                         break;
                 /* Device is active. We want to keep it. */
@@ -2061,6 +2079,7 @@ dasd_generic_auto_online (struct ccw_driver *dasd_discipline_driver)
         put_driver(drv);
 }
 
+
 static int __init
 dasd_init(void)
 {
@@ -2093,7 +2112,7 @@ dasd_init(void)
         rc = dasd_parse();
         if (rc)
                 goto failed;
-        rc = dasd_ioctl_init();
+        rc = dasd_eer_init();
         if (rc)
                 goto failed;
 #ifdef CONFIG_PROC_FS
diff --git a/drivers/s390/block/dasd_3990_erp.c b/drivers/s390/block/dasd_3990_erp.c
index 4ee0f934e3..2ed5156231 100644
--- a/drivers/s390/block/dasd_3990_erp.c
+++ b/drivers/s390/block/dasd_3990_erp.c
@@ -1108,6 +1108,9 @@ dasd_3990_handle_env_data(struct dasd_ccw_req * erp, char *sense)
                 case 0x0B:
                         DEV_MESSAGE(KERN_WARNING, device, "%s",
                                     "FORMAT F - Volume is suspended duplex");
+                        /* call extended error reporting (EER) */
+                        dasd_eer_write(device, erp->refers,
+                                       DASD_EER_PPRCSUSPEND);
                         break;
                 case 0x0C:
                         DEV_MESSAGE(KERN_WARNING, device, "%s",
diff --git a/drivers/s390/block/dasd_cmb.c b/drivers/s390/block/dasd_cmb.c
deleted file mode 100644
index e88f73ee72..0000000000
--- a/drivers/s390/block/dasd_cmb.c
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
- * Linux on zSeries Channel Measurement Facility support
- *  (dasd device driver interface)
- *
- * Copyright 2000,2003 IBM Corporation
- *
- * Author: Arnd Bergmann <arndb@de.ibm.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2, or (at your option)
- * any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-#include <linux/init.h>
-#include <linux/module.h>
-#include <asm/ccwdev.h>
-#include <asm/cmb.h>
-
-#include "dasd_int.h"
-
-static int
-dasd_ioctl_cmf_enable(struct block_device *bdev, int no, long args)
-{
-        struct dasd_device *device;
-
-        device = bdev->bd_disk->private_data;
-        if (!device)
-                return -EINVAL;
-
-        return enable_cmf(device->cdev);
-}
-
-static int
-dasd_ioctl_cmf_disable(struct block_device *bdev, int no, long args)
-{
-        struct dasd_device *device;
-
-        device = bdev->bd_disk->private_data;
-        if (!device)
-                return -EINVAL;
-
-        return disable_cmf(device->cdev);
-}
-
-static int
-dasd_ioctl_readall_cmb(struct block_device *bdev, int no, long args)
-{
-        struct dasd_device *device;
-        struct cmbdata __user *udata;
-        struct cmbdata data;
-        size_t size;
-        int ret;
-
-        device = bdev->bd_disk->private_data;
-        if (!device)
-                return -EINVAL;
-        udata = (void __user *) args;
-        size = _IOC_SIZE(no);
-
-        if (!access_ok(VERIFY_WRITE, udata, size))
-                return -EFAULT;
-        ret = cmf_readall(device->cdev, &data);
-        if (ret)
-                return ret;
-        if (copy_to_user(udata, &data, min(size, sizeof(*udata))))
-                return -EFAULT;
-        return 0;
-}
-
-/* module initialization below here. dasd already provides a mechanism
- * to dynamically register ioctl functions, so we simply use this. */
-static inline int
-ioctl_reg(unsigned int no, dasd_ioctl_fn_t handler)
-{
-        return dasd_ioctl_no_register(THIS_MODULE, no, handler);
-}
-
-static inline void
-ioctl_unreg(unsigned int no, dasd_ioctl_fn_t handler)
-{
-        dasd_ioctl_no_unregister(THIS_MODULE, no, handler);
-}
-
-static void
-dasd_cmf_exit(void)
-{
-        ioctl_unreg(BIODASDCMFENABLE,  dasd_ioctl_cmf_enable);
-        ioctl_unreg(BIODASDCMFDISABLE, dasd_ioctl_cmf_disable);
-        ioctl_unreg(BIODASDREADALLCMB, dasd_ioctl_readall_cmb);
-}
-
-static int __init
-dasd_cmf_init(void)
-{
-        int ret;
-        ret = ioctl_reg (BIODASDCMFENABLE, dasd_ioctl_cmf_enable);
-        if (ret)
-                goto err;
-        ret = ioctl_reg (BIODASDCMFDISABLE, dasd_ioctl_cmf_disable);
-        if (ret)
-                goto err;
-        ret = ioctl_reg (BIODASDREADALLCMB, dasd_ioctl_readall_cmb);
-        if (ret)
-                goto err;
-
-        return 0;
-err:
-        dasd_cmf_exit();
-
-        return ret;
-}
-
-module_init(dasd_cmf_init);
-module_exit(dasd_cmf_exit);
-
-MODULE_AUTHOR("Arnd Bergmann <arndb@de.ibm.com>");
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("channel measurement facility interface for dasd\n"
-                   "Copyright 2003 IBM Corporation\n");
diff --git a/drivers/s390/block/dasd_devmap.c b/drivers/s390/block/dasd_devmap.c
index 1629b27c48..f576f243cd 100644
--- a/drivers/s390/block/dasd_devmap.c
+++ b/drivers/s390/block/dasd_devmap.c
@@ -715,10 +715,51 @@ dasd_discipline_show(struct device *dev, struct device_attribute *attr, char *bu
 
 static DEVICE_ATTR(discipline, 0444, dasd_discipline_show, NULL);
 
+/*
+ * extended error-reporting
+ */
+static ssize_t
+dasd_eer_show(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        struct dasd_devmap *devmap;
+        int eer_flag;
+
+        devmap = dasd_find_busid(dev->bus_id);
+        if (!IS_ERR(devmap) && devmap->device)
+                eer_flag = dasd_eer_enabled(devmap->device);
+        else
+                eer_flag = 0;
+        return snprintf(buf, PAGE_SIZE, eer_flag ? "1\n" : "0\n");
+}
+
+static ssize_t
+dasd_eer_store(struct device *dev, struct device_attribute *attr,
+               const char *buf, size_t count)
+{
+        struct dasd_devmap *devmap;
+        int rc;
+
+        devmap = dasd_devmap_from_cdev(to_ccwdev(dev));
+        if (IS_ERR(devmap))
+                return PTR_ERR(devmap);
+        if (!devmap->device)
+                return count;
+        if (buf[0] == '1') {
+                rc = dasd_eer_enable(devmap->device);
+                if (rc)
+                        return rc;
+        } else
+                dasd_eer_disable(devmap->device);
+        return count;
+}
+
+static DEVICE_ATTR(eer_enabled, 0644, dasd_eer_show, dasd_eer_store);
+
 static struct attribute * dasd_attrs[] = {
         &dev_attr_readonly.attr,
         &dev_attr_discipline.attr,
         &dev_attr_use_diag.attr,
+        &dev_attr_eer_enabled.attr,
         NULL,
 };
 
diff --git a/drivers/s390/block/dasd_eckd.c b/drivers/s390/block/dasd_eckd.c
index 822e2a2655..ee09ef33d0 100644
--- a/drivers/s390/block/dasd_eckd.c
+++ b/drivers/s390/block/dasd_eckd.c
@@ -1227,19 +1227,14 @@ dasd_eckd_fill_info(struct dasd_device * device,
  * (see dasd_eckd_reserve) device.
  */
 static int
-dasd_eckd_release(struct block_device *bdev, int no, long args)
+dasd_eckd_release(struct dasd_device *device)
 {
-        struct dasd_device *device;
         struct dasd_ccw_req *cqr;
         int rc;
 
         if (!capable(CAP_SYS_ADMIN))
                 return -EACCES;
 
-        device = bdev->bd_disk->private_data;
-        if (device == NULL)
-                return -ENODEV;
-
         cqr = dasd_smalloc_request(dasd_eckd_discipline.name,
                                    1, 32, device);
         if (IS_ERR(cqr)) {
@@ -1272,19 +1267,14 @@ dasd_eckd_release(struct block_device *bdev, int no, long args)
  * the interrupt is outstanding for a certain time. 
  */
 static int
-dasd_eckd_reserve(struct block_device *bdev, int no, long args)
+dasd_eckd_reserve(struct dasd_device *device)
 {
-        struct dasd_device *device;
         struct dasd_ccw_req *cqr;
         int rc;
 
         if (!capable(CAP_SYS_ADMIN))
                 return -EACCES;
 
-        device = bdev->bd_disk->private_data;
-        if (device == NULL)
-                return -ENODEV;
-
         cqr = dasd_smalloc_request(dasd_eckd_discipline.name,
                                    1, 32, device);
         if (IS_ERR(cqr)) {
@@ -1316,19 +1306,14 @@ dasd_eckd_reserve(struct block_device *bdev, int no, long args)
  * (unconditional reserve)
  */
 static int
-dasd_eckd_steal_lock(struct block_device *bdev, int no, long args)
+dasd_eckd_steal_lock(struct dasd_device *device)
 {
-        struct dasd_device *device;
         struct dasd_ccw_req *cqr;
         int rc;
 
         if (!capable(CAP_SYS_ADMIN))
                 return -EACCES;
 
-        device = bdev->bd_disk->private_data;
-        if (device == NULL)
-                return -ENODEV;
-
         cqr = dasd_smalloc_request(dasd_eckd_discipline.name,
                                    1, 32, device);
         if (IS_ERR(cqr)) {
@@ -1358,19 +1343,14 @@ dasd_eckd_steal_lock(struct block_device *bdev, int no, long args)
  * Read performance statistics
  */
 static int
-dasd_eckd_performance(struct block_device *bdev, int no, long args)
+dasd_eckd_performance(struct dasd_device *device, void __user *argp)
 {
-        struct dasd_device *device;
         struct dasd_psf_prssd_data *prssdp;
         struct dasd_rssd_perf_stats_t *stats;
         struct dasd_ccw_req *cqr;
         struct ccw1 *ccw;
         int rc;
 
-        device = bdev->bd_disk->private_data;
-        if (device == NULL)
-                return -ENODEV;
-
         cqr = dasd_smalloc_request(dasd_eckd_discipline.name,
                                    1 /* PSF */  + 1 /* RSSD */ ,
                                    (sizeof (struct dasd_psf_prssd_data) +
@@ -1414,8 +1394,9 @@ dasd_eckd_performance(struct block_device *bdev, int no, long args)
                 /* Prepare for Read Subsystem Data */
                 prssdp = (struct dasd_psf_prssd_data *) cqr->data;
                 stats = (struct dasd_rssd_perf_stats_t *) (prssdp + 1);
-                rc = copy_to_user((long __user *) args, (long *) stats,
-                                  sizeof(struct dasd_rssd_perf_stats_t));
+                if (copy_to_user(argp, stats,
+                                 sizeof(struct dasd_rssd_perf_stats_t)))
+                        rc = -EFAULT;
         }
         dasd_sfree_request(cqr, cqr->device);
         return rc;
@@ -1426,27 +1407,22 @@ dasd_eckd_performance(struct block_device *bdev, int no, long args)
  * Returnes the cache attributes used in Define Extend (DE).
  */
 static int
-dasd_eckd_get_attrib (struct block_device *bdev, int no, long args)
+dasd_eckd_get_attrib(struct dasd_device *device, void __user *argp)
 {
-        struct dasd_device *device;
-        struct dasd_eckd_private *private;
-        struct attrib_data_t attrib;
+        struct dasd_eckd_private *private =
+                (struct dasd_eckd_private *)device->private;
+        struct attrib_data_t attrib = private->attrib;
         int rc;
 
         if (!capable(CAP_SYS_ADMIN))
                 return -EACCES;
-        if (!args)
+        if (!argp)
                 return -EINVAL;
 
-        device = bdev->bd_disk->private_data;
-        if (device == NULL)
-                return -ENODEV;
-
-        private = (struct dasd_eckd_private *) device->private;
-        attrib = private->attrib;
-
-        rc = copy_to_user((long __user *) args, (long *) &attrib,
-                          sizeof (struct attrib_data_t));
+        rc = 0;
+        if (copy_to_user(argp, (long *) &attrib,
+                         sizeof (struct attrib_data_t)))
+                rc = -EFAULT;
 
         return rc;
 }
@@ -1456,26 +1432,19 @@ dasd_eckd_get_attrib (struct block_device *bdev, int no, long args)
  * Stores the attributes for cache operation to be used in Define Extend (DE).
  */
 static int
-dasd_eckd_set_attrib(struct block_device *bdev, int no, long args)
+dasd_eckd_set_attrib(struct dasd_device *device, void __user *argp)
 {
-        struct dasd_device *device;
-        struct dasd_eckd_private *private;
+        struct dasd_eckd_private *private =
+                (struct dasd_eckd_private *)device->private;
         struct attrib_data_t attrib;
 
         if (!capable(CAP_SYS_ADMIN))
                 return -EACCES;
-        if (!args)
+        if (!argp)
                 return -EINVAL;
 
-        device = bdev->bd_disk->private_data;
-        if (device == NULL)
-                return -ENODEV;
-
-        if (copy_from_user(&attrib, (void __user *) args,
-                           sizeof (struct attrib_data_t))) {
+        if (copy_from_user(&attrib, argp, sizeof(struct attrib_data_t)))
                 return -EFAULT;
-        }
-        private = (struct dasd_eckd_private *) device->private;
         private->attrib = attrib;
 
         DEV_MESSAGE(KERN_INFO, device,
@@ -1484,6 +1453,27 @@ dasd_eckd_set_attrib(struct block_device *bdev, int no, long args)
         return 0;
 }
 
+static int
+dasd_eckd_ioctl(struct dasd_device *device, unsigned int cmd, void __user *argp)
+{
+        switch (cmd) {
+        case BIODASDGATTR:
+                return dasd_eckd_get_attrib(device, argp);
+        case BIODASDSATTR:
+                return dasd_eckd_set_attrib(device, argp);
+        case BIODASDPSRD:
+                return dasd_eckd_performance(device, argp);
+        case BIODASDRLSE:
+                return dasd_eckd_release(device);
+        case BIODASDRSRV:
+                return dasd_eckd_reserve(device);
+        case BIODASDSLCK:
+                return dasd_eckd_steal_lock(device);
+        default:
+                return -ENOIOCTLCMD;
+        }
+}
+
 /*
  * Print sense data and related channel program.
  * Parts are printed because printk buffer is only 1024 bytes.
@@ -1642,6 +1632,7 @@ static struct dasd_discipline dasd_eckd_discipline = {
         .free_cp = dasd_eckd_free_cp,
         .dump_sense = dasd_eckd_dump_sense,
         .fill_info = dasd_eckd_fill_info,
+        .ioctl = dasd_eckd_ioctl,
 };
 
 static int __init
@@ -1649,59 +1640,18 @@ dasd_eckd_init(void)
 {
         int ret;
 
-        dasd_ioctl_no_register(THIS_MODULE, BIODASDGATTR,
-                               dasd_eckd_get_attrib);
-        dasd_ioctl_no_register(THIS_MODULE, BIODASDSATTR,
-                               dasd_eckd_set_attrib);
-        dasd_ioctl_no_register(THIS_MODULE, BIODASDPSRD,
-                               dasd_eckd_performance);
-        dasd_ioctl_no_register(THIS_MODULE, BIODASDRLSE,
-                               dasd_eckd_release);
-        dasd_ioctl_no_register(THIS_MODULE, BIODASDRSRV,
-                               dasd_eckd_reserve);
-        dasd_ioctl_no_register(THIS_MODULE, BIODASDSLCK,
-                               dasd_eckd_steal_lock);
-
         ASCEBC(dasd_eckd_discipline.ebcname, 4);
 
         ret = ccw_driver_register(&dasd_eckd_driver);
-        if (ret) {
-                dasd_ioctl_no_unregister(THIS_MODULE, BIODASDGATTR,
-                                         dasd_eckd_get_attrib);
-                dasd_ioctl_no_unregister(THIS_MODULE, BIODASDSATTR,
-                                         dasd_eckd_set_attrib);
-                dasd_ioctl_no_unregister(THIS_MODULE, BIODASDPSRD,
-                                         dasd_eckd_performance);
-                dasd_ioctl_no_unregister(THIS_MODULE, BIODASDRLSE,
-                                         dasd_eckd_release);
-                dasd_ioctl_no_unregister(THIS_MODULE, BIODASDRSRV,
-                                         dasd_eckd_reserve);
-                dasd_ioctl_no_unregister(THIS_MODULE, BIODASDSLCK,
-                                         dasd_eckd_steal_lock);
-                return ret;
-        }
-
-        dasd_generic_auto_online(&dasd_eckd_driver);
-        return 0;
+        if (!ret)
+                dasd_generic_auto_online(&dasd_eckd_driver);
+        return ret;
 }
 
 static void __exit
 dasd_eckd_cleanup(void)
 {
         ccw_driver_unregister(&dasd_eckd_driver);
-
-        dasd_ioctl_no_unregister(THIS_MODULE, BIODASDGATTR,
-                                 dasd_eckd_get_attrib);
-        dasd_ioctl_no_unregister(THIS_MODULE, BIODASDSATTR,
-                                 dasd_eckd_set_attrib);
-        dasd_ioctl_no_unregister(THIS_MODULE, BIODASDPSRD,
-                                 dasd_eckd_performance);
-        dasd_ioctl_no_unregister(THIS_MODULE, BIODASDRLSE,
-                                 dasd_eckd_release);
-        dasd_ioctl_no_unregister(THIS_MODULE, BIODASDRSRV,
-                                 dasd_eckd_reserve);
-        dasd_ioctl_no_unregister(THIS_MODULE, BIODASDSLCK,
-                                 dasd_eckd_steal_lock);
 }
 
 module_init(dasd_eckd_init);
diff --git a/drivers/s390/block/dasd_eckd.h b/drivers/s390/block/dasd_eckd.h
index bc3823d352..ad8524bb7b 100644
--- a/drivers/s390/block/dasd_eckd.h
+++ b/drivers/s390/block/dasd_eckd.h
@@ -29,6 +29,7 @@
 #define DASD_ECKD_CCW_PSF                0x27
 #define DASD_ECKD_CCW_RSSD               0x3e
 #define DASD_ECKD_CCW_LOCATE_RECORD      0x47
+#define DASD_ECKD_CCW_SNSS               0x54
 #define DASD_ECKD_CCW_DEFINE_EXTENT      0x63
 #define DASD_ECKD_CCW_WRITE_MT           0x85
 #define DASD_ECKD_CCW_READ_MT            0x86
diff --git a/drivers/s390/block/dasd_eer.c b/drivers/s390/block/dasd_eer.c
new file mode 100644
index 0000000000..2d946b6ca0
--- /dev/null
+++ b/drivers/s390/block/dasd_eer.c
@@ -0,0 +1,682 @@
+/*
+ *  Character device driver for extended error reporting.
+ *
+ *  Copyright (C) 2005 IBM Corporation
+ *  extended error reporting for DASD ECKD devices
+ *  Author(s): Stefan Weinhuber <wein@de.ibm.com>
+ */
+
+#include <linux/init.h>
+#include <linux/fs.h>
+#include <linux/kernel.h>
+#include <linux/miscdevice.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/device.h>
+#include <linux/poll.h>
+
+#include <asm/uaccess.h>
+#include <asm/semaphore.h>
+#include <asm/atomic.h>
+#include <asm/ebcdic.h>
+
+#include "dasd_int.h"
+#include "dasd_eckd.h"
+
+#ifdef PRINTK_HEADER
+#undef PRINTK_HEADER
+#endif                          /* PRINTK_HEADER */
+#define PRINTK_HEADER "dasd(eer):"
+
+/*
+ * SECTION: the internal buffer
+ */
+
+/*
+ * The internal buffer is meant to store obaque blobs of data, so it does
+ * not know of higher level concepts like triggers.
+ * It consists of a number of pages that are used as a ringbuffer. Each data
+ * blob is stored in a simple record that consists of an integer, which
+ * contains the size of the following data, and the data bytes themselfes.
+ *
+ * To allow for multiple independent readers we create one internal buffer
+ * each time the device is opened and destroy the buffer when the file is
+ * closed again. The number of pages used for this buffer is determined by
+ * the module parmeter eer_pages.
+ *
+ * One record can be written to a buffer by using the functions
+ * - dasd_eer_start_record (one time per record to write the size to the
+ *                          buffer and reserve the space for the data)
+ * - dasd_eer_write_buffer (one or more times per record to write the data)
+ * The data can be written in several steps but you will have to compute
+ * the total size up front for the invocation of dasd_eer_start_record.
+ * If the ringbuffer is full, dasd_eer_start_record will remove the required
+ * number of old records.
+ *
+ * A record is typically read in two steps, first read the integer that
+ * specifies the size of the following data, then read the data.
+ * Both can be done by
+ * - dasd_eer_read_buffer
+ *
+ * For all mentioned functions you need to get the bufferlock first and keep
+ * it until a complete record is written or read.
+ *
+ * All information necessary to keep track of an internal buffer is kept in
+ * a struct eerbuffer. The buffer specific to a file pointer is strored in
+ * the private_data field of that file. To be able to write data to all
+ * existing buffers, each buffer is also added to the bufferlist.
+ * If the user does not want to read a complete record in one go, we have to
+ * keep track of the rest of the record. residual stores the number of bytes
+ * that are still to deliver. If the rest of the record is invalidated between
+ * two reads then residual will be set to -1 so that the next read will fail.
+ * All entries in the eerbuffer structure are protected with the bufferlock.
+ * To avoid races between writing to a buffer on the one side and creating
+ * and destroying buffers on the other side, the bufferlock must also be used
+ * to protect the bufferlist.
+ */
+
+static int eer_pages = 5;
+module_param(eer_pages, int, S_IRUGO|S_IWUSR);
+
+struct eerbuffer {
+        struct list_head list;
+        char **buffer;
+        int buffersize;
+        int buffer_page_count;
+        int head;
+        int tail;
+        int residual;
+};
+
+static LIST_HEAD(bufferlist);
+static spinlock_t bufferlock = SPIN_LOCK_UNLOCKED;
+static DECLARE_WAIT_QUEUE_HEAD(dasd_eer_read_wait_queue);
+
+/*
+ * How many free bytes are available on the buffer.
+ * Needs to be called with bufferlock held.
+ */
+static int dasd_eer_get_free_bytes(struct eerbuffer *eerb)
+{
+        if (eerb->head < eerb->tail)
+                return eerb->tail - eerb->head - 1;
+        return eerb->buffersize - eerb->head + eerb->tail -1;
+}
+
+/*
+ * How many bytes of buffer space are used.
+ * Needs to be called with bufferlock held.
+ */
+static int dasd_eer_get_filled_bytes(struct eerbuffer *eerb)
+{
+
+        if (eerb->head >= eerb->tail)
+                return eerb->head - eerb->tail;
+        return eerb->buffersize - eerb->tail + eerb->head;
+}
+
+/*
+ * The dasd_eer_write_buffer function just copies count bytes of data
+ * to the buffer. Make sure to call dasd_eer_start_record first, to
+ * make sure that enough free space is available.
+ * Needs to be called with bufferlock held.
+ */
+static void dasd_eer_write_buffer(struct eerbuffer *eerb,
+                                  char *data, int count)
+{
+
+        unsigned long headindex,localhead;
+        unsigned long rest, len;
+        char *nextdata;
+
+        nextdata = data;
+        rest = count;
+        while (rest > 0) {
+                headindex = eerb->head / PAGE_SIZE;
+                localhead = eerb->head % PAGE_SIZE;
+                len = min(rest, PAGE_SIZE - localhead);
+                memcpy(eerb->buffer[headindex]+localhead, nextdata, len);
+                nextdata += len;
+                rest -= len;
+                eerb->head += len;
+                if (eerb->head == eerb->buffersize)
+                        eerb->head = 0; /* wrap around */
+                BUG_ON(eerb->head > eerb->buffersize);
+        }
+}
+
+/*
+ * Needs to be called with bufferlock held.
+ */
+static int dasd_eer_read_buffer(struct eerbuffer *eerb, char *data, int count)
+{
+
+        unsigned long tailindex,localtail;
+        unsigned long rest, len, finalcount;
+        char *nextdata;
+
+        finalcount = min(count, dasd_eer_get_filled_bytes(eerb));
+        nextdata = data;
+        rest = finalcount;
+        while (rest > 0) {
+                tailindex = eerb->tail / PAGE_SIZE;
+                localtail = eerb->tail % PAGE_SIZE;
+                len = min(rest, PAGE_SIZE - localtail);
+                memcpy(nextdata, eerb->buffer[tailindex] + localtail, len);
+                nextdata += len;
+                rest -= len;
+                eerb->tail += len;
+                if (eerb->tail == eerb->buffersize)
+                        eerb->tail = 0; /* wrap around */
+                BUG_ON(eerb->tail > eerb->buffersize);
+        }
+        return finalcount;
+}
+
+/*
+ * Whenever you want to write a blob of data to the internal buffer you
+ * have to start by using this function first. It will write the number
+ * of bytes that will be written to the buffer. If necessary it will remove
+ * old records to make room for the new one.
+ * Needs to be called with bufferlock held.
+ */
+static int dasd_eer_start_record(struct eerbuffer *eerb, int count)
+{
+        int tailcount;
+
+        if (count + sizeof(count) > eerb->buffersize)
+                return -ENOMEM;
+        while (dasd_eer_get_free_bytes(eerb) < count + sizeof(count)) {
+                if (eerb->residual > 0) {
+                        eerb->tail += eerb->residual;
+                        if (eerb->tail >= eerb->buffersize)
+                                eerb->tail -= eerb->buffersize;
+                        eerb->residual = -1;
+                }
+                dasd_eer_read_buffer(eerb, (char *) &tailcount,
+                                     sizeof(tailcount));
+                eerb->tail += tailcount;
+                if (eerb->tail >= eerb->buffersize)
+                        eerb->tail -= eerb->buffersize;
+        }
+        dasd_eer_write_buffer(eerb, (char*) &count, sizeof(count));
+
+        return 0;
+};
+
+/*
+ * Release pages that are not used anymore.
+ */
+static void dasd_eer_free_buffer_pages(char **buf, int no_pages)
+{
+        int i;
+
+        for (i = 0; i < no_pages; i++)
+                free_page((unsigned long) buf[i]);
+}
+
+/*
+ * Allocate a new set of memory pages.
+ */
+static int dasd_eer_allocate_buffer_pages(char **buf, int no_pages)
+{
+        int i;
+
+        for (i = 0; i < no_pages; i++) {
+                buf[i] = (char *) get_zeroed_page(GFP_KERNEL);
+                if (!buf[i]) {
+                        dasd_eer_free_buffer_pages(buf, i);
+                        return -ENOMEM;
+                }
+        }
+        return 0;
+}
+
+/*
+ * SECTION: The extended error reporting functionality
+ */
+
+/*
+ * When a DASD device driver wants to report an error, it calls the
+ * function dasd_eer_write and gives the respective trigger ID as
+ * parameter. Currently there are four kinds of triggers:
+ *
+ * DASD_EER_FATALERROR:  all kinds of unrecoverable I/O problems
+ * DASD_EER_PPRCSUSPEND: PPRC was suspended
+ * DASD_EER_NOPATH:      There is no path to the device left.
+ * DASD_EER_STATECHANGE: The state of the device has changed.
+ *
+ * For the first three triggers all required information can be supplied by
+ * the caller. For these triggers a record is written by the function
+ * dasd_eer_write_standard_trigger.
+ *
+ * The DASD_EER_STATECHANGE trigger is special since a sense subsystem
+ * status ccw need to be executed to gather the necessary sense data first.
+ * The dasd_eer_snss function will queue the SNSS request and the request
+ * callback will then call dasd_eer_write with the DASD_EER_STATCHANGE
+ * trigger.
+ *
+ * To avoid memory allocations at runtime, the necessary memory is allocated
+ * when the extended error reporting is enabled for a device (by
+ * dasd_eer_probe). There is one sense subsystem status request for each
+ * eer enabled DASD device. The presence of the cqr in device->eer_cqr
+ * indicates that eer is enable for the device. The use of the snss request
+ * is protected by the DASD_FLAG_EER_IN_USE bit. When this flag indicates
+ * that the cqr is currently in use, dasd_eer_snss cannot start a second
+ * request but sets the DASD_FLAG_EER_SNSS flag instead. The callback of
+ * the SNSS request will check the bit and call dasd_eer_snss again.
+ */
+
+#define SNSS_DATA_SIZE 44
+
+#define DASD_EER_BUSID_SIZE 10
+struct dasd_eer_header {
+        __u32 total_size;
+        __u32 trigger;
+        __u64 tv_sec;
+        __u64 tv_usec;
+        char busid[DASD_EER_BUSID_SIZE];
+};
+
+/*
+ * The following function can be used for those triggers that have
+ * all necessary data available when the function is called.
+ * If the parameter cqr is not NULL, the chain of requests will be searched
+ * for valid sense data, and all valid sense data sets will be added to
+ * the triggers data.
+ */
+static void dasd_eer_write_standard_trigger(struct dasd_device *device,
+                                            struct dasd_ccw_req *cqr,
+                                            int trigger)
+{
+        struct dasd_ccw_req *temp_cqr;
+        int data_size;
+        struct timeval tv;
+        struct dasd_eer_header header;
+        unsigned long flags;
+        struct eerbuffer *eerb;
+
+        /* go through cqr chain and count the valid sense data sets */
+        data_size = 0;
+        for (temp_cqr = cqr; temp_cqr; temp_cqr = temp_cqr->refers)
+                if (temp_cqr->irb.esw.esw0.erw.cons)
+                        data_size += 32;
+
+        header.total_size = sizeof(header) + data_size + 4; /* "EOR" */
+        header.trigger = trigger;
+        do_gettimeofday(&tv);
+        header.tv_sec = tv.tv_sec;
+        header.tv_usec = tv.tv_usec;
+        strncpy(header.busid, device->cdev->dev.bus_id, DASD_EER_BUSID_SIZE);
+
+        spin_lock_irqsave(&bufferlock, flags);
+        list_for_each_entry(eerb, &bufferlist, list) {
+                dasd_eer_start_record(eerb, header.total_size);
+                dasd_eer_write_buffer(eerb, (char *) &header, sizeof(header));
+                for (temp_cqr = cqr; temp_cqr; temp_cqr = temp_cqr->refers)
+                        if (temp_cqr->irb.esw.esw0.erw.cons)
+                                dasd_eer_write_buffer(eerb, cqr->irb.ecw, 32);
+                dasd_eer_write_buffer(eerb, "EOR", 4);
+        }
+        spin_unlock_irqrestore(&bufferlock, flags);
+        wake_up_interruptible(&dasd_eer_read_wait_queue);
+}
+
+/*
+ * This function writes a DASD_EER_STATECHANGE trigger.
+ */
+static void dasd_eer_write_snss_trigger(struct dasd_device *device,
+                                        struct dasd_ccw_req *cqr,
+                                        int trigger)
+{
+        int data_size;
+        int snss_rc;
+        struct timeval tv;
+        struct dasd_eer_header header;
+        unsigned long flags;
+        struct eerbuffer *eerb;
+
+        snss_rc = (cqr->status == DASD_CQR_FAILED) ? -EIO : 0;
+        if (snss_rc)
+                data_size = 0;
+        else
+                data_size = SNSS_DATA_SIZE;
+
+        header.total_size = sizeof(header) + data_size + 4; /* "EOR" */
+        header.trigger = DASD_EER_STATECHANGE;
+        do_gettimeofday(&tv);
+        header.tv_sec = tv.tv_sec;
+        header.tv_usec = tv.tv_usec;
+        strncpy(header.busid, device->cdev->dev.bus_id, DASD_EER_BUSID_SIZE);
+
+        spin_lock_irqsave(&bufferlock, flags);
+        list_for_each_entry(eerb, &bufferlist, list) {
+                dasd_eer_start_record(eerb, header.total_size);
+                dasd_eer_write_buffer(eerb, (char *) &header , sizeof(header));
+                if (!snss_rc)
+                        dasd_eer_write_buffer(eerb, cqr->data, SNSS_DATA_SIZE);
+                dasd_eer_write_buffer(eerb, "EOR", 4);
+        }
+        spin_unlock_irqrestore(&bufferlock, flags);
+        wake_up_interruptible(&dasd_eer_read_wait_queue);
+}
+
+/*
+ * This function is called for all triggers. It calls the appropriate
+ * function that writes the actual trigger records.
+ */
+void dasd_eer_write(struct dasd_device *device, struct dasd_ccw_req *cqr,
+                    unsigned int id)
+{
+        if (!device->eer_cqr)
+                return;
+        switch (id) {
+        case DASD_EER_FATALERROR:
+        case DASD_EER_PPRCSUSPEND:
+                dasd_eer_write_standard_trigger(device, cqr, id);
+                break;
+        case DASD_EER_NOPATH:
+                dasd_eer_write_standard_trigger(device, NULL, id);
+                break;
+        case DASD_EER_STATECHANGE:
+                dasd_eer_write_snss_trigger(device, cqr, id);
+                break;
+        default: /* unknown trigger, so we write it without any sense data */
+                dasd_eer_write_standard_trigger(device, NULL, id);
+                break;
+        }
+}
+EXPORT_SYMBOL(dasd_eer_write);
+
+/*
+ * Start a sense subsystem status request.
+ * Needs to be called with the device held.
+ */
+void dasd_eer_snss(struct dasd_device *device)
+{
+        struct dasd_ccw_req *cqr;
+
+        cqr = device->eer_cqr;
+        if (!cqr)       /* Device not eer enabled. */
+                return;
+        if (test_and_set_bit(DASD_FLAG_EER_IN_USE, &device->flags)) {
+                /* Sense subsystem status request in use. */
+                set_bit(DASD_FLAG_EER_SNSS, &device->flags);
+                return;
+        }
+        clear_bit(DASD_FLAG_EER_SNSS, &device->flags);
+        cqr->status = DASD_CQR_QUEUED;
+        list_add(&cqr->list, &device->ccw_queue);
+        dasd_schedule_bh(device);
+}
+
+/*
+ * Callback function for use with sense subsystem status request.
+ */
+static void dasd_eer_snss_cb(struct dasd_ccw_req *cqr, void *data)
+{
+        struct dasd_device *device = cqr->device;
+        unsigned long flags;
+
+        dasd_eer_write(device, cqr, DASD_EER_STATECHANGE);
+        spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
+        if (device->eer_cqr == cqr) {
+                clear_bit(DASD_FLAG_EER_IN_USE, &device->flags);
+                if (test_bit(DASD_FLAG_EER_SNSS, &device->flags))
+                        /* Another SNSS has been requested in the meantime. */
+                        dasd_eer_snss(device);
+                cqr = NULL;
+        }
+        spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
+        if (cqr)
+                /*
+                 * Extended error recovery has been switched off while
+                 * the SNSS request was running. It could even have
+                 * been switched off and on again in which case there
+                 * is a new ccw in device->eer_cqr. Free the "old"
+                 * snss request now.
+                 */
+                dasd_kfree_request(cqr, device);
+}
+
+/*
+ * Enable error reporting on a given device.
+ */
+int dasd_eer_enable(struct dasd_device *device)
+{
+        struct dasd_ccw_req *cqr;
+        unsigned long flags;
+
+        if (device->eer_cqr)
+                return 0;
+
+        if (!device->discipline || strcmp(device->discipline->name, "ECKD"))
+                return -EPERM;  /* FIXME: -EMEDIUMTYPE ? */
+
+        cqr = dasd_kmalloc_request("ECKD", 1 /* SNSS */,
+                                   SNSS_DATA_SIZE, device);
+        if (!cqr)
+                return -ENOMEM;
+
+        cqr->device = device;
+        cqr->retries = 255;
+        cqr->expires = 10 * HZ;
+
+        cqr->cpaddr->cmd_code = DASD_ECKD_CCW_SNSS;
+        cqr->cpaddr->count = SNSS_DATA_SIZE;
+        cqr->cpaddr->flags = 0;
+        cqr->cpaddr->cda = (__u32)(addr_t) cqr->data;
+
+        cqr->buildclk = get_clock();
+        cqr->status = DASD_CQR_FILLED;
+        cqr->callback = dasd_eer_snss_cb;
+
+        spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
+        if (!device->eer_cqr) {
+                device->eer_cqr = cqr;
+                cqr = NULL;
+        }
+        spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
+        if (cqr)
+                dasd_kfree_request(cqr, device);
+        return 0;
+}
+
+/*
+ * Disable error reporting on a given device.
+ */
+void dasd_eer_disable(struct dasd_device *device)
+{
+        struct dasd_ccw_req *cqr;
+        unsigned long flags;
+        int in_use;
+
+        if (!device->eer_cqr)
+                return;
+        spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
+        cqr = device->eer_cqr;
+        device->eer_cqr = NULL;
+        clear_bit(DASD_FLAG_EER_SNSS, &device->flags);
+        in_use = test_and_clear_bit(DASD_FLAG_EER_IN_USE, &device->flags);
+        spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
+        if (cqr && !in_use)
+                dasd_kfree_request(cqr, device);
+}
+
+/*
+ * SECTION: the device operations
+ */
+
+/*
+ * On the one side we need a lock to access our internal buffer, on the
+ * other side a copy_to_user can sleep. So we need to copy the data we have
+ * to transfer in a readbuffer, which is protected by the readbuffer_mutex.
+ */
+static char readbuffer[PAGE_SIZE];
+static DECLARE_MUTEX(readbuffer_mutex);
+
+static int dasd_eer_open(struct inode *inp, struct file *filp)
+{
+        struct eerbuffer *eerb;
+        unsigned long flags;
+
+        eerb = kzalloc(sizeof(struct eerbuffer), GFP_KERNEL);
+        eerb->buffer_page_count = eer_pages;
+        if (eerb->buffer_page_count < 1 ||
+            eerb->buffer_page_count > INT_MAX / PAGE_SIZE) {
+                kfree(eerb);
+                MESSAGE(KERN_WARNING, "can't open device since module "
+                        "parameter eer_pages is smaller then 1 or"
+                        " bigger then %d", (int)(INT_MAX / PAGE_SIZE));
+                return -EINVAL;
+        }
+        eerb->buffersize = eerb->buffer_page_count * PAGE_SIZE;
+        eerb->buffer = kmalloc(eerb->buffer_page_count * sizeof(char *),
+                               GFP_KERNEL);
+        if (!eerb->buffer) {
+                kfree(eerb);
+                return -ENOMEM;
+        }
+        if (dasd_eer_allocate_buffer_pages(eerb->buffer,
+                                           eerb->buffer_page_count)) {
+                kfree(eerb->buffer);
+                kfree(eerb);
+                return -ENOMEM;
+        }
+        filp->private_data = eerb;
+        spin_lock_irqsave(&bufferlock, flags);
+        list_add(&eerb->list, &bufferlist);
+        spin_unlock_irqrestore(&bufferlock, flags);
+
+        return nonseekable_open(inp,filp);
+}
+
+static int dasd_eer_close(struct inode *inp, struct file *filp)
+{
+        struct eerbuffer *eerb;
+        unsigned long flags;
+
+        eerb = (struct eerbuffer *) filp->private_data;
+        spin_lock_irqsave(&bufferlock, flags);
+        list_del(&eerb->list);
+        spin_unlock_irqrestore(&bufferlock, flags);
+        dasd_eer_free_buffer_pages(eerb->buffer, eerb->buffer_page_count);
+        kfree(eerb->buffer);
+        kfree(eerb);
+
+        return 0;
+}
+
+static ssize_t dasd_eer_read(struct file *filp, char __user *buf,
+                             size_t count, loff_t *ppos)
+{
+        int tc,rc;
+        int tailcount,effective_count;
+        unsigned long flags;
+        struct eerbuffer *eerb;
+
+        eerb = (struct eerbuffer *) filp->private_data;
+        if (down_interruptible(&readbuffer_mutex))
+                return -ERESTARTSYS;
+
+        spin_lock_irqsave(&bufferlock, flags);
+
+        if (eerb->residual < 0) { /* the remainder of this record */
+                                  /* has been deleted             */
+                eerb->residual = 0;
+                spin_unlock_irqrestore(&bufferlock, flags);
+                up(&readbuffer_mutex);
+                return -EIO;
+        } else if (eerb->residual > 0) {
+                /* OK we still have a second half of a record to deliver */
+                effective_count = min(eerb->residual, (int) count);
+                eerb->residual -= effective_count;
+        } else {
+                tc = 0;
+                while (!tc) {
+                        tc = dasd_eer_read_buffer(eerb, (char *) &tailcount,
+                                                  sizeof(tailcount));
+                        if (!tc) {
+                                /* no data available */
+                                spin_unlock_irqrestore(&bufferlock, flags);
+                                up(&readbuffer_mutex);
+                                if (filp->f_flags & O_NONBLOCK)
+                                        return -EAGAIN;
+                                rc = wait_event_interruptible(
+                                        dasd_eer_read_wait_queue,
+                                        eerb->head != eerb->tail);
+                                if (rc)
+                                        return rc;
+                                if (down_interruptible(&readbuffer_mutex))
+                                        return -ERESTARTSYS;
+                                spin_lock_irqsave(&bufferlock, flags);
+                        }
+                }
+                WARN_ON(tc != sizeof(tailcount));
+                effective_count = min(tailcount,(int)count);
+                eerb->residual = tailcount - effective_count;
+        }
+
+        tc = dasd_eer_read_buffer(eerb, readbuffer, effective_count);
+        WARN_ON(tc != effective_count);
+
+        spin_unlock_irqrestore(&bufferlock, flags);
+
+        if (copy_to_user(buf, readbuffer, effective_count)) {
+                up(&readbuffer_mutex);
+                return -EFAULT;
+        }
+
+        up(&readbuffer_mutex);
+        return effective_count;
+}
+
+static unsigned int dasd_eer_poll(struct file *filp, poll_table *ptable)
+{
+        unsigned int mask;
+        unsigned long flags;
+        struct eerbuffer *eerb;
+
+        eerb = (struct eerbuffer *) filp->private_data;
+        poll_wait(filp, &dasd_eer_read_wait_queue, ptable);
+        spin_lock_irqsave(&bufferlock, flags);
+        if (eerb->head != eerb->tail)
+                mask = POLLIN | POLLRDNORM ;
+        else
+                mask = 0;
+        spin_unlock_irqrestore(&bufferlock, flags);
+        return mask;
+}
+
+static struct file_operations dasd_eer_fops = {
+        .open           = &dasd_eer_open,
+        .release        = &dasd_eer_close,
+        .read           = &dasd_eer_read,
+        .poll           = &dasd_eer_poll,
+        .owner          = THIS_MODULE,
+};
+
+static struct miscdevice dasd_eer_dev = {
+        .minor      = MISC_DYNAMIC_MINOR,
+        .name       = "dasd_eer",
+        .fops       = &dasd_eer_fops,
+};
+
+int __init dasd_eer_init(void)
+{
+        int rc;
+
+        rc = misc_register(&dasd_eer_dev);
+        if (rc) {
+                MESSAGE(KERN_ERR, "%s", "dasd_eer_init could not "
+                       "register misc device");
+                return rc;
+        }
+
+        return 0;
+}
+
+void __exit dasd_eer_exit(void)
+{
+        WARN_ON(misc_deregister(&dasd_eer_dev) != 0);
+}
diff --git a/drivers/s390/block/dasd_int.h b/drivers/s390/block/dasd_int.h
index 7cb0b9e78a..4293ba8275 100644
--- a/drivers/s390/block/dasd_int.h
+++ b/drivers/s390/block/dasd_int.h
@@ -69,15 +69,6 @@
  */
 struct dasd_device;
 
-typedef int (*dasd_ioctl_fn_t) (struct block_device *bdev, int no, long args);
-
-struct dasd_ioctl {
-        struct list_head list;
-        struct module *owner;
-        int no;
-        dasd_ioctl_fn_t handler;
-};
-
 typedef enum {
         dasd_era_fatal = -1,    /* no chance to recover              */
         dasd_era_none = 0,      /* don't recover, everything alright */
@@ -272,10 +263,28 @@ struct dasd_discipline {
         /* i/o control functions. */
         int (*fill_geometry) (struct dasd_device *, struct hd_geometry *);
         int (*fill_info) (struct dasd_device *, struct dasd_information2_t *);
+        int (*ioctl) (struct dasd_device *, unsigned int, void __user *);
 };
 
 extern struct dasd_discipline *dasd_diag_discipline_pointer;
 
+
+/*
+ * Notification numbers for extended error reporting notifications:
+ * The DASD_EER_DISABLE notification is sent before a dasd_device (and it's
+ * eer pointer) is freed. The error reporting module needs to do all necessary
+ * cleanup steps.
+ * The DASD_EER_TRIGGER notification sends the actual error reports (triggers).
+ */
+#define DASD_EER_DISABLE 0
+#define DASD_EER_TRIGGER 1
+
+/* Trigger IDs for extended error reporting DASD_EER_TRIGGER notification */
+#define DASD_EER_FATALERROR  1
+#define DASD_EER_NOPATH      2
+#define DASD_EER_STATECHANGE 3
+#define DASD_EER_PPRCSUSPEND 4
+
 struct dasd_device {
         /* Block device stuff. */
         struct gendisk *gdp;
@@ -289,6 +298,9 @@ struct dasd_device {
         unsigned long flags;            /* per device flags */
         unsigned short features;        /* copy of devmap-features (read-only!) */
 
+        /* extended error reporting stuff (eer) */
+        struct dasd_ccw_req *eer_cqr;
+
         /* Device discipline stuff. */
         struct dasd_discipline *discipline;
         struct dasd_discipline *base_discipline;
@@ -334,6 +346,8 @@ struct dasd_device {
 /* per device flags */
 #define DASD_FLAG_DSC_ERROR     2       /* return -EIO when disconnected */
 #define DASD_FLAG_OFFLINE       3       /* device is in offline processing */
+#define DASD_FLAG_EER_SNSS      4       /* A SNSS is required */
+#define DASD_FLAG_EER_IN_USE    5       /* A SNSS request is running */
 
 void dasd_put_device_wake(struct dasd_device *);
 
@@ -523,10 +537,6 @@ int dasd_scan_partitions(struct dasd_device *);
 void dasd_destroy_partitions(struct dasd_device *);
 
 /* externals in dasd_ioctl.c */
-int  dasd_ioctl_init(void);
-void dasd_ioctl_exit(void);
-int  dasd_ioctl_no_register(struct module *, int, dasd_ioctl_fn_t);
-int  dasd_ioctl_no_unregister(struct module *, int, dasd_ioctl_fn_t);
 int  dasd_ioctl(struct inode *, struct file *, unsigned int, unsigned long);
 long dasd_compat_ioctl(struct file *, unsigned int, unsigned long);
 
@@ -557,6 +567,30 @@ dasd_era_t dasd_9336_erp_examine(struct dasd_ccw_req *, struct irb *);
 dasd_era_t dasd_9343_erp_examine(struct dasd_ccw_req *, struct irb *);
 struct dasd_ccw_req *dasd_9343_erp_action(struct dasd_ccw_req *);
 
+/* externals in dasd_eer.c */
+#ifdef CONFIG_DASD_EER
+int dasd_eer_init(void);
+void dasd_eer_exit(void);
+int dasd_eer_enable(struct dasd_device *);
+void dasd_eer_disable(struct dasd_device *);
+void dasd_eer_write(struct dasd_device *, struct dasd_ccw_req *cqr,
+                    unsigned int id);
+void dasd_eer_snss(struct dasd_device *);
+
+static inline int dasd_eer_enabled(struct dasd_device *device)
+{
+        return device->eer_cqr != NULL;
+}
+#else
+#define dasd_eer_init()         (0)
+#define dasd_eer_exit()         do { } while (0)
+#define dasd_eer_enable(d)      (0)
+#define dasd_eer_disable(d)     do { } while (0)
+#define dasd_eer_write(d,c,i)   do { } while (0)
+#define dasd_eer_snss(d)        do { } while (0)
+#define dasd_eer_enabled(d)     (0)
+#endif  /* CONFIG_DASD_ERR */
+
 #endif                          /* __KERNEL__ */
 
 #endif                          /* DASD_H */
diff --git a/drivers/s390/block/dasd_ioctl.c b/drivers/s390/block/dasd_ioctl.c
index fafeeae526..b8c80d28df 100644
--- a/drivers/s390/block/dasd_ioctl.c
+++ b/drivers/s390/block/dasd_ioctl.c
@@ -16,6 +16,7 @@
 #include <linux/blkpg.h>
 
 #include <asm/ccwdev.h>
+#include <asm/cmb.h>
 #include <asm/uaccess.h>
 
 /* This is ugly... */
@@ -23,116 +24,12 @@
 
 #include "dasd_int.h"
 
-/*
- * SECTION: ioctl functions.
- */
-static struct list_head dasd_ioctl_list = LIST_HEAD_INIT(dasd_ioctl_list);
-
-/*
- * Find the ioctl with number no.
- */
-static struct dasd_ioctl *
-dasd_find_ioctl(int no)
-{
-        struct dasd_ioctl *ioctl;
-
-        list_for_each_entry (ioctl, &dasd_ioctl_list, list)
-                if (ioctl->no == no)
-                        return ioctl;
-        return NULL;
-}
-
-/*
- * Register ioctl with number no.
- */
-int
-dasd_ioctl_no_register(struct module *owner, int no, dasd_ioctl_fn_t handler)
-{
-        struct dasd_ioctl *new;
-        if (dasd_find_ioctl(no))
-                return -EBUSY;
-        new = kmalloc(sizeof (struct dasd_ioctl), GFP_KERNEL);
-        if (new == NULL)
-                return -ENOMEM;
-        new->owner = owner;
-        new->no = no;
-        new->handler = handler;
-        list_add(&new->list, &dasd_ioctl_list);
-        return 0;
-}
-
-/*
- * Deregister ioctl with number no.
- */
-int
-dasd_ioctl_no_unregister(struct module *owner, int no, dasd_ioctl_fn_t handler)
-{
-        struct dasd_ioctl *old = dasd_find_ioctl(no);
-        if (old == NULL)
-                return -ENOENT;
-        if (old->no != no || old->handler != handler || owner != old->owner)
-                return -EINVAL;
-        list_del(&old->list);
-        kfree(old);
-        return 0;
-}
-
-int
-dasd_ioctl(struct inode *inp, struct file *filp,
-           unsigned int no, unsigned long data)
-{
-        struct block_device *bdev = inp->i_bdev;
-        struct dasd_device *device = bdev->bd_disk->private_data;
-        struct dasd_ioctl *ioctl;
-        const char *dir;
-        int rc;
-
-        if ((_IOC_DIR(no) != _IOC_NONE) && (data == 0)) {
-                PRINT_DEBUG("empty data ptr");
-                return -EINVAL;
-        }
-        dir = _IOC_DIR (no) == _IOC_NONE ? "0" :
-                _IOC_DIR (no) == _IOC_READ ? "r" :
-                _IOC_DIR (no) == _IOC_WRITE ? "w" : 
-                _IOC_DIR (no) == (_IOC_READ | _IOC_WRITE) ? "rw" : "u";
-        DBF_DEV_EVENT(DBF_DEBUG, device,
-                      "ioctl 0x%08x %s'0x%x'%d(%d) with data %8lx", no,
-                      dir, _IOC_TYPE(no), _IOC_NR(no), _IOC_SIZE(no), data);
-        /* Search for ioctl no in the ioctl list. */
-        list_for_each_entry(ioctl, &dasd_ioctl_list, list) {
-                if (ioctl->no == no) {
-                        /* Found a matching ioctl. Call it. */
-                        if (!try_module_get(ioctl->owner))
-                                continue;
-                        rc = ioctl->handler(bdev, no, data);
-                        module_put(ioctl->owner);
-                        return rc;
-                }
-        }
-        /* No ioctl with number no. */
-        DBF_DEV_EVENT(DBF_INFO, device,
-                      "unknown ioctl 0x%08x=%s'0x%x'%d(%d) data %8lx", no,
-                      dir, _IOC_TYPE(no), _IOC_NR(no), _IOC_SIZE(no), data);
-        return -EINVAL;
-}
-
-long
-dasd_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
-{
-        int rval;
-
-        lock_kernel();
-        rval = dasd_ioctl(filp->f_dentry->d_inode, filp, cmd, arg);
-        unlock_kernel();
-
-        return (rval == -EINVAL) ? -ENOIOCTLCMD : rval;
-}
 
 static int
-dasd_ioctl_api_version(struct block_device *bdev, int no, long args)
+dasd_ioctl_api_version(void __user *argp)
 {
         int ver = DASD_API_VERSION;
-        return put_user(ver, (int __user *) args);
+        return put_user(ver, (int __user *)argp);
 }
 
 /*
@@ -140,20 +37,18 @@ dasd_ioctl_api_version(struct block_device *bdev, int no, long args)
  * used by dasdfmt after BIODASDDISABLE to retrigger blocksize detection
  */
 static int
-dasd_ioctl_enable(struct block_device *bdev, int no, long args)
+dasd_ioctl_enable(struct block_device *bdev)
 {
-        struct dasd_device *device;
+        struct dasd_device *device = bdev->bd_disk->private_data;
 
         if (!capable(CAP_SYS_ADMIN))
                 return -EACCES;
-        device = bdev->bd_disk->private_data;
-        if (device == NULL)
-                return -ENODEV;
+
         dasd_enable_device(device);
         /* Formatting the dasd device can change the capacity. */
-        down(&bdev->bd_sem);
+        mutex_lock(&bdev->bd_mutex);
         i_size_write(bdev->bd_inode, (loff_t)get_capacity(device->gdp) << 9);
-        up(&bdev->bd_sem);
+        mutex_unlock(&bdev->bd_mutex);
         return 0;
 }
 
@@ -162,15 +57,13 @@ dasd_ioctl_enable(struct block_device *bdev, int no, long args)
  * Used by dasdfmt. Disable I/O operations but allow ioctls.
  */
 static int
-dasd_ioctl_disable(struct block_device *bdev, int no, long args)
+dasd_ioctl_disable(struct block_device *bdev)
 {
-        struct dasd_device *device;
+        struct dasd_device *device = bdev->bd_disk->private_data;
 
         if (!capable(CAP_SYS_ADMIN))
                 return -EACCES;
-        device = bdev->bd_disk->private_data;
-        if (device == NULL)
-                return -ENODEV;
+
         /*
          * Man this is sick. We don't do a real disable but only downgrade
          * the device to DASD_STATE_BASIC. The reason is that dasdfmt uses
@@ -184,9 +77,9 @@ dasd_ioctl_disable(struct block_device *bdev, int no, long args)
          * Set i_size to zero, since read, write, etc. check against this
          * value.
          */
-        down(&bdev->bd_sem);
+        mutex_lock(&bdev->bd_mutex);
         i_size_write(bdev->bd_inode, 0);
-        up(&bdev->bd_sem);
+        mutex_unlock(&bdev->bd_mutex);
         return 0;
 }
 
@@ -194,18 +87,13 @@ dasd_ioctl_disable(struct block_device *bdev, int no, long args)
  * Quiesce device.
  */
 static int
-dasd_ioctl_quiesce(struct block_device *bdev, int no, long args)
+dasd_ioctl_quiesce(struct dasd_device *device)
 {
-        struct dasd_device *device;
         unsigned long flags;
         
         if (!capable (CAP_SYS_ADMIN))
                 return -EACCES;
         
-        device = bdev->bd_disk->private_data;
-        if (device == NULL)
-                return -ENODEV;
-        
         DEV_MESSAGE (KERN_DEBUG, device, "%s",
                      "Quiesce IO on device");
         spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
@@ -219,18 +107,13 @@ dasd_ioctl_quiesce(struct block_device *bdev, int no, long args)
  * Quiesce device.
  */
 static int
-dasd_ioctl_resume(struct block_device *bdev, int no, long args)
+dasd_ioctl_resume(struct dasd_device *device)
 {
-        struct dasd_device *device;
         unsigned long flags;
         
         if (!capable (CAP_SYS_ADMIN)) 
                 return -EACCES;
 
-        device = bdev->bd_disk->private_data;
-        if (device == NULL)
-                return -ENODEV;
-
         DEV_MESSAGE (KERN_DEBUG, device, "%s",
                      "resume IO on device");
         
@@ -302,25 +185,19 @@ dasd_format(struct dasd_device * device, struct format_data_t * fdata)
  * Format device.
  */
 static int
-dasd_ioctl_format(struct block_device *bdev, int no, long args)
+dasd_ioctl_format(struct block_device *bdev, void __user *argp)
 {
-        struct dasd_device *device;
+        struct dasd_device *device = bdev->bd_disk->private_data;
         struct format_data_t fdata;
 
         if (!capable(CAP_SYS_ADMIN))
                 return -EACCES;
-        if (!args)
+        if (!argp)
                 return -EINVAL;
-        /* fdata == NULL is no longer a valid arg to dasd_format ! */
-        device = bdev->bd_disk->private_data;
-
-        if (device == NULL)
-                return -ENODEV;
 
         if (device->features & DASD_FEATURE_READONLY)
                 return -EROFS;
-        if (copy_from_user(&fdata, (void __user *) args,
-                           sizeof (struct format_data_t)))
+        if (copy_from_user(&fdata, argp, sizeof(struct format_data_t)))
                 return -EFAULT;
         if (bdev != bdev->bd_contains) {
                 DEV_MESSAGE(KERN_WARNING, device, "%s",
@@ -335,17 +212,8 @@ dasd_ioctl_format(struct block_device *bdev, int no, long args)
  * Reset device profile information
  */
 static int
-dasd_ioctl_reset_profile(struct block_device *bdev, int no, long args)
+dasd_ioctl_reset_profile(struct dasd_device *device)
 {
-        struct dasd_device *device;
-
-        if (!capable(CAP_SYS_ADMIN))
-                return -EACCES;
-
-        device = bdev->bd_disk->private_data;
-        if (device == NULL)
-                return -ENODEV;
-
         memset(&device->profile, 0, sizeof (struct dasd_profile_info_t));
         return 0;
 }
@@ -354,31 +222,24 @@ dasd_ioctl_reset_profile(struct block_device *bdev, int no, long args)
  * Return device profile information
  */
 static int
-dasd_ioctl_read_profile(struct block_device *bdev, int no, long args)
+dasd_ioctl_read_profile(struct dasd_device *device, void __user *argp)
 {
-        struct dasd_device *device;
-
-        device = bdev->bd_disk->private_data;
-        if (device == NULL)
-                return -ENODEV;
-
         if (dasd_profile_level == DASD_PROFILE_OFF)
                 return -EIO;
-
-        if (copy_to_user((long __user *) args, (long *) &device->profile,
+        if (copy_to_user(argp, &device->profile,
                          sizeof (struct dasd_profile_info_t)))
                 return -EFAULT;
         return 0;
 }
 #else
 static int
-dasd_ioctl_reset_profile(struct block_device *bdev, int no, long args)
+dasd_ioctl_reset_profile(struct dasd_device *device)
 {
         return -ENOSYS;
 }
 
 static int
-dasd_ioctl_read_profile(struct block_device *bdev, int no, long args)
+dasd_ioctl_read_profile(struct dasd_device *device, void __user *argp)
 {
         return -ENOSYS;
 }
@@ -388,22 +249,18 @@ dasd_ioctl_read_profile(struct block_device *bdev, int no, long args)
  * Return dasd information. Used for BIODASDINFO and BIODASDINFO2.
  */
 static int
-dasd_ioctl_information(struct block_device *bdev, int no, long args)
+dasd_ioctl_information(struct dasd_device *device,
+                unsigned int cmd, void __user *argp)
 {
-        struct dasd_device *device;
         struct dasd_information2_t *dasd_info;
         unsigned long flags;
         int rc;
         struct ccw_device *cdev;
 
-        device = bdev->bd_disk->private_data;
-        if (device == NULL)
-                return -ENODEV;
-
         if (!device->discipline->fill_info)
                 return -EINVAL;
 
-        dasd_info = kmalloc(sizeof(struct dasd_information2_t), GFP_KERNEL);
+        dasd_info = kzalloc(sizeof(struct dasd_information2_t), GFP_KERNEL);
         if (dasd_info == NULL)
                 return -ENOMEM;
 
@@ -446,8 +303,7 @@ dasd_ioctl_information(struct block_device *bdev, int no, long args)
                 memcpy(dasd_info->type, device->discipline->name, 4);
         else
                 memcpy(dasd_info->type, "none", 4);
-        dasd_info->req_queue_len = 0;
-        dasd_info->chanq_len = 0;
+
         if (device->request_queue->request_fn) {
                 struct list_head *l;
 #ifdef DASD_EXTENDED_PROFILING
@@ -467,8 +323,8 @@ dasd_ioctl_information(struct block_device *bdev, int no, long args)
         }
 
         rc = 0;
-        if (copy_to_user((long __user *) args, (long *) dasd_info,
-                         ((no == (unsigned int) BIODASDINFO2) ?
+        if (copy_to_user(argp, dasd_info,
+                         ((cmd == (unsigned int) BIODASDINFO2) ?
                           sizeof (struct dasd_information2_t) :
                           sizeof (struct dasd_information_t))))
                 rc = -EFAULT;
@@ -480,69 +336,103 @@ dasd_ioctl_information(struct block_device *bdev, int no, long args)
  * Set read only
  */
 static int
-dasd_ioctl_set_ro(struct block_device *bdev, int no, long args)
+dasd_ioctl_set_ro(struct block_device *bdev, void __user *argp)
 {
-        struct dasd_device *device;
-        int intval, rc;
+        struct dasd_device *device =  bdev->bd_disk->private_data;
+        int intval;
 
         if (!capable(CAP_SYS_ADMIN))
                 return -EACCES;
         if (bdev != bdev->bd_contains)
                 // ro setting is not allowed for partitions
                 return -EINVAL;
-        if (get_user(intval, (int __user *) args))
+        if (get_user(intval, (int *)argp))
                 return -EFAULT;
-        device =  bdev->bd_disk->private_data;
-        if (device == NULL)
-                return -ENODEV;
 
         set_disk_ro(bdev->bd_disk, intval);
-        rc = dasd_set_feature(device->cdev, DASD_FEATURE_READONLY, intval);
-
-        return rc;
+        return dasd_set_feature(device->cdev, DASD_FEATURE_READONLY, intval);
 }
 
-/*
- * List of static ioctls.
- */
-static struct { int no; dasd_ioctl_fn_t fn; } dasd_ioctls[] =
+static int
+dasd_ioctl_readall_cmb(struct dasd_device *device, unsigned int cmd,
+                unsigned long arg)
 {
-        { BIODASDDISABLE, dasd_ioctl_disable },
-        { BIODASDENABLE, dasd_ioctl_enable },
-        { BIODASDQUIESCE, dasd_ioctl_quiesce },
-        { BIODASDRESUME, dasd_ioctl_resume },
-        { BIODASDFMT, dasd_ioctl_format },
-        { BIODASDINFO, dasd_ioctl_information },
-        { BIODASDINFO2, dasd_ioctl_information },
-        { BIODASDPRRD, dasd_ioctl_read_profile },
-        { BIODASDPRRST, dasd_ioctl_reset_profile },
-        { BLKROSET, dasd_ioctl_set_ro },
-        { DASDAPIVER, dasd_ioctl_api_version },
-        { -1, NULL }
-};
+        struct cmbdata __user *argp = (void __user *) arg;
+        size_t size = _IOC_SIZE(cmd);
+        struct cmbdata data;
+        int ret;
+
+        ret = cmf_readall(device->cdev, &data);
+        if (!ret && copy_to_user(argp, &data, min(size, sizeof(*argp))))
+                return -EFAULT;
+        return ret;
+}
 
 int
-dasd_ioctl_init(void)
+dasd_ioctl(struct inode *inode, struct file *file,
+           unsigned int cmd, unsigned long arg)
 {
-        int i;
+        struct block_device *bdev = inode->i_bdev;
+        struct dasd_device *device = bdev->bd_disk->private_data;
+        void __user *argp = (void __user *)arg;
 
-        for (i = 0; dasd_ioctls[i].no != -1; i++)
-                dasd_ioctl_no_register(NULL, dasd_ioctls[i].no,
-                                       dasd_ioctls[i].fn);
-        return 0;
+        if (!device)
+                return -ENODEV;
+
+        if ((_IOC_DIR(cmd) != _IOC_NONE) && !arg) {
+                PRINT_DEBUG("empty data ptr");
+                return -EINVAL;
+        }
 
+        switch (cmd) {
+        case BIODASDDISABLE:
+                return dasd_ioctl_disable(bdev);
+        case BIODASDENABLE:
+                return dasd_ioctl_enable(bdev);
+        case BIODASDQUIESCE:
+                return dasd_ioctl_quiesce(device);
+        case BIODASDRESUME:
+                return dasd_ioctl_resume(device);
+        case BIODASDFMT:
+                return dasd_ioctl_format(bdev, argp);
+        case BIODASDINFO:
+                return dasd_ioctl_information(device, cmd, argp);
+        case BIODASDINFO2:
+                return dasd_ioctl_information(device, cmd, argp);
+        case BIODASDPRRD:
+                return dasd_ioctl_read_profile(device, argp);
+        case BIODASDPRRST:
+                return dasd_ioctl_reset_profile(device);
+        case BLKROSET:
+                return dasd_ioctl_set_ro(bdev, argp);
+        case DASDAPIVER:
+                return dasd_ioctl_api_version(argp);
+        case BIODASDCMFENABLE:
+                return enable_cmf(device->cdev);
+        case BIODASDCMFDISABLE:
+                return disable_cmf(device->cdev);
+        case BIODASDREADALLCMB:
+                return dasd_ioctl_readall_cmb(device, cmd, arg);
+        default:
+                /* if the discipline has an ioctl method try it. */
+                if (device->discipline->ioctl) {
+                        int rval = device->discipline->ioctl(device, cmd, argp);
+                        if (rval != -ENOIOCTLCMD)
+                                return rval;
+                }
+
+                return -EINVAL;
+        }
 }
 
-void
-dasd_ioctl_exit(void)
+long
+dasd_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 {
-        int i;
+        int rval;
 
-        for (i = 0; dasd_ioctls[i].no != -1; i++)
-                dasd_ioctl_no_unregister(NULL, dasd_ioctls[i].no,
-                                         dasd_ioctls[i].fn);
+        lock_kernel();
+        rval = dasd_ioctl(filp->f_dentry->d_inode, filp, cmd, arg);
+        unlock_kernel();
 
+        return (rval == -EINVAL) ? -ENOIOCTLCMD : rval;
 }
-
-EXPORT_SYMBOL(dasd_ioctl_no_register);
-EXPORT_SYMBOL(dasd_ioctl_no_unregister);
diff --git a/drivers/s390/block/dcssblk.c b/drivers/s390/block/dcssblk.c
index 44133250da..be9b05347b 100644
--- a/drivers/s390/block/dcssblk.c
+++ b/drivers/s390/block/dcssblk.c
@@ -388,12 +388,11 @@ dcssblk_add_store(struct device *dev, struct device_attribute *attr, const char
         /*
          * get a struct dcssblk_dev_info
          */
-        dev_info = kmalloc(sizeof(struct dcssblk_dev_info), GFP_KERNEL);
+        dev_info = kzalloc(sizeof(struct dcssblk_dev_info), GFP_KERNEL);
         if (dev_info == NULL) {
                 rc = -ENOMEM;
                 goto out;
         }
-        memset(dev_info, 0, sizeof(struct dcssblk_dev_info));
 
         strcpy(dev_info->segment_name, local_buf);
         strlcpy(dev_info->dev.bus_id, local_buf, BUS_ID_SIZE);
diff --git a/drivers/s390/char/Makefile b/drivers/s390/char/Makefile
index 6377a96735..0c0162ff6c 100644
--- a/drivers/s390/char/Makefile
+++ b/drivers/s390/char/Makefile
@@ -26,4 +26,5 @@ tape-$(CONFIG_PROC_FS) += tape_proc.o
 tape-objs := tape_core.o tape_std.o tape_char.o $(tape-y)
 obj-$(CONFIG_S390_TAPE) += tape.o tape_class.o
 obj-$(CONFIG_S390_TAPE_34XX) += tape_34xx.o
+obj-$(CONFIG_S390_TAPE_3590) += tape_3590.o
 obj-$(CONFIG_MONREADER) += monreader.o
diff --git a/drivers/s390/char/fs3270.c b/drivers/s390/char/fs3270.c
index 5f6fa4c678..a6415377bc 100644
--- a/drivers/s390/char/fs3270.c
+++ b/drivers/s390/char/fs3270.c
@@ -368,10 +368,9 @@ fs3270_alloc_view(void)
 {
         struct fs3270 *fp;
 
-        fp = (struct fs3270 *) kmalloc(sizeof(struct fs3270),GFP_KERNEL);
+        fp = kzalloc(sizeof(struct fs3270),GFP_KERNEL);
         if (!fp)
                 return ERR_PTR(-ENOMEM);
-        memset(fp, 0, sizeof(struct fs3270));
         fp->init = raw3270_request_alloc(0);
         if (IS_ERR(fp->init)) {
                 kfree(fp);
diff --git a/drivers/s390/char/keyboard.c b/drivers/s390/char/keyboard.c
index a317a123da..6badd84034 100644
--- a/drivers/s390/char/keyboard.c
+++ b/drivers/s390/char/keyboard.c
@@ -50,14 +50,12 @@ kbd_alloc(void) {
         struct kbd_data *kbd;
         int i, len;
 
-        kbd = kmalloc(sizeof(struct kbd_data), GFP_KERNEL);
+        kbd = kzalloc(sizeof(struct kbd_data), GFP_KERNEL);
         if (!kbd)
                 goto out;
-        memset(kbd, 0, sizeof(struct kbd_data));
-        kbd->key_maps = kmalloc(sizeof(key_maps), GFP_KERNEL);
+        kbd->key_maps = kzalloc(sizeof(key_maps), GFP_KERNEL);
         if (!key_maps)
                 goto out_kbd;
-        memset(kbd->key_maps, 0, sizeof(key_maps));
         for (i = 0; i < ARRAY_SIZE(key_maps); i++) {
                 if (key_maps[i]) {
                         kbd->key_maps[i] =
@@ -68,10 +66,9 @@ kbd_alloc(void) {
                                sizeof(u_short)*NR_KEYS);
                 }
         }
-        kbd->func_table = kmalloc(sizeof(func_table), GFP_KERNEL);
+        kbd->func_table = kzalloc(sizeof(func_table), GFP_KERNEL);
         if (!kbd->func_table)
                 goto out_maps;
-        memset(kbd->func_table, 0, sizeof(func_table));
         for (i = 0; i < ARRAY_SIZE(func_table); i++) {
                 if (func_table[i]) {
                         len = strlen(func_table[i]) + 1;
@@ -82,10 +79,9 @@ kbd_alloc(void) {
                 }
         }
         kbd->fn_handler =
-                kmalloc(sizeof(fn_handler_fn *) * NR_FN_HANDLER, GFP_KERNEL);
+                kzalloc(sizeof(fn_handler_fn *) * NR_FN_HANDLER, GFP_KERNEL);
         if (!kbd->fn_handler)
                 goto out_func;
-        memset(kbd->fn_handler, 0, sizeof(fn_handler_fn *) * NR_FN_HANDLER);
         kbd->accent_table =
                 kmalloc(sizeof(struct kbdiacr)*MAX_DIACR, GFP_KERNEL);
         if (!kbd->accent_table)
diff --git a/drivers/s390/char/monreader.c b/drivers/s390/char/monreader.c
index 5fd3ad8673..fb7bc9e5ee 100644
--- a/drivers/s390/char/monreader.c
+++ b/drivers/s390/char/monreader.c
@@ -257,14 +257,13 @@ mon_alloc_mem(void)
         int i,j;
         struct mon_private *monpriv;
 
-        monpriv = kmalloc(sizeof(struct mon_private), GFP_KERNEL);
+        monpriv = kzalloc(sizeof(struct mon_private), GFP_KERNEL);
         if (!monpriv) {
                 P_ERROR("no memory for monpriv\n");
                 return NULL;
         }
-        memset(monpriv, 0, sizeof(struct mon_private));
         for (i = 0; i < MON_MSGLIM; i++) {
-                monpriv->msg_array[i] = kmalloc(sizeof(struct mon_msg),
+                monpriv->msg_array[i] = kzalloc(sizeof(struct mon_msg),
                                                     GFP_KERNEL);
                 if (!monpriv->msg_array[i]) {
                         P_ERROR("open, no memory for msg_array\n");
@@ -272,7 +271,6 @@ mon_alloc_mem(void)
                                 kfree(monpriv->msg_array[j]);
                         return NULL;
                 }
-                memset(monpriv->msg_array[i], 0, sizeof(struct mon_msg));
         }
         return monpriv;
 }
diff --git a/drivers/s390/char/raw3270.c b/drivers/s390/char/raw3270.c
index 1026f2bc31..bd06607a5d 100644
--- a/drivers/s390/char/raw3270.c
+++ b/drivers/s390/char/raw3270.c
@@ -115,10 +115,9 @@ raw3270_request_alloc(size_t size)
         struct raw3270_request *rq;
 
         /* Allocate request structure */
-        rq = kmalloc(sizeof(struct raw3270_request), GFP_KERNEL | GFP_DMA);
+        rq = kzalloc(sizeof(struct raw3270_request), GFP_KERNEL | GFP_DMA);
         if (!rq)
                 return ERR_PTR(-ENOMEM);
-        memset(rq, 0, sizeof(struct raw3270_request));
 
         /* alloc output buffer. */
         if (size > 0) {
diff --git a/drivers/s390/char/tape.h b/drivers/s390/char/tape.h
index 01d865d937..cd51ace8b6 100644
--- a/drivers/s390/char/tape.h
+++ b/drivers/s390/char/tape.h
@@ -250,6 +250,7 @@ extern void tape_free_request(struct tape_request *);
 extern int tape_do_io(struct tape_device *, struct tape_request *);
 extern int tape_do_io_async(struct tape_device *, struct tape_request *);
 extern int tape_do_io_interruptible(struct tape_device *, struct tape_request *);
+extern int tape_cancel_io(struct tape_device *, struct tape_request *);
 void tape_hotplug_event(struct tape_device *, int major, int action);
 
 static inline int
diff --git a/drivers/s390/char/tape_34xx.c b/drivers/s390/char/tape_34xx.c
index 682039cac1..d4f2da7380 100644
--- a/drivers/s390/char/tape_34xx.c
+++ b/drivers/s390/char/tape_34xx.c
@@ -2,8 +2,7 @@
  *  drivers/s390/char/tape_34xx.c
  *    tape device discipline for 3480/3490 tapes.
  *
- *  S390 and zSeries version
- *    Copyright (C) 2001,2002 IBM Deutschland Entwicklung GmbH, IBM Corporation
+ *    Copyright (C) IBM Corp. 2001,2006
  *    Author(s): Carsten Otte <cotte@de.ibm.com>
  *               Tuan Ngo-Anh <ngoanh@de.ibm.com>
  *               Martin Schwidefsky <schwidefsky@de.ibm.com>
@@ -28,11 +27,6 @@
 debug_info_t *TAPE_DBF_AREA = NULL;
 EXPORT_SYMBOL(TAPE_DBF_AREA);
 
-enum tape_34xx_type {
-        tape_3480,
-        tape_3490,
-};
-
 #define TAPE34XX_FMT_3480       0
 #define TAPE34XX_FMT_3480_2_XF  1
 #define TAPE34XX_FMT_3480_XF    2
diff --git a/drivers/s390/char/tape_3590.c b/drivers/s390/char/tape_3590.c
new file mode 100644
index 0000000000..c3915f60a3
--- /dev/null
+++ b/drivers/s390/char/tape_3590.c
@@ -0,0 +1,1301 @@
+/*
+ *  drivers/s390/char/tape_3590.c
+ *    tape device discipline for 3590 tapes.
+ *
+ *    Copyright (C) IBM Corp. 2001,2006
+ *    Author(s): Stefan Bader <shbader@de.ibm.com>
+ *               Michael Holzheu <holzheu@de.ibm.com>
+ *               Martin Schwidefsky <schwidefsky@de.ibm.com>
+ */
+
+#include <linux/config.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/bio.h>
+
+#define TAPE_DBF_AREA   tape_3590_dbf
+
+#include "tape.h"
+#include "tape_std.h"
+#include "tape_3590.h"
+
+/*
+ * Pointer to debug area.
+ */
+debug_info_t *TAPE_DBF_AREA = NULL;
+EXPORT_SYMBOL(TAPE_DBF_AREA);
+
+/*******************************************************************
+ * Error Recovery fuctions:
+ * - Read Opposite:              implemented
+ * - Read Device (buffered) log: BRA
+ * - Read Library log:           BRA
+ * - Swap Devices:               BRA
+ * - Long Busy:                  BRA
+ * - Special Intercept:          BRA
+ * - Read Alternate:             implemented
+ *******************************************************************/
+
+#define PRINTK_HEADER "TAPE_3590: "
+
+static const char *tape_3590_msg[TAPE_3590_MAX_MSG] = {
+        [0x00] = "",
+        [0x10] = "Lost Sense",
+        [0x11] = "Assigned Elsewhere",
+        [0x12] = "Allegiance Reset",
+        [0x13] = "Shared Access Violation",
+        [0x20] = "Command Reject",
+        [0x21] = "Configuration Error",
+        [0x22] = "Protection Exception",
+        [0x23] = "Write Protect",
+        [0x24] = "Write Length",
+        [0x25] = "Read-Only Format",
+        [0x31] = "Beginning of Partition",
+        [0x33] = "End of Partition",
+        [0x34] = "End of Data",
+        [0x35] = "Block not found",
+        [0x40] = "Device Intervention",
+        [0x41] = "Loader Intervention",
+        [0x42] = "Library Intervention",
+        [0x50] = "Write Error",
+        [0x51] = "Erase Error",
+        [0x52] = "Formatting Error",
+        [0x53] = "Read Error",
+        [0x54] = "Unsupported Format",
+        [0x55] = "No Formatting",
+        [0x56] = "Positioning lost",
+        [0x57] = "Read Length",
+        [0x60] = "Unsupported Medium",
+        [0x61] = "Medium Length Error",
+        [0x62] = "Medium removed",
+        [0x64] = "Load Check",
+        [0x65] = "Unload Check",
+        [0x70] = "Equipment Check",
+        [0x71] = "Bus out Check",
+        [0x72] = "Protocol Error",
+        [0x73] = "Interface Error",
+        [0x74] = "Overrun",
+        [0x75] = "Halt Signal",
+        [0x90] = "Device fenced",
+        [0x91] = "Device Path fenced",
+        [0xa0] = "Volume misplaced",
+        [0xa1] = "Volume inaccessible",
+        [0xa2] = "Volume in input",
+        [0xa3] = "Volume ejected",
+        [0xa4] = "All categories reserved",
+        [0xa5] = "Duplicate Volume",
+        [0xa6] = "Library Manager Offline",
+        [0xa7] = "Library Output Station full",
+        [0xa8] = "Vision System non-operational",
+        [0xa9] = "Library Manager Equipment Check",
+        [0xaa] = "Library Equipment Check",
+        [0xab] = "All Library Cells full",
+        [0xac] = "No Cleaner Volumes in Library",
+        [0xad] = "I/O Station door open",
+        [0xae] = "Subsystem environmental alert",
+};
+
+/*
+ * 3590 IOCTL Overload
+ */
+static int
+tape_3590_ioctl(struct tape_device *device, unsigned int cmd, unsigned long arg)
+{
+        switch (cmd) {
+        case TAPE390_DISPLAY: {
+                struct display_struct disp;
+
+                if (copy_from_user(&disp, (char __user *) arg, sizeof(disp)))
+                        return -EFAULT;
+
+                return tape_std_display(device, &disp);
+        }
+        default:
+                return -EINVAL; /* no additional ioctls */
+        }
+}
+
+/*
+ * SENSE Medium: Get Sense data about medium state
+ */
+static int
+tape_3590_sense_medium(struct tape_device *device)
+{
+        struct tape_request *request;
+
+        request = tape_alloc_request(1, 128);
+        if (IS_ERR(request))
+                return PTR_ERR(request);
+        request->op = TO_MSEN;
+        tape_ccw_end(request->cpaddr, MEDIUM_SENSE, 128, request->cpdata);
+        return tape_do_io_free(device, request);
+}
+
+/*
+ * MTTELL: Tell block. Return the number of block relative to current file.
+ */
+static int
+tape_3590_mttell(struct tape_device *device, int mt_count)
+{
+        __u64 block_id;
+        int rc;
+
+        rc = tape_std_read_block_id(device, &block_id);
+        if (rc)
+                return rc;
+        return block_id >> 32;
+}
+
+/*
+ * MTSEEK: seek to the specified block.
+ */
+static int
+tape_3590_mtseek(struct tape_device *device, int count)
+{
+        struct tape_request *request;
+
+        DBF_EVENT(6, "xsee id: %x\n", count);
+        request = tape_alloc_request(3, 4);
+        if (IS_ERR(request))
+                return PTR_ERR(request);
+        request->op = TO_LBL;
+        tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1, device->modeset_byte);
+        *(__u32 *) request->cpdata = count;
+        tape_ccw_cc(request->cpaddr + 1, LOCATE, 4, request->cpdata);
+        tape_ccw_end(request->cpaddr + 2, NOP, 0, NULL);
+        return tape_do_io_free(device, request);
+}
+
+/*
+ * Read Opposite Error Recovery Function:
+ * Used, when Read Forward does not work
+ */
+static void
+tape_3590_read_opposite(struct tape_device *device,
+                        struct tape_request *request)
+{
+        struct tape_3590_disc_data *data;
+
+        /*
+         * We have allocated 4 ccws in tape_std_read, so we can now
+         * transform the request to a read backward, followed by a
+         * forward space block.
+         */
+        request->op = TO_RBA;
+        tape_ccw_cc(request->cpaddr, MODE_SET_DB, 1, device->modeset_byte);
+        data = device->discdata;
+        tape_ccw_cc_idal(request->cpaddr + 1, data->read_back_op,
+                         device->char_data.idal_buf);
+        tape_ccw_cc(request->cpaddr + 2, FORSPACEBLOCK, 0, NULL);
+        tape_ccw_end(request->cpaddr + 3, NOP, 0, NULL);
+        DBF_EVENT(6, "xrop ccwg\n");
+}
+
+/*
+ * Read Attention Msg
+ * This should be done after an interrupt with attention bit (0x80)
+ * in device state.
+ *
+ * After a "read attention message" request there are two possible
+ * results:
+ *
+ * 1. A unit check is presented, when attention sense is present (e.g. when
+ * a medium has been unloaded). The attention sense comes then
+ * together with the unit check. The recovery action is either "retry"
+ * (in case there is an attention message pending) or "permanent error".
+ *
+ * 2. The attention msg is written to the "read subsystem data" buffer.
+ * In this case we probably should print it to the console.
+ */
+static int
+tape_3590_read_attmsg(struct tape_device *device)
+{
+        struct tape_request *request;
+        char *buf;
+
+        request = tape_alloc_request(3, 4096);
+        if (IS_ERR(request))
+                return PTR_ERR(request);
+        request->op = TO_READ_ATTMSG;
+        buf = request->cpdata;
+        buf[0] = PREP_RD_SS_DATA;
+        buf[6] = RD_ATTMSG;     /* read att msg */
+        tape_ccw_cc(request->cpaddr, PERFORM_SS_FUNC, 12, buf);
+        tape_ccw_cc(request->cpaddr + 1, READ_SS_DATA, 4096 - 12, buf + 12);
+        tape_ccw_end(request->cpaddr + 2, NOP, 0, NULL);
+        return tape_do_io_free(device, request);
+}
+
+/*
+ * These functions are used to schedule follow-up actions from within an
+ * interrupt context (like unsolicited interrupts).
+ */
+static void
+tape_3590_work_handler(void *data)
+{
+        struct {
+                struct tape_device *device;
+                enum tape_op op;
+                struct work_struct work;
+        } *p = data;
+
+        switch (p->op) {
+        case TO_MSEN:
+                tape_3590_sense_medium(p->device);
+                break;
+        case TO_READ_ATTMSG:
+                tape_3590_read_attmsg(p->device);
+                break;
+        default:
+                DBF_EVENT(3, "T3590: work handler undefined for "
+                          "operation 0x%02x\n", p->op);
+        }
+        tape_put_device(p->device);
+        kfree(p);
+}
+
+static int
+tape_3590_schedule_work(struct tape_device *device, enum tape_op op)
+{
+        struct {
+                struct tape_device *device;
+                enum tape_op op;
+                struct work_struct work;
+        } *p;
+
+        if ((p = kzalloc(sizeof(*p), GFP_ATOMIC)) == NULL)
+                return -ENOMEM;
+
+        INIT_WORK(&p->work, tape_3590_work_handler, p);
+
+        p->device = tape_get_device_reference(device);
+        p->op = op;
+
+        schedule_work(&p->work);
+        return 0;
+}
+
+#ifdef CONFIG_S390_TAPE_BLOCK
+/*
+ * Tape Block READ
+ */
+static struct tape_request *
+tape_3590_bread(struct tape_device *device, struct request *req)
+{
+        struct tape_request *request;
+        struct ccw1 *ccw;
+        int count = 0, start_block, i;
+        unsigned off;
+        char *dst;
+        struct bio_vec *bv;
+        struct bio *bio;
+
+        DBF_EVENT(6, "xBREDid:");
+        start_block = req->sector >> TAPEBLOCK_HSEC_S2B;
+        DBF_EVENT(6, "start_block = %i\n", start_block);
+
+        rq_for_each_bio(bio, req) {
+                bio_for_each_segment(bv, bio, i) {
+                        count += bv->bv_len >> (TAPEBLOCK_HSEC_S2B + 9);
+                }
+        }
+        request = tape_alloc_request(2 + count + 1, 4);
+        if (IS_ERR(request))
+                return request;
+        request->op = TO_BLOCK;
+        *(__u32 *) request->cpdata = start_block;
+        ccw = request->cpaddr;
+        ccw = tape_ccw_cc(ccw, MODE_SET_DB, 1, device->modeset_byte);
+
+        /*
+         * We always setup a nop after the mode set ccw. This slot is
+         * used in tape_std_check_locate to insert a locate ccw if the
+         * current tape position doesn't match the start block to be read.
+         */
+        ccw = tape_ccw_cc(ccw, NOP, 0, NULL);
+
+        rq_for_each_bio(bio, req) {
+                bio_for_each_segment(bv, bio, i) {
+                        dst = kmap(bv->bv_page) + bv->bv_offset;
+                        for (off = 0; off < bv->bv_len;
+                             off += TAPEBLOCK_HSEC_SIZE) {
+                                ccw->flags = CCW_FLAG_CC;
+                                ccw->cmd_code = READ_FORWARD;
+                                ccw->count = TAPEBLOCK_HSEC_SIZE;
+                                set_normalized_cda(ccw, (void *) __pa(dst));
+                                ccw++;
+                                dst += TAPEBLOCK_HSEC_SIZE;
+                        }
+                        if (off > bv->bv_len)
+                                BUG();
+                }
+        }
+        ccw = tape_ccw_end(ccw, NOP, 0, NULL);
+        DBF_EVENT(6, "xBREDccwg\n");
+        return request;
+}
+
+static void
+tape_3590_free_bread(struct tape_request *request)
+{
+        struct ccw1 *ccw;
+
+        /* Last ccw is a nop and doesn't need clear_normalized_cda */
+        for (ccw = request->cpaddr; ccw->flags & CCW_FLAG_CC; ccw++)
+                if (ccw->cmd_code == READ_FORWARD)
+                        clear_normalized_cda(ccw);
+        tape_free_request(request);
+}
+
+/*
+ * check_locate is called just before the tape request is passed to
+ * the common io layer for execution. It has to check the current
+ * tape position and insert a locate ccw if it doesn't match the
+ * start block for the request.
+ */
+static void
+tape_3590_check_locate(struct tape_device *device, struct tape_request *request)
+{
+        __u32 *start_block;
+
+        start_block = (__u32 *) request->cpdata;
+        if (*start_block != device->blk_data.block_position) {
+                /* Add the start offset of the file to get the real block. */
+                *start_block += device->bof;
+                tape_ccw_cc(request->cpaddr + 1, LOCATE, 4, request->cpdata);
+        }
+}
+#endif
+
+/*
+ * The done handler is called at device/channel end and wakes up the sleeping
+ * process
+ */
+static int
+tape_3590_done(struct tape_device *device, struct tape_request *request)
+{
+        struct tape_3590_med_sense *sense;
+
+        DBF_EVENT(6, "%s done\n", tape_op_verbose[request->op]);
+
+        switch (request->op) {
+        case TO_BSB:
+        case TO_BSF:
+        case TO_DSE:
+        case TO_FSB:
+        case TO_FSF:
+        case TO_LBL:
+        case TO_RFO:
+        case TO_RBA:
+        case TO_REW:
+        case TO_WRI:
+        case TO_WTM:
+        case TO_BLOCK:
+        case TO_LOAD:
+                tape_med_state_set(device, MS_LOADED);
+                break;
+        case TO_RUN:
+                tape_med_state_set(device, MS_UNLOADED);
+                break;
+        case TO_MSEN:
+                sense = (struct tape_3590_med_sense *) request->cpdata;
+                if (sense->masst == MSENSE_UNASSOCIATED)
+                        tape_med_state_set(device, MS_UNLOADED);
+                if (sense->masst == MSENSE_ASSOCIATED_MOUNT)
+                        tape_med_state_set(device, MS_LOADED);
+                break;
+        case TO_RBI:    /* RBI seems to succeed even without medium loaded. */
+        case TO_NOP:    /* Same to NOP. */
+        case TO_READ_CONFIG:
+        case TO_READ_ATTMSG:
+        case TO_DIS:
+        case TO_ASSIGN:
+        case TO_UNASSIGN:
+                break;
+        case TO_SIZE:
+                break;
+        }
+        return TAPE_IO_SUCCESS;
+}
+
+/*
+ * This fuction is called, when error recovery was successfull
+ */
+static inline int
+tape_3590_erp_succeded(struct tape_device *device, struct tape_request *request)
+{
+        DBF_EVENT(3, "Error Recovery successfull for %s\n",
+                  tape_op_verbose[request->op]);
+        return tape_3590_done(device, request);
+}
+
+/*
+ * This fuction is called, when error recovery was not successfull
+ */
+static inline int
+tape_3590_erp_failed(struct tape_device *device, struct tape_request *request,
+                     struct irb *irb, int rc)
+{
+        DBF_EVENT(3, "Error Recovery failed for %s\n",
+                  tape_op_verbose[request->op]);
+        tape_dump_sense_dbf(device, request, irb);
+        return rc;
+}
+
+/*
+ * Error Recovery do retry
+ */
+static inline int
+tape_3590_erp_retry(struct tape_device *device, struct tape_request *request,
+                    struct irb *irb)
+{
+        DBF_EVENT(2, "Retry: %s\n", tape_op_verbose[request->op]);
+        tape_dump_sense_dbf(device, request, irb);
+        return TAPE_IO_RETRY;
+}
+
+/*
+ * Handle unsolicited interrupts
+ */
+static int
+tape_3590_unsolicited_irq(struct tape_device *device, struct irb *irb)
+{
+        if (irb->scsw.dstat == DEV_STAT_CHN_END)
+                /* Probably result of halt ssch */
+                return TAPE_IO_PENDING;
+        else if (irb->scsw.dstat == 0x85)
+                /* Device Ready -> check medium state */
+                tape_3590_schedule_work(device, TO_MSEN);
+        else if (irb->scsw.dstat & DEV_STAT_ATTENTION)
+                tape_3590_schedule_work(device, TO_READ_ATTMSG);
+        else {
+                DBF_EVENT(3, "unsol.irq! dev end: %08x\n", device->cdev_id);
+                PRINT_WARN("Unsolicited IRQ (Device End) caught.\n");
+                tape_dump_sense(device, NULL, irb);
+        }
+        return TAPE_IO_SUCCESS;
+}
+
+/*
+ * Basic Recovery routine
+ */
+static int
+tape_3590_erp_basic(struct tape_device *device, struct tape_request *request,
+                    struct irb *irb, int rc)
+{
+        struct tape_3590_sense *sense;
+
+        sense = (struct tape_3590_sense *) irb->ecw;
+
+        switch (sense->bra) {
+        case SENSE_BRA_PER:
+                return tape_3590_erp_failed(device, request, irb, rc);
+        case SENSE_BRA_CONT:
+                return tape_3590_erp_succeded(device, request);
+        case SENSE_BRA_RE:
+                return tape_3590_erp_retry(device, request, irb);
+        case SENSE_BRA_DRE:
+                return tape_3590_erp_failed(device, request, irb, rc);
+        default:
+                PRINT_ERR("Unknown BRA %x - This should not happen!\n",
+                          sense->bra);
+                BUG();
+                return TAPE_IO_STOP;
+        }
+}
+
+/*
+ *  RDL: Read Device (buffered) log
+ */
+static int
+tape_3590_erp_read_buf_log(struct tape_device *device,
+                           struct tape_request *request, struct irb *irb)
+{
+        /*
+         * We just do the basic error recovery at the moment (retry).
+         * Perhaps in the future, we read the log and dump it somewhere...
+         */
+        return tape_3590_erp_basic(device, request, irb, -EIO);
+}
+
+/*
+ *  SWAP: Swap Devices
+ */
+static int
+tape_3590_erp_swap(struct tape_device *device, struct tape_request *request,
+                   struct irb *irb)
+{
+        /*
+         * This error recovery should swap the tapes
+         * if the original has a problem. The operation
+         * should proceed with the new tape... this
+         * should probably be done in user space!
+         */
+        PRINT_WARN("(%s): Swap Tape Device!\n", device->cdev->dev.bus_id);
+        return tape_3590_erp_basic(device, request, irb, -EIO);
+}
+
+/*
+ *  LBY: Long Busy
+ */
+static int
+tape_3590_erp_long_busy(struct tape_device *device,
+                        struct tape_request *request, struct irb *irb)
+{
+        /* FIXME: how about WAITING for a minute ? */
+        PRINT_WARN("(%s): Device is busy! Please wait a minute!\n",
+                   device->cdev->dev.bus_id);
+        return tape_3590_erp_basic(device, request, irb, -EBUSY);
+}
+
+/*
+ *  SPI: Special Intercept
+ */
+static int
+tape_3590_erp_special_interrupt(struct tape_device *device,
+                                struct tape_request *request, struct irb *irb)
+{
+        return tape_3590_erp_basic(device, request, irb, -EIO);
+}
+
+/*
+ *  RDA: Read Alternate
+ */
+static int
+tape_3590_erp_read_alternate(struct tape_device *device,
+                             struct tape_request *request, struct irb *irb)
+{
+        struct tape_3590_disc_data *data;
+
+        /*
+         * The issued Read Backward or Read Previous command is not
+         * supported by the device
+         * The recovery action should be to issue another command:
+         * Read Revious: if Read Backward is not supported
+         * Read Backward: if Read Previous is not supported
+         */
+        data = device->discdata;
+        if (data->read_back_op == READ_PREVIOUS) {
+                DBF_EVENT(2, "(%08x): No support for READ_PREVIOUS command\n",
+                          device->cdev_id);
+                data->read_back_op = READ_BACKWARD;
+        } else {
+                DBF_EVENT(2, "(%08x): No support for READ_BACKWARD command\n",
+                          device->cdev_id);
+                data->read_back_op = READ_PREVIOUS;
+        }
+        tape_3590_read_opposite(device, request);
+        return tape_3590_erp_retry(device, request, irb);
+}
+
+/*
+ * Error Recovery read opposite
+ */
+static int
+tape_3590_erp_read_opposite(struct tape_device *device,
+                            struct tape_request *request, struct irb *irb)
+{
+        switch (request->op) {
+        case TO_RFO:
+                /*
+                 * We did read forward, but the data could not be read.
+                 * We will read backward and then skip forward again.
+                 */
+                tape_3590_read_opposite(device, request);
+                return tape_3590_erp_retry(device, request, irb);
+        case TO_RBA:
+                /* We tried to read forward and backward, but hat no success */
+                return tape_3590_erp_failed(device, request, irb, -EIO);
+                break;
+        default:
+                PRINT_WARN("read_opposite_recovery_called_with_op: %s\n",
+                           tape_op_verbose[request->op]);
+                return tape_3590_erp_failed(device, request, irb, -EIO);
+        }
+}
+
+/*
+ * Print an MIM (Media Information  Message) (message code f0)
+ */
+static void
+tape_3590_print_mim_msg_f0(struct tape_device *device, struct irb *irb)
+{
+        struct tape_3590_sense *sense;
+
+        sense = (struct tape_3590_sense *) irb->ecw;
+        /* Exception Message */
+        switch (sense->fmt.f70.emc) {
+        case 0x02:
+                PRINT_WARN("(%s): Data degraded\n", device->cdev->dev.bus_id);
+                break;
+        case 0x03:
+                PRINT_WARN("(%s): Data degraded in partion %i\n",
+                           device->cdev->dev.bus_id, sense->fmt.f70.mp);
+                break;
+        case 0x04:
+                PRINT_WARN("(%s): Medium degraded\n", device->cdev->dev.bus_id);
+                break;
+        case 0x05:
+                PRINT_WARN("(%s): Medium degraded in partition %i\n",
+                           device->cdev->dev.bus_id, sense->fmt.f70.mp);
+                break;
+        case 0x06:
+                PRINT_WARN("(%s): Block 0 Error\n", device->cdev->dev.bus_id);
+                break;
+        case 0x07:
+                PRINT_WARN("(%s): Medium Exception 0x%02x\n",
+                           device->cdev->dev.bus_id, sense->fmt.f70.md);
+                break;
+        default:
+                PRINT_WARN("(%s): MIM ExMsg: 0x%02x\n",
+                           device->cdev->dev.bus_id, sense->fmt.f70.emc);
+                break;
+        }
+        /* Service Message */
+        switch (sense->fmt.f70.smc) {
+        case 0x02:
+                PRINT_WARN("(%s): Reference Media maintenance procedure %i\n",
+                           device->cdev->dev.bus_id, sense->fmt.f70.md);
+                break;
+        default:
+                PRINT_WARN("(%s): MIM ServiceMsg: 0x%02x\n",
+                           device->cdev->dev.bus_id, sense->fmt.f70.smc);
+                break;
+        }
+}
+
+/*
+ * Print an I/O Subsystem Service Information Message (message code f1)
+ */
+static void
+tape_3590_print_io_sim_msg_f1(struct tape_device *device, struct irb *irb)
+{
+        struct tape_3590_sense *sense;
+
+        sense = (struct tape_3590_sense *) irb->ecw;
+        /* Exception Message */
+        switch (sense->fmt.f71.emc) {
+        case 0x01:
+                PRINT_WARN("(%s): Effect of failure is unknown\n",
+                           device->cdev->dev.bus_id);
+                break;
+        case 0x02:
+                PRINT_WARN("(%s): CU Exception - no performance impact\n",
+                           device->cdev->dev.bus_id);
+                break;
+        case 0x03:
+                PRINT_WARN("(%s): CU Exception on channel interface 0x%02x\n",
+                           device->cdev->dev.bus_id, sense->fmt.f71.md[0]);
+                break;
+        case 0x04:
+                PRINT_WARN("(%s): CU Exception on device path 0x%02x\n",
+                           device->cdev->dev.bus_id, sense->fmt.f71.md[0]);
+                break;
+        case 0x05:
+                PRINT_WARN("(%s): CU Exception on library path 0x%02x\n",
+                           device->cdev->dev.bus_id, sense->fmt.f71.md[0]);
+                break;
+        case 0x06:
+                PRINT_WARN("(%s): CU Exception on node 0x%02x\n",
+                           device->cdev->dev.bus_id, sense->fmt.f71.md[0]);
+                break;
+        case 0x07:
+                PRINT_WARN("(%s): CU Exception on partition 0x%02x\n",
+                           device->cdev->dev.bus_id, sense->fmt.f71.md[0]);
+                break;
+        default:
+                PRINT_WARN("(%s): SIM ExMsg: 0x%02x\n",
+                           device->cdev->dev.bus_id, sense->fmt.f71.emc);
+        }
+        /* Service Message */
+        switch (sense->fmt.f71.smc) {
+        case 0x01:
+                PRINT_WARN("(%s): Repair impact is unknown\n",
+                           device->cdev->dev.bus_id);
+                break;
+        case 0x02:
+                PRINT_WARN("(%s): Repair will not impact cu performance\n",
+                           device->cdev->dev.bus_id);
+                break;
+        case 0x03:
+                if (sense->fmt.f71.mdf == 0)
+                        PRINT_WARN("(%s): Repair will disable node "
+                                   "0x%x on CU\n",
+                                   device->cdev->dev.bus_id,
+                                   sense->fmt.f71.md[1]);
+                else
+                        PRINT_WARN("(%s): Repair will disable nodes "
+                                   "(0x%x-0x%x) on CU\n",
+                                   device->cdev->dev.bus_id,
+                                   sense->fmt.f71.md[1], sense->fmt.f71.md[2]);
+                break;
+        case 0x04:
+                if (sense->fmt.f71.mdf == 0)
+                        PRINT_WARN("(%s): Repair will disable cannel path "
+                                   "0x%x on CU\n",
+                                   device->cdev->dev.bus_id,
+                                   sense->fmt.f71.md[1]);
+                else
+                        PRINT_WARN("(%s): Repair will disable cannel paths "
+                                   "(0x%x-0x%x) on CU\n",
+                                   device->cdev->dev.bus_id,
+                                   sense->fmt.f71.md[1], sense->fmt.f71.md[2]);
+                break;
+        case 0x05:
+                if (sense->fmt.f71.mdf == 0)
+                        PRINT_WARN("(%s): Repair will disable device path "
+                                   "0x%x on CU\n",
+                                   device->cdev->dev.bus_id,
+                                   sense->fmt.f71.md[1]);
+                else
+                        PRINT_WARN("(%s): Repair will disable device paths "
+                                   "(0x%x-0x%x) on CU\n",
+                                   device->cdev->dev.bus_id,
+                                   sense->fmt.f71.md[1], sense->fmt.f71.md[2]);
+                break;
+        case 0x06:
+                if (sense->fmt.f71.mdf == 0)
+                        PRINT_WARN("(%s): Repair will disable library path "
+                                   "0x%x on CU\n",
+                                   device->cdev->dev.bus_id,
+                                   sense->fmt.f71.md[1]);
+                else
+                        PRINT_WARN("(%s): Repair will disable library paths "
+                                   "(0x%x-0x%x) on CU\n",
+                                   device->cdev->dev.bus_id,
+                                   sense->fmt.f71.md[1], sense->fmt.f71.md[2]);
+                break;
+        case 0x07:
+                PRINT_WARN("(%s): Repair will disable access to CU\n",
+                           device->cdev->dev.bus_id);
+                break;
+        default:
+                PRINT_WARN("(%s): SIM ServiceMsg: 0x%02x\n",
+                           device->cdev->dev.bus_id, sense->fmt.f71.smc);
+        }
+}
+
+/*
+ * Print an Device Subsystem Service Information Message (message code f2)
+ */
+static void
+tape_3590_print_dev_sim_msg_f2(struct tape_device *device, struct irb *irb)
+{
+        struct tape_3590_sense *sense;
+
+        sense = (struct tape_3590_sense *) irb->ecw;
+        /* Exception Message */
+        switch (sense->fmt.f71.emc) {
+        case 0x01:
+                PRINT_WARN("(%s): Effect of failure is unknown\n",
+                           device->cdev->dev.bus_id);
+                break;
+        case 0x02:
+                PRINT_WARN("(%s): DV Exception - no performance impact\n",
+                           device->cdev->dev.bus_id);
+                break;
+        case 0x03:
+                PRINT_WARN("(%s): DV Exception on channel interface 0x%02x\n",
+                           device->cdev->dev.bus_id, sense->fmt.f71.md[0]);
+                break;
+        case 0x04:
+                PRINT_WARN("(%s): DV Exception on loader 0x%02x\n",
+                           device->cdev->dev.bus_id, sense->fmt.f71.md[0]);
+                break;
+        case 0x05:
+                PRINT_WARN("(%s): DV Exception on message display 0x%02x\n",
+                           device->cdev->dev.bus_id, sense->fmt.f71.md[0]);
+                break;
+        case 0x06:
+                PRINT_WARN("(%s): DV Exception in tape path\n",
+                           device->cdev->dev.bus_id);
+                break;
+        case 0x07:
+                PRINT_WARN("(%s): DV Exception in drive\n",
+                           device->cdev->dev.bus_id);
+                break;
+        default:
+                PRINT_WARN("(%s): DSIM ExMsg: 0x%02x\n",
+                           device->cdev->dev.bus_id, sense->fmt.f71.emc);
+        }
+        /* Service Message */
+        switch (sense->fmt.f71.smc) {
+        case 0x01:
+                PRINT_WARN("(%s): Repair impact is unknown\n",
+                           device->cdev->dev.bus_id);
+                break;
+        case 0x02:
+                PRINT_WARN("(%s): Repair will not impact device performance\n",
+                           device->cdev->dev.bus_id);
+                break;
+        case 0x03:
+                if (sense->fmt.f71.mdf == 0)
+                        PRINT_WARN("(%s): Repair will disable channel path "
+                                   "0x%x on DV\n",
+                                   device->cdev->dev.bus_id,
+                                   sense->fmt.f71.md[1]);
+                else
+                        PRINT_WARN("(%s): Repair will disable channel path "
+                                   "(0x%x-0x%x) on DV\n",
+                                   device->cdev->dev.bus_id,
+                                   sense->fmt.f71.md[1], sense->fmt.f71.md[2]);
+                break;
+        case 0x04:
+                if (sense->fmt.f71.mdf == 0)
+                        PRINT_WARN("(%s): Repair will disable interface 0x%x "
+                                   "on DV\n",
+                                   device->cdev->dev.bus_id,
+                                   sense->fmt.f71.md[1]);
+                else
+                        PRINT_WARN("(%s): Repair will disable interfaces "
+                                   "(0x%x-0x%x) on DV\n",
+                                   device->cdev->dev.bus_id,
+                                   sense->fmt.f71.md[1], sense->fmt.f71.md[2]);
+                break;
+        case 0x05:
+                if (sense->fmt.f71.mdf == 0)
+                        PRINT_WARN("(%s): Repair will disable loader 0x%x "
+                                   "on DV\n",
+                                   device->cdev->dev.bus_id,
+                                   sense->fmt.f71.md[1]);
+                else
+                        PRINT_WARN("(%s): Repair will disable loader "
+                                   "(0x%x-0x%x) on DV\n",
+                                   device->cdev->dev.bus_id,
+                                   sense->fmt.f71.md[1], sense->fmt.f71.md[2]);
+                break;
+        case 0x07:
+                PRINT_WARN("(%s): Repair will disable access to DV\n",
+                           device->cdev->dev.bus_id);
+                break;
+        case 0x08:
+                if (sense->fmt.f71.mdf == 0)
+                        PRINT_WARN("(%s): Repair will disable message "
+                                   "display 0x%x on DV\n",
+                                   device->cdev->dev.bus_id,
+                                   sense->fmt.f71.md[1]);
+                else
+                        PRINT_WARN("(%s): Repair will disable message "
+                                   "displays (0x%x-0x%x) on DV\n",
+                                   device->cdev->dev.bus_id,
+                                   sense->fmt.f71.md[1], sense->fmt.f71.md[2]);
+                break;
+        case 0x09:
+                PRINT_WARN("(%s): Clean DV\n", device->cdev->dev.bus_id);
+                break;
+        default:
+                PRINT_WARN("(%s): DSIM ServiceMsg: 0x%02x\n",
+                           device->cdev->dev.bus_id, sense->fmt.f71.smc);
+        }
+}
+
+/*
+ * Print standard ERA Message
+ */
+static void
+tape_3590_print_era_msg(struct tape_device *device, struct irb *irb)
+{
+        struct tape_3590_sense *sense;
+
+        sense = (struct tape_3590_sense *) irb->ecw;
+        if (sense->mc == 0)
+                return;
+        if ((sense->mc > 0) && (sense->mc < TAPE_3590_MAX_MSG)) {
+                if (tape_3590_msg[sense->mc] != NULL)
+                        PRINT_WARN("(%s): %s\n", device->cdev->dev.bus_id,
+                                   tape_3590_msg[sense->mc]);
+                else {
+                        PRINT_WARN("(%s): Message Code 0x%x\n",
+                                   device->cdev->dev.bus_id, sense->mc);
+                }
+                return;
+        }
+        if (sense->mc == 0xf0) {
+                /* Standard Media Information Message */
+                PRINT_WARN("(%s): MIM SEV=%i, MC=%02x, ES=%x/%x, "
+                           "RC=%02x-%04x-%02x\n", device->cdev->dev.bus_id,
+                           sense->fmt.f70.sev, sense->mc,
+                           sense->fmt.f70.emc, sense->fmt.f70.smc,
+                           sense->fmt.f70.refcode, sense->fmt.f70.mid,
+                           sense->fmt.f70.fid);
+                tape_3590_print_mim_msg_f0(device, irb);
+                return;
+        }
+        if (sense->mc == 0xf1) {
+                /* Standard I/O Subsystem Service Information Message */
+                PRINT_WARN("(%s): IOSIM SEV=%i, DEVTYPE=3590/%02x, "
+                           "MC=%02x, ES=%x/%x, REF=0x%04x-0x%04x-0x%04x\n",
+                           device->cdev->dev.bus_id, sense->fmt.f71.sev,
+                           device->cdev->id.dev_model,
+                           sense->mc, sense->fmt.f71.emc,
+                           sense->fmt.f71.smc, sense->fmt.f71.refcode1,
+                           sense->fmt.f71.refcode2, sense->fmt.f71.refcode3);
+                tape_3590_print_io_sim_msg_f1(device, irb);
+                return;
+        }
+        if (sense->mc == 0xf2) {
+                /* Standard Device Service Information Message */
+                PRINT_WARN("(%s): DEVSIM SEV=%i, DEVTYPE=3590/%02x, "
+                           "MC=%02x, ES=%x/%x, REF=0x%04x-0x%04x-0x%04x\n",
+                           device->cdev->dev.bus_id, sense->fmt.f71.sev,
+                           device->cdev->id.dev_model,
+                           sense->mc, sense->fmt.f71.emc,
+                           sense->fmt.f71.smc, sense->fmt.f71.refcode1,
+                           sense->fmt.f71.refcode2, sense->fmt.f71.refcode3);
+                tape_3590_print_dev_sim_msg_f2(device, irb);
+                return;
+        }
+        if (sense->mc == 0xf3) {
+                /* Standard Library Service Information Message */
+                return;
+        }
+        PRINT_WARN("(%s): Device Message(%x)\n",
+                   device->cdev->dev.bus_id, sense->mc);
+}
+
+/*
+ *  3590 error Recovery routine:
+ *  If possible, it tries to recover from the error. If this is not possible,
+ *  inform the user about the problem.
+ */
+static int
+tape_3590_unit_check(struct tape_device *device, struct tape_request *request,
+                     struct irb *irb)
+{
+        struct tape_3590_sense *sense;
+        int rc;
+
+#ifdef CONFIG_S390_TAPE_BLOCK
+        if (request->op == TO_BLOCK) {
+                /*
+                 * Recovery for block device requests. Set the block_position
+                 * to something invalid and retry.
+                 */
+                device->blk_data.block_position = -1;
+                if (request->retries-- <= 0)
+                        return tape_3590_erp_failed(device, request, irb, -EIO);
+                else
+                        return tape_3590_erp_retry(device, request, irb);
+        }
+#endif
+
+        sense = (struct tape_3590_sense *) irb->ecw;
+
+        /*
+         * First check all RC-QRCs where we want to do something special
+         *   - "break":     basic error recovery is done
+         *   - "goto out:": just print error message if available
+         */
+        rc = -EIO;
+        switch (sense->rc_rqc) {
+
+        case 0x1110:
+                tape_3590_print_era_msg(device, irb);
+                return tape_3590_erp_read_buf_log(device, request, irb);
+
+        case 0x2011:
+                tape_3590_print_era_msg(device, irb);
+                return tape_3590_erp_read_alternate(device, request, irb);
+
+        case 0x2230:
+        case 0x2231:
+                tape_3590_print_era_msg(device, irb);
+                return tape_3590_erp_special_interrupt(device, request, irb);
+
+        case 0x3010:
+                DBF_EVENT(2, "(%08x): Backward at Beginning of Partition\n",
+                          device->cdev_id);
+                return tape_3590_erp_basic(device, request, irb, -ENOSPC);
+        case 0x3012:
+                DBF_EVENT(2, "(%08x): Forward at End of Partition\n",
+                          device->cdev_id);
+                return tape_3590_erp_basic(device, request, irb, -ENOSPC);
+        case 0x3020:
+                DBF_EVENT(2, "(%08x): End of Data Mark\n", device->cdev_id);
+                return tape_3590_erp_basic(device, request, irb, -ENOSPC);
+
+        case 0x3122:
+                DBF_EVENT(2, "(%08x): Rewind Unload initiated\n",
+                          device->cdev_id);
+                return tape_3590_erp_basic(device, request, irb, -EIO);
+        case 0x3123:
+                DBF_EVENT(2, "(%08x): Rewind Unload complete\n",
+                          device->cdev_id);
+                tape_med_state_set(device, MS_UNLOADED);
+                return tape_3590_erp_basic(device, request, irb, 0);
+
+        case 0x4010:
+                /*
+                 * print additional msg since default msg
+                 * "device intervention" is not very meaningfull
+                 */
+                PRINT_WARN("(%s): Tape operation when medium not loaded\n",
+                           device->cdev->dev.bus_id);
+                tape_med_state_set(device, MS_UNLOADED);
+                return tape_3590_erp_basic(device, request, irb, -ENOMEDIUM);
+        case 0x4012:            /* Device Long Busy */
+                tape_3590_print_era_msg(device, irb);
+                return tape_3590_erp_long_busy(device, request, irb);
+
+        case 0x5010:
+                if (sense->rac == 0xd0) {
+                        /* Swap */
+                        tape_3590_print_era_msg(device, irb);
+                        return tape_3590_erp_swap(device, request, irb);
+                }
+                if (sense->rac == 0x26) {
+                        /* Read Opposite */
+                        tape_3590_print_era_msg(device, irb);
+                        return tape_3590_erp_read_opposite(device, request,
+                                                           irb);
+                }
+                return tape_3590_erp_basic(device, request, irb, -EIO);
+        case 0x5020:
+        case 0x5021:
+        case 0x5022:
+        case 0x5040:
+        case 0x5041:
+        case 0x5042:
+                tape_3590_print_era_msg(device, irb);
+                return tape_3590_erp_swap(device, request, irb);
+
+        case 0x5110:
+        case 0x5111:
+                return tape_3590_erp_basic(device, request, irb, -EMEDIUMTYPE);
+
+        case 0x5120:
+        case 0x1120:
+                tape_med_state_set(device, MS_UNLOADED);
+                return tape_3590_erp_basic(device, request, irb, -ENOMEDIUM);
+
+        case 0x6020:
+                PRINT_WARN("(%s): Cartridge of wrong type ?\n",
+                           device->cdev->dev.bus_id);
+                return tape_3590_erp_basic(device, request, irb, -EMEDIUMTYPE);
+
+        case 0x8011:
+                PRINT_WARN("(%s): Another host has reserved the tape device\n",
+                           device->cdev->dev.bus_id);
+                return tape_3590_erp_basic(device, request, irb, -EPERM);
+        case 0x8013:
+                PRINT_WARN("(%s): Another host has priviliged access to the "
+                           "tape device\n", device->cdev->dev.bus_id);
+                PRINT_WARN("(%s): To solve the problem unload the current "
+                           "cartridge!\n", device->cdev->dev.bus_id);
+                return tape_3590_erp_basic(device, request, irb, -EPERM);
+        default:
+                return tape_3590_erp_basic(device, request, irb, -EIO);
+        }
+}
+
+/*
+ * 3590 interrupt handler:
+ */
+static int
+tape_3590_irq(struct tape_device *device, struct tape_request *request,
+              struct irb *irb)
+{
+        if (request == NULL)
+                return tape_3590_unsolicited_irq(device, irb);
+
+        if ((irb->scsw.dstat & DEV_STAT_UNIT_EXCEP) &&
+            (irb->scsw.dstat & DEV_STAT_DEV_END) && (request->op == TO_WRI)) {
+                /* Write at end of volume */
+                DBF_EVENT(2, "End of volume\n");
+                return tape_3590_erp_failed(device, request, irb, -ENOSPC);
+        }
+
+        if (irb->scsw.dstat & DEV_STAT_UNIT_CHECK)
+                return tape_3590_unit_check(device, request, irb);
+
+        if (irb->scsw.dstat & DEV_STAT_DEV_END) {
+                if (irb->scsw.dstat == DEV_STAT_UNIT_EXCEP) {
+                        if (request->op == TO_FSB || request->op == TO_BSB)
+                                request->rescnt++;
+                        else
+                                DBF_EVENT(5, "Unit Exception!\n");
+                }
+
+                return tape_3590_done(device, request);
+        }
+
+        if (irb->scsw.dstat & DEV_STAT_CHN_END) {
+                DBF_EVENT(2, "cannel end\n");
+                return TAPE_IO_PENDING;
+        }
+
+        if (irb->scsw.dstat & DEV_STAT_ATTENTION) {
+                DBF_EVENT(2, "Unit Attention when busy..\n");
+                return TAPE_IO_PENDING;
+        }
+
+        DBF_EVENT(6, "xunknownirq\n");
+        PRINT_ERR("Unexpected interrupt.\n");
+        PRINT_ERR("Current op is: %s", tape_op_verbose[request->op]);
+        tape_dump_sense(device, request, irb);
+        return TAPE_IO_STOP;
+}
+
+/*
+ * Setup device function
+ */
+static int
+tape_3590_setup_device(struct tape_device *device)
+{
+        int rc;
+        struct tape_3590_disc_data *data;
+
+        DBF_EVENT(6, "3590 device setup\n");
+        data = kmalloc(sizeof(struct tape_3590_disc_data),
+                       GFP_KERNEL | GFP_DMA);
+        if (data == NULL)
+                return -ENOMEM;
+        data->read_back_op = READ_PREVIOUS;
+        device->discdata = data;
+
+        if ((rc = tape_std_assign(device)) == 0) {
+                /* Try to find out if medium is loaded */
+                if ((rc = tape_3590_sense_medium(device)) != 0)
+                        DBF_LH(3, "3590 medium sense returned %d\n", rc);
+        }
+
+        return rc;
+}
+
+/*
+ * Cleanup device function
+ */
+static void
+tape_3590_cleanup_device(struct tape_device *device)
+{
+        tape_std_unassign(device);
+
+        kfree(device->discdata);
+        device->discdata = NULL;
+}
+
+/*
+ * List of 3590 magnetic tape commands.
+ */
+static tape_mtop_fn tape_3590_mtop[TAPE_NR_MTOPS] = {
+        [MTRESET]        = tape_std_mtreset,
+        [MTFSF]          = tape_std_mtfsf,
+        [MTBSF]          = tape_std_mtbsf,
+        [MTFSR]          = tape_std_mtfsr,
+        [MTBSR]          = tape_std_mtbsr,
+        [MTWEOF]         = tape_std_mtweof,
+        [MTREW]          = tape_std_mtrew,
+        [MTOFFL]         = tape_std_mtoffl,
+        [MTNOP]          = tape_std_mtnop,
+        [MTRETEN]        = tape_std_mtreten,
+        [MTBSFM]         = tape_std_mtbsfm,
+        [MTFSFM]         = tape_std_mtfsfm,
+        [MTEOM]          = tape_std_mteom,
+        [MTERASE]        = tape_std_mterase,
+        [MTRAS1]         = NULL,
+        [MTRAS2]         = NULL,
+        [MTRAS3]         = NULL,
+        [MTSETBLK]       = tape_std_mtsetblk,
+        [MTSETDENSITY]   = NULL,
+        [MTSEEK]         = tape_3590_mtseek,
+        [MTTELL]         = tape_3590_mttell,
+        [MTSETDRVBUFFER] = NULL,
+        [MTFSS]          = NULL,
+        [MTBSS]          = NULL,
+        [MTWSM]          = NULL,
+        [MTLOCK]         = NULL,
+        [MTUNLOCK]       = NULL,
+        [MTLOAD]         = tape_std_mtload,
+        [MTUNLOAD]       = tape_std_mtunload,
+        [MTCOMPRESSION]  = tape_std_mtcompression,
+        [MTSETPART]      = NULL,
+        [MTMKPART]       = NULL
+};
+
+/*
+ * Tape discipline structure for 3590.
+ */
+static struct tape_discipline tape_discipline_3590 = {
+        .owner = THIS_MODULE,
+        .setup_device = tape_3590_setup_device,
+        .cleanup_device = tape_3590_cleanup_device,
+        .process_eov = tape_std_process_eov,
+        .irq = tape_3590_irq,
+        .read_block = tape_std_read_block,
+        .write_block = tape_std_write_block,
+#ifdef CONFIG_S390_TAPE_BLOCK
+        .bread = tape_3590_bread,
+        .free_bread = tape_3590_free_bread,
+        .check_locate = tape_3590_check_locate,
+#endif
+        .ioctl_fn = tape_3590_ioctl,
+        .mtop_array = tape_3590_mtop
+};
+
+static struct ccw_device_id tape_3590_ids[] = {
+        {CCW_DEVICE_DEVTYPE(0x3590, 0, 0x3590, 0), .driver_info = tape_3590},
+        { /* end of list */ }
+};
+
+static int
+tape_3590_online(struct ccw_device *cdev)
+{
+        return tape_generic_online(cdev->dev.driver_data,
+                                   &tape_discipline_3590);
+}
+
+static int
+tape_3590_offline(struct ccw_device *cdev)
+{
+        return tape_generic_offline(cdev->dev.driver_data);
+}
+
+static struct ccw_driver tape_3590_driver = {
+        .name = "tape_3590",
+        .owner = THIS_MODULE,
+        .ids = tape_3590_ids,
+        .probe = tape_generic_probe,
+        .remove = tape_generic_remove,
+        .set_offline = tape_3590_offline,
+        .set_online = tape_3590_online,
+};
+
+/*
+ * Setup discipline structure.
+ */
+static int
+tape_3590_init(void)
+{
+        int rc;
+
+        TAPE_DBF_AREA = debug_register("tape_3590", 2, 2, 4 * sizeof(long));
+        debug_register_view(TAPE_DBF_AREA, &debug_sprintf_view);
+#ifdef DBF_LIKE_HELL
+        debug_set_level(TAPE_DBF_AREA, 6);
+#endif
+
+        DBF_EVENT(3, "3590 init\n");
+        /* Register driver for 3590 tapes. */
+        rc = ccw_driver_register(&tape_3590_driver);
+        if (rc)
+                DBF_EVENT(3, "3590 init failed\n");
+        else
+                DBF_EVENT(3, "3590 registered\n");
+        return rc;
+}
+
+static void
+tape_3590_exit(void)
+{
+        ccw_driver_unregister(&tape_3590_driver);
+
+        debug_unregister(TAPE_DBF_AREA);
+}
+
+MODULE_DEVICE_TABLE(ccw, tape_3590_ids);
+MODULE_AUTHOR("(C) 2001,2006 IBM Corporation");
+MODULE_DESCRIPTION("Linux on zSeries channel attached 3590 tape device driver");
+MODULE_LICENSE("GPL");
+
+module_init(tape_3590_init);
+module_exit(tape_3590_exit);
diff --git a/drivers/s390/char/tape_3590.h b/drivers/s390/char/tape_3590.h
new file mode 100644
index 0000000000..cf274b9445
--- /dev/null
+++ b/drivers/s390/char/tape_3590.h
@@ -0,0 +1,124 @@
+/*
+ *  drivers/s390/char/tape_3590.h
+ *    tape device discipline for 3590 tapes.
+ *
+ *    Copyright (C) IBM Corp. 2001,2006
+ *    Author(s): Stefan Bader <shbader@de.ibm.com>
+ *               Michael Holzheu <holzheu@de.ibm.com>
+ *               Martin Schwidefsky <schwidefsky@de.ibm.com>
+ */
+
+#ifndef _TAPE_3590_H
+#define _TAPE_3590_H
+
+#define MEDIUM_SENSE    0xc2
+#define READ_PREVIOUS   0x0a
+#define MODE_SENSE      0xcf
+#define PERFORM_SS_FUNC 0x77
+#define READ_SS_DATA    0x3e
+
+#define PREP_RD_SS_DATA 0x18
+#define RD_ATTMSG       0x3
+
+#define SENSE_BRA_PER  0
+#define SENSE_BRA_CONT 1
+#define SENSE_BRA_RE   2
+#define SENSE_BRA_DRE  3
+
+#define SENSE_FMT_LIBRARY       0x23
+#define SENSE_FMT_UNSOLICITED   0x40
+#define SENSE_FMT_COMMAND_REJ   0x41
+#define SENSE_FMT_COMMAND_EXEC0 0x50
+#define SENSE_FMT_COMMAND_EXEC1 0x51
+#define SENSE_FMT_EVENT0        0x60
+#define SENSE_FMT_EVENT1        0x61
+#define SENSE_FMT_MIM           0x70
+#define SENSE_FMT_SIM           0x71
+
+#define MSENSE_UNASSOCIATED      0x00
+#define MSENSE_ASSOCIATED_MOUNT  0x01
+#define MSENSE_ASSOCIATED_UMOUNT 0x02
+
+#define TAPE_3590_MAX_MSG        0xb0
+
+/* Datatypes */
+
+struct tape_3590_disc_data {
+        unsigned char modeset_byte;
+        int read_back_op;
+};
+
+struct tape_3590_sense {
+
+        unsigned int command_rej:1;
+        unsigned int interv_req:1;
+        unsigned int bus_out_check:1;
+        unsigned int eq_check:1;
+        unsigned int data_check:1;
+        unsigned int overrun:1;
+        unsigned int def_unit_check:1;
+        unsigned int assgnd_elsew:1;
+
+        unsigned int locate_fail:1;
+        unsigned int inst_online:1;
+        unsigned int reserved:1;
+        unsigned int blk_seq_err:1;
+        unsigned int begin_part:1;
+        unsigned int wr_mode:1;
+        unsigned int wr_prot:1;
+        unsigned int not_cap:1;
+
+        unsigned int bra:2;
+        unsigned int lc:3;
+        unsigned int vlf_active:1;
+        unsigned int stm:1;
+        unsigned int med_pos:1;
+
+        unsigned int rac:8;
+
+        unsigned int rc_rqc:16;
+
+        unsigned int mc:8;
+
+        unsigned int sense_fmt:8;
+
+        union {
+                struct {
+                        unsigned int emc:4;
+                        unsigned int smc:4;
+                        unsigned int sev:2;
+                        unsigned int reserved:6;
+                        unsigned int md:8;
+                        unsigned int refcode:8;
+                        unsigned int mid:16;
+                        unsigned int mp:16;
+                        unsigned char volid[6];
+                        unsigned int fid:8;
+                } f70;
+                struct {
+                        unsigned int emc:4;
+                        unsigned int smc:4;
+                        unsigned int sev:2;
+                        unsigned int reserved1:5;
+                        unsigned int mdf:1;
+                        unsigned char md[3];
+                        unsigned int simid:8;
+                        unsigned int uid:16;
+                        unsigned int refcode1:16;
+                        unsigned int refcode2:16;
+                        unsigned int refcode3:16;
+                        unsigned int reserved2:8;
+                } f71;
+                unsigned char data[14];
+        } fmt;
+        unsigned char pad[10];
+
+} __attribute__ ((packed));
+
+struct tape_3590_med_sense {
+        unsigned int macst:4;
+        unsigned int masst:4;
+        char pad[127];
+} __attribute__ ((packed));
+
+#endif /* _TAPE_3590_H */
diff --git a/drivers/s390/char/tape_class.c b/drivers/s390/char/tape_class.c
index b3569c82bb..a5c68e60fc 100644
--- a/drivers/s390/char/tape_class.c
+++ b/drivers/s390/char/tape_class.c
@@ -44,11 +44,10 @@ struct tape_class_device *register_tape_dev(
         int             rc;
         char *          s;
 
-        tcd = kmalloc(sizeof(struct tape_class_device), GFP_KERNEL);
+        tcd = kzalloc(sizeof(struct tape_class_device), GFP_KERNEL);
         if (!tcd)
                 return ERR_PTR(-ENOMEM);
 
-        memset(tcd, 0, sizeof(struct tape_class_device));
         strncpy(tcd->device_name, device_name, TAPECLASS_NAME_LEN);
         for (s = strchr(tcd->device_name, '/'); s; s = strchr(s, '/'))
                 *s = '!';
diff --git a/drivers/s390/char/tape_core.c b/drivers/s390/char/tape_core.c
index 4ea438c749..389ee2c0f4 100644
--- a/drivers/s390/char/tape_core.c
+++ b/drivers/s390/char/tape_core.c
@@ -453,16 +453,14 @@ tape_alloc_device(void)
 {
         struct tape_device *device;
 
-        device = (struct tape_device *)
-                kmalloc(sizeof(struct tape_device), GFP_KERNEL);
+        device = kzalloc(sizeof(struct tape_device), GFP_KERNEL);
         if (device == NULL) {
                 DBF_EXCEPTION(2, "ti:no mem\n");
                 PRINT_INFO ("can't allocate memory for "
                             "tape info structure\n");
                 return ERR_PTR(-ENOMEM);
         }
-        memset(device, 0, sizeof(struct tape_device));
-        device->modeset_byte = (char *) kmalloc(1, GFP_KERNEL | GFP_DMA);
+        device->modeset_byte = kmalloc(1, GFP_KERNEL | GFP_DMA);
         if (device->modeset_byte == NULL) {
                 DBF_EXCEPTION(2, "ti:no mem\n");
                 PRINT_INFO("can't allocate memory for modeset byte\n");
@@ -659,34 +657,30 @@ tape_alloc_request(int cplength, int datasize)
 
         DBF_LH(6, "tape_alloc_request(%d, %d)\n", cplength, datasize);
 
-        request = (struct tape_request *) kmalloc(sizeof(struct tape_request),
-                                                  GFP_KERNEL);
+        request = kzalloc(sizeof(struct tape_request), GFP_KERNEL);
         if (request == NULL) {
                 DBF_EXCEPTION(1, "cqra nomem\n");
                 return ERR_PTR(-ENOMEM);
         }
-        memset(request, 0, sizeof(struct tape_request));
         /* allocate channel program */
         if (cplength > 0) {
-                request->cpaddr = kmalloc(cplength*sizeof(struct ccw1),
+                request->cpaddr = kcalloc(cplength, sizeof(struct ccw1),
                                           GFP_ATOMIC | GFP_DMA);
                 if (request->cpaddr == NULL) {
                         DBF_EXCEPTION(1, "cqra nomem\n");
                         kfree(request);
                         return ERR_PTR(-ENOMEM);
                 }
-                memset(request->cpaddr, 0, cplength*sizeof(struct ccw1));
         }
         /* alloc small kernel buffer */
         if (datasize > 0) {
-                request->cpdata = kmalloc(datasize, GFP_KERNEL | GFP_DMA);
+                request->cpdata = kzalloc(datasize, GFP_KERNEL | GFP_DMA);
                 if (request->cpdata == NULL) {
                         DBF_EXCEPTION(1, "cqra nomem\n");
                         kfree(request->cpaddr);
                         kfree(request);
                         return ERR_PTR(-ENOMEM);
                 }
-                memset(request->cpdata, 0, datasize);
         }
         DBF_LH(6, "New request %p(%p/%p)\n", request, request->cpaddr,
                 request->cpdata);
@@ -761,6 +755,13 @@ __tape_start_next_request(struct tape_device *device)
                  */
                 if (request->status == TAPE_REQUEST_IN_IO)
                         return;
+                /*
+                 * Request has already been stopped. We have to wait until
+                 * the request is removed from the queue in the interrupt
+                 * handling.
+                 */
+                if (request->status == TAPE_REQUEST_DONE)
+                        return;
 
                 /*
                  * We wanted to cancel the request but the common I/O layer
@@ -1015,7 +1016,7 @@ tape_do_io_interruptible(struct tape_device *device,
                                 wq,
                                 (request->callback == NULL)
                         );
-                } while (rc != -ERESTARTSYS);
+                } while (rc == -ERESTARTSYS);
 
                 DBF_EVENT(3, "IO stopped on %08x\n", device->cdev_id);
                 rc = -ERESTARTSYS;
@@ -1024,6 +1025,20 @@ tape_do_io_interruptible(struct tape_device *device,
 }
 
 /*
+ * Stop running ccw.
+ */
+int
+tape_cancel_io(struct tape_device *device, struct tape_request *request)
+{
+        int rc;
+
+        spin_lock_irq(get_ccwdev_lock(device->cdev));
+        rc = __tape_cancel_io(device, request);
+        spin_unlock_irq(get_ccwdev_lock(device->cdev));
+        return rc;
+}
+
+/*
  * Tape interrupt routine, called from the ccw_device layer
  */
 static void
@@ -1064,15 +1079,16 @@ __tape_do_irq (struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
         /*
          * If the condition code is not zero and the start function bit is
          * still set, this is an deferred error and the last start I/O did
-         * not succeed. Restart the request now.
+         * not succeed. At this point the condition that caused the deferred
+         * error might still apply. So we just schedule the request to be
+         * started later.
          */
-        if (irb->scsw.cc != 0 && (irb->scsw.fctl & SCSW_FCTL_START_FUNC)) {
-                PRINT_WARN("(%s): deferred cc=%i. restaring\n",
-                        cdev->dev.bus_id,
-                        irb->scsw.cc);
-                rc = __tape_start_io(device, request);
-                if (rc)
-                        __tape_end_request(device, request, rc);
+        if (irb->scsw.cc != 0 && (irb->scsw.fctl & SCSW_FCTL_START_FUNC) &&
+            (request->status == TAPE_REQUEST_IN_IO)) {
+                DBF_EVENT(3,"(%08x): deferred cc=%i, fctl=%i. restarting\n",
+                        device->cdev_id, irb->scsw.cc, irb->scsw.fctl);
+                request->status = TAPE_REQUEST_QUEUED;
+                schedule_delayed_work(&device->tape_dnr, HZ);
                 return;
         }
 
@@ -1286,4 +1302,5 @@ EXPORT_SYMBOL(tape_dump_sense_dbf);
 EXPORT_SYMBOL(tape_do_io);
 EXPORT_SYMBOL(tape_do_io_async);
 EXPORT_SYMBOL(tape_do_io_interruptible);
+EXPORT_SYMBOL(tape_cancel_io);
 EXPORT_SYMBOL(tape_mtop);
diff --git a/drivers/s390/char/tape_std.c b/drivers/s390/char/tape_std.c
index 2f9fe30989..99cf881f41 100644
--- a/drivers/s390/char/tape_std.c
+++ b/drivers/s390/char/tape_std.c
@@ -37,20 +37,19 @@ tape_std_assign_timeout(unsigned long data)
 {
         struct tape_request *   request;
         struct tape_device *    device;
+        int rc;
 
         request = (struct tape_request *) data;
         if ((device = request->device) == NULL)
                 BUG();
 
-        spin_lock_irq(get_ccwdev_lock(device->cdev));
-        if (request->callback != NULL) {
-                DBF_EVENT(3, "%08x: Assignment timeout. Device busy.\n",
+        DBF_EVENT(3, "%08x: Assignment timeout. Device busy.\n",
                         device->cdev_id);
-                PRINT_ERR("%s: Assignment timeout. Device busy.\n",
-                        device->cdev->dev.bus_id);
-                ccw_device_clear(device->cdev, (long) request);
-        }
-        spin_unlock_irq(get_ccwdev_lock(device->cdev));
+        rc = tape_cancel_io(device, request);
+        if(rc)
+                PRINT_ERR("(%s): Assign timeout: Cancel failed with rc = %i\n",
+                        device->cdev->dev.bus_id, rc);
+
 }
 
 int
diff --git a/drivers/s390/char/tape_std.h b/drivers/s390/char/tape_std.h
index 3ab6aafb73..2d311798ed 100644
--- a/drivers/s390/char/tape_std.h
+++ b/drivers/s390/char/tape_std.h
@@ -1,9 +1,8 @@
 /*
- *  drivers/s390/char/tape_34xx.h
+ *  drivers/s390/char/tape_std.h
  *    standard tape device functions for ibm tapes.
  *
- *  S390 and zSeries version
- *    Copyright (C) 2001,2002 IBM Deutschland Entwicklung GmbH, IBM Corporation
+ *    Copyright (C) IBM Corp. 2001,2006
  *    Author(s): Carsten Otte <cotte@de.ibm.com>
  *               Tuan Ngo-Anh <ngoanh@de.ibm.com>
  *               Martin Schwidefsky <schwidefsky@de.ibm.com>
@@ -149,4 +148,11 @@ void tape_std_error_recovery_do_retry(struct tape_device *);
 void tape_std_error_recovery_read_opposite(struct tape_device *);
 void tape_std_error_recovery_HWBUG(struct tape_device *, int condno);
 
+/* S390 tape types */
+enum s390_tape_type {
+        tape_3480,
+        tape_3490,
+        tape_3590,
+};
+
 #endif // _TAPE_STD_H
diff --git a/drivers/s390/char/tty3270.c b/drivers/s390/char/tty3270.c
index 4b90693703..9a14177687 100644
--- a/drivers/s390/char/tty3270.c
+++ b/drivers/s390/char/tty3270.c
@@ -691,10 +691,9 @@ tty3270_alloc_view(void)
         struct tty3270 *tp;
         int pages;
 
-        tp = kmalloc(sizeof(struct tty3270),GFP_KERNEL);
+        tp = kzalloc(sizeof(struct tty3270), GFP_KERNEL);
         if (!tp)
                 goto out_err;
-        memset(tp, 0, sizeof(struct tty3270));
         tp->freemem_pages =
                 kmalloc(sizeof(void *) * TTY3270_STRING_PAGES, GFP_KERNEL);
         if (!tp->freemem_pages)
@@ -767,16 +766,14 @@ tty3270_alloc_screen(struct tty3270 *tp)
         int lines;
 
         size = sizeof(struct tty3270_line) * (tp->view.rows - 2);
-        tp->screen = kmalloc(size, GFP_KERNEL);
+        tp->screen = kzalloc(size, GFP_KERNEL);
         if (!tp->screen)
                 goto out_err;
-        memset(tp->screen, 0, size);
         for (lines = 0; lines < tp->view.rows - 2; lines++) {
                 size = sizeof(struct tty3270_cell) * tp->view.cols;
-                tp->screen[lines].cells = kmalloc(size, GFP_KERNEL);
+                tp->screen[lines].cells = kzalloc(size, GFP_KERNEL);
                 if (!tp->screen[lines].cells)
                         goto out_screen;
-                memset(tp->screen[lines].cells, 0, size);
         }
         return 0;
 out_screen:
diff --git a/drivers/s390/char/vmlogrdr.c b/drivers/s390/char/vmlogrdr.c
index b2d75de144..c625b69ebd 100644
--- a/drivers/s390/char/vmlogrdr.c
+++ b/drivers/s390/char/vmlogrdr.c
@@ -759,9 +759,8 @@ vmlogrdr_register_device(struct vmlogrdr_priv_t *priv) {
         struct device *dev;
         int ret;
 
-        dev = kmalloc(sizeof(struct device), GFP_KERNEL);
+        dev = kzalloc(sizeof(struct device), GFP_KERNEL);
         if (dev) {
-                memset(dev, 0, sizeof(struct device));
                 snprintf(dev->bus_id, BUS_ID_SIZE, "%s",
                          priv->internal_name);
                 dev->bus = &iucv_bus;
diff --git a/drivers/s390/cio/ccwgroup.c b/drivers/s390/cio/ccwgroup.c
index 8013c8eb76..bdfee7fbaa 100644
--- a/drivers/s390/cio/ccwgroup.c
+++ b/drivers/s390/cio/ccwgroup.c
@@ -157,11 +157,10 @@ ccwgroup_create(struct device *root,
         if (argc > 256) /* disallow dumb users */
                 return -EINVAL;
 
-        gdev = kmalloc(sizeof(*gdev) + argc*sizeof(gdev->cdev[0]), GFP_KERNEL);
+        gdev = kzalloc(sizeof(*gdev) + argc*sizeof(gdev->cdev[0]), GFP_KERNEL);
         if (!gdev)
                 return -ENOMEM;
 
-        memset(gdev, 0, sizeof(*gdev) + argc*sizeof(gdev->cdev[0]));
         atomic_set(&gdev->onoff, 0);
 
         del_drvdata = 0;
diff --git a/drivers/s390/cio/chsc.c b/drivers/s390/cio/chsc.c
index f4183d6602..6412b2c3ed 100644
--- a/drivers/s390/cio/chsc.c
+++ b/drivers/s390/cio/chsc.c
@@ -98,10 +98,8 @@ chsc_get_sch_desc_irq(struct subchannel *sch, void *page)
 
         ssd_area = page;
 
-        ssd_area->request = (struct chsc_header) {
-                .length = 0x0010,
-                .code   = 0x0004,
-        };
+        ssd_area->request.length = 0x0010;
+        ssd_area->request.code = 0x0004;
 
         ssd_area->ssid = sch->schid.ssid;
         ssd_area->f_sch = sch->schid.sch_no;
@@ -517,10 +515,8 @@ chsc_process_crw(void)
                 struct device *dev;
                 memset(sei_area, 0, sizeof(*sei_area));
                 memset(&res_data, 0, sizeof(struct res_acc_data));
-                sei_area->request = (struct chsc_header) {
-                        .length = 0x0010,
-                        .code   = 0x000e,
-                };
+                sei_area->request.length = 0x0010;
+                sei_area->request.code = 0x000e;
 
                 ccode = chsc(sei_area);
                 if (ccode > 0)
@@ -875,6 +871,264 @@ s390_vary_chpid( __u8 chpid, int on)
 }
 
 /*
+ * Channel measurement related functions
+ */
+static ssize_t
+chp_measurement_chars_read(struct kobject *kobj, char *buf, loff_t off,
+                           size_t count)
+{
+        struct channel_path *chp;
+        unsigned int size;
+
+        chp = to_channelpath(container_of(kobj, struct device, kobj));
+        if (!chp->cmg_chars)
+                return 0;
+
+        size = sizeof(struct cmg_chars);
+
+        if (off > size)
+                return 0;
+        if (off + count > size)
+                count = size - off;
+        memcpy(buf, chp->cmg_chars + off, count);
+        return count;
+}
+
+static struct bin_attribute chp_measurement_chars_attr = {
+        .attr = {
+                .name = "measurement_chars",
+                .mode = S_IRUSR,
+                .owner = THIS_MODULE,
+        },
+        .size = sizeof(struct cmg_chars),
+        .read = chp_measurement_chars_read,
+};
+
+static void
+chp_measurement_copy_block(struct cmg_entry *buf,
+                           struct channel_subsystem *css, int chpid)
+{
+        void *area;
+        struct cmg_entry *entry, reference_buf;
+        int idx;
+
+        if (chpid < 128) {
+                area = css->cub_addr1;
+                idx = chpid;
+        } else {
+                area = css->cub_addr2;
+                idx = chpid - 128;
+        }
+        entry = area + (idx * sizeof(struct cmg_entry));
+        do {
+                memcpy(buf, entry, sizeof(*entry));
+                memcpy(&reference_buf, entry, sizeof(*entry));
+        } while (reference_buf.values[0] != buf->values[0]);
+}
+
+static ssize_t
+chp_measurement_read(struct kobject *kobj, char *buf, loff_t off, size_t count)
+{
+        struct channel_path *chp;
+        struct channel_subsystem *css;
+        unsigned int size;
+
+        chp = to_channelpath(container_of(kobj, struct device, kobj));
+        css = to_css(chp->dev.parent);
+
+        size = sizeof(struct cmg_chars);
+
+        /* Only allow single reads. */
+        if (off || count < size)
+                return 0;
+        chp_measurement_copy_block((struct cmg_entry *)buf, css, chp->id);
+        return count;
+}
+
+static struct bin_attribute chp_measurement_attr = {
+        .attr = {
+                .name = "measurement",
+                .mode = S_IRUSR,
+                .owner = THIS_MODULE,
+        },
+        .size = sizeof(struct cmg_entry),
+        .read = chp_measurement_read,
+};
+
+static void
+chsc_remove_chp_cmg_attr(struct channel_path *chp)
+{
+        sysfs_remove_bin_file(&chp->dev.kobj, &chp_measurement_chars_attr);
+        sysfs_remove_bin_file(&chp->dev.kobj, &chp_measurement_attr);
+}
+
+static int
+chsc_add_chp_cmg_attr(struct channel_path *chp)
+{
+        int ret;
+
+        ret = sysfs_create_bin_file(&chp->dev.kobj,
+                                    &chp_measurement_chars_attr);
+        if (ret)
+                return ret;
+        ret = sysfs_create_bin_file(&chp->dev.kobj, &chp_measurement_attr);
+        if (ret)
+                sysfs_remove_bin_file(&chp->dev.kobj,
+                                      &chp_measurement_chars_attr);
+        return ret;
+}
+
+static void
+chsc_remove_cmg_attr(struct channel_subsystem *css)
+{
+        int i;
+
+        for (i = 0; i <= __MAX_CHPID; i++) {
+                if (!css->chps[i])
+                        continue;
+                chsc_remove_chp_cmg_attr(css->chps[i]);
+        }
+}
+
+static int
+chsc_add_cmg_attr(struct channel_subsystem *css)
+{
+        int i, ret;
+
+        ret = 0;
+        for (i = 0; i <= __MAX_CHPID; i++) {
+                if (!css->chps[i])
+                        continue;
+                ret = chsc_add_chp_cmg_attr(css->chps[i]);
+                if (ret)
+                        goto cleanup;
+        }
+        return ret;
+cleanup:
+        for (--i; i >= 0; i--) {
+                if (!css->chps[i])
+                        continue;
+                chsc_remove_chp_cmg_attr(css->chps[i]);
+        }
+        return ret;
+}
+
+
+static int
+__chsc_do_secm(struct channel_subsystem *css, int enable, void *page)
+{
+        struct {
+                struct chsc_header request;
+                u32 operation_code : 2;
+                u32 : 30;
+                u32 key : 4;
+                u32 : 28;
+                u32 zeroes1;
+                u32 cub_addr1;
+                u32 zeroes2;
+                u32 cub_addr2;
+                u32 reserved[13];
+                struct chsc_header response;
+                u32 status : 8;
+                u32 : 4;
+                u32 fmt : 4;
+                u32 : 16;
+        } *secm_area;
+        int ret, ccode;
+
+        secm_area = page;
+        secm_area->request.length = 0x0050;
+        secm_area->request.code = 0x0016;
+
+        secm_area->key = PAGE_DEFAULT_KEY;
+        secm_area->cub_addr1 = (u64)(unsigned long)css->cub_addr1;
+        secm_area->cub_addr2 = (u64)(unsigned long)css->cub_addr2;
+
+        secm_area->operation_code = enable ? 0 : 1;
+
+        ccode = chsc(secm_area);
+        if (ccode > 0)
+                return (ccode == 3) ? -ENODEV : -EBUSY;
+
+        switch (secm_area->response.code) {
+        case 0x0001: /* Success. */
+                ret = 0;
+                break;
+        case 0x0003: /* Invalid block. */
+        case 0x0007: /* Invalid format. */
+        case 0x0008: /* Other invalid block. */
+                CIO_CRW_EVENT(2, "Error in chsc request block!\n");
+                ret = -EINVAL;
+                break;
+        case 0x0004: /* Command not provided in model. */
+                CIO_CRW_EVENT(2, "Model does not provide secm\n");
+                ret = -EOPNOTSUPP;
+                break;
+        case 0x0102: /* cub adresses incorrect */
+                CIO_CRW_EVENT(2, "Invalid addresses in chsc request block\n");
+                ret = -EINVAL;
+                break;
+        case 0x0103: /* key error */
+                CIO_CRW_EVENT(2, "Access key error in secm\n");
+                ret = -EINVAL;
+                break;
+        case 0x0105: /* error while starting */
+                CIO_CRW_EVENT(2, "Error while starting channel measurement\n");
+                ret = -EIO;
+                break;
+        default:
+                CIO_CRW_EVENT(2, "Unknown CHSC response %d\n",
+                              secm_area->response.code);
+                ret = -EIO;
+        }
+        return ret;
+}
+
+int
+chsc_secm(struct channel_subsystem *css, int enable)
+{
+        void  *secm_area;
+        int ret;
+
+        secm_area = (void *)get_zeroed_page(GFP_KERNEL |  GFP_DMA);
+        if (!secm_area)
+                return -ENOMEM;
+
+        mutex_lock(&css->mutex);
+        if (enable && !css->cm_enabled) {
+                css->cub_addr1 = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
+                css->cub_addr2 = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
+                if (!css->cub_addr1 || !css->cub_addr2) {
+                        free_page((unsigned long)css->cub_addr1);
+                        free_page((unsigned long)css->cub_addr2);
+                        free_page((unsigned long)secm_area);
+                        mutex_unlock(&css->mutex);
+                        return -ENOMEM;
+                }
+        }
+        ret = __chsc_do_secm(css, enable, secm_area);
+        if (!ret) {
+                css->cm_enabled = enable;
+                if (css->cm_enabled) {
+                        ret = chsc_add_cmg_attr(css);
+                        if (ret) {
+                                memset(secm_area, 0, PAGE_SIZE);
+                                __chsc_do_secm(css, 0, secm_area);
+                                css->cm_enabled = 0;
+                        }
+                } else
+                        chsc_remove_cmg_attr(css);
+        }
+        if (enable && !css->cm_enabled) {
+                free_page((unsigned long)css->cub_addr1);
+                free_page((unsigned long)css->cub_addr2);
+        }
+        mutex_unlock(&css->mutex);
+        free_page((unsigned long)secm_area);
+        return ret;
+}
+
+/*
  * Files for the channel path entries.
  */
 static ssize_t
@@ -925,9 +1179,39 @@ chp_type_show(struct device *dev, struct device_attribute *attr, char *buf)
 
 static DEVICE_ATTR(type, 0444, chp_type_show, NULL);
 
+static ssize_t
+chp_cmg_show(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        struct channel_path *chp = to_channelpath(dev);
+
+        if (!chp)
+                return 0;
+        if (chp->cmg == -1) /* channel measurements not available */
+                return sprintf(buf, "unknown\n");
+        return sprintf(buf, "%x\n", chp->cmg);
+}
+
+static DEVICE_ATTR(cmg, 0444, chp_cmg_show, NULL);
+
+static ssize_t
+chp_shared_show(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        struct channel_path *chp = to_channelpath(dev);
+
+        if (!chp)
+                return 0;
+        if (chp->shared == -1) /* channel measurements not available */
+                return sprintf(buf, "unknown\n");
+        return sprintf(buf, "%x\n", chp->shared);
+}
+
+static DEVICE_ATTR(shared, 0444, chp_shared_show, NULL);
+
 static struct attribute * chp_attrs[] = {
         &dev_attr_status.attr,
         &dev_attr_type.attr,
+        &dev_attr_cmg.attr,
+        &dev_attr_shared.attr,
         NULL,
 };
 
@@ -966,10 +1250,8 @@ chsc_determine_channel_path_description(int chpid,
         if (!scpd_area)
                 return -ENOMEM;
 
-        scpd_area->request = (struct chsc_header) {
-                .length = 0x0010,
-                .code   = 0x0002,
-        };
+        scpd_area->request.length = 0x0010;
+        scpd_area->request.code = 0x0002;
 
         scpd_area->first_chpid = chpid;
         scpd_area->last_chpid = chpid;
@@ -1006,6 +1288,111 @@ out:
         return ret;
 }
 
+static void
+chsc_initialize_cmg_chars(struct channel_path *chp, u8 cmcv,
+                          struct cmg_chars *chars)
+{
+        switch (chp->cmg) {
+        case 2:
+        case 3:
+                chp->cmg_chars = kmalloc(sizeof(struct cmg_chars),
+                                         GFP_KERNEL);
+                if (chp->cmg_chars) {
+                        int i, mask;
+                        struct cmg_chars *cmg_chars;
+
+                        cmg_chars = chp->cmg_chars;
+                        for (i = 0; i < NR_MEASUREMENT_CHARS; i++) {
+                                mask = 0x80 >> (i + 3);
+                                if (cmcv & mask)
+                                        cmg_chars->values[i] = chars->values[i];
+                                else
+                                        cmg_chars->values[i] = 0;
+                        }
+                }
+                break;
+        default:
+                /* No cmg-dependent data. */
+                break;
+        }
+}
+
+static int
+chsc_get_channel_measurement_chars(struct channel_path *chp)
+{
+        int ccode, ret;
+
+        struct {
+                struct chsc_header request;
+                u32 : 24;
+                u32 first_chpid : 8;
+                u32 : 24;
+                u32 last_chpid : 8;
+                u32 zeroes1;
+                struct chsc_header response;
+                u32 zeroes2;
+                u32 not_valid : 1;
+                u32 shared : 1;
+                u32 : 22;
+                u32 chpid : 8;
+                u32 cmcv : 5;
+                u32 : 11;
+                u32 cmgq : 8;
+                u32 cmg : 8;
+                u32 zeroes3;
+                u32 data[NR_MEASUREMENT_CHARS];
+        } *scmc_area;
+
+        scmc_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
+        if (!scmc_area)
+                return -ENOMEM;
+
+        scmc_area->request.length = 0x0010;
+        scmc_area->request.code = 0x0022;
+
+        scmc_area->first_chpid = chp->id;
+        scmc_area->last_chpid = chp->id;
+
+        ccode = chsc(scmc_area);
+        if (ccode > 0) {
+                ret = (ccode == 3) ? -ENODEV : -EBUSY;
+                goto out;
+        }
+
+        switch (scmc_area->response.code) {
+        case 0x0001: /* Success. */
+                if (!scmc_area->not_valid) {
+                        chp->cmg = scmc_area->cmg;
+                        chp->shared = scmc_area->shared;
+                        chsc_initialize_cmg_chars(chp, scmc_area->cmcv,
+                                                  (struct cmg_chars *)
+                                                  &scmc_area->data);
+                } else {
+                        chp->cmg = -1;
+                        chp->shared = -1;
+                }
+                ret = 0;
+                break;
+        case 0x0003: /* Invalid block. */
+        case 0x0007: /* Invalid format. */
+        case 0x0008: /* Invalid bit combination. */
+                CIO_CRW_EVENT(2, "Error in chsc request block!\n");
+                ret = -EINVAL;
+                break;
+        case 0x0004: /* Command not provided. */
+                CIO_CRW_EVENT(2, "Model does not provide scmc\n");
+                ret = -EOPNOTSUPP;
+                break;
+        default:
+                CIO_CRW_EVENT(2, "Unknown CHSC response %d\n",
+                              scmc_area->response.code);
+                ret = -EIO;
+        }
+out:
+        free_page((unsigned long)scmc_area);
+        return ret;
+}
+
 /*
  * Entries for chpids on the system bus.
  * This replaces /proc/chpids.
@@ -1016,10 +1403,9 @@ new_channel_path(int chpid)
         struct channel_path *chp;
         int ret;
 
-        chp = kmalloc(sizeof(struct channel_path), GFP_KERNEL);
+        chp = kzalloc(sizeof(struct channel_path), GFP_KERNEL);
         if (!chp)
                 return -ENOMEM;
-        memset(chp, 0, sizeof(struct channel_path));
 
         /* fill in status, etc. */
         chp->id = chpid;
@@ -1034,6 +1420,22 @@ new_channel_path(int chpid)
         ret = chsc_determine_channel_path_description(chpid, &chp->desc);
         if (ret)
                 goto out_free;
+        /* Get channel-measurement characteristics. */
+        if (css_characteristics_avail && css_chsc_characteristics.scmc
+            && css_chsc_characteristics.secm) {
+                ret = chsc_get_channel_measurement_chars(chp);
+                if (ret)
+                        goto out_free;
+        } else {
+                static int msg_done;
+
+                if (!msg_done) {
+                        printk(KERN_WARNING "cio: Channel measurements not "
+                               "available, continuing.\n");
+                        msg_done = 1;
+                }
+                chp->cmg = -1;
+        }
 
         /* make it known to the system */
         ret = device_register(&chp->dev);
@@ -1046,8 +1448,19 @@ new_channel_path(int chpid)
         if (ret) {
                 device_unregister(&chp->dev);
                 goto out_free;
-        } else
-                css[0]->chps[chpid] = chp;
+        }
+        mutex_lock(&css[0]->mutex);
+        if (css[0]->cm_enabled) {
+                ret = chsc_add_chp_cmg_attr(chp);
+                if (ret) {
+                        sysfs_remove_group(&chp->dev.kobj, &chp_attr_group);
+                        device_unregister(&chp->dev);
+                        mutex_unlock(&css[0]->mutex);
+                        goto out_free;
+                }
+        }
+        css[0]->chps[chpid] = chp;
+        mutex_unlock(&css[0]->mutex);
         return ret;
 out_free:
         kfree(chp);
@@ -1103,10 +1516,8 @@ chsc_enable_facility(int operation_code)
         sda_area = (void *)get_zeroed_page(GFP_KERNEL|GFP_DMA);
         if (!sda_area)
                 return -ENOMEM;
-        sda_area->request = (struct chsc_header) {
-                .length = 0x0400,
-                .code = 0x0031,
-        };
+        sda_area->request.length = 0x0400;
+        sda_area->request.code = 0x0031;
         sda_area->operation_code = operation_code;
 
         ret = chsc(sda_area);
@@ -1161,10 +1572,8 @@ chsc_determine_css_characteristics(void)
                 return -ENOMEM;
         }
 
-        scsc_area->request = (struct chsc_header) {
-                .length = 0x0010,
-                .code   = 0x0010,
-        };
+        scsc_area->request.length = 0x0010;
+        scsc_area->request.code = 0x0010;
 
         result = chsc(scsc_area);
         if (result) {
diff --git a/drivers/s390/cio/chsc.h b/drivers/s390/cio/chsc.h
index 3e75095f35..a259245780 100644
--- a/drivers/s390/cio/chsc.h
+++ b/drivers/s390/cio/chsc.h
@@ -12,6 +12,16 @@ struct chsc_header {
         u16 code;
 };
 
+#define NR_MEASUREMENT_CHARS 5
+struct cmg_chars {
+        u32 values[NR_MEASUREMENT_CHARS];
+};
+
+#define NR_MEASUREMENT_ENTRIES 8
+struct cmg_entry {
+        u32 values[NR_MEASUREMENT_ENTRIES];
+};
+
 struct channel_path_desc {
         u8 flags;
         u8 lsn;
@@ -27,6 +37,10 @@ struct channel_path {
         int id;
         int state;
         struct channel_path_desc desc;
+        /* Channel-measurement related stuff: */
+        int cmg;
+        int shared;
+        void *cmg_chars;
         struct device dev;
 };
 
@@ -52,7 +66,11 @@ struct css_general_char {
 
 struct css_chsc_char {
         u64 res;
-        u64 : 43;
+        u64 : 20;
+        u32 secm : 1; /* bit 84 */
+        u32 : 1;
+        u32 scmc : 1; /* bit 86 */
+        u32 : 20;
         u32 scssc : 1;  /* bit 107 */
         u32 scsscf : 1; /* bit 108 */
         u32 : 19;
@@ -67,6 +85,8 @@ extern int css_characteristics_avail;
 extern void *chsc_get_chp_desc(struct subchannel*, int);
 
 extern int chsc_enable_facility(int);
+struct channel_subsystem;
+extern int chsc_secm(struct channel_subsystem *, int);
 
 #define to_channelpath(device) container_of(device, struct channel_path, dev)
 
diff --git a/drivers/s390/cio/css.c b/drivers/s390/cio/css.c
index 3c77d65960..74ea8aac4b 100644
--- a/drivers/s390/cio/css.c
+++ b/drivers/s390/cio/css.c
@@ -452,15 +452,50 @@ channel_subsystem_release(struct device *dev)
         struct channel_subsystem *css;
 
         css = to_css(dev);
+        mutex_destroy(&css->mutex);
         kfree(css);
 }
 
+static ssize_t
+css_cm_enable_show(struct device *dev, struct device_attribute *attr,
+                   char *buf)
+{
+        struct channel_subsystem *css = to_css(dev);
+
+        if (!css)
+                return 0;
+        return sprintf(buf, "%x\n", css->cm_enabled);
+}
+
+static ssize_t
+css_cm_enable_store(struct device *dev, struct device_attribute *attr,
+                    const char *buf, size_t count)
+{
+        struct channel_subsystem *css = to_css(dev);
+        int ret;
+
+        switch (buf[0]) {
+        case '0':
+                ret = css->cm_enabled ? chsc_secm(css, 0) : 0;
+                break;
+        case '1':
+                ret = css->cm_enabled ? 0 : chsc_secm(css, 1);
+                break;
+        default:
+                ret = -EINVAL;
+        }
+        return ret < 0 ? ret : count;
+}
+
+static DEVICE_ATTR(cm_enable, 0644, css_cm_enable_show, css_cm_enable_store);
+
 static inline void __init
 setup_css(int nr)
 {
         u32 tod_high;
 
         memset(css[nr], 0, sizeof(struct channel_subsystem));
+        mutex_init(&css[nr]->mutex);
         css[nr]->valid = 1;
         css[nr]->cssid = nr;
         sprintf(css[nr]->device.bus_id, "css%x", nr);
@@ -507,6 +542,9 @@ init_channel_subsystem (void)
                 ret = device_register(&css[i]->device);
                 if (ret)
                         goto out_free;
+                if (css_characteristics_avail && css_chsc_characteristics.secm)
+                        device_create_file(&css[i]->device,
+                                           &dev_attr_cm_enable);
         }
         css_init_done = 1;
 
@@ -519,6 +557,9 @@ out_free:
 out_unregister:
         while (i > 0) {
                 i--;
+                if (css_characteristics_avail && css_chsc_characteristics.secm)
+                        device_remove_file(&css[i]->device,
+                                           &dev_attr_cm_enable);
                 device_unregister(&css[i]->device);
         }
 out_bus:
@@ -589,10 +630,9 @@ css_enqueue_subchannel_slow(struct subchannel_id schid)
         struct slow_subchannel *new_slow_sch;
         unsigned long flags;
 
-        new_slow_sch = kmalloc(sizeof(struct slow_subchannel), GFP_ATOMIC);
+        new_slow_sch = kzalloc(sizeof(struct slow_subchannel), GFP_ATOMIC);
         if (!new_slow_sch)
                 return -ENOMEM;
-        memset(new_slow_sch, 0, sizeof(struct slow_subchannel));
         new_slow_sch->schid = schid;
         spin_lock_irqsave(&slow_subchannel_lock, flags);
         list_add_tail(&new_slow_sch->slow_list, &slow_subchannels_head);
diff --git a/drivers/s390/cio/css.h b/drivers/s390/cio/css.h
index b6375861cb..74a257b233 100644
--- a/drivers/s390/cio/css.h
+++ b/drivers/s390/cio/css.h
@@ -1,6 +1,7 @@
 #ifndef _CSS_H
 #define _CSS_H
 
+#include <linux/mutex.h>
 #include <linux/wait.h>
 #include <linux/workqueue.h>
 
@@ -150,6 +151,11 @@ struct channel_subsystem {
         struct channel_path *chps[__MAX_CHPID + 1];
         struct device device;
         struct pgid global_pgid;
+        struct mutex mutex;
+        /* channel measurement related */
+        int cm_enabled;
+        void *cub_addr1;
+        void *cub_addr2;
 };
 #define to_css(dev) container_of(dev, struct channel_subsystem, device)
 
diff --git a/drivers/s390/cio/device.c b/drivers/s390/cio/device.c
index afc4e88551..8e3053c2a4 100644
--- a/drivers/s390/cio/device.c
+++ b/drivers/s390/cio/device.c
@@ -826,17 +826,15 @@ io_subchannel_probe (struct subchannel *sch)
                         get_device(&cdev->dev);
                 return 0;
         }
-        cdev  = kmalloc (sizeof(*cdev), GFP_KERNEL);
+        cdev = kzalloc (sizeof(*cdev), GFP_KERNEL);
         if (!cdev)
                 return -ENOMEM;
-        memset(cdev, 0, sizeof(struct ccw_device));
-        cdev->private = kmalloc(sizeof(struct ccw_device_private), 
+        cdev->private = kzalloc(sizeof(struct ccw_device_private),
                                 GFP_KERNEL | GFP_DMA);
         if (!cdev->private) {
                 kfree(cdev);
                 return -ENOMEM;
         }
-        memset(cdev->private, 0, sizeof(struct ccw_device_private));
         atomic_set(&cdev->private->onoff, 0);
         cdev->dev = (struct device) {
                 .parent = &sch->dev,
diff --git a/drivers/s390/cio/device_fsm.c b/drivers/s390/cio/device_fsm.c
index b302779e7c..180b3bf8b9 100644
--- a/drivers/s390/cio/device_fsm.c
+++ b/drivers/s390/cio/device_fsm.c
@@ -827,6 +827,17 @@ ccw_device_w4sense(struct ccw_device *cdev, enum dev_event dev_event)
                 }
                 return;
         }
+        /*
+         * Check if a halt or clear has been issued in the meanwhile. If yes,
+         * only deliver the halt/clear interrupt to the device driver as if it
+         * had killed the original request.
+         */
+        if (irb->scsw.fctl & (SCSW_FCTL_CLEAR_FUNC | SCSW_FCTL_HALT_FUNC)) {
+                cdev->private->flags.dosense = 0;
+                memset(&cdev->private->irb, 0, sizeof(struct irb));
+                ccw_device_accumulate_irb(cdev, irb);
+                goto call_handler;
+        }
         /* Add basic sense info to irb. */
         ccw_device_accumulate_basic_sense(cdev, irb);
         if (cdev->private->flags.dosense) {
@@ -834,6 +845,7 @@ ccw_device_w4sense(struct ccw_device *cdev, enum dev_event dev_event)
                 ccw_device_do_sense(cdev, irb);
                 return;
         }
+call_handler:
         cdev->private->state = DEV_STATE_ONLINE;
         /* Call the handler. */
         if (ccw_device_call_handler(cdev) && cdev->private->flags.doverify)
diff --git a/drivers/s390/cio/device_ops.c b/drivers/s390/cio/device_ops.c
index 3a50b19032..795abb5a65 100644
--- a/drivers/s390/cio/device_ops.c
+++ b/drivers/s390/cio/device_ops.c
@@ -359,10 +359,9 @@ read_dev_chars (struct ccw_device *cdev, void **buffer, int length)
         CIO_TRACE_EVENT (4, "rddevch");
         CIO_TRACE_EVENT (4, sch->dev.bus_id);
 
-        rdc_ccw = kmalloc(sizeof(struct ccw1), GFP_KERNEL | GFP_DMA);
+        rdc_ccw = kzalloc(sizeof(struct ccw1), GFP_KERNEL | GFP_DMA);
         if (!rdc_ccw)
                 return -ENOMEM;
-        memset(rdc_ccw, 0, sizeof(struct ccw1));
         rdc_ccw->cmd_code = CCW_CMD_RDC;
         rdc_ccw->count = length;
         rdc_ccw->flags = CCW_FLAG_SLI;
@@ -426,16 +425,14 @@ read_conf_data_lpm (struct ccw_device *cdev, void **buffer, int *length, __u8 lp
         if (!ciw || ciw->cmd == 0)
                 return -EOPNOTSUPP;
 
-        rcd_ccw = kmalloc(sizeof(struct ccw1), GFP_KERNEL | GFP_DMA);
+        rcd_ccw = kzalloc(sizeof(struct ccw1), GFP_KERNEL | GFP_DMA);
         if (!rcd_ccw)
                 return -ENOMEM;
-        memset(rcd_ccw, 0, sizeof(struct ccw1));
-        rcd_buf = kmalloc(ciw->count, GFP_KERNEL | GFP_DMA);
+        rcd_buf = kzalloc(ciw->count, GFP_KERNEL | GFP_DMA);
         if (!rcd_buf) {
                 kfree(rcd_ccw);
                 return -ENOMEM;
         }
-        memset (rcd_buf, 0, ciw->count);
         rcd_ccw->cmd_code = ciw->cmd;
         rcd_ccw->cda = (__u32) __pa (rcd_buf);
         rcd_ccw->count = ciw->count;
diff --git a/drivers/s390/cio/qdio.c b/drivers/s390/cio/qdio.c
index 9ed37dc9a1..814f9258ce 100644
--- a/drivers/s390/cio/qdio.c
+++ b/drivers/s390/cio/qdio.c
@@ -1686,16 +1686,14 @@ qdio_alloc_qs(struct qdio_irq *irq_ptr,
         int result=-ENOMEM;
 
         for (i=0;i<no_input_qs;i++) {
-                q=kmalloc(sizeof(struct qdio_q),GFP_KERNEL);
+                q = kzalloc(sizeof(struct qdio_q), GFP_KERNEL);
 
                 if (!q) {
                         QDIO_PRINT_ERR("kmalloc of q failed!\n");
                         goto out;
                 }
 
-                memset(q,0,sizeof(struct qdio_q));
-
-                q->slib=kmalloc(PAGE_SIZE,GFP_KERNEL);
+                q->slib = kmalloc(PAGE_SIZE, GFP_KERNEL);
                 if (!q->slib) {
                         QDIO_PRINT_ERR("kmalloc of slib failed!\n");
                         goto out;
@@ -1705,14 +1703,12 @@ qdio_alloc_qs(struct qdio_irq *irq_ptr,
         }
 
         for (i=0;i<no_output_qs;i++) {
-                q=kmalloc(sizeof(struct qdio_q),GFP_KERNEL);
+                q = kzalloc(sizeof(struct qdio_q), GFP_KERNEL);
 
                 if (!q) {
                         goto out;
                 }
 
-                memset(q,0,sizeof(struct qdio_q));
-
                 q->slib=kmalloc(PAGE_SIZE,GFP_KERNEL);
                 if (!q->slib) {
                         QDIO_PRINT_ERR("kmalloc of slib failed!\n");
@@ -2984,7 +2980,7 @@ qdio_allocate(struct qdio_initialize *init_data)
         qdio_allocate_do_dbf(init_data);
 
         /* create irq */
-        irq_ptr=kmalloc(sizeof(struct qdio_irq), GFP_KERNEL | GFP_DMA);
+        irq_ptr = kzalloc(sizeof(struct qdio_irq), GFP_KERNEL | GFP_DMA);
 
         QDIO_DBF_TEXT0(0,setup,"irq_ptr:");
         QDIO_DBF_HEX0(0,setup,&irq_ptr,sizeof(void*));
@@ -2994,8 +2990,6 @@ qdio_allocate(struct qdio_initialize *init_data)
                 return -ENOMEM;
         }
 
-        memset(irq_ptr,0,sizeof(struct qdio_irq));
-
         init_MUTEX(&irq_ptr->setting_up_sema);
 
         /* QDR must be in DMA area since CCW data address is only 32 bit */
@@ -3686,10 +3680,10 @@ qdio_get_qdio_memory(void)
 
         for (i=1;i<INDICATORS_PER_CACHELINE;i++)
                 indicator_used[i]=0;
-        indicators=(__u32*)kmalloc(sizeof(__u32)*(INDICATORS_PER_CACHELINE),
+        indicators = kzalloc(sizeof(__u32)*(INDICATORS_PER_CACHELINE),
                                    GFP_KERNEL);
-        if (!indicators) return -ENOMEM;
-        memset(indicators,0,sizeof(__u32)*(INDICATORS_PER_CACHELINE));
+        if (!indicators)
+                return -ENOMEM;
         return 0;
 }
 
diff --git a/drivers/s390/crypto/z90hardware.c b/drivers/s390/crypto/z90hardware.c
index 4141919da8..be60795f4a 100644
--- a/drivers/s390/crypto/z90hardware.c
+++ b/drivers/s390/crypto/z90hardware.c
@@ -2214,7 +2214,7 @@ ICACRT_msg_to_type50CRT_msg(struct ica_rsa_modexpo_crt *icaMsg_p,
                 long_len = 128;
         }
 
-        tmp_size = ((mod_len <= 128) ? TYPE50_CRB1_LEN : TYPE50_CRB2_LEN) +
+        tmp_size = ((long_len <= 64) ? TYPE50_CRB1_LEN : TYPE50_CRB2_LEN) +
                     CALLER_HEADER;
 
         memset(z90cMsg_p, 0, tmp_size);
@@ -2479,8 +2479,16 @@ convert_response(unsigned char *response, unsigned char *buffer,
 
         if (reply_code)
                 switch (reply_code) {
+                case REP82_ERROR_MACHINE_FAILURE:
+                        if (errh_p->type == TYPE82_RSP_CODE)
+                                PRINTKW("Machine check failure\n");
+                        else
+                                PRINTKW("Module failure\n");
+                        return REC_HARDWAR_ERR;
                 case REP82_ERROR_OPERAND_INVALID:
+                        return REC_OPERAND_INV;
                 case REP88_ERROR_MESSAGE_MALFORMD:
+                        PRINTKW("Message malformed\n");
                         return REC_OPERAND_INV;
                 case REP82_ERROR_OPERAND_SIZE:
                         return REC_OPERAND_SIZE;
diff --git a/drivers/s390/crypto/z90main.c b/drivers/s390/crypto/z90main.c
index 7d6f19030e..982acc7303 100644
--- a/drivers/s390/crypto/z90main.c
+++ b/drivers/s390/crypto/z90main.c
@@ -1,9 +1,9 @@
 /*
  *  linux/drivers/s390/crypto/z90main.c
  *
- *  z90crypt 1.3.2
+ *  z90crypt 1.3.3
  *
- *  Copyright (C)  2001, 2004 IBM Corporation
+ *  Copyright (C)  2001, 2005 IBM Corporation
  *  Author(s): Robert Burroughs (burrough@us.ibm.com)
  *             Eric Rossman (edrossma@us.ibm.com)
  *
@@ -707,13 +707,12 @@ z90crypt_open(struct inode *inode, struct file *filp)
         if (quiesce_z90crypt)
                 return -EQUIESCE;
 
-        private_data_p = kmalloc(sizeof(struct priv_data), GFP_KERNEL);
+        private_data_p = kzalloc(sizeof(struct priv_data), GFP_KERNEL);
         if (!private_data_p) {
                 PRINTK("Memory allocate failed\n");
                 return -ENOMEM;
         }
 
-        memset((void *)private_data_p, 0, sizeof(struct priv_data));
         private_data_p->status = STAT_OPEN;
         private_data_p->opener_pid = PID();
         filp->private_data = private_data_p;
@@ -991,6 +990,7 @@ remove_device(struct device *device_p)
  * PCIXCC_MCL2   512-2048     ----- (applying any GA LIC will make an MCL3 card)
  * PCIXCC_MCL3   -----        128-2048
  * CEX2C         512-2048     128-2048
+ * CEX2A          ??-2048     same (the lower limit is less than 128 bit...)
  *
  * ext_bitlens (extended bitlengths) is a global, since you should not apply an
  * MCL to just one card in a machine. We assume, at first, that all cards have
@@ -2736,13 +2736,11 @@ create_z90crypt(int *cdx_p)
         z90crypt.max_count = Z90CRYPT_NUM_DEVS;
         z90crypt.cdx = *cdx_p;
 
-        hdware_blk_p = (struct hdware_block *)
-                kmalloc(sizeof(struct hdware_block), GFP_ATOMIC);
+        hdware_blk_p = kzalloc(sizeof(struct hdware_block), GFP_ATOMIC);
         if (!hdware_blk_p) {
                 PDEBUG("kmalloc for hardware block failed\n");
                 return ENOMEM;
         }
-        memset(hdware_blk_p, 0x00, sizeof(struct hdware_block));
         z90crypt.hdware_info = hdware_blk_p;
 
         return 0;
@@ -2977,12 +2975,11 @@ create_crypto_device(int index)
                 total_size = sizeof(struct device) +
                              z90crypt.q_depth_array[index] * sizeof(int);
 
-                dev_ptr = (struct device *) kmalloc(total_size, GFP_ATOMIC);
+                dev_ptr = kzalloc(total_size, GFP_ATOMIC);
                 if (!dev_ptr) {
                         PRINTK("kmalloc device %d failed\n", index);
                         return ENOMEM;
                 }
-                memset(dev_ptr, 0, total_size);
                 dev_ptr->dev_resp_p = kmalloc(MAX_RESPONSE_SIZE, GFP_ATOMIC);
                 if (!dev_ptr->dev_resp_p) {
                         kfree(dev_ptr);
diff --git a/drivers/s390/net/claw.c b/drivers/s390/net/claw.c
index acd2a3f005..23d53bf9da 100644
--- a/drivers/s390/net/claw.c
+++ b/drivers/s390/net/claw.c
@@ -310,7 +310,7 @@ claw_probe(struct ccwgroup_device *cgdev)
         printk(KERN_INFO "claw: variable cgdev =\n");
         dumpit((char *)cgdev, sizeof(struct ccwgroup_device));
 #endif
-        privptr = kmalloc(sizeof(struct claw_privbk), GFP_KERNEL);
+        privptr = kzalloc(sizeof(struct claw_privbk), GFP_KERNEL);
         if (privptr == NULL) {
                 probe_error(cgdev);
                 put_device(&cgdev->dev);
@@ -319,7 +319,6 @@ claw_probe(struct ccwgroup_device *cgdev)
                 CLAW_DBF_TEXT_(2,setup,"probex%d",-ENOMEM);
                 return -ENOMEM;
         }
-        memset(privptr,0x00,sizeof(struct claw_privbk));
         privptr->p_mtc_envelope= kmalloc( MAX_ENVELOPE_SIZE, GFP_KERNEL);
         privptr->p_env = kmalloc(sizeof(struct claw_env), GFP_KERNEL);
         if ((privptr->p_mtc_envelope==NULL) || (privptr->p_env==NULL)) {
diff --git a/drivers/s390/net/fsm.c b/drivers/s390/net/fsm.c
index 6caf5fa6a3..7145e2134c 100644
--- a/drivers/s390/net/fsm.c
+++ b/drivers/s390/net/fsm.c
@@ -21,38 +21,34 @@ init_fsm(char *name, const char **state_names, const char **event_names, int nr_
         fsm_function_t *m;
         fsm *f;
 
-        this = (fsm_instance *)kmalloc(sizeof(fsm_instance), order);
+        this = kzalloc(sizeof(fsm_instance), order);
         if (this == NULL) {
                 printk(KERN_WARNING
                         "fsm(%s): init_fsm: Couldn't alloc instance\n", name);
                 return NULL;
         }
-        memset(this, 0, sizeof(fsm_instance));
         strlcpy(this->name, name, sizeof(this->name));
 
-        f = (fsm *)kmalloc(sizeof(fsm), order);
+        f = kzalloc(sizeof(fsm), order);
         if (f == NULL) {
                 printk(KERN_WARNING
                         "fsm(%s): init_fsm: Couldn't alloc fsm\n", name);
                 kfree_fsm(this);
                 return NULL;
         }
-        memset(f, 0, sizeof(fsm));
         f->nr_events = nr_events;
         f->nr_states = nr_states;
         f->event_names = event_names;
         f->state_names = state_names;
         this->f = f;
 
-        m = (fsm_function_t *)kmalloc(
-                        sizeof(fsm_function_t) * nr_states * nr_events, order);
+        m = kcalloc(nr_states*nr_events, sizeof(fsm_function_t), order);
         if (m == NULL) {
                 printk(KERN_WARNING
                         "fsm(%s): init_fsm: Couldn't alloc jumptable\n", name);
                 kfree_fsm(this);
                 return NULL;
         }
-        memset(m, 0, sizeof(fsm_function_t) * f->nr_states * f->nr_events);
         f->jumpmatrix = m;
 
         for (i = 0; i < tmpl_len; i++) {
diff --git a/drivers/s390/net/iucv.c b/drivers/s390/net/iucv.c
index 760e77ec5a..6190be9dca 100644
--- a/drivers/s390/net/iucv.c
+++ b/drivers/s390/net/iucv.c
@@ -386,7 +386,7 @@ iucv_init(void)
         }
 
         /* Note: GFP_DMA used used to get memory below 2G */
-        iucv_external_int_buffer = kmalloc(sizeof(iucv_GeneralInterrupt),
+        iucv_external_int_buffer = kzalloc(sizeof(iucv_GeneralInterrupt),
                                            GFP_KERNEL|GFP_DMA);
         if (!iucv_external_int_buffer) {
                 printk(KERN_WARNING
@@ -396,10 +396,9 @@ iucv_init(void)
                 bus_unregister(&iucv_bus);
                 return -ENOMEM;
         }
-        memset(iucv_external_int_buffer, 0, sizeof(iucv_GeneralInterrupt));
 
         /* Initialize parameter pool */
-        iucv_param_pool = kmalloc(sizeof(iucv_param) * PARAM_POOL_SIZE,
+        iucv_param_pool = kzalloc(sizeof(iucv_param) * PARAM_POOL_SIZE,
                                   GFP_KERNEL|GFP_DMA);
         if (!iucv_param_pool) {
                 printk(KERN_WARNING "%s: Could not allocate param pool\n",
@@ -410,7 +409,6 @@ iucv_init(void)
                 bus_unregister(&iucv_bus);
                 return -ENOMEM;
         }
-        memset(iucv_param_pool, 0, sizeof(iucv_param) * PARAM_POOL_SIZE);
 
         /* Initialize irq queue */
         INIT_LIST_HEAD(&iucv_irq_queue);
@@ -793,15 +791,14 @@ iucv_register_program (__u8 pgmname[16],
                 }
 
                 max_connections = iucv_query_maxconn();
-                iucv_pathid_table = kmalloc(max_connections * sizeof(handler *),
-                                       GFP_ATOMIC);
+                iucv_pathid_table = kcalloc(max_connections, sizeof(handler *),
+                                        GFP_ATOMIC);
                 if (iucv_pathid_table == NULL) {
                         printk(KERN_WARNING "%s: iucv_pathid_table storage "
                                "allocation failed\n", __FUNCTION__);
                         kfree(new_handler);
                         return NULL;
                 }
-                memset (iucv_pathid_table, 0, max_connections * sizeof(handler *));
         }
         memset(new_handler, 0, sizeof (handler));
         memcpy(new_handler->id.user_data, pgmname,
diff --git a/drivers/s390/net/lcs.c b/drivers/s390/net/lcs.c
index 9cf88d7201..edcf05d5d5 100644
--- a/drivers/s390/net/lcs.c
+++ b/drivers/s390/net/lcs.c
@@ -115,11 +115,10 @@ lcs_alloc_channel(struct lcs_channel *channel)
         LCS_DBF_TEXT(2, setup, "ichalloc");
         for (cnt = 0; cnt < LCS_NUM_BUFFS; cnt++) {
                 /* alloc memory fo iobuffer */
-                channel->iob[cnt].data = (void *)
-                        kmalloc(LCS_IOBUFFERSIZE, GFP_DMA | GFP_KERNEL);
+                channel->iob[cnt].data =
+                        kzalloc(LCS_IOBUFFERSIZE, GFP_DMA | GFP_KERNEL);
                 if (channel->iob[cnt].data == NULL)
                         break;
-                memset(channel->iob[cnt].data, 0, LCS_IOBUFFERSIZE);
                 channel->iob[cnt].state = BUF_STATE_EMPTY;
         }
         if (cnt < LCS_NUM_BUFFS) {
@@ -182,10 +181,9 @@ lcs_alloc_card(void)
 
         LCS_DBF_TEXT(2, setup, "alloclcs");
 
-        card = kmalloc(sizeof(struct lcs_card), GFP_KERNEL | GFP_DMA);
+        card = kzalloc(sizeof(struct lcs_card), GFP_KERNEL | GFP_DMA);
         if (card == NULL)
                 return NULL;
-        memset(card, 0, sizeof(struct lcs_card));
         card->lan_type = LCS_FRAME_TYPE_AUTO;
         card->pkt_seq = 0;
         card->lancmd_timeout = LCS_LANCMD_TIMEOUT_DEFAULT;
@@ -793,10 +791,9 @@ lcs_alloc_reply(struct lcs_cmd *cmd)
 
         LCS_DBF_TEXT(4, trace, "getreply");
 
-        reply = kmalloc(sizeof(struct lcs_reply), GFP_ATOMIC);
+        reply = kzalloc(sizeof(struct lcs_reply), GFP_ATOMIC);
         if (!reply)
                 return NULL;
-        memset(reply,0,sizeof(struct lcs_reply));
         atomic_set(&reply->refcnt,1);
         reply->sequence_no = cmd->sequence_no;
         reply->received = 0;
diff --git a/drivers/s390/net/netiucv.c b/drivers/s390/net/netiucv.c
index 71d3853e86..260a93c8c4 100644
--- a/drivers/s390/net/netiucv.c
+++ b/drivers/s390/net/netiucv.c
@@ -1728,14 +1728,13 @@ static int
 netiucv_register_device(struct net_device *ndev)
 {
         struct netiucv_priv *priv = ndev->priv;
-        struct device *dev = kmalloc(sizeof(struct device), GFP_KERNEL);
+        struct device *dev = kzalloc(sizeof(struct device), GFP_KERNEL);
         int ret;
 
 
         IUCV_DBF_TEXT(trace, 3, __FUNCTION__);
 
         if (dev) {
-                memset(dev, 0, sizeof(struct device));
                 snprintf(dev->bus_id, BUS_ID_SIZE, "net%s", ndev->name);
                 dev->bus = &iucv_bus;
                 dev->parent = iucv_root;
@@ -1784,11 +1783,9 @@ netiucv_new_connection(struct net_device *dev, char *username)
 {
         struct iucv_connection **clist = &iucv_connections;
         struct iucv_connection *conn =
-                (struct iucv_connection *)
-                kmalloc(sizeof(struct iucv_connection), GFP_KERNEL);
+                kzalloc(sizeof(struct iucv_connection), GFP_KERNEL);
 
         if (conn) {
-                memset(conn, 0, sizeof(struct iucv_connection));
                 skb_queue_head_init(&conn->collect_queue);
                 skb_queue_head_init(&conn->commit_queue);
                 conn->max_buffsize = NETIUCV_BUFSIZE_DEFAULT;
diff --git a/drivers/s390/net/qeth_eddp.c b/drivers/s390/net/qeth_eddp.c
index 82cb4af2f0..44e226f211 100644
--- a/drivers/s390/net/qeth_eddp.c
+++ b/drivers/s390/net/qeth_eddp.c
@@ -389,9 +389,8 @@ qeth_eddp_create_eddp_data(struct qeth_hdr *qh, u8 *nh, u8 nhl, u8 *th, u8 thl)
         struct qeth_eddp_data *eddp;
 
         QETH_DBF_TEXT(trace, 5, "eddpcrda");
-        eddp = kmalloc(sizeof(struct qeth_eddp_data), GFP_ATOMIC);
+        eddp = kzalloc(sizeof(struct qeth_eddp_data), GFP_ATOMIC);
         if (eddp){
-                memset(eddp, 0, sizeof(struct qeth_eddp_data));
                 eddp->nhl = nhl;
                 eddp->thl = thl;
                 memcpy(&eddp->qh, qh, sizeof(struct qeth_hdr));
@@ -542,12 +541,11 @@ qeth_eddp_create_context_generic(struct qeth_card *card, struct sk_buff *skb,
 
         QETH_DBF_TEXT(trace, 5, "creddpcg");
         /* create the context and allocate pages */
-        ctx = kmalloc(sizeof(struct qeth_eddp_context), GFP_ATOMIC);
+        ctx = kzalloc(sizeof(struct qeth_eddp_context), GFP_ATOMIC);
         if (ctx == NULL){
                 QETH_DBF_TEXT(trace, 2, "ceddpcn1");
                 return NULL;
         }
-        memset(ctx, 0, sizeof(struct qeth_eddp_context));
         ctx->type = QETH_LARGE_SEND_EDDP;
         qeth_eddp_calc_num_pages(ctx, skb, hdr_len);
         if (ctx->elements_per_skb > QETH_MAX_BUFFER_ELEMENTS(card)){
@@ -555,13 +553,12 @@ qeth_eddp_create_context_generic(struct qeth_card *card, struct sk_buff *skb,
                 kfree(ctx);
                 return NULL;
         }
-        ctx->pages = kmalloc(ctx->num_pages * sizeof(u8 *), GFP_ATOMIC);
+        ctx->pages = kcalloc(ctx->num_pages, sizeof(u8 *), GFP_ATOMIC);
         if (ctx->pages == NULL){
                 QETH_DBF_TEXT(trace, 2, "ceddpcn2");
                 kfree(ctx);
                 return NULL;
         }
-        memset(ctx->pages, 0, ctx->num_pages * sizeof(u8 *));
         for (i = 0; i < ctx->num_pages; ++i){
                 addr = (u8 *)__get_free_page(GFP_ATOMIC);
                 if (addr == NULL){
@@ -573,15 +570,13 @@ qeth_eddp_create_context_generic(struct qeth_card *card, struct sk_buff *skb,
                 memset(addr, 0, PAGE_SIZE);
                 ctx->pages[i] = addr;
         }
-        ctx->elements = kmalloc(ctx->num_elements *
+        ctx->elements = kcalloc(ctx->num_elements,
                                 sizeof(struct qeth_eddp_element), GFP_ATOMIC);
         if (ctx->elements == NULL){
                 QETH_DBF_TEXT(trace, 2, "ceddpcn4");
                 qeth_eddp_free_context(ctx);
                 return NULL;
         }
-        memset(ctx->elements, 0,
-               ctx->num_elements * sizeof(struct qeth_eddp_element));
         /* reset num_elements; will be incremented again in fill_buffer to
          * reflect number of actually used elements */
         ctx->num_elements = 0;
diff --git a/drivers/s390/net/qeth_main.c b/drivers/s390/net/qeth_main.c
index 021cd5d08c..b3c6e79077 100644
--- a/drivers/s390/net/qeth_main.c
+++ b/drivers/s390/net/qeth_main.c
@@ -297,12 +297,10 @@ qeth_alloc_card(void)
         struct qeth_card *card;
 
         QETH_DBF_TEXT(setup, 2, "alloccrd");
-        card = (struct qeth_card *) kmalloc(sizeof(struct qeth_card),
-                                            GFP_DMA|GFP_KERNEL);
+        card = kzalloc(sizeof(struct qeth_card), GFP_DMA|GFP_KERNEL);
         if (!card)
                 return NULL;
         QETH_DBF_HEX(setup, 2, &card, sizeof(void *));
-        memset(card, 0, sizeof(struct qeth_card));
         if (qeth_setup_channel(&card->read)) {
                 kfree(card);
                 return NULL;
@@ -1632,9 +1630,8 @@ qeth_alloc_reply(struct qeth_card *card)
 {
         struct qeth_reply *reply;
 
-        reply = kmalloc(sizeof(struct qeth_reply), GFP_ATOMIC);
+        reply = kzalloc(sizeof(struct qeth_reply), GFP_ATOMIC);
         if (reply){
-                memset(reply, 0, sizeof(struct qeth_reply));
                 atomic_set(&reply->refcnt, 1);
                 reply->card = card;
         };
@@ -3348,13 +3345,11 @@ qeth_qdio_establish(struct qeth_card *card)
 
         QETH_DBF_TEXT(setup, 2, "qdioest");
 
-        qib_param_field = kmalloc(QDIO_MAX_BUFFERS_PER_Q * sizeof(char),
+        qib_param_field = kzalloc(QDIO_MAX_BUFFERS_PER_Q * sizeof(char),
                               GFP_KERNEL);
         if (!qib_param_field)
                 return -ENOMEM;
 
-        memset(qib_param_field, 0, QDIO_MAX_BUFFERS_PER_Q * sizeof(char));
-
         qeth_create_qib_param_field(card, qib_param_field);
         qeth_create_qib_param_field_blkt(card, qib_param_field);
 
@@ -4819,9 +4814,8 @@ qeth_arp_query(struct qeth_card *card, char *udata)
         /* get size of userspace buffer and mask_bits -> 6 bytes */
         if (copy_from_user(&qinfo, udata, 6))
                 return -EFAULT;
-        if (!(qinfo.udata = kmalloc(qinfo.udata_len, GFP_KERNEL)))
+        if (!(qinfo.udata = kzalloc(qinfo.udata_len, GFP_KERNEL)))
                 return -ENOMEM;
-        memset(qinfo.udata, 0, qinfo.udata_len);
         qinfo.udata_offset = QETH_QARP_ENTRIES_OFFSET;
         iob = qeth_get_setassparms_cmd(card, IPA_ARP_PROCESSING,
                                        IPA_CMD_ASS_ARP_QUERY_INFO,
@@ -4969,11 +4963,10 @@ qeth_snmp_command(struct qeth_card *card, char *udata)
                 return -EFAULT;
         }
         qinfo.udata_len = ureq->hdr.data_len;
-        if (!(qinfo.udata = kmalloc(qinfo.udata_len, GFP_KERNEL))){
+        if (!(qinfo.udata = kzalloc(qinfo.udata_len, GFP_KERNEL))){
                 kfree(ureq);
                 return -ENOMEM;
         }
-        memset(qinfo.udata, 0, qinfo.udata_len);
         qinfo.udata_offset = sizeof(struct qeth_snmp_ureq_hdr);
 
         iob = qeth_get_adapter_cmd(card, IPA_SETADP_SET_SNMP_CONTROL,
@@ -5564,12 +5557,11 @@ qeth_get_addr_buffer(enum qeth_prot_versions prot)
 {
         struct qeth_ipaddr *addr;
 
-        addr = kmalloc(sizeof(struct qeth_ipaddr), GFP_ATOMIC);
+        addr = kzalloc(sizeof(struct qeth_ipaddr), GFP_ATOMIC);
         if (addr == NULL) {
                 PRINT_WARN("Not enough memory to add address\n");
                 return NULL;
         }
-        memset(addr,0,sizeof(struct qeth_ipaddr));
         addr->type = QETH_IP_TYPE_NORMAL;
         addr->proto = prot;
         return addr;
diff --git a/drivers/s390/net/qeth_sys.c b/drivers/s390/net/qeth_sys.c
index f2a076a2b2..882d419e41 100644
--- a/drivers/s390/net/qeth_sys.c
+++ b/drivers/s390/net/qeth_sys.c
@@ -1145,11 +1145,10 @@ qeth_dev_ipato_add_store(const char *buf, size_t count,
         if ((rc = qeth_parse_ipatoe(buf, proto, addr, &mask_bits)))
                 return rc;
 
-        if (!(ipatoe = kmalloc(sizeof(struct qeth_ipato_entry), GFP_KERNEL))){
+        if (!(ipatoe = kzalloc(sizeof(struct qeth_ipato_entry), GFP_KERNEL))){
                 PRINT_WARN("No memory to allocate ipato entry\n");
                 return -ENOMEM;
         }
-        memset(ipatoe, 0, sizeof(struct qeth_ipato_entry));
         ipatoe->proto = proto;
         memcpy(ipatoe->addr, addr, (proto == QETH_PROT_IPV4)? 4:16);
         ipatoe->mask_bits = mask_bits;
diff --git a/drivers/s390/s390_rdev.c b/drivers/s390/s390_rdev.c
index e3f6471698..3c7145d9f9 100644
--- a/drivers/s390/s390_rdev.c
+++ b/drivers/s390/s390_rdev.c
@@ -27,10 +27,9 @@ s390_root_dev_register(const char *name)
 
         if (!strlen(name))
                 return ERR_PTR(-EINVAL);
-        dev = kmalloc(sizeof(struct device), GFP_KERNEL);
+        dev = kzalloc(sizeof(struct device), GFP_KERNEL);
         if (!dev)
                 return ERR_PTR(-ENOMEM);
-        memset(dev, 0, sizeof(struct device));
         strncpy(dev->bus_id, name, min(strlen(name), (size_t)BUS_ID_SIZE));
         dev->release = s390_root_dev_release;
         ret = device_register(dev);
diff --git a/drivers/scsi/ata_piix.c b/drivers/scsi/ata_piix.c
index a74e23d39b..2d5be84d8b 100644
--- a/drivers/scsi/ata_piix.c
+++ b/drivers/scsi/ata_piix.c
@@ -742,7 +742,7 @@ static int piix_disable_ahci(struct pci_dev *pdev)
 /**
  *      piix_check_450nx_errata -       Check for problem 450NX setup
  *      @ata_dev: the PCI device to check
- *      
+ *
  *      Check for the present of 450NX errata #19 and errata #25. If
  *      they are found return an error code so we can turn off DMA
  */
@@ -753,7 +753,7 @@ static int __devinit piix_check_450nx_errata(struct pci_dev *ata_dev)
         u16 cfg;
         u8 rev;
         int no_piix_dma = 0;
-        
+
         while((pdev = pci_get_device(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82454NX, pdev)) != NULL)
         {
                 /* Look for 450NX PXB. Check for problem configurations
@@ -772,7 +772,7 @@ static int __devinit piix_check_450nx_errata(struct pci_dev *ata_dev)
         if(no_piix_dma == 2)
                 dev_printk(KERN_WARNING, &ata_dev->dev, "A BIOS update may resolve this.\n");
         return no_piix_dma;
-}               
+}
 
 static void __devinit piix_init_sata_map(struct pci_dev *pdev,
                                          struct ata_port_info *pinfo)
diff --git a/drivers/scsi/g_NCR5380.c b/drivers/scsi/g_NCR5380.c
index 45756fa907..e6bcfe9493 100644
--- a/drivers/scsi/g_NCR5380.c
+++ b/drivers/scsi/g_NCR5380.c
@@ -127,7 +127,7 @@ static int ncr_53c400a = NCR_NOT_SET;
 static int dtc_3181e = NCR_NOT_SET;
 
 static struct override {
-        NCR5380_implementation_fields;
+        NCR5380_map_type NCR5380_map_name;
         int irq;
         int dma;
         int board;              /* Use NCR53c400, Ricoh, etc. extensions ? */
@@ -299,6 +299,10 @@ int __init generic_NCR5380_detect(struct scsi_host_template * tpnt)
         };
         int flags = 0;
         struct Scsi_Host *instance;
+#ifdef CONFIG_SCSI_G_NCR5380_MEM
+        unsigned long base;
+        void __iomem *iomem;
+#endif
 
         if (ncr_irq != NCR_NOT_SET)
                 overrides[0].irq = ncr_irq;
@@ -424,15 +428,22 @@ int __init generic_NCR5380_detect(struct scsi_host_template * tpnt)
                         region_size = NCR5380_region_size;
                 }
 #else
-                if(!request_mem_region(overrides[current_override].NCR5380_map_name, NCR5380_region_size, "ncr5380"))
+                base = overrides[current_override].NCR5380_map_name;
+                if (!request_mem_region(base, NCR5380_region_size, "ncr5380"))
+                        continue;
+                iomem = ioremap(base, NCR5380_region_size);
+                if (!iomem) {
+                        release_mem_region(base, NCR5380_region_size);
                         continue;
+                }
 #endif
                 instance = scsi_register(tpnt, sizeof(struct NCR5380_hostdata));
                 if (instance == NULL) {
 #ifndef CONFIG_SCSI_G_NCR5380_MEM
                         release_region(overrides[current_override].NCR5380_map_name, region_size);
 #else
-                        release_mem_region(overrides[current_override].NCR5380_map_name, NCR5380_region_size);
+                        iounmap(iomem);
+                        release_mem_region(base, NCR5380_region_size);
 #endif
                         continue;
                 }
@@ -440,6 +451,8 @@ int __init generic_NCR5380_detect(struct scsi_host_template * tpnt)
                 instance->NCR5380_instance_name = overrides[current_override].NCR5380_map_name;
 #ifndef CONFIG_SCSI_G_NCR5380_MEM
                 instance->n_io_port = region_size;
+#else
+                ((struct NCR5380_hostdata *)instance->hostdata).iomem = iomem;
 #endif
 
                 NCR5380_init(instance, flags);
@@ -509,6 +522,7 @@ int generic_NCR5380_release_resources(struct Scsi_Host *instance)
 #ifndef CONFIG_SCSI_G_NCR5380_MEM
         release_region(instance->NCR5380_instance_name, instance->n_io_port);
 #else
+        iounmap(((struct NCR5380_hostdata *)instance->hostdata).iomem);
         release_mem_region(instance->NCR5380_instance_name, NCR5380_region_size);
 #endif
 
@@ -586,7 +600,7 @@ static inline int NCR5380_pread(struct Scsi_Host *instance, unsigned char *dst,
                 }
 #else
                 /* implies CONFIG_SCSI_G_NCR5380_MEM */
-                isa_memcpy_fromio(dst + start, NCR53C400_host_buffer + NCR5380_map_name, 128);
+                memcpy_fromio(dst + start, iomem + NCR53C400_host_buffer, 128);
 #endif
                 start += 128;
                 blocks--;
@@ -606,7 +620,7 @@ static inline int NCR5380_pread(struct Scsi_Host *instance, unsigned char *dst,
                 }
 #else
                 /* implies CONFIG_SCSI_G_NCR5380_MEM */
-                isa_memcpy_fromio(dst + start, NCR53C400_host_buffer + NCR5380_map_name, 128);
+                memcpy_fromio(dst + start, iomem + NCR53C400_host_buffer, 128);
 #endif
                 start += 128;
                 blocks--;
@@ -671,7 +685,7 @@ static inline int NCR5380_pwrite(struct Scsi_Host *instance, unsigned char *src,
                 }
 #else
                 /* implies CONFIG_SCSI_G_NCR5380_MEM */
-                isa_memcpy_toio(NCR53C400_host_buffer + NCR5380_map_name, src + start, 128);
+                memcpy_toio(iomem + NCR53C400_host_buffer, src + start, 128);
 #endif
                 start += 128;
                 blocks--;
@@ -687,7 +701,7 @@ static inline int NCR5380_pwrite(struct Scsi_Host *instance, unsigned char *src,
                 }
 #else
                 /* implies CONFIG_SCSI_G_NCR5380_MEM */
-                isa_memcpy_toio(NCR53C400_host_buffer + NCR5380_map_name, src + start, 128);
+                memcpy_toio(iomem + NCR53C400_host_buffer, src + start, 128);
 #endif
                 start += 128;
                 blocks--;
diff --git a/drivers/scsi/g_NCR5380.h b/drivers/scsi/g_NCR5380.h
index 656fbe2f91..d60a89cb80 100644
--- a/drivers/scsi/g_NCR5380.h
+++ b/drivers/scsi/g_NCR5380.h
@@ -82,6 +82,15 @@ static const char* generic_NCR5380_info(struct Scsi_Host *);
 #define NCR5380_read(reg) (inb(NCR5380_map_name + (reg)))
 #define NCR5380_write(reg, value) (outb((value), (NCR5380_map_name + (reg))))
 
+#define NCR5380_implementation_fields \
+    NCR5380_map_type NCR5380_map_name
+
+#define NCR5380_local_declare() \
+    register NCR5380_implementation_fields
+
+#define NCR5380_setup(instance) \
+    NCR5380_map_name = (NCR5380_map_type)((instance)->NCR5380_instance_name)
+
 #else 
 /* therefore CONFIG_SCSI_G_NCR5380_MEM */
 
@@ -95,18 +104,20 @@ static const char* generic_NCR5380_info(struct Scsi_Host *);
 #define NCR53C400_host_buffer 0x3900
 #define NCR5380_region_size 0x3a00
 
-#define NCR5380_read(reg) isa_readb(NCR5380_map_name + NCR53C400_mem_base + (reg))
-#define NCR5380_write(reg, value) isa_writeb(value, NCR5380_map_name + NCR53C400_mem_base + (reg))
-#endif
+#define NCR5380_read(reg) readb(iomem + NCR53C400_mem_base + (reg))
+#define NCR5380_write(reg, value) writeb(value, iomem + NCR53C400_mem_base + (reg))
 
 #define NCR5380_implementation_fields \
-    NCR5380_map_type NCR5380_map_name
+    NCR5380_map_type NCR5380_map_name; \
+    void __iomem *iomem;
 
 #define NCR5380_local_declare() \
-    register NCR5380_implementation_fields
+    register void __iomem *iomem
 
 #define NCR5380_setup(instance) \
-    NCR5380_map_name = (NCR5380_map_type)((instance)->NCR5380_instance_name)
+    iomem = (((struct NCR5380_hostdata *)(instance)->hostdata).iomem)
+
+#endif
 
 #define NCR5380_intr generic_NCR5380_intr
 #define NCR5380_queue_command generic_NCR5380_queue_command
diff --git a/drivers/scsi/ide-scsi.c b/drivers/scsi/ide-scsi.c
index 0cf0e4c7ac..39b760a242 100644
--- a/drivers/scsi/ide-scsi.c
+++ b/drivers/scsi/ide-scsi.c
@@ -47,6 +47,7 @@
 #include <linux/ide.h>
 #include <linux/scatterlist.h>
 #include <linux/delay.h>
+#include <linux/mutex.h>
 
 #include <asm/io.h>
 #include <asm/bitops.h>
@@ -109,7 +110,7 @@ typedef struct ide_scsi_obj {
         unsigned long log;                      /* log flags */
 } idescsi_scsi_t;
 
-static DECLARE_MUTEX(idescsi_ref_sem);
+static DEFINE_MUTEX(idescsi_ref_mutex);
 
 #define ide_scsi_g(disk) \
         container_of((disk)->private_data, struct ide_scsi_obj, driver)
@@ -118,19 +119,19 @@ static struct ide_scsi_obj *ide_scsi_get(struct gendisk *disk)
 {
         struct ide_scsi_obj *scsi = NULL;
 
-        down(&idescsi_ref_sem);
+        mutex_lock(&idescsi_ref_mutex);
         scsi = ide_scsi_g(disk);
         if (scsi)
                 scsi_host_get(scsi->host);
-        up(&idescsi_ref_sem);
+        mutex_unlock(&idescsi_ref_mutex);
         return scsi;
 }
 
 static void ide_scsi_put(struct ide_scsi_obj *scsi)
 {
-        down(&idescsi_ref_sem);
+        mutex_lock(&idescsi_ref_mutex);
         scsi_host_put(scsi->host);
-        up(&idescsi_ref_sem);
+        mutex_unlock(&idescsi_ref_mutex);
 }
 
 static inline idescsi_scsi_t *scsihost_to_idescsi(struct Scsi_Host *host)
diff --git a/drivers/scsi/in2000.c b/drivers/scsi/in2000.c
index 34daa3e068..9c519876f8 100644
--- a/drivers/scsi/in2000.c
+++ b/drivers/scsi/in2000.c
@@ -1898,6 +1898,21 @@ static int int_tab[] in2000__INITDATA = {
         10
 };
 
+static int probe_bios(u32 addr, u32 *s1, uchar *switches)
+{
+        void __iomem *p = ioremap(addr, 0x34);
+        if (!p)
+                return 0;
+        *s1 = readl(p + 0x10);
+        if (*s1 == 0x41564f4e || readl(p + 0x30) == 0x61776c41) {
+                /* Read the switch image that's mapped into EPROM space */
+                *switches = ~readb(p + 0x20);
+                iounmap(p);
+                return 1;
+        }
+        iounmap(p);
+        return 0;
+}
 
 static int __init in2000_detect(struct scsi_host_template * tpnt)
 {
@@ -1930,6 +1945,7 @@ static int __init in2000_detect(struct scsi_host_template * tpnt)
 
         detect_count = 0;
         for (bios = 0; bios_tab[bios]; bios++) {
+                u32 s1 = 0;
                 if (check_setup_args("ioport", &val, buf)) {
                         base = val;
                         switches = ~inb(base + IO_SWITCHES) & 0xff;
@@ -1941,13 +1957,9 @@ static int __init in2000_detect(struct scsi_host_template * tpnt)
  * for the obvious ID strings. We look for the 2 most common ones and
  * hope that they cover all the cases...
  */
-                else if (isa_readl(bios_tab[bios] + 0x10) == 0x41564f4e || isa_readl(bios_tab[bios] + 0x30) == 0x61776c41) {
+                else if (probe_bios(bios_tab[bios], &s1, &switches)) {
                         printk("Found IN2000 BIOS at 0x%x ", (unsigned int) bios_tab[bios]);
 
-/* Read the switch image that's mapped into EPROM space */
-
-                        switches = ~((isa_readb(bios_tab[bios] + 0x20) & 0xff));
-
 /* Find out where the IO space is */
 
                         x = switches & (SW_ADDR0 | SW_ADDR1);
@@ -2037,7 +2049,7 @@ static int __init in2000_detect(struct scsi_host_template * tpnt)
 
 /* Older BIOS's had a 'sync on/off' switch - use its setting */
 
-                if (isa_readl(bios_tab[bios] + 0x10) == 0x41564f4e && (switches & SW_SYNC_DOS5))
+                if (s1 == 0x41564f4e && (switches & SW_SYNC_DOS5))
                         hostdata->sync_off = 0x00;      /* sync defaults to on */
                 else
                         hostdata->sync_off = 0xff;      /* sync defaults to off */
diff --git a/drivers/scsi/libata-bmdma.c b/drivers/scsi/libata-bmdma.c
index a00a78b308..95d81d86d8 100644
--- a/drivers/scsi/libata-bmdma.c
+++ b/drivers/scsi/libata-bmdma.c
@@ -941,7 +941,7 @@ err_out:
  *      @pdev: PCI device
  *
  *      Some PCI ATA devices report simplex mode but in fact can be told to
- *      enter non simplex mode. This implements the neccessary logic to 
+ *      enter non simplex mode. This implements the neccessary logic to
  *      perform the task on such devices. Calling it on other devices will
  *      have -undefined- behaviour.
  */
@@ -966,7 +966,7 @@ unsigned long ata_pci_default_filter(const struct ata_port *ap, struct ata_devic
 {
         /* Filter out DMA modes if the device has been configured by
            the BIOS as PIO only */
-           
+
         if (ap->ioaddr.bmdma_addr == 0)
                 xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
         return xfer_mask;
diff --git a/drivers/scsi/libata-core.c b/drivers/scsi/libata-core.c
index dcce0f494d..c3c4263fdb 100644
--- a/drivers/scsi/libata-core.c
+++ b/drivers/scsi/libata-core.c
@@ -64,10 +64,10 @@
 static unsigned int ata_dev_init_params(struct ata_port *ap,
                                         struct ata_device *dev);
 static void ata_set_mode(struct ata_port *ap);
-static void ata_dev_set_xfermode(struct ata_port *ap, struct ata_device *dev);
+static unsigned int ata_dev_set_xfermode(struct ata_port *ap,
+                                         struct ata_device *dev);
+static void ata_dev_xfermask(struct ata_port *ap, struct ata_device *dev);
 static void ata_pio_error(struct ata_port *ap);
-static unsigned int ata_dev_xfermask(struct ata_port *ap,
-                                     struct ata_device *dev);
 
 static unsigned int ata_unique_id = 1;
 static struct workqueue_struct *ata_wq;
@@ -191,7 +191,7 @@ static const u8 ata_rw_cmds[] = {
  *      ata_rwcmd_protocol - set taskfile r/w commands and protocol
  *      @qc: command to examine and configure
  *
- *      Examine the device configuration and tf->flags to calculate 
+ *      Examine the device configuration and tf->flags to calculate
  *      the proper read/write commands and protocol to use.
  *
  *      LOCKING:
@@ -204,7 +204,7 @@ int ata_rwcmd_protocol(struct ata_queued_cmd *qc)
         u8 cmd;
 
         int index, fua, lba48, write;
- 
+
         fua = (tf->flags & ATA_TFLAG_FUA) ? 4 : 0;
         lba48 = (tf->flags & ATA_TFLAG_LBA48) ? 2 : 0;
         write = (tf->flags & ATA_TFLAG_WRITE) ? 1 : 0;
@@ -253,6 +253,29 @@ static unsigned int ata_pack_xfermask(unsigned int pio_mask,
                 ((udma_mask << ATA_SHIFT_UDMA) & ATA_MASK_UDMA);
 }
 
+/**
+ *      ata_unpack_xfermask - Unpack xfer_mask into pio, mwdma and udma masks
+ *      @xfer_mask: xfer_mask to unpack
+ *      @pio_mask: resulting pio_mask
+ *      @mwdma_mask: resulting mwdma_mask
+ *      @udma_mask: resulting udma_mask
+ *
+ *      Unpack @xfer_mask into @pio_mask, @mwdma_mask and @udma_mask.
+ *      Any NULL distination masks will be ignored.
+ */
+static void ata_unpack_xfermask(unsigned int xfer_mask,
+                                unsigned int *pio_mask,
+                                unsigned int *mwdma_mask,
+                                unsigned int *udma_mask)
+{
+        if (pio_mask)
+                *pio_mask = (xfer_mask & ATA_MASK_PIO) >> ATA_SHIFT_PIO;
+        if (mwdma_mask)
+                *mwdma_mask = (xfer_mask & ATA_MASK_MWDMA) >> ATA_SHIFT_MWDMA;
+        if (udma_mask)
+                *udma_mask = (xfer_mask & ATA_MASK_UDMA) >> ATA_SHIFT_UDMA;
+}
+
 static const struct ata_xfer_ent {
         unsigned int shift, bits;
         u8 base;
@@ -373,6 +396,15 @@ static const char *ata_mode_string(unsigned int xfer_mask)
         return "<n/a>";
 }
 
+static void ata_dev_disable(struct ata_port *ap, struct ata_device *dev)
+{
+        if (ata_dev_present(dev)) {
+                printk(KERN_WARNING "ata%u: dev %u disabled\n",
+                       ap->id, dev->devno);
+                dev->class++;
+        }
+}
+
 /**
  *      ata_pio_devchk - PATA device presence detection
  *      @ap: ATA channel to examine
@@ -988,6 +1020,22 @@ ata_exec_internal(struct ata_port *ap, struct ata_device *dev,
 
         ata_qc_free(qc);
 
+        /* XXX - Some LLDDs (sata_mv) disable port on command failure.
+         * Until those drivers are fixed, we detect the condition
+         * here, fail the command with AC_ERR_SYSTEM and reenable the
+         * port.
+         *
+         * Note that this doesn't change any behavior as internal
+         * command failure results in disabling the device in the
+         * higher layer for LLDDs without new reset/EH callbacks.
+         *
+         * Kill the following code as soon as those drivers are fixed.
+         */
+        if (ap->flags & ATA_FLAG_PORT_DISABLED) {
+                err_mask |= AC_ERR_SYSTEM;
+                ata_port_probe(ap);
+        }
+
         return err_mask;
 }
 
@@ -1008,7 +1056,7 @@ unsigned int ata_pio_need_iordy(const struct ata_device *adev)
                 return 0;
         if (speed > 2)
                 return 1;
-                
+
         /* If we have no drive specific rule, then PIO 2 is non IORDY */
 
         if (adev->id[ATA_ID_FIELD_VALID] & 2) { /* EIDE */
@@ -1034,9 +1082,8 @@ unsigned int ata_pio_need_iordy(const struct ata_device *adev)
  *
  *      Read ID data from the specified device.  ATA_CMD_ID_ATA is
  *      performed on ATA devices and ATA_CMD_ID_ATAPI on ATAPI
- *      devices.  This function also takes care of EDD signature
- *      misreporting (to be removed once EDD support is gone) and
- *      issues ATA_CMD_INIT_DEV_PARAMS for pre-ATA4 drives.
+ *      devices.  This function also issues ATA_CMD_INIT_DEV_PARAMS
+ *      for pre-ATA4 drives.
  *
  *      LOCKING:
  *      Kernel thread context (may sleep)
@@ -1048,7 +1095,6 @@ static int ata_dev_read_id(struct ata_port *ap, struct ata_device *dev,
                            unsigned int *p_class, int post_reset, u16 **p_id)
 {
         unsigned int class = *p_class;
-        unsigned int using_edd;
         struct ata_taskfile tf;
         unsigned int err_mask = 0;
         u16 *id;
@@ -1057,12 +1103,6 @@ static int ata_dev_read_id(struct ata_port *ap, struct ata_device *dev,
 
         DPRINTK("ENTER, host %u, dev %u\n", ap->id, dev->devno);
 
-        if (ap->ops->probe_reset ||
-            ap->flags & (ATA_FLAG_SRST | ATA_FLAG_SATA_RESET))
-                using_edd = 0;
-        else
-                using_edd = 1;
-
         ata_dev_select(ap, dev->devno, 1, 1); /* select device 0/1 */
 
         id = kmalloc(sizeof(id[0]) * ATA_ID_WORDS, GFP_KERNEL);
@@ -1092,32 +1132,9 @@ static int ata_dev_read_id(struct ata_port *ap, struct ata_device *dev,
 
         err_mask = ata_exec_internal(ap, dev, &tf, DMA_FROM_DEVICE,
                                      id, sizeof(id[0]) * ATA_ID_WORDS);
-
         if (err_mask) {
                 rc = -EIO;
                 reason = "I/O error";
-
-                if (err_mask & ~AC_ERR_DEV)
-                        goto err_out;
-
-                /*
-                 * arg!  EDD works for all test cases, but seems to return
-                 * the ATA signature for some ATAPI devices.  Until the
-                 * reason for this is found and fixed, we fix up the mess
-                 * here.  If IDENTIFY DEVICE returns command aborted
-                 * (as ATAPI devices do), then we issue an
-                 * IDENTIFY PACKET DEVICE.
-                 *
-                 * ATA software reset (SRST, the default) does not appear
-                 * to have this problem.
-                 */
-                if ((using_edd) && (class == ATA_DEV_ATA)) {
-                        u8 err = tf.feature;
-                        if (err & ATA_ABORTED) {
-                                class = ATA_DEV_ATAPI;
-                                goto retry;
-                        }
-                }
                 goto err_out;
         }
 
@@ -1314,7 +1331,7 @@ static int ata_dev_configure(struct ata_port *ap, struct ata_device *dev,
                 if (print_info)
                         printk(KERN_INFO "ata%u(%u): applying bridge limits\n",
                                ap->id, dev->devno);
-                ap->udma_mask &= ATA_UDMA5;
+                dev->udma_mask &= ATA_UDMA5;
                 dev->max_sectors = ATA_MAX_SECTORS;
         }
 
@@ -1325,8 +1342,6 @@ static int ata_dev_configure(struct ata_port *ap, struct ata_device *dev,
         return 0;
 
 err_out_nosup:
-        printk(KERN_WARNING "ata%u: dev %u not supported, ignoring\n",
-               ap->id, dev->devno);
         DPRINTK("EXIT, err\n");
         return rc;
 }
@@ -1393,7 +1408,7 @@ static int ata_bus_probe(struct ata_port *ap)
                 }
 
                 if (ata_dev_configure(ap, dev, 1)) {
-                        dev->class++;   /* disable device */
+                        ata_dev_disable(ap, dev);
                         continue;
                 }
 
@@ -1539,6 +1554,23 @@ void sata_phy_reset(struct ata_port *ap)
 }
 
 /**
+ *      ata_dev_pair            -       return other device on cable
+ *      @ap: port
+ *      @adev: device
+ *
+ *      Obtain the other device on the same cable, or if none is
+ *      present NULL is returned
+ */
+
+struct ata_device *ata_dev_pair(struct ata_port *ap, struct ata_device *adev)
+{
+        struct ata_device *pair = &ap->device[1 - adev->devno];
+        if (!ata_dev_present(pair))
+                return NULL;
+        return pair;
+}
+
+/**
  *      ata_port_disable - Disable port.
  *      @ap: Port to be disabled.
  *
@@ -1566,7 +1598,7 @@ void ata_port_disable(struct ata_port *ap)
  * PIO 0-5, MWDMA 0-2 and UDMA 0-6 timings (in nanoseconds).
  * These were taken from ATA/ATAPI-6 standard, rev 0a, except
  * for PIO 5, which is a nonstandard extension and UDMA6, which
- * is currently supported only by Maxtor drives. 
+ * is currently supported only by Maxtor drives.
  */
 
 static const struct ata_timing ata_timing[] = {
@@ -1581,11 +1613,11 @@ static const struct ata_timing ata_timing[] = {
         { XFER_UDMA_0,     0,   0,   0,   0,   0,   0,   0, 120 },
 
 /*      { XFER_UDMA_SLOW,  0,   0,   0,   0,   0,   0,   0, 150 }, */
-                                          
+
         { XFER_MW_DMA_2,  25,   0,   0,   0,  70,  25, 120,   0 },
         { XFER_MW_DMA_1,  45,   0,   0,   0,  80,  50, 150,   0 },
         { XFER_MW_DMA_0,  60,   0,   0,   0, 215, 215, 480,   0 },
-                                          
+
         { XFER_SW_DMA_2,  60,   0,   0,   0, 120, 120, 240,   0 },
         { XFER_SW_DMA_1,  90,   0,   0,   0, 240, 240, 480,   0 },
         { XFER_SW_DMA_0, 120,   0,   0,   0, 480, 480, 960,   0 },
@@ -1638,7 +1670,7 @@ static const struct ata_timing* ata_timing_find_mode(unsigned short speed)
         for (t = ata_timing; t->mode != speed; t++)
                 if (t->mode == 0xFF)
                         return NULL;
-        return t; 
+        return t;
 }
 
 int ata_timing_compute(struct ata_device *adev, unsigned short speed,
@@ -1648,7 +1680,7 @@ int ata_timing_compute(struct ata_device *adev, unsigned short speed,
         struct ata_timing p;
 
         /*
-         * Find the mode. 
+         * Find the mode.
          */
 
         if (!(s = ata_timing_find_mode(speed)))
@@ -1706,20 +1738,28 @@ int ata_timing_compute(struct ata_device *adev, unsigned short speed,
         return 0;
 }
 
-static void ata_dev_set_mode(struct ata_port *ap, struct ata_device *dev)
+static int ata_dev_set_mode(struct ata_port *ap, struct ata_device *dev)
 {
-        if (!ata_dev_present(dev) || (ap->flags & ATA_FLAG_PORT_DISABLED))
-                return;
+        unsigned int err_mask;
+        int rc;
 
         if (dev->xfer_shift == ATA_SHIFT_PIO)
                 dev->flags |= ATA_DFLAG_PIO;
 
-        ata_dev_set_xfermode(ap, dev);
+        err_mask = ata_dev_set_xfermode(ap, dev);
+        if (err_mask) {
+                printk(KERN_ERR
+                       "ata%u: failed to set xfermode (err_mask=0x%x)\n",
+                       ap->id, err_mask);
+                return -EIO;
+        }
 
-        if (ata_dev_revalidate(ap, dev, 0)) {
-                printk(KERN_ERR "ata%u: failed to revalidate after set "
-                       "xfermode, disabled\n", ap->id);
-                ata_port_disable(ap);
+        rc = ata_dev_revalidate(ap, dev, 0);
+        if (rc) {
+                printk(KERN_ERR
+                       "ata%u: failed to revalidate after set xfermode\n",
+                       ap->id);
+                return rc;
         }
 
         DPRINTK("xfer_shift=%u, xfer_mode=0x%x\n",
@@ -1728,6 +1768,7 @@ static void ata_dev_set_mode(struct ata_port *ap, struct ata_device *dev)
         printk(KERN_INFO "ata%u: dev %u configured for %s\n",
                ap->id, dev->devno,
                ata_mode_string(ata_xfer_mode2mask(dev->xfer_mode)));
+        return 0;
 }
 
 static int ata_host_set_pio(struct ata_port *ap)
@@ -1787,16 +1828,19 @@ static void ata_set_mode(struct ata_port *ap)
         /* step 1: calculate xfer_mask */
         for (i = 0; i < ATA_MAX_DEVICES; i++) {
                 struct ata_device *dev = &ap->device[i];
-                unsigned int xfer_mask;
+                unsigned int pio_mask, dma_mask;
 
                 if (!ata_dev_present(dev))
                         continue;
 
-                xfer_mask = ata_dev_xfermask(ap, dev);
+                ata_dev_xfermask(ap, dev);
+
+                /* TODO: let LLDD filter dev->*_mask here */
 
-                dev->pio_mode = ata_xfer_mask2mode(xfer_mask & ATA_MASK_PIO);
-                dev->dma_mode = ata_xfer_mask2mode(xfer_mask & (ATA_MASK_MWDMA |
-                                                                ATA_MASK_UDMA));
+                pio_mask = ata_pack_xfermask(dev->pio_mask, 0, 0);
+                dma_mask = ata_pack_xfermask(0, dev->mwdma_mask, dev->udma_mask);
+                dev->pio_mode = ata_xfer_mask2mode(pio_mask);
+                dev->dma_mode = ata_xfer_mask2mode(dma_mask);
         }
 
         /* step 2: always set host PIO timings */
@@ -1808,11 +1852,15 @@ static void ata_set_mode(struct ata_port *ap)
         ata_host_set_dma(ap);
 
         /* step 4: update devices' xfer mode */
-        for (i = 0; i < ATA_MAX_DEVICES; i++)
-                ata_dev_set_mode(ap, &ap->device[i]);
+        for (i = 0; i < ATA_MAX_DEVICES; i++) {
+                struct ata_device *dev = &ap->device[i];
 
-        if (ap->flags & ATA_FLAG_PORT_DISABLED)
-                return;
+                if (!ata_dev_present(dev))
+                        continue;
+
+                if (ata_dev_set_mode(ap, dev))
+                        goto err_out;
+        }
 
         if (ap->ops->post_set_mode)
                 ap->ops->post_set_mode(ap);
@@ -1935,45 +1983,6 @@ static void ata_bus_post_reset(struct ata_port *ap, unsigned int devmask)
                 ap->ops->dev_select(ap, 0);
 }
 
-/**
- *      ata_bus_edd - Issue EXECUTE DEVICE DIAGNOSTIC command.
- *      @ap: Port to reset and probe
- *
- *      Use the EXECUTE DEVICE DIAGNOSTIC command to reset and
- *      probe the bus.  Not often used these days.
- *
- *      LOCKING:
- *      PCI/etc. bus probe sem.
- *      Obtains host_set lock.
- *
- */
-
-static unsigned int ata_bus_edd(struct ata_port *ap)
-{
-        struct ata_taskfile tf;
-        unsigned long flags;
-
-        /* set up execute-device-diag (bus reset) taskfile */
-        /* also, take interrupts to a known state (disabled) */
-        DPRINTK("execute-device-diag\n");
-        ata_tf_init(ap, &tf, 0);
-        tf.ctl |= ATA_NIEN;
-        tf.command = ATA_CMD_EDD;
-        tf.protocol = ATA_PROT_NODATA;
-
-        /* do bus reset */
-        spin_lock_irqsave(&ap->host_set->lock, flags);
-        ata_tf_to_host(ap, &tf);
-        spin_unlock_irqrestore(&ap->host_set->lock, flags);
-
-        /* spec says at least 2ms.  but who knows with those
-         * crazy ATAPI devices...
-         */
-        msleep(150);
-
-        return ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
-}
-
 static unsigned int ata_bus_softreset(struct ata_port *ap,
                                       unsigned int devmask)
 {
@@ -2008,11 +2017,11 @@ static unsigned int ata_bus_softreset(struct ata_port *ap,
          */
         msleep(150);
 
-        
-        /* Before we perform post reset processing we want to see if 
+
+        /* Before we perform post reset processing we want to see if
            the bus shows 0xFF because the odd clown forgets the D7 pulldown
            resistor */
-        
+
         if (ata_check_status(ap) == 0xFF)
                 return 1;       /* Positive is failure for some reason */
 
@@ -2046,7 +2055,7 @@ void ata_bus_reset(struct ata_port *ap)
         struct ata_ioports *ioaddr = &ap->ioaddr;
         unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
         u8 err;
-        unsigned int dev0, dev1 = 0, rc = 0, devmask = 0;
+        unsigned int dev0, dev1 = 0, devmask = 0;
 
         DPRINTK("ENTER, host %u, port %u\n", ap->id, ap->port_no);
 
@@ -2069,18 +2078,8 @@ void ata_bus_reset(struct ata_port *ap)
 
         /* issue bus reset */
         if (ap->flags & ATA_FLAG_SRST)
-                rc = ata_bus_softreset(ap, devmask);
-        else if ((ap->flags & ATA_FLAG_SATA_RESET) == 0) {
-                /* set up device control */
-                if (ap->flags & ATA_FLAG_MMIO)
-                        writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
-                else
-                        outb(ap->ctl, ioaddr->ctl_addr);
-                rc = ata_bus_edd(ap);
-        }
-
-        if (rc)
-                goto err_out;
+                if (ata_bus_softreset(ap, devmask))
+                        goto err_out;
 
         /*
          * determine by signature whether we have ATA or ATAPI devices
@@ -2581,22 +2580,22 @@ static const char * const ata_dma_blacklist [] = {
         "SanDisk SDP3B-64", NULL,
         "SANYO CD-ROM CRD", NULL,
         "HITACHI CDR-8", NULL,
-        "HITACHI CDR-8335", NULL, 
+        "HITACHI CDR-8335", NULL,
         "HITACHI CDR-8435", NULL,
-        "Toshiba CD-ROM XM-6202B", NULL, 
-        "TOSHIBA CD-ROM XM-1702BC", NULL, 
-        "CD-532E-A", NULL, 
-        "E-IDE CD-ROM CR-840", NULL, 
-        "CD-ROM Drive/F5A", NULL, 
-        "WPI CDD-820", NULL, 
+        "Toshiba CD-ROM XM-6202B", NULL,
+        "TOSHIBA CD-ROM XM-1702BC", NULL,
+        "CD-532E-A", NULL,
+        "E-IDE CD-ROM CR-840", NULL,
+        "CD-ROM Drive/F5A", NULL,
+        "WPI CDD-820", NULL,
         "SAMSUNG CD-ROM SC-148C", NULL,
-        "SAMSUNG CD-ROM SC", NULL, 
+        "SAMSUNG CD-ROM SC", NULL,
         "SanDisk SDP3B-64", NULL,
         "ATAPI CD-ROM DRIVE 40X MAXIMUM",NULL,
         "_NEC DV5800A", NULL,
         "SAMSUNG CD-ROM SN-124", "N001"
 };
- 
+
 static int ata_strim(char *s, size_t len)
 {
         len = strnlen(s, len);
@@ -2639,18 +2638,15 @@ static int ata_dma_blacklisted(const struct ata_device *dev)
  *      @ap: Port on which the device to compute xfermask for resides
  *      @dev: Device to compute xfermask for
  *
- *      Compute supported xfermask of @dev.  This function is
- *      responsible for applying all known limits including host
- *      controller limits, device blacklist, etc...
+ *      Compute supported xfermask of @dev and store it in
+ *      dev->*_mask.  This function is responsible for applying all
+ *      known limits including host controller limits, device
+ *      blacklist, etc...
  *
  *      LOCKING:
  *      None.
- *
- *      RETURNS:
- *      Computed xfermask.
  */
-static unsigned int ata_dev_xfermask(struct ata_port *ap,
-                                     struct ata_device *dev)
+static void ata_dev_xfermask(struct ata_port *ap, struct ata_device *dev)
 {
         unsigned long xfer_mask;
         int i;
@@ -2663,6 +2659,8 @@ static unsigned int ata_dev_xfermask(struct ata_port *ap,
                 struct ata_device *d = &ap->device[i];
                 if (!ata_dev_present(d))
                         continue;
+                xfer_mask &= ata_pack_xfermask(d->pio_mask, d->mwdma_mask,
+                                               d->udma_mask);
                 xfer_mask &= ata_id_xfermask(d->id);
                 if (ata_dma_blacklisted(d))
                         xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
@@ -2672,7 +2670,8 @@ static unsigned int ata_dev_xfermask(struct ata_port *ap,
                 printk(KERN_WARNING "ata%u: dev %u is on DMA blacklist, "
                        "disabling DMA\n", ap->id, dev->devno);
 
-        return xfer_mask;
+        ata_unpack_xfermask(xfer_mask, &dev->pio_mask, &dev->mwdma_mask,
+                            &dev->udma_mask);
 }
 
 /**
@@ -2685,11 +2684,16 @@ static unsigned int ata_dev_xfermask(struct ata_port *ap,
  *
  *      LOCKING:
  *      PCI/etc. bus probe sem.
+ *
+ *      RETURNS:
+ *      0 on success, AC_ERR_* mask otherwise.
  */
 
-static void ata_dev_set_xfermode(struct ata_port *ap, struct ata_device *dev)
+static unsigned int ata_dev_set_xfermode(struct ata_port *ap,
+                                         struct ata_device *dev)
 {
         struct ata_taskfile tf;
+        unsigned int err_mask;
 
         /* set up set-features taskfile */
         DPRINTK("set features - xfer mode\n");
@@ -2701,13 +2705,10 @@ static void ata_dev_set_xfermode(struct ata_port *ap, struct ata_device *dev)
         tf.protocol = ATA_PROT_NODATA;
         tf.nsect = dev->xfer_mode;
 
-        if (ata_exec_internal(ap, dev, &tf, DMA_NONE, NULL, 0)) {
-                printk(KERN_ERR "ata%u: failed to set xfermode, disabled\n",
-                       ap->id);
-                ata_port_disable(ap);
-        }
+        err_mask = ata_exec_internal(ap, dev, &tf, DMA_NONE, NULL, 0);
 
-        DPRINTK("EXIT\n");
+        DPRINTK("EXIT, err_mask=%x\n", err_mask);
+        return err_mask;
 }
 
 /**
@@ -2784,7 +2785,7 @@ static void ata_sg_clean(struct ata_queued_cmd *qc)
 
         if (qc->flags & ATA_QCFLAG_SG) {
                 if (qc->n_elem)
-                        dma_unmap_sg(ap->host_set->dev, sg, qc->n_elem, dir);
+                        dma_unmap_sg(ap->dev, sg, qc->n_elem, dir);
                 /* restore last sg */
                 sg[qc->orig_n_elem - 1].length += qc->pad_len;
                 if (pad_buf) {
@@ -2795,7 +2796,7 @@ static void ata_sg_clean(struct ata_queued_cmd *qc)
                 }
         } else {
                 if (qc->n_elem)
-                        dma_unmap_single(ap->host_set->dev,
+                        dma_unmap_single(ap->dev,
                                 sg_dma_address(&sg[0]), sg_dma_len(&sg[0]),
                                 dir);
                 /* restore sg */
@@ -3006,7 +3007,7 @@ static int ata_sg_setup_one(struct ata_queued_cmd *qc)
                 goto skip_map;
         }
 
-        dma_address = dma_map_single(ap->host_set->dev, qc->buf_virt,
+        dma_address = dma_map_single(ap->dev, qc->buf_virt,
                                      sg->length, dir);
         if (dma_mapping_error(dma_address)) {
                 /* restore sg */
@@ -3094,7 +3095,7 @@ static int ata_sg_setup(struct ata_queued_cmd *qc)
         }
 
         dir = qc->dma_dir;
-        n_elem = dma_map_sg(ap->host_set->dev, sg, pre_n_elem, dir);
+        n_elem = dma_map_sg(ap->dev, sg, pre_n_elem, dir);
         if (n_elem < 1) {
                 /* restore last sg */
                 lsg->length += qc->pad_len;
@@ -3793,7 +3794,7 @@ static void ata_pio_error(struct ata_port *ap)
         if (qc->tf.command != ATA_CMD_PACKET)
                 printk(KERN_WARNING "ata%u: PIO error\n", ap->id);
 
-        /* make sure qc->err_mask is available to 
+        /* make sure qc->err_mask is available to
          * know what's wrong and recover
          */
         WARN_ON(qc->err_mask == 0);
@@ -4630,14 +4631,15 @@ int ata_device_resume(struct ata_port *ap, struct ata_device *dev)
  *      Flush the cache on the drive, if appropriate, then issue a
  *      standbynow command.
  */
-int ata_device_suspend(struct ata_port *ap, struct ata_device *dev)
+int ata_device_suspend(struct ata_port *ap, struct ata_device *dev, pm_message_t state)
 {
         if (!ata_dev_present(dev))
                 return 0;
         if (dev->class == ATA_DEV_ATA)
                 ata_flush_cache(ap, dev);
 
-        ata_standby_drive(ap, dev);
+        if (state.event != PM_EVENT_FREEZE)
+                ata_standby_drive(ap, dev);
         ap->flags |= ATA_FLAG_SUSPENDED;
         return 0;
 }
@@ -4657,7 +4659,7 @@ int ata_device_suspend(struct ata_port *ap, struct ata_device *dev)
 
 int ata_port_start (struct ata_port *ap)
 {
-        struct device *dev = ap->host_set->dev;
+        struct device *dev = ap->dev;
         int rc;
 
         ap->prd = dma_alloc_coherent(dev, ATA_PRD_TBL_SZ, &ap->prd_dma, GFP_KERNEL);
@@ -4690,7 +4692,7 @@ int ata_port_start (struct ata_port *ap)
 
 void ata_port_stop (struct ata_port *ap)
 {
-        struct device *dev = ap->host_set->dev;
+        struct device *dev = ap->dev;
 
         dma_free_coherent(dev, ATA_PRD_TBL_SZ, ap->prd, ap->prd_dma);
         ata_pad_free(ap, dev);
@@ -4756,6 +4758,7 @@ static void ata_host_init(struct ata_port *ap, struct Scsi_Host *host,
         ap->host = host;
         ap->ctl = ATA_DEVCTL_OBS;
         ap->host_set = host_set;
+        ap->dev = ent->dev;
         ap->port_no = port_no;
         ap->hard_port_no =
                 ent->legacy_mode ? ent->hard_port_no : port_no;
@@ -4771,8 +4774,13 @@ static void ata_host_init(struct ata_port *ap, struct Scsi_Host *host,
         INIT_WORK(&ap->port_task, NULL, NULL);
         INIT_LIST_HEAD(&ap->eh_done_q);
 
-        for (i = 0; i < ATA_MAX_DEVICES; i++)
-                ap->device[i].devno = i;
+        for (i = 0; i < ATA_MAX_DEVICES; i++) {
+                struct ata_device *dev = &ap->device[i];
+                dev->devno = i;
+                dev->pio_mask = UINT_MAX;
+                dev->mwdma_mask = UINT_MAX;
+                dev->udma_mask = UINT_MAX;
+        }
 
 #ifdef ATA_IRQ_TRAP
         ap->stats.unhandled_irq = 1;
@@ -4806,6 +4814,14 @@ static struct ata_port * ata_host_add(const struct ata_probe_ent *ent,
         int rc;
 
         DPRINTK("ENTER\n");
+
+        if (!ent->port_ops->probe_reset &&
+            !(ent->host_flags & (ATA_FLAG_SATA_RESET | ATA_FLAG_SRST))) {
+                printk(KERN_ERR "ata%u: no reset mechanism available\n",
+                       port_no);
+                return NULL;
+        }
+
         host = scsi_host_alloc(ent->sht, sizeof(struct ata_port));
         if (!host)
                 return NULL;
@@ -4966,7 +4982,7 @@ err_free_ret:
  *      ata_host_set_remove - PCI layer callback for device removal
  *      @host_set: ATA host set that was removed
  *
- *      Unregister all objects associated with this host set. Free those 
+ *      Unregister all objects associated with this host set. Free those
  *      objects.
  *
  *      LOCKING:
@@ -5238,6 +5254,8 @@ EXPORT_SYMBOL_GPL(ata_std_postreset);
 EXPORT_SYMBOL_GPL(ata_std_probe_reset);
 EXPORT_SYMBOL_GPL(ata_drive_probe_reset);
 EXPORT_SYMBOL_GPL(ata_dev_revalidate);
+EXPORT_SYMBOL_GPL(ata_dev_classify);
+EXPORT_SYMBOL_GPL(ata_dev_pair);
 EXPORT_SYMBOL_GPL(ata_port_disable);
 EXPORT_SYMBOL_GPL(ata_ratelimit);
 EXPORT_SYMBOL_GPL(ata_busy_sleep);
@@ -5248,7 +5266,6 @@ EXPORT_SYMBOL_GPL(ata_scsi_error);
 EXPORT_SYMBOL_GPL(ata_scsi_slave_config);
 EXPORT_SYMBOL_GPL(ata_scsi_release);
 EXPORT_SYMBOL_GPL(ata_host_intr);
-EXPORT_SYMBOL_GPL(ata_dev_classify);
 EXPORT_SYMBOL_GPL(ata_id_string);
 EXPORT_SYMBOL_GPL(ata_id_c_string);
 EXPORT_SYMBOL_GPL(ata_scsi_simulate);
diff --git a/drivers/scsi/libata-scsi.c b/drivers/scsi/libata-scsi.c
index a1259b242b..628191bfd9 100644
--- a/drivers/scsi/libata-scsi.c
+++ b/drivers/scsi/libata-scsi.c
@@ -256,7 +256,7 @@ int ata_task_ioctl(struct scsi_device *scsidev, void __user *arg)
         scsi_cmd[14] = args[0];
 
         /* Good values for timeout and retries?  Values below
-           from scsi_ioctl_send_command() for default case... */        
+           from scsi_ioctl_send_command() for default case... */
         if (scsi_execute_req(scsidev, scsi_cmd, DMA_NONE, NULL, 0, &sshdr,
                              (10*HZ), 5))
                 rc = -EIO;
@@ -267,20 +267,8 @@ int ata_task_ioctl(struct scsi_device *scsidev, void __user *arg)
 
 int ata_scsi_ioctl(struct scsi_device *scsidev, int cmd, void __user *arg)
 {
-        struct ata_port *ap;
-        struct ata_device *dev;
         int val = -EINVAL, rc = -EINVAL;
 
-        ap = (struct ata_port *) &scsidev->host->hostdata[0];
-        if (!ap)
-                goto out;
-
-        dev = ata_scsi_find_dev(ap, scsidev);
-        if (!dev) {
-                rc = -ENODEV;
-                goto out;
-        }
-
         switch (cmd) {
         case ATA_IOC_GET_IO32:
                 val = 0;
@@ -309,7 +297,6 @@ int ata_scsi_ioctl(struct scsi_device *scsidev, int cmd, void __user *arg)
                 break;
         }
 
-out:
         return rc;
 }
 
@@ -414,12 +401,12 @@ int ata_scsi_device_resume(struct scsi_device *sdev)
         return ata_device_resume(ap, dev);
 }
 
-int ata_scsi_device_suspend(struct scsi_device *sdev)
+int ata_scsi_device_suspend(struct scsi_device *sdev, pm_message_t state)
 {
         struct ata_port *ap = (struct ata_port *) &sdev->host->hostdata[0];
         struct ata_device *dev = &ap->device[sdev->id];
 
-        return ata_device_suspend(ap, dev);
+        return ata_device_suspend(ap, dev, state);
 }
 
 /**
@@ -438,7 +425,7 @@ int ata_scsi_device_suspend(struct scsi_device *sdev)
  *      LOCKING:
  *      spin_lock_irqsave(host_set lock)
  */
-void ata_to_sense_error(unsigned id, u8 drv_stat, u8 drv_err, u8 *sk, u8 *asc, 
+void ata_to_sense_error(unsigned id, u8 drv_stat, u8 drv_err, u8 *sk, u8 *asc,
                         u8 *ascq)
 {
         int i;
@@ -495,7 +482,7 @@ void ata_to_sense_error(unsigned id, u8 drv_stat, u8 drv_err, u8 *sk, u8 *asc,
                 /* Look for drv_err */
                 for (i = 0; sense_table[i][0] != 0xFF; i++) {
                         /* Look for best matches first */
-                        if ((sense_table[i][0] & drv_err) == 
+                        if ((sense_table[i][0] & drv_err) ==
                             sense_table[i][0]) {
                                 *sk = sense_table[i][1];
                                 *asc = sense_table[i][2];
@@ -518,7 +505,7 @@ void ata_to_sense_error(unsigned id, u8 drv_stat, u8 drv_err, u8 *sk, u8 *asc,
                 }
         }
         /* No error?  Undecoded? */
-        printk(KERN_WARNING "ata%u: no sense translation for status: 0x%02x\n", 
+        printk(KERN_WARNING "ata%u: no sense translation for status: 0x%02x\n",
                id, drv_stat);
 
         /* We need a sensible error return here, which is tricky, and one
@@ -1150,14 +1137,14 @@ static unsigned int ata_scsi_verify_xlat(struct ata_queued_cmd *qc, const u8 *sc
 
                 DPRINTK("block %u track %u cyl %u head %u sect %u\n",
                         (u32)block, track, cyl, head, sect);
-                
-                /* Check whether the converted CHS can fit. 
-                   Cylinder: 0-65535 
+
+                /* Check whether the converted CHS can fit.
+                   Cylinder: 0-65535
                    Head: 0-15
                    Sector: 1-255*/
-                if ((cyl >> 16) || (head >> 4) || (sect >> 8) || (!sect)) 
+                if ((cyl >> 16) || (head >> 4) || (sect >> 8) || (!sect))
                         goto out_of_range;
-                
+
                 tf->command = ATA_CMD_VERIFY;
                 tf->nsect = n_block & 0xff; /* Sector count 0 means 256 sectors */
                 tf->lbal = sect;
@@ -1289,7 +1276,7 @@ static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc, const u8 *scsicm
                 tf->lbal = block & 0xff;
 
                 tf->device |= ATA_LBA;
-        } else { 
+        } else {
                 /* CHS */
                 u32 sect, head, cyl, track;
 
@@ -1309,8 +1296,8 @@ static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc, const u8 *scsicm
                 DPRINTK("block %u track %u cyl %u head %u sect %u\n",
                         (u32)block, track, cyl, head, sect);
 
-                /* Check whether the converted CHS can fit. 
-                   Cylinder: 0-65535 
+                /* Check whether the converted CHS can fit.
+                   Cylinder: 0-65535
                    Head: 0-15
                    Sector: 1-255*/
                 if ((cyl >> 16) || (head >> 4) || (sect >> 8) || (!sect))
@@ -1697,7 +1684,7 @@ unsigned int ata_scsiop_inq_83(struct ata_scsi_args *args, u8 *rbuf,
 
         if (buflen > (ATA_SERNO_LEN + num + 3)) {
                 /* piv=0, assoc=lu, code_set=ACSII, designator=vendor */
-                rbuf[num + 0] = 2;      
+                rbuf[num + 0] = 2;
                 rbuf[num + 3] = ATA_SERNO_LEN;
                 num += 4;
                 ata_id_string(args->id, (unsigned char *) rbuf + num,
@@ -1707,8 +1694,8 @@ unsigned int ata_scsiop_inq_83(struct ata_scsi_args *args, u8 *rbuf,
         if (buflen > (sat_model_serial_desc_len + num + 3)) {
                 /* SAT defined lu model and serial numbers descriptor */
                 /* piv=0, assoc=lu, code_set=ACSII, designator=t10 vendor id */
-                rbuf[num + 0] = 2;      
-                rbuf[num + 1] = 1;      
+                rbuf[num + 0] = 2;
+                rbuf[num + 1] = 1;
                 rbuf[num + 3] = sat_model_serial_desc_len;
                 num += 4;
                 memcpy(rbuf + num, "ATA     ", 8);
@@ -2597,6 +2584,21 @@ static inline void ata_scsi_dump_cdb(struct ata_port *ap,
 #endif
 }
 
+static inline void __ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *),
+                                       struct ata_port *ap, struct ata_device *dev)
+{
+        if (dev->class == ATA_DEV_ATA) {
+                ata_xlat_func_t xlat_func = ata_get_xlat_func(dev,
+                                                              cmd->cmnd[0]);
+
+                if (xlat_func)
+                        ata_scsi_translate(ap, dev, cmd, done, xlat_func);
+                else
+                        ata_scsi_simulate(ap, dev, cmd, done);
+        } else
+                ata_scsi_translate(ap, dev, cmd, done, atapi_xlat);
+}
+
 /**
  *      ata_scsi_queuecmd - Issue SCSI cdb to libata-managed device
  *      @cmd: SCSI command to be sent
@@ -2631,24 +2633,13 @@ int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
         ata_scsi_dump_cdb(ap, cmd);
 
         dev = ata_scsi_find_dev(ap, scsidev);
-        if (unlikely(!dev)) {
+        if (likely(dev))
+                __ata_scsi_queuecmd(cmd, done, ap, dev);
+        else {
                 cmd->result = (DID_BAD_TARGET << 16);
                 done(cmd);
-                goto out_unlock;
         }
 
-        if (dev->class == ATA_DEV_ATA) {
-                ata_xlat_func_t xlat_func = ata_get_xlat_func(dev,
-                                                              cmd->cmnd[0]);
-
-                if (xlat_func)
-                        ata_scsi_translate(ap, dev, cmd, done, xlat_func);
-                else
-                        ata_scsi_simulate(ap, dev, cmd, done);
-        } else
-                ata_scsi_translate(ap, dev, cmd, done, atapi_xlat);
-
-out_unlock:
         spin_unlock(&ap->host_set->lock);
         spin_lock(shost->host_lock);
         return 0;
diff --git a/drivers/scsi/megaraid/megaraid_mbox.c b/drivers/scsi/megaraid/megaraid_mbox.c
index bf9f7f7ba3..c11e5ce686 100644
--- a/drivers/scsi/megaraid/megaraid_mbox.c
+++ b/drivers/scsi/megaraid/megaraid_mbox.c
@@ -2797,7 +2797,7 @@ mbox_post_sync_cmd(adapter_t *adapter, uint8_t raw_mbox[])
         // available within 1 second, assume FW is initializing and wait
         // for an extended amount of time
         if (mbox->numstatus == 0xFF) {  // status not yet available
-                udelay(25);;
+                udelay(25);
 
                 for (i = 0; mbox->numstatus == 0xFF && i < 1000; i++) {
                         rmb();
diff --git a/drivers/scsi/sata_sil.c b/drivers/scsi/sata_sil.c
index 3e75d67332..18c296c568 100644
--- a/drivers/scsi/sata_sil.c
+++ b/drivers/scsi/sata_sil.c
@@ -371,7 +371,7 @@ static void sil_dev_config(struct ata_port *ap, struct ata_device *dev)
         if (quirks & SIL_QUIRK_UDMA5MAX) {
                 printk(KERN_INFO "ata%u(%u): applying Maxtor errata fix %s\n",
                        ap->id, dev->devno, model_num);
-                ap->udma_mask &= ATA_UDMA5;
+                dev->udma_mask &= ATA_UDMA5;
                 return;
         }
 }
diff --git a/drivers/scsi/sata_sil24.c b/drivers/scsi/sata_sil24.c
index 3efebea211..068c98a411 100644
--- a/drivers/scsi/sata_sil24.c
+++ b/drivers/scsi/sata_sil24.c
@@ -342,7 +342,7 @@ static struct ata_port_info sil24_port_info[] = {
                 .udma_mask      = 0x3f,                 /* udma0-5 */
                 .port_ops       = &sil24_ops,
         },
-        /* sil_3132 */ 
+        /* sil_3132 */
         {
                 .sht            = &sil24_sht,
                 .host_flags     = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
diff --git a/drivers/scsi/sata_vsc.c b/drivers/scsi/sata_vsc.c
index 9f621a97c9..5af6d5f9f4 100644
--- a/drivers/scsi/sata_vsc.c
+++ b/drivers/scsi/sata_vsc.c
@@ -237,11 +237,11 @@ static irqreturn_t vsc_sata_interrupt (int irq, void *dev_instance,
                                         handled += ata_host_intr(ap, qc);
                                 else if (is_vsc_sata_int_err(i, int_status)) {
                                         /*
-                                         * On some chips (i.e. Intel 31244), an error 
+                                         * On some chips (i.e. Intel 31244), an error
                                          * interrupt will sneak in at initialization
                                          * time (phy state changes).  Clearing the SCR
                                          * error register is not required, but it prevents
-                                         * the phy state change interrupts from recurring 
+                                         * the phy state change interrupts from recurring
                                          * later.
                                          */
                                         u32 err_status;
diff --git a/drivers/scsi/scsi_sysfs.c b/drivers/scsi/scsi_sysfs.c
index 89055494df..a6fde52946 100644
--- a/drivers/scsi/scsi_sysfs.c
+++ b/drivers/scsi/scsi_sysfs.c
@@ -286,7 +286,7 @@ static int scsi_bus_suspend(struct device * dev, pm_message_t state)
                 return err;
 
         if (sht->suspend)
-                err = sht->suspend(sdev);
+                err = sht->suspend(sdev, state);
 
         return err;
 }
diff --git a/drivers/scsi/sr.c b/drivers/scsi/sr.c
index f9c1192dc1..7c80711e18 100644
--- a/drivers/scsi/sr.c
+++ b/drivers/scsi/sr.c
@@ -71,7 +71,7 @@ MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_CDROM_MAJOR);
 #define SR_CAPABILITIES \
         (CDC_CLOSE_TRAY|CDC_OPEN_TRAY|CDC_LOCK|CDC_SELECT_SPEED| \
          CDC_SELECT_DISC|CDC_MULTI_SESSION|CDC_MCN|CDC_MEDIA_CHANGED| \
-         CDC_PLAY_AUDIO|CDC_RESET|CDC_IOCTLS|CDC_DRIVE_STATUS| \
+         CDC_PLAY_AUDIO|CDC_RESET|CDC_DRIVE_STATUS| \
          CDC_CD_R|CDC_CD_RW|CDC_DVD|CDC_DVD_R|CDC_DVD_RAM|CDC_GENERIC_PACKET| \
          CDC_MRW|CDC_MRW_W|CDC_RAM)
 
@@ -118,7 +118,6 @@ static struct cdrom_device_ops sr_dops = {
         .get_mcn                = sr_get_mcn,
         .reset                  = sr_reset,
         .audio_ioctl            = sr_audio_ioctl,
-        .dev_ioctl              = sr_dev_ioctl,
         .capability             = SR_CAPABILITIES,
         .generic_packet         = sr_packet,
 };
@@ -456,17 +455,33 @@ static int sr_block_ioctl(struct inode *inode, struct file *file, unsigned cmd,
 {
         struct scsi_cd *cd = scsi_cd(inode->i_bdev->bd_disk);
         struct scsi_device *sdev = cd->device;
+        void __user *argp = (void __user *)arg;
+        int ret;
 
-        /*
-         * Send SCSI addressing ioctls directly to mid level, send other
-         * ioctls to cdrom/block level.
-         */
-        switch (cmd) {
-                case SCSI_IOCTL_GET_IDLUN:
-                case SCSI_IOCTL_GET_BUS_NUMBER:
-                        return scsi_ioctl(sdev, cmd, (void __user *)arg);
+        /*
+         * Send SCSI addressing ioctls directly to mid level, send other
+         * ioctls to cdrom/block level.
+         */
+        switch (cmd) {
+        case SCSI_IOCTL_GET_IDLUN:
+        case SCSI_IOCTL_GET_BUS_NUMBER:
+                return scsi_ioctl(sdev, cmd, argp);
         }
-        return cdrom_ioctl(file, &cd->cdi, inode, cmd, arg);
+
+        ret = cdrom_ioctl(file, &cd->cdi, inode, cmd, arg);
+        if (ret != ENOSYS)
+                return ret;
+
+        /*
+         * ENODEV means that we didn't recognise the ioctl, or that we
+         * cannot execute it in the current device state.  In either
+         * case fall through to scsi_ioctl, which will return ENDOEV again
+         * if it doesn't recognise the ioctl
+         */
+        ret = scsi_nonblockable_ioctl(sdev, cmd, argp, NULL);
+        if (ret != -ENODEV)
+                return ret;
+        return scsi_ioctl(sdev, cmd, argp);
 }
 
 static int sr_block_media_changed(struct gendisk *disk)
diff --git a/drivers/scsi/sr.h b/drivers/scsi/sr.h
index d2bcd99c27..d65de9621b 100644
--- a/drivers/scsi/sr.h
+++ b/drivers/scsi/sr.h
@@ -55,7 +55,6 @@ int sr_get_mcn(struct cdrom_device_info *, struct cdrom_mcn *);
 int sr_reset(struct cdrom_device_info *);
 int sr_select_speed(struct cdrom_device_info *cdi, int speed);
 int sr_audio_ioctl(struct cdrom_device_info *, unsigned int, void *);
-int sr_dev_ioctl(struct cdrom_device_info *, unsigned int, unsigned long);
 
 int sr_is_xa(Scsi_CD *);
 
diff --git a/drivers/scsi/sr_ioctl.c b/drivers/scsi/sr_ioctl.c
index b65462f764..d1268cb468 100644
--- a/drivers/scsi/sr_ioctl.c
+++ b/drivers/scsi/sr_ioctl.c
@@ -562,22 +562,3 @@ int sr_is_xa(Scsi_CD *cd)
 #endif
         return is_xa;
 }
-
-int sr_dev_ioctl(struct cdrom_device_info *cdi,
-                 unsigned int cmd, unsigned long arg)
-{
-        Scsi_CD *cd = cdi->handle;
-        int ret;
-        
-        ret = scsi_nonblockable_ioctl(cd->device, cmd,
-                                      (void __user *)arg, NULL);
-        /*
-         * ENODEV means that we didn't recognise the ioctl, or that we
-         * cannot execute it in the current device state.  In either
-         * case fall through to scsi_ioctl, which will return ENDOEV again
-         * if it doesn't recognise the ioctl
-         */
-        if (ret != -ENODEV)
-                return ret;
-        return scsi_ioctl(cd->device, cmd, (void __user *)arg);
-}
diff --git a/drivers/serial/68328serial.c b/drivers/serial/68328serial.c
index 7f0f35a05d..b88a7c1158 100644
--- a/drivers/serial/68328serial.c
+++ b/drivers/serial/68328serial.c
@@ -101,8 +101,6 @@ struct tty_driver *serial_driver;
 
 #define RS_ISR_PASS_LIMIT 256
 
-#define _INLINE_ inline
-
 static void change_speed(struct m68k_serial *info);
 
 /*
@@ -262,7 +260,7 @@ static void batten_down_hatches(void)
         /* Drop into the debugger */
 }
 
-static _INLINE_ void status_handle(struct m68k_serial *info, unsigned short status)
+static void status_handle(struct m68k_serial *info, unsigned short status)
 {
 #if 0
         if(status & DCD) {
@@ -289,7 +287,8 @@ static _INLINE_ void status_handle(struct m68k_serial *info, unsigned short stat
         return;
 }
 
-static _INLINE_ void receive_chars(struct m68k_serial *info, struct pt_regs *regs, unsigned short rx)
+static void receive_chars(struct m68k_serial *info, struct pt_regs *regs,
+                          unsigned short rx)
 {
         struct tty_struct *tty = info->tty;
         m68328_uart *uart = &uart_addr[info->line];
@@ -359,7 +358,7 @@ clear_and_exit:
         return;
 }
 
-static _INLINE_ void transmit_chars(struct m68k_serial *info)
+static void transmit_chars(struct m68k_serial *info)
 {
         m68328_uart *uart = &uart_addr[info->line];
 
diff --git a/drivers/serial/au1x00_uart.c b/drivers/serial/au1x00_uart.c
index 29f94bbb79..948880ac58 100644
--- a/drivers/serial/au1x00_uart.c
+++ b/drivers/serial/au1x00_uart.c
@@ -133,13 +133,12 @@ static const struct serial_uart_config uart_config[PORT_MAX_8250+1] = {
         { "AU1X00_UART",16,     UART_CLEAR_FIFO | UART_USE_FIFO },
 };
 
-static _INLINE_ unsigned int serial_in(struct uart_8250_port *up, int offset)
+static unsigned int serial_in(struct uart_8250_port *up, int offset)
 {
         return au_readl((unsigned long)up->port.membase + offset);
 }
 
-static _INLINE_ void
-serial_out(struct uart_8250_port *up, int offset, int value)
+static void serial_out(struct uart_8250_port *up, int offset, int value)
 {
         au_writel(value, (unsigned long)up->port.membase + offset);
 }
@@ -237,7 +236,7 @@ static void serial8250_enable_ms(struct uart_port *port)
         serial_out(up, UART_IER, up->ier);
 }
 
-static _INLINE_ void
+static void
 receive_chars(struct uart_8250_port *up, int *status, struct pt_regs *regs)
 {
         struct tty_struct *tty = up->port.info->tty;
@@ -312,7 +311,7 @@ receive_chars(struct uart_8250_port *up, int *status, struct pt_regs *regs)
         spin_lock(&up->port.lock);
 }
 
-static _INLINE_ void transmit_chars(struct uart_8250_port *up)
+static void transmit_chars(struct uart_8250_port *up)
 {
         struct circ_buf *xmit = &up->port.info->xmit;
         int count;
@@ -346,7 +345,7 @@ static _INLINE_ void transmit_chars(struct uart_8250_port *up)
                 serial8250_stop_tx(&up->port);
 }
 
-static _INLINE_ void check_modem_status(struct uart_8250_port *up)
+static void check_modem_status(struct uart_8250_port *up)
 {
         int status;
 
diff --git a/drivers/serial/crisv10.c b/drivers/serial/crisv10.c
index be12623d85..89700141f8 100644
--- a/drivers/serial/crisv10.c
+++ b/drivers/serial/crisv10.c
@@ -481,8 +481,6 @@ static char *serial_version = "$Revision: 1.25 $";
 #include "serial_compat.h"
 #endif
 
-#define _INLINE_ inline
-
 struct tty_driver *serial_driver;
 
 /* serial subtype definitions */
@@ -591,8 +589,6 @@ static void rs_throttle(struct tty_struct * tty);
 static void rs_wait_until_sent(struct tty_struct *tty, int timeout);
 static int rs_write(struct tty_struct * tty, int from_user,
                     const unsigned char *buf, int count);
-extern _INLINE_ int rs_raw_write(struct tty_struct * tty, int from_user,
-                            const unsigned char *buf, int count);
 #ifdef CONFIG_ETRAX_RS485
 static int e100_write_rs485(struct tty_struct * tty, int from_user,
                             const unsigned char *buf, int count);
@@ -1538,8 +1534,7 @@ e100_enable_rxdma_irq(struct e100_serial *info)
 
 /* the tx DMA uses only dma_descr interrupt */
 
-static _INLINE_ void
-e100_disable_txdma_irq(struct e100_serial *info)
+static void e100_disable_txdma_irq(struct e100_serial *info)
 {
 #ifdef SERIAL_DEBUG_INTR
         printk("txdma_irq(%d): 0\n",info->line);
@@ -1548,8 +1543,7 @@ e100_disable_txdma_irq(struct e100_serial *info)
         *R_IRQ_MASK2_CLR = info->irq;
 }
 
-static _INLINE_ void
-e100_enable_txdma_irq(struct e100_serial *info)
+static void e100_enable_txdma_irq(struct e100_serial *info)
 {
 #ifdef SERIAL_DEBUG_INTR
         printk("txdma_irq(%d): 1\n",info->line);
@@ -1558,8 +1552,7 @@ e100_enable_txdma_irq(struct e100_serial *info)
         *R_IRQ_MASK2_SET = info->irq;
 }
 
-static _INLINE_ void
-e100_disable_txdma_channel(struct e100_serial *info)
+static void e100_disable_txdma_channel(struct e100_serial *info)
 {
         unsigned long flags;
 
@@ -1599,8 +1592,7 @@ e100_disable_txdma_channel(struct e100_serial *info)
 }
 
 
-static _INLINE_ void
-e100_enable_txdma_channel(struct e100_serial *info)
+static void e100_enable_txdma_channel(struct e100_serial *info)
 {
         unsigned long flags;
 
@@ -1625,8 +1617,7 @@ e100_enable_txdma_channel(struct e100_serial *info)
         restore_flags(flags);
 }
 
-static _INLINE_ void
-e100_disable_rxdma_channel(struct e100_serial *info)
+static void e100_disable_rxdma_channel(struct e100_serial *info)
 {
         unsigned long flags;
 
@@ -1665,8 +1656,7 @@ e100_disable_rxdma_channel(struct e100_serial *info)
 }
 
 
-static _INLINE_ void
-e100_enable_rxdma_channel(struct e100_serial *info)
+static void e100_enable_rxdma_channel(struct e100_serial *info)
 {
         unsigned long flags;
 
@@ -1913,9 +1903,7 @@ rs_start(struct tty_struct *tty)
  * This routine is used by the interrupt handler to schedule
  * processing in the software interrupt portion of the driver.
  */
-static _INLINE_ void
-rs_sched_event(struct e100_serial *info,
-                                    int event)
+static void rs_sched_event(struct e100_serial *info, int event)
 {
         if (info->event & (1 << event))
                 return;
@@ -2155,8 +2143,9 @@ add_char_and_flag(struct e100_serial *info, unsigned char data, unsigned char fl
         return 1;
 }
 
-extern _INLINE_ unsigned int
-handle_descr_data(struct e100_serial *info, struct etrax_dma_descr *descr, unsigned int recvl)
+static unsigned int handle_descr_data(struct e100_serial *info,
+                                      struct etrax_dma_descr *descr,
+                                      unsigned int recvl)
 {
         struct etrax_recv_buffer *buffer = phys_to_virt(descr->buf) - sizeof *buffer;
 
@@ -2182,8 +2171,7 @@ handle_descr_data(struct e100_serial *info, struct etrax_dma_descr *descr, unsig
         return recvl;
 }
 
-static _INLINE_ unsigned int
-handle_all_descr_data(struct e100_serial *info)
+static unsigned int handle_all_descr_data(struct e100_serial *info)
 {
         struct etrax_dma_descr *descr;
         unsigned int recvl;
@@ -2230,8 +2218,7 @@ handle_all_descr_data(struct e100_serial *info)
         return ret;
 }
 
-static _INLINE_ void
-receive_chars_dma(struct e100_serial *info)
+static void receive_chars_dma(struct e100_serial *info)
 {
         struct tty_struct *tty;
         unsigned char rstat;
@@ -2292,8 +2279,7 @@ receive_chars_dma(struct e100_serial *info)
         *info->icmdadr = IO_STATE(R_DMA_CH6_CMD, cmd, restart);
 }
 
-static _INLINE_ int
-start_recv_dma(struct e100_serial *info)
+static int start_recv_dma(struct e100_serial *info)
 {
         struct etrax_dma_descr *descr = info->rec_descr;
         struct etrax_recv_buffer *buffer;
@@ -2348,11 +2334,6 @@ start_receive(struct e100_serial *info)
 }
 
 
-static _INLINE_ void
-status_handle(struct e100_serial *info, unsigned short status)
-{
-}
-
 /* the bits in the MASK2 register are laid out like this:
    DMAI_EOP DMAI_DESCR DMAO_EOP DMAO_DESCR
    where I is the input channel and O is the output channel for the port.
@@ -2454,8 +2435,7 @@ rec_interrupt(int irq, void *dev_id, struct pt_regs * regs)
         return IRQ_RETVAL(handled);
 } /* rec_interrupt */
 
-static _INLINE_ int
-force_eop_if_needed(struct e100_serial *info)
+static int force_eop_if_needed(struct e100_serial *info)
 {
         /* We check data_avail bit to determine if data has
          * arrived since last time
@@ -2499,8 +2479,7 @@ force_eop_if_needed(struct e100_serial *info)
         return 1;
 }
 
-extern _INLINE_ void
-flush_to_flip_buffer(struct e100_serial *info)
+static void flush_to_flip_buffer(struct e100_serial *info)
 {
         struct tty_struct *tty;
         struct etrax_recv_buffer *buffer;
@@ -2611,8 +2590,7 @@ flush_to_flip_buffer(struct e100_serial *info)
         tty_flip_buffer_push(tty);
 }
 
-static _INLINE_ void
-check_flush_timeout(struct e100_serial *info)
+static void check_flush_timeout(struct e100_serial *info)
 {
         /* Flip what we've got (if we can) */
         flush_to_flip_buffer(info);
@@ -2741,7 +2719,7 @@ TODO: The break will be delayed until an F or V character is received.
 
 */
 
-extern _INLINE_
+static
 struct e100_serial * handle_ser_rx_interrupt_no_dma(struct e100_serial *info)
 {
         unsigned long data_read;
@@ -2875,8 +2853,7 @@ more_data:
         return info;
 }
 
-extern _INLINE_
-struct e100_serial* handle_ser_rx_interrupt(struct e100_serial *info)
+static struct e100_serial* handle_ser_rx_interrupt(struct e100_serial *info)
 {
         unsigned char rstat;
 
@@ -2995,7 +2972,7 @@ struct e100_serial* handle_ser_rx_interrupt(struct e100_serial *info)
         return info;
 } /* handle_ser_rx_interrupt */
 
-extern _INLINE_ void handle_ser_tx_interrupt(struct e100_serial *info)
+static void handle_ser_tx_interrupt(struct e100_serial *info)
 {
         unsigned long flags;
 
@@ -3621,9 +3598,8 @@ rs_flush_chars(struct tty_struct *tty)
         restore_flags(flags);
 }
 
-extern _INLINE_ int
-rs_raw_write(struct tty_struct * tty, int from_user,
-          const unsigned char *buf, int count)
+static int rs_raw_write(struct tty_struct * tty, int from_user,
+                        const unsigned char *buf, int count)
 {
         int     c, ret = 0;
         struct e100_serial *info = (struct e100_serial *)tty->driver_data;
@@ -4710,7 +4686,7 @@ rs_open(struct tty_struct *tty, struct file * filp)
  * /proc fs routines....
  */
 
-extern _INLINE_ int line_info(char *buf, struct e100_serial *info)
+static int line_info(char *buf, struct e100_serial *info)
 {
         char    stat_buf[30];
         int     ret;
diff --git a/drivers/serial/m32r_sio.c b/drivers/serial/m32r_sio.c
index 876bc5e027..e9c10c0a30 100644
--- a/drivers/serial/m32r_sio.c
+++ b/drivers/serial/m32r_sio.c
@@ -248,17 +248,17 @@ static void sio_error(int *status)
 
 #endif /* CONFIG_SERIAL_M32R_PLDSIO */
 
-static _INLINE_ unsigned int sio_in(struct uart_sio_port *up, int offset)
+static unsigned int sio_in(struct uart_sio_port *up, int offset)
 {
         return __sio_in(up->port.iobase + offset);
 }
 
-static _INLINE_ void sio_out(struct uart_sio_port *up, int offset, int value)
+static void sio_out(struct uart_sio_port *up, int offset, int value)
 {
         __sio_out(value, up->port.iobase + offset);
 }
 
-static _INLINE_ unsigned int serial_in(struct uart_sio_port *up, int offset)
+static unsigned int serial_in(struct uart_sio_port *up, int offset)
 {
         if (!offset)
                 return 0;
@@ -266,8 +266,7 @@ static _INLINE_ unsigned int serial_in(struct uart_sio_port *up, int offset)
         return __sio_in(offset);
 }
 
-static _INLINE_ void
-serial_out(struct uart_sio_port *up, int offset, int value)
+static void serial_out(struct uart_sio_port *up, int offset, int value)
 {
         if (!offset)
                 return;
@@ -326,8 +325,8 @@ static void m32r_sio_enable_ms(struct uart_port *port)
         serial_out(up, UART_IER, up->ier);
 }
 
-static _INLINE_ void receive_chars(struct uart_sio_port *up, int *status,
-        struct pt_regs *regs)
+static void receive_chars(struct uart_sio_port *up, int *status,
+                          struct pt_regs *regs)
 {
         struct tty_struct *tty = up->port.info->tty;
         unsigned char ch;
@@ -400,7 +399,7 @@ static _INLINE_ void receive_chars(struct uart_sio_port *up, int *status,
         tty_flip_buffer_push(tty);
 }
 
-static _INLINE_ void transmit_chars(struct uart_sio_port *up)
+static void transmit_chars(struct uart_sio_port *up)
 {
         struct circ_buf *xmit = &up->port.info->xmit;
         int count;
diff --git a/drivers/serial/sunsu.c b/drivers/serial/sunsu.c
index 7fc3d3b41d..9fe2283d91 100644
--- a/drivers/serial/sunsu.c
+++ b/drivers/serial/sunsu.c
@@ -102,9 +102,7 @@ struct uart_sunsu_port {
 #endif
 };
 
-#define _INLINE_
-
-static _INLINE_ unsigned int serial_in(struct uart_sunsu_port *up, int offset)
+static unsigned int serial_in(struct uart_sunsu_port *up, int offset)
 {
         offset <<= up->port.regshift;
 
@@ -121,8 +119,7 @@ static _INLINE_ unsigned int serial_in(struct uart_sunsu_port *up, int offset)
         }
 }
 
-static _INLINE_ void
-serial_out(struct uart_sunsu_port *up, int offset, int value)
+static void serial_out(struct uart_sunsu_port *up, int offset, int value)
 {
 #ifndef CONFIG_SPARC64
         /*
@@ -316,7 +313,7 @@ static void sunsu_enable_ms(struct uart_port *port)
         spin_unlock_irqrestore(&up->port.lock, flags);
 }
 
-static _INLINE_ struct tty_struct *
+static struct tty_struct *
 receive_chars(struct uart_sunsu_port *up, unsigned char *status, struct pt_regs *regs)
 {
         struct tty_struct *tty = up->port.info->tty;
@@ -395,7 +392,7 @@ receive_chars(struct uart_sunsu_port *up, unsigned char *status, struct pt_regs
         return tty;
 }
 
-static _INLINE_ void transmit_chars(struct uart_sunsu_port *up)
+static void transmit_chars(struct uart_sunsu_port *up)
 {
         struct circ_buf *xmit = &up->port.info->xmit;
         int count;
@@ -431,7 +428,7 @@ static _INLINE_ void transmit_chars(struct uart_sunsu_port *up)
                 __stop_tx(up);
 }
 
-static _INLINE_ void check_modem_status(struct uart_sunsu_port *up)
+static void check_modem_status(struct uart_sunsu_port *up)
 {
         int status;
 
diff --git a/drivers/tc/zs.c b/drivers/tc/zs.c
index 6756d0fab6..2dffa8e303 100644
--- a/drivers/tc/zs.c
+++ b/drivers/tc/zs.c
@@ -186,8 +186,6 @@ static struct tty_driver *serial_driver;
 #define RS_STROBE_TIME 10
 #define RS_ISR_PASS_LIMIT 256
 
-#define _INLINE_ inline
-
 static void probe_sccs(void);
 static void change_speed(struct dec_serial *info);
 static void rs_wait_until_sent(struct tty_struct *tty, int timeout);
@@ -344,14 +342,13 @@ static inline void rs_recv_clear(struct dec_zschannel *zsc)
  * This routine is used by the interrupt handler to schedule
  * processing in the software interrupt portion of the driver.
  */
-static _INLINE_ void rs_sched_event(struct dec_serial *info, int event)
+static void rs_sched_event(struct dec_serial *info, int event)
 {
         info->event |= 1 << event;
         tasklet_schedule(&info->tlet);
 }
 
-static _INLINE_ void receive_chars(struct dec_serial *info,
-                                   struct pt_regs *regs)
+static void receive_chars(struct dec_serial *info, struct pt_regs *regs)
 {
         struct tty_struct *tty = info->tty;
         unsigned char ch, stat, flag;
@@ -441,7 +438,7 @@ static void transmit_chars(struct dec_serial *info)
                 rs_sched_event(info, RS_EVENT_WRITE_WAKEUP);
 }
 
-static _INLINE_ void status_handle(struct dec_serial *info)
+static void status_handle(struct dec_serial *info)
 {
         unsigned char stat;
 
diff --git a/drivers/usb/image/microtek.c b/drivers/usb/image/microtek.c
index 28538db9ea..2a0e18a487 100644
--- a/drivers/usb/image/microtek.c
+++ b/drivers/usb/image/microtek.c
@@ -360,7 +360,7 @@ static int mts_scsi_host_reset (Scsi_Cmnd *srb)
         rc = usb_lock_device_for_reset(desc->usb_dev, desc->usb_intf);
         if (rc < 0)
                 return FAILED;
-        result = usb_reset_device(desc->usb_dev);;
+        result = usb_reset_device(desc->usb_dev);
         if (rc)
                 usb_unlock_device(desc->usb_dev);
         return result ? FAILED : SUCCESS;
diff --git a/drivers/usb/input/hid-core.c b/drivers/usb/input/hid-core.c
index 58b59f6e98..d4bf170104 100644
--- a/drivers/usb/input/hid-core.c
+++ b/drivers/usb/input/hid-core.c
@@ -1215,7 +1215,7 @@ static void hid_irq_out(struct urb *urb, struct pt_regs *regs)
 
         if (hid->outhead != hid->outtail) {
                 if (hid_submit_out(hid)) {
-                        clear_bit(HID_OUT_RUNNING, &hid->iofl);;
+                        clear_bit(HID_OUT_RUNNING, &hid->iofl);
                         wake_up(&hid->wait);
                 }
                 spin_unlock_irqrestore(&hid->outlock, flags);
diff --git a/drivers/video/aty/radeon_pm.c b/drivers/video/aty/radeon_pm.c
index 1f8d805c61..5886a2f132 100644
--- a/drivers/video/aty/radeon_pm.c
+++ b/drivers/video/aty/radeon_pm.c
@@ -2080,7 +2080,7 @@ static void radeon_reinitialize_M9P(struct radeonfb_info *rinfo)
         OUTREG(0x2ec, 0x6332a3f0);
         mdelay(17);
 
-        OUTPLL(pllPPLL_REF_DIV, rinfo->pll.ref_div);;
+        OUTPLL(pllPPLL_REF_DIV, rinfo->pll.ref_div);
         OUTPLL(pllPPLL_DIV_0, rinfo->save_regs[92]);
 
         mdelay(40);
diff --git a/drivers/w1/Kconfig b/drivers/w1/Kconfig
index 4baf61a223..5e61ed59a4 100644
--- a/drivers/w1/Kconfig
+++ b/drivers/w1/Kconfig
@@ -11,63 +11,7 @@ config W1
           This W1 support can also be built as a module.  If so, the module
           will be called wire.ko.
 
-config W1_MATROX
-        tristate "Matrox G400 transport layer for 1-wire"
-        depends on W1 && PCI
-        help
-          Say Y here if you want to communicate with your 1-wire devices
-          using Matrox's G400 GPIO pins.
-
-          This support is also available as a module.  If so, the module
-          will be called matrox_w1.ko.
-
-config W1_DS9490
-        tristate "DS9490R transport layer driver"
-        depends on W1 && USB
-        help
-          Say Y here if you want to have a driver for DS9490R UWB <-> W1 bridge.
-
-          This support is also available as a module.  If so, the module
-          will be called ds9490r.ko.
-
-config W1_DS9490_BRIDGE
-        tristate "DS9490R USB <-> W1 transport layer for 1-wire"
-        depends on W1_DS9490
-        help
-          Say Y here if you want to communicate with your 1-wire devices
-          using DS9490R USB bridge.
-
-          This support is also available as a module.  If so, the module
-          will be called ds_w1_bridge.ko.
-
-config W1_THERM
-        tristate "Thermal family implementation"
-        depends on W1
-        help
-          Say Y here if you want to connect 1-wire thermal sensors to you
-          wire.
-
-config W1_SMEM
-        tristate "Simple 64bit memory family implementation"
-        depends on W1
-        help
-          Say Y here if you want to connect 1-wire
-          simple 64bit memory rom(ds2401/ds2411/ds1990*) to you wire.
-
-config W1_DS2433
-        tristate "4kb EEPROM family support (DS2433)"
-        depends on W1
-        help
-          Say Y here if you want to use a 1-wire
-          4kb EEPROM family device (DS2433).
-
-config W1_DS2433_CRC
-        bool "Protect DS2433 data with a CRC16"
-        depends on W1_DS2433
-        select CRC16
-        help
-          Say Y here to protect DS2433 data with a CRC16.
-          Each block has 30 bytes of data and a two byte CRC16.
-          Full block writes are only allowed if the CRC is valid.
+source drivers/w1/masters/Kconfig
+source drivers/w1/slaves/Kconfig
 
 endmenu
diff --git a/drivers/w1/Makefile b/drivers/w1/Makefile
index 01fb543914..0c2aa22d8c 100644
--- a/drivers/w1/Makefile
+++ b/drivers/w1/Makefile
@@ -13,13 +13,5 @@ endif
 obj-$(CONFIG_W1)        += wire.o
 wire-objs               := w1.o w1_int.o w1_family.o w1_netlink.o w1_io.o
 
-obj-$(CONFIG_W1_MATROX)         += matrox_w1.o
-obj-$(CONFIG_W1_THERM)          += w1_therm.o
-obj-$(CONFIG_W1_SMEM)           += w1_smem.o
+obj-y                   += masters/ slaves/
 
-obj-$(CONFIG_W1_DS9490)         += ds9490r.o
-ds9490r-objs    := dscore.o
-
-obj-$(CONFIG_W1_DS9490_BRIDGE)  += ds_w1_bridge.o
-
-obj-$(CONFIG_W1_DS2433)         += w1_ds2433.o
diff --git a/drivers/w1/masters/Kconfig b/drivers/w1/masters/Kconfig
new file mode 100644
index 0000000000..c6bad4dbdc
--- /dev/null
+++ b/drivers/w1/masters/Kconfig
@@ -0,0 +1,48 @@
+#
+# 1-wire bus master configuration
+#
+
+menu "1-wire Bus Masters"
+        depends on W1
+
+config W1_MASTER_MATROX
+        tristate "Matrox G400 transport layer for 1-wire"
+        depends on W1 && PCI
+        help
+          Say Y here if you want to communicate with your 1-wire devices
+          using Matrox's G400 GPIO pins.
+
+          This support is also available as a module.  If so, the module
+          will be called matrox_w1.ko.
+
+config W1_MASTER_DS9490
+        tristate "DS9490R transport layer driver"
+        depends on W1 && USB
+        help
+          Say Y here if you want to have a driver for DS9490R UWB <-> W1 bridge.
+
+          This support is also available as a module.  If so, the module
+          will be called ds9490r.ko.
+
+config W1_MASTER_DS9490_BRIDGE
+        tristate "DS9490R USB <-> W1 transport layer for 1-wire"
+        depends on W1_MASTER_DS9490
+        help
+          Say Y here if you want to communicate with your 1-wire devices
+          using DS9490R USB bridge.
+
+          This support is also available as a module.  If so, the module
+          will be called ds_w1_bridge.ko.
+
+config W1_MASTER_DS2482
+        tristate "Maxim DS2482 I2C to 1-Wire bridge"
+        depends on I2C && W1 && EXPERIMENTAL
+        help
+          If you say yes here you get support for the Maxim DS2482
+          I2C to 1-Wire bridge.
+
+          This driver can also be built as a module.  If so, the module
+          will be called ds2482.
+
+endmenu
+
diff --git a/drivers/w1/masters/Makefile b/drivers/w1/masters/Makefile
new file mode 100644
index 0000000000..1f3c8b983d
--- /dev/null
+++ b/drivers/w1/masters/Makefile
@@ -0,0 +1,13 @@
+#
+# Makefile for 1-wire bus master drivers.
+#
+
+obj-$(CONFIG_W1_MASTER_MATROX)          += matrox_w1.o
+
+obj-$(CONFIG_W1_MASTER_DS9490)          += ds9490r.o
+ds9490r-objs    := dscore.o
+
+obj-$(CONFIG_W1_MASTER_DS9490_BRIDGE)   += ds_w1_bridge.o
+
+obj-$(CONFIG_W1_MASTER_DS2482)          += ds2482.o
+
diff --git a/drivers/w1/masters/ds2482.c b/drivers/w1/masters/ds2482.c
new file mode 100644
index 0000000000..d1cacd2357
--- /dev/null
+++ b/drivers/w1/masters/ds2482.c
@@ -0,0 +1,564 @@
+/**
+ * ds2482.c - provides i2c to w1-master bridge(s)
+ * Copyright (C) 2005  Ben Gardner <bgardner@wabtec.com>
+ *
+ * The DS2482 is a sensor chip made by Dallas Semiconductor (Maxim).
+ * It is a I2C to 1-wire bridge.
+ * There are two variations: -100 and -800, which have 1 or 8 1-wire ports.
+ * The complete datasheet can be obtained from MAXIM's website at:
+ *   http://www.maxim-ic.com/quick_view2.cfm/qv_pk/4382
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/delay.h>
+#include <asm/delay.h>
+
+#include "../w1.h"
+#include "../w1_int.h"
+
+/**
+ * Address is selected using 2 pins, resulting in 4 possible addresses.
+ *  0x18, 0x19, 0x1a, 0x1b
+ * However, the chip cannot be detected without doing an i2c write,
+ * so use the force module parameter.
+ */
+static unsigned short normal_i2c[] = {I2C_CLIENT_END};
+
+/**
+ * Insmod parameters
+ */
+I2C_CLIENT_INSMOD_1(ds2482);
+
+/**
+ * The DS2482 registers - there are 3 registers that are addressed by a read
+ * pointer. The read pointer is set by the last command executed.
+ *
+ * To read the data, issue a register read for any address
+ */
+#define DS2482_CMD_RESET                0xF0    /* No param */
+#define DS2482_CMD_SET_READ_PTR         0xE1    /* Param: DS2482_PTR_CODE_xxx */
+#define DS2482_CMD_CHANNEL_SELECT       0xC3    /* Param: Channel byte - DS2482-800 only */
+#define DS2482_CMD_WRITE_CONFIG         0xD2    /* Param: Config byte */
+#define DS2482_CMD_1WIRE_RESET          0xB4    /* Param: None */
+#define DS2482_CMD_1WIRE_SINGLE_BIT     0x87    /* Param: Bit byte (bit7) */
+#define DS2482_CMD_1WIRE_WRITE_BYTE     0xA5    /* Param: Data byte */
+#define DS2482_CMD_1WIRE_READ_BYTE      0x96    /* Param: None */
+/* Note to read the byte, Set the ReadPtr to Data then read (any addr) */
+#define DS2482_CMD_1WIRE_TRIPLET        0x78    /* Param: Dir byte (bit7) */
+
+/* Values for DS2482_CMD_SET_READ_PTR */
+#define DS2482_PTR_CODE_STATUS          0xF0
+#define DS2482_PTR_CODE_DATA            0xE1
+#define DS2482_PTR_CODE_CHANNEL         0xD2    /* DS2482-800 only */
+#define DS2482_PTR_CODE_CONFIG          0xC3
+
+/**
+ * Configure Register bit definitions
+ * The top 4 bits always read 0.
+ * To write, the top nibble must be the 1's compl. of the low nibble.
+ */
+#define DS2482_REG_CFG_1WS              0x08
+#define DS2482_REG_CFG_SPU              0x04
+#define DS2482_REG_CFG_PPM              0x02
+#define DS2482_REG_CFG_APU              0x01
+
+
+/**
+ * Write and verify codes for the CHANNEL_SELECT command (DS2482-800 only).
+ * To set the channel, write the value at the index of the channel.
+ * Read and compare against the corresponding value to verify the change.
+ */
+static const u8 ds2482_chan_wr[8] =
+        { 0xF0, 0xE1, 0xD2, 0xC3, 0xB4, 0xA5, 0x96, 0x87 };
+static const u8 ds2482_chan_rd[8] =
+        { 0xB8, 0xB1, 0xAA, 0xA3, 0x9C, 0x95, 0x8E, 0x87 };
+
+
+/**
+ * Status Register bit definitions (read only)
+ */
+#define DS2482_REG_STS_DIR              0x80
+#define DS2482_REG_STS_TSB              0x40
+#define DS2482_REG_STS_SBR              0x20
+#define DS2482_REG_STS_RST              0x10
+#define DS2482_REG_STS_LL               0x08
+#define DS2482_REG_STS_SD               0x04
+#define DS2482_REG_STS_PPD              0x02
+#define DS2482_REG_STS_1WB              0x01
+
+
+static int ds2482_attach_adapter(struct i2c_adapter *adapter);
+static int ds2482_detect(struct i2c_adapter *adapter, int address, int kind);
+static int ds2482_detach_client(struct i2c_client *client);
+
+
+/**
+ * Driver data (common to all clients)
+ */
+static struct i2c_driver ds2482_driver = {
+        .driver = {
+                .owner  = THIS_MODULE,
+                .name   = "ds2482",
+        },
+        .attach_adapter = ds2482_attach_adapter,
+        .detach_client  = ds2482_detach_client,
+};
+
+/*
+ * Client data (each client gets its own)
+ */
+
+struct ds2482_data;
+
+struct ds2482_w1_chan {
+        struct ds2482_data      *pdev;
+        u8                      channel;
+        struct w1_bus_master    w1_bm;
+};
+
+struct ds2482_data {
+        struct i2c_client       client;
+        struct semaphore        access_lock;
+
+        /* 1-wire interface(s) */
+        int                     w1_count;       /* 1 or 8 */
+        struct ds2482_w1_chan   w1_ch[8];
+
+        /* per-device values */
+        u8                      channel;
+        u8                      read_prt;       /* see DS2482_PTR_CODE_xxx */
+        u8                      reg_config;
+};
+
+
+/**
+ * Sets the read pointer.
+ * @param pdev          The ds2482 client pointer
+ * @param read_ptr      see DS2482_PTR_CODE_xxx above
+ * @return -1 on failure, 0 on success
+ */
+static inline int ds2482_select_register(struct ds2482_data *pdev, u8 read_ptr)
+{
+        if (pdev->read_prt != read_ptr) {
+                if (i2c_smbus_write_byte_data(&pdev->client,
+                                              DS2482_CMD_SET_READ_PTR,
+                                              read_ptr) < 0)
+                        return -1;
+
+                pdev->read_prt = read_ptr;
+        }
+        return 0;
+}
+
+/**
+ * Sends a command without a parameter
+ * @param pdev  The ds2482 client pointer
+ * @param cmd   DS2482_CMD_RESET,
+ *              DS2482_CMD_1WIRE_RESET,
+ *              DS2482_CMD_1WIRE_READ_BYTE
+ * @return -1 on failure, 0 on success
+ */
+static inline int ds2482_send_cmd(struct ds2482_data *pdev, u8 cmd)
+{
+        if (i2c_smbus_write_byte(&pdev->client, cmd) < 0)
+                return -1;
+
+        pdev->read_prt = DS2482_PTR_CODE_STATUS;
+        return 0;
+}
+
+/**
+ * Sends a command with a parameter
+ * @param pdev  The ds2482 client pointer
+ * @param cmd   DS2482_CMD_WRITE_CONFIG,
+ *              DS2482_CMD_1WIRE_SINGLE_BIT,
+ *              DS2482_CMD_1WIRE_WRITE_BYTE,
+ *              DS2482_CMD_1WIRE_TRIPLET
+ * @param byte  The data to send
+ * @return -1 on failure, 0 on success
+ */
+static inline int ds2482_send_cmd_data(struct ds2482_data *pdev,
+                                       u8 cmd, u8 byte)
+{
+        if (i2c_smbus_write_byte_data(&pdev->client, cmd, byte) < 0)
+                return -1;
+
+        /* all cmds leave in STATUS, except CONFIG */
+        pdev->read_prt = (cmd != DS2482_CMD_WRITE_CONFIG) ?
+                         DS2482_PTR_CODE_STATUS : DS2482_PTR_CODE_CONFIG;
+        return 0;
+}
+
+
+/*
+ * 1-Wire interface code
+ */
+
+#define DS2482_WAIT_IDLE_TIMEOUT        100
+
+/**
+ * Waits until the 1-wire interface is idle (not busy)
+ *
+ * @param pdev Pointer to the device structure
+ * @return the last value read from status or -1 (failure)
+ */
+static int ds2482_wait_1wire_idle(struct ds2482_data *pdev)
+{
+        int temp = -1;
+        int retries = 0;
+
+        if (!ds2482_select_register(pdev, DS2482_PTR_CODE_STATUS)) {
+                do {
+                        temp = i2c_smbus_read_byte(&pdev->client);
+                } while ((temp >= 0) && (temp & DS2482_REG_STS_1WB) &&
+                         (++retries > DS2482_WAIT_IDLE_TIMEOUT));
+        }
+
+        if (retries > DS2482_WAIT_IDLE_TIMEOUT)
+                printk(KERN_ERR "%s: timeout on channel %d\n",
+                       __func__, pdev->channel);
+
+        return temp;
+}
+
+/**
+ * Selects a w1 channel.
+ * The 1-wire interface must be idle before calling this function.
+ *
+ * @param pdev          The ds2482 client pointer
+ * @param channel       0-7
+ * @return              -1 (failure) or 0 (success)
+ */
+static int ds2482_set_channel(struct ds2482_data *pdev, u8 channel)
+{
+        if (i2c_smbus_write_byte_data(&pdev->client, DS2482_CMD_CHANNEL_SELECT,
+                                      ds2482_chan_wr[channel]) < 0)
+                return -1;
+
+        pdev->read_prt = DS2482_PTR_CODE_CHANNEL;
+        pdev->channel = -1;
+        if (i2c_smbus_read_byte(&pdev->client) == ds2482_chan_rd[channel]) {
+                pdev->channel = channel;
+                return 0;
+        }
+        return -1;
+}
+
+
+/**
+ * Performs the touch-bit function, which writes a 0 or 1 and reads the level.
+ *
+ * @param data  The ds2482 channel pointer
+ * @param bit   The level to write: 0 or non-zero
+ * @return      The level read: 0 or 1
+ */
+static u8 ds2482_w1_touch_bit(void *data, u8 bit)
+{
+        struct ds2482_w1_chan *pchan = data;
+        struct ds2482_data    *pdev = pchan->pdev;
+        int status = -1;
+
+        down(&pdev->access_lock);
+
+        /* Select the channel */
+        ds2482_wait_1wire_idle(pdev);
+        if (pdev->w1_count > 1)
+                ds2482_set_channel(pdev, pchan->channel);
+
+        /* Send the touch command, wait until 1WB == 0, return the status */
+        if (!ds2482_send_cmd_data(pdev, DS2482_CMD_1WIRE_SINGLE_BIT,
+                                  bit ? 0xFF : 0))
+                status = ds2482_wait_1wire_idle(pdev);
+
+        up(&pdev->access_lock);
+
+        return (status & DS2482_REG_STS_SBR) ? 1 : 0;
+}
+
+/**
+ * Performs the triplet function, which reads two bits and writes a bit.
+ * The bit written is determined by the two reads:
+ *   00 => dbit, 01 => 0, 10 => 1
+ *
+ * @param data  The ds2482 channel pointer
+ * @param dbit  The direction to choose if both branches are valid
+ * @return      b0=read1 b1=read2 b3=bit written
+ */
+static u8 ds2482_w1_triplet(void *data, u8 dbit)
+{
+        struct ds2482_w1_chan *pchan = data;
+        struct ds2482_data    *pdev = pchan->pdev;
+        int status = (3 << 5);
+
+        down(&pdev->access_lock);
+
+        /* Select the channel */
+        ds2482_wait_1wire_idle(pdev);
+        if (pdev->w1_count > 1)
+                ds2482_set_channel(pdev, pchan->channel);
+
+        /* Send the triplet command, wait until 1WB == 0, return the status */
+        if (!ds2482_send_cmd_data(pdev, DS2482_CMD_1WIRE_TRIPLET,
+                                  dbit ? 0xFF : 0))
+                status = ds2482_wait_1wire_idle(pdev);
+
+        up(&pdev->access_lock);
+
+        /* Decode the status */
+        return (status >> 5);
+}
+
+/**
+ * Performs the write byte function.
+ *
+ * @param data  The ds2482 channel pointer
+ * @param byte  The value to write
+ */
+static void ds2482_w1_write_byte(void *data, u8 byte)
+{
+        struct ds2482_w1_chan *pchan = data;
+        struct ds2482_data    *pdev = pchan->pdev;
+
+        down(&pdev->access_lock);
+
+        /* Select the channel */
+        ds2482_wait_1wire_idle(pdev);
+        if (pdev->w1_count > 1)
+                ds2482_set_channel(pdev, pchan->channel);
+
+        /* Send the write byte command */
+        ds2482_send_cmd_data(pdev, DS2482_CMD_1WIRE_WRITE_BYTE, byte);
+
+        up(&pdev->access_lock);
+}
+
+/**
+ * Performs the read byte function.
+ *
+ * @param data  The ds2482 channel pointer
+ * @return      The value read
+ */
+static u8 ds2482_w1_read_byte(void *data)
+{
+        struct ds2482_w1_chan *pchan = data;
+        struct ds2482_data    *pdev = pchan->pdev;
+        int result;
+
+        down(&pdev->access_lock);
+
+        /* Select the channel */
+        ds2482_wait_1wire_idle(pdev);
+        if (pdev->w1_count > 1)
+                ds2482_set_channel(pdev, pchan->channel);
+
+        /* Send the read byte command */
+        ds2482_send_cmd(pdev, DS2482_CMD_1WIRE_READ_BYTE);
+
+        /* Wait until 1WB == 0 */
+        ds2482_wait_1wire_idle(pdev);
+
+        /* Select the data register */
+        ds2482_select_register(pdev, DS2482_PTR_CODE_DATA);
+
+        /* Read the data byte */
+        result = i2c_smbus_read_byte(&pdev->client);
+
+        up(&pdev->access_lock);
+
+        return result;
+}
+
+
+/**
+ * Sends a reset on the 1-wire interface
+ *
+ * @param data  The ds2482 channel pointer
+ * @return      0=Device present, 1=No device present or error
+ */
+static u8 ds2482_w1_reset_bus(void *data)
+{
+        struct ds2482_w1_chan *pchan = data;
+        struct ds2482_data    *pdev = pchan->pdev;
+        int err;
+        u8 retval = 1;
+
+        down(&pdev->access_lock);
+
+        /* Select the channel */
+        ds2482_wait_1wire_idle(pdev);
+        if (pdev->w1_count > 1)
+                ds2482_set_channel(pdev, pchan->channel);
+
+        /* Send the reset command */
+        err = ds2482_send_cmd(pdev, DS2482_CMD_1WIRE_RESET);
+        if (err >= 0) {
+                /* Wait until the reset is complete */
+                err = ds2482_wait_1wire_idle(pdev);
+                retval = !(err & DS2482_REG_STS_PPD);
+
+                /* If the chip did reset since detect, re-config it */
+                if (err & DS2482_REG_STS_RST)
+                        ds2482_send_cmd_data(pdev, DS2482_CMD_WRITE_CONFIG,
+                                             0xF0);
+        }
+
+        up(&pdev->access_lock);
+
+        return retval;
+}
+
+
+/**
+ * Called to see if the device exists on an i2c bus.
+ */
+static int ds2482_attach_adapter(struct i2c_adapter *adapter)
+{
+        return i2c_probe(adapter, &addr_data, ds2482_detect);
+}
+
+
+/*
+ * The following function does more than just detection. If detection
+ * succeeds, it also registers the new chip.
+ */
+static int ds2482_detect(struct i2c_adapter *adapter, int address, int kind)
+{
+        struct ds2482_data *data;
+        struct i2c_client  *new_client;
+        int err = 0;
+        int temp1;
+        int idx;
+
+        if (!i2c_check_functionality(adapter,
+                                     I2C_FUNC_SMBUS_WRITE_BYTE_DATA |
+                                     I2C_FUNC_SMBUS_BYTE))
+                goto exit;
+
+        if (!(data = kzalloc(sizeof(struct ds2482_data), GFP_KERNEL))) {
+                err = -ENOMEM;
+                goto exit;
+        }
+
+        new_client = &data->client;
+        i2c_set_clientdata(new_client, data);
+        new_client->addr = address;
+        new_client->driver = &ds2482_driver;
+        new_client->adapter = adapter;
+
+        /* Reset the device (sets the read_ptr to status) */
+        if (ds2482_send_cmd(data, DS2482_CMD_RESET) < 0) {
+                dev_dbg(&adapter->dev, "DS2482 reset failed at 0x%02x.\n",
+                        address);
+                goto exit_free;
+        }
+
+        /* Sleep at least 525ns to allow the reset to complete */
+        ndelay(525);
+
+        /* Read the status byte - only reset bit and line should be set */
+        temp1 = i2c_smbus_read_byte(new_client);
+        if (temp1 != (DS2482_REG_STS_LL | DS2482_REG_STS_RST)) {
+                dev_dbg(&adapter->dev, "DS2482 (0x%02x) reset status "
+                        "0x%02X - not a DS2482\n", address, temp1);
+                goto exit_free;
+        }
+
+        /* Detect the 8-port version */
+        data->w1_count = 1;
+        if (ds2482_set_channel(data, 7) == 0)
+                data->w1_count = 8;
+
+        /* Set all config items to 0 (off) */
+        ds2482_send_cmd_data(data, DS2482_CMD_WRITE_CONFIG, 0xF0);
+
+        /* We can fill in the remaining client fields */
+        snprintf(new_client->name, sizeof(new_client->name), "ds2482-%d00",
+                 data->w1_count);
+
+        init_MUTEX(&data->access_lock);
+
+        /* Tell the I2C layer a new client has arrived */
+        if ((err = i2c_attach_client(new_client)))
+                goto exit_free;
+
+        /* Register 1-wire interface(s) */
+        for (idx = 0; idx < data->w1_count; idx++) {
+                data->w1_ch[idx].pdev = data;
+                data->w1_ch[idx].channel = idx;
+
+                /* Populate all the w1 bus master stuff */
+                data->w1_ch[idx].w1_bm.data       = &data->w1_ch[idx];
+                data->w1_ch[idx].w1_bm.read_byte  = ds2482_w1_read_byte;
+                data->w1_ch[idx].w1_bm.write_byte = ds2482_w1_write_byte;
+                data->w1_ch[idx].w1_bm.touch_bit  = ds2482_w1_touch_bit;
+                data->w1_ch[idx].w1_bm.triplet    = ds2482_w1_triplet;
+                data->w1_ch[idx].w1_bm.reset_bus  = ds2482_w1_reset_bus;
+
+                err = w1_add_master_device(&data->w1_ch[idx].w1_bm);
+                if (err) {
+                        data->w1_ch[idx].pdev = NULL;
+                        goto exit_w1_remove;
+                }
+        }
+
+        return 0;
+
+exit_w1_remove:
+        i2c_detach_client(new_client);
+
+        for (idx = 0; idx < data->w1_count; idx++) {
+                if (data->w1_ch[idx].pdev != NULL)
+                        w1_remove_master_device(&data->w1_ch[idx].w1_bm);
+        }
+exit_free:
+        kfree(data);
+exit:
+        return err;
+}
+
+static int ds2482_detach_client(struct i2c_client *client)
+{
+        struct ds2482_data   *data = i2c_get_clientdata(client);
+        int err, idx;
+
+        /* Unregister the 1-wire bridge(s) */
+        for (idx = 0; idx < data->w1_count; idx++) {
+                if (data->w1_ch[idx].pdev != NULL)
+                        w1_remove_master_device(&data->w1_ch[idx].w1_bm);
+        }
+
+        /* Detach the i2c device */
+        if ((err = i2c_detach_client(client))) {
+                dev_err(&client->dev,
+                        "Deregistration failed, client not detached.\n");
+                return err;
+        }
+
+        /* Free the memory */
+        kfree(data);
+        return 0;
+}
+
+static int __init sensors_ds2482_init(void)
+{
+        return i2c_add_driver(&ds2482_driver);
+}
+
+static void __exit sensors_ds2482_exit(void)
+{
+        i2c_del_driver(&ds2482_driver);
+}
+
+MODULE_AUTHOR("Ben Gardner <bgardner@wabtec.com>");
+MODULE_DESCRIPTION("DS2482 driver");
+MODULE_LICENSE("GPL");
+
+module_init(sensors_ds2482_init);
+module_exit(sensors_ds2482_exit);
diff --git a/drivers/w1/ds_w1_bridge.c b/drivers/w1/masters/ds_w1_bridge.c
index a79d16d566..5d30783a3e 100644
--- a/drivers/w1/ds_w1_bridge.c
+++ b/drivers/w1/masters/ds_w1_bridge.c
@@ -22,17 +22,17 @@
 #include <linux/module.h>
 #include <linux/types.h>
 
-#include "../w1/w1.h"
-#include "../w1/w1_int.h"
+#include "../w1.h"
+#include "../w1_int.h"
 #include "dscore.h"
 
 static struct ds_device *ds_dev;
 static struct w1_bus_master *ds_bus_master;
 
-static u8 ds9490r_touch_bit(unsigned long data, u8 bit)
+static u8 ds9490r_touch_bit(void *data, u8 bit)
 {
         u8 ret;
-        struct ds_device *dev = (struct ds_device *)data;
+        struct ds_device *dev = data;
 
         if (ds_touch_bit(dev, bit, &ret))
                 return 0;
@@ -40,23 +40,23 @@ static u8 ds9490r_touch_bit(unsigned long data, u8 bit)
         return ret;
 }
 
-static void ds9490r_write_bit(unsigned long data, u8 bit)
+static void ds9490r_write_bit(void *data, u8 bit)
 {
-        struct ds_device *dev = (struct ds_device *)data;
+        struct ds_device *dev = data;
 
         ds_write_bit(dev, bit);
 }
 
-static void ds9490r_write_byte(unsigned long data, u8 byte)
+static void ds9490r_write_byte(void *data, u8 byte)
 {
-        struct ds_device *dev = (struct ds_device *)data;
+        struct ds_device *dev = data;
 
         ds_write_byte(dev, byte);
 }
 
-static u8 ds9490r_read_bit(unsigned long data)
+static u8 ds9490r_read_bit(void *data)
 {
-        struct ds_device *dev = (struct ds_device *)data;
+        struct ds_device *dev = data;
         int err;
         u8 bit = 0;
 
@@ -70,9 +70,9 @@ static u8 ds9490r_read_bit(unsigned long data)
         return bit & 1;
 }
 
-static u8 ds9490r_read_byte(unsigned long data)
+static u8 ds9490r_read_byte(void *data)
 {
-        struct ds_device *dev = (struct ds_device *)data;
+        struct ds_device *dev = data;
         int err;
         u8 byte = 0;
 
@@ -83,16 +83,16 @@ static u8 ds9490r_read_byte(unsigned long data)
         return byte;
 }
 
-static void ds9490r_write_block(unsigned long data, const u8 *buf, int len)
+static void ds9490r_write_block(void *data, const u8 *buf, int len)
 {
-        struct ds_device *dev = (struct ds_device *)data;
+        struct ds_device *dev = data;
 
         ds_write_block(dev, (u8 *)buf, len);
 }
 
-static u8 ds9490r_read_block(unsigned long data, u8 *buf, int len)
+static u8 ds9490r_read_block(void *data, u8 *buf, int len)
 {
-        struct ds_device *dev = (struct ds_device *)data;
+        struct ds_device *dev = data;
         int err;
 
         err = ds_read_block(dev, buf, len);
@@ -102,9 +102,9 @@ static u8 ds9490r_read_block(unsigned long data, u8 *buf, int len)
         return len;
 }
 
-static u8 ds9490r_reset(unsigned long data)
+static u8 ds9490r_reset(void *data)
 {
-        struct ds_device *dev = (struct ds_device *)data;
+        struct ds_device *dev = data;
         struct ds_status st;
         int err;
 
@@ -136,7 +136,7 @@ static int __devinit ds_w1_init(void)
 
         memset(ds_bus_master, 0, sizeof(*ds_bus_master));
 
-        ds_bus_master->data             = (unsigned long)ds_dev;
+        ds_bus_master->data             = ds_dev;
         ds_bus_master->touch_bit        = &ds9490r_touch_bit;
         ds_bus_master->read_bit         = &ds9490r_read_bit;
         ds_bus_master->write_bit        = &ds9490r_write_bit;
diff --git a/drivers/w1/dscore.c b/drivers/w1/masters/dscore.c
index b9146306df..2cf7776a70 100644
--- a/drivers/w1/dscore.c
+++ b/drivers/w1/masters/dscore.c
@@ -340,7 +340,7 @@ int ds_reset(struct ds_device *dev, struct ds_status *st)
                 return -EIO;
         }
 #endif
-        
+
         return 0;
 }
 
@@ -348,7 +348,7 @@ int ds_reset(struct ds_device *dev, struct ds_status *st)
 int ds_set_speed(struct ds_device *dev, int speed)
 {
         int err;
-        
+
         if (speed != SPEED_NORMAL && speed != SPEED_FLEXIBLE && speed != SPEED_OVERDRIVE)
                 return -EINVAL;
 
diff --git a/drivers/w1/dscore.h b/drivers/w1/masters/dscore.h
index 6cf5671d6e..6cf5671d6e 100644
--- a/drivers/w1/dscore.h
+++ b/drivers/w1/masters/dscore.h
diff --git a/drivers/w1/matrox_w1.c b/drivers/w1/masters/matrox_w1.c
index 0b03f8f93f..591809cbbb 100644
--- a/drivers/w1/matrox_w1.c
+++ b/drivers/w1/masters/matrox_w1.c
@@ -19,8 +19,8 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  */
 
-#include <asm/atomic.h>
 #include <asm/types.h>
+#include <asm/atomic.h>
 #include <asm/io.h>
 
 #include <linux/delay.h>
@@ -35,9 +35,9 @@
 #include <linux/pci.h>
 #include <linux/timer.h>
 
-#include "w1.h"
-#include "w1_int.h"
-#include "w1_log.h"
+#include "../w1.h"
+#include "../w1_int.h"
+#include "../w1_log.h"
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Evgeniy Polyakov <johnpol@2ka.mipt.ru>");
@@ -90,8 +90,8 @@ struct matrox_device
         struct w1_bus_master *bus_master;
 };
 
-static u8 matrox_w1_read_ddc_bit(unsigned long);
-static void matrox_w1_write_ddc_bit(unsigned long, u8);
+static u8 matrox_w1_read_ddc_bit(void *);
+static void matrox_w1_write_ddc_bit(void *, u8);
 
 /*
  * These functions read and write DDC Data bit.
@@ -122,10 +122,10 @@ static __inline__ void matrox_w1_write_reg(struct matrox_device *dev, u8 reg, u8
         wmb();
 }
 
-static void matrox_w1_write_ddc_bit(unsigned long data, u8 bit)
+static void matrox_w1_write_ddc_bit(void *data, u8 bit)
 {
         u8 ret;
-        struct matrox_device *dev = (struct matrox_device *) data;
+        struct matrox_device *dev = data;
 
         if (bit)
                 bit = 0;
@@ -137,10 +137,10 @@ static void matrox_w1_write_ddc_bit(unsigned long data, u8 bit)
         matrox_w1_write_reg(dev, MATROX_GET_DATA, 0x00);
 }
 
-static u8 matrox_w1_read_ddc_bit(unsigned long data)
+static u8 matrox_w1_read_ddc_bit(void *data)
 {
         u8 ret;
-        struct matrox_device *dev = (struct matrox_device *) data;
+        struct matrox_device *dev = data;
 
         ret = matrox_w1_read_reg(dev, MATROX_GET_DATA);
 
@@ -198,7 +198,7 @@ static int __devinit matrox_w1_probe(struct pci_dev *pdev, const struct pci_devi
 
         matrox_w1_hw_init(dev);
 
-        dev->bus_master->data = (unsigned long) dev;
+        dev->bus_master->data = dev;
         dev->bus_master->read_bit = &matrox_w1_read_ddc_bit;
         dev->bus_master->write_bit = &matrox_w1_write_ddc_bit;
 
diff --git a/drivers/w1/slaves/Kconfig b/drivers/w1/slaves/Kconfig
new file mode 100644
index 0000000000..f9d4c91fc5
--- /dev/null
+++ b/drivers/w1/slaves/Kconfig
@@ -0,0 +1,38 @@
+#
+# 1-wire slaves configuration
+#
+
+menu "1-wire Slaves"
+        depends on W1
+
+config W1_SLAVE_THERM
+        tristate "Thermal family implementation"
+        depends on W1
+        help
+          Say Y here if you want to connect 1-wire thermal sensors to you
+          wire.
+
+config W1_SLAVE_SMEM
+        tristate "Simple 64bit memory family implementation"
+        depends on W1
+        help
+          Say Y here if you want to connect 1-wire
+          simple 64bit memory rom(ds2401/ds2411/ds1990*) to you wire.
+
+config W1_SLAVE_DS2433
+        tristate "4kb EEPROM family support (DS2433)"
+        depends on W1
+        help
+          Say Y here if you want to use a 1-wire
+          4kb EEPROM family device (DS2433).
+
+config W1_SLAVE_DS2433_CRC
+        bool "Protect DS2433 data with a CRC16"
+        depends on W1_DS2433
+        select CRC16
+        help
+          Say Y here to protect DS2433 data with a CRC16.
+          Each block has 30 bytes of data and a two byte CRC16.
+          Full block writes are only allowed if the CRC is valid.
+
+endmenu
diff --git a/drivers/w1/slaves/Makefile b/drivers/w1/slaves/Makefile
new file mode 100644
index 0000000000..70e21e2d70
--- /dev/null
+++ b/drivers/w1/slaves/Makefile
@@ -0,0 +1,12 @@
+#
+# Makefile for the Dallas's 1-wire slaves.
+#
+
+ifeq ($(CONFIG_W1_SLAVE_DS2433_CRC), y)
+EXTRA_CFLAGS += -DCONFIG_W1_F23_CRC
+endif
+
+obj-$(CONFIG_W1_SLAVE_THERM)    += w1_therm.o
+obj-$(CONFIG_W1_SLAVE_SMEM)     += w1_smem.o
+obj-$(CONFIG_W1_SLAVE_DS2433)   += w1_ds2433.o
+
diff --git a/drivers/w1/w1_ds2433.c b/drivers/w1/slaves/w1_ds2433.c
index 1e3d98aac1..fb118be789 100644
--- a/drivers/w1/w1_ds2433.c
+++ b/drivers/w1/slaves/w1_ds2433.c
@@ -21,10 +21,10 @@
 
 #endif
 
-#include "w1.h"
-#include "w1_io.h"
-#include "w1_int.h"
-#include "w1_family.h"
+#include "../w1.h"
+#include "../w1_io.h"
+#include "../w1_int.h"
+#include "../w1_family.h"
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Ben Gardner <bgardner@wabtec.com>");
diff --git a/drivers/w1/w1_smem.c b/drivers/w1/slaves/w1_smem.c
index e3209d0aca..c6d3be54f9 100644
--- a/drivers/w1/w1_smem.c
+++ b/drivers/w1/slaves/w1_smem.c
@@ -27,10 +27,10 @@
 #include <linux/device.h>
 #include <linux/types.h>
 
-#include "w1.h"
-#include "w1_io.h"
-#include "w1_int.h"
-#include "w1_family.h"
+#include "../w1.h"
+#include "../w1_io.h"
+#include "../w1_int.h"
+#include "../w1_family.h"
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Evgeniy Polyakov <johnpol@2ka.mipt.ru>");
@@ -51,7 +51,7 @@ static int __init w1_smem_init(void)
         err = w1_register_family(&w1_smem_family_01);
         if (err)
                 return err;
-        
+
         err = w1_register_family(&w1_smem_family_81);
         if (err) {
                 w1_unregister_family(&w1_smem_family_01);
diff --git a/drivers/w1/w1_therm.c b/drivers/w1/slaves/w1_therm.c
index 4577df3cfc..536d16d78d 100644
--- a/drivers/w1/w1_therm.c
+++ b/drivers/w1/slaves/w1_therm.c
@@ -28,10 +28,10 @@
 #include <linux/types.h>
 #include <linux/delay.h>
 
-#include "w1.h"
-#include "w1_io.h"
-#include "w1_int.h"
-#include "w1_family.h"
+#include "../w1.h"
+#include "../w1_io.h"
+#include "../w1_int.h"
+#include "../w1_family.h"
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Evgeniy Polyakov <johnpol@2ka.mipt.ru>");
@@ -123,12 +123,12 @@ static inline int w1_DS18S20_convert_temp(u8 rom[9])
 
         if (!rom[7])
                 return 0;
-        
+
         if (rom[1] == 0)
                 t = ((s32)rom[0] >> 1)*1000;
         else
                 t = 1000*(-1*(s32)(0x100-rom[0]) >> 1);
-        
+
         t -= 250;
         h = 1000*((s32)rom[7] - (s32)rom[6]);
         h /= (s32)rom[7];
@@ -231,7 +231,7 @@ static ssize_t w1_therm_read_bin(struct kobject *kobj, char *buf, loff_t off, si
 
         for (i = 0; i < 9; ++i)
                 count += sprintf(buf + count, "%02x ", sl->rom[i]);
-        
+
         count += sprintf(buf + count, "t=%d\n", w1_convert_temp(rom, sl->family->fid));
 out:
         up(&dev->mutex);
diff --git a/drivers/w1/w1.c b/drivers/w1/w1.c
index 024206c4a0..a698b517e8 100644
--- a/drivers/w1/w1.c
+++ b/drivers/w1/w1.c
@@ -30,6 +30,7 @@
 #include <linux/device.h>
 #include <linux/slab.h>
 #include <linux/sched.h>
+#include <linux/kthread.h>
 
 #include <asm/atomic.h>
 
@@ -57,9 +58,7 @@ module_param_named(slave_ttl, w1_max_slave_ttl, int, 0);
 DEFINE_SPINLOCK(w1_mlock);
 LIST_HEAD(w1_masters);
 
-static pid_t control_thread;
-static int control_needs_exit;
-static DECLARE_COMPLETION(w1_control_complete);
+static struct task_struct *w1_control_thread;
 
 static int w1_master_match(struct device *dev, struct device_driver *drv)
 {
@@ -164,11 +163,12 @@ struct device w1_master_device = {
         .release = &w1_master_release
 };
 
-struct device_driver w1_slave_driver = {
+static struct device_driver w1_slave_driver = {
         .name = "w1_slave_driver",
         .bus = &w1_bus_type,
 };
 
+#if 0
 struct device w1_slave_device = {
         .parent = NULL,
         .bus = &w1_bus_type,
@@ -176,6 +176,7 @@ struct device w1_slave_device = {
         .driver = &w1_slave_driver,
         .release = &w1_slave_release
 };
+#endif  /*  0  */
 
 static ssize_t w1_master_attribute_show_name(struct device *dev, struct device_attribute *attr, char *buf)
 {
@@ -355,7 +356,7 @@ int w1_create_master_attributes(struct w1_master *master)
         return sysfs_create_group(&master->dev.kobj, &w1_master_defattr_group);
 }
 
-void w1_destroy_master_attributes(struct w1_master *master)
+static void w1_destroy_master_attributes(struct w1_master *master)
 {
         sysfs_remove_group(&master->dev.kobj, &w1_master_defattr_group);
 }
@@ -386,11 +387,14 @@ static int w1_uevent(struct device *dev, char **envp, int num_envp, char *buffer
         if (dev->driver != &w1_slave_driver || !sl)
                 return 0;
 
-        err = add_uevent_var(envp, num_envp, &cur_index, buffer, buffer_size, &cur_len, "W1_FID=%02X", sl->reg_num.family);
+        err = add_uevent_var(envp, num_envp, &cur_index, buffer, buffer_size,
+                        &cur_len, "W1_FID=%02X", sl->reg_num.family);
         if (err)
                 return err;
 
-        err = add_uevent_var(envp, num_envp, &cur_index, buffer, buffer_size, &cur_len, "W1_SLAVE_ID=%024LX", (u64)sl->reg_num.id);
+        err = add_uevent_var(envp, num_envp, &cur_index, buffer, buffer_size,
+                        &cur_len, "W1_SLAVE_ID=%024LX",
+                        (unsigned long long)sl->reg_num.id);
         if (err)
                 return err;
 
@@ -552,7 +556,7 @@ static void w1_slave_detach(struct w1_slave *sl)
         kfree(sl);
 }
 
-static struct w1_master *w1_search_master(unsigned long data)
+static struct w1_master *w1_search_master(void *data)
 {
         struct w1_master *dev;
         int found = 0;
@@ -583,7 +587,7 @@ void w1_reconnect_slaves(struct w1_family *f)
         spin_unlock_bh(&w1_mlock);
 }
 
-static void w1_slave_found(unsigned long data, u64 rn)
+static void w1_slave_found(void *data, u64 rn)
 {
         int slave_count;
         struct w1_slave *sl;
@@ -595,8 +599,8 @@ static void w1_slave_found(unsigned long data, u64 rn)
 
         dev = w1_search_master(data);
         if (!dev) {
-                printk(KERN_ERR "Failed to find w1 master device for data %08lx, it is impossible.\n",
-                                data);
+                printk(KERN_ERR "Failed to find w1 master device for data %p, "
+                       "it is impossible.\n", data);
                 return;
         }
 
@@ -712,22 +716,16 @@ static int w1_control(void *data)
 {
         struct w1_slave *sl, *sln;
         struct w1_master *dev, *n;
-        int err, have_to_wait = 0;
+        int have_to_wait = 0;
 
-        daemonize("w1_control");
-        allow_signal(SIGTERM);
-
-        while (!control_needs_exit || have_to_wait) {
+        while (!kthread_should_stop() || have_to_wait) {
                 have_to_wait = 0;
 
                 try_to_freeze();
                 msleep_interruptible(w1_control_timeout * 1000);
 
-                if (signal_pending(current))
-                        flush_signals(current);
-
                 list_for_each_entry_safe(dev, n, &w1_masters, w1_master_entry) {
-                        if (!control_needs_exit && !dev->flags)
+                        if (!kthread_should_stop() && !dev->flags)
                                 continue;
                         /*
                          * Little race: we can create thread but not set the flag.
@@ -738,21 +736,12 @@ static int w1_control(void *data)
                                 continue;
                         }
 
-                        if (control_needs_exit) {
+                        if (kthread_should_stop() || test_bit(W1_MASTER_NEED_EXIT, &dev->flags)) {
                                 set_bit(W1_MASTER_NEED_EXIT, &dev->flags);
 
-                                err = kill_proc(dev->kpid, SIGTERM, 1);
-                                if (err)
-                                        dev_err(&dev->dev,
-                                                 "Failed to send signal to w1 kernel thread %d.\n",
-                                                 dev->kpid);
-                        }
-
-                        if (test_bit(W1_MASTER_NEED_EXIT, &dev->flags)) {
-                                wait_for_completion(&dev->dev_exited);
-                                spin_lock_bh(&w1_mlock);
+                                spin_lock(&w1_mlock);
                                 list_del(&dev->w1_master_entry);
-                                spin_unlock_bh(&w1_mlock);
+                                spin_unlock(&w1_mlock);
 
                                 down(&dev->mutex);
                                 list_for_each_entry_safe(sl, sln, &dev->slist, w1_slave_entry) {
@@ -784,7 +773,7 @@ static int w1_control(void *data)
                 }
         }
 
-        complete_and_exit(&w1_control_complete, 0);
+        return 0;
 }
 
 int w1_process(void *data)
@@ -792,17 +781,11 @@ int w1_process(void *data)
         struct w1_master *dev = (struct w1_master *) data;
         struct w1_slave *sl, *sln;
 
-        daemonize("%s", dev->name);
-        allow_signal(SIGTERM);
-
-        while (!test_bit(W1_MASTER_NEED_EXIT, &dev->flags)) {
+        while (!kthread_should_stop() && !test_bit(W1_MASTER_NEED_EXIT, &dev->flags)) {
                 try_to_freeze();
                 msleep_interruptible(w1_timeout * 1000);
 
-                if (signal_pending(current))
-                        flush_signals(current);
-
-                if (test_bit(W1_MASTER_NEED_EXIT, &dev->flags))
+                if (kthread_should_stop() || test_bit(W1_MASTER_NEED_EXIT, &dev->flags))
                         break;
 
                 if (!dev->initialized)
@@ -835,7 +818,6 @@ int w1_process(void *data)
         }
 
         atomic_dec(&dev->refcnt);
-        complete_and_exit(&dev->dev_exited, 0);
 
         return 0;
 }
@@ -868,11 +850,11 @@ static int w1_init(void)
                 goto err_out_master_unregister;
         }
 
-        control_thread = kernel_thread(&w1_control, NULL, 0);
-        if (control_thread < 0) {
+        w1_control_thread = kthread_run(w1_control, NULL, "w1_control");
+        if (IS_ERR(w1_control_thread)) {
+                retval = PTR_ERR(w1_control_thread);
                 printk(KERN_ERR "Failed to create control thread. err=%d\n",
-                        control_thread);
-                retval = control_thread;
+                        retval);
                 goto err_out_slave_unregister;
         }
 
@@ -898,8 +880,7 @@ static void w1_fini(void)
         list_for_each_entry(dev, &w1_masters, w1_master_entry)
                 __w1_remove_master_device(dev);
 
-        control_needs_exit = 1;
-        wait_for_completion(&w1_control_complete);
+        kthread_stop(w1_control_thread);
 
         driver_unregister(&w1_slave_driver);
         driver_unregister(&w1_master_driver);
diff --git a/drivers/w1/w1.h b/drivers/w1/w1.h
index d8900780c3..56980505e6 100644
--- a/drivers/w1/w1.h
+++ b/drivers/w1/w1.h
@@ -80,7 +80,7 @@ struct w1_slave
         struct completion       released;
 };
 
-typedef void (* w1_slave_found_callback)(unsigned long, u64);
+typedef void (* w1_slave_found_callback)(void *, u64);
 
 
 /**
@@ -93,16 +93,16 @@ typedef void (* w1_slave_found_callback)(unsigned long, u64);
 struct w1_bus_master
 {
         /** the first parameter in all the functions below */
-        unsigned long   data;
+        void            *data;
 
         /**
          * Sample the line level
          * @return the level read (0 or 1)
          */
-        u8              (*read_bit)(unsigned long);
+        u8              (*read_bit)(void *);
 
         /** Sets the line level */
-        void            (*write_bit)(unsigned long, u8);
+        void            (*write_bit)(void *, u8);
 
         /**
          * touch_bit is the lowest-level function for devices that really
@@ -111,42 +111,42 @@ struct w1_bus_master
          * touch_bit(1) = write-1 / read cycle
          * @return the bit read (0 or 1)
          */
-        u8              (*touch_bit)(unsigned long, u8);
+        u8              (*touch_bit)(void *, u8);
 
         /**
          * Reads a bytes. Same as 8 touch_bit(1) calls.
          * @return the byte read
          */
-        u8              (*read_byte)(unsigned long);
+        u8              (*read_byte)(void *);
 
         /**
          * Writes a byte. Same as 8 touch_bit(x) calls.
          */
-        void            (*write_byte)(unsigned long, u8);
+        void            (*write_byte)(void *, u8);
 
         /**
          * Same as a series of read_byte() calls
          * @return the number of bytes read
          */
-        u8              (*read_block)(unsigned long, u8 *, int);
+        u8              (*read_block)(void *, u8 *, int);
 
         /** Same as a series of write_byte() calls */
-        void            (*write_block)(unsigned long, const u8 *, int);
+        void            (*write_block)(void *, const u8 *, int);
 
         /**
          * Combines two reads and a smart write for ROM searches
          * @return bit0=Id bit1=comp_id bit2=dir_taken
          */
-        u8              (*triplet)(unsigned long, u8);
+        u8              (*triplet)(void *, u8);
 
         /**
          * long write-0 with a read for the presence pulse detection
          * @return -1=Error, 0=Device present, 1=No device present
          */
-        u8              (*reset_bus)(unsigned long);
+        u8              (*reset_bus)(void *);
 
         /** Really nice hardware can handles the ROM searches */
-        void            (*search)(unsigned long, w1_slave_found_callback);
+        void            (*search)(void *, w1_slave_found_callback);
 };
 
 #define W1_MASTER_NEED_EXIT             0
@@ -172,12 +172,11 @@ struct w1_master
 
         long                    flags;
 
-        pid_t                   kpid;
+        struct task_struct      *thread;
         struct semaphore        mutex;
 
         struct device_driver    *driver;
         struct device           dev;
-        struct completion       dev_exited;
 
         struct w1_bus_master    *bus_master;
 
@@ -203,6 +202,16 @@ static inline struct w1_master* dev_to_w1_master(struct device *dev)
         return container_of(dev, struct w1_master, dev);
 }
 
+extern int w1_max_slave_count;
+extern int w1_max_slave_ttl;
+extern spinlock_t w1_mlock;
+extern struct list_head w1_masters;
+extern struct device_driver w1_master_driver;
+extern struct device w1_master_device;
+
+int w1_process(void *data);
+void w1_reconnect_slaves(struct w1_family *f);
+
 #endif /* __KERNEL__ */
 
 #endif /* __W1_H */
diff --git a/drivers/w1/w1_family.c b/drivers/w1/w1_family.c
index 9e293e139a..0e32c114f9 100644
--- a/drivers/w1/w1_family.c
+++ b/drivers/w1/w1_family.c
@@ -25,10 +25,10 @@
 #include <linux/delay.h>
 
 #include "w1_family.h"
+#include "w1.h"
 
 DEFINE_SPINLOCK(w1_flock);
 static LIST_HEAD(w1_families);
-extern void w1_reconnect_slaves(struct w1_family *f);
 
 int w1_register_family(struct w1_family *newf)
 {
diff --git a/drivers/w1/w1_int.c b/drivers/w1/w1_int.c
index c3f67eafc7..68565aacec 100644
--- a/drivers/w1/w1_int.c
+++ b/drivers/w1/w1_int.c
@@ -22,23 +22,15 @@
 #include <linux/kernel.h>
 #include <linux/list.h>
 #include <linux/delay.h>
+#include <linux/kthread.h>
 
 #include "w1.h"
 #include "w1_log.h"
 #include "w1_netlink.h"
+#include "w1_int.h"
 
 static u32 w1_ids = 1;
 
-extern struct device_driver w1_master_driver;
-extern struct bus_type w1_bus_type;
-extern struct device w1_master_device;
-extern int w1_max_slave_count;
-extern int w1_max_slave_ttl;
-extern struct list_head w1_masters;
-extern spinlock_t w1_mlock;
-
-extern int w1_process(void *);
-
 static struct w1_master * w1_alloc_dev(u32 id, int slave_count, int slave_ttl,
                                        struct device_driver *driver,
                                        struct device *device)
@@ -65,7 +57,6 @@ static struct w1_master * w1_alloc_dev(u32 id, int slave_count, int slave_ttl,
         dev->max_slave_count    = slave_count;
         dev->slave_count        = 0;
         dev->attempts           = 0;
-        dev->kpid               = -1;
         dev->initialized        = 0;
         dev->id                 = id;
         dev->slave_ttl          = slave_ttl;
@@ -76,8 +67,6 @@ static struct w1_master * w1_alloc_dev(u32 id, int slave_count, int slave_ttl,
         INIT_LIST_HEAD(&dev->slist);
         init_MUTEX(&dev->mutex);
 
-        init_completion(&dev->dev_exited);
-
         memcpy(&dev->dev, device, sizeof(struct device));
         snprintf(dev->dev.bus_id, sizeof(dev->dev.bus_id),
                   "w1_bus_master%u", dev->id);
@@ -103,7 +92,7 @@ static struct w1_master * w1_alloc_dev(u32 id, int slave_count, int slave_ttl,
         return dev;
 }
 
-void w1_free_dev(struct w1_master *dev)
+static void w1_free_dev(struct w1_master *dev)
 {
         device_unregister(&dev->dev);
 }
@@ -125,12 +114,12 @@ int w1_add_master_device(struct w1_bus_master *master)
         if (!dev)
                 return -ENOMEM;
 
-        dev->kpid = kernel_thread(&w1_process, dev, 0);
-        if (dev->kpid < 0) {
+        dev->thread = kthread_run(&w1_process, dev, "%s", dev->name);
+        if (IS_ERR(dev->thread)) {
+                retval = PTR_ERR(dev->thread);
                 dev_err(&dev->dev,
                          "Failed to create new kernel thread. err=%d\n",
-                         dev->kpid);
-                retval = dev->kpid;
+                         retval);
                 goto err_out_free_dev;
         }
 
@@ -147,20 +136,14 @@ int w1_add_master_device(struct w1_bus_master *master)
         spin_unlock(&w1_mlock);
 
         msg.id.mst.id = dev->id;
-        msg.id.mst.pid = dev->kpid;
+        msg.id.mst.pid = dev->thread->pid;
         msg.type = W1_MASTER_ADD;
         w1_netlink_send(dev, &msg);
 
         return 0;
 
 err_out_kill_thread:
-        set_bit(W1_MASTER_NEED_EXIT, &dev->flags);
-        if (kill_proc(dev->kpid, SIGTERM, 1))
-                dev_err(&dev->dev,
-                         "Failed to send signal to w1 kernel thread %d.\n",
-                         dev->kpid);
-        wait_for_completion(&dev->dev_exited);
-
+        kthread_stop(dev->thread);
 err_out_free_dev:
         w1_free_dev(dev);
 
@@ -169,18 +152,14 @@ err_out_free_dev:
 
 void __w1_remove_master_device(struct w1_master *dev)
 {
-        int err;
         struct w1_netlink_msg msg;
+        pid_t pid = dev->thread->pid;
 
         set_bit(W1_MASTER_NEED_EXIT, &dev->flags);
-        err = kill_proc(dev->kpid, SIGTERM, 1);
-        if (err)
-                dev_err(&dev->dev,
-                         "%s: Failed to send signal to w1 kernel thread %d.\n",
-                         __func__, dev->kpid);
+        kthread_stop(dev->thread);
 
         while (atomic_read(&dev->refcnt)) {
-                dev_dbg(&dev->dev, "Waiting for %s to become free: refcnt=%d.\n",
+                dev_info(&dev->dev, "Waiting for %s to become free: refcnt=%d.\n",
                                 dev->name, atomic_read(&dev->refcnt));
 
                 if (msleep_interruptible(1000))
@@ -188,7 +167,7 @@ void __w1_remove_master_device(struct w1_master *dev)
         }
 
         msg.id.mst.id = dev->id;
-        msg.id.mst.pid = dev->kpid;
+        msg.id.mst.pid = pid;
         msg.type = W1_MASTER_REMOVE;
         w1_netlink_send(dev, &msg);
 
@@ -217,5 +196,3 @@ void w1_remove_master_device(struct w1_bus_master *bm)
 
 EXPORT_SYMBOL(w1_add_master_device);
 EXPORT_SYMBOL(w1_remove_master_device);
-
-MODULE_ALIAS_NET_PF_PROTO(PF_NETLINK, NETLINK_W1);
diff --git a/drivers/w1/w1_io.c b/drivers/w1/w1_io.c
index e2a043354d..f7f7e8bec3 100644
--- a/drivers/w1/w1_io.c
+++ b/drivers/w1/w1_io.c
@@ -28,7 +28,7 @@
 #include "w1_log.h"
 #include "w1_io.h"
 
-int w1_delay_parm = 1;
+static int w1_delay_parm = 1;
 module_param_named(delay_coef, w1_delay_parm, int, 0);
 
 static u8 w1_crc8_table[] = {