124 files changed, 8572 insertions, 3210 deletions

diff --git a/Documentation/ABI/testing/sysfs-driver-samsung-laptop b/Documentation/ABI/testing/sysfs-driver-samsung-laptop
new file mode 100644
index 000000000000..0a810231aad4
--- /dev/null
+++ b/Documentation/ABI/testing/sysfs-driver-samsung-laptop
@@ -0,0 +1,19 @@
+What:           /sys/devices/platform/samsung/performance_level
+Date:           January 1, 2010
+KernelVersion:  2.6.33
+Contact:        Greg Kroah-Hartman <gregkh@suse.de>
+Description:    Some Samsung laptops have different "performance levels"
+                that are can be modified by a function key, and by this
+                sysfs file.  These values don't always make a whole lot
+                of sense, but some users like to modify them to keep
+                their fans quiet at all costs.  Reading from this file
+                will show the current performance level.  Writing to the
+                file can change this value.
+                        Valid options:
+                                "silent"
+                                "normal"
+                                "overclock"
+                Note that not all laptops support all of these options.
+                Specifically, not all support the "overclock" option,
+                and it's still unknown if this value even changes
+                anything, other than making the user feel a bit better.
diff --git a/Documentation/ABI/testing/sysfs-platform-asus-wmi b/Documentation/ABI/testing/sysfs-platform-asus-wmi
new file mode 100644
index 000000000000..2e7df91620de
--- /dev/null
+++ b/Documentation/ABI/testing/sysfs-platform-asus-wmi
@@ -0,0 +1,31 @@
+What:           /sys/devices/platform/<platform>/cpufv
+Date:           Oct 2010
+KernelVersion:  2.6.37
+Contact:        "Corentin Chary" <corentincj@iksaif.net>
+Description:
+                Change CPU clock configuration (write-only).
+                There are three available clock configuration:
+                    * 0 -> Super Performance Mode
+                    * 1 -> High Performance Mode
+                    * 2 -> Power Saving Mode
+
+What:           /sys/devices/platform/<platform>/camera
+Date:           Jan 2010
+KernelVersion:  2.6.39
+Contact:        "Corentin Chary" <corentincj@iksaif.net>
+Description:
+                Control the camera. 1 means on, 0 means off.
+
+What:           /sys/devices/platform/<platform>/cardr
+Date:           Jan 2010
+KernelVersion:  2.6.39
+Contact:        "Corentin Chary" <corentincj@iksaif.net>
+Description:
+                Control the card reader. 1 means on, 0 means off.
+
+What:           /sys/devices/platform/<platform>/touchpad
+Date:           Jan 2010
+KernelVersion:  2.6.39
+Contact:        "Corentin Chary" <corentincj@iksaif.net>
+Description:
+                Control the card touchpad. 1 means on, 0 means off.
diff --git a/Documentation/ABI/testing/sysfs-platform-eeepc-wmi b/Documentation/ABI/testing/sysfs-platform-eeepc-wmi
deleted file mode 100644
index e4b5fef5fadd..000000000000
--- a/Documentation/ABI/testing/sysfs-platform-eeepc-wmi
+++ /dev/null
@@ -1,10 +0,0 @@
-What:           /sys/devices/platform/eeepc-wmi/cpufv
-Date:           Oct 2010
-KernelVersion:  2.6.37
-Contact:        "Corentin Chary" <corentincj@iksaif.net>
-Description:
-                Change CPU clock configuration (write-only).
-                There are three available clock configuration:
-                    * 0 -> Super Performance Mode
-                    * 1 -> High Performance Mode
-                    * 2 -> Power Saving Mode
diff --git a/Documentation/laptops/sony-laptop.txt b/Documentation/laptops/sony-laptop.txt
index 23ce7d350d1a..2bd4e82e5d9f 100644
--- a/Documentation/laptops/sony-laptop.txt
+++ b/Documentation/laptops/sony-laptop.txt
@@ -14,7 +14,8 @@ Some models report hotkeys through the SNC or SPIC devices, such events are
 reported both through the ACPI subsystem as acpi events and through the INPUT
 subsystem. See the logs of acpid or /proc/acpi/event and
 /proc/bus/input/devices to find out what those events are and which input
-devices are created by the driver.
+devices are created by the driver. Additionally, loading the driver with the
+debug option will report all events in the kernel log.
 
 Backlight control:
 ------------------
@@ -64,6 +65,16 @@ powers off the sound card,
         # echo "1" > /sys/devices/platform/sony-laptop/audiopower
 powers on the sound card.
 
+
+RFkill control:
+---------------
+More recent Vaio models expose a consistent set of ACPI methods to
+control radio frequency emitting devices. If you are a lucky owner of
+such a laptop you will find the necessary rfkill devices under
+/sys/class/rfkill. Check those starting with sony-* in
+        # grep . /sys/class/rfkill/*/{state,name}
+
+
 Development:
 ------------
 
@@ -75,8 +86,21 @@ pass the option 'debug=1'.
 REPEAT: DON'T DO THIS IF YOU DON'T LIKE RISKY BUSINESS.
 
 In your kernel logs you will find the list of all ACPI methods
-the SNC device has on your laptop. You can see the GCDP/GCDP methods
-used to pwer on/off the CD drive, but there are others.
+the SNC device has on your laptop.
+
+* For new models you will see a long list of meaningless method names,
+reading the DSDT table source should reveal that:
+(1) the SNC device uses an internal capability lookup table
+(2) SN00 is used to find values in the lookup table
+(3) SN06 and SN07 are used to call into the real methods based on
+    offsets you can obtain iterating the table using SN00
+(4) SN02 used to enable events.
+Some values in the capability lookup table are more or less known, see
+the code for all sony_call_snc_handle calls, others are more obscure.
+
+* For old models you can see the GCDP/GCDP methods used to pwer on/off
+the CD drive, but there are others and they are usually different from
+model to model.
 
 I HAVE NO IDEA WHAT THOSE METHODS DO.
 
@@ -108,9 +132,8 @@ Bugs/Limitations:
   laptop, including permanent damage.
 
 * The sony-laptop and sonypi drivers do not interact at all. In the
-  future, sonypi could use sony-laptop to do (part of) its business.
+  future, sonypi will be removed and replaced by sony-laptop.
 
 * spicctrl, which is the userspace tool used to communicate with the
-  sonypi driver (through /dev/sonypi) does not try to use the
-  sony-laptop driver. In the future, spicctrl could try sonypi first,
-  and if it isn't present, try sony-laptop instead.
+  sonypi driver (through /dev/sonypi) is deprecated as well since all
+  its features are now available under the sysfs tree via sony-laptop.
diff --git a/MAINTAINERS b/MAINTAINERS
index 8aa1cacddbcc..6b4b9cdec370 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -1157,14 +1157,14 @@ S:	Maintained
 F:      Documentation/hwmon/asc7621
 F:      drivers/hwmon/asc7621.c
 
-ASUS ACPI EXTRAS DRIVER
+ASUS NOTEBOOKS AND EEEPC ACPI/WMI EXTRAS DRIVERS
 M:      Corentin Chary <corentincj@iksaif.net>
-M:      Karol Kozimor <sziwan@users.sourceforge.net>
 L:      acpi4asus-user@lists.sourceforge.net
 L:      platform-driver-x86@vger.kernel.org
 W:      http://acpi4asus.sf.net
 S:      Maintained
-F:      drivers/platform/x86/asus_acpi.c
+F:      drivers/platform/x86/asus*.c
+F:      drivers/platform/x86/eeepc*.c
 
 ASUS ASB100 HARDWARE MONITOR DRIVER
 M:      "Mark M. Hoffman" <mhoffman@lightlink.com>
@@ -1172,14 +1172,6 @@ L:	lm-sensors@lm-sensors.org
 S:      Maintained
 F:      drivers/hwmon/asb100.c
 
-ASUS LAPTOP EXTRAS DRIVER
-M:      Corentin Chary <corentincj@iksaif.net>
-L:      acpi4asus-user@lists.sourceforge.net
-L:      platform-driver-x86@vger.kernel.org
-W:      http://acpi4asus.sf.net
-S:      Maintained
-F:      drivers/platform/x86/asus-laptop.c
-
 ASYNCHRONOUS TRANSFERS/TRANSFORMS (IOAT) API
 M:      Dan Williams <dan.j.williams@intel.com>
 W:      http://sourceforge.net/projects/xscaleiop
@@ -2414,22 +2406,6 @@ T:	git git://git.alsa-project.org/alsa-kernel.git
 S:      Maintained
 F:      sound/usb/misc/ua101.c
 
-EEEPC LAPTOP EXTRAS DRIVER
-M:      Corentin Chary <corentincj@iksaif.net>
-L:      acpi4asus-user@lists.sourceforge.net
-L:      platform-driver-x86@vger.kernel.org
-W:      http://acpi4asus.sf.net
-S:      Maintained
-F:      drivers/platform/x86/eeepc-laptop.c
-
-EEEPC WMI EXTRAS DRIVER
-M:      Corentin Chary <corentincj@iksaif.net>
-L:      acpi4asus-user@lists.sourceforge.net
-L:      platform-driver-x86@vger.kernel.org
-W:      http://acpi4asus.sf.net
-S:      Maintained
-F:      drivers/platform/x86/eeepc-wmi.c
-
 EFIFB FRAMEBUFFER DRIVER
 L:      linux-fbdev@vger.kernel.org
 M:      Peter Jones <pjones@redhat.com>
diff --git a/arch/arm/Kconfig b/arch/arm/Kconfig
index 93d595a7477a..efe06e004714 100644
--- a/arch/arm/Kconfig
+++ b/arch/arm/Kconfig
@@ -2009,6 +2009,7 @@ menu "Power management options"
 source "kernel/power/Kconfig"
 
 config ARCH_SUSPEND_POSSIBLE
+        depends on !ARCH_S5P64X0 && !ARCH_S5P6442
         def_bool y
 
 endmenu
diff --git a/arch/arm/mach-exynos4/Kconfig b/arch/arm/mach-exynos4/Kconfig
index a021b5240bba..e849f67be47d 100644
--- a/arch/arm/mach-exynos4/Kconfig
+++ b/arch/arm/mach-exynos4/Kconfig
@@ -20,6 +20,11 @@ config EXYNOS4_MCT
         help
           Use MCT (Multi Core Timer) as kernel timers
 
+config EXYNOS4_DEV_AHCI
+        bool
+        help
+          Compile in platform device definitions for AHCI
+
 config EXYNOS4_DEV_PD
         bool
         help
@@ -134,9 +139,9 @@ config MACH_ARMLEX4210
         select S3C_DEV_HSMMC
         select S3C_DEV_HSMMC2
         select S3C_DEV_HSMMC3
+        select EXYNOS4_DEV_AHCI
         select EXYNOS4_DEV_SYSMMU
         select EXYNOS4_SETUP_SDHCI
-        select SATA_AHCI_PLATFORM
         help
           Machine support for Samsung ARMLEX4210 based on EXYNOS4210
 
diff --git a/arch/arm/mach-exynos4/Makefile b/arch/arm/mach-exynos4/Makefile
index b8f0e7d82d7e..9be104f63c0b 100644
--- a/arch/arm/mach-exynos4/Makefile
+++ b/arch/arm/mach-exynos4/Makefile
@@ -39,6 +39,7 @@ obj-$(CONFIG_MACH_NURI)			+= mach-nuri.o
 # device support
 
 obj-y                                   += dev-audio.o
+obj-$(CONFIG_EXYNOS4_DEV_AHCI)          += dev-ahci.o
 obj-$(CONFIG_EXYNOS4_DEV_PD)            += dev-pd.o
 obj-$(CONFIG_EXYNOS4_DEV_SYSMMU)        += dev-sysmmu.o
 
@@ -53,4 +54,3 @@ obj-$(CONFIG_EXYNOS4_SETUP_I2C7)	+= setup-i2c7.o
 obj-$(CONFIG_EXYNOS4_SETUP_KEYPAD)      += setup-keypad.o
 obj-$(CONFIG_EXYNOS4_SETUP_SDHCI)       += setup-sdhci.o
 obj-$(CONFIG_EXYNOS4_SETUP_SDHCI_GPIO)  += setup-sdhci-gpio.o
-obj-$(CONFIG_SATA_AHCI_PLATFORM)        += dev-ahci.o
diff --git a/arch/arm/mach-exynos4/include/mach/debug-macro.S b/arch/arm/mach-exynos4/include/mach/debug-macro.S
index 58bbd049a6c4..a442ef861167 100644
--- a/arch/arm/mach-exynos4/include/mach/debug-macro.S
+++ b/arch/arm/mach-exynos4/include/mach/debug-macro.S
@@ -21,8 +21,8 @@
          */
 
         .macro addruart, rp, rv
-                ldreq   \rp, = S3C_PA_UART
-                ldrne   \rv, = S3C_VA_UART
+                ldr     \rp, = S3C_PA_UART
+                ldr     \rv, = S3C_VA_UART
 #if CONFIG_DEBUG_S3C_UART != 0
                 add     \rp, \rp, #(0x10000 * CONFIG_DEBUG_S3C_UART)
                 add     \rv, \rv, #(0x10000 * CONFIG_DEBUG_S3C_UART)
diff --git a/arch/arm/mach-exynos4/mach-smdkc210.c b/arch/arm/mach-exynos4/mach-smdkc210.c
index 25a256818122..e645f7a955f0 100644
--- a/arch/arm/mach-exynos4/mach-smdkc210.c
+++ b/arch/arm/mach-exynos4/mach-smdkc210.c
@@ -125,7 +125,7 @@ static struct resource smdkc210_smsc911x_resources[] = {
 };
 
 static struct smsc911x_platform_config smsc9215_config = {
-        .irq_polarity   = SMSC911X_IRQ_POLARITY_ACTIVE_HIGH,
+        .irq_polarity   = SMSC911X_IRQ_POLARITY_ACTIVE_LOW,
         .irq_type       = SMSC911X_IRQ_TYPE_PUSH_PULL,
         .flags          = SMSC911X_USE_16BIT | SMSC911X_FORCE_INTERNAL_PHY,
         .phy_interface  = PHY_INTERFACE_MODE_MII,
diff --git a/arch/arm/mach-exynos4/mach-smdkv310.c b/arch/arm/mach-exynos4/mach-smdkv310.c
index 88e0275143be..152676471b67 100644
--- a/arch/arm/mach-exynos4/mach-smdkv310.c
+++ b/arch/arm/mach-exynos4/mach-smdkv310.c
@@ -127,7 +127,7 @@ static struct resource smdkv310_smsc911x_resources[] = {
 };
 
 static struct smsc911x_platform_config smsc9215_config = {
-        .irq_polarity   = SMSC911X_IRQ_POLARITY_ACTIVE_HIGH,
+        .irq_polarity   = SMSC911X_IRQ_POLARITY_ACTIVE_LOW,
         .irq_type       = SMSC911X_IRQ_TYPE_PUSH_PULL,
         .flags          = SMSC911X_USE_16BIT | SMSC911X_FORCE_INTERNAL_PHY,
         .phy_interface  = PHY_INTERFACE_MODE_MII,
diff --git a/arch/arm/mach-mx5/mx51_efika.c b/arch/arm/mach-mx5/mx51_efika.c
index 51a67fc7f0ef..868af8f435fa 100644
--- a/arch/arm/mach-mx5/mx51_efika.c
+++ b/arch/arm/mach-mx5/mx51_efika.c
@@ -572,8 +572,10 @@ static struct mc13xxx_regulator_init_data mx51_efika_regulators[] = {
 
 static struct mc13xxx_platform_data mx51_efika_mc13892_data = {
         .flags = MC13XXX_USE_RTC | MC13XXX_USE_REGULATOR,
-        .num_regulators = ARRAY_SIZE(mx51_efika_regulators),
-        .regulators = mx51_efika_regulators,
+        .regulators = {
+                .num_regulators = ARRAY_SIZE(mx51_efika_regulators),
+                .regulators = mx51_efika_regulators,
+        },
 };
 
 static struct spi_board_info mx51_efika_spi_board_info[] __initdata = {
diff --git a/arch/arm/mach-ns9xxx/irq.c b/arch/arm/mach-ns9xxx/irq.c
index 389fa5c669de..bf0fd48cbd80 100644
--- a/arch/arm/mach-ns9xxx/irq.c
+++ b/arch/arm/mach-ns9xxx/irq.c
@@ -31,17 +31,11 @@ static void ns9xxx_mask_irq(struct irq_data *d)
         __raw_writel(ic, SYS_IC(prio / 4));
 }
 
-static void ns9xxx_ack_irq(struct irq_data *d)
+static void ns9xxx_eoi_irq(struct irq_data *d)
 {
         __raw_writel(0, SYS_ISRADDR);
 }
 
-static void ns9xxx_maskack_irq(struct irq_data *d)
-{
-        ns9xxx_mask_irq(d);
-        ns9xxx_ack_irq(d);
-}
-
 static void ns9xxx_unmask_irq(struct irq_data *d)
 {
         /* XXX: better use cpp symbols */
@@ -52,56 +46,11 @@ static void ns9xxx_unmask_irq(struct irq_data *d)
 }
 
 static struct irq_chip ns9xxx_chip = {
-        .irq_ack        = ns9xxx_ack_irq,
+        .irq_eoi        = ns9xxx_eoi_irq,
         .irq_mask       = ns9xxx_mask_irq,
-        .irq_mask_ack   = ns9xxx_maskack_irq,
         .irq_unmask     = ns9xxx_unmask_irq,
 };
 
-#if 0
-#define handle_irq handle_level_irq
-#else
-static void handle_prio_irq(unsigned int irq, struct irq_desc *desc)
-{
-        struct irqaction *action;
-        irqreturn_t action_ret;
-
-        raw_spin_lock(&desc->lock);
-
-        BUG_ON(desc->status & IRQ_INPROGRESS);
-
-        desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
-        kstat_incr_irqs_this_cpu(irq, desc);
-
-        action = desc->action;
-        if (unlikely(!action || (desc->status & IRQ_DISABLED)))
-                goto out_mask;
-
-        desc->status |= IRQ_INPROGRESS;
-        raw_spin_unlock(&desc->lock);
-
-        action_ret = handle_IRQ_event(irq, action);
-
-        /* XXX: There is no direct way to access noirqdebug, so check
-         * unconditionally for spurious irqs...
-         * Maybe this function should go to kernel/irq/chip.c? */
-        note_interrupt(irq, desc, action_ret);
-
-        raw_spin_lock(&desc->lock);
-        desc->status &= ~IRQ_INPROGRESS;
-
-        if (desc->status & IRQ_DISABLED)
-out_mask:
-                desc->irq_data.chip->irq_mask(&desc->irq_data);
-
-        /* ack unconditionally to unmask lower prio irqs */
-        desc->irq_data.chip->irq_ack(&desc->irq_data);
-
-        raw_spin_unlock(&desc->lock);
-}
-#define handle_irq handle_prio_irq
-#endif
-
 void __init ns9xxx_init_irq(void)
 {
         int i;
@@ -119,7 +68,8 @@ void __init ns9xxx_init_irq(void)
 
         for (i = 0; i <= 31; ++i) {
                 set_irq_chip(i, &ns9xxx_chip);
-                set_irq_handler(i, handle_irq);
+                set_irq_handler(i, handle_fasteoi_irq);
                 set_irq_flags(i, IRQF_VALID);
+                irq_set_status_flags(i, IRQ_LEVEL);
         }
 }
diff --git a/arch/arm/mach-s5p64x0/cpu.c b/arch/arm/mach-s5p64x0/cpu.c
index b8d02eb4cf30..a5c00952ea35 100644
--- a/arch/arm/mach-s5p64x0/cpu.c
+++ b/arch/arm/mach-s5p64x0/cpu.c
@@ -119,7 +119,7 @@ void __init s5p6450_map_io(void)
         s3c_adc_setname("s3c64xx-adc");
 
         iotable_init(s5p64x0_iodesc, ARRAY_SIZE(s5p64x0_iodesc));
-        iotable_init(s5p6450_iodesc, ARRAY_SIZE(s5p6440_iodesc));
+        iotable_init(s5p6450_iodesc, ARRAY_SIZE(s5p6450_iodesc));
 }
 
 /*
diff --git a/arch/arm/mach-s5pv210/include/mach/irqs.h b/arch/arm/mach-s5pv210/include/mach/irqs.h
index 26710b35ef87..b9f9ec33384d 100644
--- a/arch/arm/mach-s5pv210/include/mach/irqs.h
+++ b/arch/arm/mach-s5pv210/include/mach/irqs.h
@@ -99,9 +99,9 @@
 #define IRQ_TC                  IRQ_PENDN
 #define IRQ_KEYPAD              S5P_IRQ_VIC2(25)
 #define IRQ_CG                  S5P_IRQ_VIC2(26)
-#define IRQ_SEC                 S5P_IRQ_VIC2(27)
-#define IRQ_SECRX               S5P_IRQ_VIC2(28)
-#define IRQ_SECTX               S5P_IRQ_VIC2(29)
+#define IRQ_SSS_INT             S5P_IRQ_VIC2(27)
+#define IRQ_SSS_HASH            S5P_IRQ_VIC2(28)
+#define IRQ_PCM2                S5P_IRQ_VIC2(29)
 #define IRQ_SDMIRQ              S5P_IRQ_VIC2(30)
 #define IRQ_SDMFIQ              S5P_IRQ_VIC2(31)
 
diff --git a/arch/arm/mach-s5pv210/mach-smdkv210.c b/arch/arm/mach-s5pv210/mach-smdkv210.c
index bc08ac42e7cc..c6a9e86c2d5c 100644
--- a/arch/arm/mach-s5pv210/mach-smdkv210.c
+++ b/arch/arm/mach-s5pv210/mach-smdkv210.c
@@ -44,7 +44,6 @@
 #include <plat/keypad.h>
 #include <plat/pm.h>
 #include <plat/fb.h>
-#include <plat/gpio-cfg.h>
 #include <plat/s5p-time.h>
 
 /* Following are default values for UCON, ULCON and UFCON UART registers */
diff --git a/arch/arm/mach-ux500/Kconfig b/arch/arm/mach-ux500/Kconfig
index 203b986280f5..58626013aa32 100644
--- a/arch/arm/mach-ux500/Kconfig
+++ b/arch/arm/mach-ux500/Kconfig
@@ -23,6 +23,7 @@ menu "Ux500 target platform"
 config MACH_U8500
         bool "U8500 Development platform"
         depends on UX500_SOC_DB8500
+        select TPS6105X
         help
           Include support for the mop500 development platform.
 
diff --git a/arch/arm/mach-ux500/board-mop500-regulators.c b/arch/arm/mach-ux500/board-mop500-regulators.c
index 875c91b2f8a4..9ed0f90cfe23 100644
--- a/arch/arm/mach-ux500/board-mop500-regulators.c
+++ b/arch/arm/mach-ux500/board-mop500-regulators.c
@@ -13,6 +13,30 @@
 #include <linux/regulator/ab8500.h>
 #include "board-mop500-regulators.h"
 
+/*
+ * TPS61052 regulator
+ */
+static struct regulator_consumer_supply tps61052_vaudio_consumers[] = {
+        /*
+         * Boost converter supply to raise voltage on audio speaker, this
+         * is actually connected to three pins, VInVhfL (left amplifier)
+         * VInVhfR (right amplifier) and VIntDClassInt - all three must
+         * be connected to the same voltage.
+         */
+        REGULATOR_SUPPLY("vintdclassint", "ab8500-codec.0"),
+};
+
+struct regulator_init_data tps61052_regulator = {
+        .constraints = {
+                .name = "vaudio-hf",
+                .min_uV = 4500000,
+                .max_uV = 4500000,
+                .valid_ops_mask = REGULATOR_CHANGE_STATUS,
+        },
+        .num_consumer_supplies = ARRAY_SIZE(tps61052_vaudio_consumers),
+        .consumer_supplies = tps61052_vaudio_consumers,
+};
+
 static struct regulator_consumer_supply ab8500_vaux1_consumers[] = {
         /* External displays, connector on board 2v5 power supply */
         REGULATOR_SUPPLY("vaux12v5", "mcde.0"),
@@ -62,6 +86,182 @@ static struct regulator_consumer_supply ab8500_vana_consumers[] = {
         REGULATOR_SUPPLY("vsmps2", "mcde.0"),
 };
 
+/* ab8500 regulator register initialization */
+struct ab8500_regulator_reg_init
+ab8500_regulator_reg_init[AB8500_NUM_REGULATOR_REGISTERS] = {
+        /*
+         * VanaRequestCtrl          = HP/LP depending on VxRequest
+         * VextSupply1RequestCtrl   = HP/LP depending on VxRequest
+         */
+        INIT_REGULATOR_REGISTER(AB8500_REGUREQUESTCTRL2, 0x00),
+        /*
+         * VextSupply2RequestCtrl   = HP/LP depending on VxRequest
+         * VextSupply3RequestCtrl   = HP/LP depending on VxRequest
+         * Vaux1RequestCtrl         = HP/LP depending on VxRequest
+         * Vaux2RequestCtrl         = HP/LP depending on VxRequest
+         */
+        INIT_REGULATOR_REGISTER(AB8500_REGUREQUESTCTRL3, 0x00),
+        /*
+         * Vaux3RequestCtrl         = HP/LP depending on VxRequest
+         * SwHPReq                  = Control through SWValid disabled
+         */
+        INIT_REGULATOR_REGISTER(AB8500_REGUREQUESTCTRL4, 0x00),
+        /*
+         * VanaSysClkReq1HPValid    = disabled
+         * Vaux1SysClkReq1HPValid   = disabled
+         * Vaux2SysClkReq1HPValid   = disabled
+         * Vaux3SysClkReq1HPValid   = disabled
+         */
+        INIT_REGULATOR_REGISTER(AB8500_REGUSYSCLKREQ1HPVALID1, 0x00),
+        /*
+         * VextSupply1SysClkReq1HPValid = disabled
+         * VextSupply2SysClkReq1HPValid = disabled
+         * VextSupply3SysClkReq1HPValid = SysClkReq1 controlled
+         */
+        INIT_REGULATOR_REGISTER(AB8500_REGUSYSCLKREQ1HPVALID2, 0x40),
+        /*
+         * VanaHwHPReq1Valid        = disabled
+         * Vaux1HwHPreq1Valid       = disabled
+         * Vaux2HwHPReq1Valid       = disabled
+         * Vaux3HwHPReqValid        = disabled
+         */
+        INIT_REGULATOR_REGISTER(AB8500_REGUHWHPREQ1VALID1, 0x00),
+        /*
+         * VextSupply1HwHPReq1Valid = disabled
+         * VextSupply2HwHPReq1Valid = disabled
+         * VextSupply3HwHPReq1Valid = disabled
+         */
+        INIT_REGULATOR_REGISTER(AB8500_REGUHWHPREQ1VALID2, 0x00),
+        /*
+         * VanaHwHPReq2Valid        = disabled
+         * Vaux1HwHPReq2Valid       = disabled
+         * Vaux2HwHPReq2Valid       = disabled
+         * Vaux3HwHPReq2Valid       = disabled
+         */
+        INIT_REGULATOR_REGISTER(AB8500_REGUHWHPREQ2VALID1, 0x00),
+        /*
+         * VextSupply1HwHPReq2Valid = disabled
+         * VextSupply2HwHPReq2Valid = disabled
+         * VextSupply3HwHPReq2Valid = HWReq2 controlled
+         */
+        INIT_REGULATOR_REGISTER(AB8500_REGUHWHPREQ2VALID2, 0x04),
+        /*
+         * VanaSwHPReqValid         = disabled
+         * Vaux1SwHPReqValid        = disabled
+         */
+        INIT_REGULATOR_REGISTER(AB8500_REGUSWHPREQVALID1, 0x00),
+        /*
+         * Vaux2SwHPReqValid        = disabled
+         * Vaux3SwHPReqValid        = disabled
+         * VextSupply1SwHPReqValid  = disabled
+         * VextSupply2SwHPReqValid  = disabled
+         * VextSupply3SwHPReqValid  = disabled
+         */
+        INIT_REGULATOR_REGISTER(AB8500_REGUSWHPREQVALID2, 0x00),
+        /*
+         * SysClkReq2Valid1         = SysClkReq2 controlled
+         * SysClkReq3Valid1         = disabled
+         * SysClkReq4Valid1         = SysClkReq4 controlled
+         * SysClkReq5Valid1         = disabled
+         * SysClkReq6Valid1         = SysClkReq6 controlled
+         * SysClkReq7Valid1         = disabled
+         * SysClkReq8Valid1         = disabled
+         */
+        INIT_REGULATOR_REGISTER(AB8500_REGUSYSCLKREQVALID1, 0x2a),
+        /*
+         * SysClkReq2Valid2         = disabled
+         * SysClkReq3Valid2         = disabled
+         * SysClkReq4Valid2         = disabled
+         * SysClkReq5Valid2         = disabled
+         * SysClkReq6Valid2         = SysClkReq6 controlled
+         * SysClkReq7Valid2         = disabled
+         * SysClkReq8Valid2         = disabled
+         */
+        INIT_REGULATOR_REGISTER(AB8500_REGUSYSCLKREQVALID2, 0x20),
+        /*
+         * VTVoutEna                = disabled
+         * Vintcore12Ena            = disabled
+         * Vintcore12Sel            = 1.25 V
+         * Vintcore12LP             = inactive (HP)
+         * VTVoutLP                 = inactive (HP)
+         */
+        INIT_REGULATOR_REGISTER(AB8500_REGUMISC1, 0x10),
+        /*
+         * VaudioEna                = disabled
+         * VdmicEna                 = disabled
+         * Vamic1Ena                = disabled
+         * Vamic2Ena                = disabled
+         */
+        INIT_REGULATOR_REGISTER(AB8500_VAUDIOSUPPLY, 0x00),
+        /*
+         * Vamic1_dzout             = high-Z when Vamic1 is disabled
+         * Vamic2_dzout             = high-Z when Vamic2 is disabled
+         */
+        INIT_REGULATOR_REGISTER(AB8500_REGUCTRL1VAMIC, 0x00),
+        /*
+         * VPll                     = Hw controlled
+         * VanaRegu                 = force off
+         */
+        INIT_REGULATOR_REGISTER(AB8500_VPLLVANAREGU, 0x02),
+        /*
+         * VrefDDREna               = disabled
+         * VrefDDRSleepMode         = inactive (no pulldown)
+         */
+        INIT_REGULATOR_REGISTER(AB8500_VREFDDR, 0x00),
+        /*
+         * VextSupply1Regu          = HW control
+         * VextSupply2Regu          = HW control
+         * VextSupply3Regu          = HW control
+         * ExtSupply2Bypass         = ExtSupply12LPn ball is 0 when Ena is 0
+         * ExtSupply3Bypass         = ExtSupply3LPn ball is 0 when Ena is 0
+         */
+        INIT_REGULATOR_REGISTER(AB8500_EXTSUPPLYREGU, 0x2a),
+        /*
+         * Vaux1Regu                = force HP
+         * Vaux2Regu                = force off
+         */
+        INIT_REGULATOR_REGISTER(AB8500_VAUX12REGU, 0x01),
+        /*
+         * Vaux3regu                = force off
+         */
+        INIT_REGULATOR_REGISTER(AB8500_VRF1VAUX3REGU, 0x00),
+        /*
+         * Vsmps1                   = 1.15V
+         */
+        INIT_REGULATOR_REGISTER(AB8500_VSMPS1SEL1, 0x24),
+        /*
+         * Vaux1Sel                 = 2.5 V
+         */
+        INIT_REGULATOR_REGISTER(AB8500_VAUX1SEL, 0x08),
+        /*
+         * Vaux2Sel                 = 2.9 V
+         */
+        INIT_REGULATOR_REGISTER(AB8500_VAUX2SEL, 0x0d),
+        /*
+         * Vaux3Sel                 = 2.91 V
+         */
+        INIT_REGULATOR_REGISTER(AB8500_VRF1VAUX3SEL, 0x07),
+        /*
+         * VextSupply12LP           = disabled (no LP)
+         */
+        INIT_REGULATOR_REGISTER(AB8500_REGUCTRL2SPARE, 0x00),
+        /*
+         * Vaux1Disch               = short discharge time
+         * Vaux2Disch               = short discharge time
+         * Vaux3Disch               = short discharge time
+         * Vintcore12Disch          = short discharge time
+         * VTVoutDisch              = short discharge time
+         * VaudioDisch              = short discharge time
+         */
+        INIT_REGULATOR_REGISTER(AB8500_REGUCTRLDISCH, 0x00),
+        /*
+         * VanaDisch                = short discharge time
+         * VdmicPullDownEna         = pulldown disabled when Vdmic is disabled
+         * VdmicDisch               = short discharge time
+         */
+        INIT_REGULATOR_REGISTER(AB8500_REGUCTRLDISCH2, 0x00),
+};
+
 /* AB8500 regulators */
 struct regulator_init_data ab8500_regulators[AB8500_NUM_REGULATORS] = {
         /* supplies to the display/camera */
@@ -72,6 +272,7 @@ struct regulator_init_data ab8500_regulators[AB8500_NUM_REGULATORS] = {
                         .max_uV = 2900000,
                         .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE |
                                           REGULATOR_CHANGE_STATUS,
+                        .boot_on = 1, /* must be on for display */
                 },
                 .num_consumer_supplies = ARRAY_SIZE(ab8500_vaux1_consumers),
                 .consumer_supplies = ab8500_vaux1_consumers,
diff --git a/arch/arm/mach-ux500/board-mop500-regulators.h b/arch/arm/mach-ux500/board-mop500-regulators.h
index f979b892e4fa..94992158d962 100644
--- a/arch/arm/mach-ux500/board-mop500-regulators.h
+++ b/arch/arm/mach-ux500/board-mop500-regulators.h
@@ -17,5 +17,6 @@
 extern struct ab8500_regulator_reg_init
 ab8500_regulator_reg_init[AB8500_NUM_REGULATOR_REGISTERS];
 extern struct regulator_init_data ab8500_regulators[AB8500_NUM_REGULATORS];
+extern struct regulator_init_data tps61052_regulator;
 
 #endif
diff --git a/arch/arm/mach-ux500/board-mop500.c b/arch/arm/mach-ux500/board-mop500.c
index d0076453d7ff..dc8746d7826e 100644
--- a/arch/arm/mach-ux500/board-mop500.c
+++ b/arch/arm/mach-ux500/board-mop500.c
@@ -22,6 +22,8 @@
 #include <linux/mfd/ab8500.h>
 #include <linux/regulator/ab8500.h>
 #include <linux/mfd/tc3589x.h>
+#include <linux/mfd/tps6105x.h>
+#include <linux/mfd/ab8500/gpio.h>
 #include <linux/leds-lp5521.h>
 #include <linux/input.h>
 #include <linux/gpio_keys.h>
@@ -42,10 +44,35 @@
 #include "board-mop500.h"
 #include "board-mop500-regulators.h"
 
+static struct ab8500_gpio_platform_data ab8500_gpio_pdata = {
+        .gpio_base              = MOP500_AB8500_GPIO(0),
+        .irq_base               = MOP500_AB8500_VIR_GPIO_IRQ_BASE,
+        /* config_reg is the initial configuration of ab8500 pins.
+         * The pins can be configured as GPIO or alt functions based
+         * on value present in GpioSel1 to GpioSel6 and AlternatFunction
+         * register. This is the array of 7 configuration settings.
+         * One has to compile time decide these settings. Below is the
+         * explaination of these setting
+         * GpioSel1 = 0x00 => Pins GPIO1 to GPIO8 are not used as GPIO
+         * GpioSel2 = 0x1E => Pins GPIO10 to GPIO13 are configured as GPIO
+         * GpioSel3 = 0x80 => Pin GPIO24 is configured as GPIO
+         * GpioSel4 = 0x01 => Pin GPIo25 is configured as GPIO
+         * GpioSel5 = 0x7A => Pins GPIO34, GPIO36 to GPIO39 are conf as GPIO
+         * GpioSel6 = 0x00 => Pins GPIO41 & GPIo42 are not configured as GPIO
+         * AlternaFunction = 0x00 => If Pins GPIO10 to 13 are not configured
+         * as GPIO then this register selectes the alternate fucntions
+         */
+        .config_reg             = {0x00, 0x1E, 0x80, 0x01,
+                                        0x7A, 0x00, 0x00},
+};
+
 static struct ab8500_platform_data ab8500_platdata = {
         .irq_base       = MOP500_AB8500_IRQ_BASE,
+        .regulator_reg_init = ab8500_regulator_reg_init,
+        .num_regulator_reg_init = ARRAY_SIZE(ab8500_regulator_reg_init),
         .regulator      = ab8500_regulators,
         .num_regulator  = ARRAY_SIZE(ab8500_regulators),
+        .gpio           = &ab8500_gpio_pdata,
 };
 
 static struct resource ab8500_resources[] = {
@@ -67,6 +94,15 @@ struct platform_device ab8500_device = {
 };
 
 /*
+ * TPS61052
+ */
+
+static struct tps6105x_platform_data mop500_tps61052_data = {
+        .mode = TPS6105X_MODE_VOLTAGE,
+        .regulator_data = &tps61052_regulator,
+};
+
+/*
  * TC35892
  */
 
@@ -136,7 +172,7 @@ static struct lp5521_platform_data __initdata lp5521_sec_data = {
        .clock_mode     = LP5521_CLOCK_EXT,
 };
 
-static struct i2c_board_info mop500_i2c0_devices[] = {
+static struct i2c_board_info __initdata mop500_i2c0_devices[] = {
         {
                 I2C_BOARD_INFO("tc3589x", 0x42),
                 .irq            = NOMADIK_GPIO_TO_IRQ(217),
@@ -144,6 +180,14 @@ static struct i2c_board_info mop500_i2c0_devices[] = {
         },
 };
 
+/* I2C0 devices only available prior to HREFv60 */
+static struct i2c_board_info __initdata mop500_i2c0_old_devices[] = {
+        {
+                I2C_BOARD_INFO("tps61052", 0x33),
+                .platform_data  = &mop500_tps61052_data,
+        },
+};
+
 static struct i2c_board_info __initdata mop500_i2c2_devices[] = {
         {
                 /* lp5521 LED driver, 1st device */
@@ -406,6 +450,9 @@ static void __init mop500_init_machine(void)
 
         i2c_register_board_info(0, mop500_i2c0_devices,
                                 ARRAY_SIZE(mop500_i2c0_devices));
+        if (!machine_is_hrefv60())
+                i2c_register_board_info(0, mop500_i2c0_old_devices,
+                                        ARRAY_SIZE(mop500_i2c0_old_devices));
         i2c_register_board_info(2, mop500_i2c2_devices,
                                 ARRAY_SIZE(mop500_i2c2_devices));
 }
diff --git a/arch/arm/mach-ux500/board-mop500.h b/arch/arm/mach-ux500/board-mop500.h
index 56722f4be71b..03a31cc9b084 100644
--- a/arch/arm/mach-ux500/board-mop500.h
+++ b/arch/arm/mach-ux500/board-mop500.h
@@ -27,6 +27,10 @@
 #define GPIO_BU21013_CS                 MOP500_EGPIO(13)
 #define GPIO_SDMMC_EN                   MOP500_EGPIO(17)
 #define GPIO_SDMMC_1V8_3V_SEL           MOP500_EGPIO(18)
+#define MOP500_EGPIO_END                MOP500_EGPIO(24)
+
+/* GPIOs on the AB8500 mixed-signals circuit */
+#define MOP500_AB8500_GPIO(x)           (MOP500_EGPIO_END + (x))
 
 struct i2c_board_info;
 
diff --git a/arch/arm/mach-ux500/include/mach/irqs-board-mop500.h b/arch/arm/mach-ux500/include/mach/irqs-board-mop500.h
index 7cdeb2af0ebb..97ef55f84934 100644
--- a/arch/arm/mach-ux500/include/mach/irqs-board-mop500.h
+++ b/arch/arm/mach-ux500/include/mach/irqs-board-mop500.h
@@ -35,9 +35,20 @@
 #define MOP500_STMPE1601_IRQBASE        MOP500_EGPIO_IRQ_END
 #define MOP500_STMPE1601_IRQ(x)         (MOP500_STMPE1601_IRQBASE + (x))
 
-#define MOP500_NR_IRQS          MOP500_STMPE1601_IRQ(STMPE_NR_INTERNAL_IRQS)
+#define MOP500_STMPE1601_IRQ_END        \
+        MOP500_STMPE1601_IRQ(STMPE_NR_INTERNAL_IRQS)
 
-#define MOP500_IRQ_END          MOP500_NR_IRQS
+/* AB8500 virtual gpio IRQ */
+#define AB8500_VIR_GPIO_NR_IRQS                 16
+
+#define MOP500_AB8500_VIR_GPIO_IRQ_BASE         \
+        MOP500_STMPE1601_IRQ_END
+#define MOP500_AB8500_VIR_GPIO_IRQ_END          \
+        (MOP500_AB8500_VIR_GPIO_IRQ_BASE + AB8500_VIR_GPIO_NR_IRQS)
+
+#define MOP500_NR_IRQS          MOP500_AB8500_VIR_GPIO_IRQ_END
+
+#define MOP500_IRQ_END          MOP500_NR_IRQS
 
 #if MOP500_IRQ_END > IRQ_BOARD_END
 #undef IRQ_BOARD_END
diff --git a/arch/arm/plat-s5p/cpu.c b/arch/arm/plat-s5p/cpu.c
index c3bfe9b13acf..5cf5e721e6ca 100644
--- a/arch/arm/plat-s5p/cpu.c
+++ b/arch/arm/plat-s5p/cpu.c
@@ -39,7 +39,7 @@ static const char name_exynos4210[] = "EXYNOS4210";
 static struct cpu_table cpu_ids[] __initdata = {
         {
                 .idcode         = 0x56440100,
-                .idmask         = 0xffffff00,
+                .idmask         = 0xfffff000,
                 .map_io         = s5p6440_map_io,
                 .init_clocks    = s5p6440_init_clocks,
                 .init_uarts     = s5p6440_init_uarts,
@@ -47,7 +47,7 @@ static struct cpu_table cpu_ids[] __initdata = {
                 .name           = name_s5p6440,
         }, {
                 .idcode         = 0x36442000,
-                .idmask         = 0xffffff00,
+                .idmask         = 0xfffff000,
                 .map_io         = s5p6442_map_io,
                 .init_clocks    = s5p6442_init_clocks,
                 .init_uarts     = s5p6442_init_uarts,
@@ -55,7 +55,7 @@ static struct cpu_table cpu_ids[] __initdata = {
                 .name           = name_s5p6442,
         }, {
                 .idcode         = 0x36450000,
-                .idmask         = 0xffffff00,
+                .idmask         = 0xfffff000,
                 .map_io         = s5p6450_map_io,
                 .init_clocks    = s5p6450_init_clocks,
                 .init_uarts     = s5p6450_init_uarts,
@@ -79,7 +79,7 @@ static struct cpu_table cpu_ids[] __initdata = {
                 .name           = name_s5pv210,
         }, {
                 .idcode         = 0x43210000,
-                .idmask         = 0xfffff000,
+                .idmask         = 0xfffe0000,
                 .map_io         = exynos4_map_io,
                 .init_clocks    = exynos4_init_clocks,
                 .init_uarts     = exynos4_init_uarts,
diff --git a/arch/arm/plat-samsung/init.c b/arch/arm/plat-samsung/init.c
index 6790edfaca6f..79d10fca9090 100644
--- a/arch/arm/plat-samsung/init.c
+++ b/arch/arm/plat-samsung/init.c
@@ -36,7 +36,7 @@ static struct cpu_table * __init s3c_lookup_cpu(unsigned long idcode,
                                                 unsigned int count)
 {
         for (; count != 0; count--, tab++) {
-                if ((idcode & tab->idmask) == tab->idcode)
+                if ((idcode & tab->idmask) == (tab->idcode & tab->idmask))
                         return tab;
         }
 
diff --git a/arch/cris/Kconfig b/arch/cris/Kconfig
index 04a7fc5eaf46..617925ddd142 100644
--- a/arch/cris/Kconfig
+++ b/arch/cris/Kconfig
@@ -296,8 +296,7 @@ config ETRAX_RTC
 choice
         prompt "RTC chip"
         depends on ETRAX_RTC
-        default ETRAX_PCF8563 if ETRAX_ARCH_V32
-        default ETRAX_DS1302 if ETRAX_ARCH_V10
+        default ETRAX_DS1302
 
 config ETRAX_DS1302
         depends on ETRAX_ARCH_V10
diff --git a/arch/cris/arch-v10/drivers/pcf8563.c b/arch/cris/arch-v10/drivers/pcf8563.c
index ea69faba9b62..1391b731ad1c 100644
--- a/arch/cris/arch-v10/drivers/pcf8563.c
+++ b/arch/cris/arch-v10/drivers/pcf8563.c
@@ -345,7 +345,7 @@ static long pcf8563_unlocked_ioctl(struct file *filp, unsigned int cmd, unsigned
         int ret;
 
         mutex_lock(&pcf8563_mutex);
-        return pcf8563_ioctl(filp, cmd, arg);
+        ret = pcf8563_ioctl(filp, cmd, arg);
         mutex_unlock(&pcf8563_mutex);
 
         return ret;
diff --git a/arch/cris/arch-v10/kernel/signal.c b/arch/cris/arch-v10/kernel/signal.c
index b6be705c2a3e..e78fe49a9849 100644
--- a/arch/cris/arch-v10/kernel/signal.c
+++ b/arch/cris/arch-v10/kernel/signal.c
@@ -537,7 +537,7 @@ void do_signal(int canrestart, struct pt_regs *regs)
                         RESTART_CRIS_SYS(regs);
                 }
                 if (regs->r10 == -ERESTART_RESTARTBLOCK) {
-                        regs->r10 = __NR_restart_syscall;
+                        regs->r9 = __NR_restart_syscall;
                         regs->irp -= 2;
                 }
         }
diff --git a/arch/cris/arch-v32/drivers/Makefile b/arch/cris/arch-v32/drivers/Makefile
index e8c02437edaf..39aa3c117a86 100644
--- a/arch/cris/arch-v32/drivers/Makefile
+++ b/arch/cris/arch-v32/drivers/Makefile
@@ -7,7 +7,6 @@ obj-$(CONFIG_ETRAX_AXISFLASHMAP)        += axisflashmap.o
 obj-$(CONFIG_ETRAXFS)                   += mach-fs/
 obj-$(CONFIG_CRIS_MACH_ARTPEC3)         += mach-a3/
 obj-$(CONFIG_ETRAX_IOP_FW_LOAD)         += iop_fw_load.o
-obj-$(CONFIG_ETRAX_PCF8563)             += pcf8563.o
 obj-$(CONFIG_ETRAX_I2C)                 += i2c.o
 obj-$(CONFIG_ETRAX_SYNCHRONOUS_SERIAL)  += sync_serial.o
 obj-$(CONFIG_PCI)                       += pci/
diff --git a/arch/cris/arch-v32/drivers/pcf8563.c b/arch/cris/arch-v32/drivers/pcf8563.c
deleted file mode 100644
index b6e4fc0aad42..000000000000
--- a/arch/cris/arch-v32/drivers/pcf8563.c
+++ /dev/null
@@ -1,377 +0,0 @@
-/*
- * PCF8563 RTC
- *
- * From Phillips' datasheet:
- *
- * The PCF8563 is a CMOS real-time clock/calendar optimized for low power
- * consumption. A programmable clock output, interrupt output and voltage
- * low detector are also provided. All address and data are transferred
- * serially via two-line bidirectional I2C-bus. Maximum bus speed is
- * 400 kbits/s. The built-in word address register is incremented
- * automatically after each written or read byte.
- *
- * Copyright (c) 2002-2007, Axis Communications AB
- * All rights reserved.
- *
- * Author: Tobias Anderberg <tobiasa@axis.com>.
- *
- */
-
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/types.h>
-#include <linux/sched.h>
-#include <linux/init.h>
-#include <linux/fs.h>
-#include <linux/ioctl.h>
-#include <linux/delay.h>
-#include <linux/bcd.h>
-#include <linux/mutex.h>
-
-#include <asm/uaccess.h>
-#include <asm/system.h>
-#include <asm/io.h>
-#include <asm/rtc.h>
-
-#include "i2c.h"
-
-#define PCF8563_MAJOR   121     /* Local major number. */
-#define DEVICE_NAME     "rtc"   /* Name which is registered in /proc/devices. */
-#define PCF8563_NAME    "PCF8563"
-#define DRIVER_VERSION  "$Revision: 1.17 $"
-
-/* Two simple wrapper macros, saves a few keystrokes. */
-#define rtc_read(x) i2c_readreg(RTC_I2C_READ, x)
-#define rtc_write(x,y) i2c_writereg(RTC_I2C_WRITE, x, y)
-
-static DEFINE_MUTEX(pcf8563_mutex);
-static DEFINE_MUTEX(rtc_lock); /* Protect state etc */
-
-static const unsigned char days_in_month[] =
-        { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
-
-static long pcf8563_unlocked_ioctl(struct file *filp, unsigned int cmd, unsigned long arg);
-
-/* Cache VL bit value read at driver init since writing the RTC_SECOND
- * register clears the VL status.
- */
-static int voltage_low;
-
-static const struct file_operations pcf8563_fops = {
-        .owner          = THIS_MODULE,
-        .unlocked_ioctl = pcf8563_unlocked_ioctl,
-        .llseek         = noop_llseek,
-};
-
-unsigned char
-pcf8563_readreg(int reg)
-{
-        unsigned char res = rtc_read(reg);
-
-        /* The PCF8563 does not return 0 for unimplemented bits. */
-        switch (reg) {
-                case RTC_SECONDS:
-                case RTC_MINUTES:
-                        res &= 0x7F;
-                        break;
-                case RTC_HOURS:
-                case RTC_DAY_OF_MONTH:
-                        res &= 0x3F;
-                        break;
-                case RTC_WEEKDAY:
-                        res &= 0x07;
-                        break;
-                case RTC_MONTH:
-                        res &= 0x1F;
-                        break;
-                case RTC_CONTROL1:
-                        res &= 0xA8;
-                        break;
-                case RTC_CONTROL2:
-                        res &= 0x1F;
-                        break;
-                case RTC_CLOCKOUT_FREQ:
-                case RTC_TIMER_CONTROL:
-                        res &= 0x83;
-                        break;
-        }
-        return res;
-}
-
-void
-pcf8563_writereg(int reg, unsigned char val)
-{
-        rtc_write(reg, val);
-}
-
-void
-get_rtc_time(struct rtc_time *tm)
-{
-        tm->tm_sec  = rtc_read(RTC_SECONDS);
-        tm->tm_min  = rtc_read(RTC_MINUTES);
-        tm->tm_hour = rtc_read(RTC_HOURS);
-        tm->tm_mday = rtc_read(RTC_DAY_OF_MONTH);
-        tm->tm_wday = rtc_read(RTC_WEEKDAY);
-        tm->tm_mon  = rtc_read(RTC_MONTH);
-        tm->tm_year = rtc_read(RTC_YEAR);
-
-        if (tm->tm_sec & 0x80) {
-                printk(KERN_ERR "%s: RTC Voltage Low - reliable date/time "
-                       "information is no longer guaranteed!\n", PCF8563_NAME);
-        }
-
-        tm->tm_year  = bcd2bin(tm->tm_year) +
-                       ((tm->tm_mon & 0x80) ? 100 : 0);
-        tm->tm_sec  &= 0x7F;
-        tm->tm_min  &= 0x7F;
-        tm->tm_hour &= 0x3F;
-        tm->tm_mday &= 0x3F;
-        tm->tm_wday &= 0x07; /* Not coded in BCD. */
-        tm->tm_mon  &= 0x1F;
-
-        tm->tm_sec = bcd2bin(tm->tm_sec);
-        tm->tm_min = bcd2bin(tm->tm_min);
-        tm->tm_hour = bcd2bin(tm->tm_hour);
-        tm->tm_mday = bcd2bin(tm->tm_mday);
-        tm->tm_mon = bcd2bin(tm->tm_mon);
-        tm->tm_mon--; /* Month is 1..12 in RTC but 0..11 in linux */
-}
-
-int __init
-pcf8563_init(void)
-{
-        static int res;
-        static int first = 1;
-
-        if (!first)
-                return res;
-        first = 0;
-
-        /* Initiate the i2c protocol. */
-        res = i2c_init();
-        if (res < 0) {
-                printk(KERN_CRIT "pcf8563_init: Failed to init i2c.\n");
-                return res;
-        }
-
-        /*
-         * First of all we need to reset the chip. This is done by
-         * clearing control1, control2 and clk freq and resetting
-         * all alarms.
-         */
-        if (rtc_write(RTC_CONTROL1, 0x00) < 0)
-                goto err;
-
-        if (rtc_write(RTC_CONTROL2, 0x00) < 0)
-                goto err;
-
-        if (rtc_write(RTC_CLOCKOUT_FREQ, 0x00) < 0)
-                goto err;
-
-        if (rtc_write(RTC_TIMER_CONTROL, 0x03) < 0)
-                goto err;
-
-        /* Reset the alarms. */
-        if (rtc_write(RTC_MINUTE_ALARM, 0x80) < 0)
-                goto err;
-
-        if (rtc_write(RTC_HOUR_ALARM, 0x80) < 0)
-                goto err;
-
-        if (rtc_write(RTC_DAY_ALARM, 0x80) < 0)
-                goto err;
-
-        if (rtc_write(RTC_WEEKDAY_ALARM, 0x80) < 0)
-                goto err;
-
-        /* Check for low voltage, and warn about it. */
-        if (rtc_read(RTC_SECONDS) & 0x80) {
-                voltage_low = 1;
-                printk(KERN_WARNING "%s: RTC Voltage Low - reliable "
-                       "date/time information is no longer guaranteed!\n",
-                       PCF8563_NAME);
-        }
-
-        return res;
-
-err:
-        printk(KERN_INFO "%s: Error initializing chip.\n", PCF8563_NAME);
-        res = -1;
-        return res;
-}
-
-void __exit
-pcf8563_exit(void)
-{
-        unregister_chrdev(PCF8563_MAJOR, DEVICE_NAME);
-}
-
-/*
- * ioctl calls for this driver. Why return -ENOTTY upon error? Because
- * POSIX says so!
- */
-static int pcf8563_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
-{
-        /* Some sanity checks. */
-        if (_IOC_TYPE(cmd) != RTC_MAGIC)
-                return -ENOTTY;
-
-        if (_IOC_NR(cmd) > RTC_MAX_IOCTL)
-                return -ENOTTY;
-
-        switch (cmd) {
-        case RTC_RD_TIME:
-        {
-                struct rtc_time tm;
-
-                mutex_lock(&rtc_lock);
-                memset(&tm, 0, sizeof tm);
-                get_rtc_time(&tm);
-
-                if (copy_to_user((struct rtc_time *) arg, &tm,
-                                 sizeof tm)) {
-                        mutex_unlock(&rtc_lock);
-                        return -EFAULT;
-                }
-
-                mutex_unlock(&rtc_lock);
-
-                return 0;
-        }
-        case RTC_SET_TIME:
-        {
-                int leap;
-                int year;
-                int century;
-                struct rtc_time tm;
-
-                memset(&tm, 0, sizeof tm);
-                if (!capable(CAP_SYS_TIME))
-                        return -EPERM;
-
-                if (copy_from_user(&tm, (struct rtc_time *) arg,
-                                   sizeof tm))
-                        return -EFAULT;
-
-                /* Convert from struct tm to struct rtc_time. */
-                tm.tm_year += 1900;
-                tm.tm_mon += 1;
-
-                /*
-                 * Check if tm.tm_year is a leap year. A year is a leap
-                 * year if it is divisible by 4 but not 100, except
-                 * that years divisible by 400 _are_ leap years.
-                 */
-                year = tm.tm_year;
-                leap = (tm.tm_mon == 2) &&
-                        ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0);
-
-                /* Perform some sanity checks. */
-                if ((tm.tm_year < 1970) ||
-                    (tm.tm_mon > 12) ||
-                    (tm.tm_mday == 0) ||
-                    (tm.tm_mday > days_in_month[tm.tm_mon] + leap) ||
-                    (tm.tm_wday >= 7) ||
-                    (tm.tm_hour >= 24) ||
-                    (tm.tm_min >= 60) ||
-                    (tm.tm_sec >= 60))
-                        return -EINVAL;
-
-                century = (tm.tm_year >= 2000) ? 0x80 : 0;
-                tm.tm_year = tm.tm_year % 100;
-
-                tm.tm_year = bin2bcd(tm.tm_year);
-                tm.tm_mon = bin2bcd(tm.tm_mon);
-                tm.tm_mday = bin2bcd(tm.tm_mday);
-                tm.tm_hour = bin2bcd(tm.tm_hour);
-                tm.tm_min = bin2bcd(tm.tm_min);
-                tm.tm_sec = bin2bcd(tm.tm_sec);
-                tm.tm_mon |= century;
-
-                mutex_lock(&rtc_lock);
-
-                rtc_write(RTC_YEAR, tm.tm_year);
-                rtc_write(RTC_MONTH, tm.tm_mon);
-                rtc_write(RTC_WEEKDAY, tm.tm_wday); /* Not coded in BCD. */
-                rtc_write(RTC_DAY_OF_MONTH, tm.tm_mday);
-                rtc_write(RTC_HOURS, tm.tm_hour);
-                rtc_write(RTC_MINUTES, tm.tm_min);
-                rtc_write(RTC_SECONDS, tm.tm_sec);
-
-                mutex_unlock(&rtc_lock);
-
-                return 0;
-        }
-        case RTC_VL_READ:
-                if (voltage_low)
-                        printk(KERN_ERR "%s: RTC Voltage Low - "
-                               "reliable date/time information is no "
-                               "longer guaranteed!\n", PCF8563_NAME);
-
-                if (copy_to_user((int *) arg, &voltage_low, sizeof(int)))
-                        return -EFAULT;
-                return 0;
-
-        case RTC_VL_CLR:
-        {
-                /* Clear the VL bit in the seconds register in case
-                 * the time has not been set already (which would
-                 * have cleared it). This does not really matter
-                 * because of the cached voltage_low value but do it
-                 * anyway for consistency. */
-
-                int ret = rtc_read(RTC_SECONDS);
-
-                rtc_write(RTC_SECONDS, (ret & 0x7F));
-
-                /* Clear the cached value. */
-                voltage_low = 0;
-
-                return 0;
-        }
-        default:
-                return -ENOTTY;
-        }
-
-        return 0;
-}
-
-static long pcf8563_unlocked_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
-{
-        int ret;
-
-        mutex_lock(&pcf8563_mutex);
-        return pcf8563_ioctl(filp, cmd, arg);
-        mutex_unlock(&pcf8563_mutex);
-
-        return ret;
-}
-
-static int __init pcf8563_register(void)
-{
-        if (pcf8563_init() < 0) {
-                printk(KERN_INFO "%s: Unable to initialize Real-Time Clock "
-                       "Driver, %s\n", PCF8563_NAME, DRIVER_VERSION);
-                return -1;
-        }
-
-        if (register_chrdev(PCF8563_MAJOR, DEVICE_NAME, &pcf8563_fops) < 0) {
-                printk(KERN_INFO "%s: Unable to get major numer %d for RTC "
-                       "device.\n", PCF8563_NAME, PCF8563_MAJOR);
-                return -1;
-        }
-
-        printk(KERN_INFO "%s Real-Time Clock Driver, %s\n", PCF8563_NAME,
-               DRIVER_VERSION);
-
-        /* Check for low voltage, and warn about it. */
-        if (voltage_low) {
-                printk(KERN_WARNING "%s: RTC Voltage Low - reliable date/time "
-                       "information is no longer guaranteed!\n", PCF8563_NAME);
-        }
-
-        return 0;
-}
-
-module_init(pcf8563_register);
-module_exit(pcf8563_exit);
diff --git a/arch/powerpc/platforms/cell/Kconfig b/arch/powerpc/platforms/cell/Kconfig
index 48cd7d2e1b75..81239ebed83f 100644
--- a/arch/powerpc/platforms/cell/Kconfig
+++ b/arch/powerpc/platforms/cell/Kconfig
@@ -9,6 +9,7 @@ config PPC_CELL_COMMON
         select PPC_INDIRECT_IO
         select PPC_NATIVE
         select PPC_RTAS
+        select IRQ_EDGE_EOI_HANDLER
 
 config PPC_CELL_NATIVE
         bool
diff --git a/arch/powerpc/platforms/cell/interrupt.c b/arch/powerpc/platforms/cell/interrupt.c
index 624d26e72f1d..ec9fc7d82068 100644
--- a/arch/powerpc/platforms/cell/interrupt.c
+++ b/arch/powerpc/platforms/cell/interrupt.c
@@ -235,54 +235,6 @@ static int iic_host_match(struct irq_host *h, struct device_node *node)
                                     "IBM,CBEA-Internal-Interrupt-Controller");
 }
 
-extern int noirqdebug;
-
-static void handle_iic_irq(unsigned int irq, struct irq_desc *desc)
-{
-        struct irq_chip *chip = get_irq_desc_chip(desc);
-
-        raw_spin_lock(&desc->lock);
-
-        desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
-
-        /*
-         * If we're currently running this IRQ, or its disabled,
-         * we shouldn't process the IRQ. Mark it pending, handle
-         * the necessary masking and go out
-         */
-        if (unlikely((desc->status & (IRQ_INPROGRESS | IRQ_DISABLED)) ||
-                    !desc->action)) {
-                desc->status |= IRQ_PENDING;
-                goto out_eoi;
-        }
-
-        kstat_incr_irqs_this_cpu(irq, desc);
-
-        /* Mark the IRQ currently in progress.*/
-        desc->status |= IRQ_INPROGRESS;
-
-        do {
-                struct irqaction *action = desc->action;
-                irqreturn_t action_ret;
-
-                if (unlikely(!action))
-                        goto out_eoi;
-
-                desc->status &= ~IRQ_PENDING;
-                raw_spin_unlock(&desc->lock);
-                action_ret = handle_IRQ_event(irq, action);
-                if (!noirqdebug)
-                        note_interrupt(irq, desc, action_ret);
-                raw_spin_lock(&desc->lock);
-
-        } while ((desc->status & (IRQ_PENDING | IRQ_DISABLED)) == IRQ_PENDING);
-
-        desc->status &= ~IRQ_INPROGRESS;
-out_eoi:
-        chip->irq_eoi(&desc->irq_data);
-        raw_spin_unlock(&desc->lock);
-}
-
 static int iic_host_map(struct irq_host *h, unsigned int virq,
                         irq_hw_number_t hw)
 {
@@ -295,7 +247,7 @@ static int iic_host_map(struct irq_host *h, unsigned int virq,
                                          handle_iic_irq);
                 break;
         default:
-                set_irq_chip_and_handler(virq, &iic_chip, handle_iic_irq);
+                set_irq_chip_and_handler(virq, &iic_chip, handle_edge_eoi_irq);
         }
         return 0;
 }
diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig
index d8d0cda2641d..d3743204a7e9 100644
--- a/drivers/gpio/Kconfig
+++ b/drivers/gpio/Kconfig
@@ -414,4 +414,9 @@ config GPIO_JANZ_TTL
           This driver provides support for driving the pins in output
           mode only. Input mode is not supported.
 
+config AB8500_GPIO
+        bool "ST-Ericsson AB8500 Mixed Signal Circuit gpio functions"
+        depends on AB8500_CORE
+        help
+          Select this to enable the AB8500 IC GPIO driver
 endif
diff --git a/drivers/gpio/Makefile b/drivers/gpio/Makefile
index 3351cf87b0ed..becef5954356 100644
--- a/drivers/gpio/Makefile
+++ b/drivers/gpio/Makefile
@@ -42,3 +42,4 @@ obj-$(CONFIG_GPIO_JANZ_TTL)	+= janz-ttl.o
 obj-$(CONFIG_GPIO_SX150X)       += sx150x.o
 obj-$(CONFIG_GPIO_VX855)        += vx855_gpio.o
 obj-$(CONFIG_GPIO_ML_IOH)       += ml_ioh_gpio.o
+obj-$(CONFIG_AB8500_GPIO)       += ab8500-gpio.o
diff --git a/drivers/gpio/ab8500-gpio.c b/drivers/gpio/ab8500-gpio.c
new file mode 100644
index 000000000000..e7b834d054b7
--- /dev/null
+++ b/drivers/gpio/ab8500-gpio.c
@@ -0,0 +1,522 @@
+/*
+ * Copyright (C) ST-Ericsson SA 2011
+ *
+ * Author: BIBEK BASU <bibek.basu@stericsson.com>
+ * License terms: GNU General Public License (GPL) version 2
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/slab.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/err.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/gpio.h>
+#include <linux/irq.h>
+#include <linux/interrupt.h>
+#include <linux/mfd/ab8500.h>
+#include <linux/mfd/abx500.h>
+#include <linux/mfd/ab8500/gpio.h>
+
+/*
+ * GPIO registers offset
+ * Bank: 0x10
+ */
+#define AB8500_GPIO_SEL1_REG    0x00
+#define AB8500_GPIO_SEL2_REG    0x01
+#define AB8500_GPIO_SEL3_REG    0x02
+#define AB8500_GPIO_SEL4_REG    0x03
+#define AB8500_GPIO_SEL5_REG    0x04
+#define AB8500_GPIO_SEL6_REG    0x05
+
+#define AB8500_GPIO_DIR1_REG    0x10
+#define AB8500_GPIO_DIR2_REG    0x11
+#define AB8500_GPIO_DIR3_REG    0x12
+#define AB8500_GPIO_DIR4_REG    0x13
+#define AB8500_GPIO_DIR5_REG    0x14
+#define AB8500_GPIO_DIR6_REG    0x15
+
+#define AB8500_GPIO_OUT1_REG    0x20
+#define AB8500_GPIO_OUT2_REG    0x21
+#define AB8500_GPIO_OUT3_REG    0x22
+#define AB8500_GPIO_OUT4_REG    0x23
+#define AB8500_GPIO_OUT5_REG    0x24
+#define AB8500_GPIO_OUT6_REG    0x25
+
+#define AB8500_GPIO_PUD1_REG    0x30
+#define AB8500_GPIO_PUD2_REG    0x31
+#define AB8500_GPIO_PUD3_REG    0x32
+#define AB8500_GPIO_PUD4_REG    0x33
+#define AB8500_GPIO_PUD5_REG    0x34
+#define AB8500_GPIO_PUD6_REG    0x35
+
+#define AB8500_GPIO_IN1_REG     0x40
+#define AB8500_GPIO_IN2_REG     0x41
+#define AB8500_GPIO_IN3_REG     0x42
+#define AB8500_GPIO_IN4_REG     0x43
+#define AB8500_GPIO_IN5_REG     0x44
+#define AB8500_GPIO_IN6_REG     0x45
+#define AB8500_GPIO_ALTFUN_REG  0x45
+#define ALTFUN_REG_INDEX        6
+#define AB8500_NUM_GPIO         42
+#define AB8500_NUM_VIR_GPIO_IRQ 16
+
+enum ab8500_gpio_action {
+        NONE,
+        STARTUP,
+        SHUTDOWN,
+        MASK,
+        UNMASK
+};
+
+struct ab8500_gpio {
+        struct gpio_chip chip;
+        struct ab8500 *parent;
+        struct device *dev;
+        struct mutex lock;
+        u32 irq_base;
+        enum ab8500_gpio_action irq_action;
+        u16 rising;
+        u16 falling;
+};
+/**
+ * to_ab8500_gpio() - get the pointer to ab8500_gpio
+ * @chip:       Member of the structure ab8500_gpio
+ */
+static inline struct ab8500_gpio *to_ab8500_gpio(struct gpio_chip *chip)
+{
+        return container_of(chip, struct ab8500_gpio, chip);
+}
+
+static int ab8500_gpio_set_bits(struct gpio_chip *chip, u8 reg,
+                                        unsigned offset, int val)
+{
+        struct ab8500_gpio *ab8500_gpio = to_ab8500_gpio(chip);
+        u8 pos = offset % 8;
+        int ret;
+
+        reg = reg + (offset / 8);
+        ret = abx500_mask_and_set_register_interruptible(ab8500_gpio->dev,
+                                AB8500_MISC, reg, 1 << pos, val << pos);
+        if (ret < 0)
+                dev_err(ab8500_gpio->dev, "%s write failed\n", __func__);
+        return ret;
+}
+/**
+ * ab8500_gpio_get() - Get the particular GPIO value
+ * @chip: Gpio device
+ * @offset: GPIO number to read
+ */
+static int ab8500_gpio_get(struct gpio_chip *chip, unsigned offset)
+{
+        struct ab8500_gpio *ab8500_gpio = to_ab8500_gpio(chip);
+        u8 mask = 1 << (offset % 8);
+        u8 reg = AB8500_GPIO_OUT1_REG + (offset / 8);
+        int ret;
+        u8 data;
+        ret = abx500_get_register_interruptible(ab8500_gpio->dev, AB8500_MISC,
+                                                reg, &data);
+        if (ret < 0) {
+                dev_err(ab8500_gpio->dev, "%s read failed\n", __func__);
+                return ret;
+        }
+        return (data & mask) >> (offset % 8);
+}
+
+static void ab8500_gpio_set(struct gpio_chip *chip, unsigned offset, int val)
+{
+        struct ab8500_gpio *ab8500_gpio = to_ab8500_gpio(chip);
+        int ret;
+        /* Write the data */
+        ret = ab8500_gpio_set_bits(chip, AB8500_GPIO_OUT1_REG, offset, 1);
+        if (ret < 0)
+                dev_err(ab8500_gpio->dev, "%s write failed\n", __func__);
+}
+
+static int ab8500_gpio_direction_output(struct gpio_chip *chip, unsigned offset,
+                                        int val)
+{
+        int ret;
+        /* set direction as output */
+        ret = ab8500_gpio_set_bits(chip, AB8500_GPIO_DIR1_REG, offset, 1);
+        if (ret < 0)
+                return ret;
+        /* disable pull down */
+        ret = ab8500_gpio_set_bits(chip, AB8500_GPIO_PUD1_REG, offset, 1);
+        if (ret < 0)
+                return ret;
+        /* set the output as 1 or 0 */
+        return ab8500_gpio_set_bits(chip, AB8500_GPIO_OUT1_REG, offset, val);
+
+}
+
+static int ab8500_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
+{
+        /* set the register as input */
+        return ab8500_gpio_set_bits(chip, AB8500_GPIO_DIR1_REG, offset, 0);
+}
+
+static int ab8500_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
+{
+        /*
+         * Only some GPIOs are interrupt capable, and they are
+         * organized in discontiguous clusters:
+         *
+         *      GPIO6 to GPIO13
+         *      GPIO24 and GPIO25
+         *      GPIO36 to GPIO41
+         */
+        static struct ab8500_gpio_irq_cluster {
+                int start;
+                int end;
+        } clusters[] = {
+                {.start = 6,  .end = 13},
+                {.start = 24, .end = 25},
+                {.start = 36, .end = 41},
+        };
+        struct ab8500_gpio *ab8500_gpio = to_ab8500_gpio(chip);
+        int base = ab8500_gpio->irq_base;
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(clusters); i++) {
+                struct ab8500_gpio_irq_cluster *cluster = &clusters[i];
+
+                if (offset >= cluster->start && offset <= cluster->end)
+                        return base + offset - cluster->start;
+
+                /* Advance by the number of gpios in this cluster */
+                base += cluster->end - cluster->start + 1;
+        }
+
+        return -EINVAL;
+}
+
+static struct gpio_chip ab8500gpio_chip = {
+        .label                  = "ab8500_gpio",
+        .owner                  = THIS_MODULE,
+        .direction_input        = ab8500_gpio_direction_input,
+        .get                    = ab8500_gpio_get,
+        .direction_output       = ab8500_gpio_direction_output,
+        .set                    = ab8500_gpio_set,
+        .to_irq                 = ab8500_gpio_to_irq,
+};
+
+static unsigned int irq_to_rising(unsigned int irq)
+{
+        struct ab8500_gpio *ab8500_gpio = get_irq_chip_data(irq);
+        int offset = irq - ab8500_gpio->irq_base;
+        int new_irq = offset +  AB8500_INT_GPIO6R
+                        + ab8500_gpio->parent->irq_base;
+        return new_irq;
+}
+
+static unsigned int irq_to_falling(unsigned int irq)
+{
+        struct ab8500_gpio *ab8500_gpio = get_irq_chip_data(irq);
+        int offset = irq - ab8500_gpio->irq_base;
+        int new_irq = offset +  AB8500_INT_GPIO6F
+                        +  ab8500_gpio->parent->irq_base;
+        return new_irq;
+
+}
+
+static unsigned int rising_to_irq(unsigned int irq, void *dev)
+{
+        struct ab8500_gpio *ab8500_gpio = dev;
+        int offset = irq - AB8500_INT_GPIO6R
+                        - ab8500_gpio->parent->irq_base ;
+        int new_irq = offset + ab8500_gpio->irq_base;
+        return new_irq;
+}
+
+static unsigned int falling_to_irq(unsigned int irq, void *dev)
+{
+        struct ab8500_gpio *ab8500_gpio = dev;
+        int offset = irq - AB8500_INT_GPIO6F
+                        - ab8500_gpio->parent->irq_base ;
+        int new_irq = offset + ab8500_gpio->irq_base;
+        return new_irq;
+
+}
+
+/*
+ * IRQ handler
+ */
+
+static irqreturn_t handle_rising(int irq, void *dev)
+{
+
+        handle_nested_irq(rising_to_irq(irq , dev));
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t handle_falling(int irq, void *dev)
+{
+
+        handle_nested_irq(falling_to_irq(irq, dev));
+        return IRQ_HANDLED;
+}
+
+static void ab8500_gpio_irq_lock(unsigned int irq)
+{
+        struct ab8500_gpio *ab8500_gpio = get_irq_chip_data(irq);
+        mutex_lock(&ab8500_gpio->lock);
+}
+
+static void ab8500_gpio_irq_sync_unlock(unsigned int irq)
+{
+        struct ab8500_gpio *ab8500_gpio = get_irq_chip_data(irq);
+        int offset = irq - ab8500_gpio->irq_base;
+        bool rising = ab8500_gpio->rising & BIT(offset);
+        bool falling = ab8500_gpio->falling & BIT(offset);
+        int ret;
+
+        switch (ab8500_gpio->irq_action)        {
+        case STARTUP:
+                if (rising)
+                        ret = request_threaded_irq(irq_to_rising(irq),
+                                        NULL, handle_rising,
+                                        IRQF_TRIGGER_RISING,
+                                        "ab8500-gpio-r", ab8500_gpio);
+                if (falling)
+                        ret = request_threaded_irq(irq_to_falling(irq),
+                                       NULL, handle_falling,
+                                       IRQF_TRIGGER_FALLING,
+                                       "ab8500-gpio-f", ab8500_gpio);
+                break;
+        case SHUTDOWN:
+                if (rising)
+                        free_irq(irq_to_rising(irq), ab8500_gpio);
+                if (falling)
+                        free_irq(irq_to_falling(irq), ab8500_gpio);
+                break;
+        case MASK:
+                if (rising)
+                        disable_irq(irq_to_rising(irq));
+                if (falling)
+                        disable_irq(irq_to_falling(irq));
+                break;
+        case UNMASK:
+                if (rising)
+                        enable_irq(irq_to_rising(irq));
+                if (falling)
+                        enable_irq(irq_to_falling(irq));
+                break;
+        case NONE:
+                break;
+        }
+        ab8500_gpio->irq_action = NONE;
+        ab8500_gpio->rising &= ~(BIT(offset));
+        ab8500_gpio->falling &= ~(BIT(offset));
+        mutex_unlock(&ab8500_gpio->lock);
+}
+
+
+static void ab8500_gpio_irq_mask(unsigned int irq)
+{
+        struct ab8500_gpio *ab8500_gpio = get_irq_chip_data(irq);
+        ab8500_gpio->irq_action = MASK;
+}
+
+static void ab8500_gpio_irq_unmask(unsigned int irq)
+{
+        struct ab8500_gpio *ab8500_gpio = get_irq_chip_data(irq);
+        ab8500_gpio->irq_action = UNMASK;
+}
+
+static int ab8500_gpio_irq_set_type(unsigned int irq, unsigned int type)
+{
+        struct ab8500_gpio *ab8500_gpio = get_irq_chip_data(irq);
+        int offset = irq - ab8500_gpio->irq_base;
+
+        if (type == IRQ_TYPE_EDGE_BOTH) {
+                ab8500_gpio->rising =  BIT(offset);
+                ab8500_gpio->falling = BIT(offset);
+        } else if (type == IRQ_TYPE_EDGE_RISING) {
+                ab8500_gpio->rising =  BIT(offset);
+        } else  {
+                ab8500_gpio->falling = BIT(offset);
+        }
+        return 0;
+}
+
+unsigned int ab8500_gpio_irq_startup(unsigned int irq)
+{
+        struct ab8500_gpio *ab8500_gpio = get_irq_chip_data(irq);
+        ab8500_gpio->irq_action = STARTUP;
+        return 0;
+}
+
+void ab8500_gpio_irq_shutdown(unsigned int irq)
+{
+        struct ab8500_gpio *ab8500_gpio = get_irq_chip_data(irq);
+        ab8500_gpio->irq_action = SHUTDOWN;
+}
+
+static struct irq_chip ab8500_gpio_irq_chip = {
+        .name                   = "ab8500-gpio",
+        .startup                = ab8500_gpio_irq_startup,
+        .shutdown               = ab8500_gpio_irq_shutdown,
+        .bus_lock               = ab8500_gpio_irq_lock,
+        .bus_sync_unlock        = ab8500_gpio_irq_sync_unlock,
+        .mask                   = ab8500_gpio_irq_mask,
+        .unmask                 = ab8500_gpio_irq_unmask,
+        .set_type               = ab8500_gpio_irq_set_type,
+};
+
+static int ab8500_gpio_irq_init(struct ab8500_gpio *ab8500_gpio)
+{
+        u32 base = ab8500_gpio->irq_base;
+        int irq;
+
+        for (irq = base; irq < base + AB8500_NUM_VIR_GPIO_IRQ ; irq++) {
+                set_irq_chip_data(irq, ab8500_gpio);
+                set_irq_chip_and_handler(irq, &ab8500_gpio_irq_chip,
+                                handle_simple_irq);
+                set_irq_nested_thread(irq, 1);
+#ifdef CONFIG_ARM
+                set_irq_flags(irq, IRQF_VALID);
+#else
+                set_irq_noprobe(irq);
+#endif
+        }
+
+        return 0;
+}
+
+static void ab8500_gpio_irq_remove(struct ab8500_gpio *ab8500_gpio)
+{
+        int base = ab8500_gpio->irq_base;
+        int irq;
+
+        for (irq = base; irq < base + AB8500_NUM_VIR_GPIO_IRQ; irq++) {
+#ifdef CONFIG_ARM
+                set_irq_flags(irq, 0);
+#endif
+                set_irq_chip_and_handler(irq, NULL, NULL);
+                set_irq_chip_data(irq, NULL);
+        }
+}
+
+static int __devinit ab8500_gpio_probe(struct platform_device *pdev)
+{
+        struct ab8500_platform_data *ab8500_pdata =
+                                dev_get_platdata(pdev->dev.parent);
+        struct ab8500_gpio_platform_data *pdata;
+        struct ab8500_gpio *ab8500_gpio;
+        int ret;
+        int i;
+
+        pdata = ab8500_pdata->gpio;
+        if (!pdata)     {
+                dev_err(&pdev->dev, "gpio platform data missing\n");
+                return -ENODEV;
+        }
+
+        ab8500_gpio = kzalloc(sizeof(struct ab8500_gpio), GFP_KERNEL);
+        if (ab8500_gpio == NULL) {
+                dev_err(&pdev->dev, "failed to allocate memory\n");
+                return -ENOMEM;
+        }
+        ab8500_gpio->dev = &pdev->dev;
+        ab8500_gpio->parent = dev_get_drvdata(pdev->dev.parent);
+        ab8500_gpio->chip = ab8500gpio_chip;
+        ab8500_gpio->chip.ngpio = AB8500_NUM_GPIO;
+        ab8500_gpio->chip.dev = &pdev->dev;
+        ab8500_gpio->chip.base = pdata->gpio_base;
+        ab8500_gpio->irq_base = pdata->irq_base;
+        /* initialize the lock */
+        mutex_init(&ab8500_gpio->lock);
+        /*
+         * AB8500 core will handle and clear the IRQ
+         * configre GPIO based on config-reg value.
+         * These values are for selecting the PINs as
+         * GPIO or alternate function
+         */
+        for (i = AB8500_GPIO_SEL1_REG; i <= AB8500_GPIO_SEL6_REG; i++)  {
+                ret = abx500_set_register_interruptible(ab8500_gpio->dev,
+                                AB8500_MISC, i,
+                                pdata->config_reg[i]);
+                if (ret < 0)
+                        goto out_free;
+        }
+        ret = abx500_set_register_interruptible(ab8500_gpio->dev, AB8500_MISC,
+                                AB8500_GPIO_ALTFUN_REG,
+                                pdata->config_reg[ALTFUN_REG_INDEX]);
+        if (ret < 0)
+                goto out_free;
+
+        ret = ab8500_gpio_irq_init(ab8500_gpio);
+        if (ret)
+                goto out_free;
+        ret = gpiochip_add(&ab8500_gpio->chip);
+        if (ret) {
+                dev_err(&pdev->dev, "unable to add gpiochip: %d\n",
+                                ret);
+                goto out_rem_irq;
+        }
+        platform_set_drvdata(pdev, ab8500_gpio);
+        return 0;
+
+out_rem_irq:
+        ab8500_gpio_irq_remove(ab8500_gpio);
+out_free:
+        mutex_destroy(&ab8500_gpio->lock);
+        kfree(ab8500_gpio);
+        return ret;
+}
+
+/*
+ * ab8500_gpio_remove() - remove Ab8500-gpio driver
+ * @pdev :      Platform device registered
+ */
+static int __devexit ab8500_gpio_remove(struct platform_device *pdev)
+{
+        struct ab8500_gpio *ab8500_gpio = platform_get_drvdata(pdev);
+        int ret;
+
+        ret = gpiochip_remove(&ab8500_gpio->chip);
+        if (ret < 0) {
+                dev_err(ab8500_gpio->dev, "unable to remove gpiochip:\
+                                %d\n", ret);
+                return ret;
+        }
+
+        platform_set_drvdata(pdev, NULL);
+        mutex_destroy(&ab8500_gpio->lock);
+        kfree(ab8500_gpio);
+
+        return 0;
+}
+
+static struct platform_driver ab8500_gpio_driver = {
+        .driver = {
+                .name = "ab8500-gpio",
+                .owner = THIS_MODULE,
+        },
+        .probe = ab8500_gpio_probe,
+        .remove = __devexit_p(ab8500_gpio_remove),
+};
+
+static int __init ab8500_gpio_init(void)
+{
+        return platform_driver_register(&ab8500_gpio_driver);
+}
+arch_initcall(ab8500_gpio_init);
+
+static void __exit ab8500_gpio_exit(void)
+{
+        platform_driver_unregister(&ab8500_gpio_driver);
+}
+module_exit(ab8500_gpio_exit);
+
+MODULE_AUTHOR("BIBEK BASU <bibek.basu@stericsson.com>");
+MODULE_DESCRIPTION("Driver allows to use AB8500 unused pins\
+                        to be used as GPIO");
+MODULE_ALIAS("AB8500 GPIO driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/memstick/host/r592.c b/drivers/memstick/host/r592.c
index 767406c95291..700d420a59ac 100644
--- a/drivers/memstick/host/r592.c
+++ b/drivers/memstick/host/r592.c
@@ -23,7 +23,7 @@
 #include <linux/swab.h>
 #include "r592.h"
 
-static int enable_dma = 1;
+static int r592_enable_dma = 1;
 static int debug;
 
 static const char *tpc_names[] = {
@@ -267,7 +267,7 @@ static void r592_stop_dma(struct r592_device *dev, int error)
 /* Test if hardware supports DMA */
 static void r592_check_dma(struct r592_device *dev)
 {
-        dev->dma_capable = enable_dma &&
+        dev->dma_capable = r592_enable_dma &&
                 (r592_read_reg(dev, R592_FIFO_DMA_SETTINGS) &
                         R592_FIFO_DMA_SETTINGS_CAP);
 }
@@ -898,7 +898,7 @@ static void __exit r592_module_exit(void)
 module_init(r592_module_init);
 module_exit(r592_module_exit);
 
-module_param(enable_dma, bool, S_IRUGO);
+module_param_named(enable_dma, r592_enable_dma, bool, S_IRUGO);
 MODULE_PARM_DESC(enable_dma, "Enable usage of the DMA (default)");
 module_param(debug, int, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(debug, "Debug level (0-3)");
diff --git a/drivers/mfd/ab8500-core.c b/drivers/mfd/ab8500-core.c
index 62e33e2258d4..67d01c938284 100644
--- a/drivers/mfd/ab8500-core.c
+++ b/drivers/mfd/ab8500-core.c
@@ -362,6 +362,15 @@ static void ab8500_irq_remove(struct ab8500 *ab8500)
         }
 }
 
+static struct resource ab8500_gpio_resources[] = {
+        {
+                .name   = "GPIO_INT6",
+                .start  = AB8500_INT_GPIO6R,
+                .end    = AB8500_INT_GPIO41F,
+                .flags  = IORESOURCE_IRQ,
+        }
+};
+
 static struct resource ab8500_gpadc_resources[] = {
         {
                 .name   = "HW_CONV_END",
@@ -596,6 +605,11 @@ static struct mfd_cell ab8500_devs[] = {
                 .name = "ab8500-regulator",
         },
         {
+                .name = "ab8500-gpio",
+                .num_resources = ARRAY_SIZE(ab8500_gpio_resources),
+                .resources = ab8500_gpio_resources,
+        },
+        {
                 .name = "ab8500-gpadc",
                 .num_resources = ARRAY_SIZE(ab8500_gpadc_resources),
                 .resources = ab8500_gpadc_resources,
diff --git a/drivers/mfd/ab8500-i2c.c b/drivers/mfd/ab8500-i2c.c
index 6820327adf4a..821e6b86afd2 100644
--- a/drivers/mfd/ab8500-i2c.c
+++ b/drivers/mfd/ab8500-i2c.c
@@ -97,7 +97,7 @@ static void __exit ab8500_i2c_exit(void)
 {
         platform_driver_unregister(&ab8500_i2c_driver);
 }
-subsys_initcall(ab8500_i2c_init);
+arch_initcall(ab8500_i2c_init);
 module_exit(ab8500_i2c_exit);
 
 MODULE_AUTHOR("Mattias WALLIN <mattias.wallin@stericsson.com");
diff --git a/drivers/platform/x86/Kconfig b/drivers/platform/x86/Kconfig
index 222dfb737b11..2ee442c2a5db 100644
--- a/drivers/platform/x86/Kconfig
+++ b/drivers/platform/x86/Kconfig
@@ -101,6 +101,19 @@ config DELL_WMI
           To compile this driver as a module, choose M here: the module will
           be called dell-wmi.
 
+config DELL_WMI_AIO
+        tristate "WMI Hotkeys for Dell All-In-One series"
+        depends on ACPI_WMI
+        depends on INPUT
+        select INPUT_SPARSEKMAP
+        ---help---
+          Say Y here if you want to support WMI-based hotkeys on Dell
+          All-In-One machines.
+
+          To compile this driver as a module, choose M here: the module will
+          be called dell-wmi.
+
+
 config FUJITSU_LAPTOP
         tristate "Fujitsu Laptop Extras"
         depends on ACPI
@@ -438,23 +451,53 @@ config EEEPC_LAPTOP
           Bluetooth, backlight and allows powering on/off some other
           devices.
 
-          If you have an Eee PC laptop, say Y or M here.
+          If you have an Eee PC laptop, say Y or M here. If this driver
+          doesn't work on your Eee PC, try eeepc-wmi instead.
 
-config EEEPC_WMI
-        tristate "Eee PC WMI Hotkey Driver (EXPERIMENTAL)"
+config ASUS_WMI
+        tristate "ASUS WMI Driver (EXPERIMENTAL)"
         depends on ACPI_WMI
         depends on INPUT
+        depends on HWMON
         depends on EXPERIMENTAL
         depends on BACKLIGHT_CLASS_DEVICE
         depends on RFKILL || RFKILL = n
+        depends on HOTPLUG_PCI
         select INPUT_SPARSEKMAP
         select LEDS_CLASS
         select NEW_LEDS
         ---help---
-          Say Y here if you want to support WMI-based hotkeys on Eee PC laptops.
+          Say Y here if you have a WMI aware Asus laptop (like Eee PCs or new
+          Asus Notebooks).
 
           To compile this driver as a module, choose M here: the module will
-          be called eeepc-wmi.
+          be called asus-wmi.
+
+config ASUS_NB_WMI
+        tristate "Asus Notebook WMI Driver (EXPERIMENTAL)"
+        depends on ASUS_WMI
+        ---help---
+          This is a driver for newer Asus notebooks. It adds extra features
+          like wireless radio and bluetooth control, leds, hotkeys, backlight...
+
+          For more informations, see
+          <file:Documentation/ABI/testing/sysfs-platform-asus-wmi>
+
+          If you have an ACPI-WMI compatible Asus Notebook, say Y or M
+          here.
+
+config EEEPC_WMI
+        tristate "Eee PC WMI Driver (EXPERIMENTAL)"
+        depends on ASUS_WMI
+        ---help---
+          This is a driver for newer Eee PC laptops. It adds extra features
+          like wireless radio and bluetooth control, leds, hotkeys, backlight...
+
+          For more informations, see
+          <file:Documentation/ABI/testing/sysfs-platform-asus-wmi>
+
+          If you have an ACPI-WMI compatible Eee PC laptop (>= 1000), say Y or M
+          here.
 
 config ACPI_WMI
         tristate "WMI"
@@ -616,6 +659,21 @@ config GPIO_INTEL_PMIC
           Say Y here to support GPIO via the SCU IPC interface
           on Intel MID platforms.
 
+config INTEL_MID_POWER_BUTTON
+        tristate "power button driver for Intel MID platforms"
+        depends on INTEL_SCU_IPC && INPUT
+        help
+          This driver handles the power button on the Intel MID platforms.
+
+          If unsure, say N.
+
+config INTEL_MFLD_THERMAL
+       tristate "Thermal driver for Intel Medfield platform"
+       depends on INTEL_SCU_IPC && THERMAL
+       help
+         Say Y here to enable thermal driver support for the  Intel Medfield
+         platform.
+
 config RAR_REGISTER
         bool "Restricted Access Region Register Driver"
         depends on PCI && X86_MRST
@@ -672,4 +730,26 @@ config XO1_RFKILL
           Support for enabling/disabling the WLAN interface on the OLPC XO-1
           laptop.
 
+config XO15_EBOOK
+        tristate "OLPC XO-1.5 ebook switch"
+        depends on ACPI && INPUT
+        ---help---
+          Support for the ebook switch on the OLPC XO-1.5 laptop.
+
+          This switch is triggered as the screen is rotated and folded down to
+          convert the device into ebook form.
+
+config SAMSUNG_LAPTOP
+        tristate "Samsung Laptop driver"
+        depends on RFKILL && BACKLIGHT_CLASS_DEVICE && X86
+        ---help---
+          This module implements a driver for a wide range of different
+          Samsung laptops.  It offers control over the different
+          function keys, wireless LED, LCD backlight level, and
+          sometimes provides a "performance_control" sysfs file to allow
+          the performance level of the laptop to be changed.
+
+          To compile this driver as a module, choose M here: the module
+          will be called samsung-laptop.
+
 endif # X86_PLATFORM_DEVICES
diff --git a/drivers/platform/x86/Makefile b/drivers/platform/x86/Makefile
index 299aefb3e74c..029e8861d086 100644
--- a/drivers/platform/x86/Makefile
+++ b/drivers/platform/x86/Makefile
@@ -3,6 +3,8 @@
 # x86 Platform-Specific Drivers
 #
 obj-$(CONFIG_ASUS_LAPTOP)       += asus-laptop.o
+obj-$(CONFIG_ASUS_WMI)          += asus-wmi.o
+obj-$(CONFIG_ASUS_NB_WMI)       += asus-nb-wmi.o
 obj-$(CONFIG_EEEPC_LAPTOP)      += eeepc-laptop.o
 obj-$(CONFIG_EEEPC_WMI)         += eeepc-wmi.o
 obj-$(CONFIG_MSI_LAPTOP)        += msi-laptop.o
@@ -10,6 +12,7 @@ obj-$(CONFIG_ACPI_CMPC)		+= classmate-laptop.o
 obj-$(CONFIG_COMPAL_LAPTOP)     += compal-laptop.o
 obj-$(CONFIG_DELL_LAPTOP)       += dell-laptop.o
 obj-$(CONFIG_DELL_WMI)          += dell-wmi.o
+obj-$(CONFIG_DELL_WMI_AIO)      += dell-wmi-aio.o
 obj-$(CONFIG_ACER_WMI)          += acer-wmi.o
 obj-$(CONFIG_ACERHDF)           += acerhdf.o
 obj-$(CONFIG_HP_ACCEL)          += hp_accel.o
@@ -29,9 +32,13 @@ obj-$(CONFIG_TOPSTAR_LAPTOP)	+= topstar-laptop.o
 obj-$(CONFIG_ACPI_TOSHIBA)      += toshiba_acpi.o
 obj-$(CONFIG_TOSHIBA_BT_RFKILL) += toshiba_bluetooth.o
 obj-$(CONFIG_INTEL_SCU_IPC)     += intel_scu_ipc.o
-obj-$(CONFIG_INTEL_SCU_IPC_UTIL)+= intel_scu_ipcutil.o
+obj-$(CONFIG_INTEL_SCU_IPC_UTIL) += intel_scu_ipcutil.o
+obj-$(CONFIG_INTEL_MFLD_THERMAL) += intel_mid_thermal.o
 obj-$(CONFIG_RAR_REGISTER)      += intel_rar_register.o
 obj-$(CONFIG_INTEL_IPS)         += intel_ips.o
 obj-$(CONFIG_GPIO_INTEL_PMIC)   += intel_pmic_gpio.o
 obj-$(CONFIG_XO1_RFKILL)        += xo1-rfkill.o
+obj-$(CONFIG_XO15_EBOOK)        += xo15-ebook.o
 obj-$(CONFIG_IBM_RTL)           += ibm_rtl.o
+obj-$(CONFIG_SAMSUNG_LAPTOP)    += samsung-laptop.o
+obj-$(CONFIG_INTEL_MFLD_THERMAL)        += intel_mid_thermal.o
diff --git a/drivers/platform/x86/acer-wmi.c b/drivers/platform/x86/acer-wmi.c
index c9784705f6ac..5ea6c3477d17 100644
--- a/drivers/platform/x86/acer-wmi.c
+++ b/drivers/platform/x86/acer-wmi.c
@@ -22,6 +22,8 @@
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/init.h>
@@ -46,12 +48,6 @@ MODULE_AUTHOR("Carlos Corbacho");
 MODULE_DESCRIPTION("Acer Laptop WMI Extras Driver");
 MODULE_LICENSE("GPL");
 
-#define ACER_LOGPREFIX "acer-wmi: "
-#define ACER_ERR KERN_ERR ACER_LOGPREFIX
-#define ACER_NOTICE KERN_NOTICE ACER_LOGPREFIX
-#define ACER_INFO KERN_INFO ACER_LOGPREFIX
-#define ACER_WARNING KERN_WARNING ACER_LOGPREFIX
-
 /*
  * Magic Number
  * Meaning is unknown - this number is required for writing to ACPI for AMW0
@@ -84,7 +80,7 @@ MODULE_LICENSE("GPL");
 #define AMW0_GUID1              "67C3371D-95A3-4C37-BB61-DD47B491DAAB"
 #define AMW0_GUID2              "431F16ED-0C2B-444C-B267-27DEB140CF9C"
 #define WMID_GUID1              "6AF4F258-B401-42FD-BE91-3D4AC2D7C0D3"
-#define WMID_GUID2              "95764E09-FB56-4e83-B31A-37761F60994A"
+#define WMID_GUID2              "95764E09-FB56-4E83-B31A-37761F60994A"
 #define WMID_GUID3              "61EF69EA-865C-4BC3-A502-A0DEBA0CB531"
 
 /*
@@ -93,7 +89,7 @@ MODULE_LICENSE("GPL");
 #define ACERWMID_EVENT_GUID "676AA15E-6A47-4D9F-A2CC-1E6D18D14026"
 
 MODULE_ALIAS("wmi:67C3371D-95A3-4C37-BB61-DD47B491DAAB");
-MODULE_ALIAS("wmi:6AF4F258-B401-42fd-BE91-3D4AC2D7C0D3");
+MODULE_ALIAS("wmi:6AF4F258-B401-42Fd-BE91-3D4AC2D7C0D3");
 MODULE_ALIAS("wmi:676AA15E-6A47-4D9F-A2CC-1E6D18D14026");
 
 enum acer_wmi_event_ids {
@@ -108,7 +104,7 @@ static const struct key_entry acer_wmi_keymap[] = {
         {KE_KEY, 0x23, {KEY_PROG3} },    /* P_Key */
         {KE_KEY, 0x24, {KEY_PROG4} },    /* Social networking_Key */
         {KE_KEY, 0x64, {KEY_SWITCHVIDEOMODE} }, /* Display Switch */
-        {KE_KEY, 0x82, {KEY_F22} },      /* Touch Pad On/Off */
+        {KE_KEY, 0x82, {KEY_TOUCHPAD_TOGGLE} }, /* Touch Pad On/Off */
         {KE_END, 0}
 };
 
@@ -221,6 +217,7 @@ struct acer_debug {
 static struct rfkill *wireless_rfkill;
 static struct rfkill *bluetooth_rfkill;
 static struct rfkill *threeg_rfkill;
+static bool rfkill_inited;
 
 /* Each low-level interface must define at least some of the following */
 struct wmi_interface {
@@ -845,7 +842,7 @@ static void type_aa_dmi_decode(const struct dmi_header *header, void *dummy)
         has_type_aa = true;
         type_aa = (struct hotkey_function_type_aa *) header;
 
-        printk(ACER_INFO "Function bitmap for Communication Button: 0x%x\n",
+        pr_info("Function bitmap for Communication Button: 0x%x\n",
                 type_aa->commun_func_bitmap);
 
         if (type_aa->commun_func_bitmap & ACER_WMID3_GDS_WIRELESS)
@@ -991,6 +988,7 @@ static int __devinit acer_led_init(struct device *dev)
 
 static void acer_led_exit(void)
 {
+        set_u32(LED_OFF, ACER_CAP_MAILLED);
         led_classdev_unregister(&mail_led);
 }
 
@@ -1036,7 +1034,7 @@ static int __devinit acer_backlight_init(struct device *dev)
         bd = backlight_device_register("acer-wmi", dev, NULL, &acer_bl_ops,
                                        &props);
         if (IS_ERR(bd)) {
-                printk(ACER_ERR "Could not register Acer backlight device\n");
+                pr_err("Could not register Acer backlight device\n");
                 acer_backlight_device = NULL;
                 return PTR_ERR(bd);
         }
@@ -1083,8 +1081,7 @@ static acpi_status wmid3_get_device_status(u32 *value, u16 device)
                 return AE_ERROR;
         }
         if (obj->buffer.length != 8) {
-                printk(ACER_WARNING "Unknown buffer length %d\n",
-                        obj->buffer.length);
+                pr_warning("Unknown buffer length %d\n", obj->buffer.length);
                 kfree(obj);
                 return AE_ERROR;
         }
@@ -1093,7 +1090,7 @@ static acpi_status wmid3_get_device_status(u32 *value, u16 device)
         kfree(obj);
 
         if (return_value.error_code || return_value.ec_return_value)
-                printk(ACER_WARNING "Get Device Status failed: "
+                pr_warning("Get Device Status failed: "
                         "0x%x - 0x%x\n", return_value.error_code,
                         return_value.ec_return_value);
         else
@@ -1161,9 +1158,13 @@ static int acer_rfkill_set(void *data, bool blocked)
 {
         acpi_status status;
         u32 cap = (unsigned long)data;
-        status = set_u32(!blocked, cap);
-        if (ACPI_FAILURE(status))
-                return -ENODEV;
+
+        if (rfkill_inited) {
+                status = set_u32(!blocked, cap);
+                if (ACPI_FAILURE(status))
+                        return -ENODEV;
+        }
+
         return 0;
 }
 
@@ -1187,14 +1188,16 @@ static struct rfkill *acer_rfkill_register(struct device *dev,
                 return ERR_PTR(-ENOMEM);
 
         status = get_device_status(&state, cap);
-        if (ACPI_SUCCESS(status))
-                rfkill_init_sw_state(rfkill_dev, !state);
 
         err = rfkill_register(rfkill_dev);
         if (err) {
                 rfkill_destroy(rfkill_dev);
                 return ERR_PTR(err);
         }
+
+        if (ACPI_SUCCESS(status))
+                rfkill_set_sw_state(rfkill_dev, !state);
+
         return rfkill_dev;
 }
 
@@ -1229,14 +1232,19 @@ static int acer_rfkill_init(struct device *dev)
                 }
         }
 
-        schedule_delayed_work(&acer_rfkill_work, round_jiffies_relative(HZ));
+        rfkill_inited = true;
+
+        if (ec_raw_mode || !wmi_has_guid(ACERWMID_EVENT_GUID))
+                schedule_delayed_work(&acer_rfkill_work,
+                        round_jiffies_relative(HZ));
 
         return 0;
 }
 
 static void acer_rfkill_exit(void)
 {
-        cancel_delayed_work_sync(&acer_rfkill_work);
+        if (ec_raw_mode || !wmi_has_guid(ACERWMID_EVENT_GUID))
+                cancel_delayed_work_sync(&acer_rfkill_work);
 
         rfkill_unregister(wireless_rfkill);
         rfkill_destroy(wireless_rfkill);
@@ -1309,7 +1317,7 @@ static void acer_wmi_notify(u32 value, void *context)
 
         status = wmi_get_event_data(value, &response);
         if (status != AE_OK) {
-                printk(ACER_WARNING "bad event status 0x%x\n", status);
+                pr_warning("bad event status 0x%x\n", status);
                 return;
         }
 
@@ -1318,14 +1326,12 @@ static void acer_wmi_notify(u32 value, void *context)
         if (!obj)
                 return;
         if (obj->type != ACPI_TYPE_BUFFER) {
-                printk(ACER_WARNING "Unknown response received %d\n",
-                        obj->type);
+                pr_warning("Unknown response received %d\n", obj->type);
                 kfree(obj);
                 return;
         }
         if (obj->buffer.length != 8) {
-                printk(ACER_WARNING "Unknown buffer length %d\n",
-                        obj->buffer.length);
+                pr_warning("Unknown buffer length %d\n", obj->buffer.length);
                 kfree(obj);
                 return;
         }
@@ -1335,13 +1341,26 @@ static void acer_wmi_notify(u32 value, void *context)
 
         switch (return_value.function) {
         case WMID_HOTKEY_EVENT:
+                if (return_value.device_state) {
+                        u16 device_state = return_value.device_state;
+                        pr_debug("deivces states: 0x%x\n", device_state);
+                        if (has_cap(ACER_CAP_WIRELESS))
+                                rfkill_set_sw_state(wireless_rfkill,
+                                !(device_state & ACER_WMID3_GDS_WIRELESS));
+                        if (has_cap(ACER_CAP_BLUETOOTH))
+                                rfkill_set_sw_state(bluetooth_rfkill,
+                                !(device_state & ACER_WMID3_GDS_BLUETOOTH));
+                        if (has_cap(ACER_CAP_THREEG))
+                                rfkill_set_sw_state(threeg_rfkill,
+                                !(device_state & ACER_WMID3_GDS_THREEG));
+                }
                 if (!sparse_keymap_report_event(acer_wmi_input_dev,
                                 return_value.key_num, 1, true))
-                        printk(ACER_WARNING "Unknown key number - 0x%x\n",
+                        pr_warning("Unknown key number - 0x%x\n",
                                 return_value.key_num);
                 break;
         default:
-                printk(ACER_WARNING "Unknown function number - %d - %d\n",
+                pr_warning("Unknown function number - %d - %d\n",
                         return_value.function, return_value.key_num);
                 break;
         }
@@ -1370,8 +1389,7 @@ wmid3_set_lm_mode(struct lm_input_params *params,
                 return AE_ERROR;
         }
         if (obj->buffer.length != 4) {
-                printk(ACER_WARNING "Unknown buffer length %d\n",
-                       obj->buffer.length);
+                pr_warning("Unknown buffer length %d\n", obj->buffer.length);
                 kfree(obj);
                 return AE_ERROR;
         }
@@ -1396,11 +1414,11 @@ static int acer_wmi_enable_ec_raw(void)
         status = wmid3_set_lm_mode(&params, &return_value);
 
         if (return_value.error_code || return_value.ec_return_value)
-                printk(ACER_WARNING "Enabling EC raw mode failed: "
+                pr_warning("Enabling EC raw mode failed: "
                        "0x%x - 0x%x\n", return_value.error_code,
                        return_value.ec_return_value);
         else
-                printk(ACER_INFO "Enabled EC raw mode");
+                pr_info("Enabled EC raw mode");
 
         return status;
 }
@@ -1419,7 +1437,7 @@ static int acer_wmi_enable_lm(void)
         status = wmid3_set_lm_mode(&params, &return_value);
 
         if (return_value.error_code || return_value.ec_return_value)
-                printk(ACER_WARNING "Enabling Launch Manager failed: "
+                pr_warning("Enabling Launch Manager failed: "
                        "0x%x - 0x%x\n", return_value.error_code,
                        return_value.ec_return_value);
 
@@ -1553,6 +1571,7 @@ pm_message_t state)
 
         if (has_cap(ACER_CAP_MAILLED)) {
                 get_u32(&value, ACER_CAP_MAILLED);
+                set_u32(LED_OFF, ACER_CAP_MAILLED);
                 data->mailled = value;
         }
 
@@ -1580,6 +1599,17 @@ static int acer_platform_resume(struct platform_device *device)
         return 0;
 }
 
+static void acer_platform_shutdown(struct platform_device *device)
+{
+        struct acer_data *data = &interface->data;
+
+        if (!data)
+                return;
+
+        if (has_cap(ACER_CAP_MAILLED))
+                set_u32(LED_OFF, ACER_CAP_MAILLED);
+}
+
 static struct platform_driver acer_platform_driver = {
         .driver = {
                 .name = "acer-wmi",
@@ -1589,6 +1619,7 @@ static struct platform_driver acer_platform_driver = {
         .remove = acer_platform_remove,
         .suspend = acer_platform_suspend,
         .resume = acer_platform_resume,
+        .shutdown = acer_platform_shutdown,
 };
 
 static struct platform_device *acer_platform_device;
@@ -1636,7 +1667,7 @@ static int create_debugfs(void)
 {
         interface->debug.root = debugfs_create_dir("acer-wmi", NULL);
         if (!interface->debug.root) {
-                printk(ACER_ERR "Failed to create debugfs directory");
+                pr_err("Failed to create debugfs directory");
                 return -ENOMEM;
         }
 
@@ -1657,11 +1688,10 @@ static int __init acer_wmi_init(void)
 {
         int err;
 
-        printk(ACER_INFO "Acer Laptop ACPI-WMI Extras\n");
+        pr_info("Acer Laptop ACPI-WMI Extras\n");
 
         if (dmi_check_system(acer_blacklist)) {
-                printk(ACER_INFO "Blacklisted hardware detected - "
-                                "not loading\n");
+                pr_info("Blacklisted hardware detected - not loading\n");
                 return -ENODEV;
         }
 
@@ -1678,12 +1708,11 @@ static int __init acer_wmi_init(void)
 
         if (wmi_has_guid(WMID_GUID2) && interface) {
                 if (ACPI_FAILURE(WMID_set_capabilities())) {
-                        printk(ACER_ERR "Unable to detect available WMID "
-                                        "devices\n");
+                        pr_err("Unable to detect available WMID devices\n");
                         return -ENODEV;
                 }
         } else if (!wmi_has_guid(WMID_GUID2) && interface) {
-                printk(ACER_ERR "No WMID device detection method found\n");
+                pr_err("No WMID device detection method found\n");
                 return -ENODEV;
         }
 
@@ -1691,8 +1720,7 @@ static int __init acer_wmi_init(void)
                 interface = &AMW0_interface;
 
                 if (ACPI_FAILURE(AMW0_set_capabilities())) {
-                        printk(ACER_ERR "Unable to detect available AMW0 "
-                                        "devices\n");
+                        pr_err("Unable to detect available AMW0 devices\n");
                         return -ENODEV;
                 }
         }
@@ -1701,8 +1729,7 @@ static int __init acer_wmi_init(void)
                 AMW0_find_mailled();
 
         if (!interface) {
-                printk(ACER_INFO "No or unsupported WMI interface, unable to "
-                                "load\n");
+                pr_err("No or unsupported WMI interface, unable to load\n");
                 return -ENODEV;
         }
 
@@ -1710,22 +1737,22 @@ static int __init acer_wmi_init(void)
 
         if (acpi_video_backlight_support() && has_cap(ACER_CAP_BRIGHTNESS)) {
                 interface->capability &= ~ACER_CAP_BRIGHTNESS;
-                printk(ACER_INFO "Brightness must be controlled by "
+                pr_info("Brightness must be controlled by "
                        "generic video driver\n");
         }
 
         if (wmi_has_guid(WMID_GUID3)) {
                 if (ec_raw_mode) {
                         if (ACPI_FAILURE(acer_wmi_enable_ec_raw())) {
-                                printk(ACER_ERR "Cannot enable EC raw mode\n");
+                                pr_err("Cannot enable EC raw mode\n");
                                 return -ENODEV;
                         }
                 } else if (ACPI_FAILURE(acer_wmi_enable_lm())) {
-                        printk(ACER_ERR "Cannot enable Launch Manager mode\n");
+                        pr_err("Cannot enable Launch Manager mode\n");
                         return -ENODEV;
                 }
         } else if (ec_raw_mode) {
-                printk(ACER_INFO "No WMID EC raw mode enable method\n");
+                pr_info("No WMID EC raw mode enable method\n");
         }
 
         if (wmi_has_guid(ACERWMID_EVENT_GUID)) {
@@ -1736,7 +1763,7 @@ static int __init acer_wmi_init(void)
 
         err = platform_driver_register(&acer_platform_driver);
         if (err) {
-                printk(ACER_ERR "Unable to register platform driver.\n");
+                pr_err("Unable to register platform driver.\n");
                 goto error_platform_register;
         }
 
@@ -1791,7 +1818,7 @@ static void __exit acer_wmi_exit(void)
         platform_device_unregister(acer_platform_device);
         platform_driver_unregister(&acer_platform_driver);
 
-        printk(ACER_INFO "Acer Laptop WMI Extras unloaded\n");
+        pr_info("Acer Laptop WMI Extras unloaded\n");
         return;
 }
 
diff --git a/drivers/platform/x86/asus-laptop.c b/drivers/platform/x86/asus-laptop.c
index 5a6f7d7575d6..c53b3ff7978a 100644
--- a/drivers/platform/x86/asus-laptop.c
+++ b/drivers/platform/x86/asus-laptop.c
@@ -29,7 +29,7 @@
  *  John Belmonte  - ACPI code for Toshiba laptop was a good starting point.
  *  Eric Burghard  - LED display support for W1N
  *  Josh Green     - Light Sens support
- *  Thomas Tuttle  - His first patch for led support was very helpfull
+ *  Thomas Tuttle  - His first patch for led support was very helpful
  *  Sam Lin        - GPS support
  */
 
@@ -50,6 +50,7 @@
 #include <linux/input/sparse-keymap.h>
 #include <linux/rfkill.h>
 #include <linux/slab.h>
+#include <linux/dmi.h>
 #include <acpi/acpi_drivers.h>
 #include <acpi/acpi_bus.h>
 
@@ -157,46 +158,9 @@ MODULE_PARM_DESC(wwan_status, "Set the wireless status on boot "
 #define METHOD_BRIGHTNESS_SET   "SPLV"
 #define METHOD_BRIGHTNESS_GET   "GPLV"
 
-/* Backlight */
-static acpi_handle lcd_switch_handle;
-static char *lcd_switch_paths[] = {
-  "\\_SB.PCI0.SBRG.EC0._Q10",   /* All new models */
-  "\\_SB.PCI0.ISA.EC0._Q10",    /* A1x */
-  "\\_SB.PCI0.PX40.ECD0._Q10",  /* L3C */
-  "\\_SB.PCI0.PX40.EC0.Q10",    /* M1A */
-  "\\_SB.PCI0.LPCB.EC0._Q10",   /* P30 */
-  "\\_SB.PCI0.LPCB.EC0._Q0E", /* P30/P35 */
-  "\\_SB.PCI0.PX40.Q10",        /* S1x */
-  "\\Q10"};             /* A2x, L2D, L3D, M2E */
-
 /* Display */
 #define METHOD_SWITCH_DISPLAY   "SDSP"
 
-static acpi_handle display_get_handle;
-static char *display_get_paths[] = {
-  /* A6B, A6K A6R A7D F3JM L4R M6R A3G M6A M6V VX-1 V6J V6V W3Z */
-  "\\_SB.PCI0.P0P1.VGA.GETD",
-  /* A3E A4K, A4D A4L A6J A7J A8J Z71V M9V S5A M5A z33A W1Jc W2V G1 */
-  "\\_SB.PCI0.P0P2.VGA.GETD",
-  /* A6V A6Q */
-  "\\_SB.PCI0.P0P3.VGA.GETD",
-  /* A6T, A6M */
-  "\\_SB.PCI0.P0PA.VGA.GETD",
-  /* L3C */
-  "\\_SB.PCI0.PCI1.VGAC.NMAP",
-  /* Z96F */
-  "\\_SB.PCI0.VGA.GETD",
-  /* A2D */
-  "\\ACTD",
-  /* A4G Z71A W1N W5A W5F M2N M3N M5N M6N S1N S5N */
-  "\\ADVG",
-  /* P30 */
-  "\\DNXT",
-  /* A2H D1 L2D L3D L3H L2E L5D L5C M1A M2E L4L W3V */
-  "\\INFB",
-  /* A3F A6F A3N A3L M6N W3N W6A */
-  "\\SSTE"};
-
 #define METHOD_ALS_CONTROL      "ALSC" /* Z71A Z71V */
 #define METHOD_ALS_LEVEL        "ALSL" /* Z71A Z71V */
 
@@ -246,7 +210,6 @@ struct asus_laptop {
 
         int wireless_status;
         bool have_rsts;
-        int lcd_state;
 
         struct rfkill *gps_rfkill;
 
@@ -559,48 +522,6 @@ error:
 /*
  * Backlight device
  */
-static int asus_lcd_status(struct asus_laptop *asus)
-{
-        return asus->lcd_state;
-}
-
-static int asus_lcd_set(struct asus_laptop *asus, int value)
-{
-        int lcd = 0;
-        acpi_status status = 0;
-
-        lcd = !!value;
-
-        if (lcd == asus_lcd_status(asus))
-                return 0;
-
-        if (!lcd_switch_handle)
-                return -ENODEV;
-
-        status = acpi_evaluate_object(lcd_switch_handle,
-                                      NULL, NULL, NULL);
-
-        if (ACPI_FAILURE(status)) {
-                pr_warning("Error switching LCD\n");
-                return -ENODEV;
-        }
-
-        asus->lcd_state = lcd;
-        return 0;
-}
-
-static void lcd_blank(struct asus_laptop *asus, int blank)
-{
-        struct backlight_device *bd = asus->backlight_device;
-
-        asus->lcd_state = (blank == FB_BLANK_UNBLANK);
-
-        if (bd) {
-                bd->props.power = blank;
-                backlight_update_status(bd);
-        }
-}
-
 static int asus_read_brightness(struct backlight_device *bd)
 {
         struct asus_laptop *asus = bl_get_data(bd);
@@ -628,16 +549,9 @@ static int asus_set_brightness(struct backlight_device *bd, int value)
 
 static int update_bl_status(struct backlight_device *bd)
 {
-        struct asus_laptop *asus = bl_get_data(bd);
-        int rv;
         int value = bd->props.brightness;
 
-        rv = asus_set_brightness(bd, value);
-        if (rv)
-                return rv;
-
-        value = (bd->props.power == FB_BLANK_UNBLANK) ? 1 : 0;
-        return asus_lcd_set(asus, value);
+        return asus_set_brightness(bd, value);
 }
 
 static const struct backlight_ops asusbl_ops = {
@@ -661,8 +575,7 @@ static int asus_backlight_init(struct asus_laptop *asus)
         struct backlight_properties props;
 
         if (acpi_check_handle(asus->handle, METHOD_BRIGHTNESS_GET, NULL) ||
-            acpi_check_handle(asus->handle, METHOD_BRIGHTNESS_SET, NULL) ||
-            !lcd_switch_handle)
+            acpi_check_handle(asus->handle, METHOD_BRIGHTNESS_SET, NULL))
                 return 0;
 
         memset(&props, 0, sizeof(struct backlight_properties));
@@ -971,41 +884,6 @@ static void asus_set_display(struct asus_laptop *asus, int value)
         return;
 }
 
-static int read_display(struct asus_laptop *asus)
-{
-        unsigned long long value = 0;
-        acpi_status rv = AE_OK;
-
-        /*
-         * In most of the case, we know how to set the display, but sometime
-         * we can't read it
-         */
-        if (display_get_handle) {
-                rv = acpi_evaluate_integer(display_get_handle, NULL,
-                                           NULL, &value);
-                if (ACPI_FAILURE(rv))
-                        pr_warning("Error reading display status\n");
-        }
-
-        value &= 0x0F; /* needed for some models, shouldn't hurt others */
-
-        return value;
-}
-
-/*
- * Now, *this* one could be more user-friendly, but so far, no-one has
- * complained. The significance of bits is the same as in store_disp()
- */
-static ssize_t show_disp(struct device *dev,
-                         struct device_attribute *attr, char *buf)
-{
-        struct asus_laptop *asus = dev_get_drvdata(dev);
-
-        if (!display_get_handle)
-                return -ENODEV;
-        return sprintf(buf, "%d\n", read_display(asus));
-}
-
 /*
  * Experimental support for display switching. As of now: 1 should activate
  * the LCD output, 2 should do for CRT, 4 for TV-Out and 8 for DVI.
@@ -1247,15 +1125,6 @@ static void asus_acpi_notify(struct acpi_device *device, u32 event)
         struct asus_laptop *asus = acpi_driver_data(device);
         u16 count;
 
-        /*
-         * We need to tell the backlight device when the backlight power is
-         * switched
-         */
-        if (event == ATKD_LCD_ON)
-                lcd_blank(asus, FB_BLANK_UNBLANK);
-        else if (event == ATKD_LCD_OFF)
-                lcd_blank(asus, FB_BLANK_POWERDOWN);
-
         /* TODO Find a better way to handle events count. */
         count = asus->event_count[event % 128]++;
         acpi_bus_generate_proc_event(asus->device, event, count);
@@ -1282,7 +1151,7 @@ static DEVICE_ATTR(bluetooth, S_IRUGO | S_IWUSR,
                    show_bluetooth, store_bluetooth);
 static DEVICE_ATTR(wimax, S_IRUGO | S_IWUSR, show_wimax, store_wimax);
 static DEVICE_ATTR(wwan, S_IRUGO | S_IWUSR, show_wwan, store_wwan);
-static DEVICE_ATTR(display, S_IRUGO | S_IWUSR, show_disp, store_disp);
+static DEVICE_ATTR(display, S_IWUSR, NULL, store_disp);
 static DEVICE_ATTR(ledd, S_IRUGO | S_IWUSR, show_ledd, store_ledd);
 static DEVICE_ATTR(ls_level, S_IRUGO | S_IWUSR, show_lslvl, store_lslvl);
 static DEVICE_ATTR(ls_switch, S_IRUGO | S_IWUSR, show_lssw, store_lssw);
@@ -1393,26 +1262,6 @@ static struct platform_driver platform_driver = {
         }
 };
 
-static int asus_handle_init(char *name, acpi_handle * handle,
-                            char **paths, int num_paths)
-{
-        int i;
-        acpi_status status;
-
-        for (i = 0; i < num_paths; i++) {
-                status = acpi_get_handle(NULL, paths[i], handle);
-                if (ACPI_SUCCESS(status))
-                        return 0;
-        }
-
-        *handle = NULL;
-        return -ENODEV;
-}
-
-#define ASUS_HANDLE_INIT(object)                                        \
-        asus_handle_init(#object, &object##_handle, object##_paths,     \
-                         ARRAY_SIZE(object##_paths))
-
 /*
  * This function is used to initialize the context with right values. In this
  * method, we can make all the detection we want, and modify the asus_laptop
@@ -1498,10 +1347,6 @@ static int asus_laptop_get_info(struct asus_laptop *asus)
         if (!acpi_check_handle(asus->handle, METHOD_WL_STATUS, NULL))
                 asus->have_rsts = true;
 
-        /* Scheduled for removal */
-        ASUS_HANDLE_INIT(lcd_switch);
-        ASUS_HANDLE_INIT(display_get);
-
         kfree(model);
 
         return AE_OK;
@@ -1553,10 +1398,23 @@ static int __devinit asus_acpi_init(struct asus_laptop *asus)
                 asus_als_level(asus, asus->light_level);
         }
 
-        asus->lcd_state = 1; /* LCD should be on when the module load */
         return result;
 }
 
+static void __devinit asus_dmi_check(void)
+{
+        const char *model;
+
+        model = dmi_get_system_info(DMI_PRODUCT_NAME);
+        if (!model)
+                return;
+
+        /* On L1400B WLED control the sound card, don't mess with it ... */
+        if (strncmp(model, "L1400B", 6) == 0) {
+                wlan_status = -1;
+        }
+}
+
 static bool asus_device_present;
 
 static int __devinit asus_acpi_add(struct acpi_device *device)
@@ -1575,6 +1433,8 @@ static int __devinit asus_acpi_add(struct acpi_device *device)
         device->driver_data = asus;
         asus->device = device;
 
+        asus_dmi_check();
+
         result = asus_acpi_init(asus);
         if (result)
                 goto fail_platform;
diff --git a/drivers/platform/x86/asus-nb-wmi.c b/drivers/platform/x86/asus-nb-wmi.c
new file mode 100644
index 000000000000..0580d99b0798
--- /dev/null
+++ b/drivers/platform/x86/asus-nb-wmi.c
@@ -0,0 +1,98 @@
+/*
+ * Asus Notebooks WMI hotkey driver
+ *
+ * Copyright(C) 2010 Corentin Chary <corentin.chary@gmail.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/input.h>
+#include <linux/input/sparse-keymap.h>
+
+#include "asus-wmi.h"
+
+#define ASUS_NB_WMI_FILE        "asus-nb-wmi"
+
+MODULE_AUTHOR("Corentin Chary <corentincj@iksaif.net>");
+MODULE_DESCRIPTION("Asus Notebooks WMI Hotkey Driver");
+MODULE_LICENSE("GPL");
+
+#define ASUS_NB_WMI_EVENT_GUID  "0B3CBB35-E3C2-45ED-91C2-4C5A6D195D1C"
+
+MODULE_ALIAS("wmi:"ASUS_NB_WMI_EVENT_GUID);
+
+static const struct key_entry asus_nb_wmi_keymap[] = {
+        { KE_KEY, 0x30, { KEY_VOLUMEUP } },
+        { KE_KEY, 0x31, { KEY_VOLUMEDOWN } },
+        { KE_KEY, 0x32, { KEY_MUTE } },
+        { KE_KEY, 0x33, { KEY_DISPLAYTOGGLE } }, /* LCD on */
+        { KE_KEY, 0x34, { KEY_DISPLAY_OFF } }, /* LCD off */
+        { KE_KEY, 0x40, { KEY_PREVIOUSSONG } },
+        { KE_KEY, 0x41, { KEY_NEXTSONG } },
+        { KE_KEY, 0x43, { KEY_STOPCD } },
+        { KE_KEY, 0x45, { KEY_PLAYPAUSE } },
+        { KE_KEY, 0x4c, { KEY_MEDIA } },
+        { KE_KEY, 0x50, { KEY_EMAIL } },
+        { KE_KEY, 0x51, { KEY_WWW } },
+        { KE_KEY, 0x55, { KEY_CALC } },
+        { KE_KEY, 0x5C, { KEY_F15 } },  /* Power Gear key */
+        { KE_KEY, 0x5D, { KEY_WLAN } },
+        { KE_KEY, 0x5E, { KEY_WLAN } },
+        { KE_KEY, 0x5F, { KEY_WLAN } },
+        { KE_KEY, 0x60, { KEY_SWITCHVIDEOMODE } },
+        { KE_KEY, 0x61, { KEY_SWITCHVIDEOMODE } },
+        { KE_KEY, 0x62, { KEY_SWITCHVIDEOMODE } },
+        { KE_KEY, 0x63, { KEY_SWITCHVIDEOMODE } },
+        { KE_KEY, 0x6B, { KEY_TOUCHPAD_TOGGLE } },
+        { KE_KEY, 0x7E, { KEY_BLUETOOTH } },
+        { KE_KEY, 0x7D, { KEY_BLUETOOTH } },
+        { KE_KEY, 0x82, { KEY_CAMERA } },
+        { KE_KEY, 0x88, { KEY_RFKILL  } },
+        { KE_KEY, 0x8A, { KEY_PROG1 } },
+        { KE_KEY, 0x95, { KEY_MEDIA } },
+        { KE_KEY, 0x99, { KEY_PHONE } },
+        { KE_KEY, 0xb5, { KEY_CALC } },
+        { KE_KEY, 0xc4, { KEY_KBDILLUMUP } },
+        { KE_KEY, 0xc5, { KEY_KBDILLUMDOWN } },
+        { KE_END, 0},
+};
+
+static struct asus_wmi_driver asus_nb_wmi_driver = {
+        .name = ASUS_NB_WMI_FILE,
+        .owner = THIS_MODULE,
+        .event_guid = ASUS_NB_WMI_EVENT_GUID,
+        .keymap = asus_nb_wmi_keymap,
+        .input_name = "Asus WMI hotkeys",
+        .input_phys = ASUS_NB_WMI_FILE "/input0",
+};
+
+
+static int __init asus_nb_wmi_init(void)
+{
+        return asus_wmi_register_driver(&asus_nb_wmi_driver);
+}
+
+static void __exit asus_nb_wmi_exit(void)
+{
+        asus_wmi_unregister_driver(&asus_nb_wmi_driver);
+}
+
+module_init(asus_nb_wmi_init);
+module_exit(asus_nb_wmi_exit);
diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c
new file mode 100644
index 000000000000..efc776cb0c66
--- /dev/null
+++ b/drivers/platform/x86/asus-wmi.c
@@ -0,0 +1,1656 @@
+/*
+ * Asus PC WMI hotkey driver
+ *
+ * Copyright(C) 2010 Intel Corporation.
+ * Copyright(C) 2010-2011 Corentin Chary <corentin.chary@gmail.com>
+ *
+ * Portions based on wistron_btns.c:
+ * Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
+ * Copyright (C) 2005 Bernhard Rosenkraenzer <bero@arklinux.org>
+ * Copyright (C) 2005 Dmitry Torokhov <dtor@mail.ru>
+ *
+ *  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/types.h>
+#include <linux/slab.h>
+#include <linux/input.h>
+#include <linux/input/sparse-keymap.h>
+#include <linux/fb.h>
+#include <linux/backlight.h>
+#include <linux/leds.h>
+#include <linux/rfkill.h>
+#include <linux/pci.h>
+#include <linux/pci_hotplug.h>
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
+#include <linux/debugfs.h>
+#include <linux/seq_file.h>
+#include <linux/platform_device.h>
+#include <acpi/acpi_bus.h>
+#include <acpi/acpi_drivers.h>
+
+#include "asus-wmi.h"
+
+MODULE_AUTHOR("Corentin Chary <corentincj@iksaif.net>, "
+              "Yong Wang <yong.y.wang@intel.com>");
+MODULE_DESCRIPTION("Asus Generic WMI Driver");
+MODULE_LICENSE("GPL");
+
+#define to_platform_driver(drv)                                 \
+        (container_of((drv), struct platform_driver, driver))
+
+#define to_asus_wmi_driver(pdrv)                                        \
+        (container_of((pdrv), struct asus_wmi_driver, platform_driver))
+
+#define ASUS_WMI_MGMT_GUID      "97845ED0-4E6D-11DE-8A39-0800200C9A66"
+
+#define NOTIFY_BRNUP_MIN                0x11
+#define NOTIFY_BRNUP_MAX                0x1f
+#define NOTIFY_BRNDOWN_MIN              0x20
+#define NOTIFY_BRNDOWN_MAX              0x2e
+
+/* WMI Methods */
+#define ASUS_WMI_METHODID_SPEC          0x43455053 /* BIOS SPECification */
+#define ASUS_WMI_METHODID_SFBD          0x44424653 /* Set First Boot Device */
+#define ASUS_WMI_METHODID_GLCD          0x44434C47 /* Get LCD status */
+#define ASUS_WMI_METHODID_GPID          0x44495047 /* Get Panel ID?? (Resol) */
+#define ASUS_WMI_METHODID_QMOD          0x444F4D51 /* Quiet MODe */
+#define ASUS_WMI_METHODID_SPLV          0x4C425053 /* Set Panel Light Value */
+#define ASUS_WMI_METHODID_SFUN          0x4E554653 /* FUNCtionalities */
+#define ASUS_WMI_METHODID_SDSP          0x50534453 /* Set DiSPlay output */
+#define ASUS_WMI_METHODID_GDSP          0x50534447 /* Get DiSPlay output */
+#define ASUS_WMI_METHODID_DEVP          0x50564544 /* DEVice Policy */
+#define ASUS_WMI_METHODID_OSVR          0x5256534F /* OS VeRsion */
+#define ASUS_WMI_METHODID_DSTS          0x53544344 /* Device STatuS */
+#define ASUS_WMI_METHODID_DSTS2         0x53545344 /* Device STatuS #2*/
+#define ASUS_WMI_METHODID_BSTS          0x53545342 /* Bios STatuS ? */
+#define ASUS_WMI_METHODID_DEVS          0x53564544 /* DEVice Set */
+#define ASUS_WMI_METHODID_CFVS          0x53564643 /* CPU Frequency Volt Set */
+#define ASUS_WMI_METHODID_KBFT          0x5446424B /* KeyBoard FilTer */
+#define ASUS_WMI_METHODID_INIT          0x54494E49 /* INITialize */
+#define ASUS_WMI_METHODID_HKEY          0x59454B48 /* Hot KEY ?? */
+
+#define ASUS_WMI_UNSUPPORTED_METHOD     0xFFFFFFFE
+
+/* Wireless */
+#define ASUS_WMI_DEVID_HW_SWITCH        0x00010001
+#define ASUS_WMI_DEVID_WIRELESS_LED     0x00010002
+#define ASUS_WMI_DEVID_WLAN             0x00010011
+#define ASUS_WMI_DEVID_BLUETOOTH        0x00010013
+#define ASUS_WMI_DEVID_GPS              0x00010015
+#define ASUS_WMI_DEVID_WIMAX            0x00010017
+#define ASUS_WMI_DEVID_WWAN3G           0x00010019
+#define ASUS_WMI_DEVID_UWB              0x00010021
+
+/* Leds */
+/* 0x000200XX and 0x000400XX */
+
+/* Backlight and Brightness */
+#define ASUS_WMI_DEVID_BACKLIGHT        0x00050011
+#define ASUS_WMI_DEVID_BRIGHTNESS       0x00050012
+#define ASUS_WMI_DEVID_KBD_BACKLIGHT    0x00050021
+#define ASUS_WMI_DEVID_LIGHT_SENSOR     0x00050022 /* ?? */
+
+/* Misc */
+#define ASUS_WMI_DEVID_CAMERA           0x00060013
+
+/* Storage */
+#define ASUS_WMI_DEVID_CARDREADER       0x00080013
+
+/* Input */
+#define ASUS_WMI_DEVID_TOUCHPAD         0x00100011
+#define ASUS_WMI_DEVID_TOUCHPAD_LED     0x00100012
+
+/* Fan, Thermal */
+#define ASUS_WMI_DEVID_THERMAL_CTRL     0x00110011
+#define ASUS_WMI_DEVID_FAN_CTRL         0x00110012
+
+/* Power */
+#define ASUS_WMI_DEVID_PROCESSOR_STATE  0x00120012
+
+/* DSTS masks */
+#define ASUS_WMI_DSTS_STATUS_BIT        0x00000001
+#define ASUS_WMI_DSTS_UNKNOWN_BIT       0x00000002
+#define ASUS_WMI_DSTS_PRESENCE_BIT      0x00010000
+#define ASUS_WMI_DSTS_USER_BIT          0x00020000
+#define ASUS_WMI_DSTS_BIOS_BIT          0x00040000
+#define ASUS_WMI_DSTS_BRIGHTNESS_MASK   0x000000FF
+#define ASUS_WMI_DSTS_MAX_BRIGTH_MASK   0x0000FF00
+
+struct bios_args {
+        u32 arg0;
+        u32 arg1;
+} __packed;
+
+/*
+ * <platform>/    - debugfs root directory
+ *   dev_id      - current dev_id
+ *   ctrl_param  - current ctrl_param
+ *   method_id   - current method_id
+ *   devs        - call DEVS(dev_id, ctrl_param) and print result
+ *   dsts        - call DSTS(dev_id)  and print result
+ *   call        - call method_id(dev_id, ctrl_param) and print result
+ */
+struct asus_wmi_debug {
+        struct dentry *root;
+        u32 method_id;
+        u32 dev_id;
+        u32 ctrl_param;
+};
+
+struct asus_rfkill {
+        struct asus_wmi *asus;
+        struct rfkill *rfkill;
+        u32 dev_id;
+};
+
+struct asus_wmi {
+        int dsts_id;
+        int spec;
+        int sfun;
+
+        struct input_dev *inputdev;
+        struct backlight_device *backlight_device;
+        struct device *hwmon_device;
+        struct platform_device *platform_device;
+
+        struct led_classdev tpd_led;
+        int tpd_led_wk;
+        struct workqueue_struct *led_workqueue;
+        struct work_struct tpd_led_work;
+
+        struct asus_rfkill wlan;
+        struct asus_rfkill bluetooth;
+        struct asus_rfkill wimax;
+        struct asus_rfkill wwan3g;
+
+        struct hotplug_slot *hotplug_slot;
+        struct mutex hotplug_lock;
+        struct mutex wmi_lock;
+        struct workqueue_struct *hotplug_workqueue;
+        struct work_struct hotplug_work;
+
+        struct asus_wmi_debug debug;
+
+        struct asus_wmi_driver *driver;
+};
+
+static int asus_wmi_input_init(struct asus_wmi *asus)
+{
+        int err;
+
+        asus->inputdev = input_allocate_device();
+        if (!asus->inputdev)
+                return -ENOMEM;
+
+        asus->inputdev->name = asus->driver->input_phys;
+        asus->inputdev->phys = asus->driver->input_name;
+        asus->inputdev->id.bustype = BUS_HOST;
+        asus->inputdev->dev.parent = &asus->platform_device->dev;
+
+        err = sparse_keymap_setup(asus->inputdev, asus->driver->keymap, NULL);
+        if (err)
+                goto err_free_dev;
+
+        err = input_register_device(asus->inputdev);
+        if (err)
+                goto err_free_keymap;
+
+        return 0;
+
+err_free_keymap:
+        sparse_keymap_free(asus->inputdev);
+err_free_dev:
+        input_free_device(asus->inputdev);
+        return err;
+}
+
+static void asus_wmi_input_exit(struct asus_wmi *asus)
+{
+        if (asus->inputdev) {
+                sparse_keymap_free(asus->inputdev);
+                input_unregister_device(asus->inputdev);
+        }
+
+        asus->inputdev = NULL;
+}
+
+static int asus_wmi_evaluate_method(u32 method_id, u32 arg0, u32 arg1,
+                                    u32 *retval)
+{
+        struct bios_args args = {
+                .arg0 = arg0,
+                .arg1 = arg1,
+        };
+        struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
+        struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
+        acpi_status status;
+        union acpi_object *obj;
+        u32 tmp;
+
+        status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID, 1, method_id,
+                                     &input, &output);
+
+        if (ACPI_FAILURE(status))
+                goto exit;
+
+        obj = (union acpi_object *)output.pointer;
+        if (obj && obj->type == ACPI_TYPE_INTEGER)
+                tmp = (u32) obj->integer.value;
+        else
+                tmp = 0;
+
+        if (retval)
+                *retval = tmp;
+
+        kfree(obj);
+
+exit:
+        if (ACPI_FAILURE(status))
+                return -EIO;
+
+        if (tmp == ASUS_WMI_UNSUPPORTED_METHOD)
+                return -ENODEV;
+
+        return 0;
+}
+
+static int asus_wmi_get_devstate(struct asus_wmi *asus, u32 dev_id, u32 *retval)
+{
+        return asus_wmi_evaluate_method(asus->dsts_id, dev_id, 0, retval);
+}
+
+static int asus_wmi_set_devstate(u32 dev_id, u32 ctrl_param,
+                                 u32 *retval)
+{
+        return asus_wmi_evaluate_method(ASUS_WMI_METHODID_DEVS, dev_id,
+                                        ctrl_param, retval);
+}
+
+/* Helper for special devices with magic return codes */
+static int asus_wmi_get_devstate_bits(struct asus_wmi *asus,
+                                      u32 dev_id, u32 mask)
+{
+        u32 retval = 0;
+        int err;
+
+        err = asus_wmi_get_devstate(asus, dev_id, &retval);
+
+        if (err < 0)
+                return err;
+
+        if (!(retval & ASUS_WMI_DSTS_PRESENCE_BIT))
+                return -ENODEV;
+
+        if (mask == ASUS_WMI_DSTS_STATUS_BIT) {
+                if (retval & ASUS_WMI_DSTS_UNKNOWN_BIT)
+                        return -ENODEV;
+        }
+
+        return retval & mask;
+}
+
+static int asus_wmi_get_devstate_simple(struct asus_wmi *asus, u32 dev_id)
+{
+        return asus_wmi_get_devstate_bits(asus, dev_id,
+                                          ASUS_WMI_DSTS_STATUS_BIT);
+}
+
+/*
+ * LEDs
+ */
+/*
+ * These functions actually update the LED's, and are called from a
+ * workqueue. By doing this as separate work rather than when the LED
+ * subsystem asks, we avoid messing with the Asus ACPI stuff during a
+ * potentially bad time, such as a timer interrupt.
+ */
+static void tpd_led_update(struct work_struct *work)
+{
+        int ctrl_param;
+        struct asus_wmi *asus;
+
+        asus = container_of(work, struct asus_wmi, tpd_led_work);
+
+        ctrl_param = asus->tpd_led_wk;
+        asus_wmi_set_devstate(ASUS_WMI_DEVID_TOUCHPAD_LED, ctrl_param, NULL);
+}
+
+static void tpd_led_set(struct led_classdev *led_cdev,
+                        enum led_brightness value)
+{
+        struct asus_wmi *asus;
+
+        asus = container_of(led_cdev, struct asus_wmi, tpd_led);
+
+        asus->tpd_led_wk = !!value;
+        queue_work(asus->led_workqueue, &asus->tpd_led_work);
+}
+
+static int read_tpd_led_state(struct asus_wmi *asus)
+{
+        return asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_TOUCHPAD_LED);
+}
+
+static enum led_brightness tpd_led_get(struct led_classdev *led_cdev)
+{
+        struct asus_wmi *asus;
+
+        asus = container_of(led_cdev, struct asus_wmi, tpd_led);
+
+        return read_tpd_led_state(asus);
+}
+
+static int asus_wmi_led_init(struct asus_wmi *asus)
+{
+        int rv;
+
+        if (read_tpd_led_state(asus) < 0)
+                return 0;
+
+        asus->led_workqueue = create_singlethread_workqueue("led_workqueue");
+        if (!asus->led_workqueue)
+                return -ENOMEM;
+        INIT_WORK(&asus->tpd_led_work, tpd_led_update);
+
+        asus->tpd_led.name = "asus::touchpad";
+        asus->tpd_led.brightness_set = tpd_led_set;
+        asus->tpd_led.brightness_get = tpd_led_get;
+        asus->tpd_led.max_brightness = 1;
+
+        rv = led_classdev_register(&asus->platform_device->dev, &asus->tpd_led);
+        if (rv) {
+                destroy_workqueue(asus->led_workqueue);
+                return rv;
+        }
+
+        return 0;
+}
+
+static void asus_wmi_led_exit(struct asus_wmi *asus)
+{
+        if (asus->tpd_led.dev)
+                led_classdev_unregister(&asus->tpd_led);
+        if (asus->led_workqueue)
+                destroy_workqueue(asus->led_workqueue);
+}
+
+/*
+ * PCI hotplug (for wlan rfkill)
+ */
+static bool asus_wlan_rfkill_blocked(struct asus_wmi *asus)
+{
+        int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
+
+        if (result < 0)
+                return false;
+        return !result;
+}
+
+static void asus_rfkill_hotplug(struct asus_wmi *asus)
+{
+        struct pci_dev *dev;
+        struct pci_bus *bus;
+        bool blocked;
+        bool absent;
+        u32 l;
+
+        mutex_lock(&asus->wmi_lock);
+        blocked = asus_wlan_rfkill_blocked(asus);
+        mutex_unlock(&asus->wmi_lock);
+
+        mutex_lock(&asus->hotplug_lock);
+
+        if (asus->wlan.rfkill)
+                rfkill_set_sw_state(asus->wlan.rfkill, blocked);
+
+        if (asus->hotplug_slot) {
+                bus = pci_find_bus(0, 1);
+                if (!bus) {
+                        pr_warning("Unable to find PCI bus 1?\n");
+                        goto out_unlock;
+                }
+
+                if (pci_bus_read_config_dword(bus, 0, PCI_VENDOR_ID, &l)) {
+                        pr_err("Unable to read PCI config space?\n");
+                        goto out_unlock;
+                }
+                absent = (l == 0xffffffff);
+
+                if (blocked != absent) {
+                        pr_warning("BIOS says wireless lan is %s, "
+                                   "but the pci device is %s\n",
+                                   blocked ? "blocked" : "unblocked",
+                                   absent ? "absent" : "present");
+                        pr_warning("skipped wireless hotplug as probably "
+                                   "inappropriate for this model\n");
+                        goto out_unlock;
+                }
+
+                if (!blocked) {
+                        dev = pci_get_slot(bus, 0);
+                        if (dev) {
+                                /* Device already present */
+                                pci_dev_put(dev);
+                                goto out_unlock;
+                        }
+                        dev = pci_scan_single_device(bus, 0);
+                        if (dev) {
+                                pci_bus_assign_resources(bus);
+                                if (pci_bus_add_device(dev))
+                                        pr_err("Unable to hotplug wifi\n");
+                        }
+                } else {
+                        dev = pci_get_slot(bus, 0);
+                        if (dev) {
+                                pci_remove_bus_device(dev);
+                                pci_dev_put(dev);
+                        }
+                }
+        }
+
+out_unlock:
+        mutex_unlock(&asus->hotplug_lock);
+}
+
+static void asus_rfkill_notify(acpi_handle handle, u32 event, void *data)
+{
+        struct asus_wmi *asus = data;
+
+        if (event != ACPI_NOTIFY_BUS_CHECK)
+                return;
+
+        /*
+         * We can't call directly asus_rfkill_hotplug because most
+         * of the time WMBC is still being executed and not reetrant.
+         * There is currently no way to tell ACPICA that  we want this
+         * method to be serialized, we schedule a asus_rfkill_hotplug
+         * call later, in a safer context.
+         */
+        queue_work(asus->hotplug_workqueue, &asus->hotplug_work);
+}
+
+static int asus_register_rfkill_notifier(struct asus_wmi *asus, char *node)
+{
+        acpi_status status;
+        acpi_handle handle;
+
+        status = acpi_get_handle(NULL, node, &handle);
+
+        if (ACPI_SUCCESS(status)) {
+                status = acpi_install_notify_handler(handle,
+                                                     ACPI_SYSTEM_NOTIFY,
+                                                     asus_rfkill_notify, asus);
+                if (ACPI_FAILURE(status))
+                        pr_warning("Failed to register notify on %s\n", node);
+        } else
+                return -ENODEV;
+
+        return 0;
+}
+
+static void asus_unregister_rfkill_notifier(struct asus_wmi *asus, char *node)
+{
+        acpi_status status = AE_OK;
+        acpi_handle handle;
+
+        status = acpi_get_handle(NULL, node, &handle);
+
+        if (ACPI_SUCCESS(status)) {
+                status = acpi_remove_notify_handler(handle,
+                                                    ACPI_SYSTEM_NOTIFY,
+                                                    asus_rfkill_notify);
+                if (ACPI_FAILURE(status))
+                        pr_err("Error removing rfkill notify handler %s\n",
+                               node);
+        }
+}
+
+static int asus_get_adapter_status(struct hotplug_slot *hotplug_slot,
+                                   u8 *value)
+{
+        struct asus_wmi *asus = hotplug_slot->private;
+        int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
+
+        if (result < 0)
+                return result;
+
+        *value = !!result;
+        return 0;
+}
+
+static void asus_cleanup_pci_hotplug(struct hotplug_slot *hotplug_slot)
+{
+        kfree(hotplug_slot->info);
+        kfree(hotplug_slot);
+}
+
+static struct hotplug_slot_ops asus_hotplug_slot_ops = {
+        .owner = THIS_MODULE,
+        .get_adapter_status = asus_get_adapter_status,
+        .get_power_status = asus_get_adapter_status,
+};
+
+static void asus_hotplug_work(struct work_struct *work)
+{
+        struct asus_wmi *asus;
+
+        asus = container_of(work, struct asus_wmi, hotplug_work);
+        asus_rfkill_hotplug(asus);
+}
+
+static int asus_setup_pci_hotplug(struct asus_wmi *asus)
+{
+        int ret = -ENOMEM;
+        struct pci_bus *bus = pci_find_bus(0, 1);
+
+        if (!bus) {
+                pr_err("Unable to find wifi PCI bus\n");
+                return -ENODEV;
+        }
+
+        asus->hotplug_workqueue =
+            create_singlethread_workqueue("hotplug_workqueue");
+        if (!asus->hotplug_workqueue)
+                goto error_workqueue;
+
+        INIT_WORK(&asus->hotplug_work, asus_hotplug_work);
+
+        asus->hotplug_slot = kzalloc(sizeof(struct hotplug_slot), GFP_KERNEL);
+        if (!asus->hotplug_slot)
+                goto error_slot;
+
+        asus->hotplug_slot->info = kzalloc(sizeof(struct hotplug_slot_info),
+                                           GFP_KERNEL);
+        if (!asus->hotplug_slot->info)
+                goto error_info;
+
+        asus->hotplug_slot->private = asus;
+        asus->hotplug_slot->release = &asus_cleanup_pci_hotplug;
+        asus->hotplug_slot->ops = &asus_hotplug_slot_ops;
+        asus_get_adapter_status(asus->hotplug_slot,
+                                &asus->hotplug_slot->info->adapter_status);
+
+        ret = pci_hp_register(asus->hotplug_slot, bus, 0, "asus-wifi");
+        if (ret) {
+                pr_err("Unable to register hotplug slot - %d\n", ret);
+                goto error_register;
+        }
+
+        return 0;
+
+error_register:
+        kfree(asus->hotplug_slot->info);
+error_info:
+        kfree(asus->hotplug_slot);
+        asus->hotplug_slot = NULL;
+error_slot:
+        destroy_workqueue(asus->hotplug_workqueue);
+error_workqueue:
+        return ret;
+}
+
+/*
+ * Rfkill devices
+ */
+static int asus_rfkill_set(void *data, bool blocked)
+{
+        struct asus_rfkill *priv = data;
+        u32 ctrl_param = !blocked;
+
+        return asus_wmi_set_devstate(priv->dev_id, ctrl_param, NULL);
+}
+
+static void asus_rfkill_query(struct rfkill *rfkill, void *data)
+{
+        struct asus_rfkill *priv = data;
+        int result;
+
+        result = asus_wmi_get_devstate_simple(priv->asus, priv->dev_id);
+
+        if (result < 0)
+                return;
+
+        rfkill_set_sw_state(priv->rfkill, !result);
+}
+
+static int asus_rfkill_wlan_set(void *data, bool blocked)
+{
+        struct asus_rfkill *priv = data;
+        struct asus_wmi *asus = priv->asus;
+        int ret;
+
+        /*
+         * This handler is enabled only if hotplug is enabled.
+         * In this case, the asus_wmi_set_devstate() will
+         * trigger a wmi notification and we need to wait
+         * this call to finish before being able to call
+         * any wmi method
+         */
+        mutex_lock(&asus->wmi_lock);
+        ret = asus_rfkill_set(data, blocked);
+        mutex_unlock(&asus->wmi_lock);
+        return ret;
+}
+
+static const struct rfkill_ops asus_rfkill_wlan_ops = {
+        .set_block = asus_rfkill_wlan_set,
+        .query = asus_rfkill_query,
+};
+
+static const struct rfkill_ops asus_rfkill_ops = {
+        .set_block = asus_rfkill_set,
+        .query = asus_rfkill_query,
+};
+
+static int asus_new_rfkill(struct asus_wmi *asus,
+                           struct asus_rfkill *arfkill,
+                           const char *name, enum rfkill_type type, int dev_id)
+{
+        int result = asus_wmi_get_devstate_simple(asus, dev_id);
+        struct rfkill **rfkill = &arfkill->rfkill;
+
+        if (result < 0)
+                return result;
+
+        arfkill->dev_id = dev_id;
+        arfkill->asus = asus;
+
+        if (dev_id == ASUS_WMI_DEVID_WLAN && asus->driver->hotplug_wireless)
+                *rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
+                                       &asus_rfkill_wlan_ops, arfkill);
+        else
+                *rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
+                                       &asus_rfkill_ops, arfkill);
+
+        if (!*rfkill)
+                return -EINVAL;
+
+        rfkill_init_sw_state(*rfkill, !result);
+        result = rfkill_register(*rfkill);
+        if (result) {
+                rfkill_destroy(*rfkill);
+                *rfkill = NULL;
+                return result;
+        }
+        return 0;
+}
+
+static void asus_wmi_rfkill_exit(struct asus_wmi *asus)
+{
+        asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
+        asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
+        asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
+        if (asus->wlan.rfkill) {
+                rfkill_unregister(asus->wlan.rfkill);
+                rfkill_destroy(asus->wlan.rfkill);
+                asus->wlan.rfkill = NULL;
+        }
+        /*
+         * Refresh pci hotplug in case the rfkill state was changed after
+         * asus_unregister_rfkill_notifier()
+         */
+        asus_rfkill_hotplug(asus);
+        if (asus->hotplug_slot)
+                pci_hp_deregister(asus->hotplug_slot);
+        if (asus->hotplug_workqueue)
+                destroy_workqueue(asus->hotplug_workqueue);
+
+        if (asus->bluetooth.rfkill) {
+                rfkill_unregister(asus->bluetooth.rfkill);
+                rfkill_destroy(asus->bluetooth.rfkill);
+                asus->bluetooth.rfkill = NULL;
+        }
+        if (asus->wimax.rfkill) {
+                rfkill_unregister(asus->wimax.rfkill);
+                rfkill_destroy(asus->wimax.rfkill);
+                asus->wimax.rfkill = NULL;
+        }
+        if (asus->wwan3g.rfkill) {
+                rfkill_unregister(asus->wwan3g.rfkill);
+                rfkill_destroy(asus->wwan3g.rfkill);
+                asus->wwan3g.rfkill = NULL;
+        }
+}
+
+static int asus_wmi_rfkill_init(struct asus_wmi *asus)
+{
+        int result = 0;
+
+        mutex_init(&asus->hotplug_lock);
+        mutex_init(&asus->wmi_lock);
+
+        result = asus_new_rfkill(asus, &asus->wlan, "asus-wlan",
+                                 RFKILL_TYPE_WLAN, ASUS_WMI_DEVID_WLAN);
+
+        if (result && result != -ENODEV)
+                goto exit;
+
+        result = asus_new_rfkill(asus, &asus->bluetooth,
+                                 "asus-bluetooth", RFKILL_TYPE_BLUETOOTH,
+                                 ASUS_WMI_DEVID_BLUETOOTH);
+
+        if (result && result != -ENODEV)
+                goto exit;
+
+        result = asus_new_rfkill(asus, &asus->wimax, "asus-wimax",
+                                 RFKILL_TYPE_WIMAX, ASUS_WMI_DEVID_WIMAX);
+
+        if (result && result != -ENODEV)
+                goto exit;
+
+        result = asus_new_rfkill(asus, &asus->wwan3g, "asus-wwan3g",
+                                 RFKILL_TYPE_WWAN, ASUS_WMI_DEVID_WWAN3G);
+
+        if (result && result != -ENODEV)
+                goto exit;
+
+        if (!asus->driver->hotplug_wireless)
+                goto exit;
+
+        result = asus_setup_pci_hotplug(asus);
+        /*
+         * If we get -EBUSY then something else is handling the PCI hotplug -
+         * don't fail in this case
+         */
+        if (result == -EBUSY)
+                result = 0;
+
+        asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
+        asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
+        asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
+        /*
+         * Refresh pci hotplug in case the rfkill state was changed during
+         * setup.
+         */
+        asus_rfkill_hotplug(asus);
+
+exit:
+        if (result && result != -ENODEV)
+                asus_wmi_rfkill_exit(asus);
+
+        if (result == -ENODEV)
+                result = 0;
+
+        return result;
+}
+
+/*
+ * Hwmon device
+ */
+static ssize_t asus_hwmon_pwm1(struct device *dev,
+                            struct device_attribute *attr,
+                            char *buf)
+{
+        struct asus_wmi *asus = dev_get_drvdata(dev);
+        u32 value;
+        int err;
+
+        err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FAN_CTRL, &value);
+
+        if (err < 0)
+                return err;
+
+        value |= 0xFF;
+
+        if (value == 1) /* Low Speed */
+                value = 85;
+        else if (value == 2)
+                value = 170;
+        else if (value == 3)
+                value = 255;
+        else if (value != 0) {
+                pr_err("Unknown fan speed %#x", value);
+                value = -1;
+        }
+
+        return sprintf(buf, "%d\n", value);
+}
+
+static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO, asus_hwmon_pwm1, NULL, 0);
+
+static ssize_t
+show_name(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        return sprintf(buf, "asus\n");
+}
+static SENSOR_DEVICE_ATTR(name, S_IRUGO, show_name, NULL, 0);
+
+static struct attribute *hwmon_attributes[] = {
+        &sensor_dev_attr_pwm1.dev_attr.attr,
+        &sensor_dev_attr_name.dev_attr.attr,
+        NULL
+};
+
+static mode_t asus_hwmon_sysfs_is_visible(struct kobject *kobj,
+                                    struct attribute *attr, int idx)
+{
+        struct device *dev = container_of(kobj, struct device, kobj);
+        struct platform_device *pdev = to_platform_device(dev->parent);
+        struct asus_wmi *asus = platform_get_drvdata(pdev);
+        bool ok = true;
+        int dev_id = -1;
+        u32 value = ASUS_WMI_UNSUPPORTED_METHOD;
+
+        if (attr == &sensor_dev_attr_pwm1.dev_attr.attr)
+                dev_id = ASUS_WMI_DEVID_FAN_CTRL;
+
+        if (dev_id != -1) {
+                int err = asus_wmi_get_devstate(asus, dev_id, &value);
+
+                if (err < 0)
+                        return err;
+        }
+
+        if (dev_id == ASUS_WMI_DEVID_FAN_CTRL) {
+                /*
+                 * We need to find a better way, probably using sfun,
+                 * bits or spec ...
+                 * Currently we disable it if:
+                 * - ASUS_WMI_UNSUPPORTED_METHOD is returned
+                 * - reverved bits are non-zero
+                 * - sfun and presence bit are not set
+                 */
+                if (value != ASUS_WMI_UNSUPPORTED_METHOD || value & 0xFFF80000
+                    || (!asus->sfun && !(value & ASUS_WMI_DSTS_PRESENCE_BIT)))
+                        ok = false;
+        }
+
+        return ok ? attr->mode : 0;
+}
+
+static struct attribute_group hwmon_attribute_group = {
+        .is_visible = asus_hwmon_sysfs_is_visible,
+        .attrs = hwmon_attributes
+};
+
+static void asus_wmi_hwmon_exit(struct asus_wmi *asus)
+{
+        struct device *hwmon;
+
+        hwmon = asus->hwmon_device;
+        if (!hwmon)
+                return;
+        sysfs_remove_group(&hwmon->kobj, &hwmon_attribute_group);
+        hwmon_device_unregister(hwmon);
+        asus->hwmon_device = NULL;
+}
+
+static int asus_wmi_hwmon_init(struct asus_wmi *asus)
+{
+        struct device *hwmon;
+        int result;
+
+        hwmon = hwmon_device_register(&asus->platform_device->dev);
+        if (IS_ERR(hwmon)) {
+                pr_err("Could not register asus hwmon device\n");
+                return PTR_ERR(hwmon);
+        }
+        asus->hwmon_device = hwmon;
+        result = sysfs_create_group(&hwmon->kobj, &hwmon_attribute_group);
+        if (result)
+                asus_wmi_hwmon_exit(asus);
+        return result;
+}
+
+/*
+ * Backlight
+ */
+static int read_backlight_power(struct asus_wmi *asus)
+{
+        int ret = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_BACKLIGHT);
+
+        if (ret < 0)
+                return ret;
+
+        return ret ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
+}
+
+static int read_brightness_max(struct asus_wmi *asus)
+{
+        u32 retval;
+        int err;
+
+        err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval);
+
+        if (err < 0)
+                return err;
+
+        retval = retval & ASUS_WMI_DSTS_MAX_BRIGTH_MASK;
+        retval >>= 8;
+
+        if (!retval)
+                return -ENODEV;
+
+        return retval;
+}
+
+static int read_brightness(struct backlight_device *bd)
+{
+        struct asus_wmi *asus = bl_get_data(bd);
+        u32 retval;
+        int err;
+
+        err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval);
+
+        if (err < 0)
+                return err;
+
+        return retval & ASUS_WMI_DSTS_BRIGHTNESS_MASK;
+}
+
+static int update_bl_status(struct backlight_device *bd)
+{
+        struct asus_wmi *asus = bl_get_data(bd);
+        u32 ctrl_param;
+        int power, err;
+
+        ctrl_param = bd->props.brightness;
+
+        err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BRIGHTNESS,
+                                    ctrl_param, NULL);
+
+        if (err < 0)
+                return err;
+
+        power = read_backlight_power(asus);
+        if (power != -ENODEV && bd->props.power != power) {
+                ctrl_param = !!(bd->props.power == FB_BLANK_UNBLANK);
+                err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BACKLIGHT,
+                                            ctrl_param, NULL);
+        }
+        return err;
+}
+
+static const struct backlight_ops asus_wmi_bl_ops = {
+        .get_brightness = read_brightness,
+        .update_status = update_bl_status,
+};
+
+static int asus_wmi_backlight_notify(struct asus_wmi *asus, int code)
+{
+        struct backlight_device *bd = asus->backlight_device;
+        int old = bd->props.brightness;
+        int new = old;
+
+        if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
+                new = code - NOTIFY_BRNUP_MIN + 1;
+        else if (code >= NOTIFY_BRNDOWN_MIN && code <= NOTIFY_BRNDOWN_MAX)
+                new = code - NOTIFY_BRNDOWN_MIN;
+
+        bd->props.brightness = new;
+        backlight_update_status(bd);
+        backlight_force_update(bd, BACKLIGHT_UPDATE_HOTKEY);
+
+        return old;
+}
+
+static int asus_wmi_backlight_init(struct asus_wmi *asus)
+{
+        struct backlight_device *bd;
+        struct backlight_properties props;
+        int max;
+        int power;
+
+        max = read_brightness_max(asus);
+
+        if (max == -ENODEV)
+                max = 0;
+        else if (max < 0)
+                return max;
+
+        power = read_backlight_power(asus);
+
+        if (power == -ENODEV)
+                power = FB_BLANK_UNBLANK;
+        else if (power < 0)
+                return power;
+
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.max_brightness = max;
+        bd = backlight_device_register(asus->driver->name,
+                                       &asus->platform_device->dev, asus,
+                                       &asus_wmi_bl_ops, &props);
+        if (IS_ERR(bd)) {
+                pr_err("Could not register backlight device\n");
+                return PTR_ERR(bd);
+        }
+
+        asus->backlight_device = bd;
+
+        bd->props.brightness = read_brightness(bd);
+        bd->props.power = power;
+        backlight_update_status(bd);
+
+        return 0;
+}
+
+static void asus_wmi_backlight_exit(struct asus_wmi *asus)
+{
+        if (asus->backlight_device)
+                backlight_device_unregister(asus->backlight_device);
+
+        asus->backlight_device = NULL;
+}
+
+static void asus_wmi_notify(u32 value, void *context)
+{
+        struct asus_wmi *asus = context;
+        struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
+        union acpi_object *obj;
+        acpi_status status;
+        int code;
+        int orig_code;
+
+        status = wmi_get_event_data(value, &response);
+        if (status != AE_OK) {
+                pr_err("bad event status 0x%x\n", status);
+                return;
+        }
+
+        obj = (union acpi_object *)response.pointer;
+
+        if (!obj || obj->type != ACPI_TYPE_INTEGER)
+                goto exit;
+
+        code = obj->integer.value;
+        orig_code = code;
+
+        if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
+                code = NOTIFY_BRNUP_MIN;
+        else if (code >= NOTIFY_BRNDOWN_MIN &&
+                 code <= NOTIFY_BRNDOWN_MAX)
+                code = NOTIFY_BRNDOWN_MIN;
+
+        if (code == NOTIFY_BRNUP_MIN || code == NOTIFY_BRNDOWN_MIN) {
+                if (!acpi_video_backlight_support())
+                        asus_wmi_backlight_notify(asus, orig_code);
+        } else if (!sparse_keymap_report_event(asus->inputdev, code, 1, true))
+                pr_info("Unknown key %x pressed\n", code);
+
+exit:
+        kfree(obj);
+}
+
+/*
+ * Sys helpers
+ */
+static int parse_arg(const char *buf, unsigned long count, int *val)
+{
+        if (!count)
+                return 0;
+        if (sscanf(buf, "%i", val) != 1)
+                return -EINVAL;
+        return count;
+}
+
+static ssize_t store_sys_wmi(struct asus_wmi *asus, int devid,
+                             const char *buf, size_t count)
+{
+        u32 retval;
+        int rv, err, value;
+
+        value = asus_wmi_get_devstate_simple(asus, devid);
+        if (value == -ENODEV)   /* Check device presence */
+                return value;
+
+        rv = parse_arg(buf, count, &value);
+        err = asus_wmi_set_devstate(devid, value, &retval);
+
+        if (err < 0)
+                return err;
+
+        return rv;
+}
+
+static ssize_t show_sys_wmi(struct asus_wmi *asus, int devid, char *buf)
+{
+        int value = asus_wmi_get_devstate_simple(asus, devid);
+
+        if (value < 0)
+                return value;
+
+        return sprintf(buf, "%d\n", value);
+}
+
+#define ASUS_WMI_CREATE_DEVICE_ATTR(_name, _mode, _cm)                  \
+        static ssize_t show_##_name(struct device *dev,                 \
+                                    struct device_attribute *attr,      \
+                                    char *buf)                          \
+        {                                                               \
+                struct asus_wmi *asus = dev_get_drvdata(dev);           \
+                                                                        \
+                return show_sys_wmi(asus, _cm, buf);                    \
+        }                                                               \
+        static ssize_t store_##_name(struct device *dev,                \
+                                     struct device_attribute *attr,     \
+                                     const char *buf, size_t count)     \
+        {                                                               \
+                struct asus_wmi *asus = dev_get_drvdata(dev);           \
+                                                                        \
+                return store_sys_wmi(asus, _cm, buf, count);            \
+        }                                                               \
+        static struct device_attribute dev_attr_##_name = {             \
+                .attr = {                                               \
+                        .name = __stringify(_name),                     \
+                        .mode = _mode },                                \
+                .show   = show_##_name,                                 \
+                .store  = store_##_name,                                \
+        }
+
+ASUS_WMI_CREATE_DEVICE_ATTR(touchpad, 0644, ASUS_WMI_DEVID_TOUCHPAD);
+ASUS_WMI_CREATE_DEVICE_ATTR(camera, 0644, ASUS_WMI_DEVID_CAMERA);
+ASUS_WMI_CREATE_DEVICE_ATTR(cardr, 0644, ASUS_WMI_DEVID_CARDREADER);
+
+static ssize_t store_cpufv(struct device *dev, struct device_attribute *attr,
+                           const char *buf, size_t count)
+{
+        int value;
+
+        if (!count || sscanf(buf, "%i", &value) != 1)
+                return -EINVAL;
+        if (value < 0 || value > 2)
+                return -EINVAL;
+
+        return asus_wmi_evaluate_method(ASUS_WMI_METHODID_CFVS, value, 0, NULL);
+}
+
+static DEVICE_ATTR(cpufv, S_IRUGO | S_IWUSR, NULL, store_cpufv);
+
+static struct attribute *platform_attributes[] = {
+        &dev_attr_cpufv.attr,
+        &dev_attr_camera.attr,
+        &dev_attr_cardr.attr,
+        &dev_attr_touchpad.attr,
+        NULL
+};
+
+static mode_t asus_sysfs_is_visible(struct kobject *kobj,
+                                    struct attribute *attr, int idx)
+{
+        struct device *dev = container_of(kobj, struct device, kobj);
+        struct platform_device *pdev = to_platform_device(dev);
+        struct asus_wmi *asus = platform_get_drvdata(pdev);
+        bool ok = true;
+        int devid = -1;
+
+        if (attr == &dev_attr_camera.attr)
+                devid = ASUS_WMI_DEVID_CAMERA;
+        else if (attr == &dev_attr_cardr.attr)
+                devid = ASUS_WMI_DEVID_CARDREADER;
+        else if (attr == &dev_attr_touchpad.attr)
+                devid = ASUS_WMI_DEVID_TOUCHPAD;
+
+        if (devid != -1)
+                ok = !(asus_wmi_get_devstate_simple(asus, devid) < 0);
+
+        return ok ? attr->mode : 0;
+}
+
+static struct attribute_group platform_attribute_group = {
+        .is_visible = asus_sysfs_is_visible,
+        .attrs = platform_attributes
+};
+
+static void asus_wmi_sysfs_exit(struct platform_device *device)
+{
+        sysfs_remove_group(&device->dev.kobj, &platform_attribute_group);
+}
+
+static int asus_wmi_sysfs_init(struct platform_device *device)
+{
+        return sysfs_create_group(&device->dev.kobj, &platform_attribute_group);
+}
+
+/*
+ * Platform device
+ */
+static int __init asus_wmi_platform_init(struct asus_wmi *asus)
+{
+        int rv;
+
+        /* INIT enable hotkeys on some models */
+        if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_INIT, 0, 0, &rv))
+                pr_info("Initialization: %#x", rv);
+
+        /* We don't know yet what to do with this version... */
+        if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SPEC, 0, 0x9, &rv)) {
+                pr_info("BIOS WMI version: %d.%d", rv >> 8, rv & 0xFF);
+                asus->spec = rv;
+        }
+
+        /*
+         * The SFUN method probably allows the original driver to get the list
+         * of features supported by a given model. For now, 0x0100 or 0x0800
+         * bit signifies that the laptop is equipped with a Wi-Fi MiniPCI card.
+         * The significance of others is yet to be found.
+         */
+        if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SFUN, 0, 0, &rv)) {
+                pr_info("SFUN value: %#x", rv);
+                asus->sfun = rv;
+        }
+
+        /*
+         * Eee PC and Notebooks seems to have different method_id for DSTS,
+         * but it may also be related to the BIOS's SPEC.
+         * Note, on most Eeepc, there is no way to check if a method exist
+         * or note, while on notebooks, they returns 0xFFFFFFFE on failure,
+         * but once again, SPEC may probably be used for that kind of things.
+         */
+        if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_DSTS, 0, 0, NULL))
+                asus->dsts_id = ASUS_WMI_METHODID_DSTS;
+        else if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_DSTS2, 0, 0, NULL))
+                asus->dsts_id = ASUS_WMI_METHODID_DSTS2;
+
+        if (!asus->dsts_id) {
+                pr_err("Can't find DSTS");
+                return -ENODEV;
+        }
+
+        return asus_wmi_sysfs_init(asus->platform_device);
+}
+
+static void asus_wmi_platform_exit(struct asus_wmi *asus)
+{
+        asus_wmi_sysfs_exit(asus->platform_device);
+}
+
+/*
+ * debugfs
+ */
+struct asus_wmi_debugfs_node {
+        struct asus_wmi *asus;
+        char *name;
+        int (*show) (struct seq_file *m, void *data);
+};
+
+static int show_dsts(struct seq_file *m, void *data)
+{
+        struct asus_wmi *asus = m->private;
+        int err;
+        u32 retval = -1;
+
+        err = asus_wmi_get_devstate(asus, asus->debug.dev_id, &retval);
+
+        if (err < 0)
+                return err;
+
+        seq_printf(m, "DSTS(%#x) = %#x\n", asus->debug.dev_id, retval);
+
+        return 0;
+}
+
+static int show_devs(struct seq_file *m, void *data)
+{
+        struct asus_wmi *asus = m->private;
+        int err;
+        u32 retval = -1;
+
+        err = asus_wmi_set_devstate(asus->debug.dev_id, asus->debug.ctrl_param,
+                                    &retval);
+
+        if (err < 0)
+                return err;
+
+        seq_printf(m, "DEVS(%#x, %#x) = %#x\n", asus->debug.dev_id,
+                   asus->debug.ctrl_param, retval);
+
+        return 0;
+}
+
+static int show_call(struct seq_file *m, void *data)
+{
+        struct asus_wmi *asus = m->private;
+        struct bios_args args = {
+                .arg0 = asus->debug.dev_id,
+                .arg1 = asus->debug.ctrl_param,
+        };
+        struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
+        struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
+        union acpi_object *obj;
+        acpi_status status;
+
+        status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID,
+                                     1, asus->debug.method_id,
+                                     &input, &output);
+
+        if (ACPI_FAILURE(status))
+                return -EIO;
+
+        obj = (union acpi_object *)output.pointer;
+        if (obj && obj->type == ACPI_TYPE_INTEGER)
+                seq_printf(m, "%#x(%#x, %#x) = %#x\n", asus->debug.method_id,
+                           asus->debug.dev_id, asus->debug.ctrl_param,
+                           (u32) obj->integer.value);
+        else
+                seq_printf(m, "%#x(%#x, %#x) = t:%d\n", asus->debug.method_id,
+                           asus->debug.dev_id, asus->debug.ctrl_param,
+                           obj ? obj->type : -1);
+
+        kfree(obj);
+
+        return 0;
+}
+
+static struct asus_wmi_debugfs_node asus_wmi_debug_files[] = {
+        {NULL, "devs", show_devs},
+        {NULL, "dsts", show_dsts},
+        {NULL, "call", show_call},
+};
+
+static int asus_wmi_debugfs_open(struct inode *inode, struct file *file)
+{
+        struct asus_wmi_debugfs_node *node = inode->i_private;
+
+        return single_open(file, node->show, node->asus);
+}
+
+static const struct file_operations asus_wmi_debugfs_io_ops = {
+        .owner = THIS_MODULE,
+        .open = asus_wmi_debugfs_open,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
+};
+
+static void asus_wmi_debugfs_exit(struct asus_wmi *asus)
+{
+        debugfs_remove_recursive(asus->debug.root);
+}
+
+static int asus_wmi_debugfs_init(struct asus_wmi *asus)
+{
+        struct dentry *dent;
+        int i;
+
+        asus->debug.root = debugfs_create_dir(asus->driver->name, NULL);
+        if (!asus->debug.root) {
+                pr_err("failed to create debugfs directory");
+                goto error_debugfs;
+        }
+
+        dent = debugfs_create_x32("method_id", S_IRUGO | S_IWUSR,
+                                  asus->debug.root, &asus->debug.method_id);
+        if (!dent)
+                goto error_debugfs;
+
+        dent = debugfs_create_x32("dev_id", S_IRUGO | S_IWUSR,
+                                  asus->debug.root, &asus->debug.dev_id);
+        if (!dent)
+                goto error_debugfs;
+
+        dent = debugfs_create_x32("ctrl_param", S_IRUGO | S_IWUSR,
+                                  asus->debug.root, &asus->debug.ctrl_param);
+        if (!dent)
+                goto error_debugfs;
+
+        for (i = 0; i < ARRAY_SIZE(asus_wmi_debug_files); i++) {
+                struct asus_wmi_debugfs_node *node = &asus_wmi_debug_files[i];
+
+                node->asus = asus;
+                dent = debugfs_create_file(node->name, S_IFREG | S_IRUGO,
+                                           asus->debug.root, node,
+                                           &asus_wmi_debugfs_io_ops);
+                if (!dent) {
+                        pr_err("failed to create debug file: %s\n", node->name);
+                        goto error_debugfs;
+                }
+        }
+
+        return 0;
+
+error_debugfs:
+        asus_wmi_debugfs_exit(asus);
+        return -ENOMEM;
+}
+
+/*
+ * WMI Driver
+ */
+static int asus_wmi_add(struct platform_device *pdev)
+{
+        struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver);
+        struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv);
+        struct asus_wmi *asus;
+        acpi_status status;
+        int err;
+
+        asus = kzalloc(sizeof(struct asus_wmi), GFP_KERNEL);
+        if (!asus)
+                return -ENOMEM;
+
+        asus->driver = wdrv;
+        asus->platform_device = pdev;
+        wdrv->platform_device = pdev;
+        platform_set_drvdata(asus->platform_device, asus);
+
+        if (wdrv->quirks)
+                wdrv->quirks(asus->driver);
+
+        err = asus_wmi_platform_init(asus);
+        if (err)
+                goto fail_platform;
+
+        err = asus_wmi_input_init(asus);
+        if (err)
+                goto fail_input;
+
+        err = asus_wmi_hwmon_init(asus);
+        if (err)
+                goto fail_hwmon;
+
+        err = asus_wmi_led_init(asus);
+        if (err)
+                goto fail_leds;
+
+        err = asus_wmi_rfkill_init(asus);
+        if (err)
+                goto fail_rfkill;
+
+        if (!acpi_video_backlight_support()) {
+                err = asus_wmi_backlight_init(asus);
+                if (err && err != -ENODEV)
+                        goto fail_backlight;
+        } else
+                pr_info("Backlight controlled by ACPI video driver\n");
+
+        status = wmi_install_notify_handler(asus->driver->event_guid,
+                                            asus_wmi_notify, asus);
+        if (ACPI_FAILURE(status)) {
+                pr_err("Unable to register notify handler - %d\n", status);
+                err = -ENODEV;
+                goto fail_wmi_handler;
+        }
+
+        err = asus_wmi_debugfs_init(asus);
+        if (err)
+                goto fail_debugfs;
+
+        return 0;
+
+fail_debugfs:
+        wmi_remove_notify_handler(asus->driver->event_guid);
+fail_wmi_handler:
+        asus_wmi_backlight_exit(asus);
+fail_backlight:
+        asus_wmi_rfkill_exit(asus);
+fail_rfkill:
+        asus_wmi_led_exit(asus);
+fail_leds:
+        asus_wmi_hwmon_exit(asus);
+fail_hwmon:
+        asus_wmi_input_exit(asus);
+fail_input:
+        asus_wmi_platform_exit(asus);
+fail_platform:
+        kfree(asus);
+        return err;
+}
+
+static int asus_wmi_remove(struct platform_device *device)
+{
+        struct asus_wmi *asus;
+
+        asus = platform_get_drvdata(device);
+        wmi_remove_notify_handler(asus->driver->event_guid);
+        asus_wmi_backlight_exit(asus);
+        asus_wmi_input_exit(asus);
+        asus_wmi_hwmon_exit(asus);
+        asus_wmi_led_exit(asus);
+        asus_wmi_rfkill_exit(asus);
+        asus_wmi_debugfs_exit(asus);
+        asus_wmi_platform_exit(asus);
+
+        kfree(asus);
+        return 0;
+}
+
+/*
+ * Platform driver - hibernate/resume callbacks
+ */
+static int asus_hotk_thaw(struct device *device)
+{
+        struct asus_wmi *asus = dev_get_drvdata(device);
+
+        if (asus->wlan.rfkill) {
+                bool wlan;
+
+                /*
+                 * Work around bios bug - acpi _PTS turns off the wireless led
+                 * during suspend.  Normally it restores it on resume, but
+                 * we should kick it ourselves in case hibernation is aborted.
+                 */
+                wlan = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
+                asus_wmi_set_devstate(ASUS_WMI_DEVID_WLAN, wlan, NULL);
+        }
+
+        return 0;
+}
+
+static int asus_hotk_restore(struct device *device)
+{
+        struct asus_wmi *asus = dev_get_drvdata(device);
+        int bl;
+
+        /* Refresh both wlan rfkill state and pci hotplug */
+        if (asus->wlan.rfkill)
+                asus_rfkill_hotplug(asus);
+
+        if (asus->bluetooth.rfkill) {
+                bl = !asus_wmi_get_devstate_simple(asus,
+                                                   ASUS_WMI_DEVID_BLUETOOTH);
+                rfkill_set_sw_state(asus->bluetooth.rfkill, bl);
+        }
+        if (asus->wimax.rfkill) {
+                bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WIMAX);
+                rfkill_set_sw_state(asus->wimax.rfkill, bl);
+        }
+        if (asus->wwan3g.rfkill) {
+                bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WWAN3G);
+                rfkill_set_sw_state(asus->wwan3g.rfkill, bl);
+        }
+
+        return 0;
+}
+
+static const struct dev_pm_ops asus_pm_ops = {
+        .thaw = asus_hotk_thaw,
+        .restore = asus_hotk_restore,
+};
+
+static int asus_wmi_probe(struct platform_device *pdev)
+{
+        struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver);
+        struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv);
+        int ret;
+
+        if (!wmi_has_guid(ASUS_WMI_MGMT_GUID)) {
+                pr_warning("Management GUID not found\n");
+                return -ENODEV;
+        }
+
+        if (wdrv->event_guid && !wmi_has_guid(wdrv->event_guid)) {
+                pr_warning("Event GUID not found\n");
+                return -ENODEV;
+        }
+
+        if (wdrv->probe) {
+                ret = wdrv->probe(pdev);
+                if (ret)
+                        return ret;
+        }
+
+        return asus_wmi_add(pdev);
+}
+
+static bool used;
+
+int asus_wmi_register_driver(struct asus_wmi_driver *driver)
+{
+        struct platform_driver *platform_driver;
+        struct platform_device *platform_device;
+
+        if (used)
+                return -EBUSY;
+
+        platform_driver = &driver->platform_driver;
+        platform_driver->remove = asus_wmi_remove;
+        platform_driver->driver.owner = driver->owner;
+        platform_driver->driver.name = driver->name;
+        platform_driver->driver.pm = &asus_pm_ops;
+
+        platform_device = platform_create_bundle(platform_driver,
+                                                 asus_wmi_probe,
+                                                 NULL, 0, NULL, 0);
+        if (IS_ERR(platform_device))
+                return PTR_ERR(platform_device);
+
+        used = true;
+        return 0;
+}
+EXPORT_SYMBOL_GPL(asus_wmi_register_driver);
+
+void asus_wmi_unregister_driver(struct asus_wmi_driver *driver)
+{
+        platform_device_unregister(driver->platform_device);
+        platform_driver_unregister(&driver->platform_driver);
+        used = false;
+}
+EXPORT_SYMBOL_GPL(asus_wmi_unregister_driver);
+
+static int __init asus_wmi_init(void)
+{
+        if (!wmi_has_guid(ASUS_WMI_MGMT_GUID)) {
+                pr_info("Asus Management GUID not found");
+                return -ENODEV;
+        }
+
+        pr_info("ASUS WMI generic driver loaded");
+        return 0;
+}
+
+static void __exit asus_wmi_exit(void)
+{
+        pr_info("ASUS WMI generic driver unloaded");
+}
+
+module_init(asus_wmi_init);
+module_exit(asus_wmi_exit);
diff --git a/drivers/platform/x86/asus-wmi.h b/drivers/platform/x86/asus-wmi.h
new file mode 100644
index 000000000000..c044522c8766
--- /dev/null
+++ b/drivers/platform/x86/asus-wmi.h
@@ -0,0 +1,58 @@
+/*
+ * Asus PC WMI hotkey driver
+ *
+ * Copyright(C) 2010 Intel Corporation.
+ * Copyright(C) 2010-2011 Corentin Chary <corentin.chary@gmail.com>
+ *
+ * Portions based on wistron_btns.c:
+ * Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
+ * Copyright (C) 2005 Bernhard Rosenkraenzer <bero@arklinux.org>
+ * Copyright (C) 2005 Dmitry Torokhov <dtor@mail.ru>
+ *
+ *  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _ASUS_WMI_H_
+#define _ASUS_WMI_H_
+
+#include <linux/platform_device.h>
+
+struct module;
+struct key_entry;
+struct asus_wmi;
+
+struct asus_wmi_driver {
+        bool                    hotplug_wireless;
+
+        const char              *name;
+        struct module           *owner;
+
+        const char              *event_guid;
+
+        const struct key_entry  *keymap;
+        const char              *input_name;
+        const char              *input_phys;
+
+        int (*probe) (struct platform_device *device);
+        void (*quirks) (struct asus_wmi_driver *driver);
+
+        struct platform_driver  platform_driver;
+        struct platform_device *platform_device;
+};
+
+int asus_wmi_register_driver(struct asus_wmi_driver *driver);
+void asus_wmi_unregister_driver(struct asus_wmi_driver *driver);
+
+#endif /* !_ASUS_WMI_H_ */
diff --git a/drivers/platform/x86/compal-laptop.c b/drivers/platform/x86/compal-laptop.c
index eb95878fa583..c16a27641ced 100644
--- a/drivers/platform/x86/compal-laptop.c
+++ b/drivers/platform/x86/compal-laptop.c
@@ -201,7 +201,7 @@ static bool extra_features;
  * into 0x4F and read a few bytes from the output, like so:
  *      u8 writeData = 0x33;
  *      ec_transaction(0x4F, &writeData, 1, buffer, 32, 0);
- * That address is labled "fan1 table information" in the service manual.
+ * That address is labelled "fan1 table information" in the service manual.
  * It should be clear which value in 'buffer' changes). This seems to be
  * related to fan speed. It isn't a proper 'realtime' fan speed value
  * though, because physically stopping or speeding up the fan doesn't
@@ -275,7 +275,7 @@ static int set_backlight_level(int level)
 
         ec_write(BACKLIGHT_LEVEL_ADDR, level);
 
-        return 1;
+        return 0;
 }
 
 static int get_backlight_level(void)
@@ -763,7 +763,7 @@ static int dmi_check_cb(const struct dmi_system_id *id)
         printk(KERN_INFO DRIVER_NAME": Identified laptop model '%s'\n",
                 id->ident);
         extra_features = false;
-        return 0;
+        return 1;
 }
 
 static int dmi_check_cb_extra(const struct dmi_system_id *id)
@@ -772,7 +772,7 @@ static int dmi_check_cb_extra(const struct dmi_system_id *id)
                 "enabling extra features\n",
                 id->ident);
         extra_features = true;
-        return 0;
+        return 1;
 }
 
 static struct dmi_system_id __initdata compal_dmi_table[] = {
diff --git a/drivers/platform/x86/dell-wmi-aio.c b/drivers/platform/x86/dell-wmi-aio.c
new file mode 100644
index 000000000000..0ed84573ae1f
--- /dev/null
+++ b/drivers/platform/x86/dell-wmi-aio.c
@@ -0,0 +1,171 @@
+/*
+ *  WMI hotkeys support for Dell All-In-One series
+ *
+ *  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/types.h>
+#include <linux/input.h>
+#include <linux/input/sparse-keymap.h>
+#include <acpi/acpi_drivers.h>
+#include <linux/acpi.h>
+#include <linux/string.h>
+
+MODULE_DESCRIPTION("WMI hotkeys driver for Dell All-In-One series");
+MODULE_LICENSE("GPL");
+
+#define EVENT_GUID1 "284A0E6B-380E-472A-921F-E52786257FB4"
+#define EVENT_GUID2 "02314822-307C-4F66-BF0E-48AEAEB26CC8"
+
+static const char *dell_wmi_aio_guids[] = {
+        EVENT_GUID1,
+        EVENT_GUID2,
+        NULL
+};
+
+MODULE_ALIAS("wmi:"EVENT_GUID1);
+MODULE_ALIAS("wmi:"EVENT_GUID2);
+
+static const struct key_entry dell_wmi_aio_keymap[] = {
+        { KE_KEY, 0xc0, { KEY_VOLUMEUP } },
+        { KE_KEY, 0xc1, { KEY_VOLUMEDOWN } },
+        { KE_END, 0 }
+};
+
+static struct input_dev *dell_wmi_aio_input_dev;
+
+static void dell_wmi_aio_notify(u32 value, void *context)
+{
+        struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
+        union acpi_object *obj;
+        acpi_status status;
+
+        status = wmi_get_event_data(value, &response);
+        if (status != AE_OK) {
+                pr_info("bad event status 0x%x\n", status);
+                return;
+        }
+
+        obj = (union acpi_object *)response.pointer;
+        if (obj) {
+                unsigned int scancode;
+
+                switch (obj->type) {
+                case ACPI_TYPE_INTEGER:
+                        /* Most All-In-One correctly return integer scancode */
+                        scancode = obj->integer.value;
+                        sparse_keymap_report_event(dell_wmi_aio_input_dev,
+                                scancode, 1, true);
+                        break;
+                case ACPI_TYPE_BUFFER:
+                        /* Broken machines return the scancode in a buffer */
+                        if (obj->buffer.pointer && obj->buffer.length > 0) {
+                                scancode = obj->buffer.pointer[0];
+                                sparse_keymap_report_event(
+                                        dell_wmi_aio_input_dev,
+                                        scancode, 1, true);
+                        }
+                        break;
+                }
+        }
+        kfree(obj);
+}
+
+static int __init dell_wmi_aio_input_setup(void)
+{
+        int err;
+
+        dell_wmi_aio_input_dev = input_allocate_device();
+
+        if (!dell_wmi_aio_input_dev)
+                return -ENOMEM;
+
+        dell_wmi_aio_input_dev->name = "Dell AIO WMI hotkeys";
+        dell_wmi_aio_input_dev->phys = "wmi/input0";
+        dell_wmi_aio_input_dev->id.bustype = BUS_HOST;
+
+        err = sparse_keymap_setup(dell_wmi_aio_input_dev,
+                        dell_wmi_aio_keymap, NULL);
+        if (err) {
+                pr_err("Unable to setup input device keymap\n");
+                goto err_free_dev;
+        }
+        err = input_register_device(dell_wmi_aio_input_dev);
+        if (err) {
+                pr_info("Unable to register input device\n");
+                goto err_free_keymap;
+        }
+        return 0;
+
+err_free_keymap:
+        sparse_keymap_free(dell_wmi_aio_input_dev);
+err_free_dev:
+        input_free_device(dell_wmi_aio_input_dev);
+        return err;
+}
+
+static const char *dell_wmi_aio_find(void)
+{
+        int i;
+
+        for (i = 0; dell_wmi_aio_guids[i] != NULL; i++)
+                if (wmi_has_guid(dell_wmi_aio_guids[i]))
+                        return dell_wmi_aio_guids[i];
+
+        return NULL;
+}
+
+static int __init dell_wmi_aio_init(void)
+{
+        int err;
+        const char *guid;
+
+        guid = dell_wmi_aio_find();
+        if (!guid) {
+                pr_warning("No known WMI GUID found\n");
+                return -ENXIO;
+        }
+
+        err = dell_wmi_aio_input_setup();
+        if (err)
+                return err;
+
+        err = wmi_install_notify_handler(guid, dell_wmi_aio_notify, NULL);
+        if (err) {
+                pr_err("Unable to register notify handler - %d\n", err);
+                sparse_keymap_free(dell_wmi_aio_input_dev);
+                input_unregister_device(dell_wmi_aio_input_dev);
+                return err;
+        }
+
+        return 0;
+}
+
+static void __exit dell_wmi_aio_exit(void)
+{
+        const char *guid;
+
+        guid = dell_wmi_aio_find();
+        wmi_remove_notify_handler(guid);
+        sparse_keymap_free(dell_wmi_aio_input_dev);
+        input_unregister_device(dell_wmi_aio_input_dev);
+}
+
+module_init(dell_wmi_aio_init);
+module_exit(dell_wmi_aio_exit);
diff --git a/drivers/platform/x86/eeepc-laptop.c b/drivers/platform/x86/eeepc-laptop.c
index 6605beac0d0e..5f2dd386152b 100644
--- a/drivers/platform/x86/eeepc-laptop.c
+++ b/drivers/platform/x86/eeepc-laptop.c
@@ -1322,7 +1322,7 @@ static void cmsg_quirk(struct eeepc_laptop *eeepc, int cm, const char *name)
 {
         int dummy;
 
-        /* Some BIOSes do not report cm although it is avaliable.
+        /* Some BIOSes do not report cm although it is available.
            Check if cm_getv[cm] works and, if yes, assume cm should be set. */
         if (!(eeepc->cm_supported & (1 << cm))
             && !read_acpi_int(eeepc->handle, cm_getv[cm], &dummy)) {
diff --git a/drivers/platform/x86/eeepc-wmi.c b/drivers/platform/x86/eeepc-wmi.c
index 4d38f98aa976..0ddc434fb93b 100644
--- a/drivers/platform/x86/eeepc-wmi.c
+++ b/drivers/platform/x86/eeepc-wmi.c
@@ -2,7 +2,7 @@
  * Eee PC WMI hotkey driver
  *
  * Copyright(C) 2010 Intel Corporation.
- * Copyright(C) 2010 Corentin Chary <corentin.chary@gmail.com>
+ * Copyright(C) 2010-2011 Corentin Chary <corentin.chary@gmail.com>
  *
  * Portions based on wistron_btns.c:
  * Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
@@ -29,841 +29,57 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/init.h>
-#include <linux/types.h>
-#include <linux/slab.h>
 #include <linux/input.h>
 #include <linux/input/sparse-keymap.h>
-#include <linux/fb.h>
-#include <linux/backlight.h>
-#include <linux/leds.h>
-#include <linux/rfkill.h>
-#include <linux/debugfs.h>
-#include <linux/seq_file.h>
-#include <linux/platform_device.h>
+#include <linux/dmi.h>
 #include <acpi/acpi_bus.h>
-#include <acpi/acpi_drivers.h>
+
+#include "asus-wmi.h"
 
 #define EEEPC_WMI_FILE  "eeepc-wmi"
 
-MODULE_AUTHOR("Yong Wang <yong.y.wang@intel.com>");
+MODULE_AUTHOR("Corentin Chary <corentincj@iksaif.net>");
 MODULE_DESCRIPTION("Eee PC WMI Hotkey Driver");
 MODULE_LICENSE("GPL");
 
 #define EEEPC_ACPI_HID          "ASUS010" /* old _HID used in eeepc-laptop */
 
 #define EEEPC_WMI_EVENT_GUID    "ABBC0F72-8EA1-11D1-00A0-C90629100000"
-#define EEEPC_WMI_MGMT_GUID     "97845ED0-4E6D-11DE-8A39-0800200C9A66"
 
 MODULE_ALIAS("wmi:"EEEPC_WMI_EVENT_GUID);
-MODULE_ALIAS("wmi:"EEEPC_WMI_MGMT_GUID);
-
-#define NOTIFY_BRNUP_MIN        0x11
-#define NOTIFY_BRNUP_MAX        0x1f
-#define NOTIFY_BRNDOWN_MIN      0x20
-#define NOTIFY_BRNDOWN_MAX      0x2e
 
-#define EEEPC_WMI_METHODID_DEVS 0x53564544
-#define EEEPC_WMI_METHODID_DSTS 0x53544344
-#define EEEPC_WMI_METHODID_CFVS 0x53564643
+static bool hotplug_wireless;
 
-#define EEEPC_WMI_DEVID_BACKLIGHT       0x00050012
-#define EEEPC_WMI_DEVID_TPDLED          0x00100011
-#define EEEPC_WMI_DEVID_WLAN            0x00010011
-#define EEEPC_WMI_DEVID_BLUETOOTH       0x00010013
-#define EEEPC_WMI_DEVID_WWAN3G          0x00010019
+module_param(hotplug_wireless, bool, 0444);
+MODULE_PARM_DESC(hotplug_wireless,
+                 "Enable hotplug for wireless device. "
+                 "If your laptop needs that, please report to "
+                 "acpi4asus-user@lists.sourceforge.net.");
 
 static const struct key_entry eeepc_wmi_keymap[] = {
         /* Sleep already handled via generic ACPI code */
-        { KE_KEY, 0x5d, { KEY_WLAN } },
-        { KE_KEY, 0x32, { KEY_MUTE } },
-        { KE_KEY, 0x31, { KEY_VOLUMEDOWN } },
         { KE_KEY, 0x30, { KEY_VOLUMEUP } },
-        { KE_IGNORE, NOTIFY_BRNDOWN_MIN, { KEY_BRIGHTNESSDOWN } },
-        { KE_IGNORE, NOTIFY_BRNUP_MIN, { KEY_BRIGHTNESSUP } },
+        { KE_KEY, 0x31, { KEY_VOLUMEDOWN } },
+        { KE_KEY, 0x32, { KEY_MUTE } },
+        { KE_KEY, 0x5c, { KEY_F15 } }, /* Power Gear key */
+        { KE_KEY, 0x5d, { KEY_WLAN } },
+        { KE_KEY, 0x6b, { KEY_TOUCHPAD_TOGGLE } }, /* Toggle Touchpad */
+        { KE_KEY, 0x82, { KEY_CAMERA } },
+        { KE_KEY, 0x83, { KEY_CAMERA_ZOOMIN } },
+        { KE_KEY, 0x88, { KEY_WLAN } },
         { KE_KEY, 0xcc, { KEY_SWITCHVIDEOMODE } },
-        { KE_KEY, 0x6b, { KEY_F13 } }, /* Disable Touchpad */
-        { KE_KEY, 0xe1, { KEY_F14 } },
-        { KE_KEY, 0xe9, { KEY_DISPLAY_OFF } },
-        { KE_KEY, 0xe0, { KEY_PROG1 } },
-        { KE_KEY, 0x5c, { KEY_F15 } },
+        { KE_KEY, 0xe0, { KEY_PROG1 } }, /* Task Manager */
+        { KE_KEY, 0xe1, { KEY_F14 } }, /* Change Resolution */
+        { KE_KEY, 0xe9, { KEY_BRIGHTNESS_ZERO } },
+        { KE_KEY, 0xeb, { KEY_CAMERA_ZOOMOUT } },
+        { KE_KEY, 0xec, { KEY_CAMERA_UP } },
+        { KE_KEY, 0xed, { KEY_CAMERA_DOWN } },
+        { KE_KEY, 0xee, { KEY_CAMERA_LEFT } },
+        { KE_KEY, 0xef, { KEY_CAMERA_RIGHT } },
         { KE_END, 0},
 };
 
-struct bios_args {
-        u32     dev_id;
-        u32     ctrl_param;
-};
-
-/*
- * eeepc-wmi/    - debugfs root directory
- *   dev_id      - current dev_id
- *   ctrl_param  - current ctrl_param
- *   devs        - call DEVS(dev_id, ctrl_param) and print result
- *   dsts        - call DSTS(dev_id)  and print result
- */
-struct eeepc_wmi_debug {
-        struct dentry *root;
-        u32 dev_id;
-        u32 ctrl_param;
-};
-
-struct eeepc_wmi {
-        struct input_dev *inputdev;
-        struct backlight_device *backlight_device;
-        struct platform_device *platform_device;
-
-        struct led_classdev tpd_led;
-        int tpd_led_wk;
-        struct workqueue_struct *led_workqueue;
-        struct work_struct tpd_led_work;
-
-        struct rfkill *wlan_rfkill;
-        struct rfkill *bluetooth_rfkill;
-        struct rfkill *wwan3g_rfkill;
-
-        struct eeepc_wmi_debug debug;
-};
-
-/* Only used in eeepc_wmi_init() and eeepc_wmi_exit() */
-static struct platform_device *platform_device;
-
-static int eeepc_wmi_input_init(struct eeepc_wmi *eeepc)
-{
-        int err;
-
-        eeepc->inputdev = input_allocate_device();
-        if (!eeepc->inputdev)
-                return -ENOMEM;
-
-        eeepc->inputdev->name = "Eee PC WMI hotkeys";
-        eeepc->inputdev->phys = EEEPC_WMI_FILE "/input0";
-        eeepc->inputdev->id.bustype = BUS_HOST;
-        eeepc->inputdev->dev.parent = &eeepc->platform_device->dev;
-
-        err = sparse_keymap_setup(eeepc->inputdev, eeepc_wmi_keymap, NULL);
-        if (err)
-                goto err_free_dev;
-
-        err = input_register_device(eeepc->inputdev);
-        if (err)
-                goto err_free_keymap;
-
-        return 0;
-
-err_free_keymap:
-        sparse_keymap_free(eeepc->inputdev);
-err_free_dev:
-        input_free_device(eeepc->inputdev);
-        return err;
-}
-
-static void eeepc_wmi_input_exit(struct eeepc_wmi *eeepc)
-{
-        if (eeepc->inputdev) {
-                sparse_keymap_free(eeepc->inputdev);
-                input_unregister_device(eeepc->inputdev);
-        }
-
-        eeepc->inputdev = NULL;
-}
-
-static acpi_status eeepc_wmi_get_devstate(u32 dev_id, u32 *retval)
-{
-        struct acpi_buffer input = { (acpi_size)sizeof(u32), &dev_id };
-        struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
-        union acpi_object *obj;
-        acpi_status status;
-        u32 tmp;
-
-        status = wmi_evaluate_method(EEEPC_WMI_MGMT_GUID,
-                        1, EEEPC_WMI_METHODID_DSTS, &input, &output);
-
-        if (ACPI_FAILURE(status))
-                return status;
-
-        obj = (union acpi_object *)output.pointer;
-        if (obj && obj->type == ACPI_TYPE_INTEGER)
-                tmp = (u32)obj->integer.value;
-        else
-                tmp = 0;
-
-        if (retval)
-                *retval = tmp;
-
-        kfree(obj);
-
-        return status;
-
-}
-
-static acpi_status eeepc_wmi_set_devstate(u32 dev_id, u32 ctrl_param,
-                                          u32 *retval)
-{
-        struct bios_args args = {
-                .dev_id = dev_id,
-                .ctrl_param = ctrl_param,
-        };
-        struct acpi_buffer input = { (acpi_size)sizeof(args), &args };
-        acpi_status status;
-
-        if (!retval) {
-                status = wmi_evaluate_method(EEEPC_WMI_MGMT_GUID, 1,
-                                             EEEPC_WMI_METHODID_DEVS,
-                                             &input, NULL);
-        } else {
-                struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
-                union acpi_object *obj;
-                u32 tmp;
-
-                status = wmi_evaluate_method(EEEPC_WMI_MGMT_GUID, 1,
-                                             EEEPC_WMI_METHODID_DEVS,
-                                             &input, &output);
-
-                if (ACPI_FAILURE(status))
-                        return status;
-
-                obj = (union acpi_object *)output.pointer;
-                if (obj && obj->type == ACPI_TYPE_INTEGER)
-                        tmp = (u32)obj->integer.value;
-                else
-                        tmp = 0;
-
-                *retval = tmp;
-
-                kfree(obj);
-        }
-
-        return status;
-}
-
-/*
- * LEDs
- */
-/*
- * These functions actually update the LED's, and are called from a
- * workqueue. By doing this as separate work rather than when the LED
- * subsystem asks, we avoid messing with the Eeepc ACPI stuff during a
- * potentially bad time, such as a timer interrupt.
- */
-static void tpd_led_update(struct work_struct *work)
-{
-        int ctrl_param;
-        struct eeepc_wmi *eeepc;
-
-        eeepc = container_of(work, struct eeepc_wmi, tpd_led_work);
-
-        ctrl_param = eeepc->tpd_led_wk;
-        eeepc_wmi_set_devstate(EEEPC_WMI_DEVID_TPDLED, ctrl_param, NULL);
-}
-
-static void tpd_led_set(struct led_classdev *led_cdev,
-                        enum led_brightness value)
-{
-        struct eeepc_wmi *eeepc;
-
-        eeepc = container_of(led_cdev, struct eeepc_wmi, tpd_led);
-
-        eeepc->tpd_led_wk = !!value;
-        queue_work(eeepc->led_workqueue, &eeepc->tpd_led_work);
-}
-
-static int read_tpd_state(struct eeepc_wmi *eeepc)
-{
-        u32 retval;
-        acpi_status status;
-
-        status = eeepc_wmi_get_devstate(EEEPC_WMI_DEVID_TPDLED, &retval);
-
-        if (ACPI_FAILURE(status))
-                return -1;
-        else if (!retval || retval == 0x00060000)
-                /*
-                 * if touchpad led is present, DSTS will set some bits,
-                 * usually 0x00020000.
-                 * 0x00060000 means that the device is not supported
-                 */
-                return -ENODEV;
-        else
-                /* Status is stored in the first bit */
-                return retval & 0x1;
-}
-
-static enum led_brightness tpd_led_get(struct led_classdev *led_cdev)
-{
-        struct eeepc_wmi *eeepc;
-
-        eeepc = container_of(led_cdev, struct eeepc_wmi, tpd_led);
-
-        return read_tpd_state(eeepc);
-}
-
-static int eeepc_wmi_led_init(struct eeepc_wmi *eeepc)
-{
-        int rv;
-
-        if (read_tpd_state(eeepc) < 0)
-                return 0;
-
-        eeepc->led_workqueue = create_singlethread_workqueue("led_workqueue");
-        if (!eeepc->led_workqueue)
-                return -ENOMEM;
-        INIT_WORK(&eeepc->tpd_led_work, tpd_led_update);
-
-        eeepc->tpd_led.name = "eeepc::touchpad";
-        eeepc->tpd_led.brightness_set = tpd_led_set;
-        eeepc->tpd_led.brightness_get = tpd_led_get;
-        eeepc->tpd_led.max_brightness = 1;
-
-        rv = led_classdev_register(&eeepc->platform_device->dev,
-                                   &eeepc->tpd_led);
-        if (rv) {
-                destroy_workqueue(eeepc->led_workqueue);
-                return rv;
-        }
-
-        return 0;
-}
-
-static void eeepc_wmi_led_exit(struct eeepc_wmi *eeepc)
-{
-        if (eeepc->tpd_led.dev)
-                led_classdev_unregister(&eeepc->tpd_led);
-        if (eeepc->led_workqueue)
-                destroy_workqueue(eeepc->led_workqueue);
-}
-
-/*
- * Rfkill devices
- */
-static int eeepc_rfkill_set(void *data, bool blocked)
-{
-        int dev_id = (unsigned long)data;
-        u32 ctrl_param = !blocked;
-
-        return eeepc_wmi_set_devstate(dev_id, ctrl_param, NULL);
-}
-
-static void eeepc_rfkill_query(struct rfkill *rfkill, void *data)
-{
-        int dev_id = (unsigned long)data;
-        u32 retval;
-        acpi_status status;
-
-        status = eeepc_wmi_get_devstate(dev_id, &retval);
-
-        if (ACPI_FAILURE(status))
-                return ;
-
-        rfkill_set_sw_state(rfkill, !(retval & 0x1));
-}
-
-static const struct rfkill_ops eeepc_rfkill_ops = {
-        .set_block = eeepc_rfkill_set,
-        .query = eeepc_rfkill_query,
-};
-
-static int eeepc_new_rfkill(struct eeepc_wmi *eeepc,
-                            struct rfkill **rfkill,
-                            const char *name,
-                            enum rfkill_type type, int dev_id)
-{
-        int result;
-        u32 retval;
-        acpi_status status;
-
-        status = eeepc_wmi_get_devstate(dev_id, &retval);
-
-        if (ACPI_FAILURE(status))
-                return -1;
-
-        /* If the device is present, DSTS will always set some bits
-         * 0x00070000 - 1110000000000000000 - device supported
-         * 0x00060000 - 1100000000000000000 - not supported
-         * 0x00020000 - 0100000000000000000 - device supported
-         * 0x00010000 - 0010000000000000000 - not supported / special mode ?
-         */
-        if (!retval || retval == 0x00060000)
-                return -ENODEV;
-
-        *rfkill = rfkill_alloc(name, &eeepc->platform_device->dev, type,
-                               &eeepc_rfkill_ops, (void *)(long)dev_id);
-
-        if (!*rfkill)
-                return -EINVAL;
-
-        rfkill_init_sw_state(*rfkill, !(retval & 0x1));
-        result = rfkill_register(*rfkill);
-        if (result) {
-                rfkill_destroy(*rfkill);
-                *rfkill = NULL;
-                return result;
-        }
-        return 0;
-}
-
-static void eeepc_wmi_rfkill_exit(struct eeepc_wmi *eeepc)
-{
-        if (eeepc->wlan_rfkill) {
-                rfkill_unregister(eeepc->wlan_rfkill);
-                rfkill_destroy(eeepc->wlan_rfkill);
-                eeepc->wlan_rfkill = NULL;
-        }
-        if (eeepc->bluetooth_rfkill) {
-                rfkill_unregister(eeepc->bluetooth_rfkill);
-                rfkill_destroy(eeepc->bluetooth_rfkill);
-                eeepc->bluetooth_rfkill = NULL;
-        }
-        if (eeepc->wwan3g_rfkill) {
-                rfkill_unregister(eeepc->wwan3g_rfkill);
-                rfkill_destroy(eeepc->wwan3g_rfkill);
-                eeepc->wwan3g_rfkill = NULL;
-        }
-}
-
-static int eeepc_wmi_rfkill_init(struct eeepc_wmi *eeepc)
-{
-        int result = 0;
-
-        result = eeepc_new_rfkill(eeepc, &eeepc->wlan_rfkill,
-                                  "eeepc-wlan", RFKILL_TYPE_WLAN,
-                                  EEEPC_WMI_DEVID_WLAN);
-
-        if (result && result != -ENODEV)
-                goto exit;
-
-        result = eeepc_new_rfkill(eeepc, &eeepc->bluetooth_rfkill,
-                                  "eeepc-bluetooth", RFKILL_TYPE_BLUETOOTH,
-                                  EEEPC_WMI_DEVID_BLUETOOTH);
-
-        if (result && result != -ENODEV)
-                goto exit;
-
-        result = eeepc_new_rfkill(eeepc, &eeepc->wwan3g_rfkill,
-                                  "eeepc-wwan3g", RFKILL_TYPE_WWAN,
-                                  EEEPC_WMI_DEVID_WWAN3G);
-
-        if (result && result != -ENODEV)
-                goto exit;
-
-exit:
-        if (result && result != -ENODEV)
-                eeepc_wmi_rfkill_exit(eeepc);
-
-        if (result == -ENODEV)
-                result = 0;
-
-        return result;
-}
-
-/*
- * Backlight
- */
-static int read_brightness(struct backlight_device *bd)
-{
-        u32 retval;
-        acpi_status status;
-
-        status = eeepc_wmi_get_devstate(EEEPC_WMI_DEVID_BACKLIGHT, &retval);
-
-        if (ACPI_FAILURE(status))
-                return -1;
-        else
-                return retval & 0xFF;
-}
-
-static int update_bl_status(struct backlight_device *bd)
-{
-
-        u32 ctrl_param;
-        acpi_status status;
-
-        ctrl_param = bd->props.brightness;
-
-        status = eeepc_wmi_set_devstate(EEEPC_WMI_DEVID_BACKLIGHT,
-                                        ctrl_param, NULL);
-
-        if (ACPI_FAILURE(status))
-                return -1;
-        else
-                return 0;
-}
-
-static const struct backlight_ops eeepc_wmi_bl_ops = {
-        .get_brightness = read_brightness,
-        .update_status = update_bl_status,
-};
-
-static int eeepc_wmi_backlight_notify(struct eeepc_wmi *eeepc, int code)
-{
-        struct backlight_device *bd = eeepc->backlight_device;
-        int old = bd->props.brightness;
-        int new = old;
-
-        if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
-                new = code - NOTIFY_BRNUP_MIN + 1;
-        else if (code >= NOTIFY_BRNDOWN_MIN && code <= NOTIFY_BRNDOWN_MAX)
-                new = code - NOTIFY_BRNDOWN_MIN;
-
-        bd->props.brightness = new;
-        backlight_update_status(bd);
-        backlight_force_update(bd, BACKLIGHT_UPDATE_HOTKEY);
-
-        return old;
-}
-
-static int eeepc_wmi_backlight_init(struct eeepc_wmi *eeepc)
-{
-        struct backlight_device *bd;
-        struct backlight_properties props;
-
-        memset(&props, 0, sizeof(struct backlight_properties));
-        props.max_brightness = 15;
-        bd = backlight_device_register(EEEPC_WMI_FILE,
-                                       &eeepc->platform_device->dev, eeepc,
-                                       &eeepc_wmi_bl_ops, &props);
-        if (IS_ERR(bd)) {
-                pr_err("Could not register backlight device\n");
-                return PTR_ERR(bd);
-        }
-
-        eeepc->backlight_device = bd;
-
-        bd->props.brightness = read_brightness(bd);
-        bd->props.power = FB_BLANK_UNBLANK;
-        backlight_update_status(bd);
-
-        return 0;
-}
-
-static void eeepc_wmi_backlight_exit(struct eeepc_wmi *eeepc)
-{
-        if (eeepc->backlight_device)
-                backlight_device_unregister(eeepc->backlight_device);
-
-        eeepc->backlight_device = NULL;
-}
-
-static void eeepc_wmi_notify(u32 value, void *context)
-{
-        struct eeepc_wmi *eeepc = context;
-        struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
-        union acpi_object *obj;
-        acpi_status status;
-        int code;
-        int orig_code;
-
-        status = wmi_get_event_data(value, &response);
-        if (status != AE_OK) {
-                pr_err("bad event status 0x%x\n", status);
-                return;
-        }
-
-        obj = (union acpi_object *)response.pointer;
-
-        if (obj && obj->type == ACPI_TYPE_INTEGER) {
-                code = obj->integer.value;
-                orig_code = code;
-
-                if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
-                        code = NOTIFY_BRNUP_MIN;
-                else if (code >= NOTIFY_BRNDOWN_MIN &&
-                         code <= NOTIFY_BRNDOWN_MAX)
-                        code = NOTIFY_BRNDOWN_MIN;
-
-                if (code == NOTIFY_BRNUP_MIN || code == NOTIFY_BRNDOWN_MIN) {
-                        if (!acpi_video_backlight_support())
-                                eeepc_wmi_backlight_notify(eeepc, orig_code);
-                }
-
-                if (!sparse_keymap_report_event(eeepc->inputdev,
-                                                code, 1, true))
-                        pr_info("Unknown key %x pressed\n", code);
-        }
-
-        kfree(obj);
-}
-
-static ssize_t store_cpufv(struct device *dev, struct device_attribute *attr,
-                           const char *buf, size_t count)
-{
-        int value;
-        struct acpi_buffer input = { (acpi_size)sizeof(value), &value };
-        acpi_status status;
-
-        if (!count || sscanf(buf, "%i", &value) != 1)
-                return -EINVAL;
-        if (value < 0 || value > 2)
-                return -EINVAL;
-
-        status = wmi_evaluate_method(EEEPC_WMI_MGMT_GUID,
-                                     1, EEEPC_WMI_METHODID_CFVS, &input, NULL);
-
-        if (ACPI_FAILURE(status))
-                return -EIO;
-        else
-                return count;
-}
-
-static DEVICE_ATTR(cpufv, S_IRUGO | S_IWUSR, NULL, store_cpufv);
-
-static struct attribute *platform_attributes[] = {
-        &dev_attr_cpufv.attr,
-        NULL
-};
-
-static struct attribute_group platform_attribute_group = {
-        .attrs = platform_attributes
-};
-
-static void eeepc_wmi_sysfs_exit(struct platform_device *device)
-{
-        sysfs_remove_group(&device->dev.kobj, &platform_attribute_group);
-}
-
-static int eeepc_wmi_sysfs_init(struct platform_device *device)
-{
-        return sysfs_create_group(&device->dev.kobj, &platform_attribute_group);
-}
-
-/*
- * Platform device
- */
-static int __init eeepc_wmi_platform_init(struct eeepc_wmi *eeepc)
-{
-        int err;
-
-        eeepc->platform_device = platform_device_alloc(EEEPC_WMI_FILE, -1);
-        if (!eeepc->platform_device)
-                return -ENOMEM;
-        platform_set_drvdata(eeepc->platform_device, eeepc);
-
-        err = platform_device_add(eeepc->platform_device);
-        if (err)
-                goto fail_platform_device;
-
-        err = eeepc_wmi_sysfs_init(eeepc->platform_device);
-        if (err)
-                goto fail_sysfs;
-        return 0;
-
-fail_sysfs:
-        platform_device_del(eeepc->platform_device);
-fail_platform_device:
-        platform_device_put(eeepc->platform_device);
-        return err;
-}
-
-static void eeepc_wmi_platform_exit(struct eeepc_wmi *eeepc)
-{
-        eeepc_wmi_sysfs_exit(eeepc->platform_device);
-        platform_device_unregister(eeepc->platform_device);
-}
-
-/*
- * debugfs
- */
-struct eeepc_wmi_debugfs_node {
-        struct eeepc_wmi *eeepc;
-        char *name;
-        int (*show)(struct seq_file *m, void *data);
-};
-
-static int show_dsts(struct seq_file *m, void *data)
-{
-        struct eeepc_wmi *eeepc = m->private;
-        acpi_status status;
-        u32 retval = -1;
-
-        status = eeepc_wmi_get_devstate(eeepc->debug.dev_id, &retval);
-
-        if (ACPI_FAILURE(status))
-                return -EIO;
-
-        seq_printf(m, "DSTS(%x) = %x\n", eeepc->debug.dev_id, retval);
-
-        return 0;
-}
-
-static int show_devs(struct seq_file *m, void *data)
-{
-        struct eeepc_wmi *eeepc = m->private;
-        acpi_status status;
-        u32 retval = -1;
-
-        status = eeepc_wmi_set_devstate(eeepc->debug.dev_id,
-                                        eeepc->debug.ctrl_param, &retval);
-        if (ACPI_FAILURE(status))
-                return -EIO;
-
-        seq_printf(m, "DEVS(%x, %x) = %x\n", eeepc->debug.dev_id,
-                   eeepc->debug.ctrl_param, retval);
-
-        return 0;
-}
-
-static struct eeepc_wmi_debugfs_node eeepc_wmi_debug_files[] = {
-        { NULL, "devs", show_devs },
-        { NULL, "dsts", show_dsts },
-};
-
-static int eeepc_wmi_debugfs_open(struct inode *inode, struct file *file)
-{
-        struct eeepc_wmi_debugfs_node *node = inode->i_private;
-
-        return single_open(file, node->show, node->eeepc);
-}
-
-static const struct file_operations eeepc_wmi_debugfs_io_ops = {
-        .owner = THIS_MODULE,
-        .open  = eeepc_wmi_debugfs_open,
-        .read = seq_read,
-        .llseek = seq_lseek,
-        .release = single_release,
-};
-
-static void eeepc_wmi_debugfs_exit(struct eeepc_wmi *eeepc)
-{
-        debugfs_remove_recursive(eeepc->debug.root);
-}
-
-static int eeepc_wmi_debugfs_init(struct eeepc_wmi *eeepc)
-{
-        struct dentry *dent;
-        int i;
-
-        eeepc->debug.root = debugfs_create_dir(EEEPC_WMI_FILE, NULL);
-        if (!eeepc->debug.root) {
-                pr_err("failed to create debugfs directory");
-                goto error_debugfs;
-        }
-
-        dent = debugfs_create_x32("dev_id", S_IRUGO|S_IWUSR,
-                                  eeepc->debug.root, &eeepc->debug.dev_id);
-        if (!dent)
-                goto error_debugfs;
-
-        dent = debugfs_create_x32("ctrl_param", S_IRUGO|S_IWUSR,
-                                  eeepc->debug.root, &eeepc->debug.ctrl_param);
-        if (!dent)
-                goto error_debugfs;
-
-        for (i = 0; i < ARRAY_SIZE(eeepc_wmi_debug_files); i++) {
-                struct eeepc_wmi_debugfs_node *node = &eeepc_wmi_debug_files[i];
-
-                node->eeepc = eeepc;
-                dent = debugfs_create_file(node->name, S_IFREG | S_IRUGO,
-                                           eeepc->debug.root, node,
-                                           &eeepc_wmi_debugfs_io_ops);
-                if (!dent) {
-                        pr_err("failed to create debug file: %s\n", node->name);
-                        goto error_debugfs;
-                }
-        }
-
-        return 0;
-
-error_debugfs:
-        eeepc_wmi_debugfs_exit(eeepc);
-        return -ENOMEM;
-}
-
-/*
- * WMI Driver
- */
-static struct platform_device * __init eeepc_wmi_add(void)
-{
-        struct eeepc_wmi *eeepc;
-        acpi_status status;
-        int err;
-
-        eeepc = kzalloc(sizeof(struct eeepc_wmi), GFP_KERNEL);
-        if (!eeepc)
-                return ERR_PTR(-ENOMEM);
-
-        /*
-         * Register the platform device first.  It is used as a parent for the
-         * sub-devices below.
-         */
-        err = eeepc_wmi_platform_init(eeepc);
-        if (err)
-                goto fail_platform;
-
-        err = eeepc_wmi_input_init(eeepc);
-        if (err)
-                goto fail_input;
-
-        err = eeepc_wmi_led_init(eeepc);
-        if (err)
-                goto fail_leds;
-
-        err = eeepc_wmi_rfkill_init(eeepc);
-        if (err)
-                goto fail_rfkill;
-
-        if (!acpi_video_backlight_support()) {
-                err = eeepc_wmi_backlight_init(eeepc);
-                if (err)
-                        goto fail_backlight;
-        } else
-                pr_info("Backlight controlled by ACPI video driver\n");
-
-        status = wmi_install_notify_handler(EEEPC_WMI_EVENT_GUID,
-                                            eeepc_wmi_notify, eeepc);
-        if (ACPI_FAILURE(status)) {
-                pr_err("Unable to register notify handler - %d\n",
-                        status);
-                err = -ENODEV;
-                goto fail_wmi_handler;
-        }
-
-        err = eeepc_wmi_debugfs_init(eeepc);
-        if (err)
-                goto fail_debugfs;
-
-        return eeepc->platform_device;
-
-fail_debugfs:
-        wmi_remove_notify_handler(EEEPC_WMI_EVENT_GUID);
-fail_wmi_handler:
-        eeepc_wmi_backlight_exit(eeepc);
-fail_backlight:
-        eeepc_wmi_rfkill_exit(eeepc);
-fail_rfkill:
-        eeepc_wmi_led_exit(eeepc);
-fail_leds:
-        eeepc_wmi_input_exit(eeepc);
-fail_input:
-        eeepc_wmi_platform_exit(eeepc);
-fail_platform:
-        kfree(eeepc);
-        return ERR_PTR(err);
-}
-
-static int eeepc_wmi_remove(struct platform_device *device)
-{
-        struct eeepc_wmi *eeepc;
-
-        eeepc = platform_get_drvdata(device);
-        wmi_remove_notify_handler(EEEPC_WMI_EVENT_GUID);
-        eeepc_wmi_backlight_exit(eeepc);
-        eeepc_wmi_input_exit(eeepc);
-        eeepc_wmi_led_exit(eeepc);
-        eeepc_wmi_rfkill_exit(eeepc);
-        eeepc_wmi_debugfs_exit(eeepc);
-        eeepc_wmi_platform_exit(eeepc);
-
-        kfree(eeepc);
-        return 0;
-}
-
-static struct platform_driver platform_driver = {
-        .driver = {
-                .name = EEEPC_WMI_FILE,
-                .owner = THIS_MODULE,
-        },
-};
-
-static acpi_status __init eeepc_wmi_parse_device(acpi_handle handle, u32 level,
+static acpi_status eeepc_wmi_parse_device(acpi_handle handle, u32 level,
                                                  void *context, void **retval)
 {
         pr_warning("Found legacy ATKD device (%s)", EEEPC_ACPI_HID);
@@ -871,7 +87,7 @@ static acpi_status __init eeepc_wmi_parse_device(acpi_handle handle, u32 level,
         return AE_CTRL_TERMINATE;
 }
 
-static int __init eeepc_wmi_check_atkd(void)
+static int eeepc_wmi_check_atkd(void)
 {
         acpi_status status;
         bool found = false;
@@ -884,16 +100,8 @@ static int __init eeepc_wmi_check_atkd(void)
         return -1;
 }
 
-static int __init eeepc_wmi_init(void)
+static int eeepc_wmi_probe(struct platform_device *pdev)
 {
-        int err;
-
-        if (!wmi_has_guid(EEEPC_WMI_EVENT_GUID) ||
-            !wmi_has_guid(EEEPC_WMI_MGMT_GUID)) {
-                pr_warning("No known WMI GUID found\n");
-                return -ENODEV;
-        }
-
         if (eeepc_wmi_check_atkd()) {
                 pr_warning("WMI device present, but legacy ATKD device is also "
                            "present and enabled.");
@@ -901,33 +109,59 @@ static int __init eeepc_wmi_init(void)
                            "acpi_osi=\"!Windows 2009\"");
                 pr_warning("Can't load eeepc-wmi, use default acpi_osi "
                            "(preferred) or eeepc-laptop");
-                return -ENODEV;
+                return -EBUSY;
         }
+        return 0;
+}
 
-        platform_device = eeepc_wmi_add();
-        if (IS_ERR(platform_device)) {
-                err = PTR_ERR(platform_device);
-                goto fail_eeepc_wmi;
-        }
+static void eeepc_dmi_check(struct asus_wmi_driver *driver)
+{
+        const char *model;
+
+        model = dmi_get_system_info(DMI_PRODUCT_NAME);
+        if (!model)
+                return;
 
-        err = platform_driver_register(&platform_driver);
-        if (err) {
-                pr_warning("Unable to register platform driver\n");
-                goto fail_platform_driver;
+        /*
+         * Whitelist for wlan hotplug
+         *
+         * Asus 1000H needs the current hotplug code to handle
+         * Fn+F2 correctly. We may add other Asus here later, but
+         * it seems that most of the laptops supported by asus-wmi
+         * don't need to be on this list
+         */
+        if (strcmp(model, "1000H") == 0) {
+                driver->hotplug_wireless = true;
+                pr_info("wlan hotplug enabled\n");
         }
+}
+
+static void eeepc_wmi_quirks(struct asus_wmi_driver *driver)
+{
+        driver->hotplug_wireless = hotplug_wireless;
+        eeepc_dmi_check(driver);
+}
+
+static struct asus_wmi_driver asus_wmi_driver = {
+        .name = EEEPC_WMI_FILE,
+        .owner = THIS_MODULE,
+        .event_guid = EEEPC_WMI_EVENT_GUID,
+        .keymap = eeepc_wmi_keymap,
+        .input_name = "Eee PC WMI hotkeys",
+        .input_phys = EEEPC_WMI_FILE "/input0",
+        .probe = eeepc_wmi_probe,
+        .quirks = eeepc_wmi_quirks,
+};
 
-        return 0;
 
-fail_platform_driver:
-        eeepc_wmi_remove(platform_device);
-fail_eeepc_wmi:
-        return err;
+static int __init eeepc_wmi_init(void)
+{
+        return asus_wmi_register_driver(&asus_wmi_driver);
 }
 
 static void __exit eeepc_wmi_exit(void)
 {
-        eeepc_wmi_remove(platform_device);
-        platform_driver_unregister(&platform_driver);
+        asus_wmi_unregister_driver(&asus_wmi_driver);
 }
 
 module_init(eeepc_wmi_init);
diff --git a/drivers/platform/x86/hp-wmi.c b/drivers/platform/x86/hp-wmi.c
index 9e05af9c41cb..1bc4a7539ba9 100644
--- a/drivers/platform/x86/hp-wmi.c
+++ b/drivers/platform/x86/hp-wmi.c
@@ -2,6 +2,7 @@
  * HP WMI hotkeys
  *
  * Copyright (C) 2008 Red Hat <mjg@redhat.com>
+ * Copyright (C) 2010, 2011 Anssi Hannula <anssi.hannula@iki.fi>
  *
  * Portions based on wistron_btns.c:
  * Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
@@ -51,6 +52,7 @@ MODULE_ALIAS("wmi:5FB7F034-2C63-45e9-BE91-3D44E2C707E4");
 #define HPWMI_HARDWARE_QUERY 0x4
 #define HPWMI_WIRELESS_QUERY 0x5
 #define HPWMI_HOTKEY_QUERY 0xc
+#define HPWMI_WIRELESS2_QUERY 0x1b
 
 #define PREFIX "HP WMI: "
 #define UNIMP "Unimplemented "
@@ -86,7 +88,46 @@ struct bios_args {
 struct bios_return {
         u32 sigpass;
         u32 return_code;
-        u32 value;
+};
+
+enum hp_return_value {
+        HPWMI_RET_WRONG_SIGNATURE       = 0x02,
+        HPWMI_RET_UNKNOWN_COMMAND       = 0x03,
+        HPWMI_RET_UNKNOWN_CMDTYPE       = 0x04,
+        HPWMI_RET_INVALID_PARAMETERS    = 0x05,
+};
+
+enum hp_wireless2_bits {
+        HPWMI_POWER_STATE       = 0x01,
+        HPWMI_POWER_SOFT        = 0x02,
+        HPWMI_POWER_BIOS        = 0x04,
+        HPWMI_POWER_HARD        = 0x08,
+};
+
+#define IS_HWBLOCKED(x) ((x & (HPWMI_POWER_BIOS | HPWMI_POWER_HARD)) \
+                         != (HPWMI_POWER_BIOS | HPWMI_POWER_HARD))
+#define IS_SWBLOCKED(x) !(x & HPWMI_POWER_SOFT)
+
+struct bios_rfkill2_device_state {
+        u8 radio_type;
+        u8 bus_type;
+        u16 vendor_id;
+        u16 product_id;
+        u16 subsys_vendor_id;
+        u16 subsys_product_id;
+        u8 rfkill_id;
+        u8 power;
+        u8 unknown[4];
+};
+
+/* 7 devices fit into the 128 byte buffer */
+#define HPWMI_MAX_RFKILL2_DEVICES       7
+
+struct bios_rfkill2_state {
+        u8 unknown[7];
+        u8 count;
+        u8 pad[8];
+        struct bios_rfkill2_device_state device[HPWMI_MAX_RFKILL2_DEVICES];
 };
 
 static const struct key_entry hp_wmi_keymap[] = {
@@ -108,6 +149,15 @@ static struct rfkill *wifi_rfkill;
 static struct rfkill *bluetooth_rfkill;
 static struct rfkill *wwan_rfkill;
 
+struct rfkill2_device {
+        u8 id;
+        int num;
+        struct rfkill *rfkill;
+};
+
+static int rfkill2_count;
+static struct rfkill2_device rfkill2[HPWMI_MAX_RFKILL2_DEVICES];
+
 static const struct dev_pm_ops hp_wmi_pm_ops = {
         .resume  = hp_wmi_resume_handler,
         .restore  = hp_wmi_resume_handler,
@@ -129,7 +179,8 @@ static struct platform_driver hp_wmi_driver = {
  * query:       The commandtype -> What should be queried
  * write:       The command -> 0 read, 1 write, 3 ODM specific
  * buffer:      Buffer used as input and/or output
- * buffersize:  Size of buffer
+ * insize:      Size of input buffer
+ * outsize:     Size of output buffer
  *
  * returns zero on success
  *         an HP WMI query specific error code (which is positive)
@@ -140,25 +191,29 @@ static struct platform_driver hp_wmi_driver = {
  *       size. E.g. Battery info query (0x7) is defined to have 1 byte input
  *       and 128 byte output. The caller would do:
  *       buffer = kzalloc(128, GFP_KERNEL);
- *       ret = hp_wmi_perform_query(0x7, 0, buffer, 128)
+ *       ret = hp_wmi_perform_query(0x7, 0, buffer, 1, 128)
  */
-static int hp_wmi_perform_query(int query, int write, u32 *buffer,
-                                int buffersize)
+static int hp_wmi_perform_query(int query, int write, void *buffer,
+                                int insize, int outsize)
 {
-        struct bios_return bios_return;
-        acpi_status status;
+        struct bios_return *bios_return;
+        int actual_outsize;
         union acpi_object *obj;
         struct bios_args args = {
                 .signature = 0x55434553,
                 .command = write ? 0x2 : 0x1,
                 .commandtype = query,
-                .datasize = buffersize,
-                .data = *buffer,
+                .datasize = insize,
+                .data = 0,
         };
         struct acpi_buffer input = { sizeof(struct bios_args), &args };
         struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
 
-        status = wmi_evaluate_method(HPWMI_BIOS_GUID, 0, 0x3, &input, &output);
+        if (WARN_ON(insize > sizeof(args.data)))
+                return -EINVAL;
+        memcpy(&args.data, buffer, insize);
+
+        wmi_evaluate_method(HPWMI_BIOS_GUID, 0, 0x3, &input, &output);
 
         obj = output.pointer;
 
@@ -169,10 +224,26 @@ static int hp_wmi_perform_query(int query, int write, u32 *buffer,
                 return -EINVAL;
         }
 
-        bios_return = *((struct bios_return *)obj->buffer.pointer);
+        bios_return = (struct bios_return *)obj->buffer.pointer;
 
-        memcpy(buffer, &bios_return.value, sizeof(bios_return.value));
+        if (bios_return->return_code) {
+                if (bios_return->return_code != HPWMI_RET_UNKNOWN_CMDTYPE)
+                        printk(KERN_WARNING PREFIX "query 0x%x returned "
+                                                   "error 0x%x\n",
+                               query, bios_return->return_code);
+                kfree(obj);
+                return bios_return->return_code;
+        }
+
+        if (!outsize) {
+                /* ignore output data */
+                kfree(obj);
+                return 0;
+        }
 
+        actual_outsize = min(outsize, (int)(obj->buffer.length - sizeof(*bios_return)));
+        memcpy(buffer, obj->buffer.pointer + sizeof(*bios_return), actual_outsize);
+        memset(buffer + actual_outsize, 0, outsize - actual_outsize);
         kfree(obj);
         return 0;
 }
@@ -181,7 +252,7 @@ static int hp_wmi_display_state(void)
 {
         int state = 0;
         int ret = hp_wmi_perform_query(HPWMI_DISPLAY_QUERY, 0, &state,
-                                       sizeof(state));
+                                       sizeof(state), sizeof(state));
         if (ret)
                 return -EINVAL;
         return state;
@@ -191,7 +262,7 @@ static int hp_wmi_hddtemp_state(void)
 {
         int state = 0;
         int ret = hp_wmi_perform_query(HPWMI_HDDTEMP_QUERY, 0, &state,
-                                       sizeof(state));
+                                       sizeof(state), sizeof(state));
         if (ret)
                 return -EINVAL;
         return state;
@@ -201,7 +272,7 @@ static int hp_wmi_als_state(void)
 {
         int state = 0;
         int ret = hp_wmi_perform_query(HPWMI_ALS_QUERY, 0, &state,
-                                       sizeof(state));
+                                       sizeof(state), sizeof(state));
         if (ret)
                 return -EINVAL;
         return state;
@@ -211,7 +282,7 @@ static int hp_wmi_dock_state(void)
 {
         int state = 0;
         int ret = hp_wmi_perform_query(HPWMI_HARDWARE_QUERY, 0, &state,
-                                       sizeof(state));
+                                       sizeof(state), sizeof(state));
 
         if (ret)
                 return -EINVAL;
@@ -223,7 +294,7 @@ static int hp_wmi_tablet_state(void)
 {
         int state = 0;
         int ret = hp_wmi_perform_query(HPWMI_HARDWARE_QUERY, 0, &state,
-                                       sizeof(state));
+                                       sizeof(state), sizeof(state));
         if (ret)
                 return ret;
 
@@ -237,7 +308,7 @@ static int hp_wmi_set_block(void *data, bool blocked)
         int ret;
 
         ret = hp_wmi_perform_query(HPWMI_WIRELESS_QUERY, 1,
-                                   &query, sizeof(query));
+                                   &query, sizeof(query), 0);
         if (ret)
                 return -EINVAL;
         return 0;
@@ -252,7 +323,8 @@ static bool hp_wmi_get_sw_state(enum hp_wmi_radio r)
         int wireless = 0;
         int mask;
         hp_wmi_perform_query(HPWMI_WIRELESS_QUERY, 0,
-                             &wireless, sizeof(wireless));
+                             &wireless, sizeof(wireless),
+                             sizeof(wireless));
         /* TBD: Pass error */
 
         mask = 0x200 << (r * 8);
@@ -268,7 +340,8 @@ static bool hp_wmi_get_hw_state(enum hp_wmi_radio r)
         int wireless = 0;
         int mask;
         hp_wmi_perform_query(HPWMI_WIRELESS_QUERY, 0,
-                             &wireless, sizeof(wireless));
+                             &wireless, sizeof(wireless),
+                             sizeof(wireless));
         /* TBD: Pass error */
 
         mask = 0x800 << (r * 8);
@@ -279,6 +352,51 @@ static bool hp_wmi_get_hw_state(enum hp_wmi_radio r)
                 return true;
 }
 
+static int hp_wmi_rfkill2_set_block(void *data, bool blocked)
+{
+        int rfkill_id = (int)(long)data;
+        char buffer[4] = { 0x01, 0x00, rfkill_id, !blocked };
+
+        if (hp_wmi_perform_query(HPWMI_WIRELESS2_QUERY, 1,
+                                   buffer, sizeof(buffer), 0))
+                return -EINVAL;
+        return 0;
+}
+
+static const struct rfkill_ops hp_wmi_rfkill2_ops = {
+        .set_block = hp_wmi_rfkill2_set_block,
+};
+
+static int hp_wmi_rfkill2_refresh(void)
+{
+        int err, i;
+        struct bios_rfkill2_state state;
+
+        err = hp_wmi_perform_query(HPWMI_WIRELESS2_QUERY, 0, &state,
+                                   0, sizeof(state));
+        if (err)
+                return err;
+
+        for (i = 0; i < rfkill2_count; i++) {
+                int num = rfkill2[i].num;
+                struct bios_rfkill2_device_state *devstate;
+                devstate = &state.device[num];
+
+                if (num >= state.count ||
+                    devstate->rfkill_id != rfkill2[i].id) {
+                        printk(KERN_WARNING PREFIX "power configuration of "
+                               "the wireless devices unexpectedly changed\n");
+                        continue;
+                }
+
+                rfkill_set_states(rfkill2[i].rfkill,
+                                  IS_SWBLOCKED(devstate->power),
+                                  IS_HWBLOCKED(devstate->power));
+        }
+
+        return 0;
+}
+
 static ssize_t show_display(struct device *dev, struct device_attribute *attr,
                             char *buf)
 {
@@ -329,7 +447,7 @@ static ssize_t set_als(struct device *dev, struct device_attribute *attr,
 {
         u32 tmp = simple_strtoul(buf, NULL, 10);
         int ret = hp_wmi_perform_query(HPWMI_ALS_QUERY, 1, &tmp,
-                                       sizeof(tmp));
+                                       sizeof(tmp), sizeof(tmp));
         if (ret)
                 return -EINVAL;
 
@@ -402,6 +520,7 @@ static void hp_wmi_notify(u32 value, void *context)
         case HPWMI_BEZEL_BUTTON:
                 ret = hp_wmi_perform_query(HPWMI_HOTKEY_QUERY, 0,
                                            &key_code,
+                                           sizeof(key_code),
                                            sizeof(key_code));
                 if (ret)
                         break;
@@ -412,6 +531,11 @@ static void hp_wmi_notify(u32 value, void *context)
                                key_code);
                 break;
         case HPWMI_WIRELESS:
+                if (rfkill2_count) {
+                        hp_wmi_rfkill2_refresh();
+                        break;
+                }
+
                 if (wifi_rfkill)
                         rfkill_set_states(wifi_rfkill,
                                           hp_wmi_get_sw_state(HPWMI_WIFI),
@@ -502,32 +626,16 @@ static void cleanup_sysfs(struct platform_device *device)
         device_remove_file(&device->dev, &dev_attr_tablet);
 }
 
-static int __devinit hp_wmi_bios_setup(struct platform_device *device)
+static int __devinit hp_wmi_rfkill_setup(struct platform_device *device)
 {
         int err;
         int wireless = 0;
 
         err = hp_wmi_perform_query(HPWMI_WIRELESS_QUERY, 0, &wireless,
-                                   sizeof(wireless));
+                                   sizeof(wireless), sizeof(wireless));
         if (err)
                 return err;
 
-        err = device_create_file(&device->dev, &dev_attr_display);
-        if (err)
-                goto add_sysfs_error;
-        err = device_create_file(&device->dev, &dev_attr_hddtemp);
-        if (err)
-                goto add_sysfs_error;
-        err = device_create_file(&device->dev, &dev_attr_als);
-        if (err)
-                goto add_sysfs_error;
-        err = device_create_file(&device->dev, &dev_attr_dock);
-        if (err)
-                goto add_sysfs_error;
-        err = device_create_file(&device->dev, &dev_attr_tablet);
-        if (err)
-                goto add_sysfs_error;
-
         if (wireless & 0x1) {
                 wifi_rfkill = rfkill_alloc("hp-wifi", &device->dev,
                                            RFKILL_TYPE_WLAN,
@@ -573,14 +681,131 @@ static int __devinit hp_wmi_bios_setup(struct platform_device *device)
         return 0;
 register_wwan_err:
         rfkill_destroy(wwan_rfkill);
+        wwan_rfkill = NULL;
         if (bluetooth_rfkill)
                 rfkill_unregister(bluetooth_rfkill);
 register_bluetooth_error:
         rfkill_destroy(bluetooth_rfkill);
+        bluetooth_rfkill = NULL;
         if (wifi_rfkill)
                 rfkill_unregister(wifi_rfkill);
 register_wifi_error:
         rfkill_destroy(wifi_rfkill);
+        wifi_rfkill = NULL;
+        return err;
+}
+
+static int __devinit hp_wmi_rfkill2_setup(struct platform_device *device)
+{
+        int err, i;
+        struct bios_rfkill2_state state;
+        err = hp_wmi_perform_query(HPWMI_WIRELESS2_QUERY, 0, &state,
+                                   0, sizeof(state));
+        if (err)
+                return err;
+
+        if (state.count > HPWMI_MAX_RFKILL2_DEVICES) {
+                printk(KERN_WARNING PREFIX "unable to parse 0x1b query output\n");
+                return -EINVAL;
+        }
+
+        for (i = 0; i < state.count; i++) {
+                struct rfkill *rfkill;
+                enum rfkill_type type;
+                char *name;
+                switch (state.device[i].radio_type) {
+                case HPWMI_WIFI:
+                        type = RFKILL_TYPE_WLAN;
+                        name = "hp-wifi";
+                        break;
+                case HPWMI_BLUETOOTH:
+                        type = RFKILL_TYPE_BLUETOOTH;
+                        name = "hp-bluetooth";
+                        break;
+                case HPWMI_WWAN:
+                        type = RFKILL_TYPE_WWAN;
+                        name = "hp-wwan";
+                        break;
+                default:
+                        printk(KERN_WARNING PREFIX "unknown device type 0x%x\n",
+                                 state.device[i].radio_type);
+                        continue;
+                }
+
+                if (!state.device[i].vendor_id) {
+                        printk(KERN_WARNING PREFIX "zero device %d while %d "
+                               "reported\n", i, state.count);
+                        continue;
+                }
+
+                rfkill = rfkill_alloc(name, &device->dev, type,
+                                      &hp_wmi_rfkill2_ops, (void *)(long)i);
+                if (!rfkill) {
+                        err = -ENOMEM;
+                        goto fail;
+                }
+
+                rfkill2[rfkill2_count].id = state.device[i].rfkill_id;
+                rfkill2[rfkill2_count].num = i;
+                rfkill2[rfkill2_count].rfkill = rfkill;
+
+                rfkill_init_sw_state(rfkill,
+                                     IS_SWBLOCKED(state.device[i].power));
+                rfkill_set_hw_state(rfkill,
+                                    IS_HWBLOCKED(state.device[i].power));
+
+                if (!(state.device[i].power & HPWMI_POWER_BIOS))
+                        printk(KERN_INFO PREFIX "device %s blocked by BIOS\n",
+                               name);
+
+                err = rfkill_register(rfkill);
+                if (err) {
+                        rfkill_destroy(rfkill);
+                        goto fail;
+                }
+
+                rfkill2_count++;
+        }
+
+        return 0;
+fail:
+        for (; rfkill2_count > 0; rfkill2_count--) {
+                rfkill_unregister(rfkill2[rfkill2_count - 1].rfkill);
+                rfkill_destroy(rfkill2[rfkill2_count - 1].rfkill);
+        }
+        return err;
+}
+
+static int __devinit hp_wmi_bios_setup(struct platform_device *device)
+{
+        int err;
+
+        /* clear detected rfkill devices */
+        wifi_rfkill = NULL;
+        bluetooth_rfkill = NULL;
+        wwan_rfkill = NULL;
+        rfkill2_count = 0;
+
+        if (hp_wmi_rfkill_setup(device))
+                hp_wmi_rfkill2_setup(device);
+
+        err = device_create_file(&device->dev, &dev_attr_display);
+        if (err)
+                goto add_sysfs_error;
+        err = device_create_file(&device->dev, &dev_attr_hddtemp);
+        if (err)
+                goto add_sysfs_error;
+        err = device_create_file(&device->dev, &dev_attr_als);
+        if (err)
+                goto add_sysfs_error;
+        err = device_create_file(&device->dev, &dev_attr_dock);
+        if (err)
+                goto add_sysfs_error;
+        err = device_create_file(&device->dev, &dev_attr_tablet);
+        if (err)
+                goto add_sysfs_error;
+        return 0;
+
 add_sysfs_error:
         cleanup_sysfs(device);
         return err;
@@ -588,8 +813,14 @@ add_sysfs_error:
 
 static int __exit hp_wmi_bios_remove(struct platform_device *device)
 {
+        int i;
         cleanup_sysfs(device);
 
+        for (i = 0; i < rfkill2_count; i++) {
+                rfkill_unregister(rfkill2[i].rfkill);
+                rfkill_destroy(rfkill2[i].rfkill);
+        }
+
         if (wifi_rfkill) {
                 rfkill_unregister(wifi_rfkill);
                 rfkill_destroy(wifi_rfkill);
@@ -622,6 +853,9 @@ static int hp_wmi_resume_handler(struct device *device)
                 input_sync(hp_wmi_input_dev);
         }
 
+        if (rfkill2_count)
+                hp_wmi_rfkill2_refresh();
+
         if (wifi_rfkill)
                 rfkill_set_states(wifi_rfkill,
                                   hp_wmi_get_sw_state(HPWMI_WIFI),
diff --git a/drivers/platform/x86/ideapad-laptop.c b/drivers/platform/x86/ideapad-laptop.c
index 114d95247cdf..21b101899bae 100644
--- a/drivers/platform/x86/ideapad-laptop.c
+++ b/drivers/platform/x86/ideapad-laptop.c
@@ -459,6 +459,8 @@ static void ideapad_acpi_notify(struct acpi_device *adevice, u32 event)
                 if (test_bit(vpc_bit, &vpc1)) {
                         if (vpc_bit == 9)
                                 ideapad_sync_rfk_state(adevice);
+                        else if (vpc_bit == 4)
+                                read_ec_data(handle, 0x12, &vpc2);
                         else
                                 ideapad_input_report(priv, vpc_bit);
                 }
diff --git a/drivers/platform/x86/intel_ips.c b/drivers/platform/x86/intel_ips.c
index 1294a39373ba..85c8ad43c0c5 100644
--- a/drivers/platform/x86/intel_ips.c
+++ b/drivers/platform/x86/intel_ips.c
@@ -1111,7 +1111,7 @@ static int ips_monitor(void *data)
                 last_msecs = jiffies_to_msecs(jiffies);
                 expire = jiffies + msecs_to_jiffies(IPS_SAMPLE_PERIOD);
 
-                __set_current_state(TASK_UNINTERRUPTIBLE);
+                __set_current_state(TASK_INTERRUPTIBLE);
                 mod_timer(&timer, expire);
                 schedule();
 
diff --git a/drivers/platform/x86/intel_mid_powerbtn.c b/drivers/platform/x86/intel_mid_powerbtn.c
new file mode 100644
index 000000000000..213e79ba68d5
--- /dev/null
+++ b/drivers/platform/x86/intel_mid_powerbtn.c
@@ -0,0 +1,148 @@
+/*
+ * Power button driver for Medfield.
+ *
+ * Copyright (C) 2010 Intel Corp
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/slab.h>
+#include <linux/platform_device.h>
+#include <linux/input.h>
+#include <asm/intel_scu_ipc.h>
+
+#define DRIVER_NAME "msic_power_btn"
+
+#define MSIC_IRQ_STAT   0x02
+  #define MSIC_IRQ_PB   (1 << 0)
+#define MSIC_PB_CONFIG  0x3e
+#define MSIC_PB_STATUS  0x3f
+  #define MSIC_PB_LEVEL (1 << 3) /* 1 - release, 0 - press */
+
+struct mfld_pb_priv {
+        struct input_dev *input;
+        unsigned int irq;
+};
+
+static irqreturn_t mfld_pb_isr(int irq, void *dev_id)
+{
+        struct mfld_pb_priv *priv = dev_id;
+        int ret;
+        u8 pbstat;
+
+        ret = intel_scu_ipc_ioread8(MSIC_PB_STATUS, &pbstat);
+        if (ret < 0)
+                return IRQ_HANDLED;
+
+        input_event(priv->input, EV_KEY, KEY_POWER, !(pbstat & MSIC_PB_LEVEL));
+        input_sync(priv->input);
+
+        return IRQ_HANDLED;
+}
+
+static int __devinit mfld_pb_probe(struct platform_device *pdev)
+{
+        struct mfld_pb_priv *priv;
+        struct input_dev *input;
+        int irq;
+        int error;
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0)
+                return -EINVAL;
+
+        priv = kzalloc(sizeof(struct mfld_pb_priv), GFP_KERNEL);
+        input = input_allocate_device();
+        if (!priv || !input) {
+                error = -ENOMEM;
+                goto err_free_mem;
+        }
+
+        priv->input = input;
+        priv->irq = irq;
+
+        input->name = pdev->name;
+        input->phys = "power-button/input0";
+        input->id.bustype = BUS_HOST;
+        input->dev.parent = &pdev->dev;
+
+        input_set_capability(input, EV_KEY, KEY_POWER);
+
+        error = request_threaded_irq(priv->irq, NULL, mfld_pb_isr,
+                                     0, DRIVER_NAME, priv);
+        if (error) {
+                dev_err(&pdev->dev,
+                        "unable to request irq %d for mfld power button\n",
+                        irq);
+                goto err_free_mem;
+        }
+
+        error = input_register_device(input);
+        if (error) {
+                dev_err(&pdev->dev,
+                        "unable to register input dev, error %d\n", error);
+                goto err_free_irq;
+        }
+
+        platform_set_drvdata(pdev, priv);
+        return 0;
+
+err_free_irq:
+        free_irq(priv->irq, priv);
+err_free_mem:
+        input_free_device(input);
+        kfree(priv);
+        return error;
+}
+
+static int __devexit mfld_pb_remove(struct platform_device *pdev)
+{
+        struct mfld_pb_priv *priv = platform_get_drvdata(pdev);
+
+        free_irq(priv->irq, priv);
+        input_unregister_device(priv->input);
+        kfree(priv);
+
+        platform_set_drvdata(pdev, NULL);
+        return 0;
+}
+
+static struct platform_driver mfld_pb_driver = {
+        .driver = {
+                .name = DRIVER_NAME,
+                .owner = THIS_MODULE,
+        },
+        .probe  = mfld_pb_probe,
+        .remove = __devexit_p(mfld_pb_remove),
+};
+
+static int __init mfld_pb_init(void)
+{
+        return platform_driver_register(&mfld_pb_driver);
+}
+module_init(mfld_pb_init);
+
+static void __exit mfld_pb_exit(void)
+{
+        platform_driver_unregister(&mfld_pb_driver);
+}
+module_exit(mfld_pb_exit);
+
+MODULE_AUTHOR("Hong Liu <hong.liu@intel.com>");
+MODULE_DESCRIPTION("Intel Medfield Power Button Driver");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:" DRIVER_NAME);
diff --git a/drivers/platform/x86/intel_mid_thermal.c b/drivers/platform/x86/intel_mid_thermal.c
new file mode 100644
index 000000000000..6c12db503161
--- /dev/null
+++ b/drivers/platform/x86/intel_mid_thermal.c
@@ -0,0 +1,576 @@
+/*
+ * intel_mid_thermal.c - Intel MID platform thermal driver
+ *
+ * Copyright (C) 2011 Intel Corporation
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.        See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ * Author: Durgadoss R <durgadoss.r@intel.com>
+ */
+
+#define pr_fmt(fmt) "intel_mid_thermal: " fmt
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/err.h>
+#include <linux/param.h>
+#include <linux/device.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/pm.h>
+#include <linux/thermal.h>
+
+#include <asm/intel_scu_ipc.h>
+
+/* Number of thermal sensors */
+#define MSIC_THERMAL_SENSORS   4
+
+/* ADC1 - thermal registers */
+#define MSIC_THERM_ADC1CNTL1   0x1C0
+#define MSIC_ADC_ENBL          0x10
+#define MSIC_ADC_START         0x08
+
+#define MSIC_THERM_ADC1CNTL3   0x1C2
+#define MSIC_ADCTHERM_ENBL     0x04
+#define MSIC_ADCRRDATA_ENBL    0x05
+#define MSIC_CHANL_MASK_VAL    0x0F
+
+#define MSIC_STOPBIT_MASK      16
+#define MSIC_ADCTHERM_MASK     4
+#define ADC_CHANLS_MAX         15 /* Number of ADC channels */
+#define ADC_LOOP_MAX           (ADC_CHANLS_MAX - MSIC_THERMAL_SENSORS)
+
+/* ADC channel code values */
+#define SKIN_SENSOR0_CODE      0x08
+#define SKIN_SENSOR1_CODE      0x09
+#define SYS_SENSOR_CODE                0x0A
+#define MSIC_DIE_SENSOR_CODE   0x03
+
+#define SKIN_THERM_SENSOR0     0
+#define SKIN_THERM_SENSOR1     1
+#define SYS_THERM_SENSOR2      2
+#define MSIC_DIE_THERM_SENSOR3 3
+
+/* ADC code range */
+#define ADC_MAX                        977
+#define ADC_MIN                        162
+#define ADC_VAL0C              887
+#define ADC_VAL20C             720
+#define ADC_VAL40C             508
+#define ADC_VAL60C             315
+
+/* ADC base addresses */
+#define ADC_CHNL_START_ADDR    0x1C5   /* increments by 1 */
+#define ADC_DATA_START_ADDR     0x1D4   /* increments by 2 */
+
+/* MSIC die attributes */
+#define MSIC_DIE_ADC_MIN       488
+#define MSIC_DIE_ADC_MAX       1004
+
+/* This holds the address of the first free ADC channel,
+ * among the 15 channels
+ */
+static int channel_index;
+
+struct platform_info {
+       struct platform_device *pdev;
+       struct thermal_zone_device *tzd[MSIC_THERMAL_SENSORS];
+};
+
+struct thermal_device_info {
+       unsigned int chnl_addr;
+       int direct;
+       /* This holds the current temperature in millidegree celsius */
+       long curr_temp;
+};
+
+/**
+ * to_msic_die_temp - converts adc_val to msic_die temperature
+ * @adc_val: ADC value to be converted
+ *
+ * Can sleep
+ */
+static int to_msic_die_temp(uint16_t adc_val)
+{
+       return (368 * (adc_val) / 1000) - 220;
+}
+
+/**
+ * is_valid_adc - checks whether the adc code is within the defined range
+ * @min: minimum value for the sensor
+ * @max: maximum value for the sensor
+ *
+ * Can sleep
+ */
+static int is_valid_adc(uint16_t adc_val, uint16_t min, uint16_t max)
+{
+       return (adc_val >= min) && (adc_val <= max);
+}
+
+/**
+ * adc_to_temp - converts the ADC code to temperature in C
+ * @direct: true if ths channel is direct index
+ * @adc_val: the adc_val that needs to be converted
+ * @tp: temperature return value
+ *
+ * Linear approximation is used to covert the skin adc value into temperature.
+ * This technique is used to avoid very long look-up table to get
+ * the appropriate temp value from ADC value.
+ * The adc code vs sensor temp curve is split into five parts
+ * to achieve very close approximate temp value with less than
+ * 0.5C error
+ */
+static int adc_to_temp(int direct, uint16_t adc_val, unsigned long *tp)
+{
+       int temp;
+
+       /* Direct conversion for die temperature */
+       if (direct) {
+               if (is_valid_adc(adc_val, MSIC_DIE_ADC_MIN, MSIC_DIE_ADC_MAX)) {
+                       *tp = to_msic_die_temp(adc_val) * 1000;
+                       return 0;
+               }
+               return -ERANGE;
+       }
+
+       if (!is_valid_adc(adc_val, ADC_MIN, ADC_MAX))
+               return -ERANGE;
+
+       /* Linear approximation for skin temperature */
+       if (adc_val > ADC_VAL0C)
+               temp = 177 - (adc_val/5);
+       else if ((adc_val <= ADC_VAL0C) && (adc_val > ADC_VAL20C))
+               temp = 111 - (adc_val/8);
+       else if ((adc_val <= ADC_VAL20C) && (adc_val > ADC_VAL40C))
+               temp = 92 - (adc_val/10);
+       else if ((adc_val <= ADC_VAL40C) && (adc_val > ADC_VAL60C))
+               temp = 91 - (adc_val/10);
+       else
+               temp = 112 - (adc_val/6);
+
+       /* Convert temperature in celsius to milli degree celsius */
+       *tp = temp * 1000;
+       return 0;
+}
+
+/**
+ * mid_read_temp - read sensors for temperature
+ * @temp: holds the current temperature for the sensor after reading
+ *
+ * reads the adc_code from the channel and converts it to real
+ * temperature. The converted value is stored in temp.
+ *
+ * Can sleep
+ */
+static int mid_read_temp(struct thermal_zone_device *tzd, unsigned long *temp)
+{
+       struct thermal_device_info *td_info = tzd->devdata;
+       uint16_t adc_val, addr;
+       uint8_t data = 0;
+       int ret;
+       unsigned long curr_temp;
+
+
+       addr = td_info->chnl_addr;
+
+       /* Enable the msic for conversion before reading */
+       ret = intel_scu_ipc_iowrite8(MSIC_THERM_ADC1CNTL3, MSIC_ADCRRDATA_ENBL);
+       if (ret)
+               return ret;
+
+       /* Re-toggle the RRDATARD bit (temporary workaround) */
+       ret = intel_scu_ipc_iowrite8(MSIC_THERM_ADC1CNTL3, MSIC_ADCTHERM_ENBL);
+       if (ret)
+               return ret;
+
+       /* Read the higher bits of data */
+       ret = intel_scu_ipc_ioread8(addr, &data);
+       if (ret)
+               return ret;
+
+       /* Shift bits to accomodate the lower two data bits */
+       adc_val = (data << 2);
+       addr++;
+
+       ret = intel_scu_ipc_ioread8(addr, &data);/* Read lower bits */
+       if (ret)
+               return ret;
+
+       /* Adding lower two bits to the higher bits */
+       data &= 03;
+       adc_val += data;
+
+       /* Convert ADC value to temperature */
+       ret = adc_to_temp(td_info->direct, adc_val, &curr_temp);
+       if (ret == 0)
+               *temp = td_info->curr_temp = curr_temp;
+       return ret;
+}
+
+/**
+ * configure_adc - enables/disables the ADC for conversion
+ * @val: zero: disables the ADC non-zero:enables the ADC
+ *
+ * Enable/Disable the ADC depending on the argument
+ *
+ * Can sleep
+ */
+static int configure_adc(int val)
+{
+       int ret;
+       uint8_t data;
+
+       ret = intel_scu_ipc_ioread8(MSIC_THERM_ADC1CNTL1, &data);
+       if (ret)
+               return ret;
+
+       if (val) {
+               /* Enable and start the ADC */
+               data |= (MSIC_ADC_ENBL | MSIC_ADC_START);
+       } else {
+               /* Just stop the ADC */
+               data &= (~MSIC_ADC_START);
+       }
+
+       return intel_scu_ipc_iowrite8(MSIC_THERM_ADC1CNTL1, data);
+}
+
+/**
+ * set_up_therm_channel - enable thermal channel for conversion
+ * @base_addr: index of free msic ADC channel
+ *
+ * Enable all the three channels for conversion
+ *
+ * Can sleep
+ */
+static int set_up_therm_channel(u16 base_addr)
+{
+       int ret;
+
+       /* Enable all the sensor channels */
+       ret = intel_scu_ipc_iowrite8(base_addr, SKIN_SENSOR0_CODE);
+       if (ret)
+               return ret;
+
+       ret = intel_scu_ipc_iowrite8(base_addr + 1, SKIN_SENSOR1_CODE);
+       if (ret)
+               return ret;
+
+       ret = intel_scu_ipc_iowrite8(base_addr + 2, SYS_SENSOR_CODE);
+       if (ret)
+               return ret;
+
+       /* Since this is the last channel, set the stop bit
+          to 1 by ORing the DIE_SENSOR_CODE with 0x10 */
+       ret = intel_scu_ipc_iowrite8(base_addr + 3,
+                                       (MSIC_DIE_SENSOR_CODE | 0x10));
+       if (ret)
+               return ret;
+
+       /* Enable ADC and start it */
+       return configure_adc(1);
+}
+
+/**
+ * reset_stopbit - sets the stop bit to 0 on the given channel
+ * @addr: address of the channel
+ *
+ * Can sleep
+ */
+static int reset_stopbit(uint16_t addr)
+{
+       int ret;
+       uint8_t data;
+       ret = intel_scu_ipc_ioread8(addr, &data);
+       if (ret)
+               return ret;
+       /* Set the stop bit to zero */
+       return intel_scu_ipc_iowrite8(addr, (data & 0xEF));
+}
+
+/**
+ * find_free_channel - finds an empty channel for conversion
+ *
+ * If the ADC is not enabled then start using 0th channel
+ * itself. Otherwise find an empty channel by looking for a
+ * channel in which the stopbit is set to 1. returns the index
+ * of the first free channel if succeeds or an error code.
+ *
+ * Context: can sleep
+ *
+ * FIXME: Ultimately the channel allocator will move into the intel_scu_ipc
+ * code.
+ */
+static int find_free_channel(void)
+{
+       int ret;
+       int i;
+       uint8_t data;
+
+       /* check whether ADC is enabled */
+       ret = intel_scu_ipc_ioread8(MSIC_THERM_ADC1CNTL1, &data);
+       if (ret)
+               return ret;
+
+       if ((data & MSIC_ADC_ENBL) == 0)
+               return 0;
+
+       /* ADC is already enabled; Looking for an empty channel */
+       for (i = 0; i < ADC_CHANLS_MAX; i++) {
+               ret = intel_scu_ipc_ioread8(ADC_CHNL_START_ADDR + i, &data);
+               if (ret)
+                       return ret;
+
+               if (data & MSIC_STOPBIT_MASK) {
+                       ret = i;
+                       break;
+               }
+       }
+       return (ret > ADC_LOOP_MAX) ? (-EINVAL) : ret;
+}
+
+/**
+ * mid_initialize_adc - initializing the ADC
+ * @dev: our device structure
+ *
+ * Initialize the ADC for reading thermistor values. Can sleep.
+ */
+static int mid_initialize_adc(struct device *dev)
+{
+       u8  data;
+       u16 base_addr;
+       int ret;
+
+       /*
+        * Ensure that adctherm is disabled before we
+        * initialize the ADC
+        */
+       ret = intel_scu_ipc_ioread8(MSIC_THERM_ADC1CNTL3, &data);
+       if (ret)
+               return ret;
+
+       if (data & MSIC_ADCTHERM_MASK)
+               dev_warn(dev, "ADCTHERM already set");
+
+       /* Index of the first channel in which the stop bit is set */
+       channel_index = find_free_channel();
+       if (channel_index < 0) {
+               dev_err(dev, "No free ADC channels");
+               return channel_index;
+       }
+
+       base_addr = ADC_CHNL_START_ADDR + channel_index;
+
+       if (!(channel_index == 0 || channel_index == ADC_LOOP_MAX)) {
+               /* Reset stop bit for channels other than 0 and 12 */
+               ret = reset_stopbit(base_addr);
+               if (ret)
+                       return ret;
+
+               /* Index of the first free channel */
+               base_addr++;
+               channel_index++;
+       }
+
+       ret = set_up_therm_channel(base_addr);
+       if (ret) {
+               dev_err(dev, "unable to enable ADC");
+               return ret;
+       }
+       dev_dbg(dev, "ADC initialization successful");
+       return ret;
+}
+
+/**
+ * initialize_sensor - sets default temp and timer ranges
+ * @index: index of the sensor
+ *
+ * Context: can sleep
+ */
+static struct thermal_device_info *initialize_sensor(int index)
+{
+       struct thermal_device_info *td_info =
+               kzalloc(sizeof(struct thermal_device_info), GFP_KERNEL);
+
+       if (!td_info)
+               return NULL;
+
+       /* Set the base addr of the channel for this sensor */
+       td_info->chnl_addr = ADC_DATA_START_ADDR + 2 * (channel_index + index);
+       /* Sensor 3 is direct conversion */
+       if (index == 3)
+               td_info->direct = 1;
+       return td_info;
+}
+
+/**
+ * mid_thermal_resume - resume routine
+ * @pdev: platform device structure
+ *
+ * mid thermal resume: re-initializes the adc. Can sleep.
+ */
+static int mid_thermal_resume(struct platform_device *pdev)
+{
+       return mid_initialize_adc(&pdev->dev);
+}
+
+/**
+ * mid_thermal_suspend - suspend routine
+ * @pdev: platform device structure
+ *
+ * mid thermal suspend implements the suspend functionality
+ * by stopping the ADC. Can sleep.
+ */
+static int mid_thermal_suspend(struct platform_device *pdev, pm_message_t mesg)
+{
+       /*
+        * This just stops the ADC and does not disable it.
+        * temporary workaround until we have a generic ADC driver.
+        * If 0 is passed, it disables the ADC.
+        */
+       return configure_adc(0);
+}
+
+/**
+ * read_curr_temp - reads the current temperature and stores in temp
+ * @temp: holds the current temperature value after reading
+ *
+ * Can sleep
+ */
+static int read_curr_temp(struct thermal_zone_device *tzd, unsigned long *temp)
+{
+       WARN_ON(tzd == NULL);
+       return mid_read_temp(tzd, temp);
+}
+
+/* Can't be const */
+static struct thermal_zone_device_ops tzd_ops = {
+       .get_temp = read_curr_temp,
+};
+
+
+/**
+ * mid_thermal_probe - mfld thermal initialize
+ * @pdev: platform device structure
+ *
+ * mid thermal probe initializes the hardware and registers
+ * all the sensors with the generic thermal framework. Can sleep.
+ */
+static int mid_thermal_probe(struct platform_device *pdev)
+{
+       static char *name[MSIC_THERMAL_SENSORS] = {
+               "skin0", "skin1", "sys", "msicdie"
+       };
+
+       int ret;
+       int i;
+       struct platform_info *pinfo;
+
+       pinfo = kzalloc(sizeof(struct platform_info), GFP_KERNEL);
+       if (!pinfo)
+               return -ENOMEM;
+
+       /* Initializing the hardware */
+       ret = mid_initialize_adc(&pdev->dev);
+       if (ret) {
+               dev_err(&pdev->dev, "ADC init failed");
+               kfree(pinfo);
+               return ret;
+       }
+
+       /* Register each sensor with the generic thermal framework*/
+       for (i = 0; i < MSIC_THERMAL_SENSORS; i++) {
+               pinfo->tzd[i] = thermal_zone_device_register(name[i],
+                                       0, initialize_sensor(i),
+                                       &tzd_ops, 0, 0, 0, 0);
+               if (IS_ERR(pinfo->tzd[i]))
+                       goto reg_fail;
+       }
+
+       pinfo->pdev = pdev;
+       platform_set_drvdata(pdev, pinfo);
+       return 0;
+
+reg_fail:
+       ret = PTR_ERR(pinfo->tzd[i]);
+       while (--i >= 0)
+               thermal_zone_device_unregister(pinfo->tzd[i]);
+       configure_adc(0);
+       kfree(pinfo);
+       return ret;
+}
+
+/**
+ * mid_thermal_remove - mfld thermal finalize
+ * @dev: platform device structure
+ *
+ * MLFD thermal remove unregisters all the sensors from the generic
+ * thermal framework. Can sleep.
+ */
+static int mid_thermal_remove(struct platform_device *pdev)
+{
+       int i;
+       struct platform_info *pinfo = platform_get_drvdata(pdev);
+
+       for (i = 0; i < MSIC_THERMAL_SENSORS; i++)
+               thermal_zone_device_unregister(pinfo->tzd[i]);
+
+       platform_set_drvdata(pdev, NULL);
+
+       /* Stop the ADC */
+       return configure_adc(0);
+}
+
+/*********************************************************************
+ *             Driver initialisation and finalization
+ *********************************************************************/
+
+#define DRIVER_NAME "msic_sensor"
+
+static const struct platform_device_id therm_id_table[] = {
+       { DRIVER_NAME, 1 },
+       { }
+};
+
+static struct platform_driver mid_thermal_driver = {
+       .driver = {
+               .name = DRIVER_NAME,
+               .owner = THIS_MODULE,
+       },
+       .probe = mid_thermal_probe,
+       .suspend = mid_thermal_suspend,
+       .resume = mid_thermal_resume,
+       .remove = __devexit_p(mid_thermal_remove),
+       .id_table = therm_id_table,
+};
+
+static int __init mid_thermal_module_init(void)
+{
+       return platform_driver_register(&mid_thermal_driver);
+}
+
+static void __exit mid_thermal_module_exit(void)
+{
+       platform_driver_unregister(&mid_thermal_driver);
+}
+
+module_init(mid_thermal_module_init);
+module_exit(mid_thermal_module_exit);
+
+MODULE_AUTHOR("Durgadoss R <durgadoss.r@intel.com>");
+MODULE_DESCRIPTION("Intel Medfield Platform Thermal Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/platform/x86/intel_rar_register.c b/drivers/platform/x86/intel_rar_register.c
index 2b11a33325e6..bde47e9080cd 100644
--- a/drivers/platform/x86/intel_rar_register.c
+++ b/drivers/platform/x86/intel_rar_register.c
@@ -485,7 +485,7 @@ EXPORT_SYMBOL(rar_lock);
  *
  *      The register_rar function is to used by other device drivers
  *      to ensure that this driver is ready. As we cannot be sure of
- *      the compile/execute order of drivers in ther kernel, it is
+ *      the compile/execute order of drivers in the kernel, it is
  *      best to give this driver a callback function to call when
  *      it is ready to give out addresses. The callback function
  *      would have those steps that continue the initialization of
diff --git a/drivers/platform/x86/intel_scu_ipc.c b/drivers/platform/x86/intel_scu_ipc.c
index a91d510a798b..940accbe28d3 100644
--- a/drivers/platform/x86/intel_scu_ipc.c
+++ b/drivers/platform/x86/intel_scu_ipc.c
@@ -9,7 +9,7 @@
  * as published by the Free Software Foundation; version 2
  * of the License.
  *
- * SCU runing in ARC processor communicates with other entity running in IA
+ * SCU running in ARC processor communicates with other entity running in IA
  * core through IPC mechanism which in turn messaging between IA core ad SCU.
  * SCU has two IPC mechanism IPC-1 and IPC-2. IPC-1 is used between IA32 and
  * SCU where IPC-2 is used between P-Unit and SCU. This driver delas with
diff --git a/drivers/platform/x86/msi-laptop.c b/drivers/platform/x86/msi-laptop.c
index 142d38579314..23fb2afda00b 100644
--- a/drivers/platform/x86/msi-laptop.c
+++ b/drivers/platform/x86/msi-laptop.c
@@ -51,6 +51,8 @@
  * laptop as MSI S270. YMMV.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
@@ -60,6 +62,8 @@
 #include <linux/platform_device.h>
 #include <linux/rfkill.h>
 #include <linux/i8042.h>
+#include <linux/input.h>
+#include <linux/input/sparse-keymap.h>
 
 #define MSI_DRIVER_VERSION "0.5"
 
@@ -78,6 +82,9 @@
 #define MSI_STANDARD_EC_SCM_LOAD_ADDRESS        0x2d
 #define MSI_STANDARD_EC_SCM_LOAD_MASK           (1 << 0)
 
+#define MSI_STANDARD_EC_TOUCHPAD_ADDRESS        0xe4
+#define MSI_STANDARD_EC_TOUCHPAD_MASK           (1 << 4)
+
 static int msi_laptop_resume(struct platform_device *device);
 
 #define MSI_STANDARD_EC_DEVICES_EXISTS_ADDRESS  0x2f
@@ -90,6 +97,14 @@ static int auto_brightness;
 module_param(auto_brightness, int, 0);
 MODULE_PARM_DESC(auto_brightness, "Enable automatic brightness control (0: disabled; 1: enabled; 2: don't touch)");
 
+static const struct key_entry msi_laptop_keymap[] = {
+        {KE_KEY, KEY_TOUCHPAD_ON, {KEY_TOUCHPAD_ON} },  /* Touch Pad On */
+        {KE_KEY, KEY_TOUCHPAD_OFF, {KEY_TOUCHPAD_OFF} },/* Touch Pad On */
+        {KE_END, 0}
+};
+
+static struct input_dev *msi_laptop_input_dev;
+
 static bool old_ec_model;
 static int wlan_s, bluetooth_s, threeg_s;
 static int threeg_exists;
@@ -432,8 +447,7 @@ static struct platform_device *msipf_device;
 
 static int dmi_check_cb(const struct dmi_system_id *id)
 {
-        printk(KERN_INFO "msi-laptop: Identified laptop model '%s'.\n",
-               id->ident);
+        pr_info("Identified laptop model '%s'.\n", id->ident);
         return 1;
 }
 
@@ -605,6 +619,21 @@ static void msi_update_rfkill(struct work_struct *ignored)
 }
 static DECLARE_DELAYED_WORK(msi_rfkill_work, msi_update_rfkill);
 
+static void msi_send_touchpad_key(struct work_struct *ignored)
+{
+        u8 rdata;
+        int result;
+
+        result = ec_read(MSI_STANDARD_EC_TOUCHPAD_ADDRESS, &rdata);
+        if (result < 0)
+                return;
+
+        sparse_keymap_report_event(msi_laptop_input_dev,
+                (rdata & MSI_STANDARD_EC_TOUCHPAD_MASK) ?
+                KEY_TOUCHPAD_ON : KEY_TOUCHPAD_OFF, 1, true);
+}
+static DECLARE_DELAYED_WORK(msi_touchpad_work, msi_send_touchpad_key);
+
 static bool msi_laptop_i8042_filter(unsigned char data, unsigned char str,
                                 struct serio *port)
 {
@@ -613,12 +642,17 @@ static bool msi_laptop_i8042_filter(unsigned char data, unsigned char str,
         if (str & 0x20)
                 return false;
 
-        /* 0x54 wwan, 0x62 bluetooth, 0x76 wlan*/
+        /* 0x54 wwan, 0x62 bluetooth, 0x76 wlan, 0xE4 touchpad toggle*/
         if (unlikely(data == 0xe0)) {
                 extended = true;
                 return false;
         } else if (unlikely(extended)) {
+                extended = false;
                 switch (data) {
+                case 0xE4:
+                        schedule_delayed_work(&msi_touchpad_work,
+                                round_jiffies_relative(0.5 * HZ));
+                        break;
                 case 0x54:
                 case 0x62:
                 case 0x76:
@@ -626,7 +660,6 @@ static bool msi_laptop_i8042_filter(unsigned char data, unsigned char str,
                                 round_jiffies_relative(0.5 * HZ));
                         break;
                 }
-                extended = false;
         }
 
         return false;
@@ -731,6 +764,42 @@ static int msi_laptop_resume(struct platform_device *device)
         return 0;
 }
 
+static int __init msi_laptop_input_setup(void)
+{
+        int err;
+
+        msi_laptop_input_dev = input_allocate_device();
+        if (!msi_laptop_input_dev)
+                return -ENOMEM;
+
+        msi_laptop_input_dev->name = "MSI Laptop hotkeys";
+        msi_laptop_input_dev->phys = "msi-laptop/input0";
+        msi_laptop_input_dev->id.bustype = BUS_HOST;
+
+        err = sparse_keymap_setup(msi_laptop_input_dev,
+                msi_laptop_keymap, NULL);
+        if (err)
+                goto err_free_dev;
+
+        err = input_register_device(msi_laptop_input_dev);
+        if (err)
+                goto err_free_keymap;
+
+        return 0;
+
+err_free_keymap:
+        sparse_keymap_free(msi_laptop_input_dev);
+err_free_dev:
+        input_free_device(msi_laptop_input_dev);
+        return err;
+}
+
+static void msi_laptop_input_destroy(void)
+{
+        sparse_keymap_free(msi_laptop_input_dev);
+        input_unregister_device(msi_laptop_input_dev);
+}
+
 static int load_scm_model_init(struct platform_device *sdev)
 {
         u8 data;
@@ -759,16 +828,23 @@ static int load_scm_model_init(struct platform_device *sdev)
         if (result < 0)
                 goto fail_rfkill;
 
+        /* setup input device */
+        result = msi_laptop_input_setup();
+        if (result)
+                goto fail_input;
+
         result = i8042_install_filter(msi_laptop_i8042_filter);
         if (result) {
-                printk(KERN_ERR
-                        "msi-laptop: Unable to install key filter\n");
+                pr_err("Unable to install key filter\n");
                 goto fail_filter;
         }
 
         return 0;
 
 fail_filter:
+        msi_laptop_input_destroy();
+
+fail_input:
         rfkill_cleanup();
 
 fail_rfkill:
@@ -799,7 +875,7 @@ static int __init msi_init(void)
         /* Register backlight stuff */
 
         if (acpi_video_backlight_support()) {
-                printk(KERN_INFO "MSI: Brightness ignored, must be controlled "
+                pr_info("Brightness ignored, must be controlled "
                        "by ACPI video driver\n");
         } else {
                 struct backlight_properties props;
@@ -854,7 +930,7 @@ static int __init msi_init(void)
         if (auto_brightness != 2)
                 set_auto_brightness(auto_brightness);
 
-        printk(KERN_INFO "msi-laptop: driver "MSI_DRIVER_VERSION" successfully loaded.\n");
+        pr_info("driver "MSI_DRIVER_VERSION" successfully loaded.\n");
 
         return 0;
 
@@ -886,6 +962,7 @@ static void __exit msi_cleanup(void)
 {
         if (load_scm_model) {
                 i8042_remove_filter(msi_laptop_i8042_filter);
+                msi_laptop_input_destroy();
                 cancel_delayed_work_sync(&msi_rfkill_work);
                 rfkill_cleanup();
         }
@@ -901,7 +978,7 @@ static void __exit msi_cleanup(void)
         if (auto_brightness != 2)
                 set_auto_brightness(1);
 
-        printk(KERN_INFO "msi-laptop: driver unloaded.\n");
+        pr_info("driver unloaded.\n");
 }
 
 module_init(msi_init);
diff --git a/drivers/platform/x86/samsung-laptop.c b/drivers/platform/x86/samsung-laptop.c
new file mode 100644
index 000000000000..de434c6dc2d6
--- /dev/null
+++ b/drivers/platform/x86/samsung-laptop.c
@@ -0,0 +1,832 @@
+/*
+ * Samsung Laptop driver
+ *
+ * Copyright (C) 2009,2011 Greg Kroah-Hartman (gregkh@suse.de)
+ * Copyright (C) 2009,2011 Novell Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ *
+ */
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/delay.h>
+#include <linux/pci.h>
+#include <linux/backlight.h>
+#include <linux/fb.h>
+#include <linux/dmi.h>
+#include <linux/platform_device.h>
+#include <linux/rfkill.h>
+
+/*
+ * This driver is needed because a number of Samsung laptops do not hook
+ * their control settings through ACPI.  So we have to poke around in the
+ * BIOS to do things like brightness values, and "special" key controls.
+ */
+
+/*
+ * We have 0 - 8 as valid brightness levels.  The specs say that level 0 should
+ * be reserved by the BIOS (which really doesn't make much sense), we tell
+ * userspace that the value is 0 - 7 and then just tell the hardware 1 - 8
+ */
+#define MAX_BRIGHT      0x07
+
+
+#define SABI_IFACE_MAIN                 0x00
+#define SABI_IFACE_SUB                  0x02
+#define SABI_IFACE_COMPLETE             0x04
+#define SABI_IFACE_DATA                 0x05
+
+/* Structure to get data back to the calling function */
+struct sabi_retval {
+        u8 retval[20];
+};
+
+struct sabi_header_offsets {
+        u8 port;
+        u8 re_mem;
+        u8 iface_func;
+        u8 en_mem;
+        u8 data_offset;
+        u8 data_segment;
+};
+
+struct sabi_commands {
+        /*
+         * Brightness is 0 - 8, as described above.
+         * Value 0 is for the BIOS to use
+         */
+        u8 get_brightness;
+        u8 set_brightness;
+
+        /*
+         * first byte:
+         * 0x00 - wireless is off
+         * 0x01 - wireless is on
+         * second byte:
+         * 0x02 - 3G is off
+         * 0x03 - 3G is on
+         * TODO, verify 3G is correct, that doesn't seem right...
+         */
+        u8 get_wireless_button;
+        u8 set_wireless_button;
+
+        /* 0 is off, 1 is on */
+        u8 get_backlight;
+        u8 set_backlight;
+
+        /*
+         * 0x80 or 0x00 - no action
+         * 0x81 - recovery key pressed
+         */
+        u8 get_recovery_mode;
+        u8 set_recovery_mode;
+
+        /*
+         * on seclinux: 0 is low, 1 is high,
+         * on swsmi: 0 is normal, 1 is silent, 2 is turbo
+         */
+        u8 get_performance_level;
+        u8 set_performance_level;
+
+        /*
+         * Tell the BIOS that Linux is running on this machine.
+         * 81 is on, 80 is off
+         */
+        u8 set_linux;
+};
+
+struct sabi_performance_level {
+        const char *name;
+        u8 value;
+};
+
+struct sabi_config {
+        const char *test_string;
+        u16 main_function;
+        const struct sabi_header_offsets header_offsets;
+        const struct sabi_commands commands;
+        const struct sabi_performance_level performance_levels[4];
+        u8 min_brightness;
+        u8 max_brightness;
+};
+
+static const struct sabi_config sabi_configs[] = {
+        {
+                .test_string = "SECLINUX",
+
+                .main_function = 0x4c49,
+
+                .header_offsets = {
+                        .port = 0x00,
+                        .re_mem = 0x02,
+                        .iface_func = 0x03,
+                        .en_mem = 0x04,
+                        .data_offset = 0x05,
+                        .data_segment = 0x07,
+                },
+
+                .commands = {
+                        .get_brightness = 0x00,
+                        .set_brightness = 0x01,
+
+                        .get_wireless_button = 0x02,
+                        .set_wireless_button = 0x03,
+
+                        .get_backlight = 0x04,
+                        .set_backlight = 0x05,
+
+                        .get_recovery_mode = 0x06,
+                        .set_recovery_mode = 0x07,
+
+                        .get_performance_level = 0x08,
+                        .set_performance_level = 0x09,
+
+                        .set_linux = 0x0a,
+                },
+
+                .performance_levels = {
+                        {
+                                .name = "silent",
+                                .value = 0,
+                        },
+                        {
+                                .name = "normal",
+                                .value = 1,
+                        },
+                        { },
+                },
+                .min_brightness = 1,
+                .max_brightness = 8,
+        },
+        {
+                .test_string = "SwSmi@",
+
+                .main_function = 0x5843,
+
+                .header_offsets = {
+                        .port = 0x00,
+                        .re_mem = 0x04,
+                        .iface_func = 0x02,
+                        .en_mem = 0x03,
+                        .data_offset = 0x05,
+                        .data_segment = 0x07,
+                },
+
+                .commands = {
+                        .get_brightness = 0x10,
+                        .set_brightness = 0x11,
+
+                        .get_wireless_button = 0x12,
+                        .set_wireless_button = 0x13,
+
+                        .get_backlight = 0x2d,
+                        .set_backlight = 0x2e,
+
+                        .get_recovery_mode = 0xff,
+                        .set_recovery_mode = 0xff,
+
+                        .get_performance_level = 0x31,
+                        .set_performance_level = 0x32,
+
+                        .set_linux = 0xff,
+                },
+
+                .performance_levels = {
+                        {
+                                .name = "normal",
+                                .value = 0,
+                        },
+                        {
+                                .name = "silent",
+                                .value = 1,
+                        },
+                        {
+                                .name = "overclock",
+                                .value = 2,
+                        },
+                        { },
+                },
+                .min_brightness = 0,
+                .max_brightness = 8,
+        },
+        { },
+};
+
+static const struct sabi_config *sabi_config;
+
+static void __iomem *sabi;
+static void __iomem *sabi_iface;
+static void __iomem *f0000_segment;
+static struct backlight_device *backlight_device;
+static struct mutex sabi_mutex;
+static struct platform_device *sdev;
+static struct rfkill *rfk;
+
+static int force;
+module_param(force, bool, 0);
+MODULE_PARM_DESC(force,
+                "Disable the DMI check and forces the driver to be loaded");
+
+static int debug;
+module_param(debug, bool, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(debug, "Debug enabled or not");
+
+static int sabi_get_command(u8 command, struct sabi_retval *sretval)
+{
+        int retval = 0;
+        u16 port = readw(sabi + sabi_config->header_offsets.port);
+        u8 complete, iface_data;
+
+        mutex_lock(&sabi_mutex);
+
+        /* enable memory to be able to write to it */
+        outb(readb(sabi + sabi_config->header_offsets.en_mem), port);
+
+        /* write out the command */
+        writew(sabi_config->main_function, sabi_iface + SABI_IFACE_MAIN);
+        writew(command, sabi_iface + SABI_IFACE_SUB);
+        writeb(0, sabi_iface + SABI_IFACE_COMPLETE);
+        outb(readb(sabi + sabi_config->header_offsets.iface_func), port);
+
+        /* write protect memory to make it safe */
+        outb(readb(sabi + sabi_config->header_offsets.re_mem), port);
+
+        /* see if the command actually succeeded */
+        complete = readb(sabi_iface + SABI_IFACE_COMPLETE);
+        iface_data = readb(sabi_iface + SABI_IFACE_DATA);
+        if (complete != 0xaa || iface_data == 0xff) {
+                pr_warn("SABI get command 0x%02x failed with completion flag 0x%02x and data 0x%02x\n",
+                        command, complete, iface_data);
+                retval = -EINVAL;
+                goto exit;
+        }
+        /*
+         * Save off the data into a structure so the caller use it.
+         * Right now we only want the first 4 bytes,
+         * There are commands that need more, but not for the ones we
+         * currently care about.
+         */
+        sretval->retval[0] = readb(sabi_iface + SABI_IFACE_DATA);
+        sretval->retval[1] = readb(sabi_iface + SABI_IFACE_DATA + 1);
+        sretval->retval[2] = readb(sabi_iface + SABI_IFACE_DATA + 2);
+        sretval->retval[3] = readb(sabi_iface + SABI_IFACE_DATA + 3);
+
+exit:
+        mutex_unlock(&sabi_mutex);
+        return retval;
+
+}
+
+static int sabi_set_command(u8 command, u8 data)
+{
+        int retval = 0;
+        u16 port = readw(sabi + sabi_config->header_offsets.port);
+        u8 complete, iface_data;
+
+        mutex_lock(&sabi_mutex);
+
+        /* enable memory to be able to write to it */
+        outb(readb(sabi + sabi_config->header_offsets.en_mem), port);
+
+        /* write out the command */
+        writew(sabi_config->main_function, sabi_iface + SABI_IFACE_MAIN);
+        writew(command, sabi_iface + SABI_IFACE_SUB);
+        writeb(0, sabi_iface + SABI_IFACE_COMPLETE);
+        writeb(data, sabi_iface + SABI_IFACE_DATA);
+        outb(readb(sabi + sabi_config->header_offsets.iface_func), port);
+
+        /* write protect memory to make it safe */
+        outb(readb(sabi + sabi_config->header_offsets.re_mem), port);
+
+        /* see if the command actually succeeded */
+        complete = readb(sabi_iface + SABI_IFACE_COMPLETE);
+        iface_data = readb(sabi_iface + SABI_IFACE_DATA);
+        if (complete != 0xaa || iface_data == 0xff) {
+                pr_warn("SABI set command 0x%02x failed with completion flag 0x%02x and data 0x%02x\n",
+                       command, complete, iface_data);
+                retval = -EINVAL;
+        }
+
+        mutex_unlock(&sabi_mutex);
+        return retval;
+}
+
+static void test_backlight(void)
+{
+        struct sabi_retval sretval;
+
+        sabi_get_command(sabi_config->commands.get_backlight, &sretval);
+        printk(KERN_DEBUG "backlight = 0x%02x\n", sretval.retval[0]);
+
+        sabi_set_command(sabi_config->commands.set_backlight, 0);
+        printk(KERN_DEBUG "backlight should be off\n");
+
+        sabi_get_command(sabi_config->commands.get_backlight, &sretval);
+        printk(KERN_DEBUG "backlight = 0x%02x\n", sretval.retval[0]);
+
+        msleep(1000);
+
+        sabi_set_command(sabi_config->commands.set_backlight, 1);
+        printk(KERN_DEBUG "backlight should be on\n");
+
+        sabi_get_command(sabi_config->commands.get_backlight, &sretval);
+        printk(KERN_DEBUG "backlight = 0x%02x\n", sretval.retval[0]);
+}
+
+static void test_wireless(void)
+{
+        struct sabi_retval sretval;
+
+        sabi_get_command(sabi_config->commands.get_wireless_button, &sretval);
+        printk(KERN_DEBUG "wireless led = 0x%02x\n", sretval.retval[0]);
+
+        sabi_set_command(sabi_config->commands.set_wireless_button, 0);
+        printk(KERN_DEBUG "wireless led should be off\n");
+
+        sabi_get_command(sabi_config->commands.get_wireless_button, &sretval);
+        printk(KERN_DEBUG "wireless led = 0x%02x\n", sretval.retval[0]);
+
+        msleep(1000);
+
+        sabi_set_command(sabi_config->commands.set_wireless_button, 1);
+        printk(KERN_DEBUG "wireless led should be on\n");
+
+        sabi_get_command(sabi_config->commands.get_wireless_button, &sretval);
+        printk(KERN_DEBUG "wireless led = 0x%02x\n", sretval.retval[0]);
+}
+
+static u8 read_brightness(void)
+{
+        struct sabi_retval sretval;
+        int user_brightness = 0;
+        int retval;
+
+        retval = sabi_get_command(sabi_config->commands.get_brightness,
+                                  &sretval);
+        if (!retval) {
+                user_brightness = sretval.retval[0];
+                if (user_brightness != 0)
+                        user_brightness -= sabi_config->min_brightness;
+        }
+        return user_brightness;
+}
+
+static void set_brightness(u8 user_brightness)
+{
+        u8 user_level = user_brightness - sabi_config->min_brightness;
+
+        sabi_set_command(sabi_config->commands.set_brightness, user_level);
+}
+
+static int get_brightness(struct backlight_device *bd)
+{
+        return (int)read_brightness();
+}
+
+static int update_status(struct backlight_device *bd)
+{
+        set_brightness(bd->props.brightness);
+
+        if (bd->props.power == FB_BLANK_UNBLANK)
+                sabi_set_command(sabi_config->commands.set_backlight, 1);
+        else
+                sabi_set_command(sabi_config->commands.set_backlight, 0);
+        return 0;
+}
+
+static const struct backlight_ops backlight_ops = {
+        .get_brightness = get_brightness,
+        .update_status  = update_status,
+};
+
+static int rfkill_set(void *data, bool blocked)
+{
+        /* Do something with blocked...*/
+        /*
+         * blocked == false is on
+         * blocked == true is off
+         */
+        if (blocked)
+                sabi_set_command(sabi_config->commands.set_wireless_button, 0);
+        else
+                sabi_set_command(sabi_config->commands.set_wireless_button, 1);
+
+        return 0;
+}
+
+static struct rfkill_ops rfkill_ops = {
+        .set_block = rfkill_set,
+};
+
+static int init_wireless(struct platform_device *sdev)
+{
+        int retval;
+
+        rfk = rfkill_alloc("samsung-wifi", &sdev->dev, RFKILL_TYPE_WLAN,
+                           &rfkill_ops, NULL);
+        if (!rfk)
+                return -ENOMEM;
+
+        retval = rfkill_register(rfk);
+        if (retval) {
+                rfkill_destroy(rfk);
+                return -ENODEV;
+        }
+
+        return 0;
+}
+
+static void destroy_wireless(void)
+{
+        rfkill_unregister(rfk);
+        rfkill_destroy(rfk);
+}
+
+static ssize_t get_performance_level(struct device *dev,
+                                     struct device_attribute *attr, char *buf)
+{
+        struct sabi_retval sretval;
+        int retval;
+        int i;
+
+        /* Read the state */
+        retval = sabi_get_command(sabi_config->commands.get_performance_level,
+                                  &sretval);
+        if (retval)
+                return retval;
+
+        /* The logic is backwards, yeah, lots of fun... */
+        for (i = 0; sabi_config->performance_levels[i].name; ++i) {
+                if (sretval.retval[0] == sabi_config->performance_levels[i].value)
+                        return sprintf(buf, "%s\n", sabi_config->performance_levels[i].name);
+        }
+        return sprintf(buf, "%s\n", "unknown");
+}
+
+static ssize_t set_performance_level(struct device *dev,
+                                struct device_attribute *attr, const char *buf,
+                                size_t count)
+{
+        if (count >= 1) {
+                int i;
+                for (i = 0; sabi_config->performance_levels[i].name; ++i) {
+                        const struct sabi_performance_level *level =
+                                &sabi_config->performance_levels[i];
+                        if (!strncasecmp(level->name, buf, strlen(level->name))) {
+                                sabi_set_command(sabi_config->commands.set_performance_level,
+                                                 level->value);
+                                break;
+                        }
+                }
+                if (!sabi_config->performance_levels[i].name)
+                        return -EINVAL;
+        }
+        return count;
+}
+static DEVICE_ATTR(performance_level, S_IWUSR | S_IRUGO,
+                   get_performance_level, set_performance_level);
+
+
+static int __init dmi_check_cb(const struct dmi_system_id *id)
+{
+        pr_info("found laptop model '%s'\n",
+                id->ident);
+        return 1;
+}
+
+static struct dmi_system_id __initdata samsung_dmi_table[] = {
+        {
+                .ident = "N128",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                        "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "N128"),
+                        DMI_MATCH(DMI_BOARD_NAME, "N128"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
+                .ident = "N130",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                        "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "N130"),
+                        DMI_MATCH(DMI_BOARD_NAME, "N130"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
+                .ident = "X125",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                        "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "X125"),
+                        DMI_MATCH(DMI_BOARD_NAME, "X125"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
+                .ident = "X120/X170",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                        "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "X120/X170"),
+                        DMI_MATCH(DMI_BOARD_NAME, "X120/X170"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
+                .ident = "NC10",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                        "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "NC10"),
+                        DMI_MATCH(DMI_BOARD_NAME, "NC10"),
+                },
+                .callback = dmi_check_cb,
+        },
+                {
+                .ident = "NP-Q45",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                        "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "SQ45S70S"),
+                        DMI_MATCH(DMI_BOARD_NAME, "SQ45S70S"),
+                },
+                .callback = dmi_check_cb,
+                },
+        {
+                .ident = "X360",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                        "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "X360"),
+                        DMI_MATCH(DMI_BOARD_NAME, "X360"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
+                .ident = "R518",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                        "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "R518"),
+                        DMI_MATCH(DMI_BOARD_NAME, "R518"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
+                .ident = "R519/R719",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                        "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "R519/R719"),
+                        DMI_MATCH(DMI_BOARD_NAME, "R519/R719"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
+                .ident = "N150/N210/N220",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                        "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "N150/N210/N220"),
+                        DMI_MATCH(DMI_BOARD_NAME, "N150/N210/N220"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
+                .ident = "N150P/N210P/N220P",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                        "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "N150P/N210P/N220P"),
+                        DMI_MATCH(DMI_BOARD_NAME, "N150P/N210P/N220P"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
+                .ident = "R530/R730",
+                .matches = {
+                      DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
+                      DMI_MATCH(DMI_PRODUCT_NAME, "R530/R730"),
+                      DMI_MATCH(DMI_BOARD_NAME, "R530/R730"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
+                .ident = "NF110/NF210/NF310",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "NF110/NF210/NF310"),
+                        DMI_MATCH(DMI_BOARD_NAME, "NF110/NF210/NF310"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
+                .ident = "N145P/N250P/N260P",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "N145P/N250P/N260P"),
+                        DMI_MATCH(DMI_BOARD_NAME, "N145P/N250P/N260P"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
+                .ident = "R70/R71",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                        "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "R70/R71"),
+                        DMI_MATCH(DMI_BOARD_NAME, "R70/R71"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
+                .ident = "P460",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "P460"),
+                        DMI_MATCH(DMI_BOARD_NAME, "P460"),
+                },
+                .callback = dmi_check_cb,
+        },
+        { },
+};
+MODULE_DEVICE_TABLE(dmi, samsung_dmi_table);
+
+static int find_signature(void __iomem *memcheck, const char *testStr)
+{
+        int i = 0;
+        int loca;
+
+        for (loca = 0; loca < 0xffff; loca++) {
+                char temp = readb(memcheck + loca);
+
+                if (temp == testStr[i]) {
+                        if (i == strlen(testStr)-1)
+                                break;
+                        ++i;
+                } else {
+                        i = 0;
+                }
+        }
+        return loca;
+}
+
+static int __init samsung_init(void)
+{
+        struct backlight_properties props;
+        struct sabi_retval sretval;
+        unsigned int ifaceP;
+        int i;
+        int loca;
+        int retval;
+
+        mutex_init(&sabi_mutex);
+
+        if (!force && !dmi_check_system(samsung_dmi_table))
+                return -ENODEV;
+
+        f0000_segment = ioremap_nocache(0xf0000, 0xffff);
+        if (!f0000_segment) {
+                pr_err("Can't map the segment at 0xf0000\n");
+                return -EINVAL;
+        }
+
+        /* Try to find one of the signatures in memory to find the header */
+        for (i = 0; sabi_configs[i].test_string != 0; ++i) {
+                sabi_config = &sabi_configs[i];
+                loca = find_signature(f0000_segment, sabi_config->test_string);
+                if (loca != 0xffff)
+                        break;
+        }
+
+        if (loca == 0xffff) {
+                pr_err("This computer does not support SABI\n");
+                goto error_no_signature;
+        }
+
+        /* point to the SMI port Number */
+        loca += 1;
+        sabi = (f0000_segment + loca);
+
+        if (debug) {
+                printk(KERN_DEBUG "This computer supports SABI==%x\n",
+                        loca + 0xf0000 - 6);
+                printk(KERN_DEBUG "SABI header:\n");
+                printk(KERN_DEBUG " SMI Port Number = 0x%04x\n",
+                        readw(sabi + sabi_config->header_offsets.port));
+                printk(KERN_DEBUG " SMI Interface Function = 0x%02x\n",
+                        readb(sabi + sabi_config->header_offsets.iface_func));
+                printk(KERN_DEBUG " SMI enable memory buffer = 0x%02x\n",
+                        readb(sabi + sabi_config->header_offsets.en_mem));
+                printk(KERN_DEBUG " SMI restore memory buffer = 0x%02x\n",
+                        readb(sabi + sabi_config->header_offsets.re_mem));
+                printk(KERN_DEBUG " SABI data offset = 0x%04x\n",
+                        readw(sabi + sabi_config->header_offsets.data_offset));
+                printk(KERN_DEBUG " SABI data segment = 0x%04x\n",
+                        readw(sabi + sabi_config->header_offsets.data_segment));
+        }
+
+        /* Get a pointer to the SABI Interface */
+        ifaceP = (readw(sabi + sabi_config->header_offsets.data_segment) & 0x0ffff) << 4;
+        ifaceP += readw(sabi + sabi_config->header_offsets.data_offset) & 0x0ffff;
+        sabi_iface = ioremap_nocache(ifaceP, 16);
+        if (!sabi_iface) {
+                pr_err("Can't remap %x\n", ifaceP);
+                goto exit;
+        }
+        if (debug) {
+                printk(KERN_DEBUG "ifaceP = 0x%08x\n", ifaceP);
+                printk(KERN_DEBUG "sabi_iface = %p\n", sabi_iface);
+
+                test_backlight();
+                test_wireless();
+
+                retval = sabi_get_command(sabi_config->commands.get_brightness,
+                                          &sretval);
+                printk(KERN_DEBUG "brightness = 0x%02x\n", sretval.retval[0]);
+        }
+
+        /* Turn on "Linux" mode in the BIOS */
+        if (sabi_config->commands.set_linux != 0xff) {
+                retval = sabi_set_command(sabi_config->commands.set_linux,
+                                          0x81);
+                if (retval) {
+                        pr_warn("Linux mode was not set!\n");
+                        goto error_no_platform;
+                }
+        }
+
+        /* knock up a platform device to hang stuff off of */
+        sdev = platform_device_register_simple("samsung", -1, NULL, 0);
+        if (IS_ERR(sdev))
+                goto error_no_platform;
+
+        /* create a backlight device to talk to this one */
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.max_brightness = sabi_config->max_brightness;
+        backlight_device = backlight_device_register("samsung", &sdev->dev,
+                                                     NULL, &backlight_ops,
+                                                     &props);
+        if (IS_ERR(backlight_device))
+                goto error_no_backlight;
+
+        backlight_device->props.brightness = read_brightness();
+        backlight_device->props.power = FB_BLANK_UNBLANK;
+        backlight_update_status(backlight_device);
+
+        retval = init_wireless(sdev);
+        if (retval)
+                goto error_no_rfk;
+
+        retval = device_create_file(&sdev->dev, &dev_attr_performance_level);
+        if (retval)
+                goto error_file_create;
+
+exit:
+        return 0;
+
+error_file_create:
+        destroy_wireless();
+
+error_no_rfk:
+        backlight_device_unregister(backlight_device);
+
+error_no_backlight:
+        platform_device_unregister(sdev);
+
+error_no_platform:
+        iounmap(sabi_iface);
+
+error_no_signature:
+        iounmap(f0000_segment);
+        return -EINVAL;
+}
+
+static void __exit samsung_exit(void)
+{
+        /* Turn off "Linux" mode in the BIOS */
+        if (sabi_config->commands.set_linux != 0xff)
+                sabi_set_command(sabi_config->commands.set_linux, 0x80);
+
+        device_remove_file(&sdev->dev, &dev_attr_performance_level);
+        backlight_device_unregister(backlight_device);
+        destroy_wireless();
+        iounmap(sabi_iface);
+        iounmap(f0000_segment);
+        platform_device_unregister(sdev);
+}
+
+module_init(samsung_init);
+module_exit(samsung_exit);
+
+MODULE_AUTHOR("Greg Kroah-Hartman <gregkh@suse.de>");
+MODULE_DESCRIPTION("Samsung Backlight driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/platform/x86/sony-laptop.c b/drivers/platform/x86/sony-laptop.c
index 13d8d63bcca9..e642f5f29504 100644
--- a/drivers/platform/x86/sony-laptop.c
+++ b/drivers/platform/x86/sony-laptop.c
@@ -71,8 +71,9 @@
 #endif
 
 #define DRV_PFX                 "sony-laptop: "
-#define dprintk(msg...)         do {                    \
-        if (debug) printk(KERN_WARNING DRV_PFX  msg);   \
+#define dprintk(msg...)         do {    \
+        if (debug)                      \
+                pr_warn(DRV_PFX msg);   \
 } while (0)
 
 #define SONY_LAPTOP_DRIVER_VERSION      "0.6"
@@ -124,6 +125,19 @@ MODULE_PARM_DESC(minor,
                  "default is -1 (automatic)");
 #endif
 
+static int kbd_backlight;       /* = 1 */
+module_param(kbd_backlight, int, 0444);
+MODULE_PARM_DESC(kbd_backlight,
+                 "set this to 0 to disable keyboard backlight, "
+                 "1 to enable it (default: 0)");
+
+static int kbd_backlight_timeout;       /* = 0 */
+module_param(kbd_backlight_timeout, int, 0444);
+MODULE_PARM_DESC(kbd_backlight_timeout,
+                 "set this to 0 to set the default 10 seconds timeout, "
+                 "1 for 30 seconds, 2 for 60 seconds and 3 to disable timeout "
+                 "(default: 0)");
+
 enum sony_nc_rfkill {
         SONY_WIFI,
         SONY_BLUETOOTH,
@@ -402,7 +416,7 @@ static int sony_laptop_setup_input(struct acpi_device *acpi_device)
         error = kfifo_alloc(&sony_laptop_input.fifo,
                             SONY_LAPTOP_BUF_SIZE, GFP_KERNEL);
         if (error) {
-                printk(KERN_ERR DRV_PFX "kfifo_alloc failed\n");
+                pr_err(DRV_PFX "kfifo_alloc failed\n");
                 goto err_dec_users;
         }
 
@@ -591,7 +605,7 @@ struct sony_nc_value {
         int value;              /* current setting */
         int valid;              /* Has ever been set */
         int debug;              /* active only in debug mode ? */
-        struct device_attribute devattr;        /* sysfs atribute */
+        struct device_attribute devattr;        /* sysfs attribute */
 };
 
 #define SNC_HANDLE_NAMES(_name, _values...) \
@@ -686,7 +700,7 @@ static int acpi_callgetfunc(acpi_handle handle, char *name, int *result)
                 return 0;
         }
 
-        printk(KERN_WARNING DRV_PFX "acpi_callreadfunc failed\n");
+        pr_warn(DRV_PFX "acpi_callreadfunc failed\n");
 
         return -1;
 }
@@ -712,7 +726,7 @@ static int acpi_callsetfunc(acpi_handle handle, char *name, int value,
         if (status == AE_OK) {
                 if (result != NULL) {
                         if (out_obj.type != ACPI_TYPE_INTEGER) {
-                                printk(KERN_WARNING DRV_PFX "acpi_evaluate_object bad "
+                                pr_warn(DRV_PFX "acpi_evaluate_object bad "
                                        "return type\n");
                                 return -1;
                         }
@@ -721,34 +735,103 @@ static int acpi_callsetfunc(acpi_handle handle, char *name, int value,
                 return 0;
         }
 
-        printk(KERN_WARNING DRV_PFX "acpi_evaluate_object failed\n");
+        pr_warn(DRV_PFX "acpi_evaluate_object failed\n");
 
         return -1;
 }
 
-static int sony_find_snc_handle(int handle)
+struct sony_nc_handles {
+        u16 cap[0x10];
+        struct device_attribute devattr;
+};
+
+static struct sony_nc_handles *handles;
+
+static ssize_t sony_nc_handles_show(struct device *dev,
+                struct device_attribute *attr, char *buffer)
+{
+        ssize_t len = 0;
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(handles->cap); i++) {
+                len += snprintf(buffer + len, PAGE_SIZE - len, "0x%.4x ",
+                                handles->cap[i]);
+        }
+        len += snprintf(buffer + len, PAGE_SIZE - len, "\n");
+
+        return len;
+}
+
+static int sony_nc_handles_setup(struct platform_device *pd)
 {
         int i;
         int result;
 
-        for (i = 0x20; i < 0x30; i++) {
-                acpi_callsetfunc(sony_nc_acpi_handle, "SN00", i, &result);
-                if (result == handle)
-                        return i-0x20;
+        handles = kzalloc(sizeof(*handles), GFP_KERNEL);
+        if (!handles)
+                return -ENOMEM;
+
+        sysfs_attr_init(&handles->devattr.attr);
+        handles->devattr.attr.name = "handles";
+        handles->devattr.attr.mode = S_IRUGO;
+        handles->devattr.show = sony_nc_handles_show;
+
+        for (i = 0; i < ARRAY_SIZE(handles->cap); i++) {
+                if (!acpi_callsetfunc(sony_nc_acpi_handle,
+                                        "SN00", i + 0x20, &result)) {
+                        dprintk("caching handle 0x%.4x (offset: 0x%.2x)\n",
+                                        result, i);
+                        handles->cap[i] = result;
+                }
+        }
+
+        /* allow reading capabilities via sysfs */
+        if (device_create_file(&pd->dev, &handles->devattr)) {
+                kfree(handles);
+                handles = NULL;
+                return -1;
+        }
+
+        return 0;
+}
+
+static int sony_nc_handles_cleanup(struct platform_device *pd)
+{
+        if (handles) {
+                device_remove_file(&pd->dev, &handles->devattr);
+                kfree(handles);
+                handles = NULL;
         }
+        return 0;
+}
 
+static int sony_find_snc_handle(int handle)
+{
+        int i;
+        for (i = 0; i < 0x10; i++) {
+                if (handles->cap[i] == handle) {
+                        dprintk("found handle 0x%.4x (offset: 0x%.2x)\n",
+                                        handle, i);
+                        return i;
+                }
+        }
+        dprintk("handle 0x%.4x not found\n", handle);
         return -1;
 }
 
 static int sony_call_snc_handle(int handle, int argument, int *result)
 {
+        int ret = 0;
         int offset = sony_find_snc_handle(handle);
 
         if (offset < 0)
                 return -1;
 
-        return acpi_callsetfunc(sony_nc_acpi_handle, "SN07", offset | argument,
-                                result);
+        ret = acpi_callsetfunc(sony_nc_acpi_handle, "SN07", offset | argument,
+                        result);
+        dprintk("called SN07 with 0x%.4x (result: 0x%.4x)\n", offset | argument,
+                        *result);
+        return ret;
 }
 
 /*
@@ -857,11 +940,39 @@ static int sony_backlight_get_brightness(struct backlight_device *bd)
         return value - 1;
 }
 
-static struct backlight_device *sony_backlight_device;
+static int sony_nc_get_brightness_ng(struct backlight_device *bd)
+{
+        int result;
+        int *handle = (int *)bl_get_data(bd);
+
+        sony_call_snc_handle(*handle, 0x0200, &result);
+
+        return result & 0xff;
+}
+
+static int sony_nc_update_status_ng(struct backlight_device *bd)
+{
+        int value, result;
+        int *handle = (int *)bl_get_data(bd);
+
+        value = bd->props.brightness;
+        sony_call_snc_handle(*handle, 0x0100 | (value << 16), &result);
+
+        return sony_nc_get_brightness_ng(bd);
+}
+
 static const struct backlight_ops sony_backlight_ops = {
+        .options = BL_CORE_SUSPENDRESUME,
         .update_status = sony_backlight_update_status,
         .get_brightness = sony_backlight_get_brightness,
 };
+static const struct backlight_ops sony_backlight_ng_ops = {
+        .options = BL_CORE_SUSPENDRESUME,
+        .update_status = sony_nc_update_status_ng,
+        .get_brightness = sony_nc_get_brightness_ng,
+};
+static int backlight_ng_handle;
+static struct backlight_device *sony_backlight_device;
 
 /*
  * New SNC-only Vaios event mapping to driver known keys
@@ -972,7 +1083,7 @@ static void sony_nc_notify(struct acpi_device *device, u32 event)
                                 }
 
                                 if (!key_event->data)
-                                        printk(KERN_INFO DRV_PFX
+                                        pr_info(DRV_PFX
                                                         "Unknown event: 0x%x 0x%x\n",
                                                         key_handle,
                                                         ev);
@@ -996,7 +1107,7 @@ static acpi_status sony_walk_callback(acpi_handle handle, u32 level,
         struct acpi_device_info *info;
 
         if (ACPI_SUCCESS(acpi_get_object_info(handle, &info))) {
-                printk(KERN_WARNING DRV_PFX "method: name: %4.4s, args %X\n",
+                pr_warn(DRV_PFX "method: name: %4.4s, args %X\n",
                         (char *)&info->name, info->param_count);
 
                 kfree(info);
@@ -1037,7 +1148,7 @@ static int sony_nc_resume(struct acpi_device *device)
                 ret = acpi_callsetfunc(sony_nc_acpi_handle, *item->acpiset,
                                        item->value, NULL);
                 if (ret < 0) {
-                        printk("%s: %d\n", __func__, ret);
+                        pr_err(DRV_PFX "%s: %d\n", __func__, ret);
                         break;
                 }
         }
@@ -1054,11 +1165,6 @@ static int sony_nc_resume(struct acpi_device *device)
                 sony_nc_function_setup(device);
         }
 
-        /* set the last requested brightness level */
-        if (sony_backlight_device &&
-                        sony_backlight_update_status(sony_backlight_device) < 0)
-                printk(KERN_WARNING DRV_PFX "unable to restore brightness level\n");
-
         /* re-read rfkill state */
         sony_nc_rfkill_update();
 
@@ -1206,12 +1312,12 @@ static void sony_nc_rfkill_setup(struct acpi_device *device)
 
         device_enum = (union acpi_object *) buffer.pointer;
         if (!device_enum) {
-                pr_err("Invalid SN06 return object\n");
+                pr_err(DRV_PFX "No SN06 return object.");
                 goto out_no_enum;
         }
         if (device_enum->type != ACPI_TYPE_BUFFER) {
-                pr_err("Invalid SN06 return object type 0x%.2x\n",
-                       device_enum->type);
+                pr_err(DRV_PFX "Invalid SN06 return object 0x%.2x\n",
+                                device_enum->type);
                 goto out_no_enum;
         }
 
@@ -1245,6 +1351,209 @@ out_no_enum:
         return;
 }
 
+/* Keyboard backlight feature */
+#define KBDBL_HANDLER   0x137
+#define KBDBL_PRESENT   0xB00
+#define SET_MODE        0xC00
+#define SET_TIMEOUT     0xE00
+
+struct kbd_backlight {
+        int mode;
+        int timeout;
+        struct device_attribute mode_attr;
+        struct device_attribute timeout_attr;
+};
+
+static struct kbd_backlight *kbdbl_handle;
+
+static ssize_t __sony_nc_kbd_backlight_mode_set(u8 value)
+{
+        int result;
+
+        if (value > 1)
+                return -EINVAL;
+
+        if (sony_call_snc_handle(KBDBL_HANDLER,
+                                (value << 0x10) | SET_MODE, &result))
+                return -EIO;
+
+        kbdbl_handle->mode = value;
+
+        return 0;
+}
+
+static ssize_t sony_nc_kbd_backlight_mode_store(struct device *dev,
+                struct device_attribute *attr,
+                const char *buffer, size_t count)
+{
+        int ret = 0;
+        unsigned long value;
+
+        if (count > 31)
+                return -EINVAL;
+
+        if (strict_strtoul(buffer, 10, &value))
+                return -EINVAL;
+
+        ret = __sony_nc_kbd_backlight_mode_set(value);
+        if (ret < 0)
+                return ret;
+
+        return count;
+}
+
+static ssize_t sony_nc_kbd_backlight_mode_show(struct device *dev,
+                struct device_attribute *attr, char *buffer)
+{
+        ssize_t count = 0;
+        count = snprintf(buffer, PAGE_SIZE, "%d\n", kbdbl_handle->mode);
+        return count;
+}
+
+static int __sony_nc_kbd_backlight_timeout_set(u8 value)
+{
+        int result;
+
+        if (value > 3)
+                return -EINVAL;
+
+        if (sony_call_snc_handle(KBDBL_HANDLER,
+                                (value << 0x10) | SET_TIMEOUT, &result))
+                return -EIO;
+
+        kbdbl_handle->timeout = value;
+
+        return 0;
+}
+
+static ssize_t sony_nc_kbd_backlight_timeout_store(struct device *dev,
+                struct device_attribute *attr,
+                const char *buffer, size_t count)
+{
+        int ret = 0;
+        unsigned long value;
+
+        if (count > 31)
+                return -EINVAL;
+
+        if (strict_strtoul(buffer, 10, &value))
+                return -EINVAL;
+
+        ret = __sony_nc_kbd_backlight_timeout_set(value);
+        if (ret < 0)
+                return ret;
+
+        return count;
+}
+
+static ssize_t sony_nc_kbd_backlight_timeout_show(struct device *dev,
+                struct device_attribute *attr, char *buffer)
+{
+        ssize_t count = 0;
+        count = snprintf(buffer, PAGE_SIZE, "%d\n", kbdbl_handle->timeout);
+        return count;
+}
+
+static int sony_nc_kbd_backlight_setup(struct platform_device *pd)
+{
+        int result;
+
+        if (sony_call_snc_handle(0x137, KBDBL_PRESENT, &result))
+                return 0;
+        if (!(result & 0x02))
+                return 0;
+
+        kbdbl_handle = kzalloc(sizeof(*kbdbl_handle), GFP_KERNEL);
+        if (!kbdbl_handle)
+                return -ENOMEM;
+
+        sysfs_attr_init(&kbdbl_handle->mode_attr.attr);
+        kbdbl_handle->mode_attr.attr.name = "kbd_backlight";
+        kbdbl_handle->mode_attr.attr.mode = S_IRUGO | S_IWUSR;
+        kbdbl_handle->mode_attr.show = sony_nc_kbd_backlight_mode_show;
+        kbdbl_handle->mode_attr.store = sony_nc_kbd_backlight_mode_store;
+
+        sysfs_attr_init(&kbdbl_handle->timeout_attr.attr);
+        kbdbl_handle->timeout_attr.attr.name = "kbd_backlight_timeout";
+        kbdbl_handle->timeout_attr.attr.mode = S_IRUGO | S_IWUSR;
+        kbdbl_handle->timeout_attr.show = sony_nc_kbd_backlight_timeout_show;
+        kbdbl_handle->timeout_attr.store = sony_nc_kbd_backlight_timeout_store;
+
+        if (device_create_file(&pd->dev, &kbdbl_handle->mode_attr))
+                goto outkzalloc;
+
+        if (device_create_file(&pd->dev, &kbdbl_handle->timeout_attr))
+                goto outmode;
+
+        __sony_nc_kbd_backlight_mode_set(kbd_backlight);
+        __sony_nc_kbd_backlight_timeout_set(kbd_backlight_timeout);
+
+        return 0;
+
+outmode:
+        device_remove_file(&pd->dev, &kbdbl_handle->mode_attr);
+outkzalloc:
+        kfree(kbdbl_handle);
+        kbdbl_handle = NULL;
+        return -1;
+}
+
+static int sony_nc_kbd_backlight_cleanup(struct platform_device *pd)
+{
+        if (kbdbl_handle) {
+                device_remove_file(&pd->dev, &kbdbl_handle->mode_attr);
+                device_remove_file(&pd->dev, &kbdbl_handle->timeout_attr);
+                kfree(kbdbl_handle);
+        }
+        return 0;
+}
+
+static void sony_nc_backlight_setup(void)
+{
+        acpi_handle unused;
+        int max_brightness = 0;
+        const struct backlight_ops *ops = NULL;
+        struct backlight_properties props;
+
+        if (sony_find_snc_handle(0x12f) != -1) {
+                backlight_ng_handle = 0x12f;
+                ops = &sony_backlight_ng_ops;
+                max_brightness = 0xff;
+
+        } else if (sony_find_snc_handle(0x137) != -1) {
+                backlight_ng_handle = 0x137;
+                ops = &sony_backlight_ng_ops;
+                max_brightness = 0xff;
+
+        } else if (ACPI_SUCCESS(acpi_get_handle(sony_nc_acpi_handle, "GBRT",
+                                                &unused))) {
+                ops = &sony_backlight_ops;
+                max_brightness = SONY_MAX_BRIGHTNESS - 1;
+
+        } else
+                return;
+
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_PLATFORM;
+        props.max_brightness = max_brightness;
+        sony_backlight_device = backlight_device_register("sony", NULL,
+                                                          &backlight_ng_handle,
+                                                          ops, &props);
+
+        if (IS_ERR(sony_backlight_device)) {
+                pr_warning(DRV_PFX "unable to register backlight device\n");
+                sony_backlight_device = NULL;
+        } else
+                sony_backlight_device->props.brightness =
+                    ops->get_brightness(sony_backlight_device);
+}
+
+static void sony_nc_backlight_cleanup(void)
+{
+        if (sony_backlight_device)
+                backlight_device_unregister(sony_backlight_device);
+}
+
 static int sony_nc_add(struct acpi_device *device)
 {
         acpi_status status;
@@ -1252,8 +1561,8 @@ static int sony_nc_add(struct acpi_device *device)
         acpi_handle handle;
         struct sony_nc_value *item;
 
-        printk(KERN_INFO DRV_PFX "%s v%s.\n",
-                SONY_NC_DRIVER_NAME, SONY_LAPTOP_DRIVER_VERSION);
+        pr_info(DRV_PFX "%s v%s.\n", SONY_NC_DRIVER_NAME,
+                        SONY_LAPTOP_DRIVER_VERSION);
 
         sony_nc_acpi_device = device;
         strcpy(acpi_device_class(device), "sony/hotkey");
@@ -1269,13 +1578,18 @@ static int sony_nc_add(struct acpi_device *device)
                 goto outwalk;
         }
 
+        result = sony_pf_add();
+        if (result)
+                goto outpresent;
+
         if (debug) {
-                status = acpi_walk_namespace(ACPI_TYPE_METHOD, sony_nc_acpi_handle,
-                                             1, sony_walk_callback, NULL, NULL, NULL);
+                status = acpi_walk_namespace(ACPI_TYPE_METHOD,
+                                sony_nc_acpi_handle, 1, sony_walk_callback,
+                                NULL, NULL, NULL);
                 if (ACPI_FAILURE(status)) {
-                        printk(KERN_WARNING DRV_PFX "unable to walk acpi resources\n");
+                        pr_warn(DRV_PFX "unable to walk acpi resources\n");
                         result = -ENODEV;
-                        goto outwalk;
+                        goto outpresent;
                 }
         }
 
@@ -1288,6 +1602,12 @@ static int sony_nc_add(struct acpi_device *device)
         if (ACPI_SUCCESS(acpi_get_handle(sony_nc_acpi_handle, "SN00",
                                          &handle))) {
                 dprintk("Doing SNC setup\n");
+                result = sony_nc_handles_setup(sony_pf_device);
+                if (result)
+                        goto outpresent;
+                result = sony_nc_kbd_backlight_setup(sony_pf_device);
+                if (result)
+                        goto outsnc;
                 sony_nc_function_setup(device);
                 sony_nc_rfkill_setup(device);
         }
@@ -1295,40 +1615,17 @@ static int sony_nc_add(struct acpi_device *device)
         /* setup input devices and helper fifo */
         result = sony_laptop_setup_input(device);
         if (result) {
-                printk(KERN_ERR DRV_PFX
-                                "Unable to create input devices.\n");
-                goto outwalk;
+                pr_err(DRV_PFX "Unable to create input devices.\n");
+                goto outkbdbacklight;
         }
 
         if (acpi_video_backlight_support()) {
-                printk(KERN_INFO DRV_PFX "brightness ignored, must be "
+                pr_info(DRV_PFX "brightness ignored, must be "
                        "controlled by ACPI video driver\n");
-        } else if (ACPI_SUCCESS(acpi_get_handle(sony_nc_acpi_handle, "GBRT",
-                                                &handle))) {
-                struct backlight_properties props;
-                memset(&props, 0, sizeof(struct backlight_properties));
-                props.type = BACKLIGHT_PLATFORM;
-                props.max_brightness = SONY_MAX_BRIGHTNESS - 1;
-                sony_backlight_device = backlight_device_register("sony", NULL,
-                                                                  NULL,
-                                                                  &sony_backlight_ops,
-                                                                  &props);
-
-                if (IS_ERR(sony_backlight_device)) {
-                        printk(KERN_WARNING DRV_PFX "unable to register backlight device\n");
-                        sony_backlight_device = NULL;
-                } else {
-                        sony_backlight_device->props.brightness =
-                            sony_backlight_get_brightness
-                            (sony_backlight_device);
-                }
-
+        } else {
+                sony_nc_backlight_setup();
         }
 
-        result = sony_pf_add();
-        if (result)
-                goto outbacklight;
-
         /* create sony_pf sysfs attributes related to the SNC device */
         for (item = sony_nc_values; item->name; ++item) {
 
@@ -1374,14 +1671,19 @@ static int sony_nc_add(struct acpi_device *device)
         for (item = sony_nc_values; item->name; ++item) {
                 device_remove_file(&sony_pf_device->dev, &item->devattr);
         }
-        sony_pf_remove();
-
-      outbacklight:
-        if (sony_backlight_device)
-                backlight_device_unregister(sony_backlight_device);
+        sony_nc_backlight_cleanup();
 
         sony_laptop_remove_input();
 
+      outkbdbacklight:
+        sony_nc_kbd_backlight_cleanup(sony_pf_device);
+
+      outsnc:
+        sony_nc_handles_cleanup(sony_pf_device);
+
+      outpresent:
+        sony_pf_remove();
+
       outwalk:
         sony_nc_rfkill_cleanup();
         return result;
@@ -1391,8 +1693,7 @@ static int sony_nc_remove(struct acpi_device *device, int type)
 {
         struct sony_nc_value *item;
 
-        if (sony_backlight_device)
-                backlight_device_unregister(sony_backlight_device);
+        sony_nc_backlight_cleanup();
 
         sony_nc_acpi_device = NULL;
 
@@ -1400,6 +1701,8 @@ static int sony_nc_remove(struct acpi_device *device, int type)
                 device_remove_file(&sony_pf_device->dev, &item->devattr);
         }
 
+        sony_nc_kbd_backlight_cleanup(sony_pf_device);
+        sony_nc_handles_cleanup(sony_pf_device);
         sony_pf_remove();
         sony_laptop_remove_input();
         sony_nc_rfkill_cleanup();
@@ -1438,7 +1741,6 @@ static struct acpi_driver sony_nc_driver = {
 #define SONYPI_DEVICE_TYPE1     0x00000001
 #define SONYPI_DEVICE_TYPE2     0x00000002
 #define SONYPI_DEVICE_TYPE3     0x00000004
-#define SONYPI_DEVICE_TYPE4     0x00000008
 
 #define SONYPI_TYPE1_OFFSET     0x04
 #define SONYPI_TYPE2_OFFSET     0x12
@@ -1584,8 +1886,8 @@ static struct sonypi_event sonypi_blueev[] = {
 
 /* The set of possible wireless events */
 static struct sonypi_event sonypi_wlessev[] = {
-        { 0x59, SONYPI_EVENT_WIRELESS_ON },
-        { 0x5a, SONYPI_EVENT_WIRELESS_OFF },
+        { 0x59, SONYPI_EVENT_IGNORE },
+        { 0x5a, SONYPI_EVENT_IGNORE },
         { 0, 0 }
 };
 
@@ -1842,7 +2144,7 @@ out:
         if (pcidev)
                 pci_dev_put(pcidev);
 
-        printk(KERN_INFO DRV_PFX "detected Type%d model\n",
+        pr_info(DRV_PFX "detected Type%d model\n",
                         dev->model == SONYPI_DEVICE_TYPE1 ? 1 :
                         dev->model == SONYPI_DEVICE_TYPE2 ? 2 : 3);
 }
@@ -1890,7 +2192,7 @@ static int __sony_pic_camera_ready(void)
 static int __sony_pic_camera_off(void)
 {
         if (!camera) {
-                printk(KERN_WARNING DRV_PFX "camera control not enabled\n");
+                pr_warn(DRV_PFX "camera control not enabled\n");
                 return -ENODEV;
         }
 
@@ -1910,7 +2212,7 @@ static int __sony_pic_camera_on(void)
         int i, j, x;
 
         if (!camera) {
-                printk(KERN_WARNING DRV_PFX "camera control not enabled\n");
+                pr_warn(DRV_PFX "camera control not enabled\n");
                 return -ENODEV;
         }
 
@@ -1933,7 +2235,7 @@ static int __sony_pic_camera_on(void)
         }
 
         if (j == 0) {
-                printk(KERN_WARNING DRV_PFX "failed to power on camera\n");
+                pr_warn(DRV_PFX "failed to power on camera\n");
                 return -ENODEV;
         }
 
@@ -1989,7 +2291,7 @@ int sony_pic_camera_command(int command, u8 value)
                                 ITERATIONS_SHORT);
                 break;
         default:
-                printk(KERN_ERR DRV_PFX "sony_pic_camera_command invalid: %d\n",
+                pr_err(DRV_PFX "sony_pic_camera_command invalid: %d\n",
                        command);
                 break;
         }
@@ -2396,7 +2698,7 @@ static int sonypi_compat_init(void)
         error =
          kfifo_alloc(&sonypi_compat.fifo, SONY_LAPTOP_BUF_SIZE, GFP_KERNEL);
         if (error) {
-                printk(KERN_ERR DRV_PFX "kfifo_alloc failed\n");
+                pr_err(DRV_PFX "kfifo_alloc failed\n");
                 return error;
         }
 
@@ -2406,11 +2708,11 @@ static int sonypi_compat_init(void)
                 sonypi_misc_device.minor = minor;
         error = misc_register(&sonypi_misc_device);
         if (error) {
-                printk(KERN_ERR DRV_PFX "misc_register failed\n");
+                pr_err(DRV_PFX "misc_register failed\n");
                 goto err_free_kfifo;
         }
         if (minor == -1)
-                printk(KERN_INFO DRV_PFX "device allocated minor is %d\n",
+                pr_info(DRV_PFX "device allocated minor is %d\n",
                        sonypi_misc_device.minor);
 
         return 0;
@@ -2470,8 +2772,7 @@ sony_pic_read_possible_resource(struct acpi_resource *resource, void *context)
                         }
                         for (i = 0; i < p->interrupt_count; i++) {
                                 if (!p->interrupts[i]) {
-                                        printk(KERN_WARNING DRV_PFX
-                                                        "Invalid IRQ %d\n",
+                                        pr_warn(DRV_PFX "Invalid IRQ %d\n",
                                                         p->interrupts[i]);
                                         continue;
                                 }
@@ -2510,7 +2811,7 @@ sony_pic_read_possible_resource(struct acpi_resource *resource, void *context)
                                                 ioport->io2.address_length);
                         }
                         else {
-                                printk(KERN_ERR DRV_PFX "Unknown SPIC Type, more than 2 IO Ports\n");
+                                pr_err(DRV_PFX "Unknown SPIC Type, more than 2 IO Ports\n");
                                 return AE_ERROR;
                         }
                         return AE_OK;
@@ -2538,7 +2839,7 @@ static int sony_pic_possible_resources(struct acpi_device *device)
         dprintk("Evaluating _STA\n");
         result = acpi_bus_get_status(device);
         if (result) {
-                printk(KERN_WARNING DRV_PFX "Unable to read status\n");
+                pr_warn(DRV_PFX "Unable to read status\n");
                 goto end;
         }
 
@@ -2554,8 +2855,7 @@ static int sony_pic_possible_resources(struct acpi_device *device)
         status = acpi_walk_resources(device->handle, METHOD_NAME__PRS,
                         sony_pic_read_possible_resource, &spic_dev);
         if (ACPI_FAILURE(status)) {
-                printk(KERN_WARNING DRV_PFX
-                                "Failure evaluating %s\n",
+                pr_warn(DRV_PFX "Failure evaluating %s\n",
                                 METHOD_NAME__PRS);
                 result = -ENODEV;
         }
@@ -2669,7 +2969,7 @@ static int sony_pic_enable(struct acpi_device *device,
 
         /* check for total failure */
         if (ACPI_FAILURE(status)) {
-                printk(KERN_ERR DRV_PFX "Error evaluating _SRS\n");
+                pr_err(DRV_PFX "Error evaluating _SRS\n");
                 result = -ENODEV;
                 goto end;
         }
@@ -2725,6 +3025,9 @@ static irqreturn_t sony_pic_irq(int irq, void *dev_id)
                         if (ev == dev->event_types[i].events[j].data) {
                                 device_event =
                                         dev->event_types[i].events[j].event;
+                                /* some events may require ignoring */
+                                if (!device_event)
+                                        return IRQ_HANDLED;
                                 goto found;
                         }
                 }
@@ -2744,7 +3047,6 @@ found:
         sony_laptop_report_input_event(device_event);
         acpi_bus_generate_proc_event(dev->acpi_dev, 1, device_event);
         sonypi_compat_report_event(device_event);
-
         return IRQ_HANDLED;
 }
 
@@ -2759,7 +3061,7 @@ static int sony_pic_remove(struct acpi_device *device, int type)
         struct sony_pic_irq *irq, *tmp_irq;
 
         if (sony_pic_disable(device)) {
-                printk(KERN_ERR DRV_PFX "Couldn't disable device.\n");
+                pr_err(DRV_PFX "Couldn't disable device.\n");
                 return -ENXIO;
         }
 
@@ -2799,8 +3101,8 @@ static int sony_pic_add(struct acpi_device *device)
         struct sony_pic_ioport *io, *tmp_io;
         struct sony_pic_irq *irq, *tmp_irq;
 
-        printk(KERN_INFO DRV_PFX "%s v%s.\n",
-                SONY_PIC_DRIVER_NAME, SONY_LAPTOP_DRIVER_VERSION);
+        pr_info(DRV_PFX "%s v%s.\n", SONY_PIC_DRIVER_NAME,
+                        SONY_LAPTOP_DRIVER_VERSION);
 
         spic_dev.acpi_dev = device;
         strcpy(acpi_device_class(device), "sony/hotkey");
@@ -2810,16 +3112,14 @@ static int sony_pic_add(struct acpi_device *device)
         /* read _PRS resources */
         result = sony_pic_possible_resources(device);
         if (result) {
-                printk(KERN_ERR DRV_PFX
-                                "Unable to read possible resources.\n");
+                pr_err(DRV_PFX "Unable to read possible resources.\n");
                 goto err_free_resources;
         }
 
         /* setup input devices and helper fifo */
         result = sony_laptop_setup_input(device);
         if (result) {
-                printk(KERN_ERR DRV_PFX
-                                "Unable to create input devices.\n");
+                pr_err(DRV_PFX "Unable to create input devices.\n");
                 goto err_free_resources;
         }
 
@@ -2829,7 +3129,7 @@ static int sony_pic_add(struct acpi_device *device)
         /* request io port */
         list_for_each_entry_reverse(io, &spic_dev.ioports, list) {
                 if (request_region(io->io1.minimum, io->io1.address_length,
-                                        "Sony Programable I/O Device")) {
+                                        "Sony Programmable I/O Device")) {
                         dprintk("I/O port1: 0x%.4x (0x%.4x) + 0x%.2x\n",
                                         io->io1.minimum, io->io1.maximum,
                                         io->io1.address_length);
@@ -2837,7 +3137,7 @@ static int sony_pic_add(struct acpi_device *device)
                         if (io->io2.minimum) {
                                 if (request_region(io->io2.minimum,
                                                 io->io2.address_length,
-                                                "Sony Programable I/O Device")) {
+                                                "Sony Programmable I/O Device")) {
                                         dprintk("I/O port2: 0x%.4x (0x%.4x) + 0x%.2x\n",
                                                         io->io2.minimum, io->io2.maximum,
                                                         io->io2.address_length);
@@ -2860,7 +3160,7 @@ static int sony_pic_add(struct acpi_device *device)
                 }
         }
         if (!spic_dev.cur_ioport) {
-                printk(KERN_ERR DRV_PFX "Failed to request_region.\n");
+                pr_err(DRV_PFX "Failed to request_region.\n");
                 result = -ENODEV;
                 goto err_remove_compat;
         }
@@ -2880,7 +3180,7 @@ static int sony_pic_add(struct acpi_device *device)
                 }
         }
         if (!spic_dev.cur_irq) {
-                printk(KERN_ERR DRV_PFX "Failed to request_irq.\n");
+                pr_err(DRV_PFX "Failed to request_irq.\n");
                 result = -ENODEV;
                 goto err_release_region;
         }
@@ -2888,7 +3188,7 @@ static int sony_pic_add(struct acpi_device *device)
         /* set resource status _SRS */
         result = sony_pic_enable(device, spic_dev.cur_ioport, spic_dev.cur_irq);
         if (result) {
-                printk(KERN_ERR DRV_PFX "Couldn't enable device.\n");
+                pr_err(DRV_PFX "Couldn't enable device.\n");
                 goto err_free_irq;
         }
 
@@ -2997,8 +3297,7 @@ static int __init sony_laptop_init(void)
         if (!no_spic && dmi_check_system(sonypi_dmi_table)) {
                 result = acpi_bus_register_driver(&sony_pic_driver);
                 if (result) {
-                        printk(KERN_ERR DRV_PFX
-                                        "Unable to register SPIC driver.");
+                        pr_err(DRV_PFX "Unable to register SPIC driver.");
                         goto out;
                 }
                 spic_drv_registered = 1;
@@ -3006,7 +3305,7 @@ static int __init sony_laptop_init(void)
 
         result = acpi_bus_register_driver(&sony_nc_driver);
         if (result) {
-                printk(KERN_ERR DRV_PFX "Unable to register SNC driver.");
+                pr_err(DRV_PFX "Unable to register SNC driver.");
                 goto out_unregister_pic;
         }
 
diff --git a/drivers/platform/x86/thinkpad_acpi.c b/drivers/platform/x86/thinkpad_acpi.c
index 947bdcaa0ce9..a08561f5349e 100644
--- a/drivers/platform/x86/thinkpad_acpi.c
+++ b/drivers/platform/x86/thinkpad_acpi.c
@@ -2407,7 +2407,7 @@ static void hotkey_compare_and_issue_event(struct tp_nvram_state *oldn,
          * This code is supposed to duplicate the IBM firmware behaviour:
          * - Pressing MUTE issues mute hotkey message, even when already mute
          * - Pressing Volume up/down issues volume up/down hotkey messages,
-         *   even when already at maximum or minumum volume
+         *   even when already at maximum or minimum volume
          * - The act of unmuting issues volume up/down notification,
          *   depending which key was used to unmute
          *
@@ -2990,7 +2990,7 @@ static void tpacpi_send_radiosw_update(void)
          * rfkill input events, or we will race the rfkill core input
          * handler.
          *
-         * tpacpi_inputdev_send_mutex works as a syncronization point
+         * tpacpi_inputdev_send_mutex works as a synchronization point
          * for the above.
          *
          * We optimize to avoid numerous calls to hotkey_get_wlsw.
diff --git a/drivers/platform/x86/xo15-ebook.c b/drivers/platform/x86/xo15-ebook.c
new file mode 100644
index 000000000000..c1372ed9d2e9
--- /dev/null
+++ b/drivers/platform/x86/xo15-ebook.c
@@ -0,0 +1,180 @@
+/*
+ *  OLPC XO-1.5 ebook switch driver
+ *  (based on generic ACPI button driver)
+ *
+ *  Copyright (C) 2009 Paul Fox <pgf@laptop.org>
+ *  Copyright (C) 2010 One Laptop per Child
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or (at
+ *  your option) any later version.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/types.h>
+#include <linux/input.h>
+#include <acpi/acpi_bus.h>
+#include <acpi/acpi_drivers.h>
+
+#define MODULE_NAME "xo15-ebook"
+#define PREFIX MODULE_NAME ": "
+
+#define XO15_EBOOK_CLASS                MODULE_NAME
+#define XO15_EBOOK_TYPE_UNKNOWN 0x00
+#define XO15_EBOOK_NOTIFY_STATUS        0x80
+
+#define XO15_EBOOK_SUBCLASS             "ebook"
+#define XO15_EBOOK_HID                  "XO15EBK"
+#define XO15_EBOOK_DEVICE_NAME          "EBook Switch"
+
+ACPI_MODULE_NAME(MODULE_NAME);
+
+MODULE_DESCRIPTION("OLPC XO-1.5 ebook switch driver");
+MODULE_LICENSE("GPL");
+
+static const struct acpi_device_id ebook_device_ids[] = {
+        { XO15_EBOOK_HID, 0 },
+        { "", 0 },
+};
+MODULE_DEVICE_TABLE(acpi, ebook_device_ids);
+
+struct ebook_switch {
+        struct input_dev *input;
+        char phys[32];                  /* for input device */
+};
+
+static int ebook_send_state(struct acpi_device *device)
+{
+        struct ebook_switch *button = acpi_driver_data(device);
+        unsigned long long state;
+        acpi_status status;
+
+        status = acpi_evaluate_integer(device->handle, "EBK", NULL, &state);
+        if (ACPI_FAILURE(status))
+                return -EIO;
+
+        /* input layer checks if event is redundant */
+        input_report_switch(button->input, SW_TABLET_MODE, !state);
+        input_sync(button->input);
+        return 0;
+}
+
+static void ebook_switch_notify(struct acpi_device *device, u32 event)
+{
+        switch (event) {
+        case ACPI_FIXED_HARDWARE_EVENT:
+        case XO15_EBOOK_NOTIFY_STATUS:
+                ebook_send_state(device);
+                break;
+        default:
+                ACPI_DEBUG_PRINT((ACPI_DB_INFO,
+                                  "Unsupported event [0x%x]\n", event));
+                break;
+        }
+}
+
+static int ebook_switch_resume(struct acpi_device *device)
+{
+        return ebook_send_state(device);
+}
+
+static int ebook_switch_add(struct acpi_device *device)
+{
+        struct ebook_switch *button;
+        struct input_dev *input;
+        const char *hid = acpi_device_hid(device);
+        char *name, *class;
+        int error;
+
+        button = kzalloc(sizeof(struct ebook_switch), GFP_KERNEL);
+        if (!button)
+                return -ENOMEM;
+
+        device->driver_data = button;
+
+        button->input = input = input_allocate_device();
+        if (!input) {
+                error = -ENOMEM;
+                goto err_free_button;
+        }
+
+        name = acpi_device_name(device);
+        class = acpi_device_class(device);
+
+        if (strcmp(hid, XO15_EBOOK_HID)) {
+                printk(KERN_ERR PREFIX "Unsupported hid [%s]\n", hid);
+                error = -ENODEV;
+                goto err_free_input;
+        }
+
+        strcpy(name, XO15_EBOOK_DEVICE_NAME);
+        sprintf(class, "%s/%s", XO15_EBOOK_CLASS, XO15_EBOOK_SUBCLASS);
+
+        snprintf(button->phys, sizeof(button->phys), "%s/button/input0", hid);
+
+        input->name = name;
+        input->phys = button->phys;
+        input->id.bustype = BUS_HOST;
+        input->dev.parent = &device->dev;
+
+        input->evbit[0] = BIT_MASK(EV_SW);
+        set_bit(SW_TABLET_MODE, input->swbit);
+
+        error = input_register_device(input);
+        if (error)
+                goto err_free_input;
+
+        ebook_send_state(device);
+
+        if (device->wakeup.flags.valid) {
+                /* Button's GPE is run-wake GPE */
+                acpi_enable_gpe(device->wakeup.gpe_device,
+                                device->wakeup.gpe_number);
+                device_set_wakeup_enable(&device->dev, true);
+        }
+
+        return 0;
+
+ err_free_input:
+        input_free_device(input);
+ err_free_button:
+        kfree(button);
+        return error;
+}
+
+static int ebook_switch_remove(struct acpi_device *device, int type)
+{
+        struct ebook_switch *button = acpi_driver_data(device);
+
+        input_unregister_device(button->input);
+        kfree(button);
+        return 0;
+}
+
+static struct acpi_driver xo15_ebook_driver = {
+        .name = MODULE_NAME,
+        .class = XO15_EBOOK_CLASS,
+        .ids = ebook_device_ids,
+        .ops = {
+                .add = ebook_switch_add,
+                .resume = ebook_switch_resume,
+                .remove = ebook_switch_remove,
+                .notify = ebook_switch_notify,
+        },
+};
+
+static int __init xo15_ebook_init(void)
+{
+        return acpi_bus_register_driver(&xo15_ebook_driver);
+}
+
+static void __exit xo15_ebook_exit(void)
+{
+        acpi_bus_unregister_driver(&xo15_ebook_driver);
+}
+
+module_init(xo15_ebook_init);
+module_exit(xo15_ebook_exit);
diff --git a/drivers/vlynq/vlynq.c b/drivers/vlynq/vlynq.c
index f885c868a04d..aa250cebecd2 100644
--- a/drivers/vlynq/vlynq.c
+++ b/drivers/vlynq/vlynq.c
@@ -135,40 +135,40 @@ static void vlynq_reset(struct vlynq_device *dev)
         msleep(5);
 }
 
-static void vlynq_irq_unmask(unsigned int irq)
+static void vlynq_irq_unmask(struct irq_data *d)
 {
-        u32 val;
-        struct vlynq_device *dev = get_irq_chip_data(irq);
+        struct vlynq_device *dev = irq_data_get_irq_chip_data(d);
         int virq;
+        u32 val;
 
         BUG_ON(!dev);
-        virq = irq - dev->irq_start;
+        virq = d->irq - dev->irq_start;
         val = readl(&dev->remote->int_device[virq >> 2]);
         val |= (VINT_ENABLE | virq) << VINT_OFFSET(virq);
         writel(val, &dev->remote->int_device[virq >> 2]);
 }
 
-static void vlynq_irq_mask(unsigned int irq)
+static void vlynq_irq_mask(struct irq_data *d)
 {
-        u32 val;
-        struct vlynq_device *dev = get_irq_chip_data(irq);
+        struct vlynq_device *dev = irq_data_get_irq_chip_data(d);
         int virq;
+        u32 val;
 
         BUG_ON(!dev);
-        virq = irq - dev->irq_start;
+        virq = d->irq - dev->irq_start;
         val = readl(&dev->remote->int_device[virq >> 2]);
         val &= ~(VINT_ENABLE << VINT_OFFSET(virq));
         writel(val, &dev->remote->int_device[virq >> 2]);
 }
 
-static int vlynq_irq_type(unsigned int irq, unsigned int flow_type)
+static int vlynq_irq_type(struct irq_data *d, unsigned int flow_type)
 {
-        u32 val;
-        struct vlynq_device *dev = get_irq_chip_data(irq);
+        struct vlynq_device *dev = irq_data_get_irq_chip_data(d);
         int virq;
+        u32 val;
 
         BUG_ON(!dev);
-        virq = irq - dev->irq_start;
+        virq = d->irq - dev->irq_start;
         val = readl(&dev->remote->int_device[virq >> 2]);
         switch (flow_type & IRQ_TYPE_SENSE_MASK) {
         case IRQ_TYPE_EDGE_RISING:
@@ -192,10 +192,9 @@ static int vlynq_irq_type(unsigned int irq, unsigned int flow_type)
         return 0;
 }
 
-static void vlynq_local_ack(unsigned int irq)
+static void vlynq_local_ack(struct irq_data *d)
 {
-        struct vlynq_device *dev = get_irq_chip_data(irq);
-
+        struct vlynq_device *dev = irq_data_get_irq_chip_data(d);
         u32 status = readl(&dev->local->status);
 
         pr_debug("%s: local status: 0x%08x\n",
@@ -203,10 +202,9 @@ static void vlynq_local_ack(unsigned int irq)
         writel(status, &dev->local->status);
 }
 
-static void vlynq_remote_ack(unsigned int irq)
+static void vlynq_remote_ack(struct irq_data *d)
 {
-        struct vlynq_device *dev = get_irq_chip_data(irq);
-
+        struct vlynq_device *dev = irq_data_get_irq_chip_data(d);
         u32 status = readl(&dev->remote->status);
 
         pr_debug("%s: remote status: 0x%08x\n",
@@ -238,23 +236,23 @@ static irqreturn_t vlynq_irq(int irq, void *dev_id)
 
 static struct irq_chip vlynq_irq_chip = {
         .name = "vlynq",
-        .unmask = vlynq_irq_unmask,
-        .mask = vlynq_irq_mask,
-        .set_type = vlynq_irq_type,
+        .irq_unmask = vlynq_irq_unmask,
+        .irq_mask = vlynq_irq_mask,
+        .irq_set_type = vlynq_irq_type,
 };
 
 static struct irq_chip vlynq_local_chip = {
         .name = "vlynq local error",
-        .unmask = vlynq_irq_unmask,
-        .mask = vlynq_irq_mask,
-        .ack = vlynq_local_ack,
+        .irq_unmask = vlynq_irq_unmask,
+        .irq_mask = vlynq_irq_mask,
+        .irq_ack = vlynq_local_ack,
 };
 
 static struct irq_chip vlynq_remote_chip = {
         .name = "vlynq local error",
-        .unmask = vlynq_irq_unmask,
-        .mask = vlynq_irq_mask,
-        .ack = vlynq_remote_ack,
+        .irq_unmask = vlynq_irq_unmask,
+        .irq_mask = vlynq_irq_mask,
+        .irq_ack = vlynq_remote_ack,
 };
 
 static int vlynq_setup_irq(struct vlynq_device *dev)
@@ -291,17 +289,17 @@ static int vlynq_setup_irq(struct vlynq_device *dev)
         for (i = dev->irq_start; i <= dev->irq_end; i++) {
                 virq = i - dev->irq_start;
                 if (virq == dev->local_irq) {
-                        set_irq_chip_and_handler(i, &vlynq_local_chip,
+                        irq_set_chip_and_handler(i, &vlynq_local_chip,
                                                  handle_level_irq);
-                        set_irq_chip_data(i, dev);
+                        irq_set_chip_data(i, dev);
                 } else if (virq == dev->remote_irq) {
-                        set_irq_chip_and_handler(i, &vlynq_remote_chip,
+                        irq_set_chip_and_handler(i, &vlynq_remote_chip,
                                                  handle_level_irq);
-                        set_irq_chip_data(i, dev);
+                        irq_set_chip_data(i, dev);
                 } else {
-                        set_irq_chip_and_handler(i, &vlynq_irq_chip,
+                        irq_set_chip_and_handler(i, &vlynq_irq_chip,
                                                  handle_simple_irq);
-                        set_irq_chip_data(i, dev);
+                        irq_set_chip_data(i, dev);
                         writel(0, &dev->remote->int_device[virq >> 2]);
                 }
         }
diff --git a/fs/btrfs/btrfs_inode.h b/fs/btrfs/btrfs_inode.h
index ccc991c542df..57c3bb2884ce 100644
--- a/fs/btrfs/btrfs_inode.h
+++ b/fs/btrfs/btrfs_inode.h
@@ -136,9 +136,8 @@ struct btrfs_inode {
          * items we think we'll end up using, and reserved_extents is the number
          * of extent items we've reserved metadata for.
          */
-        spinlock_t accounting_lock;
         atomic_t outstanding_extents;
-        int reserved_extents;
+        atomic_t reserved_extents;
 
         /*
          * ordered_data_close is set by truncate when a file that used
diff --git a/fs/btrfs/compression.c b/fs/btrfs/compression.c
index 4d2110eafe29..41d1d7c70e29 100644
--- a/fs/btrfs/compression.c
+++ b/fs/btrfs/compression.c
@@ -340,6 +340,8 @@ int btrfs_submit_compressed_write(struct inode *inode, u64 start,
 
         WARN_ON(start & ((u64)PAGE_CACHE_SIZE - 1));
         cb = kmalloc(compressed_bio_size(root, compressed_len), GFP_NOFS);
+        if (!cb)
+                return -ENOMEM;
         atomic_set(&cb->pending_bios, 0);
         cb->errors = 0;
         cb->inode = inode;
@@ -354,6 +356,10 @@ int btrfs_submit_compressed_write(struct inode *inode, u64 start,
         bdev = BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev;
 
         bio = compressed_bio_alloc(bdev, first_byte, GFP_NOFS);
+        if(!bio) {
+                kfree(cb);
+                return -ENOMEM;
+        }
         bio->bi_private = cb;
         bio->bi_end_io = end_compressed_bio_write;
         atomic_inc(&cb->pending_bios);
@@ -657,8 +663,9 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
                         atomic_inc(&cb->pending_bios);
 
                         if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)) {
-                                btrfs_lookup_bio_sums(root, inode, comp_bio,
-                                                      sums);
+                                ret = btrfs_lookup_bio_sums(root, inode,
+                                                        comp_bio, sums);
+                                BUG_ON(ret);
                         }
                         sums += (comp_bio->bi_size + root->sectorsize - 1) /
                                 root->sectorsize;
@@ -683,8 +690,10 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
         ret = btrfs_bio_wq_end_io(root->fs_info, comp_bio, 0);
         BUG_ON(ret);
 
-        if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM))
-                btrfs_lookup_bio_sums(root, inode, comp_bio, sums);
+        if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)) {
+                ret = btrfs_lookup_bio_sums(root, inode, comp_bio, sums);
+                BUG_ON(ret);
+        }
 
         ret = btrfs_map_bio(root, READ, comp_bio, mirror_num, 0);
         BUG_ON(ret);
diff --git a/fs/btrfs/ctree.c b/fs/btrfs/ctree.c
index b5baff0dccfe..84d7ca1fe0ba 100644
--- a/fs/btrfs/ctree.c
+++ b/fs/btrfs/ctree.c
@@ -147,10 +147,11 @@ noinline void btrfs_release_path(struct btrfs_root *root, struct btrfs_path *p)
 struct extent_buffer *btrfs_root_node(struct btrfs_root *root)
 {
         struct extent_buffer *eb;
-        spin_lock(&root->node_lock);
-        eb = root->node;
+
+        rcu_read_lock();
+        eb = rcu_dereference(root->node);
         extent_buffer_get(eb);
-        spin_unlock(&root->node_lock);
+        rcu_read_unlock();
         return eb;
 }
 
@@ -165,14 +166,8 @@ struct extent_buffer *btrfs_lock_root_node(struct btrfs_root *root)
         while (1) {
                 eb = btrfs_root_node(root);
                 btrfs_tree_lock(eb);
-
-                spin_lock(&root->node_lock);
-                if (eb == root->node) {
-                        spin_unlock(&root->node_lock);
+                if (eb == root->node)
                         break;
-                }
-                spin_unlock(&root->node_lock);
-
                 btrfs_tree_unlock(eb);
                 free_extent_buffer(eb);
         }
@@ -458,10 +453,8 @@ static noinline int __btrfs_cow_block(struct btrfs_trans_handle *trans,
                 else
                         parent_start = 0;
 
-                spin_lock(&root->node_lock);
-                root->node = cow;
                 extent_buffer_get(cow);
-                spin_unlock(&root->node_lock);
+                rcu_assign_pointer(root->node, cow);
 
                 btrfs_free_tree_block(trans, root, buf, parent_start,
                                       last_ref);
@@ -542,6 +535,9 @@ noinline int btrfs_cow_block(struct btrfs_trans_handle *trans,
 
         ret = __btrfs_cow_block(trans, root, buf, parent,
                                  parent_slot, cow_ret, search_start, 0);
+
+        trace_btrfs_cow_block(root, buf, *cow_ret);
+
         return ret;
 }
 
@@ -686,6 +682,8 @@ int btrfs_realloc_node(struct btrfs_trans_handle *trans,
                         if (!cur) {
                                 cur = read_tree_block(root, blocknr,
                                                          blocksize, gen);
+                                if (!cur)
+                                        return -EIO;
                         } else if (!uptodate) {
                                 btrfs_read_buffer(cur, gen);
                         }
@@ -732,122 +730,6 @@ static inline unsigned int leaf_data_end(struct btrfs_root *root,
         return btrfs_item_offset_nr(leaf, nr - 1);
 }
 
-/*
- * extra debugging checks to make sure all the items in a key are
- * well formed and in the proper order
- */
-static int check_node(struct btrfs_root *root, struct btrfs_path *path,
-                      int level)
-{
-        struct extent_buffer *parent = NULL;
-        struct extent_buffer *node = path->nodes[level];
-        struct btrfs_disk_key parent_key;
-        struct btrfs_disk_key node_key;
-        int parent_slot;
-        int slot;
-        struct btrfs_key cpukey;
-        u32 nritems = btrfs_header_nritems(node);
-
-        if (path->nodes[level + 1])
-                parent = path->nodes[level + 1];
-
-        slot = path->slots[level];
-        BUG_ON(nritems == 0);
-        if (parent) {
-                parent_slot = path->slots[level + 1];
-                btrfs_node_key(parent, &parent_key, parent_slot);
-                btrfs_node_key(node, &node_key, 0);
-                BUG_ON(memcmp(&parent_key, &node_key,
-                              sizeof(struct btrfs_disk_key)));
-                BUG_ON(btrfs_node_blockptr(parent, parent_slot) !=
-                       btrfs_header_bytenr(node));
-        }
-        BUG_ON(nritems > BTRFS_NODEPTRS_PER_BLOCK(root));
-        if (slot != 0) {
-                btrfs_node_key_to_cpu(node, &cpukey, slot - 1);
-                btrfs_node_key(node, &node_key, slot);
-                BUG_ON(comp_keys(&node_key, &cpukey) <= 0);
-        }
-        if (slot < nritems - 1) {
-                btrfs_node_key_to_cpu(node, &cpukey, slot + 1);
-                btrfs_node_key(node, &node_key, slot);
-                BUG_ON(comp_keys(&node_key, &cpukey) >= 0);
-        }
-        return 0;
-}
-
-/*
- * extra checking to make sure all the items in a leaf are
- * well formed and in the proper order
- */
-static int check_leaf(struct btrfs_root *root, struct btrfs_path *path,
-                      int level)
-{
-        struct extent_buffer *leaf = path->nodes[level];
-        struct extent_buffer *parent = NULL;
-        int parent_slot;
-        struct btrfs_key cpukey;
-        struct btrfs_disk_key parent_key;
-        struct btrfs_disk_key leaf_key;
-        int slot = path->slots[0];
-
-        u32 nritems = btrfs_header_nritems(leaf);
-
-        if (path->nodes[level + 1])
-                parent = path->nodes[level + 1];
-
-        if (nritems == 0)
-                return 0;
-
-        if (parent) {
-                parent_slot = path->slots[level + 1];
-                btrfs_node_key(parent, &parent_key, parent_slot);
-                btrfs_item_key(leaf, &leaf_key, 0);
-
-                BUG_ON(memcmp(&parent_key, &leaf_key,
-                       sizeof(struct btrfs_disk_key)));
-                BUG_ON(btrfs_node_blockptr(parent, parent_slot) !=
-                       btrfs_header_bytenr(leaf));
-        }
-        if (slot != 0 && slot < nritems - 1) {
-                btrfs_item_key(leaf, &leaf_key, slot);
-                btrfs_item_key_to_cpu(leaf, &cpukey, slot - 1);
-                if (comp_keys(&leaf_key, &cpukey) <= 0) {
-                        btrfs_print_leaf(root, leaf);
-                        printk(KERN_CRIT "slot %d offset bad key\n", slot);
-                        BUG_ON(1);
-                }
-                if (btrfs_item_offset_nr(leaf, slot - 1) !=
-                       btrfs_item_end_nr(leaf, slot)) {
-                        btrfs_print_leaf(root, leaf);
-                        printk(KERN_CRIT "slot %d offset bad\n", slot);
-                        BUG_ON(1);
-                }
-        }
-        if (slot < nritems - 1) {
-                btrfs_item_key(leaf, &leaf_key, slot);
-                btrfs_item_key_to_cpu(leaf, &cpukey, slot + 1);
-                BUG_ON(comp_keys(&leaf_key, &cpukey) >= 0);
-                if (btrfs_item_offset_nr(leaf, slot) !=
-                        btrfs_item_end_nr(leaf, slot + 1)) {
-                        btrfs_print_leaf(root, leaf);
-                        printk(KERN_CRIT "slot %d offset bad\n", slot);
-                        BUG_ON(1);
-                }
-        }
-        BUG_ON(btrfs_item_offset_nr(leaf, 0) +
-               btrfs_item_size_nr(leaf, 0) != BTRFS_LEAF_DATA_SIZE(root));
-        return 0;
-}
-
-static noinline int check_block(struct btrfs_root *root,
-                                struct btrfs_path *path, int level)
-{
-        return 0;
-        if (level == 0)
-                return check_leaf(root, path, level);
-        return check_node(root, path, level);
-}
 
 /*
  * search for key in the extent_buffer.  The items start at offset p,
@@ -1046,9 +928,7 @@ static noinline int balance_level(struct btrfs_trans_handle *trans,
                         goto enospc;
                 }
 
-                spin_lock(&root->node_lock);
-                root->node = child;
-                spin_unlock(&root->node_lock);
+                rcu_assign_pointer(root->node, child);
 
                 add_root_to_dirty_list(root);
                 btrfs_tree_unlock(child);
@@ -1188,7 +1068,6 @@ static noinline int balance_level(struct btrfs_trans_handle *trans,
                 }
         }
         /* double check we haven't messed things up */
-        check_block(root, path, level);
         if (orig_ptr !=
             btrfs_node_blockptr(path->nodes[level], path->slots[level]))
                 BUG();
@@ -1798,12 +1677,6 @@ cow_done:
                 if (!cow)
                         btrfs_unlock_up_safe(p, level + 1);
 
-                ret = check_block(root, p, level);
-                if (ret) {
-                        ret = -1;
-                        goto done;
-                }
-
                 ret = bin_search(b, key, level, &slot);
 
                 if (level != 0) {
@@ -2130,10 +2003,8 @@ static noinline int insert_new_root(struct btrfs_trans_handle *trans,
 
         btrfs_mark_buffer_dirty(c);
 
-        spin_lock(&root->node_lock);
         old = root->node;
-        root->node = c;
-        spin_unlock(&root->node_lock);
+        rcu_assign_pointer(root->node, c);
 
         /* the super has an extra ref to root->node */
         free_extent_buffer(old);
@@ -3840,7 +3711,8 @@ int btrfs_insert_item(struct btrfs_trans_handle *trans, struct btrfs_root
         unsigned long ptr;
 
         path = btrfs_alloc_path();
-        BUG_ON(!path);
+        if (!path)
+                return -ENOMEM;
         ret = btrfs_insert_empty_item(trans, root, path, cpu_key, data_size);
         if (!ret) {
                 leaf = path->nodes[0];
@@ -4217,6 +4089,7 @@ find_next_key:
                 }
                 btrfs_set_path_blocking(path);
                 cur = read_node_slot(root, cur, slot);
+                BUG_ON(!cur);
 
                 btrfs_tree_lock(cur);
 
diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index 7f78cc78fdd0..d47ce8307854 100644
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -28,6 +28,7 @@
 #include <linux/wait.h>
 #include <linux/slab.h>
 #include <linux/kobject.h>
+#include <trace/events/btrfs.h>
 #include <asm/kmap_types.h>
 #include "extent_io.h"
 #include "extent_map.h"
@@ -40,6 +41,7 @@ extern struct kmem_cache *btrfs_trans_handle_cachep;
 extern struct kmem_cache *btrfs_transaction_cachep;
 extern struct kmem_cache *btrfs_bit_radix_cachep;
 extern struct kmem_cache *btrfs_path_cachep;
+extern struct kmem_cache *btrfs_free_space_cachep;
 struct btrfs_ordered_sum;
 
 #define BTRFS_MAGIC "_BHRfS_M"
@@ -782,9 +784,6 @@ struct btrfs_free_cluster {
         /* first extent starting offset */
         u64 window_start;
 
-        /* if this cluster simply points at a bitmap in the block group */
-        bool points_to_bitmap;
-
         struct btrfs_block_group_cache *block_group;
         /*
          * when a cluster is allocated from a block group, we put the
@@ -1283,6 +1282,7 @@ struct btrfs_root {
 #define BTRFS_INODE_NODUMP              (1 << 8)
 #define BTRFS_INODE_NOATIME             (1 << 9)
 #define BTRFS_INODE_DIRSYNC             (1 << 10)
+#define BTRFS_INODE_COMPRESS            (1 << 11)
 
 /* some macros to generate set/get funcs for the struct fields.  This
  * assumes there is a lefoo_to_cpu for every type, so lets make a simple
@@ -2157,6 +2157,8 @@ int btrfs_free_extent(struct btrfs_trans_handle *trans,
                       u64 root_objectid, u64 owner, u64 offset);
 
 int btrfs_free_reserved_extent(struct btrfs_root *root, u64 start, u64 len);
+int btrfs_update_reserved_bytes(struct btrfs_block_group_cache *cache,
+                                u64 num_bytes, int reserve, int sinfo);
 int btrfs_prepare_extent_commit(struct btrfs_trans_handle *trans,
                                 struct btrfs_root *root);
 int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans,
@@ -2227,10 +2229,12 @@ u64 btrfs_account_ro_block_groups_free_space(struct btrfs_space_info *sinfo);
 int btrfs_error_unpin_extent_range(struct btrfs_root *root,
                                    u64 start, u64 end);
 int btrfs_error_discard_extent(struct btrfs_root *root, u64 bytenr,
-                               u64 num_bytes);
+                               u64 num_bytes, u64 *actual_bytes);
 int btrfs_force_chunk_alloc(struct btrfs_trans_handle *trans,
                             struct btrfs_root *root, u64 type);
+int btrfs_trim_fs(struct btrfs_root *root, struct fstrim_range *range);
 
+int btrfs_init_space_info(struct btrfs_fs_info *fs_info);
 /* ctree.c */
 int btrfs_bin_search(struct extent_buffer *eb, struct btrfs_key *key,
                      int level, int *slot);
@@ -2392,6 +2396,9 @@ struct btrfs_dir_item *btrfs_lookup_xattr(struct btrfs_trans_handle *trans,
                                           struct btrfs_path *path, u64 dir,
                                           const char *name, u16 name_len,
                                           int mod);
+int verify_dir_item(struct btrfs_root *root,
+                    struct extent_buffer *leaf,
+                    struct btrfs_dir_item *dir_item);
 
 /* orphan.c */
 int btrfs_insert_orphan_item(struct btrfs_trans_handle *trans,
@@ -2528,7 +2535,7 @@ int btrfs_update_inode(struct btrfs_trans_handle *trans,
                               struct inode *inode);
 int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode);
 int btrfs_orphan_del(struct btrfs_trans_handle *trans, struct inode *inode);
-void btrfs_orphan_cleanup(struct btrfs_root *root);
+int btrfs_orphan_cleanup(struct btrfs_root *root);
 void btrfs_orphan_pre_snapshot(struct btrfs_trans_handle *trans,
                                 struct btrfs_pending_snapshot *pending,
                                 u64 *bytes_to_reserve);
@@ -2536,7 +2543,7 @@ void btrfs_orphan_post_snapshot(struct btrfs_trans_handle *trans,
                                 struct btrfs_pending_snapshot *pending);
 void btrfs_orphan_commit_root(struct btrfs_trans_handle *trans,
                               struct btrfs_root *root);
-int btrfs_cont_expand(struct inode *inode, loff_t size);
+int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size);
 int btrfs_invalidate_inodes(struct btrfs_root *root);
 void btrfs_add_delayed_iput(struct inode *inode);
 void btrfs_run_delayed_iputs(struct btrfs_root *root);
diff --git a/fs/btrfs/delayed-ref.c b/fs/btrfs/delayed-ref.c
index e807b143b857..bce28f653899 100644
--- a/fs/btrfs/delayed-ref.c
+++ b/fs/btrfs/delayed-ref.c
@@ -483,6 +483,8 @@ static noinline int add_delayed_ref_head(struct btrfs_trans_handle *trans,
         INIT_LIST_HEAD(&head_ref->cluster);
         mutex_init(&head_ref->mutex);
 
+        trace_btrfs_delayed_ref_head(ref, head_ref, action);
+
         existing = tree_insert(&delayed_refs->root, &ref->rb_node);
 
         if (existing) {
@@ -537,6 +539,8 @@ static noinline int add_delayed_tree_ref(struct btrfs_trans_handle *trans,
         }
         full_ref->level = level;
 
+        trace_btrfs_delayed_tree_ref(ref, full_ref, action);
+
         existing = tree_insert(&delayed_refs->root, &ref->rb_node);
 
         if (existing) {
@@ -591,6 +595,8 @@ static noinline int add_delayed_data_ref(struct btrfs_trans_handle *trans,
         full_ref->objectid = owner;
         full_ref->offset = offset;
 
+        trace_btrfs_delayed_data_ref(ref, full_ref, action);
+
         existing = tree_insert(&delayed_refs->root, &ref->rb_node);
 
         if (existing) {
diff --git a/fs/btrfs/dir-item.c b/fs/btrfs/dir-item.c
index f0cad5ae5be7..c62f02f6ae69 100644
--- a/fs/btrfs/dir-item.c
+++ b/fs/btrfs/dir-item.c
@@ -151,7 +151,7 @@ int btrfs_insert_dir_item(struct btrfs_trans_handle *trans, struct btrfs_root
                 ret = PTR_ERR(dir_item);
                 if (ret == -EEXIST)
                         goto second_insert;
-                goto out;
+                goto out_free;
         }
 
         leaf = path->nodes[0];
@@ -170,7 +170,7 @@ second_insert:
         /* FIXME, use some real flag for selecting the extra index */
         if (root == root->fs_info->tree_root) {
                 ret = 0;
-                goto out;
+                goto out_free;
         }
         btrfs_release_path(root, path);
 
@@ -180,7 +180,7 @@ second_insert:
                                         name, name_len);
         if (IS_ERR(dir_item)) {
                 ret2 = PTR_ERR(dir_item);
-                goto out;
+                goto out_free;
         }
         leaf = path->nodes[0];
         btrfs_cpu_key_to_disk(&disk_key, location);
@@ -192,7 +192,9 @@ second_insert:
         name_ptr = (unsigned long)(dir_item + 1);
         write_extent_buffer(leaf, name, name_ptr, name_len);
         btrfs_mark_buffer_dirty(leaf);
-out:
+
+out_free:
+
         btrfs_free_path(path);
         if (ret)
                 return ret;
@@ -377,6 +379,9 @@ struct btrfs_dir_item *btrfs_match_dir_item_name(struct btrfs_root *root,
 
         leaf = path->nodes[0];
         dir_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dir_item);
+        if (verify_dir_item(root, leaf, dir_item))
+                return NULL;
+
         total_len = btrfs_item_size_nr(leaf, path->slots[0]);
         while (cur < total_len) {
                 this_len = sizeof(*dir_item) +
@@ -429,3 +434,35 @@ int btrfs_delete_one_dir_name(struct btrfs_trans_handle *trans,
         }
         return ret;
 }
+
+int verify_dir_item(struct btrfs_root *root,
+                    struct extent_buffer *leaf,
+                    struct btrfs_dir_item *dir_item)
+{
+        u16 namelen = BTRFS_NAME_LEN;
+        u8 type = btrfs_dir_type(leaf, dir_item);
+
+        if (type >= BTRFS_FT_MAX) {
+                printk(KERN_CRIT "btrfs: invalid dir item type: %d\n",
+                       (int)type);
+                return 1;
+        }
+
+        if (type == BTRFS_FT_XATTR)
+                namelen = XATTR_NAME_MAX;
+
+        if (btrfs_dir_name_len(leaf, dir_item) > namelen) {
+                printk(KERN_CRIT "btrfS: invalid dir item name len: %u\n",
+                       (unsigned)btrfs_dir_data_len(leaf, dir_item));
+                return 1;
+        }
+
+        /* BTRFS_MAX_XATTR_SIZE is the same for all dir items */
+        if (btrfs_dir_data_len(leaf, dir_item) > BTRFS_MAX_XATTR_SIZE(root)) {
+                printk(KERN_CRIT "btrfs: invalid dir item data len: %u\n",
+                       (unsigned)btrfs_dir_data_len(leaf, dir_item));
+                return 1;
+        }
+
+        return 0;
+}
diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index 830d261d0e6b..d7a7315bd031 100644
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -29,6 +29,7 @@
 #include <linux/crc32c.h>
 #include <linux/slab.h>
 #include <linux/migrate.h>
+#include <asm/unaligned.h>
 #include "compat.h"
 #include "ctree.h"
 #include "disk-io.h"
@@ -198,7 +199,7 @@ u32 btrfs_csum_data(struct btrfs_root *root, char *data, u32 seed, size_t len)
 
 void btrfs_csum_final(u32 crc, char *result)
 {
-        *(__le32 *)result = ~cpu_to_le32(crc);
+        put_unaligned_le32(~crc, result);
 }
 
 /*
@@ -323,6 +324,7 @@ static int btree_read_extent_buffer_pages(struct btrfs_root *root,
         int num_copies = 0;
         int mirror_num = 0;
 
+        clear_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags);
         io_tree = &BTRFS_I(root->fs_info->btree_inode)->io_tree;
         while (1) {
                 ret = read_extent_buffer_pages(io_tree, eb, start, 1,
@@ -331,6 +333,14 @@ static int btree_read_extent_buffer_pages(struct btrfs_root *root,
                     !verify_parent_transid(io_tree, eb, parent_transid))
                         return ret;
 
+                /*
+                 * This buffer's crc is fine, but its contents are corrupted, so
+                 * there is no reason to read the other copies, they won't be
+                 * any less wrong.
+                 */
+                if (test_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags))
+                        return ret;
+
                 num_copies = btrfs_num_copies(&root->fs_info->mapping_tree,
                                               eb->start, eb->len);
                 if (num_copies == 1)
@@ -419,6 +429,73 @@ static int check_tree_block_fsid(struct btrfs_root *root,
         return ret;
 }
 
+#define CORRUPT(reason, eb, root, slot)                         \
+        printk(KERN_CRIT "btrfs: corrupt leaf, %s: block=%llu," \
+               "root=%llu, slot=%d\n", reason,                  \
+               (unsigned long long)btrfs_header_bytenr(eb),     \
+               (unsigned long long)root->objectid, slot)
+
+static noinline int check_leaf(struct btrfs_root *root,
+                               struct extent_buffer *leaf)
+{
+        struct btrfs_key key;
+        struct btrfs_key leaf_key;
+        u32 nritems = btrfs_header_nritems(leaf);
+        int slot;
+
+        if (nritems == 0)
+                return 0;
+
+        /* Check the 0 item */
+        if (btrfs_item_offset_nr(leaf, 0) + btrfs_item_size_nr(leaf, 0) !=
+            BTRFS_LEAF_DATA_SIZE(root)) {
+                CORRUPT("invalid item offset size pair", leaf, root, 0);
+                return -EIO;
+        }
+
+        /*
+         * Check to make sure each items keys are in the correct order and their
+         * offsets make sense.  We only have to loop through nritems-1 because
+         * we check the current slot against the next slot, which verifies the
+         * next slot's offset+size makes sense and that the current's slot
+         * offset is correct.
+         */
+        for (slot = 0; slot < nritems - 1; slot++) {
+                btrfs_item_key_to_cpu(leaf, &leaf_key, slot);
+                btrfs_item_key_to_cpu(leaf, &key, slot + 1);
+
+                /* Make sure the keys are in the right order */
+                if (btrfs_comp_cpu_keys(&leaf_key, &key) >= 0) {
+                        CORRUPT("bad key order", leaf, root, slot);
+                        return -EIO;
+                }
+
+                /*
+                 * Make sure the offset and ends are right, remember that the
+                 * item data starts at the end of the leaf and grows towards the
+                 * front.
+                 */
+                if (btrfs_item_offset_nr(leaf, slot) !=
+                        btrfs_item_end_nr(leaf, slot + 1)) {
+                        CORRUPT("slot offset bad", leaf, root, slot);
+                        return -EIO;
+                }
+
+                /*
+                 * Check to make sure that we don't point outside of the leaf,
+                 * just incase all the items are consistent to eachother, but
+                 * all point outside of the leaf.
+                 */
+                if (btrfs_item_end_nr(leaf, slot) >
+                    BTRFS_LEAF_DATA_SIZE(root)) {
+                        CORRUPT("slot end outside of leaf", leaf, root, slot);
+                        return -EIO;
+                }
+        }
+
+        return 0;
+}
+
 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 void btrfs_set_buffer_lockdep_class(struct extent_buffer *eb, int level)
 {
@@ -485,8 +562,20 @@ static int btree_readpage_end_io_hook(struct page *page, u64 start, u64 end,
         btrfs_set_buffer_lockdep_class(eb, found_level);
 
         ret = csum_tree_block(root, eb, 1);
-        if (ret)
+        if (ret) {
                 ret = -EIO;
+                goto err;
+        }
+
+        /*
+         * If this is a leaf block and it is corrupt, set the corrupt bit so
+         * that we don't try and read the other copies of this block, just
+         * return -EIO.
+         */
+        if (found_level == 0 && check_leaf(root, eb)) {
+                set_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags);
+                ret = -EIO;
+        }
 
         end = min_t(u64, eb->len, PAGE_CACHE_SIZE);
         end = eb->start + end - 1;
@@ -1159,7 +1248,10 @@ struct btrfs_root *btrfs_read_fs_root_no_radix(struct btrfs_root *tree_root,
                      root, fs_info, location->objectid);
 
         path = btrfs_alloc_path();
-        BUG_ON(!path);
+        if (!path) {
+                kfree(root);
+                return ERR_PTR(-ENOMEM);
+        }
         ret = btrfs_search_slot(NULL, tree_root, location, path, 0, 0);
         if (ret == 0) {
                 l = path->nodes[0];
@@ -1553,6 +1645,8 @@ struct btrfs_root *open_ctree(struct super_block *sb,
                 goto fail_bdi;
         }
 
+        fs_info->btree_inode->i_mapping->flags &= ~__GFP_FS;
+
         INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_ATOMIC);
         INIT_LIST_HEAD(&fs_info->trans_list);
         INIT_LIST_HEAD(&fs_info->dead_roots);
@@ -1683,6 +1777,12 @@ struct btrfs_root *open_ctree(struct super_block *sb,
 
         btrfs_check_super_valid(fs_info, sb->s_flags & MS_RDONLY);
 
+        /*
+         * In the long term, we'll store the compression type in the super
+         * block, and it'll be used for per file compression control.
+         */
+        fs_info->compress_type = BTRFS_COMPRESS_ZLIB;
+
         ret = btrfs_parse_options(tree_root, options);
         if (ret) {
                 err = ret;
@@ -1888,6 +1988,12 @@ struct btrfs_root *open_ctree(struct super_block *sb,
         fs_info->metadata_alloc_profile = (u64)-1;
         fs_info->system_alloc_profile = fs_info->metadata_alloc_profile;
 
+        ret = btrfs_init_space_info(fs_info);
+        if (ret) {
+                printk(KERN_ERR "Failed to initial space info: %d\n", ret);
+                goto fail_block_groups;
+        }
+
         ret = btrfs_read_block_groups(extent_root);
         if (ret) {
                 printk(KERN_ERR "Failed to read block groups: %d\n", ret);
@@ -1979,9 +2085,14 @@ struct btrfs_root *open_ctree(struct super_block *sb,
 
         if (!(sb->s_flags & MS_RDONLY)) {
                 down_read(&fs_info->cleanup_work_sem);
-                btrfs_orphan_cleanup(fs_info->fs_root);
-                btrfs_orphan_cleanup(fs_info->tree_root);
+                err = btrfs_orphan_cleanup(fs_info->fs_root);
+                if (!err)
+                        err = btrfs_orphan_cleanup(fs_info->tree_root);
                 up_read(&fs_info->cleanup_work_sem);
+                if (err) {
+                        close_ctree(tree_root);
+                        return ERR_PTR(err);
+                }
         }
 
         return tree_root;
@@ -2356,8 +2467,12 @@ int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info)
 
                 root_objectid = gang[ret - 1]->root_key.objectid + 1;
                 for (i = 0; i < ret; i++) {
+                        int err;
+
                         root_objectid = gang[i]->root_key.objectid;
-                        btrfs_orphan_cleanup(gang[i]);
+                        err = btrfs_orphan_cleanup(gang[i]);
+                        if (err)
+                                return err;
                 }
                 root_objectid++;
         }
@@ -2868,7 +2983,10 @@ static int btrfs_destroy_pinned_extent(struct btrfs_root *root,
                         break;
 
                 /* opt_discard */
-                ret = btrfs_error_discard_extent(root, start, end + 1 - start);
+                if (btrfs_test_opt(root, DISCARD))
+                        ret = btrfs_error_discard_extent(root, start,
+                                                         end + 1 - start,
+                                                         NULL);
 
                 clear_extent_dirty(unpin, start, end, GFP_NOFS);
                 btrfs_error_unpin_extent_range(root, start, end);
diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 7b3089b5c2df..f619c3cb13b7 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -36,8 +36,6 @@
 static int update_block_group(struct btrfs_trans_handle *trans,
                               struct btrfs_root *root,
                               u64 bytenr, u64 num_bytes, int alloc);
-static int update_reserved_bytes(struct btrfs_block_group_cache *cache,
-                                 u64 num_bytes, int reserve, int sinfo);
 static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
                                 struct btrfs_root *root,
                                 u64 bytenr, u64 num_bytes, u64 parent,
@@ -442,7 +440,7 @@ static int cache_block_group(struct btrfs_block_group_cache *cache,
          * allocate blocks for the tree root we can't do the fast caching since
          * we likely hold important locks.
          */
-        if (!trans->transaction->in_commit &&
+        if (trans && (!trans->transaction->in_commit) &&
             (root && root != root->fs_info->tree_root)) {
                 spin_lock(&cache->lock);
                 if (cache->cached != BTRFS_CACHE_NO) {
@@ -471,7 +469,7 @@ static int cache_block_group(struct btrfs_block_group_cache *cache,
         if (load_cache_only)
                 return 0;
 
-        caching_ctl = kzalloc(sizeof(*caching_ctl), GFP_KERNEL);
+        caching_ctl = kzalloc(sizeof(*caching_ctl), GFP_NOFS);
         BUG_ON(!caching_ctl);
 
         INIT_LIST_HEAD(&caching_ctl->list);
@@ -1740,39 +1738,45 @@ static int remove_extent_backref(struct btrfs_trans_handle *trans,
         return ret;
 }
 
-static void btrfs_issue_discard(struct block_device *bdev,
+static int btrfs_issue_discard(struct block_device *bdev,
                                 u64 start, u64 len)
 {
-        blkdev_issue_discard(bdev, start >> 9, len >> 9, GFP_KERNEL, 0);
+        return blkdev_issue_discard(bdev, start >> 9, len >> 9, GFP_NOFS, 0);
 }
 
 static int btrfs_discard_extent(struct btrfs_root *root, u64 bytenr,
-                                u64 num_bytes)
+                                u64 num_bytes, u64 *actual_bytes)
 {
         int ret;
-        u64 map_length = num_bytes;
+        u64 discarded_bytes = 0;
         struct btrfs_multi_bio *multi = NULL;
 
-        if (!btrfs_test_opt(root, DISCARD))
-                return 0;
 
         /* Tell the block device(s) that the sectors can be discarded */
-        ret = btrfs_map_block(&root->fs_info->mapping_tree, READ,
-                              bytenr, &map_length, &multi, 0);
+        ret = btrfs_map_block(&root->fs_info->mapping_tree, REQ_DISCARD,
+                              bytenr, &num_bytes, &multi, 0);
         if (!ret) {
                 struct btrfs_bio_stripe *stripe = multi->stripes;
                 int i;
 
-                if (map_length > num_bytes)
-                        map_length = num_bytes;
 
                 for (i = 0; i < multi->num_stripes; i++, stripe++) {
-                        btrfs_issue_discard(stripe->dev->bdev,
-                                            stripe->physical,
-                                            map_length);
+                        ret = btrfs_issue_discard(stripe->dev->bdev,
+                                                  stripe->physical,
+                                                  stripe->length);
+                        if (!ret)
+                                discarded_bytes += stripe->length;
+                        else if (ret != -EOPNOTSUPP)
+                                break;
                 }
                 kfree(multi);
         }
+        if (discarded_bytes && ret == -EOPNOTSUPP)
+                ret = 0;
+
+        if (actual_bytes)
+                *actual_bytes = discarded_bytes;
+
 
         return ret;
 }
@@ -3996,6 +4000,7 @@ int btrfs_delalloc_reserve_metadata(struct inode *inode, u64 num_bytes)
         struct btrfs_block_rsv *block_rsv = &root->fs_info->delalloc_block_rsv;
         u64 to_reserve;
         int nr_extents;
+        int reserved_extents;
         int ret;
 
         if (btrfs_transaction_in_commit(root->fs_info))
@@ -4003,25 +4008,24 @@ int btrfs_delalloc_reserve_metadata(struct inode *inode, u64 num_bytes)
 
         num_bytes = ALIGN(num_bytes, root->sectorsize);
 
-        spin_lock(&BTRFS_I(inode)->accounting_lock);
         nr_extents = atomic_read(&BTRFS_I(inode)->outstanding_extents) + 1;
-        if (nr_extents > BTRFS_I(inode)->reserved_extents) {
-                nr_extents -= BTRFS_I(inode)->reserved_extents;
+        reserved_extents = atomic_read(&BTRFS_I(inode)->reserved_extents);
+
+        if (nr_extents > reserved_extents) {
+                nr_extents -= reserved_extents;
                 to_reserve = calc_trans_metadata_size(root, nr_extents);
         } else {
                 nr_extents = 0;
                 to_reserve = 0;
         }
-        spin_unlock(&BTRFS_I(inode)->accounting_lock);
+
         to_reserve += calc_csum_metadata_size(inode, num_bytes);
         ret = reserve_metadata_bytes(NULL, root, block_rsv, to_reserve, 1);
         if (ret)
                 return ret;
 
-        spin_lock(&BTRFS_I(inode)->accounting_lock);
-        BTRFS_I(inode)->reserved_extents += nr_extents;
+        atomic_add(nr_extents, &BTRFS_I(inode)->reserved_extents);
         atomic_inc(&BTRFS_I(inode)->outstanding_extents);
-        spin_unlock(&BTRFS_I(inode)->accounting_lock);
 
         block_rsv_add_bytes(block_rsv, to_reserve, 1);
 
@@ -4036,20 +4040,30 @@ void btrfs_delalloc_release_metadata(struct inode *inode, u64 num_bytes)
         struct btrfs_root *root = BTRFS_I(inode)->root;
         u64 to_free;
         int nr_extents;
+        int reserved_extents;
 
         num_bytes = ALIGN(num_bytes, root->sectorsize);
         atomic_dec(&BTRFS_I(inode)->outstanding_extents);
         WARN_ON(atomic_read(&BTRFS_I(inode)->outstanding_extents) < 0);
 
-        spin_lock(&BTRFS_I(inode)->accounting_lock);
-        nr_extents = atomic_read(&BTRFS_I(inode)->outstanding_extents);
-        if (nr_extents < BTRFS_I(inode)->reserved_extents) {
-                nr_extents = BTRFS_I(inode)->reserved_extents - nr_extents;
-                BTRFS_I(inode)->reserved_extents -= nr_extents;
-        } else {
-                nr_extents = 0;
-        }
-        spin_unlock(&BTRFS_I(inode)->accounting_lock);
+        reserved_extents = atomic_read(&BTRFS_I(inode)->reserved_extents);
+        do {
+                int old, new;
+
+                nr_extents = atomic_read(&BTRFS_I(inode)->outstanding_extents);
+                if (nr_extents >= reserved_extents) {
+                        nr_extents = 0;
+                        break;
+                }
+                old = reserved_extents;
+                nr_extents = reserved_extents - nr_extents;
+                new = reserved_extents - nr_extents;
+                old = atomic_cmpxchg(&BTRFS_I(inode)->reserved_extents,
+                                     reserved_extents, new);
+                if (likely(old == reserved_extents))
+                        break;
+                reserved_extents = old;
+        } while (1);
 
         to_free = calc_csum_metadata_size(inode, num_bytes);
         if (nr_extents > 0)
@@ -4223,8 +4237,8 @@ int btrfs_pin_extent(struct btrfs_root *root,
  * update size of reserved extents. this function may return -EAGAIN
  * if 'reserve' is true or 'sinfo' is false.
  */
-static int update_reserved_bytes(struct btrfs_block_group_cache *cache,
-                                 u64 num_bytes, int reserve, int sinfo)
+int btrfs_update_reserved_bytes(struct btrfs_block_group_cache *cache,
+                                u64 num_bytes, int reserve, int sinfo)
 {
         int ret = 0;
         if (sinfo) {
@@ -4363,7 +4377,9 @@ int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans,
                 if (ret)
                         break;
 
-                ret = btrfs_discard_extent(root, start, end + 1 - start);
+                if (btrfs_test_opt(root, DISCARD))
+                        ret = btrfs_discard_extent(root, start,
+                                                   end + 1 - start, NULL);
 
                 clear_extent_dirty(unpin, start, end, GFP_NOFS);
                 unpin_extent_range(root, start, end);
@@ -4704,10 +4720,10 @@ void btrfs_free_tree_block(struct btrfs_trans_handle *trans,
                 WARN_ON(test_bit(EXTENT_BUFFER_DIRTY, &buf->bflags));
 
                 btrfs_add_free_space(cache, buf->start, buf->len);
-                ret = update_reserved_bytes(cache, buf->len, 0, 0);
+                ret = btrfs_update_reserved_bytes(cache, buf->len, 0, 0);
                 if (ret == -EAGAIN) {
                         /* block group became read-only */
-                        update_reserved_bytes(cache, buf->len, 0, 1);
+                        btrfs_update_reserved_bytes(cache, buf->len, 0, 1);
                         goto out;
                 }
 
@@ -4744,6 +4760,11 @@ pin:
                 }
         }
 out:
+        /*
+         * Deleting the buffer, clear the corrupt flag since it doesn't matter
+         * anymore.
+         */
+        clear_bit(EXTENT_BUFFER_CORRUPT, &buf->bflags);
         btrfs_put_block_group(cache);
 }
 
@@ -5191,7 +5212,7 @@ checks:
                                              search_start - offset);
                 BUG_ON(offset > search_start);
 
-                ret = update_reserved_bytes(block_group, num_bytes, 1,
+                ret = btrfs_update_reserved_bytes(block_group, num_bytes, 1,
                                             (data & BTRFS_BLOCK_GROUP_DATA));
                 if (ret == -EAGAIN) {
                         btrfs_add_free_space(block_group, offset, num_bytes);
@@ -5397,6 +5418,8 @@ again:
                 dump_space_info(sinfo, num_bytes, 1);
         }
 
+        trace_btrfs_reserved_extent_alloc(root, ins->objectid, ins->offset);
+
         return ret;
 }
 
@@ -5412,12 +5435,15 @@ int btrfs_free_reserved_extent(struct btrfs_root *root, u64 start, u64 len)
                 return -ENOSPC;
         }
 
-        ret = btrfs_discard_extent(root, start, len);
+        if (btrfs_test_opt(root, DISCARD))
+                ret = btrfs_discard_extent(root, start, len, NULL);
 
         btrfs_add_free_space(cache, start, len);
-        update_reserved_bytes(cache, len, 0, 1);
+        btrfs_update_reserved_bytes(cache, len, 0, 1);
         btrfs_put_block_group(cache);
 
+        trace_btrfs_reserved_extent_free(root, start, len);
+
         return ret;
 }
 
@@ -5444,7 +5470,8 @@ static int alloc_reserved_file_extent(struct btrfs_trans_handle *trans,
         size = sizeof(*extent_item) + btrfs_extent_inline_ref_size(type);
 
         path = btrfs_alloc_path();
-        BUG_ON(!path);
+        if (!path)
+                return -ENOMEM;
 
         path->leave_spinning = 1;
         ret = btrfs_insert_empty_item(trans, fs_info->extent_root, path,
@@ -5614,7 +5641,7 @@ int btrfs_alloc_logged_file_extent(struct btrfs_trans_handle *trans,
                 put_caching_control(caching_ctl);
         }
 
-        ret = update_reserved_bytes(block_group, ins->offset, 1, 1);
+        ret = btrfs_update_reserved_bytes(block_group, ins->offset, 1, 1);
         BUG_ON(ret);
         btrfs_put_block_group(block_group);
         ret = alloc_reserved_file_extent(trans, root, 0, root_objectid,
@@ -6047,6 +6074,8 @@ static noinline int do_walk_down(struct btrfs_trans_handle *trans,
                 if (reada && level == 1)
                         reada_walk_down(trans, root, wc, path);
                 next = read_tree_block(root, bytenr, blocksize, generation);
+                if (!next)
+                        return -EIO;
                 btrfs_tree_lock(next);
                 btrfs_set_lock_blocking(next);
         }
@@ -6438,10 +6467,14 @@ int btrfs_drop_subtree(struct btrfs_trans_handle *trans,
         BUG_ON(root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID);
 
         path = btrfs_alloc_path();
-        BUG_ON(!path);
+        if (!path)
+                return -ENOMEM;
 
         wc = kzalloc(sizeof(*wc), GFP_NOFS);
-        BUG_ON(!wc);
+        if (!wc) {
+                btrfs_free_path(path);
+                return -ENOMEM;
+        }
 
         btrfs_assert_tree_locked(parent);
         parent_level = btrfs_header_level(parent);
@@ -6899,7 +6932,11 @@ static noinline int get_new_locations(struct inode *reloc_inode,
         }
 
         path = btrfs_alloc_path();
-        BUG_ON(!path);
+        if (!path) {
+                if (exts != *extents)
+                        kfree(exts);
+                return -ENOMEM;
+        }
 
         cur_pos = extent_key->objectid - offset;
         last_byte = extent_key->objectid + extent_key->offset;
@@ -6941,6 +6978,10 @@ static noinline int get_new_locations(struct inode *reloc_inode,
                         struct disk_extent *old = exts;
                         max *= 2;
                         exts = kzalloc(sizeof(*exts) * max, GFP_NOFS);
+                        if (!exts) {
+                                ret = -ENOMEM;
+                                goto out;
+                        }
                         memcpy(exts, old, sizeof(*exts) * nr);
                         if (old != *extents)
                                 kfree(old);
@@ -7423,7 +7464,8 @@ static noinline int replace_extents_in_leaf(struct btrfs_trans_handle *trans,
         int ret;
 
         new_extent = kmalloc(sizeof(*new_extent), GFP_NOFS);
-        BUG_ON(!new_extent);
+        if (!new_extent)
+                return -ENOMEM;
 
         ref = btrfs_lookup_leaf_ref(root, leaf->start);
         BUG_ON(!ref);
@@ -7609,7 +7651,8 @@ int btrfs_cleanup_reloc_trees(struct btrfs_root *root)
 
         reloc_root = btrfs_read_fs_root_no_name(root->fs_info, &location);
         BUG_ON(!reloc_root);
-        btrfs_orphan_cleanup(reloc_root);
+        ret = btrfs_orphan_cleanup(reloc_root);
+        BUG_ON(ret);
         return 0;
 }
 
@@ -7627,7 +7670,8 @@ static noinline int init_reloc_tree(struct btrfs_trans_handle *trans,
                 return 0;
 
         root_item = kmalloc(sizeof(*root_item), GFP_NOFS);
-        BUG_ON(!root_item);
+        if (!root_item)
+                return -ENOMEM;
 
         ret = btrfs_copy_root(trans, root, root->commit_root,
                               &eb, BTRFS_TREE_RELOC_OBJECTID);
@@ -7653,7 +7697,7 @@ static noinline int init_reloc_tree(struct btrfs_trans_handle *trans,
 
         reloc_root = btrfs_read_fs_root_no_radix(root->fs_info->tree_root,
                                                  &root_key);
-        BUG_ON(!reloc_root);
+        BUG_ON(IS_ERR(reloc_root));
         reloc_root->last_trans = trans->transid;
         reloc_root->commit_root = NULL;
         reloc_root->ref_tree = &root->fs_info->reloc_ref_tree;
@@ -7906,6 +7950,10 @@ static noinline int relocate_one_extent(struct btrfs_root *extent_root,
 
                         eb = read_tree_block(found_root, block_start,
                                              block_size, 0);
+                        if (!eb) {
+                                ret = -EIO;
+                                goto out;
+                        }
                         btrfs_tree_lock(eb);
                         BUG_ON(level != btrfs_header_level(eb));
 
@@ -8621,6 +8669,12 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans,
         BUG_ON(!block_group);
         BUG_ON(!block_group->ro);
 
+        /*
+         * Free the reserved super bytes from this block group before
+         * remove it.
+         */
+        free_excluded_extents(root, block_group);
+
         memcpy(&key, &block_group->key, sizeof(key));
         if (block_group->flags & (BTRFS_BLOCK_GROUP_DUP |
                                   BTRFS_BLOCK_GROUP_RAID1 |
@@ -8724,13 +8778,84 @@ out:
         return ret;
 }
 
+int btrfs_init_space_info(struct btrfs_fs_info *fs_info)
+{
+        struct btrfs_space_info *space_info;
+        int ret;
+
+        ret = update_space_info(fs_info, BTRFS_BLOCK_GROUP_SYSTEM, 0, 0,
+                                                                 &space_info);
+        if (ret)
+                return ret;
+
+        ret = update_space_info(fs_info, BTRFS_BLOCK_GROUP_METADATA, 0, 0,
+                                                                 &space_info);
+        if (ret)
+                return ret;
+
+        ret = update_space_info(fs_info, BTRFS_BLOCK_GROUP_DATA, 0, 0,
+                                                                 &space_info);
+        if (ret)
+                return ret;
+
+        return ret;
+}
+
 int btrfs_error_unpin_extent_range(struct btrfs_root *root, u64 start, u64 end)
 {
         return unpin_extent_range(root, start, end);
 }
 
 int btrfs_error_discard_extent(struct btrfs_root *root, u64 bytenr,
-                               u64 num_bytes)
+                               u64 num_bytes, u64 *actual_bytes)
+{
+        return btrfs_discard_extent(root, bytenr, num_bytes, actual_bytes);
+}
+
+int btrfs_trim_fs(struct btrfs_root *root, struct fstrim_range *range)
 {
-        return btrfs_discard_extent(root, bytenr, num_bytes);
+        struct btrfs_fs_info *fs_info = root->fs_info;
+        struct btrfs_block_group_cache *cache = NULL;
+        u64 group_trimmed;
+        u64 start;
+        u64 end;
+        u64 trimmed = 0;
+        int ret = 0;
+
+        cache = btrfs_lookup_block_group(fs_info, range->start);
+
+        while (cache) {
+                if (cache->key.objectid >= (range->start + range->len)) {
+                        btrfs_put_block_group(cache);
+                        break;
+                }
+
+                start = max(range->start, cache->key.objectid);
+                end = min(range->start + range->len,
+                                cache->key.objectid + cache->key.offset);
+
+                if (end - start >= range->minlen) {
+                        if (!block_group_cache_done(cache)) {
+                                ret = cache_block_group(cache, NULL, root, 0);
+                                if (!ret)
+                                        wait_block_group_cache_done(cache);
+                        }
+                        ret = btrfs_trim_block_group(cache,
+                                                     &group_trimmed,
+                                                     start,
+                                                     end,
+                                                     range->minlen);
+
+                        trimmed += group_trimmed;
+                        if (ret) {
+                                btrfs_put_block_group(cache);
+                                break;
+                        }
+                }
+
+                cache = next_block_group(fs_info->tree_root, cache);
+        }
+
+        range->len = trimmed;
+        return ret;
 }
diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index b5b92824a271..20ddb28602a8 100644
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -2192,6 +2192,8 @@ static int __extent_writepage(struct page *page, struct writeback_control *wbc,
         else
                 write_flags = WRITE;
 
+        trace___extent_writepage(page, inode, wbc);
+
         WARN_ON(!PageLocked(page));
         pg_offset = i_size & (PAGE_CACHE_SIZE - 1);
         if (page->index > end_index ||
@@ -3690,6 +3692,7 @@ int map_private_extent_buffer(struct extent_buffer *eb, unsigned long start,
                        "wanted %lu %lu\n", (unsigned long long)eb->start,
                        eb->len, start, min_len);
                 WARN_ON(1);
+                return -EINVAL;
         }
 
         p = extent_buffer_page(eb, i);
diff --git a/fs/btrfs/extent_io.h b/fs/btrfs/extent_io.h
index 9318dfefd59c..f62c5442835d 100644
--- a/fs/btrfs/extent_io.h
+++ b/fs/btrfs/extent_io.h
@@ -31,6 +31,7 @@
 #define EXTENT_BUFFER_UPTODATE 0
 #define EXTENT_BUFFER_BLOCKING 1
 #define EXTENT_BUFFER_DIRTY 2
+#define EXTENT_BUFFER_CORRUPT 3
 
 /* these are flags for extent_clear_unlock_delalloc */
 #define EXTENT_CLEAR_UNLOCK_PAGE 0x1
diff --git a/fs/btrfs/file-item.c b/fs/btrfs/file-item.c
index 4f19a3e1bf32..a6a9d4e8b491 100644
--- a/fs/btrfs/file-item.c
+++ b/fs/btrfs/file-item.c
@@ -48,7 +48,8 @@ int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
         struct extent_buffer *leaf;
 
         path = btrfs_alloc_path();
-        BUG_ON(!path);
+        if (!path)
+                return -ENOMEM;
         file_key.objectid = objectid;
         file_key.offset = pos;
         btrfs_set_key_type(&file_key, BTRFS_EXTENT_DATA_KEY);
@@ -169,6 +170,8 @@ static int __btrfs_lookup_bio_sums(struct btrfs_root *root,
         struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
 
         path = btrfs_alloc_path();
+        if (!path)
+                return -ENOMEM;
         if (bio->bi_size > PAGE_CACHE_SIZE * 8)
                 path->reada = 2;
 
diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index f447b783bb84..656bc0a892b1 100644
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -45,14 +45,14 @@
  * and be replaced with calls into generic code.
  */
 static noinline int btrfs_copy_from_user(loff_t pos, int num_pages,
-                                         int write_bytes,
+                                         size_t write_bytes,
                                          struct page **prepared_pages,
                                          struct iov_iter *i)
 {
         size_t copied = 0;
+        size_t total_copied = 0;
         int pg = 0;
         int offset = pos & (PAGE_CACHE_SIZE - 1);
-        int total_copied = 0;
 
         while (write_bytes > 0) {
                 size_t count = min_t(size_t,
@@ -88,9 +88,8 @@ static noinline int btrfs_copy_from_user(loff_t pos, int num_pages,
                 total_copied += copied;
 
                 /* Return to btrfs_file_aio_write to fault page */
-                if (unlikely(copied == 0)) {
+                if (unlikely(copied == 0))
                         break;
-                }
 
                 if (unlikely(copied < PAGE_CACHE_SIZE - offset)) {
                         offset += copied;
@@ -109,8 +108,6 @@ static noinline void btrfs_drop_pages(struct page **pages, size_t num_pages)
 {
         size_t i;
         for (i = 0; i < num_pages; i++) {
-                if (!pages[i])
-                        break;
                 /* page checked is some magic around finding pages that
                  * have been modified without going through btrfs_set_page_dirty
                  * clear it here
@@ -130,13 +127,12 @@ static noinline void btrfs_drop_pages(struct page **pages, size_t num_pages)
  * this also makes the decision about creating an inline extent vs
  * doing real data extents, marking pages dirty and delalloc as required.
  */
-static noinline int dirty_and_release_pages(struct btrfs_trans_handle *trans,
-                                   struct btrfs_root *root,
-                                   struct file *file,
-                                   struct page **pages,
-                                   size_t num_pages,
-                                   loff_t pos,
-                                   size_t write_bytes)
+static noinline int dirty_and_release_pages(struct btrfs_root *root,
+                                            struct file *file,
+                                            struct page **pages,
+                                            size_t num_pages,
+                                            loff_t pos,
+                                            size_t write_bytes)
 {
         int err = 0;
         int i;
@@ -154,7 +150,8 @@ static noinline int dirty_and_release_pages(struct btrfs_trans_handle *trans,
         end_of_last_block = start_pos + num_bytes - 1;
         err = btrfs_set_extent_delalloc(inode, start_pos, end_of_last_block,
                                         NULL);
-        BUG_ON(err);
+        if (err)
+                return err;
 
         for (i = 0; i < num_pages; i++) {
                 struct page *p = pages[i];
@@ -162,13 +159,14 @@ static noinline int dirty_and_release_pages(struct btrfs_trans_handle *trans,
                 ClearPageChecked(p);
                 set_page_dirty(p);
         }
-        if (end_pos > isize) {
+
+        /*
+         * we've only changed i_size in ram, and we haven't updated
+         * the disk i_size.  There is no need to log the inode
+         * at this time.
+         */
+        if (end_pos > isize)
                 i_size_write(inode, end_pos);
-                /* we've only changed i_size in ram, and we haven't updated
-                 * the disk i_size.  There is no need to log the inode
-                 * at this time.
-                 */
-        }
         return 0;
 }
 
@@ -610,6 +608,8 @@ again:
         key.offset = split;
 
         ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
+        if (ret < 0)
+                goto out;
         if (ret > 0 && path->slots[0] > 0)
                 path->slots[0]--;
 
@@ -819,12 +819,11 @@ static noinline int prepare_pages(struct btrfs_root *root, struct file *file,
         last_pos = ((u64)index + num_pages) << PAGE_CACHE_SHIFT;
 
         if (start_pos > inode->i_size) {
-                err = btrfs_cont_expand(inode, start_pos);
+                err = btrfs_cont_expand(inode, i_size_read(inode), start_pos);
                 if (err)
                         return err;
         }
 
-        memset(pages, 0, num_pages * sizeof(struct page *));
 again:
         for (i = 0; i < num_pages; i++) {
                 pages[i] = grab_cache_page(inode->i_mapping, index + i);
@@ -896,156 +895,71 @@ fail:
 
 }
 
-static ssize_t btrfs_file_aio_write(struct kiocb *iocb,
-                                    const struct iovec *iov,
-                                    unsigned long nr_segs, loff_t pos)
+static noinline ssize_t __btrfs_buffered_write(struct file *file,
+                                               struct iov_iter *i,
+                                               loff_t pos)
 {
-        struct file *file = iocb->ki_filp;
         struct inode *inode = fdentry(file)->d_inode;
         struct btrfs_root *root = BTRFS_I(inode)->root;
         struct page **pages = NULL;
-        struct iov_iter i;
-        loff_t *ppos = &iocb->ki_pos;
-        loff_t start_pos;
-        ssize_t num_written = 0;
-        ssize_t err = 0;
-        size_t count;
-        size_t ocount;
-        int ret = 0;
-        int nrptrs;
         unsigned long first_index;
         unsigned long last_index;
-        int will_write;
-        int buffered = 0;
-        int copied = 0;
-        int dirty_pages = 0;
-
-        will_write = ((file->f_flags & O_DSYNC) || IS_SYNC(inode) ||
-                      (file->f_flags & O_DIRECT));
-
-        start_pos = pos;
-
-        vfs_check_frozen(inode->i_sb, SB_FREEZE_WRITE);
-
-        mutex_lock(&inode->i_mutex);
-
-        err = generic_segment_checks(iov, &nr_segs, &ocount, VERIFY_READ);
-        if (err)
-                goto out;
-        count = ocount;
-
-        current->backing_dev_info = inode->i_mapping->backing_dev_info;
-        err = generic_write_checks(file, &pos, &count, S_ISBLK(inode->i_mode));
-        if (err)
-                goto out;
-
-        if (count == 0)
-                goto out;
-
-        err = file_remove_suid(file);
-        if (err)
-                goto out;
-
-        /*
-         * If BTRFS flips readonly due to some impossible error
-         * (fs_info->fs_state now has BTRFS_SUPER_FLAG_ERROR),
-         * although we have opened a file as writable, we have
-         * to stop this write operation to ensure FS consistency.
-         */
-        if (root->fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) {
-                err = -EROFS;
-                goto out;
-        }
-
-        file_update_time(file);
-        BTRFS_I(inode)->sequence++;
-
-        if (unlikely(file->f_flags & O_DIRECT)) {
-                num_written = generic_file_direct_write(iocb, iov, &nr_segs,
-                                                        pos, ppos, count,
-                                                        ocount);
-                /*
-                 * the generic O_DIRECT will update in-memory i_size after the
-                 * DIOs are done.  But our endio handlers that update the on
-                 * disk i_size never update past the in memory i_size.  So we
-                 * need one more update here to catch any additions to the
-                 * file
-                 */
-                if (inode->i_size != BTRFS_I(inode)->disk_i_size) {
-                        btrfs_ordered_update_i_size(inode, inode->i_size, NULL);
-                        mark_inode_dirty(inode);
-                }
-
-                if (num_written < 0) {
-                        ret = num_written;
-                        num_written = 0;
-                        goto out;
-                } else if (num_written == count) {
-                        /* pick up pos changes done by the generic code */
-                        pos = *ppos;
-                        goto out;
-                }
-                /*
-                 * We are going to do buffered for the rest of the range, so we
-                 * need to make sure to invalidate the buffered pages when we're
-                 * done.
-                 */
-                buffered = 1;
-                pos += num_written;
-        }
+        size_t num_written = 0;
+        int nrptrs;
+        int ret;
 
-        iov_iter_init(&i, iov, nr_segs, count, num_written);
-        nrptrs = min((iov_iter_count(&i) + PAGE_CACHE_SIZE - 1) /
+        nrptrs = min((iov_iter_count(i) + PAGE_CACHE_SIZE - 1) /
                      PAGE_CACHE_SIZE, PAGE_CACHE_SIZE /
                      (sizeof(struct page *)));
         pages = kmalloc(nrptrs * sizeof(struct page *), GFP_KERNEL);
-        if (!pages) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        /* generic_write_checks can change our pos */
-        start_pos = pos;
+        if (!pages)
+                return -ENOMEM;
 
         first_index = pos >> PAGE_CACHE_SHIFT;
-        last_index = (pos + iov_iter_count(&i)) >> PAGE_CACHE_SHIFT;
+        last_index = (pos + iov_iter_count(i)) >> PAGE_CACHE_SHIFT;
 
-        while (iov_iter_count(&i) > 0) {
+        while (iov_iter_count(i) > 0) {
                 size_t offset = pos & (PAGE_CACHE_SIZE - 1);
-                size_t write_bytes = min(iov_iter_count(&i),
+                size_t write_bytes = min(iov_iter_count(i),
                                          nrptrs * (size_t)PAGE_CACHE_SIZE -
                                          offset);
                 size_t num_pages = (write_bytes + offset +
                                     PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
+                size_t dirty_pages;
+                size_t copied;
 
                 WARN_ON(num_pages > nrptrs);
-                memset(pages, 0, sizeof(struct page *) * nrptrs);
 
                 /*
                  * Fault pages before locking them in prepare_pages
                  * to avoid recursive lock
                  */
-                if (unlikely(iov_iter_fault_in_readable(&i, write_bytes))) {
+                if (unlikely(iov_iter_fault_in_readable(i, write_bytes))) {
                         ret = -EFAULT;
-                        goto out;
+                        break;
                 }
 
                 ret = btrfs_delalloc_reserve_space(inode,
                                         num_pages << PAGE_CACHE_SHIFT);
                 if (ret)
-                        goto out;
+                        break;
 
+                /*
+                 * This is going to setup the pages array with the number of
+                 * pages we want, so we don't really need to worry about the
+                 * contents of pages from loop to loop
+                 */
                 ret = prepare_pages(root, file, pages, num_pages,
                                     pos, first_index, last_index,
                                     write_bytes);
                 if (ret) {
                         btrfs_delalloc_release_space(inode,
                                         num_pages << PAGE_CACHE_SHIFT);
-                        goto out;
+                        break;
                 }
 
                 copied = btrfs_copy_from_user(pos, num_pages,
-                                           write_bytes, pages, &i);
+                                           write_bytes, pages, i);
 
                 /*
                  * if we have trouble faulting in the pages, fall
@@ -1061,6 +975,13 @@ static ssize_t btrfs_file_aio_write(struct kiocb *iocb,
                                        PAGE_CACHE_SIZE - 1) >>
                                        PAGE_CACHE_SHIFT;
 
+                /*
+                 * If we had a short copy we need to release the excess delaloc
+                 * bytes we reserved.  We need to increment outstanding_extents
+                 * because btrfs_delalloc_release_space will decrement it, but
+                 * we still have an outstanding extent for the chunk we actually
+                 * managed to copy.
+                 */
                 if (num_pages > dirty_pages) {
                         if (copied > 0)
                                 atomic_inc(
@@ -1071,39 +992,157 @@ static ssize_t btrfs_file_aio_write(struct kiocb *iocb,
                 }
 
                 if (copied > 0) {
-                        dirty_and_release_pages(NULL, root, file, pages,
-                                                dirty_pages, pos, copied);
+                        ret = dirty_and_release_pages(root, file, pages,
+                                                      dirty_pages, pos,
+                                                      copied);
+                        if (ret) {
+                                btrfs_delalloc_release_space(inode,
+                                        dirty_pages << PAGE_CACHE_SHIFT);
+                                btrfs_drop_pages(pages, num_pages);
+                                break;
+                        }
                 }
 
                 btrfs_drop_pages(pages, num_pages);
 
-                if (copied > 0) {
-                        if (will_write) {
-                                filemap_fdatawrite_range(inode->i_mapping, pos,
-                                                         pos + copied - 1);
-                        } else {
-                                balance_dirty_pages_ratelimited_nr(
-                                                        inode->i_mapping,
-                                                        dirty_pages);
-                                if (dirty_pages <
-                                (root->leafsize >> PAGE_CACHE_SHIFT) + 1)
-                                        btrfs_btree_balance_dirty(root, 1);
-                                btrfs_throttle(root);
-                        }
-                }
+                cond_resched();
+
+                balance_dirty_pages_ratelimited_nr(inode->i_mapping,
+                                                   dirty_pages);
+                if (dirty_pages < (root->leafsize >> PAGE_CACHE_SHIFT) + 1)
+                        btrfs_btree_balance_dirty(root, 1);
+                btrfs_throttle(root);
 
                 pos += copied;
                 num_written += copied;
+        }
 
-                cond_resched();
+        kfree(pages);
+
+        return num_written ? num_written : ret;
+}
+
+static ssize_t __btrfs_direct_write(struct kiocb *iocb,
+                                    const struct iovec *iov,
+                                    unsigned long nr_segs, loff_t pos,
+                                    loff_t *ppos, size_t count, size_t ocount)
+{
+        struct file *file = iocb->ki_filp;
+        struct inode *inode = fdentry(file)->d_inode;
+        struct iov_iter i;
+        ssize_t written;
+        ssize_t written_buffered;
+        loff_t endbyte;
+        int err;
+
+        written = generic_file_direct_write(iocb, iov, &nr_segs, pos, ppos,
+                                            count, ocount);
+
+        /*
+         * the generic O_DIRECT will update in-memory i_size after the
+         * DIOs are done.  But our endio handlers that update the on
+         * disk i_size never update past the in memory i_size.  So we
+         * need one more update here to catch any additions to the
+         * file
+         */
+        if (inode->i_size != BTRFS_I(inode)->disk_i_size) {
+                btrfs_ordered_update_i_size(inode, inode->i_size, NULL);
+                mark_inode_dirty(inode);
         }
+
+        if (written < 0 || written == count)
+                return written;
+
+        pos += written;
+        count -= written;
+        iov_iter_init(&i, iov, nr_segs, count, written);
+        written_buffered = __btrfs_buffered_write(file, &i, pos);
+        if (written_buffered < 0) {
+                err = written_buffered;
+                goto out;
+        }
+        endbyte = pos + written_buffered - 1;
+        err = filemap_write_and_wait_range(file->f_mapping, pos, endbyte);
+        if (err)
+                goto out;
+        written += written_buffered;
+        *ppos = pos + written_buffered;
+        invalidate_mapping_pages(file->f_mapping, pos >> PAGE_CACHE_SHIFT,
+                                 endbyte >> PAGE_CACHE_SHIFT);
 out:
-        mutex_unlock(&inode->i_mutex);
-        if (ret)
-                err = ret;
+        return written ? written : err;
+}
 
-        kfree(pages);
-        *ppos = pos;
+static ssize_t btrfs_file_aio_write(struct kiocb *iocb,
+                                    const struct iovec *iov,
+                                    unsigned long nr_segs, loff_t pos)
+{
+        struct file *file = iocb->ki_filp;
+        struct inode *inode = fdentry(file)->d_inode;
+        struct btrfs_root *root = BTRFS_I(inode)->root;
+        loff_t *ppos = &iocb->ki_pos;
+        ssize_t num_written = 0;
+        ssize_t err = 0;
+        size_t count, ocount;
+
+        vfs_check_frozen(inode->i_sb, SB_FREEZE_WRITE);
+
+        mutex_lock(&inode->i_mutex);
+
+        err = generic_segment_checks(iov, &nr_segs, &ocount, VERIFY_READ);
+        if (err) {
+                mutex_unlock(&inode->i_mutex);
+                goto out;
+        }
+        count = ocount;
+
+        current->backing_dev_info = inode->i_mapping->backing_dev_info;
+        err = generic_write_checks(file, &pos, &count, S_ISBLK(inode->i_mode));
+        if (err) {
+                mutex_unlock(&inode->i_mutex);
+                goto out;
+        }
+
+        if (count == 0) {
+                mutex_unlock(&inode->i_mutex);
+                goto out;
+        }
+
+        err = file_remove_suid(file);
+        if (err) {
+                mutex_unlock(&inode->i_mutex);
+                goto out;
+        }
+
+        /*
+         * If BTRFS flips readonly due to some impossible error
+         * (fs_info->fs_state now has BTRFS_SUPER_FLAG_ERROR),
+         * although we have opened a file as writable, we have
+         * to stop this write operation to ensure FS consistency.
+         */
+        if (root->fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) {
+                mutex_unlock(&inode->i_mutex);
+                err = -EROFS;
+                goto out;
+        }
+
+        file_update_time(file);
+        BTRFS_I(inode)->sequence++;
+
+        if (unlikely(file->f_flags & O_DIRECT)) {
+                num_written = __btrfs_direct_write(iocb, iov, nr_segs,
+                                                   pos, ppos, count, ocount);
+        } else {
+                struct iov_iter i;
+
+                iov_iter_init(&i, iov, nr_segs, count, num_written);
+
+                num_written = __btrfs_buffered_write(file, &i, pos);
+                if (num_written > 0)
+                        *ppos = pos + num_written;
+        }
+
+        mutex_unlock(&inode->i_mutex);
 
         /*
          * we want to make sure fsync finds this change
@@ -1118,43 +1157,12 @@ out:
          * one running right now.
          */
         BTRFS_I(inode)->last_trans = root->fs_info->generation + 1;
-
-        if (num_written > 0 && will_write) {
-                struct btrfs_trans_handle *trans;
-
-                err = btrfs_wait_ordered_range(inode, start_pos, num_written);
-                if (err)
+        if (num_written > 0 || num_written == -EIOCBQUEUED) {
+                err = generic_write_sync(file, pos, num_written);
+                if (err < 0 && num_written > 0)
                         num_written = err;
-
-                if ((file->f_flags & O_DSYNC) || IS_SYNC(inode)) {
-                        trans = btrfs_start_transaction(root, 0);
-                        if (IS_ERR(trans)) {
-                                num_written = PTR_ERR(trans);
-                                goto done;
-                        }
-                        mutex_lock(&inode->i_mutex);
-                        ret = btrfs_log_dentry_safe(trans, root,
-                                                    file->f_dentry);
-                        mutex_unlock(&inode->i_mutex);
-                        if (ret == 0) {
-                                ret = btrfs_sync_log(trans, root);
-                                if (ret == 0)
-                                        btrfs_end_transaction(trans, root);
-                                else
-                                        btrfs_commit_transaction(trans, root);
-                        } else if (ret != BTRFS_NO_LOG_SYNC) {
-                                btrfs_commit_transaction(trans, root);
-                        } else {
-                                btrfs_end_transaction(trans, root);
-                        }
-                }
-                if (file->f_flags & O_DIRECT && buffered) {
-                        invalidate_mapping_pages(inode->i_mapping,
-                              start_pos >> PAGE_CACHE_SHIFT,
-                             (start_pos + num_written - 1) >> PAGE_CACHE_SHIFT);
-                }
         }
-done:
+out:
         current->backing_dev_info = NULL;
         return num_written ? num_written : err;
 }
@@ -1197,6 +1205,7 @@ int btrfs_sync_file(struct file *file, int datasync)
         int ret = 0;
         struct btrfs_trans_handle *trans;
 
+        trace_btrfs_sync_file(file, datasync);
 
         /* we wait first, since the writeback may change the inode */
         root->log_batch++;
@@ -1324,7 +1333,8 @@ static long btrfs_fallocate(struct file *file, int mode,
                 goto out;
 
         if (alloc_start > inode->i_size) {
-                ret = btrfs_cont_expand(inode, alloc_start);
+                ret = btrfs_cont_expand(inode, i_size_read(inode),
+                                        alloc_start);
                 if (ret)
                         goto out;
         }
diff --git a/fs/btrfs/free-space-cache.c b/fs/btrfs/free-space-cache.c
index a0390657451b..0037427d8a9d 100644
--- a/fs/btrfs/free-space-cache.c
+++ b/fs/btrfs/free-space-cache.c
@@ -393,7 +393,8 @@ int load_free_space_cache(struct btrfs_fs_info *fs_info,
                                 break;
 
                         need_loop = 1;
-                        e = kzalloc(sizeof(struct btrfs_free_space), GFP_NOFS);
+                        e = kmem_cache_zalloc(btrfs_free_space_cachep,
+                                              GFP_NOFS);
                         if (!e) {
                                 kunmap(page);
                                 unlock_page(page);
@@ -405,7 +406,7 @@ int load_free_space_cache(struct btrfs_fs_info *fs_info,
                         e->bytes = le64_to_cpu(entry->bytes);
                         if (!e->bytes) {
                                 kunmap(page);
-                                kfree(e);
+                                kmem_cache_free(btrfs_free_space_cachep, e);
                                 unlock_page(page);
                                 page_cache_release(page);
                                 goto free_cache;
@@ -420,7 +421,8 @@ int load_free_space_cache(struct btrfs_fs_info *fs_info,
                                 e->bitmap = kzalloc(PAGE_CACHE_SIZE, GFP_NOFS);
                                 if (!e->bitmap) {
                                         kunmap(page);
-                                        kfree(e);
+                                        kmem_cache_free(
+                                                btrfs_free_space_cachep, e);
                                         unlock_page(page);
                                         page_cache_release(page);
                                         goto free_cache;
@@ -1187,7 +1189,7 @@ static void free_bitmap(struct btrfs_block_group_cache *block_group,
 {
         unlink_free_space(block_group, bitmap_info);
         kfree(bitmap_info->bitmap);
-        kfree(bitmap_info);
+        kmem_cache_free(btrfs_free_space_cachep, bitmap_info);
         block_group->total_bitmaps--;
         recalculate_thresholds(block_group);
 }
@@ -1285,9 +1287,22 @@ static int insert_into_bitmap(struct btrfs_block_group_cache *block_group,
          * If we are below the extents threshold then we can add this as an
          * extent, and don't have to deal with the bitmap
          */
-        if (block_group->free_extents < block_group->extents_thresh &&
-            info->bytes > block_group->sectorsize * 4)
-                return 0;
+        if (block_group->free_extents < block_group->extents_thresh) {
+                /*
+                 * If this block group has some small extents we don't want to
+                 * use up all of our free slots in the cache with them, we want
+                 * to reserve them to larger extents, however if we have plent
+                 * of cache left then go ahead an dadd them, no sense in adding
+                 * the overhead of a bitmap if we don't have to.
+                 */
+                if (info->bytes <= block_group->sectorsize * 4) {
+                        if (block_group->free_extents * 2 <=
+                            block_group->extents_thresh)
+                                return 0;
+                } else {
+                        return 0;
+                }
+        }
 
         /*
          * some block groups are so tiny they can't be enveloped by a bitmap, so
@@ -1342,8 +1357,8 @@ new_bitmap:
 
                 /* no pre-allocated info, allocate a new one */
                 if (!info) {
-                        info = kzalloc(sizeof(struct btrfs_free_space),
-                                       GFP_NOFS);
+                        info = kmem_cache_zalloc(btrfs_free_space_cachep,
+                                                 GFP_NOFS);
                         if (!info) {
                                 spin_lock(&block_group->tree_lock);
                                 ret = -ENOMEM;
@@ -1365,7 +1380,7 @@ out:
         if (info) {
                 if (info->bitmap)
                         kfree(info->bitmap);
-                kfree(info);
+                kmem_cache_free(btrfs_free_space_cachep, info);
         }
 
         return ret;
@@ -1398,7 +1413,7 @@ bool try_merge_free_space(struct btrfs_block_group_cache *block_group,
                 else
                         __unlink_free_space(block_group, right_info);
                 info->bytes += right_info->bytes;
-                kfree(right_info);
+                kmem_cache_free(btrfs_free_space_cachep, right_info);
                 merged = true;
         }
 
@@ -1410,7 +1425,7 @@ bool try_merge_free_space(struct btrfs_block_group_cache *block_group,
                         __unlink_free_space(block_group, left_info);
                 info->offset = left_info->offset;
                 info->bytes += left_info->bytes;
-                kfree(left_info);
+                kmem_cache_free(btrfs_free_space_cachep, left_info);
                 merged = true;
         }
 
@@ -1423,7 +1438,7 @@ int btrfs_add_free_space(struct btrfs_block_group_cache *block_group,
         struct btrfs_free_space *info;
         int ret = 0;
 
-        info = kzalloc(sizeof(struct btrfs_free_space), GFP_NOFS);
+        info = kmem_cache_zalloc(btrfs_free_space_cachep, GFP_NOFS);
         if (!info)
                 return -ENOMEM;
 
@@ -1450,7 +1465,7 @@ int btrfs_add_free_space(struct btrfs_block_group_cache *block_group,
 link:
         ret = link_free_space(block_group, info);
         if (ret)
-                kfree(info);
+                kmem_cache_free(btrfs_free_space_cachep, info);
 out:
         spin_unlock(&block_group->tree_lock);
 
@@ -1520,7 +1535,7 @@ again:
                         kfree(info->bitmap);
                         block_group->total_bitmaps--;
                 }
-                kfree(info);
+                kmem_cache_free(btrfs_free_space_cachep, info);
                 goto out_lock;
         }
 
@@ -1556,7 +1571,7 @@ again:
                         /* the hole we're creating ends at the end
                          * of the info struct, just free the info
                          */
-                        kfree(info);
+                        kmem_cache_free(btrfs_free_space_cachep, info);
                 }
                 spin_unlock(&block_group->tree_lock);
 
@@ -1629,30 +1644,28 @@ __btrfs_return_cluster_to_free_space(
 {
         struct btrfs_free_space *entry;
         struct rb_node *node;
-        bool bitmap;
 
         spin_lock(&cluster->lock);
         if (cluster->block_group != block_group)
                 goto out;
 
-        bitmap = cluster->points_to_bitmap;
         cluster->block_group = NULL;
         cluster->window_start = 0;
         list_del_init(&cluster->block_group_list);
-        cluster->points_to_bitmap = false;
-
-        if (bitmap)
-                goto out;
 
         node = rb_first(&cluster->root);
         while (node) {
+                bool bitmap;
+
                 entry = rb_entry(node, struct btrfs_free_space, offset_index);
                 node = rb_next(&entry->offset_index);
                 rb_erase(&entry->offset_index, &cluster->root);
-                BUG_ON(entry->bitmap);
-                try_merge_free_space(block_group, entry, false);
+
+                bitmap = (entry->bitmap != NULL);
+                if (!bitmap)
+                        try_merge_free_space(block_group, entry, false);
                 tree_insert_offset(&block_group->free_space_offset,
-                                   entry->offset, &entry->offset_index, 0);
+                                   entry->offset, &entry->offset_index, bitmap);
         }
         cluster->root = RB_ROOT;
 
@@ -1689,7 +1702,7 @@ void btrfs_remove_free_space_cache(struct btrfs_block_group_cache *block_group)
                 unlink_free_space(block_group, info);
                 if (info->bitmap)
                         kfree(info->bitmap);
-                kfree(info);
+                kmem_cache_free(btrfs_free_space_cachep, info);
                 if (need_resched()) {
                         spin_unlock(&block_group->tree_lock);
                         cond_resched();
@@ -1722,7 +1735,7 @@ u64 btrfs_find_space_for_alloc(struct btrfs_block_group_cache *block_group,
                 entry->offset += bytes;
                 entry->bytes -= bytes;
                 if (!entry->bytes)
-                        kfree(entry);
+                        kmem_cache_free(btrfs_free_space_cachep, entry);
                 else
                         link_free_space(block_group, entry);
         }
@@ -1775,50 +1788,24 @@ int btrfs_return_cluster_to_free_space(
 
 static u64 btrfs_alloc_from_bitmap(struct btrfs_block_group_cache *block_group,
                                    struct btrfs_free_cluster *cluster,
+                                   struct btrfs_free_space *entry,
                                    u64 bytes, u64 min_start)
 {
-        struct btrfs_free_space *entry;
         int err;
         u64 search_start = cluster->window_start;
         u64 search_bytes = bytes;
         u64 ret = 0;
 
-        spin_lock(&block_group->tree_lock);
-        spin_lock(&cluster->lock);
-
-        if (!cluster->points_to_bitmap)
-                goto out;
-
-        if (cluster->block_group != block_group)
-                goto out;
-
-        /*
-         * search_start is the beginning of the bitmap, but at some point it may
-         * be a good idea to point to the actual start of the free area in the
-         * bitmap, so do the offset_to_bitmap trick anyway, and set bitmap_only
-         * to 1 to make sure we get the bitmap entry
-         */
-        entry = tree_search_offset(block_group,
-                                   offset_to_bitmap(block_group, search_start),
-                                   1, 0);
-        if (!entry || !entry->bitmap)
-                goto out;
-
         search_start = min_start;
         search_bytes = bytes;
 
         err = search_bitmap(block_group, entry, &search_start,
                             &search_bytes);
         if (err)
-                goto out;
+                return 0;
 
         ret = search_start;
         bitmap_clear_bits(block_group, entry, ret, bytes);
-        if (entry->bytes == 0)
-                free_bitmap(block_group, entry);
-out:
-        spin_unlock(&cluster->lock);
-        spin_unlock(&block_group->tree_lock);
 
         return ret;
 }
@@ -1836,10 +1823,6 @@ u64 btrfs_alloc_from_cluster(struct btrfs_block_group_cache *block_group,
         struct rb_node *node;
         u64 ret = 0;
 
-        if (cluster->points_to_bitmap)
-                return btrfs_alloc_from_bitmap(block_group, cluster, bytes,
-                                               min_start);
-
         spin_lock(&cluster->lock);
         if (bytes > cluster->max_size)
                 goto out;
@@ -1852,9 +1835,9 @@ u64 btrfs_alloc_from_cluster(struct btrfs_block_group_cache *block_group,
                 goto out;
 
         entry = rb_entry(node, struct btrfs_free_space, offset_index);
-
         while(1) {
-                if (entry->bytes < bytes || entry->offset < min_start) {
+                if (entry->bytes < bytes ||
+                    (!entry->bitmap && entry->offset < min_start)) {
                         struct rb_node *node;
 
                         node = rb_next(&entry->offset_index);
@@ -1864,10 +1847,27 @@ u64 btrfs_alloc_from_cluster(struct btrfs_block_group_cache *block_group,
                                          offset_index);
                         continue;
                 }
-                ret = entry->offset;
 
-                entry->offset += bytes;
-                entry->bytes -= bytes;
+                if (entry->bitmap) {
+                        ret = btrfs_alloc_from_bitmap(block_group,
+                                                      cluster, entry, bytes,
+                                                      min_start);
+                        if (ret == 0) {
+                                struct rb_node *node;
+                                node = rb_next(&entry->offset_index);
+                                if (!node)
+                                        break;
+                                entry = rb_entry(node, struct btrfs_free_space,
+                                                 offset_index);
+                                continue;
+                        }
+                } else {
+
+                        ret = entry->offset;
+
+                        entry->offset += bytes;
+                        entry->bytes -= bytes;
+                }
 
                 if (entry->bytes == 0)
                         rb_erase(&entry->offset_index, &cluster->root);
@@ -1884,7 +1884,12 @@ out:
         block_group->free_space -= bytes;
         if (entry->bytes == 0) {
                 block_group->free_extents--;
-                kfree(entry);
+                if (entry->bitmap) {
+                        kfree(entry->bitmap);
+                        block_group->total_bitmaps--;
+                        recalculate_thresholds(block_group);
+                }
+                kmem_cache_free(btrfs_free_space_cachep, entry);
         }
 
         spin_unlock(&block_group->tree_lock);
@@ -1904,12 +1909,13 @@ static int btrfs_bitmap_cluster(struct btrfs_block_group_cache *block_group,
         unsigned long found_bits;
         unsigned long start = 0;
         unsigned long total_found = 0;
+        int ret;
         bool found = false;
 
         i = offset_to_bit(entry->offset, block_group->sectorsize,
                           max_t(u64, offset, entry->offset));
-        search_bits = bytes_to_bits(min_bytes, block_group->sectorsize);
-        total_bits = bytes_to_bits(bytes, block_group->sectorsize);
+        search_bits = bytes_to_bits(bytes, block_group->sectorsize);
+        total_bits = bytes_to_bits(min_bytes, block_group->sectorsize);
 
 again:
         found_bits = 0;
@@ -1926,7 +1932,7 @@ again:
         }
 
         if (!found_bits)
-                return -1;
+                return -ENOSPC;
 
         if (!found) {
                 start = i;
@@ -1950,189 +1956,208 @@ again:
 
         cluster->window_start = start * block_group->sectorsize +
                 entry->offset;
-        cluster->points_to_bitmap = true;
+        rb_erase(&entry->offset_index, &block_group->free_space_offset);
+        ret = tree_insert_offset(&cluster->root, entry->offset,
+                                 &entry->offset_index, 1);
+        BUG_ON(ret);
 
         return 0;
 }
 
 /*
- * here we try to find a cluster of blocks in a block group.  The goal
- * is to find at least bytes free and up to empty_size + bytes free.
- * We might not find them all in one contiguous area.
- *
- * returns zero and sets up cluster if things worked out, otherwise
- * it returns -enospc
+ * This searches the block group for just extents to fill the cluster with.
  */
-int btrfs_find_space_cluster(struct btrfs_trans_handle *trans,
-                             struct btrfs_root *root,
-                             struct btrfs_block_group_cache *block_group,
-                             struct btrfs_free_cluster *cluster,
-                             u64 offset, u64 bytes, u64 empty_size)
+static int setup_cluster_no_bitmap(struct btrfs_block_group_cache *block_group,
+                                   struct btrfs_free_cluster *cluster,
+                                   u64 offset, u64 bytes, u64 min_bytes)
 {
+        struct btrfs_free_space *first = NULL;
         struct btrfs_free_space *entry = NULL;
+        struct btrfs_free_space *prev = NULL;
+        struct btrfs_free_space *last;
         struct rb_node *node;
-        struct btrfs_free_space *next;
-        struct btrfs_free_space *last = NULL;
-        u64 min_bytes;
         u64 window_start;
         u64 window_free;
-        u64 max_extent = 0;
-        bool found_bitmap = false;
-        int ret;
+        u64 max_extent;
+        u64 max_gap = 128 * 1024;
 
-        /* for metadata, allow allocates with more holes */
-        if (btrfs_test_opt(root, SSD_SPREAD)) {
-                min_bytes = bytes + empty_size;
-        } else if (block_group->flags & BTRFS_BLOCK_GROUP_METADATA) {
-                /*
-                 * we want to do larger allocations when we are
-                 * flushing out the delayed refs, it helps prevent
-                 * making more work as we go along.
-                 */
-                if (trans->transaction->delayed_refs.flushing)
-                        min_bytes = max(bytes, (bytes + empty_size) >> 1);
-                else
-                        min_bytes = max(bytes, (bytes + empty_size) >> 4);
-        } else
-                min_bytes = max(bytes, (bytes + empty_size) >> 2);
-
-        spin_lock(&block_group->tree_lock);
-        spin_lock(&cluster->lock);
-
-        /* someone already found a cluster, hooray */
-        if (cluster->block_group) {
-                ret = 0;
-                goto out;
-        }
-again:
-        entry = tree_search_offset(block_group, offset, found_bitmap, 1);
-        if (!entry) {
-                ret = -ENOSPC;
-                goto out;
-        }
+        entry = tree_search_offset(block_group, offset, 0, 1);
+        if (!entry)
+                return -ENOSPC;
 
         /*
-         * If found_bitmap is true, we exhausted our search for extent entries,
-         * and we just want to search all of the bitmaps that we can find, and
-         * ignore any extent entries we find.
+         * We don't want bitmaps, so just move along until we find a normal
+         * extent entry.
          */
-        while (entry->bitmap || found_bitmap ||
-               (!entry->bitmap && entry->bytes < min_bytes)) {
-                struct rb_node *node = rb_next(&entry->offset_index);
-
-                if (entry->bitmap && entry->bytes > bytes + empty_size) {
-                        ret = btrfs_bitmap_cluster(block_group, entry, cluster,
-                                                   offset, bytes + empty_size,
-                                                   min_bytes);
-                        if (!ret)
-                                goto got_it;
-                }
-
-                if (!node) {
-                        ret = -ENOSPC;
-                        goto out;
-                }
+        while (entry->bitmap) {
+                node = rb_next(&entry->offset_index);
+                if (!node)
+                        return -ENOSPC;
                 entry = rb_entry(node, struct btrfs_free_space, offset_index);
         }
 
-        /*
-         * We already searched all the extent entries from the passed in offset
-         * to the end and didn't find enough space for the cluster, and we also
-         * didn't find any bitmaps that met our criteria, just go ahead and exit
-         */
-        if (found_bitmap) {
-                ret = -ENOSPC;
-                goto out;
-        }
-
-        cluster->points_to_bitmap = false;
         window_start = entry->offset;
         window_free = entry->bytes;
-        last = entry;
         max_extent = entry->bytes;
+        first = entry;
+        last = entry;
+        prev = entry;
 
-        while (1) {
-                /* out window is just right, lets fill it */
-                if (window_free >= bytes + empty_size)
-                        break;
-
-                node = rb_next(&last->offset_index);
-                if (!node) {
-                        if (found_bitmap)
-                                goto again;
-                        ret = -ENOSPC;
-                        goto out;
-                }
-                next = rb_entry(node, struct btrfs_free_space, offset_index);
+        while (window_free <= min_bytes) {
+                node = rb_next(&entry->offset_index);
+                if (!node)
+                        return -ENOSPC;
+                entry = rb_entry(node, struct btrfs_free_space, offset_index);
 
-                /*
-                 * we found a bitmap, so if this search doesn't result in a
-                 * cluster, we know to go and search again for the bitmaps and
-                 * start looking for space there
-                 */
-                if (next->bitmap) {
-                        if (!found_bitmap)
-                                offset = next->offset;
-                        found_bitmap = true;
-                        last = next;
+                if (entry->bitmap)
                         continue;
-                }
-
                 /*
                  * we haven't filled the empty size and the window is
                  * very large.  reset and try again
                  */
-                if (next->offset - (last->offset + last->bytes) > 128 * 1024 ||
-                    next->offset - window_start > (bytes + empty_size) * 2) {
-                        entry = next;
+                if (entry->offset - (prev->offset + prev->bytes) > max_gap ||
+                    entry->offset - window_start > (min_bytes * 2)) {
+                        first = entry;
                         window_start = entry->offset;
                         window_free = entry->bytes;
                         last = entry;
                         max_extent = entry->bytes;
                 } else {
-                        last = next;
-                        window_free += next->bytes;
+                        last = entry;
+                        window_free += entry->bytes;
                         if (entry->bytes > max_extent)
                                 max_extent = entry->bytes;
                 }
+                prev = entry;
         }
 
-        cluster->window_start = entry->offset;
+        cluster->window_start = first->offset;
+
+        node = &first->offset_index;
 
         /*
          * now we've found our entries, pull them out of the free space
          * cache and put them into the cluster rbtree
-         *
-         * The cluster includes an rbtree, but only uses the offset index
-         * of each free space cache entry.
          */
-        while (1) {
+        do {
+                int ret;
+
+                entry = rb_entry(node, struct btrfs_free_space, offset_index);
                 node = rb_next(&entry->offset_index);
-                if (entry->bitmap && node) {
-                        entry = rb_entry(node, struct btrfs_free_space,
-                                         offset_index);
+                if (entry->bitmap)
                         continue;
-                } else if (entry->bitmap && !node) {
-                        break;
-                }
 
                 rb_erase(&entry->offset_index, &block_group->free_space_offset);
                 ret = tree_insert_offset(&cluster->root, entry->offset,
                                          &entry->offset_index, 0);
                 BUG_ON(ret);
+        } while (node && entry != last);
 
-                if (!node || entry == last)
-                        break;
+        cluster->max_size = max_extent;
+
+        return 0;
+}
+
+/*
+ * This specifically looks for bitmaps that may work in the cluster, we assume
+ * that we have already failed to find extents that will work.
+ */
+static int setup_cluster_bitmap(struct btrfs_block_group_cache *block_group,
+                                struct btrfs_free_cluster *cluster,
+                                u64 offset, u64 bytes, u64 min_bytes)
+{
+        struct btrfs_free_space *entry;
+        struct rb_node *node;
+        int ret = -ENOSPC;
+
+        if (block_group->total_bitmaps == 0)
+                return -ENOSPC;
 
+        entry = tree_search_offset(block_group,
+                                   offset_to_bitmap(block_group, offset),
+                                   0, 1);
+        if (!entry)
+                return -ENOSPC;
+
+        node = &entry->offset_index;
+        do {
                 entry = rb_entry(node, struct btrfs_free_space, offset_index);
+                node = rb_next(&entry->offset_index);
+                if (!entry->bitmap)
+                        continue;
+                if (entry->bytes < min_bytes)
+                        continue;
+                ret = btrfs_bitmap_cluster(block_group, entry, cluster, offset,
+                                           bytes, min_bytes);
+        } while (ret && node);
+
+        return ret;
+}
+
+/*
+ * here we try to find a cluster of blocks in a block group.  The goal
+ * is to find at least bytes free and up to empty_size + bytes free.
+ * We might not find them all in one contiguous area.
+ *
+ * returns zero and sets up cluster if things worked out, otherwise
+ * it returns -enospc
+ */
+int btrfs_find_space_cluster(struct btrfs_trans_handle *trans,
+                             struct btrfs_root *root,
+                             struct btrfs_block_group_cache *block_group,
+                             struct btrfs_free_cluster *cluster,
+                             u64 offset, u64 bytes, u64 empty_size)
+{
+        u64 min_bytes;
+        int ret;
+
+        /* for metadata, allow allocates with more holes */
+        if (btrfs_test_opt(root, SSD_SPREAD)) {
+                min_bytes = bytes + empty_size;
+        } else if (block_group->flags & BTRFS_BLOCK_GROUP_METADATA) {
+                /*
+                 * we want to do larger allocations when we are
+                 * flushing out the delayed refs, it helps prevent
+                 * making more work as we go along.
+                 */
+                if (trans->transaction->delayed_refs.flushing)
+                        min_bytes = max(bytes, (bytes + empty_size) >> 1);
+                else
+                        min_bytes = max(bytes, (bytes + empty_size) >> 4);
+        } else
+                min_bytes = max(bytes, (bytes + empty_size) >> 2);
+
+        spin_lock(&block_group->tree_lock);
+
+        /*
+         * If we know we don't have enough space to make a cluster don't even
+         * bother doing all the work to try and find one.
+         */
+        if (block_group->free_space < min_bytes) {
+                spin_unlock(&block_group->tree_lock);
+                return -ENOSPC;
         }
 
-        cluster->max_size = max_extent;
-got_it:
-        ret = 0;
-        atomic_inc(&block_group->count);
-        list_add_tail(&cluster->block_group_list, &block_group->cluster_list);
-        cluster->block_group = block_group;
+        spin_lock(&cluster->lock);
+
+        /* someone already found a cluster, hooray */
+        if (cluster->block_group) {
+                ret = 0;
+                goto out;
+        }
+
+        ret = setup_cluster_no_bitmap(block_group, cluster, offset, bytes,
+                                      min_bytes);
+        if (ret)
+                ret = setup_cluster_bitmap(block_group, cluster, offset,
+                                           bytes, min_bytes);
+
+        if (!ret) {
+                atomic_inc(&block_group->count);
+                list_add_tail(&cluster->block_group_list,
+                              &block_group->cluster_list);
+                cluster->block_group = block_group;
+        }
 out:
         spin_unlock(&cluster->lock);
         spin_unlock(&block_group->tree_lock);
@@ -2149,8 +2174,99 @@ void btrfs_init_free_cluster(struct btrfs_free_cluster *cluster)
         spin_lock_init(&cluster->refill_lock);
         cluster->root = RB_ROOT;
         cluster->max_size = 0;
-        cluster->points_to_bitmap = false;
         INIT_LIST_HEAD(&cluster->block_group_list);
         cluster->block_group = NULL;
 }
 
+int btrfs_trim_block_group(struct btrfs_block_group_cache *block_group,
+                           u64 *trimmed, u64 start, u64 end, u64 minlen)
+{
+        struct btrfs_free_space *entry = NULL;
+        struct btrfs_fs_info *fs_info = block_group->fs_info;
+        u64 bytes = 0;
+        u64 actually_trimmed;
+        int ret = 0;
+
+        *trimmed = 0;
+
+        while (start < end) {
+                spin_lock(&block_group->tree_lock);
+
+                if (block_group->free_space < minlen) {
+                        spin_unlock(&block_group->tree_lock);
+                        break;
+                }
+
+                entry = tree_search_offset(block_group, start, 0, 1);
+                if (!entry)
+                        entry = tree_search_offset(block_group,
+                                                   offset_to_bitmap(block_group,
+                                                                    start),
+                                                   1, 1);
+
+                if (!entry || entry->offset >= end) {
+                        spin_unlock(&block_group->tree_lock);
+                        break;
+                }
+
+                if (entry->bitmap) {
+                        ret = search_bitmap(block_group, entry, &start, &bytes);
+                        if (!ret) {
+                                if (start >= end) {
+                                        spin_unlock(&block_group->tree_lock);
+                                        break;
+                                }
+                                bytes = min(bytes, end - start);
+                                bitmap_clear_bits(block_group, entry,
+                                                  start, bytes);
+                                if (entry->bytes == 0)
+                                        free_bitmap(block_group, entry);
+                        } else {
+                                start = entry->offset + BITS_PER_BITMAP *
+                                        block_group->sectorsize;
+                                spin_unlock(&block_group->tree_lock);
+                                ret = 0;
+                                continue;
+                        }
+                } else {
+                        start = entry->offset;
+                        bytes = min(entry->bytes, end - start);
+                        unlink_free_space(block_group, entry);
+                        kfree(entry);
+                }
+
+                spin_unlock(&block_group->tree_lock);
+
+                if (bytes >= minlen) {
+                        int update_ret;
+                        update_ret = btrfs_update_reserved_bytes(block_group,
+                                                                 bytes, 1, 1);
+
+                        ret = btrfs_error_discard_extent(fs_info->extent_root,
+                                                         start,
+                                                         bytes,
+                                                         &actually_trimmed);
+
+                        btrfs_add_free_space(block_group,
+                                             start, bytes);
+                        if (!update_ret)
+                                btrfs_update_reserved_bytes(block_group,
+                                                            bytes, 0, 1);
+
+                        if (ret)
+                                break;
+                        *trimmed += actually_trimmed;
+                }
+                start += bytes;
+                bytes = 0;
+
+                if (fatal_signal_pending(current)) {
+                        ret = -ERESTARTSYS;
+                        break;
+                }
+
+                cond_resched();
+        }
+
+        return ret;
+}
diff --git a/fs/btrfs/free-space-cache.h b/fs/btrfs/free-space-cache.h
index e49ca5c321b5..65c3b935289f 100644
--- a/fs/btrfs/free-space-cache.h
+++ b/fs/btrfs/free-space-cache.h
@@ -68,4 +68,6 @@ u64 btrfs_alloc_from_cluster(struct btrfs_block_group_cache *block_group,
 int btrfs_return_cluster_to_free_space(
                                struct btrfs_block_group_cache *block_group,
                                struct btrfs_free_cluster *cluster);
+int btrfs_trim_block_group(struct btrfs_block_group_cache *block_group,
+                           u64 *trimmed, u64 start, u64 end, u64 minlen);
 #endif
diff --git a/fs/btrfs/inode-map.c b/fs/btrfs/inode-map.c
index c56eb5909172..c05a08f4c411 100644
--- a/fs/btrfs/inode-map.c
+++ b/fs/btrfs/inode-map.c
@@ -30,7 +30,8 @@ int btrfs_find_highest_inode(struct btrfs_root *root, u64 *objectid)
         int slot;
 
         path = btrfs_alloc_path();
-        BUG_ON(!path);
+        if (!path)
+                return -ENOMEM;
 
         search_key.objectid = BTRFS_LAST_FREE_OBJECTID;
         search_key.type = -1;
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 119520bdb9a5..93c28a1d6bdc 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -50,6 +50,7 @@
 #include "tree-log.h"
 #include "compression.h"
 #include "locking.h"
+#include "free-space-cache.h"
 
 struct btrfs_iget_args {
         u64 ino;
@@ -70,6 +71,7 @@ static struct kmem_cache *btrfs_inode_cachep;
 struct kmem_cache *btrfs_trans_handle_cachep;
 struct kmem_cache *btrfs_transaction_cachep;
 struct kmem_cache *btrfs_path_cachep;
+struct kmem_cache *btrfs_free_space_cachep;
 
 #define S_SHIFT 12
 static unsigned char btrfs_type_by_mode[S_IFMT >> S_SHIFT] = {
@@ -82,7 +84,8 @@ static unsigned char btrfs_type_by_mode[S_IFMT >> S_SHIFT] = {
         [S_IFLNK >> S_SHIFT]    = BTRFS_FT_SYMLINK,
 };
 
-static void btrfs_truncate(struct inode *inode);
+static int btrfs_setsize(struct inode *inode, loff_t newsize);
+static int btrfs_truncate(struct inode *inode);
 static int btrfs_finish_ordered_io(struct inode *inode, u64 start, u64 end);
 static noinline int cow_file_range(struct inode *inode,
                                    struct page *locked_page,
@@ -288,6 +291,7 @@ static noinline int add_async_extent(struct async_cow *cow,
         struct async_extent *async_extent;
 
         async_extent = kmalloc(sizeof(*async_extent), GFP_NOFS);
+        BUG_ON(!async_extent);
         async_extent->start = start;
         async_extent->ram_size = ram_size;
         async_extent->compressed_size = compressed_size;
@@ -382,9 +386,11 @@ again:
          */
         if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NOCOMPRESS) &&
             (btrfs_test_opt(root, COMPRESS) ||
-             (BTRFS_I(inode)->force_compress))) {
+             (BTRFS_I(inode)->force_compress) ||
+             (BTRFS_I(inode)->flags & BTRFS_INODE_COMPRESS))) {
                 WARN_ON(pages);
                 pages = kzalloc(sizeof(struct page *) * nr_pages, GFP_NOFS);
+                BUG_ON(!pages);
 
                 if (BTRFS_I(inode)->force_compress)
                         compress_type = BTRFS_I(inode)->force_compress;
@@ -1254,7 +1260,8 @@ static int run_delalloc_range(struct inode *inode, struct page *locked_page,
                 ret = run_delalloc_nocow(inode, locked_page, start, end,
                                          page_started, 0, nr_written);
         else if (!btrfs_test_opt(root, COMPRESS) &&
-                 !(BTRFS_I(inode)->force_compress))
+                 !(BTRFS_I(inode)->force_compress) &&
+                 !(BTRFS_I(inode)->flags & BTRFS_INODE_COMPRESS))
                 ret = cow_file_range(inode, locked_page, start, end,
                                       page_started, nr_written, 1);
         else
@@ -1461,8 +1468,11 @@ static int btrfs_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
                 if (bio_flags & EXTENT_BIO_COMPRESSED) {
                         return btrfs_submit_compressed_read(inode, bio,
                                                     mirror_num, bio_flags);
-                } else if (!skip_sum)
-                        btrfs_lookup_bio_sums(root, inode, bio, NULL);
+                } else if (!skip_sum) {
+                        ret = btrfs_lookup_bio_sums(root, inode, bio, NULL);
+                        if (ret)
+                                return ret;
+                }
                 goto mapit;
         } else if (!skip_sum) {
                 /* csum items have already been cloned */
@@ -1785,6 +1795,8 @@ out:
 static int btrfs_writepage_end_io_hook(struct page *page, u64 start, u64 end,
                                 struct extent_state *state, int uptodate)
 {
+        trace_btrfs_writepage_end_io_hook(page, start, end, uptodate);
+
         ClearPagePrivate2(page);
         return btrfs_finish_ordered_io(page->mapping->host, start, end);
 }
@@ -1895,10 +1907,10 @@ static int btrfs_io_failed_hook(struct bio *failed_bio,
         else
                 rw = READ;
 
-        BTRFS_I(inode)->io_tree.ops->submit_bio_hook(inode, rw, bio,
+        ret = BTRFS_I(inode)->io_tree.ops->submit_bio_hook(inode, rw, bio,
                                                       failrec->last_mirror,
                                                       failrec->bio_flags, 0);
-        return 0;
+        return ret;
 }
 
 /*
@@ -2282,7 +2294,7 @@ int btrfs_orphan_del(struct btrfs_trans_handle *trans, struct inode *inode)
  * this cleans up any orphans that may be left on the list from the last use
  * of this root.
  */
-void btrfs_orphan_cleanup(struct btrfs_root *root)
+int btrfs_orphan_cleanup(struct btrfs_root *root)
 {
         struct btrfs_path *path;
         struct extent_buffer *leaf;
@@ -2292,10 +2304,13 @@ void btrfs_orphan_cleanup(struct btrfs_root *root)
         int ret = 0, nr_unlink = 0, nr_truncate = 0;
 
         if (cmpxchg(&root->orphan_cleanup_state, 0, ORPHAN_CLEANUP_STARTED))
-                return;
+                return 0;
 
         path = btrfs_alloc_path();
-        BUG_ON(!path);
+        if (!path) {
+                ret = -ENOMEM;
+                goto out;
+        }
         path->reada = -1;
 
         key.objectid = BTRFS_ORPHAN_OBJECTID;
@@ -2304,11 +2319,8 @@ void btrfs_orphan_cleanup(struct btrfs_root *root)
 
         while (1) {
                 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
-                if (ret < 0) {
-                        printk(KERN_ERR "Error searching slot for orphan: %d"
-                               "\n", ret);
-                        break;
-                }
+                if (ret < 0)
+                        goto out;
 
                 /*
                  * if ret == 0 means we found what we were searching for, which
@@ -2316,6 +2328,7 @@ void btrfs_orphan_cleanup(struct btrfs_root *root)
                  * find the key and see if we have stuff that matches
                  */
                 if (ret > 0) {
+                        ret = 0;
                         if (path->slots[0] == 0)
                                 break;
                         path->slots[0]--;
@@ -2343,7 +2356,10 @@ void btrfs_orphan_cleanup(struct btrfs_root *root)
                 found_key.type = BTRFS_INODE_ITEM_KEY;
                 found_key.offset = 0;
                 inode = btrfs_iget(root->fs_info->sb, &found_key, root, NULL);
-                BUG_ON(IS_ERR(inode));
+                if (IS_ERR(inode)) {
+                        ret = PTR_ERR(inode);
+                        goto out;
+                }
 
                 /*
                  * add this inode to the orphan list so btrfs_orphan_del does
@@ -2361,7 +2377,10 @@ void btrfs_orphan_cleanup(struct btrfs_root *root)
                  */
                 if (is_bad_inode(inode)) {
                         trans = btrfs_start_transaction(root, 0);
-                        BUG_ON(IS_ERR(trans));
+                        if (IS_ERR(trans)) {
+                                ret = PTR_ERR(trans);
+                                goto out;
+                        }
                         btrfs_orphan_del(trans, inode);
                         btrfs_end_transaction(trans, root);
                         iput(inode);
@@ -2370,17 +2389,22 @@ void btrfs_orphan_cleanup(struct btrfs_root *root)
 
                 /* if we have links, this was a truncate, lets do that */
                 if (inode->i_nlink) {
+                        if (!S_ISREG(inode->i_mode)) {
+                                WARN_ON(1);
+                                iput(inode);
+                                continue;
+                        }
                         nr_truncate++;
-                        btrfs_truncate(inode);
+                        ret = btrfs_truncate(inode);
                 } else {
                         nr_unlink++;
                 }
 
                 /* this will do delete_inode and everything for us */
                 iput(inode);
+                if (ret)
+                        goto out;
         }
-        btrfs_free_path(path);
-
         root->orphan_cleanup_state = ORPHAN_CLEANUP_DONE;
 
         if (root->orphan_block_rsv)
@@ -2389,14 +2413,20 @@ void btrfs_orphan_cleanup(struct btrfs_root *root)
 
         if (root->orphan_block_rsv || root->orphan_item_inserted) {
                 trans = btrfs_join_transaction(root, 1);
-                BUG_ON(IS_ERR(trans));
-                btrfs_end_transaction(trans, root);
+                if (!IS_ERR(trans))
+                        btrfs_end_transaction(trans, root);
         }
 
         if (nr_unlink)
                 printk(KERN_INFO "btrfs: unlinked %d orphans\n", nr_unlink);
         if (nr_truncate)
                 printk(KERN_INFO "btrfs: truncated %d orphans\n", nr_truncate);
+
+out:
+        if (ret)
+                printk(KERN_CRIT "btrfs: could not do orphan cleanup %d\n", ret);
+        btrfs_free_path(path);
+        return ret;
 }
 
 /*
@@ -2507,6 +2537,8 @@ static void btrfs_read_locked_inode(struct inode *inode)
         BTRFS_I(inode)->flags = btrfs_inode_flags(leaf, inode_item);
 
         alloc_group_block = btrfs_inode_block_group(leaf, inode_item);
+        if (location.objectid == BTRFS_FREE_SPACE_OBJECTID)
+                inode->i_mapping->flags &= ~__GFP_FS;
 
         /*
          * try to precache a NULL acl entry for files that don't have
@@ -2635,10 +2667,10 @@ failed:
  * recovery code.  It remove a link in a directory with a given name, and
  * also drops the back refs in the inode to the directory
  */
-int btrfs_unlink_inode(struct btrfs_trans_handle *trans,
-                       struct btrfs_root *root,
-                       struct inode *dir, struct inode *inode,
-                       const char *name, int name_len)
+static int __btrfs_unlink_inode(struct btrfs_trans_handle *trans,
+                                struct btrfs_root *root,
+                                struct inode *dir, struct inode *inode,
+                                const char *name, int name_len)
 {
         struct btrfs_path *path;
         int ret = 0;
@@ -2710,12 +2742,25 @@ err:
         btrfs_i_size_write(dir, dir->i_size - name_len * 2);
         inode->i_ctime = dir->i_mtime = dir->i_ctime = CURRENT_TIME;
         btrfs_update_inode(trans, root, dir);
-        btrfs_drop_nlink(inode);
-        ret = btrfs_update_inode(trans, root, inode);
 out:
         return ret;
 }
 
+int btrfs_unlink_inode(struct btrfs_trans_handle *trans,
+                       struct btrfs_root *root,
+                       struct inode *dir, struct inode *inode,
+                       const char *name, int name_len)
+{
+        int ret;
+        ret = __btrfs_unlink_inode(trans, root, dir, inode, name, name_len);
+        if (!ret) {
+                btrfs_drop_nlink(inode);
+                ret = btrfs_update_inode(trans, root, inode);
+        }
+        return ret;
+}
+                
+
 /* helper to check if there is any shared block in the path */
 static int check_path_shared(struct btrfs_root *root,
                              struct btrfs_path *path)
@@ -3537,7 +3582,13 @@ out:
         return ret;
 }
 
-int btrfs_cont_expand(struct inode *inode, loff_t size)
+/*
+ * This function puts in dummy file extents for the area we're creating a hole
+ * for.  So if we are truncating this file to a larger size we need to insert
+ * these file extents so that btrfs_get_extent will return a EXTENT_MAP_HOLE for
+ * the range between oldsize and size
+ */
+int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size)
 {
         struct btrfs_trans_handle *trans;
         struct btrfs_root *root = BTRFS_I(inode)->root;
@@ -3545,7 +3596,7 @@ int btrfs_cont_expand(struct inode *inode, loff_t size)
         struct extent_map *em = NULL;
         struct extent_state *cached_state = NULL;
         u64 mask = root->sectorsize - 1;
-        u64 hole_start = (inode->i_size + mask) & ~mask;
+        u64 hole_start = (oldsize + mask) & ~mask;
         u64 block_end = (size + mask) & ~mask;
         u64 last_byte;
         u64 cur_offset;
@@ -3590,13 +3641,15 @@ int btrfs_cont_expand(struct inode *inode, loff_t size)
                         err = btrfs_drop_extents(trans, inode, cur_offset,
                                                  cur_offset + hole_size,
                                                  &hint_byte, 1);
-                        BUG_ON(err);
+                        if (err)
+                                break;
 
                         err = btrfs_insert_file_extent(trans, root,
                                         inode->i_ino, cur_offset, 0,
                                         0, hole_size, 0, hole_size,
                                         0, 0, 0);
-                        BUG_ON(err);
+                        if (err)
+                                break;
 
                         btrfs_drop_extent_cache(inode, hole_start,
                                         last_byte - 1, 0);
@@ -3616,81 +3669,41 @@ int btrfs_cont_expand(struct inode *inode, loff_t size)
         return err;
 }
 
-static int btrfs_setattr_size(struct inode *inode, struct iattr *attr)
+static int btrfs_setsize(struct inode *inode, loff_t newsize)
 {
-        struct btrfs_root *root = BTRFS_I(inode)->root;
-        struct btrfs_trans_handle *trans;
-        unsigned long nr;
+        loff_t oldsize = i_size_read(inode);
         int ret;
 
-        if (attr->ia_size == inode->i_size)
+        if (newsize == oldsize)
                 return 0;
 
-        if (attr->ia_size > inode->i_size) {
-                unsigned long limit;
-                limit = current->signal->rlim[RLIMIT_FSIZE].rlim_cur;
-                if (attr->ia_size > inode->i_sb->s_maxbytes)
-                        return -EFBIG;
-                if (limit != RLIM_INFINITY && attr->ia_size > limit) {
-                        send_sig(SIGXFSZ, current, 0);
-                        return -EFBIG;
-                }
-        }
-
-        trans = btrfs_start_transaction(root, 5);
-        if (IS_ERR(trans))
-                return PTR_ERR(trans);
-
-        btrfs_set_trans_block_group(trans, inode);
-
-        ret = btrfs_orphan_add(trans, inode);
-        BUG_ON(ret);
-
-        nr = trans->blocks_used;
-        btrfs_end_transaction(trans, root);
-        btrfs_btree_balance_dirty(root, nr);
-
-        if (attr->ia_size > inode->i_size) {
-                ret = btrfs_cont_expand(inode, attr->ia_size);
+        if (newsize > oldsize) {
+                i_size_write(inode, newsize);
+                btrfs_ordered_update_i_size(inode, i_size_read(inode), NULL);
+                truncate_pagecache(inode, oldsize, newsize);
+                ret = btrfs_cont_expand(inode, oldsize, newsize);
                 if (ret) {
-                        btrfs_truncate(inode);
+                        btrfs_setsize(inode, oldsize);
                         return ret;
                 }
 
-                i_size_write(inode, attr->ia_size);
-                btrfs_ordered_update_i_size(inode, inode->i_size, NULL);
+                mark_inode_dirty(inode);
+        } else {
 
-                trans = btrfs_start_transaction(root, 0);
-                BUG_ON(IS_ERR(trans));
-                btrfs_set_trans_block_group(trans, inode);
-                trans->block_rsv = root->orphan_block_rsv;
-                BUG_ON(!trans->block_rsv);
+                /*
+                 * We're truncating a file that used to have good data down to
+                 * zero. Make sure it gets into the ordered flush list so that
+                 * any new writes get down to disk quickly.
+                 */
+                if (newsize == 0)
+                        BTRFS_I(inode)->ordered_data_close = 1;
 
-                ret = btrfs_update_inode(trans, root, inode);
-                BUG_ON(ret);
-                if (inode->i_nlink > 0) {
-                        ret = btrfs_orphan_del(trans, inode);
-                        BUG_ON(ret);
-                }
-                nr = trans->blocks_used;
-                btrfs_end_transaction(trans, root);
-                btrfs_btree_balance_dirty(root, nr);
-                return 0;
+                /* we don't support swapfiles, so vmtruncate shouldn't fail */
+                truncate_setsize(inode, newsize);
+                ret = btrfs_truncate(inode);
         }
 
-        /*
-         * We're truncating a file that used to have good data down to
-         * zero. Make sure it gets into the ordered flush list so that
-         * any new writes get down to disk quickly.
-         */
-        if (attr->ia_size == 0)
-                BTRFS_I(inode)->ordered_data_close = 1;
-
-        /* we don't support swapfiles, so vmtruncate shouldn't fail */
-        ret = vmtruncate(inode, attr->ia_size);
-        BUG_ON(ret);
-
-        return 0;
+        return ret;
 }
 
 static int btrfs_setattr(struct dentry *dentry, struct iattr *attr)
@@ -3707,7 +3720,7 @@ static int btrfs_setattr(struct dentry *dentry, struct iattr *attr)
                 return err;
 
         if (S_ISREG(inode->i_mode) && (attr->ia_valid & ATTR_SIZE)) {
-                err = btrfs_setattr_size(inode, attr);
+                err = btrfs_setsize(inode, attr->ia_size);
                 if (err)
                         return err;
         }
@@ -3730,6 +3743,8 @@ void btrfs_evict_inode(struct inode *inode)
         unsigned long nr;
         int ret;
 
+        trace_btrfs_inode_evict(inode);
+
         truncate_inode_pages(&inode->i_data, 0);
         if (inode->i_nlink && (btrfs_root_refs(&root->root_item) != 0 ||
                                root == root->fs_info->tree_root))
@@ -4072,7 +4087,6 @@ struct inode *btrfs_iget(struct super_block *s, struct btrfs_key *location,
                 BTRFS_I(inode)->root = root;
                 memcpy(&BTRFS_I(inode)->location, location, sizeof(*location));
                 btrfs_read_locked_inode(inode);
-
                 inode_tree_add(inode);
                 unlock_new_inode(inode);
                 if (new)
@@ -4147,8 +4161,10 @@ struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry)
         if (!IS_ERR(inode) && root != sub_root) {
                 down_read(&root->fs_info->cleanup_work_sem);
                 if (!(inode->i_sb->s_flags & MS_RDONLY))
-                        btrfs_orphan_cleanup(sub_root);
+                        ret = btrfs_orphan_cleanup(sub_root);
                 up_read(&root->fs_info->cleanup_work_sem);
+                if (ret)
+                        inode = ERR_PTR(ret);
         }
 
         return inode;
@@ -4282,6 +4298,9 @@ static int btrfs_real_readdir(struct file *filp, void *dirent,
                 while (di_cur < di_total) {
                         struct btrfs_key location;
 
+                        if (verify_dir_item(root, leaf, di))
+                                break;
+
                         name_len = btrfs_dir_name_len(leaf, di);
                         if (name_len <= sizeof(tmp_name)) {
                                 name_ptr = tmp_name;
@@ -4517,6 +4536,8 @@ static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
                 return ERR_PTR(-ENOMEM);
 
         if (dir) {
+                trace_btrfs_inode_request(dir);
+
                 ret = btrfs_set_inode_index(dir, index);
                 if (ret) {
                         iput(inode);
@@ -4585,12 +4606,16 @@ static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
         if ((mode & S_IFREG)) {
                 if (btrfs_test_opt(root, NODATASUM))
                         BTRFS_I(inode)->flags |= BTRFS_INODE_NODATASUM;
-                if (btrfs_test_opt(root, NODATACOW))
+                if (btrfs_test_opt(root, NODATACOW) ||
+                    (BTRFS_I(dir)->flags & BTRFS_INODE_NODATACOW))
                         BTRFS_I(inode)->flags |= BTRFS_INODE_NODATACOW;
         }
 
         insert_inode_hash(inode);
         inode_tree_add(inode);
+
+        trace_btrfs_inode_new(inode);
+
         return inode;
 fail:
         if (dir)
@@ -4809,7 +4834,10 @@ static int btrfs_link(struct dentry *old_dentry, struct inode *dir,
 
         /* do not allow sys_link's with other subvols of the same device */
         if (root->objectid != BTRFS_I(inode)->root->objectid)
-                return -EPERM;
+                return -EXDEV;
+
+        if (inode->i_nlink == ~0U)
+                return -EMLINK;
 
         btrfs_inc_nlink(inode);
         inode->i_ctime = CURRENT_TIME;
@@ -5265,6 +5293,9 @@ insert:
         }
         write_unlock(&em_tree->lock);
 out:
+
+        trace_btrfs_get_extent(root, em);
+
         if (path)
                 btrfs_free_path(path);
         if (trans) {
@@ -5748,6 +5779,10 @@ static void btrfs_endio_direct_read(struct bio *bio, int err)
 
         kfree(dip->csums);
         kfree(dip);
+
+        /* If we had a csum failure make sure to clear the uptodate flag */
+        if (err)
+                clear_bit(BIO_UPTODATE, &bio->bi_flags);
         dio_end_io(bio, err);
 }
 
@@ -5849,6 +5884,10 @@ out_done:
 
         kfree(dip->csums);
         kfree(dip);
+
+        /* If we had an error make sure to clear the uptodate flag */
+        if (err)
+                clear_bit(BIO_UPTODATE, &bio->bi_flags);
         dio_end_io(bio, err);
 }
 
@@ -5922,9 +5961,12 @@ static inline int __btrfs_submit_dio_bio(struct bio *bio, struct inode *inode,
                                    __btrfs_submit_bio_start_direct_io,
                                    __btrfs_submit_bio_done);
                 goto err;
-        } else if (!skip_sum)
-                btrfs_lookup_bio_sums_dio(root, inode, bio,
+        } else if (!skip_sum) {
+                ret = btrfs_lookup_bio_sums_dio(root, inode, bio,
                                           file_offset, csums);
+                if (ret)
+                        goto err;
+        }
 
         ret = btrfs_map_bio(root, rw, bio, 0, 1);
 err:
@@ -5948,6 +5990,7 @@ static int btrfs_submit_direct_hook(int rw, struct btrfs_dio_private *dip,
         int nr_pages = 0;
         u32 *csums = dip->csums;
         int ret = 0;
+        int write = rw & REQ_WRITE;
 
         bio = btrfs_dio_bio_alloc(orig_bio->bi_bdev, start_sector, GFP_NOFS);
         if (!bio)
@@ -5984,7 +6027,8 @@ static int btrfs_submit_direct_hook(int rw, struct btrfs_dio_private *dip,
                                 goto out_err;
                         }
 
-                        if (!skip_sum)
+                        /* Write's use the ordered csums */
+                        if (!write && !skip_sum)
                                 csums = csums + nr_pages;
                         start_sector += submit_len >> 9;
                         file_offset += submit_len;
@@ -6052,7 +6096,8 @@ static void btrfs_submit_direct(int rw, struct bio *bio, struct inode *inode,
         }
         dip->csums = NULL;
 
-        if (!skip_sum) {
+        /* Write's use the ordered csum stuff, so we don't need dip->csums */
+        if (!write && !skip_sum) {
                 dip->csums = kmalloc(sizeof(u32) * bio->bi_vcnt, GFP_NOFS);
                 if (!dip->csums) {
                         kfree(dip);
@@ -6474,28 +6519,42 @@ out:
         return ret;
 }
 
-static void btrfs_truncate(struct inode *inode)
+static int btrfs_truncate(struct inode *inode)
 {
         struct btrfs_root *root = BTRFS_I(inode)->root;
         int ret;
+        int err = 0;
         struct btrfs_trans_handle *trans;
         unsigned long nr;
         u64 mask = root->sectorsize - 1;
 
-        if (!S_ISREG(inode->i_mode)) {
-                WARN_ON(1);
-                return;
-        }
-
         ret = btrfs_truncate_page(inode->i_mapping, inode->i_size);
         if (ret)
-                return;
+                return ret;
 
         btrfs_wait_ordered_range(inode, inode->i_size & (~mask), (u64)-1);
         btrfs_ordered_update_i_size(inode, inode->i_size, NULL);
 
+        trans = btrfs_start_transaction(root, 5);
+        if (IS_ERR(trans))
+                return PTR_ERR(trans);
+
+        btrfs_set_trans_block_group(trans, inode);
+
+        ret = btrfs_orphan_add(trans, inode);
+        if (ret) {
+                btrfs_end_transaction(trans, root);
+                return ret;
+        }
+
+        nr = trans->blocks_used;
+        btrfs_end_transaction(trans, root);
+        btrfs_btree_balance_dirty(root, nr);
+
+        /* Now start a transaction for the truncate */
         trans = btrfs_start_transaction(root, 0);
-        BUG_ON(IS_ERR(trans));
+        if (IS_ERR(trans))
+                return PTR_ERR(trans);
         btrfs_set_trans_block_group(trans, inode);
         trans->block_rsv = root->orphan_block_rsv;
 
@@ -6522,29 +6581,38 @@ static void btrfs_truncate(struct inode *inode)
         while (1) {
                 if (!trans) {
                         trans = btrfs_start_transaction(root, 0);
-                        BUG_ON(IS_ERR(trans));
+                        if (IS_ERR(trans))
+                                return PTR_ERR(trans);
                         btrfs_set_trans_block_group(trans, inode);
                         trans->block_rsv = root->orphan_block_rsv;
                 }
 
                 ret = btrfs_block_rsv_check(trans, root,
                                             root->orphan_block_rsv, 0, 5);
-                if (ret) {
-                        BUG_ON(ret != -EAGAIN);
+                if (ret == -EAGAIN) {
                         ret = btrfs_commit_transaction(trans, root);
-                        BUG_ON(ret);
+                        if (ret)
+                                return ret;
                         trans = NULL;
                         continue;
+                } else if (ret) {
+                        err = ret;
+                        break;
                 }
 
                 ret = btrfs_truncate_inode_items(trans, root, inode,
                                                  inode->i_size,
                                                  BTRFS_EXTENT_DATA_KEY);
-                if (ret != -EAGAIN)
+                if (ret != -EAGAIN) {
+                        err = ret;
                         break;
+                }
 
                 ret = btrfs_update_inode(trans, root, inode);
-                BUG_ON(ret);
+                if (ret) {
+                        err = ret;
+                        break;
+                }
 
                 nr = trans->blocks_used;
                 btrfs_end_transaction(trans, root);
@@ -6554,16 +6622,27 @@ static void btrfs_truncate(struct inode *inode)
 
         if (ret == 0 && inode->i_nlink > 0) {
                 ret = btrfs_orphan_del(trans, inode);
-                BUG_ON(ret);
+                if (ret)
+                        err = ret;
+        } else if (ret && inode->i_nlink > 0) {
+                /*
+                 * Failed to do the truncate, remove us from the in memory
+                 * orphan list.
+                 */
+                ret = btrfs_orphan_del(NULL, inode);
         }
 
         ret = btrfs_update_inode(trans, root, inode);
-        BUG_ON(ret);
+        if (ret && !err)
+                err = ret;
 
         nr = trans->blocks_used;
         ret = btrfs_end_transaction_throttle(trans, root);
-        BUG_ON(ret);
+        if (ret && !err)
+                err = ret;
         btrfs_btree_balance_dirty(root, nr);
+
+        return err;
 }
 
 /*
@@ -6630,9 +6709,8 @@ struct inode *btrfs_alloc_inode(struct super_block *sb)
         ei->index_cnt = (u64)-1;
         ei->last_unlink_trans = 0;
 
-        spin_lock_init(&ei->accounting_lock);
         atomic_set(&ei->outstanding_extents, 0);
-        ei->reserved_extents = 0;
+        atomic_set(&ei->reserved_extents, 0);
 
         ei->ordered_data_close = 0;
         ei->orphan_meta_reserved = 0;
@@ -6668,7 +6746,7 @@ void btrfs_destroy_inode(struct inode *inode)
         WARN_ON(!list_empty(&inode->i_dentry));
         WARN_ON(inode->i_data.nrpages);
         WARN_ON(atomic_read(&BTRFS_I(inode)->outstanding_extents));
-        WARN_ON(BTRFS_I(inode)->reserved_extents);
+        WARN_ON(atomic_read(&BTRFS_I(inode)->reserved_extents));
 
         /*
          * This can happen where we create an inode, but somebody else also
@@ -6760,6 +6838,8 @@ void btrfs_destroy_cachep(void)
                 kmem_cache_destroy(btrfs_transaction_cachep);
         if (btrfs_path_cachep)
                 kmem_cache_destroy(btrfs_path_cachep);
+        if (btrfs_free_space_cachep)
+                kmem_cache_destroy(btrfs_free_space_cachep);
 }
 
 int btrfs_init_cachep(void)
@@ -6788,6 +6868,12 @@ int btrfs_init_cachep(void)
         if (!btrfs_path_cachep)
                 goto fail;
 
+        btrfs_free_space_cachep = kmem_cache_create("btrfs_free_space_cache",
+                        sizeof(struct btrfs_free_space), 0,
+                        SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
+        if (!btrfs_free_space_cachep)
+                goto fail;
+
         return 0;
 fail:
         btrfs_destroy_cachep();
@@ -6806,6 +6892,26 @@ static int btrfs_getattr(struct vfsmount *mnt,
         return 0;
 }
 
+/*
+ * If a file is moved, it will inherit the cow and compression flags of the new
+ * directory.
+ */
+static void fixup_inode_flags(struct inode *dir, struct inode *inode)
+{
+        struct btrfs_inode *b_dir = BTRFS_I(dir);
+        struct btrfs_inode *b_inode = BTRFS_I(inode);
+
+        if (b_dir->flags & BTRFS_INODE_NODATACOW)
+                b_inode->flags |= BTRFS_INODE_NODATACOW;
+        else
+                b_inode->flags &= ~BTRFS_INODE_NODATACOW;
+
+        if (b_dir->flags & BTRFS_INODE_COMPRESS)
+                b_inode->flags |= BTRFS_INODE_COMPRESS;
+        else
+                b_inode->flags &= ~BTRFS_INODE_COMPRESS;
+}
+
 static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                            struct inode *new_dir, struct dentry *new_dentry)
 {
@@ -6908,11 +7014,12 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                                         old_dentry->d_name.name,
                                         old_dentry->d_name.len);
         } else {
-                btrfs_inc_nlink(old_dentry->d_inode);
-                ret = btrfs_unlink_inode(trans, root, old_dir,
-                                         old_dentry->d_inode,
-                                         old_dentry->d_name.name,
-                                         old_dentry->d_name.len);
+                ret = __btrfs_unlink_inode(trans, root, old_dir,
+                                        old_dentry->d_inode,
+                                        old_dentry->d_name.name,
+                                        old_dentry->d_name.len);
+                if (!ret)
+                        ret = btrfs_update_inode(trans, root, old_inode);
         }
         BUG_ON(ret);
 
@@ -6939,6 +7046,8 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                 }
         }
 
+        fixup_inode_flags(new_dir, old_inode);
+
         ret = btrfs_add_link(trans, new_dir, old_inode,
                              new_dentry->d_name.name,
                              new_dentry->d_name.len, 0, index);
@@ -7355,7 +7464,6 @@ static const struct address_space_operations btrfs_symlink_aops = {
 };
 
 static const struct inode_operations btrfs_file_inode_operations = {
-        .truncate       = btrfs_truncate,
         .getattr        = btrfs_getattr,
         .setattr        = btrfs_setattr,
         .setxattr       = btrfs_setxattr,
diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
index d1bace3df9b6..7c07fe26b7cf 100644
--- a/fs/btrfs/ioctl.c
+++ b/fs/btrfs/ioctl.c
@@ -40,6 +40,7 @@
 #include <linux/xattr.h>
 #include <linux/vmalloc.h>
 #include <linux/slab.h>
+#include <linux/blkdev.h>
 #include "compat.h"
 #include "ctree.h"
 #include "disk-io.h"
@@ -138,6 +139,24 @@ static int btrfs_ioctl_getflags(struct file *file, void __user *arg)
         return 0;
 }
 
+static int check_flags(unsigned int flags)
+{
+        if (flags & ~(FS_IMMUTABLE_FL | FS_APPEND_FL | \
+                      FS_NOATIME_FL | FS_NODUMP_FL | \
+                      FS_SYNC_FL | FS_DIRSYNC_FL | \
+                      FS_NOCOMP_FL | FS_COMPR_FL | \
+                      FS_NOCOW_FL | FS_COW_FL))
+                return -EOPNOTSUPP;
+
+        if ((flags & FS_NOCOMP_FL) && (flags & FS_COMPR_FL))
+                return -EINVAL;
+
+        if ((flags & FS_NOCOW_FL) && (flags & FS_COW_FL))
+                return -EINVAL;
+
+        return 0;
+}
+
 static int btrfs_ioctl_setflags(struct file *file, void __user *arg)
 {
         struct inode *inode = file->f_path.dentry->d_inode;
@@ -153,10 +172,9 @@ static int btrfs_ioctl_setflags(struct file *file, void __user *arg)
         if (copy_from_user(&flags, arg, sizeof(flags)))
                 return -EFAULT;
 
-        if (flags & ~(FS_IMMUTABLE_FL | FS_APPEND_FL | \
-                      FS_NOATIME_FL | FS_NODUMP_FL | \
-                      FS_SYNC_FL | FS_DIRSYNC_FL))
-                return -EOPNOTSUPP;
+        ret = check_flags(flags);
+        if (ret)
+                return ret;
 
         if (!inode_owner_or_capable(inode))
                 return -EACCES;
@@ -201,6 +219,22 @@ static int btrfs_ioctl_setflags(struct file *file, void __user *arg)
         else
                 ip->flags &= ~BTRFS_INODE_DIRSYNC;
 
+        /*
+         * The COMPRESS flag can only be changed by users, while the NOCOMPRESS
+         * flag may be changed automatically if compression code won't make
+         * things smaller.
+         */
+        if (flags & FS_NOCOMP_FL) {
+                ip->flags &= ~BTRFS_INODE_COMPRESS;
+                ip->flags |= BTRFS_INODE_NOCOMPRESS;
+        } else if (flags & FS_COMPR_FL) {
+                ip->flags |= BTRFS_INODE_COMPRESS;
+                ip->flags &= ~BTRFS_INODE_NOCOMPRESS;
+        }
+        if (flags & FS_NOCOW_FL)
+                ip->flags |= BTRFS_INODE_NODATACOW;
+        else if (flags & FS_COW_FL)
+                ip->flags &= ~BTRFS_INODE_NODATACOW;
 
         trans = btrfs_join_transaction(root, 1);
         BUG_ON(IS_ERR(trans));
@@ -213,9 +247,11 @@ static int btrfs_ioctl_setflags(struct file *file, void __user *arg)
         btrfs_end_transaction(trans, root);
 
         mnt_drop_write(file->f_path.mnt);
+
+        ret = 0;
  out_unlock:
         mutex_unlock(&inode->i_mutex);
-        return 0;
+        return ret;
 }
 
 static int btrfs_ioctl_getversion(struct file *file, int __user *arg)
@@ -225,6 +261,49 @@ static int btrfs_ioctl_getversion(struct file *file, int __user *arg)
         return put_user(inode->i_generation, arg);
 }
 
+static noinline int btrfs_ioctl_fitrim(struct file *file, void __user *arg)
+{
+        struct btrfs_root *root = fdentry(file)->d_sb->s_fs_info;
+        struct btrfs_fs_info *fs_info = root->fs_info;
+        struct btrfs_device *device;
+        struct request_queue *q;
+        struct fstrim_range range;
+        u64 minlen = ULLONG_MAX;
+        u64 num_devices = 0;
+        int ret;
+
+        if (!capable(CAP_SYS_ADMIN))
+                return -EPERM;
+
+        mutex_lock(&fs_info->fs_devices->device_list_mutex);
+        list_for_each_entry(device, &fs_info->fs_devices->devices, dev_list) {
+                if (!device->bdev)
+                        continue;
+                q = bdev_get_queue(device->bdev);
+                if (blk_queue_discard(q)) {
+                        num_devices++;
+                        minlen = min((u64)q->limits.discard_granularity,
+                                     minlen);
+                }
+        }
+        mutex_unlock(&fs_info->fs_devices->device_list_mutex);
+        if (!num_devices)
+                return -EOPNOTSUPP;
+
+        if (copy_from_user(&range, arg, sizeof(range)))
+                return -EFAULT;
+
+        range.minlen = max(range.minlen, minlen);
+        ret = btrfs_trim_fs(root, &range);
+        if (ret < 0)
+                return ret;
+
+        if (copy_to_user(arg, &range, sizeof(range)))
+                return -EFAULT;
+
+        return 0;
+}
+
 static noinline int create_subvol(struct btrfs_root *root,
                                   struct dentry *dentry,
                                   char *name, int namelen,
@@ -409,7 +488,9 @@ static int create_snapshot(struct btrfs_root *root, struct dentry *dentry,
         if (ret)
                 goto fail;
 
-        btrfs_orphan_cleanup(pending_snapshot->snap);
+        ret = btrfs_orphan_cleanup(pending_snapshot->snap);
+        if (ret)
+                goto fail;
 
         parent = dget_parent(dentry);
         inode = btrfs_lookup_dentry(parent->d_inode, dentry);
@@ -2348,12 +2429,15 @@ static noinline long btrfs_ioctl_start_sync(struct file *file, void __user *argp
         struct btrfs_root *root = BTRFS_I(file->f_dentry->d_inode)->root;
         struct btrfs_trans_handle *trans;
         u64 transid;
+        int ret;
 
         trans = btrfs_start_transaction(root, 0);
         if (IS_ERR(trans))
                 return PTR_ERR(trans);
         transid = trans->transid;
-        btrfs_commit_transaction_async(trans, root, 0);
+        ret = btrfs_commit_transaction_async(trans, root, 0);
+        if (ret)
+                return ret;
 
         if (argp)
                 if (copy_to_user(argp, &transid, sizeof(transid)))
@@ -2388,6 +2472,8 @@ long btrfs_ioctl(struct file *file, unsigned int
                 return btrfs_ioctl_setflags(file, argp);
         case FS_IOC_GETVERSION:
                 return btrfs_ioctl_getversion(file, argp);
+        case FITRIM:
+                return btrfs_ioctl_fitrim(file, argp);
         case BTRFS_IOC_SNAP_CREATE:
                 return btrfs_ioctl_snap_create(file, argp, 0);
         case BTRFS_IOC_SNAP_CREATE_V2:
diff --git a/fs/btrfs/ordered-data.c b/fs/btrfs/ordered-data.c
index 083a55477375..a1c940425307 100644
--- a/fs/btrfs/ordered-data.c
+++ b/fs/btrfs/ordered-data.c
@@ -202,6 +202,8 @@ static int __btrfs_add_ordered_extent(struct inode *inode, u64 file_offset,
         INIT_LIST_HEAD(&entry->list);
         INIT_LIST_HEAD(&entry->root_extent_list);
 
+        trace_btrfs_ordered_extent_add(inode, entry);
+
         spin_lock(&tree->lock);
         node = tree_insert(&tree->tree, file_offset,
                            &entry->rb_node);
@@ -387,6 +389,8 @@ int btrfs_put_ordered_extent(struct btrfs_ordered_extent *entry)
         struct list_head *cur;
         struct btrfs_ordered_sum *sum;
 
+        trace_btrfs_ordered_extent_put(entry->inode, entry);
+
         if (atomic_dec_and_test(&entry->refs)) {
                 while (!list_empty(&entry->list)) {
                         cur = entry->list.next;
@@ -420,6 +424,8 @@ static int __btrfs_remove_ordered_extent(struct inode *inode,
         spin_lock(&root->fs_info->ordered_extent_lock);
         list_del_init(&entry->root_extent_list);
 
+        trace_btrfs_ordered_extent_remove(inode, entry);
+
         /*
          * we have no more ordered extents for this inode and
          * no dirty pages.  We can safely remove it from the
@@ -585,6 +591,8 @@ void btrfs_start_ordered_extent(struct inode *inode,
         u64 start = entry->file_offset;
         u64 end = start + entry->len - 1;
 
+        trace_btrfs_ordered_extent_start(inode, entry);
+
         /*
          * pages in the range can be dirty, clean or writeback.  We
          * start IO on any dirty ones so the wait doesn't stall waiting
diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c
index 31ade5802ae8..58250e09eb05 100644
--- a/fs/btrfs/relocation.c
+++ b/fs/btrfs/relocation.c
@@ -1724,6 +1724,7 @@ again:
 
                         eb = read_tree_block(dest, old_bytenr, blocksize,
                                              old_ptr_gen);
+                        BUG_ON(!eb);
                         btrfs_tree_lock(eb);
                         if (cow) {
                                 ret = btrfs_cow_block(trans, dest, eb, parent,
@@ -2513,6 +2514,10 @@ static int do_relocation(struct btrfs_trans_handle *trans,
                 blocksize = btrfs_level_size(root, node->level);
                 generation = btrfs_node_ptr_generation(upper->eb, slot);
                 eb = read_tree_block(root, bytenr, blocksize, generation);
+                if (!eb) {
+                        err = -EIO;
+                        goto next;
+                }
                 btrfs_tree_lock(eb);
                 btrfs_set_lock_blocking(eb);
 
@@ -2670,6 +2675,7 @@ static int get_tree_block_key(struct reloc_control *rc,
         BUG_ON(block->key_ready);
         eb = read_tree_block(rc->extent_root, block->bytenr,
                              block->key.objectid, block->key.offset);
+        BUG_ON(!eb);
         WARN_ON(btrfs_header_level(eb) != block->level);
         if (block->level == 0)
                 btrfs_item_key_to_cpu(eb, &block->key, 0);
@@ -4209,7 +4215,7 @@ out:
                 if (IS_ERR(fs_root))
                         err = PTR_ERR(fs_root);
                 else
-                        btrfs_orphan_cleanup(fs_root);
+                        err = btrfs_orphan_cleanup(fs_root);
         }
         return err;
 }
diff --git a/fs/btrfs/root-tree.c b/fs/btrfs/root-tree.c
index 6a1086e83ffc..29b2d7c930eb 100644
--- a/fs/btrfs/root-tree.c
+++ b/fs/btrfs/root-tree.c
@@ -88,7 +88,8 @@ int btrfs_find_last_root(struct btrfs_root *root, u64 objectid,
         search_key.offset = (u64)-1;
 
         path = btrfs_alloc_path();
-        BUG_ON(!path);
+        if (!path)
+                return -ENOMEM;
         ret = btrfs_search_slot(NULL, root, &search_key, path, 0, 0);
         if (ret < 0)
                 goto out;
@@ -332,7 +333,8 @@ int btrfs_del_root(struct btrfs_trans_handle *trans, struct btrfs_root *root,
         struct extent_buffer *leaf;
 
         path = btrfs_alloc_path();
-        BUG_ON(!path);
+        if (!path)
+                return -ENOMEM;
         ret = btrfs_search_slot(trans, root, key, path, -1, 1);
         if (ret < 0)
                 goto out;
diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c
index d39a9895d932..2edfc039f098 100644
--- a/fs/btrfs/super.c
+++ b/fs/btrfs/super.c
@@ -52,6 +52,9 @@
 #include "export.h"
 #include "compression.h"
 
+#define CREATE_TRACE_POINTS
+#include <trace/events/btrfs.h>
+
 static const struct super_operations btrfs_super_ops;
 
 static const char *btrfs_decode_error(struct btrfs_fs_info *fs_info, int errno,
@@ -620,6 +623,8 @@ int btrfs_sync_fs(struct super_block *sb, int wait)
         struct btrfs_root *root = btrfs_sb(sb);
         int ret;
 
+        trace_btrfs_sync_fs(wait);
+
         if (!wait) {
                 filemap_flush(root->fs_info->btree_inode->i_mapping);
                 return 0;
diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c
index 3d73c8d93bbb..ce48eb59d615 100644
--- a/fs/btrfs/transaction.c
+++ b/fs/btrfs/transaction.c
@@ -57,7 +57,8 @@ static noinline int join_transaction(struct btrfs_root *root)
         if (!cur_trans) {
                 cur_trans = kmem_cache_alloc(btrfs_transaction_cachep,
                                              GFP_NOFS);
-                BUG_ON(!cur_trans);
+                if (!cur_trans)
+                        return -ENOMEM;
                 root->fs_info->generation++;
                 cur_trans->num_writers = 1;
                 cur_trans->num_joined = 0;
@@ -195,7 +196,11 @@ again:
                 wait_current_trans(root);
 
         ret = join_transaction(root);
-        BUG_ON(ret);
+        if (ret < 0) {
+                if (type != TRANS_JOIN_NOLOCK)
+                        mutex_unlock(&root->fs_info->trans_mutex);
+                return ERR_PTR(ret);
+        }
 
         cur_trans = root->fs_info->running_transaction;
         cur_trans->use_count++;
@@ -1156,7 +1161,8 @@ int btrfs_commit_transaction_async(struct btrfs_trans_handle *trans,
         struct btrfs_transaction *cur_trans;
 
         ac = kmalloc(sizeof(*ac), GFP_NOFS);
-        BUG_ON(!ac);
+        if (!ac)
+                return -ENOMEM;
 
         INIT_DELAYED_WORK(&ac->work, do_async_commit);
         ac->root = root;
@@ -1389,6 +1395,8 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
         put_transaction(cur_trans);
         put_transaction(cur_trans);
 
+        trace_btrfs_transaction_commit(root);
+
         mutex_unlock(&root->fs_info->trans_mutex);
 
         if (current->journal_info == trans)
diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index a4bbb854dfd2..c50271ad3157 100644
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -799,12 +799,12 @@ static noinline int add_inode_ref(struct btrfs_trans_handle *trans,
         struct inode *dir;
         int ret;
         struct btrfs_inode_ref *ref;
-        struct btrfs_dir_item *di;
         struct inode *inode;
         char *name;
         int namelen;
         unsigned long ref_ptr;
         unsigned long ref_end;
+        int search_done = 0;
 
         /*
          * it is possible that we didn't log all the parent directories
@@ -845,7 +845,10 @@ again:
          * existing back reference, and we don't want to create
          * dangling pointers in the directory.
          */
-conflict_again:
+
+        if (search_done)
+                goto insert;
+
         ret = btrfs_search_slot(NULL, root, key, path, 0, 0);
         if (ret == 0) {
                 char *victim_name;
@@ -886,37 +889,21 @@ conflict_again:
                                 ret = btrfs_unlink_inode(trans, root, dir,
                                                          inode, victim_name,
                                                          victim_name_len);
-                                kfree(victim_name);
-                                btrfs_release_path(root, path);
-                                goto conflict_again;
                         }
                         kfree(victim_name);
                         ptr = (unsigned long)(victim_ref + 1) + victim_name_len;
                 }
                 BUG_ON(ret);
-        }
-        btrfs_release_path(root, path);
-
-        /* look for a conflicting sequence number */
-        di = btrfs_lookup_dir_index_item(trans, root, path, dir->i_ino,
-                                         btrfs_inode_ref_index(eb, ref),
-                                         name, namelen, 0);
-        if (di && !IS_ERR(di)) {
-                ret = drop_one_dir_item(trans, root, path, dir, di);
-                BUG_ON(ret);
-        }
-        btrfs_release_path(root, path);
 
-
-        /* look for a conflicting name */
-        di = btrfs_lookup_dir_item(trans, root, path, dir->i_ino,
-                                   name, namelen, 0);
-        if (di && !IS_ERR(di)) {
-                ret = drop_one_dir_item(trans, root, path, dir, di);
-                BUG_ON(ret);
+                /*
+                 * NOTE: we have searched root tree and checked the
+                 * coresponding ref, it does not need to check again.
+                 */
+                search_done = 1;
         }
         btrfs_release_path(root, path);
 
+insert:
         /* insert our name */
         ret = btrfs_add_link(trans, dir, inode, name, namelen, 0,
                              btrfs_inode_ref_index(eb, ref));
@@ -1286,6 +1273,8 @@ static noinline int replay_one_dir_item(struct btrfs_trans_handle *trans,
         ptr_end = ptr + item_size;
         while (ptr < ptr_end) {
                 di = (struct btrfs_dir_item *)ptr;
+                if (verify_dir_item(root, eb, di))
+                        return -EIO;
                 name_len = btrfs_dir_name_len(eb, di);
                 ret = replay_one_name(trans, root, path, eb, di, key);
                 BUG_ON(ret);
@@ -1412,6 +1401,11 @@ again:
         ptr_end = ptr + item_size;
         while (ptr < ptr_end) {
                 di = (struct btrfs_dir_item *)ptr;
+                if (verify_dir_item(root, eb, di)) {
+                        ret = -EIO;
+                        goto out;
+                }
+
                 name_len = btrfs_dir_name_len(eb, di);
                 name = kmalloc(name_len, GFP_NOFS);
                 if (!name) {
@@ -1821,7 +1815,8 @@ static int walk_log_tree(struct btrfs_trans_handle *trans,
         int orig_level;
 
         path = btrfs_alloc_path();
-        BUG_ON(!path);
+        if (!path)
+                return -ENOMEM;
 
         level = btrfs_header_level(log->node);
         orig_level = level;
@@ -3107,9 +3102,11 @@ int btrfs_recover_log_trees(struct btrfs_root *log_root_tree)
                 .stage = 0,
         };
 
-        fs_info->log_root_recovering = 1;
         path = btrfs_alloc_path();
-        BUG_ON(!path);
+        if (!path)
+                return -ENOMEM;
+
+        fs_info->log_root_recovering = 1;
 
         trans = btrfs_start_transaction(fs_info->tree_root, 0);
         BUG_ON(IS_ERR(trans));
@@ -3117,7 +3114,8 @@ int btrfs_recover_log_trees(struct btrfs_root *log_root_tree)
         wc.trans = trans;
         wc.pin = 1;
 
-        walk_log_tree(trans, log_root_tree, &wc);
+        ret = walk_log_tree(trans, log_root_tree, &wc);
+        BUG_ON(ret);
 
 again:
         key.objectid = BTRFS_TREE_LOG_OBJECTID;
@@ -3141,8 +3139,7 @@ again:
 
                 log = btrfs_read_fs_root_no_radix(log_root_tree,
                                                   &found_key);
-                BUG_ON(!log);
-
+                BUG_ON(IS_ERR(log));
 
                 tmp_key.objectid = found_key.offset;
                 tmp_key.type = BTRFS_ROOT_ITEM_KEY;
diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index 9d554e8e6583..309a57b9fc85 100644
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -33,17 +33,6 @@
 #include "volumes.h"
 #include "async-thread.h"
 
-struct map_lookup {
-        u64 type;
-        int io_align;
-        int io_width;
-        int stripe_len;
-        int sector_size;
-        int num_stripes;
-        int sub_stripes;
-        struct btrfs_bio_stripe stripes[];
-};
-
 static int init_first_rw_device(struct btrfs_trans_handle *trans,
                                 struct btrfs_root *root,
                                 struct btrfs_device *device);
@@ -1879,6 +1868,8 @@ static int btrfs_relocate_chunk(struct btrfs_root *root,
 
         BUG_ON(ret);
 
+        trace_btrfs_chunk_free(root, map, chunk_offset, em->len);
+
         if (map->type & BTRFS_BLOCK_GROUP_SYSTEM) {
                 ret = btrfs_del_sys_chunk(root, chunk_objectid, chunk_offset);
                 BUG_ON(ret);
@@ -2606,6 +2597,8 @@ static int __btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
         *num_bytes = chunk_bytes_by_type(type, calc_size,
                                          map->num_stripes, sub_stripes);
 
+        trace_btrfs_chunk_alloc(info->chunk_root, map, start, *num_bytes);
+
         em = alloc_extent_map(GFP_NOFS);
         if (!em) {
                 ret = -ENOMEM;
@@ -2714,6 +2707,7 @@ static int __finish_chunk_alloc(struct btrfs_trans_handle *trans,
                                              item_size);
                 BUG_ON(ret);
         }
+
         kfree(chunk);
         return 0;
 }
@@ -2918,7 +2912,10 @@ static int __btrfs_map_block(struct btrfs_mapping_tree *map_tree, int rw,
         struct extent_map_tree *em_tree = &map_tree->map_tree;
         u64 offset;
         u64 stripe_offset;
+        u64 stripe_end_offset;
         u64 stripe_nr;
+        u64 stripe_nr_orig;
+        u64 stripe_nr_end;
         int stripes_allocated = 8;
         int stripes_required = 1;
         int stripe_index;
@@ -2927,7 +2924,7 @@ static int __btrfs_map_block(struct btrfs_mapping_tree *map_tree, int rw,
         int max_errors = 0;
         struct btrfs_multi_bio *multi = NULL;
 
-        if (multi_ret && !(rw & REQ_WRITE))
+        if (multi_ret && !(rw & (REQ_WRITE | REQ_DISCARD)))
                 stripes_allocated = 1;
 again:
         if (multi_ret) {
@@ -2968,7 +2965,15 @@ again:
                         max_errors = 1;
                 }
         }
-        if (multi_ret && (rw & REQ_WRITE) &&
+        if (rw & REQ_DISCARD) {
+                if (map->type & (BTRFS_BLOCK_GROUP_RAID0 |
+                                 BTRFS_BLOCK_GROUP_RAID1 |
+                                 BTRFS_BLOCK_GROUP_DUP |
+                                 BTRFS_BLOCK_GROUP_RAID10)) {
+                        stripes_required = map->num_stripes;
+                }
+        }
+        if (multi_ret && (rw & (REQ_WRITE | REQ_DISCARD)) &&
             stripes_allocated < stripes_required) {
                 stripes_allocated = map->num_stripes;
                 free_extent_map(em);
@@ -2988,12 +2993,15 @@ again:
         /* stripe_offset is the offset of this block in its stripe*/
         stripe_offset = offset - stripe_offset;
 
-        if (map->type & (BTRFS_BLOCK_GROUP_RAID0 | BTRFS_BLOCK_GROUP_RAID1 |
-                         BTRFS_BLOCK_GROUP_RAID10 |
-                         BTRFS_BLOCK_GROUP_DUP)) {
+        if (rw & REQ_DISCARD)
+                *length = min_t(u64, em->len - offset, *length);
+        else if (map->type & (BTRFS_BLOCK_GROUP_RAID0 |
+                              BTRFS_BLOCK_GROUP_RAID1 |
+                              BTRFS_BLOCK_GROUP_RAID10 |
+                              BTRFS_BLOCK_GROUP_DUP)) {
                 /* we limit the length of each bio to what fits in a stripe */
                 *length = min_t(u64, em->len - offset,
-                              map->stripe_len - stripe_offset);
+                                map->stripe_len - stripe_offset);
         } else {
                 *length = em->len - offset;
         }
@@ -3003,8 +3011,19 @@ again:
 
         num_stripes = 1;
         stripe_index = 0;
-        if (map->type & BTRFS_BLOCK_GROUP_RAID1) {
-                if (rw & REQ_WRITE)
+        stripe_nr_orig = stripe_nr;
+        stripe_nr_end = (offset + *length + map->stripe_len - 1) &
+                        (~(map->stripe_len - 1));
+        do_div(stripe_nr_end, map->stripe_len);
+        stripe_end_offset = stripe_nr_end * map->stripe_len -
+                            (offset + *length);
+        if (map->type & BTRFS_BLOCK_GROUP_RAID0) {
+                if (rw & REQ_DISCARD)
+                        num_stripes = min_t(u64, map->num_stripes,
+                                            stripe_nr_end - stripe_nr_orig);
+                stripe_index = do_div(stripe_nr, map->num_stripes);
+        } else if (map->type & BTRFS_BLOCK_GROUP_RAID1) {
+                if (rw & (REQ_WRITE | REQ_DISCARD))
                         num_stripes = map->num_stripes;
                 else if (mirror_num)
                         stripe_index = mirror_num - 1;
@@ -3015,7 +3034,7 @@ again:
                 }
 
         } else if (map->type & BTRFS_BLOCK_GROUP_DUP) {
-                if (rw & REQ_WRITE)
+                if (rw & (REQ_WRITE | REQ_DISCARD))
                         num_stripes = map->num_stripes;
                 else if (mirror_num)
                         stripe_index = mirror_num - 1;
@@ -3028,6 +3047,10 @@ again:
 
                 if (rw & REQ_WRITE)
                         num_stripes = map->sub_stripes;
+                else if (rw & REQ_DISCARD)
+                        num_stripes = min_t(u64, map->sub_stripes *
+                                            (stripe_nr_end - stripe_nr_orig),
+                                            map->num_stripes);
                 else if (mirror_num)
                         stripe_index += mirror_num - 1;
                 else {
@@ -3045,12 +3068,101 @@ again:
         }
         BUG_ON(stripe_index >= map->num_stripes);
 
-        for (i = 0; i < num_stripes; i++) {
-                multi->stripes[i].physical =
-                        map->stripes[stripe_index].physical +
-                        stripe_offset + stripe_nr * map->stripe_len;
-                multi->stripes[i].dev = map->stripes[stripe_index].dev;
-                stripe_index++;
+        if (rw & REQ_DISCARD) {
+                for (i = 0; i < num_stripes; i++) {
+                        multi->stripes[i].physical =
+                                map->stripes[stripe_index].physical +
+                                stripe_offset + stripe_nr * map->stripe_len;
+                        multi->stripes[i].dev = map->stripes[stripe_index].dev;
+
+                        if (map->type & BTRFS_BLOCK_GROUP_RAID0) {
+                                u64 stripes;
+                                u32 last_stripe = 0;
+                                int j;
+
+                                div_u64_rem(stripe_nr_end - 1,
+                                            map->num_stripes,
+                                            &last_stripe);
+
+                                for (j = 0; j < map->num_stripes; j++) {
+                                        u32 test;
+
+                                        div_u64_rem(stripe_nr_end - 1 - j,
+                                                    map->num_stripes, &test);
+                                        if (test == stripe_index)
+                                                break;
+                                }
+                                stripes = stripe_nr_end - 1 - j;
+                                do_div(stripes, map->num_stripes);
+                                multi->stripes[i].length = map->stripe_len *
+                                        (stripes - stripe_nr + 1);
+
+                                if (i == 0) {
+                                        multi->stripes[i].length -=
+                                                stripe_offset;
+                                        stripe_offset = 0;
+                                }
+                                if (stripe_index == last_stripe)
+                                        multi->stripes[i].length -=
+                                                stripe_end_offset;
+                        } else if (map->type & BTRFS_BLOCK_GROUP_RAID10) {
+                                u64 stripes;
+                                int j;
+                                int factor = map->num_stripes /
+                                             map->sub_stripes;
+                                u32 last_stripe = 0;
+
+                                div_u64_rem(stripe_nr_end - 1,
+                                            factor, &last_stripe);
+                                last_stripe *= map->sub_stripes;
+
+                                for (j = 0; j < factor; j++) {
+                                        u32 test;
+
+                                        div_u64_rem(stripe_nr_end - 1 - j,
+                                                    factor, &test);
+
+                                        if (test ==
+                                            stripe_index / map->sub_stripes)
+                                                break;
+                                }
+                                stripes = stripe_nr_end - 1 - j;
+                                do_div(stripes, factor);
+                                multi->stripes[i].length = map->stripe_len *
+                                        (stripes - stripe_nr + 1);
+
+                                if (i < map->sub_stripes) {
+                                        multi->stripes[i].length -=
+                                                stripe_offset;
+                                        if (i == map->sub_stripes - 1)
+                                                stripe_offset = 0;
+                                }
+                                if (stripe_index >= last_stripe &&
+                                    stripe_index <= (last_stripe +
+                                                     map->sub_stripes - 1)) {
+                                        multi->stripes[i].length -=
+                                                stripe_end_offset;
+                                }
+                        } else
+                                multi->stripes[i].length = *length;
+
+                        stripe_index++;
+                        if (stripe_index == map->num_stripes) {
+                                /* This could only happen for RAID0/10 */
+                                stripe_index = 0;
+                                stripe_nr++;
+                        }
+                }
+        } else {
+                for (i = 0; i < num_stripes; i++) {
+                        multi->stripes[i].physical =
+                                map->stripes[stripe_index].physical +
+                                stripe_offset +
+                                stripe_nr * map->stripe_len;
+                        multi->stripes[i].dev =
+                                map->stripes[stripe_index].dev;
+                        stripe_index++;
+                }
         }
         if (multi_ret) {
                 *multi_ret = multi;
diff --git a/fs/btrfs/volumes.h b/fs/btrfs/volumes.h
index 7fb59d45fe8c..cc2eadaf7a27 100644
--- a/fs/btrfs/volumes.h
+++ b/fs/btrfs/volumes.h
@@ -126,6 +126,7 @@ struct btrfs_fs_devices {
 struct btrfs_bio_stripe {
         struct btrfs_device *dev;
         u64 physical;
+        u64 length; /* only used for discard mappings */
 };
 
 struct btrfs_multi_bio {
@@ -145,6 +146,17 @@ struct btrfs_device_info {
         u64 max_avail;
 };
 
+struct map_lookup {
+        u64 type;
+        int io_align;
+        int io_width;
+        int stripe_len;
+        int sector_size;
+        int num_stripes;
+        int sub_stripes;
+        struct btrfs_bio_stripe stripes[];
+};
+
 /* Used to sort the devices by max_avail(descending sort) */
 int btrfs_cmp_device_free_bytes(const void *dev_info1, const void *dev_info2);
 
diff --git a/fs/btrfs/xattr.c b/fs/btrfs/xattr.c
index d779cefcfd7d..a5303b871b13 100644
--- a/fs/btrfs/xattr.c
+++ b/fs/btrfs/xattr.c
@@ -242,6 +242,8 @@ ssize_t btrfs_listxattr(struct dentry *dentry, char *buffer, size_t size)
                         break;
 
                 di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item);
+                if (verify_dir_item(root, leaf, di))
+                        continue;
 
                 name_len = btrfs_dir_name_len(leaf, di);
                 total_size += name_len + 1;
diff --git a/fs/ecryptfs/crypto.c b/fs/ecryptfs/crypto.c
index bfd8b680e648..d2a70a4561f9 100644
--- a/fs/ecryptfs/crypto.c
+++ b/fs/ecryptfs/crypto.c
@@ -266,7 +266,6 @@ void ecryptfs_destroy_mount_crypt_stat(
                                  &mount_crypt_stat->global_auth_tok_list,
                                  mount_crypt_stat_list) {
                 list_del(&auth_tok->mount_crypt_stat_list);
-                mount_crypt_stat->num_global_auth_toks--;
                 if (auth_tok->global_auth_tok_key
                     && !(auth_tok->flags & ECRYPTFS_AUTH_TOK_INVALID))
                         key_put(auth_tok->global_auth_tok_key);
@@ -1389,6 +1388,7 @@ int ecryptfs_write_metadata(struct dentry *ecryptfs_dentry)
                 rc = -ENOMEM;
                 goto out;
         }
+        /* Zeroed page ensures the in-header unencrypted i_size is set to 0 */
         rc = ecryptfs_write_headers_virt(virt, virt_len, &size, crypt_stat,
                                          ecryptfs_dentry);
         if (unlikely(rc)) {
diff --git a/fs/ecryptfs/ecryptfs_kernel.h b/fs/ecryptfs/ecryptfs_kernel.h
index e00753496e3e..bd3cafd0949d 100644
--- a/fs/ecryptfs/ecryptfs_kernel.h
+++ b/fs/ecryptfs/ecryptfs_kernel.h
@@ -233,7 +233,7 @@ ecryptfs_get_key_payload_data(struct key *key)
 
 struct ecryptfs_key_sig {
         struct list_head crypt_stat_list;
-        char keysig[ECRYPTFS_SIG_SIZE_HEX];
+        char keysig[ECRYPTFS_SIG_SIZE_HEX + 1];
 };
 
 struct ecryptfs_filename {
@@ -257,19 +257,18 @@ struct ecryptfs_filename {
 struct ecryptfs_crypt_stat {
 #define ECRYPTFS_STRUCT_INITIALIZED   0x00000001
 #define ECRYPTFS_POLICY_APPLIED       0x00000002
-#define ECRYPTFS_NEW_FILE             0x00000004
-#define ECRYPTFS_ENCRYPTED            0x00000008
-#define ECRYPTFS_SECURITY_WARNING     0x00000010
-#define ECRYPTFS_ENABLE_HMAC          0x00000020
-#define ECRYPTFS_ENCRYPT_IV_PAGES     0x00000040
-#define ECRYPTFS_KEY_VALID            0x00000080
-#define ECRYPTFS_METADATA_IN_XATTR    0x00000100
-#define ECRYPTFS_VIEW_AS_ENCRYPTED    0x00000200
-#define ECRYPTFS_KEY_SET              0x00000400
-#define ECRYPTFS_ENCRYPT_FILENAMES    0x00000800
-#define ECRYPTFS_ENCFN_USE_MOUNT_FNEK 0x00001000
-#define ECRYPTFS_ENCFN_USE_FEK        0x00002000
-#define ECRYPTFS_UNLINK_SIGS          0x00004000
+#define ECRYPTFS_ENCRYPTED            0x00000004
+#define ECRYPTFS_SECURITY_WARNING     0x00000008
+#define ECRYPTFS_ENABLE_HMAC          0x00000010
+#define ECRYPTFS_ENCRYPT_IV_PAGES     0x00000020
+#define ECRYPTFS_KEY_VALID            0x00000040
+#define ECRYPTFS_METADATA_IN_XATTR    0x00000080
+#define ECRYPTFS_VIEW_AS_ENCRYPTED    0x00000100
+#define ECRYPTFS_KEY_SET              0x00000200
+#define ECRYPTFS_ENCRYPT_FILENAMES    0x00000400
+#define ECRYPTFS_ENCFN_USE_MOUNT_FNEK 0x00000800
+#define ECRYPTFS_ENCFN_USE_FEK        0x00001000
+#define ECRYPTFS_UNLINK_SIGS          0x00002000
         u32 flags;
         unsigned int file_version;
         size_t iv_bytes;
@@ -297,7 +296,6 @@ struct ecryptfs_inode_info {
         struct inode vfs_inode;
         struct inode *wii_inode;
         struct file *lower_file;
-        struct mutex lower_file_mutex;
         struct ecryptfs_crypt_stat crypt_stat;
 };
 
@@ -333,7 +331,6 @@ struct ecryptfs_global_auth_tok {
         u32 flags;
         struct list_head mount_crypt_stat_list;
         struct key *global_auth_tok_key;
-        struct ecryptfs_auth_tok *global_auth_tok;
         unsigned char sig[ECRYPTFS_SIG_SIZE_HEX + 1];
 };
 
@@ -380,7 +377,6 @@ struct ecryptfs_mount_crypt_stat {
         u32 flags;
         struct list_head global_auth_tok_list;
         struct mutex global_auth_tok_list_mutex;
-        size_t num_global_auth_toks;
         size_t global_default_cipher_key_size;
         size_t global_default_fn_cipher_key_bytes;
         unsigned char global_default_cipher_name[ECRYPTFS_MAX_CIPHER_NAME_SIZE
diff --git a/fs/ecryptfs/file.c b/fs/ecryptfs/file.c
index 7d1050e254f9..cedc913d11ba 100644
--- a/fs/ecryptfs/file.c
+++ b/fs/ecryptfs/file.c
@@ -273,7 +273,14 @@ static int ecryptfs_release(struct inode *inode, struct file *file)
 static int
 ecryptfs_fsync(struct file *file, int datasync)
 {
-        return vfs_fsync(ecryptfs_file_to_lower(file), datasync);
+        int rc = 0;
+
+        rc = generic_file_fsync(file, datasync);
+        if (rc)
+                goto out;
+        rc = vfs_fsync(ecryptfs_file_to_lower(file), datasync);
+out:
+        return rc;
 }
 
 static int ecryptfs_fasync(int fd, struct file *file, int flag)
diff --git a/fs/ecryptfs/inode.c b/fs/ecryptfs/inode.c
index b592938a84bc..f99051b7adab 100644
--- a/fs/ecryptfs/inode.c
+++ b/fs/ecryptfs/inode.c
@@ -143,26 +143,6 @@ out:
 }
 
 /**
- * grow_file
- * @ecryptfs_dentry: the eCryptfs dentry
- *
- * This is the code which will grow the file to its correct size.
- */
-static int grow_file(struct dentry *ecryptfs_dentry)
-{
-        struct inode *ecryptfs_inode = ecryptfs_dentry->d_inode;
-        char zero_virt[] = { 0x00 };
-        int rc = 0;
-
-        rc = ecryptfs_write(ecryptfs_inode, zero_virt, 0, 1);
-        i_size_write(ecryptfs_inode, 0);
-        rc = ecryptfs_write_inode_size_to_metadata(ecryptfs_inode);
-        ecryptfs_inode_to_private(ecryptfs_inode)->crypt_stat.flags |=
-                ECRYPTFS_NEW_FILE;
-        return rc;
-}
-
-/**
  * ecryptfs_initialize_file
  *
  * Cause the file to be changed from a basic empty file to an ecryptfs
@@ -181,7 +161,6 @@ static int ecryptfs_initialize_file(struct dentry *ecryptfs_dentry)
                 crypt_stat->flags &= ~(ECRYPTFS_ENCRYPTED);
                 goto out;
         }
-        crypt_stat->flags |= ECRYPTFS_NEW_FILE;
         ecryptfs_printk(KERN_DEBUG, "Initializing crypto context\n");
         rc = ecryptfs_new_file_context(ecryptfs_dentry);
         if (rc) {
@@ -202,9 +181,6 @@ static int ecryptfs_initialize_file(struct dentry *ecryptfs_dentry)
                 printk(KERN_ERR "Error writing headers; rc = [%d]\n", rc);
                 goto out;
         }
-        rc = grow_file(ecryptfs_dentry);
-        if (rc)
-                printk(KERN_ERR "Error growing file; rc = [%d]\n", rc);
 out:
         return rc;
 }
diff --git a/fs/ecryptfs/keystore.c b/fs/ecryptfs/keystore.c
index c1436cff6f2d..03e609c45012 100644
--- a/fs/ecryptfs/keystore.c
+++ b/fs/ecryptfs/keystore.c
@@ -65,6 +65,24 @@ static int process_request_key_err(long err_code)
         return rc;
 }
 
+static int process_find_global_auth_tok_for_sig_err(int err_code)
+{
+        int rc = err_code;
+
+        switch (err_code) {
+        case -ENOENT:
+                ecryptfs_printk(KERN_WARNING, "Missing auth tok\n");
+                break;
+        case -EINVAL:
+                ecryptfs_printk(KERN_WARNING, "Invalid auth tok\n");
+                break;
+        default:
+                rc = process_request_key_err(err_code);
+                break;
+        }
+        return rc;
+}
+
 /**
  * ecryptfs_parse_packet_length
  * @data: Pointer to memory containing length at offset
@@ -403,27 +421,120 @@ out:
         return rc;
 }
 
+/**
+ * ecryptfs_verify_version
+ * @version: The version number to confirm
+ *
+ * Returns zero on good version; non-zero otherwise
+ */
+static int ecryptfs_verify_version(u16 version)
+{
+        int rc = 0;
+        unsigned char major;
+        unsigned char minor;
+
+        major = ((version >> 8) & 0xFF);
+        minor = (version & 0xFF);
+        if (major != ECRYPTFS_VERSION_MAJOR) {
+                ecryptfs_printk(KERN_ERR, "Major version number mismatch. "
+                                "Expected [%d]; got [%d]\n",
+                                ECRYPTFS_VERSION_MAJOR, major);
+                rc = -EINVAL;
+                goto out;
+        }
+        if (minor != ECRYPTFS_VERSION_MINOR) {
+                ecryptfs_printk(KERN_ERR, "Minor version number mismatch. "
+                                "Expected [%d]; got [%d]\n",
+                                ECRYPTFS_VERSION_MINOR, minor);
+                rc = -EINVAL;
+                goto out;
+        }
+out:
+        return rc;
+}
+
+/**
+ * ecryptfs_verify_auth_tok_from_key
+ * @auth_tok_key: key containing the authentication token
+ * @auth_tok: authentication token
+ *
+ * Returns zero on valid auth tok; -EINVAL otherwise
+ */
+static int
+ecryptfs_verify_auth_tok_from_key(struct key *auth_tok_key,
+                                  struct ecryptfs_auth_tok **auth_tok)
+{
+        int rc = 0;
+
+        (*auth_tok) = ecryptfs_get_key_payload_data(auth_tok_key);
+        if (ecryptfs_verify_version((*auth_tok)->version)) {
+                printk(KERN_ERR "Data structure version mismatch. Userspace "
+                       "tools must match eCryptfs kernel module with major "
+                       "version [%d] and minor version [%d]\n",
+                       ECRYPTFS_VERSION_MAJOR, ECRYPTFS_VERSION_MINOR);
+                rc = -EINVAL;
+                goto out;
+        }
+        if ((*auth_tok)->token_type != ECRYPTFS_PASSWORD
+            && (*auth_tok)->token_type != ECRYPTFS_PRIVATE_KEY) {
+                printk(KERN_ERR "Invalid auth_tok structure "
+                       "returned from key query\n");
+                rc = -EINVAL;
+                goto out;
+        }
+out:
+        return rc;
+}
+
 static int
 ecryptfs_find_global_auth_tok_for_sig(
-        struct ecryptfs_global_auth_tok **global_auth_tok,
+        struct key **auth_tok_key,
+        struct ecryptfs_auth_tok **auth_tok,
         struct ecryptfs_mount_crypt_stat *mount_crypt_stat, char *sig)
 {
         struct ecryptfs_global_auth_tok *walker;
         int rc = 0;
 
-        (*global_auth_tok) = NULL;
+        (*auth_tok_key) = NULL;
+        (*auth_tok) = NULL;
         mutex_lock(&mount_crypt_stat->global_auth_tok_list_mutex);
         list_for_each_entry(walker,
                             &mount_crypt_stat->global_auth_tok_list,
                             mount_crypt_stat_list) {
-                if (memcmp(walker->sig, sig, ECRYPTFS_SIG_SIZE_HEX) == 0) {
-                        rc = key_validate(walker->global_auth_tok_key);
-                        if (!rc)
-                                (*global_auth_tok) = walker;
+                if (memcmp(walker->sig, sig, ECRYPTFS_SIG_SIZE_HEX))
+                        continue;
+
+                if (walker->flags & ECRYPTFS_AUTH_TOK_INVALID) {
+                        rc = -EINVAL;
                         goto out;
                 }
+
+                rc = key_validate(walker->global_auth_tok_key);
+                if (rc) {
+                        if (rc == -EKEYEXPIRED)
+                                goto out;
+                        goto out_invalid_auth_tok;
+                }
+
+                down_write(&(walker->global_auth_tok_key->sem));
+                rc = ecryptfs_verify_auth_tok_from_key(
+                                walker->global_auth_tok_key, auth_tok);
+                if (rc)
+                        goto out_invalid_auth_tok_unlock;
+
+                (*auth_tok_key) = walker->global_auth_tok_key;
+                key_get(*auth_tok_key);
+                goto out;
         }
-        rc = -EINVAL;
+        rc = -ENOENT;
+        goto out;
+out_invalid_auth_tok_unlock:
+        up_write(&(walker->global_auth_tok_key->sem));
+out_invalid_auth_tok:
+        printk(KERN_WARNING "Invalidating auth tok with sig = [%s]\n", sig);
+        walker->flags |= ECRYPTFS_AUTH_TOK_INVALID;
+        key_put(walker->global_auth_tok_key);
+        walker->global_auth_tok_key = NULL;
 out:
         mutex_unlock(&mount_crypt_stat->global_auth_tok_list_mutex);
         return rc;
@@ -451,14 +562,11 @@ ecryptfs_find_auth_tok_for_sig(
         struct ecryptfs_mount_crypt_stat *mount_crypt_stat,
         char *sig)
 {
-        struct ecryptfs_global_auth_tok *global_auth_tok;
         int rc = 0;
 
-        (*auth_tok_key) = NULL;
-        (*auth_tok) = NULL;
-        if (ecryptfs_find_global_auth_tok_for_sig(&global_auth_tok,
-                                                  mount_crypt_stat, sig)) {
-
+        rc = ecryptfs_find_global_auth_tok_for_sig(auth_tok_key, auth_tok,
+                                                   mount_crypt_stat, sig);
+        if (rc == -ENOENT) {
                 /* if the flag ECRYPTFS_GLOBAL_MOUNT_AUTH_TOK_ONLY is set in the
                  * mount_crypt_stat structure, we prevent to use auth toks that
                  * are not inserted through the ecryptfs_add_global_auth_tok
@@ -470,8 +578,7 @@ ecryptfs_find_auth_tok_for_sig(
 
                 rc = ecryptfs_keyring_auth_tok_for_sig(auth_tok_key, auth_tok,
                                                        sig);
-        } else
-                (*auth_tok) = global_auth_tok->global_auth_tok;
+        }
         return rc;
 }
 
@@ -531,6 +638,16 @@ ecryptfs_write_tag_70_packet(char *dest, size_t *remaining_bytes,
         }
         s->desc.flags = CRYPTO_TFM_REQ_MAY_SLEEP;
         (*packet_size) = 0;
+        rc = ecryptfs_find_auth_tok_for_sig(
+                &auth_tok_key,
+                &s->auth_tok, mount_crypt_stat,
+                mount_crypt_stat->global_default_fnek_sig);
+        if (rc) {
+                printk(KERN_ERR "%s: Error attempting to find auth tok for "
+                       "fnek sig [%s]; rc = [%d]\n", __func__,
+                       mount_crypt_stat->global_default_fnek_sig, rc);
+                goto out;
+        }
         rc = ecryptfs_get_tfm_and_mutex_for_cipher_name(
                 &s->desc.tfm,
                 &s->tfm_mutex, mount_crypt_stat->global_default_fn_cipher_name);
@@ -616,16 +733,6 @@ ecryptfs_write_tag_70_packet(char *dest, size_t *remaining_bytes,
                 goto out_free_unlock;
         }
         dest[s->i++] = s->cipher_code;
-        rc = ecryptfs_find_auth_tok_for_sig(
-                &auth_tok_key,
-                &s->auth_tok, mount_crypt_stat,
-                mount_crypt_stat->global_default_fnek_sig);
-        if (rc) {
-                printk(KERN_ERR "%s: Error attempting to find auth tok for "
-                       "fnek sig [%s]; rc = [%d]\n", __func__,
-                       mount_crypt_stat->global_default_fnek_sig, rc);
-                goto out_free_unlock;
-        }
         /* TODO: Support other key modules than passphrase for
          * filename encryption */
         if (s->auth_tok->token_type != ECRYPTFS_PASSWORD) {
@@ -765,8 +872,10 @@ out_free_unlock:
 out_unlock:
         mutex_unlock(s->tfm_mutex);
 out:
-        if (auth_tok_key)
+        if (auth_tok_key) {
+                up_write(&(auth_tok_key->sem));
                 key_put(auth_tok_key);
+        }
         kfree(s);
         return rc;
 }
@@ -879,6 +988,15 @@ ecryptfs_parse_tag_70_packet(char **filename, size_t *filename_size,
                        __func__, s->cipher_code);
                 goto out;
         }
+        rc = ecryptfs_find_auth_tok_for_sig(&auth_tok_key,
+                                            &s->auth_tok, mount_crypt_stat,
+                                            s->fnek_sig_hex);
+        if (rc) {
+                printk(KERN_ERR "%s: Error attempting to find auth tok for "
+                       "fnek sig [%s]; rc = [%d]\n", __func__, s->fnek_sig_hex,
+                       rc);
+                goto out;
+        }
         rc = ecryptfs_get_tfm_and_mutex_for_cipher_name(&s->desc.tfm,
                                                         &s->tfm_mutex,
                                                         s->cipher_string);
@@ -925,15 +1043,6 @@ ecryptfs_parse_tag_70_packet(char **filename, size_t *filename_size,
          * >= ECRYPTFS_MAX_IV_BYTES. */
         memset(s->iv, 0, ECRYPTFS_MAX_IV_BYTES);
         s->desc.info = s->iv;
-        rc = ecryptfs_find_auth_tok_for_sig(&auth_tok_key,
-                                            &s->auth_tok, mount_crypt_stat,
-                                            s->fnek_sig_hex);
-        if (rc) {
-                printk(KERN_ERR "%s: Error attempting to find auth tok for "
-                       "fnek sig [%s]; rc = [%d]\n", __func__, s->fnek_sig_hex,
-                       rc);
-                goto out_free_unlock;
-        }
         /* TODO: Support other key modules than passphrase for
          * filename encryption */
         if (s->auth_tok->token_type != ECRYPTFS_PASSWORD) {
@@ -1002,8 +1111,10 @@ out:
                 (*filename_size) = 0;
                 (*filename) = NULL;
         }
-        if (auth_tok_key)
+        if (auth_tok_key) {
+                up_write(&(auth_tok_key->sem));
                 key_put(auth_tok_key);
+        }
         kfree(s);
         return rc;
 }
@@ -1520,38 +1631,6 @@ out:
         return rc;
 }
 
-/**
- * ecryptfs_verify_version
- * @version: The version number to confirm
- *
- * Returns zero on good version; non-zero otherwise
- */
-static int ecryptfs_verify_version(u16 version)
-{
-        int rc = 0;
-        unsigned char major;
-        unsigned char minor;
-
-        major = ((version >> 8) & 0xFF);
-        minor = (version & 0xFF);
-        if (major != ECRYPTFS_VERSION_MAJOR) {
-                ecryptfs_printk(KERN_ERR, "Major version number mismatch. "
-                                "Expected [%d]; got [%d]\n",
-                                ECRYPTFS_VERSION_MAJOR, major);
-                rc = -EINVAL;
-                goto out;
-        }
-        if (minor != ECRYPTFS_VERSION_MINOR) {
-                ecryptfs_printk(KERN_ERR, "Minor version number mismatch. "
-                                "Expected [%d]; got [%d]\n",
-                                ECRYPTFS_VERSION_MINOR, minor);
-                rc = -EINVAL;
-                goto out;
-        }
-out:
-        return rc;
-}
-
 int ecryptfs_keyring_auth_tok_for_sig(struct key **auth_tok_key,
                                       struct ecryptfs_auth_tok **auth_tok,
                                       char *sig)
@@ -1563,31 +1642,16 @@ int ecryptfs_keyring_auth_tok_for_sig(struct key **auth_tok_key,
                 printk(KERN_ERR "Could not find key with description: [%s]\n",
                        sig);
                 rc = process_request_key_err(PTR_ERR(*auth_tok_key));
+                (*auth_tok_key) = NULL;
                 goto out;
         }
-        (*auth_tok) = ecryptfs_get_key_payload_data(*auth_tok_key);
-        if (ecryptfs_verify_version((*auth_tok)->version)) {
-                printk(KERN_ERR
-                       "Data structure version mismatch. "
-                       "Userspace tools must match eCryptfs "
-                       "kernel module with major version [%d] "
-                       "and minor version [%d]\n",
-                       ECRYPTFS_VERSION_MAJOR,
-                       ECRYPTFS_VERSION_MINOR);
-                rc = -EINVAL;
-                goto out_release_key;
-        }
-        if ((*auth_tok)->token_type != ECRYPTFS_PASSWORD
-            && (*auth_tok)->token_type != ECRYPTFS_PRIVATE_KEY) {
-                printk(KERN_ERR "Invalid auth_tok structure "
-                       "returned from key query\n");
-                rc = -EINVAL;
-                goto out_release_key;
-        }
-out_release_key:
+        down_write(&(*auth_tok_key)->sem);
+        rc = ecryptfs_verify_auth_tok_from_key(*auth_tok_key, auth_tok);
         if (rc) {
+                up_write(&(*auth_tok_key)->sem);
                 key_put(*auth_tok_key);
                 (*auth_tok_key) = NULL;
+                goto out;
         }
 out:
         return rc;
@@ -1809,6 +1873,7 @@ int ecryptfs_parse_packet_set(struct ecryptfs_crypt_stat *crypt_stat,
 find_next_matching_auth_tok:
         found_auth_tok = 0;
         if (auth_tok_key) {
+                up_write(&(auth_tok_key->sem));
                 key_put(auth_tok_key);
                 auth_tok_key = NULL;
         }
@@ -1895,8 +1960,10 @@ found_matching_auth_tok:
 out_wipe_list:
         wipe_auth_tok_list(&auth_tok_list);
 out:
-        if (auth_tok_key)
+        if (auth_tok_key) {
+                up_write(&(auth_tok_key->sem));
                 key_put(auth_tok_key);
+        }
         return rc;
 }
 
@@ -2324,7 +2391,7 @@ ecryptfs_generate_key_packet_set(char *dest_base,
                                  size_t max)
 {
         struct ecryptfs_auth_tok *auth_tok;
-        struct ecryptfs_global_auth_tok *global_auth_tok;
+        struct key *auth_tok_key = NULL;
         struct ecryptfs_mount_crypt_stat *mount_crypt_stat =
                 &ecryptfs_superblock_to_private(
                         ecryptfs_dentry->d_sb)->mount_crypt_stat;
@@ -2343,21 +2410,16 @@ ecryptfs_generate_key_packet_set(char *dest_base,
         list_for_each_entry(key_sig, &crypt_stat->keysig_list,
                             crypt_stat_list) {
                 memset(key_rec, 0, sizeof(*key_rec));
-                rc = ecryptfs_find_global_auth_tok_for_sig(&global_auth_tok,
+                rc = ecryptfs_find_global_auth_tok_for_sig(&auth_tok_key,
+                                                           &auth_tok,
                                                            mount_crypt_stat,
                                                            key_sig->keysig);
                 if (rc) {
-                        printk(KERN_ERR "Error attempting to get the global "
-                               "auth_tok; rc = [%d]\n", rc);
+                        printk(KERN_WARNING "Unable to retrieve auth tok with "
+                               "sig = [%s]\n", key_sig->keysig);
+                        rc = process_find_global_auth_tok_for_sig_err(rc);
                         goto out_free;
                 }
-                if (global_auth_tok->flags & ECRYPTFS_AUTH_TOK_INVALID) {
-                        printk(KERN_WARNING
-                               "Skipping invalid auth tok with sig = [%s]\n",
-                               global_auth_tok->sig);
-                        continue;
-                }
-                auth_tok = global_auth_tok->global_auth_tok;
                 if (auth_tok->token_type == ECRYPTFS_PASSWORD) {
                         rc = write_tag_3_packet((dest_base + (*len)),
                                                 &max, auth_tok,
@@ -2395,6 +2457,9 @@ ecryptfs_generate_key_packet_set(char *dest_base,
                         rc = -EINVAL;
                         goto out_free;
                 }
+                up_write(&(auth_tok_key->sem));
+                key_put(auth_tok_key);
+                auth_tok_key = NULL;
         }
         if (likely(max > 0)) {
                 dest_base[(*len)] = 0x00;
@@ -2407,6 +2472,11 @@ out_free:
 out:
         if (rc)
                 (*len) = 0;
+        if (auth_tok_key) {
+                up_write(&(auth_tok_key->sem));
+                key_put(auth_tok_key);
+        }
+
         mutex_unlock(&crypt_stat->keysig_list_mutex);
         return rc;
 }
@@ -2424,6 +2494,7 @@ int ecryptfs_add_keysig(struct ecryptfs_crypt_stat *crypt_stat, char *sig)
                 return -ENOMEM;
         }
         memcpy(new_key_sig->keysig, sig, ECRYPTFS_SIG_SIZE_HEX);
+        new_key_sig->keysig[ECRYPTFS_SIG_SIZE_HEX] = '\0';
         /* Caller must hold keysig_list_mutex */
         list_add(&new_key_sig->crypt_stat_list, &crypt_stat->keysig_list);
 
@@ -2453,7 +2524,6 @@ ecryptfs_add_global_auth_tok(struct ecryptfs_mount_crypt_stat *mount_crypt_stat,
         mutex_lock(&mount_crypt_stat->global_auth_tok_list_mutex);
         list_add(&new_auth_tok->mount_crypt_stat_list,
                  &mount_crypt_stat->global_auth_tok_list);
-        mount_crypt_stat->num_global_auth_toks++;
         mutex_unlock(&mount_crypt_stat->global_auth_tok_list_mutex);
 out:
         return rc;
diff --git a/fs/ecryptfs/main.c b/fs/ecryptfs/main.c
index 758323a0f09a..c27c0ecf90bc 100644
--- a/fs/ecryptfs/main.c
+++ b/fs/ecryptfs/main.c
@@ -122,7 +122,6 @@ int ecryptfs_init_persistent_file(struct dentry *ecryptfs_dentry)
                 ecryptfs_inode_to_private(ecryptfs_dentry->d_inode);
         int rc = 0;
 
-        mutex_lock(&inode_info->lower_file_mutex);
         if (!inode_info->lower_file) {
                 struct dentry *lower_dentry;
                 struct vfsmount *lower_mnt =
@@ -138,7 +137,6 @@ int ecryptfs_init_persistent_file(struct dentry *ecryptfs_dentry)
                         inode_info->lower_file = NULL;
                 }
         }
-        mutex_unlock(&inode_info->lower_file_mutex);
         return rc;
 }
 
@@ -241,14 +239,14 @@ static int ecryptfs_init_global_auth_toks(
         struct ecryptfs_mount_crypt_stat *mount_crypt_stat)
 {
         struct ecryptfs_global_auth_tok *global_auth_tok;
+        struct ecryptfs_auth_tok *auth_tok;
         int rc = 0;
 
         list_for_each_entry(global_auth_tok,
                             &mount_crypt_stat->global_auth_tok_list,
                             mount_crypt_stat_list) {
                 rc = ecryptfs_keyring_auth_tok_for_sig(
-                        &global_auth_tok->global_auth_tok_key,
-                        &global_auth_tok->global_auth_tok,
+                        &global_auth_tok->global_auth_tok_key, &auth_tok,
                         global_auth_tok->sig);
                 if (rc) {
                         printk(KERN_ERR "Could not find valid key in user "
@@ -256,8 +254,10 @@ static int ecryptfs_init_global_auth_toks(
                                "option: [%s]\n", global_auth_tok->sig);
                         global_auth_tok->flags |= ECRYPTFS_AUTH_TOK_INVALID;
                         goto out;
-                } else
+                } else {
                         global_auth_tok->flags &= ~ECRYPTFS_AUTH_TOK_INVALID;
+                        up_write(&(global_auth_tok->global_auth_tok_key)->sem);
+                }
         }
 out:
         return rc;
diff --git a/fs/ecryptfs/mmap.c b/fs/ecryptfs/mmap.c
index cc64fca89f8d..6a44148c5fb9 100644
--- a/fs/ecryptfs/mmap.c
+++ b/fs/ecryptfs/mmap.c
@@ -62,6 +62,18 @@ static int ecryptfs_writepage(struct page *page, struct writeback_control *wbc)
 {
         int rc;
 
+        /*
+         * Refuse to write the page out if we are called from reclaim context
+         * since our writepage() path may potentially allocate memory when
+         * calling into the lower fs vfs_write() which may in turn invoke
+         * us again.
+         */
+        if (current->flags & PF_MEMALLOC) {
+                redirty_page_for_writepage(wbc, page);
+                rc = 0;
+                goto out;
+        }
+
         rc = ecryptfs_encrypt_page(page);
         if (rc) {
                 ecryptfs_printk(KERN_WARNING, "Error encrypting "
@@ -70,8 +82,8 @@ static int ecryptfs_writepage(struct page *page, struct writeback_control *wbc)
                 goto out;
         }
         SetPageUptodate(page);
-        unlock_page(page);
 out:
+        unlock_page(page);
         return rc;
 }
 
@@ -193,11 +205,7 @@ static int ecryptfs_readpage(struct file *file, struct page *page)
                 &ecryptfs_inode_to_private(page->mapping->host)->crypt_stat;
         int rc = 0;
 
-        if (!crypt_stat
-            || !(crypt_stat->flags & ECRYPTFS_ENCRYPTED)
-            || (crypt_stat->flags & ECRYPTFS_NEW_FILE)) {
-                ecryptfs_printk(KERN_DEBUG,
-                                "Passing through unencrypted page\n");
+        if (!crypt_stat || !(crypt_stat->flags & ECRYPTFS_ENCRYPTED)) {
                 rc = ecryptfs_read_lower_page_segment(page, page->index, 0,
                                                       PAGE_CACHE_SIZE,
                                                       page->mapping->host);
@@ -295,8 +303,7 @@ static int ecryptfs_write_begin(struct file *file,
                 struct ecryptfs_crypt_stat *crypt_stat =
                         &ecryptfs_inode_to_private(mapping->host)->crypt_stat;
 
-                if (!(crypt_stat->flags & ECRYPTFS_ENCRYPTED)
-                    || (crypt_stat->flags & ECRYPTFS_NEW_FILE)) {
+                if (!(crypt_stat->flags & ECRYPTFS_ENCRYPTED)) {
                         rc = ecryptfs_read_lower_page_segment(
                                 page, index, 0, PAGE_CACHE_SIZE, mapping->host);
                         if (rc) {
@@ -374,6 +381,11 @@ static int ecryptfs_write_begin(struct file *file,
             && (pos != 0))
                 zero_user(page, 0, PAGE_CACHE_SIZE);
 out:
+        if (unlikely(rc)) {
+                unlock_page(page);
+                page_cache_release(page);
+                *pagep = NULL;
+        }
         return rc;
 }
 
@@ -486,13 +498,8 @@ static int ecryptfs_write_end(struct file *file,
         struct ecryptfs_crypt_stat *crypt_stat =
                 &ecryptfs_inode_to_private(ecryptfs_inode)->crypt_stat;
         int rc;
+        int need_unlock_page = 1;
 
-        if (crypt_stat->flags & ECRYPTFS_NEW_FILE) {
-                ecryptfs_printk(KERN_DEBUG, "ECRYPTFS_NEW_FILE flag set in "
-                        "crypt_stat at memory location [%p]\n", crypt_stat);
-                crypt_stat->flags &= ~(ECRYPTFS_NEW_FILE);
-        } else
-                ecryptfs_printk(KERN_DEBUG, "Not a new file\n");
         ecryptfs_printk(KERN_DEBUG, "Calling fill_zeros_to_end_of_page"
                         "(page w/ index = [0x%.16lx], to = [%d])\n", index, to);
         if (!(crypt_stat->flags & ECRYPTFS_ENCRYPTED)) {
@@ -512,26 +519,26 @@ static int ecryptfs_write_end(struct file *file,
                         "zeros in page with index = [0x%.16lx]\n", index);
                 goto out;
         }
-        rc = ecryptfs_encrypt_page(page);
-        if (rc) {
-                ecryptfs_printk(KERN_WARNING, "Error encrypting page (upper "
-                                "index [0x%.16lx])\n", index);
-                goto out;
-        }
+        set_page_dirty(page);
+        unlock_page(page);
+        need_unlock_page = 0;
         if (pos + copied > i_size_read(ecryptfs_inode)) {
                 i_size_write(ecryptfs_inode, pos + copied);
                 ecryptfs_printk(KERN_DEBUG, "Expanded file size to "
                         "[0x%.16llx]\n",
                         (unsigned long long)i_size_read(ecryptfs_inode));
+                balance_dirty_pages_ratelimited(mapping);
+                rc = ecryptfs_write_inode_size_to_metadata(ecryptfs_inode);
+                if (rc) {
+                        printk(KERN_ERR "Error writing inode size to metadata; "
+                               "rc = [%d]\n", rc);
+                        goto out;
+                }
         }
-        rc = ecryptfs_write_inode_size_to_metadata(ecryptfs_inode);
-        if (rc)
-                printk(KERN_ERR "Error writing inode size to metadata; "
-                       "rc = [%d]\n", rc);
-        else
-                rc = copied;
+        rc = copied;
 out:
-        unlock_page(page);
+        if (need_unlock_page)
+                unlock_page(page);
         page_cache_release(page);
         return rc;
 }
diff --git a/fs/ecryptfs/read_write.c b/fs/ecryptfs/read_write.c
index db184ef15d3d..85d430963116 100644
--- a/fs/ecryptfs/read_write.c
+++ b/fs/ecryptfs/read_write.c
@@ -44,15 +44,11 @@ int ecryptfs_write_lower(struct inode *ecryptfs_inode, char *data,
         ssize_t rc;
 
         inode_info = ecryptfs_inode_to_private(ecryptfs_inode);
-        mutex_lock(&inode_info->lower_file_mutex);
         BUG_ON(!inode_info->lower_file);
-        inode_info->lower_file->f_pos = offset;
         fs_save = get_fs();
         set_fs(get_ds());
-        rc = vfs_write(inode_info->lower_file, data, size,
-                       &inode_info->lower_file->f_pos);
+        rc = vfs_write(inode_info->lower_file, data, size, &offset);
         set_fs(fs_save);
-        mutex_unlock(&inode_info->lower_file_mutex);
         mark_inode_dirty_sync(ecryptfs_inode);
         return rc;
 }
@@ -234,15 +230,11 @@ int ecryptfs_read_lower(char *data, loff_t offset, size_t size,
         mm_segment_t fs_save;
         ssize_t rc;
 
-        mutex_lock(&inode_info->lower_file_mutex);
         BUG_ON(!inode_info->lower_file);
-        inode_info->lower_file->f_pos = offset;
         fs_save = get_fs();
         set_fs(get_ds());
-        rc = vfs_read(inode_info->lower_file, data, size,
-                      &inode_info->lower_file->f_pos);
+        rc = vfs_read(inode_info->lower_file, data, size, &offset);
         set_fs(fs_save);
-        mutex_unlock(&inode_info->lower_file_mutex);
         return rc;
 }
 
diff --git a/fs/ecryptfs/super.c b/fs/ecryptfs/super.c
index 3042fe123a34..bacc882e1ae4 100644
--- a/fs/ecryptfs/super.c
+++ b/fs/ecryptfs/super.c
@@ -55,7 +55,6 @@ static struct inode *ecryptfs_alloc_inode(struct super_block *sb)
         if (unlikely(!inode_info))
                 goto out;
         ecryptfs_init_crypt_stat(&inode_info->crypt_stat);
-        mutex_init(&inode_info->lower_file_mutex);
         inode_info->lower_file = NULL;
         inode = &inode_info->vfs_inode;
 out:
@@ -198,7 +197,7 @@ static int ecryptfs_show_options(struct seq_file *m, struct vfsmount *mnt)
 const struct super_operations ecryptfs_sops = {
         .alloc_inode = ecryptfs_alloc_inode,
         .destroy_inode = ecryptfs_destroy_inode,
-        .drop_inode = generic_delete_inode,
+        .drop_inode = generic_drop_inode,
         .statfs = ecryptfs_statfs,
         .remount_fs = NULL,
         .evict_inode = ecryptfs_evict_inode,
diff --git a/fs/xfs/linux-2.6/xfs_buf.c b/fs/xfs/linux-2.6/xfs_buf.c
index c05324d3282c..596bb2c9de42 100644
--- a/fs/xfs/linux-2.6/xfs_buf.c
+++ b/fs/xfs/linux-2.6/xfs_buf.c
@@ -94,75 +94,6 @@ xfs_buf_vmap_len(
 }
 
 /*
- *      Page Region interfaces.
- *
- *      For pages in filesystems where the blocksize is smaller than the
- *      pagesize, we use the page->private field (long) to hold a bitmap
- *      of uptodate regions within the page.
- *
- *      Each such region is "bytes per page / bits per long" bytes long.
- *
- *      NBPPR == number-of-bytes-per-page-region
- *      BTOPR == bytes-to-page-region (rounded up)
- *      BTOPRT == bytes-to-page-region-truncated (rounded down)
- */
-#if (BITS_PER_LONG == 32)
-#define PRSHIFT         (PAGE_CACHE_SHIFT - 5)  /* (32 == 1<<5) */
-#elif (BITS_PER_LONG == 64)
-#define PRSHIFT         (PAGE_CACHE_SHIFT - 6)  /* (64 == 1<<6) */
-#else
-#error BITS_PER_LONG must be 32 or 64
-#endif
-#define NBPPR           (PAGE_CACHE_SIZE/BITS_PER_LONG)
-#define BTOPR(b)        (((unsigned int)(b) + (NBPPR - 1)) >> PRSHIFT)
-#define BTOPRT(b)       (((unsigned int)(b) >> PRSHIFT))
-
-STATIC unsigned long
-page_region_mask(
-        size_t          offset,
-        size_t          length)
-{
-        unsigned long   mask;
-        int             first, final;
-
-        first = BTOPR(offset);
-        final = BTOPRT(offset + length - 1);
-        first = min(first, final);
-
-        mask = ~0UL;
-        mask <<= BITS_PER_LONG - (final - first);
-        mask >>= BITS_PER_LONG - (final);
-
-        ASSERT(offset + length <= PAGE_CACHE_SIZE);
-        ASSERT((final - first) < BITS_PER_LONG && (final - first) >= 0);
-
-        return mask;
-}
-
-STATIC void
-set_page_region(
-        struct page     *page,
-        size_t          offset,
-        size_t          length)
-{
-        set_page_private(page,
-                page_private(page) | page_region_mask(offset, length));
-        if (page_private(page) == ~0UL)
-                SetPageUptodate(page);
-}
-
-STATIC int
-test_page_region(
-        struct page     *page,
-        size_t          offset,
-        size_t          length)
-{
-        unsigned long   mask = page_region_mask(offset, length);
-
-        return (mask && (page_private(page) & mask) == mask);
-}
-
-/*
  * xfs_buf_lru_add - add a buffer to the LRU.
  *
  * The LRU takes a new reference to the buffer so that it will only be freed
@@ -332,7 +263,7 @@ xfs_buf_free(
 
         ASSERT(list_empty(&bp->b_lru));
 
-        if (bp->b_flags & (_XBF_PAGE_CACHE|_XBF_PAGES)) {
+        if (bp->b_flags & _XBF_PAGES) {
                 uint            i;
 
                 if (xfs_buf_is_vmapped(bp))
@@ -342,25 +273,22 @@ xfs_buf_free(
                 for (i = 0; i < bp->b_page_count; i++) {
                         struct page     *page = bp->b_pages[i];
 
-                        if (bp->b_flags & _XBF_PAGE_CACHE)
-                                ASSERT(!PagePrivate(page));
-                        page_cache_release(page);
+                        __free_page(page);
                 }
-        }
+        } else if (bp->b_flags & _XBF_KMEM)
+                kmem_free(bp->b_addr);
         _xfs_buf_free_pages(bp);
         xfs_buf_deallocate(bp);
 }
 
 /*
- *      Finds all pages for buffer in question and builds it's page list.
+ * Allocates all the pages for buffer in question and builds it's page list.
  */
 STATIC int
-_xfs_buf_lookup_pages(
+xfs_buf_allocate_memory(
         xfs_buf_t               *bp,
         uint                    flags)
 {
-        struct address_space    *mapping = bp->b_target->bt_mapping;
-        size_t                  blocksize = bp->b_target->bt_bsize;
         size_t                  size = bp->b_count_desired;
         size_t                  nbytes, offset;
         gfp_t                   gfp_mask = xb_to_gfp(flags);
@@ -369,29 +297,55 @@ _xfs_buf_lookup_pages(
         xfs_off_t               end;
         int                     error;
 
+        /*
+         * for buffers that are contained within a single page, just allocate
+         * the memory from the heap - there's no need for the complexity of
+         * page arrays to keep allocation down to order 0.
+         */
+        if (bp->b_buffer_length < PAGE_SIZE) {
+                bp->b_addr = kmem_alloc(bp->b_buffer_length, xb_to_km(flags));
+                if (!bp->b_addr) {
+                        /* low memory - use alloc_page loop instead */
+                        goto use_alloc_page;
+                }
+
+                if (((unsigned long)(bp->b_addr + bp->b_buffer_length - 1) &
+                                                                PAGE_MASK) !=
+                    ((unsigned long)bp->b_addr & PAGE_MASK)) {
+                        /* b_addr spans two pages - use alloc_page instead */
+                        kmem_free(bp->b_addr);
+                        bp->b_addr = NULL;
+                        goto use_alloc_page;
+                }
+                bp->b_offset = offset_in_page(bp->b_addr);
+                bp->b_pages = bp->b_page_array;
+                bp->b_pages[0] = virt_to_page(bp->b_addr);
+                bp->b_page_count = 1;
+                bp->b_flags |= XBF_MAPPED | _XBF_KMEM;
+                return 0;
+        }
+
+use_alloc_page:
         end = bp->b_file_offset + bp->b_buffer_length;
         page_count = xfs_buf_btoc(end) - xfs_buf_btoct(bp->b_file_offset);
-
         error = _xfs_buf_get_pages(bp, page_count, flags);
         if (unlikely(error))
                 return error;
-        bp->b_flags |= _XBF_PAGE_CACHE;
 
         offset = bp->b_offset;
-        first = bp->b_file_offset >> PAGE_CACHE_SHIFT;
+        first = bp->b_file_offset >> PAGE_SHIFT;
+        bp->b_flags |= _XBF_PAGES;
 
         for (i = 0; i < bp->b_page_count; i++) {
                 struct page     *page;
                 uint            retries = 0;
-
-              retry:
-                page = find_or_create_page(mapping, first + i, gfp_mask);
+retry:
+                page = alloc_page(gfp_mask);
                 if (unlikely(page == NULL)) {
                         if (flags & XBF_READ_AHEAD) {
                                 bp->b_page_count = i;
-                                for (i = 0; i < bp->b_page_count; i++)
-                                        unlock_page(bp->b_pages[i]);
-                                return -ENOMEM;
+                                error = ENOMEM;
+                                goto out_free_pages;
                         }
 
                         /*
@@ -412,33 +366,16 @@ _xfs_buf_lookup_pages(
 
                 XFS_STATS_INC(xb_page_found);
 
-                nbytes = min_t(size_t, size, PAGE_CACHE_SIZE - offset);
+                nbytes = min_t(size_t, size, PAGE_SIZE - offset);
                 size -= nbytes;
-
-                ASSERT(!PagePrivate(page));
-                if (!PageUptodate(page)) {
-                        page_count--;
-                        if (blocksize >= PAGE_CACHE_SIZE) {
-                                if (flags & XBF_READ)
-                                        bp->b_flags |= _XBF_PAGE_LOCKED;
-                        } else if (!PagePrivate(page)) {
-                                if (test_page_region(page, offset, nbytes))
-                                        page_count++;
-                        }
-                }
-
                 bp->b_pages[i] = page;
                 offset = 0;
         }
+        return 0;
 
-        if (!(bp->b_flags & _XBF_PAGE_LOCKED)) {
-                for (i = 0; i < bp->b_page_count; i++)
-                        unlock_page(bp->b_pages[i]);
-        }
-
-        if (page_count == bp->b_page_count)
-                bp->b_flags |= XBF_DONE;
-
+out_free_pages:
+        for (i = 0; i < bp->b_page_count; i++)
+                __free_page(bp->b_pages[i]);
         return error;
 }
 
@@ -450,14 +387,23 @@ _xfs_buf_map_pages(
         xfs_buf_t               *bp,
         uint                    flags)
 {
-        /* A single page buffer is always mappable */
+        ASSERT(bp->b_flags & _XBF_PAGES);
         if (bp->b_page_count == 1) {
+                /* A single page buffer is always mappable */
                 bp->b_addr = page_address(bp->b_pages[0]) + bp->b_offset;
                 bp->b_flags |= XBF_MAPPED;
         } else if (flags & XBF_MAPPED) {
-                bp->b_addr = vm_map_ram(bp->b_pages, bp->b_page_count,
-                                        -1, PAGE_KERNEL);
-                if (unlikely(bp->b_addr == NULL))
+                int retried = 0;
+
+                do {
+                        bp->b_addr = vm_map_ram(bp->b_pages, bp->b_page_count,
+                                                -1, PAGE_KERNEL);
+                        if (bp->b_addr)
+                                break;
+                        vm_unmap_aliases();
+                } while (retried++ <= 1);
+
+                if (!bp->b_addr)
                         return -ENOMEM;
                 bp->b_addr += bp->b_offset;
                 bp->b_flags |= XBF_MAPPED;
@@ -568,9 +514,14 @@ found:
                 }
         }
 
+        /*
+         * if the buffer is stale, clear all the external state associated with
+         * it. We need to keep flags such as how we allocated the buffer memory
+         * intact here.
+         */
         if (bp->b_flags & XBF_STALE) {
                 ASSERT((bp->b_flags & _XBF_DELWRI_Q) == 0);
-                bp->b_flags &= XBF_MAPPED;
+                bp->b_flags &= XBF_MAPPED | _XBF_KMEM | _XBF_PAGES;
         }
 
         trace_xfs_buf_find(bp, flags, _RET_IP_);
@@ -591,7 +542,7 @@ xfs_buf_get(
         xfs_buf_flags_t         flags)
 {
         xfs_buf_t               *bp, *new_bp;
-        int                     error = 0, i;
+        int                     error = 0;
 
         new_bp = xfs_buf_allocate(flags);
         if (unlikely(!new_bp))
@@ -599,7 +550,7 @@ xfs_buf_get(
 
         bp = _xfs_buf_find(target, ioff, isize, flags, new_bp);
         if (bp == new_bp) {
-                error = _xfs_buf_lookup_pages(bp, flags);
+                error = xfs_buf_allocate_memory(bp, flags);
                 if (error)
                         goto no_buffer;
         } else {
@@ -608,9 +559,6 @@ xfs_buf_get(
                         return NULL;
         }
 
-        for (i = 0; i < bp->b_page_count; i++)
-                mark_page_accessed(bp->b_pages[i]);
-
         if (!(bp->b_flags & XBF_MAPPED)) {
                 error = _xfs_buf_map_pages(bp, flags);
                 if (unlikely(error)) {
@@ -711,8 +659,7 @@ xfs_buf_readahead(
 {
         struct backing_dev_info *bdi;
 
-        bdi = target->bt_mapping->backing_dev_info;
-        if (bdi_read_congested(bdi))
+        if (bdi_read_congested(target->bt_bdi))
                 return;
 
         xfs_buf_read(target, ioff, isize,
@@ -790,10 +737,10 @@ xfs_buf_associate_memory(
         size_t                  buflen;
         int                     page_count;
 
-        pageaddr = (unsigned long)mem & PAGE_CACHE_MASK;
+        pageaddr = (unsigned long)mem & PAGE_MASK;
         offset = (unsigned long)mem - pageaddr;
-        buflen = PAGE_CACHE_ALIGN(len + offset);
-        page_count = buflen >> PAGE_CACHE_SHIFT;
+        buflen = PAGE_ALIGN(len + offset);
+        page_count = buflen >> PAGE_SHIFT;
 
         /* Free any previous set of page pointers */
         if (bp->b_pages)
@@ -810,13 +757,12 @@ xfs_buf_associate_memory(
 
         for (i = 0; i < bp->b_page_count; i++) {
                 bp->b_pages[i] = mem_to_page((void *)pageaddr);
-                pageaddr += PAGE_CACHE_SIZE;
+                pageaddr += PAGE_SIZE;
         }
 
         bp->b_count_desired = len;
         bp->b_buffer_length = buflen;
         bp->b_flags |= XBF_MAPPED;
-        bp->b_flags &= ~_XBF_PAGE_LOCKED;
 
         return 0;
 }
@@ -923,20 +869,7 @@ xfs_buf_rele(
 
 
 /*
- *      Mutual exclusion on buffers.  Locking model:
- *
- *      Buffers associated with inodes for which buffer locking
- *      is not enabled are not protected by semaphores, and are
- *      assumed to be exclusively owned by the caller.  There is a
- *      spinlock in the buffer, used by the caller when concurrent
- *      access is possible.
- */
-
-/*
- *      Locks a buffer object, if it is not already locked.  Note that this in
- *      no way locks the underlying pages, so it is only useful for
- *      synchronizing concurrent use of buffer objects, not for synchronizing
- *      independent access to the underlying pages.
+ *      Lock a buffer object, if it is not already locked.
  *
  *      If we come across a stale, pinned, locked buffer, we know that we are
  *      being asked to lock a buffer that has been reallocated. Because it is
@@ -970,10 +903,7 @@ xfs_buf_lock_value(
 }
 
 /*
- *      Locks a buffer object.
- *      Note that this in no way locks the underlying pages, so it is only
- *      useful for synchronizing concurrent use of buffer objects, not for
- *      synchronizing independent access to the underlying pages.
+ *      Lock a buffer object.
  *
  *      If we come across a stale, pinned, locked buffer, we know that we
  *      are being asked to lock a buffer that has been reallocated. Because
@@ -1246,10 +1176,8 @@ _xfs_buf_ioend(
         xfs_buf_t               *bp,
         int                     schedule)
 {
-        if (atomic_dec_and_test(&bp->b_io_remaining) == 1) {
-                bp->b_flags &= ~_XBF_PAGE_LOCKED;
+        if (atomic_dec_and_test(&bp->b_io_remaining) == 1)
                 xfs_buf_ioend(bp, schedule);
-        }
 }
 
 STATIC void
@@ -1258,35 +1186,12 @@ xfs_buf_bio_end_io(
         int                     error)
 {
         xfs_buf_t               *bp = (xfs_buf_t *)bio->bi_private;
-        unsigned int            blocksize = bp->b_target->bt_bsize;
-        struct bio_vec          *bvec = bio->bi_io_vec + bio->bi_vcnt - 1;
 
         xfs_buf_ioerror(bp, -error);
 
         if (!error && xfs_buf_is_vmapped(bp) && (bp->b_flags & XBF_READ))
                 invalidate_kernel_vmap_range(bp->b_addr, xfs_buf_vmap_len(bp));
 
-        do {
-                struct page     *page = bvec->bv_page;
-
-                ASSERT(!PagePrivate(page));
-                if (unlikely(bp->b_error)) {
-                        if (bp->b_flags & XBF_READ)
-                                ClearPageUptodate(page);
-                } else if (blocksize >= PAGE_CACHE_SIZE) {
-                        SetPageUptodate(page);
-                } else if (!PagePrivate(page) &&
-                                (bp->b_flags & _XBF_PAGE_CACHE)) {
-                        set_page_region(page, bvec->bv_offset, bvec->bv_len);
-                }
-
-                if (--bvec >= bio->bi_io_vec)
-                        prefetchw(&bvec->bv_page->flags);
-
-                if (bp->b_flags & _XBF_PAGE_LOCKED)
-                        unlock_page(page);
-        } while (bvec >= bio->bi_io_vec);
-
         _xfs_buf_ioend(bp, 1);
         bio_put(bio);
 }
@@ -1300,7 +1205,6 @@ _xfs_buf_ioapply(
         int                     offset = bp->b_offset;
         int                     size = bp->b_count_desired;
         sector_t                sector = bp->b_bn;
-        unsigned int            blocksize = bp->b_target->bt_bsize;
 
         total_nr_pages = bp->b_page_count;
         map_i = 0;
@@ -1321,29 +1225,6 @@ _xfs_buf_ioapply(
                      (bp->b_flags & XBF_READ_AHEAD) ? READA : READ;
         }
 
-        /* Special code path for reading a sub page size buffer in --
-         * we populate up the whole page, and hence the other metadata
-         * in the same page.  This optimization is only valid when the
-         * filesystem block size is not smaller than the page size.
-         */
-        if ((bp->b_buffer_length < PAGE_CACHE_SIZE) &&
-            ((bp->b_flags & (XBF_READ|_XBF_PAGE_LOCKED)) ==
-              (XBF_READ|_XBF_PAGE_LOCKED)) &&
-            (blocksize >= PAGE_CACHE_SIZE)) {
-                bio = bio_alloc(GFP_NOIO, 1);
-
-                bio->bi_bdev = bp->b_target->bt_bdev;
-                bio->bi_sector = sector - (offset >> BBSHIFT);
-                bio->bi_end_io = xfs_buf_bio_end_io;
-                bio->bi_private = bp;
-
-                bio_add_page(bio, bp->b_pages[0], PAGE_CACHE_SIZE, 0);
-                size = 0;
-
-                atomic_inc(&bp->b_io_remaining);
-
-                goto submit_io;
-        }
 
 next_chunk:
         atomic_inc(&bp->b_io_remaining);
@@ -1357,8 +1238,9 @@ next_chunk:
         bio->bi_end_io = xfs_buf_bio_end_io;
         bio->bi_private = bp;
 
+
         for (; size && nr_pages; nr_pages--, map_i++) {
-                int     rbytes, nbytes = PAGE_CACHE_SIZE - offset;
+                int     rbytes, nbytes = PAGE_SIZE - offset;
 
                 if (nbytes > size)
                         nbytes = size;
@@ -1373,7 +1255,6 @@ next_chunk:
                 total_nr_pages--;
         }
 
-submit_io:
         if (likely(bio->bi_size)) {
                 if (xfs_buf_is_vmapped(bp)) {
                         flush_kernel_vmap_range(bp->b_addr,
@@ -1383,18 +1264,7 @@ submit_io:
                 if (size)
                         goto next_chunk;
         } else {
-                /*
-                 * if we get here, no pages were added to the bio. However,
-                 * we can't just error out here - if the pages are locked then
-                 * we have to unlock them otherwise we can hang on a later
-                 * access to the page.
-                 */
                 xfs_buf_ioerror(bp, EIO);
-                if (bp->b_flags & _XBF_PAGE_LOCKED) {
-                        int i;
-                        for (i = 0; i < bp->b_page_count; i++)
-                                unlock_page(bp->b_pages[i]);
-                }
                 bio_put(bio);
         }
 }
@@ -1458,8 +1328,8 @@ xfs_buf_offset(
                 return XFS_BUF_PTR(bp) + offset;
 
         offset += bp->b_offset;
-        page = bp->b_pages[offset >> PAGE_CACHE_SHIFT];
-        return (xfs_caddr_t)page_address(page) + (offset & (PAGE_CACHE_SIZE-1));
+        page = bp->b_pages[offset >> PAGE_SHIFT];
+        return (xfs_caddr_t)page_address(page) + (offset & (PAGE_SIZE-1));
 }
 
 /*
@@ -1481,9 +1351,9 @@ xfs_buf_iomove(
                 page = bp->b_pages[xfs_buf_btoct(boff + bp->b_offset)];
                 cpoff = xfs_buf_poff(boff + bp->b_offset);
                 csize = min_t(size_t,
-                              PAGE_CACHE_SIZE-cpoff, bp->b_count_desired-boff);
+                              PAGE_SIZE-cpoff, bp->b_count_desired-boff);
 
-                ASSERT(((csize + cpoff) <= PAGE_CACHE_SIZE));
+                ASSERT(((csize + cpoff) <= PAGE_SIZE));
 
                 switch (mode) {
                 case XBRW_ZERO:
@@ -1596,7 +1466,6 @@ xfs_free_buftarg(
         xfs_flush_buftarg(btp, 1);
         if (mp->m_flags & XFS_MOUNT_BARRIER)
                 xfs_blkdev_issue_flush(btp);
-        iput(btp->bt_mapping->host);
 
         kthread_stop(btp->bt_task);
         kmem_free(btp);
@@ -1620,15 +1489,6 @@ xfs_setsize_buftarg_flags(
                 return EINVAL;
         }
 
-        if (verbose &&
-            (PAGE_CACHE_SIZE / BITS_PER_LONG) > sectorsize) {
-                printk(KERN_WARNING
-                        "XFS: %u byte sectors in use on device %s.  "
-                        "This is suboptimal; %u or greater is ideal.\n",
-                        sectorsize, XFS_BUFTARG_NAME(btp),
-                        (unsigned int)PAGE_CACHE_SIZE / BITS_PER_LONG);
-        }
-
         return 0;
 }
 
@@ -1643,7 +1503,7 @@ xfs_setsize_buftarg_early(
         struct block_device     *bdev)
 {
         return xfs_setsize_buftarg_flags(btp,
-                        PAGE_CACHE_SIZE, bdev_logical_block_size(bdev), 0);
+                        PAGE_SIZE, bdev_logical_block_size(bdev), 0);
 }
 
 int
@@ -1656,40 +1516,6 @@ xfs_setsize_buftarg(
 }
 
 STATIC int
-xfs_mapping_buftarg(
-        xfs_buftarg_t           *btp,
-        struct block_device     *bdev)
-{
-        struct backing_dev_info *bdi;
-        struct inode            *inode;
-        struct address_space    *mapping;
-        static const struct address_space_operations mapping_aops = {
-                .migratepage = fail_migrate_page,
-        };
-
-        inode = new_inode(bdev->bd_inode->i_sb);
-        if (!inode) {
-                printk(KERN_WARNING
-                        "XFS: Cannot allocate mapping inode for device %s\n",
-                        XFS_BUFTARG_NAME(btp));
-                return ENOMEM;
-        }
-        inode->i_ino = get_next_ino();
-        inode->i_mode = S_IFBLK;
-        inode->i_bdev = bdev;
-        inode->i_rdev = bdev->bd_dev;
-        bdi = blk_get_backing_dev_info(bdev);
-        if (!bdi)
-                bdi = &default_backing_dev_info;
-        mapping = &inode->i_data;
-        mapping->a_ops = &mapping_aops;
-        mapping->backing_dev_info = bdi;
-        mapping_set_gfp_mask(mapping, GFP_NOFS);
-        btp->bt_mapping = mapping;
-        return 0;
-}
-
-STATIC int
 xfs_alloc_delwrite_queue(
         xfs_buftarg_t           *btp,
         const char              *fsname)
@@ -1717,12 +1543,14 @@ xfs_alloc_buftarg(
         btp->bt_mount = mp;
         btp->bt_dev =  bdev->bd_dev;
         btp->bt_bdev = bdev;
+        btp->bt_bdi = blk_get_backing_dev_info(bdev);
+        if (!btp->bt_bdi)
+                goto error;
+
         INIT_LIST_HEAD(&btp->bt_lru);
         spin_lock_init(&btp->bt_lru_lock);
         if (xfs_setsize_buftarg_early(btp, bdev))
                 goto error;
-        if (xfs_mapping_buftarg(btp, bdev))
-                goto error;
         if (xfs_alloc_delwrite_queue(btp, fsname))
                 goto error;
         btp->bt_shrinker.shrink = xfs_buftarg_shrink;
diff --git a/fs/xfs/linux-2.6/xfs_buf.h b/fs/xfs/linux-2.6/xfs_buf.h
index cbe65950e524..a9a1c4512645 100644
--- a/fs/xfs/linux-2.6/xfs_buf.h
+++ b/fs/xfs/linux-2.6/xfs_buf.h
@@ -61,30 +61,11 @@ typedef enum {
 #define XBF_DONT_BLOCK  (1 << 16)/* do not block in current thread */
 
 /* flags used only internally */
-#define _XBF_PAGE_CACHE (1 << 17)/* backed by pagecache */
 #define _XBF_PAGES      (1 << 18)/* backed by refcounted pages */
 #define _XBF_RUN_QUEUES (1 << 19)/* run block device task queue */
+#define _XBF_KMEM       (1 << 20)/* backed by heap memory */
 #define _XBF_DELWRI_Q   (1 << 21)/* buffer on delwri queue */
 
-/*
- * Special flag for supporting metadata blocks smaller than a FSB.
- *
- * In this case we can have multiple xfs_buf_t on a single page and
- * need to lock out concurrent xfs_buf_t readers as they only
- * serialise access to the buffer.
- *
- * If the FSB size >= PAGE_CACHE_SIZE case, we have no serialisation
- * between reads of the page. Hence we can have one thread read the
- * page and modify it, but then race with another thread that thinks
- * the page is not up-to-date and hence reads it again.
- *
- * The result is that the first modifcation to the page is lost.
- * This sort of AGF/AGI reading race can happen when unlinking inodes
- * that require truncation and results in the AGI unlinked list
- * modifications being lost.
- */
-#define _XBF_PAGE_LOCKED        (1 << 22)
-
 typedef unsigned int xfs_buf_flags_t;
 
 #define XFS_BUF_FLAGS \
@@ -100,12 +81,10 @@ typedef unsigned int xfs_buf_flags_t;
         { XBF_LOCK,             "LOCK" },       /* should never be set */\
         { XBF_TRYLOCK,          "TRYLOCK" },    /* ditto */\
         { XBF_DONT_BLOCK,       "DONT_BLOCK" }, /* ditto */\
-        { _XBF_PAGE_CACHE,      "PAGE_CACHE" }, \
         { _XBF_PAGES,           "PAGES" }, \
         { _XBF_RUN_QUEUES,      "RUN_QUEUES" }, \
-        { _XBF_DELWRI_Q,        "DELWRI_Q" }, \
-        { _XBF_PAGE_LOCKED,     "PAGE_LOCKED" }
-
+        { _XBF_KMEM,            "KMEM" }, \
+        { _XBF_DELWRI_Q,        "DELWRI_Q" }
 
 typedef enum {
         XBT_FORCE_SLEEP = 0,
@@ -120,7 +99,7 @@ typedef struct xfs_bufhash {
 typedef struct xfs_buftarg {
         dev_t                   bt_dev;
         struct block_device     *bt_bdev;
-        struct address_space    *bt_mapping;
+        struct backing_dev_info *bt_bdi;
         struct xfs_mount        *bt_mount;
         unsigned int            bt_bsize;
         unsigned int            bt_sshift;
@@ -139,17 +118,6 @@ typedef struct xfs_buftarg {
         unsigned int            bt_lru_nr;
 } xfs_buftarg_t;
 
-/*
- *      xfs_buf_t:  Buffer structure for pagecache-based buffers
- *
- * This buffer structure is used by the pagecache buffer management routines
- * to refer to an assembly of pages forming a logical buffer.
- *
- * The buffer structure is used on a temporary basis only, and discarded when
- * released.  The real data storage is recorded in the pagecache. Buffers are
- * hashed to the block device on which the file system resides.
- */
-
 struct xfs_buf;
 typedef void (*xfs_buf_iodone_t)(struct xfs_buf *);
 
diff --git a/fs/xfs/linux-2.6/xfs_file.c b/fs/xfs/linux-2.6/xfs_file.c
index a55c1b46b219..52aadfbed132 100644
--- a/fs/xfs/linux-2.6/xfs_file.c
+++ b/fs/xfs/linux-2.6/xfs_file.c
@@ -896,6 +896,7 @@ xfs_file_fallocate(
         xfs_flock64_t   bf;
         xfs_inode_t     *ip = XFS_I(inode);
         int             cmd = XFS_IOC_RESVSP;
+        int             attr_flags = XFS_ATTR_NOLOCK;
 
         if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE))
                 return -EOPNOTSUPP;
@@ -918,7 +919,10 @@ xfs_file_fallocate(
                         goto out_unlock;
         }
 
-        error = -xfs_change_file_space(ip, cmd, &bf, 0, XFS_ATTR_NOLOCK);
+        if (file->f_flags & O_DSYNC)
+                attr_flags |= XFS_ATTR_SYNC;
+
+        error = -xfs_change_file_space(ip, cmd, &bf, 0, attr_flags);
         if (error)
                 goto out_unlock;
 
diff --git a/fs/xfs/linux-2.6/xfs_ioctl.c b/fs/xfs/linux-2.6/xfs_ioctl.c
index 0ca0e3c024d7..acca2c5ca3fa 100644
--- a/fs/xfs/linux-2.6/xfs_ioctl.c
+++ b/fs/xfs/linux-2.6/xfs_ioctl.c
@@ -624,6 +624,10 @@ xfs_ioc_space(
 
         if (filp->f_flags & (O_NDELAY|O_NONBLOCK))
                 attr_flags |= XFS_ATTR_NONBLOCK;
+
+        if (filp->f_flags & O_DSYNC)
+                attr_flags |= XFS_ATTR_SYNC;
+
         if (ioflags & IO_INVIS)
                 attr_flags |= XFS_ATTR_DMI;
 
diff --git a/fs/xfs/linux-2.6/xfs_super.c b/fs/xfs/linux-2.6/xfs_super.c
index 818c4cf2de86..1ba5c451da36 100644
--- a/fs/xfs/linux-2.6/xfs_super.c
+++ b/fs/xfs/linux-2.6/xfs_super.c
@@ -1078,7 +1078,7 @@ xfs_fs_write_inode(
                         error = 0;
                         goto out_unlock;
                 }
-                error = xfs_iflush(ip, 0);
+                error = xfs_iflush(ip, SYNC_TRYLOCK);
         }
 
  out_unlock:
@@ -1539,10 +1539,14 @@ xfs_fs_fill_super(
         if (error)
                 goto out_free_sb;
 
-        error = xfs_mountfs(mp);
-        if (error)
-                goto out_filestream_unmount;
-
+        /*
+         * we must configure the block size in the superblock before we run the
+         * full mount process as the mount process can lookup and cache inodes.
+         * For the same reason we must also initialise the syncd and register
+         * the inode cache shrinker so that inodes can be reclaimed during
+         * operations like a quotacheck that iterate all inodes in the
+         * filesystem.
+         */
         sb->s_magic = XFS_SB_MAGIC;
         sb->s_blocksize = mp->m_sb.sb_blocksize;
         sb->s_blocksize_bits = ffs(sb->s_blocksize) - 1;
@@ -1550,6 +1554,16 @@ xfs_fs_fill_super(
         sb->s_time_gran = 1;
         set_posix_acl_flag(sb);
 
+        error = xfs_syncd_init(mp);
+        if (error)
+                goto out_filestream_unmount;
+
+        xfs_inode_shrinker_register(mp);
+
+        error = xfs_mountfs(mp);
+        if (error)
+                goto out_syncd_stop;
+
         root = igrab(VFS_I(mp->m_rootip));
         if (!root) {
                 error = ENOENT;
@@ -1565,14 +1579,11 @@ xfs_fs_fill_super(
                 goto fail_vnrele;
         }
 
-        error = xfs_syncd_init(mp);
-        if (error)
-                goto fail_vnrele;
-
-        xfs_inode_shrinker_register(mp);
-
         return 0;
 
+ out_syncd_stop:
+        xfs_inode_shrinker_unregister(mp);
+        xfs_syncd_stop(mp);
  out_filestream_unmount:
         xfs_filestream_unmount(mp);
  out_free_sb:
@@ -1596,6 +1607,9 @@ xfs_fs_fill_super(
         }
 
  fail_unmount:
+        xfs_inode_shrinker_unregister(mp);
+        xfs_syncd_stop(mp);
+
         /*
          * Blow away any referenced inode in the filestreams cache.
          * This can and will cause log traffic as inodes go inactive
diff --git a/fs/xfs/linux-2.6/xfs_sync.c b/fs/xfs/linux-2.6/xfs_sync.c
index 6c10f1d2e3d3..594cd822d84d 100644
--- a/fs/xfs/linux-2.6/xfs_sync.c
+++ b/fs/xfs/linux-2.6/xfs_sync.c
@@ -761,8 +761,10 @@ xfs_reclaim_inode(
         struct xfs_perag        *pag,
         int                     sync_mode)
 {
-        int     error = 0;
+        int     error;
 
+restart:
+        error = 0;
         xfs_ilock(ip, XFS_ILOCK_EXCL);
         if (!xfs_iflock_nowait(ip)) {
                 if (!(sync_mode & SYNC_WAIT))
@@ -788,9 +790,31 @@ xfs_reclaim_inode(
         if (xfs_inode_clean(ip))
                 goto reclaim;
 
-        /* Now we have an inode that needs flushing */
-        error = xfs_iflush(ip, sync_mode);
+        /*
+         * Now we have an inode that needs flushing.
+         *
+         * We do a nonblocking flush here even if we are doing a SYNC_WAIT
+         * reclaim as we can deadlock with inode cluster removal.
+         * xfs_ifree_cluster() can lock the inode buffer before it locks the
+         * ip->i_lock, and we are doing the exact opposite here. As a result,
+         * doing a blocking xfs_itobp() to get the cluster buffer will result
+         * in an ABBA deadlock with xfs_ifree_cluster().
+         *
+         * As xfs_ifree_cluser() must gather all inodes that are active in the
+         * cache to mark them stale, if we hit this case we don't actually want
+         * to do IO here - we want the inode marked stale so we can simply
+         * reclaim it. Hence if we get an EAGAIN error on a SYNC_WAIT flush,
+         * just unlock the inode, back off and try again. Hopefully the next
+         * pass through will see the stale flag set on the inode.
+         */
+        error = xfs_iflush(ip, SYNC_TRYLOCK | sync_mode);
         if (sync_mode & SYNC_WAIT) {
+                if (error == EAGAIN) {
+                        xfs_iunlock(ip, XFS_ILOCK_EXCL);
+                        /* backoff longer than in xfs_ifree_cluster */
+                        delay(2);
+                        goto restart;
+                }
                 xfs_iflock(ip);
                 goto reclaim;
         }
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index da871f532236..742c8330994a 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -2835,7 +2835,7 @@ xfs_iflush(
          * Get the buffer containing the on-disk inode.
          */
         error = xfs_itobp(mp, NULL, ip, &dip, &bp,
-                                (flags & SYNC_WAIT) ? XBF_LOCK : XBF_TRYLOCK);
+                                (flags & SYNC_TRYLOCK) ? XBF_TRYLOCK : XBF_LOCK);
         if (error || !bp) {
                 xfs_ifunlock(ip);
                 return error;
diff --git a/fs/xfs/xfs_inode_item.c b/fs/xfs/xfs_inode_item.c
index fd4f398bd6f1..46cc40131d4a 100644
--- a/fs/xfs/xfs_inode_item.c
+++ b/fs/xfs/xfs_inode_item.c
@@ -760,11 +760,11 @@ xfs_inode_item_push(
          * Push the inode to it's backing buffer. This will not remove the
          * inode from the AIL - a further push will be required to trigger a
          * buffer push. However, this allows all the dirty inodes to be pushed
-         * to the buffer before it is pushed to disk. THe buffer IO completion
-         * will pull th einode from the AIL, mark it clean and unlock the flush
+         * to the buffer before it is pushed to disk. The buffer IO completion
+         * will pull the inode from the AIL, mark it clean and unlock the flush
          * lock.
          */
-        (void) xfs_iflush(ip, 0);
+        (void) xfs_iflush(ip, SYNC_TRYLOCK);
         xfs_iunlock(ip, XFS_ILOCK_SHARED);
 }
 
diff --git a/fs/xfs/xfs_trans_buf.c b/fs/xfs/xfs_trans_buf.c
index 3bea66132334..03b3b7f85a3b 100644
--- a/fs/xfs/xfs_trans_buf.c
+++ b/fs/xfs/xfs_trans_buf.c
@@ -383,7 +383,8 @@ xfs_trans_read_buf(
         bp = xfs_buf_read(target, blkno, len, flags | XBF_DONT_BLOCK);
         if (bp == NULL) {
                 *bpp = NULL;
-                return 0;
+                return (flags & XBF_TRYLOCK) ?
+                                        0 : XFS_ERROR(ENOMEM);
         }
         if (XFS_BUF_GETERROR(bp) != 0) {
             XFS_BUF_SUPER_STALE(bp);
diff --git a/fs/xfs/xfs_vnodeops.c b/fs/xfs/xfs_vnodeops.c
index 37d8146ee15b..c48b4217ec47 100644
--- a/fs/xfs/xfs_vnodeops.c
+++ b/fs/xfs/xfs_vnodeops.c
@@ -2831,7 +2831,8 @@ xfs_change_file_space(
                 ip->i_d.di_flags &= ~XFS_DIFLAG_PREALLOC;
 
         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
-        xfs_trans_set_sync(tp);
+        if (attr_flags & XFS_ATTR_SYNC)
+                xfs_trans_set_sync(tp);
 
         error = xfs_trans_commit(tp, 0);
 
diff --git a/fs/xfs/xfs_vnodeops.h b/fs/xfs/xfs_vnodeops.h
index f6702927eee4..3bcd23353d6c 100644
--- a/fs/xfs/xfs_vnodeops.h
+++ b/fs/xfs/xfs_vnodeops.h
@@ -18,6 +18,7 @@ int xfs_setattr(struct xfs_inode *ip, struct iattr *vap, int flags);
 #define XFS_ATTR_NONBLOCK       0x02    /* return EAGAIN if operation would block */
 #define XFS_ATTR_NOLOCK         0x04    /* Don't grab any conflicting locks */
 #define XFS_ATTR_NOACL          0x08    /* Don't call xfs_acl_chmod */
+#define XFS_ATTR_SYNC           0x10    /* synchronous operation required */
 
 int xfs_readlink(struct xfs_inode *ip, char *link);
 int xfs_release(struct xfs_inode *ip);
diff --git a/include/linux/fs.h b/include/linux/fs.h
index b677bd77f2d6..52f283c1edb2 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -357,6 +357,8 @@ struct inodes_stat_t {
 #define FS_TOPDIR_FL                    0x00020000 /* Top of directory hierarchies*/
 #define FS_EXTENT_FL                    0x00080000 /* Extents */
 #define FS_DIRECTIO_FL                  0x00100000 /* Use direct i/o */
+#define FS_NOCOW_FL                     0x00800000 /* Do not cow file */
+#define FS_COW_FL                       0x02000000 /* Cow file */
 #define FS_RESERVED_FL                  0x80000000 /* reserved for ext2 lib */
 
 #define FS_FL_USER_VISIBLE              0x0003DFFF /* User visible flags */
diff --git a/include/linux/input.h b/include/linux/input.h
index 056ae8a5bd9b..f3a7794a18c4 100644
--- a/include/linux/input.h
+++ b/include/linux/input.h
@@ -664,6 +664,13 @@ struct input_keymap_entry {
 #define KEY_TOUCHPAD_ON         0x213
 #define KEY_TOUCHPAD_OFF        0x214
 
+#define KEY_CAMERA_ZOOMIN       0x215
+#define KEY_CAMERA_ZOOMOUT      0x216
+#define KEY_CAMERA_UP           0x217
+#define KEY_CAMERA_DOWN         0x218
+#define KEY_CAMERA_LEFT         0x219
+#define KEY_CAMERA_RIGHT        0x21a
+
 #define BTN_TRIGGER_HAPPY               0x2c0
 #define BTN_TRIGGER_HAPPY1              0x2c0
 #define BTN_TRIGGER_HAPPY2              0x2c1
diff --git a/include/linux/irq.h b/include/linux/irq.h
index 5d876c9b3a3d..b3741c83774c 100644
--- a/include/linux/irq.h
+++ b/include/linux/irq.h
@@ -135,7 +135,7 @@ struct msi_desc;
  * struct irq_data - per irq and irq chip data passed down to chip functions
  * @irq:                interrupt number
  * @node:               node index useful for balancing
- * @state_use_accessor: status information for irq chip functions.
+ * @state_use_accessors: status information for irq chip functions.
  *                      Use accessor functions to deal with it
  * @chip:               low level interrupt hardware access
  * @handler_data:       per-IRQ data for the irq_chip methods
@@ -174,6 +174,9 @@ struct irq_data {
  *                                from suspend
  * IRDQ_MOVE_PCNTXT             - Interrupt can be moved in process
  *                                context
+ * IRQD_IRQ_DISABLED            - Disabled state of the interrupt
+ * IRQD_IRQ_MASKED              - Masked state of the interrupt
+ * IRQD_IRQ_INPROGRESS          - In progress state of the interrupt
  */
 enum {
         IRQD_TRIGGER_MASK               = 0xf,
@@ -184,6 +187,9 @@ enum {
         IRQD_LEVEL                      = (1 << 13),
         IRQD_WAKEUP_STATE               = (1 << 14),
         IRQD_MOVE_PCNTXT                = (1 << 15),
+        IRQD_IRQ_DISABLED               = (1 << 16),
+        IRQD_IRQ_MASKED                 = (1 << 17),
+        IRQD_IRQ_INPROGRESS             = (1 << 18),
 };
 
 static inline bool irqd_is_setaffinity_pending(struct irq_data *d)
@@ -206,6 +212,11 @@ static inline bool irqd_affinity_was_set(struct irq_data *d)
         return d->state_use_accessors & IRQD_AFFINITY_SET;
 }
 
+static inline void irqd_mark_affinity_was_set(struct irq_data *d)
+{
+        d->state_use_accessors |= IRQD_AFFINITY_SET;
+}
+
 static inline u32 irqd_get_trigger_type(struct irq_data *d)
 {
         return d->state_use_accessors & IRQD_TRIGGER_MASK;
@@ -235,6 +246,36 @@ static inline bool irqd_can_move_in_process_context(struct irq_data *d)
         return d->state_use_accessors & IRQD_MOVE_PCNTXT;
 }
 
+static inline bool irqd_irq_disabled(struct irq_data *d)
+{
+        return d->state_use_accessors & IRQD_IRQ_DISABLED;
+}
+
+static inline bool irqd_irq_masked(struct irq_data *d)
+{
+        return d->state_use_accessors & IRQD_IRQ_MASKED;
+}
+
+static inline bool irqd_irq_inprogress(struct irq_data *d)
+{
+        return d->state_use_accessors & IRQD_IRQ_INPROGRESS;
+}
+
+/*
+ * Functions for chained handlers which can be enabled/disabled by the
+ * standard disable_irq/enable_irq calls. Must be called with
+ * irq_desc->lock held.
+ */
+static inline void irqd_set_chained_irq_inprogress(struct irq_data *d)
+{
+        d->state_use_accessors |= IRQD_IRQ_INPROGRESS;
+}
+
+static inline void irqd_clr_chained_irq_inprogress(struct irq_data *d)
+{
+        d->state_use_accessors &= ~IRQD_IRQ_INPROGRESS;
+}
+
 /**
  * struct irq_chip - hardware interrupt chip descriptor
  *
@@ -271,6 +312,8 @@ static inline bool irqd_can_move_in_process_context(struct irq_data *d)
  * @irq_set_wake:       enable/disable power-management wake-on of an IRQ
  * @irq_bus_lock:       function to lock access to slow bus (i2c) chips
  * @irq_bus_sync_unlock:function to sync and unlock slow bus (i2c) chips
+ * @irq_cpu_online:     configure an interrupt source for a secondary CPU
+ * @irq_cpu_offline:    un-configure an interrupt source for a secondary CPU
  * @irq_print_chip:     optional to print special chip info in show_interrupts
  * @flags:              chip specific flags
  *
@@ -319,6 +362,9 @@ struct irq_chip {
         void            (*irq_bus_lock)(struct irq_data *data);
         void            (*irq_bus_sync_unlock)(struct irq_data *data);
 
+        void            (*irq_cpu_online)(struct irq_data *data);
+        void            (*irq_cpu_offline)(struct irq_data *data);
+
         void            (*irq_print_chip)(struct irq_data *data, struct seq_file *p);
 
         unsigned long   flags;
@@ -335,11 +381,14 @@ struct irq_chip {
  * IRQCHIP_SET_TYPE_MASKED:     Mask before calling chip.irq_set_type()
  * IRQCHIP_EOI_IF_HANDLED:      Only issue irq_eoi() when irq was handled
  * IRQCHIP_MASK_ON_SUSPEND:     Mask non wake irqs in the suspend path
+ * IRQCHIP_ONOFFLINE_ENABLED:   Only call irq_on/off_line callbacks
+ *                              when irq enabled
  */
 enum {
         IRQCHIP_SET_TYPE_MASKED         = (1 <<  0),
         IRQCHIP_EOI_IF_HANDLED          = (1 <<  1),
         IRQCHIP_MASK_ON_SUSPEND         = (1 <<  2),
+        IRQCHIP_ONOFFLINE_ENABLED       = (1 <<  3),
 };
 
 /* This include will go away once we isolated irq_desc usage to core code */
@@ -364,6 +413,10 @@ struct irqaction;
 extern int setup_irq(unsigned int irq, struct irqaction *new);
 extern void remove_irq(unsigned int irq, struct irqaction *act);
 
+extern void irq_cpu_online(void);
+extern void irq_cpu_offline(void);
+extern int __irq_set_affinity_locked(struct irq_data *data,  const struct cpumask *cpumask);
+
 #ifdef CONFIG_GENERIC_HARDIRQS
 
 #if defined(CONFIG_SMP) && defined(CONFIG_GENERIC_PENDING_IRQ)
@@ -380,9 +433,6 @@ static inline void irq_move_masked_irq(struct irq_data *data) { }
 
 extern int no_irq_affinity;
 
-/* Handle irq action chains: */
-extern irqreturn_t handle_IRQ_event(unsigned int irq, struct irqaction *action);
-
 /*
  * Built-in IRQ handlers for various IRQ types,
  * callable via desc->handle_irq()
@@ -390,6 +440,7 @@ extern irqreturn_t handle_IRQ_event(unsigned int irq, struct irqaction *action);
 extern void handle_level_irq(unsigned int irq, struct irq_desc *desc);
 extern void handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc);
 extern void handle_edge_irq(unsigned int irq, struct irq_desc *desc);
+extern void handle_edge_eoi_irq(unsigned int irq, struct irq_desc *desc);
 extern void handle_simple_irq(unsigned int irq, struct irq_desc *desc);
 extern void handle_percpu_irq(unsigned int irq, struct irq_desc *desc);
 extern void handle_bad_irq(unsigned int irq, struct irq_desc *desc);
diff --git a/include/linux/mfd/ab8500.h b/include/linux/mfd/ab8500.h
index 6e4f77ef4d20..b31843075198 100644
--- a/include/linux/mfd/ab8500.h
+++ b/include/linux/mfd/ab8500.h
@@ -74,6 +74,45 @@
 #define AB8500_INT_ACC_DETECT_21DB_F    37
 #define AB8500_INT_ACC_DETECT_21DB_R    38
 #define AB8500_INT_GP_SW_ADC_CONV_END   39
+#define AB8500_INT_ACC_DETECT_1DB_F     33
+#define AB8500_INT_ACC_DETECT_1DB_R     34
+#define AB8500_INT_ACC_DETECT_22DB_F    35
+#define AB8500_INT_ACC_DETECT_22DB_R    36
+#define AB8500_INT_ACC_DETECT_21DB_F    37
+#define AB8500_INT_ACC_DETECT_21DB_R    38
+#define AB8500_INT_GP_SW_ADC_CONV_END   39
+#define AB8500_INT_GPIO6R               40
+#define AB8500_INT_GPIO7R               41
+#define AB8500_INT_GPIO8R               42
+#define AB8500_INT_GPIO9R               43
+#define AB8500_INT_GPIO10R              44
+#define AB8500_INT_GPIO11R              45
+#define AB8500_INT_GPIO12R              46
+#define AB8500_INT_GPIO13R              47
+#define AB8500_INT_GPIO24R              48
+#define AB8500_INT_GPIO25R              49
+#define AB8500_INT_GPIO36R              50
+#define AB8500_INT_GPIO37R              51
+#define AB8500_INT_GPIO38R              52
+#define AB8500_INT_GPIO39R              53
+#define AB8500_INT_GPIO40R              54
+#define AB8500_INT_GPIO41R              55
+#define AB8500_INT_GPIO6F               56
+#define AB8500_INT_GPIO7F               57
+#define AB8500_INT_GPIO8F               58
+#define AB8500_INT_GPIO9F               59
+#define AB8500_INT_GPIO10F              60
+#define AB8500_INT_GPIO11F              61
+#define AB8500_INT_GPIO12F              62
+#define AB8500_INT_GPIO13F              63
+#define AB8500_INT_GPIO24F              64
+#define AB8500_INT_GPIO25F              65
+#define AB8500_INT_GPIO36F              66
+#define AB8500_INT_GPIO37F              67
+#define AB8500_INT_GPIO38F              68
+#define AB8500_INT_GPIO39F              69
+#define AB8500_INT_GPIO40F              70
+#define AB8500_INT_GPIO41F              71
 #define AB8500_INT_ADP_SOURCE_ERROR     72
 #define AB8500_INT_ADP_SINK_ERROR       73
 #define AB8500_INT_ADP_PROBE_PLUG       74
@@ -141,6 +180,7 @@ struct ab8500 {
 
 struct regulator_reg_init;
 struct regulator_init_data;
+struct ab8500_gpio_platform_data;
 
 /**
  * struct ab8500_platform_data - AB8500 platform data
@@ -158,6 +198,7 @@ struct ab8500_platform_data {
         struct ab8500_regulator_reg_init *regulator_reg_init;
         int num_regulator;
         struct regulator_init_data *regulator;
+        struct ab8500_gpio_platform_data *gpio;
 };
 
 extern int __devinit ab8500_init(struct ab8500 *ab8500);
diff --git a/include/linux/mfd/ab8500/gpio.h b/include/linux/mfd/ab8500/gpio.h
new file mode 100644
index 000000000000..488a8c920a29
--- /dev/null
+++ b/include/linux/mfd/ab8500/gpio.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright ST-Ericsson 2010.
+ *
+ * Author: Bibek Basu <bibek.basu@stericsson.com>
+ * Licensed under GPLv2.
+ */
+
+#ifndef _AB8500_GPIO_H
+#define _AB8500_GPIO_H
+
+/*
+ * Platform data to register a block: only the initial gpio/irq number.
+ */
+
+struct ab8500_gpio_platform_data {
+        int gpio_base;
+        u32 irq_base;
+        u8  config_reg[7];
+};
+
+#endif /* _AB8500_GPIO_H */
diff --git a/include/linux/sonypi.h b/include/linux/sonypi.h
index 0e6dc3891942..c0f87da78f8a 100644
--- a/include/linux/sonypi.h
+++ b/include/linux/sonypi.h
@@ -40,6 +40,7 @@
 
 /* events the user application reading /dev/sonypi can use */
 
+#define SONYPI_EVENT_IGNORE                      0
 #define SONYPI_EVENT_JOGDIAL_DOWN                1
 #define SONYPI_EVENT_JOGDIAL_UP                  2
 #define SONYPI_EVENT_JOGDIAL_DOWN_PRESSED        3
diff --git a/include/trace/events/btrfs.h b/include/trace/events/btrfs.h
new file mode 100644
index 000000000000..f445cff66ab7
--- /dev/null
+++ b/include/trace/events/btrfs.h
@@ -0,0 +1,667 @@
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM btrfs
+
+#if !defined(_TRACE_BTRFS_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_BTRFS_H
+
+#include <linux/writeback.h>
+#include <linux/tracepoint.h>
+
+struct btrfs_root;
+struct btrfs_fs_info;
+struct btrfs_inode;
+struct extent_map;
+struct btrfs_ordered_extent;
+struct btrfs_delayed_ref_node;
+struct btrfs_delayed_tree_ref;
+struct btrfs_delayed_data_ref;
+struct btrfs_delayed_ref_head;
+struct map_lookup;
+struct extent_buffer;
+
+#define show_ref_type(type)                                             \
+        __print_symbolic(type,                                          \
+                { BTRFS_TREE_BLOCK_REF_KEY,     "TREE_BLOCK_REF" },     \
+                { BTRFS_EXTENT_DATA_REF_KEY,    "EXTENT_DATA_REF" },    \
+                { BTRFS_EXTENT_REF_V0_KEY,      "EXTENT_REF_V0" },      \
+                { BTRFS_SHARED_BLOCK_REF_KEY,   "SHARED_BLOCK_REF" },   \
+                { BTRFS_SHARED_DATA_REF_KEY,    "SHARED_DATA_REF" })
+
+#define __show_root_type(obj)                                           \
+        __print_symbolic(obj,                                           \
+                { BTRFS_ROOT_TREE_OBJECTID,     "ROOT_TREE"     },      \
+                { BTRFS_EXTENT_TREE_OBJECTID,   "EXTENT_TREE"   },      \
+                { BTRFS_CHUNK_TREE_OBJECTID,    "CHUNK_TREE"    },      \
+                { BTRFS_DEV_TREE_OBJECTID,      "DEV_TREE"      },      \
+                { BTRFS_FS_TREE_OBJECTID,       "FS_TREE"       },      \
+                { BTRFS_ROOT_TREE_DIR_OBJECTID, "ROOT_TREE_DIR" },      \
+                { BTRFS_CSUM_TREE_OBJECTID,     "CSUM_TREE"     },      \
+                { BTRFS_TREE_LOG_OBJECTID,      "TREE_LOG"      },      \
+                { BTRFS_TREE_RELOC_OBJECTID,    "TREE_RELOC"    },      \
+                { BTRFS_DATA_RELOC_TREE_OBJECTID, "DATA_RELOC_TREE" })
+
+#define show_root_type(obj)                                             \
+        obj, ((obj >= BTRFS_DATA_RELOC_TREE_OBJECTID) ||                \
+              (obj <= BTRFS_CSUM_TREE_OBJECTID )) ? __show_root_type(obj) : "-"
+
+TRACE_EVENT(btrfs_transaction_commit,
+
+        TP_PROTO(struct btrfs_root *root),
+
+        TP_ARGS(root),
+
+        TP_STRUCT__entry(
+                __field(        u64,  generation                )
+                __field(        u64,  root_objectid             )
+        ),
+
+        TP_fast_assign(
+                __entry->generation     = root->fs_info->generation;
+                __entry->root_objectid  = root->root_key.objectid;
+        ),
+
+        TP_printk("root = %llu(%s), gen = %llu",
+                  show_root_type(__entry->root_objectid),
+                  (unsigned long long)__entry->generation)
+);
+
+DECLARE_EVENT_CLASS(btrfs__inode,
+
+        TP_PROTO(struct inode *inode),
+
+        TP_ARGS(inode),
+
+        TP_STRUCT__entry(
+                __field(        ino_t,  ino                     )
+                __field(        blkcnt_t,  blocks               )
+                __field(        u64,  disk_i_size               )
+                __field(        u64,  generation                )
+                __field(        u64,  last_trans                )
+                __field(        u64,  logged_trans              )
+                __field(        u64,  root_objectid             )
+        ),
+
+        TP_fast_assign(
+                __entry->ino    = inode->i_ino;
+                __entry->blocks = inode->i_blocks;
+                __entry->disk_i_size  = BTRFS_I(inode)->disk_i_size;
+                __entry->generation = BTRFS_I(inode)->generation;
+                __entry->last_trans = BTRFS_I(inode)->last_trans;
+                __entry->logged_trans = BTRFS_I(inode)->logged_trans;
+                __entry->root_objectid =
+                                BTRFS_I(inode)->root->root_key.objectid;
+        ),
+
+        TP_printk("root = %llu(%s), gen = %llu, ino = %lu, blocks = %llu, "
+                  "disk_i_size = %llu, last_trans = %llu, logged_trans = %llu",
+                  show_root_type(__entry->root_objectid),
+                  (unsigned long long)__entry->generation,
+                  (unsigned long)__entry->ino,
+                  (unsigned long long)__entry->blocks,
+                  (unsigned long long)__entry->disk_i_size,
+                  (unsigned long long)__entry->last_trans,
+                  (unsigned long long)__entry->logged_trans)
+);
+
+DEFINE_EVENT(btrfs__inode, btrfs_inode_new,
+
+        TP_PROTO(struct inode *inode),
+
+        TP_ARGS(inode)
+);
+
+DEFINE_EVENT(btrfs__inode, btrfs_inode_request,
+
+        TP_PROTO(struct inode *inode),
+
+        TP_ARGS(inode)
+);
+
+DEFINE_EVENT(btrfs__inode, btrfs_inode_evict,
+
+        TP_PROTO(struct inode *inode),
+
+        TP_ARGS(inode)
+);
+
+#define __show_map_type(type)                                           \
+        __print_symbolic(type,                                          \
+                { EXTENT_MAP_LAST_BYTE, "LAST_BYTE"     },              \
+                { EXTENT_MAP_HOLE,      "HOLE"          },              \
+                { EXTENT_MAP_INLINE,    "INLINE"        },              \
+                { EXTENT_MAP_DELALLOC,  "DELALLOC"      })
+
+#define show_map_type(type)                     \
+        type, (type >= EXTENT_MAP_LAST_BYTE) ? "-" :  __show_map_type(type)
+
+#define show_map_flags(flag)                                            \
+        __print_flags(flag, "|",                                        \
+                { EXTENT_FLAG_PINNED,           "PINNED"        },      \
+                { EXTENT_FLAG_COMPRESSED,       "COMPRESSED"    },      \
+                { EXTENT_FLAG_VACANCY,          "VACANCY"       },      \
+                { EXTENT_FLAG_PREALLOC,         "PREALLOC"      })
+
+TRACE_EVENT(btrfs_get_extent,
+
+        TP_PROTO(struct btrfs_root *root, struct extent_map *map),
+
+        TP_ARGS(root, map),
+
+        TP_STRUCT__entry(
+                __field(        u64,  root_objectid     )
+                __field(        u64,  start             )
+                __field(        u64,  len               )
+                __field(        u64,  orig_start        )
+                __field(        u64,  block_start       )
+                __field(        u64,  block_len         )
+                __field(        unsigned long,  flags   )
+                __field(        int,  refs              )
+                __field(        unsigned int,  compress_type    )
+        ),
+
+        TP_fast_assign(
+                __entry->root_objectid  = root->root_key.objectid;
+                __entry->start          = map->start;
+                __entry->len            = map->len;
+                __entry->orig_start     = map->orig_start;
+                __entry->block_start    = map->block_start;
+                __entry->block_len      = map->block_len;
+                __entry->flags          = map->flags;
+                __entry->refs           = atomic_read(&map->refs);
+                __entry->compress_type  = map->compress_type;
+        ),
+
+        TP_printk("root = %llu(%s), start = %llu, len = %llu, "
+                  "orig_start = %llu, block_start = %llu(%s), "
+                  "block_len = %llu, flags = %s, refs = %u, "
+                  "compress_type = %u",
+                  show_root_type(__entry->root_objectid),
+                  (unsigned long long)__entry->start,
+                  (unsigned long long)__entry->len,
+                  (unsigned long long)__entry->orig_start,
+                  show_map_type(__entry->block_start),
+                  (unsigned long long)__entry->block_len,
+                  show_map_flags(__entry->flags),
+                  __entry->refs, __entry->compress_type)
+);
+
+#define show_ordered_flags(flags)                                       \
+        __print_symbolic(flags,                                 \
+                { BTRFS_ORDERED_IO_DONE,        "IO_DONE"       },      \
+                { BTRFS_ORDERED_COMPLETE,       "COMPLETE"      },      \
+                { BTRFS_ORDERED_NOCOW,          "NOCOW"         },      \
+                { BTRFS_ORDERED_COMPRESSED,     "COMPRESSED"    },      \
+                { BTRFS_ORDERED_PREALLOC,       "PREALLOC"      },      \
+                { BTRFS_ORDERED_DIRECT,         "DIRECT"        })
+
+DECLARE_EVENT_CLASS(btrfs__ordered_extent,
+
+        TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
+
+        TP_ARGS(inode, ordered),
+
+        TP_STRUCT__entry(
+                __field(        ino_t,  ino             )
+                __field(        u64,  file_offset       )
+                __field(        u64,  start             )
+                __field(        u64,  len               )
+                __field(        u64,  disk_len          )
+                __field(        u64,  bytes_left        )
+                __field(        unsigned long,  flags   )
+                __field(        int,  compress_type     )
+                __field(        int,  refs              )
+                __field(        u64,  root_objectid     )
+        ),
+
+        TP_fast_assign(
+                __entry->ino            = inode->i_ino;
+                __entry->file_offset    = ordered->file_offset;
+                __entry->start          = ordered->start;
+                __entry->len            = ordered->len;
+                __entry->disk_len       = ordered->disk_len;
+                __entry->bytes_left     = ordered->bytes_left;
+                __entry->flags          = ordered->flags;
+                __entry->compress_type  = ordered->compress_type;
+                __entry->refs           = atomic_read(&ordered->refs);
+                __entry->root_objectid  =
+                                BTRFS_I(inode)->root->root_key.objectid;
+        ),
+
+        TP_printk("root = %llu(%s), ino = %llu, file_offset = %llu, "
+                  "start = %llu, len = %llu, disk_len = %llu, "
+                  "bytes_left = %llu, flags = %s, compress_type = %d, "
+                  "refs = %d",
+                  show_root_type(__entry->root_objectid),
+                  (unsigned long long)__entry->ino,
+                  (unsigned long long)__entry->file_offset,
+                  (unsigned long long)__entry->start,
+                  (unsigned long long)__entry->len,
+                  (unsigned long long)__entry->disk_len,
+                  (unsigned long long)__entry->bytes_left,
+                  show_ordered_flags(__entry->flags),
+                  __entry->compress_type, __entry->refs)
+);
+
+DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_add,
+
+        TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
+
+        TP_ARGS(inode, ordered)
+);
+
+DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_remove,
+
+        TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
+
+        TP_ARGS(inode, ordered)
+);
+
+DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_start,
+
+        TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
+
+        TP_ARGS(inode, ordered)
+);
+
+DEFINE_EVENT(btrfs__ordered_extent, btrfs_ordered_extent_put,
+
+        TP_PROTO(struct inode *inode, struct btrfs_ordered_extent *ordered),
+
+        TP_ARGS(inode, ordered)
+);
+
+DECLARE_EVENT_CLASS(btrfs__writepage,
+
+        TP_PROTO(struct page *page, struct inode *inode,
+                 struct writeback_control *wbc),
+
+        TP_ARGS(page, inode, wbc),
+
+        TP_STRUCT__entry(
+                __field(        ino_t,  ino                     )
+                __field(        pgoff_t,  index                 )
+                __field(        long,   nr_to_write             )
+                __field(        long,   pages_skipped           )
+                __field(        loff_t, range_start             )
+                __field(        loff_t, range_end               )
+                __field(        char,   nonblocking             )
+                __field(        char,   for_kupdate             )
+                __field(        char,   for_reclaim             )
+                __field(        char,   range_cyclic            )
+                __field(        pgoff_t,  writeback_index       )
+                __field(        u64,    root_objectid           )
+        ),
+
+        TP_fast_assign(
+                __entry->ino            = inode->i_ino;
+                __entry->index          = page->index;
+                __entry->nr_to_write    = wbc->nr_to_write;
+                __entry->pages_skipped  = wbc->pages_skipped;
+                __entry->range_start    = wbc->range_start;
+                __entry->range_end      = wbc->range_end;
+                __entry->nonblocking    = wbc->nonblocking;
+                __entry->for_kupdate    = wbc->for_kupdate;
+                __entry->for_reclaim    = wbc->for_reclaim;
+                __entry->range_cyclic   = wbc->range_cyclic;
+                __entry->writeback_index = inode->i_mapping->writeback_index;
+                __entry->root_objectid  =
+                                 BTRFS_I(inode)->root->root_key.objectid;
+        ),
+
+        TP_printk("root = %llu(%s), ino = %lu, page_index = %lu, "
+                  "nr_to_write = %ld, pages_skipped = %ld, range_start = %llu, "
+                  "range_end = %llu, nonblocking = %d, for_kupdate = %d, "
+                  "for_reclaim = %d, range_cyclic = %d, writeback_index = %lu",
+                  show_root_type(__entry->root_objectid),
+                  (unsigned long)__entry->ino, __entry->index,
+                  __entry->nr_to_write, __entry->pages_skipped,
+                  __entry->range_start, __entry->range_end,
+                  __entry->nonblocking, __entry->for_kupdate,
+                  __entry->for_reclaim, __entry->range_cyclic,
+                  (unsigned long)__entry->writeback_index)
+);
+
+DEFINE_EVENT(btrfs__writepage, __extent_writepage,
+
+        TP_PROTO(struct page *page, struct inode *inode,
+                 struct writeback_control *wbc),
+
+        TP_ARGS(page, inode, wbc)
+);
+
+TRACE_EVENT(btrfs_writepage_end_io_hook,
+
+        TP_PROTO(struct page *page, u64 start, u64 end, int uptodate),
+
+        TP_ARGS(page, start, end, uptodate),
+
+        TP_STRUCT__entry(
+                __field(        ino_t,   ino            )
+                __field(        pgoff_t, index          )
+                __field(        u64,     start          )
+                __field(        u64,     end            )
+                __field(        int,     uptodate       )
+                __field(        u64,    root_objectid   )
+        ),
+
+        TP_fast_assign(
+                __entry->ino    = page->mapping->host->i_ino;
+                __entry->index  = page->index;
+                __entry->start  = start;
+                __entry->end    = end;
+                __entry->uptodate = uptodate;
+                __entry->root_objectid  =
+                         BTRFS_I(page->mapping->host)->root->root_key.objectid;
+        ),
+
+        TP_printk("root = %llu(%s), ino = %lu, page_index = %lu, start = %llu, "
+                  "end = %llu, uptodate = %d",
+                  show_root_type(__entry->root_objectid),
+                  (unsigned long)__entry->ino, (unsigned long)__entry->index,
+                  (unsigned long long)__entry->start,
+                  (unsigned long long)__entry->end, __entry->uptodate)
+);
+
+TRACE_EVENT(btrfs_sync_file,
+
+        TP_PROTO(struct file *file, int datasync),
+
+        TP_ARGS(file, datasync),
+
+        TP_STRUCT__entry(
+                __field(        ino_t,  ino             )
+                __field(        ino_t,  parent          )
+                __field(        int,    datasync        )
+                __field(        u64,    root_objectid   )
+        ),
+
+        TP_fast_assign(
+                struct dentry *dentry = file->f_path.dentry;
+                struct inode *inode = dentry->d_inode;
+
+                __entry->ino            = inode->i_ino;
+                __entry->parent         = dentry->d_parent->d_inode->i_ino;
+                __entry->datasync       = datasync;
+                __entry->root_objectid  =
+                                 BTRFS_I(inode)->root->root_key.objectid;
+        ),
+
+        TP_printk("root = %llu(%s), ino = %ld, parent = %ld, datasync = %d",
+                  show_root_type(__entry->root_objectid),
+                  (unsigned long)__entry->ino, (unsigned long)__entry->parent,
+                  __entry->datasync)
+);
+
+TRACE_EVENT(btrfs_sync_fs,
+
+        TP_PROTO(int wait),
+
+        TP_ARGS(wait),
+
+        TP_STRUCT__entry(
+                __field(        int,  wait              )
+        ),
+
+        TP_fast_assign(
+                __entry->wait   = wait;
+        ),
+
+        TP_printk("wait = %d", __entry->wait)
+);
+
+#define show_ref_action(action)                                         \
+        __print_symbolic(action,                                        \
+                { BTRFS_ADD_DELAYED_REF,    "ADD_DELAYED_REF" },        \
+                { BTRFS_DROP_DELAYED_REF,   "DROP_DELAYED_REF" },       \
+                { BTRFS_ADD_DELAYED_EXTENT, "ADD_DELAYED_EXTENT" },     \
+                { BTRFS_UPDATE_DELAYED_HEAD, "UPDATE_DELAYED_HEAD" })
+                        
+
+TRACE_EVENT(btrfs_delayed_tree_ref,
+
+        TP_PROTO(struct btrfs_delayed_ref_node *ref,
+                 struct btrfs_delayed_tree_ref *full_ref,
+                 int action),
+
+        TP_ARGS(ref, full_ref, action),
+
+        TP_STRUCT__entry(
+                __field(        u64,  bytenr            )
+                __field(        u64,  num_bytes         )
+                __field(        int,  action            ) 
+                __field(        u64,  parent            )
+                __field(        u64,  ref_root          )
+                __field(        int,  level             )
+                __field(        int,  type              )
+        ),
+
+        TP_fast_assign(
+                __entry->bytenr         = ref->bytenr;
+                __entry->num_bytes      = ref->num_bytes;
+                __entry->action         = action;
+                __entry->parent         = full_ref->parent;
+                __entry->ref_root       = full_ref->root;
+                __entry->level          = full_ref->level;
+                __entry->type           = ref->type;
+        ),
+
+        TP_printk("bytenr = %llu, num_bytes = %llu, action = %s, "
+                  "parent = %llu(%s), ref_root = %llu(%s), level = %d, "
+                  "type = %s",
+                  (unsigned long long)__entry->bytenr,
+                  (unsigned long long)__entry->num_bytes,
+                  show_ref_action(__entry->action),
+                  show_root_type(__entry->parent),
+                  show_root_type(__entry->ref_root),
+                  __entry->level, show_ref_type(__entry->type))
+);
+
+TRACE_EVENT(btrfs_delayed_data_ref,
+
+        TP_PROTO(struct btrfs_delayed_ref_node *ref,
+                 struct btrfs_delayed_data_ref *full_ref,
+                 int action),
+
+        TP_ARGS(ref, full_ref, action),
+
+        TP_STRUCT__entry(
+                __field(        u64,  bytenr            )
+                __field(        u64,  num_bytes         )
+                __field(        int,  action            ) 
+                __field(        u64,  parent            )
+                __field(        u64,  ref_root          )
+                __field(        u64,  owner             )
+                __field(        u64,  offset            )
+                __field(        int,  type              )
+        ),
+
+        TP_fast_assign(
+                __entry->bytenr         = ref->bytenr;
+                __entry->num_bytes      = ref->num_bytes;
+                __entry->action         = action;
+                __entry->parent         = full_ref->parent;
+                __entry->ref_root       = full_ref->root;
+                __entry->owner          = full_ref->objectid;
+                __entry->offset         = full_ref->offset;
+                __entry->type           = ref->type;
+        ),
+
+        TP_printk("bytenr = %llu, num_bytes = %llu, action = %s, "
+                  "parent = %llu(%s), ref_root = %llu(%s), owner = %llu, "
+                  "offset = %llu, type = %s",
+                  (unsigned long long)__entry->bytenr,
+                  (unsigned long long)__entry->num_bytes,
+                  show_ref_action(__entry->action),
+                  show_root_type(__entry->parent),
+                  show_root_type(__entry->ref_root),
+                  (unsigned long long)__entry->owner,
+                  (unsigned long long)__entry->offset,
+                  show_ref_type(__entry->type))
+);
+
+TRACE_EVENT(btrfs_delayed_ref_head,
+
+        TP_PROTO(struct btrfs_delayed_ref_node *ref,
+                 struct btrfs_delayed_ref_head *head_ref,
+                 int action),
+
+        TP_ARGS(ref, head_ref, action),
+
+        TP_STRUCT__entry(
+                __field(        u64,  bytenr            )
+                __field(        u64,  num_bytes         )
+                __field(        int,  action            ) 
+                __field(        int,  is_data           )
+        ),
+
+        TP_fast_assign(
+                __entry->bytenr         = ref->bytenr;
+                __entry->num_bytes      = ref->num_bytes;
+                __entry->action         = action;
+                __entry->is_data        = head_ref->is_data;
+        ),
+
+        TP_printk("bytenr = %llu, num_bytes = %llu, action = %s, is_data = %d",
+                  (unsigned long long)__entry->bytenr,
+                  (unsigned long long)__entry->num_bytes,
+                  show_ref_action(__entry->action),
+                  __entry->is_data)
+);
+
+#define show_chunk_type(type)                                   \
+        __print_flags(type, "|",                                \
+                { BTRFS_BLOCK_GROUP_DATA,       "DATA"  },      \
+                { BTRFS_BLOCK_GROUP_SYSTEM,     "SYSTEM"},      \
+                { BTRFS_BLOCK_GROUP_METADATA,   "METADATA"},    \
+                { BTRFS_BLOCK_GROUP_RAID0,      "RAID0" },      \
+                { BTRFS_BLOCK_GROUP_RAID1,      "RAID1" },      \
+                { BTRFS_BLOCK_GROUP_DUP,        "DUP"   },      \
+                { BTRFS_BLOCK_GROUP_RAID10,     "RAID10"})
+
+DECLARE_EVENT_CLASS(btrfs__chunk,
+
+        TP_PROTO(struct btrfs_root *root, struct map_lookup *map,
+                 u64 offset, u64 size),
+
+        TP_ARGS(root, map, offset, size),
+
+        TP_STRUCT__entry(
+                __field(        int,  num_stripes               )
+                __field(        u64,  type                      )
+                __field(        int,  sub_stripes               )
+                __field(        u64,  offset                    )
+                __field(        u64,  size                      )
+                __field(        u64,  root_objectid             )
+        ),
+
+        TP_fast_assign(
+                __entry->num_stripes    = map->num_stripes;
+                __entry->type           = map->type;
+                __entry->sub_stripes    = map->sub_stripes;
+                __entry->offset         = offset;
+                __entry->size           = size;
+                __entry->root_objectid  = root->root_key.objectid;
+        ),
+
+        TP_printk("root = %llu(%s), offset = %llu, size = %llu, "
+                  "num_stripes = %d, sub_stripes = %d, type = %s",
+                  show_root_type(__entry->root_objectid),
+                  (unsigned long long)__entry->offset,
+                  (unsigned long long)__entry->size,
+                  __entry->num_stripes, __entry->sub_stripes,
+                  show_chunk_type(__entry->type))
+);
+
+DEFINE_EVENT(btrfs__chunk,  btrfs_chunk_alloc,
+
+        TP_PROTO(struct btrfs_root *root, struct map_lookup *map,
+                 u64 offset, u64 size),
+
+        TP_ARGS(root, map, offset, size)
+);
+
+DEFINE_EVENT(btrfs__chunk,  btrfs_chunk_free,
+
+        TP_PROTO(struct btrfs_root *root, struct map_lookup *map,
+                 u64 offset, u64 size),
+
+        TP_ARGS(root, map, offset, size)
+);
+
+TRACE_EVENT(btrfs_cow_block,
+
+        TP_PROTO(struct btrfs_root *root, struct extent_buffer *buf,
+                 struct extent_buffer *cow),
+
+        TP_ARGS(root, buf, cow),
+
+        TP_STRUCT__entry(
+                __field(        u64,  root_objectid             )
+                __field(        u64,  buf_start                 )
+                __field(        int,  refs                      )
+                __field(        u64,  cow_start                 )
+                __field(        int,  buf_level                 )
+                __field(        int,  cow_level                 )
+        ),
+
+        TP_fast_assign(
+                __entry->root_objectid  = root->root_key.objectid;
+                __entry->buf_start      = buf->start;
+                __entry->refs           = atomic_read(&buf->refs);
+                __entry->cow_start      = cow->start;
+                __entry->buf_level      = btrfs_header_level(buf);
+                __entry->cow_level      = btrfs_header_level(cow);
+        ),
+
+        TP_printk("root = %llu(%s), refs = %d, orig_buf = %llu "
+                  "(orig_level = %d), cow_buf = %llu (cow_level = %d)",
+                  show_root_type(__entry->root_objectid),
+                  __entry->refs,
+                  (unsigned long long)__entry->buf_start,
+                  __entry->buf_level,
+                  (unsigned long long)__entry->cow_start,
+                  __entry->cow_level)
+);
+
+DECLARE_EVENT_CLASS(btrfs__reserved_extent,
+
+        TP_PROTO(struct btrfs_root *root, u64 start, u64 len),
+
+        TP_ARGS(root, start, len),
+
+        TP_STRUCT__entry(
+                __field(        u64,  root_objectid             )
+                __field(        u64,  start                     )
+                __field(        u64,  len                       )
+        ),
+
+        TP_fast_assign(
+                __entry->root_objectid  = root->root_key.objectid;
+                __entry->start          = start;
+                __entry->len            = len;
+        ),
+
+        TP_printk("root = %llu(%s), start = %llu, len = %llu",
+                  show_root_type(__entry->root_objectid),
+                  (unsigned long long)__entry->start,
+                  (unsigned long long)__entry->len)
+);
+
+DEFINE_EVENT(btrfs__reserved_extent,  btrfs_reserved_extent_alloc,
+
+        TP_PROTO(struct btrfs_root *root, u64 start, u64 len),
+
+        TP_ARGS(root, start, len)
+);
+
+DEFINE_EVENT(btrfs__reserved_extent,  btrfs_reserved_extent_free,
+
+        TP_PROTO(struct btrfs_root *root, u64 start, u64 len),
+
+        TP_ARGS(root, start, len)
+);
+
+#endif /* _TRACE_BTRFS_H */
+
+/* This part must be outside protection */
+#include <trace/define_trace.h>
diff --git a/kernel/irq/Kconfig b/kernel/irq/Kconfig
index 00f2c037267a..72606ba10b14 100644
--- a/kernel/irq/Kconfig
+++ b/kernel/irq/Kconfig
@@ -51,6 +51,10 @@ config HARDIRQS_SW_RESEND
 config IRQ_PREFLOW_FASTEOI
        bool
 
+# Edge style eoi based handler (cell)
+config IRQ_EDGE_EOI_HANDLER
+       bool
+
 # Support forced irq threading
 config IRQ_FORCED_THREADING
        bool
diff --git a/kernel/irq/chip.c b/kernel/irq/chip.c
index c9c0601f0615..03099d521f5e 100644
--- a/kernel/irq/chip.c
+++ b/kernel/irq/chip.c
@@ -37,6 +37,12 @@ int irq_set_chip(unsigned int irq, struct irq_chip *chip)
         irq_chip_set_defaults(chip);
         desc->irq_data.chip = chip;
         irq_put_desc_unlock(desc, flags);
+        /*
+         * For !CONFIG_SPARSE_IRQ make the irq show up in
+         * allocated_irqs. For the CONFIG_SPARSE_IRQ case, it is
+         * already marked, and this call is harmless.
+         */
+        irq_reserve_irq(irq);
         return 0;
 }
 EXPORT_SYMBOL(irq_set_chip);
@@ -134,25 +140,25 @@ EXPORT_SYMBOL_GPL(irq_get_irq_data);
 
 static void irq_state_clr_disabled(struct irq_desc *desc)
 {
-        desc->istate &= ~IRQS_DISABLED;
+        irqd_clear(&desc->irq_data, IRQD_IRQ_DISABLED);
         irq_compat_clr_disabled(desc);
 }
 
 static void irq_state_set_disabled(struct irq_desc *desc)
 {
-        desc->istate |= IRQS_DISABLED;
+        irqd_set(&desc->irq_data, IRQD_IRQ_DISABLED);
         irq_compat_set_disabled(desc);
 }
 
 static void irq_state_clr_masked(struct irq_desc *desc)
 {
-        desc->istate &= ~IRQS_MASKED;
+        irqd_clear(&desc->irq_data, IRQD_IRQ_MASKED);
         irq_compat_clr_masked(desc);
 }
 
 static void irq_state_set_masked(struct irq_desc *desc)
 {
-        desc->istate |= IRQS_MASKED;
+        irqd_set(&desc->irq_data, IRQD_IRQ_MASKED);
         irq_compat_set_masked(desc);
 }
 
@@ -372,11 +378,11 @@ void handle_nested_irq(unsigned int irq)
         kstat_incr_irqs_this_cpu(irq, desc);
 
         action = desc->action;
-        if (unlikely(!action || (desc->istate & IRQS_DISABLED)))
+        if (unlikely(!action || irqd_irq_disabled(&desc->irq_data)))
                 goto out_unlock;
 
         irq_compat_set_progress(desc);
-        desc->istate |= IRQS_INPROGRESS;
+        irqd_set(&desc->irq_data, IRQD_IRQ_INPROGRESS);
         raw_spin_unlock_irq(&desc->lock);
 
         action_ret = action->thread_fn(action->irq, action->dev_id);
@@ -384,7 +390,7 @@ void handle_nested_irq(unsigned int irq)
                 note_interrupt(irq, desc, action_ret);
 
         raw_spin_lock_irq(&desc->lock);
-        desc->istate &= ~IRQS_INPROGRESS;
+        irqd_clear(&desc->irq_data, IRQD_IRQ_INPROGRESS);
         irq_compat_clr_progress(desc);
 
 out_unlock:
@@ -416,14 +422,14 @@ handle_simple_irq(unsigned int irq, struct irq_desc *desc)
 {
         raw_spin_lock(&desc->lock);
 
-        if (unlikely(desc->istate & IRQS_INPROGRESS))
+        if (unlikely(irqd_irq_inprogress(&desc->irq_data)))
                 if (!irq_check_poll(desc))
                         goto out_unlock;
 
         desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);
         kstat_incr_irqs_this_cpu(irq, desc);
 
-        if (unlikely(!desc->action || (desc->istate & IRQS_DISABLED)))
+        if (unlikely(!desc->action || irqd_irq_disabled(&desc->irq_data)))
                 goto out_unlock;
 
         handle_irq_event(desc);
@@ -448,7 +454,7 @@ handle_level_irq(unsigned int irq, struct irq_desc *desc)
         raw_spin_lock(&desc->lock);
         mask_ack_irq(desc);
 
-        if (unlikely(desc->istate & IRQS_INPROGRESS))
+        if (unlikely(irqd_irq_inprogress(&desc->irq_data)))
                 if (!irq_check_poll(desc))
                         goto out_unlock;
 
@@ -459,12 +465,12 @@ handle_level_irq(unsigned int irq, struct irq_desc *desc)
          * If its disabled or no action available
          * keep it masked and get out of here
          */
-        if (unlikely(!desc->action || (desc->istate & IRQS_DISABLED)))
+        if (unlikely(!desc->action || irqd_irq_disabled(&desc->irq_data)))
                 goto out_unlock;
 
         handle_irq_event(desc);
 
-        if (!(desc->istate & (IRQS_DISABLED | IRQS_ONESHOT)))
+        if (!irqd_irq_disabled(&desc->irq_data) && !(desc->istate & IRQS_ONESHOT))
                 unmask_irq(desc);
 out_unlock:
         raw_spin_unlock(&desc->lock);
@@ -496,7 +502,7 @@ handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc)
 {
         raw_spin_lock(&desc->lock);
 
-        if (unlikely(desc->istate & IRQS_INPROGRESS))
+        if (unlikely(irqd_irq_inprogress(&desc->irq_data)))
                 if (!irq_check_poll(desc))
                         goto out;
 
@@ -507,7 +513,7 @@ handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc)
          * If its disabled or no action available
          * then mask it and get out of here:
          */
-        if (unlikely(!desc->action || (desc->istate & IRQS_DISABLED))) {
+        if (unlikely(!desc->action || irqd_irq_disabled(&desc->irq_data))) {
                 irq_compat_set_pending(desc);
                 desc->istate |= IRQS_PENDING;
                 mask_irq(desc);
@@ -558,8 +564,8 @@ handle_edge_irq(unsigned int irq, struct irq_desc *desc)
          * we shouldn't process the IRQ. Mark it pending, handle
          * the necessary masking and go out
          */
-        if (unlikely((desc->istate & (IRQS_DISABLED | IRQS_INPROGRESS) ||
-                      !desc->action))) {
+        if (unlikely(irqd_irq_disabled(&desc->irq_data) ||
+                     irqd_irq_inprogress(&desc->irq_data) || !desc->action)) {
                 if (!irq_check_poll(desc)) {
                         irq_compat_set_pending(desc);
                         desc->istate |= IRQS_PENDING;
@@ -584,20 +590,65 @@ handle_edge_irq(unsigned int irq, struct irq_desc *desc)
                  * Renable it, if it was not disabled in meantime.
                  */
                 if (unlikely(desc->istate & IRQS_PENDING)) {
-                        if (!(desc->istate & IRQS_DISABLED) &&
-                            (desc->istate & IRQS_MASKED))
+                        if (!irqd_irq_disabled(&desc->irq_data) &&
+                            irqd_irq_masked(&desc->irq_data))
                                 unmask_irq(desc);
                 }
 
                 handle_irq_event(desc);
 
         } while ((desc->istate & IRQS_PENDING) &&
-                 !(desc->istate & IRQS_DISABLED));
+                 !irqd_irq_disabled(&desc->irq_data));
 
 out_unlock:
         raw_spin_unlock(&desc->lock);
 }
 
+#ifdef CONFIG_IRQ_EDGE_EOI_HANDLER
+/**
+ *      handle_edge_eoi_irq - edge eoi type IRQ handler
+ *      @irq:   the interrupt number
+ *      @desc:  the interrupt description structure for this irq
+ *
+ * Similar as the above handle_edge_irq, but using eoi and w/o the
+ * mask/unmask logic.
+ */
+void handle_edge_eoi_irq(unsigned int irq, struct irq_desc *desc)
+{
+        struct irq_chip *chip = irq_desc_get_chip(desc);
+
+        raw_spin_lock(&desc->lock);
+
+        desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);
+        /*
+         * If we're currently running this IRQ, or its disabled,
+         * we shouldn't process the IRQ. Mark it pending, handle
+         * the necessary masking and go out
+         */
+        if (unlikely(irqd_irq_disabled(&desc->irq_data) ||
+                     irqd_irq_inprogress(&desc->irq_data) || !desc->action)) {
+                if (!irq_check_poll(desc)) {
+                        desc->istate |= IRQS_PENDING;
+                        goto out_eoi;
+                }
+        }
+        kstat_incr_irqs_this_cpu(irq, desc);
+
+        do {
+                if (unlikely(!desc->action))
+                        goto out_eoi;
+
+                handle_irq_event(desc);
+
+        } while ((desc->istate & IRQS_PENDING) &&
+                 !irqd_irq_disabled(&desc->irq_data));
+
+out_unlock:
+        chip->irq_eoi(&desc->irq_data);
+        raw_spin_unlock(&desc->lock);
+}
+#endif
+
 /**
  *      handle_percpu_irq - Per CPU local irq handler
  *      @irq:   the interrupt number
@@ -642,8 +693,7 @@ __irq_set_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
         if (handle == handle_bad_irq) {
                 if (desc->irq_data.chip != &no_irq_chip)
                         mask_ack_irq(desc);
-                irq_compat_set_disabled(desc);
-                desc->istate |= IRQS_DISABLED;
+                irq_state_set_disabled(desc);
                 desc->depth = 1;
         }
         desc->handle_irq = handle;
@@ -684,8 +734,70 @@ void irq_modify_status(unsigned int irq, unsigned long clr, unsigned long set)
                 irqd_set(&desc->irq_data, IRQD_PER_CPU);
         if (irq_settings_can_move_pcntxt(desc))
                 irqd_set(&desc->irq_data, IRQD_MOVE_PCNTXT);
+        if (irq_settings_is_level(desc))
+                irqd_set(&desc->irq_data, IRQD_LEVEL);
 
         irqd_set(&desc->irq_data, irq_settings_get_trigger_mask(desc));
 
         irq_put_desc_unlock(desc, flags);
 }
+
+/**
+ *      irq_cpu_online - Invoke all irq_cpu_online functions.
+ *
+ *      Iterate through all irqs and invoke the chip.irq_cpu_online()
+ *      for each.
+ */
+void irq_cpu_online(void)
+{
+        struct irq_desc *desc;
+        struct irq_chip *chip;
+        unsigned long flags;
+        unsigned int irq;
+
+        for_each_active_irq(irq) {
+                desc = irq_to_desc(irq);
+                if (!desc)
+                        continue;
+
+                raw_spin_lock_irqsave(&desc->lock, flags);
+
+                chip = irq_data_get_irq_chip(&desc->irq_data);
+                if (chip && chip->irq_cpu_online &&
+                    (!(chip->flags & IRQCHIP_ONOFFLINE_ENABLED) ||
+                     !irqd_irq_disabled(&desc->irq_data)))
+                        chip->irq_cpu_online(&desc->irq_data);
+
+                raw_spin_unlock_irqrestore(&desc->lock, flags);
+        }
+}
+
+/**
+ *      irq_cpu_offline - Invoke all irq_cpu_offline functions.
+ *
+ *      Iterate through all irqs and invoke the chip.irq_cpu_offline()
+ *      for each.
+ */
+void irq_cpu_offline(void)
+{
+        struct irq_desc *desc;
+        struct irq_chip *chip;
+        unsigned long flags;
+        unsigned int irq;
+
+        for_each_active_irq(irq) {
+                desc = irq_to_desc(irq);
+                if (!desc)
+                        continue;
+
+                raw_spin_lock_irqsave(&desc->lock, flags);
+
+                chip = irq_data_get_irq_chip(&desc->irq_data);
+                if (chip && chip->irq_cpu_offline &&
+                    (!(chip->flags & IRQCHIP_ONOFFLINE_ENABLED) ||
+                     !irqd_irq_disabled(&desc->irq_data)))
+                        chip->irq_cpu_offline(&desc->irq_data);
+
+                raw_spin_unlock_irqrestore(&desc->lock, flags);
+        }
+}
diff --git a/kernel/irq/debug.h b/kernel/irq/debug.h
index d1a33b7fa61d..a0bd875ba3d5 100644
--- a/kernel/irq/debug.h
+++ b/kernel/irq/debug.h
@@ -6,6 +6,8 @@
 
 #define P(f) if (desc->status & f) printk("%14s set\n", #f)
 #define PS(f) if (desc->istate & f) printk("%14s set\n", #f)
+/* FIXME */
+#define PD(f) do { } while (0)
 
 static inline void print_irq_desc(unsigned int irq, struct irq_desc *desc)
 {
@@ -28,13 +30,15 @@ static inline void print_irq_desc(unsigned int irq, struct irq_desc *desc)
         P(IRQ_NOAUTOEN);
 
         PS(IRQS_AUTODETECT);
-        PS(IRQS_INPROGRESS);
         PS(IRQS_REPLAY);
         PS(IRQS_WAITING);
-        PS(IRQS_DISABLED);
         PS(IRQS_PENDING);
-        PS(IRQS_MASKED);
+
+        PD(IRQS_INPROGRESS);
+        PD(IRQS_DISABLED);
+        PD(IRQS_MASKED);
 }
 
 #undef P
 #undef PS
+#undef PD
diff --git a/kernel/irq/handle.c b/kernel/irq/handle.c
index 517561fc7317..1a2fb77f2fd6 100644
--- a/kernel/irq/handle.c
+++ b/kernel/irq/handle.c
@@ -178,25 +178,13 @@ irqreturn_t handle_irq_event(struct irq_desc *desc)
         irq_compat_clr_pending(desc);
         desc->istate &= ~IRQS_PENDING;
         irq_compat_set_progress(desc);
-        desc->istate |= IRQS_INPROGRESS;
+        irqd_set(&desc->irq_data, IRQD_IRQ_INPROGRESS);
         raw_spin_unlock(&desc->lock);
 
         ret = handle_irq_event_percpu(desc, action);
 
         raw_spin_lock(&desc->lock);
-        desc->istate &= ~IRQS_INPROGRESS;
+        irqd_clear(&desc->irq_data, IRQD_IRQ_INPROGRESS);
         irq_compat_clr_progress(desc);
         return ret;
 }
-
-/**
- * handle_IRQ_event - irq action chain handler
- * @irq:        the interrupt number
- * @action:     the interrupt action chain for this irq
- *
- * Handles the action chain of an irq event
- */
-irqreturn_t handle_IRQ_event(unsigned int irq, struct irqaction *action)
-{
-        return handle_irq_event_percpu(irq_to_desc(irq), action);
-}
diff --git a/kernel/irq/internals.h b/kernel/irq/internals.h
index 6c6ec9a49027..6b8b9713e28d 100644
--- a/kernel/irq/internals.h
+++ b/kernel/irq/internals.h
@@ -44,26 +44,20 @@ enum {
  * IRQS_SPURIOUS_DISABLED       - was disabled due to spurious interrupt
  *                                detection
  * IRQS_POLL_INPROGRESS         - polling in progress
- * IRQS_INPROGRESS              - Interrupt in progress
  * IRQS_ONESHOT                 - irq is not unmasked in primary handler
  * IRQS_REPLAY                  - irq is replayed
  * IRQS_WAITING                 - irq is waiting
- * IRQS_DISABLED                - irq is disabled
  * IRQS_PENDING                 - irq is pending and replayed later
- * IRQS_MASKED                  - irq is masked
  * IRQS_SUSPENDED               - irq is suspended
  */
 enum {
         IRQS_AUTODETECT         = 0x00000001,
         IRQS_SPURIOUS_DISABLED  = 0x00000002,
         IRQS_POLL_INPROGRESS    = 0x00000008,
-        IRQS_INPROGRESS         = 0x00000010,
         IRQS_ONESHOT            = 0x00000020,
         IRQS_REPLAY             = 0x00000040,
         IRQS_WAITING            = 0x00000080,
-        IRQS_DISABLED           = 0x00000100,
         IRQS_PENDING            = 0x00000200,
-        IRQS_MASKED             = 0x00000400,
         IRQS_SUSPENDED          = 0x00000800,
 };
 
diff --git a/kernel/irq/irqdesc.c b/kernel/irq/irqdesc.c
index 6fb014f172f7..2c039c9b9383 100644
--- a/kernel/irq/irqdesc.c
+++ b/kernel/irq/irqdesc.c
@@ -80,7 +80,7 @@ static void desc_set_defaults(unsigned int irq, struct irq_desc *desc, int node)
         desc->irq_data.handler_data = NULL;
         desc->irq_data.msi_desc = NULL;
         irq_settings_clr_and_set(desc, ~0, _IRQ_DEFAULT_INIT_FLAGS);
-        desc->istate = IRQS_DISABLED;
+        irqd_set(&desc->irq_data, IRQD_IRQ_DISABLED);
         desc->handle_irq = handle_bad_irq;
         desc->depth = 1;
         desc->irq_count = 0;
@@ -238,7 +238,6 @@ int __init early_irq_init(void)
 
 struct irq_desc irq_desc[NR_IRQS] __cacheline_aligned_in_smp = {
         [0 ... NR_IRQS-1] = {
-                .istate         = IRQS_DISABLED,
                 .handle_irq     = handle_bad_irq,
                 .depth          = 1,
                 .lock           = __RAW_SPIN_LOCK_UNLOCKED(irq_desc->lock),
diff --git a/kernel/irq/manage.c b/kernel/irq/manage.c
index 0a2aa73e536c..acf540768b8f 100644
--- a/kernel/irq/manage.c
+++ b/kernel/irq/manage.c
@@ -41,7 +41,7 @@ early_param("threadirqs", setup_forced_irqthreads);
 void synchronize_irq(unsigned int irq)
 {
         struct irq_desc *desc = irq_to_desc(irq);
-        unsigned int state;
+        bool inprogress;
 
         if (!desc)
                 return;
@@ -53,16 +53,16 @@ void synchronize_irq(unsigned int irq)
                  * Wait until we're out of the critical section.  This might
                  * give the wrong answer due to the lack of memory barriers.
                  */
-                while (desc->istate & IRQS_INPROGRESS)
+                while (irqd_irq_inprogress(&desc->irq_data))
                         cpu_relax();
 
                 /* Ok, that indicated we're done: double-check carefully. */
                 raw_spin_lock_irqsave(&desc->lock, flags);
-                state = desc->istate;
+                inprogress = irqd_irq_inprogress(&desc->irq_data);
                 raw_spin_unlock_irqrestore(&desc->lock, flags);
 
                 /* Oops, that failed? */
-        } while (state & IRQS_INPROGRESS);
+        } while (inprogress);
 
         /*
          * We made sure that no hardirq handler is running. Now verify
@@ -112,13 +112,13 @@ void irq_set_thread_affinity(struct irq_desc *desc)
 }
 
 #ifdef CONFIG_GENERIC_PENDING_IRQ
-static inline bool irq_can_move_pcntxt(struct irq_desc *desc)
+static inline bool irq_can_move_pcntxt(struct irq_data *data)
 {
-        return irq_settings_can_move_pcntxt(desc);
+        return irqd_can_move_in_process_context(data);
 }
-static inline bool irq_move_pending(struct irq_desc *desc)
+static inline bool irq_move_pending(struct irq_data *data)
 {
-        return irqd_is_setaffinity_pending(&desc->irq_data);
+        return irqd_is_setaffinity_pending(data);
 }
 static inline void
 irq_copy_pending(struct irq_desc *desc, const struct cpumask *mask)
@@ -131,43 +131,34 @@ irq_get_pending(struct cpumask *mask, struct irq_desc *desc)
         cpumask_copy(mask, desc->pending_mask);
 }
 #else
-static inline bool irq_can_move_pcntxt(struct irq_desc *desc) { return true; }
-static inline bool irq_move_pending(struct irq_desc *desc) { return false; }
+static inline bool irq_can_move_pcntxt(struct irq_data *data) { return true; }
+static inline bool irq_move_pending(struct irq_desc *data) { return false; }
 static inline void
 irq_copy_pending(struct irq_desc *desc, const struct cpumask *mask) { }
 static inline void
 irq_get_pending(struct cpumask *mask, struct irq_desc *desc) { }
 #endif
 
-/**
- *      irq_set_affinity - Set the irq affinity of a given irq
- *      @irq:           Interrupt to set affinity
- *      @cpumask:       cpumask
- *
- */
-int irq_set_affinity(unsigned int irq, const struct cpumask *mask)
+int __irq_set_affinity_locked(struct irq_data *data, const struct cpumask *mask)
 {
-        struct irq_desc *desc = irq_to_desc(irq);
-        struct irq_chip *chip = desc->irq_data.chip;
-        unsigned long flags;
+        struct irq_chip *chip = irq_data_get_irq_chip(data);
+        struct irq_desc *desc = irq_data_to_desc(data);
         int ret = 0;
 
-        if (!chip->irq_set_affinity)
+        if (!chip || !chip->irq_set_affinity)
                 return -EINVAL;
 
-        raw_spin_lock_irqsave(&desc->lock, flags);
-
-        if (irq_can_move_pcntxt(desc)) {
-                ret = chip->irq_set_affinity(&desc->irq_data, mask, false);
+        if (irq_can_move_pcntxt(data)) {
+                ret = chip->irq_set_affinity(data, mask, false);
                 switch (ret) {
                 case IRQ_SET_MASK_OK:
-                        cpumask_copy(desc->irq_data.affinity, mask);
+                        cpumask_copy(data->affinity, mask);
                 case IRQ_SET_MASK_OK_NOCOPY:
                         irq_set_thread_affinity(desc);
                         ret = 0;
                 }
         } else {
-                irqd_set_move_pending(&desc->irq_data);
+                irqd_set_move_pending(data);
                 irq_copy_pending(desc, mask);
         }
 
@@ -176,7 +167,28 @@ int irq_set_affinity(unsigned int irq, const struct cpumask *mask)
                 schedule_work(&desc->affinity_notify->work);
         }
         irq_compat_set_affinity(desc);
-        irqd_set(&desc->irq_data, IRQD_AFFINITY_SET);
+        irqd_set(data, IRQD_AFFINITY_SET);
+
+        return ret;
+}
+
+/**
+ *      irq_set_affinity - Set the irq affinity of a given irq
+ *      @irq:           Interrupt to set affinity
+ *      @mask:          cpumask
+ *
+ */
+int irq_set_affinity(unsigned int irq, const struct cpumask *mask)
+{
+        struct irq_desc *desc = irq_to_desc(irq);
+        unsigned long flags;
+        int ret;
+
+        if (!desc)
+                return -EINVAL;
+
+        raw_spin_lock_irqsave(&desc->lock, flags);
+        ret =  __irq_set_affinity_locked(irq_desc_get_irq_data(desc), mask);
         raw_spin_unlock_irqrestore(&desc->lock, flags);
         return ret;
 }
@@ -206,7 +218,7 @@ static void irq_affinity_notify(struct work_struct *work)
                 goto out;
 
         raw_spin_lock_irqsave(&desc->lock, flags);
-        if (irq_move_pending(desc))
+        if (irq_move_pending(&desc->irq_data))
                 irq_get_pending(cpumask, desc);
         else
                 cpumask_copy(cpumask, desc->irq_data.affinity);
@@ -551,9 +563,9 @@ int __irq_set_trigger(struct irq_desc *desc, unsigned int irq,
         flags &= IRQ_TYPE_SENSE_MASK;
 
         if (chip->flags & IRQCHIP_SET_TYPE_MASKED) {
-                if (!(desc->istate & IRQS_MASKED))
+                if (!irqd_irq_masked(&desc->irq_data))
                         mask_irq(desc);
-                if (!(desc->istate & IRQS_DISABLED))
+                if (!irqd_irq_disabled(&desc->irq_data))
                         unmask = 1;
         }
 
@@ -651,7 +663,7 @@ again:
          * irq_wake_thread(). See the comment there which explains the
          * serialization.
          */
-        if (unlikely(desc->istate & IRQS_INPROGRESS)) {
+        if (unlikely(irqd_irq_inprogress(&desc->irq_data))) {
                 raw_spin_unlock_irq(&desc->lock);
                 chip_bus_sync_unlock(desc);
                 cpu_relax();
@@ -668,12 +680,10 @@ again:
 
         desc->threads_oneshot &= ~action->thread_mask;
 
-        if (!desc->threads_oneshot && !(desc->istate & IRQS_DISABLED) &&
-            (desc->istate & IRQS_MASKED)) {
-                irq_compat_clr_masked(desc);
-                desc->istate &= ~IRQS_MASKED;
-                desc->irq_data.chip->irq_unmask(&desc->irq_data);
-        }
+        if (!desc->threads_oneshot && !irqd_irq_disabled(&desc->irq_data) &&
+            irqd_irq_masked(&desc->irq_data))
+                unmask_irq(desc);
+
 out_unlock:
         raw_spin_unlock_irq(&desc->lock);
         chip_bus_sync_unlock(desc);
@@ -767,7 +777,7 @@ static int irq_thread(void *data)
                 atomic_inc(&desc->threads_active);
 
                 raw_spin_lock_irq(&desc->lock);
-                if (unlikely(desc->istate & IRQS_DISABLED)) {
+                if (unlikely(irqd_irq_disabled(&desc->irq_data))) {
                         /*
                          * CHECKME: We might need a dedicated
                          * IRQ_THREAD_PENDING flag here, which
@@ -985,8 +995,8 @@ __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
                 }
 
                 desc->istate &= ~(IRQS_AUTODETECT | IRQS_SPURIOUS_DISABLED | \
-                                  IRQS_INPROGRESS | IRQS_ONESHOT | \
-                                  IRQS_WAITING);
+                                  IRQS_ONESHOT | IRQS_WAITING);
+                irqd_clear(&desc->irq_data, IRQD_IRQ_INPROGRESS);
 
                 if (new->flags & IRQF_PERCPU) {
                         irqd_set(&desc->irq_data, IRQD_PER_CPU);
diff --git a/kernel/irq/migration.c b/kernel/irq/migration.c
index ec4806d4778b..e33d9c8d5089 100644
--- a/kernel/irq/migration.c
+++ b/kernel/irq/migration.c
@@ -60,13 +60,12 @@ void move_masked_irq(int irq)
 
 void irq_move_irq(struct irq_data *idata)
 {
-        struct irq_desc *desc = irq_data_to_desc(idata);
         bool masked;
 
         if (likely(!irqd_is_setaffinity_pending(idata)))
                 return;
 
-        if (unlikely(desc->istate & IRQS_DISABLED))
+        if (unlikely(irqd_irq_disabled(idata)))
                 return;
 
         /*
@@ -74,7 +73,7 @@ void irq_move_irq(struct irq_data *idata)
          * threaded interrupt with ONESHOT set, we can end up with an
          * interrupt storm.
          */
-        masked = desc->istate & IRQS_MASKED;
+        masked = irqd_irq_masked(idata);
         if (!masked)
                 idata->chip->irq_mask(idata);
         irq_move_masked_irq(idata);
diff --git a/kernel/irq/spurious.c b/kernel/irq/spurious.c
index dd586ebf9c8c..83f4799f46be 100644
--- a/kernel/irq/spurious.c
+++ b/kernel/irq/spurious.c
@@ -45,12 +45,12 @@ bool irq_wait_for_poll(struct irq_desc *desc)
 #ifdef CONFIG_SMP
         do {
                 raw_spin_unlock(&desc->lock);
-                while (desc->istate & IRQS_INPROGRESS)
+                while (irqd_irq_inprogress(&desc->irq_data))
                         cpu_relax();
                 raw_spin_lock(&desc->lock);
-        } while (desc->istate & IRQS_INPROGRESS);
+        } while (irqd_irq_inprogress(&desc->irq_data));
         /* Might have been disabled in meantime */
-        return !(desc->istate & IRQS_DISABLED) && desc->action;
+        return !irqd_irq_disabled(&desc->irq_data) && desc->action;
 #else
         return false;
 #endif
@@ -75,7 +75,7 @@ static int try_one_irq(int irq, struct irq_desc *desc, bool force)
          * Do not poll disabled interrupts unless the spurious
          * disabled poller asks explicitely.
          */
-        if ((desc->istate & IRQS_DISABLED) && !force)
+        if (irqd_irq_disabled(&desc->irq_data) && !force)
                 goto out;
 
         /*
@@ -88,7 +88,7 @@ static int try_one_irq(int irq, struct irq_desc *desc, bool force)
                 goto out;
 
         /* Already running on another processor */
-        if (desc->istate & IRQS_INPROGRESS) {
+        if (irqd_irq_inprogress(&desc->irq_data)) {
                 /*
                  * Already running: If it is shared get the other
                  * CPU to go looking for our mystery interrupt too
diff --git a/kernel/signal.c b/kernel/signal.c
index 324eff5468ad..1186cf7fac77 100644
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -2437,7 +2437,7 @@ SYSCALL_DEFINE3(rt_sigqueueinfo, pid_t, pid, int, sig,
         /* Not even root can pretend to send signals from the kernel.
          * Nor can they impersonate a kill()/tgkill(), which adds source info.
          */
-        if (info.si_code != SI_QUEUE) {
+        if (info.si_code >= 0 || info.si_code == SI_TKILL) {
                 /* We used to allow any < 0 si_code */
                 WARN_ON_ONCE(info.si_code < 0);
                 return -EPERM;
@@ -2457,7 +2457,7 @@ long do_rt_tgsigqueueinfo(pid_t tgid, pid_t pid, int sig, siginfo_t *info)
         /* Not even root can pretend to send signals from the kernel.
          * Nor can they impersonate a kill()/tgkill(), which adds source info.
          */
-        if (info->si_code != SI_QUEUE) {
+        if (info->si_code >= 0 || info->si_code == SI_TKILL) {
                 /* We used to allow any < 0 si_code */
                 WARN_ON_ONCE(info->si_code < 0);
                 return -EPERM;