214 files changed, 2174 insertions, 604 deletions

diff --git a/Documentation/filesystems/ubifs.txt b/Documentation/filesystems/ubifs.txt
index 540e9e7f59c5..6a0d70a22f05 100644
--- a/Documentation/filesystems/ubifs.txt
+++ b/Documentation/filesystems/ubifs.txt
@@ -57,7 +57,7 @@ Similarly to JFFS2, UBIFS supports on-the-flight compression which makes
 it possible to fit quite a lot of data to the flash.
 
 Similarly to JFFS2, UBIFS is tolerant of unclean reboots and power-cuts.
-It does not need stuff like ckfs.ext2. UBIFS automatically replays its
+It does not need stuff like fsck.ext2. UBIFS automatically replays its
 journal and recovers from crashes, ensuring that the on-flash data
 structures are consistent.
 
diff --git a/Documentation/hwmon/ibmaem b/Documentation/hwmon/ibmaem
index 2fefaf582a43..e98bdfea3467 100644
--- a/Documentation/hwmon/ibmaem
+++ b/Documentation/hwmon/ibmaem
@@ -1,8 +1,11 @@
 Kernel driver ibmaem
 ======================
 
+This driver talks to the IBM Systems Director Active Energy Manager, known
+henceforth as AEM.
+
 Supported systems:
-  * Any recent IBM System X server with Active Energy Manager support.
+  * Any recent IBM System X server with AEM support.
     This includes the x3350, x3550, x3650, x3655, x3755, x3850 M2,
     x3950 M2, and certain HS2x/LS2x/QS2x blades.  The IPMI host interface
     driver ("ipmi-si") needs to be loaded for this driver to do anything.
@@ -14,24 +17,22 @@ Author: Darrick J. Wong
 Description
 -----------
 
-This driver implements sensor reading support for the energy and power
-meters available on various IBM System X hardware through the BMC.  All
-sensor banks will be exported as platform devices; this driver can talk
-to both v1 and v2 interfaces.  This driver is completely separate from the
-older ibmpex driver.
+This driver implements sensor reading support for the energy and power meters
+available on various IBM System X hardware through the BMC.  All sensor banks
+will be exported as platform devices; this driver can talk to both v1 and v2
+interfaces.  This driver is completely separate from the older ibmpex driver.
 
-The v1 AEM interface has a simple set of features to monitor energy use.
-There is a register that displays an estimate of raw energy consumption
-since the last BMC reset, and a power sensor that returns average power
-use over a configurable interval.
+The v1 AEM interface has a simple set of features to monitor energy use.  There
+is a register that displays an estimate of raw energy consumption since the
+last BMC reset, and a power sensor that returns average power use over a
+configurable interval.
 
-The v2 AEM interface is a bit more sophisticated, being able to present
-a wider range of energy and power use registers, the power cap as
-set by the AEM software, and temperature sensors.
+The v2 AEM interface is a bit more sophisticated, being able to present a wider
+range of energy and power use registers, the power cap as set by the AEM
+software, and temperature sensors.
 
 Special Features
 ----------------
 
-The "power_cap" value displays the current system power cap, as set by
-the Active Energy Manager software.  Setting the power cap from the host
-is not currently supported.
+The "power_cap" value displays the current system power cap, as set by the AEM
+software.  Setting the power cap from the host is not currently supported.
diff --git a/Documentation/sound/alsa/ALSA-Configuration.txt b/Documentation/sound/alsa/ALSA-Configuration.txt
index 6f6d117ac7e2..b117e42a6166 100644
--- a/Documentation/sound/alsa/ALSA-Configuration.txt
+++ b/Documentation/sound/alsa/ALSA-Configuration.txt
@@ -1144,8 +1144,6 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed.
 
     This module supports autoprobe and multiple cards.
 
-    Power management is _not_ supported.
-
   Module snd-ice1712
   ------------------
 
@@ -1628,8 +1626,6 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed.
 
     This module supports autoprobe and multiple cards.
 
-    Power management is _not_ supported.
-
   Module snd-pcsp
   -----------------
 
@@ -2081,13 +2077,11 @@ Prior to version 0.9.0rc4 options had a 'snd_' prefix. This was removed.
   Module snd-virtuoso
   -------------------
 
-    Module for sound cards based on the Asus AV200 chip, i.e.,
-    Xonar D2 and Xonar D2X.
+    Module for sound cards based on the Asus AV100/AV200 chips,
+    i.e., Xonar D1, DX, D2 and D2X.
 
     This module supports autoprobe and multiple cards.
 
-    Power management is _not_ supported.
-
   Module snd-vx222
   ----------------
 
diff --git a/Documentation/vm/page_migration b/Documentation/vm/page_migration
index 99f89aa10169..d5fdfd34bbaf 100644
--- a/Documentation/vm/page_migration
+++ b/Documentation/vm/page_migration
@@ -18,10 +18,11 @@ migrate_pages function call takes two sets of nodes and moves pages of a
 process that are located on the from nodes to the destination nodes.
 Page migration functions are provided by the numactl package by Andi Kleen
 (a version later than 0.9.3 is required. Get it from
-ftp://ftp.suse.com/pub/people/ak). numactl provided libnuma which
-provides an interface similar to other numa functionality for page migration.
-cat /proc/<pid>/numa_maps allows an easy review of where the pages of
-a process are located. See also the numa_maps manpage in the numactl package.
+ftp://oss.sgi.com/www/projects/libnuma/download/). numactl provides libnuma
+which provides an interface similar to other numa functionality for page
+migration.  cat /proc/<pid>/numa_maps allows an easy review of where the
+pages of a process are located. See also the numa_maps documentation in the
+proc(5) man page.
 
 Manual migration is useful if for example the scheduler has relocated
 a process to a processor on a distant node. A batch scheduler or an
diff --git a/MAINTAINERS b/MAINTAINERS
index 4c5e9fe0f7db..663485b004fb 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -175,12 +175,18 @@ M:	bcrl@kvack.org
 L:      linux-aio@kvack.org
 S:      Supported
 
-ABIT UGURU HARDWARE MONITOR DRIVER
+ABIT UGURU 1,2 HARDWARE MONITOR DRIVER
 P:      Hans de Goede
 M:      j.w.r.degoede@hhs.nl
 L:      lm-sensors@lm-sensors.org
 S:      Maintained
 
+ABIT UGURU 3 HARDWARE MONITOR DRIVER
+P:      Alistair John Strachan
+M:      alistair@devzero.co.uk
+L:      lm-sensors@lm-sensors.org
+S:      Maintained
+
 ACENIC DRIVER
 P:      Jes Sorensen
 M:      jes@trained-monkey.org
@@ -3748,6 +3754,16 @@ L:	linux-visws-devel@lists.sf.net
 W:      http://linux-visws.sf.net
 S:      Maintained for 2.6.
 
+SGI GRU DRIVER
+P:      Jack Steiner
+M:      steiner@sgi.com
+S:      Maintained
+
+SGI XP/XPC/XPNET DRIVER
+P:      Dean Nelson
+M:      dcn@sgi.com
+S:      Maintained
+
 SIMTEC EB110ATX (Chalice CATS)
 P:      Ben Dooks
 P:      Vincent Sanders
diff --git a/include/asm-alpha/8253pit.h b/arch/alpha/include/asm/8253pit.h
index fef5c1450e47..fef5c1450e47 100644
--- a/include/asm-alpha/8253pit.h
+++ b/arch/alpha/include/asm/8253pit.h
diff --git a/include/asm-alpha/Kbuild b/arch/alpha/include/asm/Kbuild
index b7c8f188b313..b7c8f188b313 100644
--- a/include/asm-alpha/Kbuild
+++ b/arch/alpha/include/asm/Kbuild
diff --git a/include/asm-alpha/a.out-core.h b/arch/alpha/include/asm/a.out-core.h
index 9e33e92e524c..9e33e92e524c 100644
--- a/include/asm-alpha/a.out-core.h
+++ b/arch/alpha/include/asm/a.out-core.h
diff --git a/include/asm-alpha/a.out.h b/arch/alpha/include/asm/a.out.h
index 02ce8473870a..02ce8473870a 100644
--- a/include/asm-alpha/a.out.h
+++ b/arch/alpha/include/asm/a.out.h
diff --git a/include/asm-alpha/agp.h b/arch/alpha/include/asm/agp.h
index 26c179135293..26c179135293 100644
--- a/include/asm-alpha/agp.h
+++ b/arch/alpha/include/asm/agp.h
diff --git a/include/asm-alpha/agp_backend.h b/arch/alpha/include/asm/agp_backend.h
index 55dd44a2cea7..55dd44a2cea7 100644
--- a/include/asm-alpha/agp_backend.h
+++ b/arch/alpha/include/asm/agp_backend.h
diff --git a/include/asm-alpha/atomic.h b/arch/alpha/include/asm/atomic.h
index ca88e54dec93..ca88e54dec93 100644
--- a/include/asm-alpha/atomic.h
+++ b/arch/alpha/include/asm/atomic.h
diff --git a/include/asm-alpha/auxvec.h b/arch/alpha/include/asm/auxvec.h
index e96fe880e310..e96fe880e310 100644
--- a/include/asm-alpha/auxvec.h
+++ b/arch/alpha/include/asm/auxvec.h
diff --git a/include/asm-alpha/barrier.h b/arch/alpha/include/asm/barrier.h
index ac78eba909bc..ac78eba909bc 100644
--- a/include/asm-alpha/barrier.h
+++ b/arch/alpha/include/asm/barrier.h
diff --git a/include/asm-alpha/bitops.h b/arch/alpha/include/asm/bitops.h
index 15f3ae25c511..15f3ae25c511 100644
--- a/include/asm-alpha/bitops.h
+++ b/arch/alpha/include/asm/bitops.h
diff --git a/include/asm-alpha/bug.h b/arch/alpha/include/asm/bug.h
index 695a5ee4b5d3..695a5ee4b5d3 100644
--- a/include/asm-alpha/bug.h
+++ b/arch/alpha/include/asm/bug.h
diff --git a/include/asm-alpha/bugs.h b/arch/alpha/include/asm/bugs.h
index 78030d1c7e7e..78030d1c7e7e 100644
--- a/include/asm-alpha/bugs.h
+++ b/arch/alpha/include/asm/bugs.h
diff --git a/include/asm-alpha/byteorder.h b/arch/alpha/include/asm/byteorder.h
index 58e958fc7f1b..58e958fc7f1b 100644
--- a/include/asm-alpha/byteorder.h
+++ b/arch/alpha/include/asm/byteorder.h
diff --git a/include/asm-alpha/cache.h b/arch/alpha/include/asm/cache.h
index f199e69a5d0b..f199e69a5d0b 100644
--- a/include/asm-alpha/cache.h
+++ b/arch/alpha/include/asm/cache.h
diff --git a/include/asm-alpha/cacheflush.h b/arch/alpha/include/asm/cacheflush.h
index b686cc7fc44e..b686cc7fc44e 100644
--- a/include/asm-alpha/cacheflush.h
+++ b/arch/alpha/include/asm/cacheflush.h
diff --git a/include/asm-alpha/checksum.h b/arch/alpha/include/asm/checksum.h
index d3854bbf0a9e..d3854bbf0a9e 100644
--- a/include/asm-alpha/checksum.h
+++ b/arch/alpha/include/asm/checksum.h
diff --git a/include/asm-alpha/compiler.h b/arch/alpha/include/asm/compiler.h
index da6bb199839c..da6bb199839c 100644
--- a/include/asm-alpha/compiler.h
+++ b/arch/alpha/include/asm/compiler.h
diff --git a/include/asm-alpha/console.h b/arch/alpha/include/asm/console.h
index a3ce4e62249b..a3ce4e62249b 100644
--- a/include/asm-alpha/console.h
+++ b/arch/alpha/include/asm/console.h
diff --git a/include/asm-alpha/core_apecs.h b/arch/alpha/include/asm/core_apecs.h
index 6785ff7e02bc..6785ff7e02bc 100644
--- a/include/asm-alpha/core_apecs.h
+++ b/arch/alpha/include/asm/core_apecs.h
diff --git a/include/asm-alpha/core_cia.h b/arch/alpha/include/asm/core_cia.h
index 9e0516c0ca27..9e0516c0ca27 100644
--- a/include/asm-alpha/core_cia.h
+++ b/arch/alpha/include/asm/core_cia.h
diff --git a/include/asm-alpha/core_irongate.h b/arch/alpha/include/asm/core_irongate.h
index 24b2db541501..24b2db541501 100644
--- a/include/asm-alpha/core_irongate.h
+++ b/arch/alpha/include/asm/core_irongate.h
diff --git a/include/asm-alpha/core_lca.h b/arch/alpha/include/asm/core_lca.h
index f7cb4b460954..f7cb4b460954 100644
--- a/include/asm-alpha/core_lca.h
+++ b/arch/alpha/include/asm/core_lca.h
diff --git a/include/asm-alpha/core_marvel.h b/arch/alpha/include/asm/core_marvel.h
index 30d55fe7aaf6..30d55fe7aaf6 100644
--- a/include/asm-alpha/core_marvel.h
+++ b/arch/alpha/include/asm/core_marvel.h
diff --git a/include/asm-alpha/core_mcpcia.h b/arch/alpha/include/asm/core_mcpcia.h
index acf55b483472..acf55b483472 100644
--- a/include/asm-alpha/core_mcpcia.h
+++ b/arch/alpha/include/asm/core_mcpcia.h
diff --git a/include/asm-alpha/core_polaris.h b/arch/alpha/include/asm/core_polaris.h
index 2f966b64659d..2f966b64659d 100644
--- a/include/asm-alpha/core_polaris.h
+++ b/arch/alpha/include/asm/core_polaris.h
diff --git a/include/asm-alpha/core_t2.h b/arch/alpha/include/asm/core_t2.h
index 46bfff58f670..46bfff58f670 100644
--- a/include/asm-alpha/core_t2.h
+++ b/arch/alpha/include/asm/core_t2.h
diff --git a/include/asm-alpha/core_titan.h b/arch/alpha/include/asm/core_titan.h
index a17f6f33b68e..a17f6f33b68e 100644
--- a/include/asm-alpha/core_titan.h
+++ b/arch/alpha/include/asm/core_titan.h
diff --git a/include/asm-alpha/core_tsunami.h b/arch/alpha/include/asm/core_tsunami.h
index 58d4fe48742c..58d4fe48742c 100644
--- a/include/asm-alpha/core_tsunami.h
+++ b/arch/alpha/include/asm/core_tsunami.h
diff --git a/include/asm-alpha/core_wildfire.h b/arch/alpha/include/asm/core_wildfire.h
index cd562f544ba2..cd562f544ba2 100644
--- a/include/asm-alpha/core_wildfire.h
+++ b/arch/alpha/include/asm/core_wildfire.h
diff --git a/include/asm-alpha/cputime.h b/arch/alpha/include/asm/cputime.h
index 19577fd93230..19577fd93230 100644
--- a/include/asm-alpha/cputime.h
+++ b/arch/alpha/include/asm/cputime.h
diff --git a/include/asm-alpha/current.h b/arch/alpha/include/asm/current.h
index 094d285a1b34..094d285a1b34 100644
--- a/include/asm-alpha/current.h
+++ b/arch/alpha/include/asm/current.h
diff --git a/include/asm-alpha/delay.h b/arch/alpha/include/asm/delay.h
index 2aa3f410f7e6..2aa3f410f7e6 100644
--- a/include/asm-alpha/delay.h
+++ b/arch/alpha/include/asm/delay.h
diff --git a/include/asm-alpha/device.h b/arch/alpha/include/asm/device.h
index d8f9872b0e2d..d8f9872b0e2d 100644
--- a/include/asm-alpha/device.h
+++ b/arch/alpha/include/asm/device.h
diff --git a/include/asm-alpha/div64.h b/arch/alpha/include/asm/div64.h
index 6cd978cefb28..6cd978cefb28 100644
--- a/include/asm-alpha/div64.h
+++ b/arch/alpha/include/asm/div64.h
diff --git a/include/asm-alpha/dma-mapping.h b/arch/alpha/include/asm/dma-mapping.h
index a5801ae02e4b..a5801ae02e4b 100644
--- a/include/asm-alpha/dma-mapping.h
+++ b/arch/alpha/include/asm/dma-mapping.h
diff --git a/include/asm-alpha/dma.h b/arch/alpha/include/asm/dma.h
index 87cfdbdf08fc..87cfdbdf08fc 100644
--- a/include/asm-alpha/dma.h
+++ b/arch/alpha/include/asm/dma.h
diff --git a/include/asm-alpha/elf.h b/arch/alpha/include/asm/elf.h
index fc1002ea1e0c..fc1002ea1e0c 100644
--- a/include/asm-alpha/elf.h
+++ b/arch/alpha/include/asm/elf.h
diff --git a/include/asm-alpha/emergency-restart.h b/arch/alpha/include/asm/emergency-restart.h
index 108d8c48e42e..108d8c48e42e 100644
--- a/include/asm-alpha/emergency-restart.h
+++ b/arch/alpha/include/asm/emergency-restart.h
diff --git a/include/asm-alpha/err_common.h b/arch/alpha/include/asm/err_common.h
index c25095942107..c25095942107 100644
--- a/include/asm-alpha/err_common.h
+++ b/arch/alpha/include/asm/err_common.h
diff --git a/include/asm-alpha/err_ev6.h b/arch/alpha/include/asm/err_ev6.h
index ea637791e4a9..ea637791e4a9 100644
--- a/include/asm-alpha/err_ev6.h
+++ b/arch/alpha/include/asm/err_ev6.h
diff --git a/include/asm-alpha/err_ev7.h b/arch/alpha/include/asm/err_ev7.h
index 87f99777c2e4..87f99777c2e4 100644
--- a/include/asm-alpha/err_ev7.h
+++ b/arch/alpha/include/asm/err_ev7.h
diff --git a/include/asm-alpha/errno.h b/arch/alpha/include/asm/errno.h
index 69e2655249d2..69e2655249d2 100644
--- a/include/asm-alpha/errno.h
+++ b/arch/alpha/include/asm/errno.h
diff --git a/include/asm-alpha/fb.h b/arch/alpha/include/asm/fb.h
index fa9bbb96b2b3..fa9bbb96b2b3 100644
--- a/include/asm-alpha/fb.h
+++ b/arch/alpha/include/asm/fb.h
diff --git a/include/asm-alpha/fcntl.h b/arch/alpha/include/asm/fcntl.h
index 25da0017ec87..25da0017ec87 100644
--- a/include/asm-alpha/fcntl.h
+++ b/arch/alpha/include/asm/fcntl.h
diff --git a/include/asm-alpha/floppy.h b/arch/alpha/include/asm/floppy.h
index 0be50413b2b5..0be50413b2b5 100644
--- a/include/asm-alpha/floppy.h
+++ b/arch/alpha/include/asm/floppy.h
diff --git a/include/asm-alpha/fpu.h b/arch/alpha/include/asm/fpu.h
index ecb17a72acc3..ecb17a72acc3 100644
--- a/include/asm-alpha/fpu.h
+++ b/arch/alpha/include/asm/fpu.h
diff --git a/include/asm-alpha/futex.h b/arch/alpha/include/asm/futex.h
index 6a332a9f099c..6a332a9f099c 100644
--- a/include/asm-alpha/futex.h
+++ b/arch/alpha/include/asm/futex.h
diff --git a/include/asm-alpha/gct.h b/arch/alpha/include/asm/gct.h
index 3504c704927c..3504c704927c 100644
--- a/include/asm-alpha/gct.h
+++ b/arch/alpha/include/asm/gct.h
diff --git a/include/asm-alpha/gentrap.h b/arch/alpha/include/asm/gentrap.h
index ae50cc3192c7..ae50cc3192c7 100644
--- a/include/asm-alpha/gentrap.h
+++ b/arch/alpha/include/asm/gentrap.h
diff --git a/include/asm-alpha/hardirq.h b/arch/alpha/include/asm/hardirq.h
index d953e234daa8..d953e234daa8 100644
--- a/include/asm-alpha/hardirq.h
+++ b/arch/alpha/include/asm/hardirq.h
diff --git a/include/asm-alpha/hw_irq.h b/arch/alpha/include/asm/hw_irq.h
index a37db0f95092..a37db0f95092 100644
--- a/include/asm-alpha/hw_irq.h
+++ b/arch/alpha/include/asm/hw_irq.h
diff --git a/include/asm-alpha/hwrpb.h b/arch/alpha/include/asm/hwrpb.h
index 8e8f871af7cf..8e8f871af7cf 100644
--- a/include/asm-alpha/hwrpb.h
+++ b/arch/alpha/include/asm/hwrpb.h
diff --git a/include/asm-alpha/io.h b/arch/alpha/include/asm/io.h
index e971ab000f95..e971ab000f95 100644
--- a/include/asm-alpha/io.h
+++ b/arch/alpha/include/asm/io.h
diff --git a/include/asm-alpha/io_trivial.h b/arch/alpha/include/asm/io_trivial.h
index 1c77f10b4b36..1c77f10b4b36 100644
--- a/include/asm-alpha/io_trivial.h
+++ b/arch/alpha/include/asm/io_trivial.h
diff --git a/include/asm-alpha/ioctl.h b/arch/alpha/include/asm/ioctl.h
index fc63727f4178..fc63727f4178 100644
--- a/include/asm-alpha/ioctl.h
+++ b/arch/alpha/include/asm/ioctl.h
diff --git a/include/asm-alpha/ioctls.h b/arch/alpha/include/asm/ioctls.h
index 67bb9f6fdbe4..67bb9f6fdbe4 100644
--- a/include/asm-alpha/ioctls.h
+++ b/arch/alpha/include/asm/ioctls.h
diff --git a/include/asm-alpha/ipcbuf.h b/arch/alpha/include/asm/ipcbuf.h
index d9c0e1a50702..d9c0e1a50702 100644
--- a/include/asm-alpha/ipcbuf.h
+++ b/arch/alpha/include/asm/ipcbuf.h
diff --git a/include/asm-alpha/irq.h b/arch/alpha/include/asm/irq.h
index 06377400dc09..06377400dc09 100644
--- a/include/asm-alpha/irq.h
+++ b/arch/alpha/include/asm/irq.h
diff --git a/include/asm-alpha/irq_regs.h b/arch/alpha/include/asm/irq_regs.h
index 3dd9c0b70270..3dd9c0b70270 100644
--- a/include/asm-alpha/irq_regs.h
+++ b/arch/alpha/include/asm/irq_regs.h
diff --git a/include/asm-alpha/jensen.h b/arch/alpha/include/asm/jensen.h
index 964b06ead43b..964b06ead43b 100644
--- a/include/asm-alpha/jensen.h
+++ b/arch/alpha/include/asm/jensen.h
diff --git a/include/asm-alpha/kdebug.h b/arch/alpha/include/asm/kdebug.h
index 6ece1b037665..6ece1b037665 100644
--- a/include/asm-alpha/kdebug.h
+++ b/arch/alpha/include/asm/kdebug.h
diff --git a/include/asm-alpha/kmap_types.h b/arch/alpha/include/asm/kmap_types.h
index 3e6735a34c57..3e6735a34c57 100644
--- a/include/asm-alpha/kmap_types.h
+++ b/arch/alpha/include/asm/kmap_types.h
diff --git a/include/asm-alpha/linkage.h b/arch/alpha/include/asm/linkage.h
index 291c2d01c44f..291c2d01c44f 100644
--- a/include/asm-alpha/linkage.h
+++ b/arch/alpha/include/asm/linkage.h
diff --git a/include/asm-alpha/local.h b/arch/alpha/include/asm/local.h
index 6ad3ea696421..6ad3ea696421 100644
--- a/include/asm-alpha/local.h
+++ b/arch/alpha/include/asm/local.h
diff --git a/include/asm-alpha/machvec.h b/arch/alpha/include/asm/machvec.h
index a86c083cdf7f..a86c083cdf7f 100644
--- a/include/asm-alpha/machvec.h
+++ b/arch/alpha/include/asm/machvec.h
diff --git a/include/asm-alpha/mc146818rtc.h b/arch/alpha/include/asm/mc146818rtc.h
index 097703f1c8cb..097703f1c8cb 100644
--- a/include/asm-alpha/mc146818rtc.h
+++ b/arch/alpha/include/asm/mc146818rtc.h
diff --git a/include/asm-alpha/md.h b/arch/alpha/include/asm/md.h
index 6c9b8222a4f2..6c9b8222a4f2 100644
--- a/include/asm-alpha/md.h
+++ b/arch/alpha/include/asm/md.h
diff --git a/include/asm-alpha/mman.h b/arch/alpha/include/asm/mman.h
index 90d7c35d2867..90d7c35d2867 100644
--- a/include/asm-alpha/mman.h
+++ b/arch/alpha/include/asm/mman.h
diff --git a/include/asm-alpha/mmu.h b/arch/alpha/include/asm/mmu.h
index 3dc127779329..3dc127779329 100644
--- a/include/asm-alpha/mmu.h
+++ b/arch/alpha/include/asm/mmu.h
diff --git a/include/asm-alpha/mmu_context.h b/arch/alpha/include/asm/mmu_context.h
index 86c08a02d239..86c08a02d239 100644
--- a/include/asm-alpha/mmu_context.h
+++ b/arch/alpha/include/asm/mmu_context.h
diff --git a/include/asm-alpha/mmzone.h b/arch/alpha/include/asm/mmzone.h
index 8af56ce346ad..8af56ce346ad 100644
--- a/include/asm-alpha/mmzone.h
+++ b/arch/alpha/include/asm/mmzone.h
diff --git a/include/asm-alpha/module.h b/arch/alpha/include/asm/module.h
index 7b63743c534a..7b63743c534a 100644
--- a/include/asm-alpha/module.h
+++ b/arch/alpha/include/asm/module.h
diff --git a/include/asm-alpha/msgbuf.h b/arch/alpha/include/asm/msgbuf.h
index 98496501a2bb..98496501a2bb 100644
--- a/include/asm-alpha/msgbuf.h
+++ b/arch/alpha/include/asm/msgbuf.h
diff --git a/include/asm-alpha/mutex.h b/arch/alpha/include/asm/mutex.h
index 458c1f7fbc18..458c1f7fbc18 100644
--- a/include/asm-alpha/mutex.h
+++ b/arch/alpha/include/asm/mutex.h
diff --git a/include/asm-alpha/page.h b/arch/alpha/include/asm/page.h
index 0995f9d13417..0995f9d13417 100644
--- a/include/asm-alpha/page.h
+++ b/arch/alpha/include/asm/page.h
diff --git a/include/asm-alpha/pal.h b/arch/alpha/include/asm/pal.h
index 9b4ba0d6f00b..9b4ba0d6f00b 100644
--- a/include/asm-alpha/pal.h
+++ b/arch/alpha/include/asm/pal.h
diff --git a/include/asm-alpha/param.h b/arch/alpha/include/asm/param.h
index e691ecfedb2c..e691ecfedb2c 100644
--- a/include/asm-alpha/param.h
+++ b/arch/alpha/include/asm/param.h
diff --git a/include/asm-alpha/parport.h b/arch/alpha/include/asm/parport.h
index c5ee7cbb2fcd..c5ee7cbb2fcd 100644
--- a/include/asm-alpha/parport.h
+++ b/arch/alpha/include/asm/parport.h
diff --git a/include/asm-alpha/pci.h b/arch/alpha/include/asm/pci.h
index 2a14302c17a3..2a14302c17a3 100644
--- a/include/asm-alpha/pci.h
+++ b/arch/alpha/include/asm/pci.h
diff --git a/include/asm-alpha/percpu.h b/arch/alpha/include/asm/percpu.h
index 3495e8e00d70..3495e8e00d70 100644
--- a/include/asm-alpha/percpu.h
+++ b/arch/alpha/include/asm/percpu.h
diff --git a/include/asm-alpha/pgalloc.h b/arch/alpha/include/asm/pgalloc.h
index fd090155dccd..fd090155dccd 100644
--- a/include/asm-alpha/pgalloc.h
+++ b/arch/alpha/include/asm/pgalloc.h
diff --git a/include/asm-alpha/pgtable.h b/arch/alpha/include/asm/pgtable.h
index 3f0c59f6d8aa..3f0c59f6d8aa 100644
--- a/include/asm-alpha/pgtable.h
+++ b/arch/alpha/include/asm/pgtable.h
diff --git a/include/asm-alpha/poll.h b/arch/alpha/include/asm/poll.h
index c98509d3149e..c98509d3149e 100644
--- a/include/asm-alpha/poll.h
+++ b/arch/alpha/include/asm/poll.h
diff --git a/include/asm-alpha/posix_types.h b/arch/alpha/include/asm/posix_types.h
index db167413300b..db167413300b 100644
--- a/include/asm-alpha/posix_types.h
+++ b/arch/alpha/include/asm/posix_types.h
diff --git a/include/asm-alpha/processor.h b/arch/alpha/include/asm/processor.h
index 94afe5859301..94afe5859301 100644
--- a/include/asm-alpha/processor.h
+++ b/arch/alpha/include/asm/processor.h
diff --git a/include/asm-alpha/ptrace.h b/arch/alpha/include/asm/ptrace.h
index 32c7a5cddd59..32c7a5cddd59 100644
--- a/include/asm-alpha/ptrace.h
+++ b/arch/alpha/include/asm/ptrace.h
diff --git a/include/asm-alpha/reg.h b/arch/alpha/include/asm/reg.h
index 86ff916fb069..86ff916fb069 100644
--- a/include/asm-alpha/reg.h
+++ b/arch/alpha/include/asm/reg.h
diff --git a/include/asm-alpha/regdef.h b/arch/alpha/include/asm/regdef.h
index 142df9c4f8b8..142df9c4f8b8 100644
--- a/include/asm-alpha/regdef.h
+++ b/arch/alpha/include/asm/regdef.h
diff --git a/include/asm-alpha/resource.h b/arch/alpha/include/asm/resource.h
index c10874ff5973..c10874ff5973 100644
--- a/include/asm-alpha/resource.h
+++ b/arch/alpha/include/asm/resource.h
diff --git a/include/asm-alpha/rtc.h b/arch/alpha/include/asm/rtc.h
index 4e854b1333eb..4e854b1333eb 100644
--- a/include/asm-alpha/rtc.h
+++ b/arch/alpha/include/asm/rtc.h
diff --git a/include/asm-alpha/rwsem.h b/arch/alpha/include/asm/rwsem.h
index 1570c0b54336..1570c0b54336 100644
--- a/include/asm-alpha/rwsem.h
+++ b/arch/alpha/include/asm/rwsem.h
diff --git a/include/asm-alpha/scatterlist.h b/arch/alpha/include/asm/scatterlist.h
index 440747ca6349..440747ca6349 100644
--- a/include/asm-alpha/scatterlist.h
+++ b/arch/alpha/include/asm/scatterlist.h
diff --git a/include/asm-alpha/sections.h b/arch/alpha/include/asm/sections.h
index 43b40edd6e44..43b40edd6e44 100644
--- a/include/asm-alpha/sections.h
+++ b/arch/alpha/include/asm/sections.h
diff --git a/include/asm-alpha/segment.h b/arch/alpha/include/asm/segment.h
index 0453d97daae7..0453d97daae7 100644
--- a/include/asm-alpha/segment.h
+++ b/arch/alpha/include/asm/segment.h
diff --git a/include/asm-alpha/sembuf.h b/arch/alpha/include/asm/sembuf.h
index 7b38b1534784..7b38b1534784 100644
--- a/include/asm-alpha/sembuf.h
+++ b/arch/alpha/include/asm/sembuf.h
diff --git a/include/asm-alpha/serial.h b/arch/alpha/include/asm/serial.h
index 9d263e8d8ccc..9d263e8d8ccc 100644
--- a/include/asm-alpha/serial.h
+++ b/arch/alpha/include/asm/serial.h
diff --git a/include/asm-alpha/setup.h b/arch/alpha/include/asm/setup.h
index 2e023a4aa317..2e023a4aa317 100644
--- a/include/asm-alpha/setup.h
+++ b/arch/alpha/include/asm/setup.h
diff --git a/include/asm-alpha/sfp-machine.h b/arch/alpha/include/asm/sfp-machine.h
index 5fe63afbd474..5fe63afbd474 100644
--- a/include/asm-alpha/sfp-machine.h
+++ b/arch/alpha/include/asm/sfp-machine.h
diff --git a/include/asm-alpha/shmbuf.h b/arch/alpha/include/asm/shmbuf.h
index 37ee84f05085..37ee84f05085 100644
--- a/include/asm-alpha/shmbuf.h
+++ b/arch/alpha/include/asm/shmbuf.h
diff --git a/include/asm-alpha/shmparam.h b/arch/alpha/include/asm/shmparam.h
index cc901d58aebb..cc901d58aebb 100644
--- a/include/asm-alpha/shmparam.h
+++ b/arch/alpha/include/asm/shmparam.h
diff --git a/include/asm-alpha/sigcontext.h b/arch/alpha/include/asm/sigcontext.h
index 323cdb026198..323cdb026198 100644
--- a/include/asm-alpha/sigcontext.h
+++ b/arch/alpha/include/asm/sigcontext.h
diff --git a/include/asm-alpha/siginfo.h b/arch/alpha/include/asm/siginfo.h
index 9822362a8424..9822362a8424 100644
--- a/include/asm-alpha/siginfo.h
+++ b/arch/alpha/include/asm/siginfo.h
diff --git a/include/asm-alpha/signal.h b/arch/alpha/include/asm/signal.h
index 13c2305d35ef..13c2305d35ef 100644
--- a/include/asm-alpha/signal.h
+++ b/arch/alpha/include/asm/signal.h
diff --git a/include/asm-alpha/smp.h b/arch/alpha/include/asm/smp.h
index 544c69af8168..544c69af8168 100644
--- a/include/asm-alpha/smp.h
+++ b/arch/alpha/include/asm/smp.h
diff --git a/include/asm-alpha/socket.h b/arch/alpha/include/asm/socket.h
index a1057c2d95e7..a1057c2d95e7 100644
--- a/include/asm-alpha/socket.h
+++ b/arch/alpha/include/asm/socket.h
diff --git a/include/asm-alpha/sockios.h b/arch/alpha/include/asm/sockios.h
index 7932c7ab4a4d..7932c7ab4a4d 100644
--- a/include/asm-alpha/sockios.h
+++ b/arch/alpha/include/asm/sockios.h
diff --git a/include/asm-alpha/spinlock.h b/arch/alpha/include/asm/spinlock.h
index aeeb125f6851..aeeb125f6851 100644
--- a/include/asm-alpha/spinlock.h
+++ b/arch/alpha/include/asm/spinlock.h
diff --git a/include/asm-alpha/spinlock_types.h b/arch/alpha/include/asm/spinlock_types.h
index 8141eb5ebf0d..8141eb5ebf0d 100644
--- a/include/asm-alpha/spinlock_types.h
+++ b/arch/alpha/include/asm/spinlock_types.h
diff --git a/include/asm-alpha/stat.h b/arch/alpha/include/asm/stat.h
index 07ad3e6b3f3e..07ad3e6b3f3e 100644
--- a/include/asm-alpha/stat.h
+++ b/arch/alpha/include/asm/stat.h
diff --git a/include/asm-alpha/statfs.h b/arch/alpha/include/asm/statfs.h
index ad15830baefe..ad15830baefe 100644
--- a/include/asm-alpha/statfs.h
+++ b/arch/alpha/include/asm/statfs.h
diff --git a/include/asm-alpha/string.h b/arch/alpha/include/asm/string.h
index b02b8a282940..b02b8a282940 100644
--- a/include/asm-alpha/string.h
+++ b/arch/alpha/include/asm/string.h
diff --git a/include/asm-alpha/suspend.h b/arch/alpha/include/asm/suspend.h
index c7042d575851..c7042d575851 100644
--- a/include/asm-alpha/suspend.h
+++ b/arch/alpha/include/asm/suspend.h
diff --git a/include/asm-alpha/sysinfo.h b/arch/alpha/include/asm/sysinfo.h
index 086aba284df2..086aba284df2 100644
--- a/include/asm-alpha/sysinfo.h
+++ b/arch/alpha/include/asm/sysinfo.h
diff --git a/include/asm-alpha/system.h b/arch/alpha/include/asm/system.h
index afe20fa58c99..afe20fa58c99 100644
--- a/include/asm-alpha/system.h
+++ b/arch/alpha/include/asm/system.h
diff --git a/include/asm-alpha/termbits.h b/arch/alpha/include/asm/termbits.h
index ad854a4a3af6..ad854a4a3af6 100644
--- a/include/asm-alpha/termbits.h
+++ b/arch/alpha/include/asm/termbits.h
diff --git a/include/asm-alpha/termios.h b/arch/alpha/include/asm/termios.h
index fa13716a11c3..fa13716a11c3 100644
--- a/include/asm-alpha/termios.h
+++ b/arch/alpha/include/asm/termios.h
diff --git a/include/asm-alpha/thread_info.h b/arch/alpha/include/asm/thread_info.h
index 15fda4344424..15fda4344424 100644
--- a/include/asm-alpha/thread_info.h
+++ b/arch/alpha/include/asm/thread_info.h
diff --git a/include/asm-alpha/timex.h b/arch/alpha/include/asm/timex.h
index afa0c45e3e98..afa0c45e3e98 100644
--- a/include/asm-alpha/timex.h
+++ b/arch/alpha/include/asm/timex.h
diff --git a/include/asm-alpha/tlb.h b/arch/alpha/include/asm/tlb.h
index c13636575fba..c13636575fba 100644
--- a/include/asm-alpha/tlb.h
+++ b/arch/alpha/include/asm/tlb.h
diff --git a/include/asm-alpha/tlbflush.h b/arch/alpha/include/asm/tlbflush.h
index 9d87aaa08c0d..9d87aaa08c0d 100644
--- a/include/asm-alpha/tlbflush.h
+++ b/arch/alpha/include/asm/tlbflush.h
diff --git a/include/asm-alpha/topology.h b/arch/alpha/include/asm/topology.h
index 149532e162c4..149532e162c4 100644
--- a/include/asm-alpha/topology.h
+++ b/arch/alpha/include/asm/topology.h
diff --git a/include/asm-alpha/types.h b/arch/alpha/include/asm/types.h
index c1541353ccef..c1541353ccef 100644
--- a/include/asm-alpha/types.h
+++ b/arch/alpha/include/asm/types.h
diff --git a/include/asm-alpha/uaccess.h b/arch/alpha/include/asm/uaccess.h
index 22de3b434a22..22de3b434a22 100644
--- a/include/asm-alpha/uaccess.h
+++ b/arch/alpha/include/asm/uaccess.h
diff --git a/include/asm-alpha/ucontext.h b/arch/alpha/include/asm/ucontext.h
index 47578ab42152..47578ab42152 100644
--- a/include/asm-alpha/ucontext.h
+++ b/arch/alpha/include/asm/ucontext.h
diff --git a/include/asm-alpha/unaligned.h b/arch/alpha/include/asm/unaligned.h
index 3787c60aed3f..3787c60aed3f 100644
--- a/include/asm-alpha/unaligned.h
+++ b/arch/alpha/include/asm/unaligned.h
diff --git a/include/asm-alpha/unistd.h b/arch/alpha/include/asm/unistd.h
index 5b5c17485942..5b5c17485942 100644
--- a/include/asm-alpha/unistd.h
+++ b/arch/alpha/include/asm/unistd.h
diff --git a/include/asm-alpha/user.h b/arch/alpha/include/asm/user.h
index a4eb6a4ca8d1..a4eb6a4ca8d1 100644
--- a/include/asm-alpha/user.h
+++ b/arch/alpha/include/asm/user.h
diff --git a/include/asm-alpha/vga.h b/arch/alpha/include/asm/vga.h
index c00106bac521..c00106bac521 100644
--- a/include/asm-alpha/vga.h
+++ b/arch/alpha/include/asm/vga.h
diff --git a/include/asm-alpha/xor.h b/arch/alpha/include/asm/xor.h
index 5ee1c2bc0499..5ee1c2bc0499 100644
--- a/include/asm-alpha/xor.h
+++ b/arch/alpha/include/asm/xor.h
diff --git a/arch/arm/include/asm/kexec.h b/arch/arm/include/asm/kexec.h
index c8986bb99ed5..df15a0dc228e 100644
--- a/arch/arm/include/asm/kexec.h
+++ b/arch/arm/include/asm/kexec.h
@@ -10,7 +10,7 @@
 /* Maximum address we can use for the control code buffer */
 #define KEXEC_CONTROL_MEMORY_LIMIT (-1UL)
 
-#define KEXEC_CONTROL_CODE_SIZE 4096
+#define KEXEC_CONTROL_PAGE_SIZE 4096
 
 #define KEXEC_ARCH KEXEC_ARCH_ARM
 
diff --git a/arch/arm/kernel/machine_kexec.c b/arch/arm/kernel/machine_kexec.c
index db8f54a3451f..fae5beb3c3d6 100644
--- a/arch/arm/kernel/machine_kexec.c
+++ b/arch/arm/kernel/machine_kexec.c
@@ -71,7 +71,7 @@ void machine_kexec(struct kimage *image)
 
 
         flush_icache_range((unsigned long) reboot_code_buffer,
-                           (unsigned long) reboot_code_buffer + KEXEC_CONTROL_CODE_SIZE);
+                           (unsigned long) reboot_code_buffer + KEXEC_CONTROL_PAGE_SIZE);
         printk(KERN_INFO "Bye!\n");
 
         cpu_proc_fin();
diff --git a/arch/ia64/include/asm/kexec.h b/arch/ia64/include/asm/kexec.h
index 541be835fc5a..e1d58f819d78 100644
--- a/arch/ia64/include/asm/kexec.h
+++ b/arch/ia64/include/asm/kexec.h
@@ -9,7 +9,7 @@
 /* Maximum address we can use for the control code buffer */
 #define KEXEC_CONTROL_MEMORY_LIMIT TASK_SIZE
 
-#define KEXEC_CONTROL_CODE_SIZE (8192 + 8192 + 4096)
+#define KEXEC_CONTROL_PAGE_SIZE (8192 + 8192 + 4096)
 
 /* The native architecture */
 #define KEXEC_ARCH KEXEC_ARCH_IA_64
diff --git a/arch/powerpc/include/asm/kexec.h b/arch/powerpc/include/asm/kexec.h
index acdcdc66f1b6..3736d9b33289 100644
--- a/arch/powerpc/include/asm/kexec.h
+++ b/arch/powerpc/include/asm/kexec.h
@@ -22,7 +22,7 @@
 #define KEXEC_CONTROL_MEMORY_LIMIT TASK_SIZE
 #endif
 
-#define KEXEC_CONTROL_CODE_SIZE 4096
+#define KEXEC_CONTROL_PAGE_SIZE 4096
 
 /* The native architecture */
 #ifdef __powerpc64__
diff --git a/arch/powerpc/kernel/machine_kexec_32.c b/arch/powerpc/kernel/machine_kexec_32.c
index cbaa34196797..ae63a964b858 100644
--- a/arch/powerpc/kernel/machine_kexec_32.c
+++ b/arch/powerpc/kernel/machine_kexec_32.c
@@ -51,7 +51,7 @@ void default_machine_kexec(struct kimage *image)
                                                 relocate_new_kernel_size);
 
         flush_icache_range(reboot_code_buffer,
-                                reboot_code_buffer + KEXEC_CONTROL_CODE_SIZE);
+                                reboot_code_buffer + KEXEC_CONTROL_PAGE_SIZE);
         printk(KERN_INFO "Bye!\n");
 
         /* now call it */
diff --git a/arch/s390/include/asm/kexec.h b/arch/s390/include/asm/kexec.h
index f219c6411e0b..bb729b84a21e 100644
--- a/arch/s390/include/asm/kexec.h
+++ b/arch/s390/include/asm/kexec.h
@@ -31,7 +31,7 @@
 #define KEXEC_CONTROL_MEMORY_LIMIT (1UL<<31)
 
 /* Allocate one page for the pdp and the second for the code */
-#define KEXEC_CONTROL_CODE_SIZE 4096
+#define KEXEC_CONTROL_PAGE_SIZE 4096
 
 /* The native architecture */
 #define KEXEC_ARCH KEXEC_ARCH_S390
diff --git a/arch/sh/include/asm/kexec.h b/arch/sh/include/asm/kexec.h
index 00f4260ef09b..765a5e1660fc 100644
--- a/arch/sh/include/asm/kexec.h
+++ b/arch/sh/include/asm/kexec.h
@@ -21,7 +21,7 @@
 /* Maximum address we can use for the control code buffer */
 #define KEXEC_CONTROL_MEMORY_LIMIT TASK_SIZE
 
-#define KEXEC_CONTROL_CODE_SIZE 4096
+#define KEXEC_CONTROL_PAGE_SIZE 4096
 
 /* The native architecture */
 #define KEXEC_ARCH KEXEC_ARCH_SH
diff --git a/arch/x86/kernel/machine_kexec_32.c b/arch/x86/kernel/machine_kexec_32.c
index 9fe478d98406..0732adba05ca 100644
--- a/arch/x86/kernel/machine_kexec_32.c
+++ b/arch/x86/kernel/machine_kexec_32.c
@@ -12,6 +12,7 @@
 #include <linux/init.h>
 #include <linux/numa.h>
 #include <linux/ftrace.h>
+#include <linux/suspend.h>
 
 #include <asm/pgtable.h>
 #include <asm/pgalloc.h>
@@ -78,7 +79,7 @@ static void load_segments(void)
 /*
  * A architecture hook called to validate the
  * proposed image and prepare the control pages
- * as needed.  The pages for KEXEC_CONTROL_CODE_SIZE
+ * as needed.  The pages for KEXEC_CONTROL_PAGE_SIZE
  * have been allocated, but the segments have yet
  * been copied into the kernel.
  *
@@ -113,6 +114,7 @@ void machine_kexec(struct kimage *image)
 {
         unsigned long page_list[PAGES_NR];
         void *control_page;
+        int save_ftrace_enabled;
         asmlinkage unsigned long
                 (*relocate_kernel_ptr)(unsigned long indirection_page,
                                        unsigned long control_page,
@@ -120,7 +122,12 @@ void machine_kexec(struct kimage *image)
                                        unsigned int has_pae,
                                        unsigned int preserve_context);
 
-        tracer_disable();
+#ifdef CONFIG_KEXEC_JUMP
+        if (kexec_image->preserve_context)
+                save_processor_state();
+#endif
+
+        save_ftrace_enabled = __ftrace_enabled_save();
 
         /* Interrupts aren't acceptable while we reboot */
         local_irq_disable();
@@ -138,7 +145,7 @@ void machine_kexec(struct kimage *image)
         }
 
         control_page = page_address(image->control_code_page);
-        memcpy(control_page, relocate_kernel, PAGE_SIZE/2);
+        memcpy(control_page, relocate_kernel, KEXEC_CONTROL_CODE_MAX_SIZE);
 
         relocate_kernel_ptr = control_page;
         page_list[PA_CONTROL_PAGE] = __pa(control_page);
@@ -178,6 +185,13 @@ void machine_kexec(struct kimage *image)
                                            (unsigned long)page_list,
                                            image->start, cpu_has_pae,
                                            image->preserve_context);
+
+#ifdef CONFIG_KEXEC_JUMP
+        if (kexec_image->preserve_context)
+                restore_processor_state();
+#endif
+
+        __ftrace_enabled_restore(save_ftrace_enabled);
 }
 
 void arch_crash_save_vmcoreinfo(void)
diff --git a/arch/x86/kernel/relocate_kernel_32.S b/arch/x86/kernel/relocate_kernel_32.S
index 703310a99023..6f50664b2ba5 100644
--- a/arch/x86/kernel/relocate_kernel_32.S
+++ b/arch/x86/kernel/relocate_kernel_32.S
@@ -20,10 +20,11 @@
 #define PAGE_ATTR (_PAGE_PRESENT | _PAGE_RW | _PAGE_ACCESSED | _PAGE_DIRTY)
 #define PAE_PGD_ATTR (_PAGE_PRESENT)
 
-/* control_page + PAGE_SIZE/2 ~ control_page + PAGE_SIZE * 3/4 are
- * used to save some data for jumping back
+/* control_page + KEXEC_CONTROL_CODE_MAX_SIZE
+ * ~ control_page + PAGE_SIZE are used as data storage and stack for
+ * jumping back
  */
-#define DATA(offset)            (PAGE_SIZE/2+(offset))
+#define DATA(offset)            (KEXEC_CONTROL_CODE_MAX_SIZE+(offset))
 
 /* Minimal CPU state */
 #define ESP                     DATA(0x0)
@@ -376,3 +377,6 @@ swap_pages:
         popl    %ebx
         popl    %ebp
         ret
+
+        .globl kexec_control_code_size
+.set kexec_control_code_size, . - relocate_kernel
diff --git a/arch/x86/kernel/vmlinux_32.lds.S b/arch/x86/kernel/vmlinux_32.lds.S
index cdb2363697d2..af5bdad84604 100644
--- a/arch/x86/kernel/vmlinux_32.lds.S
+++ b/arch/x86/kernel/vmlinux_32.lds.S
@@ -209,3 +209,11 @@ SECTIONS
 
   DWARF_DEBUG
 }
+
+#ifdef CONFIG_KEXEC
+/* Link time checks */
+#include <asm/kexec.h>
+
+ASSERT(kexec_control_code_size <= KEXEC_CONTROL_CODE_MAX_SIZE,
+       "kexec control code size is too big")
+#endif
diff --git a/drivers/char/tty_io.c b/drivers/char/tty_io.c
index 0e6866fe0f96..a27160ba21d7 100644
--- a/drivers/char/tty_io.c
+++ b/drivers/char/tty_io.c
@@ -2496,45 +2496,25 @@ static int tiocgwinsz(struct tty_struct *tty, struct winsize __user *arg)
 }
 
 /**
- *      tiocswinsz              -       implement window size set ioctl
- *      @tty; tty
- *      @arg: user buffer for result
+ *      tty_do_resize           -       resize event
+ *      @tty: tty being resized
+ *      @real_tty: real tty (if using a pty/tty pair)
+ *      @rows: rows (character)
+ *      @cols: cols (character)
  *
- *      Copies the user idea of the window size to the kernel. Traditionally
- *      this is just advisory information but for the Linux console it
- *      actually has driver level meaning and triggers a VC resize.
- *
- *      Locking:
- *              Called function use the console_sem is used to ensure we do
- *      not try and resize the console twice at once.
- *              The tty->termios_mutex is used to ensure we don't double
- *      resize and get confused. Lock order - tty->termios_mutex before
- *      console sem
+ *      Update the termios variables and send the neccessary signals to
+ *      peform a terminal resize correctly
  */
 
-static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
-        struct winsize __user *arg)
+int tty_do_resize(struct tty_struct *tty, struct tty_struct *real_tty,
+                                        struct winsize *ws)
 {
-        struct winsize tmp_ws;
         struct pid *pgrp, *rpgrp;
         unsigned long flags;
 
-        if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
-                return -EFAULT;
-
         mutex_lock(&tty->termios_mutex);
-        if (!memcmp(&tmp_ws, &tty->winsize, sizeof(*arg)))
+        if (!memcmp(ws, &tty->winsize, sizeof(*ws)))
                 goto done;
-
-#ifdef CONFIG_VT
-        if (tty->driver->type == TTY_DRIVER_TYPE_CONSOLE) {
-                if (vc_lock_resize(tty->driver_data, tmp_ws.ws_col,
-                                        tmp_ws.ws_row)) {
-                        mutex_unlock(&tty->termios_mutex);
-                        return -ENXIO;
-                }
-        }
-#endif
         /* Get the PID values and reference them so we can
            avoid holding the tty ctrl lock while sending signals */
         spin_lock_irqsave(&tty->ctrl_lock, flags);
@@ -2550,14 +2530,42 @@ static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
         put_pid(pgrp);
         put_pid(rpgrp);
 
-        tty->winsize = tmp_ws;
-        real_tty->winsize = tmp_ws;
+        tty->winsize = *ws;
+        real_tty->winsize = *ws;
 done:
         mutex_unlock(&tty->termios_mutex);
         return 0;
 }
 
 /**
+ *      tiocswinsz              -       implement window size set ioctl
+ *      @tty; tty
+ *      @arg: user buffer for result
+ *
+ *      Copies the user idea of the window size to the kernel. Traditionally
+ *      this is just advisory information but for the Linux console it
+ *      actually has driver level meaning and triggers a VC resize.
+ *
+ *      Locking:
+ *              Driver dependant. The default do_resize method takes the
+ *      tty termios mutex and ctrl_lock. The console takes its own lock
+ *      then calls into the default method.
+ */
+
+static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
+        struct winsize __user *arg)
+{
+        struct winsize tmp_ws;
+        if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
+                return -EFAULT;
+
+        if (tty->ops->resize)
+                return tty->ops->resize(tty, real_tty, &tmp_ws);
+        else
+                return tty_do_resize(tty, real_tty, &tmp_ws);
+}
+
+/**
  *      tioccons        -       allow admin to move logical console
  *      @file: the file to become console
  *
diff --git a/drivers/char/vt.c b/drivers/char/vt.c
index 1bc00c9d860d..60359c360912 100644
--- a/drivers/char/vt.c
+++ b/drivers/char/vt.c
@@ -803,7 +803,25 @@ static inline int resize_screen(struct vc_data *vc, int width, int height,
  */
 #define VC_RESIZE_MAXCOL (32767)
 #define VC_RESIZE_MAXROW (32767)
-int vc_resize(struct vc_data *vc, unsigned int cols, unsigned int lines)
+
+/**
+ *      vc_do_resize    -       resizing method for the tty
+ *      @tty: tty being resized
+ *      @real_tty: real tty (different to tty if a pty/tty pair)
+ *      @vc: virtual console private data
+ *      @cols: columns
+ *      @lines: lines
+ *
+ *      Resize a virtual console, clipping according to the actual constraints.
+ *      If the caller passes a tty structure then update the termios winsize
+ *      information and perform any neccessary signal handling.
+ *
+ *      Caller must hold the console semaphore. Takes the termios mutex and
+ *      ctrl_lock of the tty IFF a tty is passed.
+ */
+
+static int vc_do_resize(struct tty_struct *tty, struct tty_struct *real_tty,
+                struct vc_data *vc, unsigned int cols, unsigned int lines)
 {
         unsigned long old_origin, new_origin, new_scr_end, rlth, rrem, err = 0;
         unsigned int old_cols, old_rows, old_row_size, old_screen_size;
@@ -907,24 +925,15 @@ int vc_resize(struct vc_data *vc, unsigned int cols, unsigned int lines)
         gotoxy(vc, vc->vc_x, vc->vc_y);
         save_cur(vc);
 
-        if (vc->vc_tty) {
-                struct winsize ws, *cws = &vc->vc_tty->winsize;
-                struct pid *pgrp = NULL;
-
+        if (tty) {
+                /* Rewrite the requested winsize data with the actual
+                   resulting sizes */
+                struct winsize ws;
                 memset(&ws, 0, sizeof(ws));
                 ws.ws_row = vc->vc_rows;
                 ws.ws_col = vc->vc_cols;
                 ws.ws_ypixel = vc->vc_scan_lines;
-
-                spin_lock_irq(&vc->vc_tty->ctrl_lock);
-                if ((ws.ws_row != cws->ws_row || ws.ws_col != cws->ws_col))
-                        pgrp = get_pid(vc->vc_tty->pgrp);
-                spin_unlock_irq(&vc->vc_tty->ctrl_lock);
-                if (pgrp) {
-                        kill_pgrp(vc->vc_tty->pgrp, SIGWINCH, 1);
-                        put_pid(pgrp);
-                }
-                *cws = ws;
+                tty_do_resize(tty, real_tty, &ws);
         }
 
         if (CON_IS_VISIBLE(vc))
@@ -932,14 +941,47 @@ int vc_resize(struct vc_data *vc, unsigned int cols, unsigned int lines)
         return err;
 }
 
-int vc_lock_resize(struct vc_data *vc, unsigned int cols, unsigned int lines)
+/**
+ *      vc_resize               -       resize a VT
+ *      @vc: virtual console
+ *      @cols: columns
+ *      @rows: rows
+ *
+ *      Resize a virtual console as seen from the console end of things. We
+ *      use the common vc_do_resize methods to update the structures. The
+ *      caller must hold the console sem to protect console internals and
+ *      vc->vc_tty
+ */
+
+int vc_resize(struct vc_data *vc, unsigned int cols, unsigned int rows)
+{
+        return vc_do_resize(vc->vc_tty, vc->vc_tty, vc, cols, rows);
+}
+
+/**
+ *      vt_resize               -       resize a VT
+ *      @tty: tty to resize
+ *      @real_tty: tty if a pty/tty pair
+ *      @ws: winsize attributes
+ *
+ *      Resize a virtual terminal. This is called by the tty layer as we
+ *      register our own handler for resizing. The mutual helper does all
+ *      the actual work.
+ *
+ *      Takes the console sem and the called methods then take the tty
+ *      termios_mutex and the tty ctrl_lock in that order.
+ */
+
+int vt_resize(struct tty_struct *tty, struct tty_struct *real_tty,
+        struct winsize *ws)
 {
-        int rc;
+        struct vc_data *vc = tty->driver_data;
+        int ret;
 
         acquire_console_sem();
-        rc = vc_resize(vc, cols, lines);
+        ret = vc_do_resize(tty, real_tty, vc, ws->ws_col, ws->ws_row);
         release_console_sem();
-        return rc;
+        return ret;
 }
 
 void vc_deallocate(unsigned int currcons)
@@ -2907,6 +2949,7 @@ static const struct tty_operations con_ops = {
         .start = con_start,
         .throttle = con_throttle,
         .unthrottle = con_unthrottle,
+        .resize = vt_resize,
 };
 
 int __init vty_init(void)
@@ -4061,7 +4104,6 @@ EXPORT_SYMBOL(default_blu);
 EXPORT_SYMBOL(update_region);
 EXPORT_SYMBOL(redraw_screen);
 EXPORT_SYMBOL(vc_resize);
-EXPORT_SYMBOL(vc_lock_resize);
 EXPORT_SYMBOL(fg_console);
 EXPORT_SYMBOL(console_blank_hook);
 EXPORT_SYMBOL(console_blanked);
diff --git a/drivers/char/vt_ioctl.c b/drivers/char/vt_ioctl.c
index 3211afd9d57e..c904e9ad4a71 100644
--- a/drivers/char/vt_ioctl.c
+++ b/drivers/char/vt_ioctl.c
@@ -947,14 +947,16 @@ int vt_ioctl(struct tty_struct *tty, struct file * file,
                     get_user(cc, &vtsizes->v_cols))
                         ret = -EFAULT;
                 else {
+                        acquire_console_sem();
                         for (i = 0; i < MAX_NR_CONSOLES; i++) {
                                 vc = vc_cons[i].d;
 
                                 if (vc) {
                                         vc->vc_resize_user = 1;
-                                        vc_lock_resize(vc_cons[i].d, cc, ll);
+                                        vc_resize(vc_cons[i].d, cc, ll);
                                 }
                         }
+                        release_console_sem();
                 }
                 break;
         }
diff --git a/drivers/hid/usbhid/hid-quirks.c b/drivers/hid/usbhid/hid-quirks.c
index 61e78a4369b9..b15f88249639 100644
--- a/drivers/hid/usbhid/hid-quirks.c
+++ b/drivers/hid/usbhid/hid-quirks.c
@@ -654,12 +654,12 @@ static const struct hid_blacklist {
         { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN },
         { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_APPLE_ISO_KEYBOARD },
         { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_JIS, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ANSI, HID_QUIRK_APPLE_HAS_FN },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ISO, HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_APPLE_ISO_KEYBOARD },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_JIS, HID_QUIRK_APPLE_HAS_FN },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI, HID_QUIRK_APPLE_HAS_FN },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ISO, HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_APPLE_ISO_KEYBOARD },
-        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_JIS, HID_QUIRK_APPLE_HAS_FN },
+        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ANSI, HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
+        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ISO, HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_APPLE_ISO_KEYBOARD | HID_QUIRK_IGNORE_MOUSE},
+        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_JIS, HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE},
+        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI, HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE},
+        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ISO, HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_APPLE_ISO_KEYBOARD | HID_QUIRK_IGNORE_MOUSE },
+        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_JIS, HID_QUIRK_APPLE_HAS_FN  | HID_QUIRK_IGNORE_MOUSE },
         { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
         { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY, HID_QUIRK_APPLE_NUMLOCK_EMULATION | HID_QUIRK_APPLE_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
 
diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
index bf4ebfb86fa5..d402e8d813ce 100644
--- a/drivers/hwmon/Kconfig
+++ b/drivers/hwmon/Kconfig
@@ -77,6 +77,22 @@ config SENSORS_AD7418
           This driver can also be built as a module. If so, the module
           will be called ad7418.
 
+config SENSORS_ADCXX
+        tristate "National Semiconductor ADCxxxSxxx"
+        depends on SPI_MASTER && EXPERIMENTAL
+        help
+          If you say yes here you get support for the National Semiconductor
+          ADC<bb><c>S<sss> chip family, where
+          * bb  is the resolution in number of bits (8, 10, 12)
+          * c   is the number of channels (1, 2, 4, 8)
+          * sss is the maximum conversion speed (021 for 200 kSPS, 051 for 500
+            kSPS and 101 for 1 MSPS)
+
+          Examples : ADC081S101, ADC124S501, ...
+
+          This driver can also be built as a module.  If so, the module
+          will be called adcxx.
+
 config SENSORS_ADM1021
         tristate "Analog Devices ADM1021 and compatibles"
         depends on I2C
diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
index 7943e5cefb06..950134ab8426 100644
--- a/drivers/hwmon/Makefile
+++ b/drivers/hwmon/Makefile
@@ -17,6 +17,7 @@ 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_ADCXX)     += adcxx.o
 obj-$(CONFIG_SENSORS_ADM1021)   += adm1021.o
 obj-$(CONFIG_SENSORS_ADM1025)   += adm1025.o
 obj-$(CONFIG_SENSORS_ADM1026)   += adm1026.o
diff --git a/drivers/hwmon/abituguru3.c b/drivers/hwmon/abituguru3.c
index f00f497b9ca9..d568c65c1370 100644
--- a/drivers/hwmon/abituguru3.c
+++ b/drivers/hwmon/abituguru3.c
@@ -1,5 +1,8 @@
 /*
-    abituguru3.c Copyright (c) 2006 Hans de Goede <j.w.r.degoede@hhs.nl>
+    abituguru3.c
+
+    Copyright (c) 2006-2008 Hans de Goede <j.w.r.degoede@hhs.nl>
+    Copyright (c) 2008 Alistair John Strachan <alistair@devzero.co.uk>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -116,7 +119,7 @@ struct abituguru3_sensor_info {
 
 struct abituguru3_motherboard_info {
         u16 id;
-        const char *name;
+        const char *dmi_name;
         /* + 1 -> end of sensors indicated by a sensor with name == NULL */
         struct abituguru3_sensor_info sensors[ABIT_UGURU3_MAX_NO_SENSORS + 1];
 };
@@ -161,7 +164,7 @@ struct abituguru3_data {
 
 /* Constants */
 static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
-        { 0x000C, "unknown", {
+        { 0x000C, NULL /* Unknown, need DMI string */, {
                 { "CPU Core",            0, 0, 10, 1, 0 },
                 { "DDR",                 1, 0, 10, 1, 0 },
                 { "DDR VTT",             2, 0, 10, 1, 0 },
@@ -183,7 +186,7 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "AUX1 Fan",           35, 2, 60, 1, 0 },
                 { NULL, 0, 0, 0, 0, 0 } }
         },
-        { 0x000D, "Abit AW8", {
+        { 0x000D, NULL /* Abit AW8, need DMI string */, {
                 { "CPU Core",            0, 0, 10, 1, 0 },
                 { "DDR",                 1, 0, 10, 1, 0 },
                 { "DDR VTT",             2, 0, 10, 1, 0 },
@@ -212,7 +215,7 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "AUX5 Fan",           39, 2, 60, 1, 0 },
                 { NULL, 0, 0, 0, 0, 0 } }
         },
-        { 0x000E, "AL-8", {
+        { 0x000E, NULL /* AL-8, need DMI string */, {
                 { "CPU Core",            0, 0, 10, 1, 0 },
                 { "DDR",                 1, 0, 10, 1, 0 },
                 { "DDR VTT",             2, 0, 10, 1, 0 },
@@ -233,7 +236,7 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "SYS Fan",            34, 2, 60, 1, 0 },
                 { NULL, 0, 0, 0, 0, 0 } }
         },
-        { 0x000F, "unknown", {
+        { 0x000F, NULL /* Unknown, need DMI string */, {
                 { "CPU Core",            0, 0, 10, 1, 0 },
                 { "DDR",                 1, 0, 10, 1, 0 },
                 { "DDR VTT",             2, 0, 10, 1, 0 },
@@ -254,7 +257,7 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "SYS Fan",            34, 2, 60, 1, 0 },
                 { NULL, 0, 0, 0, 0, 0 } }
         },
-        { 0x0010, "Abit NI8 SLI GR", {
+        { 0x0010, NULL /* Abit NI8 SLI GR, need DMI string */, {
                 { "CPU Core",            0, 0, 10, 1, 0 },
                 { "DDR",                 1, 0, 10, 1, 0 },
                 { "DDR VTT",             2, 0, 10, 1, 0 },
@@ -276,7 +279,7 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "OTES1 Fan",          36, 2, 60, 1, 0 },
                 { NULL, 0, 0, 0, 0, 0 } }
         },
-        { 0x0011, "Abit AT8 32X", {
+        { 0x0011, NULL /* Abit AT8 32X, need DMI string */, {
                 { "CPU Core",            0, 0, 10, 1, 0 },
                 { "DDR",                 1, 0, 20, 1, 0 },
                 { "DDR VTT",             2, 0, 10, 1, 0 },
@@ -302,7 +305,7 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "AUX2 Fan",           36, 2, 60, 1, 0 },
                 { NULL, 0, 0, 0, 0, 0 } }
         },
-        { 0x0012, "Abit AN8 32X", {
+        { 0x0012, NULL /* Abit AN8 32X, need DMI string */, {
                 { "CPU Core",            0, 0, 10, 1, 0 },
                 { "DDR",                 1, 0, 20, 1, 0 },
                 { "DDR VTT",             2, 0, 10, 1, 0 },
@@ -324,7 +327,7 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "AUX1 Fan",           36, 2, 60, 1, 0 },
                 { NULL, 0, 0, 0, 0, 0 } }
         },
-        { 0x0013, "Abit AW8D", {
+        { 0x0013, NULL /* Abit AW8D, need DMI string */, {
                 { "CPU Core",            0, 0, 10, 1, 0 },
                 { "DDR",                 1, 0, 10, 1, 0 },
                 { "DDR VTT",             2, 0, 10, 1, 0 },
@@ -353,7 +356,7 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "AUX5 Fan",           39, 2, 60, 1, 0 },
                 { NULL, 0, 0, 0, 0, 0 } }
         },
-        { 0x0014, "Abit AB9 Pro", {
+        { 0x0014, NULL /* Abit AB9 Pro, need DMI string */, {
                 { "CPU Core",            0, 0, 10, 1, 0 },
                 { "DDR",                 1, 0, 10, 1, 0 },
                 { "DDR VTT",             2, 0, 10, 1, 0 },
@@ -374,7 +377,7 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "SYS Fan",            34, 2, 60, 1, 0 },
                 { NULL, 0, 0, 0, 0, 0 } }
         },
-        { 0x0015, "unknown", {
+        { 0x0015, NULL /* Unknown, need DMI string */, {
                 { "CPU Core",            0, 0, 10, 1, 0 },
                 { "DDR",                 1, 0, 20, 1, 0 },
                 { "DDR VTT",             2, 0, 10, 1, 0 },
@@ -398,7 +401,7 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "AUX3 Fan",           36, 2, 60, 1, 0 },
                 { NULL, 0, 0, 0, 0, 0 } }
         },
-        { 0x0016, "AW9D-MAX", {
+        { 0x0016, NULL /* AW9D-MAX, need DMI string */, {
                 { "CPU Core",            0, 0, 10, 1, 0 },
                 { "DDR2",                1, 0, 20, 1, 0 },
                 { "DDR2 VTT",            2, 0, 10, 1, 0 },
@@ -426,7 +429,7 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "OTES1 Fan",          38, 2, 60, 1, 0 },
                 { NULL, 0, 0, 0, 0, 0 } }
         },
-        { 0x0017, "unknown", {
+        { 0x0017, NULL /* Unknown, need DMI string */, {
                 { "CPU Core",            0, 0, 10, 1, 0 },
                 { "DDR2",                1, 0, 20, 1, 0 },
                 { "DDR2 VTT",            2, 0, 10, 1, 0 },
@@ -451,7 +454,7 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "AUX3 FAN",           37, 2, 60, 1, 0 },
                 { NULL, 0, 0, 0, 0, 0 } }
         },
-        { 0x0018, "unknown", {
+        { 0x0018, NULL /* Unknown, need DMI string */, {
                 { "CPU Core",            0, 0, 10, 1, 0 },
                 { "DDR2",                1, 0, 20, 1, 0 },
                 { "DDR2 VTT",            2, 0, 10, 1, 0 },
@@ -478,7 +481,7 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "AUX3 Fan",           36, 2, 60, 1, 0 },
                 { NULL, 0, 0, 0, 0, 0 } }
         },
-        { 0x0019, "unknown", {
+        { 0x0019, NULL /* Unknown, need DMI string */, {
                 { "CPU Core",            7, 0, 10, 1, 0 },
                 { "DDR2",               13, 0, 20, 1, 0 },
                 { "DDR2 VTT",           14, 0, 10, 1, 0 },
@@ -505,7 +508,7 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "AUX3 FAN",           36, 2, 60, 1, 0 },
                 { NULL, 0, 0, 0, 0, 0 } }
         },
-        { 0x001A, "Abit IP35 Pro", {
+        { 0x001A, "IP35 Pro(Intel P35-ICH9R)", {
                 { "CPU Core",            0, 0, 10, 1, 0 },
                 { "DDR2",                1, 0, 20, 1, 0 },
                 { "DDR2 VTT",            2, 0, 10, 1, 0 },
@@ -533,7 +536,7 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "AUX4 Fan",           37, 2, 60, 1, 0 },
                 { NULL, 0, 0, 0, 0, 0 } }
         },
-        { 0x001B, "unknown", {
+        { 0x001B, NULL /* Unknown, need DMI string */, {
                 { "CPU Core",            0, 0, 10, 1, 0 },
                 { "DDR3",                1, 0, 20, 1, 0 },
                 { "DDR3 VTT",            2, 0, 10, 1, 0 },
@@ -560,7 +563,7 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "AUX3 Fan",           36, 2, 60, 1, 0 },
                 { NULL, 0, 0, 0, 0, 0 } }
         },
-        { 0x001C, "unknown", {
+        { 0x001C, NULL /* Unknown, need DMI string */, {
                 { "CPU Core",            0, 0, 10, 1, 0 },
                 { "DDR2",                1, 0, 20, 1, 0 },
                 { "DDR2 VTT",            2, 0, 10, 1, 0 },
@@ -935,9 +938,18 @@ static int __devinit abituguru3_probe(struct platform_device *pdev)
                 goto abituguru3_probe_error;
         }
         data->sensors = abituguru3_motherboards[i].sensors;
+
         printk(KERN_INFO ABIT_UGURU3_NAME ": found Abit uGuru3, motherboard "
-                "ID: %04X (%s)\n", (unsigned int)id,
-                abituguru3_motherboards[i].name);
+                "ID: %04X\n", (unsigned int)id);
+
+#ifdef CONFIG_DMI
+        if (!abituguru3_motherboards[i].dmi_name) {
+                printk(KERN_WARNING ABIT_UGURU3_NAME ": this motherboard was "
+                        "not detected using DMI. Please send the output of "
+                        "\"dmidecode\" to the abituguru3 maintainer"
+                        "(see MAINTAINERS)\n");
+        }
+#endif
 
         /* Fill the sysfs attr array */
         sysfs_attr_i = 0;
@@ -1109,6 +1121,46 @@ static struct platform_driver abituguru3_driver = {
         .resume = abituguru3_resume
 };
 
+#ifdef CONFIG_DMI
+
+static int __init abituguru3_dmi_detect(void)
+{
+        const char *board_vendor, *board_name;
+        int i, err = (force) ? 1 : -ENODEV;
+
+        board_vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
+        if (!board_vendor || strcmp(board_vendor, "http://www.abit.com.tw/"))
+                return err;
+
+        board_name = dmi_get_system_info(DMI_BOARD_NAME);
+        if (!board_name)
+                return err;
+
+        for (i = 0; abituguru3_motherboards[i].id; i++) {
+                const char *dmi_name = abituguru3_motherboards[i].dmi_name;
+                if (dmi_name && !strcmp(dmi_name, board_name))
+                        break;
+        }
+
+        if (!abituguru3_motherboards[i].id)
+                return 1;
+
+        return 0;
+}
+
+#else /* !CONFIG_DMI */
+
+static inline int abituguru3_dmi_detect(void)
+{
+        return -ENODEV;
+}
+
+#endif /* CONFIG_DMI */
+
+/* FIXME: Manual detection should die eventually; we need to collect stable
+ *        DMI model names first before we can rely entirely on CONFIG_DMI.
+ */
+
 static int __init abituguru3_detect(void)
 {
         /* See if there is an uguru3 there. An idle uGuru3 will hold 0x00 or
@@ -1119,7 +1171,7 @@ static int __init abituguru3_detect(void)
         if (((data_val == 0x00) || (data_val == 0x08)) &&
                         ((cmd_val == 0xAC) || (cmd_val == 0x05) ||
                          (cmd_val == 0x55)))
-                return ABIT_UGURU3_BASE;
+                return 0;
 
         ABIT_UGURU3_DEBUG("no Abit uGuru3 found, data = 0x%02X, cmd = "
                 "0x%02X\n", (unsigned int)data_val, (unsigned int)cmd_val);
@@ -1127,7 +1179,7 @@ static int __init abituguru3_detect(void)
         if (force) {
                 printk(KERN_INFO ABIT_UGURU3_NAME ": Assuming Abit uGuru3 is "
                                 "present because of \"force\" parameter\n");
-                return ABIT_UGURU3_BASE;
+                return 0;
         }
 
         /* No uGuru3 found */
@@ -1138,27 +1190,29 @@ static struct platform_device *abituguru3_pdev;
 
 static int __init abituguru3_init(void)
 {
-        int address, err;
         struct resource res = { .flags = IORESOURCE_IO };
-
-#ifdef CONFIG_DMI
-        const char *board_vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
-
-        /* safety check, refuse to load on non Abit motherboards */
-        if (!force && (!board_vendor ||
-                        strcmp(board_vendor, "http://www.abit.com.tw/")))
-                return -ENODEV;
-#endif
-
-        address = abituguru3_detect();
-        if (address < 0)
-                return address;
+        int err;
+
+        /* Attempt DMI detection first */
+        err = abituguru3_dmi_detect();
+        if (err < 0)
+                return err;
+
+        /* Fall back to manual detection if there was no exact
+         * board name match, or force was specified.
+         */
+        if (err > 0) {
+                err = abituguru3_detect();
+                if (err)
+                        return err;
+        }
 
         err = platform_driver_register(&abituguru3_driver);
         if (err)
                 goto exit;
 
-        abituguru3_pdev = platform_device_alloc(ABIT_UGURU3_NAME, address);
+        abituguru3_pdev = platform_device_alloc(ABIT_UGURU3_NAME,
+                                                ABIT_UGURU3_BASE);
         if (!abituguru3_pdev) {
                 printk(KERN_ERR ABIT_UGURU3_NAME
                         ": Device allocation failed\n");
@@ -1166,8 +1220,8 @@ static int __init abituguru3_init(void)
                 goto exit_driver_unregister;
         }
 
-        res.start = address;
-        res.end = address + ABIT_UGURU3_REGION_LENGTH - 1;
+        res.start = ABIT_UGURU3_BASE;
+        res.end = ABIT_UGURU3_BASE + ABIT_UGURU3_REGION_LENGTH - 1;
         res.name = ABIT_UGURU3_NAME;
 
         err = platform_device_add_resources(abituguru3_pdev, &res, 1);
diff --git a/drivers/hwmon/adcxx.c b/drivers/hwmon/adcxx.c
new file mode 100644
index 000000000000..242294db3db6
--- /dev/null
+++ b/drivers/hwmon/adcxx.c
@@ -0,0 +1,329 @@
+/*
+ * adcxx.c
+ *
+ * The adcxx4s is an AD converter family from National Semiconductor (NS).
+ *
+ * Copyright (c) 2008 Marc Pignat <marc.pignat@hevs.ch>
+ *
+ * The adcxx4s communicates with a host processor via an SPI/Microwire Bus
+ * interface. This driver supports the whole family of devices with name
+ * ADC<bb><c>S<sss>, where
+ * * bb is the resolution in number of bits (8, 10, 12)
+ * * c is the number of channels (1, 2, 4, 8)
+ * * sss is the maximum conversion speed (021 for 200 kSPS, 051 for 500 kSPS
+ *   and 101 for 1 MSPS)
+ *
+ * Complete datasheets are available at National's website here:
+ * http://www.national.com/ds/DC/ADC<bb><c>S<sss>.pdf
+ *
+ * Handling of 8, 10 and 12 bits converters are the same, the
+ * unavailable bits are 0 :)
+ *
+ * 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/init.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/device.h>
+#include <linux/err.h>
+#include <linux/sysfs.h>
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
+#include <linux/mutex.h>
+#include <linux/spi/spi.h>
+
+#define DRVNAME         "adcxx"
+
+struct adcxx {
+        struct device *hwmon_dev;
+        struct mutex lock;
+        u32 channels;
+        u32 reference; /* in millivolts */
+};
+
+/* sysfs hook function */
+static ssize_t adcxx_read(struct device *dev,
+                struct device_attribute *devattr, char *buf)
+{
+        struct spi_device *spi = to_spi_device(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+        struct adcxx *adc = dev_get_drvdata(&spi->dev);
+        u8 tx_buf[2] = { attr->index << 3 }; /* other bits are don't care */
+        u8 rx_buf[2];
+        int status;
+        int value;
+
+        if (mutex_lock_interruptible(&adc->lock))
+                return -ERESTARTSYS;
+
+        status = spi_write_then_read(spi, tx_buf, sizeof(tx_buf),
+                                        rx_buf, sizeof(rx_buf));
+        if (status < 0) {
+                dev_warn(dev, "spi_write_then_read failed with status %d\n",
+                                status);
+                goto out;
+        }
+
+        value = (rx_buf[0] << 8) + rx_buf[1];
+        dev_dbg(dev, "raw value = 0x%x\n", value);
+
+        value = value * adc->reference >> 12;
+        status = sprintf(buf, "%d\n", value);
+out:
+        mutex_unlock(&adc->lock);
+        return status;
+}
+
+static ssize_t adcxx_show_min(struct device *dev,
+                struct device_attribute *devattr, char *buf)
+{
+        /* The minimum reference is 0 for this chip family */
+        return sprintf(buf, "0\n");
+}
+
+static ssize_t adcxx_show_max(struct device *dev,
+                struct device_attribute *devattr, char *buf)
+{
+        struct spi_device *spi = to_spi_device(dev);
+        struct adcxx *adc = dev_get_drvdata(&spi->dev);
+        u32 reference;
+
+        if (mutex_lock_interruptible(&adc->lock))
+                return -ERESTARTSYS;
+
+        reference = adc->reference;
+
+        mutex_unlock(&adc->lock);
+
+        return sprintf(buf, "%d\n", reference);
+}
+
+static ssize_t adcxx_set_max(struct device *dev,
+        struct device_attribute *devattr, const char *buf, size_t count)
+{
+        struct spi_device *spi = to_spi_device(dev);
+        struct adcxx *adc = dev_get_drvdata(&spi->dev);
+        unsigned long value;
+
+        if (strict_strtoul(buf, 10, &value))
+                return -EINVAL;
+
+        if (mutex_lock_interruptible(&adc->lock))
+                return -ERESTARTSYS;
+
+        adc->reference = value;
+
+        mutex_unlock(&adc->lock);
+
+        return count;
+}
+
+static ssize_t adcxx_show_name(struct device *dev, struct device_attribute
+                              *devattr, char *buf)
+{
+        struct spi_device *spi = to_spi_device(dev);
+        struct adcxx *adc = dev_get_drvdata(&spi->dev);
+
+        return sprintf(buf, "adcxx%ds\n", adc->channels);
+}
+
+static struct sensor_device_attribute ad_input[] = {
+        SENSOR_ATTR(name, S_IRUGO, adcxx_show_name, NULL, 0),
+        SENSOR_ATTR(in_min, S_IRUGO, adcxx_show_min, NULL, 0),
+        SENSOR_ATTR(in_max, S_IWUSR | S_IRUGO, adcxx_show_max,
+                                        adcxx_set_max, 0),
+        SENSOR_ATTR(in0_input, S_IRUGO, adcxx_read, NULL, 0),
+        SENSOR_ATTR(in1_input, S_IRUGO, adcxx_read, NULL, 1),
+        SENSOR_ATTR(in2_input, S_IRUGO, adcxx_read, NULL, 2),
+        SENSOR_ATTR(in3_input, S_IRUGO, adcxx_read, NULL, 3),
+        SENSOR_ATTR(in4_input, S_IRUGO, adcxx_read, NULL, 4),
+        SENSOR_ATTR(in5_input, S_IRUGO, adcxx_read, NULL, 5),
+        SENSOR_ATTR(in6_input, S_IRUGO, adcxx_read, NULL, 6),
+        SENSOR_ATTR(in7_input, S_IRUGO, adcxx_read, NULL, 7),
+};
+
+/*----------------------------------------------------------------------*/
+
+static int __devinit adcxx_probe(struct spi_device *spi, int channels)
+{
+        struct adcxx *adc;
+        int status;
+        int i;
+
+        adc = kzalloc(sizeof *adc, GFP_KERNEL);
+        if (!adc)
+                return -ENOMEM;
+
+        /* set a default value for the reference */
+        adc->reference = 3300;
+        adc->channels = channels;
+        mutex_init(&adc->lock);
+
+        mutex_lock(&adc->lock);
+
+        dev_set_drvdata(&spi->dev, adc);
+
+        for (i = 0; i < 3 + adc->channels; i++) {
+                status = device_create_file(&spi->dev, &ad_input[i].dev_attr);
+                if (status) {
+                        dev_err(&spi->dev, "device_create_file failed.\n");
+                        goto out_err;
+                }
+        }
+
+        adc->hwmon_dev = hwmon_device_register(&spi->dev);
+        if (IS_ERR(adc->hwmon_dev)) {
+                dev_err(&spi->dev, "hwmon_device_register failed.\n");
+                status = PTR_ERR(adc->hwmon_dev);
+                goto out_err;
+        }
+
+        mutex_unlock(&adc->lock);
+        return 0;
+
+out_err:
+        for (i--; i >= 0; i--)
+                device_remove_file(&spi->dev, &ad_input[i].dev_attr);
+
+        dev_set_drvdata(&spi->dev, NULL);
+        mutex_unlock(&adc->lock);
+        kfree(adc);
+        return status;
+}
+
+static int __devinit adcxx1s_probe(struct spi_device *spi)
+{
+        return adcxx_probe(spi, 1);
+}
+
+static int __devinit adcxx2s_probe(struct spi_device *spi)
+{
+        return adcxx_probe(spi, 2);
+}
+
+static int __devinit adcxx4s_probe(struct spi_device *spi)
+{
+        return adcxx_probe(spi, 4);
+}
+
+static int __devinit adcxx8s_probe(struct spi_device *spi)
+{
+        return adcxx_probe(spi, 8);
+}
+
+static int __devexit adcxx_remove(struct spi_device *spi)
+{
+        struct adcxx *adc = dev_get_drvdata(&spi->dev);
+        int i;
+
+        mutex_lock(&adc->lock);
+        hwmon_device_unregister(adc->hwmon_dev);
+        for (i = 0; i < 3 + adc->channels; i++)
+                device_remove_file(&spi->dev, &ad_input[i].dev_attr);
+
+        dev_set_drvdata(&spi->dev, NULL);
+        mutex_unlock(&adc->lock);
+        kfree(adc);
+
+        return 0;
+}
+
+static struct spi_driver adcxx1s_driver = {
+        .driver = {
+                .name   = "adcxx1s",
+                .owner  = THIS_MODULE,
+        },
+        .probe  = adcxx1s_probe,
+        .remove = __devexit_p(adcxx_remove),
+};
+
+static struct spi_driver adcxx2s_driver = {
+        .driver = {
+                .name   = "adcxx2s",
+                .owner  = THIS_MODULE,
+        },
+        .probe  = adcxx2s_probe,
+        .remove = __devexit_p(adcxx_remove),
+};
+
+static struct spi_driver adcxx4s_driver = {
+        .driver = {
+                .name   = "adcxx4s",
+                .owner  = THIS_MODULE,
+        },
+        .probe  = adcxx4s_probe,
+        .remove = __devexit_p(adcxx_remove),
+};
+
+static struct spi_driver adcxx8s_driver = {
+        .driver = {
+                .name   = "adcxx8s",
+                .owner  = THIS_MODULE,
+        },
+        .probe  = adcxx8s_probe,
+        .remove = __devexit_p(adcxx_remove),
+};
+
+static int __init init_adcxx(void)
+{
+        int status;
+        status = spi_register_driver(&adcxx1s_driver);
+        if (status)
+                goto reg_1_failed;
+
+        status = spi_register_driver(&adcxx2s_driver);
+        if (status)
+                goto reg_2_failed;
+
+        status = spi_register_driver(&adcxx4s_driver);
+        if (status)
+                goto reg_4_failed;
+
+        status = spi_register_driver(&adcxx8s_driver);
+        if (status)
+                goto reg_8_failed;
+
+        return status;
+
+reg_8_failed:
+        spi_unregister_driver(&adcxx4s_driver);
+reg_4_failed:
+        spi_unregister_driver(&adcxx2s_driver);
+reg_2_failed:
+        spi_unregister_driver(&adcxx1s_driver);
+reg_1_failed:
+        return status;
+}
+
+static void __exit exit_adcxx(void)
+{
+        spi_unregister_driver(&adcxx1s_driver);
+        spi_unregister_driver(&adcxx2s_driver);
+        spi_unregister_driver(&adcxx4s_driver);
+        spi_unregister_driver(&adcxx8s_driver);
+}
+
+module_init(init_adcxx);
+module_exit(exit_adcxx);
+
+MODULE_AUTHOR("Marc Pignat");
+MODULE_DESCRIPTION("National Semiconductor adcxx8sxxx Linux driver");
+MODULE_LICENSE("GPL");
+
+MODULE_ALIAS("adcxx1s");
+MODULE_ALIAS("adcxx2s");
+MODULE_ALIAS("adcxx4s");
+MODULE_ALIAS("adcxx8s");
diff --git a/drivers/hwmon/applesmc.c b/drivers/hwmon/applesmc.c
index aacc0c4b809c..b06b8e090a27 100644
--- a/drivers/hwmon/applesmc.c
+++ b/drivers/hwmon/applesmc.c
@@ -98,6 +98,12 @@ static const char* temperature_sensors_sets[][36] = {
           "TH1P", "TH2P", "TH3P", "TMAP", "TMAS", "TMBS", "TM0P", "TM0S",
           "TM1P", "TM1S", "TM2P", "TM2S", "TM3S", "TM8P", "TM8S", "TM9P",
           "TM9S", "TN0H", "TS0C", NULL },
+/* Set 5: iMac */
+        { "TC0D", "TA0P", "TG0P", "TG0D", "TG0H", "TH0P", "Tm0P", "TO0P",
+          "Tp0C", NULL },
+/* Set 6: Macbook3 set */
+        { "TB0T", "TC0D", "TC0P", "TM0P", "TN0P", "TTF0", "TW0P", "Th0H",
+          "Th0S", "Th1H", NULL },
 };
 
 /* List of keys used to read/write fan speeds */
@@ -1223,6 +1229,10 @@ static __initdata struct dmi_match_data applesmc_dmi_data[] = {
         { .accelerometer = 0, .light = 0, .temperature_set = 3 },
 /* MacPro: temperature set 4 */
         { .accelerometer = 0, .light = 0, .temperature_set = 4 },
+/* iMac: temperature set 5 */
+        { .accelerometer = 0, .light = 0, .temperature_set = 5 },
+/* MacBook3: accelerometer and temperature set 6 */
+        { .accelerometer = 1, .light = 0, .temperature_set = 6 },
 };
 
 /* Note that DMI_MATCH(...,"MacBook") will match "MacBookPro1,1".
@@ -1232,10 +1242,14 @@ static __initdata struct dmi_system_id applesmc_whitelist[] = {
           DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
           DMI_MATCH(DMI_PRODUCT_NAME,"MacBookPro") },
                 (void*)&applesmc_dmi_data[0]},
-        { applesmc_dmi_match, "Apple MacBook", {
+        { applesmc_dmi_match, "Apple MacBook (v2)", {
           DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
           DMI_MATCH(DMI_PRODUCT_NAME,"MacBook2") },
                 (void*)&applesmc_dmi_data[1]},
+        { applesmc_dmi_match, "Apple MacBook (v3)", {
+          DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
+          DMI_MATCH(DMI_PRODUCT_NAME,"MacBook3") },
+                (void*)&applesmc_dmi_data[6]},
         { applesmc_dmi_match, "Apple MacBook", {
           DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
           DMI_MATCH(DMI_PRODUCT_NAME,"MacBook") },
@@ -1248,6 +1262,10 @@ static __initdata struct dmi_system_id applesmc_whitelist[] = {
           DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
           DMI_MATCH(DMI_PRODUCT_NAME,"MacPro2") },
                 (void*)&applesmc_dmi_data[4]},
+        { applesmc_dmi_match, "Apple iMac", {
+          DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
+          DMI_MATCH(DMI_PRODUCT_NAME,"iMac") },
+                (void*)&applesmc_dmi_data[5]},
         { .ident = NULL }
 };
 
diff --git a/drivers/hwmon/coretemp.c b/drivers/hwmon/coretemp.c
index 70239acecc8e..93c17223b527 100644
--- a/drivers/hwmon/coretemp.c
+++ b/drivers/hwmon/coretemp.c
@@ -413,10 +413,11 @@ static int __init coretemp_init(void)
         for_each_online_cpu(i) {
                 struct cpuinfo_x86 *c = &cpu_data(i);
 
-                /* check if family 6, models 0xe, 0xf, 0x16, 0x17 */
+                /* check if family 6, models 0xe, 0xf, 0x16, 0x17, 0x1A */
                 if ((c->cpuid_level < 0) || (c->x86 != 0x6) ||
                     !((c->x86_model == 0xe) || (c->x86_model == 0xf) ||
-                        (c->x86_model == 0x16) || (c->x86_model == 0x17))) {
+                        (c->x86_model == 0x16) || (c->x86_model == 0x17) ||
+                        (c->x86_model == 0x1A))) {
 
                         /* supported CPU not found, but report the unknown
                            family 6 CPU */
diff --git a/drivers/hwmon/hwmon-vid.c b/drivers/hwmon/hwmon-vid.c
index 7b0a32c4dcfb..c54eff92be4a 100644
--- a/drivers/hwmon/hwmon-vid.c
+++ b/drivers/hwmon/hwmon-vid.c
@@ -37,13 +37,21 @@
  * 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,
+ * AMD Athlon 64 and AMD Opteron Processors, AMD Publication 26094,
+ * http://www.amd.com/us-en/assets/content_type/white_papers_and_tech_docs/26094.PDF
+ * Table 74. VID Code Voltages
+ * This corresponds to an arbitrary VRM code of 24 in the functions below.
+ * These CPU models (K8 revision <= E) have 5 VID pins. See also:
+ * Revision Guide for AMD Athlon 64 and AMD Opteron Processors, AMD Publication 25759,
+ * http://www.amd.com/us-en/assets/content_type/white_papers_and_tech_docs/25759.pdf
+ *
+ * AMD NPT Family 0Fh Processors, 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.
+ * This corresponds to an arbitrary VRM code of 25 in the functions below.
+ * These CPU models (K8 revision >= F) have 6 VID pins. See also:
+ * Revision Guide for AMD NPT Family 0Fh Processors, AMD Publication 33610,
+ * http://www.amd.com/us-en/assets/content_type/white_papers_and_tech_docs/33610.pdf
  *
  * The 17 specification is in fact Intel Mobile Voltage Positioning -
  * (IMVP-II). You can find more information in the datasheet of Max1718
@@ -95,7 +103,12 @@ int vid_from_reg(int val, u8 vrm)
                         return 0;
                 return((1600000 - (val - 2) * 6250 + 500) / 1000);
 
-        case 24:                /* AMD NPT 0Fh (Athlon64 & Opteron) */
+        case 24:                /* Athlon64 & Opteron */
+                val &= 0x1f;
+                if (val == 0x1f)
+                        return 0;
+                                /* fall through */
+        case 25:                /* AMD NPT 0Fh */
                 val &= 0x3f;
                 return (val < 32) ? 1550 - 25 * val
                         : 775 - (25 * (val - 31)) / 2;
@@ -157,11 +170,16 @@ struct vrm_model {
 
 #ifdef CONFIG_X86
 
-/* the stepping parameter is highest acceptable stepping for current line */
+/*
+ * The stepping parameter is highest acceptable stepping for current line.
+ * The model match must be exact for 4-bit values. For model values 0x10
+ * and above (extended model), all models below the parameter will match.
+ */
 
 static struct vrm_model vrm_models[] = {
         {X86_VENDOR_AMD, 0x6, ANY, ANY, 90},            /* Athlon Duron etc */
-        {X86_VENDOR_AMD, 0xF, ANY, ANY, 24},            /* Athlon 64, Opteron and above VRM 24 */
+        {X86_VENDOR_AMD, 0xF, 0x3F, ANY, 24},           /* Athlon 64, Opteron */
+        {X86_VENDOR_AMD, 0xF, ANY, ANY, 25},            /* NPT family 0Fh */
         {X86_VENDOR_INTEL, 0x6, 0x9, ANY, 13},          /* Pentium M (130 nm) */
         {X86_VENDOR_INTEL, 0x6, 0xB, ANY, 85},          /* Tualatin */
         {X86_VENDOR_INTEL, 0x6, 0xD, ANY, 13},          /* Pentium M (90 nm) */
@@ -189,6 +207,8 @@ static u8 find_vrm(u8 eff_family, u8 eff_model, u8 eff_stepping, u8 vendor)
                 if (vrm_models[i].vendor==vendor)
                         if ((vrm_models[i].eff_family==eff_family)
                          && ((vrm_models[i].eff_model==eff_model) ||
+                             (vrm_models[i].eff_model >= 0x10 &&
+                              eff_model <= vrm_models[i].eff_model) ||
                              (vrm_models[i].eff_model==ANY)) &&
                              (eff_stepping <= vrm_models[i].eff_stepping))
                                 return vrm_models[i].vrm_type;
diff --git a/drivers/hwmon/i5k_amb.c b/drivers/hwmon/i5k_amb.c
index f9e2ed621f7b..2ede9388096b 100644
--- a/drivers/hwmon/i5k_amb.c
+++ b/drivers/hwmon/i5k_amb.c
@@ -81,6 +81,8 @@ static unsigned long amb_reg_temp(unsigned int amb)
 #define MAX_AMBS_PER_CHANNEL            16
 #define MAX_AMBS                        (MAX_MEM_CHANNELS * \
                                          MAX_AMBS_PER_CHANNEL)
+#define CHANNEL_SHIFT                   4
+#define DIMM_MASK                       0xF
 /*
  * Ugly hack: For some reason the highest bit is set if there
  * are _any_ DIMMs in the channel.  Attempting to read from
@@ -89,7 +91,7 @@ static unsigned long amb_reg_temp(unsigned int amb)
  * might prevent us from seeing the 16th DIMM in the channel.
  */
 #define REAL_MAX_AMBS_PER_CHANNEL       15
-#define KNOBS_PER_AMB                   5
+#define KNOBS_PER_AMB                   6
 
 static unsigned long amb_num_from_reg(unsigned int byte_num, unsigned int bit)
 {
@@ -238,6 +240,16 @@ static ssize_t show_amb_temp(struct device *dev,
                 500 * amb_read_byte(data, amb_reg_temp(attr->index)));
 }
 
+static ssize_t show_label(struct device *dev,
+                          struct device_attribute *devattr,
+                          char *buf)
+{
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+
+        return sprintf(buf, "Ch. %d DIMM %d\n", attr->index >> CHANNEL_SHIFT,
+                       attr->index & DIMM_MASK);
+}
+
 static int __devinit i5k_amb_hwmon_init(struct platform_device *pdev)
 {
         int i, j, k, d = 0;
@@ -268,6 +280,20 @@ static int __devinit i5k_amb_hwmon_init(struct platform_device *pdev)
                                 continue;
                         d++;
 
+                        /* sysfs label */
+                        iattr = data->attrs + data->num_attrs;
+                        snprintf(iattr->name, AMB_SYSFS_NAME_LEN,
+                                 "temp%d_label", d);
+                        iattr->s_attr.dev_attr.attr.name = iattr->name;
+                        iattr->s_attr.dev_attr.attr.mode = S_IRUGO;
+                        iattr->s_attr.dev_attr.show = show_label;
+                        iattr->s_attr.index = k;
+                        res = device_create_file(&pdev->dev,
+                                                 &iattr->s_attr.dev_attr);
+                        if (res)
+                                goto exit_remove;
+                        data->num_attrs++;
+
                         /* Temperature sysfs knob */
                         iattr = data->attrs + data->num_attrs;
                         snprintf(iattr->name, AMB_SYSFS_NAME_LEN,
diff --git a/drivers/hwmon/ibmaem.c b/drivers/hwmon/ibmaem.c
index c9416e657487..0f70dc204105 100644
--- a/drivers/hwmon/ibmaem.c
+++ b/drivers/hwmon/ibmaem.c
@@ -1,6 +1,6 @@
 /*
- * A hwmon driver for the IBM Active Energy Manager temperature/power sensors
- * and capping functionality.
+ * A hwmon driver for the IBM System Director Active Energy Manager (AEM)
+ * temperature/power/energy sensors and capping functionality.
  * Copyright (C) 2008 IBM
  *
  * Author: Darrick J. Wong <djwong@us.ibm.com>
@@ -463,12 +463,18 @@ static int aem_read_sensor(struct aem_data *data, u8 elt, u8 reg,
 }
 
 /* Update AEM energy registers */
+static void update_aem_energy_one(struct aem_data *data, int which)
+{
+        aem_read_sensor(data, AEM_ENERGY_ELEMENT, which,
+                        &data->energy[which], 8);
+}
+
 static void update_aem_energy(struct aem_data *data)
 {
-        aem_read_sensor(data, AEM_ENERGY_ELEMENT, 0, &data->energy[0], 8);
+        update_aem_energy_one(data, 0);
         if (data->ver_major < 2)
                 return;
-        aem_read_sensor(data, AEM_ENERGY_ELEMENT, 1, &data->energy[1], 8);
+        update_aem_energy_one(data, 1);
 }
 
 /* Update all AEM1 sensors */
@@ -676,7 +682,8 @@ static int aem_find_aem2(struct aem_ipmi_data *data,
                 return -ETIMEDOUT;
 
         if (data->rx_result || data->rx_msg_len != sizeof(*fi_resp) ||
-            memcmp(&fi_resp->id, &system_x_id, sizeof(system_x_id)))
+            memcmp(&fi_resp->id, &system_x_id, sizeof(system_x_id)) ||
+            fi_resp->num_instances <= instance_num)
                 return -ENOENT;
 
         return 0;
@@ -849,7 +856,7 @@ static ssize_t aem_show_power(struct device *dev,
         struct timespec b, a;
 
         mutex_lock(&data->lock);
-        update_aem_energy(data);
+        update_aem_energy_one(data, attr->index);
         getnstimeofday(&b);
         before = data->energy[attr->index];
 
@@ -861,7 +868,7 @@ static ssize_t aem_show_power(struct device *dev,
                 return 0;
         }
 
-        update_aem_energy(data);
+        update_aem_energy_one(data, attr->index);
         getnstimeofday(&a);
         after = data->energy[attr->index];
         mutex_unlock(&data->lock);
@@ -880,7 +887,9 @@ static ssize_t aem_show_energy(struct device *dev,
 {
         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
         struct aem_data *a = dev_get_drvdata(dev);
-        a->update(a);
+        mutex_lock(&a->lock);
+        update_aem_energy_one(a, attr->index);
+        mutex_unlock(&a->lock);
 
         return sprintf(buf, "%llu\n",
                         (unsigned long long)a->energy[attr->index] * 1000);
@@ -1104,7 +1113,7 @@ static void __exit aem_exit(void)
 }
 
 MODULE_AUTHOR("Darrick J. Wong <djwong@us.ibm.com>");
-MODULE_DESCRIPTION("IBM Active Energy Manager power/temp sensor driver");
+MODULE_DESCRIPTION("IBM AEM power/temp/energy sensor driver");
 MODULE_LICENSE("GPL");
 
 module_init(aem_init);
diff --git a/drivers/hwmon/w83791d.c b/drivers/hwmon/w83791d.c
index daa7d121483b..de21142d106c 100644
--- a/drivers/hwmon/w83791d.c
+++ b/drivers/hwmon/w83791d.c
@@ -1055,9 +1055,10 @@ static int w83791d_probe(struct i2c_client *client,
 {
         struct w83791d_data *data;
         struct device *dev = &client->dev;
-        int i, val1, err;
+        int i, err;
 
 #ifdef DEBUG
+        int val1;
         val1 = w83791d_read(client, W83791D_REG_DID_VID4);
         dev_dbg(dev, "Device ID version: %d.%d (0x%02x)\n",
                         (val1 >> 5) & 0x07, (val1 >> 1) & 0x0f, val1);
diff --git a/drivers/input/evdev.c b/drivers/input/evdev.c
index 2d65411f6763..a92d81567559 100644
--- a/drivers/input/evdev.c
+++ b/drivers/input/evdev.c
@@ -647,6 +647,47 @@ static int str_to_user(const char *str, unsigned int maxlen, void __user *p)
         return copy_to_user(p, str, len) ? -EFAULT : len;
 }
 
+#define OLD_KEY_MAX     0x1ff
+static int handle_eviocgbit(struct input_dev *dev, unsigned int cmd, void __user *p, int compat_mode)
+{
+        static unsigned long keymax_warn_time;
+        unsigned long *bits;
+        int len;
+
+        switch (_IOC_NR(cmd) & EV_MAX) {
+
+        case      0: bits = dev->evbit;  len = EV_MAX;  break;
+        case EV_KEY: bits = dev->keybit; len = KEY_MAX; break;
+        case EV_REL: bits = dev->relbit; len = REL_MAX; break;
+        case EV_ABS: bits = dev->absbit; len = ABS_MAX; break;
+        case EV_MSC: bits = dev->mscbit; len = MSC_MAX; break;
+        case EV_LED: bits = dev->ledbit; len = LED_MAX; break;
+        case EV_SND: bits = dev->sndbit; len = SND_MAX; break;
+        case EV_FF:  bits = dev->ffbit;  len = FF_MAX;  break;
+        case EV_SW:  bits = dev->swbit;  len = SW_MAX;  break;
+        default: return -EINVAL;
+        }
+
+        /*
+         * Work around bugs in userspace programs that like to do
+         * EVIOCGBIT(EV_KEY, KEY_MAX) and not realize that 'len'
+         * should be in bytes, not in bits.
+         */
+        if ((_IOC_NR(cmd) & EV_MAX) == EV_KEY && _IOC_SIZE(cmd) == OLD_KEY_MAX) {
+                len = OLD_KEY_MAX;
+                if (printk_timed_ratelimit(&keymax_warn_time, 10 * 1000))
+                        printk(KERN_WARNING
+                                "evdev.c(EVIOCGBIT): Suspicious buffer size %d, "
+                                "limiting output to %d bytes. See "
+                                "http://userweb.kernel.org/~dtor/eviocgbit-bug.html\n",
+                                OLD_KEY_MAX,
+                                BITS_TO_LONGS(OLD_KEY_MAX) * sizeof(long));
+        }
+
+        return bits_to_user(bits, len, _IOC_SIZE(cmd), p, compat_mode);
+}
+#undef OLD_KEY_MAX
+
 static long evdev_do_ioctl(struct file *file, unsigned int cmd,
                            void __user *p, int compat_mode)
 {
@@ -733,26 +774,8 @@ static long evdev_do_ioctl(struct file *file, unsigned int cmd,
 
                 if (_IOC_DIR(cmd) == _IOC_READ) {
 
-                        if ((_IOC_NR(cmd) & ~EV_MAX) == _IOC_NR(EVIOCGBIT(0, 0))) {
-
-                                unsigned long *bits;
-                                int len;
-
-                                switch (_IOC_NR(cmd) & EV_MAX) {
-
-                                case      0: bits = dev->evbit;  len = EV_MAX;  break;
-                                case EV_KEY: bits = dev->keybit; len = KEY_MAX; break;
-                                case EV_REL: bits = dev->relbit; len = REL_MAX; break;
-                                case EV_ABS: bits = dev->absbit; len = ABS_MAX; break;
-                                case EV_MSC: bits = dev->mscbit; len = MSC_MAX; break;
-                                case EV_LED: bits = dev->ledbit; len = LED_MAX; break;
-                                case EV_SND: bits = dev->sndbit; len = SND_MAX; break;
-                                case EV_FF:  bits = dev->ffbit;  len = FF_MAX;  break;
-                                case EV_SW:  bits = dev->swbit;  len = SW_MAX;  break;
-                                default: return -EINVAL;
-                                }
-                                return bits_to_user(bits, len, _IOC_SIZE(cmd), p, compat_mode);
-                        }
+                        if ((_IOC_NR(cmd) & ~EV_MAX) == _IOC_NR(EVIOCGBIT(0, 0)))
+                                return handle_eviocgbit(dev, cmd, p, compat_mode);
 
                         if (_IOC_NR(cmd) == _IOC_NR(EVIOCGKEY(0)))
                                 return bits_to_user(dev->key, KEY_MAX, _IOC_SIZE(cmd),
diff --git a/drivers/input/joystick/xpad.c b/drivers/input/joystick/xpad.c
index 87d3e7eabffd..6791be81eb29 100644
--- a/drivers/input/joystick/xpad.c
+++ b/drivers/input/joystick/xpad.c
@@ -127,6 +127,7 @@ static const struct xpad_device {
         { 0x0738, 0x4716, "Mad Catz Wired Xbox 360 Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX360 },
         { 0x0738, 0x6040, "Mad Catz Beat Pad Pro", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
         { 0x0c12, 0x8802, "Zeroplus Xbox Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX },
+        { 0x0c12, 0x880a, "Pelican Eclipse PL-2023", MAP_DPAD_TO_AXES, XTYPE_XBOX },
         { 0x0c12, 0x8810, "Zeroplus Xbox Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX },
         { 0x0c12, 0x9902, "HAMA VibraX - *FAULTY HARDWARE*", MAP_DPAD_TO_AXES, XTYPE_XBOX },
         { 0x0e4c, 0x1097, "Radica Gamester Controller", MAP_DPAD_TO_AXES, XTYPE_XBOX },
diff --git a/drivers/input/keyboard/gpio_keys.c b/drivers/input/keyboard/gpio_keys.c
index be58730e636a..3f48279f2195 100644
--- a/drivers/input/keyboard/gpio_keys.c
+++ b/drivers/input/keyboard/gpio_keys.c
@@ -118,6 +118,7 @@ static int __devinit gpio_keys_probe(struct platform_device *pdev)
                 unsigned int type = button->type ?: EV_KEY;
 
                 bdata->input = input;
+                bdata->button = button;
                 setup_timer(&bdata->timer,
                             gpio_check_button, (unsigned long)bdata);
 
@@ -256,7 +257,7 @@ static int gpio_keys_resume(struct platform_device *pdev)
 #define gpio_keys_resume        NULL
 #endif
 
-struct platform_driver gpio_keys_device_driver = {
+static struct platform_driver gpio_keys_device_driver = {
         .probe          = gpio_keys_probe,
         .remove         = __devexit_p(gpio_keys_remove),
         .suspend        = gpio_keys_suspend,
diff --git a/drivers/input/mouse/Kconfig b/drivers/input/mouse/Kconfig
index 7bbea097cda2..f996546fc443 100644
--- a/drivers/input/mouse/Kconfig
+++ b/drivers/input/mouse/Kconfig
@@ -130,6 +130,29 @@ config MOUSE_APPLETOUCH
           To compile this driver as a module, choose M here: the
           module will be called appletouch.
 
+config MOUSE_BCM5974
+        tristate "Apple USB BCM5974 Multitouch trackpad support"
+        depends on USB_ARCH_HAS_HCD
+        select USB
+        help
+          Say Y here if you have an Apple USB BCM5974 Multitouch
+          trackpad.
+
+          The BCM5974 is the multitouch trackpad found in the Macbook
+          Air (JAN2008) and Macbook Pro Penryn (FEB2008) laptops.
+
+          It is also found in the IPhone (2007) and Ipod Touch (2008).
+
+          This driver provides multitouch functionality together with
+          the synaptics X11 driver.
+
+          The interface is currently identical to the appletouch interface,
+          for further information, see
+          <file:Documentation/input/appletouch.txt>.
+
+          To compile this driver as a module, choose M here: the
+          module will be called bcm5974.
+
 config MOUSE_INPORT
         tristate "InPort/MS/ATIXL busmouse"
         depends on ISA
diff --git a/drivers/input/mouse/Makefile b/drivers/input/mouse/Makefile
index 9e6e36330820..d4d202516090 100644
--- a/drivers/input/mouse/Makefile
+++ b/drivers/input/mouse/Makefile
@@ -6,6 +6,7 @@
 
 obj-$(CONFIG_MOUSE_AMIGA)       += amimouse.o
 obj-$(CONFIG_MOUSE_APPLETOUCH)  += appletouch.o
+obj-$(CONFIG_MOUSE_BCM5974)     += bcm5974.o
 obj-$(CONFIG_MOUSE_ATARI)       += atarimouse.o
 obj-$(CONFIG_MOUSE_RISCPC)      += rpcmouse.o
 obj-$(CONFIG_MOUSE_INPORT)      += inport.o
diff --git a/drivers/input/mouse/bcm5974.c b/drivers/input/mouse/bcm5974.c
new file mode 100644
index 000000000000..2ec921bf3c60
--- /dev/null
+++ b/drivers/input/mouse/bcm5974.c
@@ -0,0 +1,681 @@
+/*
+ * Apple USB BCM5974 (Macbook Air and Penryn Macbook Pro) multitouch driver
+ *
+ * Copyright (C) 2008      Henrik Rydberg (rydberg@euromail.se)
+ *
+ * The USB initialization and package decoding was made by
+ * Scott Shawcroft as part of the touchd user-space driver project:
+ * Copyright (C) 2008      Scott Shawcroft (scott.shawcroft@gmail.com)
+ *
+ * The BCM5974 driver is based on the appletouch driver:
+ * Copyright (C) 2001-2004 Greg Kroah-Hartman (greg@kroah.com)
+ * Copyright (C) 2005      Johannes Berg (johannes@sipsolutions.net)
+ * Copyright (C) 2005      Stelian Pop (stelian@popies.net)
+ * Copyright (C) 2005      Frank Arnold (frank@scirocco-5v-turbo.de)
+ * Copyright (C) 2005      Peter Osterlund (petero2@telia.com)
+ * Copyright (C) 2005      Michael Hanselmann (linux-kernel@hansmi.ch)
+ * Copyright (C) 2006      Nicolas Boichat (nicolas@boichat.ch)
+ *
+ * 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/kernel.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/usb/input.h>
+#include <linux/hid.h>
+#include <linux/mutex.h>
+
+#define USB_VENDOR_ID_APPLE             0x05ac
+
+/* MacbookAir, aka wellspring */
+#define USB_DEVICE_ID_APPLE_WELLSPRING_ANSI     0x0223
+#define USB_DEVICE_ID_APPLE_WELLSPRING_ISO      0x0224
+#define USB_DEVICE_ID_APPLE_WELLSPRING_JIS      0x0225
+/* MacbookProPenryn, aka wellspring2 */
+#define USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI    0x0230
+#define USB_DEVICE_ID_APPLE_WELLSPRING2_ISO     0x0231
+#define USB_DEVICE_ID_APPLE_WELLSPRING2_JIS     0x0232
+
+#define BCM5974_DEVICE(prod) {                                  \
+        .match_flags = (USB_DEVICE_ID_MATCH_DEVICE |            \
+                        USB_DEVICE_ID_MATCH_INT_CLASS |         \
+                        USB_DEVICE_ID_MATCH_INT_PROTOCOL),      \
+        .idVendor = USB_VENDOR_ID_APPLE,                        \
+        .idProduct = (prod),                                    \
+        .bInterfaceClass = USB_INTERFACE_CLASS_HID,             \
+        .bInterfaceProtocol = USB_INTERFACE_PROTOCOL_MOUSE      \
+}
+
+/* table of devices that work with this driver */
+static const struct usb_device_id bcm5974_table [] = {
+        /* MacbookAir1.1 */
+        BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING_ANSI),
+        BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING_ISO),
+        BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING_JIS),
+        /* MacbookProPenryn */
+        BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI),
+        BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING2_ISO),
+        BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING2_JIS),
+        /* Terminating entry */
+        {}
+};
+MODULE_DEVICE_TABLE(usb, bcm5974_table);
+
+MODULE_AUTHOR("Henrik Rydberg");
+MODULE_DESCRIPTION("Apple USB BCM5974 multitouch driver");
+MODULE_LICENSE("GPL");
+
+#define dprintk(level, format, a...)\
+        { if (debug >= level) printk(KERN_DEBUG format, ##a); }
+
+static int debug = 1;
+module_param(debug, int, 0644);
+MODULE_PARM_DESC(debug, "Activate debugging output");
+
+/* button data structure */
+struct bt_data {
+        u8 unknown1;            /* constant */
+        u8 button;              /* left button */
+        u8 rel_x;               /* relative x coordinate */
+        u8 rel_y;               /* relative y coordinate */
+};
+
+/* trackpad header structure */
+struct tp_header {
+        u8 unknown1[16];        /* constants, timers, etc */
+        u8 fingers;             /* number of fingers on trackpad */
+        u8 unknown2[9];         /* constants, timers, etc */
+};
+
+/* trackpad finger structure */
+struct tp_finger {
+        __le16 origin;          /* left/right origin? */
+        __le16 abs_x;           /* absolute x coodinate */
+        __le16 abs_y;           /* absolute y coodinate */
+        __le16 rel_x;           /* relative x coodinate */
+        __le16 rel_y;           /* relative y coodinate */
+        __le16 size_major;      /* finger size, major axis? */
+        __le16 size_minor;      /* finger size, minor axis? */
+        __le16 orientation;     /* 16384 when point, else 15 bit angle */
+        __le16 force_major;     /* trackpad force, major axis? */
+        __le16 force_minor;     /* trackpad force, minor axis? */
+        __le16 unused[3];       /* zeros */
+        __le16 multi;           /* one finger: varies, more fingers: constant */
+};
+
+/* trackpad data structure, empirically at least ten fingers */
+struct tp_data {
+        struct tp_header header;
+        struct tp_finger finger[16];
+};
+
+/* device-specific parameters */
+struct bcm5974_param {
+        int dim;                /* logical dimension */
+        int fuzz;               /* logical noise value */
+        int devmin;             /* device minimum reading */
+        int devmax;             /* device maximum reading */
+};
+
+/* device-specific configuration */
+struct bcm5974_config {
+        int ansi, iso, jis;     /* the product id of this device */
+        int bt_ep;              /* the endpoint of the button interface */
+        int bt_datalen;         /* data length of the button interface */
+        int tp_ep;              /* the endpoint of the trackpad interface */
+        int tp_datalen;         /* data length of the trackpad interface */
+        struct bcm5974_param p; /* finger pressure limits */
+        struct bcm5974_param w; /* finger width limits */
+        struct bcm5974_param x; /* horizontal limits */
+        struct bcm5974_param y; /* vertical limits */
+};
+
+/* logical device structure */
+struct bcm5974 {
+        char phys[64];
+        struct usb_device *udev;        /* usb device */
+        struct usb_interface *intf;     /* our interface */
+        struct input_dev *input;        /* input dev */
+        struct bcm5974_config cfg;      /* device configuration */
+        struct mutex pm_mutex;          /* serialize access to open/suspend */
+        int opened;                     /* 1: opened, 0: closed */
+        struct urb *bt_urb;             /* button usb request block */
+        struct bt_data *bt_data;        /* button transferred data */
+        struct urb *tp_urb;             /* trackpad usb request block */
+        struct tp_data *tp_data;        /* trackpad transferred data */
+};
+
+/* logical dimensions */
+#define DIM_PRESSURE    256             /* maximum finger pressure */
+#define DIM_WIDTH       16              /* maximum finger width */
+#define DIM_X           1280            /* maximum trackpad x value */
+#define DIM_Y           800             /* maximum trackpad y value */
+
+/* logical signal quality */
+#define SN_PRESSURE     45              /* pressure signal-to-noise ratio */
+#define SN_WIDTH        100             /* width signal-to-noise ratio */
+#define SN_COORD        250             /* coordinate signal-to-noise ratio */
+
+/* device constants */
+static const struct bcm5974_config bcm5974_config_table[] = {
+        {
+                USB_DEVICE_ID_APPLE_WELLSPRING_ANSI,
+                USB_DEVICE_ID_APPLE_WELLSPRING_ISO,
+                USB_DEVICE_ID_APPLE_WELLSPRING_JIS,
+                0x84, sizeof(struct bt_data),
+                0x81, sizeof(struct tp_data),
+                { DIM_PRESSURE, DIM_PRESSURE / SN_PRESSURE, 0, 256 },
+                { DIM_WIDTH, DIM_WIDTH / SN_WIDTH, 0, 2048 },
+                { DIM_X, DIM_X / SN_COORD, -4824, 5342 },
+                { DIM_Y, DIM_Y / SN_COORD, -172, 5820 }
+        },
+        {
+                USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI,
+                USB_DEVICE_ID_APPLE_WELLSPRING2_ISO,
+                USB_DEVICE_ID_APPLE_WELLSPRING2_JIS,
+                0x84, sizeof(struct bt_data),
+                0x81, sizeof(struct tp_data),
+                { DIM_PRESSURE, DIM_PRESSURE / SN_PRESSURE, 0, 256 },
+                { DIM_WIDTH, DIM_WIDTH / SN_WIDTH, 0, 2048 },
+                { DIM_X, DIM_X / SN_COORD, -4824, 4824 },
+                { DIM_Y, DIM_Y / SN_COORD, -172, 4290 }
+        },
+        {}
+};
+
+/* return the device-specific configuration by device */
+static const struct bcm5974_config *bcm5974_get_config(struct usb_device *udev)
+{
+        u16 id = le16_to_cpu(udev->descriptor.idProduct);
+        const struct bcm5974_config *cfg;
+
+        for (cfg = bcm5974_config_table; cfg->ansi; ++cfg)
+                if (cfg->ansi == id || cfg->iso == id || cfg->jis == id)
+                        return cfg;
+
+        return bcm5974_config_table;
+}
+
+/* convert 16-bit little endian to signed integer */
+static inline int raw2int(__le16 x)
+{
+        return (signed short)le16_to_cpu(x);
+}
+
+/* scale device data to logical dimensions (asserts devmin < devmax) */
+static inline int int2scale(const struct bcm5974_param *p, int x)
+{
+        return x * p->dim / (p->devmax - p->devmin);
+}
+
+/* all logical value ranges are [0,dim). */
+static inline int int2bound(const struct bcm5974_param *p, int x)
+{
+        int s = int2scale(p, x);
+
+        return clamp_val(s, 0, p->dim - 1);
+}
+
+/* setup which logical events to report */
+static void setup_events_to_report(struct input_dev *input_dev,
+                                   const struct bcm5974_config *cfg)
+{
+        __set_bit(EV_ABS, input_dev->evbit);
+
+        input_set_abs_params(input_dev, ABS_PRESSURE,
+                                0, cfg->p.dim, cfg->p.fuzz, 0);
+        input_set_abs_params(input_dev, ABS_TOOL_WIDTH,
+                                0, cfg->w.dim, cfg->w.fuzz, 0);
+        input_set_abs_params(input_dev, ABS_X,
+                                0, cfg->x.dim, cfg->x.fuzz, 0);
+        input_set_abs_params(input_dev, ABS_Y,
+                                0, cfg->y.dim, cfg->y.fuzz, 0);
+
+        __set_bit(EV_KEY, input_dev->evbit);
+        __set_bit(BTN_TOOL_FINGER, input_dev->keybit);
+        __set_bit(BTN_TOOL_DOUBLETAP, input_dev->keybit);
+        __set_bit(BTN_TOOL_TRIPLETAP, input_dev->keybit);
+        __set_bit(BTN_LEFT, input_dev->keybit);
+}
+
+/* report button data as logical button state */
+static int report_bt_state(struct bcm5974 *dev, int size)
+{
+        if (size != sizeof(struct bt_data))
+                return -EIO;
+
+        input_report_key(dev->input, BTN_LEFT, dev->bt_data->button);
+        input_sync(dev->input);
+
+        return 0;
+}
+
+/* report trackpad data as logical trackpad state */
+static int report_tp_state(struct bcm5974 *dev, int size)
+{
+        const struct bcm5974_config *c = &dev->cfg;
+        const struct tp_finger *f = dev->tp_data->finger;
+        struct input_dev *input = dev->input;
+        const int fingers = (size - 26) / 28;
+        int p = 0, w, x, y, n = 0;
+
+        if (size < 26 || (size - 26) % 28 != 0)
+                return -EIO;
+
+        if (fingers) {
+                p = raw2int(f->force_major);
+                w = raw2int(f->size_major);
+                x = raw2int(f->abs_x);
+                y = raw2int(f->abs_y);
+                n = p > 0 ? fingers : 0;
+
+                dprintk(9,
+                        "bcm5974: p: %+05d w: %+05d x: %+05d y: %+05d n: %d\n",
+                        p, w, x, y, n);
+
+                input_report_abs(input, ABS_TOOL_WIDTH, int2bound(&c->w, w));
+                input_report_abs(input, ABS_X, int2bound(&c->x, x - c->x.devmin));
+                input_report_abs(input, ABS_Y, int2bound(&c->y, c->y.devmax - y));
+        }
+
+        input_report_abs(input, ABS_PRESSURE, int2bound(&c->p, p));
+
+        input_report_key(input, BTN_TOOL_FINGER, n == 1);
+        input_report_key(input, BTN_TOOL_DOUBLETAP, n == 2);
+        input_report_key(input, BTN_TOOL_TRIPLETAP, n > 2);
+
+        input_sync(input);
+
+        return 0;
+}
+
+/* Wellspring initialization constants */
+#define BCM5974_WELLSPRING_MODE_READ_REQUEST_ID         1
+#define BCM5974_WELLSPRING_MODE_WRITE_REQUEST_ID        9
+#define BCM5974_WELLSPRING_MODE_REQUEST_VALUE           0x300
+#define BCM5974_WELLSPRING_MODE_REQUEST_INDEX           0
+#define BCM5974_WELLSPRING_MODE_VENDOR_VALUE            0x01
+
+static int bcm5974_wellspring_mode(struct bcm5974 *dev)
+{
+        char *data = kmalloc(8, GFP_KERNEL);
+        int retval = 0, size;
+
+        if (!data) {
+                err("bcm5974: out of memory");
+                retval = -ENOMEM;
+                goto out;
+        }
+
+        /* read configuration */
+        size = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
+                        BCM5974_WELLSPRING_MODE_READ_REQUEST_ID,
+                        USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
+                        BCM5974_WELLSPRING_MODE_REQUEST_VALUE,
+                        BCM5974_WELLSPRING_MODE_REQUEST_INDEX, data, 8, 5000);
+
+        if (size != 8) {
+                err("bcm5974: could not read from device");
+                retval = -EIO;
+                goto out;
+        }
+
+        /* apply the mode switch */
+        data[0] = BCM5974_WELLSPRING_MODE_VENDOR_VALUE;
+
+        /* write configuration */
+        size = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
+                        BCM5974_WELLSPRING_MODE_WRITE_REQUEST_ID,
+                        USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
+                        BCM5974_WELLSPRING_MODE_REQUEST_VALUE,
+                        BCM5974_WELLSPRING_MODE_REQUEST_INDEX, data, 8, 5000);
+
+        if (size != 8) {
+                err("bcm5974: could not write to device");
+                retval = -EIO;
+                goto out;
+        }
+
+        dprintk(2, "bcm5974: switched to wellspring mode.\n");
+
+ out:
+        kfree(data);
+        return retval;
+}
+
+static void bcm5974_irq_button(struct urb *urb)
+{
+        struct bcm5974 *dev = urb->context;
+        int error;
+
+        switch (urb->status) {
+        case 0:
+                break;
+        case -EOVERFLOW:
+        case -ECONNRESET:
+        case -ENOENT:
+        case -ESHUTDOWN:
+                dbg("bcm5974: button urb shutting down: %d", urb->status);
+                return;
+        default:
+                dbg("bcm5974: button urb status: %d", urb->status);
+                goto exit;
+        }
+
+        if (report_bt_state(dev, dev->bt_urb->actual_length))
+                dprintk(1, "bcm5974: bad button package, length: %d\n",
+                        dev->bt_urb->actual_length);
+
+exit:
+        error = usb_submit_urb(dev->bt_urb, GFP_ATOMIC);
+        if (error)
+                err("bcm5974: button urb failed: %d", error);
+}
+
+static void bcm5974_irq_trackpad(struct urb *urb)
+{
+        struct bcm5974 *dev = urb->context;
+        int error;
+
+        switch (urb->status) {
+        case 0:
+                break;
+        case -EOVERFLOW:
+        case -ECONNRESET:
+        case -ENOENT:
+        case -ESHUTDOWN:
+                dbg("bcm5974: trackpad urb shutting down: %d", urb->status);
+                return;
+        default:
+                dbg("bcm5974: trackpad urb status: %d", urb->status);
+                goto exit;
+        }
+
+        /* control response ignored */
+        if (dev->tp_urb->actual_length == 2)
+                goto exit;
+
+        if (report_tp_state(dev, dev->tp_urb->actual_length))
+                dprintk(1, "bcm5974: bad trackpad package, length: %d\n",
+                        dev->tp_urb->actual_length);
+
+exit:
+        error = usb_submit_urb(dev->tp_urb, GFP_ATOMIC);
+        if (error)
+                err("bcm5974: trackpad urb failed: %d", error);
+}
+
+/*
+ * The Wellspring trackpad, like many recent Apple trackpads, share
+ * the usb device with the keyboard. Since keyboards are usually
+ * handled by the HID system, the device ends up being handled by two
+ * modules. Setting up the device therefore becomes slightly
+ * complicated. To enable multitouch features, a mode switch is
+ * required, which is usually applied via the control interface of the
+ * device.  It can be argued where this switch should take place. In
+ * some drivers, like appletouch, the switch is made during
+ * probe. However, the hid module may also alter the state of the
+ * device, resulting in trackpad malfunction under certain
+ * circumstances. To get around this problem, there is at least one
+ * example that utilizes the USB_QUIRK_RESET_RESUME quirk in order to
+ * recieve a reset_resume request rather than the normal resume.
+ * Since the implementation of reset_resume is equal to mode switch
+ * plus start_traffic, it seems easier to always do the switch when
+ * starting traffic on the device.
+ */
+static int bcm5974_start_traffic(struct bcm5974 *dev)
+{
+        if (bcm5974_wellspring_mode(dev)) {
+                dprintk(1, "bcm5974: mode switch failed\n");
+                goto error;
+        }
+
+        if (usb_submit_urb(dev->bt_urb, GFP_KERNEL))
+                goto error;
+
+        if (usb_submit_urb(dev->tp_urb, GFP_KERNEL))
+                goto err_kill_bt;
+
+        return 0;
+
+err_kill_bt:
+        usb_kill_urb(dev->bt_urb);
+error:
+        return -EIO;
+}
+
+static void bcm5974_pause_traffic(struct bcm5974 *dev)
+{
+        usb_kill_urb(dev->tp_urb);
+        usb_kill_urb(dev->bt_urb);
+}
+
+/*
+ * The code below implements open/close and manual suspend/resume.
+ * All functions may be called in random order.
+ *
+ * Opening a suspended device fails with EACCES - permission denied.
+ *
+ * Failing a resume leaves the device resumed but closed.
+ */
+static int bcm5974_open(struct input_dev *input)
+{
+        struct bcm5974 *dev = input_get_drvdata(input);
+        int error;
+
+        error = usb_autopm_get_interface(dev->intf);
+        if (error)
+                return error;
+
+        mutex_lock(&dev->pm_mutex);
+
+        error = bcm5974_start_traffic(dev);
+        if (!error)
+                dev->opened = 1;
+
+        mutex_unlock(&dev->pm_mutex);
+
+        if (error)
+                usb_autopm_put_interface(dev->intf);
+
+        return error;
+}
+
+static void bcm5974_close(struct input_dev *input)
+{
+        struct bcm5974 *dev = input_get_drvdata(input);
+
+        mutex_lock(&dev->pm_mutex);
+
+        bcm5974_pause_traffic(dev);
+        dev->opened = 0;
+
+        mutex_unlock(&dev->pm_mutex);
+
+        usb_autopm_put_interface(dev->intf);
+}
+
+static int bcm5974_suspend(struct usb_interface *iface, pm_message_t message)
+{
+        struct bcm5974 *dev = usb_get_intfdata(iface);
+
+        mutex_lock(&dev->pm_mutex);
+
+        if (dev->opened)
+                bcm5974_pause_traffic(dev);
+
+        mutex_unlock(&dev->pm_mutex);
+
+        return 0;
+}
+
+static int bcm5974_resume(struct usb_interface *iface)
+{
+        struct bcm5974 *dev = usb_get_intfdata(iface);
+        int error = 0;
+
+        mutex_lock(&dev->pm_mutex);
+
+        if (dev->opened)
+                error = bcm5974_start_traffic(dev);
+
+        mutex_unlock(&dev->pm_mutex);
+
+        return error;
+}
+
+static int bcm5974_probe(struct usb_interface *iface,
+                         const struct usb_device_id *id)
+{
+        struct usb_device *udev = interface_to_usbdev(iface);
+        const struct bcm5974_config *cfg;
+        struct bcm5974 *dev;
+        struct input_dev *input_dev;
+        int error = -ENOMEM;
+
+        /* find the product index */
+        cfg = bcm5974_get_config(udev);
+
+        /* allocate memory for our device state and initialize it */
+        dev = kzalloc(sizeof(struct bcm5974), GFP_KERNEL);
+        input_dev = input_allocate_device();
+        if (!dev || !input_dev) {
+                err("bcm5974: out of memory");
+                goto err_free_devs;
+        }
+
+        dev->udev = udev;
+        dev->intf = iface;
+        dev->input = input_dev;
+        dev->cfg = *cfg;
+        mutex_init(&dev->pm_mutex);
+
+        /* setup urbs */
+        dev->bt_urb = usb_alloc_urb(0, GFP_KERNEL);
+        if (!dev->bt_urb)
+                goto err_free_devs;
+
+        dev->tp_urb = usb_alloc_urb(0, GFP_KERNEL);
+        if (!dev->tp_urb)
+                goto err_free_bt_urb;
+
+        dev->bt_data = usb_buffer_alloc(dev->udev,
+                                        dev->cfg.bt_datalen, GFP_KERNEL,
+                                        &dev->bt_urb->transfer_dma);
+        if (!dev->bt_data)
+                goto err_free_urb;
+
+        dev->tp_data = usb_buffer_alloc(dev->udev,
+                                        dev->cfg.tp_datalen, GFP_KERNEL,
+                                        &dev->tp_urb->transfer_dma);
+        if (!dev->tp_data)
+                goto err_free_bt_buffer;
+
+        usb_fill_int_urb(dev->bt_urb, udev,
+                         usb_rcvintpipe(udev, cfg->bt_ep),
+                         dev->bt_data, dev->cfg.bt_datalen,
+                         bcm5974_irq_button, dev, 1);
+
+        usb_fill_int_urb(dev->tp_urb, udev,
+                         usb_rcvintpipe(udev, cfg->tp_ep),
+                         dev->tp_data, dev->cfg.tp_datalen,
+                         bcm5974_irq_trackpad, dev, 1);
+
+        /* create bcm5974 device */
+        usb_make_path(udev, dev->phys, sizeof(dev->phys));
+        strlcat(dev->phys, "/input0", sizeof(dev->phys));
+
+        input_dev->name = "bcm5974";
+        input_dev->phys = dev->phys;
+        usb_to_input_id(dev->udev, &input_dev->id);
+        input_dev->dev.parent = &iface->dev;
+
+        input_set_drvdata(input_dev, dev);
+
+        input_dev->open = bcm5974_open;
+        input_dev->close = bcm5974_close;
+
+        setup_events_to_report(input_dev, cfg);
+
+        error = input_register_device(dev->input);
+        if (error)
+                goto err_free_buffer;
+
+        /* save our data pointer in this interface device */
+        usb_set_intfdata(iface, dev);
+
+        return 0;
+
+err_free_buffer:
+        usb_buffer_free(dev->udev, dev->cfg.tp_datalen,
+                dev->tp_data, dev->tp_urb->transfer_dma);
+err_free_bt_buffer:
+        usb_buffer_free(dev->udev, dev->cfg.bt_datalen,
+                dev->bt_data, dev->bt_urb->transfer_dma);
+err_free_urb:
+        usb_free_urb(dev->tp_urb);
+err_free_bt_urb:
+        usb_free_urb(dev->bt_urb);
+err_free_devs:
+        usb_set_intfdata(iface, NULL);
+        input_free_device(input_dev);
+        kfree(dev);
+        return error;
+}
+
+static void bcm5974_disconnect(struct usb_interface *iface)
+{
+        struct bcm5974 *dev = usb_get_intfdata(iface);
+
+        usb_set_intfdata(iface, NULL);
+
+        input_unregister_device(dev->input);
+        usb_buffer_free(dev->udev, dev->cfg.tp_datalen,
+                        dev->tp_data, dev->tp_urb->transfer_dma);
+        usb_buffer_free(dev->udev, dev->cfg.bt_datalen,
+                        dev->bt_data, dev->bt_urb->transfer_dma);
+        usb_free_urb(dev->tp_urb);
+        usb_free_urb(dev->bt_urb);
+        kfree(dev);
+}
+
+static struct usb_driver bcm5974_driver = {
+        .name                   = "bcm5974",
+        .probe                  = bcm5974_probe,
+        .disconnect             = bcm5974_disconnect,
+        .suspend                = bcm5974_suspend,
+        .resume                 = bcm5974_resume,
+        .reset_resume           = bcm5974_resume,
+        .id_table               = bcm5974_table,
+        .supports_autosuspend   = 1,
+};
+
+static int __init bcm5974_init(void)
+{
+        return usb_register(&bcm5974_driver);
+}
+
+static void __exit bcm5974_exit(void)
+{
+        usb_deregister(&bcm5974_driver);
+}
+
+module_init(bcm5974_init);
+module_exit(bcm5974_exit);
+
diff --git a/drivers/input/serio/i8042-x86ia64io.h b/drivers/input/serio/i8042-x86ia64io.h
index fe732a574ec2..3282b741e246 100644
--- a/drivers/input/serio/i8042-x86ia64io.h
+++ b/drivers/input/serio/i8042-x86ia64io.h
@@ -394,6 +394,13 @@ static struct dmi_system_id __initdata i8042_dmi_dritek_table[] = {
                         DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 2490"),
                 },
         },
+        {
+                .ident = "Acer TravelMate 4280",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 4280"),
+                },
+        },
         { }
 };
 
diff --git a/drivers/input/serio/xilinx_ps2.c b/drivers/input/serio/xilinx_ps2.c
index 0ed044d5e685..765007899d9a 100644
--- a/drivers/input/serio/xilinx_ps2.c
+++ b/drivers/input/serio/xilinx_ps2.c
@@ -269,8 +269,8 @@ static int xps2_setup(struct device *dev, struct resource *regs_res,
          * we have the PS2 in a good state */
         out_be32(drvdata->base_address + XPS2_SRST_OFFSET, XPS2_SRST_RESET);
 
-        dev_info(dev, "Xilinx PS2 at 0x%08X mapped to 0x%08X, irq=%d\n",
-                drvdata->phys_addr, (u32)drvdata->base_address, drvdata->irq);
+        dev_info(dev, "Xilinx PS2 at 0x%08X mapped to 0x%p, irq=%d\n",
+                drvdata->phys_addr, drvdata->base_address, drvdata->irq);
 
         serio = &drvdata->serio;
         serio->id.type = SERIO_8042;
diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
index 6e60a97a234c..25287e80e236 100644
--- a/drivers/input/touchscreen/Kconfig
+++ b/drivers/input/touchscreen/Kconfig
@@ -249,29 +249,26 @@ config TOUCHSCREEN_WM97XX
 config TOUCHSCREEN_WM9705
         bool "WM9705 Touchscreen interface support"
         depends on TOUCHSCREEN_WM97XX
+        default y
         help
-          Say Y here if you have a Wolfson Microelectronics WM9705
-          touchscreen controller connected to your system.
-
-          If unsure, say N.
+          Say Y here to enable support for the Wolfson Microelectronics
+          WM9705 touchscreen controller.
 
 config TOUCHSCREEN_WM9712
         bool "WM9712 Touchscreen interface support"
         depends on TOUCHSCREEN_WM97XX
+        default y
         help
-          Say Y here if you have a Wolfson Microelectronics WM9712
-          touchscreen controller connected to your system.
-
-          If unsure, say N.
+          Say Y here to enable support for the Wolfson Microelectronics
+          WM9712 touchscreen controller.
 
 config TOUCHSCREEN_WM9713
         bool "WM9713 Touchscreen interface support"
         depends on TOUCHSCREEN_WM97XX
+        default y
         help
-          Say Y here if you have a Wolfson Microelectronics WM9713 touchscreen
-          controller connected to your system.
-
-          If unsure, say N.
+          Say Y here to enable support for the Wolfson Microelectronics
+          WM9713 touchscreen controller.
 
 config TOUCHSCREEN_WM97XX_MAINSTONE
         tristate "WM97xx Mainstone accelerated touch"
diff --git a/drivers/md/md.c b/drivers/md/md.c
index c7aae66c6f9b..8cfadc5bd2ba 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -2393,6 +2393,8 @@ static void analyze_sbs(mddev_t * mddev)
 
 }
 
+static void md_safemode_timeout(unsigned long data);
+
 static ssize_t
 safe_delay_show(mddev_t *mddev, char *page)
 {
@@ -2432,9 +2434,12 @@ safe_delay_store(mddev_t *mddev, const char *cbuf, size_t len)
         if (msec == 0)
                 mddev->safemode_delay = 0;
         else {
+                unsigned long old_delay = mddev->safemode_delay;
                 mddev->safemode_delay = (msec*HZ)/1000;
                 if (mddev->safemode_delay == 0)
                         mddev->safemode_delay = 1;
+                if (mddev->safemode_delay < old_delay)
+                        md_safemode_timeout((unsigned long)mddev);
         }
         return len;
 }
@@ -4634,6 +4639,11 @@ static int update_size(mddev_t *mddev, sector_t num_sectors)
          */
         if (mddev->sync_thread)
                 return -EBUSY;
+        if (mddev->bitmap)
+                /* Sorry, cannot grow a bitmap yet, just remove it,
+                 * grow, and re-add.
+                 */
+                return -EBUSY;
         rdev_for_each(rdev, tmp, mddev) {
                 sector_t avail;
                 avail = rdev->size * 2;
@@ -5993,7 +6003,7 @@ static int remove_and_add_spares(mddev_t *mddev)
                         }
                 }
 
-        if (mddev->degraded) {
+        if (mddev->degraded && ! mddev->ro) {
                 rdev_for_each(rdev, rtmp, mddev) {
                         if (rdev->raid_disk >= 0 &&
                             !test_bit(In_sync, &rdev->flags) &&
@@ -6067,6 +6077,8 @@ void md_check_recovery(mddev_t *mddev)
                 flush_signals(current);
         }
 
+        if (mddev->ro && !test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))
+                return;
         if ( ! (
                 (mddev->flags && !mddev->external) ||
                 test_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
@@ -6080,6 +6092,15 @@ void md_check_recovery(mddev_t *mddev)
         if (mddev_trylock(mddev)) {
                 int spares = 0;
 
+                if (mddev->ro) {
+                        /* Only thing we do on a ro array is remove
+                         * failed devices.
+                         */
+                        remove_and_add_spares(mddev);
+                        clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
+                        goto unlock;
+                }
+
                 if (!mddev->external) {
                         int did_change = 0;
                         spin_lock_irq(&mddev->write_lock);
@@ -6117,7 +6138,8 @@ void md_check_recovery(mddev_t *mddev)
                         /* resync has finished, collect result */
                         md_unregister_thread(mddev->sync_thread);
                         mddev->sync_thread = NULL;
-                        if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
+                        if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
+                            !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) {
                                 /* success...*/
                                 /* activate any spares */
                                 if (mddev->pers->spare_active(mddev))
@@ -6169,6 +6191,7 @@ void md_check_recovery(mddev_t *mddev)
                 } else if ((spares = remove_and_add_spares(mddev))) {
                         clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
                         clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
+                        clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
                         set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
                 } else if (mddev->recovery_cp < MaxSector) {
                         set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
@@ -6232,7 +6255,11 @@ static int md_notify_reboot(struct notifier_block *this,
 
                 for_each_mddev(mddev, tmp)
                         if (mddev_trylock(mddev)) {
-                                do_md_stop (mddev, 1, 0);
+                                /* Force a switch to readonly even array
+                                 * appears to still be in use.  Hence
+                                 * the '100'.
+                                 */
+                                do_md_stop (mddev, 1, 100);
                                 mddev_unlock(mddev);
                         }
                 /*
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index d41bebb6da0f..e34cd0e62473 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -76,11 +76,13 @@ static void r10bio_pool_free(void *r10_bio, void *data)
         kfree(r10_bio);
 }
 
+/* Maximum size of each resync request */
 #define RESYNC_BLOCK_SIZE (64*1024)
-//#define RESYNC_BLOCK_SIZE PAGE_SIZE
-#define RESYNC_SECTORS (RESYNC_BLOCK_SIZE >> 9)
 #define RESYNC_PAGES ((RESYNC_BLOCK_SIZE + PAGE_SIZE-1) / PAGE_SIZE)
-#define RESYNC_WINDOW (2048*1024)
+/* amount of memory to reserve for resync requests */
+#define RESYNC_WINDOW (1024*1024)
+/* maximum number of concurrent requests, memory permitting */
+#define RESYNC_DEPTH (32*1024*1024/RESYNC_BLOCK_SIZE)
 
 /*
  * When performing a resync, we need to read and compare, so
@@ -690,7 +692,6 @@ static int flush_pending_writes(conf_t *conf)
  *    there is no normal IO happeing.  It must arrange to call
  *    lower_barrier when the particular background IO completes.
  */
-#define RESYNC_DEPTH 32
 
 static void raise_barrier(conf_t *conf, int force)
 {
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index 40e939675657..224de022e7c5 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -2568,10 +2568,10 @@ static bool handle_stripe5(struct stripe_head *sh)
                 if (dev->written)
                         s.written++;
                 rdev = rcu_dereference(conf->disks[i].rdev);
-                if (rdev && unlikely(test_bit(Blocked, &rdev->flags))) {
+                if (blocked_rdev == NULL &&
+                    rdev && unlikely(test_bit(Blocked, &rdev->flags))) {
                         blocked_rdev = rdev;
                         atomic_inc(&rdev->nr_pending);
-                        break;
                 }
                 if (!rdev || !test_bit(In_sync, &rdev->flags)) {
                         /* The ReadError flag will just be confusing now */
@@ -2588,8 +2588,14 @@ static bool handle_stripe5(struct stripe_head *sh)
         rcu_read_unlock();
 
         if (unlikely(blocked_rdev)) {
-                set_bit(STRIPE_HANDLE, &sh->state);
-                goto unlock;
+                if (s.syncing || s.expanding || s.expanded ||
+                    s.to_write || s.written) {
+                        set_bit(STRIPE_HANDLE, &sh->state);
+                        goto unlock;
+                }
+                /* There is nothing for the blocked_rdev to block */
+                rdev_dec_pending(blocked_rdev, conf->mddev);
+                blocked_rdev = NULL;
         }
 
         if (s.to_fill && !test_bit(STRIPE_BIOFILL_RUN, &sh->state)) {
@@ -2832,10 +2838,10 @@ static bool handle_stripe6(struct stripe_head *sh, struct page *tmp_page)
                 if (dev->written)
                         s.written++;
                 rdev = rcu_dereference(conf->disks[i].rdev);
-                if (rdev && unlikely(test_bit(Blocked, &rdev->flags))) {
+                if (blocked_rdev == NULL &&
+                    rdev && unlikely(test_bit(Blocked, &rdev->flags))) {
                         blocked_rdev = rdev;
                         atomic_inc(&rdev->nr_pending);
-                        break;
                 }
                 if (!rdev || !test_bit(In_sync, &rdev->flags)) {
                         /* The ReadError flag will just be confusing now */
@@ -2853,9 +2859,16 @@ static bool handle_stripe6(struct stripe_head *sh, struct page *tmp_page)
         rcu_read_unlock();
 
         if (unlikely(blocked_rdev)) {
-                set_bit(STRIPE_HANDLE, &sh->state);
-                goto unlock;
+                if (s.syncing || s.expanding || s.expanded ||
+                    s.to_write || s.written) {
+                        set_bit(STRIPE_HANDLE, &sh->state);
+                        goto unlock;
+                }
+                /* There is nothing for the blocked_rdev to block */
+                rdev_dec_pending(blocked_rdev, conf->mddev);
+                blocked_rdev = NULL;
         }
+
         pr_debug("locked=%d uptodate=%d to_read=%d"
                " to_write=%d failed=%d failed_num=%d,%d\n",
                s.locked, s.uptodate, s.to_read, s.to_write, s.failed,
@@ -4446,6 +4459,9 @@ static int raid5_check_reshape(mddev_t *mddev)
                 return -EINVAL; /* Cannot shrink array or change level yet */
         if (mddev->delta_disks == 0)
                 return 0; /* nothing to do */
+        if (mddev->bitmap)
+                /* Cannot grow a bitmap yet */
+                return -EBUSY;
 
         /* Can only proceed if there are plenty of stripe_heads.
          * We need a minimum of one full stripe,, and for sensible progress
diff --git a/drivers/spi/spi.c b/drivers/spi/spi.c
index 964124b60db2..75e86865234c 100644
--- a/drivers/spi/spi.c
+++ b/drivers/spi/spi.c
@@ -226,10 +226,11 @@ EXPORT_SYMBOL_GPL(spi_alloc_device);
  * Companion function to spi_alloc_device.  Devices allocated with
  * spi_alloc_device can be added onto the spi bus with this function.
  *
- * Returns 0 on success; non-zero on failure
+ * Returns 0 on success; negative errno on failure
  */
 int spi_add_device(struct spi_device *spi)
 {
+        static DEFINE_MUTEX(spi_add_lock);
         struct device *dev = spi->master->dev.parent;
         int status;
 
@@ -246,26 +247,43 @@ int spi_add_device(struct spi_device *spi)
                         "%s.%u", spi->master->dev.bus_id,
                         spi->chip_select);
 
-        /* drivers may modify this initial i/o setup */
+
+        /* We need to make sure there's no other device with this
+         * chipselect **BEFORE** we call setup(), else we'll trash
+         * its configuration.  Lock against concurrent add() calls.
+         */
+        mutex_lock(&spi_add_lock);
+
+        if (bus_find_device_by_name(&spi_bus_type, NULL, spi->dev.bus_id)
+                        != NULL) {
+                dev_err(dev, "chipselect %d already in use\n",
+                                spi->chip_select);
+                status = -EBUSY;
+                goto done;
+        }
+
+        /* Drivers may modify this initial i/o setup, but will
+         * normally rely on the device being setup.  Devices
+         * using SPI_CS_HIGH can't coexist well otherwise...
+         */
         status = spi->master->setup(spi);
         if (status < 0) {
                 dev_err(dev, "can't %s %s, status %d\n",
                                 "setup", spi->dev.bus_id, status);
-                return status;
+                goto done;
         }
 
-        /* driver core catches callers that misbehave by defining
-         * devices that already exist.
-         */
+        /* Device may be bound to an active driver when this returns */
         status = device_add(&spi->dev);
-        if (status < 0) {
+        if (status < 0)
                 dev_err(dev, "can't %s %s, status %d\n",
                                 "add", spi->dev.bus_id, status);
-                return status;
-        }
+        else
+                dev_dbg(dev, "registered child %s\n", spi->dev.bus_id);
 
-        dev_dbg(dev, "registered child %s\n", spi->dev.bus_id);
-        return 0;
+done:
+        mutex_unlock(&spi_add_lock);
+        return status;
 }
 EXPORT_SYMBOL_GPL(spi_add_device);
 
diff --git a/drivers/video/fsl-diu-fb.c b/drivers/video/fsl-diu-fb.c
index bd320a2bfb7c..fb51197d1c98 100644
--- a/drivers/video/fsl-diu-fb.c
+++ b/drivers/video/fsl-diu-fb.c
@@ -479,6 +479,10 @@ static void adjust_aoi_size_position(struct fb_var_screeninfo *var,
         base_plane_width = machine_data->fsl_diu_info[0]->var.xres;
         base_plane_height = machine_data->fsl_diu_info[0]->var.yres;
 
+        if (mfbi->x_aoi_d < 0)
+                mfbi->x_aoi_d = 0;
+        if (mfbi->y_aoi_d < 0)
+                mfbi->y_aoi_d = 0;
         switch (index) {
         case 0:
                 if (mfbi->x_aoi_d != 0)
@@ -778,6 +782,22 @@ static void unmap_video_memory(struct fb_info *info)
 }
 
 /*
+ * Using the fb_var_screeninfo in fb_info we set the aoi of this
+ * particular framebuffer. It is a light version of fsl_diu_set_par.
+ */
+static int fsl_diu_set_aoi(struct fb_info *info)
+{
+        struct fb_var_screeninfo *var = &info->var;
+        struct mfb_info *mfbi = info->par;
+        struct diu_ad *ad = mfbi->ad;
+
+        /* AOI should not be greater than display size */
+        ad->offset_xyi = cpu_to_le32((var->yoffset << 16) | var->xoffset);
+        ad->offset_xyd = cpu_to_le32((mfbi->y_aoi_d << 16) | mfbi->x_aoi_d);
+        return 0;
+}
+
+/*
  * Using the fb_var_screeninfo in fb_info we set the resolution of this
  * particular framebuffer. This function alters the fb_fix_screeninfo stored
  * in fb_info. It does not alter var in fb_info since we are using that
@@ -817,11 +837,11 @@ static int fsl_diu_set_par(struct fb_info *info)
                 diu_ops.get_pixel_format(var->bits_per_pixel,
                                          machine_data->monitor_port);
         ad->addr    = cpu_to_le32(info->fix.smem_start);
-        ad->src_size_g_alpha = cpu_to_le32((var->yres << 12) |
-                                var->xres) | mfbi->g_alpha;
-        /* fix me. AOI should not be greater than display size */
+        ad->src_size_g_alpha = cpu_to_le32((var->yres_virtual << 12) |
+                                var->xres_virtual) | mfbi->g_alpha;
+        /* AOI should not be greater than display size */
         ad->aoi_size    = cpu_to_le32((var->yres << 16) | var->xres);
-        ad->offset_xyi = 0;
+        ad->offset_xyi = cpu_to_le32((var->yoffset << 16) | var->xoffset);
         ad->offset_xyd = cpu_to_le32((mfbi->y_aoi_d << 16) | mfbi->x_aoi_d);
 
         /* Disable chroma keying function */
@@ -921,6 +941,8 @@ static int fsl_diu_pan_display(struct fb_var_screeninfo *var,
         else
                 info->var.vmode &= ~FB_VMODE_YWRAP;
 
+        fsl_diu_set_aoi(info);
+
         return 0;
 }
 
@@ -989,7 +1011,7 @@ static int fsl_diu_ioctl(struct fb_info *info, unsigned int cmd,
                 pr_debug("set AOI display offset of index %d to (%d,%d)\n",
                                  mfbi->index, aoi_d.x_aoi_d, aoi_d.y_aoi_d);
                 fsl_diu_check_var(&info->var, info);
-                fsl_diu_set_par(info);
+                fsl_diu_set_aoi(info);
                 break;
         case MFB_GET_AOID:
                 aoi_d.x_aoi_d = mfbi->x_aoi_d;
diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
index e8da4ee761b5..25ecbd5b0404 100644
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -175,6 +175,8 @@ out_no_root:
         if (inode)
                 iput(inode);
 
+        cifs_umount(sb, cifs_sb);
+
 out_mount_failed:
         if (cifs_sb) {
 #ifdef CONFIG_CIFS_DFS_UPCALL
diff --git a/fs/cifs/inode.c b/fs/cifs/inode.c
index 28a22092d450..848286861c31 100644
--- a/fs/cifs/inode.c
+++ b/fs/cifs/inode.c
@@ -649,6 +649,7 @@ struct inode *cifs_iget(struct super_block *sb, unsigned long ino)
                 inode->i_fop = &simple_dir_operations;
                 inode->i_uid = cifs_sb->mnt_uid;
                 inode->i_gid = cifs_sb->mnt_gid;
+        } else if (rc) {
                 _FreeXid(xid);
                 iget_failed(inode);
                 return ERR_PTR(rc);
diff --git a/fs/inode.c b/fs/inode.c
index b6726f644530..0487ddba1397 100644
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -166,6 +166,7 @@ static struct inode *alloc_inode(struct super_block *sb)
                 mapping_set_gfp_mask(mapping, GFP_HIGHUSER_PAGECACHE);
                 mapping->assoc_mapping = NULL;
                 mapping->backing_dev_info = &default_backing_dev_info;
+                mapping->writeback_index = 0;
 
                 /*
                  * If the block_device provides a backing_dev_info for client
diff --git a/fs/omfs/bitmap.c b/fs/omfs/bitmap.c
index 697663b01bae..e1c0ec0ae989 100644
--- a/fs/omfs/bitmap.c
+++ b/fs/omfs/bitmap.c
@@ -92,7 +92,7 @@ int omfs_allocate_block(struct super_block *sb, u64 block)
         struct buffer_head *bh;
         struct omfs_sb_info *sbi = OMFS_SB(sb);
         int bits_per_entry = 8 * sb->s_blocksize;
-        int map, bit;
+        unsigned int map, bit;
         int ret = 0;
         u64 tmp;
 
@@ -176,7 +176,8 @@ int omfs_clear_range(struct super_block *sb, u64 block, int count)
         struct omfs_sb_info *sbi = OMFS_SB(sb);
         int bits_per_entry = 8 * sb->s_blocksize;
         u64 tmp;
-        int map, bit, ret;
+        unsigned int map, bit;
+        int ret;
 
         tmp = block;
         bit = do_div(tmp, bits_per_entry);
diff --git a/fs/omfs/file.c b/fs/omfs/file.c
index 7e2499053e4d..834b2331f6b3 100644
--- a/fs/omfs/file.c
+++ b/fs/omfs/file.c
@@ -26,6 +26,13 @@ static int omfs_sync_file(struct file *file, struct dentry *dentry,
         return err ? -EIO : 0;
 }
 
+static u32 omfs_max_extents(struct omfs_sb_info *sbi, int offset)
+{
+        return (sbi->s_sys_blocksize - offset -
+                sizeof(struct omfs_extent)) /
+                sizeof(struct omfs_extent_entry) + 1;
+}
+
 void omfs_make_empty_table(struct buffer_head *bh, int offset)
 {
         struct omfs_extent *oe = (struct omfs_extent *) &bh->b_data[offset];
@@ -45,6 +52,7 @@ int omfs_shrink_inode(struct inode *inode)
         struct buffer_head *bh;
         u64 next, last;
         u32 extent_count;
+        u32 max_extents;
         int ret;
 
         /* traverse extent table, freeing each entry that is greater
@@ -62,15 +70,18 @@ int omfs_shrink_inode(struct inode *inode)
                 goto out;
 
         oe = (struct omfs_extent *)(&bh->b_data[OMFS_EXTENT_START]);
+        max_extents = omfs_max_extents(sbi, OMFS_EXTENT_START);
 
         for (;;) {
 
-                if (omfs_is_bad(sbi, (struct omfs_header *) bh->b_data, next)) {
-                        brelse(bh);
-                        goto out;
-                }
+                if (omfs_is_bad(sbi, (struct omfs_header *) bh->b_data, next))
+                        goto out_brelse;
 
                 extent_count = be32_to_cpu(oe->e_extent_count);
+
+                if (extent_count > max_extents)
+                        goto out_brelse;
+
                 last = next;
                 next = be64_to_cpu(oe->e_next);
                 entry = &oe->e_entry;
@@ -98,10 +109,14 @@ int omfs_shrink_inode(struct inode *inode)
                 if (!bh)
                         goto out;
                 oe = (struct omfs_extent *) (&bh->b_data[OMFS_EXTENT_CONT]);
+                max_extents = omfs_max_extents(sbi, OMFS_EXTENT_CONT);
         }
         ret = 0;
 out:
         return ret;
+out_brelse:
+        brelse(bh);
+        return ret;
 }
 
 static void omfs_truncate(struct inode *inode)
@@ -154,9 +169,7 @@ static int omfs_grow_extent(struct inode *inode, struct omfs_extent *oe,
                         goto out;
                 }
         }
-        max_count = (sbi->s_sys_blocksize - OMFS_EXTENT_START -
-                sizeof(struct omfs_extent)) /
-                sizeof(struct omfs_extent_entry) + 1;
+        max_count = omfs_max_extents(sbi, OMFS_EXTENT_START);
 
         /* TODO: add a continuation block here */
         if (be32_to_cpu(oe->e_extent_count) > max_count-1)
@@ -225,6 +238,7 @@ static int omfs_get_block(struct inode *inode, sector_t block,
         sector_t next, offset;
         int ret;
         u64 new_block;
+        u32 max_extents;
         int extent_count;
         struct omfs_extent *oe;
         struct omfs_extent_entry *entry;
@@ -238,6 +252,7 @@ static int omfs_get_block(struct inode *inode, sector_t block,
                 goto out;
 
         oe = (struct omfs_extent *)(&bh->b_data[OMFS_EXTENT_START]);
+        max_extents = omfs_max_extents(sbi, OMFS_EXTENT_START);
         next = inode->i_ino;
 
         for (;;) {
@@ -249,6 +264,9 @@ static int omfs_get_block(struct inode *inode, sector_t block,
                 next = be64_to_cpu(oe->e_next);
                 entry = &oe->e_entry;
 
+                if (extent_count > max_extents)
+                        goto out_brelse;
+
                 offset = find_block(inode, entry, block, extent_count, &remain);
                 if (offset > 0) {
                         ret = 0;
@@ -266,6 +284,7 @@ static int omfs_get_block(struct inode *inode, sector_t block,
                 if (!bh)
                         goto out;
                 oe = (struct omfs_extent *) (&bh->b_data[OMFS_EXTENT_CONT]);
+                max_extents = omfs_max_extents(sbi, OMFS_EXTENT_CONT);
         }
         if (create) {
                 ret = omfs_grow_extent(inode, oe, &new_block);
diff --git a/fs/omfs/inode.c b/fs/omfs/inode.c
index a95fe5984f4b..d29047b1b9b0 100644
--- a/fs/omfs/inode.c
+++ b/fs/omfs/inode.c
@@ -232,8 +232,7 @@ struct inode *omfs_iget(struct super_block *sb, ino_t ino)
                 inode->i_mode = S_IFDIR | (S_IRWXUGO & ~sbi->s_dmask);
                 inode->i_op = &omfs_dir_inops;
                 inode->i_fop = &omfs_dir_operations;
-                inode->i_size = be32_to_cpu(oi->i_head.h_body_size) +
-                        sizeof(struct omfs_header);
+                inode->i_size = sbi->s_sys_blocksize;
                 inc_nlink(inode);
                 break;
         case OMFS_FILE:
diff --git a/fs/ubifs/budget.c b/fs/ubifs/budget.c
index d81fb9ed2b8e..154098157473 100644
--- a/fs/ubifs/budget.c
+++ b/fs/ubifs/budget.c
@@ -263,8 +263,8 @@ int ubifs_calc_min_idx_lebs(struct ubifs_info *c)
 
         idx_size = c->old_idx_sz + c->budg_idx_growth + c->budg_uncommitted_idx;
 
-        /* And make sure we have twice the index size of space reserved */
-        idx_size <<= 1;
+        /* And make sure we have thrice the index size of space reserved */
+        idx_size = idx_size + (idx_size << 1);
 
         /*
          * We do not maintain 'old_idx_size' as 'old_idx_lebs'/'old_idx_bytes'
@@ -388,11 +388,11 @@ static int can_use_rp(struct ubifs_info *c)
  * This function makes sure UBIFS has enough free eraseblocks for index growth
  * and data.
  *
- * When budgeting index space, UBIFS reserves twice as more LEBs as the index
+ * When budgeting index space, UBIFS reserves thrice as many LEBs as the index
  * would take if it was consolidated and written to the flash. This guarantees
  * that the "in-the-gaps" commit method always succeeds and UBIFS will always
  * be able to commit dirty index. So this function basically adds amount of
- * budgeted index space to the size of the current index, multiplies this by 2,
+ * budgeted index space to the size of the current index, multiplies this by 3,
  * and makes sure this does not exceed the amount of free eraseblocks.
  *
  * Notes about @c->min_idx_lebs and @c->lst.idx_lebs variables:
@@ -543,8 +543,16 @@ int ubifs_budget_space(struct ubifs_info *c, struct ubifs_budget_req *req)
         int err, idx_growth, data_growth, dd_growth;
         struct retries_info ri;
 
+        ubifs_assert(req->new_page <= 1);
+        ubifs_assert(req->dirtied_page <= 1);
+        ubifs_assert(req->new_dent <= 1);
+        ubifs_assert(req->mod_dent <= 1);
+        ubifs_assert(req->new_ino <= 1);
+        ubifs_assert(req->new_ino_d <= UBIFS_MAX_INO_DATA);
         ubifs_assert(req->dirtied_ino <= 4);
         ubifs_assert(req->dirtied_ino_d <= UBIFS_MAX_INO_DATA * 4);
+        ubifs_assert(!(req->new_ino_d & 7));
+        ubifs_assert(!(req->dirtied_ino_d & 7));
 
         data_growth = calc_data_growth(c, req);
         dd_growth = calc_dd_growth(c, req);
@@ -618,8 +626,16 @@ again:
  */
 void ubifs_release_budget(struct ubifs_info *c, struct ubifs_budget_req *req)
 {
+        ubifs_assert(req->new_page <= 1);
+        ubifs_assert(req->dirtied_page <= 1);
+        ubifs_assert(req->new_dent <= 1);
+        ubifs_assert(req->mod_dent <= 1);
+        ubifs_assert(req->new_ino <= 1);
+        ubifs_assert(req->new_ino_d <= UBIFS_MAX_INO_DATA);
         ubifs_assert(req->dirtied_ino <= 4);
         ubifs_assert(req->dirtied_ino_d <= UBIFS_MAX_INO_DATA * 4);
+        ubifs_assert(!(req->new_ino_d & 7));
+        ubifs_assert(!(req->dirtied_ino_d & 7));
         if (!req->recalculate) {
                 ubifs_assert(req->idx_growth >= 0);
                 ubifs_assert(req->data_growth >= 0);
@@ -647,7 +663,11 @@ void ubifs_release_budget(struct ubifs_info *c, struct ubifs_budget_req *req)
 
         ubifs_assert(c->budg_idx_growth >= 0);
         ubifs_assert(c->budg_data_growth >= 0);
+        ubifs_assert(c->budg_dd_growth >= 0);
         ubifs_assert(c->min_idx_lebs < c->main_lebs);
+        ubifs_assert(!(c->budg_idx_growth & 7));
+        ubifs_assert(!(c->budg_data_growth & 7));
+        ubifs_assert(!(c->budg_dd_growth & 7));
         spin_unlock(&c->space_lock);
 }
 
@@ -686,9 +706,10 @@ void ubifs_convert_page_budget(struct ubifs_info *c)
 void ubifs_release_dirty_inode_budget(struct ubifs_info *c,
                                       struct ubifs_inode *ui)
 {
-        struct ubifs_budget_req req = {.dd_growth = c->inode_budget,
-                                       .dirtied_ino_d = ui->data_len};
+        struct ubifs_budget_req req;
 
+        memset(&req, 0, sizeof(struct ubifs_budget_req));
+        req.dd_growth = c->inode_budget + ALIGN(ui->data_len, 8);
         ubifs_release_budget(c, &req);
 }
 
diff --git a/fs/ubifs/commit.c b/fs/ubifs/commit.c
index 3b516316c9b3..0a6aa2cc78f0 100644
--- a/fs/ubifs/commit.c
+++ b/fs/ubifs/commit.c
@@ -74,6 +74,7 @@ static int do_commit(struct ubifs_info *c)
                         goto out_up;
         }
 
+        c->cmt_no += 1;
         err = ubifs_gc_start_commit(c);
         if (err)
                 goto out_up;
@@ -115,7 +116,7 @@ static int do_commit(struct ubifs_info *c)
                 goto out;
 
         mutex_lock(&c->mst_mutex);
-        c->mst_node->cmt_no      = cpu_to_le64(++c->cmt_no);
+        c->mst_node->cmt_no      = cpu_to_le64(c->cmt_no);
         c->mst_node->log_lnum    = cpu_to_le32(new_ltail_lnum);
         c->mst_node->root_lnum   = cpu_to_le32(zroot.lnum);
         c->mst_node->root_offs   = cpu_to_le32(zroot.offs);
diff --git a/fs/ubifs/debug.c b/fs/ubifs/debug.c
index 4e3aaeba4eca..b9cb77473758 100644
--- a/fs/ubifs/debug.c
+++ b/fs/ubifs/debug.c
@@ -568,8 +568,8 @@ void dbg_dump_budget_req(const struct ubifs_budget_req *req)
 void dbg_dump_lstats(const struct ubifs_lp_stats *lst)
 {
         spin_lock(&dbg_lock);
-        printk(KERN_DEBUG "Lprops statistics: empty_lebs %d, idx_lebs  %d\n",
-               lst->empty_lebs, lst->idx_lebs);
+        printk(KERN_DEBUG "(pid %d) Lprops statistics: empty_lebs %d, "
+               "idx_lebs  %d\n", current->pid, lst->empty_lebs, lst->idx_lebs);
         printk(KERN_DEBUG "\ttaken_empty_lebs %d, total_free %lld, "
                "total_dirty %lld\n", lst->taken_empty_lebs, lst->total_free,
                lst->total_dirty);
@@ -587,8 +587,8 @@ void dbg_dump_budg(struct ubifs_info *c)
         struct ubifs_gced_idx_leb *idx_gc;
 
         spin_lock(&dbg_lock);
-        printk(KERN_DEBUG "Budgeting info: budg_data_growth %lld, "
-               "budg_dd_growth %lld, budg_idx_growth %lld\n",
+        printk(KERN_DEBUG "(pid %d) Budgeting info: budg_data_growth %lld, "
+               "budg_dd_growth %lld, budg_idx_growth %lld\n", current->pid,
                c->budg_data_growth, c->budg_dd_growth, c->budg_idx_growth);
         printk(KERN_DEBUG "\tdata budget sum %lld, total budget sum %lld, "
                "freeable_cnt %d\n", c->budg_data_growth + c->budg_dd_growth,
@@ -634,7 +634,7 @@ void dbg_dump_lprops(struct ubifs_info *c)
         struct ubifs_lprops lp;
         struct ubifs_lp_stats lst;
 
-        printk(KERN_DEBUG "Dumping LEB properties\n");
+        printk(KERN_DEBUG "(pid %d) Dumping LEB properties\n", current->pid);
         ubifs_get_lp_stats(c, &lst);
         dbg_dump_lstats(&lst);
 
@@ -655,7 +655,7 @@ void dbg_dump_leb(const struct ubifs_info *c, int lnum)
         if (dbg_failure_mode)
                 return;
 
-        printk(KERN_DEBUG "Dumping LEB %d\n", lnum);
+        printk(KERN_DEBUG "(pid %d) Dumping LEB %d\n", current->pid, lnum);
 
         sleb = ubifs_scan(c, lnum, 0, c->dbg_buf);
         if (IS_ERR(sleb)) {
@@ -720,8 +720,8 @@ void dbg_dump_heap(struct ubifs_info *c, struct ubifs_lpt_heap *heap, int cat)
 {
         int i;
 
-        printk(KERN_DEBUG "Dumping heap cat %d (%d elements)\n",
-               cat, heap->cnt);
+        printk(KERN_DEBUG "(pid %d) Dumping heap cat %d (%d elements)\n",
+               current->pid, cat, heap->cnt);
         for (i = 0; i < heap->cnt; i++) {
                 struct ubifs_lprops *lprops = heap->arr[i];
 
@@ -736,7 +736,7 @@ void dbg_dump_pnode(struct ubifs_info *c, struct ubifs_pnode *pnode,
 {
         int i;
 
-        printk(KERN_DEBUG "Dumping pnode:\n");
+        printk(KERN_DEBUG "(pid %d) Dumping pnode:\n", current->pid);
         printk(KERN_DEBUG "\taddress %zx parent %zx cnext %zx\n",
                (size_t)pnode, (size_t)parent, (size_t)pnode->cnext);
         printk(KERN_DEBUG "\tflags %lu iip %d level %d num %d\n",
@@ -755,7 +755,7 @@ void dbg_dump_tnc(struct ubifs_info *c)
         int level;
 
         printk(KERN_DEBUG "\n");
-        printk(KERN_DEBUG "Dumping the TNC tree\n");
+        printk(KERN_DEBUG "(pid %d) Dumping the TNC tree\n", current->pid);
         znode = ubifs_tnc_levelorder_next(c->zroot.znode, NULL);
         level = znode->level;
         printk(KERN_DEBUG "== Level %d ==\n", level);
@@ -2208,16 +2208,17 @@ int dbg_leb_read(struct ubi_volume_desc *desc, int lnum, char *buf, int offset,
 int dbg_leb_write(struct ubi_volume_desc *desc, int lnum, const void *buf,
                   int offset, int len, int dtype)
 {
-        int err;
+        int err, failing;
 
         if (in_failure_mode(desc))
                 return -EIO;
-        if (do_fail(desc, lnum, 1))
+        failing = do_fail(desc, lnum, 1);
+        if (failing)
                 cut_data(buf, len);
         err = ubi_leb_write(desc, lnum, buf, offset, len, dtype);
         if (err)
                 return err;
-        if (in_failure_mode(desc))
+        if (failing)
                 return -EIO;
         return 0;
 }
diff --git a/fs/ubifs/debug.h b/fs/ubifs/debug.h
index 3c4f1e93c9e0..50315fc57185 100644
--- a/fs/ubifs/debug.h
+++ b/fs/ubifs/debug.h
@@ -27,7 +27,7 @@
 
 #define UBIFS_DBG(op) op
 
-#define ubifs_assert(expr)  do {                                               \
+#define ubifs_assert(expr) do {                                                \
         if (unlikely(!(expr))) {                                               \
                 printk(KERN_CRIT "UBIFS assert failed in %s at %u (pid %d)\n", \
                        __func__, __LINE__, current->pid);                      \
@@ -73,50 +73,50 @@ const char *dbg_key_str1(const struct ubifs_info *c,
                          const union ubifs_key *key);
 
 /*
- * DBGKEY macros require dbg_lock to be held, which it is in the dbg message
+ * DBGKEY macros require @dbg_lock to be held, which it is in the dbg message
  * macros.
  */
 #define DBGKEY(key) dbg_key_str0(c, (key))
 #define DBGKEY1(key) dbg_key_str1(c, (key))
 
 /* General messages */
-#define dbg_gen(fmt, ...)        dbg_do_msg(UBIFS_MSG_GEN, fmt, ##__VA_ARGS__)
+#define dbg_gen(fmt, ...)   dbg_do_msg(UBIFS_MSG_GEN, fmt, ##__VA_ARGS__)
 
 /* Additional journal messages */
-#define dbg_jnl(fmt, ...)        dbg_do_msg(UBIFS_MSG_JNL, fmt, ##__VA_ARGS__)
+#define dbg_jnl(fmt, ...)   dbg_do_msg(UBIFS_MSG_JNL, fmt, ##__VA_ARGS__)
 
 /* Additional TNC messages */
-#define dbg_tnc(fmt, ...)        dbg_do_msg(UBIFS_MSG_TNC, fmt, ##__VA_ARGS__)
+#define dbg_tnc(fmt, ...)   dbg_do_msg(UBIFS_MSG_TNC, fmt, ##__VA_ARGS__)
 
 /* Additional lprops messages */
-#define dbg_lp(fmt, ...)         dbg_do_msg(UBIFS_MSG_LP, fmt, ##__VA_ARGS__)
+#define dbg_lp(fmt, ...)    dbg_do_msg(UBIFS_MSG_LP, fmt, ##__VA_ARGS__)
 
 /* Additional LEB find messages */
-#define dbg_find(fmt, ...)       dbg_do_msg(UBIFS_MSG_FIND, fmt, ##__VA_ARGS__)
+#define dbg_find(fmt, ...)  dbg_do_msg(UBIFS_MSG_FIND, fmt, ##__VA_ARGS__)
 
 /* Additional mount messages */
-#define dbg_mnt(fmt, ...)        dbg_do_msg(UBIFS_MSG_MNT, fmt, ##__VA_ARGS__)
+#define dbg_mnt(fmt, ...)   dbg_do_msg(UBIFS_MSG_MNT, fmt, ##__VA_ARGS__)
 
 /* Additional I/O messages */
-#define dbg_io(fmt, ...)         dbg_do_msg(UBIFS_MSG_IO, fmt, ##__VA_ARGS__)
+#define dbg_io(fmt, ...)    dbg_do_msg(UBIFS_MSG_IO, fmt, ##__VA_ARGS__)
 
 /* Additional commit messages */
-#define dbg_cmt(fmt, ...)        dbg_do_msg(UBIFS_MSG_CMT, fmt, ##__VA_ARGS__)
+#define dbg_cmt(fmt, ...)   dbg_do_msg(UBIFS_MSG_CMT, fmt, ##__VA_ARGS__)
 
 /* Additional budgeting messages */
-#define dbg_budg(fmt, ...)       dbg_do_msg(UBIFS_MSG_BUDG, fmt, ##__VA_ARGS__)
+#define dbg_budg(fmt, ...)  dbg_do_msg(UBIFS_MSG_BUDG, fmt, ##__VA_ARGS__)
 
 /* Additional log messages */
-#define dbg_log(fmt, ...)        dbg_do_msg(UBIFS_MSG_LOG, fmt, ##__VA_ARGS__)
+#define dbg_log(fmt, ...)   dbg_do_msg(UBIFS_MSG_LOG, fmt, ##__VA_ARGS__)
 
 /* Additional gc messages */
-#define dbg_gc(fmt, ...)         dbg_do_msg(UBIFS_MSG_GC, fmt, ##__VA_ARGS__)
+#define dbg_gc(fmt, ...)    dbg_do_msg(UBIFS_MSG_GC, fmt, ##__VA_ARGS__)
 
 /* Additional scan messages */
-#define dbg_scan(fmt, ...)       dbg_do_msg(UBIFS_MSG_SCAN, fmt, ##__VA_ARGS__)
+#define dbg_scan(fmt, ...)  dbg_do_msg(UBIFS_MSG_SCAN, fmt, ##__VA_ARGS__)
 
 /* Additional recovery messages */
-#define dbg_rcvry(fmt, ...)      dbg_do_msg(UBIFS_MSG_RCVRY, fmt, ##__VA_ARGS__)
+#define dbg_rcvry(fmt, ...) dbg_do_msg(UBIFS_MSG_RCVRY, fmt, ##__VA_ARGS__)
 
 /*
  * Debugging message type flags (must match msg_type_names in debug.c).
@@ -239,34 +239,23 @@ typedef int (*dbg_leaf_callback)(struct ubifs_info *c,
                                  struct ubifs_zbranch *zbr, void *priv);
 typedef int (*dbg_znode_callback)(struct ubifs_info *c,
                                   struct ubifs_znode *znode, void *priv);
-
 int dbg_walk_index(struct ubifs_info *c, dbg_leaf_callback leaf_cb,
                    dbg_znode_callback znode_cb, void *priv);
 
 /* Checking functions */
 
 int dbg_check_lprops(struct ubifs_info *c);
-
 int dbg_old_index_check_init(struct ubifs_info *c, struct ubifs_zbranch *zroot);
 int dbg_check_old_index(struct ubifs_info *c, struct ubifs_zbranch *zroot);
-
 int dbg_check_cats(struct ubifs_info *c);
-
 int dbg_check_ltab(struct ubifs_info *c);
-
 int dbg_check_synced_i_size(struct inode *inode);
-
 int dbg_check_dir_size(struct ubifs_info *c, const struct inode *dir);
-
 int dbg_check_tnc(struct ubifs_info *c, int extra);
-
 int dbg_check_idx_size(struct ubifs_info *c, long long idx_size);
-
 int dbg_check_filesystem(struct ubifs_info *c);
-
 void dbg_check_heap(struct ubifs_info *c, struct ubifs_lpt_heap *heap, int cat,
                     int add_pos);
-
 int dbg_check_lprops(struct ubifs_info *c);
 int dbg_check_lpt_nodes(struct ubifs_info *c, struct ubifs_cnode *cnode,
                         int row, int col);
@@ -329,71 +318,77 @@ static inline int dbg_change(struct ubi_volume_desc *desc, int lnum,
 #else /* !CONFIG_UBIFS_FS_DEBUG */
 
 #define UBIFS_DBG(op)
-#define ubifs_assert(expr)                         ({})
-#define ubifs_assert_cmt_locked(c)
+
+/* Use "if (0)" to make compiler check arguments even if debugging is off */
+#define ubifs_assert(expr)  do {                                               \
+        if (0 && (expr))                                                       \
+                printk(KERN_CRIT "UBIFS assert failed in %s at %u (pid %d)\n", \
+                       __func__, __LINE__, current->pid);                      \
+} while (0)
+
+#define dbg_err(fmt, ...)   do {                                               \
+        if (0)                                                                 \
+                ubifs_err(fmt, ##__VA_ARGS__);                                 \
+} while (0)
+
+#define dbg_msg(fmt, ...) do {                                                 \
+        if (0)                                                                 \
+                printk(KERN_DEBUG "UBIFS DBG (pid %d): %s: " fmt "\n",         \
+                       current->pid, __func__, ##__VA_ARGS__);                 \
+} while (0)
+
 #define dbg_dump_stack()
-#define dbg_err(fmt, ...)                          ({})
-#define dbg_msg(fmt, ...)                          ({})
-#define dbg_key(c, key, fmt, ...)                  ({})
-
-#define dbg_gen(fmt, ...)                          ({})
-#define dbg_jnl(fmt, ...)                          ({})
-#define dbg_tnc(fmt, ...)                          ({})
-#define dbg_lp(fmt, ...)                           ({})
-#define dbg_find(fmt, ...)                         ({})
-#define dbg_mnt(fmt, ...)                          ({})
-#define dbg_io(fmt, ...)                           ({})
-#define dbg_cmt(fmt, ...)                          ({})
-#define dbg_budg(fmt, ...)                         ({})
-#define dbg_log(fmt, ...)                          ({})
-#define dbg_gc(fmt, ...)                           ({})
-#define dbg_scan(fmt, ...)                         ({})
-#define dbg_rcvry(fmt, ...)                        ({})
-
-#define dbg_ntype(type)                            ""
-#define dbg_cstate(cmt_state)                      ""
-#define dbg_get_key_dump(c, key)                   ({})
-#define dbg_dump_inode(c, inode)                   ({})
-#define dbg_dump_node(c, node)                     ({})
-#define dbg_dump_budget_req(req)                   ({})
-#define dbg_dump_lstats(lst)                       ({})
-#define dbg_dump_budg(c)                           ({})
-#define dbg_dump_lprop(c, lp)                      ({})
-#define dbg_dump_lprops(c)                         ({})
-#define dbg_dump_leb(c, lnum)                      ({})
-#define dbg_dump_znode(c, znode)                   ({})
-#define dbg_dump_heap(c, heap, cat)                ({})
-#define dbg_dump_pnode(c, pnode, parent, iip)      ({})
-#define dbg_dump_tnc(c)                            ({})
-#define dbg_dump_index(c)                          ({})
+#define ubifs_assert_cmt_locked(c)
 
-#define dbg_walk_index(c, leaf_cb, znode_cb, priv) 0
+#define dbg_gen(fmt, ...)   dbg_msg(fmt, ##__VA_ARGS__)
+#define dbg_jnl(fmt, ...)   dbg_msg(fmt, ##__VA_ARGS__)
+#define dbg_tnc(fmt, ...)   dbg_msg(fmt, ##__VA_ARGS__)
+#define dbg_lp(fmt, ...)    dbg_msg(fmt, ##__VA_ARGS__)
+#define dbg_find(fmt, ...)  dbg_msg(fmt, ##__VA_ARGS__)
+#define dbg_mnt(fmt, ...)   dbg_msg(fmt, ##__VA_ARGS__)
+#define dbg_io(fmt, ...)    dbg_msg(fmt, ##__VA_ARGS__)
+#define dbg_cmt(fmt, ...)   dbg_msg(fmt, ##__VA_ARGS__)
+#define dbg_budg(fmt, ...)  dbg_msg(fmt, ##__VA_ARGS__)
+#define dbg_log(fmt, ...)   dbg_msg(fmt, ##__VA_ARGS__)
+#define dbg_gc(fmt, ...)    dbg_msg(fmt, ##__VA_ARGS__)
+#define dbg_scan(fmt, ...)  dbg_msg(fmt, ##__VA_ARGS__)
+#define dbg_rcvry(fmt, ...) dbg_msg(fmt, ##__VA_ARGS__)
+
+#define DBGKEY(key)  ((char *)(key))
+#define DBGKEY1(key) ((char *)(key))
+
+#define dbg_ntype(type)                       ""
+#define dbg_cstate(cmt_state)                 ""
+#define dbg_get_key_dump(c, key)              ({})
+#define dbg_dump_inode(c, inode)              ({})
+#define dbg_dump_node(c, node)                ({})
+#define dbg_dump_budget_req(req)              ({})
+#define dbg_dump_lstats(lst)                  ({})
+#define dbg_dump_budg(c)                      ({})
+#define dbg_dump_lprop(c, lp)                 ({})
+#define dbg_dump_lprops(c)                    ({})
+#define dbg_dump_leb(c, lnum)                 ({})
+#define dbg_dump_znode(c, znode)              ({})
+#define dbg_dump_heap(c, heap, cat)           ({})
+#define dbg_dump_pnode(c, pnode, parent, iip) ({})
+#define dbg_dump_tnc(c)                       ({})
+#define dbg_dump_index(c)                     ({})
 
+#define dbg_walk_index(c, leaf_cb, znode_cb, priv) 0
 #define dbg_old_index_check_init(c, zroot)         0
 #define dbg_check_old_index(c, zroot)              0
-
 #define dbg_check_cats(c)                          0
-
 #define dbg_check_ltab(c)                          0
-
 #define dbg_check_synced_i_size(inode)             0
-
 #define dbg_check_dir_size(c, dir)                 0
-
 #define dbg_check_tnc(c, x)                        0
-
 #define dbg_check_idx_size(c, idx_size)            0
-
 #define dbg_check_filesystem(c)                    0
-
 #define dbg_check_heap(c, heap, cat, add_pos)      ({})
-
 #define dbg_check_lprops(c)                        0
 #define dbg_check_lpt_nodes(c, cnode, row, col)    0
-
 #define dbg_force_in_the_gaps_enabled              0
 #define dbg_force_in_the_gaps()                    0
-
 #define dbg_failure_mode                           0
 #define dbg_failure_mode_registration(c)           ({})
 #define dbg_failure_mode_deregistration(c)         ({})
diff --git a/fs/ubifs/dir.c b/fs/ubifs/dir.c
index e90374be7d3b..5c96f1fb7016 100644
--- a/fs/ubifs/dir.c
+++ b/fs/ubifs/dir.c
@@ -165,7 +165,6 @@ struct inode *ubifs_new_inode(struct ubifs_info *c, const struct inode *dir,
         }
 
         inode->i_ino = ++c->highest_inum;
-        inode->i_generation = ++c->vfs_gen;
         /*
          * The creation sequence number remains with this inode for its
          * lifetime. All nodes for this inode have a greater sequence number,
@@ -220,15 +219,7 @@ static struct dentry *ubifs_lookup(struct inode *dir, struct dentry *dentry,
 
         err = ubifs_tnc_lookup_nm(c, &key, dent, &dentry->d_name);
         if (err) {
-                /*
-                 * Do not hash the direntry if parent 'i_nlink' is zero, because
-                 * this has side-effects - '->delete_inode()' call will not be
-                 * called for the parent orphan inode, because 'd_count' of its
-                 * direntry will stay 1 (it'll be negative direntry I guess)
-                 * and prevent 'iput_final()' until the dentry is destroyed due
-                 * to unmount or memory pressure.
-                 */
-                if (err == -ENOENT && dir->i_nlink != 0) {
+                if (err == -ENOENT) {
                         dbg_gen("not found");
                         goto done;
                 }
@@ -525,7 +516,7 @@ static int ubifs_link(struct dentry *old_dentry, struct inode *dir,
         struct ubifs_inode *dir_ui = ubifs_inode(dir);
         int err, sz_change = CALC_DENT_SIZE(dentry->d_name.len);
         struct ubifs_budget_req req = { .new_dent = 1, .dirtied_ino = 2,
-                                        .dirtied_ino_d = ui->data_len };
+                                .dirtied_ino_d = ALIGN(ui->data_len, 8) };
 
         /*
          * Budget request settings: new direntry, changing the target inode,
@@ -727,8 +718,7 @@ static int ubifs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
         struct ubifs_inode *dir_ui = ubifs_inode(dir);
         struct ubifs_info *c = dir->i_sb->s_fs_info;
         int err, sz_change = CALC_DENT_SIZE(dentry->d_name.len);
-        struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1,
-                                        .dirtied_ino_d = 1 };
+        struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1 };
 
         /*
          * Budget request settings: new inode, new direntry and changing parent
@@ -789,7 +779,8 @@ static int ubifs_mknod(struct inode *dir, struct dentry *dentry,
         int sz_change = CALC_DENT_SIZE(dentry->d_name.len);
         int err, devlen = 0;
         struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1,
-                                        .new_ino_d = devlen, .dirtied_ino = 1 };
+                                        .new_ino_d = ALIGN(devlen, 8),
+                                        .dirtied_ino = 1 };
 
         /*
          * Budget request settings: new inode, new direntry and changing parent
@@ -863,7 +854,8 @@ static int ubifs_symlink(struct inode *dir, struct dentry *dentry,
         int err, len = strlen(symname);
         int sz_change = CALC_DENT_SIZE(dentry->d_name.len);
         struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1,
-                                        .new_ino_d = len, .dirtied_ino = 1 };
+                                        .new_ino_d = ALIGN(len, 8),
+                                        .dirtied_ino = 1 };
 
         /*
          * Budget request settings: new inode, new direntry and changing parent
@@ -1012,7 +1004,7 @@ static int ubifs_rename(struct inode *old_dir, struct dentry *old_dentry,
         struct ubifs_budget_req req = { .new_dent = 1, .mod_dent = 1,
                                         .dirtied_ino = 3 };
         struct ubifs_budget_req ino_req = { .dirtied_ino = 1,
-                                .dirtied_ino_d = old_inode_ui->data_len };
+                        .dirtied_ino_d = ALIGN(old_inode_ui->data_len, 8) };
         struct timespec time;
 
         /*
diff --git a/fs/ubifs/file.c b/fs/ubifs/file.c
index 8565e586e533..4071d1cae29f 100644
--- a/fs/ubifs/file.c
+++ b/fs/ubifs/file.c
@@ -890,7 +890,7 @@ static int do_setattr(struct ubifs_info *c, struct inode *inode,
         loff_t new_size = attr->ia_size;
         struct ubifs_inode *ui = ubifs_inode(inode);
         struct ubifs_budget_req req = { .dirtied_ino = 1,
-                                        .dirtied_ino_d = ui->data_len };
+                                .dirtied_ino_d = ALIGN(ui->data_len, 8) };
 
         err = ubifs_budget_space(c, &req);
         if (err)
@@ -941,7 +941,8 @@ int ubifs_setattr(struct dentry *dentry, struct iattr *attr)
         struct inode *inode = dentry->d_inode;
         struct ubifs_info *c = inode->i_sb->s_fs_info;
 
-        dbg_gen("ino %lu, ia_valid %#x", inode->i_ino, attr->ia_valid);
+        dbg_gen("ino %lu, mode %#x, ia_valid %#x",
+                inode->i_ino, inode->i_mode, attr->ia_valid);
         err = inode_change_ok(inode, attr);
         if (err)
                 return err;
@@ -1051,7 +1052,7 @@ static int update_mctime(struct ubifs_info *c, struct inode *inode)
         if (mctime_update_needed(inode, &now)) {
                 int err, release;
                 struct ubifs_budget_req req = { .dirtied_ino = 1,
-                                                .dirtied_ino_d = ui->data_len };
+                                .dirtied_ino_d = ALIGN(ui->data_len, 8) };
 
                 err = ubifs_budget_space(c, &req);
                 if (err)
@@ -1270,6 +1271,7 @@ struct file_operations ubifs_file_operations = {
         .fsync          = ubifs_fsync,
         .unlocked_ioctl = ubifs_ioctl,
         .splice_read    = generic_file_splice_read,
+        .splice_write   = generic_file_splice_write,
 #ifdef CONFIG_COMPAT
         .compat_ioctl   = ubifs_compat_ioctl,
 #endif
diff --git a/fs/ubifs/find.c b/fs/ubifs/find.c
index 10394c548367..adee7b5ddeab 100644
--- a/fs/ubifs/find.c
+++ b/fs/ubifs/find.c
@@ -290,9 +290,14 @@ int ubifs_find_dirty_leb(struct ubifs_info *c, struct ubifs_lprops *ret_lp,
                 idx_lp = idx_heap->arr[0];
                 sum = idx_lp->free + idx_lp->dirty;
                 /*
-                 * Since we reserve twice as more space for the index than it
+                 * Since we reserve thrice as much space for the index than it
                  * actually takes, it does not make sense to pick indexing LEBs
-                 * with less than half LEB of dirty space.
+                 * with less than, say, half LEB of dirty space. May be half is
+                 * not the optimal boundary - this should be tested and
+                 * checked. This boundary should determine how much we use
+                 * in-the-gaps to consolidate the index comparing to how much
+                 * we use garbage collector to consolidate it. The "half"
+                 * criteria just feels to be fine.
                  */
                 if (sum < min_space || sum < c->half_leb_size)
                         idx_lp = NULL;
diff --git a/fs/ubifs/io.c b/fs/ubifs/io.c
index 3374f91b6709..054363f2b207 100644
--- a/fs/ubifs/io.c
+++ b/fs/ubifs/io.c
@@ -54,6 +54,20 @@
 #include "ubifs.h"
 
 /**
+ * ubifs_ro_mode - switch UBIFS to read read-only mode.
+ * @c: UBIFS file-system description object
+ * @err: error code which is the reason of switching to R/O mode
+ */
+void ubifs_ro_mode(struct ubifs_info *c, int err)
+{
+        if (!c->ro_media) {
+                c->ro_media = 1;
+                ubifs_warn("switched to read-only mode, error %d", err);
+                dbg_dump_stack();
+        }
+}
+
+/**
  * ubifs_check_node - check node.
  * @c: UBIFS file-system description object
  * @buf: node to check
diff --git a/fs/ubifs/journal.c b/fs/ubifs/journal.c
index 283155abe5f5..22993f867d19 100644
--- a/fs/ubifs/journal.c
+++ b/fs/ubifs/journal.c
@@ -447,13 +447,11 @@ static int get_dent_type(int mode)
  * @ino: buffer in which to pack inode node
  * @inode: inode to pack
  * @last: indicates the last node of the group
- * @last_reference: non-zero if this is a deletion inode
  */
 static void pack_inode(struct ubifs_info *c, struct ubifs_ino_node *ino,
-                       const struct inode *inode, int last,
-                       int last_reference)
+                       const struct inode *inode, int last)
 {
-        int data_len = 0;
+        int data_len = 0, last_reference = !inode->i_nlink;
         struct ubifs_inode *ui = ubifs_inode(inode);
 
         ino->ch.node_type = UBIFS_INO_NODE;
@@ -596,9 +594,9 @@ int ubifs_jnl_update(struct ubifs_info *c, const struct inode *dir,
         ubifs_prep_grp_node(c, dent, dlen, 0);
 
         ino = (void *)dent + aligned_dlen;
-        pack_inode(c, ino, inode, 0, last_reference);
+        pack_inode(c, ino, inode, 0);
         ino = (void *)ino + aligned_ilen;
-        pack_inode(c, ino, dir, 1, 0);
+        pack_inode(c, ino, dir, 1);
 
         if (last_reference) {
                 err = ubifs_add_orphan(c, inode->i_ino);
@@ -606,6 +604,7 @@ int ubifs_jnl_update(struct ubifs_info *c, const struct inode *dir,
                         release_head(c, BASEHD);
                         goto out_finish;
                 }
+                ui->del_cmtno = c->cmt_no;
         }
 
         err = write_head(c, BASEHD, dent, len, &lnum, &dent_offs, sync);
@@ -750,30 +749,25 @@ out_free:
  * ubifs_jnl_write_inode - flush inode to the journal.
  * @c: UBIFS file-system description object
  * @inode: inode to flush
- * @deletion: inode has been deleted
  *
  * This function writes inode @inode to the journal. If the inode is
  * synchronous, it also synchronizes the write-buffer. Returns zero in case of
  * success and a negative error code in case of failure.
  */
-int ubifs_jnl_write_inode(struct ubifs_info *c, const struct inode *inode,
-                          int deletion)
+int ubifs_jnl_write_inode(struct ubifs_info *c, const struct inode *inode)
 {
-        int err, len, lnum, offs, sync = 0;
+        int err, lnum, offs;
         struct ubifs_ino_node *ino;
         struct ubifs_inode *ui = ubifs_inode(inode);
+        int sync = 0, len = UBIFS_INO_NODE_SZ, last_reference = !inode->i_nlink;
 
-        dbg_jnl("ino %lu%s", inode->i_ino,
-                deletion ? " (last reference)" : "");
-        if (deletion)
-                ubifs_assert(inode->i_nlink == 0);
+        dbg_jnl("ino %lu, nlink %u", inode->i_ino, inode->i_nlink);
 
-        len = UBIFS_INO_NODE_SZ;
         /*
          * If the inode is being deleted, do not write the attached data. No
          * need to synchronize the write-buffer either.
          */
-        if (!deletion) {
+        if (!last_reference) {
                 len += ui->data_len;
                 sync = IS_SYNC(inode);
         }
@@ -786,7 +780,7 @@ int ubifs_jnl_write_inode(struct ubifs_info *c, const struct inode *inode,
         if (err)
                 goto out_free;
 
-        pack_inode(c, ino, inode, 1, deletion);
+        pack_inode(c, ino, inode, 1);
         err = write_head(c, BASEHD, ino, len, &lnum, &offs, sync);
         if (err)
                 goto out_release;
@@ -795,7 +789,7 @@ int ubifs_jnl_write_inode(struct ubifs_info *c, const struct inode *inode,
                                           inode->i_ino);
         release_head(c, BASEHD);
 
-        if (deletion) {
+        if (last_reference) {
                 err = ubifs_tnc_remove_ino(c, inode->i_ino);
                 if (err)
                         goto out_ro;
@@ -828,6 +822,65 @@ out_free:
 }
 
 /**
+ * ubifs_jnl_delete_inode - delete an inode.
+ * @c: UBIFS file-system description object
+ * @inode: inode to delete
+ *
+ * This function deletes inode @inode which includes removing it from orphans,
+ * deleting it from TNC and, in some cases, writing a deletion inode to the
+ * journal.
+ *
+ * When regular file inodes are unlinked or a directory inode is removed, the
+ * 'ubifs_jnl_update()' function writes a corresponding deletion inode and
+ * direntry to the media, and adds the inode to orphans. After this, when the
+ * last reference to this inode has been dropped, this function is called. In
+ * general, it has to write one more deletion inode to the media, because if
+ * a commit happened between 'ubifs_jnl_update()' and
+ * 'ubifs_jnl_delete_inode()', the deletion inode is not in the journal
+ * anymore, and in fact it might not be on the flash anymore, because it might
+ * have been garbage-collected already. And for optimization reasons UBIFS does
+ * not read the orphan area if it has been unmounted cleanly, so it would have
+ * no indication in the journal that there is a deleted inode which has to be
+ * removed from TNC.
+ *
+ * However, if there was no commit between 'ubifs_jnl_update()' and
+ * 'ubifs_jnl_delete_inode()', then there is no need to write the deletion
+ * inode to the media for the second time. And this is quite a typical case.
+ *
+ * This function returns zero in case of success and a negative error code in
+ * case of failure.
+ */
+int ubifs_jnl_delete_inode(struct ubifs_info *c, const struct inode *inode)
+{
+        int err;
+        struct ubifs_inode *ui = ubifs_inode(inode);
+
+        ubifs_assert(inode->i_nlink == 0);
+
+        if (ui->del_cmtno != c->cmt_no)
+                /* A commit happened for sure */
+                return ubifs_jnl_write_inode(c, inode);
+
+        down_read(&c->commit_sem);
+        /*
+         * Check commit number again, because the first test has been done
+         * without @c->commit_sem, so a commit might have happened.
+         */
+        if (ui->del_cmtno != c->cmt_no) {
+                up_read(&c->commit_sem);
+                return ubifs_jnl_write_inode(c, inode);
+        }
+
+        err = ubifs_tnc_remove_ino(c, inode->i_ino);
+        if (err)
+                ubifs_ro_mode(c, err);
+        else
+                ubifs_delete_orphan(c, inode->i_ino);
+        up_read(&c->commit_sem);
+        return err;
+}
+
+/**
  * ubifs_jnl_rename - rename a directory entry.
  * @c: UBIFS file-system description object
  * @old_dir: parent inode of directory entry to rename
@@ -917,16 +970,16 @@ int ubifs_jnl_rename(struct ubifs_info *c, const struct inode *old_dir,
 
         p = (void *)dent2 + aligned_dlen2;
         if (new_inode) {
-                pack_inode(c, p, new_inode, 0, last_reference);
+                pack_inode(c, p, new_inode, 0);
                 p += ALIGN(ilen, 8);
         }
 
         if (!move)
-                pack_inode(c, p, old_dir, 1, 0);
+                pack_inode(c, p, old_dir, 1);
         else {
-                pack_inode(c, p, old_dir, 0, 0);
+                pack_inode(c, p, old_dir, 0);
                 p += ALIGN(plen, 8);
-                pack_inode(c, p, new_dir, 1, 0);
+                pack_inode(c, p, new_dir, 1);
         }
 
         if (last_reference) {
@@ -935,6 +988,7 @@ int ubifs_jnl_rename(struct ubifs_info *c, const struct inode *old_dir,
                         release_head(c, BASEHD);
                         goto out_finish;
                 }
+                new_ui->del_cmtno = c->cmt_no;
         }
 
         err = write_head(c, BASEHD, dent, len, &lnum, &offs, sync);
@@ -1131,7 +1185,7 @@ int ubifs_jnl_truncate(struct ubifs_info *c, const struct inode *inode,
         if (err)
                 goto out_free;
 
-        pack_inode(c, ino, inode, 0, 0);
+        pack_inode(c, ino, inode, 0);
         ubifs_prep_grp_node(c, trun, UBIFS_TRUN_NODE_SZ, dlen ? 0 : 1);
         if (dlen)
                 ubifs_prep_grp_node(c, dn, dlen, 1);
@@ -1251,9 +1305,9 @@ int ubifs_jnl_delete_xattr(struct ubifs_info *c, const struct inode *host,
         ubifs_prep_grp_node(c, xent, xlen, 0);
 
         ino = (void *)xent + aligned_xlen;
-        pack_inode(c, ino, inode, 0, 1);
+        pack_inode(c, ino, inode, 0);
         ino = (void *)ino + UBIFS_INO_NODE_SZ;
-        pack_inode(c, ino, host, 1, 0);
+        pack_inode(c, ino, host, 1);
 
         err = write_head(c, BASEHD, xent, len, &lnum, &xent_offs, sync);
         if (!sync && !err)
@@ -1320,7 +1374,7 @@ int ubifs_jnl_change_xattr(struct ubifs_info *c, const struct inode *inode,
                            const struct inode *host)
 {
         int err, len1, len2, aligned_len, aligned_len1, lnum, offs;
-        struct ubifs_inode *host_ui = ubifs_inode(inode);
+        struct ubifs_inode *host_ui = ubifs_inode(host);
         struct ubifs_ino_node *ino;
         union ubifs_key key;
         int sync = IS_DIRSYNC(host);
@@ -1344,8 +1398,8 @@ int ubifs_jnl_change_xattr(struct ubifs_info *c, const struct inode *inode,
         if (err)
                 goto out_free;
 
-        pack_inode(c, ino, host, 0, 0);
-        pack_inode(c, (void *)ino + aligned_len1, inode, 1, 0);
+        pack_inode(c, ino, host, 0);
+        pack_inode(c, (void *)ino + aligned_len1, inode, 1);
 
         err = write_head(c, BASEHD, ino, aligned_len, &lnum, &offs, 0);
         if (!sync && !err) {
diff --git a/fs/ubifs/log.c b/fs/ubifs/log.c
index 36857b9ed59e..3e0aa7367556 100644
--- a/fs/ubifs/log.c
+++ b/fs/ubifs/log.c
@@ -317,6 +317,8 @@ int ubifs_add_bud_to_log(struct ubifs_info *c, int jhead, int lnum, int offs)
         return 0;
 
 out_unlock:
+        if (err != -EAGAIN)
+                ubifs_ro_mode(c, err);
         mutex_unlock(&c->log_mutex);
         kfree(ref);
         kfree(bud);
@@ -410,7 +412,7 @@ int ubifs_log_start_commit(struct ubifs_info *c, int *ltail_lnum)
                 return -ENOMEM;
 
         cs->ch.node_type = UBIFS_CS_NODE;
-        cs->cmt_no = cpu_to_le64(c->cmt_no + 1);
+        cs->cmt_no = cpu_to_le64(c->cmt_no);
         ubifs_prepare_node(c, cs, UBIFS_CS_NODE_SZ, 0);
 
         /*
diff --git a/fs/ubifs/misc.h b/fs/ubifs/misc.h
index 4beccfc256d2..87dabf9fe742 100644
--- a/fs/ubifs/misc.h
+++ b/fs/ubifs/misc.h
@@ -80,20 +80,6 @@ static inline struct ubifs_inode *ubifs_inode(const struct inode *inode)
 }
 
 /**
- * ubifs_ro_mode - switch UBIFS to read read-only mode.
- * @c: UBIFS file-system description object
- * @err: error code which is the reason of switching to R/O mode
- */
-static inline void ubifs_ro_mode(struct ubifs_info *c, int err)
-{
-        if (!c->ro_media) {
-                c->ro_media = 1;
-                ubifs_warn("switched to read-only mode, error %d", err);
-                dbg_dump_stack();
-        }
-}
-
-/**
  * ubifs_compr_present - check if compressor was compiled in.
  * @compr_type: compressor type to check
  *
@@ -322,7 +308,7 @@ static inline long long ubifs_reported_space(const struct ubifs_info *c,
 {
         int divisor, factor;
 
-        divisor = UBIFS_MAX_DATA_NODE_SZ + (c->max_idx_node_sz << 1);
+        divisor = UBIFS_MAX_DATA_NODE_SZ + (c->max_idx_node_sz * 3);
         factor = UBIFS_MAX_DATA_NODE_SZ - UBIFS_DATA_NODE_SZ;
         do_div(free, divisor);
 
diff --git a/fs/ubifs/orphan.c b/fs/ubifs/orphan.c
index 3afeb9242c6a..02d3462f4d3e 100644
--- a/fs/ubifs/orphan.c
+++ b/fs/ubifs/orphan.c
@@ -310,10 +310,10 @@ static int write_orph_node(struct ubifs_info *c, int atomic)
         c->cmt_orphans -= cnt;
         spin_unlock(&c->orphan_lock);
         if (c->cmt_orphans)
-                orph->cmt_no = cpu_to_le64(c->cmt_no + 1);
+                orph->cmt_no = cpu_to_le64(c->cmt_no);
         else
                 /* Mark the last node of the commit */
-                orph->cmt_no = cpu_to_le64((c->cmt_no + 1) | (1ULL << 63));
+                orph->cmt_no = cpu_to_le64((c->cmt_no) | (1ULL << 63));
         ubifs_assert(c->ohead_offs + len <= c->leb_size);
         ubifs_assert(c->ohead_lnum >= c->orph_first);
         ubifs_assert(c->ohead_lnum <= c->orph_last);
diff --git a/fs/ubifs/super.c b/fs/ubifs/super.c
index ca1e2d4e03cc..f71e6b8822c4 100644
--- a/fs/ubifs/super.c
+++ b/fs/ubifs/super.c
@@ -30,7 +30,6 @@
 #include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/ctype.h>
-#include <linux/random.h>
 #include <linux/kthread.h>
 #include <linux/parser.h>
 #include <linux/seq_file.h>
@@ -149,7 +148,7 @@ struct inode *ubifs_iget(struct super_block *sb, unsigned long inum)
         if (err)
                 goto out_invalid;
 
-        /* Disable readahead */
+        /* Disable read-ahead */
         inode->i_mapping->backing_dev_info = &c->bdi;
 
         switch (inode->i_mode & S_IFMT) {
@@ -278,7 +277,7 @@ static void ubifs_destroy_inode(struct inode *inode)
  */
 static int ubifs_write_inode(struct inode *inode, int wait)
 {
-        int err;
+        int err = 0;
         struct ubifs_info *c = inode->i_sb->s_fs_info;
         struct ubifs_inode *ui = ubifs_inode(inode);
 
@@ -299,10 +298,18 @@ static int ubifs_write_inode(struct inode *inode, int wait)
                 return 0;
         }
 
-        dbg_gen("inode %lu", inode->i_ino);
-        err = ubifs_jnl_write_inode(c, inode, 0);
-        if (err)
-                ubifs_err("can't write inode %lu, error %d", inode->i_ino, err);
+        /*
+         * As an optimization, do not write orphan inodes to the media just
+         * because this is not needed.
+         */
+        dbg_gen("inode %lu, mode %#x, nlink %u",
+                inode->i_ino, (int)inode->i_mode, inode->i_nlink);
+        if (inode->i_nlink) {
+                err = ubifs_jnl_write_inode(c, inode);
+                if (err)
+                        ubifs_err("can't write inode %lu, error %d",
+                                  inode->i_ino, err);
+        }
 
         ui->dirty = 0;
         mutex_unlock(&ui->ui_mutex);
@@ -314,8 +321,9 @@ static void ubifs_delete_inode(struct inode *inode)
 {
         int err;
         struct ubifs_info *c = inode->i_sb->s_fs_info;
+        struct ubifs_inode *ui = ubifs_inode(inode);
 
-        if (ubifs_inode(inode)->xattr)
+        if (ui->xattr)
                 /*
                  * Extended attribute inode deletions are fully handled in
                  * 'ubifs_removexattr()'. These inodes are special and have
@@ -323,7 +331,7 @@ static void ubifs_delete_inode(struct inode *inode)
                  */
                 goto out;
 
-        dbg_gen("inode %lu", inode->i_ino);
+        dbg_gen("inode %lu, mode %#x", inode->i_ino, (int)inode->i_mode);
         ubifs_assert(!atomic_read(&inode->i_count));
         ubifs_assert(inode->i_nlink == 0);
 
@@ -331,15 +339,19 @@ static void ubifs_delete_inode(struct inode *inode)
         if (is_bad_inode(inode))
                 goto out;
 
-        ubifs_inode(inode)->ui_size = inode->i_size = 0;
-        err = ubifs_jnl_write_inode(c, inode, 1);
+        ui->ui_size = inode->i_size = 0;
+        err = ubifs_jnl_delete_inode(c, inode);
         if (err)
                 /*
                  * Worst case we have a lost orphan inode wasting space, so a
-                 * simple error message is ok here.
+                 * simple error message is OK here.
                  */
-                ubifs_err("can't write inode %lu, error %d", inode->i_ino, err);
+                ubifs_err("can't delete inode %lu, error %d",
+                          inode->i_ino, err);
+
 out:
+        if (ui->dirty)
+                ubifs_release_dirty_inode_budget(c, ui);
         clear_inode(inode);
 }
 
@@ -1122,8 +1134,8 @@ static int mount_ubifs(struct ubifs_info *c)
         if (err)
                 goto out_infos;
 
-        ubifs_msg("mounted UBI device %d, volume %d", c->vi.ubi_num,
-                  c->vi.vol_id);
+        ubifs_msg("mounted UBI device %d, volume %d, name \"%s\"",
+                  c->vi.ubi_num, c->vi.vol_id, c->vi.name);
         if (mounted_read_only)
                 ubifs_msg("mounted read-only");
         x = (long long)c->main_lebs * c->leb_size;
@@ -1469,6 +1481,7 @@ static void ubifs_put_super(struct super_block *sb)
          */
         ubifs_assert(atomic_long_read(&c->dirty_pg_cnt) == 0);
         ubifs_assert(c->budg_idx_growth == 0);
+        ubifs_assert(c->budg_dd_growth == 0);
         ubifs_assert(c->budg_data_growth == 0);
 
         /*
@@ -1657,7 +1670,6 @@ static int ubifs_fill_super(struct super_block *sb, void *data, int silent)
         INIT_LIST_HEAD(&c->orph_new);
 
         c->highest_inum = UBIFS_FIRST_INO;
-        get_random_bytes(&c->vfs_gen, sizeof(int));
         c->lhead_lnum = c->ltail_lnum = UBIFS_LOG_LNUM;
 
         ubi_get_volume_info(ubi, &c->vi);
@@ -1671,10 +1683,10 @@ static int ubifs_fill_super(struct super_block *sb, void *data, int silent)
         }
 
         /*
-         * UBIFS provids 'backing_dev_info' in order to disable readahead. For
+         * UBIFS provides 'backing_dev_info' in order to disable read-ahead. For
          * UBIFS, I/O is not deferred, it is done immediately in readpage,
          * which means the user would have to wait not just for their own I/O
-         * but the readahead I/O as well i.e. completely pointless.
+         * but the read-ahead I/O as well i.e. completely pointless.
          *
          * Read-ahead will be disabled because @c->bdi.ra_pages is 0.
          */
diff --git a/fs/ubifs/tnc_commit.c b/fs/ubifs/tnc_commit.c
index 8117e65ba2e9..8ac76b1c2d55 100644
--- a/fs/ubifs/tnc_commit.c
+++ b/fs/ubifs/tnc_commit.c
@@ -372,26 +372,25 @@ static int layout_in_gaps(struct ubifs_info *c, int cnt)
                 written = layout_leb_in_gaps(c, p);
                 if (written < 0) {
                         err = written;
-                        if (err == -ENOSPC) {
-                                if (!dbg_force_in_the_gaps_enabled) {
-                                        /*
-                                         * Do not print scary warnings if the
-                                         * debugging option which forces
-                                         * in-the-gaps is enabled.
-                                         */
-                                        ubifs_err("out of space");
-                                        spin_lock(&c->space_lock);
-                                        dbg_dump_budg(c);
-                                        spin_unlock(&c->space_lock);
-                                        dbg_dump_lprops(c);
-                                }
-                                /* Try to commit anyway */
-                                err = 0;
-                                break;
+                        if (err != -ENOSPC) {
+                                kfree(c->gap_lebs);
+                                c->gap_lebs = NULL;
+                                return err;
                         }
-                        kfree(c->gap_lebs);
-                        c->gap_lebs = NULL;
-                        return err;
+                        if (!dbg_force_in_the_gaps_enabled) {
+                                /*
+                                 * Do not print scary warnings if the debugging
+                                 * option which forces in-the-gaps is enabled.
+                                 */
+                                ubifs_err("out of space");
+                                spin_lock(&c->space_lock);
+                                dbg_dump_budg(c);
+                                spin_unlock(&c->space_lock);
+                                dbg_dump_lprops(c);
+                        }
+                        /* Try to commit anyway */
+                        err = 0;
+                        break;
                 }
                 p++;
                 cnt -= written;
diff --git a/fs/ubifs/ubifs-media.h b/fs/ubifs/ubifs-media.h
index 0cc7da9bed47..bd2121f3426e 100644
--- a/fs/ubifs/ubifs-media.h
+++ b/fs/ubifs/ubifs-media.h
@@ -228,10 +228,10 @@ enum {
 /* Minimum number of orphan area logical eraseblocks */
 #define UBIFS_MIN_ORPH_LEBS 1
 /*
- * Minimum number of main area logical eraseblocks (buds, 2 for the index, 1
+ * Minimum number of main area logical eraseblocks (buds, 3 for the index, 1
  * for GC, 1 for deletions, and at least 1 for committed data).
  */
-#define UBIFS_MIN_MAIN_LEBS (UBIFS_MIN_BUD_LEBS + 5)
+#define UBIFS_MIN_MAIN_LEBS (UBIFS_MIN_BUD_LEBS + 6)
 
 /* Minimum number of logical eraseblocks */
 #define UBIFS_MIN_LEB_CNT (UBIFS_SB_LEBS + UBIFS_MST_LEBS + \
diff --git a/fs/ubifs/ubifs.h b/fs/ubifs/ubifs.h
index e4f89f271827..d7f706f7a302 100644
--- a/fs/ubifs/ubifs.h
+++ b/fs/ubifs/ubifs.h
@@ -20,8 +20,6 @@
  *          Adrian Hunter
  */
 
-/* Implementation version 0.7 */
-
 #ifndef __UBIFS_H__
 #define __UBIFS_H__
 
@@ -322,6 +320,8 @@ struct ubifs_gced_idx_leb {
  * struct ubifs_inode - UBIFS in-memory inode description.
  * @vfs_inode: VFS inode description object
  * @creat_sqnum: sequence number at time of creation
+ * @del_cmtno: commit number corresponding to the time the inode was deleted,
+ *             protected by @c->commit_sem;
  * @xattr_size: summarized size of all extended attributes in bytes
  * @xattr_cnt: count of extended attributes this inode has
  * @xattr_names: sum of lengths of all extended attribute names belonging to
@@ -373,6 +373,7 @@ struct ubifs_gced_idx_leb {
 struct ubifs_inode {
         struct inode vfs_inode;
         unsigned long long creat_sqnum;
+        unsigned long long del_cmtno;
         unsigned int xattr_size;
         unsigned int xattr_cnt;
         unsigned int xattr_names;
@@ -779,7 +780,7 @@ struct ubifs_compressor {
 /**
  * struct ubifs_budget_req - budget requirements of an operation.
  *
- * @fast: non-zero if the budgeting should try to aquire budget quickly and
+ * @fast: non-zero if the budgeting should try to acquire budget quickly and
  *        should not try to call write-back
  * @recalculate: non-zero if @idx_growth, @data_growth, and @dd_growth fields
  *               have to be re-calculated
@@ -805,21 +806,31 @@ struct ubifs_compressor {
  * An inode may contain 4KiB of data at max., thus the widths of @new_ino_d
  * is 13 bits, and @dirtied_ino_d - 15, because up to 4 inodes may be made
  * dirty by the re-name operation.
+ *
+ * Note, UBIFS aligns node lengths to 8-bytes boundary, so the requester has to
+ * make sure the amount of inode data which contribute to @new_ino_d and
+ * @dirtied_ino_d fields are aligned.
  */
 struct ubifs_budget_req {
         unsigned int fast:1;
         unsigned int recalculate:1;
+#ifndef UBIFS_DEBUG
         unsigned int new_page:1;
         unsigned int dirtied_page:1;
         unsigned int new_dent:1;
         unsigned int mod_dent:1;
         unsigned int new_ino:1;
         unsigned int new_ino_d:13;
-#ifndef UBIFS_DEBUG
         unsigned int dirtied_ino:4;
         unsigned int dirtied_ino_d:15;
 #else
         /* Not bit-fields to check for overflows */
+        unsigned int new_page;
+        unsigned int dirtied_page;
+        unsigned int new_dent;
+        unsigned int mod_dent;
+        unsigned int new_ino;
+        unsigned int new_ino_d;
         unsigned int dirtied_ino;
         unsigned int dirtied_ino_d;
 #endif
@@ -860,13 +871,13 @@ struct ubifs_mount_opts {
  * struct ubifs_info - UBIFS file-system description data structure
  * (per-superblock).
  * @vfs_sb: VFS @struct super_block object
- * @bdi: backing device info object to make VFS happy and disable readahead
+ * @bdi: backing device info object to make VFS happy and disable read-ahead
  *
  * @highest_inum: highest used inode number
- * @vfs_gen: VFS inode generation counter
  * @max_sqnum: current global sequence number
- * @cmt_no: commit number (last successfully completed commit)
- * @cnt_lock: protects @highest_inum, @vfs_gen, and @max_sqnum counters
+ * @cmt_no: commit number of the last successfully completed commit, protected
+ *          by @commit_sem
+ * @cnt_lock: protects @highest_inum and @max_sqnum counters
  * @fmt_version: UBIFS on-flash format version
  * @uuid: UUID from super block
  *
@@ -1103,7 +1114,6 @@ struct ubifs_info {
         struct backing_dev_info bdi;
 
         ino_t highest_inum;
-        unsigned int vfs_gen;
         unsigned long long max_sqnum;
         unsigned long long cmt_no;
         spinlock_t cnt_lock;
@@ -1346,6 +1356,7 @@ extern struct backing_dev_info ubifs_backing_dev_info;
 extern struct ubifs_compressor *ubifs_compressors[UBIFS_COMPR_TYPES_CNT];
 
 /* io.c */
+void ubifs_ro_mode(struct ubifs_info *c, int err);
 int ubifs_wbuf_write_nolock(struct ubifs_wbuf *wbuf, void *buf, int len);
 int ubifs_wbuf_seek_nolock(struct ubifs_wbuf *wbuf, int lnum, int offs,
                            int dtype);
@@ -1399,8 +1410,8 @@ int ubifs_jnl_update(struct ubifs_info *c, const struct inode *dir,
                      int deletion, int xent);
 int ubifs_jnl_write_data(struct ubifs_info *c, const struct inode *inode,
                          const union ubifs_key *key, const void *buf, int len);
-int ubifs_jnl_write_inode(struct ubifs_info *c, const struct inode *inode,
-                          int last_reference);
+int ubifs_jnl_write_inode(struct ubifs_info *c, const struct inode *inode);
+int ubifs_jnl_delete_inode(struct ubifs_info *c, const struct inode *inode);
 int ubifs_jnl_rename(struct ubifs_info *c, const struct inode *old_dir,
                      const struct dentry *old_dentry,
                      const struct inode *new_dir,
diff --git a/fs/ubifs/xattr.c b/fs/ubifs/xattr.c
index 1388a078e1a9..649bec78b645 100644
--- a/fs/ubifs/xattr.c
+++ b/fs/ubifs/xattr.c
@@ -61,7 +61,7 @@
 
 /*
  * Limit the number of extended attributes per inode so that the total size
- * (xattr_size) is guaranteeded to fit in an 'unsigned int'.
+ * (@xattr_size) is guaranteeded to fit in an 'unsigned int'.
  */
 #define MAX_XATTRS_PER_INODE 65535
 
@@ -103,14 +103,14 @@ static int create_xattr(struct ubifs_info *c, struct inode *host,
         struct inode *inode;
         struct ubifs_inode *ui, *host_ui = ubifs_inode(host);
         struct ubifs_budget_req req = { .new_ino = 1, .new_dent = 1,
-                                        .new_ino_d = size, .dirtied_ino = 1,
-                                        .dirtied_ino_d = host_ui->data_len};
+                                .new_ino_d = ALIGN(size, 8), .dirtied_ino = 1,
+                                .dirtied_ino_d = ALIGN(host_ui->data_len, 8) };
 
         if (host_ui->xattr_cnt >= MAX_XATTRS_PER_INODE)
                 return -ENOSPC;
         /*
          * Linux limits the maximum size of the extended attribute names list
-         * to %XATTR_LIST_MAX. This means we should not allow creating more*
+         * to %XATTR_LIST_MAX. This means we should not allow creating more
          * extended attributes if the name list becomes larger. This limitation
          * is artificial for UBIFS, though.
          */
@@ -128,7 +128,6 @@ static int create_xattr(struct ubifs_info *c, struct inode *host,
                 goto out_budg;
         }
 
-        mutex_lock(&host_ui->ui_mutex);
         /* Re-define all operations to be "nothing" */
         inode->i_mapping->a_ops = &none_address_operations;
         inode->i_op = &none_inode_operations;
@@ -141,23 +140,19 @@ static int create_xattr(struct ubifs_info *c, struct inode *host,
         ui->data = kmalloc(size, GFP_NOFS);
         if (!ui->data) {
                 err = -ENOMEM;
-                goto out_unlock;
+                goto out_free;
         }
-
         memcpy(ui->data, value, size);
+        inode->i_size = ui->ui_size = size;
+        ui->data_len = size;
+
+        mutex_lock(&host_ui->ui_mutex);
         host->i_ctime = ubifs_current_time(host);
         host_ui->xattr_cnt += 1;
         host_ui->xattr_size += CALC_DENT_SIZE(nm->len);
         host_ui->xattr_size += CALC_XATTR_BYTES(size);
         host_ui->xattr_names += nm->len;
 
-        /*
-         * We do not use i_size_write() because nobody can race with us as we
-         * are holding host @host->i_mutex - every xattr operation for this
-         * inode is serialized by it.
-         */
-        inode->i_size = ui->ui_size = size;
-        ui->data_len = size;
         err = ubifs_jnl_update(c, host, nm, inode, 0, 1);
         if (err)
                 goto out_cancel;
@@ -172,8 +167,8 @@ out_cancel:
         host_ui->xattr_cnt -= 1;
         host_ui->xattr_size -= CALC_DENT_SIZE(nm->len);
         host_ui->xattr_size -= CALC_XATTR_BYTES(size);
-out_unlock:
         mutex_unlock(&host_ui->ui_mutex);
+out_free:
         make_bad_inode(inode);
         iput(inode);
 out_budg:
@@ -200,29 +195,28 @@ static int change_xattr(struct ubifs_info *c, struct inode *host,
         struct ubifs_inode *host_ui = ubifs_inode(host);
         struct ubifs_inode *ui = ubifs_inode(inode);
         struct ubifs_budget_req req = { .dirtied_ino = 2,
-                                .dirtied_ino_d = size + host_ui->data_len };
+                .dirtied_ino_d = ALIGN(size, 8) + ALIGN(host_ui->data_len, 8) };
 
         ubifs_assert(ui->data_len == inode->i_size);
         err = ubifs_budget_space(c, &req);
         if (err)
                 return err;
 
-        mutex_lock(&host_ui->ui_mutex);
-        host->i_ctime = ubifs_current_time(host);
-        host_ui->xattr_size -= CALC_XATTR_BYTES(ui->data_len);
-        host_ui->xattr_size += CALC_XATTR_BYTES(size);
-
         kfree(ui->data);
         ui->data = kmalloc(size, GFP_NOFS);
         if (!ui->data) {
                 err = -ENOMEM;
-                goto out_unlock;
+                goto out_free;
         }
-
         memcpy(ui->data, value, size);
         inode->i_size = ui->ui_size = size;
         ui->data_len = size;
 
+        mutex_lock(&host_ui->ui_mutex);
+        host->i_ctime = ubifs_current_time(host);
+        host_ui->xattr_size -= CALC_XATTR_BYTES(ui->data_len);
+        host_ui->xattr_size += CALC_XATTR_BYTES(size);
+
         /*
          * It is important to write the host inode after the xattr inode
          * because if the host inode gets synchronized (via 'fsync()'), then
@@ -240,9 +234,9 @@ static int change_xattr(struct ubifs_info *c, struct inode *host,
 out_cancel:
         host_ui->xattr_size -= CALC_XATTR_BYTES(size);
         host_ui->xattr_size += CALC_XATTR_BYTES(ui->data_len);
-        make_bad_inode(inode);
-out_unlock:
         mutex_unlock(&host_ui->ui_mutex);
+        make_bad_inode(inode);
+out_free:
         ubifs_release_budget(c, &req);
         return err;
 }
@@ -312,6 +306,7 @@ int ubifs_setxattr(struct dentry *dentry, const char *name,
 
         dbg_gen("xattr '%s', host ino %lu ('%.*s'), size %zd", name,
                 host->i_ino, dentry->d_name.len, dentry->d_name.name, size);
+        ubifs_assert(mutex_is_locked(&host->i_mutex));
 
         if (size > UBIFS_MAX_INO_DATA)
                 return -ERANGE;
@@ -384,7 +379,6 @@ ssize_t ubifs_getxattr(struct dentry *dentry, const char *name, void *buf,
         if (!xent)
                 return -ENOMEM;
 
-        mutex_lock(&host->i_mutex);
         xent_key_init(c, &key, host->i_ino, &nm);
         err = ubifs_tnc_lookup_nm(c, &key, xent, &nm);
         if (err) {
@@ -419,7 +413,6 @@ ssize_t ubifs_getxattr(struct dentry *dentry, const char *name, void *buf,
 out_iput:
         iput(inode);
 out_unlock:
-        mutex_unlock(&host->i_mutex);
         kfree(xent);
         return err;
 }
@@ -449,8 +442,6 @@ ssize_t ubifs_listxattr(struct dentry *dentry, char *buffer, size_t size)
                 return -ERANGE;
 
         lowest_xent_key(c, &key, host->i_ino);
-
-        mutex_lock(&host->i_mutex);
         while (1) {
                 int type;
 
@@ -479,7 +470,6 @@ ssize_t ubifs_listxattr(struct dentry *dentry, char *buffer, size_t size)
                 pxent = xent;
                 key_read(c, &xent->key, &key);
         }
-        mutex_unlock(&host->i_mutex);
 
         kfree(pxent);
         if (err != -ENOENT) {
@@ -497,8 +487,8 @@ static int remove_xattr(struct ubifs_info *c, struct inode *host,
         int err;
         struct ubifs_inode *host_ui = ubifs_inode(host);
         struct ubifs_inode *ui = ubifs_inode(inode);
-        struct ubifs_budget_req req = { .dirtied_ino = 1, .mod_dent = 1,
-                                        .dirtied_ino_d = host_ui->data_len };
+        struct ubifs_budget_req req = { .dirtied_ino = 2, .mod_dent = 1,
+                                .dirtied_ino_d = ALIGN(host_ui->data_len, 8) };
 
         ubifs_assert(ui->data_len == inode->i_size);
 
diff --git a/include/asm-mips/kexec.h b/include/asm-mips/kexec.h
index cdbab43b7d3a..4314892aaebb 100644
--- a/include/asm-mips/kexec.h
+++ b/include/asm-mips/kexec.h
@@ -16,7 +16,7 @@
  /* Maximum address we can use for the control code buffer */
 #define KEXEC_CONTROL_MEMORY_LIMIT (0x20000000)
 
-#define KEXEC_CONTROL_CODE_SIZE 4096
+#define KEXEC_CONTROL_PAGE_SIZE 4096
 
 /* The native architecture */
 #define KEXEC_ARCH KEXEC_ARCH_MIPS
diff --git a/include/asm-x86/kexec.h b/include/asm-x86/kexec.h
index c0e52a14fd4d..4246ab7dc988 100644
--- a/include/asm-x86/kexec.h
+++ b/include/asm-x86/kexec.h
@@ -41,6 +41,10 @@
 # define PAGES_NR               17
 #endif
 
+#ifdef CONFIG_X86_32
+# define KEXEC_CONTROL_CODE_MAX_SIZE    2048
+#endif
+
 #ifndef __ASSEMBLY__
 
 #include <linux/string.h>
@@ -63,7 +67,7 @@
 /* Maximum address we can use for the control code buffer */
 # define KEXEC_CONTROL_MEMORY_LIMIT TASK_SIZE
 
-# define KEXEC_CONTROL_CODE_SIZE        4096
+# define KEXEC_CONTROL_PAGE_SIZE        4096
 
 /* The native architecture */
 # define KEXEC_ARCH KEXEC_ARCH_386
@@ -79,7 +83,7 @@
 # define KEXEC_CONTROL_MEMORY_LIMIT     (0xFFFFFFFFFFUL)
 
 /* Allocate one page for the pdp and the second for the code */
-# define KEXEC_CONTROL_CODE_SIZE  (4096UL + 4096UL)
+# define KEXEC_CONTROL_PAGE_SIZE  (4096UL + 4096UL)
 
 /* The native architecture */
 # define KEXEC_ARCH KEXEC_ARCH_X86_64
diff --git a/include/asm-x86/mman.h b/include/asm-x86/mman.h
index c1682b542daf..90bc4108a4fd 100644
--- a/include/asm-x86/mman.h
+++ b/include/asm-x86/mman.h
@@ -12,6 +12,7 @@
 #define MAP_NORESERVE   0x4000          /* don't check for reservations */
 #define MAP_POPULATE    0x8000          /* populate (prefault) pagetables */
 #define MAP_NONBLOCK    0x10000         /* do not block on IO */
+#define MAP_STACK       0x20000         /* give out an address that is best suited for process/thread stacks */
 
 #define MCL_CURRENT     1               /* lock all current mappings */
 #define MCL_FUTURE      2               /* lock all future mappings */
diff --git a/include/linux/completion.h b/include/linux/completion.h
index 57faa60de9bd..02ef8835999c 100644
--- a/include/linux/completion.h
+++ b/include/linux/completion.h
@@ -49,6 +49,8 @@ extern unsigned long wait_for_completion_timeout(struct completion *x,
                                                    unsigned long timeout);
 extern unsigned long wait_for_completion_interruptible_timeout(
                         struct completion *x, unsigned long timeout);
+extern bool try_wait_for_completion(struct completion *x);
+extern bool completion_done(struct completion *x);
 
 extern void complete(struct completion *);
 extern void complete_all(struct completion *);
@@ -56,48 +58,4 @@ extern void complete_all(struct completion *);
 #define INIT_COMPLETION(x)      ((x).done = 0)
 
 
-/**
- *      try_wait_for_completion - try to decrement a completion without blocking
- *      @x:     completion structure
- *
- *      Returns: 0 if a decrement cannot be done without blocking
- *               1 if a decrement succeeded.
- *
- *      If a completion is being used as a counting completion,
- *      attempt to decrement the counter without blocking. This
- *      enables us to avoid waiting if the resource the completion
- *      is protecting is not available.
- */
-static inline bool try_wait_for_completion(struct completion *x)
-{
-        int ret = 1;
-
-        spin_lock_irq(&x->wait.lock);
-        if (!x->done)
-                ret = 0;
-        else
-                x->done--;
-        spin_unlock_irq(&x->wait.lock);
-        return ret;
-}
-
-/**
- *      completion_done - Test to see if a completion has any waiters
- *      @x:     completion structure
- *
- *      Returns: 0 if there are waiters (wait_for_completion() in progress)
- *               1 if there are no waiters.
- *
- */
-static inline bool completion_done(struct completion *x)
-{
-        int ret = 1;
-
-        spin_lock_irq(&x->wait.lock);
-        if (!x->done)
-                ret = 0;
-        spin_unlock_irq(&x->wait.lock);
-        return ret;
-}
-
 #endif
diff --git a/include/linux/ftrace.h b/include/linux/ftrace.h
index f368d041e02d..bb384068272e 100644
--- a/include/linux/ftrace.h
+++ b/include/linux/ftrace.h
@@ -98,6 +98,27 @@ static inline void tracer_disable(void)
 #endif
 }
 
+/* Ftrace disable/restore without lock. Some synchronization mechanism
+ * must be used to prevent ftrace_enabled to be changed between
+ * disable/restore. */
+static inline int __ftrace_enabled_save(void)
+{
+#ifdef CONFIG_FTRACE
+        int saved_ftrace_enabled = ftrace_enabled;
+        ftrace_enabled = 0;
+        return saved_ftrace_enabled;
+#else
+        return 0;
+#endif
+}
+
+static inline void __ftrace_enabled_restore(int enabled)
+{
+#ifdef CONFIG_FTRACE
+        ftrace_enabled = enabled;
+#endif
+}
+
 #ifdef CONFIG_FRAME_POINTER
 /* TODO: need to fix this for ARM */
 # define CALLER_ADDR0 ((unsigned long)__builtin_return_address(0))
diff --git a/include/linux/kexec.h b/include/linux/kexec.h
index 32110cede64f..17f76fc05173 100644
--- a/include/linux/kexec.h
+++ b/include/linux/kexec.h
@@ -25,8 +25,8 @@
 #error KEXEC_CONTROL_MEMORY_LIMIT not defined
 #endif
 
-#ifndef KEXEC_CONTROL_CODE_SIZE
-#error KEXEC_CONTROL_CODE_SIZE not defined
+#ifndef KEXEC_CONTROL_PAGE_SIZE
+#error KEXEC_CONTROL_PAGE_SIZE not defined
 #endif
 
 #ifndef KEXEC_ARCH
diff --git a/include/linux/reboot.h b/include/linux/reboot.h
index b93b541cf111..988e55fe649b 100644
--- a/include/linux/reboot.h
+++ b/include/linux/reboot.h
@@ -59,6 +59,7 @@ extern void machine_crash_shutdown(struct pt_regs *);
  * Architecture independent implemenations of sys_reboot commands.
  */
 
+extern void kernel_restart_prepare(char *cmd);
 extern void kernel_restart(char *cmd);
 extern void kernel_halt(void);
 extern void kernel_power_off(void);
diff --git a/include/linux/suspend.h b/include/linux/suspend.h
index c63435095970..2ce8207686e2 100644
--- a/include/linux/suspend.h
+++ b/include/linux/suspend.h
@@ -217,11 +217,11 @@ struct platform_hibernation_ops {
 #ifdef CONFIG_HIBERNATION
 /* kernel/power/snapshot.c */
 extern void __register_nosave_region(unsigned long b, unsigned long e, int km);
-static inline void register_nosave_region(unsigned long b, unsigned long e)
+static inline void __init register_nosave_region(unsigned long b, unsigned long e)
 {
         __register_nosave_region(b, e, 0);
 }
-static inline void register_nosave_region_late(unsigned long b, unsigned long e)
+static inline void __init register_nosave_region_late(unsigned long b, unsigned long e)
 {
         __register_nosave_region(b, e, 1);
 }
diff --git a/include/linux/tty.h b/include/linux/tty.h
index e3579cb086e0..0cbec74ec086 100644
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -331,6 +331,8 @@ extern int tty_write_room(struct tty_struct *tty);
 extern void tty_driver_flush_buffer(struct tty_struct *tty);
 extern void tty_throttle(struct tty_struct *tty);
 extern void tty_unthrottle(struct tty_struct *tty);
+extern int tty_do_resize(struct tty_struct *tty, struct tty_struct *real_tty,
+                                                struct winsize *ws);
 
 extern int is_current_pgrp_orphaned(void);
 extern struct pid *tty_get_pgrp(struct tty_struct *tty);
diff --git a/include/linux/tty_driver.h b/include/linux/tty_driver.h
index e1065ac0d922..16d27944c321 100644
--- a/include/linux/tty_driver.h
+++ b/include/linux/tty_driver.h
@@ -168,6 +168,18 @@
  *
  *      Optional: If not provided then the write method is called under
  *      the atomic write lock to keep it serialized with the ldisc.
+ *
+ * int (*resize)(struct tty_struct *tty, struct tty_struct *real_tty,
+ *                              unsigned int rows, unsigned int cols);
+ *
+ *      Called when a termios request is issued which changes the
+ *      requested terminal geometry.
+ *
+ *      Optional: the default action is to update the termios structure
+ *      without error. This is usually the correct behaviour. Drivers should
+ *      not force errors here if they are not resizable objects (eg a serial
+ *      line). See tty_do_resize() if you need to wrap the standard method
+ *      in your own logic - the usual case.
  */
 
 #include <linux/fs.h>
@@ -206,6 +218,8 @@ struct tty_operations {
         int (*tiocmget)(struct tty_struct *tty, struct file *file);
         int (*tiocmset)(struct tty_struct *tty, struct file *file,
                         unsigned int set, unsigned int clear);
+        int (*resize)(struct tty_struct *tty, struct tty_struct *real_tty,
+                                struct winsize *ws);
 #ifdef CONFIG_CONSOLE_POLL
         int (*poll_init)(struct tty_driver *driver, int line, char *options);
         int (*poll_get_char)(struct tty_driver *driver, int line);
diff --git a/include/linux/vt_kern.h b/include/linux/vt_kern.h
index 1c78d56c57e5..1cbd0a7db4e6 100644
--- a/include/linux/vt_kern.h
+++ b/include/linux/vt_kern.h
@@ -35,7 +35,6 @@ extern int fg_console, last_console, want_console;
 int vc_allocate(unsigned int console);
 int vc_cons_allocated(unsigned int console);
 int vc_resize(struct vc_data *vc, unsigned int cols, unsigned int lines);
-int vc_lock_resize(struct vc_data *vc, unsigned int cols, unsigned int lines);
 void vc_deallocate(unsigned int console);
 void reset_palette(struct vc_data *vc);
 void do_blank_screen(int entering_gfx);
diff --git a/kernel/kexec.c b/kernel/kexec.c
index c8a4370e2a34..59f3f0df35d4 100644
--- a/kernel/kexec.c
+++ b/kernel/kexec.c
@@ -12,7 +12,7 @@
 #include <linux/slab.h>
 #include <linux/fs.h>
 #include <linux/kexec.h>
-#include <linux/spinlock.h>
+#include <linux/mutex.h>
 #include <linux/list.h>
 #include <linux/highmem.h>
 #include <linux/syscalls.h>
@@ -77,7 +77,7 @@ int kexec_should_crash(struct task_struct *p)
  *
  * The code for the transition from the current kernel to the
  * the new kernel is placed in the control_code_buffer, whose size
- * is given by KEXEC_CONTROL_CODE_SIZE.  In the best case only a single
+ * is given by KEXEC_CONTROL_PAGE_SIZE.  In the best case only a single
  * page of memory is necessary, but some architectures require more.
  * Because this memory must be identity mapped in the transition from
  * virtual to physical addresses it must live in the range
@@ -242,7 +242,7 @@ static int kimage_normal_alloc(struct kimage **rimage, unsigned long entry,
          */
         result = -ENOMEM;
         image->control_code_page = kimage_alloc_control_pages(image,
-                                           get_order(KEXEC_CONTROL_CODE_SIZE));
+                                           get_order(KEXEC_CONTROL_PAGE_SIZE));
         if (!image->control_code_page) {
                 printk(KERN_ERR "Could not allocate control_code_buffer\n");
                 goto out;
@@ -317,7 +317,7 @@ static int kimage_crash_alloc(struct kimage **rimage, unsigned long entry,
          */
         result = -ENOMEM;
         image->control_code_page = kimage_alloc_control_pages(image,
-                                           get_order(KEXEC_CONTROL_CODE_SIZE));
+                                           get_order(KEXEC_CONTROL_PAGE_SIZE));
         if (!image->control_code_page) {
                 printk(KERN_ERR "Could not allocate control_code_buffer\n");
                 goto out;
@@ -924,19 +924,14 @@ static int kimage_load_segment(struct kimage *image,
  */
 struct kimage *kexec_image;
 struct kimage *kexec_crash_image;
-/*
- * A home grown binary mutex.
- * Nothing can wait so this mutex is safe to use
- * in interrupt context :)
- */
-static int kexec_lock;
+
+static DEFINE_MUTEX(kexec_mutex);
 
 asmlinkage long sys_kexec_load(unsigned long entry, unsigned long nr_segments,
                                 struct kexec_segment __user *segments,
                                 unsigned long flags)
 {
         struct kimage **dest_image, *image;
-        int locked;
         int result;
 
         /* We only trust the superuser with rebooting the system. */
@@ -972,8 +967,7 @@ asmlinkage long sys_kexec_load(unsigned long entry, unsigned long nr_segments,
          *
          * KISS: always take the mutex.
          */
-        locked = xchg(&kexec_lock, 1);
-        if (locked)
+        if (!mutex_trylock(&kexec_mutex))
                 return -EBUSY;
 
         dest_image = &kexec_image;
@@ -1015,8 +1009,7 @@ asmlinkage long sys_kexec_load(unsigned long entry, unsigned long nr_segments,
         image = xchg(dest_image, image);
 
 out:
-        locked = xchg(&kexec_lock, 0); /* Release the mutex */
-        BUG_ON(!locked);
+        mutex_unlock(&kexec_mutex);
         kimage_free(image);
 
         return result;
@@ -1063,10 +1056,7 @@ asmlinkage long compat_sys_kexec_load(unsigned long entry,
 
 void crash_kexec(struct pt_regs *regs)
 {
-        int locked;
-
-
-        /* Take the kexec_lock here to prevent sys_kexec_load
+        /* Take the kexec_mutex here to prevent sys_kexec_load
          * running on one cpu from replacing the crash kernel
          * we are using after a panic on a different cpu.
          *
@@ -1074,8 +1064,7 @@ void crash_kexec(struct pt_regs *regs)
          * of memory the xchg(&kexec_crash_image) would be
          * sufficient.  But since I reuse the memory...
          */
-        locked = xchg(&kexec_lock, 1);
-        if (!locked) {
+        if (mutex_trylock(&kexec_mutex)) {
                 if (kexec_crash_image) {
                         struct pt_regs fixed_regs;
                         crash_setup_regs(&fixed_regs, regs);
@@ -1083,8 +1072,7 @@ void crash_kexec(struct pt_regs *regs)
                         machine_crash_shutdown(&fixed_regs);
                         machine_kexec(kexec_crash_image);
                 }
-                locked = xchg(&kexec_lock, 0);
-                BUG_ON(!locked);
+                mutex_unlock(&kexec_mutex);
         }
 }
 
@@ -1426,25 +1414,23 @@ static int __init crash_save_vmcoreinfo_init(void)
 
 module_init(crash_save_vmcoreinfo_init)
 
-/**
- *      kernel_kexec - reboot the system
- *
- *      Move into place and start executing a preloaded standalone
- *      executable.  If nothing was preloaded return an error.
+/*
+ * Move into place and start executing a preloaded standalone
+ * executable.  If nothing was preloaded return an error.
  */
 int kernel_kexec(void)
 {
         int error = 0;
 
-        if (xchg(&kexec_lock, 1))
+        if (!mutex_trylock(&kexec_mutex))
                 return -EBUSY;
         if (!kexec_image) {
                 error = -EINVAL;
                 goto Unlock;
         }
 
-        if (kexec_image->preserve_context) {
 #ifdef CONFIG_KEXEC_JUMP
+        if (kexec_image->preserve_context) {
                 mutex_lock(&pm_mutex);
                 pm_prepare_console();
                 error = freeze_processes();
@@ -1459,6 +1445,7 @@ int kernel_kexec(void)
                 error = disable_nonboot_cpus();
                 if (error)
                         goto Resume_devices;
+                device_pm_lock();
                 local_irq_disable();
                 /* At this point, device_suspend() has been called,
                  * but *not* device_power_down(). We *must*
@@ -1470,26 +1457,22 @@ int kernel_kexec(void)
                 error = device_power_down(PMSG_FREEZE);
                 if (error)
                         goto Enable_irqs;
-                save_processor_state();
+        } else
 #endif
-        } else {
-                blocking_notifier_call_chain(&reboot_notifier_list,
-                                             SYS_RESTART, NULL);
-                system_state = SYSTEM_RESTART;
-                device_shutdown();
-                sysdev_shutdown();
+        {
+                kernel_restart_prepare(NULL);
                 printk(KERN_EMERG "Starting new kernel\n");
                 machine_shutdown();
         }
 
         machine_kexec(kexec_image);
 
-        if (kexec_image->preserve_context) {
 #ifdef CONFIG_KEXEC_JUMP
-                restore_processor_state();
+        if (kexec_image->preserve_context) {
                 device_power_up(PMSG_RESTORE);
  Enable_irqs:
                 local_irq_enable();
+                device_pm_unlock();
                 enable_nonboot_cpus();
  Resume_devices:
                 device_resume(PMSG_RESTORE);
@@ -1499,11 +1482,10 @@ int kernel_kexec(void)
  Restore_console:
                 pm_restore_console();
                 mutex_unlock(&pm_mutex);
-#endif
         }
+#endif
 
  Unlock:
-        xchg(&kexec_lock, 0);
-
+        mutex_unlock(&kexec_mutex);
         return error;
 }
diff --git a/kernel/sched.c b/kernel/sched.c
index d601fb0406ca..95e6ad3c231d 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -4669,6 +4669,52 @@ int __sched wait_for_completion_killable(struct completion *x)
 }
 EXPORT_SYMBOL(wait_for_completion_killable);
 
+/**
+ *      try_wait_for_completion - try to decrement a completion without blocking
+ *      @x:     completion structure
+ *
+ *      Returns: 0 if a decrement cannot be done without blocking
+ *               1 if a decrement succeeded.
+ *
+ *      If a completion is being used as a counting completion,
+ *      attempt to decrement the counter without blocking. This
+ *      enables us to avoid waiting if the resource the completion
+ *      is protecting is not available.
+ */
+bool try_wait_for_completion(struct completion *x)
+{
+        int ret = 1;
+
+        spin_lock_irq(&x->wait.lock);
+        if (!x->done)
+                ret = 0;
+        else
+                x->done--;
+        spin_unlock_irq(&x->wait.lock);
+        return ret;
+}
+EXPORT_SYMBOL(try_wait_for_completion);
+
+/**
+ *      completion_done - Test to see if a completion has any waiters
+ *      @x:     completion structure
+ *
+ *      Returns: 0 if there are waiters (wait_for_completion() in progress)
+ *               1 if there are no waiters.
+ *
+ */
+bool completion_done(struct completion *x)
+{
+        int ret = 1;
+
+        spin_lock_irq(&x->wait.lock);
+        if (!x->done)
+                ret = 0;
+        spin_unlock_irq(&x->wait.lock);
+        return ret;
+}
+EXPORT_SYMBOL(completion_done);
+
 static long __sched
 sleep_on_common(wait_queue_head_t *q, int state, long timeout)
 {
diff --git a/kernel/sys.c b/kernel/sys.c
index c01858090a98..3dacb00a7f76 100644
--- a/kernel/sys.c
+++ b/kernel/sys.c
@@ -274,7 +274,7 @@ void emergency_restart(void)
 }
 EXPORT_SYMBOL_GPL(emergency_restart);
 
-static void kernel_restart_prepare(char *cmd)
+void kernel_restart_prepare(char *cmd)
 {
         blocking_notifier_call_chain(&reboot_notifier_list, SYS_RESTART, cmd);
         system_state = SYSTEM_RESTART;
diff --git a/mm/bootmem.c b/mm/bootmem.c
index 4af15d0340ad..e023c68b0255 100644
--- a/mm/bootmem.c
+++ b/mm/bootmem.c
@@ -473,7 +473,7 @@ find_block:
                                 goto find_block;
                         }
 
-                if (bdata->last_end_off &&
+                if (bdata->last_end_off & (PAGE_SIZE - 1) &&
                                 PFN_DOWN(bdata->last_end_off) + 1 == sidx)
                         start_off = ALIGN(bdata->last_end_off, align);
                 else
diff --git a/sound/pci/Kconfig b/sound/pci/Kconfig
index f7d95b224a98..31f52d3fc21f 100644
--- a/sound/pci/Kconfig
+++ b/sound/pci/Kconfig
@@ -845,7 +845,7 @@ config SND_VIRTUOSO
         select SND_OXYGEN_LIB
         help
           Say Y here to include support for sound cards based on the
-          Asus AV100/AV200 chips, i.e., Xonar D2, DX and D2X.
+          Asus AV100/AV200 chips, i.e., Xonar D1, DX, D2 and D2X.
 
           To compile this driver as a module, choose M here: the module
           will be called snd-virtuoso.
diff --git a/sound/pci/oxygen/virtuoso.c b/sound/pci/oxygen/virtuoso.c
index 9a2c16bf94e0..01d7b75f9182 100644
--- a/sound/pci/oxygen/virtuoso.c
+++ b/sound/pci/oxygen/virtuoso.c
@@ -36,15 +36,15 @@
  */
 
 /*
- * Xonar DX
- * --------
+ * Xonar D1/DX
+ * -----------
  *
  * CMI8788:
  *
  * I²C <-> CS4398 (front)
  *     <-> CS4362A (surround, center/LFE, back)
  *
- * GPI 0 <- external power present
+ * GPI 0 <- external power present (DX only)
  *
  * GPIO 0 -> enable output to speakers
  * GPIO 1 -> enable front panel I/O
@@ -96,6 +96,7 @@ MODULE_PARM_DESC(enable, "enable card");
 enum {
         MODEL_D2,
         MODEL_D2X,
+        MODEL_D1,
         MODEL_DX,
 };
 
@@ -103,6 +104,7 @@ static struct pci_device_id xonar_ids[] __devinitdata = {
         { OXYGEN_PCI_SUBID(0x1043, 0x8269), .driver_data = MODEL_D2 },
         { OXYGEN_PCI_SUBID(0x1043, 0x8275), .driver_data = MODEL_DX },
         { OXYGEN_PCI_SUBID(0x1043, 0x82b7), .driver_data = MODEL_D2X },
+        { OXYGEN_PCI_SUBID(0x1043, 0x834f), .driver_data = MODEL_D1 },
         { }
 };
 MODULE_DEVICE_TABLE(pci, xonar_ids);
@@ -313,15 +315,12 @@ static void cs43xx_init(struct oxygen *chip)
         cs4362a_write(chip, 0x01, CS4362A_CPEN);
 }
 
-static void xonar_dx_init(struct oxygen *chip)
+static void xonar_d1_init(struct oxygen *chip)
 {
         struct xonar_data *data = chip->model_data;
 
         data->anti_pop_delay = 800;
         data->output_enable_bit = GPIO_DX_OUTPUT_ENABLE;
-        data->ext_power_reg = OXYGEN_GPI_DATA;
-        data->ext_power_int_reg = OXYGEN_GPI_INTERRUPT_MASK;
-        data->ext_power_bit = GPI_DX_EXT_POWER;
         data->cs4398_fm = CS4398_FM_SINGLE | CS4398_DEM_NONE | CS4398_DIF_LJUST;
         data->cs4362a_fm = CS4362A_FM_SINGLE |
                 CS4362A_ATAPI_B_R | CS4362A_ATAPI_A_L;
@@ -345,6 +344,16 @@ static void xonar_dx_init(struct oxygen *chip)
         snd_component_add(chip->card, "CS5361");
 }
 
+static void xonar_dx_init(struct oxygen *chip)
+{
+        struct xonar_data *data = chip->model_data;
+
+        data->ext_power_reg = OXYGEN_GPI_DATA;
+        data->ext_power_int_reg = OXYGEN_GPI_INTERRUPT_MASK;
+        data->ext_power_bit = GPI_DX_EXT_POWER;
+        xonar_d1_init(chip);
+}
+
 static void xonar_cleanup(struct oxygen *chip)
 {
         struct xonar_data *data = chip->model_data;
@@ -352,7 +361,7 @@ static void xonar_cleanup(struct oxygen *chip)
         oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA, data->output_enable_bit);
 }
 
-static void xonar_dx_cleanup(struct oxygen *chip)
+static void xonar_d1_cleanup(struct oxygen *chip)
 {
         xonar_cleanup(chip);
         cs4362a_write(chip, 0x01, CS4362A_PDN | CS4362A_CPEN);
@@ -365,7 +374,7 @@ static void xonar_d2_resume(struct oxygen *chip)
         xonar_enable_output(chip);
 }
 
-static void xonar_dx_resume(struct oxygen *chip)
+static void xonar_d1_resume(struct oxygen *chip)
 {
         cs43xx_init(chip);
         xonar_enable_output(chip);
@@ -513,7 +522,7 @@ static const struct snd_kcontrol_new front_panel_switch = {
         .put = front_panel_put,
 };
 
-static void xonar_dx_ac97_switch(struct oxygen *chip,
+static void xonar_d1_ac97_switch(struct oxygen *chip,
                                  unsigned int reg, unsigned int mute)
 {
         if (reg == AC97_LINE) {
@@ -536,7 +545,7 @@ static int xonar_d2_control_filter(struct snd_kcontrol_new *template)
         return 0;
 }
 
-static int xonar_dx_control_filter(struct snd_kcontrol_new *template)
+static int xonar_d1_control_filter(struct snd_kcontrol_new *template)
 {
         if (!strncmp(template->name, "CD Capture ", 11))
                 return 1; /* no CD input */
@@ -548,7 +557,7 @@ static int xonar_mixer_init(struct oxygen *chip)
         return snd_ctl_add(chip->card, snd_ctl_new1(&alt_switch, chip));
 }
 
-static int xonar_dx_mixer_init(struct oxygen *chip)
+static int xonar_d1_mixer_init(struct oxygen *chip)
 {
         return snd_ctl_add(chip->card, snd_ctl_new1(&front_panel_switch, chip));
 }
@@ -615,23 +624,51 @@ static const struct oxygen_model xonar_models[] = {
                 .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
                 .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
         },
+        [MODEL_D1] = {
+                .shortname = "Xonar D1",
+                .longname = "Asus Virtuoso 100",
+                .chip = "AV200",
+                .owner = THIS_MODULE,
+                .init = xonar_d1_init,
+                .control_filter = xonar_d1_control_filter,
+                .mixer_init = xonar_d1_mixer_init,
+                .cleanup = xonar_d1_cleanup,
+                .suspend = xonar_d1_cleanup,
+                .resume = xonar_d1_resume,
+                .set_dac_params = set_cs43xx_params,
+                .set_adc_params = set_cs53x1_params,
+                .update_dac_volume = update_cs43xx_volume,
+                .update_dac_mute = update_cs43xx_mute,
+                .ac97_switch = xonar_d1_ac97_switch,
+                .dac_tlv = cs4362a_db_scale,
+                .model_data_size = sizeof(struct xonar_data),
+                .pcm_dev_cfg = PLAYBACK_0_TO_I2S |
+                               PLAYBACK_1_TO_SPDIF |
+                               CAPTURE_0_FROM_I2S_2,
+                .dac_channels = 8,
+                .dac_volume_min = 0,
+                .dac_volume_max = 127,
+                .function_flags = OXYGEN_FUNCTION_2WIRE,
+                .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
+                .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
+        },
         [MODEL_DX] = {
                 .shortname = "Xonar DX",
                 .longname = "Asus Virtuoso 100",
                 .chip = "AV200",
                 .owner = THIS_MODULE,
                 .init = xonar_dx_init,
-                .control_filter = xonar_dx_control_filter,
-                .mixer_init = xonar_dx_mixer_init,
-                .cleanup = xonar_dx_cleanup,
-                .suspend = xonar_dx_cleanup,
-                .resume = xonar_dx_resume,
+                .control_filter = xonar_d1_control_filter,
+                .mixer_init = xonar_d1_mixer_init,
+                .cleanup = xonar_d1_cleanup,
+                .suspend = xonar_d1_cleanup,
+                .resume = xonar_d1_resume,
                 .set_dac_params = set_cs43xx_params,
                 .set_adc_params = set_cs53x1_params,
                 .update_dac_volume = update_cs43xx_volume,
                 .update_dac_mute = update_cs43xx_mute,
                 .gpio_changed = xonar_gpio_changed,
-                .ac97_switch = xonar_dx_ac97_switch,
+                .ac97_switch = xonar_d1_ac97_switch,
                 .dac_tlv = cs4362a_db_scale,
                 .model_data_size = sizeof(struct xonar_data),
                 .pcm_dev_cfg = PLAYBACK_0_TO_I2S |
diff --git a/sound/soc/codecs/wm8990.c b/sound/soc/codecs/wm8990.c
index 3ecce5168e94..e44153fa38de 100644
--- a/sound/soc/codecs/wm8990.c
+++ b/sound/soc/codecs/wm8990.c
@@ -82,7 +82,7 @@ static const u16 wm8990_reg[] = {
         0x0003,     /* R35 - ClassD1 */
         0x0000,     /* R36 */
         0x0100,     /* R37 - ClassD3 */
-        0x0000,     /* R38 */
+        0x0079,     /* R38 - ClassD4 */
         0x0000,     /* R39 - Input Mixer1 */
         0x0000,     /* R40 - Input Mixer2 */
         0x0000,     /* R41 - Input Mixer3 */
@@ -311,11 +311,15 @@ SOC_SINGLE("Speaker Mode Switch", WM8990_CLASSD1,
         WM8990_CDMODE_BIT, 1, 0),
 
 SOC_SINGLE("Speaker Output Attenuation Volume", WM8990_SPEAKER_VOLUME,
-        WM8990_SPKVOL_SHIFT, WM8990_SPKVOL_MASK, 0),
+        WM8990_SPKATTN_SHIFT, WM8990_SPKATTN_MASK, 0),
 SOC_SINGLE("Speaker DC Boost Volume", WM8990_CLASSD3,
         WM8990_DCGAIN_SHIFT, WM8990_DCGAIN_MASK, 0),
 SOC_SINGLE("Speaker AC Boost Volume", WM8990_CLASSD3,
         WM8990_ACGAIN_SHIFT, WM8990_ACGAIN_MASK, 0),
+SOC_SINGLE_TLV("Speaker Volume", WM8990_CLASSD4,
+        WM8990_SPKVOL_SHIFT, WM8990_SPKVOL_MASK, 0, out_pga_tlv),
+SOC_SINGLE("Speaker ZC Switch", WM8990_CLASSD4,
+        WM8990_SPKZC_SHIFT, WM8990_SPKZC_MASK, 0),
 
 SOC_WM899X_OUTPGA_SINGLE_R_TLV("Left DAC Digital Volume",
         WM8990_LEFT_DAC_DIGITAL_VOLUME,
@@ -920,7 +924,7 @@ static const struct snd_soc_dapm_route audio_map[] = {
         {"SPKMIX", "SPKMIX Left Mixer PGA Switch", "LOPGA"},
         {"SPKMIX", "SPKMIX Right Mixer PGA Switch", "ROPGA"},
         {"SPKMIX", "SPKMIX Right DAC Switch", "Right DAC"},
-        {"SPKMIX", "SPKMIX Left DAC Switch", "Right DAC"},
+        {"SPKMIX", "SPKMIX Left DAC Switch", "Left DAC"},
 
         /* LONMIX */
         {"LONMIX", "LONMIX Left Mixer PGA Switch", "LOPGA"},
diff --git a/sound/soc/codecs/wm8990.h b/sound/soc/codecs/wm8990.h
index 6bea57485283..0a08325d5443 100644
--- a/sound/soc/codecs/wm8990.h
+++ b/sound/soc/codecs/wm8990.h
@@ -54,6 +54,7 @@
 #define WM8990_SPEAKER_VOLUME                   0x22
 #define WM8990_CLASSD1                          0x23
 #define WM8990_CLASSD3                          0x25
+#define WM8990_CLASSD4                          0x26
 #define WM8990_INPUT_MIXER1                     0x27
 #define WM8990_INPUT_MIXER2                     0x28
 #define WM8990_INPUT_MIXER3                     0x29
@@ -528,8 +529,8 @@
 /*
  * R34 (0x22) - Speaker Volume
  */
-#define WM8990_SPKVOL_MASK                      0x0003  /* SPKVOL - [1:0] */
-#define WM8990_SPKVOL_SHIFT                     0
+#define WM8990_SPKATTN_MASK                      0x0003  /* SPKATTN - [1:0] */
+#define WM8990_SPKATTN_SHIFT                     0
 
 /*
  * R35 (0x23) - ClassD1
@@ -544,6 +545,15 @@
 #define WM8990_DCGAIN_SHIFT                     3
 #define WM8990_ACGAIN_MASK                      0x0007  /* ACGAIN - [2:0] */
 #define WM8990_ACGAIN_SHIFT                     0
+
+/*
+ * R38 (0x26) - ClassD4
+ */
+#define WM8990_SPKZC_MASK                       0x0001  /* SPKZC */
+#define WM8990_SPKZC_SHIFT                           7  /* SPKZC */
+#define WM8990_SPKVOL_MASK                      0x007F  /* SPKVOL - [6:0] */
+#define WM8990_SPKVOL_SHIFT                          0  /* SPKVOL - [6:0] */
+
 /*
  * R39 (0x27) - Input Mixer1
  */