133 files changed, 5835 insertions, 6318 deletions

diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index 0ce0c279aabf..b73116ef9236 100644
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -159,7 +159,7 @@ static int cciss_ioctl(struct inode *inode, struct file *filep,
 static int cciss_getgeo(struct block_device *bdev, struct hd_geometry *geo);
 
 static int cciss_revalidate(struct gendisk *disk);
-static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk);
+static int rebuild_lun_table(ctlr_info_t *h, int first_time);
 static int deregister_disk(struct gendisk *disk, drive_info_struct *drv,
                            int clear_all);
 
@@ -171,7 +171,6 @@ static void cciss_geometry_inquiry(int ctlr, int logvol,
                         int withirq, sector_t total_size,
                         unsigned int block_size, InquiryData_struct *inq_buff,
                                    drive_info_struct *drv);
-static void cciss_getgeometry(int cntl_num);
 static void __devinit cciss_interrupt_mode(ctlr_info_t *, struct pci_dev *,
                                            __u32);
 static void start_io(ctlr_info_t *h);
@@ -929,8 +928,10 @@ static int cciss_ioctl(struct inode *inode, struct file *filep,
                         return 0;
                 }
 
+        case CCISS_DEREGDISK:
+        case CCISS_REGNEWD:
         case CCISS_REVALIDVOLS:
-                return rebuild_lun_table(host, NULL);
+                return rebuild_lun_table(host, 0);
 
         case CCISS_GETLUNINFO:{
                         LogvolInfo_struct luninfo;
@@ -943,12 +944,6 @@ static int cciss_ioctl(struct inode *inode, struct file *filep,
                                 return -EFAULT;
                         return 0;
                 }
-        case CCISS_DEREGDISK:
-                return rebuild_lun_table(host, disk);
-
-        case CCISS_REGNEWD:
-                return rebuild_lun_table(host, NULL);
-
         case CCISS_PASSTHRU:
                 {
                         IOCTL_Command_struct iocommand;
@@ -1134,7 +1129,7 @@ static int cciss_ioctl(struct inode *inode, struct file *filep,
                                 if (ioc->Request.Type.Direction == XFER_WRITE) {
                                         if (copy_from_user
                                             (buff[sg_used], data_ptr, sz)) {
-                                                status = -ENOMEM;
+                                                status = -EFAULT;
                                                 goto cleanup1;
                                         }
                                 } else {
@@ -1330,15 +1325,84 @@ static void cciss_softirq_done(struct request *rq)
         spin_unlock_irqrestore(&h->lock, flags);
 }
 
+/* This function gets the serial number of a logical drive via
+ * inquiry page 0x83.  Serial no. is 16 bytes.  If the serial
+ * number cannot be had, for whatever reason, 16 bytes of 0xff
+ * are returned instead.
+ */
+static void cciss_get_serial_no(int ctlr, int logvol, int withirq,
+                                unsigned char *serial_no, int buflen)
+{
+#define PAGE_83_INQ_BYTES 64
+        int rc;
+        unsigned char *buf;
+
+        if (buflen > 16)
+                buflen = 16;
+        memset(serial_no, 0xff, buflen);
+        buf = kzalloc(PAGE_83_INQ_BYTES, GFP_KERNEL);
+        if (!buf)
+                return;
+        memset(serial_no, 0, buflen);
+        if (withirq)
+                rc = sendcmd_withirq(CISS_INQUIRY, ctlr, buf,
+                        PAGE_83_INQ_BYTES, 1, logvol, 0x83, TYPE_CMD);
+        else
+                rc = sendcmd(CISS_INQUIRY, ctlr, buf,
+                        PAGE_83_INQ_BYTES, 1, logvol, 0x83, NULL, TYPE_CMD);
+        if (rc == IO_OK)
+                memcpy(serial_no, &buf[8], buflen);
+        kfree(buf);
+        return;
+}
+
+static void cciss_add_disk(ctlr_info_t *h, struct gendisk *disk,
+                                int drv_index)
+{
+        disk->queue = blk_init_queue(do_cciss_request, &h->lock);
+        sprintf(disk->disk_name, "cciss/c%dd%d", h->ctlr, drv_index);
+        disk->major = h->major;
+        disk->first_minor = drv_index << NWD_SHIFT;
+        disk->fops = &cciss_fops;
+        disk->private_data = &h->drv[drv_index];
+
+        /* Set up queue information */
+        blk_queue_bounce_limit(disk->queue, h->pdev->dma_mask);
+
+        /* This is a hardware imposed limit. */
+        blk_queue_max_hw_segments(disk->queue, MAXSGENTRIES);
+
+        /* This is a limit in the driver and could be eliminated. */
+        blk_queue_max_phys_segments(disk->queue, MAXSGENTRIES);
+
+        blk_queue_max_sectors(disk->queue, h->cciss_max_sectors);
+
+        blk_queue_softirq_done(disk->queue, cciss_softirq_done);
+
+        disk->queue->queuedata = h;
+
+        blk_queue_hardsect_size(disk->queue,
+                                h->drv[drv_index].block_size);
+
+        /* Make sure all queue data is written out before */
+        /* setting h->drv[drv_index].queue, as setting this */
+        /* allows the interrupt handler to start the queue */
+        wmb();
+        h->drv[drv_index].queue = disk->queue;
+        add_disk(disk);
+}
+
 /* This function will check the usage_count of the drive to be updated/added.
- * If the usage_count is zero then the drive information will be updated and
- * the disk will be re-registered with the kernel.  If not then it will be
- * left alone for the next reboot.  The exception to this is disk 0 which
- * will always be left registered with the kernel since it is also the
- * controller node.  Any changes to disk 0 will show up on the next
- * reboot.
+ * If the usage_count is zero and it is a heretofore unknown drive, or,
+ * the drive's capacity, geometry, or serial number has changed,
+ * then the drive information will be updated and the disk will be
+ * re-registered with the kernel.  If these conditions don't hold,
+ * then it will be left alone for the next reboot.  The exception to this
+ * is disk 0 which will always be left registered with the kernel since it
+ * is also the controller node.  Any changes to disk 0 will show up on
+ * the next reboot.
  */
-static void cciss_update_drive_info(int ctlr, int drv_index)
+static void cciss_update_drive_info(int ctlr, int drv_index, int first_time)
 {
         ctlr_info_t *h = hba[ctlr];
         struct gendisk *disk;
@@ -1347,16 +1411,81 @@ static void cciss_update_drive_info(int ctlr, int drv_index)
         sector_t total_size;
         unsigned long flags = 0;
         int ret = 0;
+        drive_info_struct *drvinfo;
+        int was_only_controller_node;
+
+        /* Get information about the disk and modify the driver structure */
+        inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL);
+        drvinfo = kmalloc(sizeof(*drvinfo), GFP_KERNEL);
+        if (inq_buff == NULL || drvinfo == NULL)
+                goto mem_msg;
+
+        /* See if we're trying to update the "controller node"
+         * this will happen the when the first logical drive gets
+         * created by ACU.
+         */
+        was_only_controller_node = (drv_index == 0 &&
+                                h->drv[0].raid_level == -1);
 
-        /* if the disk already exists then deregister it before proceeding */
-        if (h->drv[drv_index].raid_level != -1) {
+        /* testing to see if 16-byte CDBs are already being used */
+        if (h->cciss_read == CCISS_READ_16) {
+                cciss_read_capacity_16(h->ctlr, drv_index, 1,
+                        &total_size, &block_size);
+
+        } else {
+                cciss_read_capacity(ctlr, drv_index, 1,
+                                    &total_size, &block_size);
+
+                /* if read_capacity returns all F's this volume is >2TB */
+                /* in size so we switch to 16-byte CDB's for all */
+                /* read/write ops */
+                if (total_size == 0xFFFFFFFFULL) {
+                        cciss_read_capacity_16(ctlr, drv_index, 1,
+                        &total_size, &block_size);
+                        h->cciss_read = CCISS_READ_16;
+                        h->cciss_write = CCISS_WRITE_16;
+                } else {
+                        h->cciss_read = CCISS_READ_10;
+                        h->cciss_write = CCISS_WRITE_10;
+                }
+        }
+
+        cciss_geometry_inquiry(ctlr, drv_index, 1, total_size, block_size,
+                               inq_buff, drvinfo);
+        drvinfo->block_size = block_size;
+        drvinfo->nr_blocks = total_size + 1;
+
+        cciss_get_serial_no(ctlr, drv_index, 1, drvinfo->serial_no,
+                        sizeof(drvinfo->serial_no));
+
+        /* Is it the same disk we already know, and nothing's changed? */
+        if (h->drv[drv_index].raid_level != -1 &&
+                ((memcmp(drvinfo->serial_no,
+                                h->drv[drv_index].serial_no, 16) == 0) &&
+                drvinfo->block_size == h->drv[drv_index].block_size &&
+                drvinfo->nr_blocks == h->drv[drv_index].nr_blocks &&
+                drvinfo->heads == h->drv[drv_index].heads &&
+                drvinfo->sectors == h->drv[drv_index].sectors &&
+                drvinfo->cylinders == h->drv[drv_index].cylinders))
+                        /* The disk is unchanged, nothing to update */
+                        goto freeret;
+
+        /* If we get here it's not the same disk, or something's changed,
+         * so we need to * deregister it, and re-register it, if it's not
+         * in use.
+         * If the disk already exists then deregister it before proceeding
+         * (unless it's the first disk (for the controller node).
+         */
+        if (h->drv[drv_index].raid_level != -1 && drv_index != 0) {
+                printk(KERN_WARNING "disk %d has changed.\n", drv_index);
                 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
                 h->drv[drv_index].busy_configuring = 1;
                 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
 
-                /* deregister_disk sets h->drv[drv_index].queue = NULL */
-                /* which keeps the interrupt handler from starting */
-                /* the queue. */
+                /* deregister_disk sets h->drv[drv_index].queue = NULL
+                 * which keeps the interrupt handler from starting
+                 * the queue.
+                 */
                 ret = deregister_disk(h->gendisk[drv_index],
                                       &h->drv[drv_index], 0);
                 h->drv[drv_index].busy_configuring = 0;
@@ -1364,81 +1493,37 @@ static void cciss_update_drive_info(int ctlr, int drv_index)
 
         /* If the disk is in use return */
         if (ret)
-                return;
+                goto freeret;
 
-        /* Get information about the disk and modify the driver structure */
-        inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL);
-        if (inq_buff == NULL)
-                goto mem_msg;
-
-        /* testing to see if 16-byte CDBs are already being used */
-        if (h->cciss_read == CCISS_READ_16) {
-                cciss_read_capacity_16(h->ctlr, drv_index, 1,
-                        &total_size, &block_size);
-                goto geo_inq;
-        }
-
-        cciss_read_capacity(ctlr, drv_index, 1,
-                            &total_size, &block_size);
-
-        /* if read_capacity returns all F's this volume is >2TB in size */
-        /* so we switch to 16-byte CDB's for all read/write ops */
-        if (total_size == 0xFFFFFFFFULL) {
-                cciss_read_capacity_16(ctlr, drv_index, 1,
-                &total_size, &block_size);
-                h->cciss_read = CCISS_READ_16;
-                h->cciss_write = CCISS_WRITE_16;
-        } else {
-                h->cciss_read = CCISS_READ_10;
-                h->cciss_write = CCISS_WRITE_10;
-        }
-geo_inq:
-        cciss_geometry_inquiry(ctlr, drv_index, 1, total_size, block_size,
-                               inq_buff, &h->drv[drv_index]);
+        /* Save the new information from cciss_geometry_inquiry
+         * and serial number inquiry.
+         */
+        h->drv[drv_index].block_size = drvinfo->block_size;
+        h->drv[drv_index].nr_blocks = drvinfo->nr_blocks;
+        h->drv[drv_index].heads = drvinfo->heads;
+        h->drv[drv_index].sectors = drvinfo->sectors;
+        h->drv[drv_index].cylinders = drvinfo->cylinders;
+        h->drv[drv_index].raid_level = drvinfo->raid_level;
+        memcpy(h->drv[drv_index].serial_no, drvinfo->serial_no, 16);
 
         ++h->num_luns;
         disk = h->gendisk[drv_index];
         set_capacity(disk, h->drv[drv_index].nr_blocks);
 
-        /* if it's the controller it's already added */
-        if (drv_index) {
-                disk->queue = blk_init_queue(do_cciss_request, &h->lock);
-                sprintf(disk->disk_name, "cciss/c%dd%d", ctlr, drv_index);
-                disk->major = h->major;
-                disk->first_minor = drv_index << NWD_SHIFT;
-                disk->fops = &cciss_fops;
-                disk->private_data = &h->drv[drv_index];
-
-                /* Set up queue information */
-                blk_queue_bounce_limit(disk->queue, hba[ctlr]->pdev->dma_mask);
-
-                /* This is a hardware imposed limit. */
-                blk_queue_max_hw_segments(disk->queue, MAXSGENTRIES);
-
-                /* This is a limit in the driver and could be eliminated. */
-                blk_queue_max_phys_segments(disk->queue, MAXSGENTRIES);
-
-                blk_queue_max_sectors(disk->queue, h->cciss_max_sectors);
-
-                blk_queue_softirq_done(disk->queue, cciss_softirq_done);
-
-                disk->queue->queuedata = hba[ctlr];
-
-                blk_queue_hardsect_size(disk->queue,
-                                        hba[ctlr]->drv[drv_index].block_size);
-
-                /* Make sure all queue data is written out before */
-                /* setting h->drv[drv_index].queue, as setting this */
-                /* allows the interrupt handler to start the queue */
-                wmb();
-                h->drv[drv_index].queue = disk->queue;
-                add_disk(disk);
-        }
+        /* If it's not disk 0 (drv_index != 0)
+         * or if it was disk 0, but there was previously
+         * no actual corresponding configured logical drive
+         * (raid_leve == -1) then we want to update the
+         * logical drive's information.
+         */
+        if (drv_index || first_time)
+                cciss_add_disk(h, disk, drv_index);
 
-      freeret:
+freeret:
         kfree(inq_buff);
+        kfree(drvinfo);
         return;
-      mem_msg:
+mem_msg:
         printk(KERN_ERR "cciss: out of memory\n");
         goto freeret;
 }
@@ -1448,21 +1533,91 @@ geo_inq:
  * where new drives will be added.  If the index to be returned is greater
  * than the highest_lun index for the controller then highest_lun is set
  * to this new index.  If there are no available indexes then -1 is returned.
+ * "controller_node" is used to know if this is a real logical drive, or just
+ * the controller node, which determines if this counts towards highest_lun.
  */
-static int cciss_find_free_drive_index(int ctlr)
+static int cciss_find_free_drive_index(int ctlr, int controller_node)
 {
         int i;
 
         for (i = 0; i < CISS_MAX_LUN; i++) {
                 if (hba[ctlr]->drv[i].raid_level == -1) {
                         if (i > hba[ctlr]->highest_lun)
-                                hba[ctlr]->highest_lun = i;
+                                if (!controller_node)
+                                        hba[ctlr]->highest_lun = i;
                         return i;
                 }
         }
         return -1;
 }
 
+/* cciss_add_gendisk finds a free hba[]->drv structure
+ * and allocates a gendisk if needed, and sets the lunid
+ * in the drvinfo structure.   It returns the index into
+ * the ->drv[] array, or -1 if none are free.
+ * is_controller_node indicates whether highest_lun should
+ * count this disk, or if it's only being added to provide
+ * a means to talk to the controller in case no logical
+ * drives have yet been configured.
+ */
+static int cciss_add_gendisk(ctlr_info_t *h, __u32 lunid, int controller_node)
+{
+        int drv_index;
+
+        drv_index = cciss_find_free_drive_index(h->ctlr, controller_node);
+        if (drv_index == -1)
+                return -1;
+        /*Check if the gendisk needs to be allocated */
+        if (!h->gendisk[drv_index]) {
+                h->gendisk[drv_index] =
+                        alloc_disk(1 << NWD_SHIFT);
+                if (!h->gendisk[drv_index]) {
+                        printk(KERN_ERR "cciss%d: could not "
+                                "allocate a new disk %d\n",
+                                h->ctlr, drv_index);
+                        return -1;
+                }
+        }
+        h->drv[drv_index].LunID = lunid;
+
+        /* Don't need to mark this busy because nobody */
+        /* else knows about this disk yet to contend */
+        /* for access to it. */
+        h->drv[drv_index].busy_configuring = 0;
+        wmb();
+        return drv_index;
+}
+
+/* This is for the special case of a controller which
+ * has no logical drives.  In this case, we still need
+ * to register a disk so the controller can be accessed
+ * by the Array Config Utility.
+ */
+static void cciss_add_controller_node(ctlr_info_t *h)
+{
+        struct gendisk *disk;
+        int drv_index;
+
+        if (h->gendisk[0] != NULL) /* already did this? Then bail. */
+                return;
+
+        drv_index = cciss_add_gendisk(h, 0, 1);
+        if (drv_index == -1) {
+                printk(KERN_WARNING "cciss%d: could not "
+                        "add disk 0.\n", h->ctlr);
+                return;
+        }
+        h->drv[drv_index].block_size = 512;
+        h->drv[drv_index].nr_blocks = 0;
+        h->drv[drv_index].heads = 0;
+        h->drv[drv_index].sectors = 0;
+        h->drv[drv_index].cylinders = 0;
+        h->drv[drv_index].raid_level = -1;
+        memset(h->drv[drv_index].serial_no, 0, 16);
+        disk = h->gendisk[drv_index];
+        cciss_add_disk(h, disk, drv_index);
+}
+
 /* This function will add and remove logical drives from the Logical
  * drive array of the controller and maintain persistency of ordering
  * so that mount points are preserved until the next reboot.  This allows
@@ -1470,15 +1625,12 @@ static int cciss_find_free_drive_index(int ctlr)
  * without a re-ordering of those drives.
  * INPUT
  * h            = The controller to perform the operations on
- * del_disk     = The disk to remove if specified.  If the value given
- *                is NULL then no disk is removed.
  */
-static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk)
+static int rebuild_lun_table(ctlr_info_t *h, int first_time)
 {
         int ctlr = h->ctlr;
         int num_luns;
         ReportLunData_struct *ld_buff = NULL;
-        drive_info_struct *drv = NULL;
         int return_code;
         int listlength = 0;
         int i;
@@ -1487,6 +1639,9 @@ static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk)
         __u32 lunid = 0;
         unsigned long flags;
 
+        if (!capable(CAP_SYS_RAWIO))
+                return -EPERM;
+
         /* Set busy_configuring flag for this operation */
         spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
         if (h->busy_configuring) {
@@ -1494,100 +1649,100 @@ static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk)
                 return -EBUSY;
         }
         h->busy_configuring = 1;
+        spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
 
-        /* if del_disk is NULL then we are being called to add a new disk
-         * and update the logical drive table.  If it is not NULL then
-         * we will check if the disk is in use or not.
-         */
-        if (del_disk != NULL) {
-                drv = get_drv(del_disk);
-                drv->busy_configuring = 1;
-                spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
-                return_code = deregister_disk(del_disk, drv, 1);
-                drv->busy_configuring = 0;
-                h->busy_configuring = 0;
-                return return_code;
-        } else {
-                spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
-                if (!capable(CAP_SYS_RAWIO))
-                        return -EPERM;
+        ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
+        if (ld_buff == NULL)
+                goto mem_msg;
 
-                ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
-                if (ld_buff == NULL)
-                        goto mem_msg;
-
-                return_code = sendcmd_withirq(CISS_REPORT_LOG, ctlr, ld_buff,
-                                              sizeof(ReportLunData_struct), 0,
-                                              0, 0, TYPE_CMD);
-
-                if (return_code == IO_OK) {
-                        listlength =
-                                be32_to_cpu(*(__be32 *) ld_buff->LUNListLength);
-                } else {        /* reading number of logical volumes failed */
-                        printk(KERN_WARNING "cciss: report logical volume"
-                               " command failed\n");
-                        listlength = 0;
-                        goto freeret;
-                }
+        return_code = sendcmd_withirq(CISS_REPORT_LOG, ctlr, ld_buff,
+                                      sizeof(ReportLunData_struct), 0,
+                                      0, 0, TYPE_CMD);
 
-                num_luns = listlength / 8;      /* 8 bytes per entry */
-                if (num_luns > CISS_MAX_LUN) {
-                        num_luns = CISS_MAX_LUN;
-                        printk(KERN_WARNING "cciss: more luns configured"
-                               " on controller than can be handled by"
-                               " this driver.\n");
+        if (return_code == IO_OK)
+                listlength = be32_to_cpu(*(__be32 *) ld_buff->LUNListLength);
+        else {  /* reading number of logical volumes failed */
+                printk(KERN_WARNING "cciss: report logical volume"
+                       " command failed\n");
+                listlength = 0;
+                goto freeret;
+        }
+
+        num_luns = listlength / 8;      /* 8 bytes per entry */
+        if (num_luns > CISS_MAX_LUN) {
+                num_luns = CISS_MAX_LUN;
+                printk(KERN_WARNING "cciss: more luns configured"
+                       " on controller than can be handled by"
+                       " this driver.\n");
+        }
+
+        if (num_luns == 0)
+                cciss_add_controller_node(h);
+
+        /* Compare controller drive array to driver's drive array
+         * to see if any drives are missing on the controller due
+         * to action of Array Config Utility (user deletes drive)
+         * and deregister logical drives which have disappeared.
+         */
+        for (i = 0; i <= h->highest_lun; i++) {
+                int j;
+                drv_found = 0;
+                for (j = 0; j < num_luns; j++) {
+                        memcpy(&lunid, &ld_buff->LUN[j][0], 4);
+                        lunid = le32_to_cpu(lunid);
+                        if (h->drv[i].LunID == lunid) {
+                                drv_found = 1;
+                                break;
+                        }
                 }
+                if (!drv_found) {
+                        /* Deregister it from the OS, it's gone. */
+                        spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
+                        h->drv[i].busy_configuring = 1;
+                        spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
+                        return_code = deregister_disk(h->gendisk[i],
+                                &h->drv[i], 1);
+                        h->drv[i].busy_configuring = 0;
+                }
+        }
+
+        /* Compare controller drive array to driver's drive array.
+         * Check for updates in the drive information and any new drives
+         * on the controller due to ACU adding logical drives, or changing
+         * a logical drive's size, etc.  Reregister any new/changed drives
+         */
+        for (i = 0; i < num_luns; i++) {
+                int j;
 
-                /* Compare controller drive array to drivers drive array.
-                 * Check for updates in the drive information and any new drives
-                 * on the controller.
+                drv_found = 0;
+
+                memcpy(&lunid, &ld_buff->LUN[i][0], 4);
+                lunid = le32_to_cpu(lunid);
+
+                /* Find if the LUN is already in the drive array
+                 * of the driver.  If so then update its info
+                 * if not in use.  If it does not exist then find
+                 * the first free index and add it.
                  */
-                for (i = 0; i < num_luns; i++) {
-                        int j;
-
-                        drv_found = 0;
-
-                        lunid = (0xff &
-                                 (unsigned int)(ld_buff->LUN[i][3])) << 24;
-                        lunid |= (0xff &
-                                  (unsigned int)(ld_buff->LUN[i][2])) << 16;
-                        lunid |= (0xff &
-                                  (unsigned int)(ld_buff->LUN[i][1])) << 8;
-                        lunid |= 0xff & (unsigned int)(ld_buff->LUN[i][0]);
-
-                        /* Find if the LUN is already in the drive array
-                         * of the controller.  If so then update its info
-                         * if not is use.  If it does not exist then find
-                         * the first free index and add it.
-                         */
-                        for (j = 0; j <= h->highest_lun; j++) {
-                                if (h->drv[j].LunID == lunid) {
-                                        drv_index = j;
-                                        drv_found = 1;
-                                }
+                for (j = 0; j <= h->highest_lun; j++) {
+                        if (h->drv[j].raid_level != -1 &&
+                                h->drv[j].LunID == lunid) {
+                                drv_index = j;
+                                drv_found = 1;
+                                break;
                         }
+                }
 
-                        /* check if the drive was found already in the array */
-                        if (!drv_found) {
-                                drv_index = cciss_find_free_drive_index(ctlr);
-                                if (drv_index == -1)
-                                        goto freeret;
-
-                                /*Check if the gendisk needs to be allocated */
-                                if (!h->gendisk[drv_index]){
-                                        h->gendisk[drv_index] = alloc_disk(1 << NWD_SHIFT);
-                                        if (!h->gendisk[drv_index]){
-                                                printk(KERN_ERR "cciss: could not allocate new disk %d\n", drv_index);
-                                                goto mem_msg;
-                                        }
-                                }
-                        }
-                        h->drv[drv_index].LunID = lunid;
-                        cciss_update_drive_info(ctlr, drv_index);
-                }               /* end for */
-        }                       /* end else */
+                /* check if the drive was found already in the array */
+                if (!drv_found) {
+                        drv_index = cciss_add_gendisk(h, lunid, 0);
+                        if (drv_index == -1)
+                                goto freeret;
+                }
+                cciss_update_drive_info(ctlr, drv_index, first_time);
+        }               /* end for */
 
-      freeret:
+freeret:
         kfree(ld_buff);
         h->busy_configuring = 0;
         /* We return -1 here to tell the ACU that we have registered/updated
@@ -1595,8 +1750,9 @@ static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk)
          * additional times.
          */
         return -1;
-      mem_msg:
+mem_msg:
         printk(KERN_ERR "cciss: out of memory\n");
+        h->busy_configuring = 0;
         goto freeret;
 }
 
@@ -1652,15 +1808,15 @@ static int deregister_disk(struct gendisk *disk, drive_info_struct *drv,
                  * other than disk 0 we will call put_disk.  We do not
                  * do this for disk 0 as we need it to be able to
                  * configure the controller.
-                */
+                 */
                 if (clear_all){
                         /* This isn't pretty, but we need to find the
                          * disk in our array and NULL our the pointer.
                          * This is so that we will call alloc_disk if
                          * this index is used again later.
-                        */
+                         */
                         for (i=0; i < CISS_MAX_LUN; i++){
-                                if(h->gendisk[i] == disk){
+                                if (h->gendisk[i] == disk) {
                                         h->gendisk[i] = NULL;
                                         break;
                                 }
@@ -1688,7 +1844,7 @@ static int deregister_disk(struct gendisk *disk, drive_info_struct *drv,
                 if (drv == h->drv + h->highest_lun) {
                         /* if so, find the new hightest lun */
                         int i, newhighest = -1;
-                        for (i = 0; i < h->highest_lun; i++) {
+                        for (i = 0; i <= h->highest_lun; i++) {
                                 /* if the disk has size > 0, it is available */
                                 if (h->drv[i].heads)
                                         newhighest = i;
@@ -3199,136 +3355,9 @@ err_out_free_res:
         return err;
 }
 
-/*
- * Gets information about the local volumes attached to the controller.
+/* Function to find the first free pointer into our hba[] array
+ * Returns -1 if no free entries are left.
  */
-static void cciss_getgeometry(int cntl_num)
-{
-        ReportLunData_struct *ld_buff;
-        InquiryData_struct *inq_buff;
-        int return_code;
-        int i;
-        int listlength = 0;
-        __u32 lunid = 0;
-        unsigned block_size;
-        sector_t total_size;
-
-        ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
-        if (ld_buff == NULL) {
-                printk(KERN_ERR "cciss: out of memory\n");
-                return;
-        }
-        inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL);
-        if (inq_buff == NULL) {
-                printk(KERN_ERR "cciss: out of memory\n");
-                kfree(ld_buff);
-                return;
-        }
-        /* Get the firmware version */
-        return_code = sendcmd(CISS_INQUIRY, cntl_num, inq_buff,
-                              sizeof(InquiryData_struct), 0, 0, 0, NULL,
-                              TYPE_CMD);
-        if (return_code == IO_OK) {
-                hba[cntl_num]->firm_ver[0] = inq_buff->data_byte[32];
-                hba[cntl_num]->firm_ver[1] = inq_buff->data_byte[33];
-                hba[cntl_num]->firm_ver[2] = inq_buff->data_byte[34];
-                hba[cntl_num]->firm_ver[3] = inq_buff->data_byte[35];
-        } else {                /* send command failed */
-
-                printk(KERN_WARNING "cciss: unable to determine firmware"
-                       " version of controller\n");
-        }
-        /* Get the number of logical volumes */
-        return_code = sendcmd(CISS_REPORT_LOG, cntl_num, ld_buff,
-                              sizeof(ReportLunData_struct), 0, 0, 0, NULL,
-                              TYPE_CMD);
-
-        if (return_code == IO_OK) {
-#ifdef CCISS_DEBUG
-                printk("LUN Data\n--------------------------\n");
-#endif                          /* CCISS_DEBUG */
-
-                listlength |=
-                    (0xff & (unsigned int)(ld_buff->LUNListLength[0])) << 24;
-                listlength |=
-                    (0xff & (unsigned int)(ld_buff->LUNListLength[1])) << 16;
-                listlength |=
-                    (0xff & (unsigned int)(ld_buff->LUNListLength[2])) << 8;
-                listlength |= 0xff & (unsigned int)(ld_buff->LUNListLength[3]);
-        } else {                /* reading number of logical volumes failed */
-
-                printk(KERN_WARNING "cciss: report logical volume"
-                       " command failed\n");
-                listlength = 0;
-        }
-        hba[cntl_num]->num_luns = listlength / 8;       // 8 bytes pre entry
-        if (hba[cntl_num]->num_luns > CISS_MAX_LUN) {
-                printk(KERN_ERR
-                       "ciss:  only %d number of logical volumes supported\n",
-                       CISS_MAX_LUN);
-                hba[cntl_num]->num_luns = CISS_MAX_LUN;
-        }
-#ifdef CCISS_DEBUG
-        printk(KERN_DEBUG "Length = %x %x %x %x = %d\n",
-               ld_buff->LUNListLength[0], ld_buff->LUNListLength[1],
-               ld_buff->LUNListLength[2], ld_buff->LUNListLength[3],
-               hba[cntl_num]->num_luns);
-#endif                          /* CCISS_DEBUG */
-
-        hba[cntl_num]->highest_lun = hba[cntl_num]->num_luns - 1;
-        for (i = 0; i < CISS_MAX_LUN; i++) {
-                if (i < hba[cntl_num]->num_luns) {
-                        lunid = (0xff & (unsigned int)(ld_buff->LUN[i][3]))
-                            << 24;
-                        lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][2]))
-                            << 16;
-                        lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][1]))
-                            << 8;
-                        lunid |= 0xff & (unsigned int)(ld_buff->LUN[i][0]);
-
-                        hba[cntl_num]->drv[i].LunID = lunid;
-
-#ifdef CCISS_DEBUG
-                        printk(KERN_DEBUG "LUN[%d]:  %x %x %x %x = %x\n", i,
-                               ld_buff->LUN[i][0], ld_buff->LUN[i][1],
-                               ld_buff->LUN[i][2], ld_buff->LUN[i][3],
-                               hba[cntl_num]->drv[i].LunID);
-#endif                          /* CCISS_DEBUG */
-
-                /* testing to see if 16-byte CDBs are already being used */
-                if(hba[cntl_num]->cciss_read == CCISS_READ_16) {
-                        cciss_read_capacity_16(cntl_num, i, 0,
-                                            &total_size, &block_size);
-                        goto geo_inq;
-                }
-                cciss_read_capacity(cntl_num, i, 0, &total_size, &block_size);
-
-                /* If read_capacity returns all F's the logical is >2TB */
-                /* so we switch to 16-byte CDBs for all read/write ops */
-                if(total_size == 0xFFFFFFFFULL) {
-                        cciss_read_capacity_16(cntl_num, i, 0,
-                        &total_size, &block_size);
-                        hba[cntl_num]->cciss_read = CCISS_READ_16;
-                        hba[cntl_num]->cciss_write = CCISS_WRITE_16;
-                } else {
-                        hba[cntl_num]->cciss_read = CCISS_READ_10;
-                        hba[cntl_num]->cciss_write = CCISS_WRITE_10;
-                }
-geo_inq:
-                        cciss_geometry_inquiry(cntl_num, i, 0, total_size,
-                                               block_size, inq_buff,
-                                               &hba[cntl_num]->drv[i]);
-                } else {
-                        /* initialize raid_level to indicate a free space */
-                        hba[cntl_num]->drv[i].raid_level = -1;
-                }
-        }
-        kfree(ld_buff);
-        kfree(inq_buff);
-}
-
-/* Function to find the first free pointer into our hba[] array */
-/* Returns -1 if no free entries are left.  */
 static int alloc_cciss_hba(void)
 {
         int i;
@@ -3340,11 +3369,6 @@ static int alloc_cciss_hba(void)
                         p = kzalloc(sizeof(ctlr_info_t), GFP_KERNEL);
                         if (!p)
                                 goto Enomem;
-                        p->gendisk[0] = alloc_disk(1 << NWD_SHIFT);
-                        if (!p->gendisk[0]) {
-                                kfree(p);
-                                goto Enomem;
-                        }
                         hba[i] = p;
                         return i;
                 }
@@ -3472,11 +3496,13 @@ static int __devinit cciss_init_one(struct pci_dev *pdev,
                ((hba[i]->nr_cmds + BITS_PER_LONG -
                  1) / BITS_PER_LONG) * sizeof(unsigned long));
 
-#ifdef CCISS_DEBUG
-        printk(KERN_DEBUG "Scanning for drives on controller cciss%d\n", i);
-#endif                          /* CCISS_DEBUG */
-
-        cciss_getgeometry(i);
+        hba[i]->num_luns = 0;
+        hba[i]->highest_lun = -1;
+        for (j = 0; j < CISS_MAX_LUN; j++) {
+                hba[i]->drv[j].raid_level = -1;
+                hba[i]->drv[j].queue = NULL;
+                hba[i]->gendisk[j] = NULL;
+        }
 
         cciss_scsi_setup(i);
 
@@ -3489,76 +3515,10 @@ static int __devinit cciss_init_one(struct pci_dev *pdev,
 
         hba[i]->busy_initializing = 0;
 
-        do {
-                drive_info_struct *drv = &(hba[i]->drv[j]);
-                struct gendisk *disk = hba[i]->gendisk[j];
-                struct request_queue *q;
-
-                /* Check if the disk was allocated already */
-                if (!disk){
-                        hba[i]->gendisk[j] = alloc_disk(1 << NWD_SHIFT);
-                        disk = hba[i]->gendisk[j];
-                }
-
-                /* Check that the disk was able to be allocated */
-                if (!disk) {
-                        printk(KERN_ERR "cciss: unable to allocate memory for disk %d\n", j);
-                        goto clean4;
-                }
-
-                q = blk_init_queue(do_cciss_request, &hba[i]->lock);
-                if (!q) {
-                        printk(KERN_ERR
-                               "cciss:  unable to allocate queue for disk %d\n",
-                               j);
-                        goto clean4;
-                }
-                drv->queue = q;
-
-                blk_queue_bounce_limit(q, hba[i]->pdev->dma_mask);
-
-                /* This is a hardware imposed limit. */
-                blk_queue_max_hw_segments(q, MAXSGENTRIES);
-
-                /* This is a limit in the driver and could be eliminated. */
-                blk_queue_max_phys_segments(q, MAXSGENTRIES);
-
-                blk_queue_max_sectors(q, hba[i]->cciss_max_sectors);
-
-                blk_queue_softirq_done(q, cciss_softirq_done);
-
-                q->queuedata = hba[i];
-                sprintf(disk->disk_name, "cciss/c%dd%d", i, j);
-                disk->major = hba[i]->major;
-                disk->first_minor = j << NWD_SHIFT;
-                disk->fops = &cciss_fops;
-                disk->queue = q;
-                disk->private_data = drv;
-                disk->driverfs_dev = &pdev->dev;
-                /* we must register the controller even if no disks exist */
-                /* this is for the online array utilities */
-                if (!drv->heads && j)
-                        continue;
-                blk_queue_hardsect_size(q, drv->block_size);
-                set_capacity(disk, drv->nr_blocks);
-                j++;
-        } while (j <= hba[i]->highest_lun);
-
-        /* Make sure all queue data is written out before */
-        /* interrupt handler, triggered by add_disk,  */
-        /* is allowed to start them. */
-        wmb();
-
-        for (j = 0; j <= hba[i]->highest_lun; j++)
-                add_disk(hba[i]->gendisk[j]);
-
-        /* we must register the controller even if no disks exist */
-        if (hba[i]->highest_lun == -1)
-                add_disk(hba[i]->gendisk[0]);
-
+        rebuild_lun_table(hba[i], 1);
         return 1;
 
-      clean4:
+clean4:
 #ifdef CONFIG_CISS_SCSI_TAPE
         kfree(hba[i]->scsi_rejects.complete);
 #endif
@@ -3573,9 +3533,9 @@ static int __devinit cciss_init_one(struct pci_dev *pdev,
                                     hba[i]->errinfo_pool,
                                     hba[i]->errinfo_pool_dhandle);
         free_irq(hba[i]->intr[SIMPLE_MODE_INT], hba[i]);
-      clean2:
+clean2:
         unregister_blkdev(hba[i]->major, hba[i]->devname);
-      clean1:
+clean1:
         hba[i]->busy_initializing = 0;
         /* cleanup any queues that may have been initialized */
         for (j=0; j <= hba[i]->highest_lun; j++){
@@ -3654,7 +3614,9 @@ static void __devexit cciss_remove_one(struct pci_dev *pdev)
                 }
         }
 
+#ifdef CONFIG_CISS_SCSI_TAPE
         cciss_unregister_scsi(i);       /* unhook from SCSI subsystem */
+#endif
 
         cciss_shutdown(pdev);
 
diff --git a/drivers/block/cciss.h b/drivers/block/cciss.h
index b70988dd33ec..24a7efa993ab 100644
--- a/drivers/block/cciss.h
+++ b/drivers/block/cciss.h
@@ -39,6 +39,8 @@ typedef struct _drive_info_struct
                                    *to prevent it from being opened or it's queue
                                    *from being started.
                                   */
+        __u8 serial_no[16]; /* from inquiry page 0x83, */
+                            /* not necc. null terminated. */
 } drive_info_struct;
 
 #ifdef CONFIG_CISS_SCSI_TAPE
diff --git a/drivers/block/cciss_scsi.c b/drivers/block/cciss_scsi.c
index e4bf9a11ca0d..e1233aabda77 100644
--- a/drivers/block/cciss_scsi.c
+++ b/drivers/block/cciss_scsi.c
@@ -358,23 +358,68 @@ find_bus_target_lun(int ctlr, int *bus, int *target, int *lun)
         }
         return (!found);        
 }
+struct scsi2map {
+        char scsi3addr[8];
+        int bus, target, lun;
+};
 
 static int 
 cciss_scsi_add_entry(int ctlr, int hostno, 
-                unsigned char *scsi3addr, int devtype)
+                unsigned char *scsi3addr, int devtype,
+                struct scsi2map *added, int *nadded)
 {
         /* assumes hba[ctlr]->scsi_ctlr->lock is held */ 
         int n = ccissscsi[ctlr].ndevices;
         struct cciss_scsi_dev_t *sd;
+        int i, bus, target, lun;
+        unsigned char addr1[8], addr2[8];
 
         if (n >= CCISS_MAX_SCSI_DEVS_PER_HBA) {
                 printk("cciss%d: Too many devices, "
                         "some will be inaccessible.\n", ctlr);
                 return -1;
         }
+
+        bus = target = -1;
+        lun = 0;
+        /* Is this device a non-zero lun of a multi-lun device */
+        /* byte 4 of the 8-byte LUN addr will contain the logical unit no. */
+        if (scsi3addr[4] != 0) {
+                /* Search through our list and find the device which */
+                /* has the same 8 byte LUN address, excepting byte 4. */
+                /* Assign the same bus and target for this new LUN. */
+                /* Use the logical unit number from the firmware. */
+                memcpy(addr1, scsi3addr, 8);
+                addr1[4] = 0;
+                for (i = 0; i < n; i++) {
+                        sd = &ccissscsi[ctlr].dev[i];
+                        memcpy(addr2, sd->scsi3addr, 8);
+                        addr2[4] = 0;
+                        /* differ only in byte 4? */
+                        if (memcmp(addr1, addr2, 8) == 0) {
+                                bus = sd->bus;
+                                target = sd->target;
+                                lun = scsi3addr[4];
+                                break;
+                        }
+                }
+        }
+
         sd = &ccissscsi[ctlr].dev[n];
-        if (find_bus_target_lun(ctlr, &sd->bus, &sd->target, &sd->lun) != 0)
-                return -1;
+        if (lun == 0) {
+                if (find_bus_target_lun(ctlr,
+                        &sd->bus, &sd->target, &sd->lun) != 0)
+                        return -1;
+        } else {
+                sd->bus = bus;
+                sd->target = target;
+                sd->lun = lun;
+        }
+        added[*nadded].bus = sd->bus;
+        added[*nadded].target = sd->target;
+        added[*nadded].lun = sd->lun;
+        (*nadded)++;
+
         memcpy(&sd->scsi3addr[0], scsi3addr, 8);
         sd->devtype = devtype;
         ccissscsi[ctlr].ndevices++;
@@ -390,7 +435,8 @@ cciss_scsi_add_entry(int ctlr, int hostno,
 }
 
 static void
-cciss_scsi_remove_entry(int ctlr, int hostno, int entry)
+cciss_scsi_remove_entry(int ctlr, int hostno, int entry,
+        struct scsi2map *removed, int *nremoved)
 {
         /* assumes hba[ctlr]->scsi_ctlr->lock is held */ 
         int i;
@@ -398,6 +444,10 @@ cciss_scsi_remove_entry(int ctlr, int hostno, int entry)
 
         if (entry < 0 || entry >= CCISS_MAX_SCSI_DEVS_PER_HBA) return;
         sd = ccissscsi[ctlr].dev[entry];
+        removed[*nremoved].bus    = sd.bus;
+        removed[*nremoved].target = sd.target;
+        removed[*nremoved].lun    = sd.lun;
+        (*nremoved)++;
         for (i=entry;i<ccissscsi[ctlr].ndevices-1;i++)
                 ccissscsi[ctlr].dev[i] = ccissscsi[ctlr].dev[i+1];
         ccissscsi[ctlr].ndevices--;
@@ -417,6 +467,26 @@ cciss_scsi_remove_entry(int ctlr, int hostno, int entry)
         (a)[1] == (b)[1] && \
         (a)[0] == (b)[0])
 
+static void fixup_botched_add(int ctlr, char *scsi3addr)
+{
+        /* called when scsi_add_device fails in order to re-adjust */
+        /* ccissscsi[] to match the mid layer's view. */
+        unsigned long flags;
+        int i, j;
+        CPQ_TAPE_LOCK(ctlr, flags);
+        for (i = 0; i < ccissscsi[ctlr].ndevices; i++) {
+                if (memcmp(scsi3addr,
+                                ccissscsi[ctlr].dev[i].scsi3addr, 8) == 0) {
+                        for (j = i; j < ccissscsi[ctlr].ndevices-1; j++)
+                                ccissscsi[ctlr].dev[j] =
+                                        ccissscsi[ctlr].dev[j+1];
+                        ccissscsi[ctlr].ndevices--;
+                        break;
+                }
+        }
+        CPQ_TAPE_UNLOCK(ctlr, flags);
+}
+
 static int
 adjust_cciss_scsi_table(int ctlr, int hostno,
         struct cciss_scsi_dev_t sd[], int nsds)
@@ -429,13 +499,33 @@ adjust_cciss_scsi_table(int ctlr, int hostno,
         int i,j, found, changes=0;
         struct cciss_scsi_dev_t *csd;
         unsigned long flags;
+        struct scsi2map *added, *removed;
+        int nadded, nremoved;
+        struct Scsi_Host *sh = NULL;
+
+        added = kzalloc(sizeof(*added) * CCISS_MAX_SCSI_DEVS_PER_HBA,
+                        GFP_KERNEL);
+        removed = kzalloc(sizeof(*removed) * CCISS_MAX_SCSI_DEVS_PER_HBA,
+                        GFP_KERNEL);
+
+        if (!added || !removed) {
+                printk(KERN_WARNING "cciss%d: Out of memory in "
+                        "adjust_cciss_scsi_table\n", ctlr);
+                goto free_and_out;
+        }
 
         CPQ_TAPE_LOCK(ctlr, flags);
 
+        if (hostno != -1)  /* if it's not the first time... */
+                sh = ((struct cciss_scsi_adapter_data_t *)
+                        hba[ctlr]->scsi_ctlr)->scsi_host;
+
         /* find any devices in ccissscsi[] that are not in 
            sd[] and remove them from ccissscsi[] */
 
         i = 0;
+        nremoved = 0;
+        nadded = 0;
         while(i<ccissscsi[ctlr].ndevices) {
                 csd = &ccissscsi[ctlr].dev[i];
                 found=0;
@@ -455,8 +545,9 @@ adjust_cciss_scsi_table(int ctlr, int hostno,
                         /* printk("cciss%d: %s device c%db%dt%dl%d removed.\n",
                                 ctlr, scsi_device_type(csd->devtype), hostno,
                                         csd->bus, csd->target, csd->lun); */
-                        cciss_scsi_remove_entry(ctlr, hostno, i);
-                        /* note, i not incremented */
+                        cciss_scsi_remove_entry(ctlr, hostno, i,
+                                removed, &nremoved);
+                        /* remove ^^^, hence i not incremented */
                 } 
                 else if (found == 1) { /* device is different kind */
                         changes++;
@@ -464,8 +555,15 @@ adjust_cciss_scsi_table(int ctlr, int hostno,
                                 "(device type now %s).\n",
                                 ctlr, hostno, csd->bus, csd->target, csd->lun,
                                         scsi_device_type(csd->devtype));
+                        cciss_scsi_remove_entry(ctlr, hostno, i,
+                                removed, &nremoved);
+                        /* remove ^^^, hence i not incremented */
+                        if (cciss_scsi_add_entry(ctlr, hostno,
+                                &sd[j].scsi3addr[0], sd[j].devtype,
+                                added, &nadded) != 0)
+                                /* we just removed one, so add can't fail. */
+                                        BUG();
                         csd->devtype = sd[j].devtype;
-                        i++;    /* so just move along. */
                 } else          /* device is same as it ever was, */
                         i++;    /* so just move along. */
         }
@@ -489,7 +587,9 @@ adjust_cciss_scsi_table(int ctlr, int hostno,
                 if (!found) {
                         changes++;
                         if (cciss_scsi_add_entry(ctlr, hostno, 
-                                &sd[i].scsi3addr[0], sd[i].devtype) != 0)
+
+                                &sd[i].scsi3addr[0], sd[i].devtype,
+                                added, &nadded) != 0)
                                 break;
                 } else if (found == 1) {
                         /* should never happen... */
@@ -501,9 +601,50 @@ adjust_cciss_scsi_table(int ctlr, int hostno,
         }
         CPQ_TAPE_UNLOCK(ctlr, flags);
 
-        if (!changes) 
-                printk("cciss%d: No device changes detected.\n", ctlr);
+        /* Don't notify scsi mid layer of any changes the first time through */
+        /* (or if there are no changes) scsi_scan_host will do it later the */
+        /* first time through. */
+        if (hostno == -1 || !changes)
+                goto free_and_out;
+
+        /* Notify scsi mid layer of any removed devices */
+        for (i = 0; i < nremoved; i++) {
+                struct scsi_device *sdev =
+                        scsi_device_lookup(sh, removed[i].bus,
+                                removed[i].target, removed[i].lun);
+                if (sdev != NULL) {
+                        scsi_remove_device(sdev);
+                        scsi_device_put(sdev);
+                } else {
+                        /* We don't expect to get here. */
+                        /* future cmds to this device will get selection */
+                        /* timeout as if the device was gone. */
+                        printk(KERN_WARNING "cciss%d: didn't find "
+                                "c%db%dt%dl%d\n for removal.",
+                                ctlr, hostno, removed[i].bus,
+                                removed[i].target, removed[i].lun);
+                }
+        }
+
+        /* Notify scsi mid layer of any added devices */
+        for (i = 0; i < nadded; i++) {
+                int rc;
+                rc = scsi_add_device(sh, added[i].bus,
+                        added[i].target, added[i].lun);
+                if (rc == 0)
+                        continue;
+                printk(KERN_WARNING "cciss%d: scsi_add_device "
+                        "c%db%dt%dl%d failed, device not added.\n",
+                        ctlr, hostno,
+                        added[i].bus, added[i].target, added[i].lun);
+                /* now we have to remove it from ccissscsi, */
+                /* since it didn't get added to scsi mid layer */
+                fixup_botched_add(ctlr, added[i].scsi3addr);
+        }
 
+free_and_out:
+        kfree(added);
+        kfree(removed);
         return 0;
 }
 
@@ -1355,32 +1496,6 @@ cciss_unregister_scsi(int ctlr)
 }
 
 static int 
-cciss_register_scsi(int ctlr)
-{
-        unsigned long flags;
-
-        CPQ_TAPE_LOCK(ctlr, flags);
-
-        /* Since this is really a block driver, the SCSI core may not be 
-           initialized at init time, in which case, calling scsi_register_host
-           would hang.  Instead, we do it later, via /proc filesystem
-           and rc scripts, when we know SCSI core is good to go. */
-
-        /* Only register if SCSI devices are detected. */
-        if (ccissscsi[ctlr].ndevices != 0) {
-                ((struct cciss_scsi_adapter_data_t *) 
-                        hba[ctlr]->scsi_ctlr)->registered = 1;
-                CPQ_TAPE_UNLOCK(ctlr, flags);
-                return cciss_scsi_detect(ctlr);
-        }
-        CPQ_TAPE_UNLOCK(ctlr, flags);
-        printk(KERN_INFO 
-                "cciss%d: No appropriate SCSI device detected, "
-                "SCSI subsystem not engaged.\n", ctlr);
-        return 0;
-}
-
-static int 
 cciss_engage_scsi(int ctlr)
 {
         struct cciss_scsi_adapter_data_t *sa;
@@ -1391,15 +1506,15 @@ cciss_engage_scsi(int ctlr)
         sa = (struct cciss_scsi_adapter_data_t *) hba[ctlr]->scsi_ctlr;
         stk = &sa->cmd_stack; 
 
-        if (((struct cciss_scsi_adapter_data_t *) 
-                hba[ctlr]->scsi_ctlr)->registered) {
+        if (sa->registered) {
                 printk("cciss%d: SCSI subsystem already engaged.\n", ctlr);
                 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
                 return ENXIO;
         }
+        sa->registered = 1;
         spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
         cciss_update_non_disk_devices(ctlr, -1);
-        cciss_register_scsi(ctlr);
+        cciss_scsi_detect(ctlr);
         return 0;
 }
 
@@ -1493,7 +1608,5 @@ static int  cciss_eh_abort_handler(struct scsi_cmnd *scsicmd)
 /* If no tape support, then these become defined out of existence */
 
 #define cciss_scsi_setup(cntl_num)
-#define cciss_unregister_scsi(ctlr)
-#define cciss_register_scsi(ctlr)
 
 #endif /* CONFIG_CISS_SCSI_TAPE */
diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c
index 9ae05c584234..3ca643cafccd 100644
--- a/drivers/block/xen-blkfront.c
+++ b/drivers/block/xen-blkfront.c
@@ -154,8 +154,8 @@ static int blkif_getgeo(struct block_device *bd, struct hd_geometry *hg)
         return 0;
 }
 
-int blkif_ioctl(struct inode *inode, struct file *filep,
-                unsigned command, unsigned long argument)
+static int blkif_ioctl(struct inode *inode, struct file *filep,
+                       unsigned command, unsigned long argument)
 {
         struct blkfront_info *info =
                 inode->i_bdev->bd_disk->private_data;
diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index d0ac944e1696..caff85149b9d 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -8,7 +8,7 @@ config VT
         bool "Virtual terminal" if EMBEDDED
         depends on !S390
         select INPUT
-        default y if !VIOCONS
+        default y
         ---help---
           If you say Y here, you will get support for terminal devices with
           display and keyboard devices. These are called "virtual" because you
diff --git a/drivers/char/Makefile b/drivers/char/Makefile
index 8a161c30e1dc..6850f6da7576 100644
--- a/drivers/char/Makefile
+++ b/drivers/char/Makefile
@@ -55,7 +55,6 @@ obj-$(CONFIG_RAW_DRIVER)	+= raw.o
 obj-$(CONFIG_SGI_SNSC)          += snsc.o snsc_event.o
 obj-$(CONFIG_MSPEC)             += mspec.o
 obj-$(CONFIG_MMTIMER)           += mmtimer.o
-obj-$(CONFIG_VIOCONS)           += viocons.o
 obj-$(CONFIG_VIOTAPE)           += viotape.o
 obj-$(CONFIG_HVCS)              += hvcs.o
 obj-$(CONFIG_IBM_BSR)           += bsr.o
diff --git a/drivers/char/amiserial.c b/drivers/char/amiserial.c
index 3530ff417a51..6e763e3f5a81 100644
--- a/drivers/char/amiserial.c
+++ b/drivers/char/amiserial.c
@@ -1254,7 +1254,7 @@ static int rs_break(struct tty_struct *tty, int break_state)
         unsigned long flags;
 
         if (serial_paranoia_check(info, tty->name, "rs_break"))
-                return;
+                return -EINVAL;
 
         local_irq_save(flags);
         if (break_state == -1)
diff --git a/drivers/char/viocons.c b/drivers/char/viocons.c
deleted file mode 100644
index 65fb848e1cce..000000000000
--- a/drivers/char/viocons.c
+++ /dev/null
@@ -1,1171 +0,0 @@
-/* -*- linux-c -*-
- *
- *  drivers/char/viocons.c
- *
- *  iSeries Virtual Terminal
- *
- *  Authors: Dave Boutcher <boutcher@us.ibm.com>
- *           Ryan Arnold <ryanarn@us.ibm.com>
- *           Colin Devilbiss <devilbis@us.ibm.com>
- *           Stephen Rothwell
- *
- * (C) Copyright 2000, 2001, 2002, 2003, 2004 IBM Corporation
- *
- * 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) anyu 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- */
-#include <linux/kernel.h>
-#include <linux/proc_fs.h>
-#include <linux/errno.h>
-#include <linux/vmalloc.h>
-#include <linux/mm.h>
-#include <linux/console.h>
-#include <linux/module.h>
-#include <asm/uaccess.h>
-#include <linux/init.h>
-#include <linux/wait.h>
-#include <linux/spinlock.h>
-#include <asm/ioctls.h>
-#include <linux/kd.h>
-#include <linux/tty.h>
-#include <linux/tty_flip.h>
-#include <linux/sysrq.h>
-
-#include <asm/firmware.h>
-#include <asm/iseries/vio.h>
-#include <asm/iseries/hv_lp_event.h>
-#include <asm/iseries/hv_call_event.h>
-#include <asm/iseries/hv_lp_config.h>
-#include <asm/iseries/hv_call.h>
-
-#ifdef CONFIG_VT
-#error You must turn off CONFIG_VT to use CONFIG_VIOCONS
-#endif
-
-#define VIOTTY_MAGIC (0x0DCB)
-#define VTTY_PORTS 10
-
-#define VIOCONS_KERN_WARN       KERN_WARNING "viocons: "
-#define VIOCONS_KERN_INFO       KERN_INFO "viocons: "
-
-static DEFINE_SPINLOCK(consolelock);
-static DEFINE_SPINLOCK(consoleloglock);
-
-static int vio_sysrq_pressed;
-
-#define VIOCHAR_NUM_BUF         16
-
-/*
- * Our port information.  We store a pointer to one entry in the
- * tty_driver_data
- */
-static struct port_info {
-        int magic;
-        struct tty_struct *tty;
-        HvLpIndex lp;
-        u8 vcons;
-        u64 seq;        /* sequence number of last HV send */
-        u64 ack;        /* last ack from HV */
-/*
- * When we get writes faster than we can send it to the partition,
- * buffer the data here. Note that used is a bit map of used buffers.
- * It had better have enough bits to hold VIOCHAR_NUM_BUF the bitops assume
- * it is a multiple of unsigned long
- */
-        unsigned long used;
-        u8 *buffer[VIOCHAR_NUM_BUF];
-        int bufferBytes[VIOCHAR_NUM_BUF];
-        int curbuf;
-        int bufferOverflow;
-        int overflowMessage;
-} port_info[VTTY_PORTS];
-
-#define viochar_is_console(pi)  ((pi) == &port_info[0])
-#define viochar_port(pi)        ((pi) - &port_info[0])
-
-static void initDataEvent(struct viocharlpevent *viochar, HvLpIndex lp);
-
-static struct tty_driver *viotty_driver;
-
-static void hvlog(char *fmt, ...)
-{
-        int i;
-        unsigned long flags;
-        va_list args;
-        static char buf[256];
-
-        spin_lock_irqsave(&consoleloglock, flags);
-        va_start(args, fmt);
-        i = vscnprintf(buf, sizeof(buf) - 1, fmt, args);
-        va_end(args);
-        buf[i++] = '\r';
-        HvCall_writeLogBuffer(buf, i);
-        spin_unlock_irqrestore(&consoleloglock, flags);
-}
-
-static void hvlogOutput(const char *buf, int count)
-{
-        unsigned long flags;
-        int begin;
-        int index;
-        static const char cr = '\r';
-
-        begin = 0;
-        spin_lock_irqsave(&consoleloglock, flags);
-        for (index = 0; index < count; index++) {
-                if (buf[index] == '\n') {
-                        /*
-                         * Start right after the last '\n' or at the zeroth
-                         * array position and output the number of characters
-                         * including the newline.
-                         */
-                        HvCall_writeLogBuffer(&buf[begin], index - begin + 1);
-                        begin = index + 1;
-                        HvCall_writeLogBuffer(&cr, 1);
-                }
-        }
-        if ((index - begin) > 0)
-                HvCall_writeLogBuffer(&buf[begin], index - begin);
-        spin_unlock_irqrestore(&consoleloglock, flags);
-}
-
-/*
- * Make sure we're pointing to a valid port_info structure.  Shamelessly
- * plagerized from serial.c
- */
-static inline int viotty_paranoia_check(struct port_info *pi,
-                                        char *name, const char *routine)
-{
-        static const char *bad_pi_addr = VIOCONS_KERN_WARN
-                "warning: bad address for port_info struct (%s) in %s\n";
-        static const char *badmagic = VIOCONS_KERN_WARN
-                "warning: bad magic number for port_info struct (%s) in %s\n";
-
-        if ((pi < &port_info[0]) || (viochar_port(pi) > VTTY_PORTS)) {
-                printk(bad_pi_addr, name, routine);
-                return 1;
-        }
-        if (pi->magic != VIOTTY_MAGIC) {
-                printk(badmagic, name, routine);
-                return 1;
-        }
-        return 0;
-}
-
-/*
- * Add data to our pending-send buffers.  
- *
- * NOTE: Don't use printk in here because it gets nastily recursive.
- * hvlog can be used to log to the hypervisor buffer
- */
-static int buffer_add(struct port_info *pi, const char *buf, size_t len)
-{
-        size_t bleft;
-        size_t curlen;
-        const char *curbuf;
-        int nextbuf;
-
-        curbuf = buf;
-        bleft = len;
-        while (bleft > 0) {
-                /*
-                 * If there is no space left in the current buffer, we have
-                 * filled everything up, so return.  If we filled the previous
-                 * buffer we would already have moved to the next one.
-                 */
-                if (pi->bufferBytes[pi->curbuf] == VIOCHAR_MAX_DATA) {
-                        hvlog ("\n\rviocons: No overflow buffer available for memcpy().\n");
-                        pi->bufferOverflow++;
-                        pi->overflowMessage = 1;
-                        break;
-                }
-
-                /*
-                 * Turn on the "used" bit for this buffer.  If it's already on,
-                 * that's fine.
-                 */
-                set_bit(pi->curbuf, &pi->used);
-
-                /*
-                 * See if this buffer has been allocated.  If not, allocate it.
-                 */
-                if (pi->buffer[pi->curbuf] == NULL) {
-                        pi->buffer[pi->curbuf] =
-                            kmalloc(VIOCHAR_MAX_DATA, GFP_ATOMIC);
-                        if (pi->buffer[pi->curbuf] == NULL) {
-                                hvlog("\n\rviocons: kmalloc failed allocating spaces for buffer %d.",
-                                        pi->curbuf);
-                                break;
-                        }
-                }
-
-                /* Figure out how much we can copy into this buffer. */
-                if (bleft < (VIOCHAR_MAX_DATA - pi->bufferBytes[pi->curbuf]))
-                        curlen = bleft;
-                else
-                        curlen = VIOCHAR_MAX_DATA - pi->bufferBytes[pi->curbuf];
-
-                /* Copy the data into the buffer. */
-                memcpy(pi->buffer[pi->curbuf] + pi->bufferBytes[pi->curbuf],
-                                curbuf, curlen);
-
-                pi->bufferBytes[pi->curbuf] += curlen;
-                curbuf += curlen;
-                bleft -= curlen;
-
-                /*
-                 * Now see if we've filled this buffer.  If not then
-                 * we'll try to use it again later.  If we've filled it
-                 * up then we'll advance the curbuf to the next in the
-                 * circular queue.
-                 */
-                if (pi->bufferBytes[pi->curbuf] == VIOCHAR_MAX_DATA) {
-                        nextbuf = (pi->curbuf + 1) % VIOCHAR_NUM_BUF;
-                        /*
-                         * Move to the next buffer if it hasn't been used yet
-                         */
-                        if (test_bit(nextbuf, &pi->used) == 0)
-                                pi->curbuf = nextbuf;
-                }
-        }
-        return len - bleft;
-}
-
-/*
- * Send pending data
- *
- * NOTE: Don't use printk in here because it gets nastily recursive.
- * hvlog can be used to log to the hypervisor buffer
- */
-static void send_buffers(struct port_info *pi)
-{
-        HvLpEvent_Rc hvrc;
-        int nextbuf;
-        struct viocharlpevent *viochar;
-        unsigned long flags;
-
-        spin_lock_irqsave(&consolelock, flags);
-
-        viochar = (struct viocharlpevent *)
-            vio_get_event_buffer(viomajorsubtype_chario);
-
-        /* Make sure we got a buffer */
-        if (viochar == NULL) {
-                hvlog("\n\rviocons: Can't get viochar buffer in sendBuffers().");
-                spin_unlock_irqrestore(&consolelock, flags);
-                return;
-        }
-
-        if (pi->used == 0) {
-                hvlog("\n\rviocons: in sendbuffers(), but no buffers used.\n");
-                vio_free_event_buffer(viomajorsubtype_chario, viochar);
-                spin_unlock_irqrestore(&consolelock, flags);
-                return;
-        }
-
-        /*
-         * curbuf points to the buffer we're filling.  We want to
-         * start sending AFTER this one.  
-         */
-        nextbuf = (pi->curbuf + 1) % VIOCHAR_NUM_BUF;
-
-        /*
-         * Loop until we find a buffer with the used bit on
-         */
-        while (test_bit(nextbuf, &pi->used) == 0)
-                nextbuf = (nextbuf + 1) % VIOCHAR_NUM_BUF;
-
-        initDataEvent(viochar, pi->lp);
-
-        /*
-         * While we have buffers with data, and our send window
-         * is open, send them
-         */
-        while ((test_bit(nextbuf, &pi->used)) &&
-               ((pi->seq - pi->ack) < VIOCHAR_WINDOW)) {
-                viochar->len = pi->bufferBytes[nextbuf];
-                viochar->event.xCorrelationToken = pi->seq++;
-                viochar->event.xSizeMinus1 =
-                        offsetof(struct viocharlpevent, data) + viochar->len;
-
-                memcpy(viochar->data, pi->buffer[nextbuf], viochar->len);
-
-                hvrc = HvCallEvent_signalLpEvent(&viochar->event);
-                if (hvrc) {
-                        /*
-                         * MUST unlock the spinlock before doing a printk
-                         */
-                        vio_free_event_buffer(viomajorsubtype_chario, viochar);
-                        spin_unlock_irqrestore(&consolelock, flags);
-
-                        printk(VIOCONS_KERN_WARN
-                               "error sending event! return code %d\n",
-                               (int)hvrc);
-                        return;
-                }
-
-                /*
-                 * clear the used bit, zero the number of bytes in
-                 * this buffer, and move to the next buffer
-                 */
-                clear_bit(nextbuf, &pi->used);
-                pi->bufferBytes[nextbuf] = 0;
-                nextbuf = (nextbuf + 1) % VIOCHAR_NUM_BUF;
-        }
-
-        /*
-         * If we have emptied all the buffers, start at 0 again.
-         * this will re-use any allocated buffers
-         */
-        if (pi->used == 0) {
-                pi->curbuf = 0;
-
-                if (pi->overflowMessage)
-                        pi->overflowMessage = 0;
-
-                if (pi->tty) {
-                        tty_wakeup(pi->tty);
-                }
-        }
-
-        vio_free_event_buffer(viomajorsubtype_chario, viochar);
-        spin_unlock_irqrestore(&consolelock, flags);
-}
-
-/*
- * Our internal writer.  Gets called both from the console device and
- * the tty device.  the tty pointer will be NULL if called from the console.
- * Return total number of bytes "written".
- *
- * NOTE: Don't use printk in here because it gets nastily recursive.  hvlog
- * can be used to log to the hypervisor buffer
- */
-static int internal_write(struct port_info *pi, const char *buf, size_t len)
-{
-        HvLpEvent_Rc hvrc;
-        size_t bleft;
-        size_t curlen;
-        const char *curbuf;
-        unsigned long flags;
-        struct viocharlpevent *viochar;
-
-        /*
-         * Write to the hvlog of inbound data are now done prior to
-         * calling internal_write() since internal_write() is only called in
-         * the event that an lp event path is active, which isn't the case for
-         * logging attempts prior to console initialization.
-         *
-         * If there is already data queued for this port, send it prior to
-         * attempting to send any new data.
-         */
-        if (pi->used)
-                send_buffers(pi);
-
-        spin_lock_irqsave(&consolelock, flags);
-
-        viochar = vio_get_event_buffer(viomajorsubtype_chario);
-        if (viochar == NULL) {
-                spin_unlock_irqrestore(&consolelock, flags);
-                hvlog("\n\rviocons: Can't get vio buffer in internal_write().");
-                return -EAGAIN;
-        }
-        initDataEvent(viochar, pi->lp);
-
-        curbuf = buf;
-        bleft = len;
-
-        while ((bleft > 0) && (pi->used == 0) &&
-               ((pi->seq - pi->ack) < VIOCHAR_WINDOW)) {
-                if (bleft > VIOCHAR_MAX_DATA)
-                        curlen = VIOCHAR_MAX_DATA;
-                else
-                        curlen = bleft;
-
-                viochar->event.xCorrelationToken = pi->seq++;
-                memcpy(viochar->data, curbuf, curlen);
-                viochar->len = curlen;
-                viochar->event.xSizeMinus1 =
-                    offsetof(struct viocharlpevent, data) + curlen;
-
-                hvrc = HvCallEvent_signalLpEvent(&viochar->event);
-                if (hvrc) {
-                        hvlog("viocons: error sending event! %d\n", (int)hvrc);
-                        goto out;
-                }
-                curbuf += curlen;
-                bleft -= curlen;
-        }
-
-        /* If we didn't send it all, buffer as much of it as we can. */
-        if (bleft > 0)
-                bleft -= buffer_add(pi, curbuf, bleft);
-out:
-        vio_free_event_buffer(viomajorsubtype_chario, viochar);
-        spin_unlock_irqrestore(&consolelock, flags);
-        return len - bleft;
-}
-
-static struct port_info *get_port_data(struct tty_struct *tty)
-{
-        unsigned long flags;
-        struct port_info *pi;
-
-        spin_lock_irqsave(&consolelock, flags);
-        if (tty) {
-                pi = (struct port_info *)tty->driver_data;
-                if (!pi || viotty_paranoia_check(pi, tty->name,
-                                             "get_port_data")) {
-                        pi = NULL;
-                }
-        } else
-                /*
-                 * If this is the console device, use the lp from
-                 * the first port entry
-                 */
-                pi = &port_info[0];
-        spin_unlock_irqrestore(&consolelock, flags);
-        return pi;
-}
-
-/*
- * Initialize the common fields in a charLpEvent
- */
-static void initDataEvent(struct viocharlpevent *viochar, HvLpIndex lp)
-{
-        struct HvLpEvent *hev = &viochar->event;
-
-        memset(viochar, 0, sizeof(struct viocharlpevent));
-
-        hev->flags = HV_LP_EVENT_VALID | HV_LP_EVENT_DEFERRED_ACK |
-                HV_LP_EVENT_INT;
-        hev->xType = HvLpEvent_Type_VirtualIo;
-        hev->xSubtype = viomajorsubtype_chario | viochardata;
-        hev->xSourceLp = HvLpConfig_getLpIndex();
-        hev->xTargetLp = lp;
-        hev->xSizeMinus1 = sizeof(struct viocharlpevent);
-        hev->xSourceInstanceId = viopath_sourceinst(lp);
-        hev->xTargetInstanceId = viopath_targetinst(lp);
-}
-
-/*
- * early console device write
- */
-static void viocons_write_early(struct console *co, const char *s, unsigned count)
-{
-        hvlogOutput(s, count);
-}
-
-/*
- * console device write
- */
-static void viocons_write(struct console *co, const char *s, unsigned count)
-{
-        int index;
-        int begin;
-        struct port_info *pi;
-
-        static const char cr = '\r';
-
-        /*
-         * Check port data first because the target LP might be valid but
-         * simply not active, in which case we want to hvlog the output.
-         */
-        pi = get_port_data(NULL);
-        if (pi == NULL) {
-                hvlog("\n\rviocons_write: unable to get port data.");
-                return;
-        }
-
-        hvlogOutput(s, count);
-
-        if (!viopath_isactive(pi->lp))
-                return;
-
-        /* 
-         * Any newline character found will cause a
-         * carriage return character to be emitted as well. 
-         */
-        begin = 0;
-        for (index = 0; index < count; index++) {
-                if (s[index] == '\n') {
-                        /* 
-                         * Newline found. Print everything up to and 
-                         * including the newline
-                         */
-                        internal_write(pi, &s[begin], index - begin + 1);
-                        begin = index + 1;
-                        /* Emit a carriage return as well */
-                        internal_write(pi, &cr, 1);
-                }
-        }
-
-        /* If any characters left to write, write them now */
-        if ((index - begin) > 0)
-                internal_write(pi, &s[begin], index - begin);
-}
-
-/*
- * Work out the device associate with this console
- */
-static struct tty_driver *viocons_device(struct console *c, int *index)
-{
-        *index = c->index;
-        return viotty_driver;
-}
-
-/*
- * console device I/O methods
- */
-static struct console viocons_early = {
-        .name = "viocons",
-        .write = viocons_write_early,
-        .flags = CON_PRINTBUFFER,
-        .index = -1,
-};
-
-static struct console viocons = {
-        .name = "viocons",
-        .write = viocons_write,
-        .device = viocons_device,
-        .flags = CON_PRINTBUFFER,
-        .index = -1,
-};
-
-/*
- * TTY Open method
- */
-static int viotty_open(struct tty_struct *tty, struct file *filp)
-{
-        int port;
-        unsigned long flags;
-        struct port_info *pi;
-
-        port = tty->index;
-
-        if ((port < 0) || (port >= VTTY_PORTS))
-                return -ENODEV;
-
-        spin_lock_irqsave(&consolelock, flags);
-
-        pi = &port_info[port];
-        /* If some other TTY is already connected here, reject the open */
-        if ((pi->tty) && (pi->tty != tty)) {
-                spin_unlock_irqrestore(&consolelock, flags);
-                printk(VIOCONS_KERN_WARN
-                       "attempt to open device twice from different ttys\n");
-                return -EBUSY;
-        }
-        tty->driver_data = pi;
-        pi->tty = tty;
-        spin_unlock_irqrestore(&consolelock, flags);
-
-        return 0;
-}
-
-/*
- * TTY Close method
- */
-static void viotty_close(struct tty_struct *tty, struct file *filp)
-{
-        unsigned long flags;
-        struct port_info *pi;
-
-        spin_lock_irqsave(&consolelock, flags);
-        pi = (struct port_info *)tty->driver_data;
-
-        if (!pi || viotty_paranoia_check(pi, tty->name, "viotty_close")) {
-                spin_unlock_irqrestore(&consolelock, flags);
-                return;
-        }
-        if (tty->count == 1)
-                pi->tty = NULL;
-        spin_unlock_irqrestore(&consolelock, flags);
-}
-
-/*
- * TTY Write method
- */
-static int viotty_write(struct tty_struct *tty, const unsigned char *buf,
-                int count)
-{
-        struct port_info *pi;
-
-        pi = get_port_data(tty);
-        if (pi == NULL) {
-                hvlog("\n\rviotty_write: no port data.");
-                return -ENODEV;
-        }
-
-        if (viochar_is_console(pi))
-                hvlogOutput(buf, count);
-
-        /*
-         * If the path to this LP is closed, don't bother doing anything more.
-         * just dump the data on the floor and return count.  For some reason
-         * some user level programs will attempt to probe available tty's and
-         * they'll attempt a viotty_write on an invalid port which maps to an
-         * invalid target lp.  If this is the case then ignore the
-         * viotty_write call and, since the viopath isn't active to this
-         * partition, return count.
-         */
-        if (!viopath_isactive(pi->lp))
-                return count;
-
-        return internal_write(pi, buf, count);
-}
-
-/*
- * TTY put_char method
- */
-static int viotty_put_char(struct tty_struct *tty, unsigned char ch)
-{
-        struct port_info *pi;
-
-        pi = get_port_data(tty);
-        if (pi == NULL)
-                return 0;
-
-        /* This will append '\r' as well if the char is '\n' */
-        if (viochar_is_console(pi))
-                hvlogOutput(&ch, 1);
-
-        if (viopath_isactive(pi->lp))
-                internal_write(pi, &ch, 1);
-        return 1;
-}
-
-/*
- * TTY write_room method
- */
-static int viotty_write_room(struct tty_struct *tty)
-{
-        int i;
-        int room = 0;
-        struct port_info *pi;
-        unsigned long flags;
-
-        spin_lock_irqsave(&consolelock, flags);
-        pi = (struct port_info *)tty->driver_data;
-        if (!pi || viotty_paranoia_check(pi, tty->name, "viotty_write_room")) {
-                spin_unlock_irqrestore(&consolelock, flags);
-                return 0;
-        }
-
-        /* If no buffers are used, return the max size. */
-        if (pi->used == 0) {
-                spin_unlock_irqrestore(&consolelock, flags);
-                return VIOCHAR_MAX_DATA * VIOCHAR_NUM_BUF;
-        }
-
-        /*
-         * We retain the spinlock because we want to get an accurate
-         * count and it can change on us between each operation if we
-         * don't hold the spinlock.
-         */
-        for (i = 0; ((i < VIOCHAR_NUM_BUF) && (room < VIOCHAR_MAX_DATA)); i++)
-                room += (VIOCHAR_MAX_DATA - pi->bufferBytes[i]);
-        spin_unlock_irqrestore(&consolelock, flags);
-
-        if (room > VIOCHAR_MAX_DATA)
-                room = VIOCHAR_MAX_DATA;
-        return room;
-}
-
-/*
- * TTY chars_in_buffer method
- */
-static int viotty_chars_in_buffer(struct tty_struct *tty)
-{
-        return 0;
-}
-
-static int viotty_ioctl(struct tty_struct *tty, struct file *file,
-                        unsigned int cmd, unsigned long arg)
-{
-        switch (cmd) {
-        /*
-         * the ioctls below read/set the flags usually shown in the leds
-         * don't use them - they will go away without warning
-         */
-        case KDGETLED:
-        case KDGKBLED:
-                return put_user(0, (char *)arg);
-
-        case KDSKBLED:
-                return 0;
-        }
-        /* FIXME: WTF is this being called for ??? */
-        lock_kernel();
-        ret =  n_tty_ioctl(tty, file, cmd, arg);
-        unlock_kernel();
-        return ret;
-}
-
-/*
- * Handle an open charLpEvent.  Could be either interrupt or ack
- */
-static void vioHandleOpenEvent(struct HvLpEvent *event)
-{
-        unsigned long flags;
-        struct viocharlpevent *cevent = (struct viocharlpevent *)event;
-        u8 port = cevent->virtual_device;
-        struct port_info *pi;
-        int reject = 0;
-
-        if (hvlpevent_is_ack(event)) {
-                if (port >= VTTY_PORTS)
-                        return;
-
-                spin_lock_irqsave(&consolelock, flags);
-                /* Got the lock, don't cause console output */
-
-                pi = &port_info[port];
-                if (event->xRc == HvLpEvent_Rc_Good) {
-                        pi->seq = pi->ack = 0;
-                        /*
-                         * This line allows connections from the primary
-                         * partition but once one is connected from the
-                         * primary partition nothing short of a reboot
-                         * of linux will allow access from the hosting
-                         * partition again without a required iSeries fix.
-                         */
-                        pi->lp = event->xTargetLp;
-                }
-
-                spin_unlock_irqrestore(&consolelock, flags);
-                if (event->xRc != HvLpEvent_Rc_Good)
-                        printk(VIOCONS_KERN_WARN
-                               "handle_open_event: event->xRc == (%d).\n",
-                               event->xRc);
-
-                if (event->xCorrelationToken != 0) {
-                        atomic_t *aptr= (atomic_t *)event->xCorrelationToken;
-                        atomic_set(aptr, 1);
-                } else
-                        printk(VIOCONS_KERN_WARN
-                               "weird...got open ack without atomic\n");
-                return;
-        }
-
-        /* This had better require an ack, otherwise complain */
-        if (!hvlpevent_need_ack(event)) {
-                printk(VIOCONS_KERN_WARN "viocharopen without ack bit!\n");
-                return;
-        }
-
-        spin_lock_irqsave(&consolelock, flags);
-        /* Got the lock, don't cause console output */
-
-        /* Make sure this is a good virtual tty */
-        if (port >= VTTY_PORTS) {
-                event->xRc = HvLpEvent_Rc_SubtypeError;
-                cevent->subtype_result_code = viorc_openRejected;
-                /*
-                 * Flag state here since we can't printk while holding
-                 * a spinlock.
-                 */
-                reject = 1;
-        } else {
-                pi = &port_info[port];
-                if ((pi->lp != HvLpIndexInvalid) &&
-                                (pi->lp != event->xSourceLp)) {
-                        /*
-                         * If this is tty is already connected to a different
-                         * partition, fail.
-                         */
-                        event->xRc = HvLpEvent_Rc_SubtypeError;
-                        cevent->subtype_result_code = viorc_openRejected;
-                        reject = 2;
-                } else {
-                        pi->lp = event->xSourceLp;
-                        event->xRc = HvLpEvent_Rc_Good;
-                        cevent->subtype_result_code = viorc_good;
-                        pi->seq = pi->ack = 0;
-                        reject = 0;
-                }
-        }
-
-        spin_unlock_irqrestore(&consolelock, flags);
-
-        if (reject == 1)
-                printk(VIOCONS_KERN_WARN "open rejected: bad virtual tty.\n");
-        else if (reject == 2)
-                printk(VIOCONS_KERN_WARN
-                        "open rejected: console in exclusive use by another partition.\n");
-
-        /* Return the acknowledgement */
-        HvCallEvent_ackLpEvent(event);
-}
-
-/*
- * Handle a close charLpEvent.  This should ONLY be an Interrupt because the
- * virtual console should never actually issue a close event to the hypervisor
- * because the virtual console never goes away.  A close event coming from the
- * hypervisor simply means that there are no client consoles connected to the
- * virtual console.
- *
- * Regardless of the number of connections masqueraded on the other side of
- * the hypervisor ONLY ONE close event should be called to accompany the ONE
- * open event that is called.  The close event should ONLY be called when NO
- * MORE connections (masqueraded or not) exist on the other side of the
- * hypervisor.
- */
-static void vioHandleCloseEvent(struct HvLpEvent *event)
-{
-        unsigned long flags;
-        struct viocharlpevent *cevent = (struct viocharlpevent *)event;
-        u8 port = cevent->virtual_device;
-
-        if (hvlpevent_is_int(event)) {
-                if (port >= VTTY_PORTS) {
-                        printk(VIOCONS_KERN_WARN
-                                        "close message from invalid virtual device.\n");
-                        return;
-                }
-
-                /* For closes, just mark the console partition invalid */
-                spin_lock_irqsave(&consolelock, flags);
-                /* Got the lock, don't cause console output */
-
-                if (port_info[port].lp == event->xSourceLp)
-                        port_info[port].lp = HvLpIndexInvalid;
-
-                spin_unlock_irqrestore(&consolelock, flags);
-                printk(VIOCONS_KERN_INFO "close from %d\n", event->xSourceLp);
-        } else
-                printk(VIOCONS_KERN_WARN
-                                "got unexpected close acknowlegement\n");
-}
-
-/*
- * Handle a config charLpEvent.  Could be either interrupt or ack
- */
-static void vioHandleConfig(struct HvLpEvent *event)
-{
-        struct viocharlpevent *cevent = (struct viocharlpevent *)event;
-
-        HvCall_writeLogBuffer(cevent->data, cevent->len);
-
-        if (cevent->data[0] == 0x01)
-                printk(VIOCONS_KERN_INFO "window resized to %d: %d: %d: %d\n",
-                       cevent->data[1], cevent->data[2],
-                       cevent->data[3], cevent->data[4]);
-        else
-                printk(VIOCONS_KERN_WARN "unknown config event\n");
-}
-
-/*
- * Handle a data charLpEvent. 
- */
-static void vioHandleData(struct HvLpEvent *event)
-{
-        struct tty_struct *tty;
-        unsigned long flags;
-        struct viocharlpevent *cevent = (struct viocharlpevent *)event;
-        struct port_info *pi;
-        int index;
-        int num_pushed;
-        u8 port = cevent->virtual_device;
-
-        if (port >= VTTY_PORTS) {
-                printk(VIOCONS_KERN_WARN "data on invalid virtual device %d\n",
-                                port);
-                return;
-        }
-
-        /*
-         * Hold the spinlock so that we don't take an interrupt that
-         * changes tty between the time we fetch the port_info
-         * pointer and the time we paranoia check.
-         */
-        spin_lock_irqsave(&consolelock, flags);
-        pi = &port_info[port];
-
-        /*
-         * Change 05/01/2003 - Ryan Arnold: If a partition other than
-         * the current exclusive partition tries to send us data
-         * events then just drop them on the floor because we don't
-         * want his stinking data.  He isn't authorized to receive
-         * data because he wasn't the first one to get the console,
-         * therefore he shouldn't be allowed to send data either.
-         * This will work without an iSeries fix.
-         */
-        if (pi->lp != event->xSourceLp) {
-                spin_unlock_irqrestore(&consolelock, flags);
-                return;
-        }
-
-        tty = pi->tty;
-        if (tty == NULL) {
-                spin_unlock_irqrestore(&consolelock, flags);
-                printk(VIOCONS_KERN_WARN "no tty for virtual device %d\n",
-                                port);
-                return;
-        }
-
-        if (tty->magic != TTY_MAGIC) {
-                spin_unlock_irqrestore(&consolelock, flags);
-                printk(VIOCONS_KERN_WARN "tty bad magic\n");
-                return;
-        }
-
-        /*
-         * Just to be paranoid, make sure the tty points back to this port
-         */
-        pi = (struct port_info *)tty->driver_data;
-        if (!pi || viotty_paranoia_check(pi, tty->name, "vioHandleData")) {
-                spin_unlock_irqrestore(&consolelock, flags);
-                return;
-        }
-        spin_unlock_irqrestore(&consolelock, flags);
-
-        /*
-         * Change 07/21/2003 - Ryan Arnold: functionality added to
-         * support sysrq utilizing ^O as the sysrq key.  The sysrq
-         * functionality will only work if built into the kernel and
-         * then only if sysrq is enabled through the proc filesystem.
-         */
-        num_pushed = 0;
-        for (index = 0; index < cevent->len; index++) {
-                /*
-                 * Will be optimized away if !CONFIG_MAGIC_SYSRQ:
-                 */
-                if (sysrq_on()) {
-                        /* 0x0f is the ascii character for ^O */
-                        if (cevent->data[index] == '\x0f') {
-                                vio_sysrq_pressed = 1;
-                                /*
-                                 * continue because we don't want to add
-                                 * the sysrq key into the data string.
-                                 */
-                                continue;
-                        } else if (vio_sysrq_pressed) {
-                                handle_sysrq(cevent->data[index], tty);
-                                vio_sysrq_pressed = 0;
-                                /*
-                                 * continue because we don't want to add
-                                 * the sysrq sequence into the data string.
-                                 */
-                                continue;
-                        }
-                }
-                /*
-                 * The sysrq sequence isn't included in this check if
-                 * sysrq is enabled and compiled into the kernel because
-                 * the sequence will never get inserted into the buffer.
-                 * Don't attempt to copy more data into the buffer than we
-                 * have room for because it would fail without indication.
-                 */
-                if(tty_insert_flip_char(tty, cevent->data[index], TTY_NORMAL) == 0) {
-                        printk(VIOCONS_KERN_WARN "input buffer overflow!\n");
-                        break;
-                }
-                num_pushed++;
-        }
-
-        if (num_pushed)
-                tty_flip_buffer_push(tty);
-}
-
-/*
- * Handle an ack charLpEvent. 
- */
-static void vioHandleAck(struct HvLpEvent *event)
-{
-        struct viocharlpevent *cevent = (struct viocharlpevent *)event;
-        unsigned long flags;
-        u8 port = cevent->virtual_device;
-
-        if (port >= VTTY_PORTS) {
-                printk(VIOCONS_KERN_WARN "data on invalid virtual device\n");
-                return;
-        }
-
-        spin_lock_irqsave(&consolelock, flags);
-        port_info[port].ack = event->xCorrelationToken;
-        spin_unlock_irqrestore(&consolelock, flags);
-
-        if (port_info[port].used)
-                send_buffers(&port_info[port]);
-}
-
-/*
- * Handle charLpEvents and route to the appropriate routine
- */
-static void vioHandleCharEvent(struct HvLpEvent *event)
-{
-        int charminor;
-
-        if (event == NULL)
-                return;
-
-        charminor = event->xSubtype & VIOMINOR_SUBTYPE_MASK;
-        switch (charminor) {
-        case viocharopen:
-                vioHandleOpenEvent(event);
-                break;
-        case viocharclose:
-                vioHandleCloseEvent(event);
-                break;
-        case viochardata:
-                vioHandleData(event);
-                break;
-        case viocharack:
-                vioHandleAck(event);
-                break;
-        case viocharconfig:
-                vioHandleConfig(event);
-                break;
-        default:
-                if (hvlpevent_is_int(event) && hvlpevent_need_ack(event)) {
-                        event->xRc = HvLpEvent_Rc_InvalidSubtype;
-                        HvCallEvent_ackLpEvent(event);
-                }
-        }
-}
-
-/*
- * Send an open event
- */
-static int send_open(HvLpIndex remoteLp, void *sem)
-{
-        return HvCallEvent_signalLpEventFast(remoteLp,
-                        HvLpEvent_Type_VirtualIo,
-                        viomajorsubtype_chario | viocharopen,
-                        HvLpEvent_AckInd_DoAck, HvLpEvent_AckType_ImmediateAck,
-                        viopath_sourceinst(remoteLp),
-                        viopath_targetinst(remoteLp),
-                        (u64)(unsigned long)sem, VIOVERSION << 16,
-                        0, 0, 0, 0);
-}
-
-static const struct tty_operations serial_ops = {
-        .open = viotty_open,
-        .close = viotty_close,
-        .write = viotty_write,
-        .put_char = viotty_put_char,
-        .write_room = viotty_write_room,
-        .chars_in_buffer = viotty_chars_in_buffer,
-        .ioctl = viotty_ioctl,
-};
-
-static int __init viocons_init2(void)
-{
-        atomic_t wait_flag;
-        int rc;
-
-        if (!firmware_has_feature(FW_FEATURE_ISERIES))
-                return -ENODEV;
-
-        /* +2 for fudge */
-        rc = viopath_open(HvLpConfig_getPrimaryLpIndex(),
-                        viomajorsubtype_chario, VIOCHAR_WINDOW + 2);
-        if (rc)
-                printk(VIOCONS_KERN_WARN "error opening to primary %d\n", rc);
-
-        if (viopath_hostLp == HvLpIndexInvalid)
-                vio_set_hostlp();
-
-        /*
-         * And if the primary is not the same as the hosting LP, open to the 
-         * hosting lp
-         */
-        if ((viopath_hostLp != HvLpIndexInvalid) &&
-            (viopath_hostLp != HvLpConfig_getPrimaryLpIndex())) {
-                printk(VIOCONS_KERN_INFO "open path to hosting (%d)\n",
-                                viopath_hostLp);
-                rc = viopath_open(viopath_hostLp, viomajorsubtype_chario,
-                                VIOCHAR_WINDOW + 2);    /* +2 for fudge */
-                if (rc)
-                        printk(VIOCONS_KERN_WARN
-                                "error opening to partition %d: %d\n",
-                                viopath_hostLp, rc);
-        }
-
-        if (vio_setHandler(viomajorsubtype_chario, vioHandleCharEvent) < 0)
-                printk(VIOCONS_KERN_WARN
-                                "error seting handler for console events!\n");
-
-        /*
-         * First, try to open the console to the hosting lp.
-         * Wait on a semaphore for the response.
-         */
-        atomic_set(&wait_flag, 0);
-        if ((viopath_isactive(viopath_hostLp)) &&
-            (send_open(viopath_hostLp, (void *)&wait_flag) == 0)) {
-                printk(VIOCONS_KERN_INFO "hosting partition %d\n",
-                        viopath_hostLp);
-                while (atomic_read(&wait_flag) == 0)
-                        mb();
-                atomic_set(&wait_flag, 0);
-        }
-
-        /*
-         * If we don't have an active console, try the primary
-         */
-        if ((!viopath_isactive(port_info[0].lp)) &&
-            (viopath_isactive(HvLpConfig_getPrimaryLpIndex())) &&
-            (send_open(HvLpConfig_getPrimaryLpIndex(), (void *)&wait_flag)
-             == 0)) {
-                printk(VIOCONS_KERN_INFO "opening console to primary partition\n");
-                while (atomic_read(&wait_flag) == 0)
-                        mb();
-        }
-
-        /* Initialize the tty_driver structure */
-        viotty_driver = alloc_tty_driver(VTTY_PORTS);
-        viotty_driver->owner = THIS_MODULE;
-        viotty_driver->driver_name = "vioconsole";
-        viotty_driver->name = "tty";
-        viotty_driver->name_base = 1;
-        viotty_driver->major = TTY_MAJOR;
-        viotty_driver->minor_start = 1;
-        viotty_driver->type = TTY_DRIVER_TYPE_CONSOLE;
-        viotty_driver->subtype = 1;
-        viotty_driver->init_termios = tty_std_termios;
-        viotty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_RESET_TERMIOS;
-        tty_set_operations(viotty_driver, &serial_ops);
-
-        if (tty_register_driver(viotty_driver)) {
-                printk(VIOCONS_KERN_WARN "couldn't register console driver\n");
-                put_tty_driver(viotty_driver);
-                viotty_driver = NULL;
-        }
-
-        unregister_console(&viocons_early);
-        register_console(&viocons);
-
-        return 0;
-}
-
-static int __init viocons_init(void)
-{
-        int i;
-
-        if (!firmware_has_feature(FW_FEATURE_ISERIES))
-                return -ENODEV;
-
-        printk(VIOCONS_KERN_INFO "registering console\n");
-        for (i = 0; i < VTTY_PORTS; i++) {
-                port_info[i].lp = HvLpIndexInvalid;
-                port_info[i].magic = VIOTTY_MAGIC;
-        }
-        HvCall_setLogBufferFormatAndCodepage(HvCall_LogBuffer_ASCII, 437);
-        add_preferred_console("viocons", 0, NULL);
-        register_console(&viocons_early);
-        return 0;
-}
-
-console_initcall(viocons_init);
-module_init(viocons_init2);
diff --git a/drivers/firewire/fw-cdev.c b/drivers/firewire/fw-cdev.c
index bc81d6fcd2fd..2e6d5848d217 100644
--- a/drivers/firewire/fw-cdev.c
+++ b/drivers/firewire/fw-cdev.c
@@ -369,22 +369,33 @@ complete_transaction(struct fw_card *card, int rcode,
         struct response *response = data;
         struct client *client = response->client;
         unsigned long flags;
+        struct fw_cdev_event_response *r = &response->response;
 
-        if (length < response->response.length)
-                response->response.length = length;
+        if (length < r->length)
+                r->length = length;
         if (rcode == RCODE_COMPLETE)
-                memcpy(response->response.data, payload,
-                       response->response.length);
+                memcpy(r->data, payload, r->length);
 
         spin_lock_irqsave(&client->lock, flags);
         list_del(&response->resource.link);
         spin_unlock_irqrestore(&client->lock, flags);
 
-        response->response.type   = FW_CDEV_EVENT_RESPONSE;
-        response->response.rcode  = rcode;
-        queue_event(client, &response->event, &response->response,
-                    sizeof(response->response) + response->response.length,
-                    NULL, 0);
+        r->type   = FW_CDEV_EVENT_RESPONSE;
+        r->rcode  = rcode;
+
+        /*
+         * In the case that sizeof(*r) doesn't align with the position of the
+         * data, and the read is short, preserve an extra copy of the data
+         * to stay compatible with a pre-2.6.27 bug.  Since the bug is harmless
+         * for short reads and some apps depended on it, this is both safe
+         * and prudent for compatibility.
+         */
+        if (r->length <= sizeof(*r) - offsetof(typeof(*r), data))
+                queue_event(client, &response->event, r, sizeof(*r),
+                            r->data, r->length);
+        else
+                queue_event(client, &response->event, r, sizeof(*r) + r->length,
+                            NULL, 0);
 }
 
 static int ioctl_send_request(struct client *client, void *buffer)
diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
index c882fd05cf29..bf4ebfb86fa5 100644
--- a/drivers/hwmon/Kconfig
+++ b/drivers/hwmon/Kconfig
@@ -57,6 +57,16 @@ config SENSORS_ABITUGURU3
           This driver can also be built as a module.  If so, the module
           will be called abituguru3.
 
+config SENSORS_AD7414
+        tristate "Analog Devices AD7414"
+        depends on I2C && EXPERIMENTAL
+        help
+          If you say yes here you get support for the Analog Devices
+          AD7414 temperature monitoring chip.
+
+          This driver can also be built as a module. If so, the module
+          will be called ad7414.
+
 config SENSORS_AD7418
         tristate "Analog Devices AD7416, AD7417 and AD7418"
         depends on I2C && EXPERIMENTAL
@@ -124,7 +134,7 @@ config SENSORS_ADM1031
 
 config SENSORS_ADM9240
         tristate "Analog Devices ADM9240 and compatibles"
-        depends on I2C && EXPERIMENTAL
+        depends on I2C
         select HWMON_VID
         help
           If you say yes here you get support for Analog Devices ADM9240,
@@ -575,8 +585,8 @@ config SENSORS_DME1737
         select HWMON_VID
         help
           If you say yes here you get support for the hardware monitoring
-          and fan control features of the SMSC DME1737 (and compatibles
-          like the Asus A8000) and SCH311x Super-I/O chips.
+          and fan control features of the SMSC DME1737, SCH311x, SCH5027, and
+          Asus A8000 Super-I/O chips.
 
           This driver can also be built as a module.  If so, the module
           will be called dme1737.
diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
index d098677e08de..7943e5cefb06 100644
--- a/drivers/hwmon/Makefile
+++ b/drivers/hwmon/Makefile
@@ -15,6 +15,7 @@ obj-$(CONFIG_SENSORS_W83791D)	+= w83791d.o
 
 obj-$(CONFIG_SENSORS_ABITUGURU) += abituguru.o
 obj-$(CONFIG_SENSORS_ABITUGURU3)+= abituguru3.o
+obj-$(CONFIG_SENSORS_AD7414)    += ad7414.o
 obj-$(CONFIG_SENSORS_AD7418)    += ad7418.o
 obj-$(CONFIG_SENSORS_ADM1021)   += adm1021.o
 obj-$(CONFIG_SENSORS_ADM1025)   += adm1025.o
diff --git a/drivers/hwmon/ad7414.c b/drivers/hwmon/ad7414.c
new file mode 100644
index 000000000000..ce8d94fbfd7e
--- /dev/null
+++ b/drivers/hwmon/ad7414.c
@@ -0,0 +1,268 @@
+/*
+ * An hwmon driver for the Analog Devices AD7414
+ *
+ * Copyright 2006 Stefan Roese <sr at denx.de>, DENX Software Engineering
+ *
+ * Copyright (c) 2008 PIKA Technologies
+ *   Sean MacLennan <smaclennan@pikatech.com>
+ *
+ * Copyright (c) 2008 Spansion Inc.
+ *   Frank Edelhaeuser <frank.edelhaeuser at spansion.com>
+ *   (converted to "new style" I2C driver model, removed checkpatch.pl warnings)
+ *
+ * Based on ad7418.c
+ * Copyright 2006 Tower Technologies, Alessandro Zummo <a.zummo at towertech.it>
+ *
+ * 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.
+ */
+
+#include <linux/module.h>
+#include <linux/jiffies.h>
+#include <linux/i2c.h>
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
+#include <linux/err.h>
+#include <linux/mutex.h>
+#include <linux/sysfs.h>
+
+
+/* AD7414 registers */
+#define AD7414_REG_TEMP         0x00
+#define AD7414_REG_CONF         0x01
+#define AD7414_REG_T_HIGH       0x02
+#define AD7414_REG_T_LOW        0x03
+
+static u8 AD7414_REG_LIMIT[] = { AD7414_REG_T_HIGH, AD7414_REG_T_LOW };
+
+struct ad7414_data {
+        struct device           *hwmon_dev;
+        struct mutex            lock;   /* atomic read data updates */
+        char                    valid;  /* !=0 if following fields are valid */
+        unsigned long           next_update;    /* In jiffies */
+        s16                     temp_input;     /* Register values */
+        s8                      temps[ARRAY_SIZE(AD7414_REG_LIMIT)];
+};
+
+/* REG: (0.25C/bit, two's complement) << 6 */
+static inline int ad7414_temp_from_reg(s16 reg)
+{
+        /* use integer division instead of equivalent right shift to
+         * guarantee arithmetic shift and preserve the sign
+         */
+        return ((int)reg / 64) * 250;
+}
+
+static inline int ad7414_read(struct i2c_client *client, u8 reg)
+{
+        if (reg == AD7414_REG_TEMP) {
+                int value = i2c_smbus_read_word_data(client, reg);
+                return (value < 0) ? value : swab16(value);
+        } else
+                return i2c_smbus_read_byte_data(client, reg);
+}
+
+static inline int ad7414_write(struct i2c_client *client, u8 reg, u8 value)
+{
+        return i2c_smbus_write_byte_data(client, reg, value);
+}
+
+struct ad7414_data *ad7414_update_device(struct device *dev)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct ad7414_data *data = i2c_get_clientdata(client);
+
+        mutex_lock(&data->lock);
+
+        if (time_after(jiffies, data->next_update) || !data->valid) {
+                int value, i;
+
+                dev_dbg(&client->dev, "starting ad7414 update\n");
+
+                value = ad7414_read(client, AD7414_REG_TEMP);
+                if (value < 0)
+                        dev_dbg(&client->dev, "AD7414_REG_TEMP err %d\n",
+                                value);
+                else
+                        data->temp_input = value;
+
+                for (i = 0; i < ARRAY_SIZE(AD7414_REG_LIMIT); ++i) {
+                        value = ad7414_read(client, AD7414_REG_LIMIT[i]);
+                        if (value < 0)
+                                dev_dbg(&client->dev, "AD7414 reg %d err %d\n",
+                                        AD7414_REG_LIMIT[i], value);
+                        else
+                                data->temps[i] = value;
+                }
+
+                data->next_update = jiffies + HZ + HZ / 2;
+                data->valid = 1;
+        }
+
+        mutex_unlock(&data->lock);
+
+        return data;
+}
+
+static ssize_t show_temp_input(struct device *dev,
+                               struct device_attribute *attr, char *buf)
+{
+        struct ad7414_data *data = ad7414_update_device(dev);
+        return sprintf(buf, "%d\n", ad7414_temp_from_reg(data->temp_input));
+}
+static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp_input, NULL, 0);
+
+static ssize_t show_max_min(struct device *dev, struct device_attribute *attr,
+                          char *buf)
+{
+        int index = to_sensor_dev_attr(attr)->index;
+        struct ad7414_data *data = ad7414_update_device(dev);
+        return sprintf(buf, "%d\n", data->temps[index] * 1000);
+}
+
+static ssize_t set_max_min(struct device *dev,
+                           struct device_attribute *attr,
+                           const char *buf, size_t count)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct ad7414_data *data = i2c_get_clientdata(client);
+        int index = to_sensor_dev_attr(attr)->index;
+        u8 reg = AD7414_REG_LIMIT[index];
+        long temp = simple_strtol(buf, NULL, 10);
+
+        temp = SENSORS_LIMIT(temp, -40000, 85000);
+        temp = (temp + (temp < 0 ? -500 : 500)) / 1000;
+
+        mutex_lock(&data->lock);
+        data->temps[index] = temp;
+        ad7414_write(client, reg, temp);
+        mutex_unlock(&data->lock);
+        return count;
+}
+
+static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO,
+                          show_max_min, set_max_min, 0);
+static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO,
+                          show_max_min, set_max_min, 1);
+
+static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
+                          char *buf)
+{
+        int bitnr = to_sensor_dev_attr(attr)->index;
+        struct ad7414_data *data = ad7414_update_device(dev);
+        int value = (data->temp_input >> bitnr) & 1;
+        return sprintf(buf, "%d\n", value);
+}
+
+static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 3);
+static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 4);
+
+static struct attribute *ad7414_attributes[] = {
+        &sensor_dev_attr_temp1_input.dev_attr.attr,
+        &sensor_dev_attr_temp1_max.dev_attr.attr,
+        &sensor_dev_attr_temp1_min.dev_attr.attr,
+        &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
+        NULL
+};
+
+static const struct attribute_group ad7414_group = {
+        .attrs = ad7414_attributes,
+};
+
+static int ad7414_probe(struct i2c_client *client,
+                        const struct i2c_device_id *dev_id)
+{
+        struct ad7414_data *data;
+        int conf;
+        int err = 0;
+
+        if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA |
+                                     I2C_FUNC_SMBUS_READ_WORD_DATA))
+                goto exit;
+
+        data = kzalloc(sizeof(struct ad7414_data), GFP_KERNEL);
+        if (!data) {
+                err = -ENOMEM;
+                goto exit;
+        }
+
+        i2c_set_clientdata(client, data);
+        mutex_init(&data->lock);
+
+        dev_info(&client->dev, "chip found\n");
+
+        /* Make sure the chip is powered up. */
+        conf = i2c_smbus_read_byte_data(client, AD7414_REG_CONF);
+        if (conf < 0)
+                dev_warn(&client->dev,
+                         "ad7414_probe unable to read config register.\n");
+        else {
+                conf &= ~(1 << 7);
+                i2c_smbus_write_byte_data(client, AD7414_REG_CONF, conf);
+        }
+
+        /* Register sysfs hooks */
+        err = sysfs_create_group(&client->dev.kobj, &ad7414_group);
+        if (err)
+                goto exit_free;
+
+        data->hwmon_dev = hwmon_device_register(&client->dev);
+        if (IS_ERR(data->hwmon_dev)) {
+                err = PTR_ERR(data->hwmon_dev);
+                goto exit_remove;
+        }
+
+        return 0;
+
+exit_remove:
+        sysfs_remove_group(&client->dev.kobj, &ad7414_group);
+exit_free:
+        kfree(data);
+exit:
+        return err;
+}
+
+static int __devexit ad7414_remove(struct i2c_client *client)
+{
+        struct ad7414_data *data = i2c_get_clientdata(client);
+
+        hwmon_device_unregister(data->hwmon_dev);
+        sysfs_remove_group(&client->dev.kobj, &ad7414_group);
+        kfree(data);
+        return 0;
+}
+
+static const struct i2c_device_id ad7414_id[] = {
+        { "ad7414", 0 },
+        {}
+};
+
+static struct i2c_driver ad7414_driver = {
+        .driver = {
+                .name   = "ad7414",
+        },
+        .probe  = ad7414_probe,
+        .remove = __devexit_p(ad7414_remove),
+        .id_table = ad7414_id,
+};
+
+static int __init ad7414_init(void)
+{
+        return i2c_add_driver(&ad7414_driver);
+}
+module_init(ad7414_init);
+
+static void __exit ad7414_exit(void)
+{
+        i2c_del_driver(&ad7414_driver);
+}
+module_exit(ad7414_exit);
+
+MODULE_AUTHOR("Stefan Roese <sr at denx.de>, "
+              "Frank Edelhaeuser <frank.edelhaeuser at spansion.com>");
+
+MODULE_DESCRIPTION("AD7414 driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/hwmon/dme1737.c b/drivers/hwmon/dme1737.c
index 5e2cf0aef480..cdb8311e4ef7 100644
--- a/drivers/hwmon/dme1737.c
+++ b/drivers/hwmon/dme1737.c
@@ -1,11 +1,11 @@
 /*
- * dme1737.c - Driver for the SMSC DME1737, Asus A8000, and SMSC SCH311x
- *             Super-I/O chips integrated hardware monitoring features.
- * Copyright (c) 2007 Juerg Haefliger <juergh@gmail.com>
+ * dme1737.c - Driver for the SMSC DME1737, Asus A8000, SMSC SCH311x and
+ *             SCH5027 Super-I/O chips integrated hardware monitoring features.
+ * Copyright (c) 2007, 2008 Juerg Haefliger <juergh@gmail.com>
  *
  * This driver is an I2C/ISA hybrid, meaning that it uses the I2C bus to access
- * the chip registers if a DME1737 (or A8000) is found and the ISA bus if a
- * SCH311x chip is found. Both types of chips have very similar hardware
+ * the chip registers if a DME1737, A8000, or SCH5027 is found and the ISA bus
+ * if a SCH311x chip is found. Both types of chips have very similar hardware
  * monitoring capabilities but differ in the way they can be accessed.
  *
  * This program is free software; you can redistribute it and/or modify
@@ -57,7 +57,10 @@ MODULE_PARM_DESC(probe_all_addr, "Include probing of non-standard LPC "
 static const unsigned short normal_i2c[] = {0x2c, 0x2d, 0x2e, I2C_CLIENT_END};
 
 /* Insmod parameters */
-I2C_CLIENT_INSMOD_1(dme1737);
+I2C_CLIENT_INSMOD_2(dme1737, sch5027);
+
+/* ISA chip types */
+enum isa_chips { sch311x = sch5027 + 1 };
 
 /* ---------------------------------------------------------------------
  * Registers
@@ -163,6 +166,7 @@ static const u8 DME1737_BIT_ALARM_FAN[] = {10, 11, 12, 13, 22, 23};
 #define DME1737_VERSTEP         0x88
 #define DME1737_VERSTEP_MASK    0xf8
 #define SCH311X_DEVICE          0x8c
+#define SCH5027_VERSTEP         0x69
 
 /* Length of ISA address segment */
 #define DME1737_EXTENT  2
@@ -182,6 +186,7 @@ struct dme1737_data {
         unsigned long last_update;      /* in jiffies */
         unsigned long last_vbat;        /* in jiffies */
         enum chips type;
+        const int *in_nominal;          /* pointer to IN_NOMINAL array */
 
         u8 vid;
         u8 pwm_rr_en;
@@ -220,23 +225,23 @@ static const int IN_NOMINAL_DME1737[] = {5000, 2250, 3300, 5000, 12000, 3300,
                                          3300};
 static const int IN_NOMINAL_SCH311x[] = {2500, 1500, 3300, 5000, 12000, 3300,
                                          3300};
-#define IN_NOMINAL(ix, type)    (((type) == dme1737) ? \
-                                IN_NOMINAL_DME1737[(ix)] : \
-                                IN_NOMINAL_SCH311x[(ix)])
+static const int IN_NOMINAL_SCH5027[] = {5000, 2250, 3300, 1125, 1125, 3300,
+                                         3300};
+#define IN_NOMINAL(type)        ((type) == sch311x ? IN_NOMINAL_SCH311x : \
+                                 (type) == sch5027 ? IN_NOMINAL_SCH5027 : \
+                                 IN_NOMINAL_DME1737)
 
 /* Voltage input
  * Voltage inputs have 16 bits resolution, limit values have 8 bits
  * resolution. */
-static inline int IN_FROM_REG(int reg, int ix, int res, int type)
+static inline int IN_FROM_REG(int reg, int nominal, int res)
 {
-        return (reg * IN_NOMINAL(ix, type) + (3 << (res - 3))) /
-                (3 << (res - 2));
+        return (reg * nominal + (3 << (res - 3))) / (3 << (res - 2));
 }
 
-static inline int IN_TO_REG(int val, int ix, int type)
+static inline int IN_TO_REG(int val, int nominal)
 {
-        return SENSORS_LIMIT((val * 192 + IN_NOMINAL(ix, type) / 2) /
-                             IN_NOMINAL(ix, type), 0, 255);
+        return SENSORS_LIMIT((val * 192 + nominal / 2) / nominal, 0, 255);
 }
 
 /* Temperature input
@@ -565,7 +570,10 @@ static struct dme1737_data *dme1737_update_device(struct device *dev)
 
         /* Sample register contents every 1 sec */
         if (time_after(jiffies, data->last_update + HZ) || !data->valid) {
-                data->vid = dme1737_read(client, DME1737_REG_VID) & 0x3f;
+                if (data->type != sch5027) {
+                        data->vid = dme1737_read(client, DME1737_REG_VID) &
+                                0x3f;
+                }
 
                 /* In (voltage) registers */
                 for (ix = 0; ix < ARRAY_SIZE(data->in); ix++) {
@@ -593,8 +601,10 @@ static struct dme1737_data *dme1737_update_device(struct device *dev)
                                         DME1737_REG_TEMP_MIN(ix));
                         data->temp_max[ix] = dme1737_read(client,
                                         DME1737_REG_TEMP_MAX(ix));
-                        data->temp_offset[ix] = dme1737_read(client,
-                                        DME1737_REG_TEMP_OFFSET(ix));
+                        if (data->type != sch5027) {
+                                data->temp_offset[ix] = dme1737_read(client,
+                                                DME1737_REG_TEMP_OFFSET(ix));
+                        }
                 }
 
                 /* In and temp LSB registers
@@ -669,9 +679,11 @@ static struct dme1737_data *dme1737_update_device(struct device *dev)
                         data->zone_abs[ix] = dme1737_read(client,
                                         DME1737_REG_ZONE_ABS(ix));
                 }
-                for (ix = 0; ix < ARRAY_SIZE(data->zone_hyst); ix++) {
-                        data->zone_hyst[ix] = dme1737_read(client,
+                if (data->type != sch5027) {
+                        for (ix = 0; ix < ARRAY_SIZE(data->zone_hyst); ix++) {
+                                data->zone_hyst[ix] = dme1737_read(client,
                                                 DME1737_REG_ZONE_HYST(ix));
+                        }
                 }
 
                 /* Alarm registers */
@@ -735,13 +747,13 @@ static ssize_t show_in(struct device *dev, struct device_attribute *attr,
 
         switch (fn) {
         case SYS_IN_INPUT:
-                res = IN_FROM_REG(data->in[ix], ix, 16, data->type);
+                res = IN_FROM_REG(data->in[ix], data->in_nominal[ix], 16);
                 break;
         case SYS_IN_MIN:
-                res = IN_FROM_REG(data->in_min[ix], ix, 8, data->type);
+                res = IN_FROM_REG(data->in_min[ix], data->in_nominal[ix], 8);
                 break;
         case SYS_IN_MAX:
-                res = IN_FROM_REG(data->in_max[ix], ix, 8, data->type);
+                res = IN_FROM_REG(data->in_max[ix], data->in_nominal[ix], 8);
                 break;
         case SYS_IN_ALARM:
                 res = (data->alarms >> DME1737_BIT_ALARM_IN[ix]) & 0x01;
@@ -768,12 +780,12 @@ static ssize_t set_in(struct device *dev, struct device_attribute *attr,
         mutex_lock(&data->update_lock);
         switch (fn) {
         case SYS_IN_MIN:
-                data->in_min[ix] = IN_TO_REG(val, ix, data->type);
+                data->in_min[ix] = IN_TO_REG(val, data->in_nominal[ix]);
                 dme1737_write(client, DME1737_REG_IN_MIN(ix),
                               data->in_min[ix]);
                 break;
         case SYS_IN_MAX:
-                data->in_max[ix] = IN_TO_REG(val, ix, data->type);
+                data->in_max[ix] = IN_TO_REG(val, data->in_nominal[ix]);
                 dme1737_write(client, DME1737_REG_IN_MAX(ix),
                               data->in_max[ix]);
                 break;
@@ -1166,7 +1178,7 @@ static ssize_t show_pwm(struct device *dev, struct device_attribute *attr,
         return sprintf(buf, "%d\n", res);
 }
 
-static struct attribute *dme1737_attr_pwm[];
+static struct attribute *dme1737_pwm_chmod_attr[];
 static void dme1737_chmod_file(struct device*, struct attribute*, mode_t);
 
 static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
@@ -1230,7 +1242,7 @@ static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
                 switch (val) {
                 case 0:
                         /* Change permissions of pwm[ix] to read-only */
-                        dme1737_chmod_file(dev, dme1737_attr_pwm[ix],
+                        dme1737_chmod_file(dev, dme1737_pwm_chmod_attr[ix],
                                            S_IRUGO);
                         /* Turn fan fully on */
                         data->pwm_config[ix] = PWM_EN_TO_REG(0,
@@ -1245,12 +1257,12 @@ static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
                         dme1737_write(client, DME1737_REG_PWM_CONFIG(ix),
                                       data->pwm_config[ix]);
                         /* Change permissions of pwm[ix] to read-writeable */
-                        dme1737_chmod_file(dev, dme1737_attr_pwm[ix],
+                        dme1737_chmod_file(dev, dme1737_pwm_chmod_attr[ix],
                                            S_IRUGO | S_IWUSR);
                         break;
                 case 2:
                         /* Change permissions of pwm[ix] to read-only */
-                        dme1737_chmod_file(dev, dme1737_attr_pwm[ix],
+                        dme1737_chmod_file(dev, dme1737_pwm_chmod_attr[ix],
                                            S_IRUGO);
                         /* Turn on auto mode using the saved zone channel
                          * assignment */
@@ -1570,88 +1582,98 @@ static struct attribute *dme1737_attr[] ={
         &sensor_dev_attr_temp1_max.dev_attr.attr,
         &sensor_dev_attr_temp1_alarm.dev_attr.attr,
         &sensor_dev_attr_temp1_fault.dev_attr.attr,
-        &sensor_dev_attr_temp1_offset.dev_attr.attr,
         &sensor_dev_attr_temp2_input.dev_attr.attr,
         &sensor_dev_attr_temp2_min.dev_attr.attr,
         &sensor_dev_attr_temp2_max.dev_attr.attr,
         &sensor_dev_attr_temp2_alarm.dev_attr.attr,
         &sensor_dev_attr_temp2_fault.dev_attr.attr,
-        &sensor_dev_attr_temp2_offset.dev_attr.attr,
         &sensor_dev_attr_temp3_input.dev_attr.attr,
         &sensor_dev_attr_temp3_min.dev_attr.attr,
         &sensor_dev_attr_temp3_max.dev_attr.attr,
         &sensor_dev_attr_temp3_alarm.dev_attr.attr,
         &sensor_dev_attr_temp3_fault.dev_attr.attr,
-        &sensor_dev_attr_temp3_offset.dev_attr.attr,
         /* Zones */
-        &sensor_dev_attr_zone1_auto_point1_temp_hyst.dev_attr.attr,
         &sensor_dev_attr_zone1_auto_point1_temp.dev_attr.attr,
         &sensor_dev_attr_zone1_auto_point2_temp.dev_attr.attr,
         &sensor_dev_attr_zone1_auto_point3_temp.dev_attr.attr,
         &sensor_dev_attr_zone1_auto_channels_temp.dev_attr.attr,
-        &sensor_dev_attr_zone2_auto_point1_temp_hyst.dev_attr.attr,
         &sensor_dev_attr_zone2_auto_point1_temp.dev_attr.attr,
         &sensor_dev_attr_zone2_auto_point2_temp.dev_attr.attr,
         &sensor_dev_attr_zone2_auto_point3_temp.dev_attr.attr,
         &sensor_dev_attr_zone2_auto_channels_temp.dev_attr.attr,
-        &sensor_dev_attr_zone3_auto_point1_temp_hyst.dev_attr.attr,
         &sensor_dev_attr_zone3_auto_point1_temp.dev_attr.attr,
         &sensor_dev_attr_zone3_auto_point2_temp.dev_attr.attr,
         &sensor_dev_attr_zone3_auto_point3_temp.dev_attr.attr,
         &sensor_dev_attr_zone3_auto_channels_temp.dev_attr.attr,
+        NULL
+};
+
+static const struct attribute_group dme1737_group = {
+        .attrs = dme1737_attr,
+};
+
+/* The following struct holds misc attributes, which are not available in all
+ * chips. Their creation depends on the chip type which is determined during
+ * module load. */
+static struct attribute *dme1737_misc_attr[] = {
+        /* Temperatures */
+        &sensor_dev_attr_temp1_offset.dev_attr.attr,
+        &sensor_dev_attr_temp2_offset.dev_attr.attr,
+        &sensor_dev_attr_temp3_offset.dev_attr.attr,
+        /* Zones */
+        &sensor_dev_attr_zone1_auto_point1_temp_hyst.dev_attr.attr,
+        &sensor_dev_attr_zone2_auto_point1_temp_hyst.dev_attr.attr,
+        &sensor_dev_attr_zone3_auto_point1_temp_hyst.dev_attr.attr,
         /* Misc */
         &dev_attr_vrm.attr,
         &dev_attr_cpu0_vid.attr,
         NULL
 };
 
-static const struct attribute_group dme1737_group = {
-        .attrs = dme1737_attr,
+static const struct attribute_group dme1737_misc_group = {
+        .attrs = dme1737_misc_attr,
 };
 
 /* The following structs hold the PWM attributes, some of which are optional.
  * Their creation depends on the chip configuration which is determined during
  * module load. */
-static struct attribute *dme1737_attr_pwm1[] = {
+static struct attribute *dme1737_pwm1_attr[] = {
         &sensor_dev_attr_pwm1.dev_attr.attr,
         &sensor_dev_attr_pwm1_freq.dev_attr.attr,
         &sensor_dev_attr_pwm1_enable.dev_attr.attr,
         &sensor_dev_attr_pwm1_ramp_rate.dev_attr.attr,
         &sensor_dev_attr_pwm1_auto_channels_zone.dev_attr.attr,
-        &sensor_dev_attr_pwm1_auto_pwm_min.dev_attr.attr,
         &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
         &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
         NULL
 };
-static struct attribute *dme1737_attr_pwm2[] = {
+static struct attribute *dme1737_pwm2_attr[] = {
         &sensor_dev_attr_pwm2.dev_attr.attr,
         &sensor_dev_attr_pwm2_freq.dev_attr.attr,
         &sensor_dev_attr_pwm2_enable.dev_attr.attr,
         &sensor_dev_attr_pwm2_ramp_rate.dev_attr.attr,
         &sensor_dev_attr_pwm2_auto_channels_zone.dev_attr.attr,
-        &sensor_dev_attr_pwm2_auto_pwm_min.dev_attr.attr,
         &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr,
         &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr,
         NULL
 };
-static struct attribute *dme1737_attr_pwm3[] = {
+static struct attribute *dme1737_pwm3_attr[] = {
         &sensor_dev_attr_pwm3.dev_attr.attr,
         &sensor_dev_attr_pwm3_freq.dev_attr.attr,
         &sensor_dev_attr_pwm3_enable.dev_attr.attr,
         &sensor_dev_attr_pwm3_ramp_rate.dev_attr.attr,
         &sensor_dev_attr_pwm3_auto_channels_zone.dev_attr.attr,
-        &sensor_dev_attr_pwm3_auto_pwm_min.dev_attr.attr,
         &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr,
         &sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr,
         NULL
 };
-static struct attribute *dme1737_attr_pwm5[] = {
+static struct attribute *dme1737_pwm5_attr[] = {
         &sensor_dev_attr_pwm5.dev_attr.attr,
         &sensor_dev_attr_pwm5_freq.dev_attr.attr,
         &sensor_dev_attr_pwm5_enable.dev_attr.attr,
         NULL
 };
-static struct attribute *dme1737_attr_pwm6[] = {
+static struct attribute *dme1737_pwm6_attr[] = {
         &sensor_dev_attr_pwm6.dev_attr.attr,
         &sensor_dev_attr_pwm6_freq.dev_attr.attr,
         &sensor_dev_attr_pwm6_enable.dev_attr.attr,
@@ -1659,53 +1681,62 @@ static struct attribute *dme1737_attr_pwm6[] = {
 };
 
 static const struct attribute_group dme1737_pwm_group[] = {
-        { .attrs = dme1737_attr_pwm1 },
-        { .attrs = dme1737_attr_pwm2 },
-        { .attrs = dme1737_attr_pwm3 },
+        { .attrs = dme1737_pwm1_attr },
+        { .attrs = dme1737_pwm2_attr },
+        { .attrs = dme1737_pwm3_attr },
         { .attrs = NULL },
-        { .attrs = dme1737_attr_pwm5 },
-        { .attrs = dme1737_attr_pwm6 },
+        { .attrs = dme1737_pwm5_attr },
+        { .attrs = dme1737_pwm6_attr },
+};
+
+/* The following struct holds misc PWM attributes, which are not available in
+ * all chips. Their creation depends on the chip type which is determined
+ * during module load. */
+static struct attribute *dme1737_pwm_misc_attr[] = {
+        &sensor_dev_attr_pwm1_auto_pwm_min.dev_attr.attr,
+        &sensor_dev_attr_pwm2_auto_pwm_min.dev_attr.attr,
+        &sensor_dev_attr_pwm3_auto_pwm_min.dev_attr.attr,
 };
 
 /* The following structs hold the fan attributes, some of which are optional.
  * Their creation depends on the chip configuration which is determined during
  * module load. */
-static struct attribute *dme1737_attr_fan1[] = {
+static struct attribute *dme1737_fan1_attr[] = {
         &sensor_dev_attr_fan1_input.dev_attr.attr,
         &sensor_dev_attr_fan1_min.dev_attr.attr,
         &sensor_dev_attr_fan1_alarm.dev_attr.attr,
         &sensor_dev_attr_fan1_type.dev_attr.attr,
         NULL
 };
-static struct attribute *dme1737_attr_fan2[] = {
+static struct attribute *dme1737_fan2_attr[] = {
         &sensor_dev_attr_fan2_input.dev_attr.attr,
         &sensor_dev_attr_fan2_min.dev_attr.attr,
         &sensor_dev_attr_fan2_alarm.dev_attr.attr,
         &sensor_dev_attr_fan2_type.dev_attr.attr,
         NULL
 };
-static struct attribute *dme1737_attr_fan3[] = {
+static struct attribute *dme1737_fan3_attr[] = {
         &sensor_dev_attr_fan3_input.dev_attr.attr,
         &sensor_dev_attr_fan3_min.dev_attr.attr,
         &sensor_dev_attr_fan3_alarm.dev_attr.attr,
         &sensor_dev_attr_fan3_type.dev_attr.attr,
         NULL
 };
-static struct attribute *dme1737_attr_fan4[] = {
+static struct attribute *dme1737_fan4_attr[] = {
         &sensor_dev_attr_fan4_input.dev_attr.attr,
         &sensor_dev_attr_fan4_min.dev_attr.attr,
         &sensor_dev_attr_fan4_alarm.dev_attr.attr,
         &sensor_dev_attr_fan4_type.dev_attr.attr,
         NULL
 };
-static struct attribute *dme1737_attr_fan5[] = {
+static struct attribute *dme1737_fan5_attr[] = {
         &sensor_dev_attr_fan5_input.dev_attr.attr,
         &sensor_dev_attr_fan5_min.dev_attr.attr,
         &sensor_dev_attr_fan5_alarm.dev_attr.attr,
         &sensor_dev_attr_fan5_max.dev_attr.attr,
         NULL
 };
-static struct attribute *dme1737_attr_fan6[] = {
+static struct attribute *dme1737_fan6_attr[] = {
         &sensor_dev_attr_fan6_input.dev_attr.attr,
         &sensor_dev_attr_fan6_min.dev_attr.attr,
         &sensor_dev_attr_fan6_alarm.dev_attr.attr,
@@ -1714,94 +1745,83 @@ static struct attribute *dme1737_attr_fan6[] = {
 };
 
 static const struct attribute_group dme1737_fan_group[] = {
-        { .attrs = dme1737_attr_fan1 },
-        { .attrs = dme1737_attr_fan2 },
-        { .attrs = dme1737_attr_fan3 },
-        { .attrs = dme1737_attr_fan4 },
-        { .attrs = dme1737_attr_fan5 },
-        { .attrs = dme1737_attr_fan6 },
+        { .attrs = dme1737_fan1_attr },
+        { .attrs = dme1737_fan2_attr },
+        { .attrs = dme1737_fan3_attr },
+        { .attrs = dme1737_fan4_attr },
+        { .attrs = dme1737_fan5_attr },
+        { .attrs = dme1737_fan6_attr },
 };
 
-/* The permissions of all of the following attributes are changed to read-
+/* The permissions of the following zone attributes are changed to read-
  * writeable if the chip is *not* locked. Otherwise they stay read-only. */
-static struct attribute *dme1737_attr_lock[] = {
-        /* Temperatures */
-        &sensor_dev_attr_temp1_offset.dev_attr.attr,
-        &sensor_dev_attr_temp2_offset.dev_attr.attr,
-        &sensor_dev_attr_temp3_offset.dev_attr.attr,
-        /* Zones */
-        &sensor_dev_attr_zone1_auto_point1_temp_hyst.dev_attr.attr,
+static struct attribute *dme1737_zone_chmod_attr[] = {
         &sensor_dev_attr_zone1_auto_point1_temp.dev_attr.attr,
         &sensor_dev_attr_zone1_auto_point2_temp.dev_attr.attr,
         &sensor_dev_attr_zone1_auto_point3_temp.dev_attr.attr,
-        &sensor_dev_attr_zone2_auto_point1_temp_hyst.dev_attr.attr,
         &sensor_dev_attr_zone2_auto_point1_temp.dev_attr.attr,
         &sensor_dev_attr_zone2_auto_point2_temp.dev_attr.attr,
         &sensor_dev_attr_zone2_auto_point3_temp.dev_attr.attr,
-        &sensor_dev_attr_zone3_auto_point1_temp_hyst.dev_attr.attr,
         &sensor_dev_attr_zone3_auto_point1_temp.dev_attr.attr,
         &sensor_dev_attr_zone3_auto_point2_temp.dev_attr.attr,
         &sensor_dev_attr_zone3_auto_point3_temp.dev_attr.attr,
         NULL
 };
 
-static const struct attribute_group dme1737_lock_group = {
-        .attrs = dme1737_attr_lock,
+static const struct attribute_group dme1737_zone_chmod_group = {
+        .attrs = dme1737_zone_chmod_attr,
 };
 
 /* The permissions of the following PWM attributes are changed to read-
  * writeable if the chip is *not* locked and the respective PWM is available.
  * Otherwise they stay read-only. */
-static struct attribute *dme1737_attr_pwm1_lock[] = {
+static struct attribute *dme1737_pwm1_chmod_attr[] = {
         &sensor_dev_attr_pwm1_freq.dev_attr.attr,
         &sensor_dev_attr_pwm1_enable.dev_attr.attr,
         &sensor_dev_attr_pwm1_ramp_rate.dev_attr.attr,
         &sensor_dev_attr_pwm1_auto_channels_zone.dev_attr.attr,
-        &sensor_dev_attr_pwm1_auto_pwm_min.dev_attr.attr,
         &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
         NULL
 };
-static struct attribute *dme1737_attr_pwm2_lock[] = {
+static struct attribute *dme1737_pwm2_chmod_attr[] = {
         &sensor_dev_attr_pwm2_freq.dev_attr.attr,
         &sensor_dev_attr_pwm2_enable.dev_attr.attr,
         &sensor_dev_attr_pwm2_ramp_rate.dev_attr.attr,
         &sensor_dev_attr_pwm2_auto_channels_zone.dev_attr.attr,
-        &sensor_dev_attr_pwm2_auto_pwm_min.dev_attr.attr,
         &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr,
         NULL
 };
-static struct attribute *dme1737_attr_pwm3_lock[] = {
+static struct attribute *dme1737_pwm3_chmod_attr[] = {
         &sensor_dev_attr_pwm3_freq.dev_attr.attr,
         &sensor_dev_attr_pwm3_enable.dev_attr.attr,
         &sensor_dev_attr_pwm3_ramp_rate.dev_attr.attr,
         &sensor_dev_attr_pwm3_auto_channels_zone.dev_attr.attr,
-        &sensor_dev_attr_pwm3_auto_pwm_min.dev_attr.attr,
         &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr,
         NULL
 };
-static struct attribute *dme1737_attr_pwm5_lock[] = {
+static struct attribute *dme1737_pwm5_chmod_attr[] = {
         &sensor_dev_attr_pwm5.dev_attr.attr,
         &sensor_dev_attr_pwm5_freq.dev_attr.attr,
         NULL
 };
-static struct attribute *dme1737_attr_pwm6_lock[] = {
+static struct attribute *dme1737_pwm6_chmod_attr[] = {
         &sensor_dev_attr_pwm6.dev_attr.attr,
         &sensor_dev_attr_pwm6_freq.dev_attr.attr,
         NULL
 };
 
-static const struct attribute_group dme1737_pwm_lock_group[] = {
-        { .attrs = dme1737_attr_pwm1_lock },
-        { .attrs = dme1737_attr_pwm2_lock },
-        { .attrs = dme1737_attr_pwm3_lock },
+static const struct attribute_group dme1737_pwm_chmod_group[] = {
+        { .attrs = dme1737_pwm1_chmod_attr },
+        { .attrs = dme1737_pwm2_chmod_attr },
+        { .attrs = dme1737_pwm3_chmod_attr },
         { .attrs = NULL },
-        { .attrs = dme1737_attr_pwm5_lock },
-        { .attrs = dme1737_attr_pwm6_lock },
+        { .attrs = dme1737_pwm5_chmod_attr },
+        { .attrs = dme1737_pwm6_chmod_attr },
 };
 
 /* Pwm[1-3] are read-writeable if the associated pwm is in manual mode and the
  * chip is not locked. Otherwise they are read-only. */
-static struct attribute *dme1737_attr_pwm[] = {
+static struct attribute *dme1737_pwm_chmod_attr[] = {
         &sensor_dev_attr_pwm1.dev_attr.attr,
         &sensor_dev_attr_pwm2.dev_attr.attr,
         &sensor_dev_attr_pwm3.dev_attr.attr,
@@ -1875,9 +1895,17 @@ static void dme1737_remove_files(struct device *dev)
                 if (data->has_pwm & (1 << ix)) {
                         sysfs_remove_group(&dev->kobj,
                                            &dme1737_pwm_group[ix]);
+                        if (data->type != sch5027 && ix < 3) {
+                                sysfs_remove_file(&dev->kobj,
+                                                  dme1737_pwm_misc_attr[ix]);
+                        }
                 }
         }
 
+        if (data->type != sch5027) {
+                sysfs_remove_group(&dev->kobj, &dme1737_misc_group);
+        }
+
         sysfs_remove_group(&dev->kobj, &dme1737_group);
 
         if (!data->client.driver) {
@@ -1901,6 +1929,13 @@ static int dme1737_create_files(struct device *dev)
                 goto exit_remove;
         }
 
+        /* Create misc sysfs attributes */
+        if ((data->type != sch5027) &&
+            (err = sysfs_create_group(&dev->kobj,
+                                      &dme1737_misc_group))) {
+                goto exit_remove;
+        }
+
         /* Create fan sysfs attributes */
         for (ix = 0; ix < ARRAY_SIZE(dme1737_fan_group); ix++) {
                 if (data->has_fan & (1 << ix)) {
@@ -1918,6 +1953,11 @@ static int dme1737_create_files(struct device *dev)
                                                 &dme1737_pwm_group[ix]))) {
                                 goto exit_remove;
                         }
+                        if (data->type != sch5027 && ix < 3 &&
+                            (err = sysfs_create_file(&dev->kobj,
+                                                dme1737_pwm_misc_attr[ix]))) {
+                                goto exit_remove;
+                        }
                 }
         }
 
@@ -1927,16 +1967,27 @@ static int dme1737_create_files(struct device *dev)
                 dev_info(dev, "Device is locked. Some attributes "
                          "will be read-only.\n");
         } else {
-                /* Change permissions of standard attributes */
-                dme1737_chmod_group(dev, &dme1737_lock_group,
+                /* Change permissions of zone sysfs attributes */
+                dme1737_chmod_group(dev, &dme1737_zone_chmod_group,
                                     S_IRUGO | S_IWUSR);
 
-                /* Change permissions of PWM attributes */
-                for (ix = 0; ix < ARRAY_SIZE(dme1737_pwm_lock_group); ix++) {
+                /* Change permissions of misc sysfs attributes */
+                if (data->type != sch5027) {
+                        dme1737_chmod_group(dev, &dme1737_misc_group,
+                                            S_IRUGO | S_IWUSR);
+                }
+
+                /* Change permissions of PWM sysfs attributes */
+                for (ix = 0; ix < ARRAY_SIZE(dme1737_pwm_chmod_group); ix++) {
                         if (data->has_pwm & (1 << ix)) {
                                 dme1737_chmod_group(dev,
-                                                &dme1737_pwm_lock_group[ix],
+                                                &dme1737_pwm_chmod_group[ix],
+                                                S_IRUGO | S_IWUSR);
+                                if (data->type != sch5027 && ix < 3) {
+                                        dme1737_chmod_file(dev,
+                                                dme1737_pwm_misc_attr[ix],
                                                 S_IRUGO | S_IWUSR);
+                                }
                         }
                 }
 
@@ -1945,7 +1996,7 @@ static int dme1737_create_files(struct device *dev)
                         if ((data->has_pwm & (1 << ix)) &&
                             (PWM_EN_FROM_REG(data->pwm_config[ix]) == 1)) {
                                 dme1737_chmod_file(dev,
-                                                dme1737_attr_pwm[ix],
+                                                dme1737_pwm_chmod_attr[ix],
                                                 S_IRUGO | S_IWUSR);
                         }
                 }
@@ -1966,6 +2017,9 @@ static int dme1737_init_device(struct device *dev)
         int ix;
         u8 reg;
 
+        /* Point to the right nominal voltages array */
+        data->in_nominal = IN_NOMINAL(data->type);
+
         data->config = dme1737_read(client, DME1737_REG_CONFIG);
         /* Inform if part is not monitoring/started */
         if (!(data->config & 0x01)) {
@@ -2076,7 +2130,9 @@ static int dme1737_init_device(struct device *dev)
         data->pwm_acz[2] = 4;   /* pwm3 -> zone3 */
 
         /* Set VRM */
-        data->vrm = vid_which_vrm();
+        if (data->type != sch5027) {
+                data->vrm = vid_which_vrm();
+        }
 
         return 0;
 }
@@ -2095,9 +2151,10 @@ static int dme1737_i2c_get_features(int sio_cip, struct dme1737_data *data)
         dme1737_sio_enter(sio_cip);
 
         /* Check device ID
-         * The DME1737 can return either 0x78 or 0x77 as its device ID. */
+         * The DME1737 can return either 0x78 or 0x77 as its device ID.
+         * The SCH5027 returns 0x89 as its device ID. */
         reg = force_id ? force_id : dme1737_sio_inb(sio_cip, 0x20);
-        if (!(reg == 0x77 || reg == 0x78)) {
+        if (!(reg == 0x77 || reg == 0x78 || reg == 0x89)) {
                 err = -ENODEV;
                 goto exit;
         }
@@ -2166,15 +2223,24 @@ static int dme1737_i2c_detect(struct i2c_adapter *adapter, int address,
                 company = dme1737_read(client, DME1737_REG_COMPANY);
                 verstep = dme1737_read(client, DME1737_REG_VERSTEP);
 
-                if (!((company == DME1737_COMPANY_SMSC) &&
-                      ((verstep & DME1737_VERSTEP_MASK) == DME1737_VERSTEP))) {
+                if (company == DME1737_COMPANY_SMSC &&
+                    (verstep & DME1737_VERSTEP_MASK) == DME1737_VERSTEP) {
+                        kind = dme1737;
+                } else if (company == DME1737_COMPANY_SMSC &&
+                           verstep == SCH5027_VERSTEP) {
+                        kind = sch5027;
+                } else {
                         err = -ENODEV;
                         goto exit_kfree;
                 }
         }
 
-        kind = dme1737;
-        name = "dme1737";
+        if (kind == sch5027) {
+                name = "sch5027";
+        } else {
+                kind = dme1737;
+                name = "dme1737";
+        }
         data->type = kind;
 
         /* Fill in the remaining client fields and put it into the global
@@ -2187,8 +2253,9 @@ static int dme1737_i2c_detect(struct i2c_adapter *adapter, int address,
                 goto exit_kfree;
         }
 
-        dev_info(dev, "Found a DME1737 chip at 0x%02x (rev 0x%02x).\n",
-                 client->addr, verstep);
+        dev_info(dev, "Found a %s chip at 0x%02x (rev 0x%02x).\n",
+                 kind == sch5027 ? "SCH5027" : "DME1737", client->addr,
+                 verstep);
 
         /* Initialize the DME1737 chip */
         if ((err = dme1737_init_device(dev))) {
@@ -2360,15 +2427,18 @@ static int __devinit dme1737_isa_probe(struct platform_device *pdev)
         client->addr = res->start;
         platform_set_drvdata(pdev, data);
 
-        company = dme1737_read(client, DME1737_REG_COMPANY);
-        device = dme1737_read(client, DME1737_REG_DEVICE);
+        /* Skip chip detection if module is loaded with force_id parameter */
+        if (!force_id) {
+                company = dme1737_read(client, DME1737_REG_COMPANY);
+                device = dme1737_read(client, DME1737_REG_DEVICE);
 
-        if (!((company == DME1737_COMPANY_SMSC) &&
-              (device == SCH311X_DEVICE))) {
-                err = -ENODEV;
-                goto exit_kfree;
+                if (!((company == DME1737_COMPANY_SMSC) &&
+                      (device == SCH311X_DEVICE))) {
+                        err = -ENODEV;
+                        goto exit_kfree;
+                }
         }
-        data->type = -1;
+        data->type = sch311x;
 
         /* Fill in the remaining client fields and initialize the mutex */
         strlcpy(client->name, "sch311x", I2C_NAME_SIZE);
diff --git a/drivers/hwmon/f71882fg.c b/drivers/hwmon/f71882fg.c
index cbeb4984b5c7..67067e9a323e 100644
--- a/drivers/hwmon/f71882fg.c
+++ b/drivers/hwmon/f71882fg.c
@@ -87,8 +87,6 @@ static inline void superio_enter(int base);
 static inline void superio_select(int base, int ld);
 static inline void superio_exit(int base);
 
-static inline u16 fan_from_reg ( u16 reg );
-
 struct f71882fg_data {
         unsigned short addr;
         struct device *hwmon_dev;
@@ -116,10 +114,6 @@ struct f71882fg_data {
         u8      temp_diode_open;
 };
 
-static u8 f71882fg_read8(struct f71882fg_data *data, u8 reg);
-static u16 f71882fg_read16(struct f71882fg_data *data, u8 reg);
-static void f71882fg_write8(struct f71882fg_data *data, u8 reg, u8 val);
-
 /* Sysfs in*/
 static ssize_t show_in(struct device *dev, struct device_attribute *devattr,
         char *buf);
diff --git a/drivers/hwmon/hwmon-vid.c b/drivers/hwmon/hwmon-vid.c
index 3330667280b9..7b0a32c4dcfb 100644
--- a/drivers/hwmon/hwmon-vid.c
+++ b/drivers/hwmon/hwmon-vid.c
@@ -1,76 +1,74 @@
 /*
-    hwmon-vid.c - VID/VRM/VRD voltage conversions
-
-    Copyright (c) 2004 Rudolf Marek <r.marek@assembler.cz>
-
-    Partly imported from i2c-vid.h of the lm_sensors project
-    Copyright (c) 2002 Mark D. Studebaker <mdsxyz123@yahoo.com>
-    With assistance from Trent Piepho <xyzzy@speakeasy.org>
-
-    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.
-*/
+ * hwmon-vid.c - VID/VRM/VRD voltage conversions
+ *
+ * Copyright (c) 2004 Rudolf Marek <r.marek@assembler.cz>
+ *
+ * Partly imported from i2c-vid.h of the lm_sensors project
+ * Copyright (c) 2002 Mark D. Studebaker <mdsxyz123@yahoo.com>
+ * With assistance from Trent Piepho <xyzzy@speakeasy.org>
+ *
+ * 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>
 #include <linux/kernel.h>
 #include <linux/hwmon-vid.h>
 
 /*
-    Common code for decoding VID pins.
-
-    References:
-
-    For VRM 8.4 to 9.1, "VRM x.y DC-DC Converter Design Guidelines",
-    available at http://developer.intel.com/.
-
-    For VRD 10.0 and up, "VRD x.y Design Guide",
-    available at http://developer.intel.com/.
-
-    AMD Opteron processors don't follow the Intel specifications.
-    I'm going to "make up" 2.4 as the spec number for the Opterons.
-    No good reason just a mnemonic for the 24x Opteron processor
-    series.
-
-    Opteron VID encoding is:
-       00000  =  1.550 V
-       00001  =  1.525 V
-        . . . .
-       11110  =  0.800 V
-       11111  =  0.000 V (off)
-
-    The 17 specification is in fact Intel Mobile Voltage Positioning -
-    (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
-
-    The 14 specification corresponds to Intel Core series. There
-    doesn't seem to be any named specification for these. The conversion
-    tables are detailed directly in the various Pentium Core datasheets:
-    http://www.intel.com/design/mobile/datashts/309221.htm
-
-    The 110 (VRM 11) specification corresponds to Intel Conroe based series.
-    http://www.intel.com/design/processor/applnots/313214.htm
-*/
-
-/* vrm is the VRM/VRD document version multiplied by 10.
-   val is the 4-bit or more VID code.
-   Returned value is in mV to avoid floating point in the kernel.
-   Some VID have some bits in uV scale, this is rounded to mV */
+ * Common code for decoding VID pins.
+ *
+ * References:
+ *
+ * For VRM 8.4 to 9.1, "VRM x.y DC-DC Converter Design Guidelines",
+ * available at http://developer.intel.com/.
+ *
+ * For VRD 10.0 and up, "VRD x.y Design Guide",
+ * available at http://developer.intel.com/.
+ *
+ * AMD NPT 0Fh (Athlon64 & Opteron), AMD Publication 32559,
+ * http://www.amd.com/us-en/assets/content_type/white_papers_and_tech_docs/32559.pdf
+ * Table 71. VID Code Voltages
+ * AMD Opteron processors don't follow the Intel specifications.
+ * I'm going to "make up" 2.4 as the spec number for the Opterons.
+ * No good reason just a mnemonic for the 24x Opteron processor
+ * series.
+ *
+ * The 17 specification is in fact Intel Mobile Voltage Positioning -
+ * (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
+ *
+ * The 14 specification corresponds to Intel Core series. There
+ * doesn't seem to be any named specification for these. The conversion
+ * tables are detailed directly in the various Pentium Core datasheets:
+ * http://www.intel.com/design/mobile/datashts/309221.htm
+ *
+ * The 110 (VRM 11) specification corresponds to Intel Conroe based series.
+ * http://www.intel.com/design/processor/applnots/313214.htm
+ */
+
+/*
+ * vrm is the VRM/VRD document version multiplied by 10.
+ * val is the 4-bit or more VID code.
+ * Returned value is in mV to avoid floating point in the kernel.
+ * Some VID have some bits in uV scale, this is rounded to mV.
+ */
 int vid_from_reg(int val, u8 vrm)
 {
         int vid;
@@ -96,9 +94,11 @@ int vid_from_reg(int val, u8 vrm)
                 if (val < 0x02 || val > 0xb2)
                         return 0;
                 return((1600000 - (val - 2) * 6250 + 500) / 1000);
-        case 24:                /* Opteron processor */
-                val &= 0x1f;
-                return(val == 0x1f ? 0 : 1550 - val * 25);
+
+        case 24:                /* AMD NPT 0Fh (Athlon64 & Opteron) */
+                val &= 0x3f;
+                return (val < 32) ? 1550 - 25 * val
+                        : 775 - (25 * (val - 31)) / 2;
 
         case 91:                /* VRM 9.1 */
         case 90:                /* VRM 9.0 */
@@ -141,9 +141,9 @@ int vid_from_reg(int val, u8 vrm)
 
 
 /*
-    After this point is the code to automatically determine which
-    VRM/VRD specification should be used depending on the CPU.
-*/
+ * After this point is the code to automatically determine which
+ * VRM/VRD specification should be used depending on the CPU.
+ */
 
 struct vrm_model {
         u8 vendor;
diff --git a/drivers/hwmon/it87.c b/drivers/hwmon/it87.c
index e12c132ff83a..30cdb0956779 100644
--- a/drivers/hwmon/it87.c
+++ b/drivers/hwmon/it87.c
@@ -151,9 +151,9 @@ static int fix_pwm_polarity;
 /* The IT8718F has the VID value in a different register, in Super-I/O
    configuration space. */
 #define IT87_REG_VID           0x0a
-/* Warning: register 0x0b is used for something completely different in
-   new chips/revisions. I suspect only 16-bit tachometer mode will work
-   for these. */
+/* The IT8705F and IT8712F earlier than revision 0x08 use register 0x0b
+   for fan divisors. Later IT8712F revisions must use 16-bit tachometer
+   mode. */
 #define IT87_REG_FAN_DIV       0x0b
 #define IT87_REG_FAN_16BIT     0x0c
 
@@ -234,6 +234,7 @@ static const unsigned int pwm_freq[8] = {
 struct it87_sio_data {
         enum chips type;
         /* Values read from Super-I/O config space */
+        u8 revision;
         u8 vid_value;
 };
 
@@ -242,6 +243,7 @@ struct it87_sio_data {
 struct it87_data {
         struct device *hwmon_dev;
         enum chips type;
+        u8 revision;
 
         unsigned short addr;
         const char *name;
@@ -268,6 +270,16 @@ struct it87_data {
         u8 manual_pwm_ctl[3];   /* manual PWM value set by user */
 };
 
+static inline int has_16bit_fans(const struct it87_data *data)
+{
+        /* IT8705F Datasheet 0.4.1, 3h == Version G.
+           IT8712F Datasheet 0.9.1, section 8.3.5 indicates 7h == Version I.
+           These are the first revisions with 16bit tachometer support. */
+        return (data->type == it87 && data->revision >= 0x03)
+            || (data->type == it8712 && data->revision >= 0x07)
+            || data->type == it8716
+            || data->type == it8718;
+}
 
 static int it87_probe(struct platform_device *pdev);
 static int __devexit it87_remove(struct platform_device *pdev);
@@ -991,8 +1003,9 @@ static int __init it87_find(unsigned short *address,
         }
 
         err = 0;
+        sio_data->revision = superio_inb(DEVREV) & 0x0f;
         pr_info("it87: Found IT%04xF chip at 0x%x, revision %d\n",
-                chip_type, *address, superio_inb(DEVREV) & 0x0f);
+                chip_type, *address, sio_data->revision);
 
         /* Read GPIO config and VID value from LDN 7 (GPIO) */
         if (chip_type != IT8705F_DEVID) {
@@ -1045,6 +1058,7 @@ static int __devinit it87_probe(struct platform_device *pdev)
 
         data->addr = res->start;
         data->type = sio_data->type;
+        data->revision = sio_data->revision;
         data->name = names[sio_data->type];
 
         /* Now, we do the remaining detection. */
@@ -1069,7 +1083,7 @@ static int __devinit it87_probe(struct platform_device *pdev)
                 goto ERROR2;
 
         /* Do not create fan files for disabled fans */
-        if (data->type == it8716 || data->type == it8718) {
+        if (has_16bit_fans(data)) {
                 /* 16-bit tachometers */
                 if (data->has_fan & (1 << 0)) {
                         if ((err = device_create_file(dev,
@@ -1350,7 +1364,7 @@ static void __devinit it87_init_device(struct platform_device *pdev)
         data->has_fan = (data->fan_main_ctrl >> 4) & 0x07;
 
         /* Set tachometers to 16-bit mode if needed */
-        if (data->type == it8716 || data->type == it8718) {
+        if (has_16bit_fans(data)) {
                 tmp = it87_read_value(data, IT87_REG_FAN_16BIT);
                 if (~tmp & 0x07 & data->has_fan) {
                         dev_dbg(&pdev->dev,
@@ -1358,10 +1372,13 @@ static void __devinit it87_init_device(struct platform_device *pdev)
                         it87_write_value(data, IT87_REG_FAN_16BIT,
                                          tmp | 0x07);
                 }
-                if (tmp & (1 << 4))
-                        data->has_fan |= (1 << 3);      /* fan4 enabled */
-                if (tmp & (1 << 5))
-                        data->has_fan |= (1 << 4);      /* fan5 enabled */
+                /* IT8705F only supports three fans. */
+                if (data->type != it87) {
+                        if (tmp & (1 << 4))
+                                data->has_fan |= (1 << 3); /* fan4 enabled */
+                        if (tmp & (1 << 5))
+                                data->has_fan |= (1 << 4); /* fan5 enabled */
+                }
         }
 
         /* Set current fan mode registers and the default settings for the
@@ -1426,7 +1443,7 @@ static struct it87_data *it87_update_device(struct device *dev)
                         data->fan[i] = it87_read_value(data,
                                        IT87_REG_FAN[i]);
                         /* Add high byte if in 16-bit mode */
-                        if (data->type == it8716 || data->type == it8718) {
+                        if (has_16bit_fans(data)) {
                                 data->fan[i] |= it87_read_value(data,
                                                 IT87_REG_FANX[i]) << 8;
                                 data->fan_min[i] |= it87_read_value(data,
@@ -1443,8 +1460,7 @@ static struct it87_data *it87_update_device(struct device *dev)
                 }
 
                 /* Newer chips don't have clock dividers */
-                if ((data->has_fan & 0x07) && data->type != it8716
-                 && data->type != it8718) {
+                if ((data->has_fan & 0x07) && !has_16bit_fans(data)) {
                         i = it87_read_value(data, IT87_REG_FAN_DIV);
                         data->fan_div[0] = i & 0x07;
                         data->fan_div[1] = (i >> 3) & 0x07;
@@ -1460,7 +1476,8 @@ static struct it87_data *it87_update_device(struct device *dev)
                 data->fan_ctl = it87_read_value(data, IT87_REG_FAN_CTL);
 
                 data->sensor = it87_read_value(data, IT87_REG_TEMP_ENABLE);
-                /* The 8705 does not have VID capability */
+                /* The 8705 does not have VID capability.
+                   The 8718 does not use IT87_REG_VID for the same purpose. */
                 if (data->type == it8712 || data->type == it8716) {
                         data->vid = it87_read_value(data, IT87_REG_VID);
                         /* The older IT8712F revisions had only 5 VID pins,
diff --git a/drivers/hwmon/thmc50.c b/drivers/hwmon/thmc50.c
index 3b01001108c1..7d97431e132f 100644
--- a/drivers/hwmon/thmc50.c
+++ b/drivers/hwmon/thmc50.c
@@ -55,8 +55,11 @@ I2C_CLIENT_MODULE_PARM(adm1022_temp3, "List of adapter,address pairs "
 static const u8 THMC50_REG_TEMP[] = { 0x27, 0x26, 0x20 };
 static const u8 THMC50_REG_TEMP_MIN[] = { 0x3A, 0x38, 0x2C };
 static const u8 THMC50_REG_TEMP_MAX[] = { 0x39, 0x37, 0x2B };
+static const u8 THMC50_REG_TEMP_CRITICAL[] = { 0x13, 0x14, 0x14 };
+static const u8 THMC50_REG_TEMP_DEFAULT[] = { 0x17, 0x18, 0x18 };
 
 #define THMC50_REG_CONF_nFANOFF                 0x20
+#define THMC50_REG_CONF_PROGRAMMED              0x08
 
 /* Each client has this additional data */
 struct thmc50_data {
@@ -72,6 +75,7 @@ struct thmc50_data {
         s8 temp_input[3];
         s8 temp_max[3];
         s8 temp_min[3];
+        s8 temp_critical[3];
         u8 analog_out;
         u8 alarms;
 };
@@ -199,6 +203,15 @@ static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
         return count;
 }
 
+static ssize_t show_temp_critical(struct device *dev,
+                                  struct device_attribute *attr,
+                                  char *buf)
+{
+        int nr = to_sensor_dev_attr(attr)->index;
+        struct thmc50_data *data = thmc50_update_device(dev);
+        return sprintf(buf, "%d\n", data->temp_critical[nr] * 1000);
+}
+
 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
                           char *buf)
 {
@@ -214,7 +227,9 @@ static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, show_temp,	\
 static SENSOR_DEVICE_ATTR(temp##offset##_min, S_IRUGO | S_IWUSR,        \
                         show_temp_min, set_temp_min, offset - 1);       \
 static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR,        \
-                        show_temp_max, set_temp_max, offset - 1);
+                        show_temp_max, set_temp_max, offset - 1);       \
+static SENSOR_DEVICE_ATTR(temp##offset##_crit, S_IRUGO,                 \
+                        show_temp_critical, NULL, offset - 1);
 
 temp_reg(1);
 temp_reg(2);
@@ -234,10 +249,12 @@ static struct attribute *thmc50_attributes[] = {
         &sensor_dev_attr_temp1_max.dev_attr.attr,
         &sensor_dev_attr_temp1_min.dev_attr.attr,
         &sensor_dev_attr_temp1_input.dev_attr.attr,
+        &sensor_dev_attr_temp1_crit.dev_attr.attr,
         &sensor_dev_attr_temp1_alarm.dev_attr.attr,
         &sensor_dev_attr_temp2_max.dev_attr.attr,
         &sensor_dev_attr_temp2_min.dev_attr.attr,
         &sensor_dev_attr_temp2_input.dev_attr.attr,
+        &sensor_dev_attr_temp2_crit.dev_attr.attr,
         &sensor_dev_attr_temp2_alarm.dev_attr.attr,
         &sensor_dev_attr_temp2_fault.dev_attr.attr,
         &sensor_dev_attr_pwm1.dev_attr.attr,
@@ -254,6 +271,7 @@ static struct attribute *temp3_attributes[] = {
         &sensor_dev_attr_temp3_max.dev_attr.attr,
         &sensor_dev_attr_temp3_min.dev_attr.attr,
         &sensor_dev_attr_temp3_input.dev_attr.attr,
+        &sensor_dev_attr_temp3_crit.dev_attr.attr,
         &sensor_dev_attr_temp3_alarm.dev_attr.attr,
         &sensor_dev_attr_temp3_fault.dev_attr.attr,
         NULL
@@ -429,6 +447,10 @@ static struct thmc50_data *thmc50_update_device(struct device *dev)
 
                 int temps = data->has_temp3 ? 3 : 2;
                 int i;
+                int prog = i2c_smbus_read_byte_data(client, THMC50_REG_CONF);
+
+                prog &= THMC50_REG_CONF_PROGRAMMED;
+
                 for (i = 0; i < temps; i++) {
                         data->temp_input[i] = i2c_smbus_read_byte_data(client,
                                                 THMC50_REG_TEMP[i]);
@@ -436,6 +458,10 @@ static struct thmc50_data *thmc50_update_device(struct device *dev)
                                                 THMC50_REG_TEMP_MAX[i]);
                         data->temp_min[i] = i2c_smbus_read_byte_data(client,
                                                 THMC50_REG_TEMP_MIN[i]);
+                        data->temp_critical[i] =
+                                i2c_smbus_read_byte_data(client,
+                                        prog ? THMC50_REG_TEMP_CRITICAL[i]
+                                             : THMC50_REG_TEMP_DEFAULT[i]);
                 }
                 data->analog_out =
                     i2c_smbus_read_byte_data(client, THMC50_REG_ANALOG_OUT);
diff --git a/drivers/hwmon/w83627hf.c b/drivers/hwmon/w83627hf.c
index 9564fb069957..b30e5796cb26 100644
--- a/drivers/hwmon/w83627hf.c
+++ b/drivers/hwmon/w83627hf.c
@@ -67,10 +67,6 @@ module_param(force_i2c, byte, 0);
 MODULE_PARM_DESC(force_i2c,
                  "Initialize the i2c address of the sensors");
 
-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");
@@ -209,6 +205,13 @@ static const u16 w83627hf_reg_temp_over[]	= { 0x39, 0x155, 0x255 };
 #define W83627HF_REG_PWM1 0x5A
 #define W83627HF_REG_PWM2 0x5B
 
+static const u8 W83627THF_REG_PWM_ENABLE[] = {
+        0x04,           /* FAN 1 mode */
+        0x04,           /* FAN 2 mode */
+        0x12,           /* FAN AUX mode */
+};
+static const u8 W83627THF_PWM_ENABLE_SHIFT[] = { 2, 4, 1 };
+
 #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 */
@@ -366,6 +369,9 @@ struct w83627hf_data {
         u32 alarms;             /* Register encoding, combined */
         u32 beep_mask;          /* Register encoding, combined */
         u8 pwm[3];              /* Register value */
+        u8 pwm_enable[3];       /* 1 = manual
+                                   2 = thermal cruise (also called SmartFan I)
+                                   3 = fan speed cruise */
         u8 pwm_freq[3];         /* Register value */
         u16 sens[3];            /* 1 = pentium diode; 2 = 3904 diode;
                                    4 = thermistor */
@@ -957,6 +963,42 @@ static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO|S_IWUSR, show_pwm, store_pwm, 1);
 static SENSOR_DEVICE_ATTR(pwm3, S_IRUGO|S_IWUSR, show_pwm, store_pwm, 2);
 
 static ssize_t
+show_pwm_enable(struct device *dev, struct device_attribute *devattr, char *buf)
+{
+        int nr = to_sensor_dev_attr(devattr)->index;
+        struct w83627hf_data *data = w83627hf_update_device(dev);
+        return sprintf(buf, "%d\n", data->pwm_enable[nr]);
+}
+
+static ssize_t
+store_pwm_enable(struct device *dev, struct device_attribute *devattr,
+          const char *buf, size_t count)
+{
+        int nr = to_sensor_dev_attr(devattr)->index;
+        struct w83627hf_data *data = dev_get_drvdata(dev);
+        unsigned long val = simple_strtoul(buf, NULL, 10);
+        u8 reg;
+
+        if (!val || (val > 3))  /* modes 1, 2 and 3 are supported */
+                return -EINVAL;
+        mutex_lock(&data->update_lock);
+        data->pwm_enable[nr] = val;
+        reg = w83627hf_read_value(data, W83627THF_REG_PWM_ENABLE[nr]);
+        reg &= ~(0x03 << W83627THF_PWM_ENABLE_SHIFT[nr]);
+        reg |= (val - 1) << W83627THF_PWM_ENABLE_SHIFT[nr];
+        w83627hf_write_value(data, W83627THF_REG_PWM_ENABLE[nr], reg);
+        mutex_unlock(&data->update_lock);
+        return count;
+}
+
+static SENSOR_DEVICE_ATTR(pwm1_enable, S_IRUGO|S_IWUSR, show_pwm_enable,
+                                                  store_pwm_enable, 0);
+static SENSOR_DEVICE_ATTR(pwm2_enable, S_IRUGO|S_IWUSR, show_pwm_enable,
+                                                  store_pwm_enable, 1);
+static SENSOR_DEVICE_ATTR(pwm3_enable, S_IRUGO|S_IWUSR, show_pwm_enable,
+                                                  store_pwm_enable, 2);
+
+static ssize_t
 show_pwm_freq(struct device *dev, struct device_attribute *devattr, char *buf)
 {
         int nr = to_sensor_dev_attr(devattr)->index;
@@ -1223,6 +1265,11 @@ static struct attribute *w83627hf_attributes_opt[] = {
         &sensor_dev_attr_pwm1_freq.dev_attr.attr,
         &sensor_dev_attr_pwm2_freq.dev_attr.attr,
         &sensor_dev_attr_pwm3_freq.dev_attr.attr,
+
+        &sensor_dev_attr_pwm1_enable.dev_attr.attr,
+        &sensor_dev_attr_pwm2_enable.dev_attr.attr,
+        &sensor_dev_attr_pwm3_enable.dev_attr.attr,
+
         NULL
 };
 
@@ -1366,6 +1413,19 @@ static int __devinit w83627hf_probe(struct platform_device *pdev)
                                 &sensor_dev_attr_pwm3_freq.dev_attr)))
                         goto ERROR4;
 
+        if (data->type != w83627hf)
+                if ((err = device_create_file(dev,
+                                &sensor_dev_attr_pwm1_enable.dev_attr))
+                 || (err = device_create_file(dev,
+                                &sensor_dev_attr_pwm2_enable.dev_attr)))
+                        goto ERROR4;
+
+        if (data->type == w83627thf || data->type == w83637hf
+         || data->type == w83687thf)
+                if ((err = device_create_file(dev,
+                                &sensor_dev_attr_pwm3_enable.dev_attr)))
+                        goto ERROR4;
+
         data->hwmon_dev = hwmon_device_register(dev);
         if (IS_ERR(data->hwmon_dev)) {
                 err = PTR_ERR(data->hwmon_dev);
@@ -1536,29 +1596,6 @@ static void __devinit w83627hf_init_device(struct platform_device *pdev)
         enum chips type = data->type;
         u8 tmp;
 
-        if (reset) {
-                /* Resetting the chip has been the default for a long time,
-                   but repeatedly caused problems (fans going to full
-                   speed...) 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(&pdev->dev, "If reset=1 solved a problem you were "
-                         "having, please report!\n");
-
-                /* save this register */
-                i = w83627hf_read_value(data, W83781D_REG_BEEP_CONFIG);
-                /* Reset all except Watchdog values and last conversion values
-                   This sets fan-divs to 2, among others */
-                w83627hf_write_value(data, W83781D_REG_CONFIG, 0x80);
-                /* Restore the register and disable power-on abnormal beep.
-                   This saves FAN 1/2/3 input/output values set by BIOS. */
-                w83627hf_write_value(data, W83781D_REG_BEEP_CONFIG, i | 0x80);
-                /* Disable master beep-enable (reset turns it on).
-                   Individual beeps should be reset to off but for some reason
-                   disabling this bit helps some people not get beeped */
-                w83627hf_write_value(data, W83781D_REG_BEEP_INTS2, 0);
-        }
-
         /* Minimize conflicts with other winbond i2c-only clients...  */
         /* disable i2c subclients... how to disable main i2c client?? */
         /* force i2c address to relatively uncommon address */
@@ -1655,6 +1692,7 @@ static struct w83627hf_data *w83627hf_update_device(struct device *dev)
 {
         struct w83627hf_data *data = dev_get_drvdata(dev);
         int i, num_temps = (data->type == w83697hf) ? 2 : 3;
+        int num_pwms = (data->type == w83697hf) ? 2 : 3;
 
         mutex_lock(&data->update_lock);
 
@@ -1707,6 +1745,15 @@ static struct w83627hf_data *w83627hf_update_device(struct device *dev)
                                         break;
                         }
                 }
+                if (data->type != w83627hf) {
+                        for (i = 0; i < num_pwms; i++) {
+                                u8 tmp = w83627hf_read_value(data,
+                                        W83627THF_REG_PWM_ENABLE[i]);
+                                data->pwm_enable[i] =
+                                        ((tmp >> W83627THF_PWM_ENABLE_SHIFT[i])
+                                        & 0x03) + 1;
+                        }
+                }
                 for (i = 0; i < num_temps; i++) {
                         data->temp[i] = w83627hf_read_value(
                                                 data, w83627hf_reg_temp[i]);
diff --git a/drivers/hwmon/w83791d.c b/drivers/hwmon/w83791d.c
index e4e91c9d480a..daa7d121483b 100644
--- a/drivers/hwmon/w83791d.c
+++ b/drivers/hwmon/w83791d.c
@@ -233,11 +233,9 @@ static u8 fan_to_reg(long rpm, int div)
 static u8 div_to_reg(int nr, long val)
 {
         int i;
-        int max;
 
-        /* first three fan's divisor max out at 8, rest max out at 128 */
-        max = (nr < 3) ? 8 : 128;
-        val = SENSORS_LIMIT(val, 1, max) >> 1;
+        /* fan divisors max out at 128 */
+        val = SENSORS_LIMIT(val, 1, 128) >> 1;
         for (i = 0; i < 7; i++) {
                 if (val == 0)
                         break;
@@ -530,6 +528,7 @@ static ssize_t store_fan_div(struct device *dev, struct device_attribute *attr,
         unsigned long min;
         u8 tmp_fan_div;
         u8 fan_div_reg;
+        u8 vbat_reg;
         int indx = 0;
         u8 keep_mask = 0;
         u8 new_shift = 0;
@@ -581,6 +580,16 @@ static ssize_t store_fan_div(struct device *dev, struct device_attribute *attr,
         w83791d_write(client, W83791D_REG_FAN_DIV[indx],
                                 fan_div_reg | tmp_fan_div);
 
+        /* Bit 2 of fans 0-2 is stored in the vbat register (bits 5-7) */
+        if (nr < 3) {
+                keep_mask = ~(1 << (nr + 5));
+                vbat_reg = w83791d_read(client, W83791D_REG_VBAT)
+                                & keep_mask;
+                tmp_fan_div = (data->fan_div[nr] << (3 + nr)) & ~keep_mask;
+                w83791d_write(client, W83791D_REG_VBAT,
+                                vbat_reg | tmp_fan_div);
+        }
+
         /* Restore fan_min */
         data->fan_min[nr] = fan_to_reg(min, DIV_FROM_REG(data->fan_div[nr]));
         w83791d_write(client, W83791D_REG_FAN_MIN[nr], data->fan_min[nr]);
@@ -1182,6 +1191,7 @@ static struct w83791d_data *w83791d_update_device(struct device *dev)
         struct w83791d_data *data = i2c_get_clientdata(client);
         int i, j;
         u8 reg_array_tmp[3];
+        u8 vbat_reg;
 
         mutex_lock(&data->update_lock);
 
@@ -1219,6 +1229,12 @@ static struct w83791d_data *w83791d_update_device(struct device *dev)
                 data->fan_div[3] = reg_array_tmp[2] & 0x07;
                 data->fan_div[4] = (reg_array_tmp[2] >> 4) & 0x07;
 
+                /* The fan divisor for fans 0-2 get bit 2 from
+                   bits 5-7 respectively of vbat register */
+                vbat_reg = w83791d_read(client, W83791D_REG_VBAT);
+                for (i = 0; i < 3; i++)
+                        data->fan_div[i] |= (vbat_reg >> (3 + i)) & 0x04;
+
                 /* Update the first temperature sensor */
                 for (i = 0; i < 3; i++) {
                         data->temp1[i] = w83791d_read(client,
diff --git a/drivers/infiniband/core/cma.c b/drivers/infiniband/core/cma.c
index e980ff3335db..d951896ff7fc 100644
--- a/drivers/infiniband/core/cma.c
+++ b/drivers/infiniband/core/cma.c
@@ -155,9 +155,7 @@ struct cma_multicast {
         } multicast;
         struct list_head        list;
         void                    *context;
-        struct sockaddr         addr;
-        u8                      pad[sizeof(struct sockaddr_in6) -
-                                    sizeof(struct sockaddr)];
+        struct sockaddr_storage addr;
 };
 
 struct cma_work {
@@ -786,8 +784,8 @@ static void cma_cancel_operation(struct rdma_id_private *id_priv,
                 cma_cancel_route(id_priv);
                 break;
         case CMA_LISTEN:
-                if (cma_any_addr(&id_priv->id.route.addr.src_addr) &&
-                    !id_priv->cma_dev)
+                if (cma_any_addr((struct sockaddr *) &id_priv->id.route.addr.src_addr)
+                                && !id_priv->cma_dev)
                         cma_cancel_listens(id_priv);
                 break;
         default:
@@ -1026,7 +1024,7 @@ static struct rdma_id_private *cma_new_conn_id(struct rdma_cm_id *listen_id,
                 rt->path_rec[1] = *ib_event->param.req_rcvd.alternate_path;
 
         ib_addr_set_dgid(&rt->addr.dev_addr, &rt->path_rec[0].dgid);
-        ret = rdma_translate_ip(&id->route.addr.src_addr,
+        ret = rdma_translate_ip((struct sockaddr *) &id->route.addr.src_addr,
                                 &id->route.addr.dev_addr);
         if (ret)
                 goto destroy_id;
@@ -1064,7 +1062,7 @@ static struct rdma_id_private *cma_new_udp_id(struct rdma_cm_id *listen_id,
         cma_save_net_info(&id->route.addr, &listen_id->route.addr,
                           ip_ver, port, src, dst);
 
-        ret = rdma_translate_ip(&id->route.addr.src_addr,
+        ret = rdma_translate_ip((struct sockaddr *) &id->route.addr.src_addr,
                                 &id->route.addr.dev_addr);
         if (ret)
                 goto err;
@@ -1377,7 +1375,7 @@ static int cma_ib_listen(struct rdma_id_private *id_priv)
         if (IS_ERR(id_priv->cm_id.ib))
                 return PTR_ERR(id_priv->cm_id.ib);
 
-        addr = &id_priv->id.route.addr.src_addr;
+        addr = (struct sockaddr *) &id_priv->id.route.addr.src_addr;
         svc_id = cma_get_service_id(id_priv->id.ps, addr);
         if (cma_any_addr(addr))
                 ret = ib_cm_listen(id_priv->cm_id.ib, svc_id, 0, NULL);
@@ -1443,7 +1441,7 @@ static void cma_listen_on_dev(struct rdma_id_private *id_priv,
 
         dev_id_priv->state = CMA_ADDR_BOUND;
         memcpy(&id->route.addr.src_addr, &id_priv->id.route.addr.src_addr,
-               ip_addr_size(&id_priv->id.route.addr.src_addr));
+               ip_addr_size((struct sockaddr *) &id_priv->id.route.addr.src_addr));
 
         cma_attach_to_dev(dev_id_priv, cma_dev);
         list_add_tail(&dev_id_priv->listen_list, &id_priv->listen_list);
@@ -1563,13 +1561,14 @@ static int cma_query_ib_route(struct rdma_id_private *id_priv, int timeout_ms,
         path_rec.pkey = cpu_to_be16(ib_addr_get_pkey(&addr->dev_addr));
         path_rec.numb_path = 1;
         path_rec.reversible = 1;
-        path_rec.service_id = cma_get_service_id(id_priv->id.ps, &addr->dst_addr);
+        path_rec.service_id = cma_get_service_id(id_priv->id.ps,
+                                                        (struct sockaddr *) &addr->dst_addr);
 
         comp_mask = IB_SA_PATH_REC_DGID | IB_SA_PATH_REC_SGID |
                     IB_SA_PATH_REC_PKEY | IB_SA_PATH_REC_NUMB_PATH |
                     IB_SA_PATH_REC_REVERSIBLE | IB_SA_PATH_REC_SERVICE_ID;
 
-        if (addr->src_addr.sa_family == AF_INET) {
+        if (addr->src_addr.ss_family == AF_INET) {
                 path_rec.qos_class = cpu_to_be16((u16) id_priv->tos);
                 comp_mask |= IB_SA_PATH_REC_QOS_CLASS;
         } else {
@@ -1848,7 +1847,7 @@ static int cma_resolve_loopback(struct rdma_id_private *id_priv)
         ib_addr_get_sgid(&id_priv->id.route.addr.dev_addr, &gid);
         ib_addr_set_dgid(&id_priv->id.route.addr.dev_addr, &gid);
 
-        if (cma_zero_addr(&id_priv->id.route.addr.src_addr)) {
+        if (cma_zero_addr((struct sockaddr *) &id_priv->id.route.addr.src_addr)) {
                 src_in = (struct sockaddr_in *)&id_priv->id.route.addr.src_addr;
                 dst_in = (struct sockaddr_in *)&id_priv->id.route.addr.dst_addr;
                 src_in->sin_family = dst_in->sin_family;
@@ -1897,7 +1896,7 @@ int rdma_resolve_addr(struct rdma_cm_id *id, struct sockaddr *src_addr,
         if (cma_any_addr(dst_addr))
                 ret = cma_resolve_loopback(id_priv);
         else
-                ret = rdma_resolve_ip(&addr_client, &id->route.addr.src_addr,
+                ret = rdma_resolve_ip(&addr_client, (struct sockaddr *) &id->route.addr.src_addr,
                                       dst_addr, &id->route.addr.dev_addr,
                                       timeout_ms, addr_handler, id_priv);
         if (ret)
@@ -2021,11 +2020,11 @@ static int cma_use_port(struct idr *ps, struct rdma_id_private *id_priv)
          * We don't support binding to any address if anyone is bound to
          * a specific address on the same port.
          */
-        if (cma_any_addr(&id_priv->id.route.addr.src_addr))
+        if (cma_any_addr((struct sockaddr *) &id_priv->id.route.addr.src_addr))
                 return -EADDRNOTAVAIL;
 
         hlist_for_each_entry(cur_id, node, &bind_list->owners, node) {
-                if (cma_any_addr(&cur_id->id.route.addr.src_addr))
+                if (cma_any_addr((struct sockaddr *) &cur_id->id.route.addr.src_addr))
                         return -EADDRNOTAVAIL;
 
                 cur_sin = (struct sockaddr_in *) &cur_id->id.route.addr.src_addr;
@@ -2060,7 +2059,7 @@ static int cma_get_port(struct rdma_id_private *id_priv)
         }
 
         mutex_lock(&lock);
-        if (cma_any_port(&id_priv->id.route.addr.src_addr))
+        if (cma_any_port((struct sockaddr *) &id_priv->id.route.addr.src_addr))
                 ret = cma_alloc_any_port(ps, id_priv);
         else
                 ret = cma_use_port(ps, id_priv);
@@ -2232,7 +2231,7 @@ static int cma_resolve_ib_udp(struct rdma_id_private *id_priv,
 
         req.path = route->path_rec;
         req.service_id = cma_get_service_id(id_priv->id.ps,
-                                            &route->addr.dst_addr);
+                                            (struct sockaddr *) &route->addr.dst_addr);
         req.timeout_ms = 1 << (CMA_CM_RESPONSE_TIMEOUT - 8);
         req.max_cm_retries = CMA_MAX_CM_RETRIES;
 
@@ -2283,7 +2282,7 @@ static int cma_connect_ib(struct rdma_id_private *id_priv,
                 req.alternate_path = &route->path_rec[1];
 
         req.service_id = cma_get_service_id(id_priv->id.ps,
-                                            &route->addr.dst_addr);
+                                            (struct sockaddr *) &route->addr.dst_addr);
         req.qp_num = id_priv->qp_num;
         req.qp_type = IB_QPT_RC;
         req.starting_psn = id_priv->seq_num;
@@ -2667,7 +2666,7 @@ static int cma_join_ib_multicast(struct rdma_id_private *id_priv,
         if (ret)
                 return ret;
 
-        cma_set_mgid(id_priv, &mc->addr, &rec.mgid);
+        cma_set_mgid(id_priv, (struct sockaddr *) &mc->addr, &rec.mgid);
         if (id_priv->id.ps == RDMA_PS_UDP)
                 rec.qkey = cpu_to_be32(RDMA_UDP_QKEY);
         ib_addr_get_sgid(dev_addr, &rec.port_gid);
diff --git a/drivers/infiniband/core/mad_rmpp.c b/drivers/infiniband/core/mad_rmpp.c
index d0ef7d61c037..3af2b84cd838 100644
--- a/drivers/infiniband/core/mad_rmpp.c
+++ b/drivers/infiniband/core/mad_rmpp.c
@@ -133,7 +133,7 @@ static void ack_recv(struct mad_rmpp_recv *rmpp_recv,
         msg = ib_create_send_mad(&rmpp_recv->agent->agent, recv_wc->wc->src_qp,
                                  recv_wc->wc->pkey_index, 1, hdr_len,
                                  0, GFP_KERNEL);
-        if (!msg)
+        if (IS_ERR(msg))
                 return;
 
         format_ack(msg, (struct ib_rmpp_mad *) recv_wc->recv_buf.mad, rmpp_recv);
diff --git a/drivers/infiniband/core/ucma.c b/drivers/infiniband/core/ucma.c
index b41dd26bbfa1..3ddacf39b7ba 100644
--- a/drivers/infiniband/core/ucma.c
+++ b/drivers/infiniband/core/ucma.c
@@ -81,9 +81,7 @@ struct ucma_multicast {
 
         u64                     uid;
         struct list_head        list;
-        struct sockaddr         addr;
-        u8                      pad[sizeof(struct sockaddr_in6) -
-                                    sizeof(struct sockaddr)];
+        struct sockaddr_storage addr;
 };
 
 struct ucma_event {
@@ -603,11 +601,11 @@ static ssize_t ucma_query_route(struct ucma_file *file,
                 return PTR_ERR(ctx);
 
         memset(&resp, 0, sizeof resp);
-        addr = &ctx->cm_id->route.addr.src_addr;
+        addr = (struct sockaddr *) &ctx->cm_id->route.addr.src_addr;
         memcpy(&resp.src_addr, addr, addr->sa_family == AF_INET ?
                                      sizeof(struct sockaddr_in) :
                                      sizeof(struct sockaddr_in6));
-        addr = &ctx->cm_id->route.addr.dst_addr;
+        addr = (struct sockaddr *) &ctx->cm_id->route.addr.dst_addr;
         memcpy(&resp.dst_addr, addr, addr->sa_family == AF_INET ?
                                      sizeof(struct sockaddr_in) :
                                      sizeof(struct sockaddr_in6));
@@ -913,7 +911,7 @@ static ssize_t ucma_join_multicast(struct ucma_file *file,
 
         mc->uid = cmd.uid;
         memcpy(&mc->addr, &cmd.addr, sizeof cmd.addr);
-        ret = rdma_join_multicast(ctx->cm_id, &mc->addr, mc);
+        ret = rdma_join_multicast(ctx->cm_id, (struct sockaddr *) &mc->addr, mc);
         if (ret)
                 goto err2;
 
@@ -929,7 +927,7 @@ static ssize_t ucma_join_multicast(struct ucma_file *file,
         return 0;
 
 err3:
-        rdma_leave_multicast(ctx->cm_id, &mc->addr);
+        rdma_leave_multicast(ctx->cm_id, (struct sockaddr *) &mc->addr);
         ucma_cleanup_mc_events(mc);
 err2:
         mutex_lock(&mut);
@@ -975,7 +973,7 @@ static ssize_t ucma_leave_multicast(struct ucma_file *file,
                 goto out;
         }
 
-        rdma_leave_multicast(mc->ctx->cm_id, &mc->addr);
+        rdma_leave_multicast(mc->ctx->cm_id, (struct sockaddr *) &mc->addr);
         mutex_lock(&mc->ctx->file->mut);
         ucma_cleanup_mc_events(mc);
         list_del(&mc->list);
diff --git a/drivers/infiniband/hw/cxgb3/cxio_hal.c b/drivers/infiniband/hw/cxgb3/cxio_hal.c
index f6d5747153a5..4dcf08b3fd83 100644
--- a/drivers/infiniband/hw/cxgb3/cxio_hal.c
+++ b/drivers/infiniband/hw/cxgb3/cxio_hal.c
@@ -725,9 +725,9 @@ static int __cxio_tpt_op(struct cxio_rdev *rdev_p, u32 reset_tpt_entry,
                                 V_TPT_STAG_TYPE(type) | V_TPT_PDID(pdid));
                 BUG_ON(page_size >= 28);
                 tpt.flags_pagesize_qpid = cpu_to_be32(V_TPT_PERM(perm) |
-                                F_TPT_MW_BIND_ENABLE |
-                                V_TPT_ADDR_TYPE((zbva ? TPT_ZBTO : TPT_VATO)) |
-                                V_TPT_PAGE_SIZE(page_size));
+                        ((perm & TPT_MW_BIND) ? F_TPT_MW_BIND_ENABLE : 0) |
+                        V_TPT_ADDR_TYPE((zbva ? TPT_ZBTO : TPT_VATO)) |
+                        V_TPT_PAGE_SIZE(page_size));
                 tpt.rsvd_pbl_addr = reset_tpt_entry ? 0 :
                                     cpu_to_be32(V_TPT_PBL_ADDR(PBL_OFF(rdev_p, pbl_addr)>>3));
                 tpt.len = cpu_to_be32(len);
diff --git a/drivers/infiniband/hw/cxgb3/iwch_provider.c b/drivers/infiniband/hw/cxgb3/iwch_provider.c
index b89640aa6e10..eb778bfd6f66 100644
--- a/drivers/infiniband/hw/cxgb3/iwch_provider.c
+++ b/drivers/infiniband/hw/cxgb3/iwch_provider.c
@@ -1187,28 +1187,6 @@ static ssize_t show_rev(struct device *dev, struct device_attribute *attr,
         return sprintf(buf, "%d\n", iwch_dev->rdev.t3cdev_p->type);
 }
 
-static int fw_supports_fastreg(struct iwch_dev *iwch_dev)
-{
-        struct ethtool_drvinfo info;
-        struct net_device *lldev = iwch_dev->rdev.t3cdev_p->lldev;
-        char *cp, *next;
-        unsigned fw_maj, fw_min;
-
-        rtnl_lock();
-        lldev->ethtool_ops->get_drvinfo(lldev, &info);
-        rtnl_unlock();
-
-        next = info.fw_version+1;
-        cp = strsep(&next, ".");
-        sscanf(cp, "%i", &fw_maj);
-        cp = strsep(&next, ".");
-        sscanf(cp, "%i", &fw_min);
-
-        PDBG("%s maj %u min %u\n", __func__, fw_maj, fw_min);
-
-        return fw_maj > 6 || (fw_maj == 6 && fw_min > 0);
-}
-
 static ssize_t show_fw_ver(struct device *dev, struct device_attribute *attr, char *buf)
 {
         struct iwch_dev *iwch_dev = container_of(dev, struct iwch_dev,
@@ -1325,12 +1303,12 @@ int iwch_register_device(struct iwch_dev *dev)
         memset(&dev->ibdev.node_guid, 0, sizeof(dev->ibdev.node_guid));
         memcpy(&dev->ibdev.node_guid, dev->rdev.t3cdev_p->lldev->dev_addr, 6);
         dev->ibdev.owner = THIS_MODULE;
-        dev->device_cap_flags = IB_DEVICE_LOCAL_DMA_LKEY | IB_DEVICE_MEM_WINDOW;
+        dev->device_cap_flags = IB_DEVICE_LOCAL_DMA_LKEY |
+                                IB_DEVICE_MEM_WINDOW |
+                                IB_DEVICE_MEM_MGT_EXTENSIONS;
 
         /* cxgb3 supports STag 0. */
         dev->ibdev.local_dma_lkey = 0;
-        if (fw_supports_fastreg(dev))
-                dev->device_cap_flags |= IB_DEVICE_MEM_MGT_EXTENSIONS;
 
         dev->ibdev.uverbs_cmd_mask =
             (1ull << IB_USER_VERBS_CMD_GET_CONTEXT) |
diff --git a/drivers/infiniband/hw/cxgb3/iwch_provider.h b/drivers/infiniband/hw/cxgb3/iwch_provider.h
index f5ceca05c435..a237d49bdcc9 100644
--- a/drivers/infiniband/hw/cxgb3/iwch_provider.h
+++ b/drivers/infiniband/hw/cxgb3/iwch_provider.h
@@ -293,9 +293,16 @@ static inline u32 iwch_ib_to_tpt_access(int acc)
         return (acc & IB_ACCESS_REMOTE_WRITE ? TPT_REMOTE_WRITE : 0) |
                (acc & IB_ACCESS_REMOTE_READ ? TPT_REMOTE_READ : 0) |
                (acc & IB_ACCESS_LOCAL_WRITE ? TPT_LOCAL_WRITE : 0) |
+               (acc & IB_ACCESS_MW_BIND ? TPT_MW_BIND : 0) |
                TPT_LOCAL_READ;
 }
 
+static inline u32 iwch_ib_to_tpt_bind_access(int acc)
+{
+        return (acc & IB_ACCESS_REMOTE_WRITE ? TPT_REMOTE_WRITE : 0) |
+               (acc & IB_ACCESS_REMOTE_READ ? TPT_REMOTE_READ : 0);
+}
+
 enum iwch_mmid_state {
         IWCH_STAG_STATE_VALID,
         IWCH_STAG_STATE_INVALID
diff --git a/drivers/infiniband/hw/cxgb3/iwch_qp.c b/drivers/infiniband/hw/cxgb3/iwch_qp.c
index 9a3be3a9d5dc..3e4585c2318a 100644
--- a/drivers/infiniband/hw/cxgb3/iwch_qp.c
+++ b/drivers/infiniband/hw/cxgb3/iwch_qp.c
@@ -565,7 +565,7 @@ int iwch_bind_mw(struct ib_qp *qp,
         wqe->bind.type = TPT_VATO;
 
         /* TBD: check perms */
-        wqe->bind.perms = iwch_ib_to_tpt_access(mw_bind->mw_access_flags);
+        wqe->bind.perms = iwch_ib_to_tpt_bind_access(mw_bind->mw_access_flags);
         wqe->bind.mr_stag = cpu_to_be32(mw_bind->mr->lkey);
         wqe->bind.mw_stag = cpu_to_be32(mw->rkey);
         wqe->bind.mw_len = cpu_to_be32(mw_bind->length);
@@ -879,20 +879,13 @@ static int rdma_init(struct iwch_dev *rhp, struct iwch_qp *qhp,
                 (qhp->attr.mpa_attr.xmit_marker_enabled << 1) |
                 (qhp->attr.mpa_attr.crc_enabled << 2);
 
-        /*
-         * XXX - The IWCM doesn't quite handle getting these
-         * attrs set before going into RTS.  For now, just turn
-         * them on always...
-         */
-#if 0
-        init_attr.qpcaps = qhp->attr.enableRdmaRead |
-                (qhp->attr.enableRdmaWrite << 1) |
-                (qhp->attr.enableBind << 2) |
-                (qhp->attr.enable_stag0_fastreg << 3) |
-                (qhp->attr.enable_stag0_fastreg << 4);
-#else
-        init_attr.qpcaps = 0x1f;
-#endif
+        init_attr.qpcaps = uP_RI_QP_RDMA_READ_ENABLE |
+                           uP_RI_QP_RDMA_WRITE_ENABLE |
+                           uP_RI_QP_BIND_ENABLE;
+        if (!qhp->ibqp.uobject)
+                init_attr.qpcaps |= uP_RI_QP_STAG0_ENABLE |
+                                    uP_RI_QP_FAST_REGISTER_ENABLE;
+
         init_attr.tcp_emss = qhp->ep->emss;
         init_attr.ord = qhp->attr.max_ord;
         init_attr.ird = qhp->attr.max_ird;
@@ -900,8 +893,6 @@ static int rdma_init(struct iwch_dev *rhp, struct iwch_qp *qhp,
         init_attr.qp_dma_size = (1UL << qhp->wq.size_log2);
         init_attr.rqe_count = iwch_rqes_posted(qhp);
         init_attr.flags = qhp->attr.mpa_attr.initiator ? MPA_INITIATOR : 0;
-        if (!qhp->ibqp.uobject)
-                init_attr.flags |= PRIV_QP;
         if (peer2peer) {
                 init_attr.rtr_type = RTR_READ;
                 if (init_attr.ord == 0 && qhp->attr.mpa_attr.initiator)
diff --git a/drivers/infiniband/hw/ipath/ipath_driver.c b/drivers/infiniband/hw/ipath/ipath_driver.c
index daad09a45910..ad0aab60b051 100644
--- a/drivers/infiniband/hw/ipath/ipath_driver.c
+++ b/drivers/infiniband/hw/ipath/ipath_driver.c
@@ -1259,7 +1259,7 @@ reloop:
                          */
                         ipath_cdbg(ERRPKT, "Error Pkt, but no eflags! egrbuf"
                                   " %x, len %x hdrq+%x rhf: %Lx\n",
-                                  etail, tlen, l,
+                                  etail, tlen, l, (unsigned long long)
                                   le64_to_cpu(*(__le64 *) rhf_addr));
                         if (ipath_debug & __IPATH_ERRPKTDBG) {
                                 u32 j, *d, dw = rsize-2;
@@ -1457,7 +1457,8 @@ static void ipath_reset_availshadow(struct ipath_devdata *dd)
                         0xaaaaaaaaaaaaaaaaULL); /* All BUSY bits in qword */
                 if (oldval != dd->ipath_pioavailshadow[i])
                         ipath_dbg("shadow[%d] was %Lx, now %lx\n",
-                                i, oldval, dd->ipath_pioavailshadow[i]);
+                                i, (unsigned long long) oldval,
+                                dd->ipath_pioavailshadow[i]);
         }
         spin_unlock_irqrestore(&ipath_pioavail_lock, flags);
 }
diff --git a/drivers/infiniband/hw/ipath/ipath_iba7220.c b/drivers/infiniband/hw/ipath/ipath_iba7220.c
index fadbfbf55a6a..d90f5e9a54fa 100644
--- a/drivers/infiniband/hw/ipath/ipath_iba7220.c
+++ b/drivers/infiniband/hw/ipath/ipath_iba7220.c
@@ -1032,7 +1032,7 @@ static int ipath_7220_bringup_serdes(struct ipath_devdata *dd)
         ipath_cdbg(VERBOSE, "done: xgxs=%llx from %llx\n",
                    (unsigned long long)
                    ipath_read_kreg64(dd, dd->ipath_kregs->kr_xgxsconfig),
-                   prev_val);
+                   (unsigned long long) prev_val);
 
         guid = be64_to_cpu(dd->ipath_guid);
 
@@ -1042,7 +1042,8 @@ static int ipath_7220_bringup_serdes(struct ipath_devdata *dd)
                 ipath_dbg("No GUID for heartbeat, faking %llx\n",
                         (unsigned long long)guid);
         } else
-                ipath_cdbg(VERBOSE, "Wrote %llX to HRTBT_GUID\n", guid);
+                ipath_cdbg(VERBOSE, "Wrote %llX to HRTBT_GUID\n",
+                        (unsigned long long) guid);
         ipath_write_kreg(dd, dd->ipath_kregs->kr_hrtbt_guid, guid);
         return ret;
 }
@@ -2505,7 +2506,7 @@ done:
         if (dd->ipath_flags & IPATH_IB_AUTONEG_INPROG) {
                 ipath_dbg("Did not get to DDR INIT (%x) after %Lu msecs\n",
                         ipath_ib_state(dd, dd->ipath_lastibcstat),
-                        jiffies_to_msecs(jiffies)-startms);
+                        (unsigned long long) jiffies_to_msecs(jiffies)-startms);
                 dd->ipath_flags &= ~IPATH_IB_AUTONEG_INPROG;
                 if (dd->ipath_autoneg_tries == IPATH_AUTONEG_TRIES) {
                         dd->ipath_flags |= IPATH_IB_AUTONEG_FAILED;
diff --git a/drivers/infiniband/hw/ipath/ipath_intr.c b/drivers/infiniband/hw/ipath/ipath_intr.c
index 26900b3b7a4e..6c21b4b5ec71 100644
--- a/drivers/infiniband/hw/ipath/ipath_intr.c
+++ b/drivers/infiniband/hw/ipath/ipath_intr.c
@@ -356,9 +356,10 @@ static void handle_e_ibstatuschanged(struct ipath_devdata *dd,
                         dd->ipath_cregs->cr_iblinkerrrecovcnt);
                 if (linkrecov != dd->ipath_lastlinkrecov) {
                         ipath_dbg("IB linkrecov up %Lx (%s %s) recov %Lu\n",
-                                ibcs, ib_linkstate(dd, ibcs),
+                                (unsigned long long) ibcs,
+                                ib_linkstate(dd, ibcs),
                                 ipath_ibcstatus_str[ltstate],
-                                linkrecov);
+                                (unsigned long long) linkrecov);
                         /* and no more until active again */
                         dd->ipath_lastlinkrecov = 0;
                         ipath_set_linkstate(dd, IPATH_IB_LINKDOWN);
@@ -1118,9 +1119,11 @@ irqreturn_t ipath_intr(int irq, void *data)
         if (unlikely(istat & ~dd->ipath_i_bitsextant))
                 ipath_dev_err(dd,
                               "interrupt with unknown interrupts %Lx set\n",
+                              (unsigned long long)
                               istat & ~dd->ipath_i_bitsextant);
         else if (istat & ~INFINIPATH_I_ERROR) /* errors do own printing */
-                ipath_cdbg(VERBOSE, "intr stat=0x%Lx\n", istat);
+                ipath_cdbg(VERBOSE, "intr stat=0x%Lx\n",
+                        (unsigned long long) istat);
 
         if (istat & INFINIPATH_I_ERROR) {
                 ipath_stats.sps_errints++;
@@ -1128,7 +1131,8 @@ irqreturn_t ipath_intr(int irq, void *data)
                                           dd->ipath_kregs->kr_errorstatus);
                 if (!estat)
                         dev_info(&dd->pcidev->dev, "error interrupt (%Lx), "
-                                 "but no error bits set!\n", istat);
+                                 "but no error bits set!\n",
+                                 (unsigned long long) istat);
                 else if (estat == -1LL)
                         /*
                          * should we try clearing all, or hope next read
diff --git a/drivers/infiniband/hw/ipath/ipath_verbs.c b/drivers/infiniband/hw/ipath/ipath_verbs.c
index 55c718828826..b766e40e9ebf 100644
--- a/drivers/infiniband/hw/ipath/ipath_verbs.c
+++ b/drivers/infiniband/hw/ipath/ipath_verbs.c
@@ -1021,7 +1021,7 @@ static void sdma_complete(void *cookie, int status)
         struct ipath_verbs_txreq *tx = cookie;
         struct ipath_qp *qp = tx->qp;
         struct ipath_ibdev *dev = to_idev(qp->ibqp.device);
-        unsigned int flags;
+        unsigned long flags;
         enum ib_wc_status ibs = status == IPATH_SDMA_TXREQ_S_OK ?
                 IB_WC_SUCCESS : IB_WC_WR_FLUSH_ERR;
 
@@ -1051,7 +1051,7 @@ static void sdma_complete(void *cookie, int status)
 
 static void decrement_dma_busy(struct ipath_qp *qp)
 {
-        unsigned int flags;
+        unsigned long flags;
 
         if (atomic_dec_and_test(&qp->s_dma_busy)) {
                 spin_lock_irqsave(&qp->s_lock, flags);
@@ -1221,7 +1221,7 @@ static int ipath_verbs_send_pio(struct ipath_qp *qp,
         unsigned flush_wc;
         u32 control;
         int ret;
-        unsigned int flags;
+        unsigned long flags;
 
         piobuf = ipath_getpiobuf(dd, plen, NULL);
         if (unlikely(piobuf == NULL)) {
diff --git a/drivers/infiniband/hw/mlx4/cq.c b/drivers/infiniband/hw/mlx4/cq.c
index a1464574bfdd..d0866a3636e2 100644
--- a/drivers/infiniband/hw/mlx4/cq.c
+++ b/drivers/infiniband/hw/mlx4/cq.c
@@ -515,17 +515,17 @@ static void mlx4_ib_handle_error_cqe(struct mlx4_err_cqe *cqe,
         wc->vendor_err = cqe->vendor_err_syndrome;
 }
 
-static int mlx4_ib_ipoib_csum_ok(__be32 status, __be16 checksum)
+static int mlx4_ib_ipoib_csum_ok(__be16 status, __be16 checksum)
 {
-        return ((status & cpu_to_be32(MLX4_CQE_IPOIB_STATUS_IPV4        |
-                                      MLX4_CQE_IPOIB_STATUS_IPV4F       |
-                                      MLX4_CQE_IPOIB_STATUS_IPV4OPT     |
-                                      MLX4_CQE_IPOIB_STATUS_IPV6        |
-                                      MLX4_CQE_IPOIB_STATUS_IPOK)) ==
-                cpu_to_be32(MLX4_CQE_IPOIB_STATUS_IPV4  |
-                            MLX4_CQE_IPOIB_STATUS_IPOK))                &&
-                (status & cpu_to_be32(MLX4_CQE_IPOIB_STATUS_UDP |
-                                      MLX4_CQE_IPOIB_STATUS_TCP))       &&
+        return ((status & cpu_to_be16(MLX4_CQE_STATUS_IPV4      |
+                                      MLX4_CQE_STATUS_IPV4F     |
+                                      MLX4_CQE_STATUS_IPV4OPT   |
+                                      MLX4_CQE_STATUS_IPV6      |
+                                      MLX4_CQE_STATUS_IPOK)) ==
+                cpu_to_be16(MLX4_CQE_STATUS_IPV4        |
+                            MLX4_CQE_STATUS_IPOK))              &&
+                (status & cpu_to_be16(MLX4_CQE_STATUS_UDP       |
+                                      MLX4_CQE_STATUS_TCP))     &&
                 checksum == cpu_to_be16(0xffff);
 }
 
@@ -582,17 +582,17 @@ repoll:
         }
 
         if (!*cur_qp ||
-            (be32_to_cpu(cqe->my_qpn) & 0xffffff) != (*cur_qp)->mqp.qpn) {
+            (be32_to_cpu(cqe->vlan_my_qpn) & MLX4_CQE_QPN_MASK) != (*cur_qp)->mqp.qpn) {
                 /*
                  * We do not have to take the QP table lock here,
                  * because CQs will be locked while QPs are removed
                  * from the table.
                  */
                 mqp = __mlx4_qp_lookup(to_mdev(cq->ibcq.device)->dev,
-                                       be32_to_cpu(cqe->my_qpn));
+                                       be32_to_cpu(cqe->vlan_my_qpn));
                 if (unlikely(!mqp)) {
                         printk(KERN_WARNING "CQ %06x with entry for unknown QPN %06x\n",
-                               cq->mcq.cqn, be32_to_cpu(cqe->my_qpn) & 0xffffff);
+                               cq->mcq.cqn, be32_to_cpu(cqe->vlan_my_qpn) & MLX4_CQE_QPN_MASK);
                         return -EINVAL;
                 }
 
@@ -692,14 +692,13 @@ repoll:
                 }
 
                 wc->slid           = be16_to_cpu(cqe->rlid);
-                wc->sl             = cqe->sl >> 4;
+                wc->sl             = be16_to_cpu(cqe->sl_vid >> 12);
                 g_mlpath_rqpn      = be32_to_cpu(cqe->g_mlpath_rqpn);
                 wc->src_qp         = g_mlpath_rqpn & 0xffffff;
                 wc->dlid_path_bits = (g_mlpath_rqpn >> 24) & 0x7f;
                 wc->wc_flags      |= g_mlpath_rqpn & 0x80000000 ? IB_WC_GRH : 0;
                 wc->pkey_index     = be32_to_cpu(cqe->immed_rss_invalid) & 0x7f;
-                wc->csum_ok        = mlx4_ib_ipoib_csum_ok(cqe->ipoib_status,
-                                                           cqe->checksum);
+                wc->csum_ok        = mlx4_ib_ipoib_csum_ok(cqe->status, cqe->checksum);
         }
 
         return 0;
@@ -767,7 +766,7 @@ void __mlx4_ib_cq_clean(struct mlx4_ib_cq *cq, u32 qpn, struct mlx4_ib_srq *srq)
          */
         while ((int) --prod_index - (int) cq->mcq.cons_index >= 0) {
                 cqe = get_cqe(cq, prod_index & cq->ibcq.cqe);
-                if ((be32_to_cpu(cqe->my_qpn) & 0xffffff) == qpn) {
+                if ((be32_to_cpu(cqe->vlan_my_qpn) & MLX4_CQE_QPN_MASK) == qpn) {
                         if (srq && !(cqe->owner_sr_opcode & MLX4_CQE_IS_SEND_MASK))
                                 mlx4_ib_free_srq_wqe(srq, be16_to_cpu(cqe->wqe_index));
                         ++nfreed;
diff --git a/drivers/infiniband/hw/mlx4/qp.c b/drivers/infiniband/hw/mlx4/qp.c
index f7bc7dd8578a..f29dbb767e87 100644
--- a/drivers/infiniband/hw/mlx4/qp.c
+++ b/drivers/infiniband/hw/mlx4/qp.c
@@ -902,7 +902,7 @@ static int __mlx4_ib_modify_qp(struct ib_qp *ibqp,
                         context->mtu_msgmax = (IB_MTU_4096 << 5) |
                                               ilog2(dev->dev->caps.max_gso_sz);
                 else
-                        context->mtu_msgmax = (IB_MTU_4096 << 5) | 11;
+                        context->mtu_msgmax = (IB_MTU_4096 << 5) | 12;
         } else if (attr_mask & IB_QP_PATH_MTU) {
                 if (attr->path_mtu < IB_MTU_256 || attr->path_mtu > IB_MTU_4096) {
                         printk(KERN_ERR "path MTU (%u) is invalid\n",
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_cm.c b/drivers/infiniband/ulp/ipoib/ipoib_cm.c
index 0f2d3045061a..7ebc400a4b3d 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib_cm.c
+++ b/drivers/infiniband/ulp/ipoib/ipoib_cm.c
@@ -337,7 +337,7 @@ static void ipoib_cm_init_rx_wr(struct net_device *dev,
                 sge[i].length = PAGE_SIZE;
 
         wr->next    = NULL;
-        wr->sg_list = priv->cm.rx_sge;
+        wr->sg_list = sge;
         wr->num_sge = priv->cm.num_frags;
 }
 
diff --git a/drivers/input/serio/i8042-sparcio.h b/drivers/input/serio/i8042-sparcio.h
index d9ca55891cd7..66bafe308b0c 100644
--- a/drivers/input/serio/i8042-sparcio.h
+++ b/drivers/input/serio/i8042-sparcio.h
@@ -41,6 +41,8 @@ static inline void i8042_write_command(int val)
         writeb(val, kbd_iobase + 0x64UL);
 }
 
+#ifdef CONFIG_PCI
+
 #define OBP_PS2KBD_NAME1        "kb_ps2"
 #define OBP_PS2KBD_NAME2        "keyboard"
 #define OBP_PS2MS_NAME1         "kdmouse"
@@ -101,9 +103,6 @@ static struct of_platform_driver sparc_i8042_driver = {
 
 static int __init i8042_platform_init(void)
 {
-#ifndef CONFIG_PCI
-        return -ENODEV;
-#else
         struct device_node *root = of_find_node_by_path("/");
 
         if (!strcmp(root->name, "SUNW,JavaStation-1")) {
@@ -131,17 +130,25 @@ static int __init i8042_platform_init(void)
         i8042_reset = 1;
 
         return 0;
-#endif /* CONFIG_PCI */
 }
 
 static inline void i8042_platform_exit(void)
 {
-#ifdef CONFIG_PCI
         struct device_node *root = of_find_node_by_path("/");
 
         if (strcmp(root->name, "SUNW,JavaStation-1"))
                 of_unregister_driver(&sparc_i8042_driver);
-#endif
 }
 
+#else /* !CONFIG_PCI */
+static int __init i8042_platform_init(void)
+{
+        return -ENODEV;
+}
+
+static inline void i8042_platform_exit(void)
+{
+}
+#endif /* !CONFIG_PCI */
+
 #endif /* _I8042_SPARCIO_H */
diff --git a/drivers/media/dvb/dvb-usb/cxusb.c b/drivers/media/dvb/dvb-usb/cxusb.c
index 578afce6884c..aaa0b6f0b521 100644
--- a/drivers/media/dvb/dvb-usb/cxusb.c
+++ b/drivers/media/dvb/dvb-usb/cxusb.c
@@ -565,7 +565,8 @@ static int cxusb_lgh064f_tuner_attach(struct dvb_usb_adapter *adap)
 
 static int dvico_bluebird_xc2028_callback(void *ptr, int command, int arg)
 {
-        struct dvb_usb_device *d = ptr;
+        struct dvb_usb_adapter *adap = ptr;
+        struct dvb_usb_device *d = adap->dev;
 
         switch (command) {
         case XC2028_TUNER_RESET:
@@ -593,9 +594,9 @@ static int cxusb_dvico_xc3028_tuner_attach(struct dvb_usb_adapter *adap)
                 .callback  = dvico_bluebird_xc2028_callback,
         };
         static struct xc2028_ctrl ctl = {
-                .fname       = "xc3028-dvico-au-01.fw",
+                .fname       = "xc3028-v27.fw",
                 .max_len     = 64,
-                .scode_table = XC3028_FE_ZARLINK456,
+                .demod       = XC3028_FE_ZARLINK456,
         };
 
         fe = dvb_attach(xc2028_attach, adap->fe, &cfg);
diff --git a/drivers/media/dvb/frontends/Kconfig b/drivers/media/dvb/frontends/Kconfig
index 574dffe91b68..7dbb4a223c99 100644
--- a/drivers/media/dvb/frontends/Kconfig
+++ b/drivers/media/dvb/frontends/Kconfig
@@ -135,9 +135,8 @@ config DVB_CX22702
 
 config DVB_DRX397XD
         tristate "Micronas DRX3975D/DRX3977D based"
-        depends on DVB_CORE && I2C && HOTPLUG
+        depends on DVB_CORE && I2C
         default m if DVB_FE_CUSTOMISE
-        select FW_LOADER
         help
           A DVB-T tuner module. Say Y when you want to support this frontend.
 
diff --git a/drivers/media/video/Kconfig b/drivers/media/video/Kconfig
index d4a6e56a7135..ecbfa1b39b70 100644
--- a/drivers/media/video/Kconfig
+++ b/drivers/media/video/Kconfig
@@ -630,7 +630,7 @@ config VIDEO_ZORAN_ZR36060
         depends on VIDEO_ZORAN
         help
           Say Y to support Zoran boards based on 36060 chips.
-          This includes Iomega Bus, Pinnacle DC10, Linux media Labs 33
+          This includes Iomega Buz, Pinnacle DC10, Linux media Labs 33
           and 33 R10 and AverMedia 6 boards.
 
 config VIDEO_ZORAN_BUZ
diff --git a/drivers/media/video/arv.c b/drivers/media/video/arv.c
index 56ebfd5ef6fa..9e436ad3d34b 100644
--- a/drivers/media/video/arv.c
+++ b/drivers/media/video/arv.c
@@ -29,6 +29,7 @@
 #include <linux/sched.h>
 #include <linux/videodev.h>
 #include <media/v4l2-common.h>
+#include <media/v4l2-ioctl.h>
 #include <linux/mutex.h>
 
 #include <asm/uaccess.h>
@@ -755,7 +756,6 @@ static const struct file_operations ar_fops = {
 
 static struct video_device ar_template = {
         .name           = "Colour AR VGA",
-        .type           = VID_TYPE_CAPTURE,
         .fops           = &ar_fops,
         .release        = ar_release,
         .minor          = -1,
diff --git a/drivers/media/video/em28xx/em28xx-cards.c b/drivers/media/video/em28xx/em28xx-cards.c
index 476ae44a62d2..452da70e719f 100644
--- a/drivers/media/video/em28xx/em28xx-cards.c
+++ b/drivers/media/video/em28xx/em28xx-cards.c
@@ -1015,6 +1015,7 @@ struct em28xx_board em28xx_boards[] = {
                 .valid        = EM28XX_BOARD_NOT_VALIDATED,
                 .vchannels    = 3,
                 .tuner_type   = TUNER_XC2028,
+                .mts_firmware = 1,
                 .decoder      = EM28XX_TVP5150,
                 .input          = { {
                         .type     = EM28XX_VMUX_TELEVISION,
diff --git a/drivers/media/video/gspca/conex.c b/drivers/media/video/gspca/conex.c
index 44b0bffeb20e..cd3a3f5829b2 100644
--- a/drivers/media/video/gspca/conex.c
+++ b/drivers/media/video/gspca/conex.c
@@ -123,7 +123,7 @@ static void reg_r(struct gspca_dev *gspca_dev,
 {
         struct usb_device *dev = gspca_dev->dev;
 
-#ifdef CONFIG_VIDEO_ADV_DEBUG
+#ifdef GSPCA_DEBUG
         if (len > sizeof gspca_dev->usb_buf) {
                 err("reg_r: buffer overflow");
                 return;
@@ -163,7 +163,7 @@ static void reg_w(struct gspca_dev *gspca_dev,
 {
         struct usb_device *dev = gspca_dev->dev;
 
-#ifdef CONFIG_VIDEO_ADV_DEBUG
+#ifdef GSPCA_DEBUG
         if (len > sizeof gspca_dev->usb_buf) {
                 err("reg_w: buffer overflow");
                 return;
diff --git a/drivers/media/video/gspca/etoms.c b/drivers/media/video/gspca/etoms.c
index c8c2f02fcf00..1dbe92d01e6a 100644
--- a/drivers/media/video/gspca/etoms.c
+++ b/drivers/media/video/gspca/etoms.c
@@ -233,7 +233,7 @@ static void reg_r(struct gspca_dev *gspca_dev,
 {
         struct usb_device *dev = gspca_dev->dev;
 
-#ifdef CONFIG_VIDEO_ADV_DEBUG
+#ifdef GSPCA_DEBUG
         if (len > sizeof gspca_dev->usb_buf) {
                 err("reg_r: buffer overflow");
                 return;
@@ -271,7 +271,7 @@ static void reg_w(struct gspca_dev *gspca_dev,
 {
         struct usb_device *dev = gspca_dev->dev;
 
-#ifdef CONFIG_VIDEO_ADV_DEBUG
+#ifdef GSPCA_DEBUG
         if (len > sizeof gspca_dev->usb_buf) {
                 err("reg_w: buffer overflow");
                 return;
@@ -461,6 +461,52 @@ static void Et_init2(struct gspca_dev *gspca_dev)
         reg_w_val(gspca_dev, 0x80, 0x20);       /* 0x20; */
 }
 
+static void setbrightness(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        int i;
+        __u8 brightness = sd->brightness;
+
+        for (i = 0; i < 4; i++)
+                reg_w_val(gspca_dev, ET_O_RED + i, brightness);
+}
+
+static void getbrightness(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        int i;
+        int brightness = 0;
+
+        for (i = 0; i < 4; i++) {
+                reg_r(gspca_dev, ET_O_RED + i, 1);
+                brightness += gspca_dev->usb_buf[0];
+        }
+        sd->brightness = brightness >> 3;
+}
+
+static void setcontrast(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        __u8 RGBG[] = { 0x80, 0x80, 0x80, 0x80, 0x00, 0x00 };
+        __u8 contrast = sd->contrast;
+
+        memset(RGBG, contrast, sizeof(RGBG) - 2);
+        reg_w(gspca_dev, ET_G_RED, RGBG, 6);
+}
+
+static void getcontrast(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        int i;
+        int contrast = 0;
+
+        for (i = 0; i < 4; i++) {
+                reg_r(gspca_dev, ET_G_RED + i, 1);
+                contrast += gspca_dev->usb_buf[0];
+        }
+        sd->contrast = contrast >> 2;
+}
+
 static void setcolors(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
@@ -492,6 +538,16 @@ static void getcolors(struct gspca_dev *gspca_dev)
         }
 }
 
+static void setautogain(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        if (sd->autogain)
+                sd->ag_cnt = AG_CNT_START;
+        else
+                sd->ag_cnt = -1;
+}
+
 static void Et_init1(struct gspca_dev *gspca_dev)
 {
         __u8 value;
@@ -614,6 +670,7 @@ static int sd_config(struct gspca_dev *gspca_dev,
         sd->contrast = CONTRAST_DEF;
         sd->colors = COLOR_DEF;
         sd->autogain = AUTOGAIN_DEF;
+        sd->ag_cnt = -1;
         return 0;
 }
 
@@ -641,6 +698,8 @@ static void sd_start(struct gspca_dev *gspca_dev)
         else
                 Et_init2(gspca_dev);
 
+        setautogain(gspca_dev);
+
         reg_w_val(gspca_dev, ET_RESET_ALL, 0x08);
         et_video(gspca_dev, 1);         /* video on */
 }
@@ -658,52 +717,6 @@ static void sd_close(struct gspca_dev *gspca_dev)
 {
 }
 
-static void setbrightness(struct gspca_dev *gspca_dev)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-        int i;
-        __u8 brightness = sd->brightness;
-
-        for (i = 0; i < 4; i++)
-                reg_w_val(gspca_dev, ET_O_RED + i, brightness);
-}
-
-static void getbrightness(struct gspca_dev *gspca_dev)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-        int i;
-        int brightness = 0;
-
-        for (i = 0; i < 4; i++) {
-                reg_r(gspca_dev, ET_O_RED + i, 1);
-                brightness += gspca_dev->usb_buf[0];
-        }
-        sd->brightness = brightness >> 3;
-}
-
-static void setcontrast(struct gspca_dev *gspca_dev)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-        __u8 RGBG[] = { 0x80, 0x80, 0x80, 0x80, 0x00, 0x00 };
-        __u8 contrast = sd->contrast;
-
-        memset(RGBG, contrast, sizeof(RGBG) - 2);
-        reg_w(gspca_dev, ET_G_RED, RGBG, 6);
-}
-
-static void getcontrast(struct gspca_dev *gspca_dev)
-{
-        struct sd *sd = (struct sd *) gspca_dev;
-        int i;
-        int contrast = 0;
-
-        for (i = 0; i < 4; i++) {
-                reg_r(gspca_dev, ET_G_RED + i, 1);
-                contrast += gspca_dev->usb_buf[0];
-        }
-        sd->contrast = contrast >> 2;
-}
-
 static __u8 Et_getgainG(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
@@ -733,15 +746,22 @@ static void Et_setgainG(struct gspca_dev *gspca_dev, __u8 gain)
 #define LIMIT(color) \
         (unsigned char)((color > 0xff)?0xff:((color < 0)?0:color))
 
-static void setautogain(struct gspca_dev *gspca_dev)
+static void do_autogain(struct gspca_dev *gspca_dev)
 {
-        __u8 luma = 0;
+        struct sd *sd = (struct sd *) gspca_dev;
+        __u8 luma;
         __u8 luma_mean = 128;
         __u8 luma_delta = 20;
         __u8 spring = 4;
-        int Gbright = 0;
+        int Gbright;
         __u8 r, g, b;
 
+        if (sd->ag_cnt < 0)
+                return;
+        if (--sd->ag_cnt >= 0)
+                return;
+        sd->ag_cnt = AG_CNT_START;
+
         Gbright = Et_getgainG(gspca_dev);
         reg_r(gspca_dev, ET_LUMA_CENTER, 4);
         g = (gspca_dev->usb_buf[0] + gspca_dev->usb_buf[3]) >> 1;
@@ -768,7 +788,6 @@ static void sd_pkt_scan(struct gspca_dev *gspca_dev,
                         __u8 *data,                     /* isoc packet */
                         int len)                        /* iso packet length */
 {
-        struct sd *sd;
         int seqframe;
 
         seqframe = data[0] & 0x3f;
@@ -783,13 +802,6 @@ static void sd_pkt_scan(struct gspca_dev *gspca_dev,
                 frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame,
                                         data, 0);
                 gspca_frame_add(gspca_dev, FIRST_PACKET, frame, data, len);
-                sd = (struct sd *) gspca_dev;
-                if (sd->ag_cnt >= 0) {
-                        if (--sd->ag_cnt < 0) {
-                                sd->ag_cnt = AG_CNT_START;
-                                setautogain(gspca_dev);
-                        }
-                }
                 return;
         }
         if (len) {
@@ -862,10 +874,8 @@ static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val)
         struct sd *sd = (struct sd *) gspca_dev;
 
         sd->autogain = val;
-        if (val)
-                sd->ag_cnt = AG_CNT_START;
-        else
-                sd->ag_cnt = -1;
+        if (gspca_dev->streaming)
+                setautogain(gspca_dev);
         return 0;
 }
 
@@ -889,6 +899,7 @@ static struct sd_desc sd_desc = {
         .stop0 = sd_stop0,
         .close = sd_close,
         .pkt_scan = sd_pkt_scan,
+        .dq_callback = do_autogain,
 };
 
 /* -- module initialisation -- */
diff --git a/drivers/media/video/gspca/gspca.c b/drivers/media/video/gspca/gspca.c
index 3a051c925ff6..15d302b28b79 100644
--- a/drivers/media/video/gspca/gspca.c
+++ b/drivers/media/video/gspca/gspca.c
@@ -47,7 +47,7 @@ MODULE_LICENSE("GPL");
 
 static int video_nr = -1;
 
-#ifdef CONFIG_VIDEO_ADV_DEBUG
+#ifdef GSPCA_DEBUG
 int gspca_debug = D_ERR | D_PROBE;
 EXPORT_SYMBOL(gspca_debug);
 
@@ -677,7 +677,7 @@ static int try_fmt_vid_cap(struct gspca_dev *gspca_dev,
         w = fmt->fmt.pix.width;
         h = fmt->fmt.pix.height;
 
-#ifdef CONFIG_VIDEO_ADV_DEBUG
+#ifdef GSPCA_DEBUG
         if (gspca_debug & D_CONF)
                 PDEBUG_MODE("try fmt cap", fmt->fmt.pix.pixelformat, w, h);
 #endif
@@ -785,7 +785,7 @@ static int dev_open(struct inode *inode, struct file *file)
         }
         gspca_dev->users++;
         file->private_data = gspca_dev;
-#ifdef CONFIG_VIDEO_ADV_DEBUG
+#ifdef GSPCA_DEBUG
         /* activate the v4l2 debug */
         if (gspca_debug & D_V4L2)
                 gspca_dev->vdev.debug |= 3;
@@ -904,7 +904,7 @@ static int vidioc_s_ctrl(struct file *file, void *priv,
                 if (ctrl->id != ctrls->qctrl.id)
                         continue;
                 if (ctrl->value < ctrls->qctrl.minimum
-                    && ctrl->value > ctrls->qctrl.maximum)
+                    || ctrl->value > ctrls->qctrl.maximum)
                         return -ERANGE;
                 PDEBUG(D_CONF, "set ctrl [%08x] = %d", ctrl->id, ctrl->value);
                 if (mutex_lock_interruptible(&gspca_dev->usb_lock))
@@ -1080,7 +1080,7 @@ static int vidioc_streamon(struct file *file, void *priv,
                 if (ret < 0)
                         goto out;
         }
-#ifdef CONFIG_VIDEO_ADV_DEBUG
+#ifdef GSPCA_DEBUG
         if (gspca_debug & D_STREAM) {
                 PDEBUG_MODE("stream on OK",
                         gspca_dev->pixfmt,
@@ -1913,7 +1913,7 @@ static void __exit gspca_exit(void)
 module_init(gspca_init);
 module_exit(gspca_exit);
 
-#ifdef CONFIG_VIDEO_ADV_DEBUG
+#ifdef GSPCA_DEBUG
 module_param_named(debug, gspca_debug, int, 0644);
 MODULE_PARM_DESC(debug,
                 "Debug (bit) 0x01:error 0x02:probe 0x04:config"
diff --git a/drivers/media/video/gspca/gspca.h b/drivers/media/video/gspca/gspca.h
index 3fd2c4eee204..67e448940eaa 100644
--- a/drivers/media/video/gspca/gspca.h
+++ b/drivers/media/video/gspca/gspca.h
@@ -9,7 +9,10 @@
 #include <media/v4l2-common.h>
 #include <linux/mutex.h>
 
-#ifdef CONFIG_VIDEO_ADV_DEBUG
+/* compilation option */
+#define GSPCA_DEBUG 1
+
+#ifdef GSPCA_DEBUG
 /* GSPCA our debug messages */
 extern int gspca_debug;
 #define PDEBUG(level, fmt, args...) \
diff --git a/drivers/media/video/gspca/ov519.c b/drivers/media/video/gspca/ov519.c
index 83139efc4629..b4f00ec0885c 100644
--- a/drivers/media/video/gspca/ov519.c
+++ b/drivers/media/video/gspca/ov519.c
@@ -40,14 +40,15 @@ struct sd {
         struct gspca_dev gspca_dev;             /* !! must be the first item */
 
         /* Determined by sensor type */
-        short maxwidth;
-        short maxheight;
+        char sif;
 
         unsigned char primary_i2c_slave;        /* I2C write id of sensor */
 
         unsigned char brightness;
         unsigned char contrast;
         unsigned char colors;
+        __u8 hflip;
+        __u8 vflip;
 
         char compress;          /* Should the next frame be compressed? */
         char compress_inited;   /* Are compression params uploaded? */
@@ -77,9 +78,12 @@ static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val);
 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val);
 static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val);
 static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val);
+static int sd_sethflip(struct gspca_dev *gspca_dev, __s32 val);
+static int sd_gethflip(struct gspca_dev *gspca_dev, __s32 *val);
+static int sd_setvflip(struct gspca_dev *gspca_dev, __s32 val);
+static int sd_getvflip(struct gspca_dev *gspca_dev, __s32 *val);
 
 static struct ctrl sd_ctrls[] = {
-#define SD_BRIGHTNESS 0
         {
             {
                 .id      = V4L2_CID_BRIGHTNESS,
@@ -88,12 +92,12 @@ static struct ctrl sd_ctrls[] = {
                 .minimum = 0,
                 .maximum = 255,
                 .step    = 1,
-                .default_value = 127,
+#define BRIGHTNESS_DEF 127
+                .default_value = BRIGHTNESS_DEF,
             },
             .set = sd_setbrightness,
             .get = sd_getbrightness,
         },
-#define SD_CONTRAST 1
         {
             {
                 .id      = V4L2_CID_CONTRAST,
@@ -102,31 +106,61 @@ static struct ctrl sd_ctrls[] = {
                 .minimum = 0,
                 .maximum = 255,
                 .step    = 1,
-                .default_value = 127,
+#define CONTRAST_DEF 127
+                .default_value = CONTRAST_DEF,
             },
             .set = sd_setcontrast,
             .get = sd_getcontrast,
         },
-#define SD_COLOR 2
         {
             {
                 .id      = V4L2_CID_SATURATION,
                 .type    = V4L2_CTRL_TYPE_INTEGER,
-                .name    = "Saturation",
+                .name    = "Color",
                 .minimum = 0,
                 .maximum = 255,
                 .step    = 1,
-                .default_value = 127,
+#define COLOR_DEF 127
+                .default_value = COLOR_DEF,
             },
             .set = sd_setcolors,
             .get = sd_getcolors,
         },
+/* next controls work with ov7670 only */
+        {
+            {
+                .id      = V4L2_CID_HFLIP,
+                .type    = V4L2_CTRL_TYPE_BOOLEAN,
+                .name    = "Mirror",
+                .minimum = 0,
+                .maximum = 1,
+                .step    = 1,
+#define HFLIP_DEF 0
+                .default_value = HFLIP_DEF,
+            },
+            .set = sd_sethflip,
+            .get = sd_gethflip,
+        },
+        {
+            {
+                .id      = V4L2_CID_VFLIP,
+                .type    = V4L2_CTRL_TYPE_BOOLEAN,
+                .name    = "Vflip",
+                .minimum = 0,
+                .maximum = 1,
+                .step    = 1,
+#define VFLIP_DEF 0
+                .default_value = VFLIP_DEF,
+            },
+            .set = sd_setvflip,
+            .get = sd_getvflip,
+        },
 };
 
 static struct v4l2_pix_format vga_mode[] = {
         {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
                 .bytesperline = 320,
-                .sizeimage = 320 * 240 * 3 / 8 + 589,
+                .sizeimage = 320 * 240 * 3 / 8 + 590,
                 .colorspace = V4L2_COLORSPACE_JPEG,
                 .priv = 1},
         {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
@@ -138,12 +172,12 @@ static struct v4l2_pix_format vga_mode[] = {
 static struct v4l2_pix_format sif_mode[] = {
         {176, 144, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
                 .bytesperline = 176,
-                .sizeimage = 176 * 144 * 3 / 8 + 589,
+                .sizeimage = 176 * 144 * 3 / 8 + 590,
                 .colorspace = V4L2_COLORSPACE_JPEG,
                 .priv = 1},
         {352, 288, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
                 .bytesperline = 352,
-                .sizeimage = 352 * 288 * 3 / 8 + 589,
+                .sizeimage = 352 * 288 * 3 / 8 + 590,
                 .colorspace = V4L2_COLORSPACE_JPEG,
                 .priv = 0},
 };
@@ -225,6 +259,7 @@ static struct v4l2_pix_format sif_mode[] = {
 #define OV7670_REG_VSTART      0x19    /* Vert start high bits */
 #define OV7670_REG_VSTOP       0x1a    /* Vert stop high bits */
 #define OV7670_REG_MVFP        0x1e    /* Mirror / vflip */
+#define   OV7670_MVFP_VFLIP      0x10    /* vertical flip */
 #define   OV7670_MVFP_MIRROR     0x20    /* Mirror image */
 #define OV7670_REG_AEW         0x24    /* AGC upper limit */
 #define OV7670_REG_AEB         0x25    /* AGC lower limit */
@@ -258,16 +293,6 @@ static struct v4l2_pix_format sif_mode[] = {
 #define OV7670_REG_HAECC7      0xaa    /* Hist AEC/AGC control 7 */
 #define OV7670_REG_BD60MAX     0xab    /* 60hz banding step limit */
 
-struct ovsensor_window {
-        short x;
-        short y;
-        short width;
-        short height;
-/*      int format; */
-        short quarter;          /* Scale width and height down 2x */
-        short clockdiv;         /* Clock divisor setting */
-};
-
 static unsigned char ov7670_abs_to_sm(unsigned char v)
 {
         if (v > 127)
@@ -499,19 +524,6 @@ static int init_ov_sensor(struct sd *sd)
         return 0;
 }
 
-/* Switch on standard JPEG compression. Returns 0 for success. */
-static int ov519_init_compression(struct sd *sd)
-{
-        if (!sd->compress_inited) {
-                if (reg_w_mask(sd, OV519_SYS_EN_CLK1, 1 << 2, 1 << 2) < 0) {
-                        PDEBUG(D_ERR, "Error switching to compressed mode");
-                        return -EIO;
-                }
-                sd->compress_inited = 1;
-        }
-        return 0;
-}
-
 /* Set the read and write slave IDs. The "slave" argument is the write slave,
  * and the read slave will be set to (slave + 1).
  * This should not be called from outside the i2c I/O functions.
@@ -681,21 +693,17 @@ static int ov8xx0_configure(struct sd *sd)
                 return -1;
         }
         if ((rc & 3) == 1) {
-                PDEBUG(D_PROBE, "Sensor is an OV8610");
                 sd->sensor = SEN_OV8610;
         } else {
                 PDEBUG(D_ERR, "Unknown image sensor version: %d", rc & 3);
                 return -1;
         }
         PDEBUG(D_PROBE, "Writing 8610 registers");
-        if (write_i2c_regvals(sd,
-                        norm_8610,
-                        sizeof norm_8610 / sizeof norm_8610[0]))
+        if (write_i2c_regvals(sd, norm_8610, ARRAY_SIZE(norm_8610)))
                 return -1;
 
         /* Set sensor-specific vars */
-        sd->maxwidth = 640;
-        sd->maxheight = 480;
+/*      sd->sif = 0;            already done */
         return 0;
 }
 
@@ -825,7 +833,7 @@ static int ov7xx0_configure(struct sd *sd)
                 { OV7670_REG_COM7, OV7670_COM7_RESET },
                 { OV7670_REG_TSLB, 0x04 },              /* OV */
                 { OV7670_REG_COM7, OV7670_COM7_FMT_VGA }, /* VGA */
-                { OV7670_REG_CLKRC, 0x1 },
+                { OV7670_REG_CLKRC, 0x01 },
         /*
          * Set the hardware window.  These values from OV don't entirely
          * make sense - hstop is less than hstart.  But they work...
@@ -839,16 +847,12 @@ static int ov7xx0_configure(struct sd *sd)
                 { 0x70, 0x3a },         { 0x71, 0x35 },
                 { 0x72, 0x11 },         { 0x73, 0xf0 },
                 { 0xa2, 0x02 },
-/* jfm */
-/* { OV7670_REG_COM10, 0x0 }, */
+/*              { OV7670_REG_COM10, 0x0 }, */
 
         /* Gamma curve values */
                 { 0x7a, 0x20 },
-/* jfm:win 7b=1c */
                 { 0x7b, 0x10 },
-/* jfm:win 7c=28 */
                 { 0x7c, 0x1e },
-/* jfm:win 7d=3c */
                 { 0x7d, 0x35 },
                 { 0x7e, 0x5a },         { 0x7f, 0x69 },
                 { 0x80, 0x76 },         { 0x81, 0x80 },
@@ -864,13 +868,11 @@ static int ov7xx0_configure(struct sd *sd)
                                  | OV7670_COM8_BFILT },
                 { OV7670_REG_GAIN, 0 }, { OV7670_REG_AECH, 0 },
                 { OV7670_REG_COM4, 0x40 }, /* magic reserved bit */
-/* jfm:win 14=38 */
                 { OV7670_REG_COM9, 0x18 }, /* 4x gain + magic rsvd bit */
                 { OV7670_REG_BD50MAX, 0x05 },   { OV7670_REG_BD60MAX, 0x07 },
                 { OV7670_REG_AEW, 0x95 },       { OV7670_REG_AEB, 0x33 },
                 { OV7670_REG_VPT, 0xe3 },       { OV7670_REG_HAECC1, 0x78 },
                 { OV7670_REG_HAECC2, 0x68 },
-/* jfm:win a1=0b */
                 { 0xa1, 0x03 }, /* magic */
                 { OV7670_REG_HAECC3, 0xd8 },    { OV7670_REG_HAECC4, 0xd8 },
                 { OV7670_REG_HAECC5, 0xf0 },    { OV7670_REG_HAECC6, 0x90 },
@@ -884,8 +886,6 @@ static int ov7xx0_configure(struct sd *sd)
         /* Almost all of these are magic "reserved" values.  */
                 { OV7670_REG_COM5, 0x61 },      { OV7670_REG_COM6, 0x4b },
                 { 0x16, 0x02 },
-/* jfm */
-/*              { OV7670_REG_MVFP, 0x07|OV7670_MVFP_MIRROR }, */
                 { OV7670_REG_MVFP, 0x07 },
                 { 0x21, 0x02 },         { 0x22, 0x91 },
                 { 0x29, 0x07 },         { 0x33, 0x0b },
@@ -930,7 +930,10 @@ static int ov7xx0_configure(struct sd *sd)
                 { OV7670_REG_EDGE, 0 },
                 { 0x75, 0x05 },         { 0x76, 0xe1 },
                 { 0x4c, 0 },            { 0x77, 0x01 },
-                { OV7670_REG_COM13, 0xc3 },     { 0x4b, 0x09 },
+                { OV7670_REG_COM13, OV7670_COM13_GAMMA
+                                  | OV7670_COM13_UVSAT
+                                  | 2},         /* was 3 */
+                { 0x4b, 0x09 },
                 { 0xc9, 0x60 },         { OV7670_REG_COM16, 0x38 },
                 { 0x56, 0x40 },
 
@@ -956,30 +959,10 @@ static int ov7xx0_configure(struct sd *sd)
                 { 0x79, 0x03 },         { 0xc8, 0x40 },
                 { 0x79, 0x05 },         { 0xc8, 0x30 },
                 { 0x79, 0x26 },
-
-        /* Format YUV422 */
-                { OV7670_REG_COM7, OV7670_COM7_YUV },  /* Selects YUV mode */
-                { OV7670_REG_RGB444, 0 },       /* No RGB444 please */
-                { OV7670_REG_COM1, 0 },
-                { OV7670_REG_COM15, OV7670_COM15_R00FF },
-                { OV7670_REG_COM9, 0x18 },
-                                /* 4x gain ceiling; 0x8 is reserved bit */
-                { 0x4f, 0x80 },         /* "matrix coefficient 1" */
-                { 0x50, 0x80 },         /* "matrix coefficient 2" */
-                { 0x52, 0x22 },         /* "matrix coefficient 4" */
-                { 0x53, 0x5e },         /* "matrix coefficient 5" */
-                { 0x54, 0x80 },         /* "matrix coefficient 6" */
-                { OV7670_REG_COM13, OV7670_COM13_GAMMA|OV7670_COM13_UVSAT },
-};
+        };
 
         PDEBUG(D_PROBE, "starting OV7xx0 configuration");
 
-/* jfm:already done? */
-        if (init_ov_sensor(sd) < 0)
-                PDEBUG(D_ERR, "Failed to read sensor ID");
-        else
-                PDEBUG(D_PROBE, "OV7xx0 initialized");
-
         /* Detect sensor (sub)type */
         rc = i2c_r(sd, OV7610_REG_COM_I);
 
@@ -1025,20 +1008,25 @@ static int ov7xx0_configure(struct sd *sd)
                         return low;
                 }
                 if (high == 0x76) {
-                        if (low == 0x30) {
+                        switch (low) {
+                        case 0x30:
                                 PDEBUG(D_PROBE, "Sensor is an OV7630/OV7635");
                                 sd->sensor = SEN_OV7630;
-                        } else if (low == 0x40) {
+                                break;
+                        case 0x40:
                                 PDEBUG(D_PROBE, "Sensor is an OV7645");
                                 sd->sensor = SEN_OV7640; /* FIXME */
-                        } else if (low == 0x45) {
+                                break;
+                        case 0x45:
                                 PDEBUG(D_PROBE, "Sensor is an OV7645B");
                                 sd->sensor = SEN_OV7640; /* FIXME */
-                        } else if (low == 0x48) {
+                                break;
+                        case 0x48:
                                 PDEBUG(D_PROBE, "Sensor is an OV7648");
                                 sd->sensor = SEN_OV7640; /* FIXME */
-                        } else {
-                                PDEBUG(D_PROBE, "Unknown sensor: 0x76%X", low);
+                                break;
+                        default:
+                                PDEBUG(D_PROBE, "Unknown sensor: 0x76%x", low);
                                 return -1;
                         }
                 } else {
@@ -1050,34 +1038,34 @@ static int ov7xx0_configure(struct sd *sd)
                 return -1;
         }
 
-        if (sd->sensor == SEN_OV7620) {
+        switch (sd->sensor) {
+        case SEN_OV7620:
                 PDEBUG(D_PROBE, "Writing 7620 registers");
-                if (write_i2c_regvals(sd, norm_7620,
-                                sizeof norm_7620 / sizeof norm_7620[0]))
+                if (write_i2c_regvals(sd, norm_7620, ARRAY_SIZE(norm_7620)))
                         return -1;
-        } else if (sd->sensor == SEN_OV7630) {
+                break;
+        case SEN_OV7630:
                 PDEBUG(D_ERR, "7630 is not supported by this driver version");
                 return -1;
-        } else if (sd->sensor == SEN_OV7640) {
+        case SEN_OV7640:
                 PDEBUG(D_PROBE, "Writing 7640 registers");
-                if (write_i2c_regvals(sd, norm_7640,
-                                sizeof norm_7640 / sizeof norm_7640[0]))
+                if (write_i2c_regvals(sd, norm_7640, ARRAY_SIZE(norm_7640)))
                         return -1;
-        } else if (sd->sensor == SEN_OV7670) {
+                break;
+        case SEN_OV7670:
                 PDEBUG(D_PROBE, "Writing 7670 registers");
-                if (write_i2c_regvals(sd, norm_7670,
-                                sizeof norm_7670 / sizeof norm_7670[0]))
+                if (write_i2c_regvals(sd, norm_7670, ARRAY_SIZE(norm_7670)))
                         return -1;
-        } else {
+                break;
+        default:
                 PDEBUG(D_PROBE, "Writing 7610 registers");
-                if (write_i2c_regvals(sd, norm_7610,
-                                sizeof norm_7610 / sizeof norm_7610[0]))
+                if (write_i2c_regvals(sd, norm_7610, ARRAY_SIZE(norm_7610)))
                         return -1;
+                break;
         }
 
         /* Set sensor-specific vars */
-        sd->maxwidth = 640;
-        sd->maxheight = 480;
+/*      sd->sif = 0;            already done */
         return 0;
 }
 
@@ -1231,43 +1219,45 @@ static int ov6xx0_configure(struct sd *sd)
         /* Ugh. The first two bits are the version bits, but
          * the entire register value must be used. I guess OVT
          * underestimated how many variants they would make. */
-        if (rc == 0x00) {
+        switch (rc) {
+        case 0x00:
                 sd->sensor = SEN_OV6630;
                 PDEBUG(D_ERR,
                         "WARNING: Sensor is an OV66308. Your camera may have");
                 PDEBUG(D_ERR, "been misdetected in previous driver versions.");
-        } else if (rc == 0x01) {
+                break;
+        case 0x01:
                 sd->sensor = SEN_OV6620;
-                PDEBUG(D_PROBE, "Sensor is an OV6620");
-        } else if (rc == 0x02) {
+                break;
+        case 0x02:
                 sd->sensor = SEN_OV6630;
                 PDEBUG(D_PROBE, "Sensor is an OV66308AE");
-        } else if (rc == 0x03) {
+                break;
+        case 0x03:
                 sd->sensor = SEN_OV6630;
                 PDEBUG(D_PROBE, "Sensor is an OV66308AF");
-        } else if (rc == 0x90) {
+                break;
+        case 0x90:
                 sd->sensor = SEN_OV6630;
                 PDEBUG(D_ERR,
                         "WARNING: Sensor is an OV66307. Your camera may have");
                 PDEBUG(D_ERR, "been misdetected in previous driver versions.");
-        } else {
+                break;
+        default:
                 PDEBUG(D_ERR, "FATAL: Unknown sensor version: 0x%02x", rc);
                 return -1;
         }
 
         /* Set sensor-specific vars */
-        sd->maxwidth = 352;
-        sd->maxheight = 288;
+        sd->sif = 1;
 
         if (sd->sensor == SEN_OV6620) {
                 PDEBUG(D_PROBE, "Writing 6x20 registers");
-                if (write_i2c_regvals(sd, norm_6x20,
-                                sizeof norm_6x20 / sizeof norm_6x20[0]))
+                if (write_i2c_regvals(sd, norm_6x20, ARRAY_SIZE(norm_6x20)))
                         return -1;
         } else {
                 PDEBUG(D_PROBE, "Writing 6x30 registers");
-                if (write_i2c_regvals(sd, norm_6x30,
-                                sizeof norm_6x30 / sizeof norm_6x30[0]))
+                if (write_i2c_regvals(sd, norm_6x30, ARRAY_SIZE(norm_6x30)))
                         return -1;
         }
         return 0;
@@ -1276,14 +1266,8 @@ static int ov6xx0_configure(struct sd *sd)
 /* Turns on or off the LED. Only has an effect with OV511+/OV518(+)/OV519 */
 static void ov51x_led_control(struct sd *sd, int on)
 {
-        PDEBUG(D_STREAM, "LED (%s)", on ? "on" : "off");
-
-/*      if (sd->bridge == BRG_OV511PLUS) */
-/*              reg_w(sd, R511_SYS_LED_CTL, on ? 1 : 0); */
-/*      else if (sd->bridge == BRG_OV519) */
-                reg_w_mask(sd, OV519_GPIO_DATA_OUT0, !on, 1);   /* 0 / 1 */
-/*      else if (sd->bclass == BCL_OV518) */
-/*              reg_w_mask(sd, R518_GPIO_OUT, on ? 0x02 : 0x00, 0x02); */
+/*      PDEBUG(D_STREAM, "LED (%s)", on ? "on" : "off"); */
+        reg_w_mask(sd, OV519_GPIO_DATA_OUT0, !on, 1);   /* 0 / 1 */
 }
 
 /* this function is called at probe time */
@@ -1293,11 +1277,8 @@ static int sd_config(struct gspca_dev *gspca_dev,
         struct sd *sd = (struct sd *) gspca_dev;
         struct cam *cam;
 
-/* (from ov519_configure) */
         static const struct ov_regvals init_519[] = {
                 { 0x5a,  0x6d }, /* EnableSystem */
-/* jfm trace usbsnoop3-1.txt */
-/* jfm 53 = fb */
                 { 0x53,  0x9b },
                 { 0x54,  0xff }, /* set bit2 to enable jpeg */
                 { 0x5d,  0x03 },
@@ -1314,9 +1295,6 @@ static int sd_config(struct gspca_dev *gspca_dev,
 
         if (write_regvals(sd, init_519, ARRAY_SIZE(init_519)))
                 goto error;
-/* jfm: not seen in windows trace */
-        if (ov519_init_compression(sd))
-                goto error;
         ov51x_led_control(sd, 0);       /* turn LED off */
 
         /* Test for 76xx */
@@ -1365,16 +1343,18 @@ static int sd_config(struct gspca_dev *gspca_dev,
 
         cam = &gspca_dev->cam;
         cam->epaddr = OV511_ENDPOINT_ADDRESS;
-        if (sd->maxwidth == 640) {
+        if (!sd->sif) {
                 cam->cam_mode = vga_mode;
-                cam->nmodes = sizeof vga_mode / sizeof vga_mode[0];
+                cam->nmodes = ARRAY_SIZE(vga_mode);
         } else {
                 cam->cam_mode = sif_mode;
-                cam->nmodes = sizeof sif_mode / sizeof sif_mode[0];
+                cam->nmodes = ARRAY_SIZE(sif_mode);
         }
-        sd->brightness = sd_ctrls[SD_BRIGHTNESS].qctrl.default_value;
-        sd->contrast = sd_ctrls[SD_CONTRAST].qctrl.default_value;
-        sd->colors = sd_ctrls[SD_COLOR].qctrl.default_value;
+        sd->brightness = BRIGHTNESS_DEF;
+        sd->contrast = CONTRAST_DEF;
+        sd->colors = COLOR_DEF;
+        sd->hflip = HFLIP_DEF;
+        sd->vflip = VFLIP_DEF;
         return 0;
 error:
         PDEBUG(D_ERR, "OV519 Config failed");
@@ -1394,8 +1374,7 @@ static int sd_open(struct gspca_dev *gspca_dev)
  *
  * Do not put any sensor-specific code in here (including I2C I/O functions)
  */
-static int ov519_mode_init_regs(struct sd *sd,
-                                int width, int height)
+static int ov519_mode_init_regs(struct sd *sd)
 {
         static const struct ov_regvals mode_init_519_ov7670[] = {
                 { 0x5d, 0x03 }, /* Turn off suspend mode */
@@ -1441,36 +1420,23 @@ static int ov519_mode_init_regs(struct sd *sd,
                 /* windows reads 0x55 at this point, why? */
         };
 
-/* int hi_res; */
-
-        PDEBUG(D_CONF, "mode init %dx%d", width, height);
-
-/*      if (width >= 800 && height >= 600)
-                hi_res = 1;
-        else
-                hi_res = 0; */
-
-/*      if (ov51x_stop(sd) < 0)
-                return -EIO; */
-
         /******** Set the mode ********/
         if (sd->sensor != SEN_OV7670) {
                 if (write_regvals(sd, mode_init_519,
                                   ARRAY_SIZE(mode_init_519)))
                         return -EIO;
+                if (sd->sensor == SEN_OV7640) {
+                        /* Select 8-bit input mode */
+                        reg_w_mask(sd, OV519_CAM_DFR, 0x10, 0x10);
+                }
         } else {
                 if (write_regvals(sd, mode_init_519_ov7670,
                                   ARRAY_SIZE(mode_init_519_ov7670)))
                         return -EIO;
         }
 
-        if (sd->sensor == SEN_OV7640) {
-                /* Select 8-bit input mode */
-                reg_w_mask(sd, OV519_CAM_DFR, 0x10, 0x10);
-        }
-
-        reg_w(sd, OV519_CAM_H_SIZE,     width >> 4);
-        reg_w(sd, OV519_CAM_V_SIZE,     height >> 3);
+        reg_w(sd, OV519_CAM_H_SIZE,     sd->gspca_dev.width >> 4);
+        reg_w(sd, OV519_CAM_V_SIZE,     sd->gspca_dev.height >> 3);
         reg_w(sd, OV519_CAM_X_OFFSETL,  0x00);
         reg_w(sd, OV519_CAM_X_OFFSETH,  0x00);
         reg_w(sd, OV519_CAM_Y_OFFSETL,  0x00);
@@ -1485,9 +1451,10 @@ static int ov519_mode_init_regs(struct sd *sd,
 
 /* FIXME: These are only valid at the max resolution. */
         sd->clockdiv = 0;
-        if (sd->sensor == SEN_OV7640) {
+        switch (sd->sensor) {
+        case SEN_OV7640:
                 switch (sd->frame_rate) {
-/*jfm: default was 30 fps */
+/*fixme: default was 30 fps */
                 case 30:
                         reg_w(sd, 0xa4, 0x0c);
                         reg_w(sd, 0x23, 0xff);
@@ -1517,7 +1484,8 @@ static int ov519_mode_init_regs(struct sd *sd,
                         sd->clockdiv = 1;
                         break;
                 }
-        } else if (sd->sensor == SEN_OV8610) {
+                break;
+        case SEN_OV8610:
                 switch (sd->frame_rate) {
                 default:        /* 15 fps */
 /*              case 15: */
@@ -1533,41 +1501,37 @@ static int ov519_mode_init_regs(struct sd *sd,
                         reg_w(sd, 0x23, 0x1b);
                         break;
                 }
-                sd->clockdiv = 0;
-        } else if (sd->sensor == SEN_OV7670) { /* guesses, based on 7640 */
+                break;
+        case SEN_OV7670:                /* guesses, based on 7640 */
                 PDEBUG(D_STREAM, "Setting framerate to %d fps",
                                  (sd->frame_rate == 0) ? 15 : sd->frame_rate);
+                reg_w(sd, 0xa4, 0x10);
                 switch (sd->frame_rate) {
                 case 30:
-                        reg_w(sd, 0xa4, 0x10);
                         reg_w(sd, 0x23, 0xff);
                         break;
                 case 20:
-                        reg_w(sd, 0xa4, 0x10);
                         reg_w(sd, 0x23, 0x1b);
                         break;
-                default: /* 15 fps */
-/*                      case 15: */
-                        reg_w(sd, 0xa4, 0x10);
+                default:
+/*              case 15: */
                         reg_w(sd, 0x23, 0xff);
                         sd->clockdiv = 1;
                         break;
                 }
+                break;
         }
 
-/*      if (ov51x_restart(sd) < 0)
-                return -EIO; */
-
-        /* Reset it just for good measure */
-/*      if (ov51x_reset(sd, OV511_RESET_NOREGS) < 0)
-                return -EIO; */
         return 0;
 }
 
-static int mode_init_ov_sensor_regs(struct sd *sd,
-                                struct ovsensor_window *win)
+static int mode_init_ov_sensor_regs(struct sd *sd)
 {
-        int qvga = win->quarter;
+        struct gspca_dev *gspca_dev;
+        int qvga;
+
+        gspca_dev = &sd->gspca_dev;
+        qvga = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv;
 
         /******** Mode (VGA/QVGA) and sensor specific regs ********/
         switch (sd->sensor) {
@@ -1611,8 +1575,6 @@ static int mode_init_ov_sensor_regs(struct sd *sd,
                          OV7670_COM7_FMT_MASK);
                 break;
         case SEN_OV6620:
-                i2c_w_mask(sd, 0x14, qvga ? 0x20 : 0x00, 0x20);
-                break;
         case SEN_OV6630:
                 i2c_w_mask(sd, 0x14, qvga ? 0x20 : 0x00, 0x20);
                 break;
@@ -1621,24 +1583,21 @@ static int mode_init_ov_sensor_regs(struct sd *sd,
         }
 
         /******** Palette-specific regs ********/
-/* Need to do work here for the OV7670 */
-
-                if (sd->sensor == SEN_OV7610 || sd->sensor == SEN_OV76BE) {
-                        /* not valid on the OV6620/OV7620/6630? */
-                        i2c_w_mask(sd, 0x0e, 0x00, 0x40);
-                }
+        if (sd->sensor == SEN_OV7610 || sd->sensor == SEN_OV76BE) {
+                /* not valid on the OV6620/OV7620/6630? */
+                i2c_w_mask(sd, 0x0e, 0x00, 0x40);
+        }
 
-                /* The OV518 needs special treatment. Although both the OV518
-                 * and the OV6630 support a 16-bit video bus, only the 8 bit Y
-                 * bus is actually used. The UV bus is tied to ground.
-                 * Therefore, the OV6630 needs to be in 8-bit multiplexed
-                 * output mode */
+        /* The OV518 needs special treatment. Although both the OV518
+         * and the OV6630 support a 16-bit video bus, only the 8 bit Y
+         * bus is actually used. The UV bus is tied to ground.
+         * Therefore, the OV6630 needs to be in 8-bit multiplexed
+         * output mode */
 
-                /* OV7640 is 8-bit only */
+        /* OV7640 is 8-bit only */
 
-                if (sd->sensor != SEN_OV6630 && sd->sensor != SEN_OV7640)
-                        i2c_w_mask(sd, 0x13, 0x00, 0x20);
-/*      } */
+        if (sd->sensor != SEN_OV6630 && sd->sensor != SEN_OV7640)
+                i2c_w_mask(sd, 0x13, 0x00, 0x20);
 
         /******** Clock programming ********/
         /* The OV6620 needs special handling. This prevents the
@@ -1647,14 +1606,14 @@ static int mode_init_ov_sensor_regs(struct sd *sd,
 
                 /* Clock down */
                 i2c_w(sd, 0x2a, 0x04);
-                i2c_w(sd, 0x11, win->clockdiv);
+                i2c_w(sd, 0x11, sd->clockdiv);
                 i2c_w(sd, 0x2a, 0x84);
                 /* This next setting is critical. It seems to improve
                  * the gain or the contrast. The "reserved" bits seem
                  * to have some effect in this case. */
                 i2c_w(sd, 0x2d, 0x85);
-        } else if (win->clockdiv >= 0) {
-                i2c_w(sd, 0x11, win->clockdiv);
+        } else if (sd->clockdiv >= 0) {
+                i2c_w(sd, 0x11, sd->clockdiv);
         }
 
         /******** Special Features ********/
@@ -1674,7 +1633,7 @@ static int mode_init_ov_sensor_regs(struct sd *sd,
         /* is fully tested. */
         /* 7620/6620/6630? don't have register 0x35, so play it safe */
         if (sd->sensor == SEN_OV7610 || sd->sensor == SEN_OV76BE) {
-                if (win->width == 640 /*&& win->height == 480*/)
+                if (!qvga)
                         i2c_w(sd, 0x35, 0x9e);
                 else
                         i2c_w(sd, 0x35, 0x1e);
@@ -1682,13 +1641,31 @@ static int mode_init_ov_sensor_regs(struct sd *sd,
         return 0;
 }
 
-static int set_ov_sensor_window(struct sd *sd,
-                                struct ovsensor_window *win)
+static void sethvflip(struct sd *sd)
 {
+        if (sd->sensor != SEN_OV7670)
+                return;
+        if (sd->gspca_dev.streaming)
+                ov51x_stop(sd);
+        i2c_w_mask(sd, OV7670_REG_MVFP,
+                OV7670_MVFP_MIRROR * sd->hflip
+                        | OV7670_MVFP_VFLIP * sd->vflip,
+                OV7670_MVFP_MIRROR | OV7670_MVFP_VFLIP);
+        if (sd->gspca_dev.streaming)
+                ov51x_restart(sd);
+}
+
+static int set_ov_sensor_window(struct sd *sd)
+{
+        struct gspca_dev *gspca_dev;
+        int qvga;
         int hwsbase, hwebase, vwsbase, vwebase, hwscale, vwscale;
         int ret, hstart, hstop, vstop, vstart;
         __u8 v;
 
+        gspca_dev = &sd->gspca_dev;
+        qvga = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv;
+
         /* The different sensor ICs handle setting up of window differently.
          * IF YOU SET IT WRONG, YOU WILL GET ALL ZERO ISOC DATA FROM OV51x!! */
         switch (sd->sensor) {
@@ -1733,7 +1710,7 @@ static int set_ov_sensor_window(struct sd *sd,
         switch (sd->sensor) {
         case SEN_OV6620:
         case SEN_OV6630:
-                if (win->quarter) {     /* QCIF */
+                if (qvga) {             /* QCIF */
                         hwscale = 0;
                         vwscale = 0;
                 } else {                /* CIF */
@@ -1743,7 +1720,7 @@ static int set_ov_sensor_window(struct sd *sd,
                 }
                 break;
         case SEN_OV8610:
-                if (win->quarter) {     /* QSVGA */
+                if (qvga) {             /* QSVGA */
                         hwscale = 1;
                         vwscale = 1;
                 } else {                /* SVGA */
@@ -1752,7 +1729,7 @@ static int set_ov_sensor_window(struct sd *sd,
                 }
                 break;
         default:                        /* SEN_OV7xx0 */
-                if (win->quarter) {     /* QVGA */
+                if (qvga) {             /* QVGA */
                         hwscale = 1;
                         vwscale = 0;
                 } else {                /* VGA */
@@ -1761,7 +1738,7 @@ static int set_ov_sensor_window(struct sd *sd,
                 }
         }
 
-        ret = mode_init_ov_sensor_regs(sd, win);
+        ret = mode_init_ov_sensor_regs(sd);
         if (ret < 0)
                 return ret;
 
@@ -1782,7 +1759,7 @@ static int set_ov_sensor_window(struct sd *sd,
         /* I can hard code this for OV7670s */
         /* Yes, these numbers do look odd, but they're tested and work! */
         if (sd->sensor == SEN_OV7670) {
-                if (win->quarter) {     /* QVGA from ov7670.c by
+                if (qvga) {             /* QVGA from ov7670.c by
                                          * Jonathan Corbet */
                         hstart = 164;
                         hstop = 20;
@@ -1796,75 +1773,45 @@ static int set_ov_sensor_window(struct sd *sd,
                 }
                 /* OV7670 hardware window registers are split across
                  * multiple locations */
-                i2c_w(sd, OV7670_REG_HSTART, (hstart >> 3) & 0xff);
-                i2c_w(sd, OV7670_REG_HSTOP, (hstop >> 3) & 0xff);
+                i2c_w(sd, OV7670_REG_HSTART, hstart >> 3);
+                i2c_w(sd, OV7670_REG_HSTOP, hstop >> 3);
                 v = i2c_r(sd, OV7670_REG_HREF);
                 v = (v & 0xc0) | ((hstop & 0x7) << 3) | (hstart & 0x07);
                 msleep(10);     /* need to sleep between read and write to
                                  * same reg! */
                 i2c_w(sd, OV7670_REG_HREF, v);
 
-                i2c_w(sd, OV7670_REG_VSTART, (vstart >> 2) & 0xff);
-                i2c_w(sd, OV7670_REG_VSTOP, (vstop >> 2) & 0xff);
+                i2c_w(sd, OV7670_REG_VSTART, vstart >> 2);
+                i2c_w(sd, OV7670_REG_VSTOP, vstop >> 2);
                 v = i2c_r(sd, OV7670_REG_VREF);
                 v = (v & 0xc0) | ((vstop & 0x3) << 2) | (vstart & 0x03);
                 msleep(10);     /* need to sleep between read and write to
                                  * same reg! */
                 i2c_w(sd, OV7670_REG_VREF, v);
-
+                sethvflip(sd);
         } else {
-                i2c_w(sd, 0x17, hwsbase + (win->x >> hwscale));
-                i2c_w(sd, 0x18, hwebase + ((win->x + win->width) >> hwscale));
-                i2c_w(sd, 0x19, vwsbase + (win->y >> vwscale));
-                i2c_w(sd, 0x1a, vwebase + ((win->y + win->height) >> vwscale));
+                i2c_w(sd, 0x17, hwsbase);
+                i2c_w(sd, 0x18, hwebase + (sd->gspca_dev.width >> hwscale));
+                i2c_w(sd, 0x19, vwsbase);
+                i2c_w(sd, 0x1a, vwebase + (sd->gspca_dev.height >> vwscale));
         }
         return 0;
 }
 
-static int ov_sensor_mode_setup(struct sd *sd,
-                                int width, int height)
-{
-        struct ovsensor_window win;
-
-/*      win.format = mode; */
-
-        /* Unless subcapture is enabled,
-         * center the image window and downsample
-         * if possible to increase the field of view */
-        /* NOTE: OV518(+) and OV519 does downsampling on its own */
-        win.width = width;
-        win.height = height;
-        if (width == sd->maxwidth)
-                win.quarter = 0;
-        else
-                win.quarter = 1;
-
-        /* Center it */
-        win.x = (win.width - width) / 2;
-        win.y = (win.height - height) / 2;
-
-        /* Clock is determined by OV519 frame rate code */
-        win.clockdiv = sd->clockdiv;
-
-        PDEBUG(D_CONF, "Setting clock divider to %d", win.clockdiv);
-        return set_ov_sensor_window(sd, &win);
-}
-
 /* -- start the camera -- */
 static void sd_start(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
         int ret;
 
-
-        ret = ov519_mode_init_regs(sd, gspca_dev->width, gspca_dev->height);
+        ret = ov519_mode_init_regs(sd);
         if (ret < 0)
                 goto out;
-        ret = ov_sensor_mode_setup(sd, gspca_dev->width, gspca_dev->height);
+        ret = set_ov_sensor_window(sd);
         if (ret < 0)
                 goto out;
 
-        ret = ov51x_restart((struct sd *) gspca_dev);
+        ret = ov51x_restart(sd);
         if (ret < 0)
                 goto out;
         PDEBUG(D_STREAM, "camera started alt: 0x%02x", gspca_dev->alt);
@@ -1938,12 +1885,10 @@ static void setbrightness(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
         int val;
-/*      int was_streaming; */
 
         val = sd->brightness;
         PDEBUG(D_CONF, "brightness:%d", val);
-/*      was_streaming = gspca_dev->streaming;
- *      if (was_streaming)
+/*      if (gspca_dev->streaming)
  *              ov51x_stop(sd); */
         switch (sd->sensor) {
         case SEN_OV8610:
@@ -1961,12 +1906,12 @@ static void setbrightness(struct gspca_dev *gspca_dev)
                         i2c_w(sd, OV7610_REG_BRT, val);
                 break;
         case SEN_OV7670:
-/*jfm - from windblows
+/*win trace
  *              i2c_w_mask(sd, OV7670_REG_COM8, 0, OV7670_COM8_AEC); */
                 i2c_w(sd, OV7670_REG_BRIGHT, ov7670_abs_to_sm(val));
                 break;
         }
-/*      if (was_streaming)
+/*      if (gspca_dev->streaming)
  *              ov51x_restart(sd); */
 }
 
@@ -1974,12 +1919,10 @@ static void setcontrast(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
         int val;
-/*      int was_streaming; */
 
         val = sd->contrast;
         PDEBUG(D_CONF, "contrast:%d", val);
-/*      was_streaming = gspca_dev->streaming;
-        if (was_streaming)
+/*      if (gspca_dev->streaming)
                 ov51x_stop(sd); */
         switch (sd->sensor) {
         case SEN_OV7610:
@@ -2016,7 +1959,7 @@ static void setcontrast(struct gspca_dev *gspca_dev)
                 i2c_w(sd, OV7670_REG_CONTRAS, val >> 1);
                 break;
         }
-/*      if (was_streaming)
+/*      if (gspca_dev->streaming)
                 ov51x_restart(sd); */
 }
 
@@ -2024,12 +1967,10 @@ static void setcolors(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
         int val;
-/*      int was_streaming; */
 
         val = sd->colors;
         PDEBUG(D_CONF, "saturation:%d", val);
-/*      was_streaming = gspca_dev->streaming;
-        if (was_streaming)
+/*      if (gspca_dev->streaming)
                 ov51x_stop(sd); */
         switch (sd->sensor) {
         case SEN_OV8610:
@@ -2055,7 +1996,7 @@ static void setcolors(struct gspca_dev *gspca_dev)
                 /* set REG_COM13 values for UV sat auto mode */
                 break;
         }
-/*      if (was_streaming)
+/*      if (gspca_dev->streaming)
                 ov51x_restart(sd); */
 }
 
@@ -2110,6 +2051,40 @@ static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val)
         return 0;
 }
 
+static int sd_sethflip(struct gspca_dev *gspca_dev, __s32 val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        sd->hflip = val;
+        sethvflip(sd);
+        return 0;
+}
+
+static int sd_gethflip(struct gspca_dev *gspca_dev, __s32 *val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        *val = sd->hflip;
+        return 0;
+}
+
+static int sd_setvflip(struct gspca_dev *gspca_dev, __s32 val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        sd->vflip = val;
+        sethvflip(sd);
+        return 0;
+}
+
+static int sd_getvflip(struct gspca_dev *gspca_dev, __s32 *val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        *val = sd->vflip;
+        return 0;
+}
+
 /* sub-driver description */
 static const struct sd_desc sd_desc = {
         .name = MODULE_NAME,
@@ -2178,4 +2153,3 @@ module_exit(sd_mod_exit);
 
 module_param(frame_rate, int, 0644);
 MODULE_PARM_DESC(frame_rate, "Frame rate (5, 10, 15, 20 or 30 fps)");
-
diff --git a/drivers/media/video/gspca/pac7311.c b/drivers/media/video/gspca/pac7311.c
index ea3d7021f401..815bea6edc44 100644
--- a/drivers/media/video/gspca/pac7311.c
+++ b/drivers/media/video/gspca/pac7311.c
@@ -31,7 +31,9 @@ MODULE_LICENSE("GPL");
 struct sd {
         struct gspca_dev gspca_dev;             /* !! must be the first item */
 
-        int avg_lum;
+        int lum_sum;
+        atomic_t avg_lum;
+        atomic_t do_gain;
 
         unsigned char brightness;
         unsigned char contrast;
@@ -271,6 +273,7 @@ static int sd_config(struct gspca_dev *gspca_dev,
         sd->contrast = CONTRAST_DEF;
         sd->colors = COLOR_DEF;
         sd->autogain = AUTOGAIN_DEF;
+        sd->ag_cnt = -1;
         return 0;
 }
 
@@ -311,6 +314,18 @@ static void setcolors(struct gspca_dev *gspca_dev)
         PDEBUG(D_CONF|D_STREAM, "color: %i", sd->colors);
 }
 
+static void setautogain(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        if (sd->autogain) {
+                sd->lum_sum = 0;
+                sd->ag_cnt = AG_CNT_START;
+        } else {
+                sd->ag_cnt = -1;
+        }
+}
+
 /* this function is called at open time */
 static int sd_open(struct gspca_dev *gspca_dev)
 {
@@ -320,8 +335,6 @@ static int sd_open(struct gspca_dev *gspca_dev)
 
 static void sd_start(struct gspca_dev *gspca_dev)
 {
-        struct sd *sd = (struct sd *) gspca_dev;
-
         reg_w(gspca_dev, 0xff, 0x01);
         reg_w_buf(gspca_dev, 0x0002, "\x48\x0a\x40\x08\x00\x00\x08\x00", 8);
         reg_w_buf(gspca_dev, 0x000a, "\x06\xff\x11\xff\x5a\x30\x90\x4c", 8);
@@ -394,6 +407,7 @@ static void sd_start(struct gspca_dev *gspca_dev)
         setcontrast(gspca_dev);
         setbrightness(gspca_dev);
         setcolors(gspca_dev);
+        setautogain(gspca_dev);
 
         /* set correct resolution */
         switch (gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv) {
@@ -431,13 +445,6 @@ static void sd_start(struct gspca_dev *gspca_dev)
         reg_w(gspca_dev, 0xff, 0x01);
         reg_w(gspca_dev, 0x78, 0x04);
         reg_w(gspca_dev, 0x78, 0x05);
-
-        if (sd->autogain) {
-                sd->ag_cnt = AG_CNT_START;
-                sd->avg_lum = 0;
-        } else {
-                sd->ag_cnt = -1;
-        }
 }
 
 static void sd_stopN(struct gspca_dev *gspca_dev)
@@ -473,13 +480,20 @@ static void sd_close(struct gspca_dev *gspca_dev)
         reg_w(gspca_dev, 0x78, 0x44); /* Bit_0=start stream, Bit_7=LED */
 }
 
-static void setautogain(struct gspca_dev *gspca_dev, int luma)
+static void do_autogain(struct gspca_dev *gspca_dev)
 {
+        struct sd *sd = (struct sd *) gspca_dev;
+        int luma;
         int luma_mean = 128;
         int luma_delta = 20;
         __u8 spring = 5;
         int Gbright;
 
+        if (!atomic_read(&sd->do_gain))
+                return;
+        atomic_set(&sd->do_gain, 0);
+
+        luma = atomic_read(&sd->avg_lum);
         Gbright = reg_r(gspca_dev, 0x02);
         PDEBUG(D_FRAM, "luma mean %d", luma);
         if (luma < luma_mean - luma_delta ||
@@ -523,12 +537,13 @@ static void sd_pkt_scan(struct gspca_dev *gspca_dev,
 
                         /* start of frame */
                         if (sd->ag_cnt >= 0 && p > 28) {
-                                sd->avg_lum += data[p - 23];
+                                sd->lum_sum += data[p - 23];
                                 if (--sd->ag_cnt < 0) {
                                         sd->ag_cnt = AG_CNT_START;
-                                        setautogain(gspca_dev,
-                                                sd->avg_lum / AG_CNT_START);
-                                        sd->avg_lum = 0;
+                                        atomic_set(&sd->avg_lum,
+                                                sd->lum_sum / AG_CNT_START);
+                                        sd->lum_sum = 0;
+                                        atomic_set(&sd->do_gain, 1);
                                 }
                         }
 
@@ -677,12 +692,8 @@ static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val)
         struct sd *sd = (struct sd *) gspca_dev;
 
         sd->autogain = val;
-        if (val) {
-                sd->ag_cnt = AG_CNT_START;
-                sd->avg_lum = 0;
-        } else {
-                sd->ag_cnt = -1;
-        }
+        if (gspca_dev->streaming)
+                setautogain(gspca_dev);
         return 0;
 }
 
@@ -706,6 +717,7 @@ static struct sd_desc sd_desc = {
         .stop0 = sd_stop0,
         .close = sd_close,
         .pkt_scan = sd_pkt_scan,
+        .dq_callback = do_autogain,
 };
 
 /* -- module initialisation -- */
diff --git a/drivers/media/video/gspca/sonixb.c b/drivers/media/video/gspca/sonixb.c
index e18748c5a14d..11210c71f66c 100644
--- a/drivers/media/video/gspca/sonixb.c
+++ b/drivers/media/video/gspca/sonixb.c
@@ -408,7 +408,7 @@ static void reg_w(struct gspca_dev *gspca_dev,
                   const __u8 *buffer,
                   int len)
 {
-#ifdef CONFIG_VIDEO_ADV_DEBUG
+#ifdef GSPCA_DEBUG
         if (len > sizeof gspca_dev->usb_buf) {
                 PDEBUG(D_ERR|D_PACK, "reg_w: buffer overflow");
                 return;
diff --git a/drivers/media/video/gspca/sonixj.c b/drivers/media/video/gspca/sonixj.c
index 33a3df1f6915..245a30ec5fb1 100644
--- a/drivers/media/video/gspca/sonixj.c
+++ b/drivers/media/video/gspca/sonixj.c
@@ -32,7 +32,7 @@ MODULE_LICENSE("GPL");
 struct sd {
         struct gspca_dev gspca_dev;     /* !! must be the first item */
 
-        int avg_lum;
+        atomic_t avg_lum;
         unsigned int exposure;
 
         unsigned short brightness;
@@ -148,55 +148,58 @@ static struct v4l2_pix_format vga_mode[] = {
 
 /*Data from sn9c102p+hv71331r */
 static const __u8 sn_hv7131[] = {
-/*      reg0  reg1  reg2  reg3  reg4  reg5  reg6  reg7  reg8  reg9 */
-        0x00, 0x03, 0x64, 0x00, 0x1A, 0x20, 0x20, 0x20, 0xA1, 0x11,
-/*      rega  regb  regc  regd  rege  regf  reg10 reg11 */
-        0x02, 0x09, 0x00, 0x00, 0x00, 0x10, 0x03, 0x00,         /* 00 */
-/*      reg12 reg13 reg14 reg15 reg16 reg17 reg18 reg19 reg1a reg1b */
-        0x00, 0x01, 0x03, 0x28, 0x1e, 0x41, 0x0a, 0x00, 0x00, 0x00,
-/*      reg1c reg1d reg1e reg1f reg20 reg21 reg22 reg23 */
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+/*      reg0    reg1    reg2    reg3    reg4    reg5    reg6    reg7 */
+        0x00,   0x03,   0x64,   0x00,   0x1a,   0x20,   0x20,   0x20,
+/*      reg8    reg9    rega    regb    regc    regd    rege    regf */
+        0xa1,   0x11,   0x02,   0x09,   0x00,   0x00,   0x00,   0x10,
+/*      reg10   reg11   reg12   reg13   reg14   reg15   reg16   reg17 */
+        0x03,   0x00,   0x00,   0x01,   0x03,   0x28,   0x1e,   0x41,
+/*      reg18   reg19   reg1a   reg1b   reg1c   reg1d   reg1e   reg1f */
+        0x0a,   0x00,   0x00,   0x00,   0x00,   0x00,   0x00,   0x00
 };
 
 static const __u8 sn_mi0360[] = {
-/*      reg0  reg1  reg2  reg3  reg4  reg5  reg6  reg7  reg8  reg9 */
-        0x00, 0x61, 0x44, 0x00, 0x1a, 0x20, 0x20, 0x20, 0xb1, 0x5d,
-/*      rega  regb  regc  regd  rege  regf  reg10 reg11 */
-        0x07, 0x00, 0x00, 0x00, 0x00, 0x10, 0x03, 0x00,
-/*      reg12 reg13 reg14 reg15 reg16 reg17 reg18 reg19 reg1a reg1b */
-        0x00, 0x02, 0x0a, 0x28, 0x1e, 0x61, 0x06, 0x00, 0x00, 0x00,
-/*      reg1c reg1d reg1e reg1f reg20 reg21 reg22 reg23 */
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+/*      reg0    reg1    reg2    reg3    reg4    reg5    reg6    reg7 */
+        0x00,   0x61,   0x44,   0x00,   0x1a,   0x20,   0x20,   0x20,
+/*      reg8    reg9    rega    regb    regc    regd    rege    regf */
+        0xb1,   0x5d,   0x07,   0x00,   0x00,   0x00,   0x00,   0x10,
+/*      reg10   reg11   reg12   reg13   reg14   reg15   reg16   reg17 */
+        0x03,   0x00,   0x00,   0x02,   0x0a,   0x28,   0x1e,   0x61,
+/*      reg18   reg19   reg1a   reg1b   reg1c   reg1d   reg1e   reg1f */
+        0x06,   0x00,   0x00,   0x00,   0x00,   0x00,   0x00,   0x00
 };
 
 static const __u8 sn_mo4000[] = {
-/*      reg0    reg1    reg2    reg3    reg4    reg5    reg6    reg7    reg8 */
-        0x12,   0x23,   0x60,   0x00,   0x1A,   0x00,   0x20,   0x18,   0x81,
-/*      reg9    rega    regb    regc    regd    rege    regf    reg10   reg11*/
-        0x21,   0x00,   0x00,   0x00,   0x00,   0x00,   0x00,   0x03,   0x00,
-/*      reg12   reg13   reg14   reg15   reg16   reg17   reg18   reg19   reg1a*/
-        0x0b,   0x0f,   0x14,   0x28,   0x1e,   0x40,   0x08,   0x00,   0x00,
-/*      reg1b   reg1c   reg1d   reg1e   reg1f   reg20   reg21   reg22   reg23*/
-        0x00,   0x00,   0x00,   0x00,   0x00,   0x08,   0x25,   0x39,   0x4b,
-        0x5c,   0x6b,   0x79,   0x87,   0x95,   0xa2,   0xaf,   0xbb,   0xc7,
-        0xd3,   0xdf,   0xea,   0xf5
+/*      reg0    reg1    reg2    reg3    reg4    reg5    reg6    reg7 */
+        0x12,   0x23,   0x60,   0x00,   0x1a,   0x00,   0x20,   0x18,
+/*      reg8    reg9    rega    regb    regc    regd    rege    regf */
+        0x81,   0x21,   0x00,   0x00,   0x00,   0x00,   0x00,   0x00,
+/*      reg10   reg11   reg12   reg13   reg14   reg15   reg16   reg17 */
+        0x03,    0x00,  0x0b,   0x0f,   0x14,   0x28,   0x1e,   0x40,
+/*      reg18   reg19   reg1a   reg1b   reg1c   reg1d   reg1e   reg1f */
+        0x08,   0x00,   0x00,   0x00,   0x00,   0x00,   0x00,   0x00
 };
 
 static const __u8 sn_ov7648[] = {
-        0x00, 0x21, 0x62, 0x00, 0x1a, 0x20, 0x20, 0x20, 0xA1, 0x6E, 0x18, 0x65,
-        0x00, 0x00, 0x00, 0x10, 0x03, 0x00, 0x00, 0x06, 0x06, 0x28, 0x1E, 0x82,
-        0x07, 0x00, 0x00, 0x00, 0x00, 0x00
+/*      reg0    reg1    reg2    reg3    reg4    reg5    reg6    reg7 */
+        0x00,   0x21,   0x62,   0x00,   0x1a,   0x20,   0x20,   0x20,
+/*      reg8    reg9    rega    regb    regc    regd    rege    regf */
+        0xa1,   0x6e,   0x18,   0x65,   0x00,   0x00,   0x00,   0x10,
+/*      reg10   reg11   reg12   reg13   reg14   reg15   reg16   reg17 */
+        0x03,   0x00,   0x00,   0x06,   0x06,   0x28,   0x1e,   0x82,
+/*      reg18   reg19   reg1a   reg1b   reg1c   reg1d   reg1e   reg1f */
+        0x07,   0x00,   0x00,   0x00,   0x00,   0x00
 };
 
 static const __u8 sn_ov7660[]   = {
-/*      reg0    reg1    reg2    reg3    reg4    reg5    reg6    reg7    reg8 */
-        0x00,   0x61,   0x40,   0x00,   0x1a,   0x00,   0x00,   0x00,   0x81,
-/*      reg9    rega    regb    regc    regd    rege    regf    reg10   reg11*/
-        0x21,   0x00,   0x00,   0x00,   0x00,   0x00,   0x00,   0x03,   0x00,
-/*      reg12   reg13   reg14   reg15   reg16   reg17   reg18   reg19   reg1a*/
-        0x01,   0x01,   0x14,   0x28,   0x1e,   0x00,   0x07,   0x00,   0x00,
-/*      reg1b   reg1c   reg1d   reg1e   reg1f   reg20   reg21   reg22   reg23*/
-        0x00,   0x00,   0x00,   0x00,   0x00,   0x00,   0x00,   0x00,   0x00
+/*      reg0    reg1    reg2    reg3    reg4    reg5    reg6    reg7 */
+        0x00,   0x61,   0x40,   0x00,   0x1a,   0x20,   0x20,   0x20,
+/*      reg8    reg9    rega    regb    regc    regd    rege    regf */
+        0x81,   0x21,   0x07,   0x00,   0x00,   0x00,   0x00,   0x10,
+/*      reg10   reg11   reg12   reg13   reg14   reg15   reg16   reg17 */
+        0x03,   0x00,   0x01,   0x01,   0x08,   0x28,   0x1e,   0x20,
+/*      reg18   reg19   reg1a   reg1b   reg1c   reg1d   reg1e   reg1f */
+        0x07,   0x00,   0x00,   0x00,   0x00,   0x00,   0x00,   0x00,
 };
 
 /* sequence specific to the sensors - !! index = SENSOR_xxx */
@@ -212,10 +215,6 @@ static const __u8 regsn20[] = {
         0x00, 0x2d, 0x46, 0x5a, 0x6c, 0x7c, 0x8b, 0x99,
         0xa6, 0xb2, 0xbf, 0xca, 0xd5, 0xe0, 0xeb, 0xf5, 0xff
 };
-static const __u8 regsn20_sn9c120[] = {
-        0x00, 0x25, 0x3c, 0x50, 0x62, 0x72, 0x81, 0x90,
-        0x9e, 0xab, 0xb8, 0xc5, 0xd1, 0xdd, 0xe9, 0xf4, 0xff
-};
 static const __u8 regsn20_sn9c325[] = {
         0x0a, 0x3a, 0x56, 0x6c, 0x7e, 0x8d, 0x9a, 0xa4,
         0xaf, 0xbb, 0xc5, 0xcd, 0xd5, 0xde, 0xe8, 0xed, 0xf5
@@ -227,21 +226,6 @@ static const __u8 reg84[] = {
 /*      0x00, 0x00, 0x00, 0x00, 0x00 */
         0xf7, 0x0f, 0x0a, 0x00, 0x00
 };
-static const __u8 reg84_sn9c120_1[] = {
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x0c, 0x00, 0x00
-};
-static const __u8 reg84_sn9c120_2[] = {
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x0c, 0x02, 0x3b
-};
-static const __u8 reg84_sn9c120_3[] = {
-        0x14, 0x00, 0x27, 0x00, 0x08, 0x00, 0xeb, 0x0f,
-        0xd5, 0x0f, 0x42, 0x00, 0x41, 0x00, 0xca, 0x0f,
-        0xf5, 0x0f, 0x0c, 0x02, 0x3b
-};
 static const __u8 reg84_sn9c325[] = {
         0x14, 0x00, 0x27, 0x00, 0x07, 0x00, 0xe4, 0x0f,
         0xd3, 0x0f, 0x4b, 0x00, 0x48, 0x00, 0xc0, 0x0f,
@@ -360,17 +344,15 @@ static const __u8 ov7660_sensor_init[][8] = {
         {0xa1, 0x21, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10}, /* reset SCCB */
 /*              (delay 20ms) */
         {0xa1, 0x21, 0x12, 0x05, 0x00, 0x00, 0x00, 0x10},
-                                                /* Outformat ?? rawRGB */
+                                                /* Outformat = rawRGB */
         {0xa1, 0x21, 0x13, 0xb8, 0x00, 0x00, 0x00, 0x10}, /* init COM8 */
-        {0xd1, 0x21, 0x00, 0x01, 0x74, 0x92, 0x00, 0x10},
-/*      {0xd1, 0x21, 0x00, 0x01, 0x74, 0x74, 0x00, 0x10}, */
+        {0xd1, 0x21, 0x00, 0x01, 0x74, 0x74, 0x00, 0x10},
                                                 /* GAIN BLUE RED VREF */
         {0xd1, 0x21, 0x04, 0x00, 0x7d, 0x62, 0x00, 0x10},
                                                 /* COM 1 BAVE GEAVE AECHH */
         {0xb1, 0x21, 0x08, 0x83, 0x01, 0x00, 0x00, 0x10}, /* RAVE COM2 */
         {0xd1, 0x21, 0x0c, 0x00, 0x08, 0x04, 0x4f, 0x10}, /* COM 3 4 5 6 */
-        {0xd1, 0x21, 0x10, 0x7f, 0x40, 0x05, 0xf8, 0x10},
-/*      {0xd1, 0x21, 0x10, 0x7f, 0x40, 0x05, 0xff, 0x10}, */
+        {0xd1, 0x21, 0x10, 0x7f, 0x40, 0x05, 0xff, 0x10},
                                                 /* AECH CLKRC COM7 COM8 */
         {0xc1, 0x21, 0x14, 0x2c, 0x00, 0x02, 0x00, 0x10}, /* COM9 COM10 */
         {0xd1, 0x21, 0x17, 0x10, 0x60, 0x02, 0x7b, 0x10},
@@ -379,8 +361,8 @@ static const __u8 ov7660_sensor_init[][8] = {
         {0xb1, 0x21, 0x1e, 0x01, 0x0e, 0x00, 0x00, 0x10}, /* MVFP LAEC */
         {0xd1, 0x21, 0x20, 0x07, 0x07, 0x07, 0x07, 0x10},
                                         /* BOS GBOS GROS ROS (BGGR offset) */
-        {0xd1, 0x21, 0x24, 0x68, 0x58, 0xd4, 0x80, 0x10},
-/*      {0xd1, 0x21, 0x24, 0x78, 0x68, 0xd4, 0x80, 0x10}, */
+/*      {0xd1, 0x21, 0x24, 0x68, 0x58, 0xd4, 0x80, 0x10}, */
+        {0xd1, 0x21, 0x24, 0x78, 0x68, 0xd4, 0x80, 0x10},
                                                 /* AEW AEB VPT BBIAS */
         {0xd1, 0x21, 0x28, 0x80, 0x30, 0x00, 0x00, 0x10},
                                                 /* GbBIAS RSVD EXHCH EXHCL */
@@ -407,9 +389,9 @@ static const __u8 ov7660_sensor_init[][8] = {
         {0xd1, 0x21, 0x62, 0x00, 0x00, 0x50, 0x30, 0x10},
                                                 /* LCC1 LCC2 LCC3 LCC4 */
         {0xa1, 0x21, 0x66, 0x00, 0x00, 0x00, 0x00, 0x10}, /* LCC5 */
-        {0xd1, 0x21, 0x67, 0x80, 0x7a, 0x90, 0x80, 0x10},
+        {0xd1, 0x21, 0x67, 0x80, 0x7a, 0x90, 0x80, 0x10}, /* MANU */
         {0xa1, 0x21, 0x6b, 0x0a, 0x00, 0x00, 0x00, 0x10},
-                                        /* band gap reference [0..3] DBLV */
+                                        /* band gap reference [0:3] DBLV */
         {0xd1, 0x21, 0x6c, 0x30, 0x48, 0x80, 0x74, 0x10}, /* gamma curve */
         {0xd1, 0x21, 0x70, 0x64, 0x60, 0x5c, 0x58, 0x10}, /* gamma curve */
         {0xd1, 0x21, 0x74, 0x54, 0x4c, 0x40, 0x38, 0x10}, /* gamma curve */
@@ -419,37 +401,35 @@ static const __u8 ov7660_sensor_init[][8] = {
         {0xd1, 0x21, 0x84, 0x6e, 0x77, 0x87, 0x95, 0x10}, /* gamma curve */
         {0xc1, 0x21, 0x88, 0xaf, 0xc7, 0xdf, 0x00, 0x10}, /* gamma curve */
         {0xc1, 0x21, 0x8b, 0x99, 0x99, 0xcf, 0x00, 0x10}, /* reserved */
-        {0xb1, 0x21, 0x92, 0x00, 0x00, 0x00, 0x00, 0x10},
+        {0xb1, 0x21, 0x92, 0x00, 0x00, 0x00, 0x00, 0x10}, /* DM_LNL/H */
 /****** (some exchanges in the win trace) ******/
-        {0xa1, 0x21, 0x1e, 0x01, 0x00, 0x00, 0x00, 0x10},
+        {0xa1, 0x21, 0x1e, 0x01, 0x00, 0x00, 0x00, 0x10}, /* MVFP */
                                                 /* bits[3..0]reserved */
         {0xa1, 0x21, 0x1e, 0x01, 0x00, 0x00, 0x00, 0x10},
         {0xa1, 0x21, 0x03, 0x00, 0x00, 0x00, 0x00, 0x10},
                                                 /* VREF vertical frame ctrl */
         {0xa1, 0x21, 0x03, 0x00, 0x00, 0x00, 0x00, 0x10},
-        {0xa1, 0x21, 0x10, 0x20, 0x00, 0x00, 0x00, 0x10}, /* 0x20 */
-        {0xa1, 0x21, 0x2d, 0x00, 0x00, 0x00, 0x00, 0x10},
-        {0xa1, 0x21, 0x2e, 0x00, 0x00, 0x00, 0x00, 0x10},
-/*      {0xa1, 0x21, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x10}, */
-        {0xa1, 0x21, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x10},
-        {0xb1, 0x21, 0x01, 0x78, 0x78, 0x00, 0x00, 0x10},
+        {0xa1, 0x21, 0x10, 0x20, 0x00, 0x00, 0x00, 0x10}, /* AECH 0x20 */
+        {0xa1, 0x21, 0x2d, 0x00, 0x00, 0x00, 0x00, 0x10}, /* ADVFL */
+        {0xa1, 0x21, 0x2e, 0x00, 0x00, 0x00, 0x00, 0x10}, /* ADVFH */
+        {0xa1, 0x21, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x10}, /* GAIN */
+/*      {0xb1, 0x21, 0x01, 0x78, 0x78, 0x00, 0x00, 0x10}, * BLUE */
 /****** (some exchanges in the win trace) ******/
         {0xa1, 0x21, 0x93, 0x00, 0x00, 0x00, 0x00, 0x10},/* dummy line hight */
-        {0xa1, 0x21, 0x92, 0x25, 0x00, 0x00, 0x00, 0x10},/* dummy line low */
-        {0xa1, 0x21, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x10},
-        {0xa1, 0x21, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x10},
-        {0xa1, 0x21, 0x02, 0x90, 0x00, 0x00, 0x00, 0x10},
+        {0xa1, 0x21, 0x92, 0x25, 0x00, 0x00, 0x00, 0x10}, /* dummy line low */
+        {0xa1, 0x21, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x10}, /* EXHCH */
+        {0xa1, 0x21, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x10}, /* EXHCL */
+/*      {0xa1, 0x21, 0x02, 0x90, 0x00, 0x00, 0x00, 0x10},  * RED */
 /****** (some exchanges in the win trace) ******/
-/**********startsensor KO if changed !!****/
+/******!! startsensor KO if changed !!****/
         {0xa1, 0x21, 0x93, 0x01, 0x00, 0x00, 0x00, 0x10},
         {0xa1, 0x21, 0x92, 0xff, 0x00, 0x00, 0x00, 0x10},
         {0xa1, 0x21, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x10},
         {0xa1, 0x21, 0x2b, 0xc3, 0x00, 0x00, 0x00, 0x10},
-/* here may start the isoc exchanges */
         {}
 };
-/* reg0x04              reg0x07         reg 0x10 */
-/* expo  = (COM1 & 0x02) | (AECHH & 0x2f <<10) [ (AECh << 2) */
+/*        reg 0x04        reg 0x07                 reg 0x10 */
+/* expo = (COM1 & 0x02) | ((AECHH & 0x2f) << 10) | (AECh << 2) */
 
 static const __u8 ov7648_sensor_init[][8] = {
         {0xC1, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00},
@@ -680,13 +660,12 @@ static int configure_gpio(struct gspca_dev *gspca_dev,
         const __u8 *reg9a;
         static const __u8 reg9a_def[] =
                 {0x08, 0x40, 0x20, 0x10, 0x00, 0x04};
-        static const __u8 reg9a_sn9c120[] =             /* from win trace */
-                {0x00, 0x40, 0x38, 0x30, 0x00, 0x20};
         static const __u8 reg9a_sn9c325[] =
                 {0x0a, 0x40, 0x38, 0x30, 0x00, 0x20};
+        static const __u8 regd4[] = {0x60, 0x00, 0x00};
 
         reg_w1(gspca_dev, 0xf1, 0x00);
-        reg_w1(gspca_dev, 0x01, sn9c1xx[0]);    /*fixme:jfm was [1] en v1*/
+        reg_w1(gspca_dev, 0x01, 0x00);          /*jfm was sn9c1xx[1] in v1*/
 
         /* configure gpio */
         reg_w(gspca_dev, 0x01, &sn9c1xx[1], 2);
@@ -696,25 +675,17 @@ static int configure_gpio(struct gspca_dev *gspca_dev,
         case BRIDGE_SN9C325:
                 reg9a = reg9a_sn9c325;
                 break;
-        case BRIDGE_SN9C120:
-                reg9a = reg9a_sn9c120;
-                break;
         default:
                 reg9a = reg9a_def;
                 break;
         }
         reg_w(gspca_dev, 0x9a, reg9a, 6);
 
-        reg_w1(gspca_dev, 0xd4, 0x60);  /*fixme:jfm 60 00 00 (3) ? */
+        reg_w(gspca_dev, 0xd4, regd4, sizeof regd4); /*fixme:jfm was 60 only*/
 
         reg_w(gspca_dev, 0x03, &sn9c1xx[3], 0x0f);
 
         switch (sd->bridge) {
-        case BRIDGE_SN9C120:                    /* from win trace */
-                reg_w1(gspca_dev, 0x01, 0x61);
-                reg_w1(gspca_dev, 0x17, 0x20);
-                reg_w1(gspca_dev, 0x01, 0x60);
-                break;
         case BRIDGE_SN9C325:
                 reg_w1(gspca_dev, 0x01, 0x43);
                 reg_w1(gspca_dev, 0x17, 0xae);
@@ -810,6 +781,8 @@ static int sd_config(struct gspca_dev *gspca_dev,
         sd->contrast = CONTRAST_DEF;
         sd->colors = COLOR_DEF;
         sd->autogain = AUTOGAIN_DEF;
+        sd->ag_cnt = -1;
+
         return 0;
 }
 
@@ -823,10 +796,11 @@ static int sd_open(struct gspca_dev *gspca_dev)
 
         /* setup a selector by bridge */
         reg_w1(gspca_dev, 0xf1, 0x01);
-        reg_r(gspca_dev, 0x00, 1);              /* -> regF1 = 0x00 */
-        reg_w1(gspca_dev, 0xf1, gspca_dev->usb_buf[0]);
         reg_r(gspca_dev, 0x00, 1);
+        reg_w1(gspca_dev, 0xf1, gspca_dev->usb_buf[0]);
+        reg_r(gspca_dev, 0x00, 1);              /* get sonix chip id */
         regF1 = gspca_dev->usb_buf[0];
+        PDEBUG(D_PROBE, "Sonix chip id: %02x", regF1);
         switch (sd->bridge) {
         case BRIDGE_SN9C102P:
                 if (regF1 != 0x11)
@@ -937,15 +911,10 @@ static void setbrightness(struct gspca_dev *gspca_dev)
                 sd->exposure = setexposure(gspca_dev, expo);
                 break;
         case SENSOR_MI0360:
-                expo = sd->brightness >> 4;
-                sd->exposure = setexposure(gspca_dev, expo);
-                break;
         case SENSOR_MO4000:
                 expo = sd->brightness >> 4;
                 sd->exposure = setexposure(gspca_dev, expo);
                 break;
-        case SENSOR_OV7660:
-                return;                         /*jfm??*/
         }
 
         k2 = sd->brightness >> 10;
@@ -958,8 +927,6 @@ static void setcontrast(struct gspca_dev *gspca_dev)
         __u8 k2;
         __u8 contrast[] = { 0x00, 0x00, 0x28, 0x00, 0x07, 0x00 };
 
-        if (sd->sensor == SENSOR_OV7660)
-                return;                         /*jfm??*/
         k2 = sd->contrast;
         contrast[2] = k2;
         contrast[0] = (k2 + 1) >> 1;
@@ -981,20 +948,32 @@ static void setcolors(struct gspca_dev *gspca_dev)
         reg_w1(gspca_dev, 0x05, data);
 }
 
+static void setautogain(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        switch (sd->sensor) {
+        case SENSOR_HV7131R:
+        case SENSOR_MO4000:
+        case SENSOR_MI0360:
+                if (sd->autogain)
+                        sd->ag_cnt = AG_CNT_START;
+                else
+                        sd->ag_cnt = -1;
+                break;
+        }
+}
+
 /* -- start the camera -- */
 static void sd_start(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
         int i;
-        __u8 data;
-        __u8 reg1;
-        __u8 reg17;
+        __u8 reg1, reg17, reg18;
         const __u8 *sn9c1xx;
         int mode;
         static const __u8 C0[] = { 0x2d, 0x2d, 0x3a, 0x05, 0x04, 0x3f };
         static const __u8 CA[] = { 0x28, 0xd8, 0x14, 0xec };
-        static const __u8 CA_sn9c120[] =
-                                 { 0x14, 0xec, 0x0a, 0xf6 };    /* SN9C120 */
         static const __u8 CE[] = { 0x32, 0xdd, 0x2d, 0xdd };    /* MI0360 */
         static const __u8 CE_sn9c325[] =
                         { 0x32, 0xdd, 0x32, 0xdd };     /* OV7648 - SN9C325 */
@@ -1002,9 +981,7 @@ static void sd_start(struct gspca_dev *gspca_dev)
         sn9c1xx = sn_tb[(int) sd->sensor];
         configure_gpio(gspca_dev, sn9c1xx);
 
-/*fixme:jfm this sequence should appear at end of sd_start */
-/* with
-        reg_w1(gspca_dev, 0x01, 0x44); */
+/*      reg_w1(gspca_dev, 0x01, 0x44);          jfm from win trace*/
         reg_w1(gspca_dev, 0x15, sn9c1xx[0x15]);
         reg_w1(gspca_dev, 0x16, sn9c1xx[0x16]);
         reg_w1(gspca_dev, 0x12, sn9c1xx[0x12]);
@@ -1016,20 +993,16 @@ static void sd_start(struct gspca_dev *gspca_dev)
         reg_w1(gspca_dev, 0xc7, 0x00);
         reg_w1(gspca_dev, 0xc8, 0x50);
         reg_w1(gspca_dev, 0xc9, 0x3c);
-/*fixme:jfm end of ending sequence */
         reg_w1(gspca_dev, 0x18, sn9c1xx[0x18]);
         switch (sd->bridge) {
         case BRIDGE_SN9C325:
-                data = 0xae;
-                break;
-        case BRIDGE_SN9C120:
-                data = 0xa0;
+                reg17 = 0xae;
                 break;
         default:
-                data = 0x60;
+                reg17 = 0x60;
                 break;
         }
-        reg_w1(gspca_dev, 0x17, data);
+        reg_w1(gspca_dev, 0x17, reg17);
         reg_w1(gspca_dev, 0x05, sn9c1xx[5]);
         reg_w1(gspca_dev, 0x07, sn9c1xx[7]);
         reg_w1(gspca_dev, 0x06, sn9c1xx[6]);
@@ -1044,20 +1017,6 @@ static void sd_start(struct gspca_dev *gspca_dev)
                 reg_w1(gspca_dev, 0x9a, 0x0a);
                 reg_w1(gspca_dev, 0x99, 0x60);
                 break;
-        case BRIDGE_SN9C120:
-                reg_w(gspca_dev, 0x20, regsn20_sn9c120,
-                                sizeof regsn20_sn9c120);
-                for (i = 0; i < 2; i++)
-                        reg_w(gspca_dev, 0x84, reg84_sn9c120_1,
-                                        sizeof reg84_sn9c120_1);
-                for (i = 0; i < 6; i++)
-                        reg_w(gspca_dev, 0x84, reg84_sn9c120_2,
-                                        sizeof reg84_sn9c120_2);
-                reg_w(gspca_dev, 0x84, reg84_sn9c120_3,
-                                sizeof reg84_sn9c120_3);
-                reg_w1(gspca_dev, 0x9a, 0x05);
-                reg_w1(gspca_dev, 0x99, 0x5b);
-                break;
         default:
                 reg_w(gspca_dev, 0x20, regsn20, sizeof regsn20);
                 for (i = 0; i < 8; i++)
@@ -1107,22 +1066,14 @@ static void sd_start(struct gspca_dev *gspca_dev)
 /*                      reg1 = 0x44; */
 /*                      reg1 = 0x46;    (done) */
                 } else {
-                        reg17 = 0xa2;   /* 640 */
-                        reg1 = 0x40;
+                        reg17 = 0x22;   /* 640 MCKSIZE */
+                        reg1 = 0x06;
                 }
                 break;
         }
         reg_w(gspca_dev, 0xc0, C0, 6);
+        reg_w(gspca_dev, 0xca, CA, 4);
         switch (sd->bridge) {
-        case BRIDGE_SN9C120:                    /*jfm ?? */
-                reg_w(gspca_dev, 0xca, CA_sn9c120, 4);
-                break;
-        default:
-                reg_w(gspca_dev, 0xca, CA, 4);
-                break;
-        }
-        switch (sd->bridge) {
-        case BRIDGE_SN9C120:                    /*jfm ?? */
         case BRIDGE_SN9C325:
                 reg_w(gspca_dev, 0xce, CE_sn9c325, 4);
                 break;
@@ -1133,19 +1084,19 @@ static void sd_start(struct gspca_dev *gspca_dev)
         }
 
         /* here change size mode 0 -> VGA; 1 -> CIF */
-        data = 0x40 | sn9c1xx[0x18] | (mode << 4);
-        reg_w1(gspca_dev, 0x18, data);
+        reg18 = sn9c1xx[0x18] | (mode << 4);
+        reg_w1(gspca_dev, 0x18, reg18 | 0x40);
 
         reg_w(gspca_dev, 0x100, qtable4, 0x40);
         reg_w(gspca_dev, 0x140, qtable4 + 0x40, 0x40);
 
-        data = sn9c1xx[0x18] | (mode << 4);
-        reg_w1(gspca_dev, 0x18, data);
+        reg_w1(gspca_dev, 0x18, reg18);
 
         reg_w1(gspca_dev, 0x17, reg17);
         reg_w1(gspca_dev, 0x01, reg1);
         setbrightness(gspca_dev);
         setcontrast(gspca_dev);
+        setautogain(gspca_dev);
 }
 
 static void sd_stopN(struct gspca_dev *gspca_dev)
@@ -1168,12 +1119,11 @@ static void sd_stopN(struct gspca_dev *gspca_dev)
                 i2c_w8(gspca_dev, stopmi0360);
                 data = 0x29;
                 break;
-        case SENSOR_MO4000:
-                break;
         case SENSOR_OV7648:
                 data = 0x29;
                 break;
         default:
+/*      case SENSOR_MO4000: */
 /*      case SENSOR_OV7660: */
                 break;
         }
@@ -1193,16 +1143,23 @@ static void sd_close(struct gspca_dev *gspca_dev)
 {
 }
 
-static void setautogain(struct gspca_dev *gspca_dev)
+static void do_autogain(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        /* Thanks S., without your advice, autobright should not work :) */
         int delta;
-        int expotimes = 0;
+        int expotimes;
         __u8 luma_mean = 130;
         __u8 luma_delta = 20;
 
-        delta = sd->avg_lum;
+        /* Thanks S., without your advice, autobright should not work :) */
+        if (sd->ag_cnt < 0)
+                return;
+        if (--sd->ag_cnt >= 0)
+                return;
+        sd->ag_cnt = AG_CNT_START;
+
+        delta = atomic_read(&sd->avg_lum);
+        PDEBUG(D_FRAM, "mean lum %d", delta);
         if (delta < luma_mean - luma_delta ||
             delta > luma_mean + luma_delta) {
                 switch (sd->sensor) {
@@ -1214,8 +1171,9 @@ static void setautogain(struct gspca_dev *gspca_dev)
                         sd->exposure = setexposure(gspca_dev,
                                         (unsigned int) (expotimes << 8));
                         break;
-                case SENSOR_MO4000:
-                case SENSOR_MI0360:
+                default:
+/*              case SENSOR_MO4000: */
+/*              case SENSOR_MI0360: */
                         expotimes = sd->exposure;
                         expotimes += (luma_mean - delta) >> 6;
                         if (expotimes < 0)
@@ -1228,6 +1186,8 @@ static void setautogain(struct gspca_dev *gspca_dev)
         }
 }
 
+/* scan the URB packets */
+/* This function is run at interrupt level. */
 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
                         struct gspca_frame *frame,      /* target */
                         __u8 *data,                     /* isoc packet */
@@ -1244,9 +1204,6 @@ static void sd_pkt_scan(struct gspca_dev *gspca_dev,
                                 frame, data, sof + 2);
                 if (sd->ag_cnt < 0)
                         return;
-                if (--sd->ag_cnt >= 0)
-                        return;
-                sd->ag_cnt = AG_CNT_START;
 /* w1 w2 w3 */
 /* w4 w5 w6 */
 /* w7 w8 */
@@ -1261,9 +1218,7 @@ static void sd_pkt_scan(struct gspca_dev *gspca_dev,
 /* w5 */
                 avg_lum += ((data[sof + 31] << 8) | data[sof + 32]) >> 4;
                 avg_lum >>= 4;
-                sd->avg_lum = avg_lum;
-                PDEBUG(D_PACK, "mean lum %d", avg_lum);
-                setautogain(gspca_dev);
+                atomic_set(&sd->avg_lum, avg_lum);
                 return;
         }
         if (gspca_dev->last_packet_type == LAST_PACKET) {
@@ -1300,6 +1255,7 @@ static unsigned int getexposure(struct gspca_dev *gspca_dev)
                         (hexpo << 10) | (mexpo << 2) | lexpo);
                 return (hexpo << 10) | (mexpo << 2) | lexpo;
         default:
+/*      case SENSOR_OV7648:             * jfm: is it ok for 7648? */
 /*      case SENSOR_OV7660: */
                 /* read sensor exposure */
                 i2c_r5(gspca_dev, 0x04);
@@ -1318,14 +1274,12 @@ static void getbrightness(struct gspca_dev *gspca_dev)
         /* hardcoded registers seem not readable */
         switch (sd->sensor) {
         case SENSOR_HV7131R:
-/*              sd->brightness = 0x7fff; */
                 sd->brightness = getexposure(gspca_dev) >> 4;
                 break;
         case SENSOR_MI0360:
                 sd->brightness = getexposure(gspca_dev) << 4;
                 break;
         case SENSOR_MO4000:
-/*              sd->brightness = 0x1fff; */
                 sd->brightness = getexposure(gspca_dev) << 4;
                 break;
         }
@@ -1391,10 +1345,8 @@ static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val)
         struct sd *sd = (struct sd *) gspca_dev;
 
         sd->autogain = val;
-        if (val)
-                sd->ag_cnt = AG_CNT_START;
-        else
-                sd->ag_cnt = -1;
+        if (gspca_dev->streaming)
+                setautogain(gspca_dev);
         return 0;
 }
 
@@ -1418,6 +1370,7 @@ static const struct sd_desc sd_desc = {
         .stop0 = sd_stop0,
         .close = sd_close,
         .pkt_scan = sd_pkt_scan,
+        .dq_callback = do_autogain,
 };
 
 /* -- module initialisation -- */
diff --git a/drivers/media/video/gspca/spca505.c b/drivers/media/video/gspca/spca505.c
index 3c2be80cbd65..eda29d609359 100644
--- a/drivers/media/video/gspca/spca505.c
+++ b/drivers/media/video/gspca/spca505.c
@@ -61,27 +61,27 @@ static struct ctrl sd_ctrls[] = {
 
 static struct v4l2_pix_format vga_mode[] = {
         {160, 120, V4L2_PIX_FMT_SPCA505, V4L2_FIELD_NONE,
-                .bytesperline = 160 * 3,
+                .bytesperline = 160,
                 .sizeimage = 160 * 120 * 3 / 2,
                 .colorspace = V4L2_COLORSPACE_SRGB,
                 .priv = 5},
         {176, 144, V4L2_PIX_FMT_SPCA505, V4L2_FIELD_NONE,
-                .bytesperline = 176 * 3,
+                .bytesperline = 176,
                 .sizeimage = 176 * 144 * 3 / 2,
                 .colorspace = V4L2_COLORSPACE_SRGB,
                 .priv = 4},
         {320, 240, V4L2_PIX_FMT_SPCA505, V4L2_FIELD_NONE,
-                .bytesperline = 320 * 3,
+                .bytesperline = 320,
                 .sizeimage = 320 * 240 * 3 / 2,
                 .colorspace = V4L2_COLORSPACE_SRGB,
                 .priv = 2},
         {352, 288, V4L2_PIX_FMT_SPCA505, V4L2_FIELD_NONE,
-                .bytesperline = 352 * 3,
+                .bytesperline = 352,
                 .sizeimage = 352 * 288 * 3 / 2,
                 .colorspace = V4L2_COLORSPACE_SRGB,
                 .priv = 1},
         {640, 480, V4L2_PIX_FMT_SPCA505, V4L2_FIELD_NONE,
-                .bytesperline = 640 * 3,
+                .bytesperline = 640,
                 .sizeimage = 640 * 480 * 3 / 2,
                 .colorspace = V4L2_COLORSPACE_SRGB,
                 .priv = 0},
@@ -776,7 +776,7 @@ static void sd_pkt_scan(struct gspca_dev *gspca_dev,
         default:
                 data += 1;
                 len -= 1;
-                gspca_frame_add(gspca_dev, FIRST_PACKET, frame,
+                gspca_frame_add(gspca_dev, INTER_PACKET, frame,
                                 data, len);
                 break;
         }
diff --git a/drivers/media/video/gspca/spca506.c b/drivers/media/video/gspca/spca506.c
index 6fe715c80ad2..f622fa75766d 100644
--- a/drivers/media/video/gspca/spca506.c
+++ b/drivers/media/video/gspca/spca506.c
@@ -112,27 +112,27 @@ static struct ctrl sd_ctrls[] = {
 
 static struct v4l2_pix_format vga_mode[] = {
         {160, 120, V4L2_PIX_FMT_SPCA505, V4L2_FIELD_NONE,
-                .bytesperline = 160 * 3,
+                .bytesperline = 160,
                 .sizeimage = 160 * 120 * 3 / 2,
                 .colorspace = V4L2_COLORSPACE_SRGB,
                 .priv = 5},
         {176, 144, V4L2_PIX_FMT_SPCA505, V4L2_FIELD_NONE,
-                .bytesperline = 176 * 3,
+                .bytesperline = 176,
                 .sizeimage = 176 * 144 * 3 / 2,
                 .colorspace = V4L2_COLORSPACE_SRGB,
                 .priv = 4},
         {320, 240, V4L2_PIX_FMT_SPCA505, V4L2_FIELD_NONE,
-                .bytesperline = 320 * 3,
+                .bytesperline = 320,
                 .sizeimage = 320 * 240 * 3 / 2,
                 .colorspace = V4L2_COLORSPACE_SRGB,
                 .priv = 2},
         {352, 288, V4L2_PIX_FMT_SPCA505, V4L2_FIELD_NONE,
-                .bytesperline = 352 * 3,
+                .bytesperline = 352,
                 .sizeimage = 352 * 288 * 3 / 2,
                 .colorspace = V4L2_COLORSPACE_SRGB,
                 .priv = 1},
         {640, 480, V4L2_PIX_FMT_SPCA505, V4L2_FIELD_NONE,
-                .bytesperline = 640 * 3,
+                .bytesperline = 640,
                 .sizeimage = 640 * 480 * 3 / 2,
                 .colorspace = V4L2_COLORSPACE_SRGB,
                 .priv = 0},
@@ -588,7 +588,7 @@ static void sd_pkt_scan(struct gspca_dev *gspca_dev,
         default:
                 data += 1;
                 len -= 1;
-                gspca_frame_add(gspca_dev, FIRST_PACKET, frame,
+                gspca_frame_add(gspca_dev, INTER_PACKET, frame,
                                 data, len);
                 break;
         }
diff --git a/drivers/media/video/gspca/spca508.c b/drivers/media/video/gspca/spca508.c
index b608a27ad115..699340c17dea 100644
--- a/drivers/media/video/gspca/spca508.c
+++ b/drivers/media/video/gspca/spca508.c
@@ -63,23 +63,23 @@ static struct ctrl sd_ctrls[] = {
 };
 
 static struct v4l2_pix_format sif_mode[] = {
-        {160, 120, V4L2_PIX_FMT_YUYV, V4L2_FIELD_NONE,
-                .bytesperline = 160 * 3,
+        {160, 120, V4L2_PIX_FMT_SPCA508, V4L2_FIELD_NONE,
+                .bytesperline = 160,
                 .sizeimage = 160 * 120 * 3 / 2,
                 .colorspace = V4L2_COLORSPACE_SRGB,
                 .priv = 3},
-        {176, 144, V4L2_PIX_FMT_YUYV, V4L2_FIELD_NONE,
-                .bytesperline = 176 * 3,
+        {176, 144, V4L2_PIX_FMT_SPCA508, V4L2_FIELD_NONE,
+                .bytesperline = 176,
                 .sizeimage = 176 * 144 * 3 / 2,
                 .colorspace = V4L2_COLORSPACE_SRGB,
                 .priv = 2},
-        {320, 240, V4L2_PIX_FMT_YUYV, V4L2_FIELD_NONE,
-                .bytesperline = 320 * 3,
+        {320, 240, V4L2_PIX_FMT_SPCA508, V4L2_FIELD_NONE,
+                .bytesperline = 320,
                 .sizeimage = 320 * 240 * 3 / 2,
                 .colorspace = V4L2_COLORSPACE_SRGB,
                 .priv = 1},
-        {352, 288, V4L2_PIX_FMT_YUYV, V4L2_FIELD_NONE,
-                .bytesperline = 352 * 3,
+        {352, 288, V4L2_PIX_FMT_SPCA508, V4L2_FIELD_NONE,
+                .bytesperline = 352,
                 .sizeimage = 352 * 288 * 3 / 2,
                 .colorspace = V4L2_COLORSPACE_SRGB,
                 .priv = 0},
@@ -1583,7 +1583,7 @@ static void sd_pkt_scan(struct gspca_dev *gspca_dev,
         default:
                 data += 1;
                 len -= 1;
-                gspca_frame_add(gspca_dev, FIRST_PACKET, frame,
+                gspca_frame_add(gspca_dev, INTER_PACKET, frame,
                                 data, len);
                 break;
         }
diff --git a/drivers/media/video/gspca/spca561.c b/drivers/media/video/gspca/spca561.c
index a26174508cb9..1073ac3d2ec6 100644
--- a/drivers/media/video/gspca/spca561.c
+++ b/drivers/media/video/gspca/spca561.c
@@ -644,6 +644,18 @@ static void setcontrast(struct gspca_dev *gspca_dev)
         }
 }
 
+static void setautogain(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        if (sd->chip_revision == Rev072A) {
+                if (sd->autogain)
+                        sd->ag_cnt = AG_CNT_START;
+                else
+                        sd->ag_cnt = -1;
+        }
+}
+
 static void sd_start(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
@@ -671,6 +683,7 @@ static void sd_start(struct gspca_dev *gspca_dev)
                 reg_w_val(dev, 0x8500, mode);   /* mode */
                 reg_w_val(dev, 0x8700, Clck);   /* 0x27 clock */
                 reg_w_val(dev, 0x8112, 0x10 | 0x20);
+                setautogain(gspca_dev);
                 break;
         default:
 /*      case Rev012A: */
@@ -720,18 +733,24 @@ static void sd_close(struct gspca_dev *gspca_dev)
         reg_w_val(gspca_dev->dev, 0x8114, 0);
 }
 
-static void setautogain(struct gspca_dev *gspca_dev)
+static void do_autogain(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
-        int expotimes = 0;
-        int pixelclk = 0;
-        int gainG = 0;
+        int expotimes;
+        int pixelclk;
+        int gainG;
         __u8 R, Gr, Gb, B;
         int y;
         __u8 luma_mean = 110;
         __u8 luma_delta = 20;
         __u8 spring = 4;
 
+        if (sd->ag_cnt < 0)
+                return;
+        if (--sd->ag_cnt >= 0)
+                return;
+        sd->ag_cnt = AG_CNT_START;
+
         switch (sd->chip_revision) {
         case Rev072A:
                 reg_r(gspca_dev, 0x8621, 1);
@@ -795,18 +814,10 @@ static void sd_pkt_scan(struct gspca_dev *gspca_dev,
                         __u8 *data,             /* isoc packet */
                         int len)                /* iso packet length */
 {
-        struct sd *sd = (struct sd *) gspca_dev;
-
         switch (data[0]) {
         case 0:         /* start of frame */
                 frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame,
                                         data, 0);
-                if (sd->ag_cnt >= 0) {
-                        if (--sd->ag_cnt < 0) {
-                                sd->ag_cnt = AG_CNT_START;
-                                setautogain(gspca_dev);
-                        }
-                }
                 data += SPCA561_OFFSET_DATA;
                 len -= SPCA561_OFFSET_DATA;
                 if (data[1] & 0x10) {
@@ -944,10 +955,8 @@ static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val)
         struct sd *sd = (struct sd *) gspca_dev;
 
         sd->autogain = val;
-        if (val)
-                sd->ag_cnt = AG_CNT_START;
-        else
-                sd->ag_cnt = -1;
+        if (gspca_dev->streaming)
+                setautogain(gspca_dev);
         return 0;
 }
 
@@ -971,6 +980,7 @@ static const struct sd_desc sd_desc = {
         .stop0 = sd_stop0,
         .close = sd_close,
         .pkt_scan = sd_pkt_scan,
+        .dq_callback = do_autogain,
 };
 
 /* -- module initialisation -- */
diff --git a/drivers/media/video/gspca/vc032x.c b/drivers/media/video/gspca/vc032x.c
index a4221753e1bf..f4a52956e0d9 100644
--- a/drivers/media/video/gspca/vc032x.c
+++ b/drivers/media/video/gspca/vc032x.c
@@ -88,12 +88,12 @@ static struct ctrl sd_ctrls[] = {
 
 static struct v4l2_pix_format vc0321_mode[] = {
         {320, 240, V4L2_PIX_FMT_YUV420, V4L2_FIELD_NONE,
-                .bytesperline = 320 * 2,
+                .bytesperline = 320,
                 .sizeimage = 320 * 240 * 2,
                 .colorspace = V4L2_COLORSPACE_SRGB,
                 .priv = 1},
         {640, 480, V4L2_PIX_FMT_YUV420, V4L2_FIELD_NONE,
-                .bytesperline = 640 * 2,
+                .bytesperline = 640,
                 .sizeimage = 640 * 480 * 2,
                 .colorspace = V4L2_COLORSPACE_SRGB,
                 .priv = 0},
diff --git a/drivers/media/video/gspca/zc3xx.c b/drivers/media/video/gspca/zc3xx.c
index 22a994ccb1d5..bc7d0eedcd81 100644
--- a/drivers/media/video/gspca/zc3xx.c
+++ b/drivers/media/video/gspca/zc3xx.c
@@ -6469,7 +6469,7 @@ static void setcontrast(struct gspca_dev *gspca_dev)
                 NULL, Tgradient_1, Tgradient_2,
                 Tgradient_3, Tgradient_4, Tgradient_5, Tgradient_6
         };
-#ifdef CONFIG_VIDEO_ADV_DEBUG
+#ifdef GSPCA_DEBUG
         __u8 v[16];
 #endif
 
@@ -6487,7 +6487,7 @@ static void setcontrast(struct gspca_dev *gspca_dev)
                 else if (g <= 0)
                         g = 1;
                 reg_w(dev, g, 0x0120 + i);      /* gamma */
-#ifdef CONFIG_VIDEO_ADV_DEBUG
+#ifdef GSPCA_DEBUG
                 if (gspca_debug & D_CONF)
                         v[i] = g;
 #endif
@@ -6507,7 +6507,7 @@ static void setcontrast(struct gspca_dev *gspca_dev)
                                 g = 1;
                 }
                 reg_w(dev, g, 0x0130 + i);      /* gradient */
-#ifdef CONFIG_VIDEO_ADV_DEBUG
+#ifdef GSPCA_DEBUG
                 if (gspca_debug & D_CONF)
                         v[i] = g;
 #endif
diff --git a/drivers/media/video/pxa_camera.c b/drivers/media/video/pxa_camera.c
index b15f82c49766..ead87ddaf7fb 100644
--- a/drivers/media/video/pxa_camera.c
+++ b/drivers/media/video/pxa_camera.c
@@ -128,6 +128,8 @@ struct pxa_camera_dev {
 
         struct pxa_buffer       *active;
         struct pxa_dma_desc     *sg_tail[3];
+
+        u32                     save_cicr[5];
 };
 
 static const char *pxa_cam_driver_description = "PXA_Camera";
@@ -997,10 +999,64 @@ static int pxa_camera_querycap(struct soc_camera_host *ici,
         return 0;
 }
 
+static int pxa_camera_suspend(struct soc_camera_device *icd, pm_message_t state)
+{
+        struct soc_camera_host *ici =
+                to_soc_camera_host(icd->dev.parent);
+        struct pxa_camera_dev *pcdev = ici->priv;
+        int i = 0, ret = 0;
+
+        pcdev->save_cicr[i++] = CICR0;
+        pcdev->save_cicr[i++] = CICR1;
+        pcdev->save_cicr[i++] = CICR2;
+        pcdev->save_cicr[i++] = CICR3;
+        pcdev->save_cicr[i++] = CICR4;
+
+        if ((pcdev->icd) && (pcdev->icd->ops->suspend))
+                ret = pcdev->icd->ops->suspend(pcdev->icd, state);
+
+        return ret;
+}
+
+static int pxa_camera_resume(struct soc_camera_device *icd)
+{
+        struct soc_camera_host *ici =
+                to_soc_camera_host(icd->dev.parent);
+        struct pxa_camera_dev *pcdev = ici->priv;
+        int i = 0, ret = 0;
+
+        DRCMR68 = pcdev->dma_chans[0] | DRCMR_MAPVLD;
+        DRCMR69 = pcdev->dma_chans[1] | DRCMR_MAPVLD;
+        DRCMR70 = pcdev->dma_chans[2] | DRCMR_MAPVLD;
+
+        CICR0 = pcdev->save_cicr[i++] & ~CICR0_ENB;
+        CICR1 = pcdev->save_cicr[i++];
+        CICR2 = pcdev->save_cicr[i++];
+        CICR3 = pcdev->save_cicr[i++];
+        CICR4 = pcdev->save_cicr[i++];
+
+        if ((pcdev->icd) && (pcdev->icd->ops->resume))
+                ret = pcdev->icd->ops->resume(pcdev->icd);
+
+        /* Restart frame capture if active buffer exists */
+        if (!ret && pcdev->active) {
+                /* Reset the FIFOs */
+                CIFR |= CIFR_RESET_F;
+                /* Enable End-Of-Frame Interrupt */
+                CICR0 &= ~CICR0_EOFM;
+                /* Restart the Capture Interface */
+                CICR0 |= CICR0_ENB;
+        }
+
+        return ret;
+}
+
 static struct soc_camera_host_ops pxa_soc_camera_host_ops = {
         .owner          = THIS_MODULE,
         .add            = pxa_camera_add_device,
         .remove         = pxa_camera_remove_device,
+        .suspend        = pxa_camera_suspend,
+        .resume         = pxa_camera_resume,
         .set_fmt_cap    = pxa_camera_set_fmt_cap,
         .try_fmt_cap    = pxa_camera_try_fmt_cap,
         .init_videobuf  = pxa_camera_init_videobuf,
@@ -1198,7 +1254,7 @@ static int __devinit pxa_camera_init(void)
 
 static void __exit pxa_camera_exit(void)
 {
-        return platform_driver_unregister(&pxa_camera_driver);
+        platform_driver_unregister(&pxa_camera_driver);
 }
 
 module_init(pxa_camera_init);
diff --git a/drivers/media/video/sh_mobile_ceu_camera.c b/drivers/media/video/sh_mobile_ceu_camera.c
index f7ca3cb9340a..318754e73132 100644
--- a/drivers/media/video/sh_mobile_ceu_camera.c
+++ b/drivers/media/video/sh_mobile_ceu_camera.c
@@ -647,7 +647,7 @@ static int __init sh_mobile_ceu_init(void)
 
 static void __exit sh_mobile_ceu_exit(void)
 {
-        return platform_driver_unregister(&sh_mobile_ceu_driver);
+        platform_driver_unregister(&sh_mobile_ceu_driver);
 }
 
 module_init(sh_mobile_ceu_init);
diff --git a/drivers/media/video/soc_camera.c b/drivers/media/video/soc_camera.c
index b6be5ee678b6..66ebe5956a87 100644
--- a/drivers/media/video/soc_camera.c
+++ b/drivers/media/video/soc_camera.c
@@ -732,10 +732,36 @@ static int soc_camera_remove(struct device *dev)
         return 0;
 }
 
+static int soc_camera_suspend(struct device *dev, pm_message_t state)
+{
+        struct soc_camera_device *icd = to_soc_camera_dev(dev);
+        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
+        int ret = 0;
+
+        if (ici->ops->suspend)
+                ret = ici->ops->suspend(icd, state);
+
+        return ret;
+}
+
+static int soc_camera_resume(struct device *dev)
+{
+        struct soc_camera_device *icd = to_soc_camera_dev(dev);
+        struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
+        int ret = 0;
+
+        if (ici->ops->resume)
+                ret = ici->ops->resume(icd);
+
+        return ret;
+}
+
 static struct bus_type soc_camera_bus_type = {
         .name           = "soc-camera",
         .probe          = soc_camera_probe,
         .remove         = soc_camera_remove,
+        .suspend        = soc_camera_suspend,
+        .resume         = soc_camera_resume,
 };
 
 static struct device_driver ic_drv = {
diff --git a/drivers/media/video/soc_camera_platform.c b/drivers/media/video/soc_camera_platform.c
index eefb0327ebb6..1adc257ebdb9 100644
--- a/drivers/media/video/soc_camera_platform.c
+++ b/drivers/media/video/soc_camera_platform.c
@@ -187,7 +187,7 @@ static int __init soc_camera_platform_module_init(void)
 
 static void __exit soc_camera_platform_module_exit(void)
 {
-        return platform_driver_unregister(&soc_camera_platform_driver);
+        platform_driver_unregister(&soc_camera_platform_driver);
 }
 
 module_init(soc_camera_platform_module_init);
diff --git a/drivers/media/video/uvc/uvc_ctrl.c b/drivers/media/video/uvc/uvc_ctrl.c
index 626f4ad7e876..6ef3e5297de8 100644
--- a/drivers/media/video/uvc/uvc_ctrl.c
+++ b/drivers/media/video/uvc/uvc_ctrl.c
@@ -585,13 +585,17 @@ int uvc_query_v4l2_ctrl(struct uvc_video_device *video,
         struct uvc_control_mapping *mapping;
         struct uvc_menu_info *menu;
         unsigned int i;
-        __u8 data[8];
+        __u8 *data;
         int ret;
 
         ctrl = uvc_find_control(video, v4l2_ctrl->id, &mapping);
         if (ctrl == NULL)
                 return -EINVAL;
 
+        data = kmalloc(8, GFP_KERNEL);
+        if (data == NULL)
+                return -ENOMEM;
+
         memset(v4l2_ctrl, 0, sizeof *v4l2_ctrl);
         v4l2_ctrl->id = mapping->id;
         v4l2_ctrl->type = mapping->v4l2_type;
@@ -604,8 +608,8 @@ int uvc_query_v4l2_ctrl(struct uvc_video_device *video,
         if (ctrl->info->flags & UVC_CONTROL_GET_DEF) {
                 if ((ret = uvc_query_ctrl(video->dev, GET_DEF, ctrl->entity->id,
                                 video->dev->intfnum, ctrl->info->selector,
-                                &data, ctrl->info->size)) < 0)
-                        return ret;
+                                data, ctrl->info->size)) < 0)
+                        goto out;
                 v4l2_ctrl->default_value = uvc_get_le_value(data, mapping);
         }
 
@@ -623,13 +627,15 @@ int uvc_query_v4l2_ctrl(struct uvc_video_device *video,
                         }
                 }
 
-                return 0;
+                ret = 0;
+                goto out;
 
         case V4L2_CTRL_TYPE_BOOLEAN:
                 v4l2_ctrl->minimum = 0;
                 v4l2_ctrl->maximum = 1;
                 v4l2_ctrl->step = 1;
-                return 0;
+                ret = 0;
+                goto out;
 
         default:
                 break;
@@ -638,26 +644,29 @@ int uvc_query_v4l2_ctrl(struct uvc_video_device *video,
         if (ctrl->info->flags & UVC_CONTROL_GET_MIN) {
                 if ((ret = uvc_query_ctrl(video->dev, GET_MIN, ctrl->entity->id,
                                 video->dev->intfnum, ctrl->info->selector,
-                                &data, ctrl->info->size)) < 0)
-                        return ret;
+                                data, ctrl->info->size)) < 0)
+                        goto out;
                 v4l2_ctrl->minimum = uvc_get_le_value(data, mapping);
         }
         if (ctrl->info->flags & UVC_CONTROL_GET_MAX) {
                 if ((ret = uvc_query_ctrl(video->dev, GET_MAX, ctrl->entity->id,
                                 video->dev->intfnum, ctrl->info->selector,
-                                &data, ctrl->info->size)) < 0)
-                        return ret;
+                                data, ctrl->info->size)) < 0)
+                        goto out;
                 v4l2_ctrl->maximum = uvc_get_le_value(data, mapping);
         }
         if (ctrl->info->flags & UVC_CONTROL_GET_RES) {
                 if ((ret = uvc_query_ctrl(video->dev, GET_RES, ctrl->entity->id,
                                 video->dev->intfnum, ctrl->info->selector,
-                                &data, ctrl->info->size)) < 0)
-                        return ret;
+                                data, ctrl->info->size)) < 0)
+                        goto out;
                 v4l2_ctrl->step = uvc_get_le_value(data, mapping);
         }
 
-        return 0;
+        ret = 0;
+out:
+        kfree(data);
+        return ret;
 }
 
 
diff --git a/drivers/media/video/uvc/uvc_driver.c b/drivers/media/video/uvc/uvc_driver.c
index b3c4d75e8490..7e102034d38d 100644
--- a/drivers/media/video/uvc/uvc_driver.c
+++ b/drivers/media/video/uvc/uvc_driver.c
@@ -1884,7 +1884,7 @@ static struct usb_device_id uvc_ids[] = {
           .bInterfaceSubClass   = 1,
           .bInterfaceProtocol   = 0,
           .driver_info          = UVC_QUIRK_PROBE_MINMAX },
-        /* Packard Bell OEM Webcam */
+        /* Packard Bell OEM Webcam - Bison Electronics */
         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
                                 | USB_DEVICE_ID_MATCH_INT_INFO,
           .idVendor             = 0x5986,
@@ -1893,7 +1893,7 @@ static struct usb_device_id uvc_ids[] = {
           .bInterfaceSubClass   = 1,
           .bInterfaceProtocol   = 0,
           .driver_info          = UVC_QUIRK_PROBE_MINMAX },
-        /* Acer Crystal Eye webcam */
+        /* Acer Crystal Eye webcam - Bison Electronics */
         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
                                 | USB_DEVICE_ID_MATCH_INT_INFO,
           .idVendor             = 0x5986,
@@ -1902,7 +1902,7 @@ static struct usb_device_id uvc_ids[] = {
           .bInterfaceSubClass   = 1,
           .bInterfaceProtocol   = 0,
           .driver_info          = UVC_QUIRK_PROBE_MINMAX },
-        /* Medion Akoya Mini E1210 */
+        /* Medion Akoya Mini E1210 - Bison Electronics */
         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
                                 | USB_DEVICE_ID_MATCH_INT_INFO,
           .idVendor             = 0x5986,
@@ -1911,7 +1911,7 @@ static struct usb_device_id uvc_ids[] = {
           .bInterfaceSubClass   = 1,
           .bInterfaceProtocol   = 0,
           .driver_info          = UVC_QUIRK_PROBE_MINMAX },
-        /* Acer OrbiCam - Unknown vendor */
+        /* Acer OrbiCam - Bison Electronics */
         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
                                 | USB_DEVICE_ID_MATCH_INT_INFO,
           .idVendor             = 0x5986,
@@ -1920,6 +1920,24 @@ static struct usb_device_id uvc_ids[] = {
           .bInterfaceSubClass   = 1,
           .bInterfaceProtocol   = 0,
           .driver_info          = UVC_QUIRK_PROBE_MINMAX },
+        /* Bison Electronics */
+        { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
+                                | USB_DEVICE_ID_MATCH_INT_INFO,
+          .idVendor             = 0x5986,
+          .idProduct            = 0x0300,
+          .bInterfaceClass      = USB_CLASS_VIDEO,
+          .bInterfaceSubClass   = 1,
+          .bInterfaceProtocol   = 0,
+          .driver_info          = UVC_QUIRK_PROBE_MINMAX },
+        /* Clevo M570TU - Bison Electronics */
+        { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
+                                | USB_DEVICE_ID_MATCH_INT_INFO,
+          .idVendor             = 0x5986,
+          .idProduct            = 0x0303,
+          .bInterfaceClass      = USB_CLASS_VIDEO,
+          .bInterfaceSubClass   = 1,
+          .bInterfaceProtocol   = 0,
+          .driver_info          = UVC_QUIRK_PROBE_MINMAX },
         /* Generic USB Video Class */
         { USB_INTERFACE_INFO(USB_CLASS_VIDEO, 1, 0) },
         {}
diff --git a/drivers/media/video/uvc/uvc_video.c b/drivers/media/video/uvc/uvc_video.c
index ad63794fda77..6854ac78a161 100644
--- a/drivers/media/video/uvc/uvc_video.c
+++ b/drivers/media/video/uvc/uvc_video.c
@@ -90,17 +90,20 @@ static void uvc_fixup_buffer_size(struct uvc_video_device *video,
 static int uvc_get_video_ctrl(struct uvc_video_device *video,
         struct uvc_streaming_control *ctrl, int probe, __u8 query)
 {
-        __u8 data[34];
-        __u8 size;
+        __u8 *data;
+        __u16 size;
         int ret;
 
         size = video->dev->uvc_version >= 0x0110 ? 34 : 26;
+        data = kmalloc(size, GFP_KERNEL);
+        if (data == NULL)
+                return -ENOMEM;
+
         ret = __uvc_query_ctrl(video->dev, query, 0, video->streaming->intfnum,
-                probe ? VS_PROBE_CONTROL : VS_COMMIT_CONTROL, &data, size,
+                probe ? VS_PROBE_CONTROL : VS_COMMIT_CONTROL, data, size,
                 UVC_CTRL_STREAMING_TIMEOUT);
-
         if (ret < 0)
-                return ret;
+                goto out;
 
         ctrl->bmHint = le16_to_cpup((__le16 *)&data[0]);
         ctrl->bFormatIndex = data[2];
@@ -136,17 +139,22 @@ static int uvc_get_video_ctrl(struct uvc_video_device *video,
          */
         uvc_fixup_buffer_size(video, ctrl);
 
-        return 0;
+out:
+        kfree(data);
+        return ret;
 }
 
 int uvc_set_video_ctrl(struct uvc_video_device *video,
         struct uvc_streaming_control *ctrl, int probe)
 {
-        __u8 data[34];
-        __u8 size;
+        __u8 *data;
+        __u16 size;
+        int ret;
 
         size = video->dev->uvc_version >= 0x0110 ? 34 : 26;
-        memset(data, 0, sizeof data);
+        data = kzalloc(size, GFP_KERNEL);
+        if (data == NULL)
+                return -ENOMEM;
 
         *(__le16 *)&data[0] = cpu_to_le16(ctrl->bmHint);
         data[2] = ctrl->bFormatIndex;
@@ -174,10 +182,13 @@ int uvc_set_video_ctrl(struct uvc_video_device *video,
                 data[33] = ctrl->bMaxVersion;
         }
 
-        return __uvc_query_ctrl(video->dev, SET_CUR, 0,
+        ret = __uvc_query_ctrl(video->dev, SET_CUR, 0,
                 video->streaming->intfnum,
-                probe ? VS_PROBE_CONTROL : VS_COMMIT_CONTROL, &data, size,
+                probe ? VS_PROBE_CONTROL : VS_COMMIT_CONTROL, data, size,
                 UVC_CTRL_STREAMING_TIMEOUT);
+
+        kfree(data);
+        return ret;
 }
 
 int uvc_probe_video(struct uvc_video_device *video,
diff --git a/drivers/media/video/v4l2-dev.c b/drivers/media/video/v4l2-dev.c
index 556615fe93de..6f36006aecda 100644
--- a/drivers/media/video/v4l2-dev.c
+++ b/drivers/media/video/v4l2-dev.c
@@ -222,11 +222,13 @@ int video_register_device(struct video_device *vfd, int type, int nr)
 EXPORT_SYMBOL(video_register_device);
 
 /**
- *      video_register_device - register video4linux devices
+ *      video_register_device_index - register video4linux devices
  *      @vfd:  video device structure we want to register
  *      @type: type of device to register
  *      @nr:   which device number (0 == /dev/video0, 1 == /dev/video1, ...
  *             -1 == first free)
+ *      @index: stream number based on parent device;
+ *              -1 if auto assign, requested number otherwise
  *
  *      The registration code assigns minor numbers based on the type
  *      requested. -ENFILE is returned in all the device slots for this
diff --git a/drivers/media/video/vino.c b/drivers/media/video/vino.c
index ef7572cbc4ab..1edda456fc64 100644
--- a/drivers/media/video/vino.c
+++ b/drivers/media/video/vino.c
@@ -41,6 +41,7 @@
 #include <linux/videodev2.h>
 #include <media/v4l2-ioctl.h>
 #include <media/v4l2-common.h>
+#include <media/v4l2-ioctl.h>
 #include <linux/video_decoder.h>
 #include <linux/mutex.h>
 
diff --git a/drivers/misc/Kconfig b/drivers/misc/Kconfig
index 82af385460e4..a726f3b01a6b 100644
--- a/drivers/misc/Kconfig
+++ b/drivers/misc/Kconfig
@@ -427,10 +427,10 @@ config ENCLOSURE_SERVICES
 config SGI_XP
         tristate "Support communication between SGI SSIs"
         depends on NET
-        depends on IA64_GENERIC || IA64_SGI_SN2 || IA64_SGI_UV || (X86_64 && SMP)
+        depends on (IA64_GENERIC || IA64_SGI_SN2 || IA64_SGI_UV || X86_64) && SMP
         select IA64_UNCACHED_ALLOCATOR if IA64_GENERIC || IA64_SGI_SN2
         select GENERIC_ALLOCATOR if IA64_GENERIC || IA64_SGI_SN2
-        select SGI_GRU if IA64_GENERIC || IA64_SGI_UV || (X86_64 && SMP)
+        select SGI_GRU if (IA64_GENERIC || IA64_SGI_UV || X86_64) && SMP
         ---help---
           An SGI machine can be divided into multiple Single System
           Images which act independently of each other and have
diff --git a/drivers/watchdog/Kconfig b/drivers/watchdog/Kconfig
index 48399e134c0d..32b9fe153641 100644
--- a/drivers/watchdog/Kconfig
+++ b/drivers/watchdog/Kconfig
@@ -463,7 +463,7 @@ config PC87413_WDT
           module will be called pc87413_wdt.
 
           Most people will say N.
- 
+
 config 60XX_WDT
         tristate "SBC-60XX Watchdog Timer"
         depends on X86
@@ -695,9 +695,17 @@ config 8xx_WDT
         tristate "MPC8xx Watchdog Timer"
         depends on 8xx
 
-config 83xx_WDT
-        tristate "MPC83xx Watchdog Timer"
-        depends on PPC_83xx
+config 8xxx_WDT
+        tristate "MPC8xxx Platform Watchdog Timer"
+        depends on PPC_8xx || PPC_83xx || PPC_86xx
+        help
+          This driver is for a SoC level watchdog that exists on some
+          Freescale PowerPC processors. So far this driver supports:
+          - MPC8xx watchdogs
+          - MPC83xx watchdogs
+          - MPC86xx watchdogs
+
+          For BookE processors (MPC85xx) use the BOOKE_WDT driver instead.
 
 config MV64X60_WDT
         tristate "MV64X60 (Marvell Discovery) Watchdog Timer"
diff --git a/drivers/watchdog/Makefile b/drivers/watchdog/Makefile
index edd305a64e63..049c91895699 100644
--- a/drivers/watchdog/Makefile
+++ b/drivers/watchdog/Makefile
@@ -92,7 +92,7 @@ obj-$(CONFIG_SBC_EPX_C3_WATCHDOG) += sbc_epx_c3.o
 
 # MIPS Architecture
 obj-$(CONFIG_INDYDOG) += indydog.o
-obj-$(CONFIG_WDT_MTX1)  += mtx-1_wdt.o
+obj-$(CONFIG_WDT_MTX1) += mtx-1_wdt.o
 obj-$(CONFIG_WDT_RM9K_GPI) += rm9k_wdt.o
 obj-$(CONFIG_SIBYTE_WDOG) += sb_wdog.o
 obj-$(CONFIG_AR7_WDT) += ar7_wdt.o
@@ -103,7 +103,7 @@ obj-$(CONFIG_TXX9_WDT) += txx9wdt.o
 # POWERPC Architecture
 obj-$(CONFIG_8xx_WDT) += mpc8xx_wdt.o
 obj-$(CONFIG_MPC5200_WDT) += mpc5200_wdt.o
-obj-$(CONFIG_83xx_WDT) += mpc83xx_wdt.o
+obj-$(CONFIG_8xxx_WDT) += mpc8xxx_wdt.o
 obj-$(CONFIG_MV64X60_WDT) += mv64x60_wdt.o
 obj-$(CONFIG_BOOKE_WDT) += booke_wdt.o
 
diff --git a/drivers/watchdog/acquirewdt.c b/drivers/watchdog/acquirewdt.c
index 85269c365a10..6e46a551395c 100644
--- a/drivers/watchdog/acquirewdt.c
+++ b/drivers/watchdog/acquirewdt.c
@@ -58,39 +58,45 @@
 #include <linux/types.h>                /* For standard types (like size_t) */
 #include <linux/errno.h>                /* For the -ENODEV/... values */
 #include <linux/kernel.h>               /* For printk/panic/... */
-#include <linux/miscdevice.h>           /* For MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR) */
+#include <linux/miscdevice.h>           /* For MODULE_ALIAS_MISCDEV
+                                                        (WATCHDOG_MINOR) */
 #include <linux/watchdog.h>             /* For the watchdog specific items */
 #include <linux/fs.h>                   /* For file operations */
 #include <linux/ioport.h>               /* For io-port access */
 #include <linux/platform_device.h>      /* For platform_driver framework */
 #include <linux/init.h>                 /* For __init/__exit/... */
-
-#include <asm/uaccess.h>                /* For copy_to_user/put_user/... */
-#include <asm/io.h>                     /* For inb/outb/... */
+#include <linux/uaccess.h>              /* For copy_to_user/put_user/... */
+#include <linux/io.h>                   /* For inb/outb/... */
 
 /* Module information */
 #define DRV_NAME "acquirewdt"
 #define PFX DRV_NAME ": "
 #define WATCHDOG_NAME "Acquire WDT"
-#define WATCHDOG_HEARTBEAT 0    /* There is no way to see what the correct time-out period is */
+/* There is no way to see what the correct time-out period is */
+#define WATCHDOG_HEARTBEAT 0
 
 /* internal variables */
-static struct platform_device *acq_platform_device;     /* the watchdog platform device */
+/* the watchdog platform device */
+static struct platform_device *acq_platform_device;
 static unsigned long acq_is_open;
 static char expect_close;
 
 /* module parameters */
-static int wdt_stop = 0x43;     /* You must set this - there is no sane way to probe for this board. */
+/* You must set this - there is no sane way to probe for this board. */
+static int wdt_stop = 0x43;
 module_param(wdt_stop, int, 0);
 MODULE_PARM_DESC(wdt_stop, "Acquire WDT 'stop' io port (default 0x43)");
 
-static int wdt_start = 0x443;   /* You must set this - there is no sane way to probe for this board. */
+/* You must set this - there is no sane way to probe for this board. */
+static int wdt_start = 0x443;
 module_param(wdt_start, int, 0);
 MODULE_PARM_DESC(wdt_start, "Acquire WDT 'start' io port (default 0x443)");
 
 static int nowayout = WATCHDOG_NOWAYOUT;
 module_param(nowayout, int, 0);
-MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+MODULE_PARM_DESC(nowayout,
+        "Watchdog cannot be stopped once started (default="
+        __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 
 /*
  *      Watchdog Operations
@@ -112,18 +118,18 @@ static void acq_stop(void)
  *      /dev/watchdog handling
  */
 
-static ssize_t acq_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
+static ssize_t acq_write(struct file *file, const char __user *buf,
+                                                size_t count, loff_t *ppos)
 {
         /* See if we got the magic character 'V' and reload the timer */
-        if(count) {
+        if (count) {
                 if (!nowayout) {
                         size_t i;
-
                         /* note: just in case someone wrote the magic character
-                         * five months ago... */
+                           five months ago... */
                         expect_close = 0;
-
-                        /* scan to see whether or not we got the magic character */
+                        /* scan to see whether or not we got the
+                           magic character */
                         for (i = 0; i != count; i++) {
                                 char c;
                                 if (get_user(c, buf + i))
@@ -132,64 +138,55 @@ static ssize_t acq_write(struct file *file, const char __user *buf, size_t count
                                         expect_close = 42;
                         }
                 }
-
-                /* Well, anyhow someone wrote to us, we should return that favour */
+                /* Well, anyhow someone wrote to us, we should
+                                return that favour */
                 acq_keepalive();
         }
         return count;
 }
 
-static int acq_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
-        unsigned long arg)
+static long acq_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
         int options, retval = -EINVAL;
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
-        static struct watchdog_info ident =
-        {
+        static struct watchdog_info ident = {
                 .options = WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE,
                 .firmware_version = 1,
                 .identity = WATCHDOG_NAME,
         };
 
-        switch(cmd)
-        {
+        switch (cmd) {
         case WDIOC_GETSUPPORT:
-          return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;
+                return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;
 
         case WDIOC_GETSTATUS:
         case WDIOC_GETBOOTSTATUS:
-          return put_user(0, p);
-
-        case WDIOC_KEEPALIVE:
-          acq_keepalive();
-          return 0;
-
-        case WDIOC_GETTIMEOUT:
-          return put_user(WATCHDOG_HEARTBEAT, p);
+                return put_user(0, p);
 
         case WDIOC_SETOPTIONS:
         {
-            if (get_user(options, p))
-              return -EFAULT;
-
-            if (options & WDIOS_DISABLECARD)
-            {
-              acq_stop();
-              retval = 0;
-            }
-
-            if (options & WDIOS_ENABLECARD)
-            {
-              acq_keepalive();
-              retval = 0;
-            }
-
-            return retval;
+                if (get_user(options, p))
+                        return -EFAULT;
+                if (options & WDIOS_DISABLECARD) {
+                        acq_stop();
+                        retval = 0;
+                }
+                if (options & WDIOS_ENABLECARD) {
+                        acq_keepalive();
+                        retval = 0;
+                }
+                return retval;
         }
+        case WDIOC_KEEPALIVE:
+                acq_keepalive();
+                return 0;
+
+        case WDIOC_GETTIMEOUT:
+                return put_user(WATCHDOG_HEARTBEAT, p);
 
         default:
-          return -ENOTTY;
+                return -ENOTTY;
         }
 }
 
@@ -211,7 +208,8 @@ static int acq_close(struct inode *inode, struct file *file)
         if (expect_close == 42) {
                 acq_stop();
         } else {
-                printk(KERN_CRIT PFX "Unexpected close, not stopping watchdog!\n");
+                printk(KERN_CRIT PFX
+                        "Unexpected close, not stopping watchdog!\n");
                 acq_keepalive();
         }
         clear_bit(0, &acq_is_open);
@@ -227,7 +225,7 @@ static const struct file_operations acq_fops = {
         .owner          = THIS_MODULE,
         .llseek         = no_llseek,
         .write          = acq_write,
-        .ioctl          = acq_ioctl,
+        .unlocked_ioctl = acq_ioctl,
         .open           = acq_open,
         .release        = acq_close,
 };
@@ -248,32 +246,29 @@ static int __devinit acq_probe(struct platform_device *dev)
 
         if (wdt_stop != wdt_start) {
                 if (!request_region(wdt_stop, 1, WATCHDOG_NAME)) {
-                        printk (KERN_ERR PFX "I/O address 0x%04x already in use\n",
-                                wdt_stop);
+                        printk(KERN_ERR PFX
+                            "I/O address 0x%04x already in use\n", wdt_stop);
                         ret = -EIO;
                         goto out;
                 }
         }
 
         if (!request_region(wdt_start, 1, WATCHDOG_NAME)) {
-                printk (KERN_ERR PFX "I/O address 0x%04x already in use\n",
+                printk(KERN_ERR PFX "I/O address 0x%04x already in use\n",
                         wdt_start);
                 ret = -EIO;
                 goto unreg_stop;
         }
-
         ret = misc_register(&acq_miscdev);
         if (ret != 0) {
-                printk (KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",
-                        WATCHDOG_MINOR, ret);
+                printk(KERN_ERR PFX
+                        "cannot register miscdev on minor=%d (err=%d)\n",
+                                                        WATCHDOG_MINOR, ret);
                 goto unreg_regions;
         }
-
-        printk (KERN_INFO PFX "initialized. (nowayout=%d)\n",
-                nowayout);
+        printk(KERN_INFO PFX "initialized. (nowayout=%d)\n", nowayout);
 
         return 0;
-
 unreg_regions:
         release_region(wdt_start, 1);
 unreg_stop:
@@ -286,9 +281,9 @@ out:
 static int __devexit acq_remove(struct platform_device *dev)
 {
         misc_deregister(&acq_miscdev);
-        release_region(wdt_start,1);
-        if(wdt_stop != wdt_start)
-                release_region(wdt_stop,1);
+        release_region(wdt_start, 1);
+        if (wdt_stop != wdt_start)
+                release_region(wdt_stop, 1);
 
         return 0;
 }
@@ -313,18 +308,19 @@ static int __init acq_init(void)
 {
         int err;
 
-        printk(KERN_INFO "WDT driver for Acquire single board computer initialising.\n");
+        printk(KERN_INFO
+              "WDT driver for Acquire single board computer initialising.\n");
 
         err = platform_driver_register(&acquirewdt_driver);
         if (err)
                 return err;
 
-        acq_platform_device = platform_device_register_simple(DRV_NAME, -1, NULL, 0);
+        acq_platform_device = platform_device_register_simple(DRV_NAME,
+                                                                -1, NULL, 0);
         if (IS_ERR(acq_platform_device)) {
                 err = PTR_ERR(acq_platform_device);
                 goto unreg_platform_driver;
         }
-
         return 0;
 
 unreg_platform_driver:
diff --git a/drivers/watchdog/advantechwdt.c b/drivers/watchdog/advantechwdt.c
index 8121cc247343..a5110f93a755 100644
--- a/drivers/watchdog/advantechwdt.c
+++ b/drivers/watchdog/advantechwdt.c
@@ -37,9 +37,9 @@
 #include <linux/ioport.h>
 #include <linux/platform_device.h>
 #include <linux/init.h>
+#include <linux/io.h>
+#include <linux/uaccess.h>
 
-#include <asm/io.h>
-#include <asm/uaccess.h>
 #include <asm/system.h>
 
 #define DRV_NAME "advantechwdt"
@@ -47,7 +47,8 @@
 #define WATCHDOG_NAME "Advantech WDT"
 #define WATCHDOG_TIMEOUT 60             /* 60 sec default timeout */
 
-static struct platform_device *advwdt_platform_device;  /* the watchdog platform device */
+/* the watchdog platform device */
+static struct platform_device *advwdt_platform_device;
 static unsigned long advwdt_is_open;
 static char adv_expect_close;
 
@@ -72,35 +73,35 @@ MODULE_PARM_DESC(wdt_start, "Advantech WDT 'start' io port (default 0x443)");
 
 static int timeout = WATCHDOG_TIMEOUT;  /* in seconds */
 module_param(timeout, int, 0);
-MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds. 1<= timeout <=63, default=" __MODULE_STRING(WATCHDOG_TIMEOUT) ".");
+MODULE_PARM_DESC(timeout,
+        "Watchdog timeout in seconds. 1<= timeout <=63, default="
+                __MODULE_STRING(WATCHDOG_TIMEOUT) ".");
 
 static int nowayout = WATCHDOG_NOWAYOUT;
 module_param(nowayout, int, 0);
-MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+MODULE_PARM_DESC(nowayout,
+        "Watchdog cannot be stopped once started (default="
+                __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 
 /*
  *      Watchdog Operations
  */
 
-static void
-advwdt_ping(void)
+static void advwdt_ping(void)
 {
         /* Write a watchdog value */
         outb_p(timeout, wdt_start);
 }
 
-static void
-advwdt_disable(void)
+static void advwdt_disable(void)
 {
         inb_p(wdt_stop);
 }
 
-static int
-advwdt_set_heartbeat(int t)
+static int advwdt_set_heartbeat(int t)
 {
-        if ((t < 1) || (t > 63))
+        if (t < 1 || t > 63)
                 return -EINVAL;
-
         timeout = t;
         return 0;
 }
@@ -109,8 +110,8 @@ advwdt_set_heartbeat(int t)
  *      /dev/watchdog handling
  */
 
-static ssize_t
-advwdt_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
+static ssize_t advwdt_write(struct file *file, const char __user *buf,
+                                                size_t count, loff_t *ppos)
 {
         if (count) {
                 if (!nowayout) {
@@ -120,7 +121,7 @@ advwdt_write(struct file *file, const char __user *buf, size_t count, loff_t *pp
 
                         for (i = 0; i != count; i++) {
                                 char c;
-                                if (get_user(c, buf+i))
+                                if (get_user(c, buf + i))
                                         return -EFAULT;
                                 if (c == 'V')
                                         adv_expect_close = 42;
@@ -131,9 +132,7 @@ advwdt_write(struct file *file, const char __user *buf, size_t count, loff_t *pp
         return count;
 }
 
-static int
-advwdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
-          unsigned long arg)
+static long advwdt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
         int new_timeout;
         void __user *argp = (void __user *)arg;
@@ -146,57 +145,50 @@ advwdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
 
         switch (cmd) {
         case WDIOC_GETSUPPORT:
-          if (copy_to_user(argp, &ident, sizeof(ident)))
-            return -EFAULT;
-          break;
+                if (copy_to_user(argp, &ident, sizeof(ident)))
+                        return -EFAULT;
+                break;
 
         case WDIOC_GETSTATUS:
         case WDIOC_GETBOOTSTATUS:
-          return put_user(0, p);
-
-        case WDIOC_KEEPALIVE:
-          advwdt_ping();
-          break;
-
-        case WDIOC_SETTIMEOUT:
-          if (get_user(new_timeout, p))
-                  return -EFAULT;
-          if (advwdt_set_heartbeat(new_timeout))
-                  return -EINVAL;
-          advwdt_ping();
-          /* Fall */
-
-        case WDIOC_GETTIMEOUT:
-          return put_user(timeout, p);
+                return put_user(0, p);
 
         case WDIOC_SETOPTIONS:
         {
-          int options, retval = -EINVAL;
-
-          if (get_user(options, p))
-            return -EFAULT;
-
-          if (options & WDIOS_DISABLECARD) {
-            advwdt_disable();
-            retval = 0;
-          }
+                int options, retval = -EINVAL;
 
-          if (options & WDIOS_ENABLECARD) {
-            advwdt_ping();
-            retval = 0;
-          }
-
-          return retval;
+                if (get_user(options, p))
+                        return -EFAULT;
+                if (options & WDIOS_DISABLECARD) {
+                        advwdt_disable();
+                        retval = 0;
+                }
+                if (options & WDIOS_ENABLECARD) {
+                        advwdt_ping();
+                        retval = 0;
+                }
+                return retval;
         }
+        case WDIOC_KEEPALIVE:
+                advwdt_ping();
+                break;
 
+        case WDIOC_SETTIMEOUT:
+                if (get_user(new_timeout, p))
+                        return -EFAULT;
+                if (advwdt_set_heartbeat(new_timeout))
+                        return -EINVAL;
+                advwdt_ping();
+                /* Fall */
+        case WDIOC_GETTIMEOUT:
+                return put_user(timeout, p);
         default:
-          return -ENOTTY;
+                return -ENOTTY;
         }
         return 0;
 }
 
-static int
-advwdt_open(struct inode *inode, struct file *file)
+static int advwdt_open(struct inode *inode, struct file *file)
 {
         if (test_and_set_bit(0, &advwdt_is_open))
                 return -EBUSY;
@@ -208,13 +200,13 @@ advwdt_open(struct inode *inode, struct file *file)
         return nonseekable_open(inode, file);
 }
 
-static int
-advwdt_close(struct inode *inode, struct file *file)
+static int advwdt_close(struct inode *inode, struct file *file)
 {
         if (adv_expect_close == 42) {
                 advwdt_disable();
         } else {
-                printk(KERN_CRIT PFX "Unexpected close, not stopping watchdog!\n");
+                printk(KERN_CRIT PFX
+                                "Unexpected close, not stopping watchdog!\n");
                 advwdt_ping();
         }
         clear_bit(0, &advwdt_is_open);
@@ -230,7 +222,7 @@ static const struct file_operations advwdt_fops = {
         .owner          = THIS_MODULE,
         .llseek         = no_llseek,
         .write          = advwdt_write,
-        .ioctl          = advwdt_ioctl,
+        .unlocked_ioctl = advwdt_ioctl,
         .open           = advwdt_open,
         .release        = advwdt_close,
 };
@@ -245,23 +237,24 @@ static struct miscdevice advwdt_miscdev = {
  *      Init & exit routines
  */
 
-static int __devinit
-advwdt_probe(struct platform_device *dev)
+static int __devinit advwdt_probe(struct platform_device *dev)
 {
         int ret;
 
         if (wdt_stop != wdt_start) {
                 if (!request_region(wdt_stop, 1, WATCHDOG_NAME)) {
-                        printk (KERN_ERR PFX "I/O address 0x%04x already in use\n",
-                                wdt_stop);
+                        printk(KERN_ERR PFX
+                                "I/O address 0x%04x already in use\n",
+                                                                wdt_stop);
                         ret = -EIO;
                         goto out;
                 }
         }
 
         if (!request_region(wdt_start, 1, WATCHDOG_NAME)) {
-                printk (KERN_ERR PFX "I/O address 0x%04x already in use\n",
-                        wdt_start);
+                printk(KERN_ERR PFX
+                                "I/O address 0x%04x already in use\n",
+                                                                wdt_start);
                 ret = -EIO;
                 goto unreg_stop;
         }
@@ -269,20 +262,19 @@ advwdt_probe(struct platform_device *dev)
         /* Check that the heartbeat value is within it's range ; if not reset to the default */
         if (advwdt_set_heartbeat(timeout)) {
                 advwdt_set_heartbeat(WATCHDOG_TIMEOUT);
-                printk (KERN_INFO PFX "timeout value must be 1<=x<=63, using %d\n",
-                        timeout);
+                printk(KERN_INFO PFX
+                        "timeout value must be 1<=x<=63, using %d\n", timeout);
         }
 
         ret = misc_register(&advwdt_miscdev);
         if (ret != 0) {
-                printk (KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",
-                        WATCHDOG_MINOR, ret);
+                printk(KERN_ERR PFX
+                        "cannot register miscdev on minor=%d (err=%d)\n",
+                                                        WATCHDOG_MINOR, ret);
                 goto unreg_regions;
         }
-
-        printk (KERN_INFO PFX "initialized. timeout=%d sec (nowayout=%d)\n",
+        printk(KERN_INFO PFX "initialized. timeout=%d sec (nowayout=%d)\n",
                 timeout, nowayout);
-
 out:
         return ret;
 unreg_regions:
@@ -293,19 +285,17 @@ unreg_stop:
         goto out;
 }
 
-static int __devexit
-advwdt_remove(struct platform_device *dev)
+static int __devexit advwdt_remove(struct platform_device *dev)
 {
         misc_deregister(&advwdt_miscdev);
-        release_region(wdt_start,1);
-        if(wdt_stop != wdt_start)
-                release_region(wdt_stop,1);
+        release_region(wdt_start, 1);
+        if (wdt_stop != wdt_start)
+                release_region(wdt_stop, 1);
 
         return 0;
 }
 
-static void
-advwdt_shutdown(struct platform_device *dev)
+static void advwdt_shutdown(struct platform_device *dev)
 {
         /* Turn the WDT off if we have a soft shutdown */
         advwdt_disable();
@@ -321,18 +311,19 @@ static struct platform_driver advwdt_driver = {
         },
 };
 
-static int __init
-advwdt_init(void)
+static int __init advwdt_init(void)
 {
         int err;
 
-        printk(KERN_INFO "WDT driver for Advantech single board computer initialising.\n");
+        printk(KERN_INFO
+             "WDT driver for Advantech single board computer initialising.\n");
 
         err = platform_driver_register(&advwdt_driver);
         if (err)
                 return err;
 
-        advwdt_platform_device = platform_device_register_simple(DRV_NAME, -1, NULL, 0);
+        advwdt_platform_device = platform_device_register_simple(DRV_NAME,
+                                                                -1, NULL, 0);
         if (IS_ERR(advwdt_platform_device)) {
                 err = PTR_ERR(advwdt_platform_device);
                 goto unreg_platform_driver;
@@ -345,8 +336,7 @@ unreg_platform_driver:
         return err;
 }
 
-static void __exit
-advwdt_exit(void)
+static void __exit advwdt_exit(void)
 {
         platform_device_unregister(advwdt_platform_device);
         platform_driver_unregister(&advwdt_driver);
diff --git a/drivers/watchdog/alim1535_wdt.c b/drivers/watchdog/alim1535_wdt.c
index 2b1fbdb2fcf7..2a7690ecf97d 100644
--- a/drivers/watchdog/alim1535_wdt.c
+++ b/drivers/watchdog/alim1535_wdt.c
@@ -18,9 +18,8 @@
 #include <linux/init.h>
 #include <linux/fs.h>
 #include <linux/pci.h>
-
-#include <asm/uaccess.h>
-#include <asm/io.h>
+#include <linux/uaccess.h>
+#include <linux/io.h>
 
 #define WATCHDOG_NAME "ALi_M1535"
 #define PFX WATCHDOG_NAME ": "
@@ -30,17 +29,21 @@
 static unsigned long ali_is_open;
 static char ali_expect_release;
 static struct pci_dev *ali_pci;
-static u32 ali_timeout_bits;    /* stores the computed timeout */
+static u32 ali_timeout_bits;            /* stores the computed timeout */
 static DEFINE_SPINLOCK(ali_lock);       /* Guards the hardware */
 
 /* module parameters */
 static int timeout = WATCHDOG_TIMEOUT;
 module_param(timeout, int, 0);
-MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds. (0<timeout<18000, default=" __MODULE_STRING(WATCHDOG_TIMEOUT) ")");
+MODULE_PARM_DESC(timeout,
+                "Watchdog timeout in seconds. (0 < timeout < 18000, default="
+                                __MODULE_STRING(WATCHDOG_TIMEOUT) ")");
 
 static int nowayout = WATCHDOG_NOWAYOUT;
 module_param(nowayout, int, 0);
-MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+MODULE_PARM_DESC(nowayout,
+                "Watchdog cannot be stopped once started (default="
+                                __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 
 /*
  *      ali_start       -       start watchdog countdown
@@ -103,15 +106,16 @@ static void ali_keepalive(void)
 
 static int ali_settimer(int t)
 {
-        if(t < 0)
+        if (t < 0)
                 return -EINVAL;
-        else if(t < 60)
+        else if (t < 60)
                 ali_timeout_bits = t|(1<<6);
-        else if(t < 3600)
+        else if (t < 3600)
                 ali_timeout_bits = (t/60)|(1<<7);
-        else if(t < 18000)
+        else if (t < 18000)
                 ali_timeout_bits = (t/300)|(1<<6)|(1<<7);
-        else return -EINVAL;
+        else
+                return -EINVAL;
 
         timeout = t;
         return 0;
@@ -134,21 +138,22 @@ static int ali_settimer(int t)
  */
 
 static ssize_t ali_write(struct file *file, const char __user *data,
-                              size_t len, loff_t * ppos)
+                              size_t len, loff_t *ppos)
 {
         /* See if we got the magic character 'V' and reload the timer */
         if (len) {
                 if (!nowayout) {
                         size_t i;
 
-                        /* note: just in case someone wrote the magic character
-                         * five months ago... */
+                        /* note: just in case someone wrote the
+                           magic character five months ago... */
                         ali_expect_release = 0;
 
-                        /* scan to see whether or not we got the magic character */
+                        /* scan to see whether or not we got
+                           the magic character */
                         for (i = 0; i != len; i++) {
                                 char c;
-                                if(get_user(c, data+i))
+                                if (get_user(c, data + i))
                                         return -EFAULT;
                                 if (c == 'V')
                                         ali_expect_release = 42;
@@ -163,7 +168,6 @@ static ssize_t ali_write(struct file *file, const char __user *data,
 
 /*
  *      ali_ioctl       -       handle watchdog ioctls
- *      @inode: VFS inode
  *      @file: VFS file pointer
  *      @cmd: ioctl number
  *      @arg: arguments to the ioctl
@@ -172,8 +176,7 @@ static ssize_t ali_write(struct file *file, const char __user *data,
  *      we want an extension to enable irq ack monitoring and the like
  */
 
-static int ali_ioctl(struct inode *inode, struct file *file,
-                          unsigned int cmd, unsigned long arg)
+static long ali_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
@@ -186,57 +189,45 @@ static int ali_ioctl(struct inode *inode, struct file *file,
         };
 
         switch (cmd) {
-                case WDIOC_GETSUPPORT:
-                        return copy_to_user(argp, &ident,
-                                sizeof (ident)) ? -EFAULT : 0;
-
-                case WDIOC_GETSTATUS:
-                case WDIOC_GETBOOTSTATUS:
-                        return put_user(0, p);
-
-                case WDIOC_KEEPALIVE:
-                        ali_keepalive();
-                        return 0;
-
-                case WDIOC_SETOPTIONS:
-                {
-                        int new_options, retval = -EINVAL;
-
-                        if (get_user (new_options, p))
-                                return -EFAULT;
-
-                        if (new_options & WDIOS_DISABLECARD) {
-                                ali_stop();
-                                retval = 0;
-                        }
-
-                        if (new_options & WDIOS_ENABLECARD) {
-                                ali_start();
-                                retval = 0;
-                        }
-
-                        return retval;
+        case WDIOC_GETSUPPORT:
+                return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;
+
+        case WDIOC_GETSTATUS:
+        case WDIOC_GETBOOTSTATUS:
+                return put_user(0, p);
+        case WDIOC_SETOPTIONS:
+        {
+                int new_options, retval = -EINVAL;
+
+                if (get_user(new_options, p))
+                        return -EFAULT;
+                if (new_options & WDIOS_DISABLECARD) {
+                        ali_stop();
+                        retval = 0;
                 }
-
-                case WDIOC_SETTIMEOUT:
-                {
-                        int new_timeout;
-
-                        if (get_user(new_timeout, p))
-                                return -EFAULT;
-
-                        if (ali_settimer(new_timeout))
-                            return -EINVAL;
-
-                        ali_keepalive();
-                        /* Fall */
+                if (new_options & WDIOS_ENABLECARD) {
+                        ali_start();
+                        retval = 0;
                 }
-
-                case WDIOC_GETTIMEOUT:
-                        return put_user(timeout, p);
-
-                default:
-                        return -ENOTTY;
+                return retval;
+        }
+        case WDIOC_KEEPALIVE:
+                ali_keepalive();
+                return 0;
+        case WDIOC_SETTIMEOUT:
+        {
+                int new_timeout;
+                if (get_user(new_timeout, p))
+                        return -EFAULT;
+                if (ali_settimer(new_timeout))
+                        return -EINVAL;
+                ali_keepalive();
+                /* Fall */
+        }
+        case WDIOC_GETTIMEOUT:
+                return put_user(timeout, p);
+        default:
+                return -ENOTTY;
         }
 }
 
@@ -274,10 +265,11 @@ static int ali_release(struct inode *inode, struct file *file)
         /*
          *      Shut off the timer.
          */
-        if (ali_expect_release == 42) {
+        if (ali_expect_release == 42)
                 ali_stop();
-        } else {
-                printk(KERN_CRIT PFX "Unexpected close, not stopping watchdog!\n");
+        else {
+                printk(KERN_CRIT PFX
+                                "Unexpected close, not stopping watchdog!\n");
                 ali_keepalive();
         }
         clear_bit(0, &ali_is_open);
@@ -292,13 +284,11 @@ static int ali_release(struct inode *inode, struct file *file)
  */
 
 
-static int ali_notify_sys(struct notifier_block *this, unsigned long code, void *unused)
+static int ali_notify_sys(struct notifier_block *this,
+                                        unsigned long code, void *unused)
 {
-        if (code==SYS_DOWN || code==SYS_HALT) {
-                /* Turn the WDT off */
-                ali_stop();
-        }
-
+        if (code == SYS_DOWN || code == SYS_HALT)
+                ali_stop();             /* Turn the WDT off */
         return NOTIFY_DONE;
 }
 
@@ -340,10 +330,10 @@ static int __init ali_find_watchdog(void)
 
         /* Check for the a 7101 PMU */
         pdev = pci_get_device(PCI_VENDOR_ID_AL, 0x7101, NULL);
-        if(pdev == NULL)
+        if (pdev == NULL)
                 return -ENODEV;
 
-        if(pci_enable_device(pdev)) {
+        if (pci_enable_device(pdev)) {
                 pci_dev_put(pdev);
                 return -EIO;
         }
@@ -355,9 +345,12 @@ static int __init ali_find_watchdog(void)
          */
         pci_read_config_dword(pdev, 0xCC, &wdog);
 
-        wdog &= ~0x3F;          /* Timer bits */
-        wdog &= ~((1<<27)|(1<<26)|(1<<25)|(1<<24));     /* Issued events */
-        wdog &= ~((1<<16)|(1<<13)|(1<<12)|(1<<11)|(1<<10)|(1<<9));      /* No monitor bits */
+        /* Timer bits */
+        wdog &= ~0x3F;
+        /* Issued events */
+        wdog &= ~((1<<27)|(1<<26)|(1<<25)|(1<<24));
+        /* No monitor bits */
+        wdog &= ~((1<<16)|(1<<13)|(1<<12)|(1<<11)|(1<<10)|(1<<9));
 
         pci_write_config_dword(pdev, 0xCC, wdog);
 
@@ -369,12 +362,12 @@ static int __init ali_find_watchdog(void)
  */
 
 static const struct file_operations ali_fops = {
-        .owner =        THIS_MODULE,
-        .llseek =       no_llseek,
-        .write =        ali_write,
-        .ioctl =        ali_ioctl,
-        .open =         ali_open,
-        .release =      ali_release,
+        .owner          =       THIS_MODULE,
+        .llseek         =       no_llseek,
+        .write          =       ali_write,
+        .unlocked_ioctl =       ali_ioctl,
+        .open           =       ali_open,
+        .release        =       ali_release,
 };
 
 static struct miscdevice ali_miscdev = {
@@ -399,15 +392,16 @@ static int __init watchdog_init(void)
         int ret;
 
         /* Check whether or not the hardware watchdog is there */
-        if (ali_find_watchdog() != 0) {
+        if (ali_find_watchdog() != 0)
                 return -ENODEV;
-        }
 
-        /* Check that the timeout value is within it's range ; if not reset to the default */
+        /* Check that the timeout value is within it's range;
+           if not reset to the default */
         if (timeout < 1 || timeout >= 18000) {
                 timeout = WATCHDOG_TIMEOUT;
-                printk(KERN_INFO PFX "timeout value must be 0<timeout<18000, using %d\n",
-                        timeout);
+                printk(KERN_INFO PFX
+                     "timeout value must be 0 < timeout < 18000, using %d\n",
+                                                        timeout);
         }
 
         /* Calculate the watchdog's timeout */
@@ -415,15 +409,16 @@ static int __init watchdog_init(void)
 
         ret = register_reboot_notifier(&ali_notifier);
         if (ret != 0) {
-                printk(KERN_ERR PFX "cannot register reboot notifier (err=%d)\n",
-                        ret);
+                printk(KERN_ERR PFX
+                        "cannot register reboot notifier (err=%d)\n", ret);
                 goto out;
         }
 
         ret = misc_register(&ali_miscdev);
         if (ret != 0) {
-                printk(KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",
-                        WATCHDOG_MINOR, ret);
+                printk(KERN_ERR PFX
+                        "cannot register miscdev on minor=%d (err=%d)\n",
+                                                WATCHDOG_MINOR, ret);
                 goto unreg_reboot;
         }
 
diff --git a/drivers/watchdog/alim7101_wdt.c b/drivers/watchdog/alim7101_wdt.c
index 238273c98656..a045ef869439 100644
--- a/drivers/watchdog/alim7101_wdt.c
+++ b/drivers/watchdog/alim7101_wdt.c
@@ -31,9 +31,9 @@
 #include <linux/init.h>
 #include <linux/fs.h>
 #include <linux/pci.h>
+#include <linux/io.h>
+#include <linux/uaccess.h>
 
-#include <asm/io.h>
-#include <asm/uaccess.h>
 #include <asm/system.h>
 
 #define OUR_NAME "alim7101_wdt"
@@ -60,13 +60,17 @@
  */
 
 #define WATCHDOG_TIMEOUT 30            /* 30 sec default timeout */
-static int timeout = WATCHDOG_TIMEOUT; /* in seconds, will be multiplied by HZ to get seconds to wait for a ping */
+/* in seconds, will be multiplied by HZ to get seconds to wait for a ping */
+static int timeout = WATCHDOG_TIMEOUT;
 module_param(timeout, int, 0);
-MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds. (1<=timeout<=3600, default=" __MODULE_STRING(WATCHDOG_TIMEOUT) ")");
+MODULE_PARM_DESC(timeout,
+                "Watchdog timeout in seconds. (1<=timeout<=3600, default="
+                                __MODULE_STRING(WATCHDOG_TIMEOUT) ")");
 
-static int use_gpio = 0; /* Use the pic (for a1d revision alim7101) */
+static int use_gpio; /* Use the pic (for a1d revision alim7101) */
 module_param(use_gpio, int, 0);
-MODULE_PARM_DESC(use_gpio, "Use the gpio watchdog.  (required by old cobalt boards)");
+MODULE_PARM_DESC(use_gpio,
+                "Use the gpio watchdog (required by old cobalt boards).");
 
 static void wdt_timer_ping(unsigned long);
 static DEFINE_TIMER(timer, wdt_timer_ping, 0, 1);
@@ -77,8 +81,9 @@ static struct pci_dev *alim7101_pmu;
 
 static int nowayout = WATCHDOG_NOWAYOUT;
 module_param(nowayout, int, 0);
-MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default="
-                 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+MODULE_PARM_DESC(nowayout,
+                "Watchdog cannot be stopped once started (default="
+                                __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 
 /*
  *      Whack the dog
@@ -89,23 +94,26 @@ static void wdt_timer_ping(unsigned long data)
         /* If we got a heartbeat pulse within the WDT_US_INTERVAL
          * we agree to ping the WDT
          */
-        char    tmp;
+        char tmp;
 
-        if(time_before(jiffies, next_heartbeat))
-        {
+        if (time_before(jiffies, next_heartbeat)) {
                 /* Ping the WDT (this is actually a disarm/arm sequence) */
                 pci_read_config_byte(alim7101_pmu, 0x92, &tmp);
-                pci_write_config_byte(alim7101_pmu, ALI_7101_WDT, (tmp & ~ALI_WDT_ARM));
-                pci_write_config_byte(alim7101_pmu, ALI_7101_WDT, (tmp | ALI_WDT_ARM));
+                pci_write_config_byte(alim7101_pmu,
+                                        ALI_7101_WDT, (tmp & ~ALI_WDT_ARM));
+                pci_write_config_byte(alim7101_pmu,
+                                        ALI_7101_WDT, (tmp | ALI_WDT_ARM));
                 if (use_gpio) {
-                        pci_read_config_byte(alim7101_pmu, ALI_7101_GPIO_O, &tmp);
-                        pci_write_config_byte(alim7101_pmu, ALI_7101_GPIO_O, tmp
-                                        | 0x20);
-                        pci_write_config_byte(alim7101_pmu, ALI_7101_GPIO_O, tmp
-                                        & ~0x20);
+                        pci_read_config_byte(alim7101_pmu,
+                                        ALI_7101_GPIO_O, &tmp);
+                        pci_write_config_byte(alim7101_pmu,
+                                        ALI_7101_GPIO_O, tmp | 0x20);
+                        pci_write_config_byte(alim7101_pmu,
+                                        ALI_7101_GPIO_O, tmp & ~0x20);
                 }
         } else {
-                printk(KERN_WARNING PFX "Heartbeat lost! Will not ping the watchdog\n");
+                printk(KERN_WARNING PFX
+                        "Heartbeat lost! Will not ping the watchdog\n");
         }
         /* Re-set the timer interval */
         mod_timer(&timer, jiffies + WDT_INTERVAL);
@@ -117,21 +125,27 @@ static void wdt_timer_ping(unsigned long data)
 
 static void wdt_change(int writeval)
 {
-        char    tmp;
+        char tmp;
 
         pci_read_config_byte(alim7101_pmu, ALI_7101_WDT, &tmp);
         if (writeval == WDT_ENABLE) {
-                pci_write_config_byte(alim7101_pmu, ALI_7101_WDT, (tmp | ALI_WDT_ARM));
+                pci_write_config_byte(alim7101_pmu,
+                                        ALI_7101_WDT, (tmp | ALI_WDT_ARM));
                 if (use_gpio) {
-                        pci_read_config_byte(alim7101_pmu, ALI_7101_GPIO_O, &tmp);
-                        pci_write_config_byte(alim7101_pmu, ALI_7101_GPIO_O, tmp & ~0x20);
+                        pci_read_config_byte(alim7101_pmu,
+                                        ALI_7101_GPIO_O, &tmp);
+                        pci_write_config_byte(alim7101_pmu,
+                                        ALI_7101_GPIO_O, tmp & ~0x20);
                 }
 
         } else {
-                pci_write_config_byte(alim7101_pmu, ALI_7101_WDT, (tmp & ~ALI_WDT_ARM));
+                pci_write_config_byte(alim7101_pmu,
+                                        ALI_7101_WDT, (tmp & ~ALI_WDT_ARM));
                 if (use_gpio) {
-                        pci_read_config_byte(alim7101_pmu, ALI_7101_GPIO_O, &tmp);
-                        pci_write_config_byte(alim7101_pmu, ALI_7101_GPIO_O, tmp | 0x20);
+                        pci_read_config_byte(alim7101_pmu,
+                                        ALI_7101_GPIO_O, &tmp);
+                        pci_write_config_byte(alim7101_pmu,
+                                        ALI_7101_GPIO_O, tmp | 0x20);
                 }
         }
 }
@@ -169,10 +183,11 @@ static void wdt_keepalive(void)
  * /dev/watchdog handling
  */
 
-static ssize_t fop_write(struct file * file, const char __user * buf, size_t count, loff_t * ppos)
+static ssize_t fop_write(struct file *file, const char __user *buf,
+                                                size_t count, loff_t *ppos)
 {
         /* See if we got the magic character 'V' and reload the timer */
-        if(count) {
+        if (count) {
                 if (!nowayout) {
                         size_t ofs;
 
@@ -183,7 +198,7 @@ static ssize_t fop_write(struct file * file, const char __user * buf, size_t cou
                         /* now scan */
                         for (ofs = 0; ofs != count; ofs++) {
                                 char c;
-                                if (get_user(c, buf+ofs))
+                                if (get_user(c, buf + ofs))
                                         return -EFAULT;
                                 if (c == 'V')
                                         wdt_expect_close = 42;
@@ -195,119 +210,116 @@ static ssize_t fop_write(struct file * file, const char __user * buf, size_t cou
         return count;
 }
 
-static int fop_open(struct inode * inode, struct file * file)
+static int fop_open(struct inode *inode, struct file *file)
 {
         /* Just in case we're already talking to someone... */
-        if(test_and_set_bit(0, &wdt_is_open))
+        if (test_and_set_bit(0, &wdt_is_open))
                 return -EBUSY;
         /* Good, fire up the show */
         wdt_startup();
         return nonseekable_open(inode, file);
 }
 
-static int fop_close(struct inode * inode, struct file * file)
+static int fop_close(struct inode *inode, struct file *file)
 {
-        if(wdt_expect_close == 42)
+        if (wdt_expect_close == 42)
                 wdt_turnoff();
         else {
                 /* wim: shouldn't there be a: del_timer(&timer); */
-                printk(KERN_CRIT PFX "device file closed unexpectedly. Will not stop the WDT!\n");
+                printk(KERN_CRIT PFX
+                  "device file closed unexpectedly. Will not stop the WDT!\n");
         }
         clear_bit(0, &wdt_is_open);
         wdt_expect_close = 0;
         return 0;
 }
 
-static int fop_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
+static long fop_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
-        static struct watchdog_info ident =
-        {
-                .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE,
+        static struct watchdog_info ident = {
+                .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT
+                                                        | WDIOF_MAGICCLOSE,
                 .firmware_version = 1,
                 .identity = "ALiM7101",
         };
 
-        switch(cmd)
+        switch (cmd) {
+        case WDIOC_GETSUPPORT:
+                return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;
+        case WDIOC_GETSTATUS:
+        case WDIOC_GETBOOTSTATUS:
+                return put_user(0, p);
+        case WDIOC_SETOPTIONS:
         {
-                case WDIOC_GETSUPPORT:
-                        return copy_to_user(argp, &ident, sizeof(ident))?-EFAULT:0;
-                case WDIOC_GETSTATUS:
-                case WDIOC_GETBOOTSTATUS:
-                        return put_user(0, p);
-                case WDIOC_KEEPALIVE:
-                        wdt_keepalive();
-                        return 0;
-                case WDIOC_SETOPTIONS:
-                {
-                        int new_options, retval = -EINVAL;
-
-                        if(get_user(new_options, p))
-                                return -EFAULT;
-
-                        if(new_options & WDIOS_DISABLECARD) {
-                                wdt_turnoff();
-                                retval = 0;
-                        }
+                int new_options, retval = -EINVAL;
 
-                        if(new_options & WDIOS_ENABLECARD) {
-                                wdt_startup();
-                                retval = 0;
-                        }
-
-                        return retval;
+                if (get_user(new_options, p))
+                        return -EFAULT;
+                if (new_options & WDIOS_DISABLECARD) {
+                        wdt_turnoff();
+                        retval = 0;
                 }
-                case WDIOC_SETTIMEOUT:
-                {
-                        int new_timeout;
-
-                        if(get_user(new_timeout, p))
-                                return -EFAULT;
-
-                        if(new_timeout < 1 || new_timeout > 3600) /* arbitrary upper limit */
-                                return -EINVAL;
-
-                        timeout = new_timeout;
-                        wdt_keepalive();
-                        /* Fall through */
+                if (new_options & WDIOS_ENABLECARD) {
+                        wdt_startup();
+                        retval = 0;
                 }
-                case WDIOC_GETTIMEOUT:
-                        return put_user(timeout, p);
-                default:
-                        return -ENOTTY;
+                return retval;
+        }
+        case WDIOC_KEEPALIVE:
+                wdt_keepalive();
+                return 0;
+        case WDIOC_SETTIMEOUT:
+        {
+                int new_timeout;
+
+                if (get_user(new_timeout, p))
+                        return -EFAULT;
+                /* arbitrary upper limit */
+                if (new_timeout < 1 || new_timeout > 3600)
+                        return -EINVAL;
+                timeout = new_timeout;
+                wdt_keepalive();
+                /* Fall through */
+        }
+        case WDIOC_GETTIMEOUT:
+                return put_user(timeout, p);
+        default:
+                return -ENOTTY;
         }
 }
 
 static const struct file_operations wdt_fops = {
-        .owner=         THIS_MODULE,
-        .llseek=        no_llseek,
-        .write=         fop_write,
-        .open=          fop_open,
-        .release=       fop_close,
-        .ioctl=         fop_ioctl,
+        .owner          =       THIS_MODULE,
+        .llseek         =       no_llseek,
+        .write          =       fop_write,
+        .open           =       fop_open,
+        .release        =       fop_close,
+        .unlocked_ioctl =       fop_ioctl,
 };
 
 static struct miscdevice wdt_miscdev = {
-        .minor=WATCHDOG_MINOR,
-        .name="watchdog",
-        .fops=&wdt_fops,
+        .minor  =       WATCHDOG_MINOR,
+        .name   =       "watchdog",
+        .fops   =       &wdt_fops,
 };
 
 /*
  *      Notifier for system down
  */
 
-static int wdt_notify_sys(struct notifier_block *this, unsigned long code, void *unused)
+static int wdt_notify_sys(struct notifier_block *this,
+                                        unsigned long code, void *unused)
 {
-        if (code==SYS_DOWN || code==SYS_HALT)
+        if (code == SYS_DOWN || code == SYS_HALT)
                 wdt_turnoff();
 
-        if (code==SYS_RESTART) {
+        if (code == SYS_RESTART) {
                 /*
-                 * Cobalt devices have no way of rebooting themselves other than
-                 * getting the watchdog to pull reset, so we restart the watchdog on
-                 * reboot with no heartbeat
+                 * Cobalt devices have no way of rebooting themselves other
+                 * than getting the watchdog to pull reset, so we restart the
+                 * watchdog on reboot with no heartbeat
                  */
                 wdt_change(WDT_ENABLE);
                 printk(KERN_INFO PFX "Watchdog timer is now enabled with no heartbeat - should reboot in ~1 second.\n");
@@ -320,8 +332,7 @@ static int wdt_notify_sys(struct notifier_block *this, unsigned long code, void
  *      turn the timebomb registers off.
  */
 
-static struct notifier_block wdt_notifier=
-{
+static struct notifier_block wdt_notifier = {
         .notifier_call = wdt_notify_sys,
 };
 
@@ -354,7 +365,8 @@ static int __init alim7101_wdt_init(void)
         ali1543_south = pci_get_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533,
                 NULL);
         if (!ali1543_south) {
-                printk(KERN_INFO PFX "ALi 1543 South-Bridge not present - WDT not set\n");
+                printk(KERN_INFO PFX
+                        "ALi 1543 South-Bridge not present - WDT not set\n");
                 goto err_out;
         }
         pci_read_config_byte(ali1543_south, 0x5e, &tmp);
@@ -363,24 +375,25 @@ static int __init alim7101_wdt_init(void)
                 if (!use_gpio) {
                         printk(KERN_INFO PFX "Detected old alim7101 revision 'a1d'.  If this is a cobalt board, set the 'use_gpio' module parameter.\n");
                         goto err_out;
-                } 
+                }
                 nowayout = 1;
         } else if ((tmp & 0x1e) != 0x12 && (tmp & 0x1e) != 0x00) {
                 printk(KERN_INFO PFX "ALi 1543 South-Bridge does not have the correct revision number (???1001?) - WDT not set\n");
                 goto err_out;
         }
 
-        if(timeout < 1 || timeout > 3600) /* arbitrary upper limit */
-        {
+        if (timeout < 1 || timeout > 3600) {
+                /* arbitrary upper limit */
                 timeout = WATCHDOG_TIMEOUT;
-                printk(KERN_INFO PFX "timeout value must be 1<=x<=3600, using %d\n",
-                        timeout);
+                printk(KERN_INFO PFX
+                        "timeout value must be 1 <= x <= 3600, using %d\n",
+                                                                timeout);
         }
 
         rc = register_reboot_notifier(&wdt_notifier);
         if (rc) {
-                printk(KERN_ERR PFX "cannot register reboot notifier (err=%d)\n",
-                        rc);
+                printk(KERN_ERR PFX
+                        "cannot register reboot notifier (err=%d)\n", rc);
                 goto err_out;
         }
 
@@ -391,9 +404,8 @@ static int __init alim7101_wdt_init(void)
                 goto err_out_reboot;
         }
 
-        if (nowayout) {
+        if (nowayout)
                 __module_get(THIS_MODULE);
-        }
 
         printk(KERN_INFO PFX "WDT driver for ALi M7101 initialised. timeout=%d sec (nowayout=%d)\n",
                 timeout, nowayout);
diff --git a/drivers/watchdog/ar7_wdt.c b/drivers/watchdog/ar7_wdt.c
index ef7b0d67095e..55dcbfe2bb72 100644
--- a/drivers/watchdog/ar7_wdt.c
+++ b/drivers/watchdog/ar7_wdt.c
@@ -213,7 +213,7 @@ static int ar7_wdt_notify_sys(struct notifier_block *this,
 }
 
 static struct notifier_block ar7_wdt_notifier = {
-        .notifier_call = ar7_wdt_notify_sys
+        .notifier_call = ar7_wdt_notify_sys,
 };
 
 static ssize_t ar7_wdt_write(struct file *file, const char *data,
@@ -230,7 +230,7 @@ static ssize_t ar7_wdt_write(struct file *file, const char *data,
                 expect_close = 0;
                 for (i = 0; i < len; ++i) {
                         char c;
-                        if (get_user(c, data+i))
+                        if (get_user(c, data + i))
                                 return -EFAULT;
                         if (c == 'V')
                                 expect_close = 1;
@@ -251,8 +251,6 @@ static long ar7_wdt_ioctl(struct file *file,
         int new_margin;
 
         switch (cmd) {
-        default:
-                return -ENOTTY;
         case WDIOC_GETSUPPORT:
                 if (copy_to_user((struct watchdog_info *)arg, &ident,
                                 sizeof(ident)))
@@ -281,6 +279,8 @@ static long ar7_wdt_ioctl(struct file *file,
                 if (put_user(margin, (int *)arg))
                         return -EFAULT;
                 return 0;
+        default:
+                return -ENOTTY;
         }
 }
 
diff --git a/drivers/watchdog/at32ap700x_wdt.c b/drivers/watchdog/at32ap700x_wdt.c
index ae0fca5e8749..e8ae638e5804 100644
--- a/drivers/watchdog/at32ap700x_wdt.c
+++ b/drivers/watchdog/at32ap700x_wdt.c
@@ -212,8 +212,8 @@ static struct watchdog_info at32_wdt_info = {
 /*
  * Handle commands from user-space.
  */
-static int at32_wdt_ioctl(struct inode *inode, struct file *file,
-                unsigned int cmd, unsigned long arg)
+static long at32_wdt_ioctl(struct file *file,
+                                unsigned int cmd, unsigned long arg)
 {
         int ret = -ENOTTY;
         int time;
@@ -221,27 +221,10 @@ static int at32_wdt_ioctl(struct inode *inode, struct file *file,
         int __user *p = argp;
 
         switch (cmd) {
-        case WDIOC_KEEPALIVE:
-                at32_wdt_pat();
-                ret = 0;
-                break;
         case WDIOC_GETSUPPORT:
                 ret = copy_to_user(argp, &at32_wdt_info,
                                 sizeof(at32_wdt_info)) ? -EFAULT : 0;
                 break;
-        case WDIOC_SETTIMEOUT:
-                ret = get_user(time, p);
-                if (ret)
-                        break;
-                ret = at32_wdt_settimeout(time);
-                if (ret)
-                        break;
-                /* Enable new time value */
-                at32_wdt_start();
-                /* fall through */
-        case WDIOC_GETTIMEOUT:
-                ret = put_user(wdt->timeout, p);
-                break;
         case WDIOC_GETSTATUS:
                 ret = put_user(0, p);
                 break;
@@ -258,6 +241,23 @@ static int at32_wdt_ioctl(struct inode *inode, struct file *file,
                         at32_wdt_start();
                 ret = 0;
                 break;
+        case WDIOC_KEEPALIVE:
+                at32_wdt_pat();
+                ret = 0;
+                break;
+        case WDIOC_SETTIMEOUT:
+                ret = get_user(time, p);
+                if (ret)
+                        break;
+                ret = at32_wdt_settimeout(time);
+                if (ret)
+                        break;
+                /* Enable new time value */
+                at32_wdt_start();
+                /* fall through */
+        case WDIOC_GETTIMEOUT:
+                ret = put_user(wdt->timeout, p);
+                break;
         }
 
         return ret;
@@ -283,7 +283,7 @@ static ssize_t at32_wdt_write(struct file *file, const char __user *data,
                          */
                         for (i = 0; i != len; i++) {
                                 char c;
-                                if (get_user(c, data+i))
+                                if (get_user(c, data + i))
                                         return -EFAULT;
                                 if (c == 'V')
                                         expect_release = 42;
@@ -298,7 +298,7 @@ static ssize_t at32_wdt_write(struct file *file, const char __user *data,
 static const struct file_operations at32_wdt_fops = {
         .owner          = THIS_MODULE,
         .llseek         = no_llseek,
-        .ioctl          = at32_wdt_ioctl,
+        .unlocked_ioctl = at32_wdt_ioctl,
         .open           = at32_wdt_open,
         .release        = at32_wdt_close,
         .write          = at32_wdt_write,
@@ -391,7 +391,6 @@ static int __exit at32_wdt_remove(struct platform_device *pdev)
                 wdt = NULL;
                 platform_set_drvdata(pdev, NULL);
         }
-
         return 0;
 }
 
diff --git a/drivers/watchdog/at91rm9200_wdt.c b/drivers/watchdog/at91rm9200_wdt.c
index 9ff9a9565320..2313f44144f8 100644
--- a/drivers/watchdog/at91rm9200_wdt.c
+++ b/drivers/watchdog/at91rm9200_wdt.c
@@ -20,7 +20,7 @@
 #include <linux/platform_device.h>
 #include <linux/types.h>
 #include <linux/watchdog.h>
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 #include <asm/arch/at91_st.h>
 
 
@@ -31,11 +31,14 @@ static int wdt_time = WDT_DEFAULT_TIME;
 static int nowayout = WATCHDOG_NOWAYOUT;
 
 module_param(wdt_time, int, 0);
-MODULE_PARM_DESC(wdt_time, "Watchdog time in seconds. (default="__MODULE_STRING(WDT_DEFAULT_TIME) ")");
+MODULE_PARM_DESC(wdt_time, "Watchdog time in seconds. (default="
+                                __MODULE_STRING(WDT_DEFAULT_TIME) ")");
 
 #ifdef CONFIG_WATCHDOG_NOWAYOUT
 module_param(nowayout, int, 0);
-MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+MODULE_PARM_DESC(nowayout,
+                "Watchdog cannot be stopped once started (default="
+                                __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 #endif
 
 
@@ -46,7 +49,7 @@ static unsigned long at91wdt_busy;
 /*
  * Disable the watchdog.
  */
-static void inline at91_wdt_stop(void)
+static inline void at91_wdt_stop(void)
 {
         at91_sys_write(AT91_ST_WDMR, AT91_ST_EXTEN);
 }
@@ -54,16 +57,17 @@ static void inline at91_wdt_stop(void)
 /*
  * Enable and reset the watchdog.
  */
-static void inline at91_wdt_start(void)
+static inline void at91_wdt_start(void)
 {
-        at91_sys_write(AT91_ST_WDMR, AT91_ST_EXTEN | AT91_ST_RSTEN | (((65536 * wdt_time) >> 8) & AT91_ST_WDV));
+        at91_sys_write(AT91_ST_WDMR, AT91_ST_EXTEN | AT91_ST_RSTEN |
+                                (((65536 * wdt_time) >> 8) & AT91_ST_WDV));
         at91_sys_write(AT91_ST_CR, AT91_ST_WDRST);
 }
 
 /*
  * Reload the watchdog timer.  (ie, pat the watchdog)
  */
-static void inline at91_wdt_reload(void)
+static inline void at91_wdt_reload(void)
 {
         at91_sys_write(AT91_ST_CR, AT91_ST_WDRST);
 }
@@ -89,8 +93,9 @@ static int at91_wdt_open(struct inode *inode, struct file *file)
  */
 static int at91_wdt_close(struct inode *inode, struct file *file)
 {
+        /* Disable the watchdog when file is closed */
         if (!nowayout)
-                at91_wdt_stop();        /* Disable the watchdog when file is closed */
+                at91_wdt_stop();
 
         clear_bit(0, &at91wdt_busy);
         return 0;
@@ -110,7 +115,8 @@ static int at91_wdt_settimeout(int new_time)
         if ((new_time <= 0) || (new_time > WDT_MAX_TIME))
                 return -EINVAL;
 
-        /* Set new watchdog time. It will be used when at91_wdt_start() is called. */
+        /* Set new watchdog time. It will be used when
+           at91_wdt_start() is called. */
         wdt_time = new_time;
         return 0;
 }
@@ -123,60 +129,52 @@ static struct watchdog_info at91_wdt_info = {
 /*
  * Handle commands from user-space.
  */
-static int at91_wdt_ioctl(struct inode *inode, struct file *file,
-                unsigned int cmd, unsigned long arg)
+static long at91_wdt_ioct(struct file *file,
+                                        unsigned int cmd, unsigned long arg)
 {
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
         int new_value;
 
-        switch(cmd) {
-                case WDIOC_KEEPALIVE:
-                        at91_wdt_reload();      /* pat the watchdog */
-                        return 0;
-
-                case WDIOC_GETSUPPORT:
-                        return copy_to_user(argp, &at91_wdt_info, sizeof(at91_wdt_info)) ? -EFAULT : 0;
-
-                case WDIOC_SETTIMEOUT:
-                        if (get_user(new_value, p))
-                                return -EFAULT;
-
-                        if (at91_wdt_settimeout(new_value))
-                                return -EINVAL;
-
-                        /* Enable new time value */
+        switch (cmd) {
+        case WDIOC_GETSUPPORT:
+                return copy_to_user(argp, &at91_wdt_info,
+                                sizeof(at91_wdt_info)) ? -EFAULT : 0;
+        case WDIOC_GETSTATUS:
+        case WDIOC_GETBOOTSTATUS:
+                return put_user(0, p);
+        case WDIOC_SETOPTIONS:
+                if (get_user(new_value, p))
+                        return -EFAULT;
+                if (new_value & WDIOS_DISABLECARD)
+                        at91_wdt_stop();
+                if (new_value & WDIOS_ENABLECARD)
                         at91_wdt_start();
-
-                        /* Return current value */
-                        return put_user(wdt_time, p);
-
-                case WDIOC_GETTIMEOUT:
-                        return put_user(wdt_time, p);
-
-                case WDIOC_GETSTATUS:
-                case WDIOC_GETBOOTSTATUS:
-                        return put_user(0, p);
-
-                case WDIOC_SETOPTIONS:
-                        if (get_user(new_value, p))
-                                return -EFAULT;
-
-                        if (new_value & WDIOS_DISABLECARD)
-                                at91_wdt_stop();
-                        if (new_value & WDIOS_ENABLECARD)
-                                at91_wdt_start();
-                        return 0;
-
-                default:
-                        return -ENOTTY;
+                return 0;
+        case WDIOC_KEEPALIVE:
+                at91_wdt_reload();      /* pat the watchdog */
+                return 0;
+        case WDIOC_SETTIMEOUT:
+                if (get_user(new_value, p))
+                        return -EFAULT;
+                if (at91_wdt_settimeout(new_value))
+                        return -EINVAL;
+                /* Enable new time value */
+                at91_wdt_start();
+                /* Return current value */
+                return put_user(wdt_time, p);
+        case WDIOC_GETTIMEOUT:
+                return put_user(wdt_time, p);
+        default:
+                return -ENOTTY;
         }
 }
 
 /*
  * Pat the watchdog whenever device is written to.
  */
-static ssize_t at91_wdt_write(struct file *file, const char *data, size_t len, loff_t *ppos)
+static ssize_t at91_wdt_write(struct file *file, const char *data,
+                                                size_t len, loff_t *ppos)
 {
         at91_wdt_reload();              /* pat the watchdog */
         return len;
@@ -187,7 +185,7 @@ static ssize_t at91_wdt_write(struct file *file, const char *data, size_t len, l
 static const struct file_operations at91wdt_fops = {
         .owner          = THIS_MODULE,
         .llseek         = no_llseek,
-        .ioctl          = at91_wdt_ioctl,
+        .unlocked_ioctl = at91_wdt_ioctl,
         .open           = at91_wdt_open,
         .release        = at91_wdt_close,
         .write          = at91_wdt_write,
@@ -211,7 +209,8 @@ static int __init at91wdt_probe(struct platform_device *pdev)
         if (res)
                 return res;
 
-        printk("AT91 Watchdog Timer enabled (%d seconds%s)\n", wdt_time, nowayout ? ", nowayout" : "");
+        printk(KERN_INFO "AT91 Watchdog Timer enabled (%d seconds%s)\n",
+                                wdt_time, nowayout ? ", nowayout" : "");
         return 0;
 }
 
@@ -265,7 +264,8 @@ static struct platform_driver at91wdt_driver = {
 
 static int __init at91_wdt_init(void)
 {
-        /* Check that the heartbeat value is within range; if not reset to the default */
+        /* Check that the heartbeat value is within range;
+           if not reset to the default */
         if (at91_wdt_settimeout(wdt_time)) {
                 at91_wdt_settimeout(WDT_DEFAULT_TIME);
                 pr_info("at91_wdt: wdt_time value must be 1 <= wdt_time <= 256, using %d\n", wdt_time);
diff --git a/drivers/watchdog/bfin_wdt.c b/drivers/watchdog/bfin_wdt.c
index 03b3e3d91e7c..31b42253054e 100644
--- a/drivers/watchdog/bfin_wdt.c
+++ b/drivers/watchdog/bfin_wdt.c
@@ -24,8 +24,8 @@
 #include <linux/reboot.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
+#include <linux/uaccess.h>
 #include <asm/blackfin.h>
-#include <asm/uaccess.h>
 
 #define stamp(fmt, args...) pr_debug("%s:%i: " fmt "\n", __func__, __LINE__, ## args)
 #define stampit() stamp("here i am")
@@ -148,7 +148,8 @@ static int bfin_wdt_set_timeout(unsigned long t)
                 int run = bfin_wdt_running();
                 bfin_wdt_stop();
                 bfin_write_WDOG_CNT(cnt);
-                if (run) bfin_wdt_start();
+                if (run)
+                        bfin_wdt_start();
         }
         spin_unlock_irqrestore(&bfin_wdt_spinlock, flags);
 
@@ -191,16 +192,15 @@ static int bfin_wdt_release(struct inode *inode, struct file *file)
 {
         stampit();
 
-        if (expect_close == 42) {
+        if (expect_close == 42)
                 bfin_wdt_stop();
-        } else {
-                printk(KERN_CRIT PFX "Unexpected close, not stopping watchdog!\n");
+        else {
+                printk(KERN_CRIT PFX
+                        "Unexpected close, not stopping watchdog!\n");
                 bfin_wdt_keepalive();
         }
-
         expect_close = 0;
         clear_bit(0, &open_check);
-
         return 0;
 }
 
@@ -214,7 +214,7 @@ static int bfin_wdt_release(struct inode *inode, struct file *file)
  *      Pings the watchdog on write.
  */
 static ssize_t bfin_wdt_write(struct file *file, const char __user *data,
-                              size_t len, loff_t *ppos)
+                                                size_t len, loff_t *ppos)
 {
         stampit();
 
@@ -241,7 +241,6 @@ static ssize_t bfin_wdt_write(struct file *file, const char __user *data,
 
 /**
  *      bfin_wdt_ioctl - Query Device
- *      @inode: inode of device
  *      @file: file handle of device
  *      @cmd: watchdog command
  *      @arg: argument
@@ -249,8 +248,8 @@ static ssize_t bfin_wdt_write(struct file *file, const char __user *data,
  *      Query basic information from the device or ping it, as outlined by the
  *      watchdog API.
  */
-static int bfin_wdt_ioctl(struct inode *inode, struct file *file,
-                          unsigned int cmd, unsigned long arg)
+static long bfin_wdt_ioctl(struct file *file,
+                                unsigned int cmd, unsigned long arg)
 {
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
@@ -258,59 +257,49 @@ static int bfin_wdt_ioctl(struct inode *inode, struct file *file,
         stampit();
 
         switch (cmd) {
-                default:
-                        return -ENOTTY;
-
-                case WDIOC_GETSUPPORT:
-                        if (copy_to_user(argp, &bfin_wdt_info, sizeof(bfin_wdt_info)))
-                                return -EFAULT;
-                        else
-                                return 0;
-
-                case WDIOC_GETSTATUS:
-                case WDIOC_GETBOOTSTATUS:
-                        return put_user(!!(_bfin_swrst & SWRST_RESET_WDOG), p);
-
-                case WDIOC_KEEPALIVE:
-                        bfin_wdt_keepalive();
+        case WDIOC_GETSUPPORT:
+                if (copy_to_user(argp, &bfin_wdt_info, sizeof(bfin_wdt_info)))
+                        return -EFAULT;
+                else
                         return 0;
-
-                case WDIOC_SETTIMEOUT: {
-                        int new_timeout;
-
-                        if (get_user(new_timeout, p))
-                                return -EFAULT;
-
-                        if (bfin_wdt_set_timeout(new_timeout))
-                                return -EINVAL;
+        case WDIOC_GETSTATUS:
+        case WDIOC_GETBOOTSTATUS:
+                return put_user(!!(_bfin_swrst & SWRST_RESET_WDOG), p);
+        case WDIOC_SETOPTIONS: {
+                unsigned long flags;
+                int options, ret = -EINVAL;
+
+                if (get_user(options, p))
+                        return -EFAULT;
+
+                spin_lock_irqsave(&bfin_wdt_spinlock, flags);
+                if (options & WDIOS_DISABLECARD) {
+                        bfin_wdt_stop();
+                        ret = 0;
                 }
-                        /* Fall */
-                case WDIOC_GETTIMEOUT:
-                        return put_user(timeout, p);
-
-                case WDIOC_SETOPTIONS: {
-                        unsigned long flags;
-                        int options, ret = -EINVAL;
-
-                        if (get_user(options, p))
-                                return -EFAULT;
-
-                        spin_lock_irqsave(&bfin_wdt_spinlock, flags);
-
-                        if (options & WDIOS_DISABLECARD) {
-                                bfin_wdt_stop();
-                                ret = 0;
-                        }
-
-                        if (options & WDIOS_ENABLECARD) {
-                                bfin_wdt_start();
-                                ret = 0;
-                        }
-
-                        spin_unlock_irqrestore(&bfin_wdt_spinlock, flags);
-
-                        return ret;
+                if (options & WDIOS_ENABLECARD) {
+                        bfin_wdt_start();
+                        ret = 0;
                 }
+                spin_unlock_irqrestore(&bfin_wdt_spinlock, flags);
+                return ret;
+        }
+        case WDIOC_KEEPALIVE:
+                bfin_wdt_keepalive();
+                return 0;
+        case WDIOC_SETTIMEOUT: {
+                int new_timeout;
+
+                if (get_user(new_timeout, p))
+                        return -EFAULT;
+                if (bfin_wdt_set_timeout(new_timeout))
+                        return -EINVAL;
+        }
+        /* Fall */
+        case WDIOC_GETTIMEOUT:
+                return put_user(timeout, p);
+        default:
+                return -ENOTTY;
         }
 }
 
@@ -323,8 +312,8 @@ static int bfin_wdt_ioctl(struct inode *inode, struct file *file,
  *      Handles specific events, such as turning off the watchdog during a
  *      shutdown event.
  */
-static int bfin_wdt_notify_sys(struct notifier_block *this, unsigned long code,
-                               void *unused)
+static int bfin_wdt_notify_sys(struct notifier_block *this,
+                                        unsigned long code, void *unused)
 {
         stampit();
 
@@ -379,12 +368,12 @@ static int bfin_wdt_resume(struct platform_device *pdev)
 #endif
 
 static const struct file_operations bfin_wdt_fops = {
-        .owner    = THIS_MODULE,
-        .llseek   = no_llseek,
-        .write    = bfin_wdt_write,
-        .ioctl    = bfin_wdt_ioctl,
-        .open     = bfin_wdt_open,
-        .release  = bfin_wdt_release,
+        .owner          = THIS_MODULE,
+        .llseek         = no_llseek,
+        .write          = bfin_wdt_write,
+        .unlocked_ioctl = bfin_wdt_ioctl,
+        .open           = bfin_wdt_open,
+        .release        = bfin_wdt_release,
 };
 
 static struct miscdevice bfin_wdt_miscdev = {
@@ -396,8 +385,8 @@ static struct miscdevice bfin_wdt_miscdev = {
 static struct watchdog_info bfin_wdt_info = {
         .identity = "Blackfin Watchdog",
         .options  = WDIOF_SETTIMEOUT |
-                    WDIOF_KEEPALIVEPING |
-                    WDIOF_MAGICCLOSE,
+                    WDIOF_KEEPALIVEPING |
+                    WDIOF_MAGICCLOSE,
 };
 
 static struct notifier_block bfin_wdt_notifier = {
@@ -416,14 +405,16 @@ static int __devinit bfin_wdt_probe(struct platform_device *pdev)
 
         ret = register_reboot_notifier(&bfin_wdt_notifier);
         if (ret) {
-                pr_devinit(KERN_ERR PFX "cannot register reboot notifier (err=%d)\n", ret);
+                pr_devinit(KERN_ERR PFX
+                        "cannot register reboot notifier (err=%d)\n", ret);
                 return ret;
         }
 
         ret = misc_register(&bfin_wdt_miscdev);
         if (ret) {
-                pr_devinit(KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",
-                       WATCHDOG_MINOR, ret);
+                pr_devinit(KERN_ERR PFX
+                        "cannot register miscdev on minor=%d (err=%d)\n",
+                                WATCHDOG_MINOR, ret);
                 unregister_reboot_notifier(&bfin_wdt_notifier);
                 return ret;
         }
@@ -516,7 +507,11 @@ MODULE_LICENSE("GPL");
 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 
 module_param(timeout, uint, 0);
-MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds. (1<=timeout<=((2^32)/SCLK), default=" __MODULE_STRING(WATCHDOG_TIMEOUT) ")");
+MODULE_PARM_DESC(timeout,
+        "Watchdog timeout in seconds. (1<=timeout<=((2^32)/SCLK), default="
+                __MODULE_STRING(WATCHDOG_TIMEOUT) ")");
 
 module_param(nowayout, int, 0);
-MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+MODULE_PARM_DESC(nowayout,
+        "Watchdog cannot be stopped once started (default="
+                __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
diff --git a/drivers/watchdog/booke_wdt.c b/drivers/watchdog/booke_wdt.c
index 770824458d45..c3b78a76f173 100644
--- a/drivers/watchdog/booke_wdt.c
+++ b/drivers/watchdog/booke_wdt.c
@@ -18,9 +18,9 @@
 #include <linux/miscdevice.h>
 #include <linux/notifier.h>
 #include <linux/watchdog.h>
+#include <linux/uaccess.h>
 
 #include <asm/reg_booke.h>
-#include <asm/uaccess.h>
 #include <asm/system.h>
 
 /* If the kernel parameter wdt=1, the watchdog will be enabled at boot.
@@ -32,7 +32,7 @@
  */
 
 #ifdef  CONFIG_FSL_BOOKE
-#define WDT_PERIOD_DEFAULT 63   /* Ex. wdt_period=28 bus=333Mhz , reset=~40sec */
+#define WDT_PERIOD_DEFAULT 63   /* Ex. wdt_period=28 bus=333Mhz,reset=~40sec */
 #else
 #define WDT_PERIOD_DEFAULT 3    /* Refer to the PPC40x and PPC4xx manuals */
 #endif                          /* for timing information */
@@ -82,16 +82,15 @@ static struct watchdog_info ident = {
         .identity = "PowerPC Book-E Watchdog",
 };
 
-static int booke_wdt_ioctl(struct inode *inode, struct file *file,
-                            unsigned int cmd, unsigned long arg)
+static long booke_wdt_ioctl(struct file *file,
+                                unsigned int cmd, unsigned long arg)
 {
         u32 tmp = 0;
         u32 __user *p = (u32 __user *)arg;
 
         switch (cmd) {
         case WDIOC_GETSUPPORT:
-                if (copy_to_user((struct watchdog_info __user *)arg, &ident,
-                                sizeof(struct watchdog_info)))
+                if (copy_to_user(arg, &ident, sizeof(struct watchdog_info)))
                         return -EFAULT;
         case WDIOC_GETSTATUS:
                 return put_user(ident.options, p);
@@ -100,16 +99,6 @@ static int booke_wdt_ioctl(struct inode *inode, struct file *file,
                 tmp = mfspr(SPRN_TSR) & TSR_WRS(3);
                 /* returns 1 if last reset was caused by the WDT */
                 return (tmp ? 1 : 0);
-        case WDIOC_KEEPALIVE:
-                booke_wdt_ping();
-                return 0;
-        case WDIOC_SETTIMEOUT:
-                if (get_user(booke_wdt_period, p))
-                        return -EFAULT;
-                mtspr(SPRN_TCR, (mfspr(SPRN_TCR)&~WDTP(0))|WDTP(booke_wdt_period));
-                return 0;
-        case WDIOC_GETTIMEOUT:
-                return put_user(booke_wdt_period, p);
         case WDIOC_SETOPTIONS:
                 if (get_user(tmp, p))
                         return -EINVAL;
@@ -119,6 +108,17 @@ static int booke_wdt_ioctl(struct inode *inode, struct file *file,
                 } else
                         return -EINVAL;
                 return 0;
+        case WDIOC_KEEPALIVE:
+                booke_wdt_ping();
+                return 0;
+        case WDIOC_SETTIMEOUT:
+                if (get_user(booke_wdt_period, p))
+                        return -EFAULT;
+                mtspr(SPRN_TCR, (mfspr(SPRN_TCR) & ~WDTP(0)) |
+                                                WDTP(booke_wdt_period));
+                return 0;
+        case WDIOC_GETTIMEOUT:
+                return put_user(booke_wdt_period, p);
         default:
                 return -ENOTTY;
         }
@@ -132,8 +132,9 @@ static int booke_wdt_open(struct inode *inode, struct file *file)
         if (booke_wdt_enabled == 0) {
                 booke_wdt_enabled = 1;
                 on_each_cpu(__booke_wdt_enable, NULL, 0);
-                printk(KERN_INFO "PowerPC Book-E Watchdog Timer Enabled "
-                                "(wdt_period=%d)\n", booke_wdt_period);
+                printk(KERN_INFO
+                      "PowerPC Book-E Watchdog Timer Enabled (wdt_period=%d)\n",
+                                booke_wdt_period);
         }
         spin_unlock(&booke_wdt_lock);
 
@@ -144,7 +145,7 @@ static const struct file_operations booke_wdt_fops = {
         .owner = THIS_MODULE,
         .llseek = no_llseek,
         .write = booke_wdt_write,
-        .ioctl = booke_wdt_ioctl,
+        .unlocked_ioctl = booke_wdt_ioctl,
         .open = booke_wdt_open,
 };
 
@@ -175,8 +176,9 @@ static int __init booke_wdt_init(void)
 
         spin_lock(&booke_wdt_lock);
         if (booke_wdt_enabled == 1) {
-                printk(KERN_INFO "PowerPC Book-E Watchdog Timer Enabled "
-                                "(wdt_period=%d)\n", booke_wdt_period);
+                printk(KERN_INFO
+                      "PowerPC Book-E Watchdog Timer Enabled (wdt_period=%d)\n",
+                                booke_wdt_period);
                 on_each_cpu(__booke_wdt_enable, NULL, 0);
         }
         spin_unlock(&booke_wdt_lock);
diff --git a/drivers/watchdog/cpu5wdt.c b/drivers/watchdog/cpu5wdt.c
index df72f90123df..71f6d7eec9a8 100644
--- a/drivers/watchdog/cpu5wdt.c
+++ b/drivers/watchdog/cpu5wdt.c
@@ -30,16 +30,16 @@
 #include <linux/timer.h>
 #include <linux/completion.h>
 #include <linux/jiffies.h>
-#include <asm/io.h>
-#include <asm/uaccess.h>
-
+#include <linux/io.h>
+#include <linux/uaccess.h>
 #include <linux/watchdog.h>
 
 /* adjustable parameters */
 
-static int verbose = 0;
+static int verbose;
 static int port = 0x91;
 static int ticks = 10000;
+static spinlock_t cpu5wdt_lock;
 
 #define PFX                     "cpu5wdt: "
 
@@ -70,12 +70,13 @@ static struct {
 
 static void cpu5wdt_trigger(unsigned long unused)
 {
-        if ( verbose > 2 )
+        if (verbose > 2)
                 printk(KERN_DEBUG PFX "trigger at %i ticks\n", ticks);
 
-        if( cpu5wdt_device.running )
+        if (cpu5wdt_device.running)
                 ticks--;
 
+        spin_lock(&cpu5wdt_lock);
         /* keep watchdog alive */
         outb(1, port + CPU5WDT_TRIGGER_REG);
 
@@ -86,6 +87,7 @@ static void cpu5wdt_trigger(unsigned long unused)
                 /* ticks doesn't matter anyway */
                 complete(&cpu5wdt_device.stop);
         }
+        spin_unlock(&cpu5wdt_lock);
 
 }
 
@@ -93,14 +95,17 @@ static void cpu5wdt_reset(void)
 {
         ticks = cpu5wdt_device.default_ticks;
 
-        if ( verbose )
+        if (verbose)
                 printk(KERN_DEBUG PFX "reset (%i ticks)\n", (int) ticks);
 
 }
 
 static void cpu5wdt_start(void)
 {
-        if ( !cpu5wdt_device.queue ) {
+        unsigned long flags;
+
+        spin_lock_irqsave(&cpu5wdt_lock, flags);
+        if (!cpu5wdt_device.queue) {
                 cpu5wdt_device.queue = 1;
                 outb(0, port + CPU5WDT_TIME_A_REG);
                 outb(0, port + CPU5WDT_TIME_B_REG);
@@ -111,18 +116,20 @@ static void cpu5wdt_start(void)
         }
         /* if process dies, counter is not decremented */
         cpu5wdt_device.running++;
+        spin_unlock_irqrestore(&cpu5wdt_lock, flags);
 }
 
 static int cpu5wdt_stop(void)
 {
-        if ( cpu5wdt_device.running )
-                cpu5wdt_device.running = 0;
+        unsigned long flags;
 
+        spin_lock_irqsave(&cpu5wdt_lock, flags);
+        if (cpu5wdt_device.running)
+                cpu5wdt_device.running = 0;
         ticks = cpu5wdt_device.default_ticks;
-
-        if ( verbose )
+        spin_unlock_irqrestore(&cpu5wdt_lock, flags);
+        if (verbose)
                 printk(KERN_CRIT PFX "stop not possible\n");
-
         return -EIO;
 }
 
@@ -130,9 +137,8 @@ static int cpu5wdt_stop(void)
 
 static int cpu5wdt_open(struct inode *inode, struct file *file)
 {
-        if ( test_and_set_bit(0, &cpu5wdt_device.inuse) )
+        if (test_and_set_bit(0, &cpu5wdt_device.inuse))
                 return -EBUSY;
-
         return nonseekable_open(inode, file);
 }
 
@@ -142,67 +148,58 @@ static int cpu5wdt_release(struct inode *inode, struct file *file)
         return 0;
 }
 
-static int cpu5wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
+static long cpu5wdt_ioctl(struct file *file, unsigned int cmd,
+                                                unsigned long arg)
 {
         void __user *argp = (void __user *)arg;
+        int __user *p = argp;
         unsigned int value;
-        static struct watchdog_info ident =
-        {
+        static struct watchdog_info ident = {
                 .options = WDIOF_CARDRESET,
                 .identity = "CPU5 WDT",
         };
 
-        switch(cmd) {
-                case WDIOC_KEEPALIVE:
-                        cpu5wdt_reset();
-                        break;
-                case WDIOC_GETSTATUS:
-                        value = inb(port + CPU5WDT_STATUS_REG);
-                        value = (value >> 2) & 1;
-                        if ( copy_to_user(argp, &value, sizeof(int)) )
-                                return -EFAULT;
-                        break;
-                case WDIOC_GETBOOTSTATUS:
-                        if ( copy_to_user(argp, &value, sizeof(int)) )
-                                return -EFAULT;
-                        break;
-                case WDIOC_GETSUPPORT:
-                        if ( copy_to_user(argp, &ident, sizeof(ident)) )
-                                return -EFAULT;
-                        break;
-                case WDIOC_SETOPTIONS:
-                        if ( copy_from_user(&value, argp, sizeof(int)) )
-                                return -EFAULT;
-                        switch(value) {
-                                case WDIOS_ENABLECARD:
-                                        cpu5wdt_start();
-                                        break;
-                                case WDIOS_DISABLECARD:
-                                        return cpu5wdt_stop();
-                                default:
-                                        return -EINVAL;
-                        }
-                        break;
-                default:
-                        return -ENOTTY;
+        switch (cmd) {
+        case WDIOC_GETSUPPORT:
+                if (copy_to_user(argp, &ident, sizeof(ident)))
+                        return -EFAULT;
+                break;
+        case WDIOC_GETSTATUS:
+                value = inb(port + CPU5WDT_STATUS_REG);
+                value = (value >> 2) & 1;
+                return put_user(value, p);
+        case WDIOC_GETBOOTSTATUS:
+                return put_user(0, p);
+        case WDIOC_SETOPTIONS:
+                if (get_user(value, p))
+                        return -EFAULT;
+                if (value & WDIOS_ENABLECARD)
+                        cpu5wdt_start();
+                if (value & WDIOS_DISABLECARD)
+                        cpu5wdt_stop();
+                break;
+        case WDIOC_KEEPALIVE:
+                cpu5wdt_reset();
+                break;
+        default:
+                return -ENOTTY;
         }
         return 0;
 }
 
-static ssize_t cpu5wdt_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
+static ssize_t cpu5wdt_write(struct file *file, const char __user *buf,
+                                                size_t count, loff_t *ppos)
 {
-        if ( !count )
+        if (!count)
                 return -EIO;
-
         cpu5wdt_reset();
-
         return count;
 }
 
 static const struct file_operations cpu5wdt_fops = {
         .owner          = THIS_MODULE,
         .llseek         = no_llseek,
-        .ioctl          = cpu5wdt_ioctl,
+        .unlocked_ioctl = cpu5wdt_ioctl,
         .open           = cpu5wdt_open,
         .write          = cpu5wdt_write,
         .release        = cpu5wdt_release,
@@ -221,37 +218,36 @@ static int __devinit cpu5wdt_init(void)
         unsigned int val;
         int err;
 
-        if ( verbose )
-                printk(KERN_DEBUG PFX "port=0x%x, verbose=%i\n", port, verbose);
+        if (verbose)
+                printk(KERN_DEBUG PFX
+                                "port=0x%x, verbose=%i\n", port, verbose);
 
-        if ( !request_region(port, CPU5WDT_EXTENT, PFX) ) {
+        init_completion(&cpu5wdt_device.stop);
+        spin_lock_init(&cpu5wdt_lock);
+        cpu5wdt_device.queue = 0;
+        setup_timer(&cpu5wdt_device.timer, cpu5wdt_trigger, 0);
+        cpu5wdt_device.default_ticks = ticks;
+
+        if (!request_region(port, CPU5WDT_EXTENT, PFX)) {
                 printk(KERN_ERR PFX "request_region failed\n");
                 err = -EBUSY;
                 goto no_port;
         }
 
-        if ( (err = misc_register(&cpu5wdt_misc)) < 0 ) {
-                printk(KERN_ERR PFX "misc_register failed\n");
-                goto no_misc;
-        }
-
         /* watchdog reboot? */
         val = inb(port + CPU5WDT_STATUS_REG);
         val = (val >> 2) & 1;
-        if ( !val )
+        if (!val)
                 printk(KERN_INFO PFX "sorry, was my fault\n");
 
-        init_completion(&cpu5wdt_device.stop);
-        cpu5wdt_device.queue = 0;
-
-        clear_bit(0, &cpu5wdt_device.inuse);
-
-        setup_timer(&cpu5wdt_device.timer, cpu5wdt_trigger, 0);
+        err = misc_register(&cpu5wdt_misc);
+        if (err < 0) {
+                printk(KERN_ERR PFX "misc_register failed\n");
+                goto no_misc;
+        }
 
-        cpu5wdt_device.default_ticks = ticks;
 
         printk(KERN_INFO PFX "init success\n");
-
         return 0;
 
 no_misc:
@@ -267,7 +263,7 @@ static int __devinit cpu5wdt_init_module(void)
 
 static void __devexit cpu5wdt_exit(void)
 {
-        if ( cpu5wdt_device.queue ) {
+        if (cpu5wdt_device.queue) {
                 cpu5wdt_device.queue = 0;
                 wait_for_completion(&cpu5wdt_device.stop);
         }
diff --git a/drivers/watchdog/davinci_wdt.c b/drivers/watchdog/davinci_wdt.c
index 1782c79eff06..802aeba347a0 100644
--- a/drivers/watchdog/davinci_wdt.c
+++ b/drivers/watchdog/davinci_wdt.c
@@ -22,10 +22,10 @@
 #include <linux/bitops.h>
 #include <linux/platform_device.h>
 #include <linux/spinlock.h>
+#include <linux/uaccess.h>
+#include <linux/io.h>
 
 #include <asm/hardware.h>
-#include <asm/uaccess.h>
-#include <asm/io.h>
 
 #define MODULE_NAME "DAVINCI-WDT: "
 
@@ -143,9 +143,8 @@ static struct watchdog_info ident = {
         .identity = "DaVinci Watchdog",
 };
 
-static int
-davinci_wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
-                  unsigned long arg)
+static long davinci_wdt_ioctl(struct file *file,
+                                        unsigned int cmd, unsigned long arg)
 {
         int ret = -ENOTTY;
 
@@ -160,14 +159,14 @@ davinci_wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
                 ret = put_user(0, (int *)arg);
                 break;
 
-        case WDIOC_GETTIMEOUT:
-                ret = put_user(heartbeat, (int *)arg);
-                break;
-
         case WDIOC_KEEPALIVE:
                 wdt_service();
                 ret = 0;
                 break;
+
+        case WDIOC_GETTIMEOUT:
+                ret = put_user(heartbeat, (int *)arg);
+                break;
         }
         return ret;
 }
@@ -184,7 +183,7 @@ static const struct file_operations davinci_wdt_fops = {
         .owner = THIS_MODULE,
         .llseek = no_llseek,
         .write = davinci_wdt_write,
-        .ioctl = davinci_wdt_ioctl,
+        .unlocked_ioctl = davinci_wdt_ioctl,
         .open = davinci_wdt_open,
         .release = davinci_wdt_release,
 };
diff --git a/drivers/watchdog/ep93xx_wdt.c b/drivers/watchdog/ep93xx_wdt.c
index 0e4787a0bb87..07b74a768922 100644
--- a/drivers/watchdog/ep93xx_wdt.c
+++ b/drivers/watchdog/ep93xx_wdt.c
@@ -28,9 +28,9 @@
 #include <linux/miscdevice.h>
 #include <linux/watchdog.h>
 #include <linux/timer.h>
+#include <linux/uaccess.h>
 
 #include <asm/hardware.h>
-#include <asm/uaccess.h>
 
 #define WDT_VERSION     "0.3"
 #define PFX             "ep93xx_wdt: "
@@ -136,9 +136,8 @@ static struct watchdog_info ident = {
         .identity = "EP93xx Watchdog",
 };
 
-static int
-ep93xx_wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
-                 unsigned long arg)
+static long ep93xx_wdt_ioctl(struct file *file,
+                                        unsigned int cmd, unsigned long arg)
 {
         int ret = -ENOTTY;
 
@@ -156,15 +155,15 @@ ep93xx_wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
                 ret = put_user(boot_status, (int __user *)arg);
                 break;
 
-        case WDIOC_GETTIMEOUT:
-                /* actually, it is 0.250 seconds.... */
-                ret = put_user(1, (int __user *)arg);
-                break;
-
         case WDIOC_KEEPALIVE:
                 wdt_keepalive();
                 ret = 0;
                 break;
+
+        case WDIOC_GETTIMEOUT:
+                /* actually, it is 0.250 seconds.... */
+                ret = put_user(1, (int __user *)arg);
+                break;
         }
         return ret;
 }
@@ -174,8 +173,8 @@ static int ep93xx_wdt_release(struct inode *inode, struct file *file)
         if (test_bit(WDT_OK_TO_CLOSE, &wdt_status))
                 wdt_shutdown();
         else
-                printk(KERN_CRIT PFX "Device closed unexpectedly - "
-                        "timer will not stop\n");
+                printk(KERN_CRIT PFX
+                        "Device closed unexpectedly - timer will not stop\n");
 
         clear_bit(WDT_IN_USE, &wdt_status);
         clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
@@ -186,7 +185,7 @@ static int ep93xx_wdt_release(struct inode *inode, struct file *file)
 static const struct file_operations ep93xx_wdt_fops = {
         .owner          = THIS_MODULE,
         .write          = ep93xx_wdt_write,
-        .ioctl          = ep93xx_wdt_ioctl,
+        .unlocked_ioctl = ep93xx_wdt_ioctl,
         .open           = ep93xx_wdt_open,
         .release        = ep93xx_wdt_release,
 };
@@ -243,7 +242,9 @@ module_param(nowayout, int, 0);
 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started");
 
 module_param(timeout, int, 0);
-MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds. (1<=timeout<=3600, default=" __MODULE_STRING(WATCHDOG_TIMEOUT) ")");
+MODULE_PARM_DESC(timeout,
+        "Watchdog timeout in seconds. (1<=timeout<=3600, default="
+                                __MODULE_STRING(WATCHDOG_TIMEOUT) ")");
 
 MODULE_AUTHOR("Ray Lehtiniemi <rayl@mail.com>,"
                 "Alessandro Zummo <a.zummo@towertech.it>");
diff --git a/drivers/watchdog/eurotechwdt.c b/drivers/watchdog/eurotechwdt.c
index b14e9d1f164d..bbd14e34319f 100644
--- a/drivers/watchdog/eurotechwdt.c
+++ b/drivers/watchdog/eurotechwdt.c
@@ -56,14 +56,15 @@
 #include <linux/notifier.h>
 #include <linux/reboot.h>
 #include <linux/init.h>
+#include <linux/io.h>
+#include <linux/uaccess.h>
 
-#include <asm/io.h>
-#include <asm/uaccess.h>
 #include <asm/system.h>
 
 static unsigned long eurwdt_is_open;
 static int eurwdt_timeout;
 static char eur_expect_close;
+static spinlock_t eurwdt_lock;
 
 /*
  * You must set these - there is no sane way to probe for this board.
@@ -78,7 +79,9 @@ static char *ev = "int";
 
 static int nowayout = WATCHDOG_NOWAYOUT;
 module_param(nowayout, int, 0);
-MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+MODULE_PARM_DESC(nowayout,
+                "Watchdog cannot be stopped once started (default="
+                                __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 
 /*
  * Some symbolic names
@@ -137,7 +140,8 @@ static void eurwdt_activate_timer(void)
 {
         eurwdt_disable_timer();
         eurwdt_write_reg(WDT_CTRL_REG, 0x01);   /* activate the WDT */
-        eurwdt_write_reg(WDT_OUTPIN_CFG, !strcmp("int", ev) ? WDT_EVENT_INT : WDT_EVENT_REBOOT);
+        eurwdt_write_reg(WDT_OUTPIN_CFG,
+                !strcmp("int", ev) ? WDT_EVENT_INT : WDT_EVENT_REBOOT);
 
         /* Setting interrupt line */
         if (irq == 2 || irq > 15 || irq < 0) {
@@ -206,21 +210,21 @@ size_t count, loff_t *ppos)
 
                         for (i = 0; i != count; i++) {
                                 char c;
-                                if(get_user(c, buf+i))
+                                if (get_user(c, buf + i))
                                         return -EFAULT;
                                 if (c == 'V')
                                         eur_expect_close = 42;
                         }
                 }
+                spin_lock(&eurwdt_lock);
                 eurwdt_ping();  /* the default timeout */
+                spin_unlock(&eurwdt_lock);
         }
-
         return count;
 }
 
 /**
  * eurwdt_ioctl:
- * @inode: inode of the device
  * @file: file handle to the device
  * @cmd: watchdog command
  * @arg: argument pointer
@@ -229,13 +233,14 @@ size_t count, loff_t *ppos)
  * according to their available features.
  */
 
-static int eurwdt_ioctl(struct inode *inode, struct file *file,
-        unsigned int cmd, unsigned long arg)
+static long eurwdt_ioctl(struct file *file,
+                                        unsigned int cmd, unsigned long arg)
 {
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
         static struct watchdog_info ident = {
-                .options          = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE,
+                .options          = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT
+                                                        | WDIOF_MAGICCLOSE,
                 .firmware_version = 1,
                 .identity         = "WDT Eurotech CPU-1220/1410",
         };
@@ -243,10 +248,7 @@ static int eurwdt_ioctl(struct inode *inode, struct file *file,
         int time;
         int options, retval = -EINVAL;
 
-        switch(cmd) {
-        default:
-                return -ENOTTY;
-
+        switch (cmd) {
         case WDIOC_GETSUPPORT:
                 return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;
 
@@ -254,8 +256,26 @@ static int eurwdt_ioctl(struct inode *inode, struct file *file,
         case WDIOC_GETBOOTSTATUS:
                 return put_user(0, p);
 
+        case WDIOC_SETOPTIONS:
+                if (get_user(options, p))
+                        return -EFAULT;
+                spin_lock(&eurwdt_lock);
+                if (options & WDIOS_DISABLECARD) {
+                        eurwdt_disable_timer();
+                        retval = 0;
+                }
+                if (options & WDIOS_ENABLECARD) {
+                        eurwdt_activate_timer();
+                        eurwdt_ping();
+                        retval = 0;
+                }
+                spin_unlock(&eurwdt_lock);
+                return retval;
+
         case WDIOC_KEEPALIVE:
+                spin_lock(&eurwdt_lock);
                 eurwdt_ping();
+                spin_unlock(&eurwdt_lock);
                 return 0;
 
         case WDIOC_SETTIMEOUT:
@@ -266,26 +286,17 @@ static int eurwdt_ioctl(struct inode *inode, struct file *file,
                 if (time < 0 || time > 255)
                         return -EINVAL;
 
+                spin_lock(&eurwdt_lock);
                 eurwdt_timeout = time;
                 eurwdt_set_timeout(time);
+                spin_unlock(&eurwdt_lock);
                 /* Fall */
 
         case WDIOC_GETTIMEOUT:
                 return put_user(eurwdt_timeout, p);
 
-        case WDIOC_SETOPTIONS:
-                if (get_user(options, p))
-                        return -EFAULT;
-                if (options & WDIOS_DISABLECARD) {
-                        eurwdt_disable_timer();
-                        retval = 0;
-                }
-                if (options & WDIOS_ENABLECARD) {
-                        eurwdt_activate_timer();
-                        eurwdt_ping();
-                        retval = 0;
-                }
-                return retval;
+        default:
+                return -ENOTTY;
         }
 }
 
@@ -322,10 +333,11 @@ static int eurwdt_open(struct inode *inode, struct file *file)
 
 static int eurwdt_release(struct inode *inode, struct file *file)
 {
-        if (eur_expect_close == 42) {
+        if (eur_expect_close == 42)
                 eurwdt_disable_timer();
-        } else {
-                printk(KERN_CRIT "eurwdt: Unexpected close, not stopping watchdog!\n");
+        else {
+                printk(KERN_CRIT
+                        "eurwdt: Unexpected close, not stopping watchdog!\n");
                 eurwdt_ping();
         }
         clear_bit(0, &eurwdt_is_open);
@@ -348,10 +360,8 @@ static int eurwdt_release(struct inode *inode, struct file *file)
 static int eurwdt_notify_sys(struct notifier_block *this, unsigned long code,
         void *unused)
 {
-        if (code == SYS_DOWN || code == SYS_HALT) {
-                /* Turn the card off */
-                eurwdt_disable_timer();
-        }
+        if (code == SYS_DOWN || code == SYS_HALT)
+                eurwdt_disable_timer(); /* Turn the card off */
 
         return NOTIFY_DONE;
 }
@@ -362,11 +372,11 @@ static int eurwdt_notify_sys(struct notifier_block *this, unsigned long code,
 
 
 static const struct file_operations eurwdt_fops = {
-        .owner  = THIS_MODULE,
-        .llseek = no_llseek,
-        .write  = eurwdt_write,
-        .ioctl  = eurwdt_ioctl,
-        .open   = eurwdt_open,
+        .owner          = THIS_MODULE,
+        .llseek         = no_llseek,
+        .write          = eurwdt_write,
+        .unlocked_ioctl = eurwdt_ioctl,
+        .open           = eurwdt_open,
         .release        = eurwdt_release,
 };
 
@@ -419,7 +429,7 @@ static int __init eurwdt_init(void)
         int ret;
 
         ret = request_irq(irq, eurwdt_interrupt, IRQF_DISABLED, "eurwdt", NULL);
-        if(ret) {
+        if (ret) {
                 printk(KERN_ERR "eurwdt: IRQ %d is not free.\n", irq);
                 goto out;
         }
@@ -432,10 +442,13 @@ static int __init eurwdt_init(void)
 
         ret = register_reboot_notifier(&eurwdt_notifier);
         if (ret) {
-                printk(KERN_ERR "eurwdt: can't register reboot notifier (err=%d)\n", ret);
+                printk(KERN_ERR
+                    "eurwdt: can't register reboot notifier (err=%d)\n", ret);
                 goto outreg;
         }
 
+        spin_lock_init(&eurwdt_lock);
+
         ret = misc_register(&eurwdt_miscdev);
         if (ret) {
                 printk(KERN_ERR "eurwdt: can't misc_register on minor=%d\n",
diff --git a/drivers/watchdog/geodewdt.c b/drivers/watchdog/geodewdt.c
index 30d09cbbad94..614a5c7017b6 100644
--- a/drivers/watchdog/geodewdt.c
+++ b/drivers/watchdog/geodewdt.c
@@ -17,8 +17,8 @@
 #include <linux/fs.h>
 #include <linux/platform_device.h>
 #include <linux/reboot.h>
+#include <linux/uaccess.h>
 
-#include <asm/uaccess.h>
 #include <asm/geode.h>
 
 #define GEODEWDT_HZ 500
@@ -77,27 +77,24 @@ static int geodewdt_set_heartbeat(int val)
         return 0;
 }
 
-static int
-geodewdt_open(struct inode *inode, struct file *file)
+static int geodewdt_open(struct inode *inode, struct file *file)
 {
-        if (test_and_set_bit(WDT_FLAGS_OPEN, &wdt_flags))
-                return -EBUSY;
+        if (test_and_set_bit(WDT_FLAGS_OPEN, &wdt_flags))
+                return -EBUSY;
 
-        if (!test_and_clear_bit(WDT_FLAGS_ORPHAN, &wdt_flags))
-                __module_get(THIS_MODULE);
+        if (!test_and_clear_bit(WDT_FLAGS_ORPHAN, &wdt_flags))
+                __module_get(THIS_MODULE);
 
         geodewdt_ping();
-        return nonseekable_open(inode, file);
+        return nonseekable_open(inode, file);
 }
 
-static int
-geodewdt_release(struct inode *inode, struct file *file)
+static int geodewdt_release(struct inode *inode, struct file *file)
 {
         if (safe_close) {
                 geodewdt_disable();
                 module_put(THIS_MODULE);
-        }
-        else {
+        } else {
                 printk(KERN_CRIT "Unexpected close - watchdog is not stopping.\n");
                 geodewdt_ping();
 
@@ -109,11 +106,10 @@ geodewdt_release(struct inode *inode, struct file *file)
         return 0;
 }
 
-static ssize_t
-geodewdt_write(struct file *file, const char __user *data, size_t len,
-               loff_t *ppos)
+static ssize_t geodewdt_write(struct file *file, const char __user *data,
+                                size_t len, loff_t *ppos)
 {
-        if(len) {
+        if (len) {
                 if (!nowayout) {
                         size_t i;
                         safe_close = 0;
@@ -134,9 +130,8 @@ geodewdt_write(struct file *file, const char __user *data, size_t len,
         return len;
 }
 
-static int
-geodewdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
-               unsigned long arg)
+static int geodewdt_ioctl(struct inode *inode, struct file *file,
+                                unsigned int cmd, unsigned long arg)
 {
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
@@ -147,9 +142,9 @@ geodewdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
                 | WDIOF_MAGICCLOSE,
                 .firmware_version =     1,
                 .identity =             WATCHDOG_NAME,
-        };
+        };
 
-        switch(cmd) {
+        switch (cmd) {
         case WDIOC_GETSUPPORT:
                 return copy_to_user(argp, &ident,
                                     sizeof(ident)) ? -EFAULT : 0;
@@ -159,22 +154,6 @@ geodewdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
         case WDIOC_GETBOOTSTATUS:
                 return put_user(0, p);
 
-        case WDIOC_KEEPALIVE:
-                geodewdt_ping();
-                return 0;
-
-        case WDIOC_SETTIMEOUT:
-                if (get_user(interval, p))
-                        return -EFAULT;
-
-                if (geodewdt_set_heartbeat(interval))
-                        return -EINVAL;
-
-/* Fall through */
-
-        case WDIOC_GETTIMEOUT:
-                return put_user(timeout, p);
-
         case WDIOC_SETOPTIONS:
         {
                 int options, ret = -EINVAL;
@@ -194,6 +173,20 @@ geodewdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
 
                 return ret;
         }
+        case WDIOC_KEEPALIVE:
+                geodewdt_ping();
+                return 0;
+
+        case WDIOC_SETTIMEOUT:
+                if (get_user(interval, p))
+                        return -EFAULT;
+
+                if (geodewdt_set_heartbeat(interval))
+                        return -EINVAL;
+        /* Fall through */
+        case WDIOC_GETTIMEOUT:
+                return put_user(timeout, p);
+
         default:
                 return -ENOTTY;
         }
@@ -202,22 +195,21 @@ geodewdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
 }
 
 static const struct file_operations geodewdt_fops = {
-        .owner          = THIS_MODULE,
-        .llseek         = no_llseek,
-        .write          = geodewdt_write,
-        .ioctl          = geodewdt_ioctl,
-        .open           = geodewdt_open,
-        .release        = geodewdt_release,
+        .owner          = THIS_MODULE,
+        .llseek         = no_llseek,
+        .write          = geodewdt_write,
+        .ioctl          = geodewdt_ioctl,
+        .open           = geodewdt_open,
+        .release        = geodewdt_release,
 };
 
 static struct miscdevice geodewdt_miscdev = {
         .minor = WATCHDOG_MINOR,
         .name = "watchdog",
-        .fops = &geodewdt_fops
+        .fops = &geodewdt_fops,
 };
 
-static int __devinit
-geodewdt_probe(struct platform_device *dev)
+static int __devinit geodewdt_probe(struct platform_device *dev)
 {
         int ret, timer;
 
@@ -248,15 +240,13 @@ geodewdt_probe(struct platform_device *dev)
         return ret;
 }
 
-static int __devexit
-geodewdt_remove(struct platform_device *dev)
+static int __devexit geodewdt_remove(struct platform_device *dev)
 {
         misc_deregister(&geodewdt_miscdev);
         return 0;
 }
 
-static void
-geodewdt_shutdown(struct platform_device *dev)
+static void geodewdt_shutdown(struct platform_device *dev)
 {
         geodewdt_disable();
 }
@@ -271,8 +261,7 @@ static struct platform_driver geodewdt_driver = {
         },
 };
 
-static int __init
-geodewdt_init(void)
+static int __init geodewdt_init(void)
 {
         int ret;
 
@@ -292,8 +281,7 @@ err:
         return ret;
 }
 
-static void __exit
-geodewdt_exit(void)
+static void __exit geodewdt_exit(void)
 {
         platform_device_unregister(geodewdt_platform_device);
         platform_driver_unregister(&geodewdt_driver);
diff --git a/drivers/watchdog/hpwdt.c b/drivers/watchdog/hpwdt.c
index ccd6c530782d..d039d5f2fd1c 100644
--- a/drivers/watchdog/hpwdt.c
+++ b/drivers/watchdog/hpwdt.c
@@ -39,9 +39,7 @@
 #include <linux/string.h>
 #include <linux/bootmem.h>
 #include <linux/slab.h>
-#include <asm/dmi.h>
 #include <asm/desc.h>
-#include <asm/kdebug.h>
 
 #define PCI_BIOS32_SD_VALUE             0x5F32335F      /* "_32_" */
 #define CRU_BIOS_SIGNATURE_VALUE        0x55524324
@@ -407,7 +405,7 @@ static int __devinit detect_cru_service(void)
         dmi_walk(dmi_find_cru);
 
         /* if cru_rom_addr has been set then we found a CRU service */
-        return ((cru_rom_addr != NULL)? 0: -ENODEV);
+        return ((cru_rom_addr != NULL) ? 0: -ENODEV);
 }
 
 /* ------------------------------------------------------------------------- */
@@ -535,7 +533,7 @@ static ssize_t hpwdt_write(struct file *file, const char __user *data,
                         /* scan to see whether or not we got the magic char. */
                         for (i = 0; i != len; i++) {
                                 char c;
-                                if (get_user(c, data+i))
+                                if (get_user(c, data + i))
                                         return -EFAULT;
                                 if (c == 'V')
                                         expect_release = 42;
diff --git a/drivers/watchdog/i6300esb.c b/drivers/watchdog/i6300esb.c
index ca44fd9b19bb..c13383f7fcb9 100644
--- a/drivers/watchdog/i6300esb.c
+++ b/drivers/watchdog/i6300esb.c
@@ -9,18 +9,18 @@
  *      as published by the Free Software Foundation; either version
  *      2 of the License, or (at your option) any later version.
  *
- *      based on i810-tco.c which is in turn based on softdog.c
+ *      based on i810-tco.c which is in turn based on softdog.c
  *
- *      The timer is implemented in the following I/O controller hubs:
- *      (See the intel documentation on http://developer.intel.com.)
- *      6300ESB chip : document number 300641-003
+ *      The timer is implemented in the following I/O controller hubs:
+ *      (See the intel documentation on http://developer.intel.com.)
+ *      6300ESB chip : document number 300641-003
  *
  *  2004YYZZ Ross Biro
  *      Initial version 0.01
  *  2004YYZZ Ross Biro
- *      Version 0.02
+ *      Version 0.02
  *  20050210 David Härdeman <david@2gen.com>
- *      Ported driver to kernel 2.6
+ *      Ported driver to kernel 2.6
  */
 
 /*
@@ -38,9 +38,8 @@
 #include <linux/init.h>
 #include <linux/pci.h>
 #include <linux/ioport.h>
-
-#include <asm/uaccess.h>
-#include <asm/io.h>
+#include <linux/uaccess.h>
+#include <linux/io.h>
 
 /* Module and version information */
 #define ESB_VERSION "0.03"
@@ -59,17 +58,17 @@
 #define ESB_RELOAD_REG  BASEADDR + 0x0c /* Reload register                   */
 
 /* Lock register bits */
-#define ESB_WDT_FUNC    ( 0x01 << 2 )   /* Watchdog functionality            */
-#define ESB_WDT_ENABLE  ( 0x01 << 1 )   /* Enable WDT                        */
-#define ESB_WDT_LOCK    ( 0x01 << 0 )   /* Lock (nowayout)                   */
+#define ESB_WDT_FUNC    (0x01 << 2)   /* Watchdog functionality            */
+#define ESB_WDT_ENABLE  (0x01 << 1)   /* Enable WDT                        */
+#define ESB_WDT_LOCK    (0x01 << 0)   /* Lock (nowayout)                   */
 
 /* Config register bits */
-#define ESB_WDT_REBOOT  ( 0x01 << 5 )   /* Enable reboot on timeout          */
-#define ESB_WDT_FREQ    ( 0x01 << 2 )   /* Decrement frequency               */
-#define ESB_WDT_INTTYPE ( 0x11 << 0 )   /* Interrupt type on timer1 timeout  */
+#define ESB_WDT_REBOOT  (0x01 << 5)   /* Enable reboot on timeout          */
+#define ESB_WDT_FREQ    (0x01 << 2)   /* Decrement frequency               */
+#define ESB_WDT_INTTYPE (0x11 << 0)   /* Interrupt type on timer1 timeout  */
 
 /* Reload register bits */
-#define ESB_WDT_RELOAD ( 0x01 << 8 )    /* prevent timeout                   */
+#define ESB_WDT_RELOAD  (0x01 << 8)    /* prevent timeout                   */
 
 /* Magic constants */
 #define ESB_UNLOCK1     0x80            /* Step 1 to unlock reset registers  */
@@ -84,14 +83,20 @@ static unsigned short triggered; /* The status of the watchdog upon boot */
 static char esb_expect_close;
 
 /* module parameters */
-#define WATCHDOG_HEARTBEAT 30   /* 30 sec default heartbeat (1<heartbeat<2*1023) */
+/* 30 sec default heartbeat (1 < heartbeat < 2*1023) */
+#define WATCHDOG_HEARTBEAT 30
 static int heartbeat = WATCHDOG_HEARTBEAT;  /* in seconds */
+
 module_param(heartbeat, int, 0);
-MODULE_PARM_DESC(heartbeat, "Watchdog heartbeat in seconds. (1<heartbeat<2046, default=" __MODULE_STRING(WATCHDOG_HEARTBEAT) ")");
+MODULE_PARM_DESC(heartbeat,
+                "Watchdog heartbeat in seconds. (1<heartbeat<2046, default="
+                                __MODULE_STRING(WATCHDOG_HEARTBEAT) ")");
 
 static int nowayout = WATCHDOG_NOWAYOUT;
 module_param(nowayout, int, 0);
-MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+MODULE_PARM_DESC(nowayout,
+                "Watchdog cannot be stopped once started (default="
+                                __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 
 /*
  * Some i6300ESB specific functions
@@ -103,9 +108,10 @@ MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" _
  * reload register. After this the appropriate registers can be written
  * to once before they need to be unlocked again.
  */
-static inline void esb_unlock_registers(void) {
-        writeb(ESB_UNLOCK1, ESB_RELOAD_REG);
-        writeb(ESB_UNLOCK2, ESB_RELOAD_REG);
+static inline void esb_unlock_registers(void)
+{
+        writeb(ESB_UNLOCK1, ESB_RELOAD_REG);
+        writeb(ESB_UNLOCK2, ESB_RELOAD_REG);
 }
 
 static void esb_timer_start(void)
@@ -114,8 +120,7 @@ static void esb_timer_start(void)
 
         /* Enable or Enable + Lock? */
         val = 0x02 | (nowayout ? 0x01 : 0x00);
-
-        pci_write_config_byte(esb_pci, ESB_LOCK_REG, val);
+        pci_write_config_byte(esb_pci, ESB_LOCK_REG, val);
 }
 
 static int esb_timer_stop(void)
@@ -140,7 +145,7 @@ static void esb_timer_keepalive(void)
         spin_lock(&esb_lock);
         esb_unlock_registers();
         writew(ESB_WDT_RELOAD, ESB_RELOAD_REG);
-        /* FIXME: Do we need to flush anything here? */
+        /* FIXME: Do we need to flush anything here? */
         spin_unlock(&esb_lock);
 }
 
@@ -165,9 +170,9 @@ static int esb_timer_set_heartbeat(int time)
 
         /* Write timer 2 */
         esb_unlock_registers();
-        writel(val, ESB_TIMER2_REG);
+        writel(val, ESB_TIMER2_REG);
 
-        /* Reload */
+        /* Reload */
         esb_unlock_registers();
         writew(ESB_WDT_RELOAD, ESB_RELOAD_REG);
 
@@ -179,54 +184,55 @@ static int esb_timer_set_heartbeat(int time)
         return 0;
 }
 
-static int esb_timer_read (void)
+static int esb_timer_read(void)
 {
-        u32 count;
+        u32 count;
 
         /* This isn't documented, and doesn't take into
-         * acount which stage is running, but it looks
-         * like a 20 bit count down, so we might as well report it.
-         */
-        pci_read_config_dword(esb_pci, 0x64, &count);
-        return (int)count;
+         * acount which stage is running, but it looks
+         * like a 20 bit count down, so we might as well report it.
+         */
+        pci_read_config_dword(esb_pci, 0x64, &count);
+        return (int)count;
 }
 
 /*
- *      /dev/watchdog handling
+ *      /dev/watchdog handling
  */
 
-static int esb_open (struct inode *inode, struct file *file)
+static int esb_open(struct inode *inode, struct file *file)
 {
-        /* /dev/watchdog can only be opened once */
-        if (test_and_set_bit(0, &timer_alive))
-                return -EBUSY;
+        /* /dev/watchdog can only be opened once */
+        if (test_and_set_bit(0, &timer_alive))
+                return -EBUSY;
 
-        /* Reload and activate timer */
-        esb_timer_keepalive ();
-        esb_timer_start ();
+        /* Reload and activate timer */
+        esb_timer_keepalive();
+        esb_timer_start();
 
         return nonseekable_open(inode, file);
 }
 
-static int esb_release (struct inode *inode, struct file *file)
+static int esb_release(struct inode *inode, struct file *file)
 {
-        /* Shut off the timer. */
-        if (esb_expect_close == 42) {
-                esb_timer_stop ();
-        } else {
-                printk(KERN_CRIT PFX "Unexpected close, not stopping watchdog!\n");
-                esb_timer_keepalive ();
-        }
-        clear_bit(0, &timer_alive);
-        esb_expect_close = 0;
-        return 0;
+        /* Shut off the timer. */
+        if (esb_expect_close == 42)
+                esb_timer_stop();
+        else {
+                printk(KERN_CRIT PFX
+                                "Unexpected close, not stopping watchdog!\n");
+                esb_timer_keepalive();
+        }
+        clear_bit(0, &timer_alive);
+        esb_expect_close = 0;
+        return 0;
 }
 
-static ssize_t esb_write (struct file *file, const char __user *data,
-                          size_t len, loff_t * ppos)
+static ssize_t esb_write(struct file *file, const char __user *data,
+                          size_t len, loff_t *ppos)
 {
         /* See if we got the magic character 'V' and reload the timer */
-        if (len) {
+        if (len) {
                 if (!nowayout) {
                         size_t i;
 
@@ -237,7 +243,7 @@ static ssize_t esb_write (struct file *file, const char __user *data,
                         /* scan to see whether or not we got the magic character */
                         for (i = 0; i != len; i++) {
                                 char c;
-                                if(get_user(c, data+i))
+                                if (get_user(c, data + i))
                                         return -EFAULT;
                                 if (c == 'V')
                                         esb_expect_close = 42;
@@ -245,92 +251,84 @@ static ssize_t esb_write (struct file *file, const char __user *data,
                 }
 
                 /* someone wrote to us, we should reload the timer */
-                esb_timer_keepalive ();
+                esb_timer_keepalive();
         }
         return len;
 }
 
-static int esb_ioctl (struct inode *inode, struct file *file,
-                      unsigned int cmd, unsigned long arg)
+static long esb_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
         int new_options, retval = -EINVAL;
         int new_heartbeat;
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
         static struct watchdog_info ident = {
-                .options =              WDIOF_SETTIMEOUT |
+                .options =              WDIOF_SETTIMEOUT |
                                         WDIOF_KEEPALIVEPING |
                                         WDIOF_MAGICCLOSE,
-                .firmware_version =     0,
-                .identity =             ESB_MODULE_NAME,
+                .firmware_version =     0,
+                .identity =             ESB_MODULE_NAME,
         };
 
         switch (cmd) {
-                case WDIOC_GETSUPPORT:
-                        return copy_to_user(argp, &ident,
-                                            sizeof (ident)) ? -EFAULT : 0;
-
-                case WDIOC_GETSTATUS:
-                        return put_user (esb_timer_read(), p);
-
-                case WDIOC_GETBOOTSTATUS:
-                        return put_user (triggered, p);
+        case WDIOC_GETSUPPORT:
+                return copy_to_user(argp, &ident,
+                                        sizeof(ident)) ? -EFAULT : 0;
 
-                case WDIOC_KEEPALIVE:
-                        esb_timer_keepalive ();
-                        return 0;
+        case WDIOC_GETSTATUS:
+                return put_user(esb_timer_read(), p);
 
-                case WDIOC_SETOPTIONS:
-                {
-                        if (get_user (new_options, p))
-                                return -EFAULT;
+        case WDIOC_GETBOOTSTATUS:
+                return put_user(triggered, p);
 
-                        if (new_options & WDIOS_DISABLECARD) {
-                                esb_timer_stop ();
-                                retval = 0;
-                        }
+        case WDIOC_SETOPTIONS:
+        {
+                if (get_user(new_options, p))
+                        return -EFAULT;
 
-                        if (new_options & WDIOS_ENABLECARD) {
-                                esb_timer_keepalive ();
-                                esb_timer_start ();
-                                retval = 0;
-                        }
-
-                        return retval;
-                }
-
-                case WDIOC_SETTIMEOUT:
-                {
-                        if (get_user(new_heartbeat, p))
-                                return -EFAULT;
-
-                        if (esb_timer_set_heartbeat(new_heartbeat))
-                            return -EINVAL;
-
-                        esb_timer_keepalive ();
-                        /* Fall */
-                }
-
-                case WDIOC_GETTIMEOUT:
-                        return put_user(heartbeat, p);
+                if (new_options & WDIOS_DISABLECARD) {
+                        esb_timer_stop();
+                        retval = 0;
+                }
 
-                default:
-                        return -ENOTTY;
-        }
+                if (new_options & WDIOS_ENABLECARD) {
+                        esb_timer_keepalive();
+                        esb_timer_start();
+                        retval = 0;
+                }
+                return retval;
+        }
+        case WDIOC_KEEPALIVE:
+                esb_timer_keepalive();
+                return 0;
+
+        case WDIOC_SETTIMEOUT:
+        {
+                if (get_user(new_heartbeat, p))
+                        return -EFAULT;
+                if (esb_timer_set_heartbeat(new_heartbeat))
+                        return -EINVAL;
+                esb_timer_keepalive();
+                /* Fall */
+        }
+        case WDIOC_GETTIMEOUT:
+                return put_user(heartbeat, p);
+        default:
+                return -ENOTTY;
+        }
 }
 
 /*
  *      Notify system
  */
 
-static int esb_notify_sys (struct notifier_block *this, unsigned long code, void *unused)
+static int esb_notify_sys(struct notifier_block *this,
+                                        unsigned long code, void *unused)
 {
-        if (code==SYS_DOWN || code==SYS_HALT) {
-                /* Turn the WDT off */
-                esb_timer_stop ();
-        }
+        if (code == SYS_DOWN || code == SYS_HALT)
+                esb_timer_stop();       /* Turn the WDT off */
 
-        return NOTIFY_DONE;
+        return NOTIFY_DONE;
 }
 
 /*
@@ -338,22 +336,22 @@ static int esb_notify_sys (struct notifier_block *this, unsigned long code, void
  */
 
 static const struct file_operations esb_fops = {
-        .owner =        THIS_MODULE,
-        .llseek =       no_llseek,
-        .write =        esb_write,
-        .ioctl =        esb_ioctl,
-        .open =         esb_open,
-        .release =      esb_release,
+        .owner = THIS_MODULE,
+        .llseek = no_llseek,
+        .write = esb_write,
+        .unlocked_ioctl = esb_ioctl,
+        .open = esb_open,
+        .release = esb_release,
 };
 
 static struct miscdevice esb_miscdev = {
-        .minor =        WATCHDOG_MINOR,
-        .name =         "watchdog",
-        .fops =         &esb_fops,
+        .minor = WATCHDOG_MINOR,
+        .name = "watchdog",
+        .fops = &esb_fops,
 };
 
 static struct notifier_block esb_notifier = {
-        .notifier_call =        esb_notify_sys,
+        .notifier_call = esb_notify_sys,
 };
 
 /*
@@ -365,50 +363,44 @@ static struct notifier_block esb_notifier = {
  * want to register another driver on the same PCI id.
  */
 static struct pci_device_id esb_pci_tbl[] = {
-        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ESB_9), },
-        { 0, },                 /* End of list */
+        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ESB_9), },
+        { 0, },                 /* End of list */
 };
-MODULE_DEVICE_TABLE (pci, esb_pci_tbl);
+MODULE_DEVICE_TABLE(pci, esb_pci_tbl);
 
 /*
  *      Init & exit routines
  */
 
-static unsigned char __init esb_getdevice (void)
+static unsigned char __init esb_getdevice(void)
 {
         u8 val1;
         unsigned short val2;
+        /*
+         *      Find the PCI device
+         */
 
-        struct pci_dev *dev = NULL;
-        /*
-         *      Find the PCI device
-         */
-
-        for_each_pci_dev(dev) {
-                if (pci_match_id(esb_pci_tbl, dev)) {
-                        esb_pci = dev;
-                        break;
-                }
-        }
+        esb_pci = pci_get_device(PCI_VENDOR_ID_INTEL,
+                                        PCI_DEVICE_ID_INTEL_ESB_9, NULL);
 
-        if (esb_pci) {
-                if (pci_enable_device(esb_pci)) {
-                        printk (KERN_ERR PFX "failed to enable device\n");
+        if (esb_pci) {
+                if (pci_enable_device(esb_pci)) {
+                        printk(KERN_ERR PFX "failed to enable device\n");
                         goto err_devput;
                 }
 
                 if (pci_request_region(esb_pci, 0, ESB_MODULE_NAME)) {
-                        printk (KERN_ERR PFX "failed to request region\n");
+                        printk(KERN_ERR PFX "failed to request region\n");
                         goto err_disable;
                 }
 
                 BASEADDR = ioremap(pci_resource_start(esb_pci, 0),
                                    pci_resource_len(esb_pci, 0));
                 if (BASEADDR == NULL) {
-                        /* Something's wrong here, BASEADDR has to be set */
-                        printk (KERN_ERR PFX "failed to get BASEADDR\n");
-                        goto err_release;
-                }
+                        /* Something's wrong here, BASEADDR has to be set */
+                        printk(KERN_ERR PFX "failed to get BASEADDR\n");
+                        goto err_release;
+                }
 
                 /*
                  * The watchdog has two timers, it can be setup so that the
@@ -425,7 +417,7 @@ static unsigned char __init esb_getdevice (void)
                 /* Check that the WDT isn't already locked */
                 pci_read_config_byte(esb_pci, ESB_LOCK_REG, &val1);
                 if (val1 & ESB_WDT_LOCK)
-                        printk (KERN_WARNING PFX "nowayout already set\n");
+                        printk(KERN_WARNING PFX "nowayout already set\n");
 
                 /* Set the timer to watchdog mode and disable it for now */
                 pci_write_config_byte(esb_pci, ESB_LOCK_REG, 0x00);
@@ -452,44 +444,44 @@ err_devput:
         return 0;
 }
 
-static int __init watchdog_init (void)
+static int __init watchdog_init(void)
 {
-        int ret;
-
-        /* Check whether or not the hardware watchdog is there */
-        if (!esb_getdevice () || esb_pci == NULL)
-                return -ENODEV;
-
-        /* Check that the heartbeat value is within it's range ; if not reset to the default */
-        if (esb_timer_set_heartbeat (heartbeat)) {
-                esb_timer_set_heartbeat (WATCHDOG_HEARTBEAT);
-                printk(KERN_INFO PFX "heartbeat value must be 1<heartbeat<2046, using %d\n",
-                       heartbeat);
-        }
-
-        ret = register_reboot_notifier(&esb_notifier);
-        if (ret != 0) {
-                printk(KERN_ERR PFX "cannot register reboot notifier (err=%d)\n",
-                        ret);
-                goto err_unmap;
-        }
-
-        ret = misc_register(&esb_miscdev);
-        if (ret != 0) {
-                printk(KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",
-                        WATCHDOG_MINOR, ret);
-                goto err_notifier;
-        }
-
-        esb_timer_stop ();
-
-        printk (KERN_INFO PFX "initialized (0x%p). heartbeat=%d sec (nowayout=%d)\n",
-                BASEADDR, heartbeat, nowayout);
+        int ret;
+
+        /* Check whether or not the hardware watchdog is there */
+        if (!esb_getdevice() || esb_pci == NULL)
+                return -ENODEV;
+
+        /* Check that the heartbeat value is within it's range;
+           if not reset to the default */
+        if (esb_timer_set_heartbeat(heartbeat)) {
+                esb_timer_set_heartbeat(WATCHDOG_HEARTBEAT);
+                printk(KERN_INFO PFX
+                        "heartbeat value must be 1<heartbeat<2046, using %d\n",
+                                                                heartbeat);
+        }
+        ret = register_reboot_notifier(&esb_notifier);
+        if (ret != 0) {
+                printk(KERN_ERR PFX
+                        "cannot register reboot notifier (err=%d)\n", ret);
+                goto err_unmap;
+        }
 
-        return 0;
+        ret = misc_register(&esb_miscdev);
+        if (ret != 0) {
+                printk(KERN_ERR PFX
+                        "cannot register miscdev on minor=%d (err=%d)\n",
+                                                        WATCHDOG_MINOR, ret);
+                goto err_notifier;
+        }
+        esb_timer_stop();
+        printk(KERN_INFO PFX
+                "initialized (0x%p). heartbeat=%d sec (nowayout=%d)\n",
+                                                BASEADDR, heartbeat, nowayout);
+        return 0;
 
 err_notifier:
-        unregister_reboot_notifier(&esb_notifier);
+        unregister_reboot_notifier(&esb_notifier);
 err_unmap:
         iounmap(BASEADDR);
 /* err_release: */
@@ -498,18 +490,18 @@ err_unmap:
         pci_disable_device(esb_pci);
 /* err_devput: */
         pci_dev_put(esb_pci);
-        return ret;
+        return ret;
 }
 
-static void __exit watchdog_cleanup (void)
+static void __exit watchdog_cleanup(void)
 {
         /* Stop the timer before we leave */
         if (!nowayout)
-                esb_timer_stop ();
+                esb_timer_stop();
 
         /* Deregister */
         misc_deregister(&esb_miscdev);
-        unregister_reboot_notifier(&esb_notifier);
+        unregister_reboot_notifier(&esb_notifier);
         iounmap(BASEADDR);
         pci_release_region(esb_pci, 0);
         pci_disable_device(esb_pci);
diff --git a/drivers/watchdog/iTCO_vendor.h b/drivers/watchdog/iTCO_vendor.h
new file mode 100644
index 000000000000..9e27e6422f66
--- /dev/null
+++ b/drivers/watchdog/iTCO_vendor.h
@@ -0,0 +1,15 @@
+/* iTCO Vendor Specific Support hooks */
+#ifdef CONFIG_ITCO_VENDOR_SUPPORT
+extern void iTCO_vendor_pre_start(unsigned long, unsigned int);
+extern void iTCO_vendor_pre_stop(unsigned long);
+extern void iTCO_vendor_pre_keepalive(unsigned long, unsigned int);
+extern void iTCO_vendor_pre_set_heartbeat(unsigned int);
+extern int iTCO_vendor_check_noreboot_on(void);
+#else
+#define iTCO_vendor_pre_start(acpibase, heartbeat)      {}
+#define iTCO_vendor_pre_stop(acpibase)                  {}
+#define iTCO_vendor_pre_keepalive(acpibase, heartbeat)  {}
+#define iTCO_vendor_pre_set_heartbeat(heartbeat)        {}
+#define iTCO_vendor_check_noreboot_on()                 1
+                                /* 1=check noreboot; 0=don't check */
+#endif
diff --git a/drivers/watchdog/iTCO_vendor_support.c b/drivers/watchdog/iTCO_vendor_support.c
index cafc465f2ae3..ca344a85eb95 100644
--- a/drivers/watchdog/iTCO_vendor_support.c
+++ b/drivers/watchdog/iTCO_vendor_support.c
@@ -18,9 +18,9 @@
  */
 
 /* Module and version information */
-#define DRV_NAME        "iTCO_vendor_support"
-#define DRV_VERSION     "1.01"
-#define DRV_RELDATE     "11-Nov-2006"
+#define DRV_NAME        "iTCO_vendor_support"
+#define DRV_VERSION     "1.01"
+#define DRV_RELDATE     "11-Nov-2006"
 #define PFX             DRV_NAME ": "
 
 /* Includes */
@@ -31,19 +31,22 @@
 #include <linux/kernel.h>               /* For printk/panic/... */
 #include <linux/init.h>                 /* For __init/__exit/... */
 #include <linux/ioport.h>               /* For io-port access */
+#include <linux/io.h>                   /* For inb/outb/... */
 
-#include <asm/io.h>                     /* For inb/outb/... */
+#include "iTCO_vendor.h"
 
 /* iTCO defines */
 #define SMI_EN          acpibase + 0x30 /* SMI Control and Enable Register */
-#define TCOBASE         acpibase + 0x60 /* TCO base address             */
-#define TCO1_STS        TCOBASE + 0x04  /* TCO1 Status Register         */
+#define TCOBASE         acpibase + 0x60 /* TCO base address */
+#define TCO1_STS        TCOBASE + 0x04  /* TCO1 Status Register */
 
 /* List of vendor support modes */
-#define SUPERMICRO_OLD_BOARD    1       /* SuperMicro Pentium 3 Era 370SSE+-OEM1/P3TSSE */
-#define SUPERMICRO_NEW_BOARD    2       /* SuperMicro Pentium 4 / Xeon 4 / EMT64T Era Systems */
+/* SuperMicro Pentium 3 Era 370SSE+-OEM1/P3TSSE */
+#define SUPERMICRO_OLD_BOARD    1
+/* SuperMicro Pentium 4 / Xeon 4 / EMT64T Era Systems */
+#define SUPERMICRO_NEW_BOARD    2
 
-static int vendorsupport = 0;
+static int vendorsupport;
 module_param(vendorsupport, int, 0);
 MODULE_PARM_DESC(vendorsupport, "iTCO vendor specific support mode, default=0 (none), 1=SuperMicro Pent3, 2=SuperMicro Pent4+");
 
@@ -143,34 +146,35 @@ static void supermicro_old_pre_keepalive(unsigned long acpibase)
  */
 
 /* I/O Port's */
-#define SM_REGINDEX     0x2e            /* SuperMicro ICH4+ Register Index */
-#define SM_DATAIO       0x2f            /* SuperMicro ICH4+ Register Data I/O */
+#define SM_REGINDEX     0x2e    /* SuperMicro ICH4+ Register Index */
+#define SM_DATAIO       0x2f    /* SuperMicro ICH4+ Register Data I/O */
 
 /* Control Register's */
-#define SM_CTLPAGESW    0x07            /* SuperMicro ICH4+ Control Page Switch */
-#define SM_CTLPAGE              0x08    /* SuperMicro ICH4+ Control Page Num */
+#define SM_CTLPAGESW    0x07    /* SuperMicro ICH4+ Control Page Switch */
+#define SM_CTLPAGE      0x08    /* SuperMicro ICH4+ Control Page Num */
 
-#define SM_WATCHENABLE  0x30            /* Watchdog enable: Bit 0: 0=off, 1=on */
+#define SM_WATCHENABLE  0x30    /* Watchdog enable: Bit 0: 0=off, 1=on */
 
-#define SM_WATCHPAGE    0x87            /* Watchdog unlock control page */
+#define SM_WATCHPAGE    0x87    /* Watchdog unlock control page */
 
-#define SM_ENDWATCH     0xAA            /* Watchdog lock control page */
+#define SM_ENDWATCH     0xAA    /* Watchdog lock control page */
 
-#define SM_COUNTMODE    0xf5            /* Watchdog count mode select */
-                                        /* (Bit 3: 0 = seconds, 1 = minutes */
+#define SM_COUNTMODE    0xf5    /* Watchdog count mode select */
+                                /* (Bit 3: 0 = seconds, 1 = minutes */
 
-#define SM_WATCHTIMER   0xf6            /* 8-bits, Watchdog timer counter (RW) */
+#define SM_WATCHTIMER   0xf6    /* 8-bits, Watchdog timer counter (RW) */
 
-#define SM_RESETCONTROL 0xf7            /* Watchdog reset control */
-                                        /* Bit 6: timer is reset by kbd interrupt */
-                                        /* Bit 7: timer is reset by mouse interrupt */
+#define SM_RESETCONTROL 0xf7    /* Watchdog reset control */
+                                /* Bit 6: timer is reset by kbd interrupt */
+                                /* Bit 7: timer is reset by mouse interrupt */
 
 static void supermicro_new_unlock_watchdog(void)
 {
-        outb(SM_WATCHPAGE, SM_REGINDEX);        /* Write 0x87 to port 0x2e twice */
+        /* Write 0x87 to port 0x2e twice */
         outb(SM_WATCHPAGE, SM_REGINDEX);
-
-        outb(SM_CTLPAGESW, SM_REGINDEX);        /* Switch to watchdog control page */
+        outb(SM_WATCHPAGE, SM_REGINDEX);
+        /* Switch to watchdog control page */
+        outb(SM_CTLPAGESW, SM_REGINDEX);
         outb(SM_CTLPAGE, SM_DATAIO);
 }
 
@@ -192,7 +196,7 @@ static void supermicro_new_pre_start(unsigned int heartbeat)
         outb(val, SM_DATAIO);
 
         /* Write heartbeat interval to WDOG */
-        outb (SM_WATCHTIMER, SM_REGINDEX);
+        outb(SM_WATCHTIMER, SM_REGINDEX);
         outb((heartbeat & 255), SM_DATAIO);
 
         /* Make sure keyboard/mouse interrupts don't interfere */
@@ -277,7 +281,7 @@ EXPORT_SYMBOL(iTCO_vendor_pre_set_heartbeat);
 
 int iTCO_vendor_check_noreboot_on(void)
 {
-        switch(vendorsupport) {
+        switch (vendorsupport) {
         case SUPERMICRO_OLD_BOARD:
                 return 0;
         default:
@@ -288,13 +292,13 @@ EXPORT_SYMBOL(iTCO_vendor_check_noreboot_on);
 
 static int __init iTCO_vendor_init_module(void)
 {
-        printk (KERN_INFO PFX "vendor-support=%d\n", vendorsupport);
+        printk(KERN_INFO PFX "vendor-support=%d\n", vendorsupport);
         return 0;
 }
 
 static void __exit iTCO_vendor_exit_module(void)
 {
-        printk (KERN_INFO PFX "Module Unloaded\n");
+        printk(KERN_INFO PFX "Module Unloaded\n");
 }
 
 module_init(iTCO_vendor_init_module);
diff --git a/drivers/watchdog/iTCO_wdt.c b/drivers/watchdog/iTCO_wdt.c
index 95ba985bd341..bfb93bc2ca9f 100644
--- a/drivers/watchdog/iTCO_wdt.c
+++ b/drivers/watchdog/iTCO_wdt.c
@@ -55,9 +55,9 @@
  */
 
 /* Module and version information */
-#define DRV_NAME        "iTCO_wdt"
-#define DRV_VERSION     "1.03"
-#define DRV_RELDATE     "30-Apr-2008"
+#define DRV_NAME        "iTCO_wdt"
+#define DRV_VERSION     "1.03"
+#define DRV_RELDATE     "30-Apr-2008"
 #define PFX             DRV_NAME ": "
 
 /* Includes */
@@ -66,7 +66,8 @@
 #include <linux/types.h>                /* For standard types (like size_t) */
 #include <linux/errno.h>                /* For the -ENODEV/... values */
 #include <linux/kernel.h>               /* For printk/panic/... */
-#include <linux/miscdevice.h>           /* For MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR) */
+#include <linux/miscdevice.h>           /* For MODULE_ALIAS_MISCDEV
+                                                        (WATCHDOG_MINOR) */
 #include <linux/watchdog.h>             /* For the watchdog specific items */
 #include <linux/init.h>                 /* For __init/__exit/... */
 #include <linux/fs.h>                   /* For file operations */
@@ -74,9 +75,10 @@
 #include <linux/pci.h>                  /* For pci functions */
 #include <linux/ioport.h>               /* For io-port access */
 #include <linux/spinlock.h>             /* For spin_lock/spin_unlock/... */
+#include <linux/uaccess.h>              /* For copy_to_user/put_user/... */
+#include <linux/io.h>                   /* For inb/outb/... */
 
-#include <asm/uaccess.h>                /* For copy_to_user/put_user/... */
-#include <asm/io.h>                     /* For inb/outb/... */
+#include "iTCO_vendor.h"
 
 /* TCO related info */
 enum iTCO_chipsets {
@@ -105,7 +107,7 @@ enum iTCO_chipsets {
         TCO_ICH9,       /* ICH9 */
         TCO_ICH9R,      /* ICH9R */
         TCO_ICH9DH,     /* ICH9DH */
-        TCO_ICH9DO,     /* ICH9DO */
+        TCO_ICH9DO,     /* ICH9DO */
         TCO_631XESB,    /* 631xESB/632xESB */
 };
 
@@ -140,7 +142,7 @@ static struct {
         {"ICH9DH", 2},
         {"ICH9DO", 2},
         {"631xESB/632xESB", 2},
-        {NULL,0}
+        {NULL, 0}
 };
 
 #define ITCO_PCI_DEVICE(dev, data)      \
@@ -159,32 +161,32 @@ static struct {
  * functions that probably will be registered by other drivers.
  */
 static struct pci_device_id iTCO_wdt_pci_tbl[] = {
-        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_82801AA_0,        TCO_ICH    )},
-        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_82801AB_0,        TCO_ICH0   )},
-        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_82801BA_0,        TCO_ICH2   )},
-        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_82801BA_10,       TCO_ICH2M  )},
-        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_82801CA_0,        TCO_ICH3   )},
-        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_82801CA_12,       TCO_ICH3M  )},
-        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_82801DB_0,        TCO_ICH4   )},
-        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_82801DB_12,       TCO_ICH4M  )},
-        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_82801E_0,         TCO_CICH   )},
-        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_82801EB_0,        TCO_ICH5   )},
+        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_82801AA_0,        TCO_ICH)},
+        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_82801AB_0,        TCO_ICH0)},
+        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_82801BA_0,        TCO_ICH2)},
+        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_82801BA_10,       TCO_ICH2M)},
+        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_82801CA_0,        TCO_ICH3)},
+        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_82801CA_12,       TCO_ICH3M)},
+        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_82801DB_0,        TCO_ICH4)},
+        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_82801DB_12,       TCO_ICH4M)},
+        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_82801E_0,         TCO_CICH)},
+        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_82801EB_0,        TCO_ICH5)},
         { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_ESB_1,            TCO_6300ESB)},
-        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_ICH6_0,           TCO_ICH6   )},
-        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_ICH6_1,           TCO_ICH6M  )},
-        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_ICH6_2,           TCO_ICH6W  )},
-        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_ICH7_0,           TCO_ICH7   )},
-        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_ICH7_1,           TCO_ICH7M  )},
+        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_ICH6_0,           TCO_ICH6)},
+        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_ICH6_1,           TCO_ICH6M)},
+        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_ICH6_2,           TCO_ICH6W)},
+        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_ICH7_0,           TCO_ICH7)},
+        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_ICH7_1,           TCO_ICH7M)},
         { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_ICH7_31,          TCO_ICH7MDH)},
-        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_ICH8_0,           TCO_ICH8   )},
-        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_ICH8_1,           TCO_ICH8ME )},
-        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_ICH8_2,           TCO_ICH8DH )},
-        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_ICH8_3,           TCO_ICH8DO )},
-        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_ICH8_4,           TCO_ICH8M  )},
-        { ITCO_PCI_DEVICE(0x2918,                               TCO_ICH9   )},
-        { ITCO_PCI_DEVICE(0x2916,                               TCO_ICH9R  )},
-        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_ICH9_2,           TCO_ICH9DH )},
-        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_ICH9_4,           TCO_ICH9DO )},
+        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_ICH8_0,           TCO_ICH8)},
+        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_ICH8_1,           TCO_ICH8ME)},
+        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_ICH8_2,           TCO_ICH8DH)},
+        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_ICH8_3,           TCO_ICH8DO)},
+        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_ICH8_4,           TCO_ICH8M)},
+        { ITCO_PCI_DEVICE(0x2918,                               TCO_ICH9)},
+        { ITCO_PCI_DEVICE(0x2916,                               TCO_ICH9R)},
+        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_ICH9_2,           TCO_ICH9DH)},
+        { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_ICH9_4,           TCO_ICH9DO)},
         { ITCO_PCI_DEVICE(PCI_DEVICE_ID_INTEL_ESB2_0,           TCO_631XESB)},
         { ITCO_PCI_DEVICE(0x2671,                               TCO_631XESB)},
         { ITCO_PCI_DEVICE(0x2672,                               TCO_631XESB)},
@@ -203,13 +205,15 @@ static struct pci_device_id iTCO_wdt_pci_tbl[] = {
         { ITCO_PCI_DEVICE(0x267f,                               TCO_631XESB)},
         { 0, },                 /* End of list */
 };
-MODULE_DEVICE_TABLE (pci, iTCO_wdt_pci_tbl);
+MODULE_DEVICE_TABLE(pci, iTCO_wdt_pci_tbl);
 
 /* Address definitions for the TCO */
-#define TCOBASE         iTCO_wdt_private.ACPIBASE + 0x60        /* TCO base address                */
-#define SMI_EN          iTCO_wdt_private.ACPIBASE + 0x30        /* SMI Control and Enable Register */
+/* TCO base address */
+#define TCOBASE         iTCO_wdt_private.ACPIBASE + 0x60
+/* SMI Control and Enable Register */
+#define SMI_EN          iTCO_wdt_private.ACPIBASE + 0x30
 
-#define TCO_RLD         TCOBASE + 0x00  /* TCO Timer Reload and Current Value */
+#define TCO_RLD         TCOBASE + 0x00  /* TCO Timer Reload and Curr. Value */
 #define TCOv1_TMR       TCOBASE + 0x01  /* TCOv1 Timer Initial Value    */
 #define TCO_DAT_IN      TCOBASE + 0x02  /* TCO Data In Register         */
 #define TCO_DAT_OUT     TCOBASE + 0x03  /* TCO Data Out Register        */
@@ -222,15 +226,21 @@ MODULE_DEVICE_TABLE (pci, iTCO_wdt_pci_tbl);
 /* internal variables */
 static unsigned long is_active;
 static char expect_release;
-static struct {                         /* this is private data for the iTCO_wdt device */
-        unsigned int iTCO_version;      /* TCO version/generation */
-        unsigned long ACPIBASE;         /* The cards ACPIBASE address (TCOBASE = ACPIBASE+0x60) */
-        unsigned long __iomem *gcs;     /* NO_REBOOT flag is Memory-Mapped GCS register bit 5 (TCO version 2) */
-        spinlock_t io_lock;             /* the lock for io operations */
-        struct pci_dev *pdev;           /* the PCI-device */
+static struct {         /* this is private data for the iTCO_wdt device */
+        /* TCO version/generation */
+        unsigned int iTCO_version;
+        /* The cards ACPIBASE address (TCOBASE = ACPIBASE+0x60) */
+        unsigned long ACPIBASE;
+        /* NO_REBOOT flag is Memory-Mapped GCS register bit 5 (TCO version 2)*/
+        unsigned long __iomem *gcs;
+        /* the lock for io operations */
+        spinlock_t io_lock;
+        /* the PCI-device */
+        struct pci_dev *pdev;
 } iTCO_wdt_private;
 
-static struct platform_device *iTCO_wdt_platform_device;        /* the watchdog platform device */
+/* the watchdog platform device */
+static struct platform_device *iTCO_wdt_platform_device;
 
 /* module parameters */
 #define WATCHDOG_HEARTBEAT 30   /* 30 sec default heartbeat */
@@ -240,22 +250,9 @@ MODULE_PARM_DESC(heartbeat, "Watchdog heartbeat in seconds. (2<heartbeat<39 (TCO
 
 static int nowayout = WATCHDOG_NOWAYOUT;
 module_param(nowayout, int, 0);
-MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
-
-/* iTCO Vendor Specific Support hooks */
-#ifdef CONFIG_ITCO_VENDOR_SUPPORT
-extern void iTCO_vendor_pre_start(unsigned long, unsigned int);
-extern void iTCO_vendor_pre_stop(unsigned long);
-extern void iTCO_vendor_pre_keepalive(unsigned long, unsigned int);
-extern void iTCO_vendor_pre_set_heartbeat(unsigned int);
-extern int iTCO_vendor_check_noreboot_on(void);
-#else
-#define iTCO_vendor_pre_start(acpibase, heartbeat)      {}
-#define iTCO_vendor_pre_stop(acpibase)                  {}
-#define iTCO_vendor_pre_keepalive(acpibase,heartbeat)   {}
-#define iTCO_vendor_pre_set_heartbeat(heartbeat)        {}
-#define iTCO_vendor_check_noreboot_on()                 1       /* 1=check noreboot; 0=don't check */
-#endif
+MODULE_PARM_DESC(nowayout,
+        "Watchdog cannot be stopped once started (default="
+                                __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 
 /*
  * Some TCO specific functions
@@ -369,11 +366,10 @@ static int iTCO_wdt_keepalive(void)
         iTCO_vendor_pre_keepalive(iTCO_wdt_private.ACPIBASE, heartbeat);
 
         /* Reload the timer by writing to the TCO Timer Counter register */
-        if (iTCO_wdt_private.iTCO_version == 2) {
+        if (iTCO_wdt_private.iTCO_version == 2)
                 outw(0x01, TCO_RLD);
-        } else if (iTCO_wdt_private.iTCO_version == 1) {
+        else if (iTCO_wdt_private.iTCO_version == 1)
                 outb(0x01, TCO_RLD);
-        }
 
         spin_unlock(&iTCO_wdt_private.io_lock);
         return 0;
@@ -425,7 +421,7 @@ static int iTCO_wdt_set_heartbeat(int t)
         return 0;
 }
 
-static int iTCO_wdt_get_timeleft (int *time_left)
+static int iTCO_wdt_get_timeleft(int *time_left)
 {
         unsigned int val16;
         unsigned char val8;
@@ -454,7 +450,7 @@ static int iTCO_wdt_get_timeleft (int *time_left)
  *      /dev/watchdog handling
  */
 
-static int iTCO_wdt_open (struct inode *inode, struct file *file)
+static int iTCO_wdt_open(struct inode *inode, struct file *file)
 {
         /* /dev/watchdog can only be opened once */
         if (test_and_set_bit(0, &is_active))
@@ -468,7 +464,7 @@ static int iTCO_wdt_open (struct inode *inode, struct file *file)
         return nonseekable_open(inode, file);
 }
 
-static int iTCO_wdt_release (struct inode *inode, struct file *file)
+static int iTCO_wdt_release(struct inode *inode, struct file *file)
 {
         /*
          *      Shut off the timer.
@@ -476,7 +472,8 @@ static int iTCO_wdt_release (struct inode *inode, struct file *file)
         if (expect_release == 42) {
                 iTCO_wdt_stop();
         } else {
-                printk(KERN_CRIT PFX "Unexpected close, not stopping watchdog!\n");
+                printk(KERN_CRIT PFX
+                        "Unexpected close, not stopping watchdog!\n");
                 iTCO_wdt_keepalive();
         }
         clear_bit(0, &is_active);
@@ -484,22 +481,23 @@ static int iTCO_wdt_release (struct inode *inode, struct file *file)
         return 0;
 }
 
-static ssize_t iTCO_wdt_write (struct file *file, const char __user *data,
-                              size_t len, loff_t * ppos)
+static ssize_t iTCO_wdt_write(struct file *file, const char __user *data,
+                              size_t len, loff_t *ppos)
 {
         /* See if we got the magic character 'V' and reload the timer */
         if (len) {
                 if (!nowayout) {
                         size_t i;
 
-                        /* note: just in case someone wrote the magic character
-                         * five months ago... */
+                        /* note: just in case someone wrote the magic
+                           character five months ago... */
                         expect_release = 0;
 
-                        /* scan to see whether or not we got the magic character */
+                        /* scan to see whether or not we got the
+                           magic character */
                         for (i = 0; i != len; i++) {
                                 char c;
-                                if (get_user(c, data+i))
+                                if (get_user(c, data + i))
                                         return -EFAULT;
                                 if (c == 'V')
                                         expect_release = 42;
@@ -512,8 +510,8 @@ static ssize_t iTCO_wdt_write (struct file *file, const char __user *data,
         return len;
 }
 
-static int iTCO_wdt_ioctl (struct inode *inode, struct file *file,
-                          unsigned int cmd, unsigned long arg)
+static long iTCO_wdt_ioctl(struct file *file, unsigned int cmd,
+                                                        unsigned long arg)
 {
         int new_options, retval = -EINVAL;
         int new_heartbeat;
@@ -528,64 +526,52 @@ static int iTCO_wdt_ioctl (struct inode *inode, struct file *file,
         };
 
         switch (cmd) {
-                case WDIOC_GETSUPPORT:
-                        return copy_to_user(argp, &ident,
-                                sizeof (ident)) ? -EFAULT : 0;
-
-                case WDIOC_GETSTATUS:
-                case WDIOC_GETBOOTSTATUS:
-                        return put_user(0, p);
-
-                case WDIOC_KEEPALIVE:
-                        iTCO_wdt_keepalive();
-                        return 0;
-
-                case WDIOC_SETOPTIONS:
-                {
-                        if (get_user(new_options, p))
-                                return -EFAULT;
-
-                        if (new_options & WDIOS_DISABLECARD) {
-                                iTCO_wdt_stop();
-                                retval = 0;
-                        }
-
-                        if (new_options & WDIOS_ENABLECARD) {
-                                iTCO_wdt_keepalive();
-                                iTCO_wdt_start();
-                                retval = 0;
-                        }
-
-                        return retval;
+        case WDIOC_GETSUPPORT:
+                return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;
+        case WDIOC_GETSTATUS:
+        case WDIOC_GETBOOTSTATUS:
+                return put_user(0, p);
+
+        case WDIOC_SETOPTIONS:
+        {
+                if (get_user(new_options, p))
+                        return -EFAULT;
+
+                if (new_options & WDIOS_DISABLECARD) {
+                        iTCO_wdt_stop();
+                        retval = 0;
                 }
-
-                case WDIOC_SETTIMEOUT:
-                {
-                        if (get_user(new_heartbeat, p))
-                                return -EFAULT;
-
-                        if (iTCO_wdt_set_heartbeat(new_heartbeat))
-                                return -EINVAL;
-
+                if (new_options & WDIOS_ENABLECARD) {
                         iTCO_wdt_keepalive();
-                        /* Fall */
-                }
-
-                case WDIOC_GETTIMEOUT:
-                        return put_user(heartbeat, p);
-
-                case WDIOC_GETTIMELEFT:
-                {
-                        int time_left;
-
-                        if (iTCO_wdt_get_timeleft(&time_left))
-                                return -EINVAL;
-
-                        return put_user(time_left, p);
+                        iTCO_wdt_start();
+                        retval = 0;
                 }
+                return retval;
+        }
+        case WDIOC_KEEPALIVE:
+                iTCO_wdt_keepalive();
+                return 0;
 
-                default:
-                        return -ENOTTY;
+        case WDIOC_SETTIMEOUT:
+        {
+                if (get_user(new_heartbeat, p))
+                        return -EFAULT;
+                if (iTCO_wdt_set_heartbeat(new_heartbeat))
+                        return -EINVAL;
+                iTCO_wdt_keepalive();
+                /* Fall */
+        }
+        case WDIOC_GETTIMEOUT:
+                return put_user(heartbeat, p);
+        case WDIOC_GETTIMELEFT:
+        {
+                int time_left;
+                if (iTCO_wdt_get_timeleft(&time_left))
+                        return -EINVAL;
+                return put_user(time_left, p);
+        }
+        default:
+                return -ENOTTY;
         }
 }
 
@@ -594,12 +580,12 @@ static int iTCO_wdt_ioctl (struct inode *inode, struct file *file,
  */
 
 static const struct file_operations iTCO_wdt_fops = {
-        .owner =        THIS_MODULE,
-        .llseek =       no_llseek,
-        .write =        iTCO_wdt_write,
-        .ioctl =        iTCO_wdt_ioctl,
-        .open =         iTCO_wdt_open,
-        .release =      iTCO_wdt_release,
+        .owner =                THIS_MODULE,
+        .llseek =               no_llseek,
+        .write =                iTCO_wdt_write,
+        .unlocked_ioctl =       iTCO_wdt_ioctl,
+        .open =                 iTCO_wdt_open,
+        .release =              iTCO_wdt_release,
 };
 
 static struct miscdevice iTCO_wdt_miscdev = {
@@ -612,7 +598,8 @@ static struct miscdevice iTCO_wdt_miscdev = {
  *      Init & exit routines
  */
 
-static int __devinit iTCO_wdt_init(struct pci_dev *pdev, const struct pci_device_id *ent, struct platform_device *dev)
+static int __devinit iTCO_wdt_init(struct pci_dev *pdev,
+                const struct pci_device_id *ent, struct platform_device *dev)
 {
         int ret;
         u32 base_address;
@@ -632,17 +619,19 @@ static int __devinit iTCO_wdt_init(struct pci_dev *pdev, const struct pci_device
                 pci_dev_put(pdev);
                 return -ENODEV;
         }
-        iTCO_wdt_private.iTCO_version = iTCO_chipset_info[ent->driver_data].iTCO_version;
+        iTCO_wdt_private.iTCO_version =
+                        iTCO_chipset_info[ent->driver_data].iTCO_version;
         iTCO_wdt_private.ACPIBASE = base_address;
         iTCO_wdt_private.pdev = pdev;
 
-        /* Get the Memory-Mapped GCS register, we need it for the NO_REBOOT flag (TCO v2) */
-        /* To get access to it you have to read RCBA from PCI Config space 0xf0
-           and use it as base. GCS = RCBA + ICH6_GCS(0x3410). */
+        /* Get the Memory-Mapped GCS register, we need it for the
+           NO_REBOOT flag (TCO v2). To get access to it you have to
+           read RCBA from PCI Config space 0xf0 and use it as base.
+           GCS = RCBA + ICH6_GCS(0x3410). */
         if (iTCO_wdt_private.iTCO_version == 2) {
                 pci_read_config_dword(pdev, 0xf0, &base_address);
                 RCBA = base_address & 0xffffc000;
-                iTCO_wdt_private.gcs = ioremap((RCBA + 0x3410),4);
+                iTCO_wdt_private.gcs = ioremap((RCBA + 0x3410), 4);
         }
 
         /* Check chipset's NO_REBOOT bit */
@@ -657,8 +646,8 @@ static int __devinit iTCO_wdt_init(struct pci_dev *pdev, const struct pci_device
 
         /* Set the TCO_EN bit in SMI_EN register */
         if (!request_region(SMI_EN, 4, "iTCO_wdt")) {
-                printk(KERN_ERR PFX "I/O address 0x%04lx already in use\n",
-                        SMI_EN );
+                printk(KERN_ERR PFX
+                        "I/O address 0x%04lx already in use\n", SMI_EN);
                 ret = -EIO;
                 goto out;
         }
@@ -667,18 +656,20 @@ static int __devinit iTCO_wdt_init(struct pci_dev *pdev, const struct pci_device
         outl(val32, SMI_EN);
         release_region(SMI_EN, 4);
 
-        /* The TCO I/O registers reside in a 32-byte range pointed to by the TCOBASE value */
-        if (!request_region (TCOBASE, 0x20, "iTCO_wdt")) {
-                printk (KERN_ERR PFX "I/O address 0x%04lx already in use\n",
+        /* The TCO I/O registers reside in a 32-byte range pointed to
+           by the TCOBASE value */
+        if (!request_region(TCOBASE, 0x20, "iTCO_wdt")) {
+                printk(KERN_ERR PFX "I/O address 0x%04lx already in use\n",
                         TCOBASE);
                 ret = -EIO;
                 goto out;
         }
 
-        printk(KERN_INFO PFX "Found a %s TCO device (Version=%d, TCOBASE=0x%04lx)\n",
-                iTCO_chipset_info[ent->driver_data].name,
-                iTCO_chipset_info[ent->driver_data].iTCO_version,
-                TCOBASE);
+        printk(KERN_INFO PFX
+                "Found a %s TCO device (Version=%d, TCOBASE=0x%04lx)\n",
+                        iTCO_chipset_info[ent->driver_data].name,
+                        iTCO_chipset_info[ent->driver_data].iTCO_version,
+                        TCOBASE);
 
         /* Clear out the (probably old) status */
         outb(0, TCO1_STS);
@@ -687,27 +678,29 @@ static int __devinit iTCO_wdt_init(struct pci_dev *pdev, const struct pci_device
         /* Make sure the watchdog is not running */
         iTCO_wdt_stop();
 
-        /* Check that the heartbeat value is within it's range ; if not reset to the default */
+        /* Check that the heartbeat value is within it's range;
+           if not reset to the default */
         if (iTCO_wdt_set_heartbeat(heartbeat)) {
                 iTCO_wdt_set_heartbeat(WATCHDOG_HEARTBEAT);
-                printk(KERN_INFO PFX "heartbeat value must be 2<heartbeat<39 (TCO v1) or 613 (TCO v2), using %d\n",
-                        heartbeat);
+                printk(KERN_INFO PFX "heartbeat value must be 2 < heartbeat < 39 (TCO v1) or 613 (TCO v2), using %d\n",
+                                                        heartbeat);
         }
 
         ret = misc_register(&iTCO_wdt_miscdev);
         if (ret != 0) {
-                printk(KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",
-                        WATCHDOG_MINOR, ret);
+                printk(KERN_ERR PFX
+                        "cannot register miscdev on minor=%d (err=%d)\n",
+                                                        WATCHDOG_MINOR, ret);
                 goto unreg_region;
         }
 
-        printk (KERN_INFO PFX "initialized. heartbeat=%d sec (nowayout=%d)\n",
-                heartbeat, nowayout);
+        printk(KERN_INFO PFX "initialized. heartbeat=%d sec (nowayout=%d)\n",
+                                                        heartbeat, nowayout);
 
         return 0;
 
 unreg_region:
-        release_region (TCOBASE, 0x20);
+        release_region(TCOBASE, 0x20);
 out:
         if (iTCO_wdt_private.iTCO_version == 2)
                 iounmap(iTCO_wdt_private.gcs);
@@ -796,7 +789,8 @@ static int __init iTCO_wdt_init_module(void)
         if (err)
                 return err;
 
-        iTCO_wdt_platform_device = platform_device_register_simple(DRV_NAME, -1, NULL, 0);
+        iTCO_wdt_platform_device = platform_device_register_simple(DRV_NAME,
+                                                                -1, NULL, 0);
         if (IS_ERR(iTCO_wdt_platform_device)) {
                 err = PTR_ERR(iTCO_wdt_platform_device);
                 goto unreg_platform_driver;
diff --git a/drivers/watchdog/ib700wdt.c b/drivers/watchdog/ib700wdt.c
index 4b89f401691a..05a28106e8eb 100644
--- a/drivers/watchdog/ib700wdt.c
+++ b/drivers/watchdog/ib700wdt.c
@@ -41,9 +41,9 @@
 #include <linux/spinlock.h>
 #include <linux/moduleparam.h>
 #include <linux/platform_device.h>
+#include <linux/io.h>
+#include <linux/uaccess.h>
 
-#include <asm/io.h>
-#include <asm/uaccess.h>
 #include <asm/system.h>
 
 static struct platform_device *ibwdt_platform_device;
@@ -120,15 +120,16 @@ static int wd_margin = WD_TIMO;
 
 static int nowayout = WATCHDOG_NOWAYOUT;
 module_param(nowayout, int, 0);
-MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+MODULE_PARM_DESC(nowayout,
+                "Watchdog cannot be stopped once started (default="
+                                __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 
 
 /*
  *      Watchdog Operations
  */
 
-static void
-ibwdt_ping(void)
+static void ibwdt_ping(void)
 {
         spin_lock(&ibwdt_lock);
 
@@ -138,16 +139,14 @@ ibwdt_ping(void)
         spin_unlock(&ibwdt_lock);
 }
 
-static void
-ibwdt_disable(void)
+static void ibwdt_disable(void)
 {
         spin_lock(&ibwdt_lock);
         outb_p(0, WDT_STOP);
         spin_unlock(&ibwdt_lock);
 }
 
-static int
-ibwdt_set_heartbeat(int t)
+static int ibwdt_set_heartbeat(int t)
 {
         int i;
 
@@ -165,8 +164,8 @@ ibwdt_set_heartbeat(int t)
  *      /dev/watchdog handling
  */
 
-static ssize_t
-ibwdt_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
+static ssize_t ibwdt_write(struct file *file, const char __user *buf,
+                                                size_t count, loff_t *ppos)
 {
         if (count) {
                 if (!nowayout) {
@@ -188,77 +187,71 @@ ibwdt_write(struct file *file, const char __user *buf, size_t count, loff_t *ppo
         return count;
 }
 
-static int
-ibwdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
-          unsigned long arg)
+static long ibwdt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
         int new_margin;
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
 
         static struct watchdog_info ident = {
-                .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE,
+                .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT
+                                                        | WDIOF_MAGICCLOSE,
                 .firmware_version = 1,
                 .identity = "IB700 WDT",
         };
 
         switch (cmd) {
         case WDIOC_GETSUPPORT:
-          if (copy_to_user(argp, &ident, sizeof(ident)))
-            return -EFAULT;
-          break;
+                if (copy_to_user(argp, &ident, sizeof(ident)))
+                        return -EFAULT;
+                break;
 
         case WDIOC_GETSTATUS:
         case WDIOC_GETBOOTSTATUS:
-          return put_user(0, p);
-
-        case WDIOC_KEEPALIVE:
-          ibwdt_ping();
-          break;
-
-        case WDIOC_SETTIMEOUT:
-          if (get_user(new_margin, p))
-                  return -EFAULT;
-          if (ibwdt_set_heartbeat(new_margin))
-                  return -EINVAL;
-          ibwdt_ping();
-          /* Fall */
-
-        case WDIOC_GETTIMEOUT:
-          return put_user(wd_times[wd_margin], p);
+                return put_user(0, p);
 
         case WDIOC_SETOPTIONS:
         {
-          int options, retval = -EINVAL;
+                int options, retval = -EINVAL;
 
-          if (get_user(options, p))
-            return -EFAULT;
+                if (get_user(options, p))
+                        return -EFAULT;
 
-          if (options & WDIOS_DISABLECARD) {
-            ibwdt_disable();
-            retval = 0;
-          }
+                if (options & WDIOS_DISABLECARD) {
+                        ibwdt_disable();
+                        retval = 0;
+                }
+                if (options & WDIOS_ENABLECARD) {
+                        ibwdt_ping();
+                        retval = 0;
+                }
+                return retval;
+        }
+        case WDIOC_KEEPALIVE:
+                ibwdt_ping();
+                break;
 
-          if (options & WDIOS_ENABLECARD) {
-            ibwdt_ping();
-            retval = 0;
-          }
+        case WDIOC_SETTIMEOUT:
+                if (get_user(new_margin, p))
+                        return -EFAULT;
+                if (ibwdt_set_heartbeat(new_margin))
+                        return -EINVAL;
+                ibwdt_ping();
+                /* Fall */
 
-          return retval;
-        }
+        case WDIOC_GETTIMEOUT:
+                return put_user(wd_times[wd_margin], p);
 
         default:
-          return -ENOTTY;
+                return -ENOTTY;
         }
         return 0;
 }
 
-static int
-ibwdt_open(struct inode *inode, struct file *file)
+static int ibwdt_open(struct inode *inode, struct file *file)
 {
-        if (test_and_set_bit(0, &ibwdt_is_open)) {
+        if (test_and_set_bit(0, &ibwdt_is_open))
                 return -EBUSY;
-        }
         if (nowayout)
                 __module_get(THIS_MODULE);
 
@@ -267,13 +260,13 @@ ibwdt_open(struct inode *inode, struct file *file)
         return nonseekable_open(inode, file);
 }
 
-static int
-ibwdt_close(struct inode *inode, struct file *file)
+static int ibwdt_close(struct inode *inode, struct file *file)
 {
         if (expect_close == 42) {
                 ibwdt_disable();
         } else {
-                printk(KERN_CRIT PFX "WDT device closed unexpectedly.  WDT will not stop!\n");
+                printk(KERN_CRIT PFX
+                     "WDT device closed unexpectedly.  WDT will not stop!\n");
                 ibwdt_ping();
         }
         clear_bit(0, &ibwdt_is_open);
@@ -289,7 +282,7 @@ static const struct file_operations ibwdt_fops = {
         .owner          = THIS_MODULE,
         .llseek         = no_llseek,
         .write          = ibwdt_write,
-        .ioctl          = ibwdt_ioctl,
+        .unlocked_ioctl = ibwdt_ioctl,
         .open           = ibwdt_open,
         .release        = ibwdt_close,
 };
@@ -310,21 +303,23 @@ static int __devinit ibwdt_probe(struct platform_device *dev)
 
 #if WDT_START != WDT_STOP
         if (!request_region(WDT_STOP, 1, "IB700 WDT")) {
-                printk (KERN_ERR PFX "STOP method I/O %X is not available.\n", WDT_STOP);
+                printk(KERN_ERR PFX "STOP method I/O %X is not available.\n",
+                                                                WDT_STOP);
                 res = -EIO;
                 goto out_nostopreg;
         }
 #endif
 
         if (!request_region(WDT_START, 1, "IB700 WDT")) {
-                printk (KERN_ERR PFX "START method I/O %X is not available.\n", WDT_START);
+                printk(KERN_ERR PFX "START method I/O %X is not available.\n",
+                                                                WDT_START);
                 res = -EIO;
                 goto out_nostartreg;
         }
 
         res = misc_register(&ibwdt_miscdev);
         if (res) {
-                printk (KERN_ERR PFX "failed to register misc device\n");
+                printk(KERN_ERR PFX "failed to register misc device\n");
                 goto out_nomisc;
         }
         return 0;
@@ -342,9 +337,9 @@ out_nostopreg:
 static int __devexit ibwdt_remove(struct platform_device *dev)
 {
         misc_deregister(&ibwdt_miscdev);
-        release_region(WDT_START,1);
+        release_region(WDT_START, 1);
 #if WDT_START != WDT_STOP
-        release_region(WDT_STOP,1);
+        release_region(WDT_STOP, 1);
 #endif
         return 0;
 }
@@ -369,13 +364,15 @@ static int __init ibwdt_init(void)
 {
         int err;
 
-        printk(KERN_INFO PFX "WDT driver for IB700 single board computer initialising.\n");
+        printk(KERN_INFO PFX
+                "WDT driver for IB700 single board computer initialising.\n");
 
         err = platform_driver_register(&ibwdt_driver);
         if (err)
                 return err;
 
-        ibwdt_platform_device = platform_device_register_simple(DRV_NAME, -1, NULL, 0);
+        ibwdt_platform_device = platform_device_register_simple(DRV_NAME,
+                                                                -1, NULL, 0);
         if (IS_ERR(ibwdt_platform_device)) {
                 err = PTR_ERR(ibwdt_platform_device);
                 goto unreg_platform_driver;
diff --git a/drivers/watchdog/ibmasr.c b/drivers/watchdog/ibmasr.c
index 94155f6136c2..b82405cfb4cd 100644
--- a/drivers/watchdog/ibmasr.c
+++ b/drivers/watchdog/ibmasr.c
@@ -19,9 +19,8 @@
 #include <linux/miscdevice.h>
 #include <linux/watchdog.h>
 #include <linux/dmi.h>
-
-#include <asm/io.h>
-#include <asm/uaccess.h>
+#include <linux/io.h>
+#include <linux/uaccess.h>
 
 
 enum {
@@ -70,10 +69,13 @@ static char asr_expect_close;
 static unsigned int asr_type, asr_base, asr_length;
 static unsigned int asr_read_addr, asr_write_addr;
 static unsigned char asr_toggle_mask, asr_disable_mask;
+static spinlock_t asr_lock;
 
-static void asr_toggle(void)
+static void __asr_toggle(void)
 {
-        unsigned char reg = inb(asr_read_addr);
+        unsigned char reg;
+
+        reg = inb(asr_read_addr);
 
         outb(reg & ~asr_toggle_mask, asr_write_addr);
         reg = inb(asr_read_addr);
@@ -83,12 +85,21 @@ static void asr_toggle(void)
 
         outb(reg & ~asr_toggle_mask, asr_write_addr);
         reg = inb(asr_read_addr);
+        spin_unlock(&asr_lock);
+}
+
+static void asr_toggle(void)
+{
+        spin_lock(&asr_lock);
+        __asr_toggle();
+        spin_unlock(&asr_lock);
 }
 
 static void asr_enable(void)
 {
         unsigned char reg;
 
+        spin_lock(&asr_lock);
         if (asr_type == ASMTYPE_TOPAZ) {
                 /* asr_write_addr == asr_read_addr */
                 reg = inb(asr_read_addr);
@@ -99,17 +110,21 @@ static void asr_enable(void)
                  * First make sure the hardware timer is reset by toggling
                  * ASR hardware timer line.
                  */
-                asr_toggle();
+                __asr_toggle();
 
                 reg = inb(asr_read_addr);
                 outb(reg & ~asr_disable_mask, asr_write_addr);
         }
         reg = inb(asr_read_addr);
+        spin_unlock(&asr_lock);
 }
 
 static void asr_disable(void)
 {
-        unsigned char reg = inb(asr_read_addr);
+        unsigned char reg;
+
+        spin_lock(&asr_lock);
+        reg = inb(asr_read_addr);
 
         if (asr_type == ASMTYPE_TOPAZ)
                 /* asr_write_addr == asr_read_addr */
@@ -122,6 +137,7 @@ static void asr_disable(void)
                 outb(reg | asr_disable_mask, asr_write_addr);
         }
         reg = inb(asr_read_addr);
+        spin_unlock(&asr_lock);
 }
 
 static int __init asr_get_base_address(void)
@@ -133,7 +149,8 @@ static int __init asr_get_base_address(void)
 
         switch (asr_type) {
         case ASMTYPE_TOPAZ:
-                /* SELECT SuperIO CHIP FOR QUERYING (WRITE 0x07 TO BOTH 0x2E and 0x2F) */
+                /* SELECT SuperIO CHIP FOR QUERYING
+                   (WRITE 0x07 TO BOTH 0x2E and 0x2F) */
                 outb(0x07, 0x2e);
                 outb(0x07, 0x2f);
 
@@ -154,14 +171,26 @@ static int __init asr_get_base_address(void)
 
         case ASMTYPE_JASPER:
                 type = "Jaspers ";
-
-                /* FIXME: need to use pci_config_lock here, but it's not exported */
+#if 0
+                u32 r;
+                /* Suggested fix */
+                pdev = pci_get_bus_and_slot(0, DEVFN(0x1f, 0));
+                if (pdev == NULL)
+                        return -ENODEV;
+                pci_read_config_dword(pdev, 0x58, &r);
+                asr_base = r & 0xFFFE;
+                pci_dev_put(pdev);
+#else
+                /* FIXME: need to use pci_config_lock here,
+                   but it's not exported */
 
 /*              spin_lock_irqsave(&pci_config_lock, flags);*/
 
                 /* Select the SuperIO chip in the PCI I/O port register */
                 outl(0x8000f858, 0xcf8);
 
+                /* BUS 0, Slot 1F, fnc 0, offset 58 */
+
                 /*
                  * Read the base address for the SuperIO chip.
                  * Only the lower 16 bits are valid, but the address is word
@@ -170,7 +199,7 @@ static int __init asr_get_base_address(void)
                 asr_base = inl(0xcfc) & 0xfffe;
 
 /*              spin_unlock_irqrestore(&pci_config_lock, flags);*/
-
+#endif
                 asr_read_addr = asr_write_addr =
                         asr_base + JASPER_ASR_REG_OFFSET;
                 asr_toggle_mask = JASPER_ASR_TOGGLE_MASK;
@@ -241,66 +270,57 @@ static ssize_t asr_write(struct file *file, const char __user *buf,
         return count;
 }
 
-static int asr_ioctl(struct inode *inode, struct file *file,
-                     unsigned int cmd, unsigned long arg)
+static long asr_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
         static const struct watchdog_info ident = {
-                .options =      WDIOF_KEEPALIVEPING | 
+                .options =      WDIOF_KEEPALIVEPING |
                                 WDIOF_MAGICCLOSE,
-                .identity =     "IBM ASR"
+                .identity =     "IBM ASR",
         };
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
         int heartbeat;
 
         switch (cmd) {
-                case WDIOC_GETSUPPORT:
-                        return copy_to_user(argp, &ident, sizeof(ident)) ?
-                                -EFAULT : 0;
-
-                case WDIOC_GETSTATUS:
-                case WDIOC_GETBOOTSTATUS:
-                        return put_user(0, p);
-
-                case WDIOC_KEEPALIVE:
+        case WDIOC_GETSUPPORT:
+                return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;
+        case WDIOC_GETSTATUS:
+        case WDIOC_GETBOOTSTATUS:
+                return put_user(0, p);
+        case WDIOC_SETOPTIONS:
+        {
+                int new_options, retval = -EINVAL;
+                if (get_user(new_options, p))
+                        return -EFAULT;
+                if (new_options & WDIOS_DISABLECARD) {
+                        asr_disable();
+                        retval = 0;
+                }
+                if (new_options & WDIOS_ENABLECARD) {
+                        asr_enable();
                         asr_toggle();
-                        return 0;
-
-                /*
-                 * The hardware has a fixed timeout value, so no WDIOC_SETTIMEOUT
-                 * and WDIOC_GETTIMEOUT always returns 256.
-                 */
-                case WDIOC_GETTIMEOUT:
-                        heartbeat = 256;
-                        return put_user(heartbeat, p);
-
-                case WDIOC_SETOPTIONS: {
-                        int new_options, retval = -EINVAL;
-
-                        if (get_user(new_options, p))
-                                return -EFAULT;
-
-                        if (new_options & WDIOS_DISABLECARD) {
-                                asr_disable();
-                                retval = 0;
-                        }
-
-                        if (new_options & WDIOS_ENABLECARD) {
-                                asr_enable();
-                                asr_toggle();
-                                retval = 0;
-                        }
-
-                        return retval;
+                        retval = 0;
                 }
+                return retval;
+        }
+        case WDIOC_KEEPALIVE:
+                asr_toggle();
+                return 0;
+        /*
+         * The hardware has a fixed timeout value, so no WDIOC_SETTIMEOUT
+         * and WDIOC_GETTIMEOUT always returns 256.
+         */
+        case WDIOC_GETTIMEOUT:
+                heartbeat = 256;
+                return put_user(heartbeat, p);
+        default:
+                return -ENOTTY;
         }
-
-        return -ENOTTY;
 }
 
 static int asr_open(struct inode *inode, struct file *file)
 {
-        if(test_and_set_bit(0, &asr_is_open))
+        if (test_and_set_bit(0, &asr_is_open))
                 return -EBUSY;
 
         asr_toggle();
@@ -314,7 +334,8 @@ static int asr_release(struct inode *inode, struct file *file)
         if (asr_expect_close == 42)
                 asr_disable();
         else {
-                printk(KERN_CRIT PFX "unexpected close, not stopping watchdog!\n");
+                printk(KERN_CRIT PFX
+                                "unexpected close, not stopping watchdog!\n");
                 asr_toggle();
         }
         clear_bit(0, &asr_is_open);
@@ -323,12 +344,12 @@ static int asr_release(struct inode *inode, struct file *file)
 }
 
 static const struct file_operations asr_fops = {
-        .owner =        THIS_MODULE,
-        .llseek =       no_llseek,
-        .write =        asr_write,
-        .ioctl =        asr_ioctl,
-        .open =         asr_open,
-        .release =      asr_release,
+        .owner =                THIS_MODULE,
+        .llseek =               no_llseek,
+        .write =                asr_write,
+        .unlocked_ioctl =       asr_ioctl,
+        .open =                 asr_open,
+        .release =              asr_release,
 };
 
 static struct miscdevice asr_miscdev = {
@@ -367,6 +388,8 @@ static int __init ibmasr_init(void)
         if (!asr_type)
                 return -ENODEV;
 
+        spin_lock_init(&asr_lock);
+
         rc = asr_get_base_address();
         if (rc)
                 return rc;
@@ -395,7 +418,9 @@ module_init(ibmasr_init);
 module_exit(ibmasr_exit);
 
 module_param(nowayout, int, 0);
-MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+MODULE_PARM_DESC(nowayout,
+        "Watchdog cannot be stopped once started (default="
+                                __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 
 MODULE_DESCRIPTION("IBM Automatic Server Restart driver");
 MODULE_AUTHOR("Andrey Panin");
diff --git a/drivers/watchdog/indydog.c b/drivers/watchdog/indydog.c
index 788245bdaa7f..73c9e7992feb 100644
--- a/drivers/watchdog/indydog.c
+++ b/drivers/watchdog/indydog.c
@@ -1,7 +1,8 @@
 /*
  *      IndyDog 0.3     A Hardware Watchdog Device for SGI IP22
  *
- *      (c) Copyright 2002 Guido Guenther <agx@sigxcpu.org>, All Rights Reserved.
+ *      (c) Copyright 2002 Guido Guenther <agx@sigxcpu.org>,
+ *                                              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
@@ -22,32 +23,42 @@
 #include <linux/notifier.h>
 #include <linux/reboot.h>
 #include <linux/init.h>
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 #include <asm/sgi/mc.h>
 
 #define PFX "indydog: "
-static int indydog_alive;
+static unsigned long indydog_alive;
+static spinlock_t indydog_lock;
 
 #define WATCHDOG_TIMEOUT 30             /* 30 sec default timeout */
 
 static int nowayout = WATCHDOG_NOWAYOUT;
 module_param(nowayout, int, 0);
-MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+MODULE_PARM_DESC(nowayout,
+                "Watchdog cannot be stopped once started (default="
+                                __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 
 static void indydog_start(void)
 {
-        u32 mc_ctrl0 = sgimc->cpuctrl0;
+        u32 mc_ctrl0;
 
+        spin_lock(&indydog_lock);
+        mc_ctrl0 = sgimc->cpuctrl0;
         mc_ctrl0 = sgimc->cpuctrl0 | SGIMC_CCTRL0_WDOG;
         sgimc->cpuctrl0 = mc_ctrl0;
+        spin_unlock(&indydog_lock);
 }
 
 static void indydog_stop(void)
 {
-        u32 mc_ctrl0 = sgimc->cpuctrl0;
+        u32 mc_ctrl0;
 
+        spin_lock(&indydog_lock);
+
+        mc_ctrl0 = sgimc->cpuctrl0;
         mc_ctrl0 &= ~SGIMC_CCTRL0_WDOG;
         sgimc->cpuctrl0 = mc_ctrl0;
+        spin_unlock(&indydog_lock);
 
         printk(KERN_INFO PFX "Stopped watchdog timer.\n");
 }
@@ -62,7 +73,7 @@ static void indydog_ping(void)
  */
 static int indydog_open(struct inode *inode, struct file *file)
 {
-        if (indydog_alive)
+        if (test_and_set_bit(0, &indydog_alive))
                 return -EBUSY;
 
         if (nowayout)
@@ -84,23 +95,21 @@ static int indydog_release(struct inode *inode, struct file *file)
          * Lock it in if it's a module and we defined ...NOWAYOUT */
         if (!nowayout)
                 indydog_stop();         /* Turn the WDT off */
-
-        indydog_alive = 0;
-
+        clear_bit(0, &indydog_alive);
         return 0;
 }
 
-static ssize_t indydog_write(struct file *file, const char *data, size_t len, loff_t *ppos)
+static ssize_t indydog_write(struct file *file, const char *data,
+                                                size_t len, loff_t *ppos)
 {
         /* Refresh the timer. */
-        if (len) {
+        if (len)
                 indydog_ping();
-        }
         return len;
 }
 
-static int indydog_ioctl(struct inode *inode, struct file *file,
-        unsigned int cmd, unsigned long arg)
+static long indydog_ioctl(struct file *file, unsigned int cmd,
+                                                        unsigned long arg)
 {
         int options, retval = -EINVAL;
         static struct watchdog_info ident = {
@@ -111,42 +120,40 @@ static int indydog_ioctl(struct inode *inode, struct file *file,
         };
 
         switch (cmd) {
-                default:
-                        return -ENOTTY;
-                case WDIOC_GETSUPPORT:
-                        if (copy_to_user((struct watchdog_info *)arg,
-                                         &ident, sizeof(ident)))
-                                return -EFAULT;
-                        return 0;
-                case WDIOC_GETSTATUS:
-                case WDIOC_GETBOOTSTATUS:
-                        return put_user(0,(int *)arg);
-                case WDIOC_KEEPALIVE:
-                        indydog_ping();
-                        return 0;
-                case WDIOC_GETTIMEOUT:
-                        return put_user(WATCHDOG_TIMEOUT,(int *)arg);
-                case WDIOC_SETOPTIONS:
-                {
-                        if (get_user(options, (int *)arg))
-                                return -EFAULT;
-
-                        if (options & WDIOS_DISABLECARD) {
-                                indydog_stop();
-                                retval = 0;
-                        }
-
-                        if (options & WDIOS_ENABLECARD) {
-                                indydog_start();
-                                retval = 0;
-                        }
-
-                        return retval;
+        case WDIOC_GETSUPPORT:
+                if (copy_to_user((struct watchdog_info *)arg,
+                                 &ident, sizeof(ident)))
+                        return -EFAULT;
+                return 0;
+        case WDIOC_GETSTATUS:
+        case WDIOC_GETBOOTSTATUS:
+                return put_user(0, (int *)arg);
+        case WDIOC_SETOPTIONS:
+        {
+                if (get_user(options, (int *)arg))
+                        return -EFAULT;
+                if (options & WDIOS_DISABLECARD) {
+                        indydog_stop();
+                        retval = 0;
                 }
+                if (options & WDIOS_ENABLECARD) {
+                        indydog_start();
+                        retval = 0;
+                }
+                return retval;
+        }
+        case WDIOC_KEEPALIVE:
+                indydog_ping();
+                return 0;
+        case WDIOC_GETTIMEOUT:
+                return put_user(WATCHDOG_TIMEOUT, (int *)arg);
+        default:
+                return -ENOTTY;
         }
 }
 
-static int indydog_notify_sys(struct notifier_block *this, unsigned long code, void *unused)
+static int indydog_notify_sys(struct notifier_block *this,
+                                        unsigned long code, void *unused)
 {
         if (code == SYS_DOWN || code == SYS_HALT)
                 indydog_stop();         /* Turn the WDT off */
@@ -158,7 +165,7 @@ static const struct file_operations indydog_fops = {
         .owner          = THIS_MODULE,
         .llseek         = no_llseek,
         .write          = indydog_write,
-        .ioctl          = indydog_ioctl,
+        .unlocked_ioctl = indydog_ioctl,
         .open           = indydog_open,
         .release        = indydog_release,
 };
@@ -180,17 +187,20 @@ static int __init watchdog_init(void)
 {
         int ret;
 
+        spin_lock_init(&indydog_lock);
+
         ret = register_reboot_notifier(&indydog_notifier);
         if (ret) {
-                printk(KERN_ERR PFX "cannot register reboot notifier (err=%d)\n",
-                        ret);
+                printk(KERN_ERR PFX
+                        "cannot register reboot notifier (err=%d)\n", ret);
                 return ret;
         }
 
         ret = misc_register(&indydog_miscdev);
         if (ret) {
-                printk(KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",
-                        WATCHDOG_MINOR, ret);
+                printk(KERN_ERR PFX
+                        "cannot register miscdev on minor=%d (err=%d)\n",
+                                                        WATCHDOG_MINOR, ret);
                 unregister_reboot_notifier(&indydog_notifier);
                 return ret;
         }
diff --git a/drivers/watchdog/iop_wdt.c b/drivers/watchdog/iop_wdt.c
index bbbd91af754d..8278b13f77c7 100644
--- a/drivers/watchdog/iop_wdt.c
+++ b/drivers/watchdog/iop_wdt.c
@@ -37,6 +37,7 @@
 static int nowayout = WATCHDOG_NOWAYOUT;
 static unsigned long wdt_status;
 static unsigned long boot_status;
+static spinlock_t wdt_lock;
 
 #define WDT_IN_USE              0
 #define WDT_OK_TO_CLOSE         1
@@ -68,8 +69,10 @@ static void wdt_enable(void)
         /* Arm and enable the Timer to starting counting down from 0xFFFF.FFFF
          * Takes approx. 10.7s to timeout
          */
+        spin_lock(&wdt_lock);
         write_wdtcr(IOP_WDTCR_EN_ARM);
         write_wdtcr(IOP_WDTCR_EN);
+        spin_unlock(&wdt_lock);
 }
 
 /* returns 0 if the timer was successfully disabled */
@@ -77,9 +80,11 @@ static int wdt_disable(void)
 {
         /* Stop Counting */
         if (wdt_supports_disable()) {
+                spin_lock(&wdt_lock);
                 write_wdtcr(IOP_WDTCR_DIS_ARM);
                 write_wdtcr(IOP_WDTCR_DIS);
                 clear_bit(WDT_ENABLED, &wdt_status);
+                spin_unlock(&wdt_lock);
                 printk(KERN_INFO "WATCHDOG: Disabled\n");
                 return 0;
         } else
@@ -92,16 +97,12 @@ static int iop_wdt_open(struct inode *inode, struct file *file)
                 return -EBUSY;
 
         clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
-
         wdt_enable();
-
         set_bit(WDT_ENABLED, &wdt_status);
-
         return nonseekable_open(inode, file);
 }
 
-static ssize_t
-iop_wdt_write(struct file *file, const char *data, size_t len,
+static ssize_t iop_wdt_write(struct file *file, const char *data, size_t len,
                   loff_t *ppos)
 {
         if (len) {
@@ -121,46 +122,35 @@ iop_wdt_write(struct file *file, const char *data, size_t len,
                 }
                 wdt_enable();
         }
-
         return len;
 }
 
-static struct watchdog_info ident = {
+static const struct watchdog_info ident = {
         .options = WDIOF_CARDRESET | WDIOF_MAGICCLOSE | WDIOF_KEEPALIVEPING,
         .identity = "iop watchdog",
 };
 
-static int
-iop_wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
-                  unsigned long arg)
+static long iop_wdt_ioctl(struct file *file,
+                                unsigned int cmd, unsigned long arg)
 {
         int options;
         int ret = -ENOTTY;
+        int __user *argp = (int __user *)arg;
 
         switch (cmd) {
         case WDIOC_GETSUPPORT:
-                if (copy_to_user
-                    ((struct watchdog_info *)arg, &ident, sizeof ident))
+                if (copy_to_user(argp, &ident, sizeof ident))
                         ret = -EFAULT;
                 else
                         ret = 0;
                 break;
 
         case WDIOC_GETSTATUS:
-                ret = put_user(0, (int *)arg);
+                ret = put_user(0, argp);
                 break;
 
         case WDIOC_GETBOOTSTATUS:
-                ret = put_user(boot_status, (int *)arg);
-                break;
-
-        case WDIOC_GETTIMEOUT:
-                ret = put_user(iop_watchdog_timeout(), (int *)arg);
-                break;
-
-        case WDIOC_KEEPALIVE:
-                wdt_enable();
-                ret = 0;
+                ret = put_user(boot_status, argp);
                 break;
 
         case WDIOC_SETOPTIONS:
@@ -177,14 +167,21 @@ iop_wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
                         } else
                                 ret = 0;
                 }
-
                 if (options & WDIOS_ENABLECARD) {
                         wdt_enable();
                         ret = 0;
                 }
                 break;
-        }
 
+        case WDIOC_KEEPALIVE:
+                wdt_enable();
+                ret = 0;
+                break;
+
+        case WDIOC_GETTIMEOUT:
+                ret = put_user(iop_watchdog_timeout(), argp);
+                break;
+        }
         return ret;
 }
 
@@ -214,7 +211,7 @@ static const struct file_operations iop_wdt_fops = {
         .owner = THIS_MODULE,
         .llseek = no_llseek,
         .write = iop_wdt_write,
-        .ioctl = iop_wdt_ioctl,
+        .unlocked_ioctl = iop_wdt_ioctl,
         .open = iop_wdt_open,
         .release = iop_wdt_release,
 };
@@ -229,10 +226,8 @@ static int __init iop_wdt_init(void)
 {
         int ret;
 
-        ret = misc_register(&iop_wdt_miscdev);
-        if (ret == 0)
-                printk("iop watchdog timer: timeout %lu sec\n",
-                       iop_watchdog_timeout());
+        spin_lock_init(&wdt_lock);
+
 
         /* check if the reset was caused by the watchdog timer */
         boot_status = (read_rcsr() & IOP_RCSR_WDT) ? WDIOF_CARDRESET : 0;
@@ -242,6 +237,13 @@ static int __init iop_wdt_init(void)
          */
         write_wdtsr(IOP13XX_WDTCR_IB_RESET);
 
+        /* Register after we have the device set up so we cannot race
+           with an open */
+        ret = misc_register(&iop_wdt_miscdev);
+        if (ret == 0)
+                printk(KERN_INFO "iop watchdog timer: timeout %lu sec\n",
+                       iop_watchdog_timeout());
+
         return ret;
 }
 
diff --git a/drivers/watchdog/it8712f_wdt.c b/drivers/watchdog/it8712f_wdt.c
index 51bfd5721833..2270ee07c01b 100644
--- a/drivers/watchdog/it8712f_wdt.c
+++ b/drivers/watchdog/it8712f_wdt.c
@@ -221,7 +221,7 @@ static ssize_t it8712f_wdt_write(struct file *file, const char __user *data,
                 expect_close = 0;
                 for (i = 0; i < len; ++i) {
                         char c;
-                        if (get_user(c, data+i))
+                        if (get_user(c, data + i))
                                 return -EFAULT;
                         if (c == 'V')
                                 expect_close = 42;
@@ -244,8 +244,6 @@ static long it8712f_wdt_ioctl(struct file *file, unsigned int cmd,
         int value;
 
         switch (cmd) {
-        default:
-                return -ENOTTY;
         case WDIOC_GETSUPPORT:
                 if (copy_to_user(argp, &ident, sizeof(ident)))
                         return -EFAULT;
@@ -284,6 +282,8 @@ static long it8712f_wdt_ioctl(struct file *file, unsigned int cmd,
                 if (put_user(margin, p))
                         return -EFAULT;
                 return 0;
+        default:
+                return -ENOTTY;
         }
 }
 
diff --git a/drivers/watchdog/ixp2000_wdt.c b/drivers/watchdog/ixp2000_wdt.c
index dc7548dcaf35..a77f69d52877 100644
--- a/drivers/watchdog/ixp2000_wdt.c
+++ b/drivers/watchdog/ixp2000_wdt.c
@@ -25,42 +25,45 @@
 #include <linux/watchdog.h>
 #include <linux/init.h>
 #include <linux/bitops.h>
+#include <linux/uaccess.h>
 
 #include <asm/hardware.h>
-#include <asm/uaccess.h>
 
 static int nowayout = WATCHDOG_NOWAYOUT;
 static unsigned int heartbeat = 60;     /* (secs) Default is 1 minute */
 static unsigned long wdt_status;
+static spinlock_t wdt_lock;
 
 #define WDT_IN_USE              0
 #define WDT_OK_TO_CLOSE         1
 
 static unsigned long wdt_tick_rate;
 
-static void
-wdt_enable(void)
+static void wdt_enable(void)
 {
+        spin_lock(&wdt_lock);
         ixp2000_reg_write(IXP2000_RESET0, *(IXP2000_RESET0) | WDT_RESET_ENABLE);
         ixp2000_reg_write(IXP2000_TWDE, WDT_ENABLE);
         ixp2000_reg_write(IXP2000_T4_CLD, heartbeat * wdt_tick_rate);
         ixp2000_reg_write(IXP2000_T4_CTL, TIMER_DIVIDER_256 | TIMER_ENABLE);
+        spin_unlock(&wdt_lock);
 }
 
-static void
-wdt_disable(void)
+static void wdt_disable(void)
 {
+        spin_lock(&wdt_lock);
         ixp2000_reg_write(IXP2000_T4_CTL, 0);
+        spin_unlock(&wdt_lock);
 }
 
-static void
-wdt_keepalive(void)
+static void wdt_keepalive(void)
 {
+        spin_lock(&wdt_lock);
         ixp2000_reg_write(IXP2000_T4_CLD, heartbeat * wdt_tick_rate);
+        spin_unlock(&wdt_lock);
 }
 
-static int
-ixp2000_wdt_open(struct inode *inode, struct file *file)
+static int ixp2000_wdt_open(struct inode *inode, struct file *file)
 {
         if (test_and_set_bit(WDT_IN_USE, &wdt_status))
                 return -EBUSY;
@@ -72,8 +75,8 @@ ixp2000_wdt_open(struct inode *inode, struct file *file)
         return nonseekable_open(inode, file);
 }
 
-static ssize_t
-ixp2000_wdt_write(struct file *file, const char *data, size_t len, loff_t *ppos)
+static ssize_t ixp2000_wdt_write(struct file *file, const char *data,
+                                                size_t len, loff_t *ppos)
 {
         if (len) {
                 if (!nowayout) {
@@ -103,9 +106,8 @@ static struct watchdog_info ident = {
         .identity       = "IXP2000 Watchdog",
 };
 
-static int
-ixp2000_wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
-                        unsigned long arg)
+static long ixp2000_wdt_ioctl(struct file *file, unsigned int cmd,
+                                                        unsigned long arg)
 {
         int ret = -ENOTTY;
         int time;
@@ -124,6 +126,11 @@ ixp2000_wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
                 ret = put_user(0, (int *)arg);
                 break;
 
+        case WDIOC_KEEPALIVE:
+                wdt_enable();
+                ret = 0;
+                break;
+
         case WDIOC_SETTIMEOUT:
                 ret = get_user(time, (int *)arg);
                 if (ret)
@@ -141,26 +148,18 @@ ixp2000_wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
         case WDIOC_GETTIMEOUT:
                 ret = put_user(heartbeat, (int *)arg);
                 break;
-
-        case WDIOC_KEEPALIVE:
-                wdt_enable();
-                ret = 0;
-                break;
         }
 
         return ret;
 }
 
-static int
-ixp2000_wdt_release(struct inode *inode, struct file *file)
+static int ixp2000_wdt_release(struct inode *inode, struct file *file)
 {
-        if (test_bit(WDT_OK_TO_CLOSE, &wdt_status)) {
+        if (test_bit(WDT_OK_TO_CLOSE, &wdt_status))
                 wdt_disable();
-        } else {
+        else
                 printk(KERN_CRIT "WATCHDOG: Device closed unexpectedly - "
                                         "timer will not stop\n");
-        }
-
         clear_bit(WDT_IN_USE, &wdt_status);
         clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
 
@@ -168,18 +167,16 @@ ixp2000_wdt_release(struct inode *inode, struct file *file)
 }
 
 
-static const struct file_operations ixp2000_wdt_fops =
-{
+static const struct file_operations ixp2000_wdt_fops = {
         .owner          = THIS_MODULE,
         .llseek         = no_llseek,
         .write          = ixp2000_wdt_write,
-        .ioctl          = ixp2000_wdt_ioctl,
+        .unlocked_ioctl = ixp2000_wdt_ioctl,
         .open           = ixp2000_wdt_open,
         .release        = ixp2000_wdt_release,
 };
 
-static struct miscdevice ixp2000_wdt_miscdev =
-{
+static struct miscdevice ixp2000_wdt_miscdev = {
         .minor          = WATCHDOG_MINOR,
         .name           = "watchdog",
         .fops           = &ixp2000_wdt_fops,
@@ -191,9 +188,8 @@ static int __init ixp2000_wdt_init(void)
                 printk(KERN_INFO "Unable to use IXP2000 watchdog due to IXP2800 erratum #25.\n");
                 return -EIO;
         }
-
         wdt_tick_rate = (*IXP2000_T1_CLD * HZ) / 256;
-
+        spin_lock_init(&wdt_lock);
         return misc_register(&ixp2000_wdt_miscdev);
 }
 
diff --git a/drivers/watchdog/ixp4xx_wdt.c b/drivers/watchdog/ixp4xx_wdt.c
index 5864bb865cfe..ef3157dc9ac1 100644
--- a/drivers/watchdog/ixp4xx_wdt.c
+++ b/drivers/watchdog/ixp4xx_wdt.c
@@ -22,48 +22,48 @@
 #include <linux/watchdog.h>
 #include <linux/init.h>
 #include <linux/bitops.h>
+#include <linux/uaccess.h>
 
 #include <asm/hardware.h>
-#include <asm/uaccess.h>
 
 static int nowayout = WATCHDOG_NOWAYOUT;
 static int heartbeat = 60;      /* (secs) Default is 1 minute */
 static unsigned long wdt_status;
 static unsigned long boot_status;
+static spin_lock_t wdt_lock;
 
 #define WDT_TICK_RATE (IXP4XX_PERIPHERAL_BUS_CLOCK * 1000000UL)
 
 #define WDT_IN_USE              0
 #define WDT_OK_TO_CLOSE         1
 
-static void
-wdt_enable(void)
+static void wdt_enable(void)
 {
+        spin_lock(&wdt_lock);
         *IXP4XX_OSWK = IXP4XX_WDT_KEY;
         *IXP4XX_OSWE = 0;
         *IXP4XX_OSWT = WDT_TICK_RATE * heartbeat;
         *IXP4XX_OSWE = IXP4XX_WDT_COUNT_ENABLE | IXP4XX_WDT_RESET_ENABLE;
         *IXP4XX_OSWK = 0;
+        spin_unlock(&wdt_lock);
 }
 
-static void
-wdt_disable(void)
+static void wdt_disable(void)
 {
+        spin_lock(&wdt_lock);
         *IXP4XX_OSWK = IXP4XX_WDT_KEY;
         *IXP4XX_OSWE = 0;
         *IXP4XX_OSWK = 0;
+        spin_unlock(&wdt_lock);
 }
 
-static int
-ixp4xx_wdt_open(struct inode *inode, struct file *file)
+static int ixp4xx_wdt_open(struct inode *inode, struct file *file)
 {
         if (test_and_set_bit(WDT_IN_USE, &wdt_status))
                 return -EBUSY;
 
         clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
-
         wdt_enable();
-
         return nonseekable_open(inode, file);
 }
 
@@ -87,7 +87,6 @@ ixp4xx_wdt_write(struct file *file, const char *data, size_t len, loff_t *ppos)
                 }
                 wdt_enable();
         }
-
         return len;
 }
 
@@ -98,9 +97,8 @@ static struct watchdog_info ident = {
 };
 
 
-static int
-ixp4xx_wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
-                        unsigned long arg)
+static long ixp4xx_wdt_ioctl(struct file *file, unsigned int cmd,
+                                                        unsigned long arg)
 {
         int ret = -ENOTTY;
         int time;
@@ -119,6 +117,11 @@ ixp4xx_wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
                 ret = put_user(boot_status, (int *)arg);
                 break;
 
+        case WDIOC_KEEPALIVE:
+                wdt_enable();
+                ret = 0;
+                break;
+
         case WDIOC_SETTIMEOUT:
                 ret = get_user(time, (int *)arg);
                 if (ret)
@@ -136,25 +139,17 @@ ixp4xx_wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
         case WDIOC_GETTIMEOUT:
                 ret = put_user(heartbeat, (int *)arg);
                 break;
-
-        case WDIOC_KEEPALIVE:
-                wdt_enable();
-                ret = 0;
-                break;
         }
         return ret;
 }
 
-static int
-ixp4xx_wdt_release(struct inode *inode, struct file *file)
+static int ixp4xx_wdt_release(struct inode *inode, struct file *file)
 {
-        if (test_bit(WDT_OK_TO_CLOSE, &wdt_status)) {
+        if (test_bit(WDT_OK_TO_CLOSE, &wdt_status))
                 wdt_disable();
-        } else {
+        else
                 printk(KERN_CRIT "WATCHDOG: Device closed unexpectedly - "
                                         "timer will not stop\n");
-        }
-
         clear_bit(WDT_IN_USE, &wdt_status);
         clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
 
@@ -162,18 +157,16 @@ ixp4xx_wdt_release(struct inode *inode, struct file *file)
 }
 
 
-static const struct file_operations ixp4xx_wdt_fops =
-{
+static const struct file_operations ixp4xx_wdt_fops = {
         .owner          = THIS_MODULE,
         .llseek         = no_llseek,
         .write          = ixp4xx_wdt_write,
-        .ioctl          = ixp4xx_wdt_ioctl,
+        .unlocked_ioctl = ixp4xx_wdt_ioctl,
         .open           = ixp4xx_wdt_open,
         .release        = ixp4xx_wdt_release,
 };
 
-static struct miscdevice ixp4xx_wdt_miscdev =
-{
+static struct miscdevice ixp4xx_wdt_miscdev = {
         .minor          = WATCHDOG_MINOR,
         .name           = "watchdog",
         .fops           = &ixp4xx_wdt_fops,
@@ -186,19 +179,18 @@ static int __init ixp4xx_wdt_init(void)
 
         asm("mrc p15, 0, %0, cr0, cr0, 0;" : "=r"(processor_id) :);
         if (!(processor_id & 0xf) && !cpu_is_ixp46x()) {
-                printk("IXP4XXX Watchdog: Rev. A0 IXP42x CPU detected - "
-                        "watchdog disabled\n");
+                printk(KERN_ERR "IXP4XXX Watchdog: Rev. A0 IXP42x CPU detected"
+                        " - watchdog disabled\n");
 
                 return -ENODEV;
         }
-
-        ret = misc_register(&ixp4xx_wdt_miscdev);
-        if (ret == 0)
-                printk("IXP4xx Watchdog Timer: heartbeat %d sec\n", heartbeat);
-
+        spin_lock_init(&wdt_lock);
         boot_status = (*IXP4XX_OSST & IXP4XX_OSST_TIMER_WARM_RESET) ?
                         WDIOF_CARDRESET : 0;
-
+        ret = misc_register(&ixp4xx_wdt_miscdev);
+        if (ret == 0)
+                printk(KERN_INFO "IXP4xx Watchdog Timer: heartbeat %d sec\n",
+                        heartbeat);
         return ret;
 }
 
diff --git a/drivers/watchdog/ks8695_wdt.c b/drivers/watchdog/ks8695_wdt.c
index df5a6b811ccd..f8566d5c62fe 100644
--- a/drivers/watchdog/ks8695_wdt.c
+++ b/drivers/watchdog/ks8695_wdt.c
@@ -19,8 +19,8 @@
 #include <linux/platform_device.h>
 #include <linux/types.h>
 #include <linux/watchdog.h>
-#include <asm/io.h>
-#include <asm/uaccess.h>
+#include <linux/io.h>
+#include <linux/uaccess.h>
 #include <asm/arch/regs-timer.h>
 
 
@@ -31,38 +31,44 @@ static int wdt_time = WDT_DEFAULT_TIME;
 static int nowayout = WATCHDOG_NOWAYOUT;
 
 module_param(wdt_time, int, 0);
-MODULE_PARM_DESC(wdt_time, "Watchdog time in seconds. (default="__MODULE_STRING(WDT_DEFAULT_TIME) ")");
+MODULE_PARM_DESC(wdt_time, "Watchdog time in seconds. (default="
+                                        __MODULE_STRING(WDT_DEFAULT_TIME) ")");
 
 #ifdef CONFIG_WATCHDOG_NOWAYOUT
 module_param(nowayout, int, 0);
-MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default="
+                                __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 #endif
 
 
 static unsigned long ks8695wdt_busy;
+static spinlock_t ks8695_lock;
 
 /* ......................................................................... */
 
 /*
  * Disable the watchdog.
  */
-static void inline ks8695_wdt_stop(void)
+static inline void ks8695_wdt_stop(void)
 {
         unsigned long tmcon;
 
+        spin_lock(&ks8695_lock);
         /* disable timer0 */
         tmcon = __raw_readl(KS8695_TMR_VA + KS8695_TMCON);
         __raw_writel(tmcon & ~TMCON_T0EN, KS8695_TMR_VA + KS8695_TMCON);
+        spin_unlock(&ks8695_lock);
 }
 
 /*
  * Enable and reset the watchdog.
  */
-static void inline ks8695_wdt_start(void)
+static inline void ks8695_wdt_start(void)
 {
         unsigned long tmcon;
         unsigned long tval = wdt_time * CLOCK_TICK_RATE;
 
+        spin_lock(&ks8695_lock);
         /* disable timer0 */
         tmcon = __raw_readl(KS8695_TMR_VA + KS8695_TMCON);
         __raw_writel(tmcon & ~TMCON_T0EN, KS8695_TMR_VA + KS8695_TMCON);
@@ -73,19 +79,22 @@ static void inline ks8695_wdt_start(void)
         /* re-enable timer0 */
         tmcon = __raw_readl(KS8695_TMR_VA + KS8695_TMCON);
         __raw_writel(tmcon | TMCON_T0EN, KS8695_TMR_VA + KS8695_TMCON);
+        spin_unlock(&ks8695_lock);
 }
 
 /*
  * Reload the watchdog timer.  (ie, pat the watchdog)
  */
-static void inline ks8695_wdt_reload(void)
+static inline void ks8695_wdt_reload(void)
 {
         unsigned long tmcon;
 
+        spin_lock(&ks8695_lock);
         /* disable, then re-enable timer0 */
         tmcon = __raw_readl(KS8695_TMR_VA + KS8695_TMCON);
         __raw_writel(tmcon & ~TMCON_T0EN, KS8695_TMR_VA + KS8695_TMCON);
         __raw_writel(tmcon | TMCON_T0EN, KS8695_TMR_VA + KS8695_TMCON);
+        spin_unlock(&ks8695_lock);
 }
 
 /*
@@ -102,7 +111,8 @@ static int ks8695_wdt_settimeout(int new_time)
         if ((new_time <= 0) || (new_time > WDT_MAX_TIME))
                 return -EINVAL;
 
-        /* Set new watchdog time. It will be used when ks8695_wdt_start() is called. */
+        /* Set new watchdog time. It will be used when
+           ks8695_wdt_start() is called. */
         wdt_time = new_time;
         return 0;
 }
@@ -128,9 +138,9 @@ static int ks8695_wdt_open(struct inode *inode, struct file *file)
  */
 static int ks8695_wdt_close(struct inode *inode, struct file *file)
 {
+        /* Disable the watchdog when file is closed */
         if (!nowayout)
-                ks8695_wdt_stop();      /* Disable the watchdog when file is closed */
-
+                ks8695_wdt_stop();
         clear_bit(0, &ks8695wdt_busy);
         return 0;
 }
@@ -143,60 +153,52 @@ static struct watchdog_info ks8695_wdt_info = {
 /*
  * Handle commands from user-space.
  */
-static int ks8695_wdt_ioctl(struct inode *inode, struct file *file,
-                unsigned int cmd, unsigned long arg)
+static long ks8695_wdt_ioctl(struct file *file, unsigned int cmd,
+                                                        unsigned long arg)
 {
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
         int new_value;
 
-        switch(cmd) {
-                case WDIOC_KEEPALIVE:
-                        ks8695_wdt_reload();    /* pat the watchdog */
-                        return 0;
-
-                case WDIOC_GETSUPPORT:
-                        return copy_to_user(argp, &ks8695_wdt_info, sizeof(ks8695_wdt_info)) ? -EFAULT : 0;
-
-                case WDIOC_SETTIMEOUT:
-                        if (get_user(new_value, p))
-                                return -EFAULT;
-
-                        if (ks8695_wdt_settimeout(new_value))
-                                return -EINVAL;
-
-                        /* Enable new time value */
+        switch (cmd) {
+        case WDIOC_GETSUPPORT:
+                return copy_to_user(argp, &ks8695_wdt_info,
+                                        sizeof(ks8695_wdt_info)) ? -EFAULT : 0;
+        case WDIOC_GETSTATUS:
+        case WDIOC_GETBOOTSTATUS:
+                return put_user(0, p);
+        case WDIOC_SETOPTIONS:
+                if (get_user(new_value, p))
+                        return -EFAULT;
+                if (new_value & WDIOS_DISABLECARD)
+                        ks8695_wdt_stop();
+                if (new_value & WDIOS_ENABLECARD)
                         ks8695_wdt_start();
-
-                        /* Return current value */
-                        return put_user(wdt_time, p);
-
-                case WDIOC_GETTIMEOUT:
-                        return put_user(wdt_time, p);
-
-                case WDIOC_GETSTATUS:
-                case WDIOC_GETBOOTSTATUS:
-                        return put_user(0, p);
-
-                case WDIOC_SETOPTIONS:
-                        if (get_user(new_value, p))
-                                return -EFAULT;
-
-                        if (new_value & WDIOS_DISABLECARD)
-                                ks8695_wdt_stop();
-                        if (new_value & WDIOS_ENABLECARD)
-                                ks8695_wdt_start();
-                        return 0;
-
-                default:
-                        return -ENOTTY;
+                return 0;
+        case WDIOC_KEEPALIVE:
+                ks8695_wdt_reload();    /* pat the watchdog */
+                return 0;
+        case WDIOC_SETTIMEOUT:
+                if (get_user(new_value, p))
+                        return -EFAULT;
+                if (ks8695_wdt_settimeout(new_value))
+                        return -EINVAL;
+                /* Enable new time value */
+                ks8695_wdt_start();
+                /* Return current value */
+                return put_user(wdt_time, p);
+        case WDIOC_GETTIMEOUT:
+                return put_user(wdt_time, p);
+        default:
+                return -ENOTTY;
         }
 }
 
 /*
  * Pat the watchdog whenever device is written to.
  */
-static ssize_t ks8695_wdt_write(struct file *file, const char *data, size_t len, loff_t *ppos)
+static ssize_t ks8695_wdt_write(struct file *file, const char *data,
+                                                size_t len, loff_t *ppos)
 {
         ks8695_wdt_reload();            /* pat the watchdog */
         return len;
@@ -207,7 +209,7 @@ static ssize_t ks8695_wdt_write(struct file *file, const char *data, size_t len,
 static const struct file_operations ks8695wdt_fops = {
         .owner          = THIS_MODULE,
         .llseek         = no_llseek,
-        .ioctl          = ks8695_wdt_ioctl,
+        .unlocked_ioctl = ks8695_wdt_ioctl,
         .open           = ks8695_wdt_open,
         .release        = ks8695_wdt_close,
         .write          = ks8695_wdt_write,
@@ -231,7 +233,8 @@ static int __init ks8695wdt_probe(struct platform_device *pdev)
         if (res)
                 return res;
 
-        printk("KS8695 Watchdog Timer enabled (%d seconds%s)\n", wdt_time, nowayout ? ", nowayout" : "");
+        printk(KERN_INFO "KS8695 Watchdog Timer enabled (%d seconds%s)\n",
+                                wdt_time, nowayout ? ", nowayout" : "");
         return 0;
 }
 
@@ -285,12 +288,14 @@ static struct platform_driver ks8695wdt_driver = {
 
 static int __init ks8695_wdt_init(void)
 {
-        /* Check that the heartbeat value is within range; if not reset to the default */
+        spin_lock_init(&ks8695_lock);
+        /* Check that the heartbeat value is within range;
+           if not reset to the default */
         if (ks8695_wdt_settimeout(wdt_time)) {
                 ks8695_wdt_settimeout(WDT_DEFAULT_TIME);
-                pr_info("ks8695_wdt: wdt_time value must be 1 <= wdt_time <= %i, using %d\n", wdt_time, WDT_MAX_TIME);
+                pr_info("ks8695_wdt: wdt_time value must be 1 <= wdt_time <= %i, using %d\n",
+                                                        wdt_time, WDT_MAX_TIME);
         }
-
         return platform_driver_register(&ks8695wdt_driver);
 }
 
diff --git a/drivers/watchdog/machzwd.c b/drivers/watchdog/machzwd.c
index 6905135a776c..2dfc27559bf7 100644
--- a/drivers/watchdog/machzwd.c
+++ b/drivers/watchdog/machzwd.c
@@ -40,9 +40,9 @@
 #include <linux/notifier.h>
 #include <linux/reboot.h>
 #include <linux/init.h>
+#include <linux/io.h>
+#include <linux/uaccess.h>
 
-#include <asm/io.h>
-#include <asm/uaccess.h>
 #include <asm/system.h>
 
 /* ports */
@@ -95,7 +95,9 @@ MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 
 static int nowayout = WATCHDOG_NOWAYOUT;
 module_param(nowayout, int, 0);
-MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+MODULE_PARM_DESC(nowayout,
+                "Watchdog cannot be stopped once started (default="
+                                __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 
 #define PFX "machzwd"
 
@@ -114,7 +116,7 @@ static struct watchdog_info zf_info = {
  * 3 = GEN_SCI
  * defaults to GEN_RESET (0)
  */
-static int action = 0;
+static int action;
 module_param(action, int, 0);
 MODULE_PARM_DESC(action, "after watchdog resets, generate: 0 = RESET(*)  1 = SMI  2 = NMI  3 = SCI");
 
@@ -123,10 +125,9 @@ static void zf_ping(unsigned long data);
 static int zf_action = GEN_RESET;
 static unsigned long zf_is_open;
 static char zf_expect_close;
-static DEFINE_SPINLOCK(zf_lock);
 static DEFINE_SPINLOCK(zf_port_lock);
 static DEFINE_TIMER(zf_timer, zf_ping, 0, 0);
-static unsigned long next_heartbeat = 0;
+static unsigned long next_heartbeat;
 
 
 /* timeout for user land heart beat (10 seconds) */
@@ -171,13 +172,13 @@ static inline void zf_set_control(unsigned short new)
 
 static inline void zf_set_timer(unsigned short new, unsigned char n)
 {
-        switch(n){
-                case WD1:
-                        zf_writew(COUNTER_1, new);
-                case WD2:
-                        zf_writeb(COUNTER_2, new > 0xff ? 0xff : new);
-                default:
-                        return;
+        switch (n) {
+        case WD1:
+                zf_writew(COUNTER_1, new);
+        case WD2:
+                zf_writeb(COUNTER_2, new > 0xff ? 0xff : new);
+        default:
+                return;
         }
 }
 
@@ -241,10 +242,8 @@ static void zf_ping(unsigned long data)
 
         zf_writeb(COUNTER_2, 0xff);
 
-        if(time_before(jiffies, next_heartbeat)){
-
+        if (time_before(jiffies, next_heartbeat)) {
                 dprintk("time_before: %ld\n", next_heartbeat - jiffies);
-
                 /*
                  * reset event is activated by transition from 0 to 1 on
                  * RESET_WD1 bit and we assume that it is already zero...
@@ -261,24 +260,21 @@ static void zf_ping(unsigned long data)
                 spin_unlock_irqrestore(&zf_port_lock, flags);
 
                 mod_timer(&zf_timer, jiffies + ZF_HW_TIMEO);
-        }else{
+        } else
                 printk(KERN_CRIT PFX ": I will reset your machine\n");
-        }
 }
 
 static ssize_t zf_write(struct file *file, const char __user *buf, size_t count,
                                                                 loff_t *ppos)
 {
         /* See if we got the magic character */
-        if(count){
-
+        if (count) {
                 /*
                  * no need to check for close confirmation
                  * no way to disable watchdog ;)
                  */
                 if (!nowayout) {
                         size_t ofs;
-
                         /*
                          * note: just in case someone wrote the magic character
                          * five months ago...
@@ -286,11 +282,11 @@ static ssize_t zf_write(struct file *file, const char __user *buf, size_t count,
                         zf_expect_close = 0;
 
                         /* now scan */
-                        for (ofs = 0; ofs != count; ofs++){
+                        for (ofs = 0; ofs != count; ofs++) {
                                 char c;
                                 if (get_user(c, buf + ofs))
                                         return -EFAULT;
-                                if (c == 'V'){
+                                if (c == 'V') {
                                         zf_expect_close = 42;
                                         dprintk("zf_expect_close = 42\n");
                                 }
@@ -303,14 +299,11 @@ static ssize_t zf_write(struct file *file, const char __user *buf, size_t count,
                  */
                 next_heartbeat = jiffies + ZF_USER_TIMEO;
                 dprintk("user ping at %ld\n", jiffies);
-
         }
-
         return count;
 }
 
-static int zf_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
-        unsigned long arg)
+static long zf_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
@@ -319,55 +312,38 @@ static int zf_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
                 if (copy_to_user(argp, &zf_info, sizeof(zf_info)))
                         return -EFAULT;
                 break;
-
         case WDIOC_GETSTATUS:
         case WDIOC_GETBOOTSTATUS:
                 return put_user(0, p);
-
         case WDIOC_KEEPALIVE:
                 zf_ping(0);
                 break;
-
         default:
                 return -ENOTTY;
         }
-
         return 0;
 }
 
 static int zf_open(struct inode *inode, struct file *file)
 {
-        spin_lock(&zf_lock);
-        if(test_and_set_bit(0, &zf_is_open)) {
-                spin_unlock(&zf_lock);
+        if (test_and_set_bit(0, &zf_is_open))
                 return -EBUSY;
-        }
-
         if (nowayout)
                 __module_get(THIS_MODULE);
-
-        spin_unlock(&zf_lock);
-
         zf_timer_on();
-
         return nonseekable_open(inode, file);
 }
 
 static int zf_close(struct inode *inode, struct file *file)
 {
-        if(zf_expect_close == 42){
+        if (zf_expect_close == 42)
                 zf_timer_off();
-        } else {
+        else {
                 del_timer(&zf_timer);
                 printk(KERN_ERR PFX ": device file closed unexpectedly. Will not stop the WDT!\n");
         }
-
-        spin_lock(&zf_lock);
         clear_bit(0, &zf_is_open);
-        spin_unlock(&zf_lock);
-
         zf_expect_close = 0;
-
         return 0;
 }
 
@@ -378,23 +354,18 @@ static int zf_close(struct inode *inode, struct file *file)
 static int zf_notify_sys(struct notifier_block *this, unsigned long code,
                                                                 void *unused)
 {
-        if(code == SYS_DOWN || code == SYS_HALT){
+        if (code == SYS_DOWN || code == SYS_HALT)
                 zf_timer_off();
-        }
-
         return NOTIFY_DONE;
 }
 
-
-
-
 static const struct file_operations zf_fops = {
-        .owner          = THIS_MODULE,
-        .llseek         = no_llseek,
-        .write          = zf_write,
-        .ioctl          = zf_ioctl,
-        .open           = zf_open,
-        .release        = zf_close,
+        .owner          = THIS_MODULE,
+        .llseek         = no_llseek,
+        .write          = zf_write,
+        .unlocked_ioctl = zf_ioctl,
+        .open           = zf_open,
+        .release        = zf_close,
 };
 
 static struct miscdevice zf_miscdev = {
@@ -402,7 +373,7 @@ static struct miscdevice zf_miscdev = {
         .name = "watchdog",
         .fops = &zf_fops,
 };
- 
+
 
 /*
  * The device needs to learn about soft shutdowns in order to
@@ -423,22 +394,23 @@ static int __init zf_init(void)
 {
         int ret;
 
-        printk(KERN_INFO PFX ": MachZ ZF-Logic Watchdog driver initializing.\n");
+        printk(KERN_INFO PFX
+                ": MachZ ZF-Logic Watchdog driver initializing.\n");
 
         ret = zf_get_ZFL_version();
-        if ((!ret) || (ret == 0xffff)) {
+        if (!ret || ret == 0xffff) {
                 printk(KERN_WARNING PFX ": no ZF-Logic found\n");
                 return -ENODEV;
         }
 
-        if((action <= 3) && (action >= 0)){
-                zf_action = zf_action>>action;
-        } else
+        if (action <= 3 && action >= 0)
+                zf_action = zf_action >> action;
+        else
                 action = 0;
 
         zf_show_action(action);
 
-        if(!request_region(ZF_IOBASE, 3, "MachZ ZFL WDT")){
+        if (!request_region(ZF_IOBASE, 3, "MachZ ZFL WDT")) {
                 printk(KERN_ERR "cannot reserve I/O ports at %d\n",
                                                         ZF_IOBASE);
                 ret = -EBUSY;
@@ -446,14 +418,14 @@ static int __init zf_init(void)
         }
 
         ret = register_reboot_notifier(&zf_notifier);
-        if(ret){
+        if (ret) {
                 printk(KERN_ERR "can't register reboot notifier (err=%d)\n",
                                                                         ret);
                 goto no_reboot;
         }
 
         ret = misc_register(&zf_miscdev);
-        if (ret){
+        if (ret) {
                 printk(KERN_ERR "can't misc_register on minor=%d\n",
                                                         WATCHDOG_MINOR);
                 goto no_misc;
diff --git a/drivers/watchdog/mixcomwd.c b/drivers/watchdog/mixcomwd.c
index 1adf1d56027d..407b025cb104 100644
--- a/drivers/watchdog/mixcomwd.c
+++ b/drivers/watchdog/mixcomwd.c
@@ -29,7 +29,8 @@
  *              - support for one more type board
  *
  * Version 0.5 (2001/12/14) Matt Domsch <Matt_Domsch@dell.com>
- *              - added nowayout module option to override CONFIG_WATCHDOG_NOWAYOUT
+ *              - added nowayout module option to override
+ *                CONFIG_WATCHDOG_NOWAYOUT
  *
  * Version 0.6 (2002/04/12): Rob Radez <rob@osinvestor.com>
  *              - make mixcomwd_opened unsigned,
@@ -53,8 +54,8 @@
 #include <linux/init.h>
 #include <linux/jiffies.h>
 #include <linux/timer.h>
-#include <asm/uaccess.h>
-#include <asm/io.h>
+#include <linux/uaccess.h>
+#include <linux/io.h>
 
 /*
  * We have two types of cards that can be probed:
@@ -108,18 +109,19 @@ static char expect_close;
 
 static int nowayout = WATCHDOG_NOWAYOUT;
 module_param(nowayout, int, 0);
-MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+MODULE_PARM_DESC(nowayout,
+                "Watchdog cannot be stopped once started (default="
+                                __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 
 static void mixcomwd_ping(void)
 {
-        outb_p(55,watchdog_port);
+        outb_p(55, watchdog_port);
         return;
 }
 
 static void mixcomwd_timerfun(unsigned long d)
 {
         mixcomwd_ping();
-
         mod_timer(&mixcomwd_timer, jiffies + 5 * HZ);
 }
 
@@ -129,22 +131,22 @@ static void mixcomwd_timerfun(unsigned long d)
 
 static int mixcomwd_open(struct inode *inode, struct file *file)
 {
-        if(test_and_set_bit(0,&mixcomwd_opened)) {
+        if (test_and_set_bit(0, &mixcomwd_opened))
                 return -EBUSY;
-        }
+
         mixcomwd_ping();
 
-        if (nowayout) {
+        if (nowayout)
                 /*
                  * fops_get() code via open() has already done
                  * a try_module_get() so it is safe to do the
                  * __module_get().
                  */
                 __module_get(THIS_MODULE);
-        } else {
-                if(mixcomwd_timer_alive) {
+        else {
+                if (mixcomwd_timer_alive) {
                         del_timer(&mixcomwd_timer);
-                        mixcomwd_timer_alive=0;
+                        mixcomwd_timer_alive = 0;
                 }
         }
         return nonseekable_open(inode, file);
@@ -153,26 +155,27 @@ static int mixcomwd_open(struct inode *inode, struct file *file)
 static int mixcomwd_release(struct inode *inode, struct file *file)
 {
         if (expect_close == 42) {
-                if(mixcomwd_timer_alive) {
-                        printk(KERN_ERR PFX "release called while internal timer alive");
+                if (mixcomwd_timer_alive) {
+                        printk(KERN_ERR PFX
+                                "release called while internal timer alive");
                         return -EBUSY;
                 }
-                mixcomwd_timer_alive=1;
+                mixcomwd_timer_alive = 1;
                 mod_timer(&mixcomwd_timer, jiffies + 5 * HZ);
-        } else {
-                printk(KERN_CRIT PFX "WDT device closed unexpectedly.  WDT will not stop!\n");
-        }
+        } else
+                printk(KERN_CRIT PFX
+                    "WDT device closed unexpectedly.  WDT will not stop!\n");
 
-        clear_bit(0,&mixcomwd_opened);
-        expect_close=0;
+        clear_bit(0, &mixcomwd_opened);
+        expect_close = 0;
         return 0;
 }
 
 
-static ssize_t mixcomwd_write(struct file *file, const char __user *data, size_t len, loff_t *ppos)
+static ssize_t mixcomwd_write(struct file *file, const char __user *data,
+                                                size_t len, loff_t *ppos)
 {
-        if(len)
-        {
+        if (len) {
                 if (!nowayout) {
                         size_t i;
 
@@ -192,8 +195,8 @@ static ssize_t mixcomwd_write(struct file *file, const char __user *data, size_t
         return len;
 }
 
-static int mixcomwd_ioctl(struct inode *inode, struct file *file,
-        unsigned int cmd, unsigned long arg)
+static long mixcomwd_ioctl(struct file *file,
+                                unsigned int cmd, unsigned long arg)
 {
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
@@ -204,32 +207,23 @@ static int mixcomwd_ioctl(struct inode *inode, struct file *file,
                 .identity = "MixCOM watchdog",
         };
 
-        switch(cmd)
-        {
-                case WDIOC_GETSTATUS:
-                        status=mixcomwd_opened;
-                        if (!nowayout) {
-                                status|=mixcomwd_timer_alive;
-                        }
-                        if (copy_to_user(p, &status, sizeof(int))) {
-                                return -EFAULT;
-                        }
-                        break;
-                case WDIOC_GETBOOTSTATUS:
-                        if (copy_to_user(p, &status, sizeof(int))) {
-                                return -EFAULT;
-                        }
-                        break;
-                case WDIOC_GETSUPPORT:
-                        if (copy_to_user(argp, &ident, sizeof(ident))) {
-                                return -EFAULT;
-                        }
-                        break;
-                case WDIOC_KEEPALIVE:
-                        mixcomwd_ping();
-                        break;
-                default:
-                        return -ENOTTY;
+        switch (cmd) {
+        case WDIOC_GETSUPPORT:
+                if (copy_to_user(argp, &ident, sizeof(ident)))
+                        return -EFAULT;
+                break;
+        case WDIOC_GETSTATUS:
+                status = mixcomwd_opened;
+                if (!nowayout)
+                        status |= mixcomwd_timer_alive;
+                return put_user(status, p);
+        case WDIOC_GETBOOTSTATUS:
+                return put_user(0, p);
+        case WDIOC_KEEPALIVE:
+                mixcomwd_ping();
+                break;
+        default:
+                return -ENOTTY;
         }
         return 0;
 }
@@ -238,7 +232,7 @@ static const struct file_operations mixcomwd_fops = {
         .owner          = THIS_MODULE,
         .llseek         = no_llseek,
         .write          = mixcomwd_write,
-        .ioctl          = mixcomwd_ioctl,
+        .unlocked_ioctl = mixcomwd_ioctl,
         .open           = mixcomwd_open,
         .release        = mixcomwd_release,
 };
@@ -253,15 +247,14 @@ static int __init checkcard(int port, int card_id)
 {
         int id;
 
-        if (!request_region(port, 1, "MixCOM watchdog")) {
+        if (!request_region(port, 1, "MixCOM watchdog"))
                 return 0;
-        }
 
-        id=inb_p(port);
-        if (card_id==MIXCOM_ID)
+        id = inb_p(port);
+        if (card_id == MIXCOM_ID)
                 id &= 0x3f;
 
-        if (id!=card_id) {
+        if (id != card_id) {
                 release_region(port, 1);
                 return 0;
         }
@@ -270,9 +263,7 @@ static int __init checkcard(int port, int card_id)
 
 static int __init mixcomwd_init(void)
 {
-        int i;
-        int ret;
-        int found=0;
+        int i, ret, found = 0;
 
         for (i = 0; !found && mixcomwd_io_info[i].ioport != 0; i++) {
                 if (checkcard(mixcomwd_io_info[i].ioport,
@@ -283,20 +274,22 @@ static int __init mixcomwd_init(void)
         }
 
         if (!found) {
-                printk(KERN_ERR PFX "No card detected, or port not available.\n");
+                printk(KERN_ERR PFX
+                        "No card detected, or port not available.\n");
                 return -ENODEV;
         }
 
         ret = misc_register(&mixcomwd_miscdev);
-        if (ret)
-        {
-                printk(KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",
-                        WATCHDOG_MINOR, ret);
+        if (ret) {
+                printk(KERN_ERR PFX
+                        "cannot register miscdev on minor=%d (err=%d)\n",
+                                        WATCHDOG_MINOR, ret);
                 goto error_misc_register_watchdog;
         }
 
-        printk(KERN_INFO "MixCOM watchdog driver v%s, watchdog port at 0x%3x\n",
-                VERSION, watchdog_port);
+        printk(KERN_INFO
+                "MixCOM watchdog driver v%s, watchdog port at 0x%3x\n",
+                                        VERSION, watchdog_port);
 
         return 0;
 
@@ -309,15 +302,15 @@ error_misc_register_watchdog:
 static void __exit mixcomwd_exit(void)
 {
         if (!nowayout) {
-                if(mixcomwd_timer_alive) {
+                if (mixcomwd_timer_alive) {
                         printk(KERN_WARNING PFX "I quit now, hardware will"
                                " probably reboot!\n");
                         del_timer_sync(&mixcomwd_timer);
-                        mixcomwd_timer_alive=0;
+                        mixcomwd_timer_alive = 0;
                 }
         }
         misc_deregister(&mixcomwd_miscdev);
-        release_region(watchdog_port,1);
+        release_region(watchdog_port, 1);
 }
 
 module_init(mixcomwd_init);
diff --git a/drivers/watchdog/mpc5200_wdt.c b/drivers/watchdog/mpc5200_wdt.c
index 77c1c2ae2cc2..db91892558f2 100644
--- a/drivers/watchdog/mpc5200_wdt.c
+++ b/drivers/watchdog/mpc5200_wdt.c
@@ -5,7 +5,7 @@
 #include <linux/io.h>
 #include <linux/spinlock.h>
 #include <linux/of_platform.h>
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 #include <asm/mpc52xx.h>
 
 
@@ -57,7 +57,8 @@ static int mpc5200_wdt_start(struct mpc5200_wdt *wdt)
         /* set timeout, with maximum prescaler */
         out_be32(&wdt->regs->count, 0x0 | wdt->count);
         /* enable watchdog */
-        out_be32(&wdt->regs->mode, GPT_MODE_CE | GPT_MODE_WDT | GPT_MODE_MS_TIMER);
+        out_be32(&wdt->regs->mode, GPT_MODE_CE | GPT_MODE_WDT |
+                                                GPT_MODE_MS_TIMER);
         spin_unlock(&wdt->io_lock);
 
         return 0;
@@ -66,7 +67,8 @@ static int mpc5200_wdt_ping(struct mpc5200_wdt *wdt)
 {
         spin_lock(&wdt->io_lock);
         /* writing A5 to OCPW resets the watchdog */
-        out_be32(&wdt->regs->mode, 0xA5000000 | (0xffffff & in_be32(&wdt->regs->mode)));
+        out_be32(&wdt->regs->mode, 0xA5000000 |
+                                (0xffffff & in_be32(&wdt->regs->mode)));
         spin_unlock(&wdt->io_lock);
         return 0;
 }
@@ -92,8 +94,8 @@ static struct watchdog_info mpc5200_wdt_info = {
         .options        = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
         .identity       = "mpc5200 watchdog on GPT0",
 };
-static int mpc5200_wdt_ioctl(struct inode *inode, struct file *file,
-                unsigned int cmd, unsigned long arg)
+static long mpc5200_wdt_ioctl(struct file *file, unsigned int cmd,
+                                                        unsigned long arg)
 {
         struct mpc5200_wdt *wdt = file->private_data;
         int __user *data = (int __user *)arg;
@@ -103,7 +105,7 @@ static int mpc5200_wdt_ioctl(struct inode *inode, struct file *file,
         switch (cmd) {
         case WDIOC_GETSUPPORT:
                 ret = copy_to_user(data, &mpc5200_wdt_info,
-                        sizeof(mpc5200_wdt_info));
+                                                sizeof(mpc5200_wdt_info));
                 if (ret)
                         ret = -EFAULT;
                 break;
@@ -135,6 +137,7 @@ static int mpc5200_wdt_ioctl(struct inode *inode, struct file *file,
         }
         return ret;
 }
+
 static int mpc5200_wdt_open(struct inode *inode, struct file *file)
 {
         /* /dev/watchdog can only be opened once */
@@ -161,13 +164,14 @@ static int mpc5200_wdt_release(struct inode *inode, struct file *file)
 static const struct file_operations mpc5200_wdt_fops = {
         .owner  = THIS_MODULE,
         .write  = mpc5200_wdt_write,
-        .ioctl  = mpc5200_wdt_ioctl,
+        .unlocked_ioctl = mpc5200_wdt_ioctl,
         .open   = mpc5200_wdt_open,
         .release = mpc5200_wdt_release,
 };
 
 /* module operations */
-static int mpc5200_wdt_probe(struct of_device *op, const struct of_device_id *match)
+static int mpc5200_wdt_probe(struct of_device *op,
+                                        const struct of_device_id *match)
 {
         struct mpc5200_wdt *wdt;
         int err;
@@ -215,9 +219,9 @@ static int mpc5200_wdt_probe(struct of_device *op, const struct of_device_id *ma
                 return 0;
 
         iounmap(wdt->regs);
- out_release:
+out_release:
         release_mem_region(wdt->mem.start, size);
- out_free:
+out_free:
         kfree(wdt);
         return err;
 }
diff --git a/drivers/watchdog/mpc83xx_wdt.c b/drivers/watchdog/mpc83xx_wdt.c
deleted file mode 100644
index b16c5cd972eb..000000000000
--- a/drivers/watchdog/mpc83xx_wdt.c
+++ /dev/null
@@ -1,230 +0,0 @@
-/*
- * mpc83xx_wdt.c - MPC83xx watchdog userspace interface
- *
- * Authors: Dave Updegraff <dave@cray.org>
- *          Kumar Gala <galak@kernel.crashing.org>
- *              Attribution: from 83xx_wst: Florian Schirmer <jolt@tuxbox.org>
- *                              ..and from sc520_wdt
- *
- * Note: it appears that you can only actually ENABLE or DISABLE the thing
- * once after POR. Once enabled, you cannot disable, and vice versa.
- *
- * 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.
- */
-
-#include <linux/fs.h>
-#include <linux/init.h>
-#include <linux/kernel.h>
-#include <linux/miscdevice.h>
-#include <linux/platform_device.h>
-#include <linux/module.h>
-#include <linux/watchdog.h>
-#include <asm/io.h>
-#include <asm/uaccess.h>
-
-struct mpc83xx_wdt {
-        __be32 res0;
-        __be32 swcrr; /* System watchdog control register */
-#define SWCRR_SWTC 0xFFFF0000 /* Software Watchdog Time Count. */
-#define SWCRR_SWEN 0x00000004 /* Watchdog Enable bit. */
-#define SWCRR_SWRI 0x00000002 /* Software Watchdog Reset/Interrupt Select bit.*/
-#define SWCRR_SWPR 0x00000001 /* Software Watchdog Counter Prescale bit. */
-        __be32 swcnr; /* System watchdog count register */
-        u8 res1[2];
-        __be16 swsrr; /* System watchdog service register */
-        u8 res2[0xF0];
-};
-
-static struct mpc83xx_wdt __iomem *wd_base;
-
-static u16 timeout = 0xffff;
-module_param(timeout, ushort, 0);
-MODULE_PARM_DESC(timeout, "Watchdog timeout in ticks. (0<timeout<65536, default=65535");
-
-static int reset = 1;
-module_param(reset, bool, 0);
-MODULE_PARM_DESC(reset, "Watchdog Interrupt/Reset Mode. 0 = interrupt, 1 = reset");
-
-/*
- * We always prescale, but if someone really doesn't want to they can set this
- * to 0
- */
-static int prescale = 1;
-static unsigned int timeout_sec;
-
-static unsigned long wdt_is_open;
-static DEFINE_SPINLOCK(wdt_spinlock);
-
-static void mpc83xx_wdt_keepalive(void)
-{
-        /* Ping the WDT */
-        spin_lock(&wdt_spinlock);
-        out_be16(&wd_base->swsrr, 0x556c);
-        out_be16(&wd_base->swsrr, 0xaa39);
-        spin_unlock(&wdt_spinlock);
-}
-
-static ssize_t mpc83xx_wdt_write(struct file *file, const char __user *buf,
-                                 size_t count, loff_t *ppos)
-{
-        if (count)
-                mpc83xx_wdt_keepalive();
-        return count;
-}
-
-static int mpc83xx_wdt_open(struct inode *inode, struct file *file)
-{
-        u32 tmp = SWCRR_SWEN;
-        if (test_and_set_bit(0, &wdt_is_open))
-                return -EBUSY;
-
-        /* Once we start the watchdog we can't stop it */
-        __module_get(THIS_MODULE);
-
-        /* Good, fire up the show */
-        if (prescale)
-                tmp |= SWCRR_SWPR;
-        if (reset)
-                tmp |= SWCRR_SWRI;
-
-        tmp |= timeout << 16;
-
-        out_be32(&wd_base->swcrr, tmp);
-
-        return nonseekable_open(inode, file);
-}
-
-static int mpc83xx_wdt_release(struct inode *inode, struct file *file)
-{
-        printk(KERN_CRIT "Unexpected close, not stopping watchdog!\n");
-        mpc83xx_wdt_keepalive();
-        clear_bit(0, &wdt_is_open);
-        return 0;
-}
-
-static int mpc83xx_wdt_ioctl(struct inode *inode, struct file *file,
-                                unsigned int cmd, unsigned long arg)
-{
-        void __user *argp = (void __user *)arg;
-        int __user *p = argp;
-        static struct watchdog_info ident = {
-                .options = WDIOF_KEEPALIVEPING,
-                .firmware_version = 1,
-                .identity = "MPC83xx",
-        };
-
-        switch (cmd) {
-        case WDIOC_GETSUPPORT:
-                return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;
-        case WDIOC_GETSTATUS:
-        case WDIOC_GETBOOTSTATUS:
-                return put_user(0, p);
-        case WDIOC_KEEPALIVE:
-                mpc83xx_wdt_keepalive();
-                return 0;
-        case WDIOC_GETTIMEOUT:
-                return put_user(timeout_sec, p);
-        default:
-                return -ENOTTY;
-        }
-}
-
-static const struct file_operations mpc83xx_wdt_fops = {
-        .owner          = THIS_MODULE,
-        .llseek         = no_llseek,
-        .write          = mpc83xx_wdt_write,
-        .ioctl          = mpc83xx_wdt_ioctl,
-        .open           = mpc83xx_wdt_open,
-        .release        = mpc83xx_wdt_release,
-};
-
-static struct miscdevice mpc83xx_wdt_miscdev = {
-        .minor  = WATCHDOG_MINOR,
-        .name   = "watchdog",
-        .fops   = &mpc83xx_wdt_fops,
-};
-
-static int __devinit mpc83xx_wdt_probe(struct platform_device *dev)
-{
-        struct resource *r;
-        int ret;
-        unsigned int *freq = dev->dev.platform_data;
-
-        /* get a pointer to the register memory */
-        r = platform_get_resource(dev, IORESOURCE_MEM, 0);
-
-        if (!r) {
-                ret = -ENODEV;
-                goto err_out;
-        }
-
-        wd_base = ioremap(r->start, sizeof (struct mpc83xx_wdt));
-
-        if (wd_base == NULL) {
-                ret = -ENOMEM;
-                goto err_out;
-        }
-
-        ret = misc_register(&mpc83xx_wdt_miscdev);
-        if (ret) {
-                printk(KERN_ERR "cannot register miscdev on minor=%d "
-                                "(err=%d)\n",
-                                WATCHDOG_MINOR, ret);
-                goto err_unmap;
-        }
-
-        /* Calculate the timeout in seconds */
-        if (prescale)
-                timeout_sec = (timeout * 0x10000) / (*freq);
-        else
-                timeout_sec = timeout / (*freq);
-
-        printk(KERN_INFO "WDT driver for MPC83xx initialized. "
-                "mode:%s timeout=%d (%d seconds)\n",
-                reset ? "reset":"interrupt", timeout, timeout_sec);
-        return 0;
-
-err_unmap:
-        iounmap(wd_base);
-err_out:
-        return ret;
-}
-
-static int __devexit mpc83xx_wdt_remove(struct platform_device *dev)
-{
-        misc_deregister(&mpc83xx_wdt_miscdev);
-        iounmap(wd_base);
-
-        return 0;
-}
-
-static struct platform_driver mpc83xx_wdt_driver = {
-        .probe          = mpc83xx_wdt_probe,
-        .remove         = __devexit_p(mpc83xx_wdt_remove),
-        .driver         = {
-                .name   = "mpc83xx_wdt",
-                .owner  = THIS_MODULE,
-        },
-};
-
-static int __init mpc83xx_wdt_init(void)
-{
-        return platform_driver_register(&mpc83xx_wdt_driver);
-}
-
-static void __exit mpc83xx_wdt_exit(void)
-{
-        platform_driver_unregister(&mpc83xx_wdt_driver);
-}
-
-module_init(mpc83xx_wdt_init);
-module_exit(mpc83xx_wdt_exit);
-
-MODULE_AUTHOR("Dave Updegraff, Kumar Gala");
-MODULE_DESCRIPTION("Driver for watchdog timer in MPC83xx uProcessor");
-MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
-MODULE_ALIAS("platform:mpc83xx_wdt");
diff --git a/drivers/watchdog/mpc8xx_wdt.c b/drivers/watchdog/mpc8xx_wdt.c
index 85b5734403a5..1336425acf20 100644
--- a/drivers/watchdog/mpc8xx_wdt.c
+++ b/drivers/watchdog/mpc8xx_wdt.c
@@ -16,36 +16,35 @@
 #include <linux/module.h>
 #include <linux/watchdog.h>
 #include <asm/8xx_immap.h>
-#include <asm/uaccess.h>
-#include <asm/io.h>
+#include <linux/uaccess.h>
+#include <linux/io.h>
 #include <syslib/m8xx_wdt.h>
 
 static unsigned long wdt_opened;
 static int wdt_status;
+static spinlock_t wdt_lock;
 
 static void mpc8xx_wdt_handler_disable(void)
 {
         volatile uint __iomem *piscr;
-        piscr = (uint *)&((immap_t*)IMAP_ADDR)->im_sit.sit_piscr;
+        piscr = (uint *)&((immap_t *)IMAP_ADDR)->im_sit.sit_piscr;
 
         if (!m8xx_has_internal_rtc)
                 m8xx_wdt_stop_timer();
         else
                 out_be32(piscr, in_be32(piscr) & ~(PISCR_PIE | PISCR_PTE));
-
         printk(KERN_NOTICE "mpc8xx_wdt: keep-alive handler deactivated\n");
 }
 
 static void mpc8xx_wdt_handler_enable(void)
 {
         volatile uint __iomem *piscr;
-        piscr = (uint *)&((immap_t*)IMAP_ADDR)->im_sit.sit_piscr;
+        piscr = (uint *)&((immap_t *)IMAP_ADDR)->im_sit.sit_piscr;
 
         if (!m8xx_has_internal_rtc)
                 m8xx_wdt_install_timer();
         else
                 out_be32(piscr, in_be32(piscr) | PISCR_PIE | PISCR_PTE);
-
         printk(KERN_NOTICE "mpc8xx_wdt: keep-alive handler activated\n");
 }
 
@@ -53,37 +52,34 @@ static int mpc8xx_wdt_open(struct inode *inode, struct file *file)
 {
         if (test_and_set_bit(0, &wdt_opened))
                 return -EBUSY;
-
         m8xx_wdt_reset();
         mpc8xx_wdt_handler_disable();
-
         return nonseekable_open(inode, file);
 }
 
 static int mpc8xx_wdt_release(struct inode *inode, struct file *file)
 {
         m8xx_wdt_reset();
-
 #if !defined(CONFIG_WATCHDOG_NOWAYOUT)
         mpc8xx_wdt_handler_enable();
 #endif
-
         clear_bit(0, &wdt_opened);
-
         return 0;
 }
 
-static ssize_t mpc8xx_wdt_write(struct file *file, const char *data, size_t len,
-                                loff_t * ppos)
+static ssize_t mpc8xx_wdt_write(struct file *file, const char *data,
+                                                size_t len, loff_t *ppos)
 {
-        if (len)
+        if (len) {
+                spin_lock(&wdt_lock);
                 m8xx_wdt_reset();
-
+                spin_unlock(&wdt_lock);
+        }
         return len;
 }
 
-static int mpc8xx_wdt_ioctl(struct inode *inode, struct file *file,
-                            unsigned int cmd, unsigned long arg)
+static long mpc8xx_wdt_ioctl(struct file *file,
+                                        unsigned int cmd, unsigned long arg)
 {
         int timeout;
         static struct watchdog_info info = {
@@ -112,15 +108,19 @@ static int mpc8xx_wdt_ioctl(struct inode *inode, struct file *file,
                 return -EOPNOTSUPP;
 
         case WDIOC_KEEPALIVE:
+                spin_lock(&wdt_lock);
                 m8xx_wdt_reset();
                 wdt_status |= WDIOF_KEEPALIVEPING;
+                spin_unlock(&wdt_lock);
                 break;
 
         case WDIOC_SETTIMEOUT:
                 return -EOPNOTSUPP;
 
         case WDIOC_GETTIMEOUT:
+                spin_lock(&wdt_lock);
                 timeout = m8xx_wdt_get_timeout();
+                spin_unlock(&wdt_lock);
                 if (put_user(timeout, (int *)arg))
                         return -EFAULT;
                 break;
@@ -136,7 +136,7 @@ static const struct file_operations mpc8xx_wdt_fops = {
         .owner = THIS_MODULE,
         .llseek = no_llseek,
         .write = mpc8xx_wdt_write,
-        .ioctl = mpc8xx_wdt_ioctl,
+        .unlocked_ioctl = mpc8xx_wdt_ioctl,
         .open = mpc8xx_wdt_open,
         .release = mpc8xx_wdt_release,
 };
@@ -149,6 +149,7 @@ static struct miscdevice mpc8xx_wdt_miscdev = {
 
 static int __init mpc8xx_wdt_init(void)
 {
+        spin_lock_init(&wdt_lock);
         return misc_register(&mpc8xx_wdt_miscdev);
 }
 
diff --git a/drivers/watchdog/mpc8xxx_wdt.c b/drivers/watchdog/mpc8xxx_wdt.c
new file mode 100644
index 000000000000..f2094960e662
--- /dev/null
+++ b/drivers/watchdog/mpc8xxx_wdt.c
@@ -0,0 +1,316 @@
+/*
+ * mpc8xxx_wdt.c - MPC8xx/MPC83xx/MPC86xx watchdog userspace interface
+ *
+ * Authors: Dave Updegraff <dave@cray.org>
+ *          Kumar Gala <galak@kernel.crashing.org>
+ *              Attribution: from 83xx_wst: Florian Schirmer <jolt@tuxbox.org>
+ *                              ..and from sc520_wdt
+ * Copyright (c) 2008  MontaVista Software, Inc.
+ *                     Anton Vorontsov <avorontsov@ru.mvista.com>
+ *
+ * Note: it appears that you can only actually ENABLE or DISABLE the thing
+ * once after POR. Once enabled, you cannot disable, and vice versa.
+ *
+ * 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.
+ */
+
+#include <linux/fs.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/timer.h>
+#include <linux/miscdevice.h>
+#include <linux/of_platform.h>
+#include <linux/module.h>
+#include <linux/watchdog.h>
+#include <linux/io.h>
+#include <linux/uaccess.h>
+#include <sysdev/fsl_soc.h>
+
+struct mpc8xxx_wdt {
+        __be32 res0;
+        __be32 swcrr; /* System watchdog control register */
+#define SWCRR_SWTC 0xFFFF0000 /* Software Watchdog Time Count. */
+#define SWCRR_SWEN 0x00000004 /* Watchdog Enable bit. */
+#define SWCRR_SWRI 0x00000002 /* Software Watchdog Reset/Interrupt Select bit.*/
+#define SWCRR_SWPR 0x00000001 /* Software Watchdog Counter Prescale bit. */
+        __be32 swcnr; /* System watchdog count register */
+        u8 res1[2];
+        __be16 swsrr; /* System watchdog service register */
+        u8 res2[0xF0];
+};
+
+struct mpc8xxx_wdt_type {
+        int prescaler;
+        bool hw_enabled;
+};
+
+static struct mpc8xxx_wdt __iomem *wd_base;
+
+static u16 timeout = 0xffff;
+module_param(timeout, ushort, 0);
+MODULE_PARM_DESC(timeout,
+        "Watchdog timeout in ticks. (0<timeout<65536, default=65535");
+
+static int reset = 1;
+module_param(reset, bool, 0);
+MODULE_PARM_DESC(reset,
+        "Watchdog Interrupt/Reset Mode. 0 = interrupt, 1 = reset");
+
+static int nowayout = WATCHDOG_NOWAYOUT;
+module_param(nowayout, int, 0);
+MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started "
+                 "(default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+
+/*
+ * We always prescale, but if someone really doesn't want to they can set this
+ * to 0
+ */
+static int prescale = 1;
+static unsigned int timeout_sec;
+
+static unsigned long wdt_is_open;
+static DEFINE_SPINLOCK(wdt_spinlock);
+
+static void mpc8xxx_wdt_keepalive(void)
+{
+        /* Ping the WDT */
+        spin_lock(&wdt_spinlock);
+        out_be16(&wd_base->swsrr, 0x556c);
+        out_be16(&wd_base->swsrr, 0xaa39);
+        spin_unlock(&wdt_spinlock);
+}
+
+static void mpc8xxx_wdt_timer_ping(unsigned long arg);
+static DEFINE_TIMER(wdt_timer, mpc8xxx_wdt_timer_ping, 0, 0);
+
+static void mpc8xxx_wdt_timer_ping(unsigned long arg)
+{
+        mpc8xxx_wdt_keepalive();
+        /* We're pinging it twice faster than needed, just to be sure. */
+        mod_timer(&wdt_timer, jiffies + HZ * timeout_sec / 2);
+}
+
+static void mpc8xxx_wdt_pr_warn(const char *msg)
+{
+        pr_crit("mpc8xxx_wdt: %s, expect the %s soon!\n", msg,
+                reset ? "reset" : "machine check exception");
+}
+
+static ssize_t mpc8xxx_wdt_write(struct file *file, const char __user *buf,
+                                 size_t count, loff_t *ppos)
+{
+        if (count)
+                mpc8xxx_wdt_keepalive();
+        return count;
+}
+
+static int mpc8xxx_wdt_open(struct inode *inode, struct file *file)
+{
+        u32 tmp = SWCRR_SWEN;
+        if (test_and_set_bit(0, &wdt_is_open))
+                return -EBUSY;
+
+        /* Once we start the watchdog we can't stop it */
+        if (nowayout)
+                __module_get(THIS_MODULE);
+
+        /* Good, fire up the show */
+        if (prescale)
+                tmp |= SWCRR_SWPR;
+        if (reset)
+                tmp |= SWCRR_SWRI;
+
+        tmp |= timeout << 16;
+
+        out_be32(&wd_base->swcrr, tmp);
+
+        del_timer_sync(&wdt_timer);
+
+        return nonseekable_open(inode, file);
+}
+
+static int mpc8xxx_wdt_release(struct inode *inode, struct file *file)
+{
+        if (!nowayout)
+                mpc8xxx_wdt_timer_ping(0);
+        else
+                mpc8xxx_wdt_pr_warn("watchdog closed");
+        clear_bit(0, &wdt_is_open);
+        return 0;
+}
+
+static long mpc8xxx_wdt_ioctl(struct file *file, unsigned int cmd,
+                                                        unsigned long arg)
+{
+        void __user *argp = (void __user *)arg;
+        int __user *p = argp;
+        static struct watchdog_info ident = {
+                .options = WDIOF_KEEPALIVEPING,
+                .firmware_version = 1,
+                .identity = "MPC8xxx",
+        };
+
+        switch (cmd) {
+        case WDIOC_GETSUPPORT:
+                return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;
+        case WDIOC_GETSTATUS:
+        case WDIOC_GETBOOTSTATUS:
+                return put_user(0, p);
+        case WDIOC_KEEPALIVE:
+                mpc8xxx_wdt_keepalive();
+                return 0;
+        case WDIOC_GETTIMEOUT:
+                return put_user(timeout_sec, p);
+        default:
+                return -ENOTTY;
+        }
+}
+
+static const struct file_operations mpc8xxx_wdt_fops = {
+        .owner          = THIS_MODULE,
+        .llseek         = no_llseek,
+        .write          = mpc8xxx_wdt_write,
+        .unlocked_ioctl = mpc8xxx_wdt_ioctl,
+        .open           = mpc8xxx_wdt_open,
+        .release        = mpc8xxx_wdt_release,
+};
+
+static struct miscdevice mpc8xxx_wdt_miscdev = {
+        .minor  = WATCHDOG_MINOR,
+        .name   = "watchdog",
+        .fops   = &mpc8xxx_wdt_fops,
+};
+
+static int __devinit mpc8xxx_wdt_probe(struct of_device *ofdev,
+                                       const struct of_device_id *match)
+{
+        int ret;
+        struct device_node *np = ofdev->node;
+        struct mpc8xxx_wdt_type *wdt_type = match->data;
+        u32 freq = fsl_get_sys_freq();
+        bool enabled;
+
+        if (!freq || freq == -1)
+                return -EINVAL;
+
+        wd_base = of_iomap(np, 0);
+        if (!wd_base)
+                return -ENOMEM;
+
+        enabled = in_be32(&wd_base->swcrr) & SWCRR_SWEN;
+        if (!enabled && wdt_type->hw_enabled) {
+                pr_info("mpc8xxx_wdt: could not be enabled in software\n");
+                ret = -ENOSYS;
+                goto err_unmap;
+        }
+
+        /* Calculate the timeout in seconds */
+        if (prescale)
+                timeout_sec = (timeout * wdt_type->prescaler) / freq;
+        else
+                timeout_sec = timeout / freq;
+
+        pr_info("WDT driver for MPC8xxx initialized. mode:%s timeout=%d "
+                "(%d seconds)\n", reset ? "reset" : "interrupt", timeout,
+                timeout_sec);
+
+        /*
+         * If the watchdog was previously enabled or we're running on
+         * MPC8xxx, we should ping the wdt from the kernel until the
+         * userspace handles it.
+         */
+        if (enabled)
+                mpc8xxx_wdt_timer_ping(0);
+        return 0;
+err_unmap:
+        iounmap(wd_base);
+        wd_base = NULL;
+        return ret;
+}
+
+static int __devexit mpc8xxx_wdt_remove(struct of_device *ofdev)
+{
+        mpc8xxx_wdt_pr_warn("watchdog removed");
+        del_timer_sync(&wdt_timer);
+        misc_deregister(&mpc8xxx_wdt_miscdev);
+        iounmap(wd_base);
+
+        return 0;
+}
+
+static const struct of_device_id mpc8xxx_wdt_match[] = {
+        {
+                .compatible = "mpc83xx_wdt",
+                .data = &(struct mpc8xxx_wdt_type) {
+                        .prescaler = 0x10000,
+                },
+        },
+        {
+                .compatible = "fsl,mpc8610-wdt",
+                .data = &(struct mpc8xxx_wdt_type) {
+                        .prescaler = 0x10000,
+                        .hw_enabled = true,
+                },
+        },
+        {
+                .compatible = "fsl,mpc823-wdt",
+                .data = &(struct mpc8xxx_wdt_type) {
+                        .prescaler = 0x800,
+                },
+        },
+        {},
+};
+MODULE_DEVICE_TABLE(of, mpc8xxx_wdt_match);
+
+static struct of_platform_driver mpc8xxx_wdt_driver = {
+        .match_table    = mpc8xxx_wdt_match,
+        .probe          = mpc8xxx_wdt_probe,
+        .remove         = __devexit_p(mpc8xxx_wdt_remove),
+        .driver         = {
+                .name   = "mpc8xxx_wdt",
+                .owner  = THIS_MODULE,
+        },
+};
+
+/*
+ * We do wdt initialization in two steps: arch_initcall probes the wdt
+ * very early to start pinging the watchdog (misc devices are not yet
+ * available), and later module_init() just registers the misc device.
+ */
+static int __init mpc8xxx_wdt_init_late(void)
+{
+        int ret;
+
+        if (!wd_base)
+                return -ENODEV;
+
+        ret = misc_register(&mpc8xxx_wdt_miscdev);
+        if (ret) {
+                pr_err("cannot register miscdev on minor=%d (err=%d)\n",
+                        WATCHDOG_MINOR, ret);
+                return ret;
+        }
+        return 0;
+}
+module_init(mpc8xxx_wdt_init_late);
+
+static int __init mpc8xxx_wdt_init(void)
+{
+        return of_register_platform_driver(&mpc8xxx_wdt_driver);
+}
+arch_initcall(mpc8xxx_wdt_init);
+
+static void __exit mpc8xxx_wdt_exit(void)
+{
+        of_unregister_platform_driver(&mpc8xxx_wdt_driver);
+}
+module_exit(mpc8xxx_wdt_exit);
+
+MODULE_AUTHOR("Dave Updegraff, Kumar Gala");
+MODULE_DESCRIPTION("Driver for watchdog timer in MPC8xx/MPC83xx/MPC86xx "
+                   "uProcessors");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/mpcore_wdt.c b/drivers/watchdog/mpcore_wdt.c
index 009573b81496..2a9bfa81f9d6 100644
--- a/drivers/watchdog/mpcore_wdt.c
+++ b/drivers/watchdog/mpcore_wdt.c
@@ -29,9 +29,9 @@
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/platform_device.h>
+#include <linux/uaccess.h>
 
 #include <asm/hardware/arm_twd.h>
-#include <asm/uaccess.h>
 
 struct mpcore_wdt {
         unsigned long   timer_alive;
@@ -43,17 +43,20 @@ struct mpcore_wdt {
 };
 
 static struct platform_device *mpcore_wdt_dev;
-
 extern unsigned int mpcore_timer_rate;
 
 #define TIMER_MARGIN    60
 static int mpcore_margin = TIMER_MARGIN;
 module_param(mpcore_margin, int, 0);
-MODULE_PARM_DESC(mpcore_margin, "MPcore timer margin in seconds. (0<mpcore_margin<65536, default=" __MODULE_STRING(TIMER_MARGIN) ")");
+MODULE_PARM_DESC(mpcore_margin,
+        "MPcore timer margin in seconds. (0 < mpcore_margin < 65536, default="
+                                __MODULE_STRING(TIMER_MARGIN) ")");
 
 static int nowayout = WATCHDOG_NOWAYOUT;
 module_param(nowayout, int, 0);
-MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+MODULE_PARM_DESC(nowayout,
+        "Watchdog cannot be stopped once started (default="
+                                __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 
 #define ONLY_TESTING    0
 static int mpcore_noboot = ONLY_TESTING;
@@ -70,14 +73,12 @@ static irqreturn_t mpcore_wdt_fire(int irq, void *arg)
 
         /* Check it really was our interrupt */
         if (readl(wdt->base + TWD_WDOG_INTSTAT)) {
-                dev_printk(KERN_CRIT, wdt->dev, "Triggered - Reboot ignored.\n");
-
+                dev_printk(KERN_CRIT, wdt->dev,
+                                        "Triggered - Reboot ignored.\n");
                 /* Clear the interrupt on the watchdog */
                 writel(1, wdt->base + TWD_WDOG_INTSTAT);
-
                 return IRQ_HANDLED;
         }
-
         return IRQ_NONE;
 }
 
@@ -96,22 +97,26 @@ static void mpcore_wdt_keepalive(struct mpcore_wdt *wdt)
         count = (mpcore_timer_rate / 256) * mpcore_margin;
 
         /* Reload the counter */
+        spin_lock(&wdt_lock);
         writel(count + wdt->perturb, wdt->base + TWD_WDOG_LOAD);
-
         wdt->perturb = wdt->perturb ? 0 : 1;
+        spin_unlock(&wdt_lock);
 }
 
 static void mpcore_wdt_stop(struct mpcore_wdt *wdt)
 {
+        spin_lock(&wdt_lock);
         writel(0x12345678, wdt->base + TWD_WDOG_DISABLE);
         writel(0x87654321, wdt->base + TWD_WDOG_DISABLE);
         writel(0x0, wdt->base + TWD_WDOG_CONTROL);
+        spin_unlock(&wdt_lock);
 }
 
 static void mpcore_wdt_start(struct mpcore_wdt *wdt)
 {
         dev_printk(KERN_INFO, wdt->dev, "enabling watchdog.\n");
 
+        spin_lock(&wdt_lock);
         /* This loads the count register but does NOT start the count yet */
         mpcore_wdt_keepalive(wdt);
 
@@ -122,6 +127,7 @@ static void mpcore_wdt_start(struct mpcore_wdt *wdt)
                 /* Enable watchdog - prescale=256, watchdog mode=1, enable=1 */
                 writel(0x0000FF09, wdt->base + TWD_WDOG_CONTROL);
         }
+        spin_unlock(&wdt_lock);
 }
 
 static int mpcore_wdt_set_heartbeat(int t)
@@ -164,10 +170,11 @@ static int mpcore_wdt_release(struct inode *inode, struct file *file)
          *      Shut off the timer.
          *      Lock it in if it's a module and we set nowayout
          */
-        if (wdt->expect_close == 42) {
+        if (wdt->expect_close == 42)
                 mpcore_wdt_stop(wdt);
-        } else {
-                dev_printk(KERN_CRIT, wdt->dev, "unexpected close, not stopping watchdog!\n");
+        else {
+                dev_printk(KERN_CRIT, wdt->dev,
+                                "unexpected close, not stopping watchdog!\n");
                 mpcore_wdt_keepalive(wdt);
         }
         clear_bit(0, &wdt->timer_alive);
@@ -175,7 +182,8 @@ static int mpcore_wdt_release(struct inode *inode, struct file *file)
         return 0;
 }
 
-static ssize_t mpcore_wdt_write(struct file *file, const char *data, size_t len, loff_t *ppos)
+static ssize_t mpcore_wdt_write(struct file *file, const char *data,
+                                                size_t len, loff_t *ppos)
 {
         struct mpcore_wdt *wdt = file->private_data;
 
@@ -210,8 +218,8 @@ static struct watchdog_info ident = {
         .identity               = "MPcore Watchdog",
 };
 
-static int mpcore_wdt_ioctl(struct inode *inode, struct file *file,
-                             unsigned int cmd, unsigned long arg)
+static long mpcore_wdt_ioctl(struct file *file, unsigned int cmd,
+                                                        unsigned long arg)
 {
         struct mpcore_wdt *wdt = file->private_data;
         int ret;
@@ -235,6 +243,12 @@ static int mpcore_wdt_ioctl(struct inode *inode, struct file *file,
                 ret = 0;
                 break;
 
+        case WDIOC_GETSTATUS:
+        case WDIOC_GETBOOTSTATUS:
+                uarg.i = 0;
+                ret = 0;
+                break;
+
         case WDIOC_SETOPTIONS:
                 ret = -EINVAL;
                 if (uarg.i & WDIOS_DISABLECARD) {
@@ -247,12 +261,6 @@ static int mpcore_wdt_ioctl(struct inode *inode, struct file *file,
                 }
                 break;
 
-        case WDIOC_GETSTATUS:
-        case WDIOC_GETBOOTSTATUS:
-                uarg.i = 0;
-                ret = 0;
-                break;
-
         case WDIOC_KEEPALIVE:
                 mpcore_wdt_keepalive(wdt);
                 ret = 0;
@@ -301,7 +309,7 @@ static const struct file_operations mpcore_wdt_fops = {
         .owner          = THIS_MODULE,
         .llseek         = no_llseek,
         .write          = mpcore_wdt_write,
-        .ioctl          = mpcore_wdt_ioctl,
+        .unlocked_ioctl = mpcore_wdt_ioctl,
         .open           = mpcore_wdt_open,
         .release        = mpcore_wdt_release,
 };
@@ -349,14 +357,17 @@ static int __devinit mpcore_wdt_probe(struct platform_device *dev)
         mpcore_wdt_miscdev.parent = &dev->dev;
         ret = misc_register(&mpcore_wdt_miscdev);
         if (ret) {
-                dev_printk(KERN_ERR, _dev, "cannot register miscdev on minor=%d (err=%d)\n",
-                           WATCHDOG_MINOR, ret);
+                dev_printk(KERN_ERR, _dev,
+                        "cannot register miscdev on minor=%d (err=%d)\n",
+                                                        WATCHDOG_MINOR, ret);
                 goto err_misc;
         }
 
-        ret = request_irq(wdt->irq, mpcore_wdt_fire, IRQF_DISABLED, "mpcore_wdt", wdt);
+        ret = request_irq(wdt->irq, mpcore_wdt_fire, IRQF_DISABLED,
+                                                        "mpcore_wdt", wdt);
         if (ret) {
-                dev_printk(KERN_ERR, _dev, "cannot register IRQ%d for watchdog\n", wdt->irq);
+                dev_printk(KERN_ERR, _dev,
+                        "cannot register IRQ%d for watchdog\n", wdt->irq);
                 goto err_irq;
         }
 
@@ -366,13 +377,13 @@ static int __devinit mpcore_wdt_probe(struct platform_device *dev)
 
         return 0;
 
- err_irq:
+err_irq:
         misc_deregister(&mpcore_wdt_miscdev);
- err_misc:
+err_misc:
         iounmap(wdt->base);
- err_free:
+err_free:
         kfree(wdt);
- err_out:
+err_out:
         return ret;
 }
 
@@ -415,7 +426,7 @@ static int __init mpcore_wdt_init(void)
          */
         if (mpcore_wdt_set_heartbeat(mpcore_margin)) {
                 mpcore_wdt_set_heartbeat(TIMER_MARGIN);
-                printk(KERN_INFO "mpcore_margin value must be 0<mpcore_margin<65536, using %d\n",
+                printk(KERN_INFO "mpcore_margin value must be 0 < mpcore_margin < 65536, using %d\n",
                         TIMER_MARGIN);
         }
 
diff --git a/drivers/watchdog/mtx-1_wdt.c b/drivers/watchdog/mtx-1_wdt.c
index a8e67383784e..b4b7b0a4c119 100644
--- a/drivers/watchdog/mtx-1_wdt.c
+++ b/drivers/watchdog/mtx-1_wdt.c
@@ -1,7 +1,8 @@
 /*
  *      Driver for the MTX-1 Watchdog.
  *
- *      (C) Copyright 2005 4G Systems <info@4g-systems.biz>, All Rights Reserved.
+ *      (C) Copyright 2005 4G Systems <info@4g-systems.biz>,
+ *                                                      All Rights Reserved.
  *                              http://www.4g-systems.biz
  *
  *      (C) Copyright 2007 OpenWrt.org, Florian Fainelli <florian@openwrt.org>
@@ -46,12 +47,11 @@
 #include <linux/jiffies.h>
 #include <linux/watchdog.h>
 #include <linux/platform_device.h>
-
-#include <asm/io.h>
-#include <asm/uaccess.h>
+#include <linux/io.h>
+#include <linux/uaccess.h>
+#include <linux/gpio.h>
 
 #include <asm/mach-au1x00/au1000.h>
-#include <asm/gpio.h>
 
 #define MTX1_WDT_INTERVAL       (5 * HZ)
 
@@ -59,6 +59,7 @@ static int ticks = 100 * HZ;
 
 static struct {
         struct completion stop;
+        spinlock_t lock;
         int running;
         struct timer_list timer;
         int queue;
@@ -71,6 +72,7 @@ static void mtx1_wdt_trigger(unsigned long unused)
 {
         u32 tmp;
 
+        spin_lock(&mtx1_wdt_device.lock);
         if (mtx1_wdt_device.running)
                 ticks--;
         /*
@@ -79,13 +81,13 @@ static void mtx1_wdt_trigger(unsigned long unused)
         tmp = au_readl(GPIO2_DIR);
         tmp = (tmp & ~(1 << mtx1_wdt_device.gpio)) |
               ((~tmp) & (1 << mtx1_wdt_device.gpio));
-        au_writel (tmp, GPIO2_DIR);
+        au_writel(tmp, GPIO2_DIR);
 
         if (mtx1_wdt_device.queue && ticks)
                 mod_timer(&mtx1_wdt_device.timer, jiffies + MTX1_WDT_INTERVAL);
-        else {
+        else
                 complete(&mtx1_wdt_device.stop);
-        }
+        spin_unlock(&mtx1_wdt_device.lock);
 }
 
 static void mtx1_wdt_reset(void)
@@ -96,23 +98,25 @@ static void mtx1_wdt_reset(void)
 
 static void mtx1_wdt_start(void)
 {
+        spin_lock_irqsave(&mtx1_wdt_device.lock, flags);
         if (!mtx1_wdt_device.queue) {
                 mtx1_wdt_device.queue = 1;
                 gpio_set_value(mtx1_wdt_device.gpio, 1);
                 mod_timer(&mtx1_wdt_device.timer, jiffies + MTX1_WDT_INTERVAL);
         }
         mtx1_wdt_device.running++;
+        spin_unlock_irqrestore(&mtx1_wdt_device.lock, flags);
 }
 
 static int mtx1_wdt_stop(void)
 {
+        spin_lock_irqsave(&mtx1_wdt_device.lock, flags);
         if (mtx1_wdt_device.queue) {
                 mtx1_wdt_device.queue = 0;
                 gpio_set_value(mtx1_wdt_device.gpio, 0);
         }
-
         ticks = mtx1_wdt_device.default_ticks;
-
+        spin_unlock_irqrestore(&mtx1_wdt_device.lock, flags);
         return 0;
 }
 
@@ -122,7 +126,6 @@ static int mtx1_wdt_open(struct inode *inode, struct file *file)
 {
         if (test_and_set_bit(0, &mtx1_wdt_device.inuse))
                 return -EBUSY;
-
         return nonseekable_open(inode, file);
 }
 
@@ -133,54 +136,51 @@ static int mtx1_wdt_release(struct inode *inode, struct file *file)
         return 0;
 }
 
-static int mtx1_wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
+static long mtx1_wdt_ioctl(struct file *file, unsigned int cmd,
+                                                        unsigned long arg)
 {
         void __user *argp = (void __user *)arg;
+        int __user *p = (int __user *)argp;
         unsigned int value;
-        static struct watchdog_info ident =
-        {
+        static const struct watchdog_info ident = {
                 .options = WDIOF_CARDRESET,
                 .identity = "MTX-1 WDT",
         };
 
-        switch(cmd) {
-                case WDIOC_KEEPALIVE:
-                        mtx1_wdt_reset();
-                        break;
-                case WDIOC_GETSTATUS:
-                case WDIOC_GETBOOTSTATUS:
-                        if ( copy_to_user(argp, &value, sizeof(int)) )
-                                return -EFAULT;
-                        break;
-                case WDIOC_GETSUPPORT:
-                        if ( copy_to_user(argp, &ident, sizeof(ident)) )
-                                return -EFAULT;
-                        break;
-                case WDIOC_SETOPTIONS:
-                        if ( copy_from_user(&value, argp, sizeof(int)) )
-                                return -EFAULT;
-                        switch(value) {
-                                case WDIOS_ENABLECARD:
-                                        mtx1_wdt_start();
-                                        break;
-                                case WDIOS_DISABLECARD:
-                                        return mtx1_wdt_stop();
-                                default:
-                                        return -EINVAL;
-                        }
-                        break;
-                default:
-                        return -ENOTTY;
+        switch (cmd) {
+        case WDIOC_GETSUPPORT:
+                if (copy_to_user(argp, &ident, sizeof(ident)))
+                        return -EFAULT;
+                break;
+        case WDIOC_GETSTATUS:
+        case WDIOC_GETBOOTSTATUS:
+                put_user(0, p);
+                break;
+        case WDIOC_SETOPTIONS:
+                if (get_user(value, p))
+                        return -EFAULT;
+                if (value & WDIOS_ENABLECARD)
+                        mtx1_wdt_start();
+                else if (value & WDIOS_DISABLECARD)
+                        mtx1_wdt_stop();
+                else
+                        return -EINVAL;
+                return 0;
+        case WDIOC_KEEPALIVE:
+                mtx1_wdt_reset();
+                break;
+        default:
+                return -ENOTTY;
         }
         return 0;
 }
 
 
-static ssize_t mtx1_wdt_write(struct file *file, const char *buf, size_t count, loff_t *ppos)
+static ssize_t mtx1_wdt_write(struct file *file, const char *buf,
+                                                size_t count, loff_t *ppos)
 {
         if (!count)
                 return -EIO;
-
         mtx1_wdt_reset();
         return count;
 }
@@ -188,17 +188,17 @@ static ssize_t mtx1_wdt_write(struct file *file, const char *buf, size_t count,
 static const struct file_operations mtx1_wdt_fops = {
         .owner          = THIS_MODULE,
         .llseek         = no_llseek,
-        .ioctl          = mtx1_wdt_ioctl,
+        .unlocked_ioctl = mtx1_wdt_ioctl,
         .open           = mtx1_wdt_open,
         .write          = mtx1_wdt_write,
-        .release        = mtx1_wdt_release
+        .release        = mtx1_wdt_release,
 };
 
 
 static struct miscdevice mtx1_wdt_misc = {
         .minor  = WATCHDOG_MINOR,
         .name   = "watchdog",
-        .fops   = &mtx1_wdt_fops
+        .fops   = &mtx1_wdt_fops,
 };
 
 
@@ -208,29 +208,26 @@ static int mtx1_wdt_probe(struct platform_device *pdev)
 
         mtx1_wdt_device.gpio = pdev->resource[0].start;
 
-        if ((ret = misc_register(&mtx1_wdt_misc)) < 0) {
-                printk(KERN_ERR " mtx-1_wdt : failed to register\n");
-                return ret;
-        }
-
+        spin_lock_init(&mtx1_wdt_device.lock);
         init_completion(&mtx1_wdt_device.stop);
         mtx1_wdt_device.queue = 0;
-
         clear_bit(0, &mtx1_wdt_device.inuse);
-
         setup_timer(&mtx1_wdt_device.timer, mtx1_wdt_trigger, 0L);
-
         mtx1_wdt_device.default_ticks = ticks;
 
+        ret = misc_register(&mtx1_wdt_misc);
+        if (ret < 0) {
+                printk(KERN_ERR " mtx-1_wdt : failed to register\n");
+                return ret;
+        }
         mtx1_wdt_start();
-
         printk(KERN_INFO "MTX-1 Watchdog driver\n");
-
         return 0;
 }
 
 static int mtx1_wdt_remove(struct platform_device *pdev)
 {
+        /* FIXME: do we need to lock this test ? */
         if (mtx1_wdt_device.queue) {
                 mtx1_wdt_device.queue = 0;
                 wait_for_completion(&mtx1_wdt_device.stop);
diff --git a/drivers/watchdog/mv64x60_wdt.c b/drivers/watchdog/mv64x60_wdt.c
index b59ca3273967..acf589dc057c 100644
--- a/drivers/watchdog/mv64x60_wdt.c
+++ b/drivers/watchdog/mv64x60_wdt.c
@@ -8,7 +8,7 @@
  * and services the watchdog.
  *
  * Derived from mpc8xx_wdt.c, with the following copyright.
- * 
+ *
  * 2002 (c) Florian Schirmer <jolt@tuxbox.org> This file is licensed under
  * the terms of the GNU General Public License version 2. This program
  * is licensed "as is" without any warranty of any kind, whether express
@@ -22,10 +22,9 @@
 #include <linux/module.h>
 #include <linux/watchdog.h>
 #include <linux/platform_device.h>
-
 #include <linux/mv643xx.h>
-#include <asm/uaccess.h>
-#include <asm/io.h>
+#include <linux/uaccess.h>
+#include <linux/io.h>
 
 #define MV64x60_WDT_WDC_OFFSET  0
 
@@ -61,7 +60,9 @@ static DEFINE_SPINLOCK(mv64x60_wdt_spinlock);
 
 static int nowayout = WATCHDOG_NOWAYOUT;
 module_param(nowayout, int, 0);
-MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+MODULE_PARM_DESC(nowayout,
+                "Watchdog cannot be stopped once started (default="
+                                __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 
 static int mv64x60_wdt_toggle_wdc(int enabled_predicate, int field_shift)
 {
@@ -150,7 +151,7 @@ static int mv64x60_wdt_release(struct inode *inode, struct file *file)
 }
 
 static ssize_t mv64x60_wdt_write(struct file *file, const char __user *data,
-                                 size_t len, loff_t * ppos)
+                                 size_t len, loff_t *ppos)
 {
         if (len) {
                 if (!nowayout) {
@@ -160,7 +161,7 @@ static ssize_t mv64x60_wdt_write(struct file *file, const char __user *data,
 
                         for (i = 0; i != len; i++) {
                                 char c;
-                                if(get_user(c, data + i))
+                                if (get_user(c, data + i))
                                         return -EFAULT;
                                 if (c == 'V')
                                         expect_close = 42;
@@ -172,8 +173,8 @@ static ssize_t mv64x60_wdt_write(struct file *file, const char __user *data,
         return len;
 }
 
-static int mv64x60_wdt_ioctl(struct inode *inode, struct file *file,
-                             unsigned int cmd, unsigned long arg)
+static long mv64x60_wdt_ioctl(struct file *file,
+                                        unsigned int cmd, unsigned long arg)
 {
         int timeout;
         int options;
@@ -240,7 +241,7 @@ static const struct file_operations mv64x60_wdt_fops = {
         .owner = THIS_MODULE,
         .llseek = no_llseek,
         .write = mv64x60_wdt_write,
-        .ioctl = mv64x60_wdt_ioctl,
+        .unlocked_ioctl = mv64x60_wdt_ioctl,
         .open = mv64x60_wdt_open,
         .release = mv64x60_wdt_release,
 };
diff --git a/drivers/watchdog/omap_wdt.c b/drivers/watchdog/omap_wdt.c
index 74bc39aa1ce8..6f5420f478a9 100644
--- a/drivers/watchdog/omap_wdt.c
+++ b/drivers/watchdog/omap_wdt.c
@@ -40,10 +40,9 @@
 #include <linux/moduleparam.h>
 #include <linux/clk.h>
 #include <linux/bitops.h>
-
-#include <asm/io.h>
-#include <asm/uaccess.h>
-#include <asm/hardware.h>
+#include <linux/io.h>
+#include <linux/uaccess.h>
+#include <linux/hardware.h>
 
 #include <asm/arch/prcm.h>
 
@@ -54,11 +53,12 @@ module_param(timer_margin, uint, 0);
 MODULE_PARM_DESC(timer_margin, "initial watchdog timeout (in seconds)");
 
 static int omap_wdt_users;
-static struct clk *armwdt_ck = NULL;
-static struct clk *mpu_wdt_ick = NULL;
-static struct clk *mpu_wdt_fck = NULL;
+static struct clk *armwdt_ck;
+static struct clk *mpu_wdt_ick;
+static struct clk *mpu_wdt_fck;
 
 static unsigned int wdt_trgr_pattern = 0x1234;
+static spinlock_t wdt_lock;
 
 static void omap_wdt_ping(void)
 {
@@ -174,30 +174,29 @@ static int omap_wdt_release(struct inode *inode, struct file *file)
         return 0;
 }
 
-static ssize_t
-omap_wdt_write(struct file *file, const char __user *data,
+static ssize_t omap_wdt_write(struct file *file, const char __user *data,
                 size_t len, loff_t *ppos)
 {
         /* Refresh LOAD_TIME. */
-        if (len)
+        if (len) {
+                spin_lock(&wdt_lock);
                 omap_wdt_ping();
+                spin_unlock(&wdt_lock);
+        }
         return len;
 }
 
-static int
-omap_wdt_ioctl(struct inode *inode, struct file *file,
-        unsigned int cmd, unsigned long arg)
+static long omap_wdt_ioctl(struct file *file, unsigned int cmd,
+                                                unsigned long arg)
 {
         int new_margin;
-        static struct watchdog_info ident = {
+        static const struct watchdog_info ident = {
                 .identity = "OMAP Watchdog",
                 .options = WDIOF_SETTIMEOUT,
                 .firmware_version = 0,
         };
 
         switch (cmd) {
-        default:
-                return -ENOTTY;
         case WDIOC_GETSUPPORT:
                 return copy_to_user((struct watchdog_info __user *)arg, &ident,
                                 sizeof(ident));
@@ -211,28 +210,34 @@ omap_wdt_ioctl(struct inode *inode, struct file *file,
                         return put_user(omap_prcm_get_reset_sources(),
                                         (int __user *)arg);
         case WDIOC_KEEPALIVE:
+                spin_lock(&wdt_lock);
                 omap_wdt_ping();
+                spin_unlock(&wdt_lock);
                 return 0;
         case WDIOC_SETTIMEOUT:
                 if (get_user(new_margin, (int __user *)arg))
                         return -EFAULT;
                 omap_wdt_adjust_timeout(new_margin);
 
+                spin_lock(&wdt_lock);
                 omap_wdt_disable();
                 omap_wdt_set_timeout();
                 omap_wdt_enable();
 
                 omap_wdt_ping();
+                spin_unlock(&wdt_lock);
                 /* Fall */
         case WDIOC_GETTIMEOUT:
                 return put_user(timer_margin, (int __user *)arg);
+        default:
+                return -ENOTTY;
         }
 }
 
 static const struct file_operations omap_wdt_fops = {
         .owner = THIS_MODULE,
         .write = omap_wdt_write,
-        .ioctl = omap_wdt_ioctl,
+        .unlocked_ioctl = omap_wdt_ioctl,
         .open = omap_wdt_open,
         .release = omap_wdt_release,
 };
@@ -240,7 +245,7 @@ static const struct file_operations omap_wdt_fops = {
 static struct miscdevice omap_wdt_miscdev = {
         .minor = WATCHDOG_MINOR,
         .name = "watchdog",
-        .fops = &omap_wdt_fops
+        .fops = &omap_wdt_fops,
 };
 
 static int __init omap_wdt_probe(struct platform_device *pdev)
@@ -373,6 +378,7 @@ static struct platform_driver omap_wdt_driver = {
 
 static int __init omap_wdt_init(void)
 {
+        spin_lock_init(&wdt_lock);
         return platform_driver_register(&omap_wdt_driver);
 }
 
diff --git a/drivers/watchdog/pc87413_wdt.c b/drivers/watchdog/pc87413_wdt.c
index 15e4f8887a9e..e91ada72da1d 100644
--- a/drivers/watchdog/pc87413_wdt.c
+++ b/drivers/watchdog/pc87413_wdt.c
@@ -31,14 +31,14 @@
 #include <linux/spinlock.h>
 #include <linux/moduleparam.h>
 #include <linux/version.h>
+#include <linux/io.h>
+#include <linux/uaccess.h>
 
-#include <asm/io.h>
-#include <asm/uaccess.h>
 #include <asm/system.h>
 
 /* #define DEBUG 1 */
 
-#define DEFAULT_TIMEOUT     1            /* 1 minute */
+#define DEFAULT_TIMEOUT     1           /* 1 minute */
 #define MAX_TIMEOUT         255
 
 #define VERSION             "1.1"
@@ -46,22 +46,22 @@
 #define PFX                 MODNAME ": "
 #define DPFX                MODNAME " - DEBUG: "
 
-#define WDT_INDEX_IO_PORT   (io+0)       /* I/O port base (index register) */
+#define WDT_INDEX_IO_PORT   (io+0)      /* I/O port base (index register) */
 #define WDT_DATA_IO_PORT    (WDT_INDEX_IO_PORT+1)
 #define SWC_LDN             0x04
-#define SIOCFG2             0x22         /* Serial IO register */
-#define WDCTL               0x10         /* Watchdog-Timer-Controll-Register */
-#define WDTO                0x11         /* Watchdog timeout register */
-#define WDCFG               0x12         /* Watchdog config register */
+#define SIOCFG2             0x22        /* Serial IO register */
+#define WDCTL               0x10        /* Watchdog-Timer-Controll-Register */
+#define WDTO                0x11        /* Watchdog timeout register */
+#define WDCFG               0x12        /* Watchdog config register */
 
-static int io = 0x2E;                    /* Address used on Portwell Boards */
+static int io = 0x2E;                   /* Address used on Portwell Boards */
 
-static int timeout = DEFAULT_TIMEOUT;    /* timeout value */
-static unsigned long timer_enabled = 0;  /* is the timer enabled? */
+static int timeout = DEFAULT_TIMEOUT;   /* timeout value */
+static unsigned long timer_enabled;     /* is the timer enabled? */
 
-static char expect_close;                /* is the close expected? */
+static char expect_close;               /* is the close expected? */
 
-static DEFINE_SPINLOCK(io_lock);/* to guard the watchdog from io races */
+static DEFINE_SPINLOCK(io_lock);        /* to guard us from io races */
 
 static int nowayout = WATCHDOG_NOWAYOUT;
 
@@ -69,7 +69,7 @@ static int nowayout = WATCHDOG_NOWAYOUT;
 
 /* Select pins for Watchdog output */
 
-static inline void pc87413_select_wdt_out (void)
+static inline void pc87413_select_wdt_out(void)
 {
         unsigned int cr_data = 0;
 
@@ -77,7 +77,7 @@ static inline void pc87413_select_wdt_out (void)
 
         outb_p(SIOCFG2, WDT_INDEX_IO_PORT);
 
-        cr_data = inb (WDT_DATA_IO_PORT);
+        cr_data = inb(WDT_DATA_IO_PORT);
 
         cr_data |= 0x80; /* Set Bit7 to 1*/
         outb_p(SIOCFG2, WDT_INDEX_IO_PORT);
@@ -85,8 +85,9 @@ static inline void pc87413_select_wdt_out (void)
         outb_p(cr_data, WDT_DATA_IO_PORT);
 
 #ifdef DEBUG
-        printk(KERN_INFO DPFX "Select multiple pin,pin55,as WDT output:"
-                              " Bit7 to 1: %d\n", cr_data);
+        printk(KERN_INFO DPFX
+                "Select multiple pin,pin55,as WDT output: Bit7 to 1: %d\n",
+                                                                cr_data);
 #endif
 }
 
@@ -94,18 +95,18 @@ static inline void pc87413_select_wdt_out (void)
 
 static inline void pc87413_enable_swc(void)
 {
-        unsigned int cr_data=0;
+        unsigned int cr_data = 0;
 
         /* Step 2: Enable SWC functions */
 
-        outb_p(0x07, WDT_INDEX_IO_PORT);        /* Point SWC_LDN (LDN=4) */
+        outb_p(0x07, WDT_INDEX_IO_PORT);        /* Point SWC_LDN (LDN=4) */
         outb_p(SWC_LDN, WDT_DATA_IO_PORT);
 
-        outb_p(0x30, WDT_INDEX_IO_PORT);        /* Read Index 0x30 First */
+        outb_p(0x30, WDT_INDEX_IO_PORT);        /* Read Index 0x30 First */
         cr_data = inb(WDT_DATA_IO_PORT);
-        cr_data |= 0x01;                        /* Set Bit0 to 1 */
+        cr_data |= 0x01;                        /* Set Bit0 to 1 */
         outb_p(0x30, WDT_INDEX_IO_PORT);
-        outb_p(cr_data, WDT_DATA_IO_PORT);      /* Index0x30_bit0P1 */
+        outb_p(cr_data, WDT_DATA_IO_PORT);      /* Index0x30_bit0P1 */
 
 #ifdef DEBUG
         printk(KERN_INFO DPFX "pc87413 - Enable SWC functions\n");
@@ -121,20 +122,19 @@ static inline unsigned int pc87413_get_swc_base(void)
 
         /* Step 3: Read SWC I/O Base Address */
 
-        outb_p(0x60, WDT_INDEX_IO_PORT);        /* Read Index 0x60 */
+        outb_p(0x60, WDT_INDEX_IO_PORT);        /* Read Index 0x60 */
         addr_h = inb(WDT_DATA_IO_PORT);
 
-        outb_p(0x61, WDT_INDEX_IO_PORT);        /* Read Index 0x61 */
+        outb_p(0x61, WDT_INDEX_IO_PORT);        /* Read Index 0x61 */
 
         addr_l = inb(WDT_DATA_IO_PORT);
 
         swc_base_addr = (addr_h << 8) + addr_l;
-
 #ifdef DEBUG
-        printk(KERN_INFO DPFX "Read SWC I/O Base Address: low %d, high %d,"
-                              " res %d\n", addr_l, addr_h, swc_base_addr);
+        printk(KERN_INFO DPFX
+                "Read SWC I/O Base Address: low %d, high %d, res %d\n",
+                                                addr_l, addr_h, swc_base_addr);
 #endif
-
         return swc_base_addr;
 }
 
@@ -143,9 +143,7 @@ static inline unsigned int pc87413_get_swc_base(void)
 static inline void pc87413_swc_bank3(unsigned int swc_base_addr)
 {
         /* Step 4: Select Bank3 of SWC */
-
         outb_p(inb(swc_base_addr + 0x0f) | 0x03, swc_base_addr + 0x0f);
-
 #ifdef DEBUG
         printk(KERN_INFO DPFX "Select Bank3 of SWC\n");
 #endif
@@ -157,9 +155,7 @@ static inline void pc87413_programm_wdto(unsigned int swc_base_addr,
                                          char pc87413_time)
 {
         /* Step 5: Programm WDTO, Twd. */
-
         outb_p(pc87413_time, swc_base_addr + WDTO);
-
 #ifdef DEBUG
         printk(KERN_INFO DPFX "Set WDTO to %d minutes\n", pc87413_time);
 #endif
@@ -170,9 +166,7 @@ static inline void pc87413_programm_wdto(unsigned int swc_base_addr,
 static inline void pc87413_enable_wden(unsigned int swc_base_addr)
 {
         /* Step 6: Enable WDEN */
-
-        outb_p(inb (swc_base_addr + WDCTL) | 0x01, swc_base_addr + WDCTL);
-
+        outb_p(inb(swc_base_addr + WDCTL) | 0x01, swc_base_addr + WDCTL);
 #ifdef DEBUG
         printk(KERN_INFO DPFX "Enable WDEN\n");
 #endif
@@ -182,9 +176,7 @@ static inline void pc87413_enable_wden(unsigned int swc_base_addr)
 static inline void pc87413_enable_sw_wd_tren(unsigned int swc_base_addr)
 {
         /* Enable SW_WD_TREN */
-
-        outb_p(inb (swc_base_addr + WDCFG) | 0x80, swc_base_addr + WDCFG);
-
+        outb_p(inb(swc_base_addr + WDCFG) | 0x80, swc_base_addr + WDCFG);
 #ifdef DEBUG
         printk(KERN_INFO DPFX "Enable SW_WD_TREN\n");
 #endif
@@ -195,9 +187,7 @@ static inline void pc87413_enable_sw_wd_tren(unsigned int swc_base_addr)
 static inline void pc87413_disable_sw_wd_tren(unsigned int swc_base_addr)
 {
         /* Disable SW_WD_TREN */
-
-        outb_p(inb (swc_base_addr + WDCFG) & 0x7f, swc_base_addr + WDCFG);
-
+        outb_p(inb(swc_base_addr + WDCFG) & 0x7f, swc_base_addr + WDCFG);
 #ifdef DEBUG
         printk(KERN_INFO DPFX "pc87413 - Disable SW_WD_TREN\n");
 #endif
@@ -208,9 +198,7 @@ static inline void pc87413_disable_sw_wd_tren(unsigned int swc_base_addr)
 static inline void pc87413_enable_sw_wd_trg(unsigned int swc_base_addr)
 {
         /* Enable SW_WD_TRG */
-
-        outb_p(inb (swc_base_addr + WDCTL) | 0x80, swc_base_addr + WDCTL);
-
+        outb_p(inb(swc_base_addr + WDCTL) | 0x80, swc_base_addr + WDCTL);
 #ifdef DEBUG
         printk(KERN_INFO DPFX "pc87413 - Enable SW_WD_TRG\n");
 #endif
@@ -221,9 +209,7 @@ static inline void pc87413_enable_sw_wd_trg(unsigned int swc_base_addr)
 static inline void pc87413_disable_sw_wd_trg(unsigned int swc_base_addr)
 {
         /* Disable SW_WD_TRG */
-
-        outb_p(inb (swc_base_addr + WDCTL) & 0x7f, swc_base_addr + WDCTL);
-
+        outb_p(inb(swc_base_addr + WDCTL) & 0x7f, swc_base_addr + WDCTL);
 #ifdef DEBUG
         printk(KERN_INFO DPFX "Disable SW_WD_TRG\n");
 #endif
@@ -314,8 +300,8 @@ static int pc87413_open(struct inode *inode, struct file *file)
         /* Reload and activate timer */
         pc87413_refresh();
 
-        printk(KERN_INFO MODNAME "Watchdog enabled. Timeout set to"
-                                 " %d minute(s).\n", timeout);
+        printk(KERN_INFO MODNAME
+                "Watchdog enabled. Timeout set to %d minute(s).\n", timeout);
 
         return nonseekable_open(inode, file);
 }
@@ -338,17 +324,15 @@ static int pc87413_release(struct inode *inode, struct file *file)
 
         if (expect_close == 42) {
                 pc87413_disable();
-                printk(KERN_INFO MODNAME "Watchdog disabled,"
-                                         " sleeping again...\n");
+                printk(KERN_INFO MODNAME
+                                "Watchdog disabled, sleeping again...\n");
         } else {
-                printk(KERN_CRIT MODNAME "Unexpected close, not stopping"
-                                         " watchdog!\n");
+                printk(KERN_CRIT MODNAME
+                                "Unexpected close, not stopping watchdog!\n");
                 pc87413_refresh();
         }
-
         clear_bit(0, &timer_enabled);
         expect_close = 0;
-
         return 0;
 }
 
@@ -386,10 +370,11 @@ static ssize_t pc87413_write(struct file *file, const char __user *data,
                         /* reset expect flag */
                         expect_close = 0;
 
-                        /* scan to see whether or not we got the magic character */
+                        /* scan to see whether or not we got the
+                           magic character */
                         for (i = 0; i != len; i++) {
                                 char c;
-                                if (get_user(c, data+i))
+                                if (get_user(c, data + i))
                                         return -EFAULT;
                                 if (c == 'V')
                                         expect_close = 42;
@@ -404,7 +389,6 @@ static ssize_t pc87413_write(struct file *file, const char __user *data,
 
 /**
  *      pc87413_ioctl:
- *      @inode: inode of the device
  *      @file: file handle to the device
  *      @cmd: watchdog command
  *      @arg: argument pointer
@@ -414,8 +398,8 @@ static ssize_t pc87413_write(struct file *file, const char __user *data,
  *      querying capabilities and current status.
  */
 
-static int pc87413_ioctl(struct inode *inode, struct file *file,
-                         unsigned int cmd, unsigned long arg)
+static long pc87413_ioctl(struct file *file, unsigned int cmd,
+                                                unsigned long arg)
 {
         int new_timeout;
 
@@ -426,75 +410,58 @@ static int pc87413_ioctl(struct inode *inode, struct file *file,
 
         static struct watchdog_info ident = {
                 .options          = WDIOF_KEEPALIVEPING |
-                                    WDIOF_SETTIMEOUT |
-                                    WDIOF_MAGICCLOSE,
+                                    WDIOF_SETTIMEOUT |
+                                    WDIOF_MAGICCLOSE,
                 .firmware_version = 1,
-                .identity         = "PC87413(HF/F) watchdog"
+                .identity         = "PC87413(HF/F) watchdog",
         };
 
         uarg.i = (int __user *)arg;
 
-        switch(cmd) {
-                default:
-                        return -ENOTTY;
-
-                case WDIOC_GETSUPPORT:
-                        return copy_to_user(uarg.ident, &ident,
-                                sizeof(ident)) ? -EFAULT : 0;
-
-                case WDIOC_GETSTATUS:
-                        return put_user(pc87413_status(), uarg.i);
-
-                case WDIOC_GETBOOTSTATUS:
-                        return put_user(0, uarg.i);
-
-                case WDIOC_KEEPALIVE:
-                        pc87413_refresh();
+        switch (cmd) {
+        case WDIOC_GETSUPPORT:
+                return copy_to_user(uarg.ident, &ident,
+                                        sizeof(ident)) ? -EFAULT : 0;
+        case WDIOC_GETSTATUS:
+                return put_user(pc87413_status(), uarg.i);
+        case WDIOC_GETBOOTSTATUS:
+                return put_user(0, uarg.i);
+        case WDIOC_SETOPTIONS:
+        {
+                int options, retval = -EINVAL;
+                if (get_user(options, uarg.i))
+                        return -EFAULT;
+                if (options & WDIOS_DISABLECARD) {
+                        pc87413_disable();
+                        retval = 0;
+                }
+                if (options & WDIOS_ENABLECARD) {
+                        pc87413_enable();
+                        retval = 0;
+                }
+                return retval;
+        }
+        case WDIOC_KEEPALIVE:
+                pc87413_refresh();
 #ifdef DEBUG
-                        printk(KERN_INFO DPFX "keepalive\n");
+                printk(KERN_INFO DPFX "keepalive\n");
 #endif
-                        return 0;
-
-                case WDIOC_SETTIMEOUT:
-                        if (get_user(new_timeout, uarg.i))
-                                return -EFAULT;
-
-                        // the API states this is given in secs
-                        new_timeout /= 60;
-
-                        if (new_timeout < 0 || new_timeout > MAX_TIMEOUT)
-                                return -EINVAL;
-
-                        timeout = new_timeout;
-                        pc87413_refresh();
-
-                        // fall through and return the new timeout...
-
-                case WDIOC_GETTIMEOUT:
-
-                        new_timeout = timeout * 60;
-
-                        return put_user(new_timeout, uarg.i);
-
-                case WDIOC_SETOPTIONS:
-                {
-                        int options, retval = -EINVAL;
-
-                        if (get_user(options, uarg.i))
-                                return -EFAULT;
-
-                        if (options & WDIOS_DISABLECARD) {
-                                pc87413_disable();
-                                retval = 0;
-                        }
-
-                        if (options & WDIOS_ENABLECARD) {
-                                pc87413_enable();
-                                retval = 0;
-                        }
-
-                        return retval;
-                }
+                return 0;
+        case WDIOC_SETTIMEOUT:
+                if (get_user(new_timeout, uarg.i))
+                        return -EFAULT;
+                /* the API states this is given in secs */
+                new_timeout /= 60;
+                if (new_timeout < 0 || new_timeout > MAX_TIMEOUT)
+                        return -EINVAL;
+                timeout = new_timeout;
+                pc87413_refresh();
+                /* fall through and return the new timeout... */
+        case WDIOC_GETTIMEOUT:
+                new_timeout = timeout * 60;
+                return put_user(new_timeout, uarg.i);
+        default:
+                return -ENOTTY;
         }
 }
 
@@ -517,10 +484,8 @@ static int pc87413_notify_sys(struct notifier_block *this,
                               void *unused)
 {
         if (code == SYS_DOWN || code == SYS_HALT)
-        {
                 /* Turn the card off */
                 pc87413_disable();
-        }
         return NOTIFY_DONE;
 }
 
@@ -530,21 +495,19 @@ static const struct file_operations pc87413_fops = {
         .owner          = THIS_MODULE,
         .llseek         = no_llseek,
         .write          = pc87413_write,
-        .ioctl          = pc87413_ioctl,
+        .unlocked_ioctl = pc87413_ioctl,
         .open           = pc87413_open,
         .release        = pc87413_release,
 };
 
-static struct notifier_block pc87413_notifier =
-{
+static struct notifier_block pc87413_notifier = {
         .notifier_call  = pc87413_notify_sys,
 };
 
-static struct miscdevice pc87413_miscdev=
-{
+static struct miscdevice pc87413_miscdev = {
         .minor          = WATCHDOG_MINOR,
         .name           = "watchdog",
-        .fops           = &pc87413_fops
+        .fops           = &pc87413_fops,
 };
 
 /* -- Module init functions -------------------------------------*/
@@ -561,29 +524,26 @@ static int __init pc87413_init(void)
 {
         int ret;
 
-        printk(KERN_INFO PFX "Version " VERSION " at io 0x%X\n", WDT_INDEX_IO_PORT);
+        printk(KERN_INFO PFX "Version " VERSION " at io 0x%X\n",
+                                                        WDT_INDEX_IO_PORT);
 
         /* request_region(io, 2, "pc87413"); */
 
         ret = register_reboot_notifier(&pc87413_notifier);
         if (ret != 0) {
-                printk(KERN_ERR PFX "cannot register reboot notifier (err=%d)\n",
-                        ret);
+                printk(KERN_ERR PFX
+                        "cannot register reboot notifier (err=%d)\n", ret);
         }
 
         ret = misc_register(&pc87413_miscdev);
-
         if (ret != 0) {
                 printk(KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",
                         WATCHDOG_MINOR, ret);
                 unregister_reboot_notifier(&pc87413_notifier);
                 return ret;
         }
-
         printk(KERN_INFO PFX "initialized. timeout=%d min \n", timeout);
-
         pc87413_enable();
-
         return 0;
 }
 
@@ -600,17 +560,16 @@ static int __init pc87413_init(void)
 static void __exit pc87413_exit(void)
 {
         /* Stop the timer before we leave */
-        if (!nowayout)
-        {
+        if (!nowayout) {
                 pc87413_disable();
                 printk(KERN_INFO MODNAME "Watchdog disabled.\n");
         }
 
         misc_deregister(&pc87413_miscdev);
         unregister_reboot_notifier(&pc87413_notifier);
-        /* release_region(io,2); */
+        /* release_region(io, 2); */
 
-        printk(MODNAME " watchdog component driver removed.\n");
+        printk(KERN_INFO MODNAME " watchdog component driver removed.\n");
 }
 
 module_init(pc87413_init);
@@ -626,8 +585,12 @@ module_param(io, int, 0);
 MODULE_PARM_DESC(io, MODNAME " I/O port (default: " __MODULE_STRING(io) ").");
 
 module_param(timeout, int, 0);
-MODULE_PARM_DESC(timeout, "Watchdog timeout in minutes (default=" __MODULE_STRING(timeout) ").");
+MODULE_PARM_DESC(timeout,
+                "Watchdog timeout in minutes (default="
+                                __MODULE_STRING(timeout) ").");
 
 module_param(nowayout, int, 0);
-MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+MODULE_PARM_DESC(nowayout,
+                "Watchdog cannot be stopped once started (default="
+                                __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 
diff --git a/drivers/watchdog/pcwd.c b/drivers/watchdog/pcwd.c
index 7b41434fac8c..3b0ddc7fcf3f 100644
--- a/drivers/watchdog/pcwd.c
+++ b/drivers/watchdog/pcwd.c
@@ -40,13 +40,15 @@
  *              fairly useless proc entry.
  * 990610       removed said useless proc code for the merge <alan>
  * 000403       Removed last traces of proc code. <davej>
- * 011214       Added nowayout module option to override CONFIG_WATCHDOG_NOWAYOUT <Matt_Domsch@dell.com>
+ * 011214       Added nowayout module option to override
+ *              CONFIG_WATCHDOG_NOWAYOUT <Matt_Domsch@dell.com>
  *              Added timeout module option to override default
  */
 
 /*
  *      A bells and whistles driver is available from http://www.pcwd.de/
- *      More info available at http://www.berkprod.com/ or http://www.pcwatchdog.com/
+ *      More info available at http://www.berkprod.com/ or
+ *      http://www.pcwatchdog.com/
  */
 
 #include <linux/module.h>       /* For module specific items */
@@ -65,9 +67,8 @@
 #include <linux/isa.h>          /* For isa devices */
 #include <linux/ioport.h>       /* For io-port access */
 #include <linux/spinlock.h>     /* For spin_lock/spin_unlock/... */
-
-#include <asm/uaccess.h>        /* For copy_to_user/put_user/... */
-#include <asm/io.h>             /* For inb/outb/... */
+#include <linux/uaccess.h>      /* For copy_to_user/put_user/... */
+#include <linux/io.h>           /* For inb/outb/... */
 
 /* Module and version information */
 #define WATCHDOG_VERSION "1.20"
@@ -111,14 +112,16 @@ static int pcwd_ioports[] = { 0x270, 0x350, 0x370, 0x000 };
 #define WD_REVC_WTRP            0x01    /* Watchdog Trip status */
 #define WD_REVC_HRBT            0x02    /* Watchdog Heartbeat */
 #define WD_REVC_TTRP            0x04    /* Temperature Trip status */
-#define WD_REVC_RL2A            0x08    /* Relay 2 activated by on-board processor */
+#define WD_REVC_RL2A            0x08    /* Relay 2 activated by
+                                                        on-board processor */
 #define WD_REVC_RL1A            0x10    /* Relay 1 active */
 #define WD_REVC_R2DS            0x40    /* Relay 2 disable */
 #define WD_REVC_RLY2            0x80    /* Relay 2 activated? */
 /* Port 2 : Control Status #2 */
 #define WD_WDIS                 0x10    /* Watchdog Disabled */
 #define WD_ENTP                 0x20    /* Watchdog Enable Temperature Trip */
-#define WD_SSEL                 0x40    /* Watchdog Switch Select (1:SW1 <-> 0:SW2) */
+#define WD_SSEL                 0x40    /* Watchdog Switch Select
+                                                        (1:SW1 <-> 0:SW2) */
 #define WD_WCMD                 0x80    /* Watchdog Command Mode */
 
 /* max. time we give an ISA watchdog card to process a command */
@@ -142,7 +145,7 @@ static int pcwd_ioports[] = { 0x270, 0x350, 0x370, 0x000 };
 #define CMD_ISA_RESET_RELAYS            0x0D
 
 /* Watchdog's Dip Switch heartbeat values */
-static const int heartbeat_tbl [] = {
+static const int heartbeat_tbl[] = {
         20,     /* OFF-OFF-OFF  = 20 Sec  */
         40,     /* OFF-OFF-ON   = 40 Sec  */
         60,     /* OFF-ON-OFF   =  1 Min  */
@@ -168,11 +171,15 @@ static int cards_found;
 static atomic_t open_allowed = ATOMIC_INIT(1);
 static char expect_close;
 static int temp_panic;
-static struct {                         /* this is private data for each ISA-PC watchdog card */
+
+/* this is private data for each ISA-PC watchdog card */
+static struct {
         char fw_ver_str[6];             /* The cards firmware version */
         int revision;                   /* The card's revision */
-        int supports_temp;              /* Wether or not the card has a temperature device */
-        int command_mode;               /* Wether or not the card is in command mode */
+        int supports_temp;              /* Whether or not the card has
+                                                a temperature device */
+        int command_mode;               /* Whether or not the card is in
+                                                command mode */
         int boot_status;                /* The card's boot status */
         int io_addr;                    /* The cards I/O address */
         spinlock_t io_lock;             /* the lock for io operations */
@@ -186,16 +193,20 @@ static struct {				/* this is private data for each ISA-PC watchdog card */
 #define DEBUG   2       /* print fancy stuff too */
 static int debug = QUIET;
 module_param(debug, int, 0);
-MODULE_PARM_DESC(debug, "Debug level: 0=Quiet, 1=Verbose, 2=Debug (default=0)");
+MODULE_PARM_DESC(debug,
+                "Debug level: 0=Quiet, 1=Verbose, 2=Debug (default=0)");
 
-#define WATCHDOG_HEARTBEAT 0            /* default heartbeat = delay-time from dip-switches */
+/* default heartbeat = delay-time from dip-switches */
+#define WATCHDOG_HEARTBEAT 0
 static int heartbeat = WATCHDOG_HEARTBEAT;
 module_param(heartbeat, int, 0);
-MODULE_PARM_DESC(heartbeat, "Watchdog heartbeat in seconds. (2<=heartbeat<=7200 or 0=delay-time from dip-switches, default=" __MODULE_STRING(WATCHDOG_HEARTBEAT) ")");
+MODULE_PARM_DESC(heartbeat, "Watchdog heartbeat in seconds. (2 <= heartbeat <= 7200 or 0=delay-time from dip-switches, default=" __MODULE_STRING(WATCHDOG_HEARTBEAT) ")");
 
 static int nowayout = WATCHDOG_NOWAYOUT;
 module_param(nowayout, int, 0);
-MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+MODULE_PARM_DESC(nowayout,
+                "Watchdog cannot be stopped once started (default="
+                                __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 
 /*
  *      Internal functions
@@ -224,7 +235,7 @@ static int send_isa_command(int cmd)
                 if (port0 == last_port0)
                         break;  /* Data is stable */
 
-                udelay (250);
+                udelay(250);
         }
 
         if (debug >= DEBUG)
@@ -236,7 +247,7 @@ static int send_isa_command(int cmd)
 
 static int set_command_mode(void)
 {
-        int i, found=0, count=0;
+        int i, found = 0, count = 0;
 
         /* Set the card into command mode */
         spin_lock(&pcwd_private.io_lock);
@@ -261,7 +272,7 @@ static int set_command_mode(void)
                 printk(KERN_DEBUG PFX "command_mode=%d\n",
                                 pcwd_private.command_mode);
 
-        return(found);
+        return found;
 }
 
 static void unset_command_mode(void)
@@ -296,7 +307,8 @@ static inline void pcwd_get_firmware(void)
                 ten = send_isa_command(CMD_ISA_VERSION_TENTH);
                 hund = send_isa_command(CMD_ISA_VERSION_HUNDRETH);
                 minor = send_isa_command(CMD_ISA_VERSION_MINOR);
-                sprintf(pcwd_private.fw_ver_str, "%c.%c%c%c", one, ten, hund, minor);
+                sprintf(pcwd_private.fw_ver_str, "%c.%c%c%c",
+                                        one, ten, hund, minor);
         }
         unset_command_mode();
 
@@ -305,7 +317,7 @@ static inline void pcwd_get_firmware(void)
 
 static inline int pcwd_get_option_switches(void)
 {
-        int option_switches=0;
+        int option_switches = 0;
 
         if (set_command_mode()) {
                 /* Get switch settings */
@@ -313,7 +325,7 @@ static inline int pcwd_get_option_switches(void)
         }
 
         unset_command_mode();
-        return(option_switches);
+        return option_switches;
 }
 
 static void pcwd_show_card_info(void)
@@ -322,7 +334,9 @@ static void pcwd_show_card_info(void)
 
         /* Get some extra info from the hardware (in command/debug/diag mode) */
         if (pcwd_private.revision == PCWD_REVISION_A)
-                printk(KERN_INFO PFX "ISA-PC Watchdog (REV.A) detected at port 0x%04x\n", pcwd_private.io_addr);
+                printk(KERN_INFO PFX
+                        "ISA-PC Watchdog (REV.A) detected at port 0x%04x\n",
+                                                        pcwd_private.io_addr);
         else if (pcwd_private.revision == PCWD_REVISION_C) {
                 pcwd_get_firmware();
                 printk(KERN_INFO PFX "ISA-PC Watchdog (REV.C) detected at port 0x%04x (Firmware version: %s)\n",
@@ -347,12 +361,15 @@ static void pcwd_show_card_info(void)
                 printk(KERN_INFO PFX "Previous reboot was caused by the card\n");
 
         if (pcwd_private.boot_status & WDIOF_OVERHEAT) {
-                printk(KERN_EMERG PFX "Card senses a CPU Overheat. Panicking!\n");
-                printk(KERN_EMERG PFX "CPU Overheat\n");
+                printk(KERN_EMERG PFX
+                        "Card senses a CPU Overheat. Panicking!\n");
+                printk(KERN_EMERG PFX
+                        "CPU Overheat\n");
         }
 
         if (pcwd_private.boot_status == 0)
-                printk(KERN_INFO PFX "No previous trip detected - Cold boot or reset\n");
+                printk(KERN_INFO PFX
+                        "No previous trip detected - Cold boot or reset\n");
 }
 
 static void pcwd_timer_ping(unsigned long data)
@@ -361,11 +378,12 @@ static void pcwd_timer_ping(unsigned long data)
 
         /* If we got a heartbeat pulse within the WDT_INTERVAL
          * we agree to ping the WDT */
-        if(time_before(jiffies, pcwd_private.next_heartbeat)) {
+        if (time_before(jiffies, pcwd_private.next_heartbeat)) {
                 /* Ping the watchdog */
                 spin_lock(&pcwd_private.io_lock);
                 if (pcwd_private.revision == PCWD_REVISION_A) {
-                        /*  Rev A cards are reset by setting the WD_WDRST bit in register 1 */
+                        /*  Rev A cards are reset by setting the
+                            WD_WDRST bit in register 1 */
                         wdrst_stat = inb_p(pcwd_private.io_addr);
                         wdrst_stat &= 0x0F;
                         wdrst_stat |= WD_WDRST;
@@ -381,7 +399,8 @@ static void pcwd_timer_ping(unsigned long data)
 
                 spin_unlock(&pcwd_private.io_lock);
         } else {
-                printk(KERN_WARNING PFX "Heartbeat lost! Will not ping the watchdog\n");
+                printk(KERN_WARNING PFX
+                        "Heartbeat lost! Will not ping the watchdog\n");
         }
 }
 
@@ -454,7 +473,7 @@ static int pcwd_keepalive(void)
 
 static int pcwd_set_heartbeat(int t)
 {
-        if ((t < 2) || (t > 7200)) /* arbitrary upper limit */
+        if (t < 2 || t > 7200) /* arbitrary upper limit */
                 return -EINVAL;
 
         heartbeat = t;
@@ -470,7 +489,7 @@ static int pcwd_get_status(int *status)
 {
         int control_status;
 
-        *status=0;
+        *status = 0;
         spin_lock(&pcwd_private.io_lock);
         if (pcwd_private.revision == PCWD_REVISION_A)
                 /* Rev A cards return status information from
@@ -494,9 +513,9 @@ static int pcwd_get_status(int *status)
                 if (control_status & WD_T110) {
                         *status |= WDIOF_OVERHEAT;
                         if (temp_panic) {
-                                printk(KERN_INFO PFX "Temperature overheat trip!\n");
+                                printk(KERN_INFO PFX
+                                        "Temperature overheat trip!\n");
                                 kernel_power_off();
-                                /* or should we just do a: panic(PFX "Temperature overheat trip!\n"); */
                         }
                 }
         } else {
@@ -506,9 +525,9 @@ static int pcwd_get_status(int *status)
                 if (control_status & WD_REVC_TTRP) {
                         *status |= WDIOF_OVERHEAT;
                         if (temp_panic) {
-                                printk(KERN_INFO PFX "Temperature overheat trip!\n");
+                                printk(KERN_INFO PFX
+                                        "Temperature overheat trip!\n");
                                 kernel_power_off();
-                                /* or should we just do a: panic(PFX "Temperature overheat trip!\n"); */
                         }
                 }
         }
@@ -524,18 +543,21 @@ static int pcwd_clear_status(void)
                 spin_lock(&pcwd_private.io_lock);
 
                 if (debug >= VERBOSE)
-                        printk(KERN_INFO PFX "clearing watchdog trip status\n");
+                        printk(KERN_INFO PFX
+                                        "clearing watchdog trip status\n");
 
                 control_status = inb_p(pcwd_private.io_addr + 1);
 
                 if (debug >= DEBUG) {
-                        printk(KERN_DEBUG PFX "status was: 0x%02x\n", control_status);
+                        printk(KERN_DEBUG PFX "status was: 0x%02x\n",
+                                control_status);
                         printk(KERN_DEBUG PFX "sending: 0x%02x\n",
                                 (control_status & WD_REVC_R2DS));
                 }
 
                 /* clear reset status & Keep Relay 2 disable state as it is */
-                outb_p((control_status & WD_REVC_R2DS), pcwd_private.io_addr + 1);
+                outb_p((control_status & WD_REVC_R2DS),
+                                                pcwd_private.io_addr + 1);
 
                 spin_unlock(&pcwd_private.io_lock);
         }
@@ -572,8 +594,7 @@ static int pcwd_get_temperature(int *temperature)
  *      /dev/watchdog handling
  */
 
-static int pcwd_ioctl(struct inode *inode, struct file *file,
-                      unsigned int cmd, unsigned long arg)
+static long pcwd_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
         int rv;
         int status;
@@ -590,12 +611,9 @@ static int pcwd_ioctl(struct inode *inode, struct file *file,
                 .identity =             "PCWD",
         };
 
-        switch(cmd) {
-        default:
-                return -ENOTTY;
-
+        switch (cmd) {
         case WDIOC_GETSUPPORT:
-                if(copy_to_user(argp, &ident, sizeof(ident)))
+                if (copy_to_user(argp, &ident, sizeof(ident)))
                         return -EFAULT;
                 return 0;
 
@@ -613,25 +631,22 @@ static int pcwd_ioctl(struct inode *inode, struct file *file,
                 return put_user(temperature, argp);
 
         case WDIOC_SETOPTIONS:
-                if (pcwd_private.revision == PCWD_REVISION_C)
-                {
-                        if(copy_from_user(&rv, argp, sizeof(int)))
+                if (pcwd_private.revision == PCWD_REVISION_C) {
+                        if (get_user(rv, argp))
                                 return -EFAULT;
 
-                        if (rv & WDIOS_DISABLECARD)
-                        {
-                                return pcwd_stop();
+                        if (rv & WDIOS_DISABLECARD) {
+                                status = pcwd_stop();
+                                if (status < 0)
+                                        return status;
                         }
-
-                        if (rv & WDIOS_ENABLECARD)
-                        {
-                                return pcwd_start();
+                        if (rv & WDIOS_ENABLECARD) {
+                                status = pcwd_start();
+                                if (status < 0)
+                                        return status;
                         }
-
                         if (rv & WDIOS_TEMPPANIC)
-                        {
                                 temp_panic = 1;
-                        }
                 }
                 return -EINVAL;
 
@@ -651,6 +666,9 @@ static int pcwd_ioctl(struct inode *inode, struct file *file,
 
         case WDIOC_GETTIMEOUT:
                 return put_user(heartbeat, argp);
+
+        default:
+                return -ENOTTY;
         }
 
         return 0;
@@ -682,16 +700,10 @@ static ssize_t pcwd_write(struct file *file, const char __user *buf, size_t len,
 
 static int pcwd_open(struct inode *inode, struct file *file)
 {
-        if (!atomic_dec_and_test(&open_allowed) ) {
-                if (debug >= VERBOSE)
-                        printk(KERN_ERR PFX "Attempt to open already opened device.\n");
-                atomic_inc( &open_allowed );
+        if (test_and_set_bit(0, &open_allowed))
                 return -EBUSY;
-        }
-
         if (nowayout)
                 __module_get(THIS_MODULE);
-
         /* Activate */
         pcwd_start();
         pcwd_keepalive();
@@ -700,14 +712,15 @@ static int pcwd_open(struct inode *inode, struct file *file)
 
 static int pcwd_close(struct inode *inode, struct file *file)
 {
-        if (expect_close == 42) {
+        if (expect_close == 42)
                 pcwd_stop();
-        } else {
-                printk(KERN_CRIT PFX "Unexpected close, not stopping watchdog!\n");
+        else {
+                printk(KERN_CRIT PFX
+                        "Unexpected close, not stopping watchdog!\n");
                 pcwd_keepalive();
         }
         expect_close = 0;
-        atomic_inc( &open_allowed );
+        clear_bit(0, &open_allowed);
         return 0;
 }
 
@@ -750,7 +763,7 @@ static const struct file_operations pcwd_fops = {
         .owner          = THIS_MODULE,
         .llseek         = no_llseek,
         .write          = pcwd_write,
-        .ioctl          = pcwd_ioctl,
+        .unlocked_ioctl = pcwd_ioctl,
         .open           = pcwd_open,
         .release        = pcwd_close,
 };
@@ -788,7 +801,7 @@ static inline int get_revision(void)
          * presumes a floating bus reads as 0xff. */
         if ((inb(pcwd_private.io_addr + 2) == 0xFF) ||
             (inb(pcwd_private.io_addr + 3) == 0xFF))
-                r=PCWD_REVISION_A;
+                r = PCWD_REVISION_A;
         spin_unlock(&pcwd_private.io_lock);
 
         return r;
@@ -803,7 +816,7 @@ static inline int get_revision(void)
  */
 static int __devinit pcwd_isa_match(struct device *dev, unsigned int id)
 {
-        int base_addr=pcwd_ioports[id];
+        int base_addr = pcwd_ioports[id];
         int port0, last_port0;  /* Reg 0, in case it's REV A */
         int port1, last_port1;  /* Register 1 for REV C cards */
         int i;
@@ -813,7 +826,7 @@ static int __devinit pcwd_isa_match(struct device *dev, unsigned int id)
                 printk(KERN_DEBUG PFX "pcwd_isa_match id=%d\n",
                         id);
 
-        if (!request_region (base_addr, 4, "PCWD")) {
+        if (!request_region(base_addr, 4, "PCWD")) {
                 printk(KERN_INFO PFX "Port 0x%04x unavailable\n", base_addr);
                 return 0;
         }
@@ -842,7 +855,7 @@ static int __devinit pcwd_isa_match(struct device *dev, unsigned int id)
                         }
                 }
         }
-        release_region (base_addr, 4);
+        release_region(base_addr, 4);
 
         return retval;
 }
@@ -857,7 +870,8 @@ static int __devinit pcwd_isa_probe(struct device *dev, unsigned int id)
 
         cards_found++;
         if (cards_found == 1)
-                printk(KERN_INFO PFX "v%s Ken Hollis (kenji@bitgate.com)\n", WD_VER);
+                printk(KERN_INFO PFX "v%s Ken Hollis (kenji@bitgate.com)\n",
+                                                                WD_VER);
 
         if (cards_found > 1) {
                 printk(KERN_ERR PFX "This driver only supports 1 device\n");
@@ -875,10 +889,11 @@ static int __devinit pcwd_isa_probe(struct device *dev, unsigned int id)
         /* Check card's revision */
         pcwd_private.revision = get_revision();
 
-        if (!request_region(pcwd_private.io_addr, (pcwd_private.revision == PCWD_REVISION_A) ? 2 : 4, "PCWD")) {
+        if (!request_region(pcwd_private.io_addr,
+                (pcwd_private.revision == PCWD_REVISION_A) ? 2 : 4, "PCWD")) {
                 printk(KERN_ERR PFX "I/O address 0x%04x already in use\n",
                         pcwd_private.io_addr);
-                ret=-EIO;
+                ret = -EIO;
                 goto error_request_region;
         }
 
@@ -908,26 +923,30 @@ static int __devinit pcwd_isa_probe(struct device *dev, unsigned int id)
         if (heartbeat == 0)
                 heartbeat = heartbeat_tbl[(pcwd_get_option_switches() & 0x07)];
 
-        /* Check that the heartbeat value is within it's range ; if not reset to the default */
+        /* Check that the heartbeat value is within it's range;
+           if not reset to the default */
         if (pcwd_set_heartbeat(heartbeat)) {
                 pcwd_set_heartbeat(WATCHDOG_HEARTBEAT);
-                printk(KERN_INFO PFX "heartbeat value must be 2<=heartbeat<=7200, using %d\n",
-                        WATCHDOG_HEARTBEAT);
+                printk(KERN_INFO PFX
+                  "heartbeat value must be 2 <= heartbeat <= 7200, using %d\n",
+                                                        WATCHDOG_HEARTBEAT);
         }
 
         if (pcwd_private.supports_temp) {
                 ret = misc_register(&temp_miscdev);
                 if (ret) {
-                        printk(KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",
-                                TEMP_MINOR, ret);
+                        printk(KERN_ERR PFX
+                            "cannot register miscdev on minor=%d (err=%d)\n",
+                                                        TEMP_MINOR, ret);
                         goto error_misc_register_temp;
                 }
         }
 
         ret = misc_register(&pcwd_miscdev);
         if (ret) {
-                printk(KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",
-                        WATCHDOG_MINOR, ret);
+                printk(KERN_ERR PFX
+                        "cannot register miscdev on minor=%d (err=%d)\n",
+                                        WATCHDOG_MINOR, ret);
                 goto error_misc_register_watchdog;
         }
 
@@ -940,7 +959,8 @@ error_misc_register_watchdog:
         if (pcwd_private.supports_temp)
                 misc_deregister(&temp_miscdev);
 error_misc_register_temp:
-        release_region(pcwd_private.io_addr, (pcwd_private.revision == PCWD_REVISION_A) ? 2 : 4);
+        release_region(pcwd_private.io_addr,
+                        (pcwd_private.revision == PCWD_REVISION_A) ? 2 : 4);
 error_request_region:
         pcwd_private.io_addr = 0x0000;
         cards_found--;
@@ -964,7 +984,8 @@ static int __devexit pcwd_isa_remove(struct device *dev, unsigned int id)
         misc_deregister(&pcwd_miscdev);
         if (pcwd_private.supports_temp)
                 misc_deregister(&temp_miscdev);
-        release_region(pcwd_private.io_addr, (pcwd_private.revision == PCWD_REVISION_A) ? 2 : 4);
+        release_region(pcwd_private.io_addr,
+                        (pcwd_private.revision == PCWD_REVISION_A) ? 2 : 4);
         pcwd_private.io_addr = 0x0000;
         cards_found--;
 
diff --git a/drivers/watchdog/pcwd_pci.c b/drivers/watchdog/pcwd_pci.c
index 61a89e959642..90eb1d4271d7 100644
--- a/drivers/watchdog/pcwd_pci.c
+++ b/drivers/watchdog/pcwd_pci.c
@@ -46,9 +46,8 @@
 #include <linux/pci.h>          /* For pci functions */
 #include <linux/ioport.h>       /* For io-port access */
 #include <linux/spinlock.h>     /* For spin_lock/spin_unlock/... */
-
-#include <asm/uaccess.h>        /* For copy_to_user/put_user/... */
-#include <asm/io.h>             /* For inb/outb/... */
+#include <linux/uaccess.h>      /* For copy_to_user/put_user/... */
+#include <linux/io.h>           /* For inb/outb/... */
 
 /* Module and version information */
 #define WATCHDOG_VERSION "1.03"
@@ -97,7 +96,7 @@
 #define CMD_GET_CLEAR_RESET_COUNT               0x84
 
 /* Watchdog's Dip Switch heartbeat values */
-static const int heartbeat_tbl [] = {
+static const int heartbeat_tbl[] = {
         5,      /* OFF-OFF-OFF  =  5 Sec  */
         10,     /* OFF-OFF-ON   = 10 Sec  */
         30,     /* OFF-ON-OFF   = 30 Sec  */
@@ -220,11 +219,10 @@ static void pcipcwd_show_card_info(void)
         int option_switches;
 
         got_fw_rev = send_command(CMD_GET_FIRMWARE_VERSION, &fw_rev_major, &fw_rev_minor);
-        if (got_fw_rev) {
+        if (got_fw_rev)
                 sprintf(fw_ver_str, "%u.%02u", fw_rev_major, fw_rev_minor);
-        } else {
+        else
                 sprintf(fw_ver_str, "<card no answer>");
-        }
 
         /* Get switch settings */
         option_switches = pcipcwd_get_option_switches();
@@ -331,7 +329,7 @@ static int pcipcwd_get_status(int *status)
 {
         int control_status;
 
-        *status=0;
+        *status = 0;
         control_status = inb_p(pcipcwd_private.io_addr + 1);
         if (control_status & WD_PCI_WTRP)
                 *status |= WDIOF_CARDRESET;
@@ -369,8 +367,8 @@ static int pcipcwd_clear_status(void)
         outb_p((control_status & WD_PCI_R2DS) | WD_PCI_WTRP, pcipcwd_private.io_addr + 1);
 
         /* clear reset counter */
-        msb=0;
-        reset_counter=0xff;
+        msb = 0;
+        reset_counter = 0xff;
         send_command(CMD_GET_CLEAR_RESET_COUNT, &msb, &reset_counter);
 
         if (debug >= DEBUG) {
@@ -442,7 +440,7 @@ static ssize_t pcipcwd_write(struct file *file, const char __user *data,
                         /* scan to see whether or not we got the magic character */
                         for (i = 0; i != len; i++) {
                                 char c;
-                                if(get_user(c, data+i))
+                                if (get_user(c, data + i))
                                         return -EFAULT;
                                 if (c == 'V')
                                         expect_release = 42;
@@ -455,8 +453,8 @@ static ssize_t pcipcwd_write(struct file *file, const char __user *data,
         return len;
 }
 
-static int pcipcwd_ioctl(struct inode *inode, struct file *file,
-                          unsigned int cmd, unsigned long arg)
+static long pcipcwd_ioctl(struct file *file, unsigned int cmd,
+                                                unsigned long arg)
 {
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
@@ -471,92 +469,89 @@ static int pcipcwd_ioctl(struct inode *inode, struct file *file,
         };
 
         switch (cmd) {
-                case WDIOC_GETSUPPORT:
-                        return copy_to_user(argp, &ident,
-                                sizeof (ident)) ? -EFAULT : 0;
+        case WDIOC_GETSUPPORT:
+                return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;
+
+        case WDIOC_GETSTATUS:
+        {
+                int status;
+                pcipcwd_get_status(&status);
+                return put_user(status, p);
+        }
 
-                case WDIOC_GETSTATUS:
-                {
-                        int status;
+        case WDIOC_GETBOOTSTATUS:
+                return put_user(pcipcwd_private.boot_status, p);
 
-                        pcipcwd_get_status(&status);
+        case WDIOC_GETTEMP:
+        {
+                int temperature;
 
-                        return put_user(status, p);
-                }
+                if (pcipcwd_get_temperature(&temperature))
+                        return -EFAULT;
 
-                case WDIOC_GETBOOTSTATUS:
-                        return put_user(pcipcwd_private.boot_status, p);
+                return put_user(temperature, p);
+        }
 
-                case WDIOC_GETTEMP:
-                {
-                        int temperature;
+        case WDIOC_SETOPTIONS:
+        {
+                int new_options, retval = -EINVAL;
 
-                        if (pcipcwd_get_temperature(&temperature))
-                                return -EFAULT;
+                if (get_user(new_options, p))
+                        return -EFAULT;
 
-                        return put_user(temperature, p);
+                if (new_options & WDIOS_DISABLECARD) {
+                        if (pcipcwd_stop())
+                                return -EIO;
+                        retval = 0;
                 }
 
-                case WDIOC_KEEPALIVE:
-                        pcipcwd_keepalive();
-                        return 0;
-
-                case WDIOC_SETOPTIONS:
-                {
-                        int new_options, retval = -EINVAL;
-
-                        if (get_user (new_options, p))
-                                return -EFAULT;
-
-                        if (new_options & WDIOS_DISABLECARD) {
-                                if (pcipcwd_stop())
-                                        return -EIO;
-                                retval = 0;
-                        }
+                if (new_options & WDIOS_ENABLECARD) {
+                        if (pcipcwd_start())
+                                return -EIO;
+                        retval = 0;
+                }
 
-                        if (new_options & WDIOS_ENABLECARD) {
-                                if (pcipcwd_start())
-                                        return -EIO;
-                                retval = 0;
-                        }
+                if (new_options & WDIOS_TEMPPANIC) {
+                        temp_panic = 1;
+                        retval = 0;
+                }
 
-                        if (new_options & WDIOS_TEMPPANIC) {
-                                temp_panic = 1;
-                                retval = 0;
-                        }
+                return retval;
+        }
 
-                        return retval;
-                }
+        case WDIOC_KEEPALIVE:
+                pcipcwd_keepalive();
+                return 0;
 
-                case WDIOC_SETTIMEOUT:
-                {
-                        int new_heartbeat;
+        case WDIOC_SETTIMEOUT:
+        {
+                int new_heartbeat;
 
-                        if (get_user(new_heartbeat, p))
-                                return -EFAULT;
+                if (get_user(new_heartbeat, p))
+                        return -EFAULT;
 
-                        if (pcipcwd_set_heartbeat(new_heartbeat))
-                            return -EINVAL;
+                if (pcipcwd_set_heartbeat(new_heartbeat))
+                    return -EINVAL;
 
-                        pcipcwd_keepalive();
-                        /* Fall */
-                }
+                pcipcwd_keepalive();
+                /* Fall */
+        }
 
-                case WDIOC_GETTIMEOUT:
-                        return put_user(heartbeat, p);
+        case WDIOC_GETTIMEOUT:
+                return put_user(heartbeat, p);
 
-                case WDIOC_GETTIMELEFT:
-                {
-                        int time_left;
+        case WDIOC_GETTIMELEFT:
+        {
+                int time_left;
 
-                        if (pcipcwd_get_timeleft(&time_left))
-                                return -EFAULT;
+                if (pcipcwd_get_timeleft(&time_left))
+                        return -EFAULT;
 
-                        return put_user(time_left, p);
-                }
+                return put_user(time_left, p);
+        }
 
-                default:
-                        return -ENOTTY;
+        default:
+                return -ENOTTY;
         }
 }
 
@@ -603,7 +598,7 @@ static ssize_t pcipcwd_temp_read(struct file *file, char __user *data,
         if (pcipcwd_get_temperature(&temperature))
                 return -EFAULT;
 
-        if (copy_to_user (data, &temperature, 1))
+        if (copy_to_user(data, &temperature, 1))
                 return -EFAULT;
 
         return 1;
@@ -628,10 +623,8 @@ static int pcipcwd_temp_release(struct inode *inode, struct file *file)
 
 static int pcipcwd_notify_sys(struct notifier_block *this, unsigned long code, void *unused)
 {
-        if (code==SYS_DOWN || code==SYS_HALT) {
-                /* Turn the WDT off */
-                pcipcwd_stop();
-        }
+        if (code == SYS_DOWN || code == SYS_HALT)
+                pcipcwd_stop(); /* Turn the WDT off */
 
         return NOTIFY_DONE;
 }
@@ -644,7 +637,7 @@ static const struct file_operations pcipcwd_fops = {
         .owner =        THIS_MODULE,
         .llseek =       no_llseek,
         .write =        pcipcwd_write,
-        .ioctl =        pcipcwd_ioctl,
+        .unlocked_ioctl = pcipcwd_ioctl,
         .open =         pcipcwd_open,
         .release =      pcipcwd_release,
 };
diff --git a/drivers/watchdog/pcwd_usb.c b/drivers/watchdog/pcwd_usb.c
index bf443d077a1e..c1685c942de6 100644
--- a/drivers/watchdog/pcwd_usb.c
+++ b/drivers/watchdog/pcwd_usb.c
@@ -40,8 +40,7 @@
 #include <linux/slab.h>         /* For kmalloc, ... */
 #include <linux/mutex.h>        /* For mutex locking */
 #include <linux/hid.h>          /* For HID_REQ_SET_REPORT & HID_DT_REPORT */
-
-#include <asm/uaccess.h>        /* For copy_to_user/put_user/... */
+#include <linux/uaccess.h>      /* For copy_to_user/put_user/... */
 
 
 #ifdef CONFIG_USB_DEBUG
@@ -88,7 +87,7 @@ MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" _
 #define USB_PCWD_PRODUCT_ID     0x1140
 
 /* table of devices that work with this driver */
-static struct usb_device_id usb_pcwd_table [] = {
+static struct usb_device_id usb_pcwd_table[] = {
         { USB_DEVICE(USB_PCWD_VENDOR_ID, USB_PCWD_PRODUCT_ID) },
         { }                                     /* Terminating entry */
 };
@@ -110,7 +109,7 @@ MODULE_DEVICE_TABLE (usb, usb_pcwd_table);
 #define CMD_DISABLE_WATCHDOG            CMD_ENABLE_WATCHDOG
 
 /* Watchdog's Dip Switch heartbeat values */
-static const int heartbeat_tbl [] = {
+static const int heartbeat_tbl[] = {
         5,      /* OFF-OFF-OFF  =  5 Sec  */
         10,     /* OFF-OFF-ON   = 10 Sec  */
         30,     /* OFF-ON-OFF   = 30 Sec  */
@@ -130,15 +129,15 @@ static char expect_release;
 
 /* Structure to hold all of our device specific stuff */
 struct usb_pcwd_private {
-        struct usb_device *     udev;                   /* save off the usb device pointer */
-        struct usb_interface *  interface;              /* the interface for this device */
+        struct usb_device       *udev;                  /* save off the usb device pointer */
+        struct usb_interface    *interface;             /* the interface for this device */
 
         unsigned int            interface_number;       /* the interface number used for cmd's */
 
-        unsigned char *         intr_buffer;            /* the buffer to intr data */
+        unsigned char           *intr_buffer;           /* the buffer to intr data */
         dma_addr_t              intr_dma;               /* the dma address for the intr buffer */
         size_t                  intr_size;              /* the size of the intr buffer */
-        struct urb *            intr_urb;               /* the urb used for the intr pipe */
+        struct urb              *intr_urb;              /* the urb used for the intr pipe */
 
         unsigned char           cmd_command;            /* The command that is reported back */
         unsigned char           cmd_data_msb;           /* The data MSB that is reported back */
@@ -154,8 +153,8 @@ static struct usb_pcwd_private *usb_pcwd_device;
 static DEFINE_MUTEX(disconnect_mutex);
 
 /* local function prototypes */
-static int usb_pcwd_probe       (struct usb_interface *interface, const struct usb_device_id *id);
-static void usb_pcwd_disconnect (struct usb_interface *interface);
+static int usb_pcwd_probe(struct usb_interface *interface, const struct usb_device_id *id);
+static void usb_pcwd_disconnect(struct usb_interface *interface);
 
 /* usb specific object needed to register this driver with the usb subsystem */
 static struct usb_driver usb_pcwd_driver = {
@@ -195,10 +194,10 @@ static void usb_pcwd_intr_done(struct urb *urb)
         usb_pcwd->cmd_data_lsb = data[2];
 
         /* notify anyone waiting that the cmd has finished */
-        atomic_set (&usb_pcwd->cmd_received, 1);
+        atomic_set(&usb_pcwd->cmd_received, 1);
 
 resubmit:
-        retval = usb_submit_urb (urb, GFP_ATOMIC);
+        retval = usb_submit_urb(urb, GFP_ATOMIC);
         if (retval)
                 printk(KERN_ERR PFX "can't resubmit intr, usb_submit_urb failed with result %d\n",
                         retval);
@@ -224,7 +223,7 @@ static int usb_pcwd_send_command(struct usb_pcwd_private *usb_pcwd, unsigned cha
         dbg("sending following data cmd=0x%02x msb=0x%02x lsb=0x%02x",
                 buf[0], buf[1], buf[2]);
 
-        atomic_set (&usb_pcwd->cmd_received, 0);
+        atomic_set(&usb_pcwd->cmd_received, 0);
 
         if (usb_control_msg(usb_pcwd->udev, usb_sndctrlpipe(usb_pcwd->udev, 0),
                         HID_REQ_SET_REPORT, HID_DT_REPORT,
@@ -237,7 +236,7 @@ static int usb_pcwd_send_command(struct usb_pcwd_private *usb_pcwd, unsigned cha
         got_response = 0;
         for (count = 0; (count < USB_COMMAND_TIMEOUT) && (!got_response); count++) {
                 mdelay(1);
-                if (atomic_read (&usb_pcwd->cmd_received))
+                if (atomic_read(&usb_pcwd->cmd_received))
                         got_response = 1;
         }
 
@@ -356,7 +355,7 @@ static ssize_t usb_pcwd_write(struct file *file, const char __user *data,
                         /* scan to see whether or not we got the magic character */
                         for (i = 0; i != len; i++) {
                                 char c;
-                                if(get_user(c, data+i))
+                                if (get_user(c, data + i))
                                         return -EFAULT;
                                 if (c == 'V')
                                         expect_release = 42;
@@ -369,8 +368,8 @@ static ssize_t usb_pcwd_write(struct file *file, const char __user *data,
         return len;
 }
 
-static int usb_pcwd_ioctl(struct inode *inode, struct file *file,
-                          unsigned int cmd, unsigned long arg)
+static long usb_pcwd_ioctl(struct file *file, unsigned int cmd,
+                                                unsigned long arg)
 {
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
@@ -383,77 +382,76 @@ static int usb_pcwd_ioctl(struct inode *inode, struct file *file,
         };
 
         switch (cmd) {
-                case WDIOC_GETSUPPORT:
-                        return copy_to_user(argp, &ident,
-                                sizeof (ident)) ? -EFAULT : 0;
+        case WDIOC_GETSUPPORT:
+                return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;
 
-                case WDIOC_GETSTATUS:
-                case WDIOC_GETBOOTSTATUS:
-                        return put_user(0, p);
+        case WDIOC_GETSTATUS:
+        case WDIOC_GETBOOTSTATUS:
+                return put_user(0, p);
 
-                case WDIOC_GETTEMP:
-                {
-                        int temperature;
+        case WDIOC_GETTEMP:
+        {
+                int temperature;
 
-                        if (usb_pcwd_get_temperature(usb_pcwd_device, &temperature))
-                                return -EFAULT;
+                if (usb_pcwd_get_temperature(usb_pcwd_device, &temperature))
+                        return -EFAULT;
 
-                        return put_user(temperature, p);
-                }
+                return put_user(temperature, p);
+        }
 
-                case WDIOC_KEEPALIVE:
-                        usb_pcwd_keepalive(usb_pcwd_device);
-                        return 0;
+        case WDIOC_SETOPTIONS:
+        {
+                int new_options, retval = -EINVAL;
 
-                case WDIOC_SETOPTIONS:
-                {
-                        int new_options, retval = -EINVAL;
+                if (get_user(new_options, p))
+                        return -EFAULT;
 
-                        if (get_user (new_options, p))
-                                return -EFAULT;
+                if (new_options & WDIOS_DISABLECARD) {
+                        usb_pcwd_stop(usb_pcwd_device);
+                        retval = 0;
+                }
 
-                        if (new_options & WDIOS_DISABLECARD) {
-                                usb_pcwd_stop(usb_pcwd_device);
-                                retval = 0;
-                        }
+                if (new_options & WDIOS_ENABLECARD) {
+                        usb_pcwd_start(usb_pcwd_device);
+                        retval = 0;
+                }
 
-                        if (new_options & WDIOS_ENABLECARD) {
-                                usb_pcwd_start(usb_pcwd_device);
-                                retval = 0;
-                        }
+                return retval;
+        }
 
-                        return retval;
-                }
+        case WDIOC_KEEPALIVE:
+                usb_pcwd_keepalive(usb_pcwd_device);
+                return 0;
 
-                case WDIOC_SETTIMEOUT:
-                {
-                        int new_heartbeat;
+        case WDIOC_SETTIMEOUT:
+        {
+                int new_heartbeat;
 
-                        if (get_user(new_heartbeat, p))
-                                return -EFAULT;
+                if (get_user(new_heartbeat, p))
+                        return -EFAULT;
 
-                        if (usb_pcwd_set_heartbeat(usb_pcwd_device, new_heartbeat))
-                            return -EINVAL;
+                if (usb_pcwd_set_heartbeat(usb_pcwd_device, new_heartbeat))
+                    return -EINVAL;
 
-                        usb_pcwd_keepalive(usb_pcwd_device);
-                        /* Fall */
-                }
+                usb_pcwd_keepalive(usb_pcwd_device);
+                /* Fall */
+        }
 
-                case WDIOC_GETTIMEOUT:
-                        return put_user(heartbeat, p);
+        case WDIOC_GETTIMEOUT:
+                return put_user(heartbeat, p);
 
-                case WDIOC_GETTIMELEFT:
-                {
-                        int time_left;
+        case WDIOC_GETTIMELEFT:
+        {
+                int time_left;
 
-                        if (usb_pcwd_get_timeleft(usb_pcwd_device, &time_left))
-                                return -EFAULT;
+                if (usb_pcwd_get_timeleft(usb_pcwd_device, &time_left))
+                        return -EFAULT;
 
-                        return put_user(time_left, p);
-                }
+                return put_user(time_left, p);
+        }
 
-                default:
-                        return -ENOTTY;
+        default:
+                return -ENOTTY;
         }
 }
 
@@ -519,10 +517,8 @@ static int usb_pcwd_temperature_release(struct inode *inode, struct file *file)
 
 static int usb_pcwd_notify_sys(struct notifier_block *this, unsigned long code, void *unused)
 {
-        if (code==SYS_DOWN || code==SYS_HALT) {
-                /* Turn the WDT off */
-                usb_pcwd_stop(usb_pcwd_device);
-        }
+        if (code == SYS_DOWN || code == SYS_HALT)
+                usb_pcwd_stop(usb_pcwd_device); /* Turn the WDT off */
 
         return NOTIFY_DONE;
 }
@@ -535,7 +531,7 @@ static const struct file_operations usb_pcwd_fops = {
         .owner =        THIS_MODULE,
         .llseek =       no_llseek,
         .write =        usb_pcwd_write,
-        .ioctl =        usb_pcwd_ioctl,
+        .unlocked_ioctl = usb_pcwd_ioctl,
         .open =         usb_pcwd_open,
         .release =      usb_pcwd_release,
 };
@@ -567,13 +563,13 @@ static struct notifier_block usb_pcwd_notifier = {
 /**
  *      usb_pcwd_delete
  */
-static inline void usb_pcwd_delete (struct usb_pcwd_private *usb_pcwd)
+static inline void usb_pcwd_delete(struct usb_pcwd_private *usb_pcwd)
 {
         usb_free_urb(usb_pcwd->intr_urb);
         if (usb_pcwd->intr_buffer != NULL)
                 usb_buffer_free(usb_pcwd->udev, usb_pcwd->intr_size,
                                 usb_pcwd->intr_buffer, usb_pcwd->intr_dma);
-        kfree (usb_pcwd);
+        kfree(usb_pcwd);
 }
 
 /**
@@ -626,7 +622,7 @@ static int usb_pcwd_probe(struct usb_interface *interface, const struct usb_devi
         maxp = usb_maxpacket(udev, pipe, usb_pipeout(pipe));
 
         /* allocate memory for our device and initialize it */
-        usb_pcwd = kzalloc (sizeof(struct usb_pcwd_private), GFP_KERNEL);
+        usb_pcwd = kzalloc(sizeof(struct usb_pcwd_private), GFP_KERNEL);
         if (usb_pcwd == NULL) {
                 printk(KERN_ERR PFX "Out of memory\n");
                 goto error;
@@ -641,7 +637,8 @@ static int usb_pcwd_probe(struct usb_interface *interface, const struct usb_devi
         usb_pcwd->intr_size = (le16_to_cpu(endpoint->wMaxPacketSize) > 8 ? le16_to_cpu(endpoint->wMaxPacketSize) : 8);
 
         /* set up the memory buffer's */
-        if (!(usb_pcwd->intr_buffer = usb_buffer_alloc(udev, usb_pcwd->intr_size, GFP_ATOMIC, &usb_pcwd->intr_dma))) {
+        usb_pcwd->intr_buffer = usb_buffer_alloc(udev, usb_pcwd->intr_size, GFP_ATOMIC, &usb_pcwd->intr_dma);
+        if (!usb_pcwd->intr_buffer) {
                 printk(KERN_ERR PFX "Out of memory\n");
                 goto error;
         }
@@ -675,11 +672,10 @@ static int usb_pcwd_probe(struct usb_interface *interface, const struct usb_devi
 
         /* Get the Firmware Version */
         got_fw_rev = usb_pcwd_send_command(usb_pcwd, CMD_GET_FIRMWARE_VERSION, &fw_rev_major, &fw_rev_minor);
-        if (got_fw_rev) {
+        if (got_fw_rev)
                 sprintf(fw_ver_str, "%u.%02u", fw_rev_major, fw_rev_minor);
-        } else {
+        else
                 sprintf(fw_ver_str, "<card no answer>");
-        }
 
         printk(KERN_INFO PFX "Found card (Firmware: %s) with temp option\n",
                 fw_ver_str);
@@ -725,7 +721,7 @@ static int usb_pcwd_probe(struct usb_interface *interface, const struct usb_devi
         }
 
         /* we can register the device now, as it is ready */
-        usb_set_intfdata (interface, usb_pcwd);
+        usb_set_intfdata(interface, usb_pcwd);
 
         printk(KERN_INFO PFX "initialized. heartbeat=%d sec (nowayout=%d)\n",
                 heartbeat, nowayout);
@@ -759,8 +755,8 @@ static void usb_pcwd_disconnect(struct usb_interface *interface)
         /* prevent races with open() */
         mutex_lock(&disconnect_mutex);
 
-        usb_pcwd = usb_get_intfdata (interface);
-        usb_set_intfdata (interface, NULL);
+        usb_pcwd = usb_get_intfdata(interface);
+        usb_set_intfdata(interface, NULL);
 
         mutex_lock(&usb_pcwd->mtx);
 
@@ -820,5 +816,5 @@ static void __exit usb_pcwd_exit(void)
 }
 
 
-module_init (usb_pcwd_init);
-module_exit (usb_pcwd_exit);
+module_init(usb_pcwd_init);
+module_exit(usb_pcwd_exit);
diff --git a/drivers/watchdog/pnx4008_wdt.c b/drivers/watchdog/pnx4008_wdt.c
index 6b8483d3c783..6eadf5ebb9b3 100644
--- a/drivers/watchdog/pnx4008_wdt.c
+++ b/drivers/watchdog/pnx4008_wdt.c
@@ -28,10 +28,10 @@
 #include <linux/platform_device.h>
 #include <linux/clk.h>
 #include <linux/spinlock.h>
+#include <linux/uaccess.h>
+#include <linux/io.h>
 
 #include <asm/hardware.h>
-#include <asm/uaccess.h>
-#include <asm/io.h>
 
 #define MODULE_NAME "PNX4008-WDT: "
 
@@ -144,9 +144,8 @@ static int pnx4008_wdt_open(struct inode *inode, struct file *file)
         return nonseekable_open(inode, file);
 }
 
-static ssize_t
-pnx4008_wdt_write(struct file *file, const char *data, size_t len,
-                  loff_t * ppos)
+static ssize_t pnx4008_wdt_write(struct file *file, const char *data,
+                                        size_t len, loff_t *ppos)
 {
         if (len) {
                 if (!nowayout) {
@@ -169,15 +168,14 @@ pnx4008_wdt_write(struct file *file, const char *data, size_t len,
         return len;
 }
 
-static struct watchdog_info ident = {
+static const struct watchdog_info ident = {
         .options = WDIOF_CARDRESET | WDIOF_MAGICCLOSE |
             WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
         .identity = "PNX4008 Watchdog",
 };
 
-static int
-pnx4008_wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
-                  unsigned long arg)
+static long pnx4008_wdt_ioctl(struct inode *inode, struct file *file,
+                                        unsigned int cmd, unsigned long arg)
 {
         int ret = -ENOTTY;
         int time;
@@ -196,6 +194,11 @@ pnx4008_wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
                 ret = put_user(boot_status, (int *)arg);
                 break;
 
+        case WDIOC_KEEPALIVE:
+                wdt_enable();
+                ret = 0;
+                break;
+
         case WDIOC_SETTIMEOUT:
                 ret = get_user(time, (int *)arg);
                 if (ret)
@@ -213,11 +216,6 @@ pnx4008_wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
         case WDIOC_GETTIMEOUT:
                 ret = put_user(heartbeat, (int *)arg);
                 break;
-
-        case WDIOC_KEEPALIVE:
-                wdt_enable();
-                ret = 0;
-                break;
         }
         return ret;
 }
@@ -238,7 +236,7 @@ static const struct file_operations pnx4008_wdt_fops = {
         .owner = THIS_MODULE,
         .llseek = no_llseek,
         .write = pnx4008_wdt_write,
-        .ioctl = pnx4008_wdt_ioctl,
+        .unlocked_ioctl = pnx4008_wdt_ioctl,
         .open = pnx4008_wdt_open,
         .release = pnx4008_wdt_release,
 };
diff --git a/drivers/watchdog/rm9k_wdt.c b/drivers/watchdog/rm9k_wdt.c
index 5c921e471564..f1ae3729a19e 100644
--- a/drivers/watchdog/rm9k_wdt.c
+++ b/drivers/watchdog/rm9k_wdt.c
@@ -29,10 +29,10 @@
 #include <linux/notifier.h>
 #include <linux/miscdevice.h>
 #include <linux/watchdog.h>
-#include <asm/io.h>
+#include <linux/io.h>
+#include <linux/uaccess.h>
 #include <asm/atomic.h>
 #include <asm/processor.h>
-#include <asm/uaccess.h>
 #include <asm/system.h>
 #include <asm/rm9k-ocd.h>
 
@@ -53,10 +53,12 @@ static void wdt_gpi_stop(void);
 static void wdt_gpi_set_timeout(unsigned int);
 static int wdt_gpi_open(struct inode *, struct file *);
 static int wdt_gpi_release(struct inode *, struct file *);
-static ssize_t wdt_gpi_write(struct file *, const char __user *, size_t, loff_t *);
+static ssize_t wdt_gpi_write(struct file *, const char __user *, size_t,
+                                                                loff_t *);
 static long wdt_gpi_ioctl(struct file *, unsigned int, unsigned long);
 static int wdt_gpi_notify(struct notifier_block *, unsigned long, void *);
-static const struct resource *wdt_gpi_get_resource(struct platform_device *, const char *, unsigned int);
+static const struct resource *wdt_gpi_get_resource(struct platform_device *,
+                                                const char *, unsigned int);
 static int __init wdt_gpi_probe(struct device *);
 static int __exit wdt_gpi_remove(struct device *);
 
@@ -68,7 +70,7 @@ static int locked;
 
 
 /* These are set from device resources */
-static void __iomem * wd_regs;
+static void __iomem *wd_regs;
 static unsigned int wd_irq, wd_ctr;
 
 
@@ -216,7 +218,8 @@ static int wdt_gpi_release(struct inode *inode, struct file *file)
                 if (expect_close) {
                         wdt_gpi_stop();
                         free_irq(wd_irq, &miscdev);
-                        printk(KERN_INFO "%s: watchdog stopped\n", wdt_gpi_name);
+                        printk(KERN_INFO "%s: watchdog stopped\n",
+                                                        wdt_gpi_name);
                 } else {
                         printk(KERN_CRIT "%s: unexpected close() -"
                                 " watchdog left running\n",
@@ -231,8 +234,8 @@ static int wdt_gpi_release(struct inode *inode, struct file *file)
         return 0;
 }
 
-static ssize_t
-wdt_gpi_write(struct file *f, const char __user *d, size_t s, loff_t *o)
+static ssize_t wdt_gpi_write(struct file *f, const char __user *d, size_t s,
+                                                                loff_t *o)
 {
         char val;
 
@@ -241,8 +244,7 @@ wdt_gpi_write(struct file *f, const char __user *d, size_t s, loff_t *o)
         return s ? 1 : 0;
 }
 
-static long
-wdt_gpi_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
+static long wdt_gpi_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
 {
         long res = -ENOTTY;
         const long size = _IOC_SIZE(cmd);
@@ -271,7 +273,8 @@ wdt_gpi_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
         case WDIOC_GETSUPPORT:
                 wdinfo.options = nowayout ?
                         WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING :
-                        WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE;
+                        WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING |
+                        WDIOF_MAGICCLOSE;
                 res = __copy_to_user(argp, &wdinfo, size) ?  -EFAULT : size;
                 break;
 
@@ -322,8 +325,8 @@ wdt_gpi_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
 
 
 /* Shutdown notifier */
-static int
-wdt_gpi_notify(struct notifier_block *this, unsigned long code, void *unused)
+static int wdt_gpi_notify(struct notifier_block *this, unsigned long code,
+                          void *unused)
 {
         if (code == SYS_DOWN || code == SYS_HALT)
                 wdt_gpi_stop();
@@ -333,9 +336,8 @@ wdt_gpi_notify(struct notifier_block *this, unsigned long code, void *unused)
 
 
 /* Init & exit procedures */
-static const struct resource *
-wdt_gpi_get_resource(struct platform_device *pdv, const char *name,
-                      unsigned int type)
+static const struct resource *wdt_gpi_get_resource(struct platform_device *pdv,
+                                        const char *name, unsigned int type)
 {
         char buf[80];
         if (snprintf(buf, sizeof buf, "%s_0", name) >= sizeof buf)
diff --git a/drivers/watchdog/s3c2410_wdt.c b/drivers/watchdog/s3c2410_wdt.c
index 97b4a2e8eb09..c417fb5e913f 100644
--- a/drivers/watchdog/s3c2410_wdt.c
+++ b/drivers/watchdog/s3c2410_wdt.c
@@ -119,17 +119,6 @@ static void __s3c2410wdt_stop(void)
 {
         unsigned long wtcon;
 
-        spin_lock(&wdt_lock);
-        wtcon = readl(wdt_base + S3C2410_WTCON);
-        wtcon &= ~(S3C2410_WTCON_ENABLE | S3C2410_WTCON_RSTEN);
-        writel(wtcon, wdt_base + S3C2410_WTCON);
-        spin_unlock(&wdt_lock);
-}
-
-static void __s3c2410wdt_stop(void)
-{
-        unsigned long wtcon;
-
         wtcon = readl(wdt_base + S3C2410_WTCON);
         wtcon &= ~(S3C2410_WTCON_ENABLE | S3C2410_WTCON_RSTEN);
         writel(wtcon, wdt_base + S3C2410_WTCON);
@@ -305,8 +294,6 @@ static long s3c2410wdt_ioctl(struct file *file,	unsigned int cmd,
         int new_margin;
 
         switch (cmd) {
-        default:
-                return -ENOTTY;
         case WDIOC_GETSUPPORT:
                 return copy_to_user(argp, &s3c2410_wdt_ident,
                         sizeof(s3c2410_wdt_ident)) ? -EFAULT : 0;
@@ -325,6 +312,8 @@ static long s3c2410wdt_ioctl(struct file *file,	unsigned int cmd,
                 return put_user(tmr_margin, p);
         case WDIOC_GETTIMEOUT:
                 return put_user(tmr_margin, p);
+        default:
+                return -ENOTTY;
         }
 }
 
diff --git a/drivers/watchdog/sa1100_wdt.c b/drivers/watchdog/sa1100_wdt.c
index 34a2b3b81800..27d6898a7c98 100644
--- a/drivers/watchdog/sa1100_wdt.c
+++ b/drivers/watchdog/sa1100_wdt.c
@@ -26,13 +26,13 @@
 #include <linux/watchdog.h>
 #include <linux/init.h>
 #include <linux/bitops.h>
+#include <linux/uaccess.h>
 
 #ifdef CONFIG_ARCH_PXA
 #include <asm/arch/pxa-regs.h>
 #endif
 
 #include <asm/hardware.h>
-#include <asm/uaccess.h>
 
 #define OSCR_FREQ               CLOCK_TICK_RATE
 
@@ -45,7 +45,7 @@ static int boot_status;
  */
 static int sa1100dog_open(struct inode *inode, struct file *file)
 {
-        if (test_and_set_bit(1,&sa1100wdt_users))
+        if (test_and_set_bit(1, &sa1100wdt_users))
                 return -EBUSY;
 
         /* Activate SA1100 Watchdog timer */
@@ -66,28 +66,27 @@ static int sa1100dog_open(struct inode *inode, struct file *file)
 static int sa1100dog_release(struct inode *inode, struct file *file)
 {
         printk(KERN_CRIT "WATCHDOG: Device closed - timer will not stop\n");
-
         clear_bit(1, &sa1100wdt_users);
-
         return 0;
 }
 
-static ssize_t sa1100dog_write(struct file *file, const char __user *data, size_t len, loff_t *ppos)
+static ssize_t sa1100dog_write(struct file *file, const char __user *data,
+                                                size_t len, loff_t *ppos)
 {
         if (len)
                 /* Refresh OSMR3 timer. */
                 OSMR3 = OSCR + pre_margin;
-
         return len;
 }
 
-static struct watchdog_info ident = {
-        .options        = WDIOF_CARDRESET | WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
+static const struct watchdog_info ident = {
+        .options        = WDIOF_CARDRESET | WDIOF_SETTIMEOUT
+                                | WDIOF_KEEPALIVEPING,
         .identity       = "SA1100/PXA255 Watchdog",
 };
 
-static int sa1100dog_ioctl(struct inode *inode, struct file *file,
-        unsigned int cmd, unsigned long arg)
+static long sa1100dog_ioctl(struct file *file, unsigned int cmd,
+                                                        unsigned long arg)
 {
         int ret = -ENOTTY;
         int time;
@@ -108,6 +107,11 @@ static int sa1100dog_ioctl(struct inode *inode, struct file *file,
                 ret = put_user(boot_status, p);
                 break;
 
+        case WDIOC_KEEPALIVE:
+                OSMR3 = OSCR + pre_margin;
+                ret = 0;
+                break;
+
         case WDIOC_SETTIMEOUT:
                 ret = get_user(time, p);
                 if (ret)
@@ -125,27 +129,20 @@ static int sa1100dog_ioctl(struct inode *inode, struct file *file,
         case WDIOC_GETTIMEOUT:
                 ret = put_user(pre_margin / OSCR_FREQ, p);
                 break;
-
-        case WDIOC_KEEPALIVE:
-                OSMR3 = OSCR + pre_margin;
-                ret = 0;
-                break;
         }
         return ret;
 }
 
-static const struct file_operations sa1100dog_fops =
-{
+static const struct file_operations sa1100dog_fops = {
         .owner          = THIS_MODULE,
         .llseek         = no_llseek,
         .write          = sa1100dog_write,
-        .ioctl          = sa1100dog_ioctl,
+        .unlocked_ioctl = sa1100dog_ioctl,
         .open           = sa1100dog_open,
         .release        = sa1100dog_release,
 };
 
-static struct miscdevice sa1100dog_miscdev =
-{
+static struct miscdevice sa1100dog_miscdev = {
         .minor          = WATCHDOG_MINOR,
         .name           = "watchdog",
         .fops           = &sa1100dog_fops,
@@ -167,8 +164,9 @@ static int __init sa1100dog_init(void)
 
         ret = misc_register(&sa1100dog_miscdev);
         if (ret == 0)
-                printk("SA1100/PXA2xx Watchdog Timer: timer margin %d sec\n",
-                       margin);
+                printk(KERN_INFO
+                        "SA1100/PXA2xx Watchdog Timer: timer margin %d sec\n",
+                                                margin);
         return ret;
 }
 
diff --git a/drivers/watchdog/sb_wdog.c b/drivers/watchdog/sb_wdog.c
index b94431433695..27e526a07c9a 100644
--- a/drivers/watchdog/sb_wdog.c
+++ b/drivers/watchdog/sb_wdog.c
@@ -57,6 +57,7 @@
 #include <asm/sibyte/sb1250_int.h>
 #include <asm/sibyte/sb1250_scd.h>
 
+static DEFINE_SPINLOCK(sbwd_lock);
 
 /*
  * set the initial count value of a timer
@@ -65,8 +66,10 @@
  */
 void sbwdog_set(char __iomem *wdog, unsigned long t)
 {
+        spin_lock(&sbwd_lock);
         __raw_writeb(0, wdog - 0x10);
         __raw_writeq(t & 0x7fffffUL, wdog);
+        spin_unlock(&sbwd_lock);
 }
 
 /*
@@ -77,7 +80,9 @@ void sbwdog_set(char __iomem *wdog, unsigned long t)
  */
 void sbwdog_pet(char __iomem *wdog)
 {
+        spin_lock(&sbwd_lock);
         __raw_writeb(__raw_readb(wdog) | 1, wdog);
+        spin_unlock(&sbwd_lock);
 }
 
 static unsigned long sbwdog_gate; /* keeps it to one thread only */
@@ -86,8 +91,9 @@ static char __iomem *user_dog = (char __iomem *)(IO_BASE + (A_SCD_WDOG_CFG_1));
 static unsigned long timeout = 0x7fffffUL;      /* useconds: 8.3ish secs. */
 static int expect_close;
 
-static struct watchdog_info ident = {
-        .options        = WDIOF_CARDRESET | WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
+static const struct watchdog_info ident = {
+        .options        = WDIOF_CARDRESET | WDIOF_SETTIMEOUT |
+                                                WDIOF_KEEPALIVEPING,
         .identity       = "SiByte Watchdog",
 };
 
@@ -97,9 +103,8 @@ static struct watchdog_info ident = {
 static int sbwdog_open(struct inode *inode, struct file *file)
 {
         nonseekable_open(inode, file);
-        if (test_and_set_bit(0, &sbwdog_gate)) {
+        if (test_and_set_bit(0, &sbwdog_gate))
                 return -EBUSY;
-        }
         __module_get(THIS_MODULE);
 
         /*
@@ -120,8 +125,9 @@ static int sbwdog_release(struct inode *inode, struct file *file)
                 __raw_writeb(0, user_dog);
                 module_put(THIS_MODULE);
         } else {
-                printk(KERN_CRIT "%s: Unexpected close, not stopping watchdog!\n",
-                        ident.identity);
+                printk(KERN_CRIT
+                        "%s: Unexpected close, not stopping watchdog!\n",
+                                                ident.identity);
                 sbwdog_pet(user_dog);
         }
         clear_bit(0, &sbwdog_gate);
@@ -147,12 +153,10 @@ static ssize_t sbwdog_write(struct file *file, const char __user *data,
                 for (i = 0; i != len; i++) {
                         char c;
 
-                        if (get_user(c, data + i)) {
+                        if (get_user(c, data + i))
                                 return -EFAULT;
-                        }
-                        if (c == 'V') {
+                        if (c == 'V')
                                 expect_close = 42;
-                        }
                 }
                 sbwdog_pet(user_dog);
         }
@@ -160,8 +164,8 @@ static ssize_t sbwdog_write(struct file *file, const char __user *data,
         return len;
 }
 
-static int sbwdog_ioctl(struct inode *inode, struct file *file,
-                        unsigned int cmd, unsigned long arg)
+static long sbwdog_ioctl(struct file *file, unsigned int cmd,
+                                                unsigned long arg)
 {
         int ret = -ENOTTY;
         unsigned long time;
@@ -178,11 +182,15 @@ static int sbwdog_ioctl(struct inode *inode, struct file *file,
                 ret = put_user(0, p);
                 break;
 
+        case WDIOC_KEEPALIVE:
+                sbwdog_pet(user_dog);
+                ret = 0;
+                break;
+
         case WDIOC_SETTIMEOUT:
                 ret = get_user(time, p);
-                if (ret) {
+                if (ret)
                         break;
-                }
 
                 time *= 1000000;
                 if (time > 0x7fffffUL) {
@@ -200,11 +208,6 @@ static int sbwdog_ioctl(struct inode *inode, struct file *file,
                  */
                 ret = put_user(__raw_readq(user_dog - 8) / 1000000, p);
                 break;
-
-        case WDIOC_KEEPALIVE:
-                sbwdog_pet(user_dog);
-                ret = 0;
-                break;
         }
         return ret;
 }
@@ -212,8 +215,8 @@ static int sbwdog_ioctl(struct inode *inode, struct file *file,
 /*
  *      Notifier for system down
  */
-static int
-sbwdog_notify_sys(struct notifier_block *this, unsigned long code, void *erf)
+static int sbwdog_notify_sys(struct notifier_block *this, unsigned long code,
+                                                                void *erf)
 {
         if (code == SYS_DOWN || code == SYS_HALT) {
                 /*
@@ -226,18 +229,16 @@ sbwdog_notify_sys(struct notifier_block *this, unsigned long code, void *erf)
         return NOTIFY_DONE;
 }
 
-static const struct file_operations sbwdog_fops =
-{
+static const struct file_operations sbwdog_fops = {
         .owner          = THIS_MODULE,
         .llseek         = no_llseek,
         .write          = sbwdog_write,
-        .ioctl          = sbwdog_ioctl,
+        .unlocked_ioctl = sbwdog_ioctl,
         .open           = sbwdog_open,
         .release        = sbwdog_release,
 };
 
-static struct miscdevice sbwdog_miscdev =
-{
+static struct miscdevice sbwdog_miscdev = {
         .minor          = WATCHDOG_MINOR,
         .name           = "watchdog",
         .fops           = &sbwdog_fops,
@@ -267,13 +268,12 @@ irqreturn_t sbwdog_interrupt(int irq, void *addr)
         /*
          * if it's the second watchdog timer, it's for those users
          */
-        if (wd_cfg_reg == user_dog) {
+        if (wd_cfg_reg == user_dog)
                 printk(KERN_CRIT
                         "%s in danger of initiating system reset in %ld.%01ld seconds\n",
                         ident.identity, wd_init / 1000000, (wd_init / 100000) % 10);
-        } else {
+        else
                 cfg |= 1;
-        }
 
         __raw_writeb(cfg, wd_cfg_reg);
 
@@ -289,28 +289,31 @@ static int __init sbwdog_init(void)
          */
         ret = register_reboot_notifier(&sbwdog_notifier);
         if (ret) {
-                printk (KERN_ERR "%s: cannot register reboot notifier (err=%d)\n",
-                        ident.identity, ret);
+                printk(KERN_ERR
+                        "%s: cannot register reboot notifier (err=%d)\n",
+                                                ident.identity, ret);
                 return ret;
         }
 
         /*
          * get the resources
          */
-        ret = misc_register(&sbwdog_miscdev);
-        if (ret == 0) {
-                printk(KERN_INFO "%s: timeout is %ld.%ld secs\n", ident.identity,
-                        timeout / 1000000, (timeout / 100000) % 10);
-        }
 
         ret = request_irq(1, sbwdog_interrupt, IRQF_DISABLED | IRQF_SHARED,
                 ident.identity, (void *)user_dog);
         if (ret) {
-                printk(KERN_ERR "%s: failed to request irq 1 - %d\n", ident.identity,
-                        ret);
-                misc_deregister(&sbwdog_miscdev);
+                printk(KERN_ERR "%s: failed to request irq 1 - %d\n",
+                                                ident.identity, ret);
+                return ret;
         }
 
+        ret = misc_register(&sbwdog_miscdev);
+        if (ret == 0) {
+                printk(KERN_INFO "%s: timeout is %ld.%ld secs\n",
+                                ident.identity,
+                                timeout / 1000000, (timeout / 100000) % 10);
+        } else
+                free_irq(1, (void *)user_dog);
         return ret;
 }
 
@@ -327,7 +330,7 @@ MODULE_DESCRIPTION("SiByte Watchdog");
 
 module_param(timeout, ulong, 0);
 MODULE_PARM_DESC(timeout,
-        "Watchdog timeout in microseconds (max/default 8388607 or 8.3ish secs)");
+      "Watchdog timeout in microseconds (max/default 8388607 or 8.3ish secs)");
 
 MODULE_LICENSE("GPL");
 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
@@ -336,16 +339,15 @@ MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
  * example code that can be put in a platform code area to utilize the
  * first watchdog timer for the kernels own purpose.
 
- void
-platform_wd_setup(void)
+void platform_wd_setup(void)
 {
         int ret;
 
-        ret = request_irq(0, sbwdog_interrupt, IRQF_DISABLED | IRQF_SHARED,
+        ret = request_irq(1, sbwdog_interrupt, IRQF_DISABLED | IRQF_SHARED,
                 "Kernel Watchdog", IOADDR(A_SCD_WDOG_CFG_0));
         if (ret) {
-                printk(KERN_CRIT "Watchdog IRQ zero(0) failed to be requested - %d\n",
-                        ret);
+                printk(KERN_CRIT
+                  "Watchdog IRQ zero(0) failed to be requested - %d\n", ret);
         }
 }
 
diff --git a/drivers/watchdog/sbc60xxwdt.c b/drivers/watchdog/sbc60xxwdt.c
index ef76f01625e7..3266daaaecf8 100644
--- a/drivers/watchdog/sbc60xxwdt.c
+++ b/drivers/watchdog/sbc60xxwdt.c
@@ -16,19 +16,23 @@
  *
  *           12/4 - 2000      [Initial revision]
  *           25/4 - 2000      Added /dev/watchdog support
- *           09/5 - 2001      [smj@oro.net] fixed fop_write to "return 1" on success
+ *           09/5 - 2001      [smj@oro.net] fixed fop_write to "return 1"
+ *                                      on success
  *           12/4 - 2002      [rob@osinvestor.com] eliminate fop_read
  *                            fix possible wdt_is_open race
  *                            add CONFIG_WATCHDOG_NOWAYOUT support
  *                            remove lock_kernel/unlock_kernel pairs
  *                            added KERN_* to printk's
  *                            got rid of extraneous comments
- *                            changed watchdog_info to correctly reflect what the driver offers
- *                            added WDIOC_GETSTATUS, WDIOC_GETBOOTSTATUS, WDIOC_SETTIMEOUT,
- *                            WDIOC_GETTIMEOUT, and WDIOC_SETOPTIONS ioctls
+ *                            changed watchdog_info to correctly reflect what
+ *                            the driver offers
+ *                            added WDIOC_GETSTATUS, WDIOC_GETBOOTSTATUS,
+ *                            WDIOC_SETTIMEOUT, WDIOC_GETTIMEOUT, and
+ *                            WDIOC_SETOPTIONS ioctls
  *           09/8 - 2003      [wim@iguana.be] cleanup of trailing spaces
  *                            use module_param
- *                            made timeout (the emulated heartbeat) a module_param
+ *                            made timeout (the emulated heartbeat) a
+ *                            module_param
  *                            made the keepalive ping an internal subroutine
  *                            made wdt_stop and wdt_start module params
  *                            added extra printk's for startup problems
@@ -56,9 +60,9 @@
 #include <linux/notifier.h>
 #include <linux/reboot.h>
 #include <linux/init.h>
+#include <linux/io.h>
+#include <linux/uaccess.h>
 
-#include <asm/io.h>
-#include <asm/uaccess.h>
 #include <asm/system.h>
 
 #define OUR_NAME "sbc60xxwdt"
@@ -94,13 +98,18 @@ MODULE_PARM_DESC(wdt_start, "SBC60xx WDT 'start' io port (default 0x443)");
  */
 
 #define WATCHDOG_TIMEOUT 30             /* 30 sec default timeout */
-static int timeout = WATCHDOG_TIMEOUT;  /* in seconds, will be multiplied by HZ to get seconds to wait for a ping */
+static int timeout = WATCHDOG_TIMEOUT;  /* in seconds, multiplied by HZ to
+                                           get seconds to wait for a ping */
 module_param(timeout, int, 0);
-MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds. (1<=timeout<=3600, default=" __MODULE_STRING(WATCHDOG_TIMEOUT) ")");
+MODULE_PARM_DESC(timeout,
+        "Watchdog timeout in seconds. (1<=timeout<=3600, default="
+                                __MODULE_STRING(WATCHDOG_TIMEOUT) ")");
 
 static int nowayout = WATCHDOG_NOWAYOUT;
 module_param(nowayout, int, 0);
-MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+MODULE_PARM_DESC(nowayout,
+        "Watchdog cannot be stopped once started (default="
+                                __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 
 static void wdt_timer_ping(unsigned long);
 static DEFINE_TIMER(timer, wdt_timer_ping, 0, 0);
@@ -117,15 +126,14 @@ static void wdt_timer_ping(unsigned long data)
         /* If we got a heartbeat pulse within the WDT_US_INTERVAL
          * we agree to ping the WDT
          */
-        if(time_before(jiffies, next_heartbeat))
-        {
+        if (time_before(jiffies, next_heartbeat)) {
                 /* Ping the WDT by reading from wdt_start */
                 inb_p(wdt_start);
                 /* Re-set the timer interval */
                 mod_timer(&timer, jiffies + WDT_INTERVAL);
-        } else {
-                printk(KERN_WARNING PFX "Heartbeat lost! Will not ping the watchdog\n");
-        }
+        } else
+                printk(KERN_WARNING PFX
+                        "Heartbeat lost! Will not ping the watchdog\n");
 }
 
 /*
@@ -159,40 +167,40 @@ static void wdt_keepalive(void)
  * /dev/watchdog handling
  */
 
-static ssize_t fop_write(struct file * file, const char __user * buf, size_t count, loff_t * ppos)
+static ssize_t fop_write(struct file *file, const char __user *buf,
+                                                size_t count, loff_t *ppos)
 {
         /* See if we got the magic character 'V' and reload the timer */
-        if(count)
-        {
-                if (!nowayout)
-                {
+        if (count) {
+                if (!nowayout) {
                         size_t ofs;
 
-                        /* note: just in case someone wrote the magic character
-                         * five months ago... */
+                        /* note: just in case someone wrote the
+                           magic character five months ago... */
                         wdt_expect_close = 0;
 
-                        /* scan to see whether or not we got the magic character */
-                        for(ofs = 0; ofs != count; ofs++)
-                        {
+                        /* scan to see whether or not we got the
+                           magic character */
+                        for (ofs = 0; ofs != count; ofs++) {
                                 char c;
-                                if(get_user(c, buf+ofs))
+                                if (get_user(c, buf + ofs))
                                         return -EFAULT;
-                                if(c == 'V')
+                                if (c == 'V')
                                         wdt_expect_close = 42;
                         }
                 }
 
-                /* Well, anyhow someone wrote to us, we should return that favour */
+                /* Well, anyhow someone wrote to us, we should
+                   return that favour */
                 wdt_keepalive();
         }
         return count;
 }
 
-static int fop_open(struct inode * inode, struct file * file)
+static int fop_open(struct inode *inode, struct file *file)
 {
         /* Just in case we're already talking to someone... */
-        if(test_and_set_bit(0, &wdt_is_open))
+        if (test_and_set_bit(0, &wdt_is_open))
                 return -EBUSY;
 
         if (nowayout)
@@ -203,78 +211,72 @@ static int fop_open(struct inode * inode, struct file * file)
         return nonseekable_open(inode, file);
 }
 
-static int fop_close(struct inode * inode, struct file * file)
+static int fop_close(struct inode *inode, struct file *file)
 {
-        if(wdt_expect_close == 42)
+        if (wdt_expect_close == 42)
                 wdt_turnoff();
         else {
                 del_timer(&timer);
-                printk(KERN_CRIT PFX "device file closed unexpectedly. Will not stop the WDT!\n");
+                printk(KERN_CRIT PFX
+                  "device file closed unexpectedly. Will not stop the WDT!\n");
         }
         clear_bit(0, &wdt_is_open);
         wdt_expect_close = 0;
         return 0;
 }
 
-static int fop_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
-        unsigned long arg)
+static long fop_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
-        static struct watchdog_info ident=
-        {
-                .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE,
+        static const struct watchdog_info ident = {
+                .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT |
+                                                        WDIOF_MAGICCLOSE,
                 .firmware_version = 1,
                 .identity = "SBC60xx",
         };
 
-        switch(cmd)
+        switch (cmd) {
+        case WDIOC_GETSUPPORT:
+                return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;
+        case WDIOC_GETSTATUS:
+        case WDIOC_GETBOOTSTATUS:
+                return put_user(0, p);
+        case WDIOC_SETOPTIONS:
         {
-                default:
-                        return -ENOTTY;
-                case WDIOC_GETSUPPORT:
-                        return copy_to_user(argp, &ident, sizeof(ident))?-EFAULT:0;
-                case WDIOC_GETSTATUS:
-                case WDIOC_GETBOOTSTATUS:
-                        return put_user(0, p);
-                case WDIOC_KEEPALIVE:
-                        wdt_keepalive();
-                        return 0;
-                case WDIOC_SETOPTIONS:
-                {
-                        int new_options, retval = -EINVAL;
-
-                        if(get_user(new_options, p))
-                                return -EFAULT;
-
-                        if(new_options & WDIOS_DISABLECARD) {
-                                wdt_turnoff();
-                                retval = 0;
-                        }
-
-                        if(new_options & WDIOS_ENABLECARD) {
-                                wdt_startup();
-                                retval = 0;
-                        }
-
-                        return retval;
+                int new_options, retval = -EINVAL;
+                if (get_user(new_options, p))
+                        return -EFAULT;
+                if (new_options & WDIOS_DISABLECARD) {
+                        wdt_turnoff();
+                        retval = 0;
                 }
-                case WDIOC_SETTIMEOUT:
-                {
-                        int new_timeout;
-
-                        if(get_user(new_timeout, p))
-                                return -EFAULT;
-
-                        if(new_timeout < 1 || new_timeout > 3600) /* arbitrary upper limit */
-                                return -EINVAL;
-
-                        timeout = new_timeout;
-                        wdt_keepalive();
-                        /* Fall through */
+                if (new_options & WDIOS_ENABLECARD) {
+                        wdt_startup();
+                        retval = 0;
                 }
-                case WDIOC_GETTIMEOUT:
-                        return put_user(timeout, p);
+                return retval;
+        }
+        case WDIOC_KEEPALIVE:
+                wdt_keepalive();
+                return 0;
+        case WDIOC_SETTIMEOUT:
+        {
+                int new_timeout;
+                if (get_user(new_timeout, p))
+                        return -EFAULT;
+                /* arbitrary upper limit */
+                if (new_timeout < 1 || new_timeout > 3600)
+                        return -EINVAL;
+
+                timeout = new_timeout;
+                wdt_keepalive();
+                /* Fall through */
+        }
+        case WDIOC_GETTIMEOUT:
+                return put_user(timeout, p);
+        default:
+                return -ENOTTY;
         }
 }
 
@@ -284,7 +286,7 @@ static const struct file_operations wdt_fops = {
         .write          = fop_write,
         .open           = fop_open,
         .release        = fop_close,
-        .ioctl          = fop_ioctl,
+        .unlocked_ioctl = fop_ioctl,
 };
 
 static struct miscdevice wdt_miscdev = {
@@ -300,7 +302,7 @@ static struct miscdevice wdt_miscdev = {
 static int wdt_notify_sys(struct notifier_block *this, unsigned long code,
         void *unused)
 {
-        if(code==SYS_DOWN || code==SYS_HALT)
+        if (code == SYS_DOWN || code == SYS_HALT)
                 wdt_turnoff();
         return NOTIFY_DONE;
 }
@@ -310,8 +312,7 @@ static int wdt_notify_sys(struct notifier_block *this, unsigned long code,
  *      turn the timebomb registers off.
  */
 
-static struct notifier_block wdt_notifier=
-{
+static struct notifier_block wdt_notifier = {
         .notifier_call = wdt_notify_sys,
 };
 
@@ -324,23 +325,22 @@ static void __exit sbc60xxwdt_unload(void)
 
         unregister_reboot_notifier(&wdt_notifier);
         if ((wdt_stop != 0x45) && (wdt_stop != wdt_start))
-                release_region(wdt_stop,1);
-        release_region(wdt_start,1);
+                release_region(wdt_stop, 1);
+        release_region(wdt_start, 1);
 }
 
 static int __init sbc60xxwdt_init(void)
 {
         int rc = -EBUSY;
 
-        if(timeout < 1 || timeout > 3600) /* arbitrary upper limit */
-        {
+        if (timeout < 1 || timeout > 3600) { /* arbitrary upper limit */
                 timeout = WATCHDOG_TIMEOUT;
-                printk(KERN_INFO PFX "timeout value must be 1<=x<=3600, using %d\n",
-                        timeout);
-        }
+                printk(KERN_INFO PFX
+                        "timeout value must be 1 <= x <= 3600, using %d\n",
+                                                                timeout);
+        }
 
-        if (!request_region(wdt_start, 1, "SBC 60XX WDT"))
-        {
+        if (!request_region(wdt_start, 1, "SBC 60XX WDT")) {
                 printk(KERN_ERR PFX "I/O address 0x%04x already in use\n",
                         wdt_start);
                 rc = -EIO;
@@ -348,33 +348,30 @@ static int __init sbc60xxwdt_init(void)
         }
 
         /* We cannot reserve 0x45 - the kernel already has! */
-        if ((wdt_stop != 0x45) && (wdt_stop != wdt_start))
-        {
-                if (!request_region(wdt_stop, 1, "SBC 60XX WDT"))
-                {
-                        printk(KERN_ERR PFX "I/O address 0x%04x already in use\n",
-                                wdt_stop);
+        if (wdt_stop != 0x45 && wdt_stop != wdt_start) {
+                if (!request_region(wdt_stop, 1, "SBC 60XX WDT")) {
+                        printk(KERN_ERR PFX
+                                "I/O address 0x%04x already in use\n",
+                                                        wdt_stop);
                         rc = -EIO;
                         goto err_out_region1;
                 }
         }
 
         rc = register_reboot_notifier(&wdt_notifier);
-        if (rc)
-        {
-                printk(KERN_ERR PFX "cannot register reboot notifier (err=%d)\n",
-                        rc);
+        if (rc) {
+                printk(KERN_ERR PFX
+                        "cannot register reboot notifier (err=%d)\n", rc);
                 goto err_out_region2;
         }
 
         rc = misc_register(&wdt_miscdev);
-        if (rc)
-        {
-                printk(KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",
-                        wdt_miscdev.minor, rc);
+        if (rc) {
+                printk(KERN_ERR PFX
+                        "cannot register miscdev on minor=%d (err=%d)\n",
+                                                wdt_miscdev.minor, rc);
                 goto err_out_reboot;
         }
-
         printk(KERN_INFO PFX "WDT driver for 60XX single board computer initialised. timeout=%d sec (nowayout=%d)\n",
                 timeout, nowayout);
 
@@ -383,10 +380,10 @@ static int __init sbc60xxwdt_init(void)
 err_out_reboot:
         unregister_reboot_notifier(&wdt_notifier);
 err_out_region2:
-        if ((wdt_stop != 0x45) && (wdt_stop != wdt_start))
-                release_region(wdt_stop,1);
+        if (wdt_stop != 0x45 && wdt_stop != wdt_start)
+                release_region(wdt_stop, 1);
 err_out_region1:
-        release_region(wdt_start,1);
+        release_region(wdt_start, 1);
 err_out:
         return rc;
 }
diff --git a/drivers/watchdog/sbc7240_wdt.c b/drivers/watchdog/sbc7240_wdt.c
index 4c8cefbd8627..67ddeb1c830a 100644
--- a/drivers/watchdog/sbc7240_wdt.c
+++ b/drivers/watchdog/sbc7240_wdt.c
@@ -27,10 +27,10 @@
 #include <linux/reboot.h>
 #include <linux/types.h>
 #include <linux/watchdog.h>
+#include <linux/io.h>
+#include <linux/uaccess.h>
 #include <asm/atomic.h>
-#include <asm/io.h>
 #include <asm/system.h>
-#include <asm/uaccess.h>
 
 #define SBC7240_PREFIX "sbc7240_wdt: "
 
@@ -159,7 +159,7 @@ static int fop_close(struct inode *inode, struct file *file)
         return 0;
 }
 
-static struct watchdog_info ident = {
+static const struct watchdog_info ident = {
         .options = WDIOF_KEEPALIVEPING|
                    WDIOF_SETTIMEOUT|
                    WDIOF_MAGICCLOSE,
@@ -168,50 +168,50 @@ static struct watchdog_info ident = {
 };
 
 
-static int fop_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
-                     unsigned long arg)
+static long fop_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
         switch (cmd) {
         case WDIOC_GETSUPPORT:
-                return copy_to_user
-                        ((void __user *)arg, &ident, sizeof(ident))
-                         ? -EFAULT : 0;
+                return copy_to_user((void __user *)arg, &ident, sizeof(ident))
+                                                 ? -EFAULT : 0;
         case WDIOC_GETSTATUS:
         case WDIOC_GETBOOTSTATUS:
                 return put_user(0, (int __user *)arg);
-        case WDIOC_KEEPALIVE:
-                wdt_keepalive();
-                return 0;
-        case WDIOC_SETOPTIONS:{
-                        int options;
-                        int retval = -EINVAL;
+        case WDIOC_SETOPTIONS:
+        {
+                int options;
+                int retval = -EINVAL;
 
-                        if (get_user(options, (int __user *)arg))
-                                return -EFAULT;
+                if (get_user(options, (int __user *)arg))
+                        return -EFAULT;
 
-                        if (options & WDIOS_DISABLECARD) {
-                                wdt_disable();
-                                retval = 0;
-                        }
-
-                        if (options & WDIOS_ENABLECARD) {
-                                wdt_enable();
-                                retval = 0;
-                        }
+                if (options & WDIOS_DISABLECARD) {
+                        wdt_disable();
+                        retval = 0;
+                }
 
-                        return retval;
+                if (options & WDIOS_ENABLECARD) {
+                        wdt_enable();
+                        retval = 0;
                 }
-        case WDIOC_SETTIMEOUT:{
-                        int new_timeout;
 
-                        if (get_user(new_timeout, (int __user *)arg))
-                                return -EFAULT;
+                return retval;
+        }
+        case WDIOC_KEEPALIVE:
+                wdt_keepalive();
+                return 0;
+        case WDIOC_SETTIMEOUT:
+        {
+                int new_timeout;
 
-                        if (wdt_set_timeout(new_timeout))
-                                return -EINVAL;
+                if (get_user(new_timeout, (int __user *)arg))
+                        return -EFAULT;
 
-                        /* Fall through */
-                }
+                if (wdt_set_timeout(new_timeout))
+                        return -EINVAL;
+
+                /* Fall through */
+        }
         case WDIOC_GETTIMEOUT:
                 return put_user(timeout, (int __user *)arg);
         default:
@@ -225,7 +225,7 @@ static const struct file_operations wdt_fops = {
         .write = fop_write,
         .open = fop_open,
         .release = fop_close,
-        .ioctl = fop_ioctl,
+        .unlocked_ioctl = fop_ioctl,
 };
 
 static struct miscdevice wdt_miscdev = {
diff --git a/drivers/watchdog/sbc8360.c b/drivers/watchdog/sbc8360.c
index 2ee2677f3648..fd83dd052d8c 100644
--- a/drivers/watchdog/sbc8360.c
+++ b/drivers/watchdog/sbc8360.c
@@ -48,13 +48,12 @@
 #include <linux/init.h>
 #include <linux/spinlock.h>
 #include <linux/moduleparam.h>
+#include <linux/io.h>
+#include <linux/uaccess.h>
 
-#include <asm/io.h>
-#include <asm/uaccess.h>
 #include <asm/system.h>
 
 static unsigned long sbc8360_is_open;
-static DEFINE_SPINLOCK(sbc8360_lock);
 static char expect_close;
 
 #define PFX "sbc8360: "
@@ -204,7 +203,8 @@ module_param(timeout, int, 0);
 MODULE_PARM_DESC(timeout, "Index into timeout table (0-63) (default=27 (60s))");
 module_param(nowayout, int, 0);
 MODULE_PARM_DESC(nowayout,
-                 "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+                 "Watchdog cannot be stopped once started (default="
+                                __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 
 /*
  *      Kernel methods.
@@ -231,9 +231,16 @@ static void sbc8360_ping(void)
         outb(wd_margin, SBC8360_BASETIME);
 }
 
+/* stop watchdog */
+static void sbc8360_stop(void)
+{
+        /* De-activate the watchdog */
+        outb(0, SBC8360_ENABLE);
+}
+
 /* Userspace pings kernel driver, or requests clean close */
-static ssize_t sbc8360_write(struct file *file, const char __user * buf,
-                             size_t count, loff_t * ppos)
+static ssize_t sbc8360_write(struct file *file, const char __user *buf,
+                             size_t count, loff_t *ppos)
 {
         if (count) {
                 if (!nowayout) {
@@ -257,16 +264,12 @@ static ssize_t sbc8360_write(struct file *file, const char __user * buf,
 
 static int sbc8360_open(struct inode *inode, struct file *file)
 {
-        spin_lock(&sbc8360_lock);
-        if (test_and_set_bit(0, &sbc8360_is_open)) {
-                spin_unlock(&sbc8360_lock);
+        if (test_and_set_bit(0, &sbc8360_is_open))
                 return -EBUSY;
-        }
         if (nowayout)
                 __module_get(THIS_MODULE);
 
         /* Activate and ping once to start the countdown */
-        spin_unlock(&sbc8360_lock);
         sbc8360_activate();
         sbc8360_ping();
         return nonseekable_open(inode, file);
@@ -274,16 +277,14 @@ static int sbc8360_open(struct inode *inode, struct file *file)
 
 static int sbc8360_close(struct inode *inode, struct file *file)
 {
-        spin_lock(&sbc8360_lock);
         if (expect_close == 42)
-                outb(0, SBC8360_ENABLE);
+                sbc8360_stop();
         else
                 printk(KERN_CRIT PFX
-                       "SBC8360 device closed unexpectedly.  SBC8360 will not stop!\n");
+                        "SBC8360 device closed unexpectedly.  SBC8360 will not stop!\n");
 
         clear_bit(0, &sbc8360_is_open);
         expect_close = 0;
-        spin_unlock(&sbc8360_lock);
         return 0;
 }
 
@@ -294,10 +295,9 @@ static int sbc8360_close(struct inode *inode, struct file *file)
 static int sbc8360_notify_sys(struct notifier_block *this, unsigned long code,
                               void *unused)
 {
-        if (code == SYS_DOWN || code == SYS_HALT) {
-                /* Disable the SBC8360 Watchdog */
-                outb(0, SBC8360_ENABLE);
-        }
+        if (code == SYS_DOWN || code == SYS_HALT)
+                sbc8360_stop(); /* Disable the SBC8360 Watchdog */
+
         return NOTIFY_DONE;
 }
 
@@ -382,13 +382,13 @@ static int __init sbc8360_init(void)
 
         return 0;
 
-      out_nomisc:
+out_nomisc:
         unregister_reboot_notifier(&sbc8360_notifier);
-      out_noreboot:
+out_noreboot:
         release_region(SBC8360_BASETIME, 1);
-      out_nobasetimereg:
+out_nobasetimereg:
         release_region(SBC8360_ENABLE, 1);
-      out:
+out:
         return res;
 }
 
diff --git a/drivers/watchdog/sbc_epx_c3.c b/drivers/watchdog/sbc_epx_c3.c
index 82cbd8809a69..e5e470ca7759 100644
--- a/drivers/watchdog/sbc_epx_c3.c
+++ b/drivers/watchdog/sbc_epx_c3.c
@@ -25,8 +25,8 @@
 #include <linux/reboot.h>
 #include <linux/init.h>
 #include <linux/ioport.h>
-#include <asm/uaccess.h>
-#include <asm/io.h>
+#include <linux/uaccess.h>
+#include <linux/io.h>
 
 #define PFX "epx_c3: "
 static int epx_c3_alive;
@@ -100,12 +100,12 @@ static ssize_t epx_c3_write(struct file *file, const char __user *data,
         return len;
 }
 
-static int epx_c3_ioctl(struct inode *inode, struct file *file,
-                        unsigned int cmd, unsigned long arg)
+static long epx_c3_ioctl(struct file *file, unsigned int cmd,
+                                                unsigned long arg)
 {
         int options, retval = -EINVAL;
         int __user *argp = (void __user *)arg;
-        static struct watchdog_info ident = {
+        static const struct watchdog_info ident = {
                 .options                = WDIOF_KEEPALIVEPING |
                                           WDIOF_MAGICCLOSE,
                 .firmware_version       = 0,
@@ -120,11 +120,6 @@ static int epx_c3_ioctl(struct inode *inode, struct file *file,
         case WDIOC_GETSTATUS:
         case WDIOC_GETBOOTSTATUS:
                 return put_user(0, argp);
-        case WDIOC_KEEPALIVE:
-                epx_c3_pet();
-                return 0;
-        case WDIOC_GETTIMEOUT:
-                return put_user(WATCHDOG_TIMEOUT, argp);
         case WDIOC_SETOPTIONS:
                 if (get_user(options, argp))
                         return -EFAULT;
@@ -140,6 +135,11 @@ static int epx_c3_ioctl(struct inode *inode, struct file *file,
                 }
 
                 return retval;
+        case WDIOC_KEEPALIVE:
+                epx_c3_pet();
+                return 0;
+        case WDIOC_GETTIMEOUT:
+                return put_user(WATCHDOG_TIMEOUT, argp);
         default:
                 return -ENOTTY;
         }
@@ -158,7 +158,7 @@ static const struct file_operations epx_c3_fops = {
         .owner          = THIS_MODULE,
         .llseek         = no_llseek,
         .write          = epx_c3_write,
-        .ioctl          = epx_c3_ioctl,
+        .unlocked_ioctl = epx_c3_ioctl,
         .open           = epx_c3_open,
         .release        = epx_c3_release,
 };
diff --git a/drivers/watchdog/sc1200wdt.c b/drivers/watchdog/sc1200wdt.c
index 621ebad56d86..23da3ccd832a 100644
--- a/drivers/watchdog/sc1200wdt.c
+++ b/drivers/watchdog/sc1200wdt.c
@@ -196,7 +196,6 @@ static long sc1200wdt_ioctl(struct file *file, unsigned int cmd,
         };
 
         switch (cmd) {
-
         case WDIOC_GETSUPPORT:
                 if (copy_to_user(argp, &ident, sizeof ident))
                         return -EFAULT;
@@ -208,24 +207,6 @@ static long sc1200wdt_ioctl(struct file *file, unsigned int cmd,
         case WDIOC_GETBOOTSTATUS:
                 return put_user(0, p);
 
-        case WDIOC_KEEPALIVE:
-                sc1200wdt_write_data(WDTO, timeout);
-                return 0;
-
-        case WDIOC_SETTIMEOUT:
-                if (get_user(new_timeout, p))
-                        return -EFAULT;
-                /* the API states this is given in secs */
-                new_timeout /= 60;
-                if (new_timeout < 0 || new_timeout > MAX_TIMEOUT)
-                        return -EINVAL;
-                timeout = new_timeout;
-                sc1200wdt_write_data(WDTO, timeout);
-                /* fall through and return the new timeout */
-
-        case WDIOC_GETTIMEOUT:
-                return put_user(timeout * 60, p);
-
         case WDIOC_SETOPTIONS:
         {
                 int options, retval = -EINVAL;
@@ -245,6 +226,24 @@ static long sc1200wdt_ioctl(struct file *file, unsigned int cmd,
 
                 return retval;
         }
+        case WDIOC_KEEPALIVE:
+                sc1200wdt_write_data(WDTO, timeout);
+                return 0;
+
+        case WDIOC_SETTIMEOUT:
+                if (get_user(new_timeout, p))
+                        return -EFAULT;
+                /* the API states this is given in secs */
+                new_timeout /= 60;
+                if (new_timeout < 0 || new_timeout > MAX_TIMEOUT)
+                        return -EINVAL;
+                timeout = new_timeout;
+                sc1200wdt_write_data(WDTO, timeout);
+                /* fall through and return the new timeout */
+
+        case WDIOC_GETTIMEOUT:
+                return put_user(timeout * 60, p);
+
         default:
                 return -ENOTTY;
         }
@@ -280,7 +279,7 @@ static ssize_t sc1200wdt_write(struct file *file, const char __user *data,
                         for (i = 0; i != len; i++) {
                                 char c;
 
-                                if (get_user(c, data+i))
+                                if (get_user(c, data + i))
                                         return -EFAULT;
                                 if (c == 'V')
                                         expect_close = 42;
diff --git a/drivers/watchdog/sc520_wdt.c b/drivers/watchdog/sc520_wdt.c
index 2847324a2be2..a2b6c1067ec5 100644
--- a/drivers/watchdog/sc520_wdt.c
+++ b/drivers/watchdog/sc520_wdt.c
@@ -64,9 +64,9 @@
 #include <linux/reboot.h>
 #include <linux/init.h>
 #include <linux/jiffies.h>
+#include <linux/io.h>
+#include <linux/uaccess.h>
 
-#include <asm/io.h>
-#include <asm/uaccess.h>
 #include <asm/system.h>
 
 #define OUR_NAME "sc520_wdt"
@@ -91,13 +91,18 @@
  */
 
 #define WATCHDOG_TIMEOUT 30             /* 30 sec default timeout */
-static int timeout = WATCHDOG_TIMEOUT;  /* in seconds, will be multiplied by HZ to get seconds to wait for a ping */
+/* in seconds, will be multiplied by HZ to get seconds to wait for a ping */
+static int timeout = WATCHDOG_TIMEOUT;
 module_param(timeout, int, 0);
-MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds. (1<=timeout<=3600, default=" __MODULE_STRING(WATCHDOG_TIMEOUT) ")");
+MODULE_PARM_DESC(timeout,
+        "Watchdog timeout in seconds. (1 <= timeout <= 3600, default="
+                                __MODULE_STRING(WATCHDOG_TIMEOUT) ")");
 
 static int nowayout = WATCHDOG_NOWAYOUT;
 module_param(nowayout, int, 0);
-MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+MODULE_PARM_DESC(nowayout,
+                "Watchdog cannot be stopped once started (default="
+                                __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 
 /*
  * AMD Elan SC520 - Watchdog Timer Registers
@@ -136,8 +141,7 @@ static void wdt_timer_ping(unsigned long data)
         /* If we got a heartbeat pulse within the WDT_US_INTERVAL
          * we agree to ping the WDT
          */
-        if(time_before(jiffies, next_heartbeat))
-        {
+        if (time_before(jiffies, next_heartbeat)) {
                 /* Ping the WDT */
                 spin_lock(&wdt_spinlock);
                 writew(0xAAAA, wdtmrctl);
@@ -146,9 +150,9 @@ static void wdt_timer_ping(unsigned long data)
 
                 /* Re-set the timer interval */
                 mod_timer(&timer, jiffies + WDT_INTERVAL);
-        } else {
-                printk(KERN_WARNING PFX "Heartbeat lost! Will not ping the watchdog\n");
-        }
+        } else
+                printk(KERN_WARNING PFX
+                        "Heartbeat lost! Will not ping the watchdog\n");
 }
 
 /*
@@ -162,7 +166,7 @@ static void wdt_config(int writeval)
 
         /* buy some time (ping) */
         spin_lock_irqsave(&wdt_spinlock, flags);
-        dummy=readw(wdtmrctl);  /* ensure write synchronization */
+        dummy = readw(wdtmrctl);        /* ensure write synchronization */
         writew(0xAAAA, wdtmrctl);
         writew(0x5555, wdtmrctl);
         /* unlock WDT = make WDT configuration register writable one time */
@@ -219,10 +223,11 @@ static int wdt_set_heartbeat(int t)
  *      /dev/watchdog handling
  */
 
-static ssize_t fop_write(struct file * file, const char __user * buf, size_t count, loff_t * ppos)
+static ssize_t fop_write(struct file *file, const char __user *buf,
+                                                size_t count, loff_t *ppos)
 {
         /* See if we got the magic character 'V' and reload the timer */
-        if(count) {
+        if (count) {
                 if (!nowayout) {
                         size_t ofs;
 
@@ -231,25 +236,26 @@ static ssize_t fop_write(struct file * file, const char __user * buf, size_t cou
                         wdt_expect_close = 0;
 
                         /* now scan */
-                        for(ofs = 0; ofs != count; ofs++) {
+                        for (ofs = 0; ofs != count; ofs++) {
                                 char c;
                                 if (get_user(c, buf + ofs))
                                         return -EFAULT;
-                                if(c == 'V')
+                                if (c == 'V')
                                         wdt_expect_close = 42;
                         }
                 }
 
-                /* Well, anyhow someone wrote to us, we should return that favour */
+                /* Well, anyhow someone wrote to us, we should
+                   return that favour */
                 wdt_keepalive();
         }
         return count;
 }
 
-static int fop_open(struct inode * inode, struct file * file)
+static int fop_open(struct inode *inode, struct file *file)
 {
         /* Just in case we're already talking to someone... */
-        if(test_and_set_bit(0, &wdt_is_open))
+        if (test_and_set_bit(0, &wdt_is_open))
                 return -EBUSY;
         if (nowayout)
                 __module_get(THIS_MODULE);
@@ -259,12 +265,13 @@ static int fop_open(struct inode * inode, struct file * file)
         return nonseekable_open(inode, file);
 }
 
-static int fop_close(struct inode * inode, struct file * file)
+static int fop_close(struct inode *inode, struct file *file)
 {
-        if(wdt_expect_close == 42) {
+        if (wdt_expect_close == 42)
                 wdt_turnoff();
-        } else {
-                printk(KERN_CRIT PFX "Unexpected close, not stopping watchdog!\n");
+        else {
+                printk(KERN_CRIT PFX
+                        "Unexpected close, not stopping watchdog!\n");
                 wdt_keepalive();
         }
         clear_bit(0, &wdt_is_open);
@@ -272,63 +279,62 @@ static int fop_close(struct inode * inode, struct file * file)
         return 0;
 }
 
-static int fop_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
-        unsigned long arg)
+static long fop_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
-        static struct watchdog_info ident = {
-                .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE,
+        static const struct watchdog_info ident = {
+                .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT
+                                                        | WDIOF_MAGICCLOSE,
                 .firmware_version = 1,
                 .identity = "SC520",
         };
 
-        switch(cmd)
+        switch (cmd) {
+        case WDIOC_GETSUPPORT:
+                return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;
+        case WDIOC_GETSTATUS:
+        case WDIOC_GETBOOTSTATUS:
+                return put_user(0, p);
+        case WDIOC_SETOPTIONS:
         {
-                default:
-                        return -ENOTTY;
-                case WDIOC_GETSUPPORT:
-                        return copy_to_user(argp, &ident, sizeof(ident))?-EFAULT:0;
-                case WDIOC_GETSTATUS:
-                case WDIOC_GETBOOTSTATUS:
-                        return put_user(0, p);
-                case WDIOC_KEEPALIVE:
-                        wdt_keepalive();
-                        return 0;
-                case WDIOC_SETOPTIONS:
-                {
-                        int new_options, retval = -EINVAL;
-
-                        if(get_user(new_options, p))
-                                return -EFAULT;
-
-                        if(new_options & WDIOS_DISABLECARD) {
-                                wdt_turnoff();
-                                retval = 0;
-                        }
+                int new_options, retval = -EINVAL;
 
-                        if(new_options & WDIOS_ENABLECARD) {
-                                wdt_startup();
-                                retval = 0;
-                        }
+                if (get_user(new_options, p))
+                        return -EFAULT;
 
-                        return retval;
+                if (new_options & WDIOS_DISABLECARD) {
+                        wdt_turnoff();
+                        retval = 0;
                 }
-                case WDIOC_SETTIMEOUT:
-                {
-                        int new_timeout;
 
-                        if(get_user(new_timeout, p))
-                                return -EFAULT;
+                if (new_options & WDIOS_ENABLECARD) {
+                        wdt_startup();
+                        retval = 0;
+                }
 
-                        if(wdt_set_heartbeat(new_timeout))
-                                return -EINVAL;
+                return retval;
+        }
+        case WDIOC_KEEPALIVE:
+                wdt_keepalive();
+                return 0;
+        case WDIOC_SETTIMEOUT:
+        {
+                int new_timeout;
 
-                        wdt_keepalive();
-                        /* Fall through */
-                }
-                case WDIOC_GETTIMEOUT:
-                        return put_user(timeout, p);
+                if (get_user(new_timeout, p))
+                        return -EFAULT;
+
+                if (wdt_set_heartbeat(new_timeout))
+                        return -EINVAL;
+
+                wdt_keepalive();
+                /* Fall through */
+        }
+        case WDIOC_GETTIMEOUT:
+                return put_user(timeout, p);
+        default:
+                return -ENOTTY;
         }
 }
 
@@ -338,7 +344,7 @@ static const struct file_operations wdt_fops = {
         .write          = fop_write,
         .open           = fop_open,
         .release        = fop_close,
-        .ioctl          = fop_ioctl,
+        .unlocked_ioctl = fop_ioctl,
 };
 
 static struct miscdevice wdt_miscdev = {
@@ -354,7 +360,7 @@ static struct miscdevice wdt_miscdev = {
 static int wdt_notify_sys(struct notifier_block *this, unsigned long code,
         void *unused)
 {
-        if(code==SYS_DOWN || code==SYS_HALT)
+        if (code == SYS_DOWN || code == SYS_HALT)
                 wdt_turnoff();
         return NOTIFY_DONE;
 }
@@ -383,11 +389,13 @@ static int __init sc520_wdt_init(void)
 {
         int rc = -EBUSY;
 
-        /* Check that the timeout value is within it's range ; if not reset to the default */
+        /* Check that the timeout value is within it's range ;
+           if not reset to the default */
         if (wdt_set_heartbeat(timeout)) {
                 wdt_set_heartbeat(WATCHDOG_TIMEOUT);
-                printk(KERN_INFO PFX "timeout value must be 1<=timeout<=3600, using %d\n",
-                        WATCHDOG_TIMEOUT);
+                printk(KERN_INFO PFX
+                    "timeout value must be 1 <= timeout <= 3600, using %d\n",
+                                                        WATCHDOG_TIMEOUT);
         }
 
         wdtmrctl = ioremap((unsigned long)(MMCR_BASE + OFFS_WDTMRCTL), 2);
@@ -399,20 +407,22 @@ static int __init sc520_wdt_init(void)
 
         rc = register_reboot_notifier(&wdt_notifier);
         if (rc) {
-                printk(KERN_ERR PFX "cannot register reboot notifier (err=%d)\n",
-                        rc);
+                printk(KERN_ERR PFX
+                        "cannot register reboot notifier (err=%d)\n", rc);
                 goto err_out_ioremap;
         }
 
         rc = misc_register(&wdt_miscdev);
         if (rc) {
-                printk(KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",
-                        WATCHDOG_MINOR, rc);
+                printk(KERN_ERR PFX
+                        "cannot register miscdev on minor=%d (err=%d)\n",
+                                                        WATCHDOG_MINOR, rc);
                 goto err_out_notifier;
         }
 
-        printk(KERN_INFO PFX "WDT driver for SC520 initialised. timeout=%d sec (nowayout=%d)\n",
-                timeout,nowayout);
+        printk(KERN_INFO PFX
+           "WDT driver for SC520 initialised. timeout=%d sec (nowayout=%d)\n",
+                                                        timeout, nowayout);
 
         return 0;
 
diff --git a/drivers/watchdog/scx200_wdt.c b/drivers/watchdog/scx200_wdt.c
index d55882bca319..9e19a10a5bb9 100644
--- a/drivers/watchdog/scx200_wdt.c
+++ b/drivers/watchdog/scx200_wdt.c
@@ -27,9 +27,8 @@
 #include <linux/fs.h>
 #include <linux/ioport.h>
 #include <linux/scx200.h>
-
-#include <asm/uaccess.h>
-#include <asm/io.h>
+#include <linux/uaccess.h>
+#include <linux/io.h>
 
 #define NAME "scx200_wdt"
 
@@ -47,8 +46,9 @@ module_param(nowayout, int, 0);
 MODULE_PARM_DESC(nowayout, "Disable watchdog shutdown on close");
 
 static u16 wdto_restart;
-static struct semaphore open_semaphore;
 static char expect_close;
+static unsigned long open_lock;
+static DEFINE_SPINLOCK(scx_lock);
 
 /* Bits of the WDCNFG register */
 #define W_ENABLE 0x00fa         /* Enable watchdog */
@@ -59,7 +59,9 @@ static char expect_close;
 
 static void scx200_wdt_ping(void)
 {
+        spin_lock(&scx_lock);
         outw(wdto_restart, scx200_cb_base + SCx200_WDT_WDTO);
+        spin_unlock(&scx_lock);
 }
 
 static void scx200_wdt_update_margin(void)
@@ -73,9 +75,11 @@ static void scx200_wdt_enable(void)
         printk(KERN_DEBUG NAME ": enabling watchdog timer, wdto_restart = %d\n",
                wdto_restart);
 
+        spin_lock(&scx_lock);
         outw(0, scx200_cb_base + SCx200_WDT_WDTO);
         outb(SCx200_WDT_WDSTS_WDOVF, scx200_cb_base + SCx200_WDT_WDSTS);
         outw(W_ENABLE, scx200_cb_base + SCx200_WDT_WDCNFG);
+        spin_unlock(&scx_lock);
 
         scx200_wdt_ping();
 }
@@ -84,15 +88,17 @@ static void scx200_wdt_disable(void)
 {
         printk(KERN_DEBUG NAME ": disabling watchdog timer\n");
 
+        spin_lock(&scx_lock);
         outw(0, scx200_cb_base + SCx200_WDT_WDTO);
         outb(SCx200_WDT_WDSTS_WDOVF, scx200_cb_base + SCx200_WDT_WDSTS);
         outw(W_DISABLE, scx200_cb_base + SCx200_WDT_WDCNFG);
+        spin_unlock(&scx_lock);
 }
 
 static int scx200_wdt_open(struct inode *inode, struct file *file)
 {
         /* only allow one at a time */
-        if (down_trylock(&open_semaphore))
+        if (test_and_set_bit(0, &open_lock))
                 return -EBUSY;
         scx200_wdt_enable();
 
@@ -101,13 +107,12 @@ static int scx200_wdt_open(struct inode *inode, struct file *file)
 
 static int scx200_wdt_release(struct inode *inode, struct file *file)
 {
-        if (expect_close != 42) {
+        if (expect_close != 42)
                 printk(KERN_WARNING NAME ": watchdog device closed unexpectedly, will not disable the watchdog timer\n");
-        } else if (!nowayout) {
+        else if (!nowayout)
                 scx200_wdt_disable();
-        }
         expect_close = 0;
-        up(&open_semaphore);
+        clear_bit(0, &open_lock);
 
         return 0;
 }
@@ -122,8 +127,7 @@ static int scx200_wdt_notify_sys(struct notifier_block *this,
         return NOTIFY_DONE;
 }
 
-static struct notifier_block scx200_wdt_notifier =
-{
+static struct notifier_block scx200_wdt_notifier = {
         .notifier_call = scx200_wdt_notify_sys,
 };
 
@@ -131,8 +135,7 @@ static ssize_t scx200_wdt_write(struct file *file, const char __user *data,
                                      size_t len, loff_t *ppos)
 {
         /* check for a magic close character */
-        if (len)
-        {
+        if (len) {
                 size_t i;
 
                 scx200_wdt_ping();
@@ -140,7 +143,7 @@ static ssize_t scx200_wdt_write(struct file *file, const char __user *data,
                 expect_close = 0;
                 for (i = 0; i < len; ++i) {
                         char c;
-                        if (get_user(c, data+i))
+                        if (get_user(c, data + i))
                                 return -EFAULT;
                         if (c == 'V')
                                 expect_close = 42;
@@ -152,23 +155,21 @@ static ssize_t scx200_wdt_write(struct file *file, const char __user *data,
         return 0;
 }
 
-static int scx200_wdt_ioctl(struct inode *inode, struct file *file,
-        unsigned int cmd, unsigned long arg)
+static long scx200_wdt_ioctl(struct file *file, unsigned int cmd,
+                                                        unsigned long arg)
 {
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
-        static struct watchdog_info ident = {
+        static const struct watchdog_info ident = {
                 .identity = "NatSemi SCx200 Watchdog",
                 .firmware_version = 1,
-                .options = (WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING),
+                .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
         };
         int new_margin;
 
         switch (cmd) {
-        default:
-                return -ENOTTY;
         case WDIOC_GETSUPPORT:
-                if(copy_to_user(argp, &ident, sizeof(ident)))
+                if (copy_to_user(argp, &ident, sizeof(ident)))
                         return -EFAULT;
                 return 0;
         case WDIOC_GETSTATUS:
@@ -191,22 +192,24 @@ static int scx200_wdt_ioctl(struct inode *inode, struct file *file,
                 if (put_user(margin, p))
                         return -EFAULT;
                 return 0;
+        default:
+                return -ENOTTY;
         }
 }
 
 static const struct file_operations scx200_wdt_fops = {
-        .owner   = THIS_MODULE,
-        .llseek  = no_llseek,
-        .write   = scx200_wdt_write,
-        .ioctl   = scx200_wdt_ioctl,
-        .open    = scx200_wdt_open,
+        .owner = THIS_MODULE,
+        .llseek = no_llseek,
+        .write = scx200_wdt_write,
+        .unlocked_ioctl = scx200_wdt_ioctl,
+        .open = scx200_wdt_open,
         .release = scx200_wdt_release,
 };
 
 static struct miscdevice scx200_wdt_miscdev = {
         .minor = WATCHDOG_MINOR,
-        .name  = "watchdog",
-        .fops  = &scx200_wdt_fops,
+        .name = "watchdog",
+        .fops = &scx200_wdt_fops,
 };
 
 static int __init scx200_wdt_init(void)
@@ -229,8 +232,6 @@ static int __init scx200_wdt_init(void)
         scx200_wdt_update_margin();
         scx200_wdt_disable();
 
-        sema_init(&open_semaphore, 1);
-
         r = register_reboot_notifier(&scx200_wdt_notifier);
         if (r) {
                 printk(KERN_ERR NAME ": unable to register reboot notifier");
@@ -263,7 +264,7 @@ module_exit(scx200_wdt_cleanup);
 
 /*
     Local variables:
-        compile-command: "make -k -C ../.. SUBDIRS=drivers/char modules"
-        c-basic-offset: 8
+        compile-command: "make -k -C ../.. SUBDIRS=drivers/char modules"
+        c-basic-offset: 8
     End:
 */
diff --git a/drivers/watchdog/shwdt.c b/drivers/watchdog/shwdt.c
index 1277f7e9cc54..824125adf90a 100644
--- a/drivers/watchdog/shwdt.c
+++ b/drivers/watchdog/shwdt.c
@@ -28,9 +28,9 @@
 #include <linux/ioport.h>
 #include <linux/fs.h>
 #include <linux/mm.h>
-#include <asm/io.h>
-#include <asm/uaccess.h>
-#include <asm/watchdog.h>
+#include <linux/io.h>
+#include <linux/uaccess.h>
+#include <linux/watchdog.h>
 
 #define PFX "shwdt: "
 
@@ -72,6 +72,7 @@ static struct watchdog_info sh_wdt_info;
 static char shwdt_expect_close;
 static DEFINE_TIMER(timer, sh_wdt_ping, 0, 0);
 static unsigned long next_heartbeat;
+static DEFINE_SPINLOCK(shwdt_lock);
 
 #define WATCHDOG_HEARTBEAT 30                   /* 30 sec default heartbeat */
 static int heartbeat = WATCHDOG_HEARTBEAT;      /* in seconds */
@@ -86,6 +87,9 @@ static int nowayout = WATCHDOG_NOWAYOUT;
 static void sh_wdt_start(void)
 {
         __u8 csr;
+        unsigned long flags;
+
+        spin_lock_irqsave(&wdt_lock, flags);
 
         next_heartbeat = jiffies + (heartbeat * HZ);
         mod_timer(&timer, next_ping_period(clock_division_ratio));
@@ -123,6 +127,7 @@ static void sh_wdt_start(void)
         csr &= ~RSTCSR_RSTS;
         sh_wdt_write_rstcsr(csr);
 #endif
+        spin_unlock_irqrestore(&wdt_lock, flags);
 }
 
 /**
@@ -132,12 +137,16 @@ static void sh_wdt_start(void)
 static void sh_wdt_stop(void)
 {
         __u8 csr;
+        unsigned long flags;
+
+        spin_lock_irqsave(&wdt_lock, flags);
 
         del_timer(&timer);
 
         csr = sh_wdt_read_csr();
         csr &= ~WTCSR_TME;
         sh_wdt_write_csr(csr);
+        spin_unlock_irqrestore(&wdt_lock, flags);
 }
 
 /**
@@ -146,7 +155,11 @@ static void sh_wdt_stop(void)
  */
 static inline void sh_wdt_keepalive(void)
 {
+        unsigned long flags;
+
+        spin_lock_irqsave(&wdt_lock, flags);
         next_heartbeat = jiffies + (heartbeat * HZ);
+        spin_unlock_irqrestore(&wdt_lock, flags);
 }
 
 /**
@@ -155,10 +168,14 @@ static inline void sh_wdt_keepalive(void)
  */
 static int sh_wdt_set_heartbeat(int t)
 {
-        if (unlikely((t < 1) || (t > 3600))) /* arbitrary upper limit */
+        unsigned long flags;
+
+        if (unlikely(t < 1 || t > 3600)) /* arbitrary upper limit */
                 return -EINVAL;
 
+        spin_lock_irqsave(&wdt_lock, flags);
         heartbeat = t;
+        spin_unlock_irqrestore(&wdt_lock, flags);
         return 0;
 }
 
@@ -170,6 +187,9 @@ static int sh_wdt_set_heartbeat(int t)
  */
 static void sh_wdt_ping(unsigned long data)
 {
+        unsigned long flags;
+
+        spin_lock_irqsave(&wdt_lock, flags);
         if (time_before(jiffies, next_heartbeat)) {
                 __u8 csr;
 
@@ -183,6 +203,7 @@ static void sh_wdt_ping(unsigned long data)
         } else
                 printk(KERN_WARNING PFX "Heartbeat lost! Will not ping "
                        "the watchdog\n");
+        spin_unlock_irqrestore(&wdt_lock, flags);
 }
 
 /**
@@ -310,7 +331,6 @@ static int sh_wdt_mmap(struct file *file, struct vm_area_struct *vma)
 
 /**
  *      sh_wdt_ioctl - Query Device
- *      @inode: inode of device
  *      @file: file handle of device
  *      @cmd: watchdog command
  *      @arg: argument
@@ -318,53 +338,51 @@ static int sh_wdt_mmap(struct file *file, struct vm_area_struct *vma)
  *      Query basic information from the device or ping it, as outlined by the
  *      watchdog API.
  */
-static int sh_wdt_ioctl(struct inode *inode, struct file *file,
-                        unsigned int cmd, unsigned long arg)
+static long sh_wdt_ioctl(struct file *file, unsigned int cmd,
+                                                        unsigned long arg)
 {
         int new_heartbeat;
         int options, retval = -EINVAL;
 
         switch (cmd) {
-                case WDIOC_GETSUPPORT:
-                        return copy_to_user((struct watchdog_info *)arg,
-                                          &sh_wdt_info,
-                                          sizeof(sh_wdt_info)) ? -EFAULT : 0;
-                case WDIOC_GETSTATUS:
-                case WDIOC_GETBOOTSTATUS:
-                        return put_user(0, (int *)arg);
-                case WDIOC_KEEPALIVE:
-                        sh_wdt_keepalive();
-                        return 0;
-                case WDIOC_SETTIMEOUT:
-                        if (get_user(new_heartbeat, (int *)arg))
-                                return -EFAULT;
-
-                        if (sh_wdt_set_heartbeat(new_heartbeat))
-                                return -EINVAL;
-
-                        sh_wdt_keepalive();
-                        /* Fall */
-                case WDIOC_GETTIMEOUT:
-                        return put_user(heartbeat, (int *)arg);
-                case WDIOC_SETOPTIONS:
-                        if (get_user(options, (int *)arg))
-                                return -EFAULT;
-
-                        if (options & WDIOS_DISABLECARD) {
-                                sh_wdt_stop();
-                                retval = 0;
-                        }
+        case WDIOC_GETSUPPORT:
+                return copy_to_user((struct watchdog_info *)arg,
+                          &sh_wdt_info, sizeof(sh_wdt_info)) ? -EFAULT : 0;
+        case WDIOC_GETSTATUS:
+        case WDIOC_GETBOOTSTATUS:
+                return put_user(0, (int *)arg);
+        case WDIOC_SETOPTIONS:
+                if (get_user(options, (int *)arg))
+                        return -EFAULT;
+
+                if (options & WDIOS_DISABLECARD) {
+                        sh_wdt_stop();
+                        retval = 0;
+                }
 
-                        if (options & WDIOS_ENABLECARD) {
-                                sh_wdt_start();
-                                retval = 0;
-                        }
+                if (options & WDIOS_ENABLECARD) {
+                        sh_wdt_start();
+                        retval = 0;
+                }
 
-                        return retval;
-                default:
-                        return -ENOTTY;
-        }
+                return retval;
+        case WDIOC_KEEPALIVE:
+                sh_wdt_keepalive();
+                return 0;
+        case WDIOC_SETTIMEOUT:
+                if (get_user(new_heartbeat, (int *)arg))
+                        return -EFAULT;
+
+                if (sh_wdt_set_heartbeat(new_heartbeat))
+                        return -EINVAL;
 
+                sh_wdt_keepalive();
+                /* Fall */
+        case WDIOC_GETTIMEOUT:
+                return put_user(heartbeat, (int *)arg);
+        default:
+                return -ENOTTY;
+        }
         return 0;
 }
 
@@ -390,13 +408,13 @@ static const struct file_operations sh_wdt_fops = {
         .owner          = THIS_MODULE,
         .llseek         = no_llseek,
         .write          = sh_wdt_write,
-        .ioctl          = sh_wdt_ioctl,
+        .unlocked_ioctl = sh_wdt_ioctl,
         .open           = sh_wdt_open,
         .release        = sh_wdt_close,
         .mmap           = sh_wdt_mmap,
 };
 
-static struct watchdog_info sh_wdt_info = {
+static const struct watchdog_info sh_wdt_info = {
         .options                = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT |
                                   WDIOF_MAGICCLOSE,
         .firmware_version       = 1,
@@ -422,30 +440,33 @@ static int __init sh_wdt_init(void)
 {
         int rc;
 
-        if ((clock_division_ratio < 0x5) || (clock_division_ratio > 0x7)) {
+        if (clock_division_ratio < 0x5 || clock_division_ratio > 0x7) {
                 clock_division_ratio = WTCSR_CKS_4096;
-                printk(KERN_INFO PFX "clock_division_ratio value must "
-                       "be 0x5<=x<=0x7, using %d\n", clock_division_ratio);
+                printk(KERN_INFO PFX
+                  "clock_division_ratio value must be 0x5<=x<=0x7, using %d\n",
+                                clock_division_ratio);
         }
 
         rc = sh_wdt_set_heartbeat(heartbeat);
         if (unlikely(rc)) {
                 heartbeat = WATCHDOG_HEARTBEAT;
-                printk(KERN_INFO PFX "heartbeat value must "
-                       "be 1<=x<=3600, using %d\n", heartbeat);
+                printk(KERN_INFO PFX
+                        "heartbeat value must be 1<=x<=3600, using %d\n",
+                                                                heartbeat);
         }
 
         rc = register_reboot_notifier(&sh_wdt_notifier);
         if (unlikely(rc)) {
-                printk(KERN_ERR PFX "Can't register reboot notifier (err=%d)\n",
-                       rc);
+                printk(KERN_ERR PFX
+                        "Can't register reboot notifier (err=%d)\n", rc);
                 return rc;
         }
 
         rc = misc_register(&sh_wdt_miscdev);
         if (unlikely(rc)) {
-                printk(KERN_ERR PFX "Can't register miscdev on "
-                       "minor=%d (err=%d)\n", sh_wdt_miscdev.minor, rc);
+                printk(KERN_ERR PFX
+                        "Can't register miscdev on minor=%d (err=%d)\n",
+                                                sh_wdt_miscdev.minor, rc);
                 unregister_reboot_notifier(&sh_wdt_notifier);
                 return rc;
         }
@@ -476,10 +497,14 @@ module_param(clock_division_ratio, int, 0);
 MODULE_PARM_DESC(clock_division_ratio, "Clock division ratio. Valid ranges are from 0x5 (1.31ms) to 0x7 (5.25ms). (default=" __MODULE_STRING(clock_division_ratio) ")");
 
 module_param(heartbeat, int, 0);
-MODULE_PARM_DESC(heartbeat, "Watchdog heartbeat in seconds. (1<=heartbeat<=3600, default=" __MODULE_STRING(WATCHDOG_HEARTBEAT) ")");
+MODULE_PARM_DESC(heartbeat,
+        "Watchdog heartbeat in seconds. (1 <= heartbeat <= 3600, default="
+                                __MODULE_STRING(WATCHDOG_HEARTBEAT) ")");
 
 module_param(nowayout, int, 0);
-MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+MODULE_PARM_DESC(nowayout,
+        "Watchdog cannot be stopped once started (default="
+                                __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 
 module_init(sh_wdt_init);
 module_exit(sh_wdt_exit);
diff --git a/drivers/watchdog/smsc37b787_wdt.c b/drivers/watchdog/smsc37b787_wdt.c
index 5d2b5ba61414..988ff1d5b4be 100644
--- a/drivers/watchdog/smsc37b787_wdt.c
+++ b/drivers/watchdog/smsc37b787_wdt.c
@@ -18,7 +18,7 @@
  *  History:
  *      2003 - Created version 1.0 for Linux 2.4.x.
  *      2006 - Ported to Linux 2.6, added nowayout and MAGICCLOSE
- *             features. Released version 1.1
+ *             features. Released version 1.1
  *
  *  Theory of operation:
  *
@@ -55,9 +55,9 @@
 #include <linux/reboot.h>
 #include <linux/init.h>
 #include <linux/spinlock.h>
+#include <linux/io.h>
+#include <linux/uaccess.h>
 
-#include <asm/io.h>
-#include <asm/uaccess.h>
 #include <asm/system.h>
 
 /* enable support for minutes as units? */
@@ -71,15 +71,15 @@
 #define UNIT_MINUTE     1
 
 #define MODNAME         "smsc37b787_wdt: "
-#define VERSION         "1.1"
+#define VERSION         "1.1"
 
-#define IOPORT          0x3F0
+#define IOPORT          0x3F0
 #define IOPORT_SIZE     2
-#define IODEV_NO        8
+#define IODEV_NO        8
 
-static int unit = UNIT_SECOND;  /* timer's unit */
-static int timeout = 60;        /* timeout value: default is 60 "units" */
-static unsigned long timer_enabled = 0;   /* is the timer enabled? */
+static int unit = UNIT_SECOND;  /* timer's unit */
+static int timeout = 60;        /* timeout value: default is 60 "units" */
+static unsigned long timer_enabled;   /* is the timer enabled? */
 
 static char expect_close;       /* is the close expected? */
 
@@ -93,114 +93,121 @@ static int nowayout = WATCHDOG_NOWAYOUT;
 
 static inline void open_io_config(void)
 {
-        outb(0x55, IOPORT);
+        outb(0x55, IOPORT);
         mdelay(1);
-        outb(0x55, IOPORT);
+        outb(0x55, IOPORT);
 }
 
 /* lock the IO chip */
 static inline void close_io_config(void)
 {
-        outb(0xAA, IOPORT);
+        outb(0xAA, IOPORT);
 }
 
 /* select the IO device */
 static inline void select_io_device(unsigned char devno)
 {
-        outb(0x07, IOPORT);
-        outb(devno, IOPORT+1);
+        outb(0x07, IOPORT);
+        outb(devno, IOPORT+1);
 }
 
 /* write to the control register */
 static inline void write_io_cr(unsigned char reg, unsigned char data)
 {
-        outb(reg, IOPORT);
-        outb(data, IOPORT+1);
+        outb(reg, IOPORT);
+        outb(data, IOPORT+1);
 }
 
 /* read from the control register */
 static inline char read_io_cr(unsigned char reg)
 {
-        outb(reg, IOPORT);
-        return inb(IOPORT+1);
+        outb(reg, IOPORT);
+        return inb(IOPORT+1);
 }
 
 /* -- Medium level functions ------------------------------------*/
 
 static inline void gpio_bit12(unsigned char reg)
 {
-        // -- General Purpose I/O Bit 1.2 --
-        // Bit 0,   In/Out: 0 = Output, 1 = Input
-        // Bit 1,   Polarity: 0 = No Invert, 1 = Invert
-        // Bit 2,   Group Enable Intr.: 0 = Disable, 1 = Enable
-        // Bit 3/4, Function select: 00 = GPI/O, 01 = WDT, 10 = P17,
-        //                           11 = Either Edge Triggered Intr. 2
-        // Bit 5/6  (Reserved)
-        // Bit 7,   Output Type: 0 = Push Pull Bit, 1 = Open Drain
-        write_io_cr(0xE2, reg);
+        /* -- General Purpose I/O Bit 1.2 --
+         * Bit 0,   In/Out: 0 = Output, 1 = Input
+         * Bit 1,   Polarity: 0 = No Invert, 1 = Invert
+         * Bit 2,   Group Enable Intr.: 0 = Disable, 1 = Enable
+         * Bit 3/4, Function select: 00 = GPI/O, 01 = WDT, 10 = P17,
+         *                           11 = Either Edge Triggered Intr. 2
+         * Bit 5/6  (Reserved)
+         * Bit 7,   Output Type: 0 = Push Pull Bit, 1 = Open Drain
+         */
+        write_io_cr(0xE2, reg);
 }
 
 static inline void gpio_bit13(unsigned char reg)
 {
-        // -- General Purpose I/O Bit 1.3 --
-        // Bit 0,  In/Out: 0 = Output, 1 = Input
-        // Bit 1,  Polarity: 0 = No Invert, 1 = Invert
-        // Bit 2,  Group Enable Intr.: 0 = Disable, 1 = Enable
-        // Bit 3,  Function select: 0 = GPI/O, 1 = LED
-        // Bit 4-6 (Reserved)
-        // Bit 7,  Output Type: 0 = Push Pull Bit, 1 = Open Drain
-        write_io_cr(0xE3, reg);
+        /* -- General Purpose I/O Bit 1.3 --
+         * Bit 0,  In/Out: 0 = Output, 1 = Input
+         * Bit 1,  Polarity: 0 = No Invert, 1 = Invert
+         * Bit 2,  Group Enable Intr.: 0 = Disable, 1 = Enable
+         * Bit 3,  Function select: 0 = GPI/O, 1 = LED
+         * Bit 4-6 (Reserved)
+         * Bit 7,  Output Type: 0 = Push Pull Bit, 1 = Open Drain
+         */
+        write_io_cr(0xE3, reg);
 }
 
 static inline void wdt_timer_units(unsigned char new_units)
 {
-        // -- Watchdog timer units --
-        // Bit 0-6 (Reserved)
-        // Bit 7,  WDT Time-out Value Units Select
-        //         (0 = Minutes, 1 = Seconds)
-        write_io_cr(0xF1, new_units);
+        /* -- Watchdog timer units --
+         * Bit 0-6 (Reserved)
+         * Bit 7,  WDT Time-out Value Units Select
+         *         (0 = Minutes, 1 = Seconds)
+         */
+        write_io_cr(0xF1, new_units);
 }
 
 static inline void wdt_timeout_value(unsigned char new_timeout)
 {
-        // -- Watchdog Timer Time-out Value --
-        // Bit 0-7 Binary coded units (0=Disabled, 1..255)
-        write_io_cr(0xF2, new_timeout);
+        /* -- Watchdog Timer Time-out Value --
+         * Bit 0-7 Binary coded units (0=Disabled, 1..255)
+         */
+        write_io_cr(0xF2, new_timeout);
 }
 
 static inline void wdt_timer_conf(unsigned char conf)
 {
-        // -- Watchdog timer configuration --
-        // Bit 0   Joystick enable: 0* = No Reset, 1 = Reset WDT upon Gameport I/O
-        // Bit 1   Keyboard enable: 0* = No Reset, 1 = Reset WDT upon KBD Intr.
-        // Bit 2   Mouse enable: 0* = No Reset, 1 = Reset WDT upon Mouse Intr.
-        // Bit 3   Reset the timer
-        //         (Wrong in SMsC documentation? Given as: PowerLED Timout Enabled)
-        // Bit 4-7 WDT Interrupt Mapping: (0000* = Disabled,
-        //            0001=IRQ1, 0010=(Invalid), 0011=IRQ3 to 1111=IRQ15)
-        write_io_cr(0xF3, conf);
+        /* -- Watchdog timer configuration --
+         * Bit 0   Joystick enable: 0* = No Reset, 1 = Reset WDT upon
+         *                                                      Gameport I/O
+         * Bit 1   Keyboard enable: 0* = No Reset, 1 = Reset WDT upon KBD Intr.
+         * Bit 2   Mouse enable: 0* = No Reset, 1 = Reset WDT upon Mouse Intr
+         * Bit 3   Reset the timer
+         *         (Wrong in SMsC documentation? Given as: PowerLED Timout
+         *                                                      Enabled)
+         * Bit 4-7 WDT Interrupt Mapping: (0000* = Disabled,
+         *            0001=IRQ1, 0010=(Invalid), 0011=IRQ3 to 1111=IRQ15)
+         */
+        write_io_cr(0xF3, conf);
 }
 
 static inline void wdt_timer_ctrl(unsigned char reg)
 {
-        // -- Watchdog timer control --
-        // Bit 0   Status Bit: 0 = Timer counting, 1 = Timeout occured
-        // Bit 1   Power LED Toggle: 0 = Disable Toggle, 1 = Toggle at 1 Hz
-        // Bit 2   Force Timeout: 1 = Forces WD timeout event (self-cleaning)
-        // Bit 3   P20 Force Timeout enabled:
-        //          0 = P20 activity does not generate the WD timeout event
-        //          1 = P20 Allows rising edge of P20, from the keyboard
-        //              controller, to force the WD timeout event.
-        // Bit 4   (Reserved)
-        // -- Soft power management --
-        // Bit 5   Stop Counter: 1 = Stop software power down counter
-        //            set via register 0xB8, (self-cleaning)
-        //            (Upon read: 0 = Counter running, 1 = Counter stopped)
-        // Bit 6   Restart Counter: 1 = Restart software power down counter
-        //            set via register 0xB8, (self-cleaning)
-        // Bit 7   SPOFF: 1 = Force software power down (self-cleaning)
-
-        write_io_cr(0xF4, reg);
+        /* -- Watchdog timer control --
+         * Bit 0   Status Bit: 0 = Timer counting, 1 = Timeout occured
+         * Bit 1   Power LED Toggle: 0 = Disable Toggle, 1 = Toggle at 1 Hz
+         * Bit 2   Force Timeout: 1 = Forces WD timeout event (self-cleaning)
+         * Bit 3   P20 Force Timeout enabled:
+         *          0 = P20 activity does not generate the WD timeout event
+         *          1 = P20 Allows rising edge of P20, from the keyboard
+         *              controller, to force the WD timeout event.
+         * Bit 4   (Reserved)
+         * -- Soft power management --
+         * Bit 5   Stop Counter: 1 = Stop software power down counter
+         *            set via register 0xB8, (self-cleaning)
+         *            (Upon read: 0 = Counter running, 1 = Counter stopped)
+         * Bit 6   Restart Counter: 1 = Restart software power down counter
+         *            set via register 0xB8, (self-cleaning)
+         * Bit 7   SPOFF: 1 = Force software power down (self-cleaning)
+         */
+        write_io_cr(0xF4, reg);
 }
 
 /* -- Higher level functions ------------------------------------*/
@@ -209,33 +216,34 @@ static inline void wdt_timer_ctrl(unsigned char reg)
 
 static void wb_smsc_wdt_initialize(void)
 {
-        unsigned char old;
+        unsigned char old;
 
         spin_lock(&io_lock);
-        open_io_config();
-        select_io_device(IODEV_NO);
+        open_io_config();
+        select_io_device(IODEV_NO);
 
-        // enable the watchdog
-        gpio_bit13(0x08);  // Select pin 80 = LED not GPIO
-        gpio_bit12(0x0A);  // Set pin 79 = WDT not GPIO/Output/Polarity=Invert
+        /* enable the watchdog */
+        gpio_bit13(0x08);  /* Select pin 80 = LED not GPIO */
+        gpio_bit12(0x0A);  /* Set pin 79 = WDT not
+                              GPIO/Output/Polarity=Invert */
+        /* disable the timeout */
+        wdt_timeout_value(0);
 
-        // disable the timeout
-        wdt_timeout_value(0);
+        /* reset control register */
+        wdt_timer_ctrl(0x00);
 
-        // reset control register
-        wdt_timer_ctrl(0x00);
-
-        // reset configuration register
+        /* reset configuration register */
         wdt_timer_conf(0x00);
 
-        // read old (timer units) register
-        old = read_io_cr(0xF1) & 0x7F;
-        if (unit == UNIT_SECOND) old |= 0x80; // set to seconds
+        /* read old (timer units) register */
+        old = read_io_cr(0xF1) & 0x7F;
+        if (unit == UNIT_SECOND)
+                old |= 0x80;    /* set to seconds */
 
-        // set the watchdog timer units
-        wdt_timer_units(old);
+        /* set the watchdog timer units */
+        wdt_timer_units(old);
 
-        close_io_config();
+        close_io_config();
         spin_unlock(&io_lock);
 }
 
@@ -244,23 +252,23 @@ static void wb_smsc_wdt_initialize(void)
 static void wb_smsc_wdt_shutdown(void)
 {
         spin_lock(&io_lock);
-        open_io_config();
-        select_io_device(IODEV_NO);
+        open_io_config();
+        select_io_device(IODEV_NO);
 
-        // disable the watchdog
-        gpio_bit13(0x09);
-        gpio_bit12(0x09);
+        /* disable the watchdog */
+        gpio_bit13(0x09);
+        gpio_bit12(0x09);
 
-        // reset watchdog config register
+        /* reset watchdog config register */
         wdt_timer_conf(0x00);
 
-        // reset watchdog control register
-        wdt_timer_ctrl(0x00);
+        /* reset watchdog control register */
+        wdt_timer_ctrl(0x00);
 
-        // disable timeout
-        wdt_timeout_value(0x00);
+        /* disable timeout */
+        wdt_timeout_value(0x00);
 
-        close_io_config();
+        close_io_config();
         spin_unlock(&io_lock);
 }
 
@@ -269,16 +277,16 @@ static void wb_smsc_wdt_shutdown(void)
 static void wb_smsc_wdt_set_timeout(unsigned char new_timeout)
 {
         spin_lock(&io_lock);
-        open_io_config();
-        select_io_device(IODEV_NO);
+        open_io_config();
+        select_io_device(IODEV_NO);
 
-        // set Power LED to blink, if we enable the timeout
-        wdt_timer_ctrl((new_timeout == 0) ? 0x00 : 0x02);
+        /* set Power LED to blink, if we enable the timeout */
+        wdt_timer_ctrl((new_timeout == 0) ? 0x00 : 0x02);
 
-        // set timeout value
-        wdt_timeout_value(new_timeout);
+        /* set timeout value */
+        wdt_timeout_value(new_timeout);
 
-        close_io_config();
+        close_io_config();
         spin_unlock(&io_lock);
 }
 
@@ -286,32 +294,32 @@ static void wb_smsc_wdt_set_timeout(unsigned char new_timeout)
 
 static unsigned char wb_smsc_wdt_get_timeout(void)
 {
-        unsigned char set_timeout;
+        unsigned char set_timeout;
 
         spin_lock(&io_lock);
-        open_io_config();
-        select_io_device(IODEV_NO);
-        set_timeout = read_io_cr(0xF2);
-        close_io_config();
+        open_io_config();
+        select_io_device(IODEV_NO);
+        set_timeout = read_io_cr(0xF2);
+        close_io_config();
         spin_unlock(&io_lock);
 
-        return set_timeout;
+        return set_timeout;
 }
 
 /* disable watchdog */
 
 static void wb_smsc_wdt_disable(void)
 {
-        // set the timeout to 0 to disable the watchdog
-        wb_smsc_wdt_set_timeout(0);
+        /* set the timeout to 0 to disable the watchdog */
+        wb_smsc_wdt_set_timeout(0);
 }
 
 /* enable watchdog by setting the current timeout */
 
 static void wb_smsc_wdt_enable(void)
 {
-        // set the current timeout...
-        wb_smsc_wdt_set_timeout(timeout);
+        /* set the current timeout... */
+        wb_smsc_wdt_set_timeout(timeout);
 }
 
 /* reset the timer */
@@ -319,14 +327,14 @@ static void wb_smsc_wdt_enable(void)
 static void wb_smsc_wdt_reset_timer(void)
 {
         spin_lock(&io_lock);
-        open_io_config();
-        select_io_device(IODEV_NO);
+        open_io_config();
+        select_io_device(IODEV_NO);
 
-        // reset the timer
+        /* reset the timer */
         wdt_timeout_value(timeout);
         wdt_timer_conf(0x08);
 
-        close_io_config();
+        close_io_config();
         spin_unlock(&io_lock);
 }
 
@@ -355,7 +363,9 @@ static int wb_smsc_wdt_open(struct inode *inode, struct file *file)
         /* Reload and activate timer */
         wb_smsc_wdt_enable();
 
-        printk(KERN_INFO MODNAME "Watchdog enabled. Timeout set to %d %s.\n", timeout, (unit == UNIT_SECOND) ? "second(s)" : "minute(s)");
+        printk(KERN_INFO MODNAME
+                "Watchdog enabled. Timeout set to %d %s.\n",
+                timeout, (unit == UNIT_SECOND) ? "second(s)" : "minute(s)");
 
         return nonseekable_open(inode, file);
 }
@@ -367,10 +377,12 @@ static int wb_smsc_wdt_release(struct inode *inode, struct file *file)
         /* Shut off the timer. */
 
         if (expect_close == 42) {
-                wb_smsc_wdt_disable();
-                printk(KERN_INFO MODNAME "Watchdog disabled, sleeping again...\n");
+                wb_smsc_wdt_disable();
+                printk(KERN_INFO MODNAME
+                                "Watchdog disabled, sleeping again...\n");
         } else {
-                printk(KERN_CRIT MODNAME "Unexpected close, not stopping watchdog!\n");
+                printk(KERN_CRIT MODNAME
+                                "Unexpected close, not stopping watchdog!\n");
                 wb_smsc_wdt_reset_timer();
         }
 
@@ -392,10 +404,11 @@ static ssize_t wb_smsc_wdt_write(struct file *file, const char __user *data,
                         /* reset expect flag */
                         expect_close = 0;
 
-                        /* scan to see whether or not we got the magic character */
+                        /* scan to see whether or not we got the
+                           magic character */
                         for (i = 0; i != len; i++) {
                                 char c;
-                                if (get_user(c, data+i))
+                                if (get_user(c, data + i))
                                         return -EFAULT;
                                 if (c == 'V')
                                         expect_close = 42;
@@ -410,8 +423,8 @@ static ssize_t wb_smsc_wdt_write(struct file *file, const char __user *data,
 
 /* ioctl => control interface */
 
-static int wb_smsc_wdt_ioctl(struct inode *inode, struct file *file,
-                             unsigned int cmd, unsigned long arg)
+static long wb_smsc_wdt_ioctl(struct file *file,
+                                        unsigned int cmd, unsigned long arg)
 {
         int new_timeout;
 
@@ -420,89 +433,73 @@ static int wb_smsc_wdt_ioctl(struct inode *inode, struct file *file,
                 int __user *i;
         } uarg;
 
-        static struct watchdog_info ident = {
+        static const struct watchdog_info ident = {
                 .options =              WDIOF_KEEPALIVEPING |
-                                        WDIOF_SETTIMEOUT |
+                                        WDIOF_SETTIMEOUT |
                                         WDIOF_MAGICCLOSE,
                 .firmware_version =     0,
-                .identity =             "SMsC 37B787 Watchdog"
+                .identity =             "SMsC 37B787 Watchdog",
         };
 
         uarg.i = (int __user *)arg;
 
         switch (cmd) {
-                default:
-                        return -ENOTTY;
-
-                case WDIOC_GETSUPPORT:
-                        return copy_to_user(uarg.ident, &ident,
-                                sizeof(ident)) ? -EFAULT : 0;
-
-                case WDIOC_GETSTATUS:
-                        return put_user(wb_smsc_wdt_status(), uarg.i);
-
-                case WDIOC_GETBOOTSTATUS:
-                        return put_user(0, uarg.i);
-
-                case WDIOC_KEEPALIVE:
-                        wb_smsc_wdt_reset_timer();
-                        return 0;
-
-                case WDIOC_SETTIMEOUT:
-                        if (get_user(new_timeout, uarg.i))
-                                return -EFAULT;
-
-                        // the API states this is given in secs
-                        if (unit == UNIT_MINUTE)
-                          new_timeout /= 60;
-
-                        if (new_timeout < 0 || new_timeout > MAX_TIMEOUT)
-                                return -EINVAL;
-
-                        timeout = new_timeout;
-                        wb_smsc_wdt_set_timeout(timeout);
-
-                        // fall through and return the new timeout...
-
-                case WDIOC_GETTIMEOUT:
-
-                        new_timeout = timeout;
-
-                        if (unit == UNIT_MINUTE)
-                          new_timeout *= 60;
-
-                        return put_user(new_timeout, uarg.i);
-
-                case WDIOC_SETOPTIONS:
-                {
-                        int options, retval = -EINVAL;
-
-                        if (get_user(options, uarg.i))
-                                return -EFAULT;
-
-                        if (options & WDIOS_DISABLECARD) {
-                                wb_smsc_wdt_disable();
-                                retval = 0;
-                        }
+        case WDIOC_GETSUPPORT:
+                return copy_to_user(uarg.ident, &ident, sizeof(ident))
+                                                                ? -EFAULT : 0;
+        case WDIOC_GETSTATUS:
+                return put_user(wb_smsc_wdt_status(), uarg.i);
+        case WDIOC_GETBOOTSTATUS:
+                return put_user(0, uarg.i);
+        case WDIOC_SETOPTIONS:
+        {
+                int options, retval = -EINVAL;
 
-                        if (options & WDIOS_ENABLECARD) {
-                                wb_smsc_wdt_enable();
-                                retval = 0;
-                        }
+                if (get_user(options, uarg.i))
+                        return -EFAULT;
 
-                        return retval;
+                if (options & WDIOS_DISABLECARD) {
+                        wb_smsc_wdt_disable();
+                        retval = 0;
+                }
+                if (options & WDIOS_ENABLECARD) {
+                        wb_smsc_wdt_enable();
+                        retval = 0;
                 }
+                return retval;
+        }
+        case WDIOC_KEEPALIVE:
+                wb_smsc_wdt_reset_timer();
+                return 0;
+        case WDIOC_SETTIMEOUT:
+                if (get_user(new_timeout, uarg.i))
+                        return -EFAULT;
+                /* the API states this is given in secs */
+                if (unit == UNIT_MINUTE)
+                        new_timeout /= 60;
+                if (new_timeout < 0 || new_timeout > MAX_TIMEOUT)
+                        return -EINVAL;
+                timeout = new_timeout;
+                wb_smsc_wdt_set_timeout(timeout);
+                /* fall through and return the new timeout... */
+        case WDIOC_GETTIMEOUT:
+                new_timeout = timeout;
+                if (unit == UNIT_MINUTE)
+                          new_timeout *= 60;
+                return put_user(new_timeout, uarg.i);
+        default:
+                return -ENOTTY;
         }
 }
 
 /* -- Notifier funtions -----------------------------------------*/
 
-static int wb_smsc_wdt_notify_sys(struct notifier_block *this, unsigned long code, void *unused)
+static int wb_smsc_wdt_notify_sys(struct notifier_block *this,
+                                        unsigned long code, void *unused)
 {
-        if (code == SYS_DOWN || code == SYS_HALT)
-        {
-                // set timeout to 0, to avoid possible race-condition
-                timeout = 0;
+        if (code == SYS_DOWN || code == SYS_HALT) {
+                /* set timeout to 0, to avoid possible race-condition */
+                timeout = 0;
                 wb_smsc_wdt_disable();
         }
         return NOTIFY_DONE;
@@ -510,23 +507,20 @@ static int wb_smsc_wdt_notify_sys(struct notifier_block *this, unsigned long cod
 
 /* -- Module's structures ---------------------------------------*/
 
-static const struct file_operations wb_smsc_wdt_fops =
-{
-        .owner          = THIS_MODULE,
+static const struct file_operations wb_smsc_wdt_fops = {
+        .owner    = THIS_MODULE,
         .llseek         = no_llseek,
         .write          = wb_smsc_wdt_write,
-        .ioctl          = wb_smsc_wdt_ioctl,
+        .unlocked_ioctl = wb_smsc_wdt_ioctl,
         .open           = wb_smsc_wdt_open,
         .release        = wb_smsc_wdt_release,
 };
 
-static struct notifier_block wb_smsc_wdt_notifier =
-{
+static struct notifier_block wb_smsc_wdt_notifier = {
         .notifier_call  = wb_smsc_wdt_notify_sys,
 };
 
-static struct miscdevice wb_smsc_wdt_miscdev =
-{
+static struct miscdevice wb_smsc_wdt_miscdev = {
         .minor          = WATCHDOG_MINOR,
         .name           = "watchdog",
         .fops           = &wb_smsc_wdt_fops,
@@ -540,39 +534,44 @@ static int __init wb_smsc_wdt_init(void)
 {
         int ret;
 
-        printk("SMsC 37B787 watchdog component driver " VERSION " initialising...\n");
+        printk(KERN_INFO "SMsC 37B787 watchdog component driver "
+                                        VERSION " initialising...\n");
 
         if (!request_region(IOPORT, IOPORT_SIZE, "SMsC 37B787 watchdog")) {
-                printk(KERN_ERR MODNAME "Unable to register IO port %#x\n", IOPORT);
+                printk(KERN_ERR MODNAME "Unable to register IO port %#x\n",
+                                                                IOPORT);
                 ret = -EBUSY;
                 goto out_pnp;
         }
 
-        // set new maximum, if it's too big
-        if (timeout > MAX_TIMEOUT)
-               timeout = MAX_TIMEOUT;
+        /* set new maximum, if it's too big */
+        if (timeout > MAX_TIMEOUT)
+                timeout = MAX_TIMEOUT;
 
-        // init the watchdog timer
-        wb_smsc_wdt_initialize();
+        /* init the watchdog timer */
+        wb_smsc_wdt_initialize();
 
         ret = register_reboot_notifier(&wb_smsc_wdt_notifier);
         if (ret) {
-                printk(KERN_ERR MODNAME "Unable to register reboot notifier err = %d\n", ret);
+                printk(KERN_ERR MODNAME
+                        "Unable to register reboot notifier err = %d\n", ret);
                 goto out_io;
         }
 
         ret = misc_register(&wb_smsc_wdt_miscdev);
         if (ret) {
-                printk(KERN_ERR MODNAME "Unable to register miscdev on minor %d\n", WATCHDOG_MINOR);
+                printk(KERN_ERR MODNAME
+                        "Unable to register miscdev on minor %d\n",
+                                                        WATCHDOG_MINOR);
                 goto out_rbt;
         }
 
-        // output info
-        printk(KERN_INFO MODNAME "Timeout set to %d %s.\n", timeout, (unit == UNIT_SECOND) ? "second(s)" : "minute(s)");
-        printk(KERN_INFO MODNAME "Watchdog initialized and sleeping (nowayout=%d)...\n", nowayout);
-
-        // ret = 0
-
+        /* output info */
+        printk(KERN_INFO MODNAME "Timeout set to %d %s.\n",
+                timeout, (unit == UNIT_SECOND) ? "second(s)" : "minute(s)");
+        printk(KERN_INFO MODNAME
+                "Watchdog initialized and sleeping (nowayout=%d)...\n",
+                                                                nowayout);
 out_clean:
         return ret;
 
@@ -591,8 +590,7 @@ out_pnp:
 static void __exit wb_smsc_wdt_exit(void)
 {
         /* Stop the timer before we leave */
-        if (!nowayout)
-        {
+        if (!nowayout) {
                 wb_smsc_wdt_shutdown();
                 printk(KERN_INFO MODNAME "Watchdog disabled.\n");
         }
@@ -601,25 +599,29 @@ static void __exit wb_smsc_wdt_exit(void)
         unregister_reboot_notifier(&wb_smsc_wdt_notifier);
         release_region(IOPORT, IOPORT_SIZE);
 
-        printk("SMsC 37B787 watchdog component driver removed.\n");
+        printk(KERN_INFO "SMsC 37B787 watchdog component driver removed.\n");
 }
 
 module_init(wb_smsc_wdt_init);
 module_exit(wb_smsc_wdt_exit);
 
 MODULE_AUTHOR("Sven Anders <anders@anduras.de>");
-MODULE_DESCRIPTION("Driver for SMsC 37B787 watchdog component (Version " VERSION ")");
+MODULE_DESCRIPTION("Driver for SMsC 37B787 watchdog component (Version "
+                                                                VERSION ")");
 MODULE_LICENSE("GPL");
 
 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 
 #ifdef SMSC_SUPPORT_MINUTES
 module_param(unit, int, 0);
-MODULE_PARM_DESC(unit, "set unit to use, 0=seconds or 1=minutes, default is 0");
+MODULE_PARM_DESC(unit,
+                "set unit to use, 0=seconds or 1=minutes, default is 0");
 #endif
 
 module_param(timeout, int, 0);
 MODULE_PARM_DESC(timeout, "range is 1-255 units, default is 60");
 
 module_param(nowayout, int, 0);
-MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+MODULE_PARM_DESC(nowayout,
+                "Watchdog cannot be stopped once started (default="
+                                __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
diff --git a/drivers/watchdog/softdog.c b/drivers/watchdog/softdog.c
index 9c3694909243..c650464c5c63 100644
--- a/drivers/watchdog/softdog.c
+++ b/drivers/watchdog/softdog.c
@@ -47,19 +47,22 @@
 #include <linux/reboot.h>
 #include <linux/init.h>
 #include <linux/jiffies.h>
-
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 
 #define PFX "SoftDog: "
 
 #define TIMER_MARGIN    60              /* Default is 60 seconds */
 static int soft_margin = TIMER_MARGIN;  /* in seconds */
 module_param(soft_margin, int, 0);
-MODULE_PARM_DESC(soft_margin, "Watchdog soft_margin in seconds. (0<soft_margin<65536, default=" __MODULE_STRING(TIMER_MARGIN) ")");
+MODULE_PARM_DESC(soft_margin,
+        "Watchdog soft_margin in seconds. (0 < soft_margin < 65536, default="
+                                        __MODULE_STRING(TIMER_MARGIN) ")");
 
 static int nowayout = WATCHDOG_NOWAYOUT;
 module_param(nowayout, int, 0);
-MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+MODULE_PARM_DESC(nowayout,
+                "Watchdog cannot be stopped once started (default="
+                                __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 
 #ifdef ONLY_TESTING
 static int soft_noboot = 1;
@@ -93,8 +96,7 @@ static void watchdog_fire(unsigned long data)
 
         if (soft_noboot)
                 printk(KERN_CRIT PFX "Triggered - Reboot ignored.\n");
-        else
-        {
+        else {
                 printk(KERN_CRIT PFX "Initiating system reboot.\n");
                 emergency_restart();
                 printk(KERN_CRIT PFX "Reboot didn't ?????\n");
@@ -153,7 +155,8 @@ static int softdog_release(struct inode *inode, struct file *file)
                 softdog_stop();
                 module_put(THIS_MODULE);
         } else {
-                printk(KERN_CRIT PFX "Unexpected close, not stopping watchdog!\n");
+                printk(KERN_CRIT PFX
+                        "Unexpected close, not stopping watchdog!\n");
                 set_bit(0, &orphan_timer);
                 softdog_keepalive();
         }
@@ -162,12 +165,13 @@ static int softdog_release(struct inode *inode, struct file *file)
         return 0;
 }
 
-static ssize_t softdog_write(struct file *file, const char __user *data, size_t len, loff_t *ppos)
+static ssize_t softdog_write(struct file *file, const char __user *data,
+                                                size_t len, loff_t *ppos)
 {
         /*
          *      Refresh the timer.
          */
-        if(len) {
+        if (len) {
                 if (!nowayout) {
                         size_t i;
 
@@ -188,13 +192,13 @@ static ssize_t softdog_write(struct file *file, const char __user *data, size_t
         return len;
 }
 
-static int softdog_ioctl(struct inode *inode, struct file *file,
-        unsigned int cmd, unsigned long arg)
+static long softdog_ioctl(struct file *file, unsigned int cmd,
+                                                        unsigned long arg)
 {
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
         int new_margin;
-        static struct watchdog_info ident = {
+        static const struct watchdog_info ident = {
                 .options =              WDIOF_SETTIMEOUT |
                                         WDIOF_KEEPALIVEPING |
                                         WDIOF_MAGICCLOSE,
@@ -202,26 +206,25 @@ static int softdog_ioctl(struct inode *inode, struct file *file,
                 .identity =             "Software Watchdog",
         };
         switch (cmd) {
-                default:
-                        return -ENOTTY;
-                case WDIOC_GETSUPPORT:
-                        return copy_to_user(argp, &ident,
-                                sizeof(ident)) ? -EFAULT : 0;
-                case WDIOC_GETSTATUS:
-                case WDIOC_GETBOOTSTATUS:
-                        return put_user(0, p);
-                case WDIOC_KEEPALIVE:
-                        softdog_keepalive();
-                        return 0;
-                case WDIOC_SETTIMEOUT:
-                        if (get_user(new_margin, p))
-                                return -EFAULT;
-                        if (softdog_set_heartbeat(new_margin))
-                                return -EINVAL;
-                        softdog_keepalive();
-                        /* Fall */
-                case WDIOC_GETTIMEOUT:
-                        return put_user(soft_margin, p);
+        case WDIOC_GETSUPPORT:
+                return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;
+        case WDIOC_GETSTATUS:
+        case WDIOC_GETBOOTSTATUS:
+                return put_user(0, p);
+        case WDIOC_KEEPALIVE:
+                softdog_keepalive();
+                return 0;
+        case WDIOC_SETTIMEOUT:
+                if (get_user(new_margin, p))
+                        return -EFAULT;
+                if (softdog_set_heartbeat(new_margin))
+                        return -EINVAL;
+                softdog_keepalive();
+                /* Fall */
+        case WDIOC_GETTIMEOUT:
+                return put_user(soft_margin, p);
+        default:
+                return -ENOTTY;
         }
 }
 
@@ -232,10 +235,9 @@ static int softdog_ioctl(struct inode *inode, struct file *file,
 static int softdog_notify_sys(struct notifier_block *this, unsigned long code,
         void *unused)
 {
-        if(code==SYS_DOWN || code==SYS_HALT) {
+        if (code == SYS_DOWN || code == SYS_HALT)
                 /* Turn the WDT off */
                 softdog_stop();
-        }
         return NOTIFY_DONE;
 }
 
@@ -247,7 +249,7 @@ static const struct file_operations softdog_fops = {
         .owner          = THIS_MODULE,
         .llseek         = no_llseek,
         .write          = softdog_write,
-        .ioctl          = softdog_ioctl,
+        .unlocked_ioctl = softdog_ioctl,
         .open           = softdog_open,
         .release        = softdog_release,
 };
@@ -268,24 +270,27 @@ static int __init watchdog_init(void)
 {
         int ret;
 
-        /* Check that the soft_margin value is within it's range ; if not reset to the default */
+        /* Check that the soft_margin value is within it's range;
+           if not reset to the default */
         if (softdog_set_heartbeat(soft_margin)) {
                 softdog_set_heartbeat(TIMER_MARGIN);
-                printk(KERN_INFO PFX "soft_margin value must be 0<soft_margin<65536, using %d\n",
+                printk(KERN_INFO PFX
+                    "soft_margin must be 0 < soft_margin < 65536, using %d\n",
                         TIMER_MARGIN);
         }
 
         ret = register_reboot_notifier(&softdog_notifier);
         if (ret) {
-                printk (KERN_ERR PFX "cannot register reboot notifier (err=%d)\n",
-                        ret);
+                printk(KERN_ERR PFX
+                        "cannot register reboot notifier (err=%d)\n", ret);
                 return ret;
         }
 
         ret = misc_register(&softdog_miscdev);
         if (ret) {
-                printk (KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",
-                        WATCHDOG_MINOR, ret);
+                printk(KERN_ERR PFX
+                        "cannot register miscdev on minor=%d (err=%d)\n",
+                                                WATCHDOG_MINOR, ret);
                 unregister_reboot_notifier(&softdog_notifier);
                 return ret;
         }
diff --git a/drivers/watchdog/txx9wdt.c b/drivers/watchdog/txx9wdt.c
index 57cefef27ce3..dbbc018a5f46 100644
--- a/drivers/watchdog/txx9wdt.c
+++ b/drivers/watchdog/txx9wdt.c
@@ -45,27 +45,34 @@ static unsigned long txx9wdt_alive;
 static int expect_close;
 static struct txx9_tmr_reg __iomem *txx9wdt_reg;
 static struct clk *txx9_imclk;
+static DECLARE_LOCK(txx9_lock);
 
 static void txx9wdt_ping(void)
 {
+        spin_lock(&txx9_lock);
         __raw_writel(TXx9_TMWTMR_TWIE | TXx9_TMWTMR_TWC, &txx9wdt_reg->wtmr);
+        spin_unlock(&txx9_lock);
 }
 
 static void txx9wdt_start(void)
 {
+        spin_lock(&txx9_lock);
         __raw_writel(WD_TIMER_CLK * timeout, &txx9wdt_reg->cpra);
         __raw_writel(WD_TIMER_CCD, &txx9wdt_reg->ccdr);
         __raw_writel(0, &txx9wdt_reg->tisr);    /* clear pending interrupt */
         __raw_writel(TXx9_TMTCR_TCE | TXx9_TMTCR_CCDE | TXx9_TMTCR_TMODE_WDOG,
                      &txx9wdt_reg->tcr);
         __raw_writel(TXx9_TMWTMR_TWIE | TXx9_TMWTMR_TWC, &txx9wdt_reg->wtmr);
+        spin_unlock(&txx9_lock);
 }
 
 static void txx9wdt_stop(void)
 {
+        spin_lock(&txx9_lock);
         __raw_writel(TXx9_TMWTMR_WDIS, &txx9wdt_reg->wtmr);
         __raw_writel(__raw_readl(&txx9wdt_reg->tcr) & ~TXx9_TMTCR_TCE,
                      &txx9wdt_reg->tcr);
+        spin_unlock(&txx9_lock);
 }
 
 static int txx9wdt_open(struct inode *inode, struct file *file)
@@ -120,13 +127,13 @@ static ssize_t txx9wdt_write(struct file *file, const char __user *data,
         return len;
 }
 
-static int txx9wdt_ioctl(struct inode *inode, struct file *file,
-        unsigned int cmd, unsigned long arg)
+static long txx9wdt_ioctl(struct file *file, unsigned int cmd,
+                                                        unsigned long arg)
 {
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
         int new_timeout;
-        static struct watchdog_info ident = {
+        static const struct watchdog_info ident = {
                 .options =              WDIOF_SETTIMEOUT |
                                         WDIOF_KEEPALIVEPING |
                                         WDIOF_MAGICCLOSE,
@@ -135,8 +142,6 @@ static int txx9wdt_ioctl(struct inode *inode, struct file *file,
         };
 
         switch (cmd) {
-        default:
-                return -ENOTTY;
         case WDIOC_GETSUPPORT:
                 return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;
         case WDIOC_GETSTATUS:
@@ -156,6 +161,8 @@ static int txx9wdt_ioctl(struct inode *inode, struct file *file,
                 /* Fall */
         case WDIOC_GETTIMEOUT:
                 return put_user(timeout, p);
+        default:
+                return -ENOTTY;
         }
 }
 
@@ -168,22 +175,22 @@ static int txx9wdt_notify_sys(struct notifier_block *this, unsigned long code,
 }
 
 static const struct file_operations txx9wdt_fops = {
-        .owner =        THIS_MODULE,
-        .llseek =       no_llseek,
-        .write =        txx9wdt_write,
-        .ioctl =        txx9wdt_ioctl,
-        .open =         txx9wdt_open,
-        .release =      txx9wdt_release,
+        .owner          =       THIS_MODULE,
+        .llseek         =       no_llseek,
+        .write          =       txx9wdt_write,
+        .unlocked_ioctl =       txx9wdt_ioctl,
+        .open           =       txx9wdt_open,
+        .release        =       txx9wdt_release,
 };
 
 static struct miscdevice txx9wdt_miscdev = {
-        .minor =        WATCHDOG_MINOR,
-        .name =         "watchdog",
-        .fops =         &txx9wdt_fops,
+        .minor  =       WATCHDOG_MINOR,
+        .name   =       "watchdog",
+        .fops   =       &txx9wdt_fops,
 };
 
 static struct notifier_block txx9wdt_notifier = {
-        .notifier_call = txx9wdt_notify_sys
+        .notifier_call = txx9wdt_notify_sys,
 };
 
 static int __init txx9wdt_probe(struct platform_device *dev)
diff --git a/drivers/watchdog/w83627hf_wdt.c b/drivers/watchdog/w83627hf_wdt.c
index 386492821fc2..69396adaa5c3 100644
--- a/drivers/watchdog/w83627hf_wdt.c
+++ b/drivers/watchdog/w83627hf_wdt.c
@@ -37,9 +37,9 @@
 #include <linux/reboot.h>
 #include <linux/init.h>
 #include <linux/spinlock.h>
+#include <linux/io.h>
+#include <linux/uaccess.h>
 
-#include <asm/io.h>
-#include <asm/uaccess.h>
 #include <asm/system.h>
 
 #define WATCHDOG_NAME "w83627hf/thf/hg WDT"
@@ -57,22 +57,26 @@ MODULE_PARM_DESC(wdt_io, "w83627hf/thf WDT io port (default 0x2E)");
 
 static int timeout = WATCHDOG_TIMEOUT;  /* in seconds */
 module_param(timeout, int, 0);
-MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds. 1<= timeout <=255, default=" __MODULE_STRING(WATCHDOG_TIMEOUT) ".");
+MODULE_PARM_DESC(timeout,
+                "Watchdog timeout in seconds. 1 <= timeout <= 255, default="
+                                __MODULE_STRING(WATCHDOG_TIMEOUT) ".");
 
 static int nowayout = WATCHDOG_NOWAYOUT;
 module_param(nowayout, int, 0);
-MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+MODULE_PARM_DESC(nowayout,
+                "Watchdog cannot be stopped once started (default="
+                                __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 
 /*
  *      Kernel methods.
  */
 
 #define WDT_EFER (wdt_io+0)   /* Extended Function Enable Registers */
-#define WDT_EFIR (wdt_io+0)   /* Extended Function Index Register (same as EFER) */
+#define WDT_EFIR (wdt_io+0)   /* Extended Function Index Register
+                                                        (same as EFER) */
 #define WDT_EFDR (WDT_EFIR+1) /* Extended Function Data Register */
 
-static void
-w83627hf_select_wd_register(void)
+static void w83627hf_select_wd_register(void)
 {
         unsigned char c;
         outb_p(0x87, WDT_EFER); /* Enter extended function mode */
@@ -93,43 +97,45 @@ w83627hf_select_wd_register(void)
         outb_p(0x01, WDT_EFDR); /* set bit 0 to activate GPIO2 */
 }
 
-static void
-w83627hf_unselect_wd_register(void)
+static void w83627hf_unselect_wd_register(void)
 {
         outb_p(0xAA, WDT_EFER); /* Leave extended function mode */
 }
 
 /* tyan motherboards seem to set F5 to 0x4C ?
  * So explicitly init to appropriate value. */
-static void
-w83627hf_init(void)
+
+static void w83627hf_init(void)
 {
         unsigned char t;
 
         w83627hf_select_wd_register();
 
         outb_p(0xF6, WDT_EFER); /* Select CRF6 */
-        t=inb_p(WDT_EFDR);      /* read CRF6 */
+        t = inb_p(WDT_EFDR);      /* read CRF6 */
         if (t != 0) {
-                printk (KERN_INFO PFX "Watchdog already running. Resetting timeout to %d sec\n", timeout);
+                printk(KERN_INFO PFX
+                     "Watchdog already running. Resetting timeout to %d sec\n",
+                                                                timeout);
                 outb_p(timeout, WDT_EFDR);    /* Write back to CRF6 */
         }
 
         outb_p(0xF5, WDT_EFER); /* Select CRF5 */
-        t=inb_p(WDT_EFDR);      /* read CRF5 */
-        t&=~0x0C;               /* set second mode & disable keyboard turning off watchdog */
+        t = inb_p(WDT_EFDR);      /* read CRF5 */
+        t &= ~0x0C;               /* set second mode & disable keyboard
+                                    turning off watchdog */
         outb_p(t, WDT_EFDR);    /* Write back to CRF5 */
 
         outb_p(0xF7, WDT_EFER); /* Select CRF7 */
-        t=inb_p(WDT_EFDR);      /* read CRF7 */
-        t&=~0xC0;               /* disable keyboard & mouse turning off watchdog */
+        t = inb_p(WDT_EFDR);      /* read CRF7 */
+        t &= ~0xC0;               /* disable keyboard & mouse turning off
+                                    watchdog */
         outb_p(t, WDT_EFDR);    /* Write back to CRF7 */
 
         w83627hf_unselect_wd_register();
 }
 
-static void
-wdt_ctrl(int timeout)
+static void wdt_ctrl(int timeout)
 {
         spin_lock(&io_lock);
 
@@ -143,32 +149,28 @@ wdt_ctrl(int timeout)
         spin_unlock(&io_lock);
 }
 
-static int
-wdt_ping(void)
+static int wdt_ping(void)
 {
         wdt_ctrl(timeout);
         return 0;
 }
 
-static int
-wdt_disable(void)
+static int wdt_disable(void)
 {
         wdt_ctrl(0);
         return 0;
 }
 
-static int
-wdt_set_heartbeat(int t)
+static int wdt_set_heartbeat(int t)
 {
-        if ((t < 1) || (t > 255))
+        if (t < 1 || t > 255)
                 return -EINVAL;
-
         timeout = t;
         return 0;
 }
 
-static ssize_t
-wdt_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
+static ssize_t wdt_write(struct file *file, const char __user *buf,
+                                                size_t count, loff_t *ppos)
 {
         if (count) {
                 if (!nowayout) {
@@ -178,7 +180,7 @@ wdt_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
 
                         for (i = 0; i != count; i++) {
                                 char c;
-                                if (get_user(c, buf+i))
+                                if (get_user(c, buf + i))
                                         return -EFAULT;
                                 if (c == 'V')
                                         expect_close = 42;
@@ -189,72 +191,61 @@ wdt_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
         return count;
 }
 
-static int
-wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
-          unsigned long arg)
+static long wdt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
         int new_timeout;
         static struct watchdog_info ident = {
-                .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE,
+                .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT |
+                                                        WDIOF_MAGICCLOSE,
                 .firmware_version = 1,
                 .identity = "W83627HF WDT",
         };
 
         switch (cmd) {
         case WDIOC_GETSUPPORT:
-          if (copy_to_user(argp, &ident, sizeof(ident)))
-            return -EFAULT;
-          break;
-
+                if (copy_to_user(argp, &ident, sizeof(ident)))
+                        return -EFAULT;
+                break;
         case WDIOC_GETSTATUS:
         case WDIOC_GETBOOTSTATUS:
-          return put_user(0, p);
-
-        case WDIOC_KEEPALIVE:
-          wdt_ping();
-          break;
-
-        case WDIOC_SETTIMEOUT:
-          if (get_user(new_timeout, p))
-                  return -EFAULT;
-          if (wdt_set_heartbeat(new_timeout))
-                  return -EINVAL;
-          wdt_ping();
-          /* Fall */
-
-        case WDIOC_GETTIMEOUT:
-          return put_user(timeout, p);
-
+                return put_user(0, p);
         case WDIOC_SETOPTIONS:
         {
-          int options, retval = -EINVAL;
-
-          if (get_user(options, p))
-            return -EFAULT;
-
-          if (options & WDIOS_DISABLECARD) {
-            wdt_disable();
-            retval = 0;
-          }
-
-          if (options & WDIOS_ENABLECARD) {
-            wdt_ping();
-            retval = 0;
-          }
+                int options, retval = -EINVAL;
 
-          return retval;
+                if (get_user(options, p))
+                        return -EFAULT;
+                if (options & WDIOS_DISABLECARD) {
+                        wdt_disable();
+                        retval = 0;
+                }
+                if (options & WDIOS_ENABLECARD) {
+                        wdt_ping();
+                        retval = 0;
+                }
+                return retval;
         }
-
+        case WDIOC_KEEPALIVE:
+                wdt_ping();
+                break;
+        case WDIOC_SETTIMEOUT:
+                if (get_user(new_timeout, p))
+                        return -EFAULT;
+                if (wdt_set_heartbeat(new_timeout))
+                        return -EINVAL;
+                wdt_ping();
+                /* Fall */
+        case WDIOC_GETTIMEOUT:
+                return put_user(timeout, p);
         default:
-          return -ENOTTY;
+                return -ENOTTY;
         }
         return 0;
 }
 
-static int
-wdt_open(struct inode *inode, struct file *file)
+static int wdt_open(struct inode *inode, struct file *file)
 {
         if (test_and_set_bit(0, &wdt_is_open))
                 return -EBUSY;
@@ -266,13 +257,13 @@ wdt_open(struct inode *inode, struct file *file)
         return nonseekable_open(inode, file);
 }
 
-static int
-wdt_close(struct inode *inode, struct file *file)
+static int wdt_close(struct inode *inode, struct file *file)
 {
-        if (expect_close == 42) {
+        if (expect_close == 42)
                 wdt_disable();
-        } else {
-                printk(KERN_CRIT PFX "Unexpected close, not stopping watchdog!\n");
+        else {
+                printk(KERN_CRIT PFX
+                        "Unexpected close, not stopping watchdog!\n");
                 wdt_ping();
         }
         expect_close = 0;
@@ -284,14 +275,12 @@ wdt_close(struct inode *inode, struct file *file)
  *      Notifier for system down
  */
 
-static int
-wdt_notify_sys(struct notifier_block *this, unsigned long code,
+static int wdt_notify_sys(struct notifier_block *this, unsigned long code,
         void *unused)
 {
-        if (code == SYS_DOWN || code == SYS_HALT) {
-                /* Turn the WDT off */
-                wdt_disable();
-        }
+        if (code == SYS_DOWN || code == SYS_HALT)
+                wdt_disable();  /* Turn the WDT off */
+
         return NOTIFY_DONE;
 }
 
@@ -303,7 +292,7 @@ static const struct file_operations wdt_fops = {
         .owner          = THIS_MODULE,
         .llseek         = no_llseek,
         .write          = wdt_write,
-        .ioctl          = wdt_ioctl,
+        .unlocked_ioctl = wdt_ioctl,
         .open           = wdt_open,
         .release        = wdt_close,
 };
@@ -323,8 +312,7 @@ static struct notifier_block wdt_notifier = {
         .notifier_call = wdt_notify_sys,
 };
 
-static int __init
-wdt_init(void)
+static int __init wdt_init(void)
 {
         int ret;
 
@@ -332,12 +320,13 @@ wdt_init(void)
 
         if (wdt_set_heartbeat(timeout)) {
                 wdt_set_heartbeat(WATCHDOG_TIMEOUT);
-                printk (KERN_INFO PFX "timeout value must be 1<=timeout<=255, using %d\n",
-                        WATCHDOG_TIMEOUT);
+                printk(KERN_INFO PFX
+                     "timeout value must be 1 <= timeout <= 255, using %d\n",
+                                WATCHDOG_TIMEOUT);
         }
 
         if (!request_region(wdt_io, 1, WATCHDOG_NAME)) {
-                printk (KERN_ERR PFX "I/O address 0x%04x already in use\n",
+                printk(KERN_ERR PFX "I/O address 0x%04x already in use\n",
                         wdt_io);
                 ret = -EIO;
                 goto out;
@@ -347,20 +336,22 @@ wdt_init(void)
 
         ret = register_reboot_notifier(&wdt_notifier);
         if (ret != 0) {
-                printk (KERN_ERR PFX "cannot register reboot notifier (err=%d)\n",
-                        ret);
+                printk(KERN_ERR PFX
+                        "cannot register reboot notifier (err=%d)\n", ret);
                 goto unreg_regions;
         }
 
         ret = misc_register(&wdt_miscdev);
         if (ret != 0) {
-                printk (KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",
-                        WATCHDOG_MINOR, ret);
+                printk(KERN_ERR PFX
+                        "cannot register miscdev on minor=%d (err=%d)\n",
+                                                        WATCHDOG_MINOR, ret);
                 goto unreg_reboot;
         }
 
-        printk (KERN_INFO PFX "initialized. timeout=%d sec (nowayout=%d)\n",
-                timeout, nowayout);
+        printk(KERN_INFO PFX
+                        "initialized. timeout=%d sec (nowayout=%d)\n",
+                                                        timeout, nowayout);
 
 out:
         return ret;
@@ -371,12 +362,11 @@ unreg_regions:
         goto out;
 }
 
-static void __exit
-wdt_exit(void)
+static void __exit wdt_exit(void)
 {
         misc_deregister(&wdt_miscdev);
         unregister_reboot_notifier(&wdt_notifier);
-        release_region(wdt_io,1);
+        release_region(wdt_io, 1);
 }
 
 module_init(wdt_init);
diff --git a/drivers/watchdog/w83697hf_wdt.c b/drivers/watchdog/w83697hf_wdt.c
index 528b882420b6..445d30a01ed3 100644
--- a/drivers/watchdog/w83697hf_wdt.c
+++ b/drivers/watchdog/w83697hf_wdt.c
@@ -36,9 +36,9 @@
 #include <linux/reboot.h>
 #include <linux/init.h>
 #include <linux/spinlock.h>
+#include <linux/io.h>
+#include <linux/uaccess.h>
 
-#include <asm/io.h>
-#include <asm/uaccess.h>
 #include <asm/system.h>
 
 #define WATCHDOG_NAME "w83697hf/hg WDT"
@@ -53,37 +53,43 @@ static DEFINE_SPINLOCK(io_lock);
 /* You must set this - there is no sane way to probe for this board. */
 static int wdt_io = 0x2e;
 module_param(wdt_io, int, 0);
-MODULE_PARM_DESC(wdt_io, "w83697hf/hg WDT io port (default 0x2e, 0 = autodetect)");
+MODULE_PARM_DESC(wdt_io,
+                "w83697hf/hg WDT io port (default 0x2e, 0 = autodetect)");
 
 static int timeout = WATCHDOG_TIMEOUT;  /* in seconds */
 module_param(timeout, int, 0);
-MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds. 1<= timeout <=255 (default=" __MODULE_STRING(WATCHDOG_TIMEOUT) ")");
+MODULE_PARM_DESC(timeout,
+        "Watchdog timeout in seconds. 1<= timeout <=255 (default="
+                                __MODULE_STRING(WATCHDOG_TIMEOUT) ")");
 
 static int nowayout = WATCHDOG_NOWAYOUT;
 module_param(nowayout, int, 0);
-MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+MODULE_PARM_DESC(nowayout,
+        "Watchdog cannot be stopped once started (default="
+                                __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 
 static int early_disable = WATCHDOG_EARLY_DISABLE;
 module_param(early_disable, int, 0);
-MODULE_PARM_DESC(early_disable, "Watchdog gets disabled at boot time (default=" __MODULE_STRING(WATCHDOG_EARLY_DISABLE) ")");
+MODULE_PARM_DESC(early_disable,
+        "Watchdog gets disabled at boot time (default="
+                                __MODULE_STRING(WATCHDOG_EARLY_DISABLE) ")");
 
 /*
  *      Kernel methods.
  */
 
-#define W83697HF_EFER (wdt_io+0)        /* Extended Function Enable Register */
-#define W83697HF_EFIR (wdt_io+0)        /* Extended Function Index Register (same as EFER) */
-#define W83697HF_EFDR (wdt_io+1)        /* Extended Function Data Register */
+#define W83697HF_EFER (wdt_io + 0)  /* Extended Function Enable Register */
+#define W83697HF_EFIR (wdt_io + 0)  /* Extended Function Index Register
+                                                        (same as EFER) */
+#define W83697HF_EFDR (wdt_io + 1)  /* Extended Function Data Register */
 
-static inline void
-w83697hf_unlock(void)
+static inline void w83697hf_unlock(void)
 {
         outb_p(0x87, W83697HF_EFER);    /* Enter extended function mode */
         outb_p(0x87, W83697HF_EFER);    /* Again according to manual */
 }
 
-static inline void
-w83697hf_lock(void)
+static inline void w83697hf_lock(void)
 {
         outb_p(0xAA, W83697HF_EFER);    /* Leave extended function mode */
 }
@@ -93,41 +99,36 @@ w83697hf_lock(void)
  *      w83697hf_write_timeout() must be called with the device unlocked.
  */
 
-static unsigned char
-w83697hf_get_reg(unsigned char reg)
+static unsigned char w83697hf_get_reg(unsigned char reg)
 {
         outb_p(reg, W83697HF_EFIR);
         return inb_p(W83697HF_EFDR);
 }
 
-static void
-w83697hf_set_reg(unsigned char reg, unsigned char data)
+static void w83697hf_set_reg(unsigned char reg, unsigned char data)
 {
         outb_p(reg, W83697HF_EFIR);
         outb_p(data, W83697HF_EFDR);
 }
 
-static void
-w83697hf_write_timeout(int timeout)
+static void w83697hf_write_timeout(int timeout)
 {
-        w83697hf_set_reg(0xF4, timeout);        /* Write Timeout counter to CRF4 */
+        /* Write Timeout counter to CRF4 */
+        w83697hf_set_reg(0xF4, timeout);
 }
 
-static void
-w83697hf_select_wdt(void)
+static void w83697hf_select_wdt(void)
 {
         w83697hf_unlock();
         w83697hf_set_reg(0x07, 0x08);   /* Switch to logic device 8 (GPIO2) */
 }
 
-static inline void
-w83697hf_deselect_wdt(void)
+static inline void w83697hf_deselect_wdt(void)
 {
         w83697hf_lock();
 }
 
-static void
-w83697hf_init(void)
+static void w83697hf_init(void)
 {
         unsigned char bbuf;
 
@@ -136,7 +137,9 @@ w83697hf_init(void)
         bbuf = w83697hf_get_reg(0x29);
         bbuf &= ~0x60;
         bbuf |= 0x20;
-        w83697hf_set_reg(0x29, bbuf);   /* Set pin 119 to WDTO# mode (= CR29, WDT0) */
+
+        /* Set pin 119 to WDTO# mode (= CR29, WDT0) */
+        w83697hf_set_reg(0x29, bbuf);
 
         bbuf = w83697hf_get_reg(0xF3);
         bbuf &= ~0x04;
@@ -145,8 +148,7 @@ w83697hf_init(void)
         w83697hf_deselect_wdt();
 }
 
-static void
-wdt_ping(void)
+static void wdt_ping(void)
 {
         spin_lock(&io_lock);
         w83697hf_select_wdt();
@@ -157,8 +159,7 @@ wdt_ping(void)
         spin_unlock(&io_lock);
 }
 
-static void
-wdt_enable(void)
+static void wdt_enable(void)
 {
         spin_lock(&io_lock);
         w83697hf_select_wdt();
@@ -170,8 +171,7 @@ wdt_enable(void)
         spin_unlock(&io_lock);
 }
 
-static void
-wdt_disable(void)
+static void wdt_disable(void)
 {
         spin_lock(&io_lock);
         w83697hf_select_wdt();
@@ -183,8 +183,7 @@ wdt_disable(void)
         spin_unlock(&io_lock);
 }
 
-static unsigned char
-wdt_running(void)
+static unsigned char wdt_running(void)
 {
         unsigned char t;
 
@@ -199,18 +198,17 @@ wdt_running(void)
         return t;
 }
 
-static int
-wdt_set_heartbeat(int t)
+static int wdt_set_heartbeat(int t)
 {
-        if ((t < 1) || (t > 255))
+        if (t < 1 || t > 255)
                 return -EINVAL;
 
         timeout = t;
         return 0;
 }
 
-static ssize_t
-wdt_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
+static ssize_t wdt_write(struct file *file, const char __user *buf,
+                                                size_t count, loff_t *ppos)
 {
         if (count) {
                 if (!nowayout) {
@@ -220,7 +218,7 @@ wdt_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
 
                         for (i = 0; i != count; i++) {
                                 char c;
-                                if (get_user(c, buf+i))
+                                if (get_user(c, buf + i))
                                         return -EFAULT;
                                 if (c == 'V')
                                         expect_close = 42;
@@ -231,15 +229,14 @@ wdt_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
         return count;
 }
 
-static int
-wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
-          unsigned long arg)
+static long wdt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
         int new_timeout;
-        static struct watchdog_info ident = {
-                .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE,
+        static const struct watchdog_info ident = {
+                .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT
+                                                        | WDIOF_MAGICCLOSE,
                 .firmware_version = 1,
                 .identity = "W83697HF WDT",
         };
@@ -254,21 +251,6 @@ wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
         case WDIOC_GETBOOTSTATUS:
                 return put_user(0, p);
 
-        case WDIOC_KEEPALIVE:
-                wdt_ping();
-                break;
-
-        case WDIOC_SETTIMEOUT:
-                if (get_user(new_timeout, p))
-                        return -EFAULT;
-                if (wdt_set_heartbeat(new_timeout))
-                        return -EINVAL;
-                wdt_ping();
-                /* Fall */
-
-        case WDIOC_GETTIMEOUT:
-                return put_user(timeout, p);
-
         case WDIOC_SETOPTIONS:
         {
                 int options, retval = -EINVAL;
@@ -289,14 +271,28 @@ wdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
                 return retval;
         }
 
+        case WDIOC_KEEPALIVE:
+                wdt_ping();
+                break;
+
+        case WDIOC_SETTIMEOUT:
+                if (get_user(new_timeout, p))
+                        return -EFAULT;
+                if (wdt_set_heartbeat(new_timeout))
+                        return -EINVAL;
+                wdt_ping();
+                /* Fall */
+
+        case WDIOC_GETTIMEOUT:
+                return put_user(timeout, p);
+
         default:
                 return -ENOTTY;
         }
         return 0;
 }
 
-static int
-wdt_open(struct inode *inode, struct file *file)
+static int wdt_open(struct inode *inode, struct file *file)
 {
         if (test_and_set_bit(0, &wdt_is_open))
                 return -EBUSY;
@@ -308,13 +304,13 @@ wdt_open(struct inode *inode, struct file *file)
         return nonseekable_open(inode, file);
 }
 
-static int
-wdt_close(struct inode *inode, struct file *file)
+static int wdt_close(struct inode *inode, struct file *file)
 {
-        if (expect_close == 42) {
+        if (expect_close == 42)
                 wdt_disable();
-        } else {
-                printk (KERN_CRIT PFX "Unexpected close, not stopping watchdog!\n");
+        else {
+                printk(KERN_CRIT PFX
+                        "Unexpected close, not stopping watchdog!\n");
                 wdt_ping();
         }
         expect_close = 0;
@@ -326,14 +322,12 @@ wdt_close(struct inode *inode, struct file *file)
  *      Notifier for system down
  */
 
-static int
-wdt_notify_sys(struct notifier_block *this, unsigned long code,
+static int wdt_notify_sys(struct notifier_block *this, unsigned long code,
         void *unused)
 {
-        if (code == SYS_DOWN || code == SYS_HALT) {
-                /* Turn the WDT off */
-                wdt_disable();
-        }
+        if (code == SYS_DOWN || code == SYS_HALT)
+                wdt_disable();  /* Turn the WDT off */
+
         return NOTIFY_DONE;
 }
 
@@ -345,7 +339,7 @@ static const struct file_operations wdt_fops = {
         .owner          = THIS_MODULE,
         .llseek         = no_llseek,
         .write          = wdt_write,
-        .ioctl          = wdt_ioctl,
+        .unlocked_ioctl = wdt_ioctl,
         .open           = wdt_open,
         .release        = wdt_close,
 };
@@ -365,36 +359,38 @@ static struct notifier_block wdt_notifier = {
         .notifier_call = wdt_notify_sys,
 };
 
-static int
-w83697hf_check_wdt(void)
+static int w83697hf_check_wdt(void)
 {
         if (!request_region(wdt_io, 2, WATCHDOG_NAME)) {
-                printk (KERN_ERR PFX "I/O address 0x%x already in use\n", wdt_io);
+                printk(KERN_ERR PFX
+                        "I/O address 0x%x already in use\n", wdt_io);
                 return -EIO;
         }
 
-        printk (KERN_DEBUG PFX "Looking for watchdog at address 0x%x\n", wdt_io);
+        printk(KERN_DEBUG PFX
+                        "Looking for watchdog at address 0x%x\n", wdt_io);
         w83697hf_unlock();
         if (w83697hf_get_reg(0x20) == 0x60) {
-                printk (KERN_INFO PFX "watchdog found at address 0x%x\n", wdt_io);
+                printk(KERN_INFO PFX
+                        "watchdog found at address 0x%x\n", wdt_io);
                 w83697hf_lock();
                 return 0;
         }
-        w83697hf_lock();        /* Reprotect in case it was a compatible device */
+        /* Reprotect in case it was a compatible device */
+        w83697hf_lock();
 
-        printk (KERN_INFO PFX "watchdog not found at address 0x%x\n", wdt_io);
+        printk(KERN_INFO PFX "watchdog not found at address 0x%x\n", wdt_io);
         release_region(wdt_io, 2);
         return -EIO;
 }
 
 static int w83697hf_ioports[] = { 0x2e, 0x4e, 0x00 };
 
-static int __init
-wdt_init(void)
+static int __init wdt_init(void)
 {
         int ret, i, found = 0;
 
-        printk (KERN_INFO PFX "WDT driver for W83697HF/HG initializing\n");
+        printk(KERN_INFO PFX "WDT driver for W83697HF/HG initializing\n");
 
         if (wdt_io == 0) {
                 /* we will autodetect the W83697HF/HG watchdog */
@@ -409,7 +405,7 @@ wdt_init(void)
         }
 
         if (!found) {
-                printk (KERN_ERR PFX "No W83697HF/HG could be found\n");
+                printk(KERN_ERR PFX "No W83697HF/HG could be found\n");
                 ret = -EIO;
                 goto out;
         }
@@ -417,31 +413,33 @@ wdt_init(void)
         w83697hf_init();
         if (early_disable) {
                 if (wdt_running())
-                        printk (KERN_WARNING PFX "Stopping previously enabled watchdog until userland kicks in\n");
+                        printk(KERN_WARNING PFX "Stopping previously enabled watchdog until userland kicks in\n");
                 wdt_disable();
         }
 
         if (wdt_set_heartbeat(timeout)) {
                 wdt_set_heartbeat(WATCHDOG_TIMEOUT);
-                printk (KERN_INFO PFX "timeout value must be 1<=timeout<=255, using %d\n",
-                        WATCHDOG_TIMEOUT);
+                printk(KERN_INFO PFX
+                     "timeout value must be 1 <= timeout <= 255, using %d\n",
+                                                        WATCHDOG_TIMEOUT);
         }
 
         ret = register_reboot_notifier(&wdt_notifier);
         if (ret != 0) {
-                printk (KERN_ERR PFX "cannot register reboot notifier (err=%d)\n",
-                        ret);
+                printk(KERN_ERR PFX
+                        "cannot register reboot notifier (err=%d)\n", ret);
                 goto unreg_regions;
         }
 
         ret = misc_register(&wdt_miscdev);
         if (ret != 0) {
-                printk (KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",
-                        WATCHDOG_MINOR, ret);
+                printk(KERN_ERR PFX
+                        "cannot register miscdev on minor=%d (err=%d)\n",
+                                                WATCHDOG_MINOR, ret);
                 goto unreg_reboot;
         }
 
-        printk (KERN_INFO PFX "initialized. timeout=%d sec (nowayout=%d)\n",
+        printk(KERN_INFO PFX "initialized. timeout=%d sec (nowayout=%d)\n",
                 timeout, nowayout);
 
 out:
@@ -453,8 +451,7 @@ unreg_regions:
         goto out;
 }
 
-static void __exit
-wdt_exit(void)
+static void __exit wdt_exit(void)
 {
         misc_deregister(&wdt_miscdev);
         unregister_reboot_notifier(&wdt_notifier);
diff --git a/drivers/watchdog/w83877f_wdt.c b/drivers/watchdog/w83877f_wdt.c
index f510a3a595e6..24587d2060c4 100644
--- a/drivers/watchdog/w83877f_wdt.c
+++ b/drivers/watchdog/w83877f_wdt.c
@@ -23,13 +23,16 @@
  *                            Added KERN_* tags to printks
  *                            add CONFIG_WATCHDOG_NOWAYOUT support
  *                            fix possible wdt_is_open race
- *                            changed watchdog_info to correctly reflect what the driver offers
- *                            added WDIOC_GETSTATUS, WDIOC_GETBOOTSTATUS, WDIOC_SETTIMEOUT,
+ *                            changed watchdog_info to correctly reflect what
+ *                            the driver offers
+ *                            added WDIOC_GETSTATUS, WDIOC_GETBOOTSTATUS,
+ *                            WDIOC_SETTIMEOUT,
  *                            WDIOC_GETTIMEOUT, and WDIOC_SETOPTIONS ioctls
  *           09/8 - 2003      [wim@iguana.be] cleanup of trailing spaces
  *                            added extra printk's for startup problems
  *                            use module_param
- *                            made timeout (the emulated heartbeat) a module_param
+ *                            made timeout (the emulated heartbeat) a
+ *                            module_param
  *                            made the keepalive ping an internal subroutine
  *
  *  This WDT driver is different from most other Linux WDT
@@ -51,8 +54,8 @@
 #include <linux/notifier.h>
 #include <linux/reboot.h>
 #include <linux/init.h>
-#include <asm/io.h>
-#include <asm/uaccess.h>
+#include <linux/io.h>
+#include <linux/uaccess.h>
 #include <asm/system.h>
 
 #define OUR_NAME "w83877f_wdt"
@@ -80,14 +83,19 @@
  */
 
 #define WATCHDOG_TIMEOUT 30            /* 30 sec default timeout */
-static int timeout = WATCHDOG_TIMEOUT; /* in seconds, will be multiplied by HZ to get seconds to wait for a ping */
+/* in seconds, will be multiplied by HZ to get seconds to wait for a ping */
+static int timeout = WATCHDOG_TIMEOUT;
 module_param(timeout, int, 0);
-MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds. (1<=timeout<=3600, default=" __MODULE_STRING(WATCHDOG_TIMEOUT) ")");
+MODULE_PARM_DESC(timeout,
+        "Watchdog timeout in seconds. (1<=timeout<=3600, default="
+                                __MODULE_STRING(WATCHDOG_TIMEOUT) ")");
 
 
 static int nowayout = WATCHDOG_NOWAYOUT;
 module_param(nowayout, int, 0);
-MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+MODULE_PARM_DESC(nowayout,
+                "Watchdog cannot be stopped once started (default="
+                                __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 
 static void wdt_timer_ping(unsigned long);
 static DEFINE_TIMER(timer, wdt_timer_ping, 0, 0);
@@ -105,8 +113,7 @@ static void wdt_timer_ping(unsigned long data)
         /* If we got a heartbeat pulse within the WDT_US_INTERVAL
          * we agree to ping the WDT
          */
-        if(time_before(jiffies, next_heartbeat))
-        {
+        if (time_before(jiffies, next_heartbeat)) {
                 /* Ping the WDT */
                 spin_lock(&wdt_spinlock);
 
@@ -118,9 +125,9 @@ static void wdt_timer_ping(unsigned long data)
 
                 spin_unlock(&wdt_spinlock);
 
-        } else {
-                printk(KERN_WARNING PFX "Heartbeat lost! Will not ping the watchdog\n");
-        }
+        } else
+                printk(KERN_WARNING PFX
+                        "Heartbeat lost! Will not ping the watchdog\n");
 }
 
 /*
@@ -181,22 +188,21 @@ static void wdt_keepalive(void)
  * /dev/watchdog handling
  */
 
-static ssize_t fop_write(struct file * file, const char __user * buf, size_t count, loff_t * ppos)
+static ssize_t fop_write(struct file *file, const char __user *buf,
+                                                size_t count, loff_t *ppos)
 {
         /* See if we got the magic character 'V' and reload the timer */
-        if(count)
-        {
-                if (!nowayout)
-                {
+        if (count) {
+                if (!nowayout) {
                         size_t ofs;
 
-                        /* note: just in case someone wrote the magic character
-                         * five months ago... */
+                        /* note: just in case someone wrote the magic
+                           character five months ago... */
                         wdt_expect_close = 0;
 
-                        /* scan to see whether or not we got the magic character */
-                        for(ofs = 0; ofs != count; ofs++)
-                        {
+                        /* scan to see whether or not we got the
+                           magic character */
+                        for (ofs = 0; ofs != count; ofs++) {
                                 char c;
                                 if (get_user(c, buf + ofs))
                                         return -EFAULT;
@@ -211,10 +217,10 @@ static ssize_t fop_write(struct file * file, const char __user * buf, size_t cou
         return count;
 }
 
-static int fop_open(struct inode * inode, struct file * file)
+static int fop_open(struct inode *inode, struct file *file)
 {
         /* Just in case we're already talking to someone... */
-        if(test_and_set_bit(0, &wdt_is_open))
+        if (test_and_set_bit(0, &wdt_is_open))
                 return -EBUSY;
 
         /* Good, fire up the show */
@@ -222,78 +228,78 @@ static int fop_open(struct inode * inode, struct file * file)
         return nonseekable_open(inode, file);
 }
 
-static int fop_close(struct inode * inode, struct file * file)
+static int fop_close(struct inode *inode, struct file *file)
 {
-        if(wdt_expect_close == 42)
+        if (wdt_expect_close == 42)
                 wdt_turnoff();
         else {
                 del_timer(&timer);
-                printk(KERN_CRIT PFX "device file closed unexpectedly. Will not stop the WDT!\n");
+                printk(KERN_CRIT PFX
+                  "device file closed unexpectedly. Will not stop the WDT!\n");
         }
         clear_bit(0, &wdt_is_open);
         wdt_expect_close = 0;
         return 0;
 }
 
-static int fop_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
-        unsigned long arg)
+static long fop_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
-        static struct watchdog_info ident=
-        {
-                .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE,
+        static const struct watchdog_info ident = {
+                .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT
+                                                        | WDIOF_MAGICCLOSE,
                 .firmware_version = 1,
                 .identity = "W83877F",
         };
 
-        switch(cmd)
+        switch (cmd) {
+        case WDIOC_GETSUPPORT:
+                return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;
+        case WDIOC_GETSTATUS:
+        case WDIOC_GETBOOTSTATUS:
+                return put_user(0, p);
+        case WDIOC_SETOPTIONS:
         {
-                default:
-                        return -ENOTTY;
-                case WDIOC_GETSUPPORT:
-                        return copy_to_user(argp, &ident, sizeof(ident))?-EFAULT:0;
-                case WDIOC_GETSTATUS:
-                case WDIOC_GETBOOTSTATUS:
-                        return put_user(0, p);
-                case WDIOC_KEEPALIVE:
-                        wdt_keepalive();
-                        return 0;
-                case WDIOC_SETOPTIONS:
-                {
-                        int new_options, retval = -EINVAL;
-
-                        if(get_user(new_options, p))
-                                return -EFAULT;
-
-                        if(new_options & WDIOS_DISABLECARD) {
-                                wdt_turnoff();
-                                retval = 0;
-                        }
+                int new_options, retval = -EINVAL;
 
-                        if(new_options & WDIOS_ENABLECARD) {
-                                wdt_startup();
-                                retval = 0;
-                        }
+                if (get_user(new_options, p))
+                        return -EFAULT;
 
-                        return retval;
+                if (new_options & WDIOS_DISABLECARD) {
+                        wdt_turnoff();
+                        retval = 0;
                 }
-                case WDIOC_SETTIMEOUT:
-                {
-                        int new_timeout;
 
-                        if(get_user(new_timeout, p))
-                                return -EFAULT;
+                if (new_options & WDIOS_ENABLECARD) {
+                        wdt_startup();
+                        retval = 0;
+                }
 
-                        if(new_timeout < 1 || new_timeout > 3600) /* arbitrary upper limit */
-                                return -EINVAL;
+                return retval;
+        }
+        case WDIOC_KEEPALIVE:
+                wdt_keepalive();
+                return 0;
+        case WDIOC_SETTIMEOUT:
+        {
+                int new_timeout;
 
-                        timeout = new_timeout;
-                        wdt_keepalive();
-                        /* Fall through */
-                }
-                case WDIOC_GETTIMEOUT:
-                        return put_user(timeout, p);
+                if (get_user(new_timeout, p))
+                        return -EFAULT;
+
+                /* arbitrary upper limit */
+                if (new_timeout < 1 || new_timeout > 3600)
+                        return -EINVAL;
+
+                timeout = new_timeout;
+                wdt_keepalive();
+                /* Fall through */
+        }
+        case WDIOC_GETTIMEOUT:
+                return put_user(timeout, p);
+        default:
+                return -ENOTTY;
         }
 }
 
@@ -303,7 +309,7 @@ static const struct file_operations wdt_fops = {
         .write          = fop_write,
         .open           = fop_open,
         .release        = fop_close,
-        .ioctl          = fop_ioctl,
+        .unlocked_ioctl = fop_ioctl,
 };
 
 static struct miscdevice wdt_miscdev = {
@@ -319,7 +325,7 @@ static struct miscdevice wdt_miscdev = {
 static int wdt_notify_sys(struct notifier_block *this, unsigned long code,
         void *unused)
 {
-        if(code==SYS_DOWN || code==SYS_HALT)
+        if (code == SYS_DOWN || code == SYS_HALT)
                 wdt_turnoff();
         return NOTIFY_DONE;
 }
@@ -329,8 +335,7 @@ static int wdt_notify_sys(struct notifier_block *this, unsigned long code,
  *      turn the timebomb registers off.
  */
 
-static struct notifier_block wdt_notifier=
-{
+static struct notifier_block wdt_notifier = {
         .notifier_call = wdt_notify_sys,
 };
 
@@ -342,31 +347,29 @@ static void __exit w83877f_wdt_unload(void)
         misc_deregister(&wdt_miscdev);
 
         unregister_reboot_notifier(&wdt_notifier);
-        release_region(WDT_PING,1);
-        release_region(ENABLE_W83877F_PORT,2);
+        release_region(WDT_PING, 1);
+        release_region(ENABLE_W83877F_PORT, 2);
 }
 
 static int __init w83877f_wdt_init(void)
 {
         int rc = -EBUSY;
 
-        if(timeout < 1 || timeout > 3600) /* arbitrary upper limit */
-        {
+        if (timeout < 1 || timeout > 3600) { /* arbitrary upper limit */
                 timeout = WATCHDOG_TIMEOUT;
-                printk(KERN_INFO PFX "timeout value must be 1<=x<=3600, using %d\n",
-                        timeout);
+                printk(KERN_INFO PFX
+                        "timeout value must be 1 <= x <= 3600, using %d\n",
+                                                        timeout);
         }
 
-        if (!request_region(ENABLE_W83877F_PORT, 2, "W83877F WDT"))
-        {
+        if (!request_region(ENABLE_W83877F_PORT, 2, "W83877F WDT")) {
                 printk(KERN_ERR PFX "I/O address 0x%04x already in use\n",
                         ENABLE_W83877F_PORT);
                 rc = -EIO;
                 goto err_out;
         }
 
-        if (!request_region(WDT_PING, 1, "W8387FF WDT"))
-        {
+        if (!request_region(WDT_PING, 1, "W8387FF WDT")) {
                 printk(KERN_ERR PFX "I/O address 0x%04x already in use\n",
                         WDT_PING);
                 rc = -EIO;
@@ -374,22 +377,22 @@ static int __init w83877f_wdt_init(void)
         }
 
         rc = register_reboot_notifier(&wdt_notifier);
-        if (rc)
-        {
-                printk(KERN_ERR PFX "cannot register reboot notifier (err=%d)\n",
-                        rc);
+        if (rc) {
+                printk(KERN_ERR PFX
+                        "cannot register reboot notifier (err=%d)\n", rc);
                 goto err_out_region2;
         }
 
         rc = misc_register(&wdt_miscdev);
-        if (rc)
-        {
-                printk(KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",
-                        wdt_miscdev.minor, rc);
+        if (rc) {
+                printk(KERN_ERR PFX
+                        "cannot register miscdev on minor=%d (err=%d)\n",
+                                                        wdt_miscdev.minor, rc);
                 goto err_out_reboot;
         }
 
-        printk(KERN_INFO PFX "WDT driver for W83877F initialised. timeout=%d sec (nowayout=%d)\n",
+        printk(KERN_INFO PFX
+          "WDT driver for W83877F initialised. timeout=%d sec (nowayout=%d)\n",
                 timeout, nowayout);
 
         return 0;
@@ -397,9 +400,9 @@ static int __init w83877f_wdt_init(void)
 err_out_reboot:
         unregister_reboot_notifier(&wdt_notifier);
 err_out_region2:
-        release_region(WDT_PING,1);
+        release_region(WDT_PING, 1);
 err_out_region1:
-        release_region(ENABLE_W83877F_PORT,2);
+        release_region(ENABLE_W83877F_PORT, 2);
 err_out:
         return rc;
 }
diff --git a/drivers/watchdog/w83977f_wdt.c b/drivers/watchdog/w83977f_wdt.c
index b209bcd7f789..2525da5080ca 100644
--- a/drivers/watchdog/w83977f_wdt.c
+++ b/drivers/watchdog/w83977f_wdt.c
@@ -26,10 +26,10 @@
 #include <linux/watchdog.h>
 #include <linux/notifier.h>
 #include <linux/reboot.h>
+#include <linux/uaccess.h>
+#include <linux/io.h>
 
-#include <asm/io.h>
 #include <asm/system.h>
-#include <asm/uaccess.h>
 
 #define WATCHDOG_VERSION  "1.00"
 #define WATCHDOG_NAME     "W83977F WDT"
@@ -53,13 +53,17 @@ static	char expect_close;
 static  DEFINE_SPINLOCK(spinlock);
 
 module_param(timeout, int, 0);
-MODULE_PARM_DESC(timeout,"Watchdog timeout in seconds (15..7635), default=" __MODULE_STRING(DEFAULT_TIMEOUT) ")");
+MODULE_PARM_DESC(timeout,
+                "Watchdog timeout in seconds (15..7635), default="
+                                __MODULE_STRING(DEFAULT_TIMEOUT) ")");
 module_param(testmode, int, 0);
-MODULE_PARM_DESC(testmode,"Watchdog testmode (1 = no reboot), default=0");
+MODULE_PARM_DESC(testmode, "Watchdog testmode (1 = no reboot), default=0");
 
 static int nowayout = WATCHDOG_NOWAYOUT;
 module_param(nowayout, int, 0);
-MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+MODULE_PARM_DESC(nowayout,
+                "Watchdog cannot be stopped once started (default="
+                                __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 
 /*
  * Start the watchdog
@@ -72,8 +76,8 @@ static int wdt_start(void)
         spin_lock_irqsave(&spinlock, flags);
 
         /* Unlock the SuperIO chip */
-        outb_p(UNLOCK_DATA,IO_INDEX_PORT);
-        outb_p(UNLOCK_DATA,IO_INDEX_PORT);
+        outb_p(UNLOCK_DATA, IO_INDEX_PORT);
+        outb_p(UNLOCK_DATA, IO_INDEX_PORT);
 
         /*
          * Select device Aux2 (device=8) to set watchdog regs F2, F3 and F4.
@@ -81,50 +85,49 @@ static int wdt_start(void)
          * F3 is set to enable watchdog LED blink at timeout.
          * F4 is used to just clear the TIMEOUT'ed state (bit 0).
          */
-        outb_p(DEVICE_REGISTER,IO_INDEX_PORT);
-        outb_p(0x08,IO_DATA_PORT);
-        outb_p(0xF2,IO_INDEX_PORT);
-        outb_p(timeoutW,IO_DATA_PORT);
-        outb_p(0xF3,IO_INDEX_PORT);
-        outb_p(0x08,IO_DATA_PORT);
-        outb_p(0xF4,IO_INDEX_PORT);
-        outb_p(0x00,IO_DATA_PORT);
+        outb_p(DEVICE_REGISTER, IO_INDEX_PORT);
+        outb_p(0x08, IO_DATA_PORT);
+        outb_p(0xF2, IO_INDEX_PORT);
+        outb_p(timeoutW, IO_DATA_PORT);
+        outb_p(0xF3, IO_INDEX_PORT);
+        outb_p(0x08, IO_DATA_PORT);
+        outb_p(0xF4, IO_INDEX_PORT);
+        outb_p(0x00, IO_DATA_PORT);
 
         /* Set device Aux2 active */
-        outb_p(0x30,IO_INDEX_PORT);
-        outb_p(0x01,IO_DATA_PORT);
+        outb_p(0x30, IO_INDEX_PORT);
+        outb_p(0x01, IO_DATA_PORT);
 
-        /* 
+        /*
          * Select device Aux1 (dev=7) to set GP16 as the watchdog output
          * (in reg E6) and GP13 as the watchdog LED output (in reg E3).
          * Map GP16 at pin 119.
          * In test mode watch the bit 0 on F4 to indicate "triggered" or
          * check watchdog LED on SBC.
          */
-        outb_p(DEVICE_REGISTER,IO_INDEX_PORT);
-        outb_p(0x07,IO_DATA_PORT);
-        if (!testmode)
-        {
+        outb_p(DEVICE_REGISTER, IO_INDEX_PORT);
+        outb_p(0x07, IO_DATA_PORT);
+        if (!testmode) {
                 unsigned pin_map;
 
-                outb_p(0xE6,IO_INDEX_PORT);
-                outb_p(0x0A,IO_DATA_PORT);
-                outb_p(0x2C,IO_INDEX_PORT);
+                outb_p(0xE6, IO_INDEX_PORT);
+                outb_p(0x0A, IO_DATA_PORT);
+                outb_p(0x2C, IO_INDEX_PORT);
                 pin_map = inb_p(IO_DATA_PORT);
                 pin_map |= 0x10;
                 pin_map &= ~(0x20);
-                outb_p(0x2C,IO_INDEX_PORT);
-                outb_p(pin_map,IO_DATA_PORT);
+                outb_p(0x2C, IO_INDEX_PORT);
+                outb_p(pin_map, IO_DATA_PORT);
         }
-        outb_p(0xE3,IO_INDEX_PORT);
-        outb_p(0x08,IO_DATA_PORT);
+        outb_p(0xE3, IO_INDEX_PORT);
+        outb_p(0x08, IO_DATA_PORT);
 
         /* Set device Aux1 active */
-        outb_p(0x30,IO_INDEX_PORT);
-        outb_p(0x01,IO_DATA_PORT);
+        outb_p(0x30, IO_INDEX_PORT);
+        outb_p(0x01, IO_DATA_PORT);
 
         /* Lock the SuperIO chip */
-        outb_p(LOCK_DATA,IO_INDEX_PORT);
+        outb_p(LOCK_DATA, IO_INDEX_PORT);
 
         spin_unlock_irqrestore(&spinlock, flags);
 
@@ -144,42 +147,41 @@ static int wdt_stop(void)
         spin_lock_irqsave(&spinlock, flags);
 
         /* Unlock the SuperIO chip */
-        outb_p(UNLOCK_DATA,IO_INDEX_PORT);
-        outb_p(UNLOCK_DATA,IO_INDEX_PORT);
+        outb_p(UNLOCK_DATA, IO_INDEX_PORT);
+        outb_p(UNLOCK_DATA, IO_INDEX_PORT);
 
-        /* 
+        /*
          * Select device Aux2 (device=8) to set watchdog regs F2, F3 and F4.
          * F2 is reset to its default value (watchdog timer disabled).
          * F3 is reset to its default state.
          * F4 clears the TIMEOUT'ed state (bit 0) - back to default.
          */
-        outb_p(DEVICE_REGISTER,IO_INDEX_PORT);
-        outb_p(0x08,IO_DATA_PORT);
-        outb_p(0xF2,IO_INDEX_PORT);
-        outb_p(0xFF,IO_DATA_PORT);
-        outb_p(0xF3,IO_INDEX_PORT);
-        outb_p(0x00,IO_DATA_PORT);
-        outb_p(0xF4,IO_INDEX_PORT);
-        outb_p(0x00,IO_DATA_PORT);
-        outb_p(0xF2,IO_INDEX_PORT);
-        outb_p(0x00,IO_DATA_PORT);
+        outb_p(DEVICE_REGISTER, IO_INDEX_PORT);
+        outb_p(0x08, IO_DATA_PORT);
+        outb_p(0xF2, IO_INDEX_PORT);
+        outb_p(0xFF, IO_DATA_PORT);
+        outb_p(0xF3, IO_INDEX_PORT);
+        outb_p(0x00, IO_DATA_PORT);
+        outb_p(0xF4, IO_INDEX_PORT);
+        outb_p(0x00, IO_DATA_PORT);
+        outb_p(0xF2, IO_INDEX_PORT);
+        outb_p(0x00, IO_DATA_PORT);
 
         /*
-         * Select device Aux1 (dev=7) to set GP16 (in reg E6) and 
+         * Select device Aux1 (dev=7) to set GP16 (in reg E6) and
          * Gp13 (in reg E3) as inputs.
          */
-        outb_p(DEVICE_REGISTER,IO_INDEX_PORT);
-        outb_p(0x07,IO_DATA_PORT);
-        if (!testmode)
-        {
-                outb_p(0xE6,IO_INDEX_PORT);
-                outb_p(0x01,IO_DATA_PORT);
+        outb_p(DEVICE_REGISTER, IO_INDEX_PORT);
+        outb_p(0x07, IO_DATA_PORT);
+        if (!testmode) {
+                outb_p(0xE6, IO_INDEX_PORT);
+                outb_p(0x01, IO_DATA_PORT);
         }
-        outb_p(0xE3,IO_INDEX_PORT);
-        outb_p(0x01,IO_DATA_PORT);
+        outb_p(0xE3, IO_INDEX_PORT);
+        outb_p(0x01, IO_DATA_PORT);
 
         /* Lock the SuperIO chip */
-        outb_p(LOCK_DATA,IO_INDEX_PORT);
+        outb_p(LOCK_DATA, IO_INDEX_PORT);
 
         spin_unlock_irqrestore(&spinlock, flags);
 
@@ -200,17 +202,17 @@ static int wdt_keepalive(void)
         spin_lock_irqsave(&spinlock, flags);
 
         /* Unlock the SuperIO chip */
-        outb_p(UNLOCK_DATA,IO_INDEX_PORT);
-        outb_p(UNLOCK_DATA,IO_INDEX_PORT);
+        outb_p(UNLOCK_DATA, IO_INDEX_PORT);
+        outb_p(UNLOCK_DATA, IO_INDEX_PORT);
 
         /* Select device Aux2 (device=8) to kick watchdog reg F2 */
-        outb_p(DEVICE_REGISTER,IO_INDEX_PORT);
-        outb_p(0x08,IO_DATA_PORT);
-        outb_p(0xF2,IO_INDEX_PORT);
-        outb_p(timeoutW,IO_DATA_PORT);
+        outb_p(DEVICE_REGISTER, IO_INDEX_PORT);
+        outb_p(0x08, IO_DATA_PORT);
+        outb_p(0xF2, IO_INDEX_PORT);
+        outb_p(timeoutW, IO_DATA_PORT);
 
         /* Lock the SuperIO chip */
-        outb_p(LOCK_DATA,IO_INDEX_PORT);
+        outb_p(LOCK_DATA, IO_INDEX_PORT);
 
         spin_unlock_irqrestore(&spinlock, flags);
 
@@ -227,7 +229,7 @@ static int wdt_set_timeout(int t)
 
         /*
          * Convert seconds to watchdog counter time units, rounding up.
-         * On PCM-5335 watchdog units are 30 seconds/step with 15 sec startup 
+         * On PCM-5335 watchdog units are 30 seconds/step with 15 sec startup
          * value. This information is supplied in the PCM-5335 manual and was
          * checked by me on a real board. This is a bit strange because W83977f
          * datasheet says counter unit is in minutes!
@@ -241,7 +243,7 @@ static int wdt_set_timeout(int t)
                 return -EINVAL;
 
         /*
-         * timeout is the timeout in seconds, 
+         * timeout is the timeout in seconds,
          * timeoutW is the timeout in watchdog counter units.
          */
         timeoutW = tmrval;
@@ -261,17 +263,17 @@ static int wdt_get_status(int *status)
         spin_lock_irqsave(&spinlock, flags);
 
         /* Unlock the SuperIO chip */
-        outb_p(UNLOCK_DATA,IO_INDEX_PORT);
-        outb_p(UNLOCK_DATA,IO_INDEX_PORT);
+        outb_p(UNLOCK_DATA, IO_INDEX_PORT);
+        outb_p(UNLOCK_DATA, IO_INDEX_PORT);
 
         /* Select device Aux2 (device=8) to read watchdog reg F4 */
-        outb_p(DEVICE_REGISTER,IO_INDEX_PORT);
-        outb_p(0x08,IO_DATA_PORT);
-        outb_p(0xF4,IO_INDEX_PORT);
+        outb_p(DEVICE_REGISTER, IO_INDEX_PORT);
+        outb_p(0x08, IO_DATA_PORT);
+        outb_p(0xF4, IO_INDEX_PORT);
         new_status = inb_p(IO_DATA_PORT);
 
         /* Lock the SuperIO chip */
-        outb_p(LOCK_DATA,IO_INDEX_PORT);
+        outb_p(LOCK_DATA, IO_INDEX_PORT);
 
         spin_unlock_irqrestore(&spinlock, flags);
 
@@ -290,7 +292,7 @@ static int wdt_get_status(int *status)
 static int wdt_open(struct inode *inode, struct file *file)
 {
         /* If the watchdog is alive we don't need to start it again */
-        if( test_and_set_bit(0, &timer_alive) )
+        if (test_and_set_bit(0, &timer_alive))
                 return -EBUSY;
 
         if (nowayout)
@@ -306,13 +308,13 @@ static int wdt_release(struct inode *inode, struct file *file)
          * Shut off the timer.
          * Lock it in if it's a module and we set nowayout
          */
-        if (expect_close == 42)
-        {
+        if (expect_close == 42) {
                 wdt_stop();
                 clear_bit(0, &timer_alive);
         } else {
                 wdt_keepalive();
-                printk(KERN_CRIT PFX "unexpected close, not stopping watchdog!\n");
+                printk(KERN_CRIT PFX
+                        "unexpected close, not stopping watchdog!\n");
         }
         expect_close = 0;
         return 0;
@@ -333,24 +335,22 @@ static ssize_t wdt_write(struct file *file, const char __user *buf,
                             size_t count, loff_t *ppos)
 {
         /* See if we got the magic character 'V' and reload the timer */
-        if(count)
-        {
-                if (!nowayout)
-                {
+        if (count) {
+                if (!nowayout) {
                         size_t ofs;
 
-                        /* note: just in case someone wrote the magic character long ago */
+                        /* note: just in case someone wrote the
+                           magic character long ago */
                         expect_close = 0;
 
-                        /* scan to see whether or not we got the magic character */
-                        for(ofs = 0; ofs != count; ofs++)
-                        {
+                        /* scan to see whether or not we got the
+                           magic character */
+                        for (ofs = 0; ofs != count; ofs++) {
                                 char c;
                                 if (get_user(c, buf + ofs))
                                         return -EFAULT;
-                                if (c == 'V') {
+                                if (c == 'V')
                                         expect_close = 42;
-                                }
                         }
                 }
 
@@ -377,8 +377,7 @@ static struct watchdog_info ident = {
         .identity = WATCHDOG_NAME,
 };
 
-static int wdt_ioctl(struct inode *inode, struct file *file,
-        unsigned int cmd, unsigned long arg)
+static long wdt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
         int status;
         int new_options, retval = -EINVAL;
@@ -390,13 +389,10 @@ static int wdt_ioctl(struct inode *inode, struct file *file,
 
         uarg.i = (int __user *)arg;
 
-        switch(cmd)
-        {
-        default:
-                return -ENOTTY;
-
+        switch (cmd) {
         case WDIOC_GETSUPPORT:
-                return copy_to_user(uarg.ident, &ident, sizeof(ident)) ? -EFAULT : 0;
+                return copy_to_user(uarg.ident, &ident,
+                                                sizeof(ident)) ? -EFAULT : 0;
 
         case WDIOC_GETSTATUS:
                 wdt_get_status(&status);
@@ -405,12 +401,8 @@ static int wdt_ioctl(struct inode *inode, struct file *file,
         case WDIOC_GETBOOTSTATUS:
                 return put_user(0, uarg.i);
 
-        case WDIOC_KEEPALIVE:
-                wdt_keepalive();
-                return 0;
-
         case WDIOC_SETOPTIONS:
-                if (get_user (new_options, uarg.i))
+                if (get_user(new_options, uarg.i))
                         return -EFAULT;
 
                 if (new_options & WDIOS_DISABLECARD) {
@@ -425,6 +417,10 @@ static int wdt_ioctl(struct inode *inode, struct file *file,
 
                 return retval;
 
+        case WDIOC_KEEPALIVE:
+                wdt_keepalive();
+                return 0;
+
         case WDIOC_SETTIMEOUT:
                 if (get_user(new_timeout, uarg.i))
                         return -EFAULT;
@@ -438,29 +434,30 @@ static int wdt_ioctl(struct inode *inode, struct file *file,
         case WDIOC_GETTIMEOUT:
                 return put_user(timeout, uarg.i);
 
+        default:
+                return -ENOTTY;
+
         }
 }
 
 static int wdt_notify_sys(struct notifier_block *this, unsigned long code,
         void *unused)
 {
-        if (code==SYS_DOWN || code==SYS_HALT)
+        if (code == SYS_DOWN || code == SYS_HALT)
                 wdt_stop();
         return NOTIFY_DONE;
 }
 
-static const struct file_operations wdt_fops=
-{
+static const struct file_operations wdt_fops = {
         .owner          = THIS_MODULE,
         .llseek         = no_llseek,
         .write          = wdt_write,
-        .ioctl          = wdt_ioctl,
+        .unlocked_ioctl = wdt_ioctl,
         .open           = wdt_open,
         .release        = wdt_release,
 };
 
-static struct miscdevice wdt_miscdev=
-{
+static struct miscdevice wdt_miscdev = {
         .minor          = WATCHDOG_MINOR,
         .name           = "watchdog",
         .fops           = &wdt_fops,
@@ -474,20 +471,20 @@ static int __init w83977f_wdt_init(void)
 {
         int rc;
 
-        printk(KERN_INFO PFX DRIVER_VERSION);
+        printk(KERN_INFO PFX DRIVER_VERSION);
 
         /*
-         * Check that the timeout value is within it's range ; 
+         * Check that the timeout value is within it's range;
          * if not reset to the default
          */
         if (wdt_set_timeout(timeout)) {
                 wdt_set_timeout(DEFAULT_TIMEOUT);
-                printk(KERN_INFO PFX "timeout value must be 15<=timeout<=7635, using %d\n",
-                        DEFAULT_TIMEOUT);
+                printk(KERN_INFO PFX
+                    "timeout value must be 15 <= timeout <= 7635, using %d\n",
+                                                        DEFAULT_TIMEOUT);
         }
 
-        if (!request_region(IO_INDEX_PORT, 2, WATCHDOG_NAME))
-        {
+        if (!request_region(IO_INDEX_PORT, 2, WATCHDOG_NAME)) {
                 printk(KERN_ERR PFX "I/O address 0x%04x already in use\n",
                         IO_INDEX_PORT);
                 rc = -EIO;
@@ -495,30 +492,30 @@ static int __init w83977f_wdt_init(void)
         }
 
         rc = register_reboot_notifier(&wdt_notifier);
-        if (rc)
-        {
-                printk(KERN_ERR PFX "cannot register reboot notifier (err=%d)\n",
-                        rc);
+        if (rc) {
+                printk(KERN_ERR PFX
+                        "cannot register reboot notifier (err=%d)\n", rc);
                 goto err_out_region;
         }
 
         rc = misc_register(&wdt_miscdev);
-        if (rc)
-        {
-                printk(KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",
-                        wdt_miscdev.minor, rc);
+        if (rc) {
+                printk(KERN_ERR PFX
+                        "cannot register miscdev on minor=%d (err=%d)\n",
+                                                wdt_miscdev.minor, rc);
                 goto err_out_reboot;
         }
 
-        printk(KERN_INFO PFX "initialized. timeout=%d sec (nowayout=%d testmode=%d)\n",
-                timeout, nowayout, testmode);
+        printk(KERN_INFO PFX
+                "initialized. timeout=%d sec (nowayout=%d testmode=%d)\n",
+                                        timeout, nowayout, testmode);
 
         return 0;
 
 err_out_reboot:
         unregister_reboot_notifier(&wdt_notifier);
 err_out_region:
-        release_region(IO_INDEX_PORT,2);
+        release_region(IO_INDEX_PORT, 2);
 err_out:
         return rc;
 }
@@ -528,7 +525,7 @@ static void __exit w83977f_wdt_exit(void)
         wdt_stop();
         misc_deregister(&wdt_miscdev);
         unregister_reboot_notifier(&wdt_notifier);
-        release_region(IO_INDEX_PORT,2);
+        release_region(IO_INDEX_PORT, 2);
 }
 
 module_init(w83977f_wdt_init);
diff --git a/drivers/watchdog/wafer5823wdt.c b/drivers/watchdog/wafer5823wdt.c
index 9e368091f799..68377ae171ff 100644
--- a/drivers/watchdog/wafer5823wdt.c
+++ b/drivers/watchdog/wafer5823wdt.c
@@ -1,11 +1,11 @@
 /*
  *      ICP Wafer 5823 Single Board Computer WDT driver
- *      http://www.icpamerica.com/wafer_5823.php
- *      May also work on other similar models
+ *      http://www.icpamerica.com/wafer_5823.php
+ *      May also work on other similar models
  *
  *      (c) Copyright 2002 Justin Cormack <justin@street-vision.com>
  *
- *      Release 0.02
+ *      Release 0.02
  *
  *      Based on advantechwdt.c which is based on wdt.c.
  *      Original copyright messages:
@@ -36,8 +36,8 @@
 #include <linux/reboot.h>
 #include <linux/init.h>
 #include <linux/spinlock.h>
-#include <asm/io.h>
-#include <asm/uaccess.h>
+#include <linux/io.h>
+#include <linux/uaccess.h>
 
 #define WATCHDOG_NAME "Wafer 5823 WDT"
 #define PFX WATCHDOG_NAME ": "
@@ -50,10 +50,10 @@ static DEFINE_SPINLOCK(wafwdt_lock);
 /*
  *      You must set these - there is no sane way to probe for this board.
  *
- *      To enable, write the timeout value in seconds (1 to 255) to I/O
- *      port WDT_START, then read the port to start the watchdog. To pat
- *      the dog, read port WDT_STOP to stop the timer, then read WDT_START
- *      to restart it again.
+ *      To enable, write the timeout value in seconds (1 to 255) to I/O
+ *      port WDT_START, then read the port to start the watchdog. To pat
+ *      the dog, read port WDT_STOP to stop the timer, then read WDT_START
+ *      to restart it again.
  */
 
 static int wdt_stop = 0x843;
@@ -61,11 +61,15 @@ static int wdt_start = 0x443;
 
 static int timeout = WD_TIMO;  /* in seconds */
 module_param(timeout, int, 0);
-MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds. 1<= timeout <=255, default=" __MODULE_STRING(WD_TIMO) ".");
+MODULE_PARM_DESC(timeout,
+                "Watchdog timeout in seconds. 1 <= timeout <= 255, default="
+                                __MODULE_STRING(WD_TIMO) ".");
 
 static int nowayout = WATCHDOG_NOWAYOUT;
 module_param(nowayout, int, 0);
-MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+MODULE_PARM_DESC(nowayout,
+                "Watchdog cannot be stopped once started (default="
+                                __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 
 static void wafwdt_ping(void)
 {
@@ -83,14 +87,14 @@ static void wafwdt_start(void)
         inb_p(wdt_start);
 }
 
-static void
-wafwdt_stop(void)
+static void wafwdt_stop(void)
 {
         /* stop watchdog */
         inb_p(wdt_stop);
 }
 
-static ssize_t wafwdt_write(struct file *file, const char __user *buf, size_t count, loff_t * ppos)
+static ssize_t wafwdt_write(struct file *file, const char __user *buf,
+                                                size_t count, loff_t *ppos)
 {
         /* See if we got the magic character 'V' and reload the timer */
         if (count) {
@@ -100,7 +104,8 @@ static ssize_t wafwdt_write(struct file *file, const char __user *buf, size_t co
                         /* In case it was set long ago */
                         expect_close = 0;
 
-                        /* scan to see whether or not we got the magic character */
+                        /* scan to see whether or not we got the magic
+                           character */
                         for (i = 0; i != count; i++) {
                                 char c;
                                 if (get_user(c, buf + i))
@@ -109,27 +114,29 @@ static ssize_t wafwdt_write(struct file *file, const char __user *buf, size_t co
                                         expect_close = 42;
                         }
                 }
-                /* Well, anyhow someone wrote to us, we should return that favour */
+                /* Well, anyhow someone wrote to us, we should
+                   return that favour */
                 wafwdt_ping();
         }
         return count;
 }
 
-static int wafwdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
-             unsigned long arg)
+static long wafwdt_ioctl(struct file *file, unsigned int cmd,
+                                                        unsigned long arg)
 {
         int new_timeout;
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
-        static struct watchdog_info ident = {
-                .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE,
+        static const struct watchdog_info ident = {
+                .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT |
+                                                        WDIOF_MAGICCLOSE,
                 .firmware_version = 1,
                 .identity = "Wafer 5823 WDT",
         };
 
         switch (cmd) {
         case WDIOC_GETSUPPORT:
-                if (copy_to_user(argp, &ident, sizeof (ident)))
+                if (copy_to_user(argp, &ident, sizeof(ident)))
                         return -EFAULT;
                 break;
 
@@ -137,22 +144,6 @@ static int wafwdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd
         case WDIOC_GETBOOTSTATUS:
                 return put_user(0, p);
 
-        case WDIOC_KEEPALIVE:
-                wafwdt_ping();
-                break;
-
-        case WDIOC_SETTIMEOUT:
-                if (get_user(new_timeout, p))
-                        return -EFAULT;
-                if ((new_timeout < 1) || (new_timeout > 255))
-                        return -EINVAL;
-                timeout = new_timeout;
-                wafwdt_stop();
-                wafwdt_start();
-                /* Fall */
-        case WDIOC_GETTIMEOUT:
-                return put_user(timeout, p);
-
         case WDIOC_SETOPTIONS:
         {
                 int options, retval = -EINVAL;
@@ -173,6 +164,22 @@ static int wafwdt_ioctl(struct inode *inode, struct file *file, unsigned int cmd
                 return retval;
         }
 
+        case WDIOC_KEEPALIVE:
+                wafwdt_ping();
+                break;
+
+        case WDIOC_SETTIMEOUT:
+                if (get_user(new_timeout, p))
+                        return -EFAULT;
+                if ((new_timeout < 1) || (new_timeout > 255))
+                        return -EINVAL;
+                timeout = new_timeout;
+                wafwdt_stop();
+                wafwdt_start();
+                /* Fall */
+        case WDIOC_GETTIMEOUT:
+                return put_user(timeout, p);
+
         default:
                 return -ENOTTY;
         }
@@ -191,13 +198,13 @@ static int wafwdt_open(struct inode *inode, struct file *file)
         return nonseekable_open(inode, file);
 }
 
-static int
-wafwdt_close(struct inode *inode, struct file *file)
+static int wafwdt_close(struct inode *inode, struct file *file)
 {
-        if (expect_close == 42) {
+        if (expect_close == 42)
                 wafwdt_stop();
-        } else {
-                printk(KERN_CRIT PFX "WDT device closed unexpectedly.  WDT will not stop!\n");
+        else {
+                printk(KERN_CRIT PFX
+                    "WDT device closed unexpectedly.  WDT will not stop!\n");
                 wafwdt_ping();
         }
         clear_bit(0, &wafwdt_is_open);
@@ -209,12 +216,11 @@ wafwdt_close(struct inode *inode, struct file *file)
  *      Notifier for system down
  */
 
-static int wafwdt_notify_sys(struct notifier_block *this, unsigned long code, void *unused)
+static int wafwdt_notify_sys(struct notifier_block *this, unsigned long code,
+                                                                void *unused)
 {
-        if (code == SYS_DOWN || code == SYS_HALT) {
-                /* Turn the WDT off */
+        if (code == SYS_DOWN || code == SYS_HALT)
                 wafwdt_stop();
-        }
         return NOTIFY_DONE;
 }
 
@@ -226,7 +232,7 @@ static const struct file_operations wafwdt_fops = {
         .owner          = THIS_MODULE,
         .llseek         = no_llseek,
         .write          = wafwdt_write,
-        .ioctl          = wafwdt_ioctl,
+        .unlocked_ioctl = wafwdt_ioctl,
         .open           = wafwdt_open,
         .release        = wafwdt_close,
 };
@@ -250,25 +256,28 @@ static int __init wafwdt_init(void)
 {
         int ret;
 
-        printk(KERN_INFO "WDT driver for Wafer 5823 single board computer initialising.\n");
+        printk(KERN_INFO
+          "WDT driver for Wafer 5823 single board computer initialising.\n");
 
         if (timeout < 1 || timeout > 255) {
                 timeout = WD_TIMO;
-                printk (KERN_INFO PFX "timeout value must be 1<=x<=255, using %d\n",
-                        timeout);
+                printk(KERN_INFO PFX
+                        "timeout value must be 1 <= x <= 255, using %d\n",
+                                                                timeout);
         }
 
         if (wdt_stop != wdt_start) {
-                if(!request_region(wdt_stop, 1, "Wafer 5823 WDT")) {
-                        printk (KERN_ERR PFX "I/O address 0x%04x already in use\n",
-                        wdt_stop);
+                if (!request_region(wdt_stop, 1, "Wafer 5823 WDT")) {
+                        printk(KERN_ERR PFX
+                                "I/O address 0x%04x already in use\n",
+                                                                wdt_stop);
                         ret = -EIO;
                         goto error;
                 }
         }
 
-        if(!request_region(wdt_start, 1, "Wafer 5823 WDT")) {
-                printk (KERN_ERR PFX "I/O address 0x%04x already in use\n",
+        if (!request_region(wdt_start, 1, "Wafer 5823 WDT")) {
+                printk(KERN_ERR PFX "I/O address 0x%04x already in use\n",
                         wdt_start);
                 ret = -EIO;
                 goto error2;
@@ -276,19 +285,20 @@ static int __init wafwdt_init(void)
 
         ret = register_reboot_notifier(&wafwdt_notifier);
         if (ret != 0) {
-                printk (KERN_ERR PFX "cannot register reboot notifier (err=%d)\n",
-                        ret);
+                printk(KERN_ERR PFX
+                        "cannot register reboot notifier (err=%d)\n", ret);
                 goto error3;
         }
 
         ret = misc_register(&wafwdt_miscdev);
         if (ret != 0) {
-                printk (KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",
-                        WATCHDOG_MINOR, ret);
+                printk(KERN_ERR PFX
+                        "cannot register miscdev on minor=%d (err=%d)\n",
+                                                WATCHDOG_MINOR, ret);
                 goto error4;
         }
 
-        printk (KERN_INFO PFX "initialized. timeout=%d sec (nowayout=%d)\n",
+        printk(KERN_INFO PFX "initialized. timeout=%d sec (nowayout=%d)\n",
                 timeout, nowayout);
 
         return ret;
@@ -307,7 +317,7 @@ static void __exit wafwdt_exit(void)
 {
         misc_deregister(&wafwdt_miscdev);
         unregister_reboot_notifier(&wafwdt_notifier);
-        if(wdt_stop != wdt_start)
+        if (wdt_stop != wdt_start)
                 release_region(wdt_stop, 1);
         release_region(wdt_start, 1);
 }
diff --git a/drivers/watchdog/wd501p.h b/drivers/watchdog/wd501p.h
index a4504f40394d..db34853c28ae 100644
--- a/drivers/watchdog/wd501p.h
+++ b/drivers/watchdog/wd501p.h
@@ -12,7 +12,7 @@
  *      http://www.cymru.net
  *
  *      This driver is provided under the GNU General Public License, incorporated
- *      herein by reference. The driver is provided without warranty or 
+ *      herein by reference. The driver is provided without warranty or
  *      support.
  *
  *      Release 0.04.
diff --git a/drivers/watchdog/wdrtas.c b/drivers/watchdog/wdrtas.c
index 1d64e277567d..5d3b1a8e28b0 100644
--- a/drivers/watchdog/wdrtas.c
+++ b/drivers/watchdog/wdrtas.c
@@ -35,9 +35,9 @@
 #include <linux/reboot.h>
 #include <linux/types.h>
 #include <linux/watchdog.h>
+#include <linux/uaccess.h>
 
 #include <asm/rtas.h>
-#include <asm/uaccess.h>
 
 #define WDRTAS_MAGIC_CHAR               42
 #define WDRTAS_SUPPORTED_MASK           (WDIOF_SETTIMEOUT | \
@@ -56,7 +56,7 @@ static int wdrtas_nowayout = 0;
 #endif
 
 static atomic_t wdrtas_miscdev_open = ATOMIC_INIT(0);
-static char wdrtas_expect_close = 0;
+static char wdrtas_expect_close;
 
 static int wdrtas_interval;
 
@@ -86,8 +86,8 @@ static char wdrtas_logbuffer[WDRTAS_LOGBUFFER_LEN];
  * RTAS function set-indicator (surveillance). The unit of interval is
  * seconds.
  */
-static int
-wdrtas_set_interval(int interval)
+
+static int wdrtas_set_interval(int interval)
 {
         long result;
         static int print_msg = 10;
@@ -97,7 +97,7 @@ wdrtas_set_interval(int interval)
 
         result = rtas_call(wdrtas_token_set_indicator, 3, 1, NULL,
                            WDRTAS_SURVEILLANCE_IND, 0, interval);
-        if ( (result < 0) && (print_msg) ) {
+        if (result < 0 && print_msg) {
                 printk(KERN_ERR "wdrtas: setting the watchdog to %i "
                        "timeout failed: %li\n", interval, result);
                 print_msg--;
@@ -116,16 +116,14 @@ wdrtas_set_interval(int interval)
  * as reported by the RTAS function ibm,get-system-parameter. The unit
  * of the return value is seconds.
  */
-static int
-wdrtas_get_interval(int fallback_value)
+static int wdrtas_get_interval(int fallback_value)
 {
         long result;
         char value[4];
 
         result = rtas_call(wdrtas_token_get_sp, 3, 1, NULL,
                            WDRTAS_SP_SPI, (void *)__pa(&value), 4);
-        if ( (value[0] != 0) || (value[1] != 2) || (value[3] != 0) ||
-             (result < 0) ) {
+        if (value[0] != 0 || value[1] != 2 || value[3] != 0 || result < 0) {
                 printk(KERN_WARNING "wdrtas: could not get sp_spi watchdog "
                        "timeout (%li). Continuing\n", result);
                 return fallback_value;
@@ -141,8 +139,7 @@ wdrtas_get_interval(int fallback_value)
  * wdrtas_timer_start starts the watchdog by calling the RTAS function
  * set-interval (surveillance)
  */
-static void
-wdrtas_timer_start(void)
+static void wdrtas_timer_start(void)
 {
         wdrtas_set_interval(wdrtas_interval);
 }
@@ -153,8 +150,7 @@ wdrtas_timer_start(void)
  * wdrtas_timer_stop stops the watchdog timer by calling the RTAS function
  * set-interval (surveillance)
  */
-static void
-wdrtas_timer_stop(void)
+static void wdrtas_timer_stop(void)
 {
         wdrtas_set_interval(0);
 }
@@ -165,8 +161,7 @@ wdrtas_timer_stop(void)
  * wdrtas_log_scanned_event prints a message to the log buffer dumping
  * the results of the last event-scan call
  */
-static void
-wdrtas_log_scanned_event(void)
+static void wdrtas_log_scanned_event(void)
 {
         int i;
 
@@ -175,13 +170,13 @@ wdrtas_log_scanned_event(void)
                        "%02x %02x %02x %02x  %02x %02x %02x %02x   "
                        "%02x %02x %02x %02x  %02x %02x %02x %02x\n",
                        (i / 16) + 1, (WDRTAS_LOGBUFFER_LEN / 16),
-                       wdrtas_logbuffer[i + 0], wdrtas_logbuffer[i + 1], 
-                       wdrtas_logbuffer[i + 2], wdrtas_logbuffer[i + 3], 
-                       wdrtas_logbuffer[i + 4], wdrtas_logbuffer[i + 5], 
-                       wdrtas_logbuffer[i + 6], wdrtas_logbuffer[i + 7], 
-                       wdrtas_logbuffer[i + 8], wdrtas_logbuffer[i + 9], 
-                       wdrtas_logbuffer[i + 10], wdrtas_logbuffer[i + 11], 
-                       wdrtas_logbuffer[i + 12], wdrtas_logbuffer[i + 13], 
+                       wdrtas_logbuffer[i + 0], wdrtas_logbuffer[i + 1],
+                       wdrtas_logbuffer[i + 2], wdrtas_logbuffer[i + 3],
+                       wdrtas_logbuffer[i + 4], wdrtas_logbuffer[i + 5],
+                       wdrtas_logbuffer[i + 6], wdrtas_logbuffer[i + 7],
+                       wdrtas_logbuffer[i + 8], wdrtas_logbuffer[i + 9],
+                       wdrtas_logbuffer[i + 10], wdrtas_logbuffer[i + 11],
+                       wdrtas_logbuffer[i + 12], wdrtas_logbuffer[i + 13],
                        wdrtas_logbuffer[i + 14], wdrtas_logbuffer[i + 15]);
 }
 
@@ -192,8 +187,7 @@ wdrtas_log_scanned_event(void)
  * RTAS function event-scan and repeats these calls as long as there are
  * events available. All events will be dumped.
  */
-static void
-wdrtas_timer_keepalive(void)
+static void wdrtas_timer_keepalive(void)
 {
         long result;
 
@@ -218,8 +212,7 @@ wdrtas_timer_keepalive(void)
  * wdrtas_get_temperature returns the current temperature in Fahrenheit. It
  * uses the RTAS call get-sensor-state, token 3 to do so
  */
-static int
-wdrtas_get_temperature(void)
+static int wdrtas_get_temperature(void)
 {
         long result;
         int temperature = 0;
@@ -243,8 +236,7 @@ wdrtas_get_temperature(void)
  * returns a bitmask of defines WDIOF_... as defined in
  * include/linux/watchdog.h
  */
-static int
-wdrtas_get_status(void)
+static int wdrtas_get_status(void)
 {
         return 0; /* TODO */
 }
@@ -255,8 +247,7 @@ wdrtas_get_status(void)
  * returns a bitmask of defines WDIOF_... as defined in
  * include/linux/watchdog.h, indicating why the watchdog rebooted the system
  */
-static int
-wdrtas_get_boot_status(void)
+static int wdrtas_get_boot_status(void)
 {
         return 0; /* TODO */
 }
@@ -276,8 +267,7 @@ wdrtas_get_boot_status(void)
  * character 'V'. This character allows the watchdog device to be closed
  * properly.
  */
-static ssize_t
-wdrtas_write(struct file *file, const char __user *buf,
+static ssize_t wdrtas_write(struct file *file, const char __user *buf,
              size_t len, loff_t *ppos)
 {
         int i;
@@ -306,7 +296,6 @@ out:
 
 /**
  * wdrtas_ioctl - ioctl function for the watchdog device
- * @inode: inode structure
  * @file: file structure
  * @cmd: command for ioctl
  * @arg: argument pointer
@@ -315,16 +304,16 @@ out:
  *
  * wdrtas_ioctl implements the watchdog API ioctls
  */
-static int
-wdrtas_ioctl(struct inode *inode, struct file *file,
-             unsigned int cmd, unsigned long arg)
+
+static long wdrtas_ioctl(struct file *file, unsigned int cmd,
+                                                        unsigned long arg)
 {
         int __user *argp = (void __user *)arg;
         int i;
         static struct watchdog_info wdinfo = {
                 .options = WDRTAS_SUPPORTED_MASK,
                 .firmware_version = 0,
-                .identity = "wdrtas"
+                .identity = "wdrtas",
         };
 
         switch (cmd) {
@@ -357,9 +346,9 @@ wdrtas_ioctl(struct inode *inode, struct file *file,
                         wdrtas_timer_keepalive();
                         wdrtas_timer_start();
                 }
+                /* not implemented. Done by H8
                 if (i & WDIOS_TEMPPANIC) {
-                        /* not implemented. Done by H8 */
-                }
+                } */
                 return 0;
 
         case WDIOC_KEEPALIVE:
@@ -399,8 +388,7 @@ wdrtas_ioctl(struct inode *inode, struct file *file,
  *
  * function called when watchdog device is opened
  */
-static int
-wdrtas_open(struct inode *inode, struct file *file)
+static int wdrtas_open(struct inode *inode, struct file *file)
 {
         /* only open once */
         if (atomic_inc_return(&wdrtas_miscdev_open) > 1) {
@@ -423,8 +411,7 @@ wdrtas_open(struct inode *inode, struct file *file)
  *
  * close function. Always succeeds
  */
-static int
-wdrtas_close(struct inode *inode, struct file *file)
+static int wdrtas_close(struct inode *inode, struct file *file)
 {
         /* only stop watchdog, if this was announced using 'V' before */
         if (wdrtas_expect_close == WDRTAS_MAGIC_CHAR)
@@ -453,8 +440,7 @@ wdrtas_close(struct inode *inode, struct file *file)
  * wdrtas_temp_read gives the temperature to the users by copying this
  * value as one byte into the user space buffer. The unit is Fahrenheit...
  */
-static ssize_t
-wdrtas_temp_read(struct file *file, char __user *buf,
+static ssize_t wdrtas_temp_read(struct file *file, char __user *buf,
                  size_t count, loff_t *ppos)
 {
         int temperature = 0;
@@ -478,8 +464,7 @@ wdrtas_temp_read(struct file *file, char __user *buf,
  *
  * function called when temperature device is opened
  */
-static int
-wdrtas_temp_open(struct inode *inode, struct file *file)
+static int wdrtas_temp_open(struct inode *inode, struct file *file)
 {
         return nonseekable_open(inode, file);
 }
@@ -493,8 +478,7 @@ wdrtas_temp_open(struct inode *inode, struct file *file)
  *
  * close function. Always succeeds
  */
-static int
-wdrtas_temp_close(struct inode *inode, struct file *file)
+static int wdrtas_temp_close(struct inode *inode, struct file *file)
 {
         return 0;
 }
@@ -509,10 +493,10 @@ wdrtas_temp_close(struct inode *inode, struct file *file)
  *
  * wdrtas_reboot stops the watchdog in case of a reboot
  */
-static int
-wdrtas_reboot(struct notifier_block *this, unsigned long code, void *ptr)
+static int wdrtas_reboot(struct notifier_block *this,
+                                        unsigned long code, void *ptr)
 {
-        if ( (code==SYS_DOWN) || (code==SYS_HALT) )
+        if (code == SYS_DOWN || code == SYS_HALT)
                 wdrtas_timer_stop();
 
         return NOTIFY_DONE;
@@ -524,7 +508,7 @@ static const struct file_operations wdrtas_fops = {
         .owner          = THIS_MODULE,
         .llseek         = no_llseek,
         .write          = wdrtas_write,
-        .ioctl          = wdrtas_ioctl,
+        .unlocked_ioctl = wdrtas_ioctl,
         .open           = wdrtas_open,
         .release        = wdrtas_close,
 };
@@ -562,8 +546,7 @@ static struct notifier_block wdrtas_notifier = {
  * this watchdog driver. It tolerates, if "get-sensor-state" and
  * "ibm,get-system-parameter" are not available.
  */
-static int
-wdrtas_get_tokens(void)
+static int wdrtas_get_tokens(void)
 {
         wdrtas_token_get_sensor_state = rtas_token("get-sensor-state");
         if (wdrtas_token_get_sensor_state == RTAS_UNKNOWN_SERVICE) {
@@ -603,8 +586,7 @@ wdrtas_get_tokens(void)
  * wdrtas_register_devs unregisters the watchdog and temperature watchdog
  * misc devs
  */
-static void
-wdrtas_unregister_devs(void)
+static void wdrtas_unregister_devs(void)
 {
         misc_deregister(&wdrtas_miscdev);
         if (wdrtas_token_get_sensor_state != RTAS_UNKNOWN_SERVICE)
@@ -619,8 +601,7 @@ wdrtas_unregister_devs(void)
  * wdrtas_register_devs registers the watchdog and temperature watchdog
  * misc devs
  */
-static int
-wdrtas_register_devs(void)
+static int wdrtas_register_devs(void)
 {
         int result;
 
@@ -651,8 +632,7 @@ wdrtas_register_devs(void)
  *
  * registers the file handlers and the reboot notifier
  */
-static int __init
-wdrtas_init(void)
+static int __init wdrtas_init(void)
 {
         if (wdrtas_get_tokens())
                 return -ENODEV;
@@ -680,8 +660,7 @@ wdrtas_init(void)
  *
  * unregisters the file handlers and the reboot notifier
  */
-static void __exit
-wdrtas_exit(void)
+static void __exit wdrtas_exit(void)
 {
         if (!wdrtas_nowayout)
                 wdrtas_timer_stop();
diff --git a/drivers/watchdog/wdt.c b/drivers/watchdog/wdt.c
index 53a6b18bcb9a..deeebb2b13ea 100644
--- a/drivers/watchdog/wdt.c
+++ b/drivers/watchdog/wdt.c
@@ -373,8 +373,6 @@ static long wdt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 #endif /* CONFIG_WDT_501 */
 
         switch (cmd) {
-        default:
-                return -ENOTTY;
         case WDIOC_GETSUPPORT:
                 return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;
         case WDIOC_GETSTATUS:
@@ -394,6 +392,8 @@ static long wdt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                 /* Fall */
         case WDIOC_GETTIMEOUT:
                 return put_user(heartbeat, p);
+        default:
+                return -ENOTTY;
         }
 }
 
diff --git a/drivers/watchdog/wdt285.c b/drivers/watchdog/wdt285.c
index e4cf661dc890..fea398a4ca32 100644
--- a/drivers/watchdog/wdt285.c
+++ b/drivers/watchdog/wdt285.c
@@ -26,9 +26,9 @@
 #include <linux/reboot.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
+#include <linux/uaccess.h>
+#include <linux/irq.h>
 
-#include <asm/irq.h>
-#include <asm/uaccess.h>
 #include <asm/hardware.h>
 #include <asm/mach-types.h>
 #include <asm/hardware/dec21285.h>
@@ -115,8 +115,8 @@ static int watchdog_release(struct inode *inode, struct file *file)
         return 0;
 }
 
-static ssize_t
-watchdog_write(struct file *file, const char *data, size_t len, loff_t *ppos)
+static ssize_t watchdog_write(struct file *file, const char *data,
+                                                size_t len, loff_t *ppos)
 {
         /*
          *      Refresh the timer.
@@ -127,19 +127,18 @@ watchdog_write(struct file *file, const char *data, size_t len, loff_t *ppos)
         return len;
 }
 
-static struct watchdog_info ident = {
+static const struct watchdog_info ident = {
         .options        = WDIOF_SETTIMEOUT,
         .identity       = "Footbridge Watchdog",
 };
 
-static int
-watchdog_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
-               unsigned long arg)
+static long watchdog_ioctl(struct file *file, unsigned int cmd,
+                                                        unsigned long arg)
 {
         unsigned int new_margin;
         int ret = -ENOTTY;
 
-        switch(cmd) {
+        switch (cmd) {
         case WDIOC_GETSUPPORT:
                 ret = 0;
                 if (copy_to_user((void *)arg, &ident, sizeof(ident)))
@@ -148,7 +147,7 @@ watchdog_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
 
         case WDIOC_GETSTATUS:
         case WDIOC_GETBOOTSTATUS:
-                ret = put_user(0,(int *)arg);
+                ret = put_user(0, (int *)arg);
                 break;
 
         case WDIOC_KEEPALIVE:
@@ -182,7 +181,7 @@ static const struct file_operations watchdog_fops = {
         .owner          = THIS_MODULE,
         .llseek         = no_llseek,
         .write          = watchdog_write,
-        .ioctl          = watchdog_ioctl,
+        .unlocked_ioctl = watchdog_ioctl,
         .open           = watchdog_open,
         .release        = watchdog_release,
 };
@@ -204,11 +203,13 @@ static int __init footbridge_watchdog_init(void)
         if (retval < 0)
                 return retval;
 
-        printk("Footbridge Watchdog Timer: 0.01, timer margin: %d sec\n",
-               soft_margin);
+        printk(KERN_INFO
+                "Footbridge Watchdog Timer: 0.01, timer margin: %d sec\n",
+                                                                soft_margin);
 
         if (machine_is_cats())
-                printk("Warning: Watchdog reset may not work on this machine.\n");
+                printk(KERN_WARN
+                  "Warning: Watchdog reset may not work on this machine.\n");
         return 0;
 }
 
@@ -223,7 +224,7 @@ MODULE_LICENSE("GPL");
 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 
 module_param(soft_margin, int, 0);
-MODULE_PARM_DESC(soft_margin,"Watchdog timeout in seconds");
+MODULE_PARM_DESC(soft_margin, "Watchdog timeout in seconds");
 
 module_init(footbridge_watchdog_init);
 module_exit(footbridge_watchdog_exit);
diff --git a/drivers/watchdog/wdt977.c b/drivers/watchdog/wdt977.c
index fb4b876c9fda..60e28d49ff52 100644
--- a/drivers/watchdog/wdt977.c
+++ b/drivers/watchdog/wdt977.c
@@ -19,7 +19,8 @@
  *      07-Jul-2003 Daniele Bellucci: Audit return code of misc_register in
  *                                    nwwatchdog_init.
  *      25-Oct-2005 Woody Suwalski: Convert addresses to #defs, add spinlocks
- *                                  remove limitiation to be used on Netwinders only
+ *                                  remove limitiation to be used on
+ *                                  Netwinders only
  */
 
 #include <linux/module.h>
@@ -33,11 +34,11 @@
 #include <linux/watchdog.h>
 #include <linux/notifier.h>
 #include <linux/reboot.h>
+#include <linux/io.h>
+#include <linux/uaccess.h>
 
-#include <asm/io.h>
 #include <asm/system.h>
 #include <asm/mach-types.h>
-#include <asm/uaccess.h>
 
 #define WATCHDOG_VERSION  "0.04"
 #define WATCHDOG_NAME     "Wdt977"
@@ -45,7 +46,7 @@
 #define DRIVER_VERSION    WATCHDOG_NAME " driver, v" WATCHDOG_VERSION "\n"
 
 #define IO_INDEX_PORT   0x370           /* on some systems it can be 0x3F0 */
-#define IO_DATA_PORT    (IO_INDEX_PORT+1)
+#define IO_DATA_PORT    (IO_INDEX_PORT + 1)
 
 #define UNLOCK_DATA     0x87
 #define LOCK_DATA       0xAA
@@ -62,13 +63,16 @@ static	char expect_close;
 static  DEFINE_SPINLOCK(spinlock);
 
 module_param(timeout, int, 0);
-MODULE_PARM_DESC(timeout,"Watchdog timeout in seconds (60..15300), default=" __MODULE_STRING(DEFAULT_TIMEOUT) ")");
+MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds (60..15300), default="
+                                __MODULE_STRING(DEFAULT_TIMEOUT) ")");
 module_param(testmode, int, 0);
-MODULE_PARM_DESC(testmode,"Watchdog testmode (1 = no reboot), default=0");
+MODULE_PARM_DESC(testmode, "Watchdog testmode (1 = no reboot), default=0");
 
 static int nowayout = WATCHDOG_NOWAYOUT;
 module_param(nowayout, int, 0);
-MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+MODULE_PARM_DESC(nowayout,
+                "Watchdog cannot be stopped once started (default="
+                                __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 
 /*
  * Start the watchdog
@@ -95,14 +99,16 @@ static int wdt977_start(void)
         outb_p(0xF2, IO_INDEX_PORT);
         outb_p(timeoutM, IO_DATA_PORT);
         outb_p(0xF3, IO_INDEX_PORT);
-        outb_p(0x00, IO_DATA_PORT);     /* another setting is 0E for kbd/mouse/LED */
+        outb_p(0x00, IO_DATA_PORT);     /* another setting is 0E for
+                                           kbd/mouse/LED */
         outb_p(0xF4, IO_INDEX_PORT);
         outb_p(0x00, IO_DATA_PORT);
 
-        /* at last select device Aux1 (dev=7) and set GP16 as a watchdog output */
-        /* in test mode watch the bit 1 on F4 to indicate "triggered" */
-        if (!testmode)
-        {
+        /* At last select device Aux1 (dev=7) and set GP16 as a
+         * watchdog output. In test mode watch the bit 1 on F4 to
+         * indicate "triggered"
+         */
+        if (!testmode) {
                 outb_p(DEVICE_REGISTER, IO_INDEX_PORT);
                 outb_p(0x07, IO_DATA_PORT);
                 outb_p(0xE6, IO_INDEX_PORT);
@@ -147,7 +153,8 @@ static int wdt977_stop(void)
         outb_p(0xF2, IO_INDEX_PORT);
         outb_p(0x00, IO_DATA_PORT);
 
-        /* at last select device Aux1 (dev=7) and set GP16 as a watchdog output */
+        /* at last select device Aux1 (dev=7) and set
+           GP16 as a watchdog output */
         outb_p(DEVICE_REGISTER, IO_INDEX_PORT);
         outb_p(0x07, IO_DATA_PORT);
         outb_p(0xE6, IO_INDEX_PORT);
@@ -202,16 +209,18 @@ static int wdt977_set_timeout(int t)
         tmrval = (t + 59) / 60;
 
         if (machine_is_netwinder()) {
-                /* we have a hw bug somewhere, so each 977 minute is actually only 30sec
-                 *  this limits the max timeout to half of device max of 255 minutes...
+                /* we have a hw bug somewhere, so each 977 minute is actually
+                 * only 30sec. This limits the max timeout to half of device
+                 * max of 255 minutes...
                  */
                 tmrval += tmrval;
         }
 
-        if ((tmrval < 1) || (tmrval > 255))
+        if (tmrval < 1 || tmrval > 255)
                 return -EINVAL;
 
-        /* timeout is the timeout in seconds, timeoutM is the timeout in minutes) */
+        /* timeout is the timeout in seconds, timeoutM is
+           the timeout in minutes) */
         timeout = t;
         timeoutM = tmrval;
         return 0;
@@ -243,7 +252,7 @@ static int wdt977_get_status(int *status)
 
         spin_unlock_irqrestore(&spinlock, flags);
 
-        *status=0;
+        *status = 0;
         if (new_status & 1)
                 *status |= WDIOF_CARDRESET;
 
@@ -258,7 +267,7 @@ static int wdt977_get_status(int *status)
 static int wdt977_open(struct inode *inode, struct file *file)
 {
         /* If the watchdog is alive we don't need to start it again */
-        if( test_and_set_bit(0,&timer_alive) )
+        if (test_and_set_bit(0, &timer_alive))
                 return -EBUSY;
 
         if (nowayout)
@@ -274,13 +283,13 @@ static int wdt977_release(struct inode *inode, struct file *file)
          *      Shut off the timer.
          *      Lock it in if it's a module and we set nowayout
          */
-        if (expect_close == 42)
-        {
+        if (expect_close == 42) {
                 wdt977_stop();
-                clear_bit(0,&timer_alive);
+                clear_bit(0, &timer_alive);
         } else {
                 wdt977_keepalive();
-                printk(KERN_CRIT PFX "Unexpected close, not stopping watchdog!\n");
+                printk(KERN_CRIT PFX
+                        "Unexpected close, not stopping watchdog!\n");
         }
         expect_close = 0;
         return 0;
@@ -301,17 +310,14 @@ static int wdt977_release(struct inode *inode, struct file *file)
 static ssize_t wdt977_write(struct file *file, const char __user *buf,
                             size_t count, loff_t *ppos)
 {
-        if (count)
-        {
-                if (!nowayout)
-                {
+        if (count) {
+                if (!nowayout) {
                         size_t i;
 
                         /* In case it was set long ago */
                         expect_close = 0;
 
-                        for (i = 0; i != count; i++)
-                        {
+                        for (i = 0; i != count; i++) {
                                 char c;
                                 if (get_user(c, buf + i))
                                         return -EFAULT;
@@ -326,6 +332,14 @@ static ssize_t wdt977_write(struct file *file, const char __user *buf,
         return count;
 }
 
+static const struct watchdog_info ident = {
+        .options =              WDIOF_SETTIMEOUT |
+                                WDIOF_MAGICCLOSE |
+                                WDIOF_KEEPALIVEPING,
+        .firmware_version =     1,
+        .identity =             WATCHDOG_NAME,
+};
+
 /*
  *      wdt977_ioctl:
  *      @inode: inode of the device
@@ -337,16 +351,8 @@ static ssize_t wdt977_write(struct file *file, const char __user *buf,
  *      according to their available features.
  */
 
-static struct watchdog_info ident = {
-        .options =              WDIOF_SETTIMEOUT |
-                                WDIOF_MAGICCLOSE |
-                                WDIOF_KEEPALIVEPING,
-        .firmware_version =     1,
-        .identity =             WATCHDOG_NAME,
-};
-
-static int wdt977_ioctl(struct inode *inode, struct file *file,
-        unsigned int cmd, unsigned long arg)
+static long wdt977_ioctl(struct file *file, unsigned int cmd,
+                                                        unsigned long arg)
 {
         int status;
         int new_options, retval = -EINVAL;
@@ -358,11 +364,7 @@ static int wdt977_ioctl(struct inode *inode, struct file *file,
 
         uarg.i = (int __user *)arg;
 
-        switch(cmd)
-        {
-        default:
-                return -ENOTTY;
-
+        switch (cmd) {
         case WDIOC_GETSUPPORT:
                 return copy_to_user(uarg.ident, &ident,
                         sizeof(ident)) ? -EFAULT : 0;
@@ -374,12 +376,8 @@ static int wdt977_ioctl(struct inode *inode, struct file *file,
         case WDIOC_GETBOOTSTATUS:
                 return put_user(0, uarg.i);
 
-        case WDIOC_KEEPALIVE:
-                wdt977_keepalive();
-                return 0;
-
         case WDIOC_SETOPTIONS:
-                if (get_user (new_options, uarg.i))
+                if (get_user(new_options, uarg.i))
                         return -EFAULT;
 
                 if (new_options & WDIOS_DISABLECARD) {
@@ -394,6 +392,10 @@ static int wdt977_ioctl(struct inode *inode, struct file *file,
 
                 return retval;
 
+        case WDIOC_KEEPALIVE:
+                wdt977_keepalive();
+                return 0;
+
         case WDIOC_SETTIMEOUT:
                 if (get_user(new_timeout, uarg.i))
                         return -EFAULT;
@@ -407,29 +409,30 @@ static int wdt977_ioctl(struct inode *inode, struct file *file,
         case WDIOC_GETTIMEOUT:
                 return put_user(timeout, uarg.i);
 
+        default:
+                return -ENOTTY;
+
         }
 }
 
 static int wdt977_notify_sys(struct notifier_block *this, unsigned long code,
         void *unused)
 {
-        if(code==SYS_DOWN || code==SYS_HALT)
+        if (code == SYS_DOWN || code == SYS_HALT)
                 wdt977_stop();
         return NOTIFY_DONE;
 }
 
-static const struct file_operations wdt977_fops=
-{
+static const struct file_operations wdt977_fops = {
         .owner          = THIS_MODULE,
         .llseek         = no_llseek,
         .write          = wdt977_write,
-        .ioctl          = wdt977_ioctl,
+        .unlocked_ioctl = wdt977_ioctl,
         .open           = wdt977_open,
         .release        = wdt977_release,
 };
 
-static struct miscdevice wdt977_miscdev=
-{
+static struct miscdevice wdt977_miscdev = {
         .minor          = WATCHDOG_MINOR,
         .name           = "watchdog",
         .fops           = &wdt977_fops,
@@ -443,51 +446,48 @@ static int __init wd977_init(void)
 {
         int rc;
 
-        //if (!machine_is_netwinder())
-        //      return -ENODEV;
-
         printk(KERN_INFO PFX DRIVER_VERSION);
 
-        /* Check that the timeout value is within it's range ; if not reset to the default */
-        if (wdt977_set_timeout(timeout))
-        {
+        /* Check that the timeout value is within its range;
+           if not reset to the default */
+        if (wdt977_set_timeout(timeout)) {
                 wdt977_set_timeout(DEFAULT_TIMEOUT);
-                printk(KERN_INFO PFX "timeout value must be 60<timeout<15300, using %d\n",
-                        DEFAULT_TIMEOUT);
+                printk(KERN_INFO PFX
+                      "timeout value must be 60 < timeout < 15300, using %d\n",
+                                                        DEFAULT_TIMEOUT);
         }
 
         /* on Netwinder the IOports are already reserved by
          * arch/arm/mach-footbridge/netwinder-hw.c
          */
-        if (!machine_is_netwinder())
-        {
-                if (!request_region(IO_INDEX_PORT, 2, WATCHDOG_NAME))
-                {
-                        printk(KERN_ERR PFX "I/O address 0x%04x already in use\n",
-                                IO_INDEX_PORT);
+        if (!machine_is_netwinder()) {
+                if (!request_region(IO_INDEX_PORT, 2, WATCHDOG_NAME)) {
+                        printk(KERN_ERR PFX
+                                "I/O address 0x%04x already in use\n",
+                                                                IO_INDEX_PORT);
                         rc = -EIO;
                         goto err_out;
                 }
         }
 
         rc = register_reboot_notifier(&wdt977_notifier);
-        if (rc)
-        {
-                printk(KERN_ERR PFX "cannot register reboot notifier (err=%d)\n",
-                        rc);
+        if (rc) {
+                printk(KERN_ERR PFX
+                        "cannot register reboot notifier (err=%d)\n", rc);
                 goto err_out_region;
         }
 
         rc = misc_register(&wdt977_miscdev);
-        if (rc)
-        {
-                printk(KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",
-                        wdt977_miscdev.minor, rc);
+        if (rc) {
+                printk(KERN_ERR PFX
+                        "cannot register miscdev on minor=%d (err=%d)\n",
+                                                wdt977_miscdev.minor, rc);
                 goto err_out_reboot;
         }
 
-        printk(KERN_INFO PFX "initialized. timeout=%d sec (nowayout=%d, testmode=%i)\n",
-                timeout, nowayout, testmode);
+        printk(KERN_INFO PFX
+                "initialized. timeout=%d sec (nowayout=%d, testmode=%i)\n",
+                                                timeout, nowayout, testmode);
 
         return 0;
 
@@ -495,7 +495,7 @@ err_out_reboot:
         unregister_reboot_notifier(&wdt977_notifier);
 err_out_region:
         if (!machine_is_netwinder())
-                release_region(IO_INDEX_PORT,2);
+                release_region(IO_INDEX_PORT, 2);
 err_out:
         return rc;
 }
@@ -505,7 +505,7 @@ static void __exit wd977_exit(void)
         wdt977_stop();
         misc_deregister(&wdt977_miscdev);
         unregister_reboot_notifier(&wdt977_notifier);
-        release_region(IO_INDEX_PORT,2);
+        release_region(IO_INDEX_PORT, 2);
 }
 
 module_init(wd977_init);
diff --git a/drivers/watchdog/wdt_pci.c b/drivers/watchdog/wdt_pci.c
index 5d922fd6eafc..ed02bdb38c09 100644
--- a/drivers/watchdog/wdt_pci.c
+++ b/drivers/watchdog/wdt_pci.c
@@ -381,7 +381,7 @@ static ssize_t wdtpci_write(struct file *file, const char __user *buf,
 
                         for (i = 0; i != count; i++) {
                                 char c;
-                                if (get_user(c, buf+i))
+                                if (get_user(c, buf + i))
                                         return -EFAULT;
                                 if (c == 'V')
                                         expect_close = 42;
@@ -428,8 +428,6 @@ static long wdtpci_ioctl(struct file *file, unsigned int cmd,
 #endif /* CONFIG_WDT_501_PCI */
 
         switch (cmd) {
-        default:
-                return -ENOTTY;
         case WDIOC_GETSUPPORT:
                 return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;
         case WDIOC_GETSTATUS:
@@ -449,7 +447,9 @@ static long wdtpci_ioctl(struct file *file, unsigned int cmd,
                 /* Fall */
         case WDIOC_GETTIMEOUT:
                 return put_user(heartbeat, p);
-                }
+        default:
+                return -ENOTTY;
+        }
 }
 
 /**