292 files changed, 6420 insertions, 6736 deletions

diff --git a/Documentation/DocBook/videobook.tmpl b/Documentation/DocBook/videobook.tmpl
index 89817795e668..0bc25949b668 100644
--- a/Documentation/DocBook/videobook.tmpl
+++ b/Documentation/DocBook/videobook.tmpl
@@ -1648,7 +1648,7 @@ static struct video_buffer capture_fb;
 
   <chapter id="pubfunctions">
      <title>Public Functions Provided</title>
-!Edrivers/media/video/videodev.c
+!Edrivers/media/video/v4l2-dev.c
   </chapter>
 
 </book>
diff --git a/Documentation/cciss.txt b/Documentation/cciss.txt
index 63e59b8847c5..8244c6442faa 100644
--- a/Documentation/cciss.txt
+++ b/Documentation/cciss.txt
@@ -112,27 +112,18 @@ Hot plug support for SCSI tape drives
 
 Hot plugging of SCSI tape drives is supported, with some caveats.
 The cciss driver must be informed that changes to the SCSI bus
-have been made, in addition to and prior to informing the SCSI 
-mid layer.  This may be done via the /proc filesystem.  For example:
+have been made.  This may be done via the /proc filesystem.
+For example:
 
         echo "rescan" > /proc/scsi/cciss0/1
 
-This causes the adapter to query the adapter about changes to the 
-physical SCSI buses and/or fibre channel arbitrated loop and the 
+This causes the driver to query the adapter about changes to the
+physical SCSI buses and/or fibre channel arbitrated loop and the
 driver to make note of any new or removed sequential access devices
 or medium changers.  The driver will output messages indicating what 
 devices have been added or removed and the controller, bus, target and 
-lun used to address the device.  Once this is done, the SCSI mid layer 
-can be informed of changes to the virtual SCSI bus which the driver 
-presents to it in the usual way. For example: 
-
-        echo scsi add-single-device 3 2 1 0 > /proc/scsi/scsi
- 
-to add a device on controller 3, bus 2, target 1, lun 0.   Note that
-the driver makes an effort to preserve the devices positions
-in the virtual SCSI bus, so if you are only moving tape drives 
-around on the same adapter and not adding or removing tape drives 
-from the adapter, informing the SCSI mid layer may not be necessary.
+lun used to address the device.  It then notifies the SCSI mid layer
+of these changes.
 
 Note that the naming convention of the /proc filesystem entries 
 contains a number in addition to the driver name.  (E.g. "cciss0" 
diff --git a/Documentation/hwmon/dme1737 b/Documentation/hwmon/dme1737
index b1fe00999439..001d2e70bc11 100644
--- a/Documentation/hwmon/dme1737
+++ b/Documentation/hwmon/dme1737
@@ -10,6 +10,10 @@ Supported chips:
     Prefix: 'sch311x'
     Addresses scanned: none, address read from Super-I/O config space
     Datasheet: http://www.nuhorizons.com/FeaturedProducts/Volume1/SMSC/311x.pdf
+  * SMSC SCH5027
+    Prefix: 'sch5027'
+    Addresses scanned: I2C 0x2c, 0x2d, 0x2e
+    Datasheet: Provided by SMSC upon request and under NDA
 
 Authors:
     Juerg Haefliger <juergh@gmail.com>
@@ -27,33 +31,31 @@ Module Parameters
                         following boards:
                         - VIA EPIA SN18000
 
-Note that there is no need to use this parameter if the driver loads without
-complaining. The driver will say so if it is necessary.
-
 
 Description
 -----------
 
 This driver implements support for the hardware monitoring capabilities of the
-SMSC DME1737 and Asus A8000 (which are the same) and SMSC SCH311x Super-I/O
-chips. These chips feature monitoring of 3 temp sensors temp[1-3] (2 remote
-diodes and 1 internal), 7 voltages in[0-6] (6 external and 1 internal) and up
-to 6 fan speeds fan[1-6]. Additionally, the chips implement up to 5 PWM
-outputs pwm[1-3,5-6] for controlling fan speeds both manually and
+SMSC DME1737 and Asus A8000 (which are the same), SMSC SCH5027, and SMSC
+SCH311x Super-I/O chips. These chips feature monitoring of 3 temp sensors
+temp[1-3] (2 remote diodes and 1 internal), 7 voltages in[0-6] (6 external and
+1 internal) and up to 6 fan speeds fan[1-6]. Additionally, the chips implement
+up to 5 PWM outputs pwm[1-3,5-6] for controlling fan speeds both manually and
 automatically.
 
-For the DME1737 and A8000, fan[1-2] and pwm[1-2] are always present. Fan[3-6]
-and pwm[3,5-6] are optional features and their availability depends on the
-configuration of the chip. The driver will detect which features are present
-during initialization and create the sysfs attributes accordingly.
+For the DME1737, A8000 and SCH5027, fan[1-2] and pwm[1-2] are always present.
+Fan[3-6] and pwm[3,5-6] are optional features and their availability depends on
+the configuration of the chip. The driver will detect which features are
+present during initialization and create the sysfs attributes accordingly.
 
 For the SCH311x, fan[1-3] and pwm[1-3] are always present and fan[4-6] and
 pwm[5-6] don't exist.
 
-The hardware monitoring features of the DME1737 and A8000 are only accessible
-via SMBus, while the SCH311x only provides access via the ISA bus. The driver
-will therefore register itself as an I2C client driver if it detects a DME1737
-or A8000 and as a platform driver if it detects a SCH311x chip.
+The hardware monitoring features of the DME1737, A8000, and SCH5027 are only
+accessible via SMBus, while the SCH311x only provides access via the ISA bus.
+The driver will therefore register itself as an I2C client driver if it detects
+a DME1737, A8000, or SCH5027 and as a platform driver if it detects a SCH311x
+chip.
 
 
 Voltage Monitoring
@@ -64,6 +66,7 @@ scaling resistors. The values returned by the driver therefore reflect true
 millivolts and don't need scaling. The voltage inputs are mapped as follows
 (the last column indicates the input ranges):
 
+DME1737, A8000:
         in0: +5VTR      (+5V standby)           0V - 6.64V
         in1: Vccp       (processor core)        0V - 3V
         in2: VCC        (internal +3.3V)        0V - 4.38V
@@ -72,6 +75,24 @@ millivolts and don't need scaling. The voltage inputs are mapped as follows
         in5: VTR        (+3.3V standby)         0V - 4.38V
         in6: Vbat       (+3.0V)                 0V - 4.38V
 
+SCH311x:
+        in0: +2.5V                              0V - 6.64V
+        in1: Vccp       (processor core)        0V - 2V
+        in2: VCC        (internal +3.3V)        0V - 4.38V
+        in3: +5V                                0V - 6.64V
+        in4: +12V                               0V - 16V
+        in5: VTR        (+3.3V standby)         0V - 4.38V
+        in6: Vbat       (+3.0V)                 0V - 4.38V
+
+SCH5027:
+        in0: +5VTR      (+5V standby)           0V - 6.64V
+        in1: Vccp       (processor core)        0V - 3V
+        in2: VCC        (internal +3.3V)        0V - 4.38V
+        in3: V2_IN                              0V - 1.5V
+        in4: V1_IN                              0V - 1.5V
+        in5: VTR        (+3.3V standby)         0V - 4.38V
+        in6: Vbat       (+3.0V)                 0V - 4.38V
+
 Each voltage input has associated min and max limits which trigger an alarm
 when crossed.
 
diff --git a/Documentation/hwmon/it87 b/Documentation/hwmon/it87
index f4ce1fdbeff6..3496b7020e7c 100644
--- a/Documentation/hwmon/it87
+++ b/Documentation/hwmon/it87
@@ -6,12 +6,14 @@ Supported chips:
     Prefix: 'it87'
     Addresses scanned: from Super I/O config space (8 I/O ports)
     Datasheet: Publicly available at the ITE website
-               http://www.ite.com.tw/
+               http://www.ite.com.tw/product_info/file/pc/IT8705F_V.0.4.1.pdf
   * IT8712F
     Prefix: 'it8712'
     Addresses scanned: from Super I/O config space (8 I/O ports)
     Datasheet: Publicly available at the ITE website
-               http://www.ite.com.tw/
+               http://www.ite.com.tw/product_info/file/pc/IT8712F_V0.9.1.pdf
+               http://www.ite.com.tw/product_info/file/pc/Errata%20V0.1%20for%20IT8712F%20V0.9.1.pdf
+               http://www.ite.com.tw/product_info/file/pc/IT8712F_V0.9.3.pdf
   * IT8716F/IT8726F
     Prefix: 'it8716'
     Addresses scanned: from Super I/O config space (8 I/O ports)
@@ -90,14 +92,13 @@ upper VID bits share their pins with voltage inputs (in5 and in6) so you
 can't have both on a given board.
 
 The IT8716F, IT8718F and later IT8712F revisions have support for
-2 additional fans. They are supported by the driver for the IT8716F and
-IT8718F but not for the IT8712F
+2 additional fans. The additional fans are supported by the driver.
 
 The IT8716F and IT8718F, and late IT8712F and IT8705F also have optional
 16-bit tachometer counters for fans 1 to 3. This is better (no more fan
 clock divider mess) but not compatible with the older chips and
-revisions. For now, the driver only uses the 16-bit mode on the
-IT8716F and IT8718F.
+revisions. The 16-bit tachometer mode is enabled by the driver when one
+of the above chips is detected.
 
 The IT8726F is just bit enhanced IT8716F with additional hardware
 for AMD power sequencing. Therefore the chip will appear as IT8716F
diff --git a/Documentation/hwmon/w83627hf b/Documentation/hwmon/w83627hf
index 880a59f53da9..6ee36dbafd64 100644
--- a/Documentation/hwmon/w83627hf
+++ b/Documentation/hwmon/w83627hf
@@ -40,10 +40,6 @@ Module Parameters
   (default is 1)
   Use 'init=0' to bypass initializing the chip.
   Try this if your computer crashes when you load the module.
-* reset: int
-  (default is 0)
-  The driver used to reset the chip on load, but does no more. Use
-  'reset=1' to restore the old behavior. Report if you need to do this.
 
 Description
 -----------
diff --git a/Documentation/hwmon/w83791d b/Documentation/hwmon/w83791d
index f153b2f6d62c..a67d3b7a7098 100644
--- a/Documentation/hwmon/w83791d
+++ b/Documentation/hwmon/w83791d
@@ -22,6 +22,7 @@ Credits:
 
 Additional contributors:
     Sven Anders <anders@anduras.de>
+    Marc Hulsman <m.hulsman@tudelft.nl>
 
 Module Parameters
 -----------------
@@ -67,9 +68,8 @@ on until the temperature falls below the Hysteresis value.
 
 Fan rotation speeds are reported in RPM (rotations per minute). An alarm is
 triggered if the rotation speed has dropped below a programmable limit. Fan
-readings can be divided by a programmable divider (1, 2, 4, 8 for fan 1/2/3
-and 1, 2, 4, 8, 16, 32, 64 or 128 for fan 4/5) to give the readings more
-range or accuracy.
+readings can be divided by a programmable divider (1, 2, 4, 8, 16,
+32, 64 or 128 for all fans) to give the readings more range or accuracy.
 
 Voltage sensors (also known as IN sensors) report their values in millivolts.
 An alarm is triggered if the voltage has crossed a programmable minimum
diff --git a/Documentation/video4linux/gspca.txt b/Documentation/video4linux/gspca.txt
index bcaf4ab383be..78a863ab8a5a 100644
--- a/Documentation/video4linux/gspca.txt
+++ b/Documentation/video4linux/gspca.txt
@@ -226,6 +226,7 @@ sonixj		0c45:6130	Sonix Pccam
 sonixj          0c45:6138       Sn9c120 Mo4000
 sonixj          0c45:613b       Surfer SN-206
 sonixj          0c45:613c       Sonix Pccam168
+sonixj          0c45:6143       Sonix Pccam168
 sunplus         0d64:0303       Sunplus FashionCam DXG
 etoms           102c:6151       Qcam Sangha CIF
 etoms           102c:6251       Qcam xxxxxx VGA
diff --git a/arch/ia64/Kconfig b/arch/ia64/Kconfig
index 451f2ffb137b..48e496fe1e75 100644
--- a/arch/ia64/Kconfig
+++ b/arch/ia64/Kconfig
@@ -171,8 +171,8 @@ config IA64_SGI_SN2
           to select this option.  If in doubt, select ia64 generic support
           instead.
 
-config IA64_SGI_UV`
-        bool "SGI-UV`"
+config IA64_SGI_UV
+        bool "SGI-UV"
         select NUMA
         select ACPI_NUMA
         select SWIOTLB
@@ -321,10 +321,10 @@ config SMP
           If you don't know what to do here, say N.
 
 config NR_CPUS
-        int "Maximum number of CPUs (2-1024)"
-        range 2 1024
+        int "Maximum number of CPUs (2-4096)"
+        range 2 4096
         depends on SMP
-        default "1024"
+        default "4096"
         help
           You should set this to the number of CPUs in your system, but
           keep in mind that a kernel compiled for, e.g., 2 CPUs will boot but
diff --git a/arch/ia64/configs/generic_defconfig b/arch/ia64/configs/generic_defconfig
index 0210545e7f61..9f483976228f 100644
--- a/arch/ia64/configs/generic_defconfig
+++ b/arch/ia64/configs/generic_defconfig
@@ -1,20 +1,16 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.22
-# Thu Jul 19 13:55:32 2007
+# Linux kernel version: 2.6.27-rc1
+# Mon Aug  4 15:38:01 2008
 #
 CONFIG_DEFCONFIG_LIST="/lib/modules/$UNAME_RELEASE/.config"
 
 #
-# Code maturity level options
+# General setup
 #
 CONFIG_EXPERIMENTAL=y
 CONFIG_LOCK_KERNEL=y
 CONFIG_INIT_ENV_ARG_LIMIT=32
-
-#
-# General setup
-#
 CONFIG_LOCALVERSION=""
 CONFIG_LOCALVERSION_AUTO=y
 CONFIG_SWAP=y
@@ -23,20 +19,34 @@ CONFIG_SYSVIPC_SYSCTL=y
 CONFIG_POSIX_MQUEUE=y
 # CONFIG_BSD_PROCESS_ACCT is not set
 # CONFIG_TASKSTATS is not set
-# CONFIG_USER_NS is not set
 # CONFIG_AUDIT is not set
 CONFIG_IKCONFIG=y
 CONFIG_IKCONFIG_PROC=y
 CONFIG_LOG_BUF_SHIFT=20
-# CONFIG_CPUSETS is not set
+CONFIG_CGROUPS=y
+# CONFIG_CGROUP_DEBUG is not set
+# CONFIG_CGROUP_NS is not set
+# CONFIG_CGROUP_DEVICE is not set
+CONFIG_CPUSETS=y
+# CONFIG_GROUP_SCHED is not set
+# CONFIG_CGROUP_CPUACCT is not set
+# CONFIG_RESOURCE_COUNTERS is not set
 CONFIG_SYSFS_DEPRECATED=y
+CONFIG_SYSFS_DEPRECATED_V2=y
+CONFIG_PROC_PID_CPUSET=y
 # CONFIG_RELAY is not set
+CONFIG_NAMESPACES=y
+# CONFIG_UTS_NS is not set
+# CONFIG_IPC_NS is not set
+# CONFIG_USER_NS is not set
+# CONFIG_PID_NS is not set
 CONFIG_BLK_DEV_INITRD=y
 CONFIG_INITRAMFS_SOURCE=""
 CONFIG_CC_OPTIMIZE_FOR_SIZE=y
 CONFIG_SYSCTL=y
 # CONFIG_EMBEDDED is not set
 CONFIG_SYSCTL_SYSCALL=y
+CONFIG_SYSCTL_SYSCALL_CHECK=y
 CONFIG_KALLSYMS=y
 CONFIG_KALLSYMS_ALL=y
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
@@ -44,6 +54,7 @@ CONFIG_HOTPLUG=y
 CONFIG_PRINTK=y
 CONFIG_BUG=y
 CONFIG_ELF_CORE=y
+CONFIG_COMPAT_BRK=y
 CONFIG_BASE_FULL=y
 CONFIG_FUTEX=y
 CONFIG_ANON_INODES=y
@@ -53,12 +64,30 @@ CONFIG_TIMERFD=y
 CONFIG_EVENTFD=y
 CONFIG_SHMEM=y
 CONFIG_VM_EVENT_COUNTERS=y
+CONFIG_SLUB_DEBUG=y
+# CONFIG_SLAB is not set
 CONFIG_SLUB=y
 # CONFIG_SLOB is not set
+# CONFIG_PROFILING is not set
+# CONFIG_MARKERS is not set
+CONFIG_HAVE_OPROFILE=y
+# CONFIG_KPROBES is not set
+# CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS is not set
+# CONFIG_HAVE_IOREMAP_PROT is not set
+CONFIG_HAVE_KPROBES=y
+CONFIG_HAVE_KRETPROBES=y
+# CONFIG_HAVE_ARCH_TRACEHOOK is not set
+CONFIG_HAVE_DMA_ATTRS=y
+CONFIG_USE_GENERIC_SMP_HELPERS=y
+# CONFIG_HAVE_CLK is not set
+CONFIG_PROC_PAGE_MONITOR=y
+# CONFIG_HAVE_GENERIC_DMA_COHERENT is not set
+CONFIG_SLABINFO=y
 CONFIG_RT_MUTEXES=y
 # CONFIG_TINY_SHMEM is not set
 CONFIG_BASE_SMALL=0
 CONFIG_MODULES=y
+# CONFIG_MODULE_FORCE_LOAD is not set
 CONFIG_MODULE_UNLOAD=y
 # CONFIG_MODULE_FORCE_UNLOAD is not set
 CONFIG_MODVERSIONS=y
@@ -68,6 +97,8 @@ CONFIG_STOP_MACHINE=y
 CONFIG_BLOCK=y
 # CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_BLK_DEV_BSG is not set
+# CONFIG_BLK_DEV_INTEGRITY is not set
+CONFIG_BLOCK_COMPAT=y
 
 #
 # IO Schedulers
@@ -81,6 +112,7 @@ CONFIG_DEFAULT_AS=y
 # CONFIG_DEFAULT_CFQ is not set
 # CONFIG_DEFAULT_NOOP is not set
 CONFIG_DEFAULT_IOSCHED="anticipatory"
+CONFIG_CLASSIC_RCU=y
 
 #
 # Processor type and features
@@ -91,22 +123,28 @@ CONFIG_ZONE_DMA=y
 CONFIG_QUICKLIST=y
 CONFIG_MMU=y
 CONFIG_SWIOTLB=y
+CONFIG_IOMMU_HELPER=y
 CONFIG_RWSEM_XCHGADD_ALGORITHM=y
 # CONFIG_ARCH_HAS_ILOG2_U32 is not set
 # CONFIG_ARCH_HAS_ILOG2_U64 is not set
+CONFIG_HUGETLB_PAGE_SIZE_VARIABLE=y
 CONFIG_GENERIC_FIND_NEXT_BIT=y
 CONFIG_GENERIC_CALIBRATE_DELAY=y
 CONFIG_GENERIC_TIME=y
+CONFIG_GENERIC_TIME_VSYSCALL=y
+CONFIG_HAVE_SETUP_PER_CPU_AREA=y
 CONFIG_DMI=y
 CONFIG_EFI=y
 CONFIG_GENERIC_IOMAP=y
 CONFIG_SCHED_NO_NO_OMIT_FRAME_POINTER=y
+CONFIG_IA64_UNCACHED_ALLOCATOR=y
 CONFIG_AUDIT_ARCH=y
 CONFIG_IA64_GENERIC=y
 # CONFIG_IA64_DIG is not set
 # CONFIG_IA64_HP_ZX1 is not set
 # CONFIG_IA64_HP_ZX1_SWIOTLB is not set
 # CONFIG_IA64_SGI_SN2 is not set
+# CONFIG_IA64_SGI_UV is not set
 # CONFIG_IA64_HP_SIM is not set
 # CONFIG_ITANIUM is not set
 CONFIG_MCKINLEY=y
@@ -116,22 +154,26 @@ CONFIG_MCKINLEY=y
 CONFIG_IA64_PAGE_SIZE_64KB=y
 CONFIG_PGTABLE_3=y
 # CONFIG_PGTABLE_4 is not set
+CONFIG_HZ=250
 # CONFIG_HZ_100 is not set
 CONFIG_HZ_250=y
 # CONFIG_HZ_300 is not set
 # CONFIG_HZ_1000 is not set
-CONFIG_HZ=250
+# CONFIG_SCHED_HRTICK is not set
 CONFIG_IA64_L1_CACHE_SHIFT=7
 CONFIG_IA64_CYCLONE=y
 CONFIG_IOSAPIC=y
-# CONFIG_IA64_SGI_SN_XP is not set
 CONFIG_FORCE_MAX_ZONEORDER=17
+# CONFIG_VIRT_CPU_ACCOUNTING is not set
 CONFIG_SMP=y
-CONFIG_NR_CPUS=512
+CONFIG_NR_CPUS=4096
 CONFIG_HOTPLUG_CPU=y
 CONFIG_ARCH_ENABLE_MEMORY_HOTPLUG=y
+CONFIG_ARCH_ENABLE_MEMORY_HOTREMOVE=y
 # CONFIG_SCHED_SMT is not set
 # CONFIG_PERMIT_BSP_REMOVE is not set
+CONFIG_PREEMPT_NONE=y
+# CONFIG_PREEMPT_VOLUNTARY is not set
 # CONFIG_PREEMPT is not set
 CONFIG_SELECT_MEMORY_MODEL=y
 # CONFIG_FLATMEM_MANUAL is not set
@@ -141,6 +183,8 @@ CONFIG_DISCONTIGMEM=y
 CONFIG_FLAT_NODE_MEM_MAP=y
 CONFIG_NEED_MULTIPLE_NODES=y
 # CONFIG_SPARSEMEM_STATIC is not set
+CONFIG_SPARSEMEM_VMEMMAP_ENABLE=y
+CONFIG_PAGEFLAGS_EXTENDED=y
 CONFIG_SPLIT_PTLOCK_CPUS=4
 CONFIG_MIGRATION=y
 CONFIG_RESOURCES_64BIT=y
@@ -148,6 +192,7 @@ CONFIG_ZONE_DMA_FLAG=1
 CONFIG_BOUNCE=y
 CONFIG_NR_QUICK=1
 CONFIG_VIRT_TO_BUS=y
+CONFIG_MMU_NOTIFIER=y
 CONFIG_ARCH_SELECT_MEMORY_MODEL=y
 CONFIG_ARCH_DISCONTIGMEM_ENABLE=y
 CONFIG_ARCH_FLATMEM_ENABLE=y
@@ -162,12 +207,14 @@ CONFIG_HAVE_ARCH_EARLY_PFN_TO_NID=y
 CONFIG_HAVE_ARCH_NODEDATA_EXTENSION=y
 CONFIG_IA32_SUPPORT=y
 CONFIG_COMPAT=y
+CONFIG_COMPAT_FOR_U64_ALIGNMENT=y
 CONFIG_IA64_MCA_RECOVERY=y
 CONFIG_PERFMON=y
 CONFIG_IA64_PALINFO=y
 # CONFIG_IA64_MC_ERR_INJECT is not set
 CONFIG_SGI_SN=y
 # CONFIG_IA64_ESI is not set
+# CONFIG_IA64_HP_AML_NFW is not set
 
 #
 # SN Devices
@@ -179,6 +226,7 @@ CONFIG_CRASH_DUMP=y
 #
 # Firmware Drivers
 #
+# CONFIG_FIRMWARE_MEMMAP is not set
 CONFIG_EFI_VARS=y
 CONFIG_EFI_PCDP=y
 CONFIG_DMIID=y
@@ -189,24 +237,25 @@ CONFIG_BINFMT_MISC=m
 # Power management and ACPI
 #
 CONFIG_PM=y
-CONFIG_PM_LEGACY=y
 # CONFIG_PM_DEBUG is not set
-
-#
-# ACPI (Advanced Configuration and Power Interface) Support
-#
 CONFIG_ACPI=y
 CONFIG_ACPI_PROCFS=y
+CONFIG_ACPI_PROCFS_POWER=y
+CONFIG_ACPI_SYSFS_POWER=y
+CONFIG_ACPI_PROC_EVENT=y
 CONFIG_ACPI_BUTTON=m
 CONFIG_ACPI_FAN=m
-# CONFIG_ACPI_DOCK is not set
+CONFIG_ACPI_DOCK=y
+# CONFIG_ACPI_BAY is not set
 CONFIG_ACPI_PROCESSOR=m
 CONFIG_ACPI_HOTPLUG_CPU=y
 CONFIG_ACPI_THERMAL=m
 CONFIG_ACPI_NUMA=y
+# CONFIG_ACPI_CUSTOM_DSDT is not set
 CONFIG_ACPI_BLACKLIST_YEAR=0
 # CONFIG_ACPI_DEBUG is not set
 CONFIG_ACPI_EC=y
+# CONFIG_ACPI_PCI_SLOT is not set
 CONFIG_ACPI_POWER=y
 CONFIG_ACPI_SYSTEM=y
 CONFIG_ACPI_CONTAINER=m
@@ -225,6 +274,7 @@ CONFIG_PCI_SYSCALL=y
 # CONFIG_PCIEPORTBUS is not set
 CONFIG_ARCH_SUPPORTS_MSI=y
 # CONFIG_PCI_MSI is not set
+CONFIG_PCI_LEGACY=y
 # CONFIG_PCI_DEBUG is not set
 CONFIG_HOTPLUG_PCI=m
 # CONFIG_HOTPLUG_PCI_FAKE is not set
@@ -233,15 +283,7 @@ CONFIG_HOTPLUG_PCI_ACPI=m
 # CONFIG_HOTPLUG_PCI_CPCI is not set
 # CONFIG_HOTPLUG_PCI_SHPC is not set
 # CONFIG_HOTPLUG_PCI_SGI is not set
-
-#
-# PCCARD (PCMCIA/CardBus) support
-#
 # CONFIG_PCCARD is not set
-
-#
-# Networking
-#
 CONFIG_NET=y
 
 #
@@ -254,6 +296,7 @@ CONFIG_XFRM=y
 # CONFIG_XFRM_USER is not set
 # CONFIG_XFRM_SUB_POLICY is not set
 # CONFIG_XFRM_MIGRATE is not set
+# CONFIG_XFRM_STATISTICS is not set
 # CONFIG_NET_KEY is not set
 CONFIG_INET=y
 CONFIG_IP_MULTICAST=y
@@ -273,6 +316,7 @@ CONFIG_SYN_COOKIES=y
 CONFIG_INET_XFRM_MODE_TRANSPORT=y
 CONFIG_INET_XFRM_MODE_TUNNEL=y
 CONFIG_INET_XFRM_MODE_BEET=y
+CONFIG_INET_LRO=m
 CONFIG_INET_DIAG=y
 CONFIG_INET_TCP_DIAG=y
 # CONFIG_TCP_CONG_ADVANCED is not set
@@ -280,8 +324,6 @@ CONFIG_TCP_CONG_CUBIC=y
 CONFIG_DEFAULT_TCP_CONG="cubic"
 # CONFIG_TCP_MD5SIG is not set
 # CONFIG_IPV6 is not set
-# CONFIG_INET6_XFRM_TUNNEL is not set
-# CONFIG_INET6_TUNNEL is not set
 # CONFIG_NETWORK_SECMARK is not set
 # CONFIG_NETFILTER is not set
 # CONFIG_IP_DCCP is not set
@@ -298,10 +340,6 @@ CONFIG_DEFAULT_TCP_CONG="cubic"
 # CONFIG_LAPB is not set
 # CONFIG_ECONET is not set
 # CONFIG_WAN_ROUTER is not set
-
-#
-# QoS and/or fair queueing
-#
 # CONFIG_NET_SCHED is not set
 
 #
@@ -309,6 +347,7 @@ CONFIG_DEFAULT_TCP_CONG="cubic"
 #
 # CONFIG_NET_PKTGEN is not set
 # CONFIG_HAMRADIO is not set
+# CONFIG_CAN is not set
 # CONFIG_IRDA is not set
 # CONFIG_BT is not set
 # CONFIG_AF_RXRPC is not set
@@ -330,13 +369,17 @@ CONFIG_DEFAULT_TCP_CONG="cubic"
 #
 # Generic Driver Options
 #
+CONFIG_UEVENT_HELPER_PATH="/sbin/hotplug"
 CONFIG_STANDALONE=y
 CONFIG_PREVENT_FIRMWARE_BUILD=y
-CONFIG_FW_LOADER=m
+CONFIG_FW_LOADER=y
+CONFIG_FIRMWARE_IN_KERNEL=y
+CONFIG_EXTRA_FIRMWARE=""
 # CONFIG_DEBUG_DRIVER is not set
 # CONFIG_DEBUG_DEVRES is not set
 # CONFIG_SYS_HYPERVISOR is not set
-# CONFIG_CONNECTOR is not set
+CONFIG_CONNECTOR=y
+CONFIG_PROC_EVENTS=y
 # CONFIG_MTD is not set
 # CONFIG_PARPORT is not set
 CONFIG_PNP=y
@@ -360,25 +403,35 @@ CONFIG_BLK_DEV_NBD=m
 CONFIG_BLK_DEV_RAM=y
 CONFIG_BLK_DEV_RAM_COUNT=16
 CONFIG_BLK_DEV_RAM_SIZE=4096
-CONFIG_BLK_DEV_RAM_BLOCKSIZE=1024
+# CONFIG_BLK_DEV_XIP is not set
 # CONFIG_CDROM_PKTCDVD is not set
 # CONFIG_ATA_OVER_ETH is not set
+# CONFIG_BLK_DEV_HD is not set
 CONFIG_MISC_DEVICES=y
 # CONFIG_PHANTOM is not set
 # CONFIG_EEPROM_93CX6 is not set
 CONFIG_SGI_IOC4=y
 # CONFIG_TIFM_CORE is not set
+# CONFIG_ENCLOSURE_SERVICES is not set
+CONFIG_SGI_XP=m
+# CONFIG_HP_ILO is not set
+CONFIG_SGI_GRU=m
+# CONFIG_SGI_GRU_DEBUG is not set
+CONFIG_HAVE_IDE=y
 CONFIG_IDE=y
 CONFIG_IDE_MAX_HWIFS=4
 CONFIG_BLK_DEV_IDE=y
 
 #
-# Please see Documentation/ide.txt for help/info on IDE drives
+# Please see Documentation/ide/ide.txt for help/info on IDE drives
 #
+CONFIG_IDE_TIMINGS=y
+CONFIG_IDE_ATAPI=y
 # CONFIG_BLK_DEV_IDE_SATA is not set
 CONFIG_BLK_DEV_IDEDISK=y
 # CONFIG_IDEDISK_MULTI_MODE is not set
 CONFIG_BLK_DEV_IDECD=y
+CONFIG_BLK_DEV_IDECD_VERBOSE_ERRORS=y
 # CONFIG_BLK_DEV_IDETAPE is not set
 CONFIG_BLK_DEV_IDEFLOPPY=y
 CONFIG_BLK_DEV_IDESCSI=m
@@ -390,25 +443,26 @@ CONFIG_IDE_PROC_FS=y
 # IDE chipset support/bugfixes
 #
 # CONFIG_IDE_GENERIC is not set
+# CONFIG_BLK_DEV_PLATFORM is not set
 # CONFIG_BLK_DEV_IDEPNP is not set
+CONFIG_BLK_DEV_IDEDMA_SFF=y
+
+#
+# PCI IDE chipsets support
+#
 CONFIG_BLK_DEV_IDEPCI=y
-CONFIG_IDEPCI_SHARE_IRQ=y
 CONFIG_IDEPCI_PCIBUS_ORDER=y
 # CONFIG_BLK_DEV_OFFBOARD is not set
 CONFIG_BLK_DEV_GENERIC=y
 # CONFIG_BLK_DEV_OPTI621 is not set
 CONFIG_BLK_DEV_IDEDMA_PCI=y
-# CONFIG_BLK_DEV_IDEDMA_FORCED is not set
-# CONFIG_IDEDMA_ONLYDISK is not set
 # CONFIG_BLK_DEV_AEC62XX is not set
 # CONFIG_BLK_DEV_ALI15X3 is not set
 # CONFIG_BLK_DEV_AMD74XX is not set
 CONFIG_BLK_DEV_CMD64X=y
 # CONFIG_BLK_DEV_TRIFLEX is not set
-# CONFIG_BLK_DEV_CY82C693 is not set
 # CONFIG_BLK_DEV_CS5520 is not set
 # CONFIG_BLK_DEV_CS5530 is not set
-# CONFIG_BLK_DEV_HPT34X is not set
 # CONFIG_BLK_DEV_HPT366 is not set
 # CONFIG_BLK_DEV_JMICRON is not set
 # CONFIG_BLK_DEV_SC1200 is not set
@@ -425,10 +479,7 @@ CONFIG_BLK_DEV_SGIIOC4=y
 # CONFIG_BLK_DEV_TRM290 is not set
 # CONFIG_BLK_DEV_VIA82CXXX is not set
 # CONFIG_BLK_DEV_TC86C001 is not set
-# CONFIG_IDE_ARM is not set
 CONFIG_BLK_DEV_IDEDMA=y
-# CONFIG_IDEDMA_IVB is not set
-# CONFIG_BLK_DEV_HD is not set
 
 #
 # SCSI device support
@@ -468,10 +519,8 @@ CONFIG_SCSI_FC_ATTRS=y
 # CONFIG_SCSI_ISCSI_ATTRS is not set
 CONFIG_SCSI_SAS_ATTRS=y
 # CONFIG_SCSI_SAS_LIBSAS is not set
-
-#
-# SCSI low-level drivers
-#
+# CONFIG_SCSI_SRP_ATTRS is not set
+CONFIG_SCSI_LOWLEVEL=y
 # CONFIG_ISCSI_TCP is not set
 # CONFIG_BLK_DEV_3W_XXXX_RAID is not set
 # CONFIG_SCSI_3W_9XXX is not set
@@ -481,6 +530,8 @@ CONFIG_SCSI_SAS_ATTRS=y
 # CONFIG_SCSI_AIC7XXX_OLD is not set
 # CONFIG_SCSI_AIC79XX is not set
 # CONFIG_SCSI_AIC94XX is not set
+# CONFIG_SCSI_DPT_I2O is not set
+# CONFIG_SCSI_ADVANSYS is not set
 # CONFIG_SCSI_ARCMSR is not set
 # CONFIG_MEGARAID_NEWGEN is not set
 # CONFIG_MEGARAID_LEGACY is not set
@@ -491,12 +542,14 @@ CONFIG_SCSI_SAS_ATTRS=y
 # CONFIG_SCSI_IPS is not set
 # CONFIG_SCSI_INITIO is not set
 # CONFIG_SCSI_INIA100 is not set
+# CONFIG_SCSI_MVSAS is not set
 # CONFIG_SCSI_STEX is not set
 CONFIG_SCSI_SYM53C8XX_2=y
 CONFIG_SCSI_SYM53C8XX_DMA_ADDRESSING_MODE=1
 CONFIG_SCSI_SYM53C8XX_DEFAULT_TAGS=16
 CONFIG_SCSI_SYM53C8XX_MAX_TAGS=64
 CONFIG_SCSI_SYM53C8XX_MMIO=y
+# CONFIG_SCSI_IPR is not set
 CONFIG_SCSI_QLOGIC_1280=y
 # CONFIG_SCSI_QLA_FC is not set
 # CONFIG_SCSI_QLA_ISCSI is not set
@@ -505,7 +558,68 @@ CONFIG_SCSI_QLOGIC_1280=y
 # CONFIG_SCSI_DC390T is not set
 # CONFIG_SCSI_DEBUG is not set
 # CONFIG_SCSI_SRP is not set
-# CONFIG_ATA is not set
+# CONFIG_SCSI_DH is not set
+CONFIG_ATA=y
+CONFIG_ATA_NONSTANDARD=y
+CONFIG_ATA_ACPI=y
+CONFIG_SATA_PMP=y
+# CONFIG_SATA_AHCI is not set
+# CONFIG_SATA_SIL24 is not set
+CONFIG_ATA_SFF=y
+# CONFIG_SATA_SVW is not set
+CONFIG_ATA_PIIX=y
+# CONFIG_SATA_MV is not set
+# CONFIG_SATA_NV is not set
+# CONFIG_PDC_ADMA is not set
+# CONFIG_SATA_QSTOR is not set
+# CONFIG_SATA_PROMISE is not set
+# CONFIG_SATA_SX4 is not set
+# CONFIG_SATA_SIL is not set
+# CONFIG_SATA_SIS is not set
+# CONFIG_SATA_ULI is not set
+# CONFIG_SATA_VIA is not set
+# CONFIG_SATA_VITESSE is not set
+# CONFIG_SATA_INIC162X is not set
+# CONFIG_PATA_ACPI is not set
+# CONFIG_PATA_ALI is not set
+# CONFIG_PATA_AMD is not set
+# CONFIG_PATA_ARTOP is not set
+# CONFIG_PATA_ATIIXP is not set
+# CONFIG_PATA_CMD640_PCI is not set
+# CONFIG_PATA_CMD64X is not set
+# CONFIG_PATA_CS5520 is not set
+# CONFIG_PATA_CS5530 is not set
+# CONFIG_PATA_CYPRESS is not set
+# CONFIG_PATA_EFAR is not set
+# CONFIG_ATA_GENERIC is not set
+# CONFIG_PATA_HPT366 is not set
+# CONFIG_PATA_HPT37X is not set
+# CONFIG_PATA_HPT3X2N is not set
+# CONFIG_PATA_HPT3X3 is not set
+# CONFIG_PATA_IT821X is not set
+# CONFIG_PATA_IT8213 is not set
+# CONFIG_PATA_JMICRON is not set
+# CONFIG_PATA_TRIFLEX is not set
+# CONFIG_PATA_MARVELL is not set
+# CONFIG_PATA_MPIIX is not set
+# CONFIG_PATA_OLDPIIX is not set
+# CONFIG_PATA_NETCELL is not set
+# CONFIG_PATA_NINJA32 is not set
+# CONFIG_PATA_NS87410 is not set
+# CONFIG_PATA_NS87415 is not set
+# CONFIG_PATA_OPTI is not set
+# CONFIG_PATA_OPTIDMA is not set
+# CONFIG_PATA_PDC_OLD is not set
+# CONFIG_PATA_RADISYS is not set
+# CONFIG_PATA_RZ1000 is not set
+# CONFIG_PATA_SC1200 is not set
+# CONFIG_PATA_SERVERWORKS is not set
+# CONFIG_PATA_PDC2027X is not set
+# CONFIG_PATA_SIL680 is not set
+# CONFIG_PATA_SIS is not set
+# CONFIG_PATA_VIA is not set
+# CONFIG_PATA_WINBOND is not set
+# CONFIG_PATA_SCH is not set
 CONFIG_MD=y
 CONFIG_BLK_DEV_MD=m
 CONFIG_MD_LINEAR=m
@@ -522,36 +636,52 @@ CONFIG_DM_SNAPSHOT=m
 CONFIG_DM_MIRROR=m
 CONFIG_DM_ZERO=m
 CONFIG_DM_MULTIPATH=m
-# CONFIG_DM_MULTIPATH_EMC is not set
-# CONFIG_DM_MULTIPATH_RDAC is not set
 # CONFIG_DM_DELAY is not set
-
-#
-# Fusion MPT device support
-#
+# CONFIG_DM_UEVENT is not set
 CONFIG_FUSION=y
 CONFIG_FUSION_SPI=y
 CONFIG_FUSION_FC=m
 CONFIG_FUSION_SAS=y
 CONFIG_FUSION_MAX_SGE=128
 # CONFIG_FUSION_CTL is not set
+# CONFIG_FUSION_LOGGING is not set
 
 #
 # IEEE 1394 (FireWire) support
 #
+
+#
+# Enable only one of the two stacks, unless you know what you are doing
+#
 # CONFIG_FIREWIRE is not set
 # CONFIG_IEEE1394 is not set
 # CONFIG_I2O is not set
 CONFIG_NETDEVICES=y
-# CONFIG_NETDEVICES_MULTIQUEUE is not set
 CONFIG_DUMMY=m
 # CONFIG_BONDING is not set
 # CONFIG_MACVLAN is not set
 # CONFIG_EQUALIZER is not set
 # CONFIG_TUN is not set
+# CONFIG_VETH is not set
 # CONFIG_NET_SB1000 is not set
 # CONFIG_ARCNET is not set
-# CONFIG_PHYLIB is not set
+CONFIG_PHYLIB=y
+
+#
+# MII PHY device drivers
+#
+# CONFIG_MARVELL_PHY is not set
+# CONFIG_DAVICOM_PHY is not set
+# CONFIG_QSEMI_PHY is not set
+# CONFIG_LXT_PHY is not set
+# CONFIG_CICADA_PHY is not set
+# CONFIG_VITESSE_PHY is not set
+# CONFIG_SMSC_PHY is not set
+# CONFIG_BROADCOM_PHY is not set
+# CONFIG_ICPLUS_PHY is not set
+# CONFIG_REALTEK_PHY is not set
+# CONFIG_FIXED_PHY is not set
+# CONFIG_MDIO_BITBANG is not set
 CONFIG_NET_ETHERNET=y
 CONFIG_MII=m
 # CONFIG_HAPPYMEAL is not set
@@ -569,13 +699,16 @@ CONFIG_TULIP=m
 # CONFIG_DM9102 is not set
 # CONFIG_ULI526X is not set
 # CONFIG_HP100 is not set
+# CONFIG_IBM_NEW_EMAC_ZMII is not set
+# CONFIG_IBM_NEW_EMAC_RGMII is not set
+# CONFIG_IBM_NEW_EMAC_TAH is not set
+# CONFIG_IBM_NEW_EMAC_EMAC4 is not set
 CONFIG_NET_PCI=y
 # CONFIG_PCNET32 is not set
 # CONFIG_AMD8111_ETH is not set
 # CONFIG_ADAPTEC_STARFIRE is not set
 # CONFIG_B44 is not set
 # CONFIG_FORCEDETH is not set
-# CONFIG_DGRS is not set
 CONFIG_EEPRO100=m
 CONFIG_E100=m
 # CONFIG_FEALNX is not set
@@ -583,17 +716,22 @@ CONFIG_E100=m
 # CONFIG_NE2K_PCI is not set
 # CONFIG_8139CP is not set
 # CONFIG_8139TOO is not set
+# CONFIG_R6040 is not set
 # CONFIG_SIS900 is not set
 # CONFIG_EPIC100 is not set
 # CONFIG_SUNDANCE is not set
+# CONFIG_TLAN is not set
 # CONFIG_VIA_RHINE is not set
 # CONFIG_SC92031 is not set
 CONFIG_NETDEV_1000=y
 # CONFIG_ACENIC is not set
 # CONFIG_DL2K is not set
 CONFIG_E1000=y
-# CONFIG_E1000_NAPI is not set
 # CONFIG_E1000_DISABLE_PACKET_SPLIT is not set
+# CONFIG_E1000E is not set
+# CONFIG_IP1000 is not set
+CONFIG_IGB=y
+# CONFIG_IGB_LRO is not set
 # CONFIG_NS83820 is not set
 # CONFIG_HAMACHI is not set
 # CONFIG_YELLOWFIN is not set
@@ -606,14 +744,20 @@ CONFIG_TIGON3=y
 # CONFIG_BNX2 is not set
 # CONFIG_QLA3XXX is not set
 # CONFIG_ATL1 is not set
+# CONFIG_ATL1E is not set
 CONFIG_NETDEV_10000=y
 # CONFIG_CHELSIO_T1 is not set
 # CONFIG_CHELSIO_T3 is not set
+# CONFIG_IXGBE is not set
 # CONFIG_IXGB is not set
 # CONFIG_S2IO is not set
 # CONFIG_MYRI10GE is not set
 # CONFIG_NETXEN_NIC is not set
+# CONFIG_NIU is not set
 # CONFIG_MLX4_CORE is not set
+# CONFIG_TEHUTI is not set
+# CONFIG_BNX2X is not set
+# CONFIG_SFC is not set
 # CONFIG_TR is not set
 
 #
@@ -621,6 +765,7 @@ CONFIG_NETDEV_10000=y
 #
 # CONFIG_WLAN_PRE80211 is not set
 # CONFIG_WLAN_80211 is not set
+# CONFIG_IWLWIFI_LEDS is not set
 
 #
 # USB Network Adapters
@@ -629,7 +774,6 @@ CONFIG_NETDEV_10000=y
 # CONFIG_USB_KAWETH is not set
 # CONFIG_USB_PEGASUS is not set
 # CONFIG_USB_RTL8150 is not set
-# CONFIG_USB_USBNET_MII is not set
 # CONFIG_USB_USBNET is not set
 # CONFIG_WAN is not set
 # CONFIG_FDDI is not set
@@ -637,8 +781,8 @@ CONFIG_NETDEV_10000=y
 # CONFIG_PPP is not set
 # CONFIG_SLIP is not set
 # CONFIG_NET_FC is not set
-# CONFIG_SHAPER is not set
 CONFIG_NETCONSOLE=y
+# CONFIG_NETCONSOLE_DYNAMIC is not set
 CONFIG_NETPOLL=y
 # CONFIG_NETPOLL_TRAP is not set
 CONFIG_NET_POLL_CONTROLLER=y
@@ -660,7 +804,6 @@ CONFIG_INPUT_MOUSEDEV_PSAUX=y
 CONFIG_INPUT_MOUSEDEV_SCREEN_X=1024
 CONFIG_INPUT_MOUSEDEV_SCREEN_Y=768
 # CONFIG_INPUT_JOYDEV is not set
-# CONFIG_INPUT_TSDEV is not set
 # CONFIG_INPUT_EVDEV is not set
 # CONFIG_INPUT_EVBUG is not set
 
@@ -709,9 +852,11 @@ CONFIG_GAMEPORT=m
 # Character devices
 #
 CONFIG_VT=y
+CONFIG_CONSOLE_TRANSLATIONS=y
 CONFIG_VT_CONSOLE=y
 CONFIG_HW_CONSOLE=y
 # CONFIG_VT_HW_CONSOLE_BINDING is not set
+CONFIG_DEVKMEM=y
 CONFIG_SERIAL_NONSTANDARD=y
 # CONFIG_COMPUTONE is not set
 # CONFIG_ROCKETPORT is not set
@@ -719,15 +864,16 @@ CONFIG_SERIAL_NONSTANDARD=y
 # CONFIG_DIGIEPCA is not set
 # CONFIG_MOXA_INTELLIO is not set
 # CONFIG_MOXA_SMARTIO is not set
-# CONFIG_MOXA_SMARTIO_NEW is not set
 # CONFIG_ISI is not set
 # CONFIG_SYNCLINKMP is not set
 # CONFIG_SYNCLINK_GT is not set
 # CONFIG_N_HDLC is not set
+# CONFIG_RISCOM8 is not set
 # CONFIG_SPECIALIX is not set
 # CONFIG_SX is not set
 # CONFIG_RIO is not set
 # CONFIG_STALDRV is not set
+# CONFIG_NOZOMI is not set
 CONFIG_SGI_SNSC=y
 CONFIG_SGI_TIOCX=y
 CONFIG_SGI_MBCS=m
@@ -759,76 +905,100 @@ CONFIG_UNIX98_PTYS=y
 CONFIG_LEGACY_PTYS=y
 CONFIG_LEGACY_PTY_COUNT=256
 # CONFIG_IPMI_HANDLER is not set
-# CONFIG_WATCHDOG is not set
 # CONFIG_HW_RANDOM is not set
 CONFIG_EFI_RTC=y
 # CONFIG_R3964 is not set
 # CONFIG_APPLICOM is not set
-CONFIG_AGP=m
-CONFIG_AGP_I460=m
-CONFIG_AGP_HP_ZX1=m
-CONFIG_AGP_SGI_TIOCA=m
-CONFIG_DRM=m
-CONFIG_DRM_TDFX=m
-CONFIG_DRM_R128=m
-CONFIG_DRM_RADEON=m
-CONFIG_DRM_MGA=m
-CONFIG_DRM_SIS=m
-# CONFIG_DRM_VIA is not set
-# CONFIG_DRM_SAVAGE is not set
 CONFIG_RAW_DRIVER=m
 CONFIG_MAX_RAW_DEVS=256
 CONFIG_HPET=y
-# CONFIG_HPET_RTC_IRQ is not set
 CONFIG_HPET_MMAP=y
 # CONFIG_HANGCHECK_TIMER is not set
 CONFIG_MMTIMER=y
 # CONFIG_TCG_TPM is not set
 CONFIG_DEVPORT=y
 # CONFIG_I2C is not set
-
-#
-# SPI support
-#
 # CONFIG_SPI is not set
-# CONFIG_SPI_MASTER is not set
 # CONFIG_W1 is not set
-# CONFIG_POWER_SUPPLY is not set
+CONFIG_POWER_SUPPLY=y
+# CONFIG_POWER_SUPPLY_DEBUG is not set
+# CONFIG_PDA_POWER is not set
+# CONFIG_BATTERY_DS2760 is not set
 CONFIG_HWMON=y
 # CONFIG_HWMON_VID is not set
-# CONFIG_SENSORS_ABITUGURU is not set
+# CONFIG_SENSORS_I5K_AMB is not set
 # CONFIG_SENSORS_F71805F is not set
+# CONFIG_SENSORS_F71882FG is not set
+# CONFIG_SENSORS_IT87 is not set
+# CONFIG_SENSORS_PC87360 is not set
 # CONFIG_SENSORS_PC87427 is not set
+# CONFIG_SENSORS_SIS5595 is not set
 # CONFIG_SENSORS_SMSC47M1 is not set
 # CONFIG_SENSORS_SMSC47B397 is not set
+# CONFIG_SENSORS_VIA686A is not set
 # CONFIG_SENSORS_VT1211 is not set
+# CONFIG_SENSORS_VT8231 is not set
 # CONFIG_SENSORS_W83627HF is not set
+# CONFIG_SENSORS_W83627EHF is not set
 # CONFIG_HWMON_DEBUG_CHIP is not set
+CONFIG_THERMAL=m
+# CONFIG_THERMAL_HWMON is not set
+# CONFIG_WATCHDOG is not set
+
+#
+# Sonics Silicon Backplane
+#
+CONFIG_SSB_POSSIBLE=y
+# CONFIG_SSB is not set
 
 #
 # Multifunction device drivers
 #
+# CONFIG_MFD_CORE is not set
 # CONFIG_MFD_SM501 is not set
+# CONFIG_HTC_PASIC3 is not set
 
 #
 # Multimedia devices
 #
+
+#
+# Multimedia core support
+#
 # CONFIG_VIDEO_DEV is not set
 # CONFIG_DVB_CORE is not set
+# CONFIG_VIDEO_MEDIA is not set
+
+#
+# Multimedia drivers
+#
 CONFIG_DAB=y
 # CONFIG_USB_DABUSB is not set
 
 #
 # Graphics support
 #
+CONFIG_AGP=m
+CONFIG_AGP_I460=m
+CONFIG_AGP_HP_ZX1=m
+CONFIG_AGP_SGI_TIOCA=m
+CONFIG_DRM=m
+CONFIG_DRM_TDFX=m
+CONFIG_DRM_R128=m
+CONFIG_DRM_RADEON=m
+CONFIG_DRM_MGA=m
+CONFIG_DRM_SIS=m
+# CONFIG_DRM_VIA is not set
+# CONFIG_DRM_SAVAGE is not set
+# CONFIG_VGASTATE is not set
+# CONFIG_VIDEO_OUTPUT_CONTROL is not set
+# CONFIG_FB is not set
 # CONFIG_BACKLIGHT_LCD_SUPPORT is not set
 
 #
 # Display device support
 #
 # CONFIG_DISPLAY_SUPPORT is not set
-# CONFIG_VGASTATE is not set
-# CONFIG_FB is not set
 
 #
 # Console display driver support
@@ -836,15 +1006,7 @@ CONFIG_DAB=y
 CONFIG_VGA_CONSOLE=y
 # CONFIG_VGACON_SOFT_SCROLLBACK is not set
 CONFIG_DUMMY_CONSOLE=y
-
-#
-# Sound
-#
 CONFIG_SOUND=m
-
-#
-# Advanced Linux Sound Architecture
-#
 CONFIG_SND=m
 CONFIG_SND_TIMER=m
 CONFIG_SND_PCM=m
@@ -862,22 +1024,18 @@ CONFIG_SND_SUPPORT_OLD_API=y
 CONFIG_SND_VERBOSE_PROCFS=y
 CONFIG_SND_VERBOSE_PRINTK=y
 # CONFIG_SND_DEBUG is not set
-
-#
-# Generic devices
-#
+CONFIG_SND_VMASTER=y
 CONFIG_SND_MPU401_UART=m
 CONFIG_SND_OPL3_LIB=m
 CONFIG_SND_AC97_CODEC=m
+CONFIG_SND_DRIVERS=y
 CONFIG_SND_DUMMY=m
 CONFIG_SND_VIRMIDI=m
 CONFIG_SND_MTPAV=m
 CONFIG_SND_SERIAL_U16550=m
 CONFIG_SND_MPU401=m
-
-#
-# PCI devices
-#
+# CONFIG_SND_AC97_POWER_SAVE is not set
+CONFIG_SND_PCI=y
 # CONFIG_SND_AD1889 is not set
 # CONFIG_SND_ALS300 is not set
 # CONFIG_SND_ALI5451 is not set
@@ -886,10 +1044,12 @@ CONFIG_SND_MPU401=m
 # CONFIG_SND_AU8810 is not set
 # CONFIG_SND_AU8820 is not set
 # CONFIG_SND_AU8830 is not set
+# CONFIG_SND_AW2 is not set
 # CONFIG_SND_AZT3328 is not set
 # CONFIG_SND_BT87X is not set
 # CONFIG_SND_CA0106 is not set
 # CONFIG_SND_CMIPCI is not set
+# CONFIG_SND_OXYGEN is not set
 CONFIG_SND_CS4281=m
 CONFIG_SND_CS46XX=m
 CONFIG_SND_CS46XX_NEW_DSP=y
@@ -912,10 +1072,10 @@ CONFIG_SND_EMU10K1=m
 # CONFIG_SND_ES1938 is not set
 # CONFIG_SND_ES1968 is not set
 CONFIG_SND_FM801=m
-# CONFIG_SND_FM801_TEA575X_BOOL is not set
 # CONFIG_SND_HDA_INTEL is not set
 # CONFIG_SND_HDSP is not set
 # CONFIG_SND_HDSPM is not set
+# CONFIG_SND_HIFIER is not set
 # CONFIG_SND_ICE1712 is not set
 # CONFIG_SND_ICE1724 is not set
 # CONFIG_SND_INTEL8X0 is not set
@@ -933,29 +1093,19 @@ CONFIG_SND_FM801=m
 # CONFIG_SND_TRIDENT is not set
 # CONFIG_SND_VIA82XX is not set
 # CONFIG_SND_VIA82XX_MODEM is not set
+# CONFIG_SND_VIRTUOSO is not set
 # CONFIG_SND_VX222 is not set
 # CONFIG_SND_YMFPCI is not set
-# CONFIG_SND_AC97_POWER_SAVE is not set
-
-#
-# USB devices
-#
+CONFIG_SND_USB=y
 # CONFIG_SND_USB_AUDIO is not set
 # CONFIG_SND_USB_CAIAQ is not set
-
-#
-# System on Chip audio support
-#
 # CONFIG_SND_SOC is not set
-
-#
-# Open Sound System
-#
 # CONFIG_SOUND_PRIME is not set
 CONFIG_AC97_BUS=m
 CONFIG_HID_SUPPORT=y
 CONFIG_HID=y
 # CONFIG_HID_DEBUG is not set
+# CONFIG_HIDRAW is not set
 
 #
 # USB Input Devices
@@ -976,6 +1126,7 @@ CONFIG_USB_ARCH_HAS_OHCI=y
 CONFIG_USB_ARCH_HAS_EHCI=y
 CONFIG_USB=m
 # CONFIG_USB_DEBUG is not set
+# CONFIG_USB_ANNOUNCE_NEW_DEVICES is not set
 
 #
 # Miscellaneous USB options
@@ -984,17 +1135,17 @@ CONFIG_USB_DEVICEFS=y
 CONFIG_USB_DEVICE_CLASS=y
 # CONFIG_USB_DYNAMIC_MINORS is not set
 # CONFIG_USB_SUSPEND is not set
-# CONFIG_USB_PERSIST is not set
 # CONFIG_USB_OTG is not set
 
 #
 # USB Host Controller Drivers
 #
+# CONFIG_USB_C67X00_HCD is not set
 CONFIG_USB_EHCI_HCD=m
-# CONFIG_USB_EHCI_SPLIT_ISO is not set
 # CONFIG_USB_EHCI_ROOT_HUB_TT is not set
 # CONFIG_USB_EHCI_TT_NEWSCHED is not set
 # CONFIG_USB_ISP116X_HCD is not set
+# CONFIG_USB_ISP1760_HCD is not set
 CONFIG_USB_OHCI_HCD=m
 # CONFIG_USB_OHCI_BIG_ENDIAN_DESC is not set
 # CONFIG_USB_OHCI_BIG_ENDIAN_MMIO is not set
@@ -1008,6 +1159,7 @@ CONFIG_USB_UHCI_HCD=m
 #
 # CONFIG_USB_ACM is not set
 # CONFIG_USB_PRINTER is not set
+# CONFIG_USB_WDM is not set
 
 #
 # NOTE: USB_STORAGE enables SCSI, and 'SCSI disk support'
@@ -1027,7 +1179,9 @@ CONFIG_USB_STORAGE=m
 # CONFIG_USB_STORAGE_SDDR55 is not set
 # CONFIG_USB_STORAGE_JUMPSHOT is not set
 # CONFIG_USB_STORAGE_ALAUDA is not set
+# CONFIG_USB_STORAGE_ONETOUCH is not set
 # CONFIG_USB_STORAGE_KARMA is not set
+# CONFIG_USB_STORAGE_CYPRESS_ATACB is not set
 # CONFIG_USB_LIBUSUAL is not set
 
 #
@@ -1040,10 +1194,6 @@ CONFIG_USB_MON=y
 #
 # USB port drivers
 #
-
-#
-# USB Serial Converter support
-#
 # CONFIG_USB_SERIAL is not set
 
 #
@@ -1069,67 +1219,32 @@ CONFIG_USB_MON=y
 # CONFIG_USB_TRANCEVIBRATOR is not set
 # CONFIG_USB_IOWARRIOR is not set
 # CONFIG_USB_TEST is not set
-
-#
-# USB DSL modem support
-#
-
-#
-# USB Gadget Support
-#
+# CONFIG_USB_ISIGHTFW is not set
 # CONFIG_USB_GADGET is not set
 # CONFIG_MMC is not set
-
-#
-# LED devices
-#
+# CONFIG_MEMSTICK is not set
 # CONFIG_NEW_LEDS is not set
-
-#
-# LED drivers
-#
-
-#
-# LED Triggers
-#
+# CONFIG_ACCESSIBILITY is not set
 CONFIG_INFINIBAND=m
 # CONFIG_INFINIBAND_USER_MAD is not set
 # CONFIG_INFINIBAND_USER_ACCESS is not set
 CONFIG_INFINIBAND_ADDR_TRANS=y
 CONFIG_INFINIBAND_MTHCA=m
 CONFIG_INFINIBAND_MTHCA_DEBUG=y
+# CONFIG_INFINIBAND_IPATH is not set
 # CONFIG_INFINIBAND_AMSO1100 is not set
 # CONFIG_MLX4_INFINIBAND is not set
+# CONFIG_INFINIBAND_NES is not set
 CONFIG_INFINIBAND_IPOIB=m
 # CONFIG_INFINIBAND_IPOIB_CM is not set
 CONFIG_INFINIBAND_IPOIB_DEBUG=y
 # CONFIG_INFINIBAND_IPOIB_DEBUG_DATA is not set
 # CONFIG_INFINIBAND_SRP is not set
 # CONFIG_INFINIBAND_ISER is not set
-
-#
-# Real Time Clock
-#
 # CONFIG_RTC_CLASS is not set
-
-#
-# DMA Engine support
-#
-# CONFIG_DMA_ENGINE is not set
-
-#
-# DMA Clients
-#
-
-#
-# DMA Devices
-#
-
-#
-# Userspace I/O
-#
+# CONFIG_DMADEVICES is not set
 # CONFIG_UIO is not set
-# CONFIG_MSPEC is not set
+CONFIG_MSPEC=m
 
 #
 # File systems
@@ -1145,7 +1260,6 @@ CONFIG_EXT3_FS_POSIX_ACL=y
 CONFIG_EXT3_FS_SECURITY=y
 # CONFIG_EXT4DEV_FS is not set
 CONFIG_JBD=y
-# CONFIG_JBD_DEBUG is not set
 CONFIG_FS_MBCACHE=y
 CONFIG_REISERFS_FS=y
 # CONFIG_REISERFS_CHECK is not set
@@ -1157,17 +1271,15 @@ CONFIG_REISERFS_FS_SECURITY=y
 CONFIG_FS_POSIX_ACL=y
 CONFIG_XFS_FS=y
 # CONFIG_XFS_QUOTA is not set
-# CONFIG_XFS_SECURITY is not set
 # CONFIG_XFS_POSIX_ACL is not set
 # CONFIG_XFS_RT is not set
+# CONFIG_XFS_DEBUG is not set
 # CONFIG_GFS2_FS is not set
 # CONFIG_OCFS2_FS is not set
-# CONFIG_MINIX_FS is not set
-# CONFIG_ROMFS_FS is not set
+CONFIG_DNOTIFY=y
 CONFIG_INOTIFY=y
 CONFIG_INOTIFY_USER=y
 # CONFIG_QUOTA is not set
-CONFIG_DNOTIFY=y
 CONFIG_AUTOFS_FS=y
 CONFIG_AUTOFS4_FS=y
 # CONFIG_FUSE_FS is not set
@@ -1205,7 +1317,6 @@ CONFIG_TMPFS=y
 # CONFIG_TMPFS_POSIX_ACL is not set
 CONFIG_HUGETLBFS=y
 CONFIG_HUGETLB_PAGE=y
-CONFIG_RAMFS=y
 # CONFIG_CONFIGFS_FS is not set
 
 #
@@ -1220,32 +1331,30 @@ CONFIG_RAMFS=y
 # CONFIG_EFS_FS is not set
 # CONFIG_CRAMFS is not set
 # CONFIG_VXFS_FS is not set
+# CONFIG_MINIX_FS is not set
+# CONFIG_OMFS_FS is not set
 # CONFIG_HPFS_FS is not set
 # CONFIG_QNX4FS_FS is not set
+# CONFIG_ROMFS_FS is not set
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
-
-#
-# Network File Systems
-#
+CONFIG_NETWORK_FILESYSTEMS=y
 CONFIG_NFS_FS=m
 CONFIG_NFS_V3=y
 # CONFIG_NFS_V3_ACL is not set
 CONFIG_NFS_V4=y
-CONFIG_NFS_DIRECTIO=y
 CONFIG_NFSD=m
 CONFIG_NFSD_V3=y
 # CONFIG_NFSD_V3_ACL is not set
 CONFIG_NFSD_V4=y
-CONFIG_NFSD_TCP=y
 CONFIG_LOCKD=m
 CONFIG_LOCKD_V4=y
 CONFIG_EXPORTFS=m
 CONFIG_NFS_COMMON=y
 CONFIG_SUNRPC=m
 CONFIG_SUNRPC_GSS=m
-# CONFIG_SUNRPC_BIND34 is not set
-CONFIG_RPCSEC_GSS_KRB5=y
+CONFIG_SUNRPC_XPRT_RDMA=m
+CONFIG_RPCSEC_GSS_KRB5=m
 # CONFIG_RPCSEC_GSS_SPKM3 is not set
 CONFIG_SMB_FS=m
 CONFIG_SMB_NLS_DEFAULT=y
@@ -1281,10 +1390,6 @@ CONFIG_SGI_PARTITION=y
 # CONFIG_KARMA_PARTITION is not set
 CONFIG_EFI_PARTITION=y
 # CONFIG_SYSV68_PARTITION is not set
-
-#
-# Native Language Support
-#
 CONFIG_NLS=y
 CONFIG_NLS_DEFAULT="iso8859-1"
 CONFIG_NLS_CODEPAGE_437=y
@@ -1325,22 +1430,24 @@ CONFIG_NLS_ISO8859_15=m
 CONFIG_NLS_KOI8_R=m
 CONFIG_NLS_KOI8_U=m
 CONFIG_NLS_UTF8=m
-
-#
-# Distributed Lock Manager
-#
 # CONFIG_DLM is not set
+CONFIG_HAVE_KVM=y
+CONFIG_VIRTUALIZATION=y
+# CONFIG_KVM is not set
 
 #
 # Library routines
 #
 CONFIG_BITREVERSE=y
+# CONFIG_GENERIC_FIND_FIRST_BIT is not set
 # CONFIG_CRC_CCITT is not set
 # CONFIG_CRC16 is not set
-# CONFIG_CRC_ITU_T is not set
+CONFIG_CRC_T10DIF=y
+CONFIG_CRC_ITU_T=m
 CONFIG_CRC32=y
 # CONFIG_CRC7 is not set
 # CONFIG_LIBCRC32C is not set
+CONFIG_GENERIC_ALLOCATOR=y
 CONFIG_PLIST=y
 CONFIG_HAS_IOMEM=y
 CONFIG_HAS_IOPORT=y
@@ -1358,16 +1465,12 @@ CONFIG_IRQ_PER_CPU=y
 # CONFIG_HP_SIMSCSI is not set
 
 #
-# Instrumentation Support
-#
-# CONFIG_PROFILING is not set
-# CONFIG_KPROBES is not set
-
-#
 # Kernel hacking
 #
 # CONFIG_PRINTK_TIME is not set
+CONFIG_ENABLE_WARN_DEPRECATED=y
 CONFIG_ENABLE_MUST_CHECK=y
+CONFIG_FRAME_WARN=2048
 CONFIG_MAGIC_SYSRQ=y
 # CONFIG_UNUSED_SYMBOLS is not set
 # CONFIG_DEBUG_FS is not set
@@ -1375,10 +1478,14 @@ CONFIG_MAGIC_SYSRQ=y
 CONFIG_DEBUG_KERNEL=y
 # CONFIG_DEBUG_SHIRQ is not set
 CONFIG_DETECT_SOFTLOCKUP=y
+# CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC is not set
+CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC_VALUE=0
 CONFIG_SCHED_DEBUG=y
 # CONFIG_SCHEDSTATS is not set
 # CONFIG_TIMER_STATS is not set
-# CONFIG_DEBUG_SLAB is not set
+# CONFIG_DEBUG_OBJECTS is not set
+# CONFIG_SLUB_DEBUG_ON is not set
+# CONFIG_SLUB_STATS is not set
 # CONFIG_DEBUG_RT_MUTEXES is not set
 # CONFIG_RT_MUTEX_TESTER is not set
 # CONFIG_DEBUG_SPINLOCK is not set
@@ -1388,10 +1495,15 @@ CONFIG_DEBUG_MUTEXES=y
 # CONFIG_DEBUG_KOBJECT is not set
 # CONFIG_DEBUG_INFO is not set
 # CONFIG_DEBUG_VM is not set
+# CONFIG_DEBUG_WRITECOUNT is not set
+CONFIG_DEBUG_MEMORY_INIT=y
 # CONFIG_DEBUG_LIST is not set
-CONFIG_FORCED_INLINING=y
+# CONFIG_DEBUG_SG is not set
+# CONFIG_BOOT_PRINTK_DELAY is not set
 # CONFIG_RCU_TORTURE_TEST is not set
+# CONFIG_BACKTRACE_SELF_TEST is not set
 # CONFIG_FAULT_INJECTION is not set
+# CONFIG_SAMPLES is not set
 CONFIG_IA64_GRANULE_16MB=y
 # CONFIG_IA64_GRANULE_64MB is not set
 # CONFIG_IA64_PRINT_HAZARDS is not set
@@ -1405,41 +1517,85 @@ CONFIG_SYSVIPC_COMPAT=y
 #
 # CONFIG_KEYS is not set
 # CONFIG_SECURITY is not set
+# CONFIG_SECURITY_FILE_CAPABILITIES is not set
 CONFIG_CRYPTO=y
+
+#
+# Crypto core or helper
+#
 CONFIG_CRYPTO_ALGAPI=y
 CONFIG_CRYPTO_BLKCIPHER=m
 CONFIG_CRYPTO_MANAGER=m
+# CONFIG_CRYPTO_GF128MUL is not set
+# CONFIG_CRYPTO_NULL is not set
+# CONFIG_CRYPTO_CRYPTD is not set
+# CONFIG_CRYPTO_AUTHENC is not set
+# CONFIG_CRYPTO_TEST is not set
+
+#
+# Authenticated Encryption with Associated Data
+#
+# CONFIG_CRYPTO_CCM is not set
+# CONFIG_CRYPTO_GCM is not set
+# CONFIG_CRYPTO_SEQIV is not set
+
+#
+# Block modes
+#
+CONFIG_CRYPTO_CBC=m
+# CONFIG_CRYPTO_CTR is not set
+# CONFIG_CRYPTO_CTS is not set
+CONFIG_CRYPTO_ECB=m
+# CONFIG_CRYPTO_LRW is not set
+CONFIG_CRYPTO_PCBC=m
+# CONFIG_CRYPTO_XTS is not set
+
+#
+# Hash modes
+#
 # CONFIG_CRYPTO_HMAC is not set
 # CONFIG_CRYPTO_XCBC is not set
-# CONFIG_CRYPTO_NULL is not set
+
+#
+# Digest
+#
+# CONFIG_CRYPTO_CRC32C is not set
 # CONFIG_CRYPTO_MD4 is not set
 CONFIG_CRYPTO_MD5=y
+# CONFIG_CRYPTO_MICHAEL_MIC is not set
+# CONFIG_CRYPTO_RMD128 is not set
+# CONFIG_CRYPTO_RMD160 is not set
+# CONFIG_CRYPTO_RMD256 is not set
+# CONFIG_CRYPTO_RMD320 is not set
 # CONFIG_CRYPTO_SHA1 is not set
 # CONFIG_CRYPTO_SHA256 is not set
 # CONFIG_CRYPTO_SHA512 is not set
-# CONFIG_CRYPTO_WP512 is not set
 # CONFIG_CRYPTO_TGR192 is not set
-# CONFIG_CRYPTO_GF128MUL is not set
-CONFIG_CRYPTO_ECB=m
-CONFIG_CRYPTO_CBC=m
-CONFIG_CRYPTO_PCBC=m
-# CONFIG_CRYPTO_LRW is not set
-# CONFIG_CRYPTO_CRYPTD is not set
-CONFIG_CRYPTO_DES=m
-# CONFIG_CRYPTO_FCRYPT is not set
-# CONFIG_CRYPTO_BLOWFISH is not set
-# CONFIG_CRYPTO_TWOFISH is not set
-# CONFIG_CRYPTO_SERPENT is not set
+# CONFIG_CRYPTO_WP512 is not set
+
+#
+# Ciphers
+#
 # CONFIG_CRYPTO_AES is not set
+# CONFIG_CRYPTO_ANUBIS is not set
+# CONFIG_CRYPTO_ARC4 is not set
+# CONFIG_CRYPTO_BLOWFISH is not set
+# CONFIG_CRYPTO_CAMELLIA is not set
 # CONFIG_CRYPTO_CAST5 is not set
 # CONFIG_CRYPTO_CAST6 is not set
-# CONFIG_CRYPTO_TEA is not set
-# CONFIG_CRYPTO_ARC4 is not set
+CONFIG_CRYPTO_DES=m
+# CONFIG_CRYPTO_FCRYPT is not set
 # CONFIG_CRYPTO_KHAZAD is not set
-# CONFIG_CRYPTO_ANUBIS is not set
+# CONFIG_CRYPTO_SALSA20 is not set
+# CONFIG_CRYPTO_SEED is not set
+# CONFIG_CRYPTO_SERPENT is not set
+# CONFIG_CRYPTO_TEA is not set
+# CONFIG_CRYPTO_TWOFISH is not set
+
+#
+# Compression
+#
 # CONFIG_CRYPTO_DEFLATE is not set
-# CONFIG_CRYPTO_MICHAEL_MIC is not set
-# CONFIG_CRYPTO_CRC32C is not set
-# CONFIG_CRYPTO_CAMELLIA is not set
-# CONFIG_CRYPTO_TEST is not set
+# CONFIG_CRYPTO_LZO is not set
 CONFIG_CRYPTO_HW=y
+# CONFIG_CRYPTO_DEV_HIFN_795X is not set
diff --git a/arch/ia64/kernel/.gitignore b/arch/ia64/kernel/.gitignore
index 98307759a3b8..21cb0da5ded8 100644
--- a/arch/ia64/kernel/.gitignore
+++ b/arch/ia64/kernel/.gitignore
@@ -1 +1,2 @@
 gate.lds
+vmlinux.lds
diff --git a/arch/ia64/kernel/ivt.S b/arch/ia64/kernel/ivt.S
index c39627df3cde..416a952b19bd 100644
--- a/arch/ia64/kernel/ivt.S
+++ b/arch/ia64/kernel/ivt.S
@@ -1243,11 +1243,11 @@ ENTRY(speculation_vector)
 
         add r17=r17,r18                 // now add the offset
         ;;
-        MOV_FROM_IIP(r17)
+        MOV_TO_IIP(r17, r19)
         dep r16=0,r16,41,2              // clear EI
         ;;
 
-        MOV_FROM_IPSR(p0, r16)
+        MOV_TO_IPSR(p0, r16, r19)
         ;;
 
         RFI
diff --git a/include/asm-m68knommu/Kbuild b/arch/m68knommu/include/asm/Kbuild
index c68e1680da01..c68e1680da01 100644
--- a/include/asm-m68knommu/Kbuild
+++ b/arch/m68knommu/include/asm/Kbuild
diff --git a/include/asm-m68knommu/MC68328.h b/arch/m68knommu/include/asm/MC68328.h
index a337e56d09bf..a337e56d09bf 100644
--- a/include/asm-m68knommu/MC68328.h
+++ b/arch/m68knommu/include/asm/MC68328.h
diff --git a/include/asm-m68knommu/MC68332.h b/arch/m68knommu/include/asm/MC68332.h
index 6bb8f02685a2..6bb8f02685a2 100644
--- a/include/asm-m68knommu/MC68332.h
+++ b/arch/m68knommu/include/asm/MC68332.h
diff --git a/include/asm-m68knommu/MC68EZ328.h b/arch/m68knommu/include/asm/MC68EZ328.h
index 69b7f9139e5e..69b7f9139e5e 100644
--- a/include/asm-m68knommu/MC68EZ328.h
+++ b/arch/m68knommu/include/asm/MC68EZ328.h
diff --git a/include/asm-m68knommu/MC68VZ328.h b/arch/m68knommu/include/asm/MC68VZ328.h
index 2b9bf626a0a5..2b9bf626a0a5 100644
--- a/include/asm-m68knommu/MC68VZ328.h
+++ b/arch/m68knommu/include/asm/MC68VZ328.h
diff --git a/include/asm-m68knommu/a.out.h b/arch/m68knommu/include/asm/a.out.h
index ce18ef99de04..ce18ef99de04 100644
--- a/include/asm-m68knommu/a.out.h
+++ b/arch/m68knommu/include/asm/a.out.h
diff --git a/include/asm-m68knommu/anchor.h b/arch/m68knommu/include/asm/anchor.h
index 871c0d5cfc3d..871c0d5cfc3d 100644
--- a/include/asm-m68knommu/anchor.h
+++ b/arch/m68knommu/include/asm/anchor.h
diff --git a/include/asm-m68knommu/atomic.h b/arch/m68knommu/include/asm/atomic.h
index d5632a305dae..d5632a305dae 100644
--- a/include/asm-m68knommu/atomic.h
+++ b/arch/m68knommu/include/asm/atomic.h
diff --git a/include/asm-m68knommu/auxvec.h b/arch/m68knommu/include/asm/auxvec.h
index 844d6d52204b..844d6d52204b 100644
--- a/include/asm-m68knommu/auxvec.h
+++ b/arch/m68knommu/include/asm/auxvec.h
diff --git a/include/asm-m68knommu/bitops.h b/arch/m68knommu/include/asm/bitops.h
index 6f3685eab44c..6f3685eab44c 100644
--- a/include/asm-m68knommu/bitops.h
+++ b/arch/m68knommu/include/asm/bitops.h
diff --git a/include/asm-m68knommu/bootinfo.h b/arch/m68knommu/include/asm/bootinfo.h
index c12e526f5189..c12e526f5189 100644
--- a/include/asm-m68knommu/bootinfo.h
+++ b/arch/m68knommu/include/asm/bootinfo.h
diff --git a/include/asm-m68knommu/bootstd.h b/arch/m68knommu/include/asm/bootstd.h
index bdc1a4ac4fe9..bdc1a4ac4fe9 100644
--- a/include/asm-m68knommu/bootstd.h
+++ b/arch/m68knommu/include/asm/bootstd.h
diff --git a/include/asm-m68knommu/bug.h b/arch/m68knommu/include/asm/bug.h
index 70e7dc0af21a..70e7dc0af21a 100644
--- a/include/asm-m68knommu/bug.h
+++ b/arch/m68knommu/include/asm/bug.h
diff --git a/include/asm-m68knommu/bugs.h b/arch/m68knommu/include/asm/bugs.h
index 5f382dac3a60..5f382dac3a60 100644
--- a/include/asm-m68knommu/bugs.h
+++ b/arch/m68knommu/include/asm/bugs.h
diff --git a/include/asm-m68knommu/byteorder.h b/arch/m68knommu/include/asm/byteorder.h
index 20bb4426b610..20bb4426b610 100644
--- a/include/asm-m68knommu/byteorder.h
+++ b/arch/m68knommu/include/asm/byteorder.h
diff --git a/include/asm-m68knommu/cache.h b/arch/m68knommu/include/asm/cache.h
index 24e9eace5f8c..24e9eace5f8c 100644
--- a/include/asm-m68knommu/cache.h
+++ b/arch/m68knommu/include/asm/cache.h
diff --git a/include/asm-m68knommu/cachectl.h b/arch/m68knommu/include/asm/cachectl.h
index bcf5a6a9dd52..bcf5a6a9dd52 100644
--- a/include/asm-m68knommu/cachectl.h
+++ b/arch/m68knommu/include/asm/cachectl.h
diff --git a/include/asm-m68knommu/cacheflush.h b/arch/m68knommu/include/asm/cacheflush.h
index 87e5dc0413b4..87e5dc0413b4 100644
--- a/include/asm-m68knommu/cacheflush.h
+++ b/arch/m68knommu/include/asm/cacheflush.h
diff --git a/include/asm-m68knommu/checksum.h b/arch/m68knommu/include/asm/checksum.h
index 81883482ffb1..81883482ffb1 100644
--- a/include/asm-m68knommu/checksum.h
+++ b/arch/m68knommu/include/asm/checksum.h
diff --git a/include/asm-m68knommu/coldfire.h b/arch/m68knommu/include/asm/coldfire.h
index 83a9fa4e618a..83a9fa4e618a 100644
--- a/include/asm-m68knommu/coldfire.h
+++ b/arch/m68knommu/include/asm/coldfire.h
diff --git a/include/asm-m68knommu/commproc.h b/arch/m68knommu/include/asm/commproc.h
index edf5eb6c08d2..edf5eb6c08d2 100644
--- a/include/asm-m68knommu/commproc.h
+++ b/arch/m68knommu/include/asm/commproc.h
diff --git a/include/asm-m68knommu/cputime.h b/arch/m68knommu/include/asm/cputime.h
index a0c4a660878d..a0c4a660878d 100644
--- a/include/asm-m68knommu/cputime.h
+++ b/arch/m68knommu/include/asm/cputime.h
diff --git a/include/asm-m68knommu/current.h b/arch/m68knommu/include/asm/current.h
index 53ee0f9f7cef..53ee0f9f7cef 100644
--- a/include/asm-m68knommu/current.h
+++ b/arch/m68knommu/include/asm/current.h
diff --git a/include/asm-m68knommu/dbg.h b/arch/m68knommu/include/asm/dbg.h
index 27af3270f671..27af3270f671 100644
--- a/include/asm-m68knommu/dbg.h
+++ b/arch/m68knommu/include/asm/dbg.h
diff --git a/include/asm-m68knommu/delay.h b/arch/m68knommu/include/asm/delay.h
index 55cbd6294ab6..55cbd6294ab6 100644
--- a/include/asm-m68knommu/delay.h
+++ b/arch/m68knommu/include/asm/delay.h
diff --git a/include/asm-m68knommu/device.h b/arch/m68knommu/include/asm/device.h
index d8f9872b0e2d..d8f9872b0e2d 100644
--- a/include/asm-m68knommu/device.h
+++ b/arch/m68knommu/include/asm/device.h
diff --git a/include/asm-m68knommu/div64.h b/arch/m68knommu/include/asm/div64.h
index 6cd978cefb28..6cd978cefb28 100644
--- a/include/asm-m68knommu/div64.h
+++ b/arch/m68knommu/include/asm/div64.h
diff --git a/include/asm-m68knommu/dma-mapping.h b/arch/m68knommu/include/asm/dma-mapping.h
index 6aeab18e58bd..6aeab18e58bd 100644
--- a/include/asm-m68knommu/dma-mapping.h
+++ b/arch/m68knommu/include/asm/dma-mapping.h
diff --git a/include/asm-m68knommu/dma.h b/arch/m68knommu/include/asm/dma.h
index 939a02056217..939a02056217 100644
--- a/include/asm-m68knommu/dma.h
+++ b/arch/m68knommu/include/asm/dma.h
diff --git a/include/asm-m68knommu/elf.h b/arch/m68knommu/include/asm/elf.h
index 27f0ec70fba8..27f0ec70fba8 100644
--- a/include/asm-m68knommu/elf.h
+++ b/arch/m68knommu/include/asm/elf.h
diff --git a/include/asm-m68knommu/elia.h b/arch/m68knommu/include/asm/elia.h
index e037d4e2de33..e037d4e2de33 100644
--- a/include/asm-m68knommu/elia.h
+++ b/arch/m68knommu/include/asm/elia.h
diff --git a/include/asm-m68knommu/emergency-restart.h b/arch/m68knommu/include/asm/emergency-restart.h
index 108d8c48e42e..108d8c48e42e 100644
--- a/include/asm-m68knommu/emergency-restart.h
+++ b/arch/m68knommu/include/asm/emergency-restart.h
diff --git a/include/asm-m68knommu/entry.h b/arch/m68knommu/include/asm/entry.h
index c2553d26273d..c2553d26273d 100644
--- a/include/asm-m68knommu/entry.h
+++ b/arch/m68knommu/include/asm/entry.h
diff --git a/include/asm-m68knommu/errno.h b/arch/m68knommu/include/asm/errno.h
index 7e8c22b9a5e6..7e8c22b9a5e6 100644
--- a/include/asm-m68knommu/errno.h
+++ b/arch/m68knommu/include/asm/errno.h
diff --git a/include/asm-m68knommu/fb.h b/arch/m68knommu/include/asm/fb.h
index c7df38030992..c7df38030992 100644
--- a/include/asm-m68knommu/fb.h
+++ b/arch/m68knommu/include/asm/fb.h
diff --git a/include/asm-m68knommu/fcntl.h b/arch/m68knommu/include/asm/fcntl.h
index f6a552cda4cd..f6a552cda4cd 100644
--- a/include/asm-m68knommu/fcntl.h
+++ b/arch/m68knommu/include/asm/fcntl.h
diff --git a/include/asm-m68knommu/flat.h b/arch/m68knommu/include/asm/flat.h
index 814b5174a8e0..814b5174a8e0 100644
--- a/include/asm-m68knommu/flat.h
+++ b/arch/m68knommu/include/asm/flat.h
diff --git a/include/asm-m68knommu/fpu.h b/arch/m68knommu/include/asm/fpu.h
index b16b2e4fca2a..b16b2e4fca2a 100644
--- a/include/asm-m68knommu/fpu.h
+++ b/arch/m68knommu/include/asm/fpu.h
diff --git a/include/asm-m68knommu/futex.h b/arch/m68knommu/include/asm/futex.h
index 6a332a9f099c..6a332a9f099c 100644
--- a/include/asm-m68knommu/futex.h
+++ b/arch/m68knommu/include/asm/futex.h
diff --git a/include/asm-m68knommu/hardirq.h b/arch/m68knommu/include/asm/hardirq.h
index bfad28149a49..bfad28149a49 100644
--- a/include/asm-m68knommu/hardirq.h
+++ b/arch/m68knommu/include/asm/hardirq.h
diff --git a/include/asm-m68knommu/hw_irq.h b/arch/m68knommu/include/asm/hw_irq.h
index f3ec9e5ae049..f3ec9e5ae049 100644
--- a/include/asm-m68knommu/hw_irq.h
+++ b/arch/m68knommu/include/asm/hw_irq.h
diff --git a/include/asm-m68knommu/hwtest.h b/arch/m68knommu/include/asm/hwtest.h
index 700626a1b1bf..700626a1b1bf 100644
--- a/include/asm-m68knommu/hwtest.h
+++ b/arch/m68knommu/include/asm/hwtest.h
diff --git a/include/asm-m68knommu/io.h b/arch/m68knommu/include/asm/io.h
index 6adef1ee2082..6adef1ee2082 100644
--- a/include/asm-m68knommu/io.h
+++ b/arch/m68knommu/include/asm/io.h
diff --git a/include/asm-m68knommu/ioctl.h b/arch/m68knommu/include/asm/ioctl.h
index b279fe06dfe5..b279fe06dfe5 100644
--- a/include/asm-m68knommu/ioctl.h
+++ b/arch/m68knommu/include/asm/ioctl.h
diff --git a/include/asm-m68knommu/ioctls.h b/arch/m68knommu/include/asm/ioctls.h
index 0b1eb4d85059..0b1eb4d85059 100644
--- a/include/asm-m68knommu/ioctls.h
+++ b/arch/m68knommu/include/asm/ioctls.h
diff --git a/include/asm-m68knommu/ipcbuf.h b/arch/m68knommu/include/asm/ipcbuf.h
index e4a7be6dd706..e4a7be6dd706 100644
--- a/include/asm-m68knommu/ipcbuf.h
+++ b/arch/m68knommu/include/asm/ipcbuf.h
diff --git a/include/asm-m68knommu/irq.h b/arch/m68knommu/include/asm/irq.h
index 9373c31ac87d..9373c31ac87d 100644
--- a/include/asm-m68knommu/irq.h
+++ b/arch/m68knommu/include/asm/irq.h
diff --git a/include/asm-m68knommu/irq_regs.h b/arch/m68knommu/include/asm/irq_regs.h
index 3dd9c0b70270..3dd9c0b70270 100644
--- a/include/asm-m68knommu/irq_regs.h
+++ b/arch/m68knommu/include/asm/irq_regs.h
diff --git a/include/asm-m68knommu/kdebug.h b/arch/m68knommu/include/asm/kdebug.h
index 6ece1b037665..6ece1b037665 100644
--- a/include/asm-m68knommu/kdebug.h
+++ b/arch/m68knommu/include/asm/kdebug.h
diff --git a/include/asm-m68knommu/kmap_types.h b/arch/m68knommu/include/asm/kmap_types.h
index bfb6707575d1..bfb6707575d1 100644
--- a/include/asm-m68knommu/kmap_types.h
+++ b/arch/m68knommu/include/asm/kmap_types.h
diff --git a/include/asm-m68knommu/linkage.h b/arch/m68knommu/include/asm/linkage.h
index c288a19ff489..c288a19ff489 100644
--- a/include/asm-m68knommu/linkage.h
+++ b/arch/m68knommu/include/asm/linkage.h
diff --git a/include/asm-m68knommu/local.h b/arch/m68knommu/include/asm/local.h
index 84a39c1b86f8..84a39c1b86f8 100644
--- a/include/asm-m68knommu/local.h
+++ b/arch/m68knommu/include/asm/local.h
diff --git a/include/asm-m68knommu/m5206sim.h b/arch/m68knommu/include/asm/m5206sim.h
index 7e3594dea88b..7e3594dea88b 100644
--- a/include/asm-m68knommu/m5206sim.h
+++ b/arch/m68knommu/include/asm/m5206sim.h
diff --git a/include/asm-m68knommu/m520xsim.h b/arch/m68knommu/include/asm/m520xsim.h
index 49d016e6391a..49d016e6391a 100644
--- a/include/asm-m68knommu/m520xsim.h
+++ b/arch/m68knommu/include/asm/m520xsim.h
diff --git a/include/asm-m68knommu/m523xsim.h b/arch/m68knommu/include/asm/m523xsim.h
index bf397313e93f..bf397313e93f 100644
--- a/include/asm-m68knommu/m523xsim.h
+++ b/arch/m68knommu/include/asm/m523xsim.h
diff --git a/include/asm-m68knommu/m5249sim.h b/arch/m68knommu/include/asm/m5249sim.h
index 366eb8602d2f..366eb8602d2f 100644
--- a/include/asm-m68knommu/m5249sim.h
+++ b/arch/m68knommu/include/asm/m5249sim.h
diff --git a/include/asm-m68knommu/m5272sim.h b/arch/m68knommu/include/asm/m5272sim.h
index 6217edc21139..6217edc21139 100644
--- a/include/asm-m68knommu/m5272sim.h
+++ b/arch/m68knommu/include/asm/m5272sim.h
diff --git a/include/asm-m68knommu/m527xsim.h b/arch/m68knommu/include/asm/m527xsim.h
index 1f63ab3fb3e6..1f63ab3fb3e6 100644
--- a/include/asm-m68knommu/m527xsim.h
+++ b/arch/m68knommu/include/asm/m527xsim.h
diff --git a/include/asm-m68knommu/m528xsim.h b/arch/m68knommu/include/asm/m528xsim.h
index 28bf783a5d6d..28bf783a5d6d 100644
--- a/include/asm-m68knommu/m528xsim.h
+++ b/arch/m68knommu/include/asm/m528xsim.h
diff --git a/include/asm-m68knommu/m5307sim.h b/arch/m68knommu/include/asm/m5307sim.h
index 5886728409c0..5886728409c0 100644
--- a/include/asm-m68knommu/m5307sim.h
+++ b/arch/m68knommu/include/asm/m5307sim.h
diff --git a/include/asm-m68knommu/m532xsim.h b/arch/m68knommu/include/asm/m532xsim.h
index 1835fd20a82c..1835fd20a82c 100644
--- a/include/asm-m68knommu/m532xsim.h
+++ b/arch/m68knommu/include/asm/m532xsim.h
diff --git a/include/asm-m68knommu/m5407sim.h b/arch/m68knommu/include/asm/m5407sim.h
index cc22c4a53005..cc22c4a53005 100644
--- a/include/asm-m68knommu/m5407sim.h
+++ b/arch/m68knommu/include/asm/m5407sim.h
diff --git a/include/asm-m68knommu/m68360.h b/arch/m68knommu/include/asm/m68360.h
index eb7d39ef2855..eb7d39ef2855 100644
--- a/include/asm-m68knommu/m68360.h
+++ b/arch/m68knommu/include/asm/m68360.h
diff --git a/include/asm-m68knommu/m68360_enet.h b/arch/m68knommu/include/asm/m68360_enet.h
index c36f4d059203..c36f4d059203 100644
--- a/include/asm-m68knommu/m68360_enet.h
+++ b/arch/m68knommu/include/asm/m68360_enet.h
diff --git a/include/asm-m68knommu/m68360_pram.h b/arch/m68knommu/include/asm/m68360_pram.h
index e6088bbce93d..e6088bbce93d 100644
--- a/include/asm-m68knommu/m68360_pram.h
+++ b/arch/m68knommu/include/asm/m68360_pram.h
diff --git a/include/asm-m68knommu/m68360_quicc.h b/arch/m68knommu/include/asm/m68360_quicc.h
index 6d40f4d18e10..6d40f4d18e10 100644
--- a/include/asm-m68knommu/m68360_quicc.h
+++ b/arch/m68knommu/include/asm/m68360_quicc.h
diff --git a/include/asm-m68knommu/m68360_regs.h b/arch/m68knommu/include/asm/m68360_regs.h
index d57217ca4f27..d57217ca4f27 100644
--- a/include/asm-m68knommu/m68360_regs.h
+++ b/arch/m68knommu/include/asm/m68360_regs.h
diff --git a/include/asm-m68knommu/machdep.h b/arch/m68knommu/include/asm/machdep.h
index de9f47a51cc2..de9f47a51cc2 100644
--- a/include/asm-m68knommu/machdep.h
+++ b/arch/m68knommu/include/asm/machdep.h
diff --git a/include/asm-m68knommu/math-emu.h b/arch/m68knommu/include/asm/math-emu.h
index 7e7090517b72..7e7090517b72 100644
--- a/include/asm-m68knommu/math-emu.h
+++ b/arch/m68knommu/include/asm/math-emu.h
diff --git a/include/asm-m68knommu/mc146818rtc.h b/arch/m68knommu/include/asm/mc146818rtc.h
index 907a0481a140..907a0481a140 100644
--- a/include/asm-m68knommu/mc146818rtc.h
+++ b/arch/m68knommu/include/asm/mc146818rtc.h
diff --git a/include/asm-m68knommu/mcfcache.h b/arch/m68knommu/include/asm/mcfcache.h
index c042634fadaa..c042634fadaa 100644
--- a/include/asm-m68knommu/mcfcache.h
+++ b/arch/m68knommu/include/asm/mcfcache.h
diff --git a/include/asm-m68knommu/mcfdma.h b/arch/m68knommu/include/asm/mcfdma.h
index 705c52c79cd8..705c52c79cd8 100644
--- a/include/asm-m68knommu/mcfdma.h
+++ b/arch/m68knommu/include/asm/mcfdma.h
diff --git a/include/asm-m68knommu/mcfmbus.h b/arch/m68knommu/include/asm/mcfmbus.h
index 319899c47a2c..319899c47a2c 100644
--- a/include/asm-m68knommu/mcfmbus.h
+++ b/arch/m68knommu/include/asm/mcfmbus.h
diff --git a/include/asm-m68knommu/mcfne.h b/arch/m68knommu/include/asm/mcfne.h
index 431f63aadd0e..431f63aadd0e 100644
--- a/include/asm-m68knommu/mcfne.h
+++ b/arch/m68knommu/include/asm/mcfne.h
diff --git a/include/asm-m68knommu/mcfpci.h b/arch/m68knommu/include/asm/mcfpci.h
index f1507dd06ec6..f1507dd06ec6 100644
--- a/include/asm-m68knommu/mcfpci.h
+++ b/arch/m68knommu/include/asm/mcfpci.h
diff --git a/include/asm-m68knommu/mcfpit.h b/arch/m68knommu/include/asm/mcfpit.h
index f570cf64fd29..f570cf64fd29 100644
--- a/include/asm-m68knommu/mcfpit.h
+++ b/arch/m68knommu/include/asm/mcfpit.h
diff --git a/include/asm-m68knommu/mcfsim.h b/arch/m68knommu/include/asm/mcfsim.h
index da3f2ceff3a4..da3f2ceff3a4 100644
--- a/include/asm-m68knommu/mcfsim.h
+++ b/arch/m68knommu/include/asm/mcfsim.h
diff --git a/include/asm-m68knommu/mcfsmc.h b/arch/m68knommu/include/asm/mcfsmc.h
index 2d7a4dbd9683..2d7a4dbd9683 100644
--- a/include/asm-m68knommu/mcfsmc.h
+++ b/arch/m68knommu/include/asm/mcfsmc.h
diff --git a/include/asm-m68knommu/mcftimer.h b/arch/m68knommu/include/asm/mcftimer.h
index 0f90f6d2227a..0f90f6d2227a 100644
--- a/include/asm-m68knommu/mcftimer.h
+++ b/arch/m68knommu/include/asm/mcftimer.h
diff --git a/include/asm-m68knommu/mcfuart.h b/arch/m68knommu/include/asm/mcfuart.h
index ef2293873612..ef2293873612 100644
--- a/include/asm-m68knommu/mcfuart.h
+++ b/arch/m68knommu/include/asm/mcfuart.h
diff --git a/include/asm-m68knommu/mcfwdebug.h b/arch/m68knommu/include/asm/mcfwdebug.h
index 27f70e45d700..27f70e45d700 100644
--- a/include/asm-m68knommu/mcfwdebug.h
+++ b/arch/m68knommu/include/asm/mcfwdebug.h
diff --git a/include/asm-m68knommu/md.h b/arch/m68knommu/include/asm/md.h
index d810c78de5ff..d810c78de5ff 100644
--- a/include/asm-m68knommu/md.h
+++ b/arch/m68knommu/include/asm/md.h
diff --git a/include/asm-m68knommu/mman.h b/arch/m68knommu/include/asm/mman.h
index 4846c682efed..4846c682efed 100644
--- a/include/asm-m68knommu/mman.h
+++ b/arch/m68knommu/include/asm/mman.h
diff --git a/include/asm-m68knommu/mmu.h b/arch/m68knommu/include/asm/mmu.h
index 5fa6b68353ba..5fa6b68353ba 100644
--- a/include/asm-m68knommu/mmu.h
+++ b/arch/m68knommu/include/asm/mmu.h
diff --git a/include/asm-m68knommu/mmu_context.h b/arch/m68knommu/include/asm/mmu_context.h
index 9ccee4278c97..9ccee4278c97 100644
--- a/include/asm-m68knommu/mmu_context.h
+++ b/arch/m68knommu/include/asm/mmu_context.h
diff --git a/include/asm-m68knommu/module.h b/arch/m68knommu/include/asm/module.h
index 2e45ab50b232..2e45ab50b232 100644
--- a/include/asm-m68knommu/module.h
+++ b/arch/m68knommu/include/asm/module.h
diff --git a/include/asm-m68knommu/movs.h b/arch/m68knommu/include/asm/movs.h
index 81a16779e833..81a16779e833 100644
--- a/include/asm-m68knommu/movs.h
+++ b/arch/m68knommu/include/asm/movs.h
diff --git a/include/asm-m68knommu/msgbuf.h b/arch/m68knommu/include/asm/msgbuf.h
index bdfadec4d52d..bdfadec4d52d 100644
--- a/include/asm-m68knommu/msgbuf.h
+++ b/arch/m68knommu/include/asm/msgbuf.h
diff --git a/include/asm-m68knommu/mutex.h b/arch/m68knommu/include/asm/mutex.h
index 458c1f7fbc18..458c1f7fbc18 100644
--- a/include/asm-m68knommu/mutex.h
+++ b/arch/m68knommu/include/asm/mutex.h
diff --git a/include/asm-m68knommu/nettel.h b/arch/m68knommu/include/asm/nettel.h
index 0299f6a2deeb..0299f6a2deeb 100644
--- a/include/asm-m68knommu/nettel.h
+++ b/arch/m68knommu/include/asm/nettel.h
diff --git a/include/asm-m68knommu/openprom.h b/arch/m68knommu/include/asm/openprom.h
index fdba7953ff9f..fdba7953ff9f 100644
--- a/include/asm-m68knommu/openprom.h
+++ b/arch/m68knommu/include/asm/openprom.h
diff --git a/include/asm-m68knommu/oplib.h b/arch/m68knommu/include/asm/oplib.h
index ce079dc332d9..ce079dc332d9 100644
--- a/include/asm-m68knommu/oplib.h
+++ b/arch/m68knommu/include/asm/oplib.h
diff --git a/include/asm-m68knommu/page.h b/arch/m68knommu/include/asm/page.h
index 3a1ede4544cb..3a1ede4544cb 100644
--- a/include/asm-m68knommu/page.h
+++ b/arch/m68knommu/include/asm/page.h
diff --git a/include/asm-m68knommu/page_offset.h b/arch/m68knommu/include/asm/page_offset.h
index d4e73e0ba646..d4e73e0ba646 100644
--- a/include/asm-m68knommu/page_offset.h
+++ b/arch/m68knommu/include/asm/page_offset.h
diff --git a/include/asm-m68knommu/param.h b/arch/m68knommu/include/asm/param.h
index 6044397adb64..6044397adb64 100644
--- a/include/asm-m68knommu/param.h
+++ b/arch/m68knommu/include/asm/param.h
diff --git a/include/asm-m68knommu/pci.h b/arch/m68knommu/include/asm/pci.h
index a13f3cc87451..a13f3cc87451 100644
--- a/include/asm-m68knommu/pci.h
+++ b/arch/m68knommu/include/asm/pci.h
diff --git a/include/asm-m68knommu/percpu.h b/arch/m68knommu/include/asm/percpu.h
index 5de72c327efd..5de72c327efd 100644
--- a/include/asm-m68knommu/percpu.h
+++ b/arch/m68knommu/include/asm/percpu.h
diff --git a/include/asm-m68knommu/pgalloc.h b/arch/m68knommu/include/asm/pgalloc.h
index d6352f671ec0..d6352f671ec0 100644
--- a/include/asm-m68knommu/pgalloc.h
+++ b/arch/m68knommu/include/asm/pgalloc.h
diff --git a/include/asm-m68knommu/pgtable.h b/arch/m68knommu/include/asm/pgtable.h
index 46251016e821..46251016e821 100644
--- a/include/asm-m68knommu/pgtable.h
+++ b/arch/m68knommu/include/asm/pgtable.h
diff --git a/include/asm-m68knommu/poll.h b/arch/m68knommu/include/asm/poll.h
index ee1b6cb549ca..ee1b6cb549ca 100644
--- a/include/asm-m68knommu/poll.h
+++ b/arch/m68knommu/include/asm/poll.h
diff --git a/include/asm-m68knommu/posix_types.h b/arch/m68knommu/include/asm/posix_types.h
index 6205fb9392a3..6205fb9392a3 100644
--- a/include/asm-m68knommu/posix_types.h
+++ b/arch/m68knommu/include/asm/posix_types.h
diff --git a/include/asm-m68knommu/processor.h b/arch/m68knommu/include/asm/processor.h
index 91cba18acdd3..91cba18acdd3 100644
--- a/include/asm-m68knommu/processor.h
+++ b/arch/m68knommu/include/asm/processor.h
diff --git a/include/asm-m68knommu/ptrace.h b/arch/m68knommu/include/asm/ptrace.h
index 8c9194b98548..8c9194b98548 100644
--- a/include/asm-m68knommu/ptrace.h
+++ b/arch/m68knommu/include/asm/ptrace.h
diff --git a/include/asm-m68knommu/quicc_simple.h b/arch/m68knommu/include/asm/quicc_simple.h
index c3636932d4bc..c3636932d4bc 100644
--- a/include/asm-m68knommu/quicc_simple.h
+++ b/arch/m68knommu/include/asm/quicc_simple.h
diff --git a/include/asm-m68knommu/resource.h b/arch/m68knommu/include/asm/resource.h
index 7fa63d5ea576..7fa63d5ea576 100644
--- a/include/asm-m68knommu/resource.h
+++ b/arch/m68knommu/include/asm/resource.h
diff --git a/include/asm-m68knommu/rtc.h b/arch/m68knommu/include/asm/rtc.h
index eaf18ec83c8e..eaf18ec83c8e 100644
--- a/include/asm-m68knommu/rtc.h
+++ b/arch/m68knommu/include/asm/rtc.h
diff --git a/include/asm-m68knommu/scatterlist.h b/arch/m68knommu/include/asm/scatterlist.h
index afc4788b0d2c..afc4788b0d2c 100644
--- a/include/asm-m68knommu/scatterlist.h
+++ b/arch/m68knommu/include/asm/scatterlist.h
diff --git a/include/asm-m68knommu/sections.h b/arch/m68knommu/include/asm/sections.h
index dd0ecb98ec08..dd0ecb98ec08 100644
--- a/include/asm-m68knommu/sections.h
+++ b/arch/m68knommu/include/asm/sections.h
diff --git a/include/asm-m68knommu/segment.h b/arch/m68knommu/include/asm/segment.h
index 42318ebec7ec..42318ebec7ec 100644
--- a/include/asm-m68knommu/segment.h
+++ b/arch/m68knommu/include/asm/segment.h
diff --git a/include/asm-m68knommu/sembuf.h b/arch/m68knommu/include/asm/sembuf.h
index 3a634f9ecf50..3a634f9ecf50 100644
--- a/include/asm-m68knommu/sembuf.h
+++ b/arch/m68knommu/include/asm/sembuf.h
diff --git a/include/asm-m68knommu/setup.h b/arch/m68knommu/include/asm/setup.h
index fb86bb2a6078..fb86bb2a6078 100644
--- a/include/asm-m68knommu/setup.h
+++ b/arch/m68knommu/include/asm/setup.h
diff --git a/include/asm-m68knommu/shm.h b/arch/m68knommu/include/asm/shm.h
index cc8e522d9050..cc8e522d9050 100644
--- a/include/asm-m68knommu/shm.h
+++ b/arch/m68knommu/include/asm/shm.h
diff --git a/include/asm-m68knommu/shmbuf.h b/arch/m68knommu/include/asm/shmbuf.h
index bc34cf8eefce..bc34cf8eefce 100644
--- a/include/asm-m68knommu/shmbuf.h
+++ b/arch/m68knommu/include/asm/shmbuf.h
diff --git a/include/asm-m68knommu/shmparam.h b/arch/m68knommu/include/asm/shmparam.h
index d7ee69648ebf..d7ee69648ebf 100644
--- a/include/asm-m68knommu/shmparam.h
+++ b/arch/m68knommu/include/asm/shmparam.h
diff --git a/include/asm-m68knommu/sigcontext.h b/arch/m68knommu/include/asm/sigcontext.h
index 36c293fc133d..36c293fc133d 100644
--- a/include/asm-m68knommu/sigcontext.h
+++ b/arch/m68knommu/include/asm/sigcontext.h
diff --git a/include/asm-m68knommu/siginfo.h b/arch/m68knommu/include/asm/siginfo.h
index b18e5f4064ae..b18e5f4064ae 100644
--- a/include/asm-m68knommu/siginfo.h
+++ b/arch/m68knommu/include/asm/siginfo.h
diff --git a/include/asm-m68knommu/signal.h b/arch/m68knommu/include/asm/signal.h
index 216c08be54a0..216c08be54a0 100644
--- a/include/asm-m68knommu/signal.h
+++ b/arch/m68knommu/include/asm/signal.h
diff --git a/include/asm-m68knommu/smp.h b/arch/m68knommu/include/asm/smp.h
index 9e9bd7e58922..9e9bd7e58922 100644
--- a/include/asm-m68knommu/smp.h
+++ b/arch/m68knommu/include/asm/smp.h
diff --git a/include/asm-m68knommu/socket.h b/arch/m68knommu/include/asm/socket.h
index ac5478bf6371..ac5478bf6371 100644
--- a/include/asm-m68knommu/socket.h
+++ b/arch/m68knommu/include/asm/socket.h
diff --git a/include/asm-m68knommu/sockios.h b/arch/m68knommu/include/asm/sockios.h
index dcc6a8900ce2..dcc6a8900ce2 100644
--- a/include/asm-m68knommu/sockios.h
+++ b/arch/m68knommu/include/asm/sockios.h
diff --git a/include/asm-m68knommu/spinlock.h b/arch/m68knommu/include/asm/spinlock.h
index 6bb1f06c4781..6bb1f06c4781 100644
--- a/include/asm-m68knommu/spinlock.h
+++ b/arch/m68knommu/include/asm/spinlock.h
diff --git a/include/asm-m68knommu/stat.h b/arch/m68knommu/include/asm/stat.h
index 3d4b260e7c03..3d4b260e7c03 100644
--- a/include/asm-m68knommu/stat.h
+++ b/arch/m68knommu/include/asm/stat.h
diff --git a/include/asm-m68knommu/statfs.h b/arch/m68knommu/include/asm/statfs.h
index 2ce99eaf0970..2ce99eaf0970 100644
--- a/include/asm-m68knommu/statfs.h
+++ b/arch/m68knommu/include/asm/statfs.h
diff --git a/include/asm-m68knommu/string.h b/arch/m68knommu/include/asm/string.h
index af09e17000fc..af09e17000fc 100644
--- a/include/asm-m68knommu/string.h
+++ b/arch/m68knommu/include/asm/string.h
diff --git a/include/asm-m68knommu/system.h b/arch/m68knommu/include/asm/system.h
index 40f49de69821..40f49de69821 100644
--- a/include/asm-m68knommu/system.h
+++ b/arch/m68knommu/include/asm/system.h
diff --git a/include/asm-m68knommu/termbits.h b/arch/m68knommu/include/asm/termbits.h
index 05dd6bc27285..05dd6bc27285 100644
--- a/include/asm-m68knommu/termbits.h
+++ b/arch/m68knommu/include/asm/termbits.h
diff --git a/include/asm-m68knommu/termios.h b/arch/m68knommu/include/asm/termios.h
index e7337881a985..e7337881a985 100644
--- a/include/asm-m68knommu/termios.h
+++ b/arch/m68knommu/include/asm/termios.h
diff --git a/include/asm-m68knommu/thread_info.h b/arch/m68knommu/include/asm/thread_info.h
index 0c9bc095f3f0..0c9bc095f3f0 100644
--- a/include/asm-m68knommu/thread_info.h
+++ b/arch/m68knommu/include/asm/thread_info.h
diff --git a/include/asm-m68knommu/timex.h b/arch/m68knommu/include/asm/timex.h
index 109050f3fe91..109050f3fe91 100644
--- a/include/asm-m68knommu/timex.h
+++ b/arch/m68knommu/include/asm/timex.h
diff --git a/include/asm-m68knommu/tlb.h b/arch/m68knommu/include/asm/tlb.h
index 77a7c51ca299..77a7c51ca299 100644
--- a/include/asm-m68knommu/tlb.h
+++ b/arch/m68knommu/include/asm/tlb.h
diff --git a/include/asm-m68knommu/tlbflush.h b/arch/m68knommu/include/asm/tlbflush.h
index a470cfb803eb..a470cfb803eb 100644
--- a/include/asm-m68knommu/tlbflush.h
+++ b/arch/m68knommu/include/asm/tlbflush.h
diff --git a/include/asm-m68knommu/topology.h b/arch/m68knommu/include/asm/topology.h
index ca173e9f26ff..ca173e9f26ff 100644
--- a/include/asm-m68knommu/topology.h
+++ b/arch/m68knommu/include/asm/topology.h
diff --git a/include/asm-m68knommu/traps.h b/arch/m68knommu/include/asm/traps.h
index d0671e5f8e29..d0671e5f8e29 100644
--- a/include/asm-m68knommu/traps.h
+++ b/arch/m68knommu/include/asm/traps.h
diff --git a/include/asm-m68knommu/types.h b/arch/m68knommu/include/asm/types.h
index 031238c2d180..031238c2d180 100644
--- a/include/asm-m68knommu/types.h
+++ b/arch/m68knommu/include/asm/types.h
diff --git a/include/asm-m68knommu/uaccess.h b/arch/m68knommu/include/asm/uaccess.h
index 68bbe9b312f1..68bbe9b312f1 100644
--- a/include/asm-m68knommu/uaccess.h
+++ b/arch/m68knommu/include/asm/uaccess.h
diff --git a/include/asm-m68knommu/ucontext.h b/arch/m68knommu/include/asm/ucontext.h
index 713a27f901cd..713a27f901cd 100644
--- a/include/asm-m68knommu/ucontext.h
+++ b/arch/m68knommu/include/asm/ucontext.h
diff --git a/include/asm-m68knommu/unaligned.h b/arch/m68knommu/include/asm/unaligned.h
index eb1ea4cb9a59..eb1ea4cb9a59 100644
--- a/include/asm-m68knommu/unaligned.h
+++ b/arch/m68knommu/include/asm/unaligned.h
diff --git a/include/asm-m68knommu/unistd.h b/arch/m68knommu/include/asm/unistd.h
index 4ba98b9c5d79..4ba98b9c5d79 100644
--- a/include/asm-m68knommu/unistd.h
+++ b/arch/m68knommu/include/asm/unistd.h
diff --git a/include/asm-m68knommu/user.h b/arch/m68knommu/include/asm/user.h
index a5a555b761c4..a5a555b761c4 100644
--- a/include/asm-m68knommu/user.h
+++ b/arch/m68knommu/include/asm/user.h
diff --git a/arch/powerpc/platforms/iseries/Kconfig b/arch/powerpc/platforms/iseries/Kconfig
index ea3e541ac74f..45ffd8e542f4 100644
--- a/arch/powerpc/platforms/iseries/Kconfig
+++ b/arch/powerpc/platforms/iseries/Kconfig
@@ -7,15 +7,6 @@ config PPC_ISERIES
 menu "iSeries device drivers"
         depends on PPC_ISERIES
 
-config VIOCONS
-        bool "iSeries Virtual Console Support (Obsolete)"
-        depends on !HVC_ISERIES
-        default n
-        help
-          This is the old virtual console driver for legacy iSeries.
-          You should use the iSeries Hypervisor Virtual Console
-          support instead.
-
 config VIODASD
         tristate "iSeries Virtual I/O disk support"
         help
@@ -38,5 +29,5 @@ endmenu
 
 config VIOPATH
         bool
-        depends on VIOCONS || VIODASD || VIOCD || VIOTAPE || ISERIES_VETH
+        depends on VIODASD || VIOCD || VIOTAPE || ISERIES_VETH
         default y
diff --git a/crypto/async_tx/async_xor.c b/crypto/async_tx/async_xor.c
index 65974c6d3d7a..c029d3eb9ef0 100644
--- a/crypto/async_tx/async_xor.c
+++ b/crypto/async_tx/async_xor.c
@@ -263,11 +263,12 @@ async_xor_zero_sum(struct page *dest, struct page **src_list,
                 if (unlikely(!tx)) {
                         async_tx_quiesce(&depend_tx);
 
-                        while (!tx)
+                        while (!tx) {
                                 dma_async_issue_pending(chan);
                                 tx = device->device_prep_dma_zero_sum(chan,
                                         dma_src, src_cnt, len, result,
                                         dma_prep_flags);
+                        }
                 }
 
                 async_tx_submit(chan, tx, flags, depend_tx, cb_fn, cb_param);
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/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 5e7ebca1968e..388cf94055d3 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 bf872aa2b9f3..bacd867dd22e 100644
--- a/drivers/watchdog/at91rm9200_wdt.c
+++ b/drivers/watchdog/at91rm9200_wdt.c
@@ -20,10 +20,9 @@
 #include <linux/platform_device.h>
 #include <linux/types.h>
 #include <linux/watchdog.h>
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 #include <mach/at91_st.h>
 
-
 #define WDT_DEFAULT_TIME        5       /* seconds */
 #define WDT_MAX_TIME            256     /* seconds */
 
@@ -31,11 +30,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 +48,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 +56,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 +92,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 +114,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 +128,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 +184,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 +208,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 +263,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 003dffe5cb19..2e1360286732 100644
--- a/drivers/watchdog/davinci_wdt.c
+++ b/drivers/watchdog/davinci_wdt.c
@@ -22,10 +22,9 @@
 #include <linux/bitops.h>
 #include <linux/platform_device.h>
 #include <linux/spinlock.h>
-
+#include <linux/uaccess.h>
+#include <linux/io.h>
 #include <mach/hardware.h>
-#include <asm/uaccess.h>
-#include <asm/io.h>
 
 #define MODULE_NAME "DAVINCI-WDT: "
 
@@ -143,9 +142,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 +158,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 +182,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 af8ef14c0e4c..e9f950ff86ea 100644
--- a/drivers/watchdog/ep93xx_wdt.c
+++ b/drivers/watchdog/ep93xx_wdt.c
@@ -28,9 +28,8 @@
 #include <linux/miscdevice.h>
 #include <linux/watchdog.h>
 #include <linux/timer.h>
-
+#include <linux/uaccess.h>
 #include <mach/hardware.h>
-#include <asm/uaccess.h>
 
 #define WDT_VERSION     "0.3"
 #define PFX             "ep93xx_wdt: "
@@ -136,9 +135,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 +154,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 +172,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 +184,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 +241,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 1946dd06d815..96eb2cbe5874 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 4226dae7d260..4f4b35a20d84 100644
--- a/drivers/watchdog/ixp2000_wdt.c
+++ b/drivers/watchdog/ixp2000_wdt.c
@@ -25,42 +25,44 @@
 #include <linux/watchdog.h>
 #include <linux/init.h>
 #include <linux/bitops.h>
-
+#include <linux/uaccess.h>
 #include <mach/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 +74,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 +105,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 +125,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 +147,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 +166,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 +187,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 2313fad0dbb1..41264a5f1731 100644
--- a/drivers/watchdog/ixp4xx_wdt.c
+++ b/drivers/watchdog/ixp4xx_wdt.c
@@ -22,48 +22,47 @@
 #include <linux/watchdog.h>
 #include <linux/init.h>
 #include <linux/bitops.h>
-
+#include <linux/uaccess.h>
 #include <mach/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 +86,6 @@ ixp4xx_wdt_write(struct file *file, const char *data, size_t len, loff_t *ppos)
                 }
                 wdt_enable();
         }
-
         return len;
 }
 
@@ -98,9 +96,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 +116,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 +138,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 +156,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 +178,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 d21a6407fe21..0b798fdaa378 100644
--- a/drivers/watchdog/ks8695_wdt.c
+++ b/drivers/watchdog/ks8695_wdt.c
@@ -19,11 +19,10 @@
 #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 <mach/regs-timer.h>
 
-
 #define WDT_DEFAULT_TIME        5       /* seconds */
 #define WDT_MAX_TIME            171     /* seconds */
 
@@ -31,38 +30,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 +78,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 +110,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 +137,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 +152,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 +208,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 +232,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 +287,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 74a10d50607b..3a11dadfd8e7 100644
--- a/drivers/watchdog/omap_wdt.c
+++ b/drivers/watchdog/omap_wdt.c
@@ -40,11 +40,9 @@
 #include <linux/moduleparam.h>
 #include <linux/clk.h>
 #include <linux/bitops.h>
-
-#include <asm/io.h>
-#include <asm/uaccess.h>
+#include <linux/io.h>
+#include <linux/uaccess.h>
 #include <mach/hardware.h>
-
 #include <mach/prcm.h>
 
 #include "omap_wdt.h"
@@ -54,11 +52,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 +173,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 +209,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 +244,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 +377,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 f431a0427eaa..0ed84162437b 100644
--- a/drivers/watchdog/pnx4008_wdt.c
+++ b/drivers/watchdog/pnx4008_wdt.c
@@ -28,10 +28,9 @@
 #include <linux/platform_device.h>
 #include <linux/clk.h>
 #include <linux/spinlock.h>
-
+#include <linux/uaccess.h>
+#include <linux/io.h>
 #include <mach/hardware.h>
-#include <asm/uaccess.h>
-#include <asm/io.h>
 
 #define MODULE_NAME "PNX4008-WDT: "
 
@@ -144,9 +143,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 +167,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 +193,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 +215,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 +235,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 f1fe800658f4..3da2b90d2fe6 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 97d9da758dcc..31a48437dc3d 100644
--- a/drivers/watchdog/sa1100_wdt.c
+++ b/drivers/watchdog/sa1100_wdt.c
@@ -26,6 +26,7 @@
 #include <linux/watchdog.h>
 #include <linux/init.h>
 #include <linux/bitops.h>
+#include <linux/uaccess.h>
 
 #ifdef CONFIG_ARCH_PXA
 #include <mach/pxa-regs.h>
@@ -33,7 +34,6 @@
 
 #include <mach/reset.h>
 #include <mach/hardware.h>
-#include <asm/uaccess.h>
 
 #define OSCR_FREQ               CLOCK_TICK_RATE
 
@@ -46,7 +46,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 */
@@ -67,28 +67,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;
@@ -109,6 +108,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)
@@ -126,27 +130,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,
@@ -169,8 +166,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 94e2d91c9ac9..c8d7f1b2df02 100644
--- a/drivers/watchdog/wdt285.c
+++ b/drivers/watchdog/wdt285.c
@@ -26,10 +26,10 @@
 #include <linux/reboot.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
-
-#include <asm/irq.h>
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
+#include <linux/irq.h>
 #include <mach/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;
+        }
 }
 
 /**
diff --git a/fs/bio.c b/fs/bio.c
index 25f1af0d81e5..8000e2fa16cb 100644
--- a/fs/bio.c
+++ b/fs/bio.c
@@ -77,11 +77,8 @@ struct bio_vec *bvec_alloc_bs(gfp_t gfp_mask, int nr, unsigned long *idx, struct
          */
 
         bvl = mempool_alloc(bs->bvec_pools[*idx], gfp_mask);
-        if (bvl) {
-                struct biovec_slab *bp = bvec_slabs + *idx;
-
-                memset(bvl, 0, bp->nr_vecs * sizeof(struct bio_vec));
-        }
+        if (bvl)
+                memset(bvl, 0, bvec_nr_vecs(*idx) * sizeof(struct bio_vec));
 
         return bvl;
 }
@@ -149,7 +146,7 @@ struct bio *bio_alloc_bioset(gfp_t gfp_mask, int nr_iovecs, struct bio_set *bs)
                                 goto out;
                         }
                         bio->bi_flags |= idx << BIO_POOL_OFFSET;
-                        bio->bi_max_vecs = bvec_slabs[idx].nr_vecs;
+                        bio->bi_max_vecs = bvec_nr_vecs(idx);
                 }
                 bio->bi_io_vec = bvl;
         }
diff --git a/include/linux/mlx4/cq.h b/include/linux/mlx4/cq.h
index 071cf96cf01f..6f65b2c8bb89 100644
--- a/include/linux/mlx4/cq.h
+++ b/include/linux/mlx4/cq.h
@@ -39,17 +39,18 @@
 #include <linux/mlx4/doorbell.h>
 
 struct mlx4_cqe {
-        __be32                  my_qpn;
+        __be32                  vlan_my_qpn;
         __be32                  immed_rss_invalid;
         __be32                  g_mlpath_rqpn;
-        u8                      sl;
-        u8                      reserved1;
+        __be16                  sl_vid;
         __be16                  rlid;
-        __be32                  ipoib_status;
+        __be16                  status;
+        u8                      ipv6_ext_mask;
+        u8                      badfcs_enc;
         __be32                  byte_cnt;
         __be16                  wqe_index;
         __be16                  checksum;
-        u8                      reserved2[3];
+        u8                      reserved[3];
         u8                      owner_sr_opcode;
 };
 
@@ -64,6 +65,11 @@ struct mlx4_err_cqe {
 };
 
 enum {
+        MLX4_CQE_VLAN_PRESENT_MASK      = 1 << 29,
+        MLX4_CQE_QPN_MASK               = 0xffffff,
+};
+
+enum {
         MLX4_CQE_OWNER_MASK     = 0x80,
         MLX4_CQE_IS_SEND_MASK   = 0x40,
         MLX4_CQE_OPCODE_MASK    = 0x1f
@@ -86,13 +92,19 @@ enum {
 };
 
 enum {
-        MLX4_CQE_IPOIB_STATUS_IPV4                      = 1 << 22,
-        MLX4_CQE_IPOIB_STATUS_IPV4F                     = 1 << 23,
-        MLX4_CQE_IPOIB_STATUS_IPV6                      = 1 << 24,
-        MLX4_CQE_IPOIB_STATUS_IPV4OPT                   = 1 << 25,
-        MLX4_CQE_IPOIB_STATUS_TCP                       = 1 << 26,
-        MLX4_CQE_IPOIB_STATUS_UDP                       = 1 << 27,
-        MLX4_CQE_IPOIB_STATUS_IPOK                      = 1 << 28,
+        MLX4_CQE_STATUS_IPV4            = 1 << 6,
+        MLX4_CQE_STATUS_IPV4F           = 1 << 7,
+        MLX4_CQE_STATUS_IPV6            = 1 << 8,
+        MLX4_CQE_STATUS_IPV4OPT         = 1 << 9,
+        MLX4_CQE_STATUS_TCP             = 1 << 10,
+        MLX4_CQE_STATUS_UDP             = 1 << 11,
+        MLX4_CQE_STATUS_IPOK            = 1 << 12,
+};
+
+enum {
+        MLX4_CQE_LLC                     = 1,
+        MLX4_CQE_SNAP                    = 1 << 1,
+        MLX4_CQE_BAD_FCS                 = 1 << 4,
 };
 
 static inline void mlx4_cq_arm(struct mlx4_cq *cq, u32 cmd,
diff --git a/include/linux/ptrace.h b/include/linux/ptrace.h
index fd31756e1a00..ea7416c901d1 100644
--- a/include/linux/ptrace.h
+++ b/include/linux/ptrace.h
@@ -172,7 +172,7 @@ static inline void ptrace_init_task(struct task_struct *child, bool ptrace)
         child->ptrace = 0;
         if (unlikely(ptrace)) {
                 child->ptrace = current->ptrace;
-                __ptrace_link(child, current->parent);
+                ptrace_link(child, current->parent);
         }
 }
 
diff --git a/include/linux/tracehook.h b/include/linux/tracehook.h
index ab3ef7aefa95..b48d81969574 100644
--- a/include/linux/tracehook.h
+++ b/include/linux/tracehook.h
@@ -280,7 +280,7 @@ static inline void tracehook_report_clone(int trace, struct pt_regs *regs,
                                           unsigned long clone_flags,
                                           pid_t pid, struct task_struct *child)
 {
-        if (unlikely(trace)) {
+        if (unlikely(trace) || unlikely(clone_flags & CLONE_PTRACE)) {
                 /*
                  * The child starts up with an immediate SIGSTOP.
                  */
diff --git a/include/media/soc_camera.h b/include/media/soc_camera.h
index 1de98f150e99..d548de326722 100644
--- a/include/media/soc_camera.h
+++ b/include/media/soc_camera.h
@@ -14,6 +14,7 @@
 
 #include <linux/videodev2.h>
 #include <media/videobuf-core.h>
+#include <linux/pm.h>
 
 struct soc_camera_device {
         struct list_head list;
@@ -63,6 +64,8 @@ struct soc_camera_host_ops {
         struct module *owner;
         int (*add)(struct soc_camera_device *);
         void (*remove)(struct soc_camera_device *);
+        int (*suspend)(struct soc_camera_device *, pm_message_t state);
+        int (*resume)(struct soc_camera_device *);
         int (*set_fmt_cap)(struct soc_camera_device *, __u32,
                            struct v4l2_rect *);
         int (*try_fmt_cap)(struct soc_camera_device *, struct v4l2_format *);
@@ -111,6 +114,8 @@ struct soc_camera_ops {
         struct module *owner;
         int (*probe)(struct soc_camera_device *);
         void (*remove)(struct soc_camera_device *);
+        int (*suspend)(struct soc_camera_device *, pm_message_t state);
+        int (*resume)(struct soc_camera_device *);
         int (*init)(struct soc_camera_device *);
         int (*release)(struct soc_camera_device *);
         int (*start_capture)(struct soc_camera_device *);
diff --git a/include/rdma/rdma_cm.h b/include/rdma/rdma_cm.h
index df7faf09d66f..c6b2962315b3 100644
--- a/include/rdma/rdma_cm.h
+++ b/include/rdma/rdma_cm.h
@@ -71,12 +71,8 @@ enum rdma_port_space {
 };
 
 struct rdma_addr {
-        struct sockaddr src_addr;
-        u8              src_pad[sizeof(struct sockaddr_in6) -
-                                sizeof(struct sockaddr)];
-        struct sockaddr dst_addr;
-        u8              dst_pad[sizeof(struct sockaddr_in6) -
-                                sizeof(struct sockaddr)];
+        struct sockaddr_storage src_addr;
+        struct sockaddr_storage dst_addr;
         struct rdma_dev_addr dev_addr;
 };
 
diff --git a/mm/hugetlb.c b/mm/hugetlb.c
index 28a2980ee435..757ca983fd99 100644
--- a/mm/hugetlb.c
+++ b/mm/hugetlb.c
@@ -17,7 +17,7 @@
 #include <linux/mutex.h>
 #include <linux/bootmem.h>
 #include <linux/sysfs.h>
-#include <asm/io.h>
+
 #include <asm/page.h>
 #include <asm/pgtable.h>
 #include <asm/io.h>
diff --git a/sound/soc/fsl/fsl_dma.c b/sound/soc/fsl/fsl_dma.c
index 7ceea2bba1f5..d2d3da9729f2 100644
--- a/sound/soc/fsl/fsl_dma.c
+++ b/sound/soc/fsl/fsl_dma.c
@@ -327,14 +327,75 @@ static int fsl_dma_new(struct snd_card *card, struct snd_soc_dai *dai,
  * fsl_dma_open: open a new substream.
  *
  * Each substream has its own DMA buffer.
+ *
+ * ALSA divides the DMA buffer into N periods.  We create NUM_DMA_LINKS link
+ * descriptors that ping-pong from one period to the next.  For example, if
+ * there are six periods and two link descriptors, this is how they look
+ * before playback starts:
+ *
+ *                 The last link descriptor
+ *   ____________  points back to the first
+ *  |            |
+ *  V            |
+ *  ___    ___   |
+ * |   |->|   |->|
+ * |___|  |___|
+ *   |      |
+ *   |      |
+ *   V      V
+ *  _________________________________________
+ * |      |      |      |      |      |      |  The DMA buffer is
+ * |      |      |      |      |      |      |    divided into 6 parts
+ * |______|______|______|______|______|______|
+ *
+ * and here's how they look after the first period is finished playing:
+ *
+ *   ____________
+ *  |            |
+ *  V            |
+ *  ___    ___   |
+ * |   |->|   |->|
+ * |___|  |___|
+ *   |      |
+ *   |______________
+ *          |       |
+ *          V       V
+ *  _________________________________________
+ * |      |      |      |      |      |      |
+ * |      |      |      |      |      |      |
+ * |______|______|______|______|______|______|
+ *
+ * The first link descriptor now points to the third period.  The DMA
+ * controller is currently playing the second period.  When it finishes, it
+ * will jump back to the first descriptor and play the third period.
+ *
+ * There are four reasons we do this:
+ *
+ * 1. The only way to get the DMA controller to automatically restart the
+ *    transfer when it gets to the end of the buffer is to use chaining
+ *    mode.  Basic direct mode doesn't offer that feature.
+ * 2. We need to receive an interrupt at the end of every period.  The DMA
+ *    controller can generate an interrupt at the end of every link transfer
+ *    (aka segment).  Making each period into a DMA segment will give us the
+ *    interrupts we need.
+ * 3. By creating only two link descriptors, regardless of the number of
+ *    periods, we do not need to reallocate the link descriptors if the
+ *    number of periods changes.
+ * 4. All of the audio data is still stored in a single, contiguous DMA
+ *    buffer, which is what ALSA expects.  We're just dividing it into
+ *    contiguous parts, and creating a link descriptor for each one.
  */
 static int fsl_dma_open(struct snd_pcm_substream *substream)
 {
         struct snd_pcm_runtime *runtime = substream->runtime;
         struct fsl_dma_private *dma_private;
+        struct ccsr_dma_channel __iomem *dma_channel;
         dma_addr_t ld_buf_phys;
+        u64 temp_link;          /* Pointer to next link descriptor */
+        u32 mr;
         unsigned int channel;
         int ret = 0;
+        unsigned int i;
 
         /*
          * Reject any DMA buffer whose size is not a multiple of the period
@@ -395,68 +456,74 @@ static int fsl_dma_open(struct snd_pcm_substream *substream)
         snd_soc_set_runtime_hwparams(substream, &fsl_dma_hardware);
         runtime->private_data = dma_private;
 
+        /* Program the fixed DMA controller parameters */
+
+        dma_channel = dma_private->dma_channel;
+
+        temp_link = dma_private->ld_buf_phys +
+                sizeof(struct fsl_dma_link_descriptor);
+
+        for (i = 0; i < NUM_DMA_LINKS; i++) {
+                struct fsl_dma_link_descriptor *link = &dma_private->link[i];
+
+                link->source_attr = cpu_to_be32(CCSR_DMA_ATR_SNOOP);
+                link->dest_attr = cpu_to_be32(CCSR_DMA_ATR_SNOOP);
+                link->next = cpu_to_be64(temp_link);
+
+                temp_link += sizeof(struct fsl_dma_link_descriptor);
+        }
+        /* The last link descriptor points to the first */
+        dma_private->link[i - 1].next = cpu_to_be64(dma_private->ld_buf_phys);
+
+        /* Tell the DMA controller where the first link descriptor is */
+        out_be32(&dma_channel->clndar,
+                CCSR_DMA_CLNDAR_ADDR(dma_private->ld_buf_phys));
+        out_be32(&dma_channel->eclndar,
+                CCSR_DMA_ECLNDAR_ADDR(dma_private->ld_buf_phys));
+
+        /* The manual says the BCR must be clear before enabling EMP */
+        out_be32(&dma_channel->bcr, 0);
+
+        /*
+         * Program the mode register for interrupts, external master control,
+         * and source/destination hold.  Also clear the Channel Abort bit.
+         */
+        mr = in_be32(&dma_channel->mr) &
+                ~(CCSR_DMA_MR_CA | CCSR_DMA_MR_DAHE | CCSR_DMA_MR_SAHE);
+
+        /*
+         * We want External Master Start and External Master Pause enabled,
+         * because the SSI is controlling the DMA controller.  We want the DMA
+         * controller to be set up in advance, and then we signal only the SSI
+         * to start transferring.
+         *
+         * We want End-Of-Segment Interrupts enabled, because this will generate
+         * an interrupt at the end of each segment (each link descriptor
+         * represents one segment).  Each DMA segment is the same thing as an
+         * ALSA period, so this is how we get an interrupt at the end of every
+         * period.
+         *
+         * We want Error Interrupt enabled, so that we can get an error if
+         * the DMA controller is mis-programmed somehow.
+         */
+        mr |= CCSR_DMA_MR_EOSIE | CCSR_DMA_MR_EIE | CCSR_DMA_MR_EMP_EN |
+                CCSR_DMA_MR_EMS_EN;
+
+        /* For playback, we want the destination address to be held.  For
+           capture, set the source address to be held. */
+        mr |= (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) ?
+                CCSR_DMA_MR_DAHE : CCSR_DMA_MR_SAHE;
+
+        out_be32(&dma_channel->mr, mr);
+
         return 0;
 }
 
 /**
- * fsl_dma_hw_params: allocate the DMA buffer and the DMA link descriptors.
- *
- * ALSA divides the DMA buffer into N periods.  We create NUM_DMA_LINKS link
- * descriptors that ping-pong from one period to the next.  For example, if
- * there are six periods and two link descriptors, this is how they look
- * before playback starts:
- *
- *                 The last link descriptor
- *   ____________  points back to the first
- *  |            |
- *  V            |
- *  ___    ___   |
- * |   |->|   |->|
- * |___|  |___|
- *   |      |
- *   |      |
- *   V      V
- *  _________________________________________
- * |      |      |      |      |      |      |  The DMA buffer is
- * |      |      |      |      |      |      |    divided into 6 parts
- * |______|______|______|______|______|______|
- *
- * and here's how they look after the first period is finished playing:
- *
- *   ____________
- *  |            |
- *  V            |
- *  ___    ___   |
- * |   |->|   |->|
- * |___|  |___|
- *   |      |
- *   |______________
- *          |       |
- *          V       V
- *  _________________________________________
- * |      |      |      |      |      |      |
- * |      |      |      |      |      |      |
- * |______|______|______|______|______|______|
+ * fsl_dma_hw_params: continue initializing the DMA links
  *
- * The first link descriptor now points to the third period.  The DMA
- * controller is currently playing the second period.  When it finishes, it
- * will jump back to the first descriptor and play the third period.
- *
- * There are four reasons we do this:
- *
- * 1. The only way to get the DMA controller to automatically restart the
- *    transfer when it gets to the end of the buffer is to use chaining
- *    mode.  Basic direct mode doesn't offer that feature.
- * 2. We need to receive an interrupt at the end of every period.  The DMA
- *    controller can generate an interrupt at the end of every link transfer
- *    (aka segment).  Making each period into a DMA segment will give us the
- *    interrupts we need.
- * 3. By creating only two link descriptors, regardless of the number of
- *    periods, we do not need to reallocate the link descriptors if the
- *    number of periods changes.
- * 4. All of the audio data is still stored in a single, contiguous DMA
- *    buffer, which is what ALSA expects.  We're just dividing it into
- *    contiguous parts, and creating a link descriptor for each one.
+ * This function obtains hardware parameters about the opened stream and
+ * programs the DMA controller accordingly.
  *
  * Note that due to a quirk of the SSI's STX register, the target address
  * for the DMA operations depends on the sample size.  So we don't program
@@ -468,11 +535,8 @@ static int fsl_dma_hw_params(struct snd_pcm_substream *substream,
 {
         struct snd_pcm_runtime *runtime = substream->runtime;
         struct fsl_dma_private *dma_private = runtime->private_data;
-        struct ccsr_dma_channel __iomem *dma_channel = dma_private->dma_channel;
 
         dma_addr_t temp_addr;   /* Pointer to next period */
-        u64 temp_link;          /* Pointer to next link descriptor */
-        u32 mr;                 /* Temporary variable for MR register */
 
         unsigned int i;
 
@@ -490,8 +554,6 @@ static int fsl_dma_hw_params(struct snd_pcm_substream *substream,
                 dma_private->dma_buf_next = dma_private->dma_buf_phys;
 
         /*
-         * Initialize each link descriptor.
-         *
          * The actual address in STX0 (destination for playback, source for
          * capture) is based on the sample size, but we don't know the sample
          * size in this function, so we'll have to adjust that later.  See
@@ -507,16 +569,11 @@ static int fsl_dma_hw_params(struct snd_pcm_substream *substream,
          * buffer itself.
          */
         temp_addr = substream->dma_buffer.addr;
-        temp_link = dma_private->ld_buf_phys +
-                sizeof(struct fsl_dma_link_descriptor);
 
         for (i = 0; i < NUM_DMA_LINKS; i++) {
                 struct fsl_dma_link_descriptor *link = &dma_private->link[i];
 
                 link->count = cpu_to_be32(period_size);
-                link->source_attr = cpu_to_be32(CCSR_DMA_ATR_SNOOP);
-                link->dest_attr = cpu_to_be32(CCSR_DMA_ATR_SNOOP);
-                link->next = cpu_to_be64(temp_link);
 
                 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
                         link->source_addr = cpu_to_be32(temp_addr);
@@ -524,51 +581,7 @@ static int fsl_dma_hw_params(struct snd_pcm_substream *substream,
                         link->dest_addr = cpu_to_be32(temp_addr);
 
                 temp_addr += period_size;
-                temp_link += sizeof(struct fsl_dma_link_descriptor);
         }
-        /* The last link descriptor points to the first */
-        dma_private->link[i - 1].next = cpu_to_be64(dma_private->ld_buf_phys);
-
-        /* Tell the DMA controller where the first link descriptor is */
-        out_be32(&dma_channel->clndar,
-                CCSR_DMA_CLNDAR_ADDR(dma_private->ld_buf_phys));
-        out_be32(&dma_channel->eclndar,
-                CCSR_DMA_ECLNDAR_ADDR(dma_private->ld_buf_phys));
-
-        /* The manual says the BCR must be clear before enabling EMP */
-        out_be32(&dma_channel->bcr, 0);
-
-        /*
-         * Program the mode register for interrupts, external master control,
-         * and source/destination hold.  Also clear the Channel Abort bit.
-         */
-        mr = in_be32(&dma_channel->mr) &
-                ~(CCSR_DMA_MR_CA | CCSR_DMA_MR_DAHE | CCSR_DMA_MR_SAHE);
-
-        /*
-         * We want External Master Start and External Master Pause enabled,
-         * because the SSI is controlling the DMA controller.  We want the DMA
-         * controller to be set up in advance, and then we signal only the SSI
-         * to start transfering.
-         *
-         * We want End-Of-Segment Interrupts enabled, because this will generate
-         * an interrupt at the end of each segment (each link descriptor
-         * represents one segment).  Each DMA segment is the same thing as an
-         * ALSA period, so this is how we get an interrupt at the end of every
-         * period.
-         *
-         * We want Error Interrupt enabled, so that we can get an error if
-         * the DMA controller is mis-programmed somehow.
-         */
-        mr |= CCSR_DMA_MR_EOSIE | CCSR_DMA_MR_EIE | CCSR_DMA_MR_EMP_EN |
-                CCSR_DMA_MR_EMS_EN;
-
-        /* For playback, we want the destination address to be held.  For
-           capture, set the source address to be held. */
-        mr |= (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) ?
-                CCSR_DMA_MR_DAHE : CCSR_DMA_MR_SAHE;
-
-        out_be32(&dma_channel->mr, mr);
 
         return 0;
 }